Examples with ScaleIOSDS com.emc.storageos.scaleio.api.restapi.response.ScaleIOSDS used on opensource projects

Example 6 with ScaleIOSDS

use of com.emc.storageos.scaleio.api.restapi.response.ScaleIOSDS in project coprhd-controller by CoprHD.

the class ScaleIOCommunicationInterface method discover.

@Override
public void discover(AccessProfile accessProfile) throws BaseCollectionException {
    StorageSystem.CompatibilityStatus compatibilityStatus = StorageSystem.CompatibilityStatus.COMPATIBLE;
    StorageSystem storageSystem = _dbClient.queryObject(StorageSystem.class, accessProfile.getSystemId());
    _locker.acquireLock(accessProfile.getIpAddress(), LOCK_WAIT_SECONDS);
    log.info("Starting discovery of ScaleIO StorageProvider. IP={} StorageSystem {}", accessProfile.getIpAddress(), storageSystem.getNativeGuid());
    String statusMsg = "";
    try {
        ScaleIORestClient scaleIOHandle = scaleIOHandleFactory.using(_dbClient).getClientHandle(storageSystem);
        if (scaleIOHandle != null) {
            ScaleIOSystem sioSystem = scaleIOHandle.getSystem();
            List<ScaleIOProtectionDomain> protectionDomains = scaleIOHandle.getProtectionDomains();
            List<ScaleIOSDC> allSDCs = scaleIOHandle.queryAllSDC();
            List<ScaleIOSDS> allSDSs = scaleIOHandle.queryAllSDS();
            List<ScaleIOScsiInitiator> allSCSIInitiators = scaleIOHandle.queryAllSCSIInitiators();
            List<StoragePort> ports = new ArrayList<>();
            List<StoragePool> newPools = new ArrayList<StoragePool>();
            List<StoragePool> updatePools = new ArrayList<StoragePool>();
            List<StoragePool> allPools = new ArrayList<StoragePool>();
            String scaleIOType = StorageSystem.Type.scaleio.name();
            String installationId = sioSystem.getInstallId();
            String version = sioSystem.getVersion().replaceAll("_", ".");
            String minimumSupported = VersionChecker.getMinimumSupportedVersion(StorageSystem.Type.scaleio);
            compatibilityStatus = (VersionChecker.verifyVersionDetails(minimumSupported, version) < 0) ? StorageSystem.CompatibilityStatus.INCOMPATIBLE : StorageSystem.CompatibilityStatus.COMPATIBLE;
            storageSystem.setFirmwareVersion(version);
            storageSystem.setCompatibilityStatus(compatibilityStatus.name());
            storageSystem.setReachableStatus(true);
            storageSystem.setLabel(storageSystem.getNativeGuid());
            for (ScaleIOProtectionDomain protectionDomain : protectionDomains) {
                String domainName = protectionDomain.getName();
                String id = String.format("%s+%s", installationId, domainName);
                String storageSystemNativeGUID = generateNativeGuid(scaleIOType, id);
                if (!storageSystemNativeGUID.equals(storageSystem.getNativeGuid())) {
                    // This is not the ProtectionDomain that we're looking for
                    continue;
                }
                String protectionDomainId = protectionDomain.getId();
                storageSystem.setSerialNumber(protectionDomainId);
                Network network = createNetwork(installationId);
                List<ScaleIOSDS> sdsList = new ArrayList<ScaleIOSDS>();
                for (ScaleIOSDS sds : allSDSs) {
                    String pdId = sds.getProtectionDomainId();
                    if (pdId.equals(protectionDomainId)) {
                        sdsList.add(sds);
                    }
                }
                List<StoragePort> thesePorts = createStoragePorts(storageSystem, compatibilityStatus.name(), network, sdsList, domainName);
                ports.addAll(thesePorts);
                createHost(network, allSDCs);
                boolean hasSCSIInitiators = createSCSIInitiatorsAndStoragePorts(storageSystem, domainName, compatibilityStatus, installationId, allSCSIInitiators, allSDCs, ports);
                List<StoragePort> notVisiblePorts = DiscoveryUtils.checkStoragePortsNotVisible(ports, _dbClient, storageSystem.getId());
                if (notVisiblePorts != null && !notVisiblePorts.isEmpty()) {
                    ports.addAll(notVisiblePorts);
                }
                Set<String> supportedProtocols = (hasSCSIInitiators) ? SCALEIO_AND_ISCSI : SCALEIO_ONLY;
                List<ScaleIOStoragePool> storagePools = scaleIOHandle.getProtectionDomainStoragePools(protectionDomainId);
                for (ScaleIOStoragePool storagePool : storagePools) {
                    String poolName = storagePool.getName();
                    String nativeGuid = String.format("%s-%s-%s", installationId, domainName, poolName);
                    log.info("Attempting to discover pool {} for ProtectionDomain {}", poolName, domainName);
                    List<StoragePool> pools = queryActiveResourcesByAltId(_dbClient, StoragePool.class, "nativeGuid", nativeGuid);
                    StoragePool pool = null;
                    if (pools.isEmpty()) {
                        log.info("Pool {} is new", poolName);
                        pool = new StoragePool();
                        pool.setId(URIUtil.createId(StoragePool.class));
                        pool.setStorageDevice(accessProfile.getSystemId());
                        pool.setPoolServiceType(StoragePool.PoolServiceType.block.toString());
                        pool.setOperationalStatus(StoragePool.PoolOperationalStatus.READY.name());
                        pool.setCompatibilityStatus(compatibilityStatus.name());
                        pool.setThinVolumePreAllocationSupported(false);
                        pool.addDriveTypes(Collections.singleton(StoragePool.SupportedDriveTypeValues.SATA.name()));
                        StringSet copyTypes = new StringSet();
                        copyTypes.add(StoragePool.CopyTypes.ASYNC.name());
                        copyTypes.add(StoragePool.CopyTypes.UNSYNC_UNASSOC.name());
                        pool.setSupportedCopyTypes(copyTypes);
                        pool.setMaximumThickVolumeSize(1048576L);
                        pool.setMinimumThickVolumeSize(1L);
                        newPools.add(pool);
                    } else if (pools.size() == 1) {
                        log.info("Pool {} was previously discovered", storagePool);
                        pool = pools.get(0);
                        updatePools.add(pool);
                    } else {
                        log.warn(String.format("There are %d StoragePools with nativeGuid = %s", pools.size(), nativeGuid));
                        continue;
                    }
                    pool.setPoolName(poolName);
                    pool.setNativeId(storagePool.getId());
                    pool.setNativeGuid(nativeGuid);
                    String availableCapacityString = storagePool.getCapacityAvailableForVolumeAllocationInKb();
                    pool.setFreeCapacity(Long.parseLong(availableCapacityString));
                    String totalCapacityString = storagePool.getMaxCapacityInKb();
                    pool.setTotalCapacity(Long.parseLong(totalCapacityString));
                    pool.addProtocols(supportedProtocols);
                    pool.setSupportedResourceTypes(StoragePool.SupportedResourceTypes.THIN_AND_THICK.name());
                    Long maxThinSize = 1048576L;
                    Long minThinSize = 1L;
                    pool.setMaximumThinVolumeSize(maxThinSize);
                    pool.setMinimumThinVolumeSize(minThinSize);
                    pool.setInactive(false);
                    pool.setDiscoveryStatus(DiscoveryStatus.VISIBLE.name());
                }
            }
            log.info(String.format("For StorageSystem %s, discovered %d new pools and %d pools to update", storageSystem.getNativeGuid(), newPools.size(), updatePools.size()));
            StoragePoolAssociationHelper.setStoragePoolVarrays(storageSystem.getId(), newPools, _dbClient);
            allPools.addAll(newPools);
            allPools.addAll(updatePools);
            _dbClient.createObject(newPools);
            _dbClient.updateAndReindexObject(updatePools);
            List<StoragePool> notVisiblePools = DiscoveryUtils.checkStoragePoolsNotVisible(allPools, _dbClient, storageSystem.getId());
            if (notVisiblePools != null && !notVisiblePools.isEmpty()) {
                allPools.addAll(notVisiblePools);
            }
            StoragePortAssociationHelper.runUpdatePortAssociationsProcess(ports, null, _dbClient, _coordinator, allPools);
            statusMsg = String.format("Discovery completed successfully for Storage System: %s", storageSystem.getNativeGuid());
        }
    } catch (Exception e) {
        storageSystem.setReachableStatus(false);
        log.error(String.format("Exception was encountered when attempting to discover ScaleIO Instance %s", accessProfile.getIpAddress()), e);
        statusMsg = String.format("Discovery failed because %s", e.getLocalizedMessage());
        throw ScaleIOException.exceptions.discoveryFailed(e);
    } finally {
        _locker.releaseLock(accessProfile.getIpAddress());
        if (storageSystem != null) {
            storageSystem.setLastDiscoveryStatusMessage(statusMsg);
        }
    }
    _dbClient.updateAndReindexObject(storageSystem);
    log.info("Completed of ScaleIO StorageProvider. IP={} StorageSystem {}", accessProfile.getIpAddress(), storageSystem.getNativeGuid());
}