Examples with StringSetMap com.emc.storageos.db.client.model.StringSetMap used on opensource projects

Example 36 with StringSetMap

use of com.emc.storageos.db.client.model.StringSetMap in project coprhd-controller by CoprHD.

the class ExportMaskRemoveInitiatorCompleter method removeUnusedTargets.

/*
     * Remove unused storage Ports from export mask
     */
private void removeUnusedTargets(ExportMask exportMask) {
    StringSet initiators = exportMask.getInitiators();
    StringSetMap zoningMap = exportMask.getZoningMap();
    Set<String> zonedTarget = new HashSet<String>();
    boolean isRollback = WorkflowService.getInstance().isStepInRollbackState(getOpId());
    for (String initiator : initiators) {
        StringSet zoneEntry = zoningMap.get(initiator);
        if (zoneEntry != null) {
            zonedTarget.addAll(zoneEntry);
        } else {
            _log.warn(String.format("removeUnusedTargets() - tried looking up initiator [%s] in zoningMap for " + "Export Mask [%s - %s], but no entry found - continue...", initiator, exportMask.getMaskName(), exportMask.getId()));
        }
    }
    Set<String> targets = new HashSet<String>();
    if (exportMask.getStoragePorts() != null) {
        targets.addAll(exportMask.getStoragePorts());
    }
    if (isRollback) {
        StringSet emStoragePorts = new StringSet();
        if (exportMask.getStoragePorts() != null) {
            emStoragePorts = exportMask.getStoragePorts();
        } else {
            _log.warn(String.format("removeUnusedTargets() - could not find any storage ports for" + "Export Mask [%s - %s].", exportMask.getMaskName(), exportMask.getId()));
        }
        targets = new HashSet<String>(emStoragePorts);
    }
    if (!targets.removeAll(zonedTarget)) {
        for (String zonedPort : zonedTarget) {
            exportMask.addTarget(URIUtil.uri(zonedPort));
        }
    }
    for (String targetPort : targets) {
        exportMask.removeTarget(URIUtil.uri(targetPort));
    }
}

Example 37 with StringSetMap

use of com.emc.storageos.db.client.model.StringSetMap in project coprhd-controller by CoprHD.

the class ZoningRemovePathsCompleter method complete.

@Override
protected void complete(DbClient dbClient, Operation.Status status, ServiceCoded coded) throws DeviceControllerException {
    try {
        if (status == Operation.Status.ready && !exportMaskAdjustedPathMap.isEmpty()) {
            for (Map.Entry<URI, Map<URI, List<URI>>> maskPathEntry : exportMaskAdjustedPathMap.entrySet()) {
                URI maskURI = maskPathEntry.getKey();
                Map<URI, List<URI>> zoningPaths = maskPathEntry.getValue();
                ExportMask exportMask = dbClient.queryObject(ExportMask.class, maskURI);
                // update zoning map
                StringSetMap zoningMap = exportMask.getZoningMap();
                zoningMap.clear();
                for (Map.Entry<URI, List<URI>> zoningPath : zoningPaths.entrySet()) {
                    zoningMap.put(zoningPath.getKey().toString(), StringSetUtil.uriListToStringSet(zoningPath.getValue()));
                }
                dbClient.updateObject(exportMask);
            }
        }
    } catch (Exception e) {
        log.error(String.format("Failed updating status for ZoningRemovePaths - Id: %s, OpId: %s", getId().toString(), getOpId()), e);
    } finally {
        super.complete(dbClient, status, coded);
    }
}

Example 38 with StringSetMap

use of com.emc.storageos.db.client.model.StringSetMap in project coprhd-controller by CoprHD.

the class StorageVolumeInfoProcessor method resetRemoteTargetVolumeInfo.

/**
 * Resets the un-managed target (replica) volume information
 *
 * @param unManagedVolume the UnManaged volume
 */
private void resetRemoteTargetVolumeInfo(UnManagedVolume unManagedVolume) {
    _logger.info("Resetting remote target un-managed volume infor for: {}", unManagedVolume.getLabel());
    StringSetMap unManagedVolumeInformation = unManagedVolume.getVolumeInformation();
    if (unManagedVolumeInformation != null) {
        if (unManagedVolumeInformation.containsKey(SupportedVolumeInformation.REMOTE_VOLUME_TYPE.name())) {
            unManagedVolumeInformation.remove(SupportedVolumeInformation.REMOTE_VOLUME_TYPE.name());
        }
        if (unManagedVolumeInformation.containsKey(SupportedVolumeInformation.REMOTE_MIRROR_RDF_GROUP.name())) {
            unManagedVolumeInformation.remove(SupportedVolumeInformation.REMOTE_MIRROR_RDF_GROUP.name());
        }
        if (unManagedVolumeInformation.containsKey(SupportedVolumeInformation.REMOTE_COPY_MODE.name())) {
            unManagedVolumeInformation.remove(SupportedVolumeInformation.REMOTE_COPY_MODE.name());
        }
        if (unManagedVolumeInformation.containsKey(SupportedVolumeInformation.REMOTE_MIRROR_SOURCE_VOLUME.name())) {
            unManagedVolumeInformation.remove(SupportedVolumeInformation.REMOTE_MIRROR_SOURCE_VOLUME.name());
        }
    }
}

Example 39 with StringSetMap

use of com.emc.storageos.db.client.model.StringSetMap in project coprhd-controller by CoprHD.

the class StorageVolumeInfoProcessor method createUnManagedVolume.

/**
 * create StorageVolume Info Object
 *
 * @param unManagedVolume
 * @param volumeInstance
 * @param unManagedVolumeNativeGuid
 * @param pool
 * @param system
 * @param volumeNativeGuid
 * @param exportedVolumes
 * @param existingVolumesInCG
 * @param volumeToRAGroupMap
 * @param volumeToLocalReplicaMap
 * @param volumeToSyncAspectMap
 * @param poolSupportedSLONames
 * @param keyMap
 * @param srdfEnabledTargetVPools
 * @param duplicateSyncAspectElementNameMap
 * @return
 */
private UnManagedVolume createUnManagedVolume(UnManagedVolume unManagedVolume, CIMInstance volumeInstance, String unManagedVolumeNativeGuid, StoragePool pool, StorageSystem system, String volumeNativeGuid, Map<String, VolHostIOObject> exportedVolumes, Set<String> existingVolumesInCG, Map<String, RemoteMirrorObject> volumeToRAGroupMap, Map<String, LocalReplicaObject> volumeToLocalReplicaMap, Map<String, Map<String, String>> volumeToSyncAspectMap, Set<String> poolSupportedSLONames, Map<String, Object> keyMap, Set<URI> srdfEnabledTargetVPools, Map<String, Set<String>> duplicateSyncAspectElementNameMap) {
    _logger.info("Create UnManagedVolume {}", unManagedVolumeNativeGuid);
    try {
        String volumeType = Types.REGULAR.toString();
        StringSetMap unManagedVolumeInformation = null;
        Map<String, String> unManagedVolumeCharacteristics = null;
        boolean created = false;
        if (null == unManagedVolume) {
            unManagedVolume = new UnManagedVolume();
            unManagedVolume.setId(URIUtil.createId(UnManagedVolume.class));
            unManagedVolume.setNativeGuid(unManagedVolumeNativeGuid);
            unManagedVolume.setStorageSystemUri(system.getId());
            created = true;
            unManagedVolumeInformation = new StringSetMap();
            unManagedVolumeCharacteristics = new HashMap<String, String>();
        }
        // so that the tiering info is updated correctly later
        if (!created) {
            unManagedVolumeInformation = unManagedVolume.getVolumeInformation();
            unManagedVolumeCharacteristics = unManagedVolume.getVolumeCharacterstics();
            if (unManagedVolumeInformation.get(SupportedVolumeInformation.AUTO_TIERING_POLICIES.toString()) != null) {
                unManagedVolumeInformation.get(SupportedVolumeInformation.AUTO_TIERING_POLICIES.toString()).clear();
            }
            unManagedVolume.putVolumeCharacterstics(SupportedVolumeCharacterstics.IS_AUTO_TIERING_ENABLED.toString(), "false");
            resetLocalReplicaInfo(unManagedVolume);
            resetRemoteSourceVolumeInfo(unManagedVolume);
            resetRemoteTargetVolumeInfo(unManagedVolume);
        }
        if (null != system) {
            StringSet systemTypes = new StringSet();
            systemTypes.add(system.getSystemType());
            unManagedVolumeInformation.put(SupportedVolumeInformation.SYSTEM_TYPE.toString(), systemTypes);
        }
        if (exportedVolumes != null && exportedVolumes.containsKey(volumeNativeGuid)) {
            VolHostIOObject obj = exportedVolumes.get(volumeNativeGuid);
            if (null != obj) {
                StringSet bwValues = new StringSet();
                bwValues.add(obj.getHostIoBw());
                if (unManagedVolumeInformation.get(SupportedVolumeInformation.EMC_MAXIMUM_IO_BANDWIDTH.toString()) == null) {
                    unManagedVolumeInformation.put(SupportedVolumeInformation.EMC_MAXIMUM_IO_BANDWIDTH.toString(), bwValues);
                } else {
                    unManagedVolumeInformation.get(SupportedVolumeInformation.EMC_MAXIMUM_IO_BANDWIDTH.toString()).replace(bwValues);
                }
                StringSet iopsVal = new StringSet();
                iopsVal.add(obj.getHostIops());
                if (unManagedVolumeInformation.get(SupportedVolumeInformation.EMC_MAXIMUM_IOPS.toString()) == null) {
                    unManagedVolumeInformation.put(SupportedVolumeInformation.EMC_MAXIMUM_IOPS.toString(), iopsVal);
                } else {
                    unManagedVolumeInformation.get(SupportedVolumeInformation.EMC_MAXIMUM_IOPS.toString()).replace(iopsVal);
                }
            }
            unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_VOLUME_EXPORTED.toString(), TRUE);
        } else {
            unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_VOLUME_EXPORTED.toString(), FALSE);
            StringSet bwValues = new StringSet();
            bwValues.add("0");
            if (unManagedVolumeInformation.get(SupportedVolumeInformation.EMC_MAXIMUM_IO_BANDWIDTH.toString()) == null) {
                unManagedVolumeInformation.put(SupportedVolumeInformation.EMC_MAXIMUM_IO_BANDWIDTH.toString(), bwValues);
            } else {
                unManagedVolumeInformation.get(SupportedVolumeInformation.EMC_MAXIMUM_IO_BANDWIDTH.toString()).replace(bwValues);
            }
            StringSet iopsVal = new StringSet();
            iopsVal.add("0");
            if (unManagedVolumeInformation.get(SupportedVolumeInformation.EMC_MAXIMUM_IOPS.toString()) == null) {
                unManagedVolumeInformation.put(SupportedVolumeInformation.EMC_MAXIMUM_IOPS.toString(), iopsVal);
            } else {
                unManagedVolumeInformation.get(SupportedVolumeInformation.EMC_MAXIMUM_IOPS.toString()).replace(iopsVal);
            }
        }
        // Set Export Mask HLUs
        @SuppressWarnings("unchecked") Map<String, StringSet> volumeToExportMasksHLUMap = (Map<String, StringSet>) keyMap.get(Constants.UN_VOLUME_EXPORT_MASK_HLUS_MAP);
        if (volumeToExportMasksHLUMap != null && volumeToExportMasksHLUMap.containsKey(unManagedVolumeNativeGuid)) {
            unManagedVolumeInformation.put(SupportedVolumeInformation.HLU_TO_EXPORT_MASK_NAME_MAP.toString(), // replace() does not work
            volumeToExportMasksHLUMap.get(unManagedVolumeNativeGuid));
        }
        // Set SLOName only for VMAX3 exported volumes
        if (system.checkIfVmax3()) {
            // set for a volume, update the tiering_enabled to false.
            if (poolSupportedSLONames == null || poolSupportedSLONames.isEmpty() || !keyMap.containsKey(Constants.VOLUMES_WITH_SLOS)) {
                unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_AUTO_TIERING_ENABLED.toString(), Boolean.FALSE.toString());
            } else {
                Map<String, String> volumesWithSLO = (Map<String, String>) keyMap.get(Constants.VOLUMES_WITH_SLOS);
                if (volumesWithSLO.containsKey(volumeNativeGuid)) {
                    String sloName = volumesWithSLO.get(volumeNativeGuid);
                    _logger.debug("formattedSLOName: {}", sloName);
                    updateSLOPolicies(poolSupportedSLONames, unManagedVolumeInformation, unManagedVolumeCharacteristics, sloName);
                } else {
                    unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_AUTO_TIERING_ENABLED.toString(), Boolean.FALSE.toString());
                }
            }
        }
        if (existingVolumesInCG != null && existingVolumesInCG.contains(volumeNativeGuid)) {
            unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_VOLUME_ADDED_TO_CONSISTENCYGROUP.toString(), TRUE);
        } else {
            unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_VOLUME_ADDED_TO_CONSISTENCYGROUP.toString(), FALSE);
        }
        // Set the attributes for new smis version.
        Object raidLevelObj;
        String isNotIngestableReason;
        String isBound;
        String isThinlyProvisioned;
        String isMetaVolume;
        String allocCapacity;
        if (keyMap.containsKey(Constants.IS_NEW_SMIS_PROVIDER) && Boolean.valueOf(keyMap.get(Constants.IS_NEW_SMIS_PROVIDER).toString())) {
            unManagedVolume.setLabel(getCIMPropertyValue(volumeInstance, "ElementName"));
            raidLevelObj = volumeInstance.getPropertyValue(SupportedVolumeInformation.RAID_LEVEL.getAlternateKey());
            isBound = getCIMPropertyValue(volumeInstance, SupportedVolumeCharacterstics.IS_BOUND.getAlterCharacterstic());
            isNotIngestableReason = isVolumeIngestable(volumeInstance, isBound, USAGE, unManagedVolumeNativeGuid, duplicateSyncAspectElementNameMap);
            isThinlyProvisioned = getCIMPropertyValue(volumeInstance, THINLY_PROVISIONED);
            isMetaVolume = getCIMPropertyValue(volumeInstance, SupportedVolumeCharacterstics.IS_METAVOLUME.getAlterCharacterstic());
            allocCapacity = getAllocatedCapacity(volumeInstance, _volumeToSpaceConsumedMap, system.checkIfVmax3());
        } else {
            unManagedVolume.setLabel(getCIMPropertyValue(volumeInstance, SVELEMENT_NAME));
            isBound = getCIMPropertyValue(volumeInstance, SupportedVolumeCharacterstics.IS_BOUND.getCharacterstic());
            raidLevelObj = volumeInstance.getPropertyValue(SupportedVolumeInformation.RAID_LEVEL.getInfoKey());
            isNotIngestableReason = isVolumeIngestable(volumeInstance, isBound, SVUSAGE, unManagedVolumeNativeGuid, duplicateSyncAspectElementNameMap);
            isThinlyProvisioned = getCIMPropertyValue(volumeInstance, EMC_THINLY_PROVISIONED);
            isMetaVolume = getCIMPropertyValue(volumeInstance, SupportedVolumeCharacterstics.IS_METAVOLUME.getCharacterstic());
            allocCapacity = getCIMPropertyValue(volumeInstance, EMC_ALLOCATED_CAPACITY);
        }
        if (null != raidLevelObj) {
            StringSet raidLevels = new StringSet();
            raidLevels.add(raidLevelObj.toString());
            unManagedVolumeInformation.put(SupportedVolumeInformation.RAID_LEVEL.toString(), raidLevels);
        }
        if (null != isBound) {
            unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_BOUND.toString(), isBound);
        }
        if (null != isThinlyProvisioned) {
            unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_THINLY_PROVISIONED.toString(), isThinlyProvisioned);
        }
        if (null != isMetaVolume) {
            unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_METAVOLUME.toString(), isMetaVolume);
        }
        // Volumes which are set EMCIsBound as false cannot be ingested
        if (isNotIngestableReason == null) {
            unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_INGESTABLE.toString(), TRUE);
        } else {
            unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_INGESTABLE.toString(), FALSE);
            unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_NOT_INGESTABLE_REASON.toString(), isNotIngestableReason);
        }
        if (volumeToRAGroupMap.containsKey(unManagedVolume.getNativeGuid())) {
            RemoteMirrorObject rmObj = volumeToRAGroupMap.get(unManagedVolume.getNativeGuid());
            _logger.info("Found RA Object {}", rmObj.toString());
            if (RemoteMirrorObject.Types.SOURCE.toString().equalsIgnoreCase(rmObj.getType())) {
                _logger.info("Found Source, updating targets {}", rmObj.getTargetVolumenativeGuids());
                // setting target Volumes
                if (unManagedVolumeInformation.get(SupportedVolumeInformation.REMOTE_MIRRORS.toString()) == null) {
                    unManagedVolumeInformation.put(SupportedVolumeInformation.REMOTE_MIRRORS.toString(), rmObj.getTargetVolumenativeGuids());
                } else {
                    if (null == rmObj.getTargetVolumenativeGuids() || rmObj.getTargetVolumenativeGuids().isEmpty()) {
                        unManagedVolumeInformation.get(SupportedVolumeInformation.REMOTE_MIRRORS.toString()).clear();
                    } else {
                        unManagedVolumeInformation.get(SupportedVolumeInformation.REMOTE_MIRRORS.toString()).replace(rmObj.getTargetVolumenativeGuids());
                    }
                }
                volumeType = Types.SOURCE.toString();
            } else if (RemoteMirrorObject.Types.TARGET.toString().equalsIgnoreCase(rmObj.getType())) {
                _logger.info("Found Target {}, updating copyMode {}, RA Group", unManagedVolume.getNativeGuid(), rmObj.getCopyMode());
                // setting srdfParent
                StringSet parentVolume = new StringSet();
                parentVolume.add(rmObj.getSourceVolumeNativeGuid());
                unManagedVolumeInformation.put(SupportedVolumeInformation.REMOTE_MIRROR_SOURCE_VOLUME.toString(), parentVolume);
                // setting RAGroup
                StringSet raGroup = new StringSet();
                // set Source array's RA group URI in Target volume
                if (rmObj.getTargetRaGroupUri() != null) {
                    raGroup.add(rmObj.getTargetRaGroupUri().toString());
                } else {
                    _logger.warn("Source Array's RA Group is not populated. Check if Source array is discovered." + " Target: {}", unManagedVolume.getNativeGuid());
                }
                volumeType = Types.TARGET.toString();
                unManagedVolumeInformation.put(SupportedVolumeInformation.REMOTE_MIRROR_RDF_GROUP.toString(), raGroup);
            }
            // setting Copy Modes
            StringSet copyModes = new StringSet();
            copyModes.add(rmObj.getCopyMode());
            if (unManagedVolumeInformation.get(SupportedVolumeInformation.REMOTE_COPY_MODE.toString()) == null) {
                unManagedVolumeInformation.put(SupportedVolumeInformation.REMOTE_COPY_MODE.toString(), copyModes);
            } else {
                unManagedVolumeInformation.get(SupportedVolumeInformation.REMOTE_COPY_MODE.toString()).replace(copyModes);
            }
            // setting Volume Type
            StringSet remoteVolumeType = new StringSet();
            remoteVolumeType.add(rmObj.getType());
            unManagedVolumeInformation.put(SupportedVolumeInformation.REMOTE_VOLUME_TYPE.toString(), remoteVolumeType);
            unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.REMOTE_MIRRORING.toString(), TRUE);
        } else {
            unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.REMOTE_MIRRORING.toString(), FALSE);
        }
        // handle clones, local mirrors and snapshots
        boolean isLocalReplica = false;
        if (volumeToLocalReplicaMap.containsKey(unManagedVolume.getNativeGuid())) {
            _logger.info("Found in localReplicaMap {}", unManagedVolume.getNativeGuid());
            LocalReplicaObject lrObj = volumeToLocalReplicaMap.get(unManagedVolume.getNativeGuid());
            isLocalReplica = lrObj.isReplica();
            // setting targets
            StringSet fullCopies = lrObj.getFullCopies();
            if (fullCopies != null && !fullCopies.isEmpty()) {
                unManagedVolumeInformation.put(SupportedVolumeInformation.FULL_COPIES.name(), fullCopies);
            }
            StringSet mirrors = lrObj.getMirrors();
            if (mirrors != null && !mirrors.isEmpty()) {
                unManagedVolumeInformation.put(SupportedVolumeInformation.MIRRORS.name(), mirrors);
            }
            StringSet snapshots = lrObj.getSnapshots();
            if (snapshots != null && !snapshots.isEmpty()) {
                unManagedVolumeInformation.put(SupportedVolumeInformation.SNAPSHOTS.name(), snapshots);
            }
            if (lrObj.hasReplica()) {
                // set the HAS_REPLICAS property
                unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.HAS_REPLICAS.name(), TRUE);
            }
            if (LocalReplicaObject.Types.FullCopy.equals(lrObj.getType())) {
                _logger.info("Found Clone {}", unManagedVolume.getNativeGuid());
                // setting clone specific info
                unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_FULL_COPY.name(), TRUE);
                StringSet sourceVolume = new StringSet();
                sourceVolume.add(lrObj.getSourceNativeGuid());
                unManagedVolumeInformation.put(SupportedVolumeInformation.LOCAL_REPLICA_SOURCE_VOLUME.name(), sourceVolume);
                StringSet isSyncActive = new StringSet();
                isSyncActive.add(new Boolean(lrObj.isSyncActive()).toString());
                unManagedVolumeInformation.put(SupportedVolumeInformation.IS_SYNC_ACTIVE.name(), isSyncActive);
                StringSet replicaState = new StringSet();
                replicaState.add(lrObj.getReplicaState());
                unManagedVolumeInformation.put(SupportedVolumeInformation.REPLICA_STATE.name(), replicaState);
            } else if (LocalReplicaObject.Types.BlockMirror.equals(lrObj.getType())) {
                _logger.info("Found Local Mirror {}", unManagedVolume.getNativeGuid());
                // setting local mirror specific info
                unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_LOCAL_MIRROR.name(), TRUE);
                StringSet sourceVolume = new StringSet();
                sourceVolume.add(lrObj.getSourceNativeGuid());
                unManagedVolumeInformation.put(SupportedVolumeInformation.LOCAL_REPLICA_SOURCE_VOLUME.name(), sourceVolume);
                StringSet syncState = new StringSet();
                syncState.add(lrObj.getSyncState());
                unManagedVolumeInformation.put(SupportedVolumeInformation.SYNC_STATE.name(), syncState);
                StringSet syncType = new StringSet();
                syncType.add(lrObj.getSyncType());
                unManagedVolumeInformation.put(SupportedVolumeInformation.SYNC_TYPE.name(), syncType);
                String syncedInst = lrObj.getSynchronizedInstance();
                if (syncedInst != null) {
                    StringSet synchronizedInstance = new StringSet();
                    synchronizedInstance.add(syncedInst);
                    unManagedVolumeInformation.put(SupportedVolumeInformation.SYNCHRONIZED_INSTANCE.name(), synchronizedInstance);
                }
            } else if (LocalReplicaObject.Types.BlockSnapshot.equals(lrObj.getType())) {
                _logger.info("Found Snapshot {}", unManagedVolume.getNativeGuid());
                // setting snapshot specific info
                unManagedVolumeCharacteristics.put(SupportedVolumeCharacterstics.IS_SNAP_SHOT.name(), TRUE);
                StringSet sourceVolume = new StringSet();
                sourceVolume.add(lrObj.getSourceNativeGuid());
                unManagedVolumeInformation.put(SupportedVolumeInformation.LOCAL_REPLICA_SOURCE_VOLUME.name(), sourceVolume);
                StringSet isSyncActive = new StringSet();
                isSyncActive.add(new Boolean(lrObj.isSyncActive()).toString());
                unManagedVolumeInformation.put(SupportedVolumeInformation.IS_SYNC_ACTIVE.name(), isSyncActive);
                StringSet needsCopyToTarget = new StringSet();
                needsCopyToTarget.add(new Boolean(lrObj.isNeedsCopyToTarget()).toString());
                unManagedVolumeInformation.put(SupportedVolumeInformation.NEEDS_COPY_TO_TARGET.name(), needsCopyToTarget);
                StringSet technologyType = new StringSet();
                technologyType.add(lrObj.getTechnologyType());
                unManagedVolumeInformation.put(SupportedVolumeInformation.TECHNOLOGY_TYPE.name(), technologyType);
                String settingsInst = lrObj.getSettingsInstance();
                if (settingsInst != null) {
                    StringSet settingsInstance = new StringSet();
                    settingsInstance.add(settingsInst);
                    unManagedVolumeInformation.put(SupportedVolumeInformation.SETTINGS_INSTANCE.name(), settingsInstance);
                }
            }
        }
        // Array snapshot sessions for which the volume is the source.
        if (volumeToSyncAspectMap.containsKey(unManagedVolume.getNativeGuid())) {
            _logger.info("Found in SyncAspectMap {}", unManagedVolume.getNativeGuid());
            StringSet syncAspectInfoForForVolume = new StringSet();
            Map<String, String> syncAspectMap = volumeToSyncAspectMap.get(unManagedVolume.getNativeGuid());
            for (String syncAspectKey : syncAspectMap.keySet()) {
                String syncAspectName = syncAspectKey.split(Constants.COLON)[1];
                String syncAspectObjPath = syncAspectMap.get(syncAspectKey);
                String syncAspectInfo = syncAspectName + Constants.COLON + syncAspectObjPath;
                syncAspectInfoForForVolume.add(syncAspectInfo);
            }
            unManagedVolumeInformation.put(SupportedVolumeInformation.SNAPSHOT_SESSIONS.name(), syncAspectInfoForForVolume);
        }
        // set volume's isSyncActive
        if (!isLocalReplica) {
            StringSet isSyncActive = new StringSet();
            isSyncActive.add(TRUE);
            unManagedVolumeInformation.put(SupportedVolumeInformation.IS_SYNC_ACTIVE.name(), isSyncActive);
        }
        if (null != pool) {
            unManagedVolume.setStoragePoolUri(pool.getId());
            StringSet pools = new StringSet();
            pools.add(pool.getId().toString());
            unManagedVolumeInformation.put(SupportedVolumeInformation.STORAGE_POOL.toString(), pools);
            StringSet driveTypes = pool.getSupportedDriveTypes();
            if (null != driveTypes) {
                unManagedVolumeInformation.put(SupportedVolumeInformation.DISK_TECHNOLOGY.toString(), driveTypes);
            }
            StringSet matchedVPools = DiscoveryUtils.getMatchedVirtualPoolsForPool(_dbClient, pool.getId(), unManagedVolumeCharacteristics.get(SupportedVolumeCharacterstics.IS_THINLY_PROVISIONED.toString()), srdfEnabledTargetVPools, null, volumeType, unManagedVolume);
            _logger.debug("Matched Pools : {}", Joiner.on("\t").join(matchedVPools));
            if (null == matchedVPools || matchedVPools.isEmpty()) {
                // clear all existing supported vpools.
                unManagedVolume.getSupportedVpoolUris().clear();
            } else {
                // replace with new StringSet
                unManagedVolume.getSupportedVpoolUris().replace(matchedVPools);
                _logger.info("Replaced Pools :" + Joiner.on("\t").join(unManagedVolume.getSupportedVpoolUris()));
            }
        }
        // set allocated capacity
        if (allocCapacity != null) {
            StringSet allocCapacitySet = new StringSet();
            allocCapacitySet.add(allocCapacity);
            unManagedVolumeInformation.put(SupportedVolumeInformation.ALLOCATED_CAPACITY.toString(), allocCapacitySet);
        }
        StringSet provCapacity = new StringSet();
        provCapacity.add(String.valueOf(returnProvisionedCapacity(volumeInstance, keyMap)));
        unManagedVolumeInformation.put(SupportedVolumeInformation.PROVISIONED_CAPACITY.toString(), provCapacity);
        injectVolumeInformation(unManagedVolume, volumeInstance, unManagedVolumeInformation);
        injectVolumeCharacterstics(unManagedVolume, volumeInstance, unManagedVolumeCharacteristics);
        unManagedVolume.getUnmanagedExportMasks().clear();
        unManagedVolume.getInitiatorUris().clear();
        unManagedVolume.getInitiatorNetworkIds().clear();
        Object wwn = getCIMPropertyValue(volumeInstance, SmisConstants.CP_WWN_NAME_ALT);
        if (null == wwn) {
            wwn = getCIMPropertyValue(volumeInstance, SmisConstants.CP_WWN_NAME);
        }
        unManagedVolume.setWwn(String.valueOf(wwn));
        if (created) {
            _unManagedVolumesInsert.add(unManagedVolume);
        } else {
            _unManagedVolumesUpdate.add(unManagedVolume);
        }
    } catch (Exception e) {
        _logger.error("Exception: ", e);
    }
    return unManagedVolume;
}

Example 40 with StringSetMap

use of com.emc.storageos.db.client.model.StringSetMap in project coprhd-controller by CoprHD.

the class StorageVolumeInfoProcessor method resetRemoteSourceVolumeInfo.

/**
 * Resets the un-managed source volume information
 *
 * @param unManagedVolume the UnManaged volume
 */
private void resetRemoteSourceVolumeInfo(UnManagedVolume unManagedVolume) {
    _logger.info("Resetting remote source un-managed volume infor for: {}", unManagedVolume.getLabel());
    StringSetMap unManagedVolumeInformation = unManagedVolume.getVolumeInformation();
    if (unManagedVolumeInformation != null) {
        if (unManagedVolumeInformation.containsKey(SupportedVolumeInformation.REMOTE_MIRRORS.name())) {
            unManagedVolumeInformation.remove(SupportedVolumeInformation.REMOTE_MIRRORS.name());
        }
        if (unManagedVolumeInformation.containsKey(SupportedVolumeInformation.REMOTE_VOLUME_TYPE.name())) {
            unManagedVolumeInformation.remove(SupportedVolumeInformation.REMOTE_VOLUME_TYPE.name());
        }
        if (unManagedVolumeInformation.containsKey(SupportedVolumeInformation.REMOTE_COPY_MODE.name())) {
            unManagedVolumeInformation.remove(SupportedVolumeInformation.REMOTE_COPY_MODE.name());
        }
        Map<String, String> unManagedVolumeCharacteristics = unManagedVolume.getVolumeCharacterstics();
        if (unManagedVolumeCharacteristics != null) {
            if (unManagedVolumeCharacteristics.containsKey(SupportedVolumeCharacterstics.REMOTE_MIRRORING.toString())) {
                unManagedVolumeCharacteristics.remove(SupportedVolumeCharacterstics.REMOTE_MIRRORING.toString());
            }
        }
    }
}