Examples with ScControllerPort com.emc.storageos.driver.dellsc.scapi.objects.ScControllerPort used on opensource projects

Example 1 with ScControllerPort

use of com.emc.storageos.driver.dellsc.scapi.objects.ScControllerPort in project coprhd-controller by CoprHD.

the class DellSCUtil method getSupportedProtocols.

/**
 * Gets the transport protocols supported by an array.
 *
 * @param api The SC API connection.
 * @param scSerialNumber The Storage Center serial number to check.
 * @return The supported protocols.
 */
private List<String> getSupportedProtocols(StorageCenterAPI api, String scSerialNumber) {
    List<String> protocols = new ArrayList<>();
    boolean hasIScsi = false;
    boolean hasFC = false;
    ScControllerPort[] controllerPorts = api.getTargetPorts(scSerialNumber, null);
    for (ScControllerPort scPort : controllerPorts) {
        if (ScControllerPort.FC_TRANSPORT_TYPE.equals(scPort.transportType)) {
            hasFC = true;
        } else if (ScControllerPort.ISCSI_TRANSPORT_TYPE.equals(scPort.transportType)) {
            hasIScsi = true;
        }
    }
    if (hasIScsi) {
        protocols.add(Protocols.iSCSI.toString());
    }
    if (hasFC) {
        protocols.add(Protocols.FC.toString());
    }
    return protocols;
}

Example 2 with ScControllerPort

use of com.emc.storageos.driver.dellsc.scapi.objects.ScControllerPort in project coprhd-controller by CoprHD.

the class DellSCDiscovery method discoverStoragePorts.

/**
 * Discover storage ports and their capabilities.
 *
 * @param storageSystem The storage system on which to discover.
 * @param storagePorts The storage ports.
 * @return The discovery task.
 */
public DriverTask discoverStoragePorts(StorageSystem storageSystem, List<StoragePort> storagePorts) {
    LOG.info("Discovering storage ports for [{}] {} {}", storageSystem.getSystemName(), storageSystem.getIpAddress(), storageSystem.getNativeId());
    DellSCDriverTask task = new DellSCDriverTask("discoverStoragePorts");
    try {
        String ssn = storageSystem.getNativeId();
        StorageCenterAPI api = connectionManager.getConnection(ssn);
        Map<String, List<ScControllerPort>> ports = getPortList(api, ssn);
        for (Entry<String, List<ScControllerPort>> entry : ports.entrySet()) {
            for (ScControllerPort scPort : entry.getValue()) {
                StoragePort port = util.getStoragePortForControllerPort(api, scPort, entry.getKey());
                LOG.info("Discovered Port {}, storageSystem {}", scPort.instanceId, scPort.scSerialNumber);
                storagePorts.add(port);
            }
        }
        task.setStatus(DriverTask.TaskStatus.READY);
    } catch (Exception e) {
        String failureMessage = String.format("Error getting port information: %s", e);
        task.setFailed(failureMessage);
        LOG.warn(failureMessage);
    }
    return task;
}

Example 3 with ScControllerPort

use of com.emc.storageos.driver.dellsc.scapi.objects.ScControllerPort in project coprhd-controller by CoprHD.

the class DellSCDiscovery method getPortList.

/**
 * Gets the ScControllerPorts for a system.
 *
 * @param api The API connection.
 * @param ssn The system serial number.
 * @return The ports.
 */
private Map<String, List<ScControllerPort>> getPortList(StorageCenterAPI api, String ssn) {
    Map<String, List<ScControllerPort>> ports = new HashMap<>();
    try {
        ScConfiguration scConfig = api.getScConfig(ssn);
        ScFaultDomain[] faultDomains = api.getFaultDomains(ssn);
        for (ScFaultDomain fd : faultDomains) {
            // See what kind of fault domain this is
            boolean virtualMode;
            if (ScControllerPort.FC_TRANSPORT_TYPE.equals(fd.transportType)) {
                virtualMode = "VirtualPort".equals(scConfig.fibreChannelTransportMode);
            } else if (ScControllerPort.ISCSI_TRANSPORT_TYPE.equals(fd.transportType)) {
                virtualMode = "VirtualPort".equals(scConfig.iscsiTransportMode);
            } else {
                // Not a currently supported transport type
                continue;
            }
            // Now get the actual ports
            if (!ports.containsKey(fd.name)) {
                ports.put(fd.name, new ArrayList<>());
            }
            ScControllerPort[] fdPorts = api.getFaultDomainPorts(fd.instanceId, virtualMode);
            for (ScControllerPort fdPort : fdPorts) {
                // See if we need to inherit the IP settings from the fault domain
                if (EMPTY_IPADDR.equals(fdPort.iscsiSubnetMask)) {
                    fdPort.iscsiSubnetMask = fd.subnetMask;
                }
                if (EMPTY_IPADDR.equals(fdPort.iscsiIpAddress)) {
                    fdPort.iscsiIpAddress = fd.targetIpv4Address;
                }
                ports.get(fd.name).add(fdPort);
            }
        }
    } catch (Exception e) {
        LOG.error(String.format("Error getting system controller ports: %s", e));
    }
    return ports;
}

Example 4 with ScControllerPort

use of com.emc.storageos.driver.dellsc.scapi.objects.ScControllerPort in project coprhd-controller by CoprHD.

the class DellSCProvisioning method populateVolumeExportInfo.

/**
 * Fills in export information for a specific volume mapping.
 *
 * @param volumeId The volume instance ID.
 * @param map The mapping.
 * @param result The export info map.
 * @param serverCache The server cache.
 * @param serverPortCache The server HBA cache.
 * @param portCache The controller port cache.
 * @throws StorageCenterAPIException
 */
private void populateVolumeExportInfo(StorageCenterAPI api, String volumeId, ScMapping map, Map<String, HostExportInfo> result, Map<String, ScServer> serverCache, Map<String, Initiator> serverPortCache, Map<String, StoragePort> portCache) throws StorageCenterAPIException {
    ScServer server;
    Initiator initiator;
    StoragePort port;
    // Get our server info
    if (serverCache.containsKey(map.server.instanceId)) {
        server = serverCache.get(map.server.instanceId);
    } else {
        server = api.getServerDefinition(map.server.instanceId);
        serverCache.put(server.instanceId, server);
    }
    // Find the server HBA
    if (serverPortCache.containsKey(map.serverHba.instanceId)) {
        initiator = serverPortCache.get(map.serverHba.instanceId);
    } else {
        ScServerHba hba = api.getServerHba(map.serverHba.instanceId);
        initiator = getInitiatorInfo(api, server, hba);
        serverPortCache.put(hba.instanceId, initiator);
    }
    // Get the controller port info
    if (portCache.containsKey(map.controllerPort.instanceId)) {
        port = portCache.get(map.controllerPort.instanceId);
    } else {
        ScControllerPort scPort = api.getControllerPort(map.controllerPort.instanceId);
        port = util.getStoragePortForControllerPort(api, scPort);
        portCache.put(scPort.instanceId, port);
    }
    String hostName = initiator.getHostName();
    if (initiator.getInitiatorType() == Type.Cluster) {
        hostName = initiator.getClusterName();
    }
    HostExportInfo exportInfo;
    if (result.containsKey(hostName)) {
        exportInfo = result.get(hostName);
    } else {
        exportInfo = new HostExportInfo(hostName, new ArrayList<>(), new ArrayList<>(), new ArrayList<>());
    }
    // Now populate all the info
    if (!exportInfo.getStorageObjectNativeIds().contains(volumeId)) {
        exportInfo.getStorageObjectNativeIds().add(volumeId);
    }
    if (!exportInfo.getTargets().contains(port)) {
        exportInfo.getTargets().add(port);
    }
    if (!exportInfo.getInitiators().contains(initiator)) {
        exportInfo.getInitiators().add(initiator);
    }
    result.put(hostName, exportInfo);
}

Example 5 with ScControllerPort

use of com.emc.storageos.driver.dellsc.scapi.objects.ScControllerPort in project coprhd-controller by CoprHD.

the class DellSCProvisioning method exportVolumesToInitiators.

/**
 * Export volumes to initiators through a given set of ports. If ports are
 * not provided, use port requirements from ExportPathsServiceOption
 * storage capability.
 *
 * @param initiators The initiators to export to.
 * @param volumes The volumes to export.
 * @param volumeToHLUMap Map of volume nativeID to requested HLU. HLU
 *            value of -1 means that HLU is not defined and will
 *            be assigned by array.
 * @param recommendedPorts List of storage ports recommended for the export.
 *            Optional.
 * @param availablePorts List of ports available for the export.
 * @param capabilities The storage capabilities.
 * @param usedRecommendedPorts True if driver used recommended and only
 *            recommended ports for the export, false
 *            otherwise.
 * @param selectedPorts Ports selected for the export (if recommended ports
 *            have not been used).
 * @return The export task.
 * @throws DellSCDriverException
 */
public DriverTask exportVolumesToInitiators(List<Initiator> initiators, List<StorageVolume> volumes, Map<String, String> volumeToHLUMap, List<StoragePort> recommendedPorts, List<StoragePort> availablePorts, StorageCapabilities capabilities, MutableBoolean usedRecommendedPorts, List<StoragePort> selectedPorts) {
    LOG.info("Exporting volumes to inititators");
    DellSCDriverTask task = new DellSCDriverTask("exportVolumes");
    ScServer server = null;
    List<ScServerHba> preferredHbas = new ArrayList<>();
    StringBuilder errBuffer = new StringBuilder();
    int volumesMapped = 0;
    Set<StoragePort> usedPorts = new HashSet<>();
    String preferredController = null;
    // Cache of controller port instance IDs to StoragePort objects
    Map<String, StoragePort> discoveredPorts = new HashMap<>();
    // See if a max port count has been specified
    int maxPaths = -1;
    List<ExportPathsServiceOption> pathOptions = capabilities.getCommonCapabilitis().getExportPathParams();
    for (ExportPathsServiceOption pathOption : pathOptions) {
        // List but appears to only ever have one option?
        maxPaths = pathOption.getMaxPath();
    }
    // Get the recommended server ports to use
    List<String> recommendedServerPorts = new ArrayList<>();
    for (StoragePort port : recommendedPorts) {
        recommendedServerPorts.add(port.getNativeId());
    }
    for (StorageVolume volume : volumes) {
        String ssn = volume.getStorageSystemId();
        try {
            StorageCenterAPI api = connectionManager.getConnection(ssn);
            // Find our actual volume
            ScVolume scVol = null;
            int dotCount = StringUtils.countMatches(volume.getNativeId(), ".");
            if (dotCount == 2) {
                // Not actually a volume
                scVol = api.createReplayView(volume.getNativeId(), String.format("View of %s", volume.getNativeId()));
            } else {
                // Normal volume instance ID
                scVol = api.getVolume(volume.getNativeId());
            }
            if (scVol == null) {
                throw new DellSCDriverException(String.format("Unable to find volume %s", volume.getNativeId()));
            }
            // Look up the server if needed
            if (server == null) {
                server = createOrFindScServer(api, ssn, initiators, preferredHbas);
            }
            if (server == null) {
                // Unable to find or create the server, can't continue
                throw new DellSCDriverException(SERVER_CREATE_FAIL_MSG);
            }
            // See if we have a preferred controller
            if (preferredController == null && scVol.active) {
                // At least first volume is active somewhere, so we need to try to
                // use that controller for all mappings
                ScVolumeConfiguration volConfig = api.getVolumeConfig(scVol.instanceId);
                if (volConfig != null) {
                    preferredController = volConfig.controller.instanceId;
                }
            }
            // Next try to get a preferred controller based on what's requested
            if (preferredController == null && !recommendedPorts.isEmpty()) {
                try {
                    ScControllerPort scPort = api.getControllerPort(recommendedPorts.get(0).getNativeId());
                    preferredController = scPort.controller.instanceId;
                } catch (Exception e) {
                    LOG.warn("Failed to get recommended port controller.", e);
                }
            }
            int preferredLun = -1;
            if (volumeToHLUMap.containsKey(volume.getNativeId())) {
                String hlu = volumeToHLUMap.get(volume.getNativeId());
                try {
                    preferredLun = Integer.parseInt(hlu);
                } catch (NumberFormatException e) {
                    LOG.warn("Unable to parse preferred LUN {}", hlu);
                }
            }
            ScMappingProfile profile;
            // See if the volume is already mapped
            ScMappingProfile[] mappingProfiles = api.getServerVolumeMapping(scVol.instanceId, server.instanceId);
            if (mappingProfiles.length > 0) {
                // This one is already mapped
                profile = mappingProfiles[0];
            } else {
                profile = api.createVolumeMappingProfile(scVol.instanceId, server.instanceId, preferredLun, new String[0], maxPaths, preferredController);
            }
            ScMapping[] maps = api.getMappingProfileMaps(profile.instanceId);
            for (ScMapping map : maps) {
                volumeToHLUMap.put(volume.getNativeId(), String.valueOf(map.lun));
                StoragePort port;
                if (discoveredPorts.containsKey(map.controllerPort.instanceId)) {
                    port = discoveredPorts.get(map.controllerPort.instanceId);
                } else {
                    ScControllerPort scPort = api.getControllerPort(map.controllerPort.instanceId);
                    port = util.getStoragePortForControllerPort(api, scPort);
                    discoveredPorts.put(map.controllerPort.instanceId, port);
                }
                usedPorts.add(port);
            }
            volumesMapped++;
            LOG.info("Volume '{}' exported to server '{}'", scVol.name, server.name);
        } catch (StorageCenterAPIException | DellSCDriverException dex) {
            String error = String.format("Error mapping volume %s: %s", volume.getDisplayName(), dex);
            LOG.error(error);
            errBuffer.append(String.format("%s%n", error));
            if (SERVER_CREATE_FAIL_MSG.equals(dex.getMessage())) {
                // Game over
                break;
            }
        }
    }
    // See if we were able to use all of the recommended ports
    // TODO: Expand this to do more accurate checking
    usedRecommendedPorts.setValue(recommendedPorts.size() == usedPorts.size());
    if (!usedRecommendedPorts.isTrue()) {
        selectedPorts.addAll(usedPorts);
    }
    task.setMessage(errBuffer.toString());
    if (volumesMapped == volumes.size()) {
        task.setStatus(TaskStatus.READY);
    } else if (volumesMapped == 0) {
        task.setStatus(TaskStatus.FAILED);
    } else {
        task.setStatus(TaskStatus.PARTIALLY_FAILED);
    }
    return task;
}