public static void setSystemResourcesIncompatible(
DbClient dbClient, CoordinatorClient coordinator, URI storageSystemId) {
// Mark all Pools as incompatible
URIQueryResultList storagePoolURIs = new URIQueryResultList();
dbClient.queryByConstraint(
ContainmentConstraint.Factory.getStorageDeviceStoragePoolConstraint(storageSystemId),
storagePoolURIs);
Iterator<URI> storagePoolIter = storagePoolURIs.iterator();
List<StoragePool> modifiedPools = new ArrayList<StoragePool>();
while (storagePoolIter.hasNext()) {
StoragePool pool = dbClient.queryObject(StoragePool.class, storagePoolIter.next());
modifiedPools.add(pool);
pool.setCompatibilityStatus(DiscoveredDataObject.CompatibilityStatus.INCOMPATIBLE.name());
dbClient.persistObject(pool);
}
ImplicitPoolMatcher.matchModifiedStoragePoolsWithAllVirtualPool(
modifiedPools, dbClient, coordinator);
;
// Mark all Ports as incompatible
URIQueryResultList storagePortURIs = new URIQueryResultList();
dbClient.queryByConstraint(
ContainmentConstraint.Factory.getStorageDeviceStoragePortConstraint(storageSystemId),
storagePortURIs);
Iterator<URI> storagePortIter = storagePortURIs.iterator();
while (storagePortIter.hasNext()) {
StoragePort port = dbClient.queryObject(StoragePort.class, storagePortIter.next());
port.setCompatibilityStatus(DiscoveredDataObject.CompatibilityStatus.INCOMPATIBLE.name());
dbClient.persistObject(port);
}
}
// Getting all the vpools
public static StringSet getMatchedVirtualPoolsForPool(DbClient dbClient, URI poolUri) {
StringSet vpoolUriSet = new StringSet();
// We should match all virtual pools as below:
// 1) Virtual pools which have useMatchedPools set to true and have the storage pool in their
// matched pools
// 2) Virtual pools which have the storage pool in their assigned pools
URIQueryResultList vpoolMatchedPoolsResultList = new URIQueryResultList();
dbClient.queryByConstraint(
ContainmentConstraint.Factory.getMatchedPoolVirtualPoolConstraint(poolUri),
vpoolMatchedPoolsResultList);
List<VirtualPool> vPoolsMatchedPools =
dbClient.queryObject(VirtualPool.class, vpoolMatchedPoolsResultList);
StoragePool storagePool = dbClient.queryObject(StoragePool.class, poolUri);
for (VirtualPool vPool : vPoolsMatchedPools) {
List<StoragePool> validPools = VirtualPool.getValidStoragePools(vPool, dbClient, true);
for (StoragePool sPool : validPools) {
if (sPool.getId().equals(storagePool.getId())) {
vpoolUriSet.add(vPool.getId().toString());
break;
}
}
}
return vpoolUriSet;
}
/**
* Allocate, initialize and persist state of the Bucket being created.
*
* @param param
* @param project
* @param tenantOrg
* @param neighborhood
* @param vpool
* @param flags
* @param placement
* @return
*/
private Bucket prepareBucket(
BucketParam param,
Project project,
TenantOrg tenantOrg,
VirtualArray neighborhood,
VirtualPool vpool,
DataObject.Flag[] flags,
BucketRecommendation placement) {
_log.debug("Preparing Bucket creation for Param : {}", param);
StoragePool pool = null;
Bucket bucket = new Bucket();
bucket.setId(URIUtil.createId(Bucket.class));
bucket.setLabel(param.getLabel().replaceAll(SPECIAL_CHAR_REGEX, ""));
bucket.setHardQuota(SizeUtil.translateSize(param.getHardQuota()));
bucket.setSoftQuota(SizeUtil.translateSize(param.getSoftQuota()));
bucket.setRetention(Integer.valueOf(param.getRetention()));
bucket.setOwner(getOwner(param.getOwner()));
bucket.setNamespace(tenantOrg.getNamespace());
bucket.setVirtualPool(param.getVpool());
if (project != null) {
bucket.setProject(new NamedURI(project.getId(), bucket.getLabel()));
}
bucket.setTenant(new NamedURI(tenantOrg.getId(), param.getLabel()));
bucket.setVirtualArray(neighborhood.getId());
if (null != placement.getSourceStoragePool()) {
pool = _dbClient.queryObject(StoragePool.class, placement.getSourceStoragePool());
if (null != pool) {
bucket.setProtocol(new StringSet());
bucket
.getProtocol()
.addAll(
VirtualPoolUtil.getMatchingProtocols(vpool.getProtocols(), pool.getProtocols()));
}
}
bucket.setStorageDevice(placement.getSourceStorageSystem());
bucket.setPool(placement.getSourceStoragePool());
bucket.setOpStatus(new OpStatusMap());
// Bucket name to be used at Storage System
String bucketName = project.getLabel() + UNDER_SCORE + param.getLabel();
bucket.setName(bucketName.replaceAll(SPECIAL_CHAR_REGEX, ""));
// Update Bucket path
StringBuilder bucketPath = new StringBuilder();
bucketPath
.append(tenantOrg.getNamespace())
.append(SLASH)
.append(project.getLabel())
.append(SLASH)
.append(param.getLabel());
bucket.setPath(bucketPath.toString());
if (flags != null) {
bucket.addInternalFlags(flags);
}
_dbClient.createObject(bucket);
return bucket;
}
public static void checkStoragePortsNotVisibleForSMI(
List<StoragePort> discoveredPorts,
Set<URI> systemsToRunRPConnectivity,
List<StoragePort> portsToRunNetworkConnectivity,
Map<URI, StoragePool> poolsToMatchWithVpool,
DbClient dbClient,
URI storageSystemId) {
List<StoragePort> notVisiblePorts =
checkStoragePortsNotVisible(discoveredPorts, dbClient, storageSystemId);
// Systems used to run RP connectivity later after runing pool matcher
if (systemsToRunRPConnectivity != null) {
systemsToRunRPConnectivity.addAll(
StoragePoolAssociationHelper.getStorageSytemsFromPorts(notVisiblePorts, null));
}
if (poolsToMatchWithVpool != null) {
List<StoragePool> modifiedPools =
StoragePoolAssociationHelper.getStoragePoolsFromPorts(dbClient, null, notVisiblePorts);
for (StoragePool pool : modifiedPools) {
// pool matcher will be invoked on this pool
if (!poolsToMatchWithVpool.containsKey(pool.getId())) {
poolsToMatchWithVpool.put(pool.getId(), pool);
}
}
}
// ports used later to run Transport Zone connectivity
if (portsToRunNetworkConnectivity != null) {
portsToRunNetworkConnectivity.addAll(notVisiblePorts);
}
}
/**
* get Matched Virtual Pools For Pool. This is called to calculate supported vpools during
* unmanaged objects discovery
*
* @param poolUri
* @return
*/
public static StringSet getMatchedVirtualPoolsForPool(
DbClient dbClient, URI poolUri, String isThinlyProvisionedUnManagedObject) {
StringSet vpoolUriSet = new StringSet();
// We should match all virtual pools as below:
// 1) Virtual pools which have useMatchedPools set to true and have the storage pool in their
// matched pools
// 2) Virtual pools which have the storage pool in their assigned pools
URIQueryResultList vpoolMatchedPoolsResultList = new URIQueryResultList();
dbClient.queryByConstraint(
ContainmentConstraint.Factory.getMatchedPoolVirtualPoolConstraint(poolUri),
vpoolMatchedPoolsResultList);
List<VirtualPool> vPoolsMatchedPools =
dbClient.queryObject(VirtualPool.class, vpoolMatchedPoolsResultList);
String provisioningTypeUnManagedObject =
UnManagedVolume.SupportedProvisioningType.getProvisioningType(
isThinlyProvisionedUnManagedObject);
StoragePool storagePool = dbClient.queryObject(StoragePool.class, poolUri);
for (VirtualPool vPool : vPoolsMatchedPools) {
if (!VirtualPool.vPoolSpecifiesHighAvailability(vPool)) {
List<StoragePool> validPools = VirtualPool.getValidStoragePools(vPool, dbClient, true);
for (StoragePool sPool : validPools) {
if (sPool.getId().equals(storagePool.getId())
&& provisioningTypeUnManagedObject.equalsIgnoreCase(
vPool.getSupportedProvisioningType())) {
vpoolUriSet.add(vPool.getId().toString());
break;
}
}
}
}
return vpoolUriSet;
}
/*
* (non-Javadoc)
*
* @see com.emc.storageos.volumecontroller.BlockStorageDevice#doExpandVolume(com.emc.storageos.db.client.model.StorageSystem,
* com.emc.storageos.db.client.model.StoragePool, com.emc.storageos.db.client.model.Volume, java.lang.Long,
* com.emc.storageos.volumecontroller.TaskCompleter)
*/
@Override
public void doExpandVolume(
StorageSystem storageSystem,
StoragePool storagePool,
Volume volume,
Long size,
TaskCompleter taskCompleter)
throws DeviceControllerException {
log.info(
String.format(
"Expand Volume Start - Array: %s, Pool: %s, Volume: %s, New size: %d",
storageSystem.getSerialNumber(), storagePool.getNativeGuid(), volume.getLabel(), size));
try {
HDSApiClient hdsApiClient =
hdsApiFactory.getClient(
HDSUtils.getHDSServerManagementServerInfo(storageSystem),
storageSystem.getSmisUserName(),
storageSystem.getSmisPassword());
String systemObjectID = HDSUtils.getSystemObjectID(storageSystem);
String asyncTaskMessageId = null;
if (volume.getThinlyProvisioned()) {
asyncTaskMessageId =
hdsApiClient.modifyThinVolume(
systemObjectID,
HDSUtils.getLogicalUnitObjectId(volume.getNativeId(), storageSystem),
size);
}
if (null != asyncTaskMessageId) {
HDSJob expandVolumeJob =
new HDSVolumeExpandJob(
asyncTaskMessageId,
storageSystem.getId(),
storagePool.getId(),
taskCompleter,
"ExpandVolume");
ControllerServiceImpl.enqueueJob(new QueueJob(expandVolumeJob));
}
} catch (final InternalException e) {
log.error("Problem in doExpandVolume: ", e);
taskCompleter.error(dbClient, e);
} catch (final Exception e) {
log.error("Problem in doExpandVolume: ", e);
ServiceError serviceError =
DeviceControllerErrors.hds.methodFailed("doExpandVolume", e.getMessage());
taskCompleter.error(dbClient, serviceError);
}
log.info(
String.format(
"Expand Volume End - Array: %s, Pool: %s, Volume: %s",
storageSystem.getSerialNumber(), storagePool.getNativeGuid(), volume.getLabel()));
}
/**
* Get Pool extensions map
*
* @return StringMap of Pool extensions
*/
public StringMap getPoolExtensions() {
StringMap extensions = null;
if (pool != null) {
extensions = pool.getControllerParams();
}
if (extensions == null) {
// do not return a null set
pool.setControllerParams(new StringMap());
} else {
return extensions;
}
return pool.getControllerParams();
}
/*
* (non-Javadoc)
*
* @see com.emc.storageos.volumecontroller.BlockStorageDevice#doExpandAsMetaVolume(com.emc.storageos.db.client.model.StorageSystem,
* com.emc.storageos.db.client.model.StoragePool, com.emc.storageos.db.client.model.Volume, long,
* com.emc.storageos.volumecontroller.impl.smis.MetaVolumeRecommendation, com.emc.storageos.volumecontroller.TaskCompleter)
*/
@Override
public void doExpandAsMetaVolume(
StorageSystem storageSystem,
StoragePool storagePool,
Volume metaHead,
long size,
MetaVolumeRecommendation recommendation,
VolumeExpandCompleter volumeCompleter)
throws DeviceControllerException {
StringBuilder logMsgBuilder =
new StringBuilder(
String.format(
"Expand Meta Volume Start - Array:%s, Pool:%s %n Volume: %s, id: %s",
storageSystem.getSerialNumber(),
storagePool.getNativeId(),
metaHead.getLabel(),
metaHead.getId()));
log.info(logMsgBuilder.toString());
long metaMemberCapacity = recommendation.getMetaMemberSize();
int metaMemberCount = (int) recommendation.getMetaMemberCount();
MetaVolumeTaskCompleter metaVolumeTaskCompleter = new MetaVolumeTaskCompleter(volumeCompleter);
try {
// Step 1: create meta members.
List<String> newMetaMembers =
metaVolumeOperations.createMetaVolumeMembers(
storageSystem,
storagePool,
metaHead,
metaMemberCount,
metaMemberCapacity,
metaVolumeTaskCompleter);
log.info("ldevMetaMembers created successfully: {}", newMetaMembers);
if (metaVolumeTaskCompleter.getLastStepStatus() == Job.JobStatus.SUCCESS) {
metaVolumeOperations.expandMetaVolume(
storageSystem, storagePool, metaHead, newMetaMembers, metaVolumeTaskCompleter);
} else {
ServiceError serviceError =
DeviceControllerErrors.hds.jobFailed("LDEV Meta Member creation failed");
volumeCompleter.error(dbClient, serviceError);
}
} catch (final InternalException e) {
log.error("Problem in doExpandAsMetaVolume: ", e);
volumeCompleter.error(dbClient, e);
} catch (final Exception e) {
log.error("Problem in doExpandAsMetaVolume: ", e);
ServiceError serviceError =
DeviceControllerErrors.hds.methodFailed("doExpandAsMetaVolume", e.getMessage());
volumeCompleter.error(dbClient, serviceError);
}
}
public static List<StoragePool> checkStoragePoolsNotVisible(
List<StoragePool> discoveredPools, DbClient dbClient, URI storageSystemId) {
List<StoragePool> modifiedPools = new ArrayList<StoragePool>();
// Get the pools previously discovered
URIQueryResultList storagePoolURIs = new URIQueryResultList();
dbClient.queryByConstraint(
ContainmentConstraint.Factory.getStorageDeviceStoragePoolConstraint(storageSystemId),
storagePoolURIs);
Iterator<URI> storagePoolIter = storagePoolURIs.iterator();
List<URI> existingPoolsURI = new ArrayList<URI>();
while (storagePoolIter.hasNext()) {
existingPoolsURI.add(storagePoolIter.next());
}
List<URI> discoveredPoolsURI = new ArrayList<URI>();
for (StoragePool pool : discoveredPools) {
discoveredPoolsURI.add(pool.getId());
}
Set<URI> poolDiff =
Sets.difference(new HashSet<URI>(existingPoolsURI), new HashSet<URI>(discoveredPoolsURI));
if (!poolDiff.isEmpty()) {
Iterator<StoragePool> storagePoolIt =
dbClient.queryIterativeObjects(StoragePool.class, poolDiff, true);
while (storagePoolIt.hasNext()) {
StoragePool pool = storagePoolIt.next();
modifiedPools.add(pool);
_log.info(
"Setting discovery status of pool {} : {} as NOTVISIBLE",
pool.getLabel(),
pool.getId());
pool.setDiscoveryStatus(DiscoveredDataObject.DiscoveryStatus.NOTVISIBLE.name());
dbClient.persistObject(pool);
}
}
return modifiedPools;
}
/*
* (non-Javadoc)
*
* @see com.emc.storageos.volumecontroller.BlockStorageDevice#doCreateVolumes(com.emc.storageos.db.client.model.StorageSystem,
* com.emc.storageos.db.client.model.StoragePool, java.lang.String, java.util.List,
* com.emc.storageos.volumecontroller.impl.utils.VirtualPoolCapabilityValuesWrapper, com.emc.storageos.volumecontroller.TaskCompleter)
*/
@Override
public void doCreateVolumes(
StorageSystem storageSystem,
StoragePool storagePool,
String opId,
List<Volume> volumes,
VirtualPoolCapabilityValuesWrapper capabilities,
TaskCompleter taskCompleter)
throws DeviceControllerException {
String label = null;
Long capacity = null;
boolean isThinVolume = false;
boolean opCreationFailed = false;
StringBuilder logMsgBuilder =
new StringBuilder(
String.format(
"Create Volume Start - Array:%s, Pool:%s",
storageSystem.getSerialNumber(), storagePool.getNativeGuid()));
for (Volume volume : volumes) {
logMsgBuilder.append(
String.format(
"%nVolume:%s , IsThinlyProvisioned: %s",
volume.getLabel(), volume.getThinlyProvisioned()));
if ((label == null) && (volumes.size() == 1)) {
String tenantName = "";
try {
TenantOrg tenant = dbClient.queryObject(TenantOrg.class, volume.getTenant().getURI());
tenantName = tenant.getLabel();
} catch (DatabaseException e) {
log.error("Error lookup TenantOrb object", e);
}
label =
nameGenerator.generate(
tenantName,
volume.getLabel(),
volume.getId().toString(),
'-',
HDSConstants.MAX_VOLUME_NAME_LENGTH);
}
if (capacity == null) {
capacity = volume.getCapacity();
}
isThinVolume = volume.getThinlyProvisioned();
}
log.info(logMsgBuilder.toString());
try {
multiVolumeCheckForHitachiModel(volumes, storageSystem);
HDSApiClient hdsApiClient =
hdsApiFactory.getClient(
HDSUtils.getHDSServerManagementServerInfo(storageSystem),
storageSystem.getSmisUserName(),
storageSystem.getSmisPassword());
String systemObjectID = HDSUtils.getSystemObjectID(storageSystem);
String poolObjectID = HDSUtils.getPoolObjectID(storagePool);
String asyncTaskMessageId = null;
// isThinVolume = true, creates VirtualVolumes
// isThinVolume = false, creates LogicalUnits
if (isThinVolume) {
asyncTaskMessageId =
hdsApiClient.createThinVolumes(
systemObjectID,
storagePool.getNativeId(),
capacity,
volumes.size(),
label,
QUICK_FORMAT_TYPE,
storageSystem.getModel());
} else if (!isThinVolume) {
asyncTaskMessageId =
hdsApiClient.createThickVolumes(
systemObjectID,
poolObjectID,
capacity,
volumes.size(),
label,
null,
storageSystem.getModel(),
null);
}
if (asyncTaskMessageId != null) {
HDSJob createHDSJob =
(volumes.size() > 1)
? new HDSCreateMultiVolumeJob(
asyncTaskMessageId,
volumes.get(0).getStorageController(),
storagePool.getId(),
volumes.size(),
taskCompleter)
: new HDSCreateVolumeJob(
asyncTaskMessageId,
volumes.get(0).getStorageController(),
storagePool.getId(),
taskCompleter);
ControllerServiceImpl.enqueueJob(new QueueJob(createHDSJob));
}
} catch (final InternalException e) {
log.error("Problem in doCreateVolumes: ", e);
opCreationFailed = true;
taskCompleter.error(dbClient, e);
} catch (final Exception e) {
log.error("Problem in doCreateVolumes: ", e);
opCreationFailed = true;
ServiceError serviceError =
DeviceControllerErrors.hds.methodFailed("doCreateVolumes", e.getMessage());
taskCompleter.error(dbClient, serviceError);
}
if (opCreationFailed) {
for (Volume vol : volumes) {
vol.setInactive(true);
dbClient.persistObject(vol);
}
}
logMsgBuilder =
new StringBuilder(
String.format(
"Create Volumes End - Array:%s, Pool:%s",
storageSystem.getSerialNumber(), storagePool.getNativeGuid()));
for (Volume volume : volumes) {
logMsgBuilder.append(String.format("%nVolume:%s", volume.getLabel()));
}
log.info(logMsgBuilder.toString());
}
@Override
public void doModifyVolumes(
StorageSystem storage,
StoragePool storagePool,
String opId,
List<Volume> volumes,
TaskCompleter taskCompleter)
throws DeviceControllerException {
StringBuilder logMsgBuilder =
new StringBuilder(
String.format(
"Modify Volume Start - Array:%s, Pool:%s",
storage.getSerialNumber(), storagePool.getNativeGuid()));
String systemObjectID = HDSUtils.getSystemObjectID(storage);
for (Volume volume : volumes) {
try {
HDSApiClient hdsApiClient =
hdsApiFactory.getClient(
HDSUtils.getHDSServerManagementServerInfo(storage),
storage.getSmisUserName(),
storage.getSmisPassword());
logMsgBuilder.append(
String.format(
"%nVolume:%s , IsThinlyProvisioned: %s, tieringPolicy: %s",
volume.getLabel(),
volume.getThinlyProvisioned(),
volume.getAutoTieringPolicyUri()));
LogicalUnit logicalUnit =
hdsApiClient.getLogicalUnitInfo(
systemObjectID, HDSUtils.getLogicalUnitObjectId(volume.getNativeId(), storage));
String policyName = ControllerUtils.getAutoTieringPolicyName(volume.getId(), dbClient);
String autoTierPolicyName = null;
if (policyName.equals(Constants.NONE)) {
autoTierPolicyName = null;
} else {
autoTierPolicyName =
HitachiTieringPolicy.getPolicy(
policyName.replaceAll(
HDSConstants.SLASH_OPERATOR, HDSConstants.UNDERSCORE_OPERATOR))
.getKey();
}
if (null != logicalUnit
&& null != logicalUnit.getLdevList()
&& !logicalUnit.getLdevList().isEmpty()) {
Iterator<LDEV> ldevItr = logicalUnit.getLdevList().iterator();
if (ldevItr.hasNext()) {
LDEV ldev = ldevItr.next();
String asyncMessageId =
hdsApiClient.modifyThinVolumeTieringPolicy(
systemObjectID,
logicalUnit.getObjectID(),
ldev.getObjectID(),
autoTierPolicyName);
if (null != asyncMessageId) {
HDSJob modifyHDSJob =
new HDSModifyVolumeJob(
asyncMessageId,
volume.getStorageController(),
taskCompleter,
HDSModifyVolumeJob.VOLUME_MODIFY_JOB);
ControllerServiceImpl.enqueueJob(new QueueJob(modifyHDSJob));
}
}
} else {
String errorMsg = String.format("No LDEV's found for volume: %s", volume.getId());
log.info(errorMsg);
ServiceError serviceError =
DeviceControllerErrors.hds.methodFailed("doModifyVolumes", errorMsg);
taskCompleter.error(dbClient, serviceError);
}
} catch (final InternalException e) {
log.error("Problem in doModifyVolumes: ", e);
taskCompleter.error(dbClient, e);
} catch (final Exception e) {
log.error("Problem in doModifyVolumes: ", e);
ServiceError serviceError =
DeviceControllerErrors.hds.methodFailed("doModifyVolumes", e.getMessage());
taskCompleter.error(dbClient, serviceError);
}
}
}
/**
* Called to update the job status when the volume expand job completes.
*
* @param jobContext The job context.
*/
public void updateStatus(JobContext jobContext) throws Exception {
CloseableIterator<CIMObjectPath> associatorIterator = null;
CloseableIterator<CIMInstance> instanceIterator = null;
JobStatus jobStatus = getJobStatus();
try {
if (jobStatus == JobStatus.IN_PROGRESS) {
return;
}
DbClient dbClient = jobContext.getDbClient();
CIMConnectionFactory cimConnectionFactory = jobContext.getCimConnectionFactory();
WBEMClient client = getWBEMClient(dbClient, cimConnectionFactory);
// If terminal state update storage pool capacity and remove reservation for volume capacity
// from pool's reserved capacity map.
if (jobStatus == JobStatus.SUCCESS
|| jobStatus == JobStatus.FAILED
|| jobStatus == JobStatus.FATAL_ERROR) {
SmisUtils.updateStoragePoolCapacity(dbClient, client, _storagePoolURI);
StoragePool pool = dbClient.queryObject(StoragePool.class, _storagePoolURI);
StringMap reservationMap = pool.getReservedCapacityMap();
URI volumeId = getTaskCompleter().getId();
// remove from reservation map
reservationMap.remove(volumeId.toString());
dbClient.persistObject(pool);
}
String opId = getTaskCompleter().getOpId();
StringBuilder logMsgBuilder =
new StringBuilder(
String.format(
"Updating status of job %s to %s, task: %s",
this.getJobName(), jobStatus.name(), opId));
if (jobStatus == JobStatus.SUCCESS) {
VolumeExpandCompleter taskCompleter = (VolumeExpandCompleter) getTaskCompleter();
Volume volume = dbClient.queryObject(Volume.class, taskCompleter.getId());
// set requested capacity
volume.setCapacity(taskCompleter.getSize());
// set meta related properties
volume.setTotalMetaMemberCapacity(taskCompleter.getTotalMetaMembersSize());
volume.setMetaMemberCount(taskCompleter.getMetaMemberCount());
volume.setMetaMemberSize(taskCompleter.getMetaMemberSize());
volume.setIsComposite(taskCompleter.isComposite());
volume.setCompositionType(taskCompleter.getMetaVolumeType());
// set provisioned capacity
associatorIterator =
client.associatorNames(getCimJob(), null, SmisConstants.CIM_STORAGE_VOLUME, null, null);
if (associatorIterator.hasNext()) {
CIMObjectPath volumePath = associatorIterator.next();
CIMInstance volumeInstance = client.getInstance(volumePath, true, false, null);
if (volumeInstance != null) {
CIMProperty consumableBlocks =
volumeInstance.getProperty(SmisConstants.CP_CONSUMABLE_BLOCKS);
CIMProperty blockSize = volumeInstance.getProperty(SmisConstants.CP_BLOCK_SIZE);
// calculate provisionedCapacity = consumableBlocks * block size
Long provisionedCapacity =
Long.valueOf(consumableBlocks.getValue().toString())
* Long.valueOf(blockSize.getValue().toString());
volume.setProvisionedCapacity(provisionedCapacity);
}
// set allocated capacity
instanceIterator =
client.referenceInstances(
volumePath,
SmisConstants.CIM_ALLOCATED_FROM_STORAGEPOOL,
null,
false,
SmisConstants.PS_SPACE_CONSUMED);
if (instanceIterator.hasNext()) {
CIMInstance allocatedFromStoragePoolPath = instanceIterator.next();
CIMProperty spaceConsumed =
allocatedFromStoragePoolPath.getProperty(SmisConstants.CP_SPACE_CONSUMED);
if (null != spaceConsumed) {
volume.setAllocatedCapacity(Long.valueOf(spaceConsumed.getValue().toString()));
}
}
}
logMsgBuilder.append(
String.format(
"%n Capacity: %s, Provisioned capacity: %s, Allocated Capacity: %s",
volume.getCapacity(),
volume.getProvisionedCapacity(),
volume.getAllocatedCapacity()));
if (volume.getIsComposite()) {
logMsgBuilder.append(
String.format(
"%n Is Meta: %s, Total meta member capacity: %s, Meta member count %s, Meta member size: %s",
volume.getIsComposite(),
volume.getTotalMetaMemberCapacity(),
volume.getMetaMemberCount(),
volume.getMetaMemberSize()));
}
_log.info(logMsgBuilder.toString());
// Reset list of meta member volumes in the volume
if (volume.getMetaVolumeMembers() != null) {
volume.getMetaVolumeMembers().clear();
}
StorageSystem storageSystem =
dbClient.queryObject(StorageSystem.class, volume.getStorageController());
// set the RP tag on the volume if the volume is RP protected
if (volume.checkForRp()
&& storageSystem.getSystemType() != null
&& storageSystem
.getSystemType()
.equalsIgnoreCase(DiscoveredDataObject.Type.vmax.toString())) {
SmisCommandHelper helper = jobContext.getSmisCommandHelper();
List<CIMObjectPath> volumePathList = new ArrayList<CIMObjectPath>();
volumePathList.add(helper.getVolumeMember(storageSystem, volume));
helper.setRecoverPointTag(storageSystem, volumePathList, true);
}
dbClient.persistObject(volume);
// Reset list of meta members native ids in WF data (when meta is created meta members are
// removed from array)
WorkflowService.getInstance().storeStepData(opId, new ArrayList<String>());
}
} catch (Exception e) {
_log.error("Caught an exception while trying to updateStatus for SmisVolumeExpandJob", e);
setPostProcessingErrorStatus(
"Encountered an internal error during volume expand job status processing : "
+ e.getMessage());
} finally {
_metaVolumeTaskCompleter.setLastStepStatus(jobStatus);
if (associatorIterator != null) {
associatorIterator.close();
}
if (instanceIterator != null) {
instanceIterator.close();
}
super.updateStatus(jobContext);
}
}
/**
* Get pool name
*
* @return
*/
public String getPoolName() {
return pool.getPoolName();
}
/*
* (non-Javadoc)
*
* @see com.emc.storageos.volumecontroller.CloneOperations#createSingleClone(
* com.emc.storageos.db.client.model.StorageSystem, java.net.URI, java.net.URI,
* java.lang.Boolean,
* com.emc.storageos.volumecontroller.TaskCompleter)
*/
@Override
public void createSingleClone(
StorageSystem storageSystem,
URI sourceObject,
URI cloneVolume,
Boolean createInactive,
TaskCompleter taskCompleter) {
log.info("START createSingleClone operation");
boolean isVolumeClone = true;
try {
BlockObject sourceObj = BlockObject.fetch(dbClient, sourceObject);
URI tenantUri = null;
if (sourceObj
instanceof BlockSnapshot) { // In case of snapshot, get the tenant from its parent volume
NamedURI parentVolUri = ((BlockSnapshot) sourceObj).getParent();
Volume parentVolume = dbClient.queryObject(Volume.class, parentVolUri);
tenantUri = parentVolume.getTenant().getURI();
isVolumeClone = false;
} else { // This is a default flow
tenantUri = ((Volume) sourceObj).getTenant().getURI();
isVolumeClone = true;
}
Volume cloneObj = dbClient.queryObject(Volume.class, cloneVolume);
StoragePool targetPool = dbClient.queryObject(StoragePool.class, cloneObj.getPool());
TenantOrg tenantOrg = dbClient.queryObject(TenantOrg.class, tenantUri);
// String cloneLabel = generateLabel(tenantOrg, cloneObj);
CinderEndPointInfo ep =
CinderUtils.getCinderEndPoint(storageSystem.getActiveProviderURI(), dbClient);
log.info(
"Getting the cinder APi for the provider with id "
+ storageSystem.getActiveProviderURI());
CinderApi cinderApi = cinderApiFactory.getApi(storageSystem.getActiveProviderURI(), ep);
String volumeId = "";
if (isVolumeClone) {
volumeId =
cinderApi.cloneVolume(
cloneObj.getLabel(),
(cloneObj.getCapacity() / (1024 * 1024 * 1024)),
targetPool.getNativeId(),
sourceObj.getNativeId());
} else {
volumeId =
cinderApi.createVolumeFromSnapshot(
cloneObj.getLabel(),
(cloneObj.getCapacity() / (1024 * 1024 * 1024)),
targetPool.getNativeId(),
sourceObj.getNativeId());
}
log.debug("Creating volume with the id " + volumeId + " on Openstack cinder node");
if (volumeId != null) {
Map<String, URI> volumeIds = new HashMap<String, URI>();
volumeIds.put(volumeId, cloneObj.getId());
ControllerServiceImpl.enqueueJob(
new QueueJob(
new CinderSingleVolumeCreateJob(
volumeId,
cloneObj.getLabel(),
storageSystem.getId(),
CinderConstants.ComponentType.volume.name(),
ep,
taskCompleter,
targetPool.getId(),
volumeIds)));
}
} catch (InternalException e) {
String errorMsg = String.format(CREATE_ERROR_MSG_FORMAT, sourceObject, cloneVolume);
log.error(errorMsg, e);
taskCompleter.error(dbClient, e);
} catch (Exception e) {
String errorMsg = String.format(CREATE_ERROR_MSG_FORMAT, sourceObject, cloneVolume);
log.error(errorMsg, e);
ServiceError serviceError =
DeviceControllerErrors.cinder.operationFailed("createSingleClone", e.getMessage());
taskCompleter.error(dbClient, serviceError);
}
}
/**
* Get pool nativeId
*
* @return
*/
public String getPoolNativeId() {
return pool.getNativeId();
}
@Override
public void processResult(Operation operation, Object resultObj, Map<String, Object> keyMap)
throws BaseCollectionException {
CloseableIterator<CIMInstance> volumeInstances = null;
EnumerateResponse<CIMInstance> volumeInstanceChunks = null;
CIMObjectPath storagePoolPath = null;
WBEMClient client = null;
try {
_dbClient = (DbClient) keyMap.get(Constants.dbClient);
client = (WBEMClient) keyMap.get(Constants._cimClient);
_profile = (AccessProfile) keyMap.get(Constants.ACCESSPROFILE);
Map<String, VolHostIOObject> exportedVolumes =
(Map<String, VolHostIOObject>) keyMap.get(Constants.EXPORTED_VOLUMES);
Set<String> existingVolumesInCG = (Set<String>) keyMap.get(Constants.VOLUMES_PART_OF_CG);
@SuppressWarnings("unchecked")
Map<String, RemoteMirrorObject> volumeToRAGroupMap =
(Map<String, RemoteMirrorObject>) keyMap.get(Constants.UN_VOLUME_RAGROUP_MAP);
@SuppressWarnings("unchecked")
Map<String, LocalReplicaObject> volumeToLocalReplicaMap =
(Map<String, LocalReplicaObject>) keyMap.get(Constants.UN_VOLUME_LOCAL_REPLICA_MAP);
@SuppressWarnings("unchecked")
Map<String, Set<String>> vmax2ThinPoolToBoundVolumesMap =
(Map<String, Set<String>>) keyMap.get(Constants.VMAX2_THIN_POOL_TO_BOUND_VOLUMES);
Set<String> boundVolumes = null;
storagePoolPath = getObjectPathfromCIMArgument(_args);
String poolNativeGuid = NativeGUIDGenerator.generateNativeGuidForPool(storagePoolPath);
StoragePool pool = checkStoragePoolExistsInDB(poolNativeGuid, _dbClient);
if (pool == null) {
_logger.error(
"Skipping unmanaged volume discovery as the storage pool with path {} doesn't exist in ViPR",
storagePoolPath.toString());
return;
}
StorageSystem system = _dbClient.queryObject(StorageSystem.class, _profile.getSystemId());
_unManagedVolumesInsert = new ArrayList<UnManagedVolume>();
_unManagedVolumesUpdate = new ArrayList<UnManagedVolume>();
_unManagedExportMasksUpdate = new ArrayList<UnManagedExportMask>();
// get bound volumes list for VMAX2 Thin pools
boundVolumes = vmax2ThinPoolToBoundVolumesMap.get(storagePoolPath.toString());
Set<String> poolSupportedSLONames = (Set<String>) keyMap.get(poolNativeGuid);
_logger.debug("Pool Supporting SLO Names:{}", poolSupportedSLONames);
_metaVolumeViewPaths = (List<CIMObjectPath>) keyMap.get(Constants.META_VOLUMES_VIEWS);
if (_metaVolumeViewPaths == null) {
_metaVolumeViewPaths = new ArrayList<CIMObjectPath>();
keyMap.put(Constants.META_VOLUMES_VIEWS, _metaVolumeViewPaths);
}
// create empty place holder list for meta volume paths (cannot
// define this in xml)
_metaVolumePaths = (List<CIMObjectPath>) keyMap.get(Constants.META_VOLUMES);
if (_metaVolumePaths == null) {
_metaVolumePaths = new ArrayList<CIMObjectPath>();
keyMap.put(Constants.META_VOLUMES, _metaVolumePaths);
}
_volumeToSpaceConsumedMap =
(Map<String, String>) keyMap.get(Constants.VOLUME_SPACE_CONSUMED_MAP);
// get VolumeInfo Object and inject Fast Policy Name.
volumeInstanceChunks = (EnumerateResponse<CIMInstance>) resultObj;
volumeInstances = volumeInstanceChunks.getResponses();
processVolumes(
volumeInstances,
keyMap,
operation,
pool,
system,
exportedVolumes,
existingVolumesInCG,
volumeToRAGroupMap,
volumeToLocalReplicaMap,
poolSupportedSLONames,
boundVolumes);
while (!volumeInstanceChunks.isEnd()) {
_logger.info("Processing Next Volume Chunk of size {}", BATCH_SIZE);
volumeInstanceChunks =
client.getInstancesWithPath(
storagePoolPath,
volumeInstanceChunks.getContext(),
new UnsignedInteger32(BATCH_SIZE));
processVolumes(
volumeInstanceChunks.getResponses(),
keyMap,
operation,
pool,
system,
exportedVolumes,
existingVolumesInCG,
volumeToRAGroupMap,
volumeToLocalReplicaMap,
poolSupportedSLONames,
boundVolumes);
}
if (null != _unManagedVolumesUpdate && _unManagedVolumesUpdate.size() > 0) {
_partitionManager.updateInBatches(
_unManagedVolumesUpdate, getPartitionSize(keyMap), _dbClient, UNMANAGED_VOLUME);
}
if (null != _unManagedVolumesInsert && _unManagedVolumesInsert.size() > 0) {
_partitionManager.insertInBatches(
_unManagedVolumesInsert, getPartitionSize(keyMap), _dbClient, UNMANAGED_VOLUME);
}
if (null != _unManagedExportMasksUpdate && _unManagedExportMasksUpdate.size() > 0) {
_partitionManager.updateInBatches(
_unManagedExportMasksUpdate,
getPartitionSize(keyMap),
_dbClient,
UNMANAGED_EXPORT_MASK);
}
performStorageUnManagedVolumeBookKeeping(pool.getId());
} catch (Exception e) {
_logger.error("Processing Storage Volume Information failed :", e);
} finally {
_unManagedVolumesInsert = null;
_unManagedVolumesUpdate = null;
if (null != volumeInstances) {
volumeInstances.close();
}
if (null != volumeInstanceChunks) {
try {
client.closeEnumeration(storagePoolPath, volumeInstanceChunks.getContext());
} catch (Exception e) {
}
}
}
}
/**
* Process the volumes to find the unmanaged volumes and populate the volume supported
* information.
*
* @param it
* @param keyMap
* @param operation
* @param pool
* @param system
* @param exportedVolumes
* @param volumesAndReplicas
* @param existingVolumesInCG
* @param volumeToRAGroupMap
* @param poolSupportedSLONames
* @param boundVolumes
*/
private void processVolumes(
Iterator<CIMInstance> it,
Map<String, Object> keyMap,
Operation operation,
StoragePool pool,
StorageSystem system,
Map<String, VolHostIOObject> exportedVolumes,
Set<String> existingVolumesInCG,
Map<String, RemoteMirrorObject> volumeToRAGroupMap,
Map<String, LocalReplicaObject> volumeToLocalReplicaMap,
Set<String> poolSupportedSLONames,
Set<String> boundVolumes) {
List<CIMObjectPath> metaVolumes = new ArrayList<CIMObjectPath>();
List<CIMObjectPath> metaVolumeViews = new ArrayList<CIMObjectPath>();
while (it.hasNext()) {
CIMInstance volumeViewInstance = null;
try {
volumeViewInstance = it.next();
String volumeNativeGuid =
getVolumeViewNativeGuid(volumeViewInstance.getObjectPath(), keyMap);
Volume volume = checkStorageVolumeExistsInDB(volumeNativeGuid, _dbClient);
if (null != volume) {
_logger.debug(
"Skipping discovery, as this Volume {} is already being managed by ViPR.",
volumeNativeGuid);
continue;
}
// skip non-bound volumes for this pool
if (boundVolumes != null) {
String deviceId = null;
if (system.getUsingSmis80()) {
deviceId = volumeViewInstance.getObjectPath().getKey(DEVICE_ID).getValue().toString();
} else {
deviceId = volumeViewInstance.getObjectPath().getKey(SVDEVICEID).getValue().toString();
}
if (!boundVolumes.contains(deviceId)) {
_logger.info(
"Skipping volume, as this Volume {} is not bound to this Thin Storage Pool {}",
volumeNativeGuid,
pool.getLabel());
continue;
}
}
addPath(keyMap, operation.get_result(), volumeViewInstance.getObjectPath());
String unManagedVolumeNativeGuid =
getUnManagedVolumeNativeGuid(volumeViewInstance.getObjectPath(), keyMap);
UnManagedVolume unManagedVolume =
checkUnManagedVolumeExistsInDB(unManagedVolumeNativeGuid, _dbClient);
unManagedVolume =
createUnManagedVolume(
unManagedVolume,
volumeViewInstance,
unManagedVolumeNativeGuid,
pool,
system,
volumeNativeGuid,
exportedVolumes,
existingVolumesInCG,
volumeToRAGroupMap,
volumeToLocalReplicaMap,
poolSupportedSLONames,
keyMap);
// set up UnManagedExportMask information
@SuppressWarnings("unchecked")
Map<String, Set<UnManagedExportMask>> masksMap =
(Map<String, Set<UnManagedExportMask>>)
keyMap.get(Constants.UNMANAGED_EXPORT_MASKS_MAP);
if (masksMap != null) {
Set<UnManagedExportMask> uems = masksMap.get(unManagedVolume.getNativeGuid());
if (uems != null) {
_logger.info(
"{} UnManagedExportMasks found in the keyMap for volume {}",
uems.size(),
unManagedVolume.getNativeGuid());
for (UnManagedExportMask uem : uems) {
_logger.info(
" adding UnManagedExportMask {} to UnManagedVolume", uem.getMaskingViewPath());
unManagedVolume.getUnmanagedExportMasks().add(uem.getId().toString());
uem.getUnmanagedVolumeUris().add(unManagedVolume.getId().toString());
_unManagedExportMasksUpdate.add(uem);
// add the known initiators, too
for (String initUri : uem.getKnownInitiatorUris()) {
_logger.info(" adding known Initiator URI {} to UnManagedVolume", initUri);
unManagedVolume.getInitiatorUris().add(initUri);
Initiator init = _dbClient.queryObject(Initiator.class, URI.create(initUri));
unManagedVolume.getInitiatorNetworkIds().add(init.getInitiatorPort());
}
// log this info for debugging
for (String path : uem.getUnmanagedInitiatorNetworkIds()) {
_logger.info(" UnManagedExportMask has this initiator unknown to ViPR: {}", path);
}
// check if this volume is in a vplex backend mask
// and mark it as such if it is
Object o = keyMap.get(Constants.UNMANAGED_VPLEX_BACKEND_MASKS_SET);
if (o != null) {
Set<String> unmanagedVplexBackendMasks = (Set<String>) o;
if (unmanagedVplexBackendMasks.size() > 0) {
if (unmanagedVplexBackendMasks.contains(uem.getId().toString())) {
_logger.info(
"unmanaged volume {} is a vplex backend volume",
unManagedVolume.getLabel());
unManagedVolume.putVolumeCharacterstics(
SupportedVolumeCharacterstics.IS_VPLEX_BACKEND_VOLUME.toString(), "true");
}
}
}
}
}
}
_logger.debug(
"Going to check if the volume is meta: {}, volume meta property: {}",
volumeViewInstance.getObjectPath(),
unManagedVolume
.getVolumeCharacterstics()
.get(SupportedVolumeCharacterstics.IS_METAVOLUME.toString()));
// Check if the volume is meta volume and add it to the meta
// volume list
String isMetaVolume =
unManagedVolume
.getVolumeCharacterstics()
.get(SupportedVolumeCharacterstics.IS_METAVOLUME.toString());
if (null != isMetaVolume && Boolean.valueOf(isMetaVolume)) {
if (keyMap.containsKey(Constants.IS_NEW_SMIS_PROVIDER)
&& Boolean.valueOf(keyMap.get(Constants.IS_NEW_SMIS_PROVIDER).toString())) {
metaVolumes.add(volumeViewInstance.getObjectPath());
} else {
metaVolumeViews.add(volumeViewInstance.getObjectPath());
}
_logger.info(
"Found meta volume: {}, name: {}",
volumeViewInstance.getObjectPath(),
unManagedVolume.getLabel());
}
// if volumes size reaches 200 , then dump to Db.
if (_unManagedVolumesInsert.size() > BATCH_SIZE) {
_partitionManager.insertInBatches(
_unManagedVolumesInsert, getPartitionSize(keyMap), _dbClient, UNMANAGED_VOLUME);
_unManagedVolumesInsert.clear();
}
if (_unManagedVolumesUpdate.size() > BATCH_SIZE) {
_partitionManager.updateInBatches(
_unManagedVolumesUpdate, getPartitionSize(keyMap), _dbClient, UNMANAGED_VOLUME);
_unManagedVolumesUpdate.clear();
}
if (_unManagedExportMasksUpdate.size() > BATCH_SIZE) {
_partitionManager.updateInBatches(
_unManagedExportMasksUpdate,
getPartitionSize(keyMap),
_dbClient,
UNMANAGED_EXPORT_MASK);
_unManagedExportMasksUpdate.clear();
}
unManagedVolumesReturnedFromProvider.add(unManagedVolume.getId());
} catch (Exception ex) {
_logger.error(
"Processing UnManaged Storage Volume {} ", volumeViewInstance.getObjectPath(), ex);
}
}
// Add meta volumes to the keyMap
try {
if (metaVolumes != null && !metaVolumes.isEmpty()) {
_metaVolumePaths.addAll(metaVolumes);
_logger.info("Added {} meta volumes.", metaVolumes.size());
}
if (metaVolumeViews != null && !metaVolumeViews.isEmpty()) {
_metaVolumeViewPaths.addAll(metaVolumeViews);
_logger.info("Added {} meta volume views.", metaVolumeViews.size());
}
} catch (Exception ex) {
_logger.error("Processing UnManaged meta volumes.", ex);
}
}
/**
* Create StoragePool Record, if not present already, else update only the properties.
*
* @param pool
* @param poolInstance
* @param profile
* @param poolClassName
* @param supportedVolumeTypes
* @param protocols
* @param poolsToMatchWithVpool
* @throws URISyntaxException
* @throws IOException
*/
private void createStoragePool(
StoragePool pool,
CIMInstance poolInstance,
AccessProfile profile,
String poolClassName,
String supportedVolumeTypes,
Set<String> protocols,
Map<URI, StoragePool> poolsToMatchWithVpool,
StorageSystem device)
throws URISyntaxException, IOException {
boolean newPool = false;
boolean modifiedPool = false; // indicates whether to add to modified pools list or not
if (null == pool) {
String instanceID = getCIMPropertyValue(poolInstance, Constants.INSTANCEID);
String nativeIdFromInstance = getNativeIDFromInstance(instanceID);
newPool = true;
pool = new StoragePool();
pool.setId(URIUtil.createId(StoragePool.class));
pool.setPoolName(getCIMPropertyValue(poolInstance, POOL_ID));
pool.setNativeId(nativeIdFromInstance);
pool.setStorageDevice(profile.getSystemId());
pool.setPoolServiceType(PoolServiceType.block.toString());
String poolNativeGuid = NativeGUIDGenerator.generateNativeGuid(_dbClient, pool);
pool.setNativeGuid(poolNativeGuid);
pool.setLabel(poolNativeGuid);
// setting default values on Pool Creation for VMAX and VNX
pool.setMaximumThickVolumeSize(0L);
pool.setMinimumThickVolumeSize(0L);
pool.setMaximumThinVolumeSize(0L);
pool.setMinimumThinVolumeSize(0L);
if (device.getAutoTieringEnabled()) {
pool.setAutoTieringEnabled(Boolean.TRUE);
} else {
pool.setAutoTieringEnabled(Boolean.FALSE);
}
_logger.info(
String.format(
"Maximum default limits for volume capacity in storage pool %s / %s : \n "
+ "max thin volume capacity: %s, max thick volume capacity: %s ",
pool.getPoolName(),
pool.getId(),
pool.getMaximumThinVolumeSize(),
pool.getMaximumThickVolumeSize()));
// set default utilization/subscription limits
double poolSubscriptionPercent =
CapacityMatcher.getMaxPoolSubscriptionPercentage(pool, _coordinator);
double poolUtilizationPercent =
CapacityMatcher.getMaxPoolUtilizationPercentage(pool, _coordinator);
pool.setMaxThinPoolSubscriptionPercentage((int) poolSubscriptionPercent);
pool.setMaxPoolUtilizationPercentage((int) poolUtilizationPercent);
}
String maxSubscriptionPercent =
getCIMPropertyValue(poolInstance, SmisConstants.CP_EMCMAXSUBSCRIPTIONPERCENT);
_logger.info(
String.format(
"Discovered maximum subscription percent of storage pool %s from array : %s ",
pool.getPoolName(), maxSubscriptionPercent));
// null value indicates "not available".
Integer newMaxSubscriptionPercentFromArray =
maxSubscriptionPercent == null ? null : new Integer(maxSubscriptionPercent);
_logger.info(
String.format(
"New maximum subscription percent of storage pool %s from array : %s ",
pool.getPoolName(), newMaxSubscriptionPercentFromArray));
processMaxSubscriptionPercent(
newMaxSubscriptionPercentFromArray, pool, _dbClient, _eventManager);
String subscribedCapacity =
getCIMPropertyValue(poolInstance, SmisConstants.CP_SUBSCRIBEDCAPACITY);
if (null != subscribedCapacity) {
pool.setSubscribedCapacity(ControllerUtils.convertBytesToKBytes(subscribedCapacity));
}
pool.setFreeCapacity(SmisUtils.getFreeCapacity(poolInstance));
pool.setTotalCapacity(SmisUtils.getTotalCapacity(poolInstance));
pool.setPoolClassName(poolClassName);
pool.setSupportedResourceTypes(supportedVolumeTypes);
String operationalStatus = determineOperationalStatus(poolInstance);
if (!newPool
&& (ImplicitPoolMatcher.checkPoolPropertiesChanged(
pool.getOperationalStatus(), operationalStatus)
|| ImplicitPoolMatcher.checkPoolPropertiesChanged(pool.getProtocols(), protocols)
|| ImplicitPoolMatcher.checkPoolPropertiesChanged(
pool.getCompatibilityStatus(),
DiscoveredDataObject.CompatibilityStatus.COMPATIBLE.name())
|| ImplicitPoolMatcher.checkPoolPropertiesChanged(
pool.getDiscoveryStatus(), DiscoveredDataObject.DiscoveryStatus.VISIBLE.name()))) {
modifiedPool = true;
}
pool.addProtocols(protocols);
pool.setOperationalStatus(operationalStatus);
pool.setCompatibilityStatus(DiscoveredDataObject.CompatibilityStatus.COMPATIBLE.name());
pool.setDiscoveryStatus(DiscoveredDataObject.DiscoveryStatus.VISIBLE.name());
Set<String> diskDrives = new HashSet<String>();
String driveTypes = getCIMPropertyValue(poolInstance, EMC_DRIVE_TYPE);
if (null != driveTypes) {
String driveTypesArr[] = driveTypes.split(SPACE_STR_DELIM);
if (device.checkIfVmax3()
&& driveTypesArr.length == 1
&& driveTypesArr[0].equals(MIXED_DRIVE_TYPE)) {
driveTypesArr = getVMAX3PoolDriveTypes(device, poolInstance);
}
for (String driveType : driveTypesArr) {
String driveDisplayName = SupportedDriveTypeValues.getDiskDriveDisplayName(driveType);
if (null == driveDisplayName) {
_logger.warn(
"UnSupported DiskDrive Type : {} resulting in drives not getting discovered for this pool: {}",
driveType,
getCIMPropertyValue(poolInstance, Constants.INSTANCEID));
continue;
}
diskDrives.add(driveDisplayName);
}
if (!newPool
&& !modifiedPool
&& ImplicitPoolMatcher.checkPoolPropertiesChanged(
pool.getSupportedDriveTypes(), diskDrives)) {
modifiedPool = true;
}
pool.addDriveTypes(diskDrives);
}
_logger.info("Discovered disk drives:[{}] for pool id:{}", driveTypes, pool.getId());
if (newPool) {
_newPoolList.add(pool);
// add new pools to modified pools list to consider them for implicit pool matching.
if (!poolsToMatchWithVpool.containsKey(pool.getId())) {
poolsToMatchWithVpool.put(pool.getId(), pool);
}
} else {
_updatePoolList.add(pool);
// add to modified pool list if pool's property which is required for vPool matcher, has
// changed.
// No need to check whether the pool is already there in the list here
// because this processor is the first to discover pools.
if (modifiedPool && !poolsToMatchWithVpool.containsKey(pool.getId())) {
poolsToMatchWithVpool.put(pool.getId(), pool);
}
}
}
public static void processMaxSubscriptionPercent(
Integer newMaxSubscriptionPercentFromArray,
StoragePool pool,
DbClient dbClient,
RecordableEventManager eventManager) {
// get limits in vipr
int poolSubscriptionPercent =
pool.getMaxThinPoolSubscriptionPercentage() == null
? 0
: pool.getMaxThinPoolSubscriptionPercentage();
int poolUtilizationPercent =
pool.getMaxPoolUtilizationPercentage() == null ? 0 : pool.getMaxPoolUtilizationPercentage();
_logger.info(
String.format(
"StoragePool %s subscription/utilization percent limits in vipr: %s / %s",
pool.getPoolName(), poolSubscriptionPercent, poolUtilizationPercent));
Integer currentMaxSubscriptionPercentFromArray =
pool.getMaxThinPoolSubscriptionPercentageFromArray();
_logger.info(
String.format(
"Current maximum subscription percent of storage pool %s from array in vipr : %s ",
pool.getPoolName(), currentMaxSubscriptionPercentFromArray));
// Currently smis uses value of 0 as indication that MaxSubscriptionPercent is not available.
// Some array clients explicitly set this array limit to 0 to indicate that the value is 0%.
// The OPT was filed 448553 and it targeted for 4.6.2
// The plan is to use null to show that this property is not available, and 0 will show 0%.
// Until the fix for OPT is in, we will use 0 and null as indication for the property is not
// available.
// TODO!! Remove check for 0 when the OPT is in.
if (newMaxSubscriptionPercentFromArray != null
&& newMaxSubscriptionPercentFromArray != 0
&& newMaxSubscriptionPercentFromArray < poolSubscriptionPercent) {
// reset vipr limit and send alert
pool.setMaxThinPoolSubscriptionPercentage(newMaxSubscriptionPercentFromArray);
recordBourneStoragePoolEvent(
RecordableEventManager.EventType.StoragePoolUpdated,
pool,
"Discovered pool max subscription percent is below current pool subscription limit. The limit will be reset.",
RecordType.Alert,
dbClient,
eventManager);
// check if we need to reset max utilization percent in vipr
// pool max utilization percent is always less or equal to pool max subscription percent,
// so we do this check in this 'if' statement
if (newMaxSubscriptionPercentFromArray < poolUtilizationPercent) {
// reset vipr utilization limit and send alert
pool.setMaxPoolUtilizationPercentage(newMaxSubscriptionPercentFromArray);
recordBourneStoragePoolEvent(
RecordableEventManager.EventType.StoragePoolUpdated,
pool,
"Discovered pool max subscription percent is below current pool utilization limit. The limit will be reset.",
RecordType.Alert,
dbClient,
eventManager);
}
} else if (currentMaxSubscriptionPercentFromArray != null
&& currentMaxSubscriptionPercentFromArray == poolSubscriptionPercent
&& (newMaxSubscriptionPercentFromArray == null
|| currentMaxSubscriptionPercentFromArray < newMaxSubscriptionPercentFromArray)) {
// In this case array limit went up from previous value and vipr max pool subscription percent
// is using old array value ---
// send event that array value was increased so client may increase vipr limits if needed.
recordBourneStoragePoolEvent(
RecordableEventManager.EventType.StoragePoolUpdated,
pool,
"Discovered pool max subscription percent is above current pool subscription limit",
RecordType.Event,
dbClient,
eventManager);
}
// set array subscription percent in the pool
pool.setMaxThinPoolSubscriptionPercentageFromArray(newMaxSubscriptionPercentFromArray);
// TODO!! Remove the "if" below when fix for OPT 448553 is in.
// Use 0 as not available until then.
if (newMaxSubscriptionPercentFromArray != null && newMaxSubscriptionPercentFromArray == 0) {
pool.setMaxThinPoolSubscriptionPercentageFromArray(null);
}
}
/**
* create StorageVolume Info Object
*
* @param unManagedVolume
* @param volumeInstance
* @param unManagedVolumeNativeGuid
* @param pool
* @return
*/
private UnManagedVolume createUnManagedVolume(
UnManagedVolume unManagedVolume,
CIMInstance volumeInstance,
String unManagedVolumeNativeGuid,
StoragePool pool,
StorageSystem system,
String volumeNativeGuid,
// to make the code uniform, passed in all the below sets as
// arguments
Map<String, VolHostIOObject> exportedVolumes,
Set<String> existingVolumesInCG,
Map<String, RemoteMirrorObject> volumeToRAGroupMap,
Map<String, LocalReplicaObject> volumeToLocalReplicaMap,
Set<String> poolSupportedSLONames,
Map<String, Object> keyMap) {
_logger.info("Process UnManagedVolume {}", unManagedVolumeNativeGuid);
try {
boolean created = false;
if (null == unManagedVolume) {
unManagedVolume = new UnManagedVolume();
unManagedVolume.setId(URIUtil.createId(UnManagedVolume.class));
unManagedVolume.setNativeGuid(unManagedVolumeNativeGuid);
unManagedVolume.setStorageSystemUri(system.getId());
created = true;
}
// reset the auto-tiering info for unmanaged volumes already present
// in db
// so that the tiering info is updated correctly later
if (!created) {
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.AUTO_TIERING_POLICIES.toString(), "");
unManagedVolume.putVolumeCharacterstics(
SupportedVolumeCharacterstics.IS_AUTO_TIERING_ENABLED.toString(), "false");
// reset local replica info
unManagedVolume.putVolumeCharacterstics(
SupportedVolumeCharacterstics.IS_FULL_COPY.name(), FALSE);
unManagedVolume.putVolumeCharacterstics(
SupportedVolumeCharacterstics.IS_LOCAL_MIRROR.name(), FALSE);
unManagedVolume.putVolumeCharacterstics(
SupportedVolumeCharacterstics.IS_SNAP_SHOT.name(), FALSE);
unManagedVolume.putVolumeCharacterstics(
SupportedVolumeCharacterstics.HAS_REPLICAS.name(), FALSE);
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.REPLICA_STATE.name(), new StringSet());
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.LOCAL_REPLICA_SOURCE_VOLUME.name(), new StringSet());
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.SYNC_STATE.name(), new StringSet());
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.SYNC_TYPE.name(), new StringSet());
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.SYNCHRONIZED_INSTANCE.name(), new StringSet());
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.IS_SYNC_ACTIVE.name(), new StringSet());
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.NEEDS_COPY_TO_TARGET.name(), new StringSet());
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.TECHNOLOGY_TYPE.name(), new StringSet());
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.SETTINGS_INSTANCE.name(), new StringSet());
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.FULL_COPIES.name(), new StringSet());
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.MIRRORS.name(), new StringSet());
unManagedVolume
.getVolumeInformation()
.put(SupportedVolumeInformation.SNAPSHOTS.name(), new StringSet());
}
Map<String, StringSet> unManagedVolumeInformation = new HashMap<String, StringSet>();
Map<String, String> unManagedVolumeCharacteristics = new HashMap<String, String>();
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 SLOName only for VMAX3 exported volumes
if (system.checkIfVmax3()) {
// If there are no slonames defined for a pool or no slo
// set for a volume, update the tiering_enabled to false.
if (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);
}
Object raidLevelObj;
boolean isIngestable;
String isBound;
String isThinlyProvisioned;
String isMetaVolume;
String allocCapacity;
// Set the attributes for new smis version.
if (keyMap.containsKey(Constants.IS_NEW_SMIS_PROVIDER)
&& Boolean.valueOf(keyMap.get(Constants.IS_NEW_SMIS_PROVIDER).toString())) {
unManagedVolume.setLabel(getCIMPropertyValue(volumeInstance, NAME));
raidLevelObj =
volumeInstance.getPropertyValue(
SupportedVolumeInformation.RAID_LEVEL.getAlternateKey());
isBound =
getCIMPropertyValue(
volumeInstance, SupportedVolumeCharacterstics.IS_BOUND.getAlterCharacterstic());
isIngestable = isVolumeIngestable(volumeInstance, isBound, USAGE);
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());
isIngestable = isVolumeIngestable(volumeInstance, isBound, SVUSAGE);
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);
}
// only Volumes with Usage 2 can be ingestable, other volumes
// [SAVE,VAULT...] apart from replicas have usage other than 2
// Volumes which are set EMCIsBound as false cannot be ingested
if (isIngestable) {
unManagedVolumeCharacteristics.put(
SupportedVolumeCharacterstics.IS_INGESTABLE.toString(), TRUE);
} else {
unManagedVolumeCharacteristics.put(
SupportedVolumeCharacterstics.IS_INGESTABLE.toString(), FALSE);
}
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().size() == 0) {
unManagedVolumeInformation
.get(SupportedVolumeInformation.REMOTE_MIRRORS.toString())
.clear();
} else {
unManagedVolumeInformation
.get(SupportedVolumeInformation.REMOTE_MIRRORS.toString())
.replace(rmObj.getTargetVolumenativeGuids());
}
}
} 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();
raGroup.add(rmObj.getRaGroupUri().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 volumeType = new StringSet();
volumeType.add(rmObj.getType());
unManagedVolumeInformation.put(
SupportedVolumeInformation.REMOTE_VOLUME_TYPE.toString(), volumeType);
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);
}
}
}
// 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()));
if (unManagedVolumeInformation.containsKey(
SupportedVolumeInformation.SUPPORTED_VPOOL_LIST.toString())) {
_logger.debug("Matched Pools :" + Joiner.on("\t").join(matchedVPools));
if (null != matchedVPools && matchedVPools.size() == 0) {
// replace with empty string set doesn't work, hence
// added explicit code to remove all
unManagedVolumeInformation
.get(SupportedVolumeInformation.SUPPORTED_VPOOL_LIST.toString())
.clear();
} else {
// replace with new StringSet
unManagedVolumeInformation
.get(SupportedVolumeInformation.SUPPORTED_VPOOL_LIST.toString())
.replace(matchedVPools);
_logger.info(
"Replaced Pools :"
+ Joiner.on("\t")
.join(
unManagedVolumeInformation.get(
SupportedVolumeInformation.SUPPORTED_VPOOL_LIST.toString())));
}
} else {
unManagedVolumeInformation.put(
SupportedVolumeInformation.SUPPORTED_VPOOL_LIST.toString(), matchedVPools);
}
}
// 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();
if (created) {
_unManagedVolumesInsert.add(unManagedVolume);
} else {
_unManagedVolumesUpdate.add(unManagedVolume);
}
} catch (Exception e) {
_logger.error("Exception: ", e);
}
return unManagedVolume;
}
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override
public void processResult(Operation operation, Object resultObj, Map<String, Object> keyMap)
throws BaseCollectionException {
final Iterator<CIMInstance> it = (Iterator<CIMInstance>) resultObj;
profile = (AccessProfile) keyMap.get(Constants.ACCESSPROFILE);
try {
_newPoolList = new ArrayList<StoragePool>();
_updatePoolList = new ArrayList<StoragePool>();
_dbClient = (DbClient) keyMap.get(Constants.dbClient);
_cimClient = (WBEMClient) keyMap.get(Constants._cimClient);
_coordinator = (CoordinatorClient) keyMap.get(Constants.COORDINATOR_CLIENT);
_eventManager = (RecordableEventManager) keyMap.get(Constants.EVENT_MANAGER);
_logger.info("StoragePoolProcessor --- event manager: " + _eventManager);
StorageSystem device = getStorageSystem(_dbClient, profile.getSystemId());
if (SupportedProvisioningTypes.NONE
.toString()
.equalsIgnoreCase(device.getSupportedProvisioningType())) {
_logger.info(
"Storage System doesn't support volume creations :" + device.getSerialNumber());
return;
}
Set<String> protocols = (Set<String>) keyMap.get(Constants.PROTOCOLS);
Map<URI, StoragePool> poolsToMatchWithVpool =
(Map<URI, StoragePool>) keyMap.get(Constants.MODIFIED_STORAGEPOOLS);
while (it.hasNext()) {
CIMInstance poolInstance = null;
try {
poolInstance = it.next();
// Supporting both thick and thin pools
String[] poolClassNameAndSupportedVolumeTypes =
determinePoolClassNameAndSupportedVolumeTypes(poolInstance, device);
if (null != poolClassNameAndSupportedVolumeTypes) {
String instanceID = getCIMPropertyValue(poolInstance, Constants.INSTANCEID);
addPath(keyMap, operation.getResult(), poolInstance.getObjectPath());
StoragePool pool =
checkStoragePoolExistsInDB(getNativeIDFromInstance(instanceID), _dbClient, device);
createStoragePool(
pool,
poolInstance,
profile,
poolClassNameAndSupportedVolumeTypes[0],
poolClassNameAndSupportedVolumeTypes[1],
protocols,
poolsToMatchWithVpool,
device);
if (DiscoveredDataObject.Type.vnxblock
.toString()
.equalsIgnoreCase(device.getSystemType())) {
addPath(keyMap, Constants.VNXPOOLS, poolInstance.getObjectPath());
}
if (DiscoveredDataObject.Type.vmax
.toString()
.equalsIgnoreCase(device.getSystemType())) {
addPath(keyMap, Constants.VMAXPOOLS, poolInstance.getObjectPath());
if (!device.checkIfVmax3()) {
addPath(keyMap, Constants.VMAX2POOLS, poolInstance.getObjectPath());
}
}
// This approach deviates from the existing built plugin framework for plugin
// Discovery
// To follow the existing pattern, we need to have different SMI-S calls
// 1st to get Device StoragePools alone ,and 2nd to get Thin Pools.
// Its a tradeoff between whether to go with the current plugin design or
// reduce the number of calls to SMI Provider.
// I chose the 2nd option.
if (!poolClassNameAndSupportedVolumeTypes[0].contains(DEVICE_STORAGE_POOL)) {
addPath(keyMap, Constants.THINPOOLS, poolInstance.getObjectPath());
}
addPath(keyMap, Constants.DEVICEANDTHINPOOLS, poolInstance.getObjectPath());
} else {
_logger.debug(
"Skipping Pools other than Unified & Virtual & Device : {}",
poolInstance.getObjectPath().toString());
}
} catch (Exception e) {
_logger.warn(
"StoragePool Discovery failed for {}",
getCIMPropertyValue(poolInstance, Constants.INSTANCEID),
e);
}
}
_dbClient.createObject(_newPoolList);
_dbClient.updateAndReindexObject(_updatePoolList);
// find the pools not visible in this discovery
List<StoragePool> discoveredPools = new ArrayList<StoragePool>(_newPoolList);
discoveredPools.addAll(_updatePoolList);
List<StoragePool> notVisiblePools =
DiscoveryUtils.checkStoragePoolsNotVisible(discoveredPools, _dbClient, device.getId());
for (StoragePool notVisiblePool : notVisiblePools) {
poolsToMatchWithVpool.put(notVisiblePool.getId(), notVisiblePool);
}
// If any storage ports on the storage system are in a transport
// zone, there is an implicit connection to the transport zone
// varray. We need to add these implicit varray
// connections for the new storage pool.
StoragePoolAssociationHelper.setStoragePoolVarrays(device.getId(), _newPoolList, _dbClient);
} catch (Exception e) {
_logger.error("StoragePool Discovery failed --> {}", getMessage(e));
} finally {
_newPoolList = null;
_updatePoolList = null;
}
}
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override
public void processResult(Operation operation, Object resultObj, Map<String, Object> keyMap)
throws BaseCollectionException {
try {
final Iterator<CIMInstance> it = (Iterator<CIMInstance>) resultObj;
profile = (AccessProfile) keyMap.get(Constants.ACCESSPROFILE);
Set<String> protocols = (Set<String>) keyMap.get(Constants.PROTOCOLS);
_newPortList = new ArrayList<StoragePort>();
_updatePortList = new ArrayList<StoragePort>();
_dbClient = (DbClient) keyMap.get(Constants.dbClient);
CoordinatorClient coordinator = (CoordinatorClient) keyMap.get(Constants.COORDINATOR_CLIENT);
Map<URI, StoragePool> poolsToMatchWithVpool =
(Map<URI, StoragePool>) keyMap.get(Constants.MODIFIED_STORAGEPOOLS);
Set<URI> systemsToRunRPConnectivity =
(HashSet<URI>) keyMap.get(Constants.SYSTEMS_RUN_RP_CONNECTIVITY);
StorageSystem device = _dbClient.queryObject(StorageSystem.class, profile.getSystemId());
CIMObjectPath storageAdapterPath = getObjectPathfromCIMArgument(args);
Iterable<String> adapterItr =
Splitter.on(Constants.PATH_DELIMITER_PATTERN)
.limit(3)
.split(storageAdapterPath.getKey(Constants.NAME).getValue().toString());
String adapterNativeGuid =
NativeGUIDGenerator.generateNativeGuid(
device, Iterables.getLast(adapterItr), NativeGUIDGenerator.ADAPTER);
StorageHADomain haDomain = getStorageAdapter(_dbClient, adapterNativeGuid);
if (null == haDomain) {
_logger.info("Adapter Not found");
return;
}
while (it.hasNext()) {
CIMInstance portInstance = null;
StoragePort port = null;
try {
portInstance = it.next();
// skip back end ports other than RDF Ports
if (!HADomainType.REMOTE.name().equalsIgnoreCase(haDomain.getAdapterType())
&& "3".equalsIgnoreCase(getCIMPropertyValue(portInstance, USAGERESTRICTION))) {
continue;
}
// only if its an EthernetPort, as protocolEnd point needs
// to run only for Ethernet
// Ports , because SCSI address we don't have it in
// CIM_LogicalPort Class
// 2 - Ethernet Port 4 - FC Port
if ("2".equalsIgnoreCase(getCIMPropertyValue(portInstance, LINKTECHNOLOGY))) {
port = createStoragePort(null, portInstance, profile, haDomain, false, IP, device);
checkProtocolAlreadyExists(protocols, ISCSI);
String deviceId = getCIMPropertyValue(portInstance, DEVICEID);
/*
* For SMI-S 8.x, While getting the iSCSI Port details, we use SystemName property
* (Ex. SYMMETRIX-+-<<SERIAL>>-+-SE-1G-+-0)
* Where this call just add the deviceId to the KeyMap (i.e SE-1G-+-0).
* Hence manually constructing the key.
*/
if (device.getUsingSmis80()) {
String systemName = getCIMPropertyValue(portInstance, SYSTEM_NAME);
StringBuffer deviceIdStrBuf = new StringBuffer(systemName);
deviceIdStrBuf.append(Constants.SMIS80_DELIMITER).append(deviceId);
deviceId = deviceIdStrBuf.toString();
}
_logger.debug("Adding iSCSI Port instance {} to keyMap", deviceId);
keyMap.put(deviceId, port);
addPath(keyMap, operation.getResult(), portInstance.getObjectPath());
} else if ("4".equalsIgnoreCase(getCIMPropertyValue(portInstance, LINKTECHNOLOGY))) {
port = checkStoragePortExistsInDB(portInstance, device, _dbClient);
checkProtocolAlreadyExists(protocols, FC);
createStoragePort(port, portInstance, profile, haDomain, true, FC, device);
} else {
_logger.debug("Unsupported Port : {}", getCIMPropertyValue(portInstance, DEVICEID));
}
} catch (Exception e) {
_logger.warn(
"Port Discovery failed for {}", getCIMPropertyValue(portInstance, DEVICEID), e);
}
}
_dbClient.createObject(_newPortList);
_dbClient.persistObject(_updatePortList);
// ports used later to run Transport Zone connectivity
List<List<StoragePort>> portsUsedToRunTZoneConnectivity =
(List<List<StoragePort>>) keyMap.get(Constants.STORAGE_PORTS);
portsUsedToRunTZoneConnectivity.add(_newPortList);
portsUsedToRunTZoneConnectivity.add(_updatePortList);
List<StoragePool> modifiedPools =
StoragePoolAssociationHelper.getStoragePoolsFromPorts(
_dbClient, _newPortList, _updatePortList);
for (StoragePool pool : modifiedPools) {
// pool matcher will be invoked on this pool
if (!poolsToMatchWithVpool.containsKey(pool.getId())) {
poolsToMatchWithVpool.put(pool.getId(), pool);
}
}
// Systems used to run RP connectivity later after runing pool matcher
systemsToRunRPConnectivity.addAll(
StoragePoolAssociationHelper.getStorageSytemsFromPorts(_newPortList, null));
systemsToRunRPConnectivity.addAll(
StoragePoolAssociationHelper.getStorageSytemsFromPorts(_updatePortList, null));
// discovered ports used later to check for not visible ports
List<StoragePort> discoveredPorts =
(List<StoragePort>) keyMap.get(Constants.DISCOVERED_PORTS);
discoveredPorts.addAll(_newPortList);
discoveredPorts.addAll(_updatePortList);
_logger.debug(
"# Pools used in invoking PoolMatcher during StoragePortProcessor {}",
Joiner.on("\t").join(poolsToMatchWithVpool.keySet()));
} catch (Exception e) {
_logger.error("Port Discovery failed -->{}", getMessage(e));
} finally {
_newPortList = null;
_updatePortList = null;
}
}
/**
* Get pool URI
*
* @return
*/
public URI getPoolId() {
return pool.getId();
}
