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

Example 1 with ScaleIORestClient

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

the class StorageSystemDataCollectionService method discoverScaleIO.

/**
 * Collect Data for ScaleIO system
 *
 * @param param ScaleIO discovery information
 * @return Data collected for ScaleIO system
 */
@POST
@Path("/scaleio")
@Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
public ScaleIOSystemDataRestRep discoverScaleIO(ScaleIOCollectDataParam param) {
    log.debug("discovering ScaleIO: {}", param.getIPAddress());
    URI baseURI = URI.create(ScaleIOConstants.getAPIBaseURI(param.getIPAddress(), param.getPortNumber()));
    ScaleIORestClient client = (ScaleIORestClient) scaleIORestClientFactory.getRESTClient(baseURI, param.getUserName(), param.getPassword());
    ScaleIOSystemDataRestRep sio = null;
    try {
        // collect and map scaleIO system
        ScaleIOSystem system = client.getSystem();
        sio = ScaleIODataMapper.map(system);
        // collect sds,device,fault set, and protection domain data
        List<ScaleIOSDS> allSDS = client.queryAllSDS();
        Map<String, ScaleIOProtectionDomain> pdMap = null;
        List<ScaleIOProtectionDomain> pdList = client.getProtectionDomains();
        if (null != pdList) {
            pdMap = pdList.stream().collect(Collectors.toMap(ScaleIOProtectionDomain::getId, p -> p));
        }
        List<ScaleIOFaultSet> fsList = client.queryAllFaultSets();
        Map<String, ScaleIOFaultSet> fsMap = null;
        if (null != fsList) {
            fsMap = client.queryAllFaultSets().stream().collect(Collectors.toMap(ScaleIOFaultSet::getId, f -> f));
        }
        Map<String, ScaleIOStoragePool> spMap = client.queryAllStoragePools().stream().collect(Collectors.toMap(ScaleIOStoragePool::getId, s -> s));
        // map SDS data
        List<ScaleIOSDSDataRestRep> scaleIOSDSDataRestReps = new ArrayList<ScaleIOSDSDataRestRep>();
        for (ScaleIOSDS sds : allSDS) {
            ScaleIOSDSDataRestRep sdsData = ScaleIODataMapper.map(sds);
            // map device data
            List<ScaleIODevice> devices = client.getSdsDevices(sds.getId());
            List<ScaleIODeviceDataRestRep> scaleIODeviceDataRestReps = new ArrayList<ScaleIODeviceDataRestRep>();
            if (null != devices) {
                for (ScaleIODevice device : devices) {
                    ScaleIODeviceDataRestRep scaleIODeviceDataRestRep = ScaleIODataMapper.map(device);
                    // map storagepool data
                    scaleIODeviceDataRestRep.setStoragePool(ScaleIODataMapper.map(spMap.get(device.getStoragePoolId())));
                    scaleIODeviceDataRestReps.add(scaleIODeviceDataRestRep);
                }
                sdsData.setDevices(scaleIODeviceDataRestReps);
            }
            // map fault set data
            if (null != fsMap) {
                sdsData.setFaultSet(ScaleIODataMapper.map(fsMap.get(sds.getFaultSetId())));
            }
            // map protection domain and IP data
            if (null != pdMap) {
                sdsData.setProtectionDomain(ScaleIODataMapper.map(pdMap.get(sds.getProtectionDomainId())));
            }
            sdsData.setIpList(ScaleIODataMapper.mapIpList(sds.getIpList()));
            scaleIOSDSDataRestReps.add(sdsData);
        }
        sio.setSdsList(scaleIOSDSDataRestReps);
        // collect and map SDC data
        List<ScaleIOSDC> allSDC = client.queryAllSDC();
        List<ScaleIOSDCDataRestRep> scaleIOSDCDataRestReps = new ArrayList<ScaleIOSDCDataRestRep>();
        for (ScaleIOSDC sdc : allSDC) {
            ScaleIOSDCDataRestRep sdcData = ScaleIODataMapper.map(sdc);
            // map device data
            List<ScaleIOVolume> volumes = client.getSdcVolumes(sdc.getId());
            List<ScaleIOVolumeDataRestRep> scaleIOVolumeDataRestReps = new ArrayList<ScaleIOVolumeDataRestRep>();
            if (null != volumes) {
                for (ScaleIOVolume volume : volumes) {
                    ScaleIOVolumeDataRestRep scaleIOVolumeDataRestRep = ScaleIODataMapper.map(volume);
                    // map storagepool data
                    scaleIOVolumeDataRestRep.setStoragePool(ScaleIODataMapper.map(spMap.get(volume.getStoragePoolId())));
                    scaleIOVolumeDataRestReps.add(scaleIOVolumeDataRestRep);
                }
                sdcData.setVolumes(scaleIOVolumeDataRestReps);
            }
            scaleIOSDCDataRestReps.add(sdcData);
        }
        sio.setSdcList(scaleIOSDCDataRestReps);
    } catch (ScaleIOException e) {
        log.error(String.format("Exception was encountered in the ScaleIO client when connecting to instance %s", param.getIPAddress()), e);
        throw APIException.badRequests.storageSystemClientException(SCALEIO, e.getLocalizedMessage());
    } catch (JSONException e) {
        log.error(String.format("Exception was encountered when attempting to discover ScaleIO Instance %s", param.getIPAddress()), e);
        throw APIException.badRequests.cannotDiscoverStorageSystemUnexpectedResponse(SCALEIO);
    }
    return sio;
}

Example 2 with ScaleIORestClient

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

the class ScaleIOCommunicationInterface method scan.

@Override
public void scan(AccessProfile accessProfile) throws BaseCollectionException {
    log.info("Starting scan of ScaleIO StorageProvider. IP={}", accessProfile.getIpAddress());
    StorageProvider.ConnectionStatus cxnStatus = StorageProvider.ConnectionStatus.CONNECTED;
    StorageProvider provider = _dbClient.queryObject(StorageProvider.class, accessProfile.getSystemId());
    if (provider.getInterfaceType().equalsIgnoreCase(DiscoveredDataObject.Type.scaleio.name())) {
        provider.setConnectionStatus(StorageProvider.ConnectionStatus.NOTCONNECTED.name());
        ScaleIOException ex = ScaleIOException.exceptions.scaleioCliNotSupported();
        provider.setLastScanStatusMessage(ex.getLocalizedMessage());
        _dbClient.persistObject(provider);
        throw ScaleIOException.exceptions.scaleioCliNotSupported();
    }
    _locker.acquireLock(accessProfile.getIpAddress(), LOCK_WAIT_SECONDS);
    try {
        ScaleIORestClient scaleIOHandle = scaleIOHandleFactory.using(_dbClient).getClientHandle(provider);
        if (scaleIOHandle != null) {
            Map<String, StorageSystemViewObject> storageSystemsCache = accessProfile.getCache();
            ScaleIOSystem sioSystem = scaleIOHandle.getSystem();
            String[] ipList = null;
            if (sioSystem.getVersion().substring(0, 1).compareTo("2") >= 0) {
                Slaves[] slaves = sioSystem.getMdmCluster().getSlaves();
                if ((slaves.length > 0))
                    ipList = new String[slaves.length];
                for (int iterInd = 0; iterInd < slaves.length; iterInd++) {
                    ipList[iterInd] = slaves[iterInd].getIps()[0];
                }
            } else {
                ipList = sioSystem.getSecondaryMdmActorIpList();
            }
            if (ipList != null && ipList.length > 0) {
                StringSet secondaryIps = new StringSet();
                secondaryIps.add(ipList[0]);
                provider.setSecondaryIps(secondaryIps);
            }
            String scaleIOType = StorageSystem.Type.scaleio.name();
            String installationId = sioSystem.getInstallId();
            String version = sioSystem.getVersion().replaceAll("_", ".");
            String minimumSupported = VersionChecker.getMinimumSupportedVersion(StorageSystem.Type.scaleio);
            String compatibility = (VersionChecker.verifyVersionDetails(minimumSupported, version) < 0) ? StorageSystem.CompatibilityStatus.INCOMPATIBLE.name() : StorageSystem.CompatibilityStatus.COMPATIBLE.name();
            provider.setCompatibilityStatus(compatibility);
            provider.setVersionString(version);
            List<ScaleIOProtectionDomain> protectionDomains = scaleIOHandle.getProtectionDomains();
            for (ScaleIOProtectionDomain protectionDomain : protectionDomains) {
                log.info("For ScaleIO instance {}, found ProtectionDomain {}", installationId, protectionDomain.getName());
                String id = String.format("%s+%s", installationId, protectionDomain.getName());
                String nativeGuid = generateNativeGuid(scaleIOType, id);
                StorageSystemViewObject viewObject = storageSystemsCache.get(nativeGuid);
                if (viewObject == null) {
                    viewObject = new StorageSystemViewObject();
                }
                viewObject.setDeviceType(scaleIOType);
                viewObject.addprovider(accessProfile.getSystemId().toString());
                viewObject.setProperty(StorageSystemViewObject.MODEL, "ScaleIO ECS");
                viewObject.setProperty(StorageSystemViewObject.SERIAL_NUMBER, id);
                storageSystemsCache.put(nativeGuid, viewObject);
            }
        }
    } catch (Exception e) {
        cxnStatus = StorageProvider.ConnectionStatus.NOTCONNECTED;
        log.error(String.format("Exception was encountered when attempting to scan ScaleIO Instance %s", accessProfile.getIpAddress()), e);
        throw ScaleIOException.exceptions.scanFailed(e);
    } finally {
        provider.setConnectionStatus(cxnStatus.name());
        _dbClient.persistObject(provider);
        log.info("Completed scan of ScaleIO StorageProvider. IP={}", accessProfile.getIpAddress());
        _locker.releaseLock(accessProfile.getIpAddress());
    }
}

Example 3 with ScaleIORestClient

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

the class ScaleIOStorageDevice method refreshConnectionStatusForAllSIOProviders.

/**
 * Refresh connection status for all ScaleIO providers.
 *
 * @return A list of providers whose connections were successful.
 */
public List<URI> refreshConnectionStatusForAllSIOProviders() {
    log.info("Refreshing connection statuses for ScaleIO providers");
    List<URI> activeProviders = Lists.newArrayList();
    List<StorageProvider> providers = CustomQueryUtility.getActiveStorageProvidersByInterfaceType(dbClient, StorageProvider.InterfaceType.scaleioapi.name());
    for (StorageProvider provider : providers) {
        try {
            // Flag for success/failure
            boolean success = false;
            // Prepare to try secondary IPs if necessary
            StringSet secondaryIps = provider.getSecondaryIps();
            Iterator<String> iterator = secondaryIps.iterator();
            // Cache the current IP address
            String currentIPAddress = provider.getIPAddress();
            String nextIp = null;
            do {
                try {
                    ScaleIORestClient handle = scaleIOHandleFactory.using(dbClient).getClientHandle(provider);
                    // Ignore the result on success, otherwise catch the exception
                    handle.getSystem();
                    log.info("Successfully connected to ScaleIO MDM {}: {}", provider.getIPAddress(), provider.getId());
                    success = true;
                    break;
                } catch (Exception e) {
                    log.error(String.format("Failed to connect to ScaleIO MDM %s: %s", provider.getIPAddress(), provider.getId()), e);
                    if (iterator.hasNext()) {
                        nextIp = iterator.next();
                        log.info("Attempting connection to potential new Primary MDM {}: {}", nextIp, provider.getId());
                        provider.setIPAddress(nextIp);
                    } else {
                        log.warn("Exhausted list of secondary IPs for ScaleIO provider: {}", provider.getId());
                        nextIp = null;
                    }
                }
            } while (// while we have more IPs to try
            nextIp != null);
            if (success) {
                // Update secondary IP addresses if we switched over
                if (!provider.getIPAddress().equalsIgnoreCase(currentIPAddress)) {
                    StringSet newSecondaryIps = new StringSet();
                    // Copy old secondary list
                    newSecondaryIps.addAll(secondaryIps);
                    // Remove the new primary IP
                    newSecondaryIps.remove(provider.getIPAddress());
                    // Add the old primary IP
                    newSecondaryIps.add(currentIPAddress);
                    // TODO Improve how we update the StringSet based on infra team suggestions
                    provider.setSecondaryIps(newSecondaryIps);
                }
                activeProviders.add(provider.getId());
                provider.setConnectionStatus(StorageProvider.ConnectionStatus.CONNECTED.toString());
            } else {
                provider.setIPAddress(currentIPAddress);
                provider.setConnectionStatus(StorageProvider.ConnectionStatus.NOTCONNECTED.toString());
            }
        } finally {
            dbClient.persistObject(provider);
        }
    }
    return activeProviders;
}

Example 4 with ScaleIORestClient

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

the class ScaleIOCloneOperations method createGroupClone.

@Override
public void createGroupClone(StorageSystem storage, List<URI> cloneList, Boolean createInactive, TaskCompleter taskCompleter) {
    try {
        ScaleIORestClient scaleIOHandle = scaleIOHandleFactory.using(dbClient).getClientHandle(storage);
        List<Volume> clones = dbClient.queryObject(Volume.class, cloneList);
        Map<String, String> parent2snap = new HashMap<>();
        Set<URI> poolsToUpdate = new HashSet<>();
        for (Volume clone : clones) {
            Volume parent = dbClient.queryObject(Volume.class, clone.getAssociatedSourceVolume());
            parent2snap.put(parent.getNativeId(), clone.getLabel());
            poolsToUpdate.add(parent.getPool());
        }
        String systemId = scaleIOHandle.getSystemId();
        ScaleIOSnapshotVolumeResponse result = scaleIOHandle.snapshotMultiVolume(parent2snap, systemId);
        List<String> nativeIds = result.getVolumeIdList();
        Map<String, ScaleIOVolume> cloneNameMap = scaleIOHandle.getVolumeNameMap(nativeIds);
        Multimap<URI, String> poolToVolumesMap = ArrayListMultimap.create();
        for (Volume clone : clones) {
            String name = clone.getLabel();
            ScaleIOVolume sioVolume = cloneNameMap.get(name);
            ScaleIOHelper.updateSnapshotWithSnapshotVolumeResult(dbClient, clone, systemId, sioVolume.getId(), storage);
            clone.setAllocatedCapacity(Long.parseLong(sioVolume.getSizeInKb()) * 1024L);
            clone.setProvisionedCapacity(clone.getAllocatedCapacity());
            clone.setCapacity(clone.getAllocatedCapacity());
            clone.setReplicationGroupInstance(result.getSnapshotGroupId());
            poolToVolumesMap.put(clone.getPool(), clone.getId().toString());
        }
        dbClient.updateObject(clones);
        List<StoragePool> pools = dbClient.queryObject(StoragePool.class, Lists.newArrayList(poolsToUpdate));
        for (StoragePool pool : pools) {
            pool.removeReservedCapacityForVolumes(poolToVolumesMap.get(pool.getId()));
            ScaleIOHelper.updateStoragePoolCapacity(dbClient, scaleIOHandle, pool, storage);
        }
        taskCompleter.ready(dbClient);
    } catch (Exception e) {
        log.error("Encountered an exception", e);
        ServiceCoded code = DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation("createGroupClone", e.getMessage());
        taskCompleter.error(dbClient, code);
    }
}

Example 5 with ScaleIORestClient

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

the class ScaleIOCloneOperations method createSingleClone.

@Override
public void createSingleClone(StorageSystem storageSystem, URI sourceVolume, URI cloneVolume, Boolean createInactive, TaskCompleter taskCompleter) {
    try {
        ScaleIORestClient scaleIOHandle = scaleIOHandleFactory.using(dbClient).getClientHandle(storageSystem);
        Volume cloneObj = dbClient.queryObject(Volume.class, cloneVolume);
        BlockObject parent = BlockObject.fetch(dbClient, sourceVolume);
        String systemId = scaleIOHandle.getSystemId();
        // Note: ScaleIO snapshots can be treated as full copies, hence re-use of #snapshotVolume here.
        ScaleIOSnapshotVolumeResponse result = scaleIOHandle.snapshotVolume(parent.getNativeId(), cloneObj.getLabel(), systemId);
        String nativeId = result.getVolumeIdList().get(0);
        ScaleIOHelper.updateSnapshotWithSnapshotVolumeResult(dbClient, cloneObj, systemId, nativeId, storageSystem);
        // Snapshots result does not provide capacity info, so we need to perform a queryVolume
        updateCloneFromQueryVolume(scaleIOHandle, cloneObj);
        dbClient.updateObject(cloneObj);
        StoragePool pool = dbClient.queryObject(StoragePool.class, cloneObj.getPool());
        pool.removeReservedCapacityForVolumes(Arrays.asList(cloneObj.getId().toString()));
        ScaleIOHelper.updateStoragePoolCapacity(dbClient, scaleIOHandle, cloneObj);
        taskCompleter.ready(dbClient);
    } catch (Exception e) {
        Volume clone = dbClient.queryObject(Volume.class, cloneVolume);
        if (clone != null) {
            clone.setInactive(true);
            dbClient.updateObject(clone);
        }
        log.error("Encountered an exception", e);
        ServiceCoded code = DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation("createSingleClone", e.getMessage());
        taskCompleter.error(dbClient, code);
    }
}