use of com.emc.storageos.db.client.model.Project in project coprhd-controller by CoprHD.
the class VPlexDeviceController method createVirtualVolumes.
/**
* Do the creation of a VPlex Virtual Volume. This is called as a Workflow Step.
* NOTE: The parameters here must match createVirtualVolumesMethod above (except stepId).
*
* @param vplexURI
* -- URI of the VPlex StorageSystem
* @param vplexVolumeURIs
* -- URI of the VPlex volumes to be created. They must contain
* associatedVolumes (URI of the underlying Storage Volumes).
* @param computeResourceMap
* A Map of the compute resource for each volume.
* @param stepId
* - The stepId used for completion.
* @throws WorkflowException
*/
public void createVirtualVolumes(URI vplexURI, List<URI> vplexVolumeURIs, Map<URI, URI> computeResourceMap, String stepId) throws WorkflowException {
List<List<VolumeInfo>> rollbackData = new ArrayList<List<VolumeInfo>>();
// Below variables will act as workflow.storeStepData Keys
final String volumeInfoStepKey = "VolumeInfo";
final String vplexVolumeInfoStepKey = "VPlexVirtualVolumeInfo";
List<URI> createdVplexVolumeURIs = new ArrayList<URI>();
try {
WorkflowStepCompleter.stepExecuting(stepId);
// Get the API client.
StorageSystem vplex = getDataObject(StorageSystem.class, vplexURI, _dbClient);
VPlexApiClient client = getVPlexAPIClient(_vplexApiFactory, vplex, _dbClient);
// Make a map of StorageSystem ids to Storage System
Map<URI, StorageSystem> storageMap = new HashMap<URI, StorageSystem>();
// Make a map of Virtual Volumes to Storage Volumes.
Map<Volume, List<Volume>> volumeMap = new HashMap<Volume, List<Volume>>();
// Make a string buffer for volume labels
StringBuffer volumeLabels = new StringBuffer();
// List of storage system Guids
List<String> storageSystemGuids = new ArrayList<String>();
Boolean isDistributedVolume = false;
Boolean isAnyHDSVolume = false;
Map<String, Set<URI>> clusterVarrayMap = new HashMap<>();
for (URI vplexVolumeURI : vplexVolumeURIs) {
Volume vplexVolume = getDataObject(Volume.class, vplexVolumeURI, _dbClient);
URI vplexVolumeVarrayURI = vplexVolume.getVirtualArray();
String clusterId = ConnectivityUtil.getVplexClusterForVarray(vplexVolumeVarrayURI, vplexVolume.getStorageController(), _dbClient);
if (clusterVarrayMap.containsKey(clusterId)) {
clusterVarrayMap.get(clusterId).add(vplexVolumeVarrayURI);
} else {
Set<URI> varraysForCluster = new HashSet<>();
varraysForCluster.add(vplexVolumeVarrayURI);
clusterVarrayMap.put(clusterId, varraysForCluster);
}
volumeLabels.append(vplexVolume.getLabel()).append(" ");
volumeMap.put(vplexVolume, new ArrayList<Volume>());
// Find the underlying Storage Volumes
StringSet associatedVolumes = vplexVolume.getAssociatedVolumes();
if (associatedVolumes.size() > 1) {
isDistributedVolume = true;
}
for (String associatedVolume : associatedVolumes) {
Volume storageVolume = getDataObject(Volume.class, new URI(associatedVolume), _dbClient);
URI storageSystemId = storageVolume.getStorageController();
if (storageMap.containsKey(storageSystemId) == false) {
StorageSystem storage = _dbClient.queryObject(StorageSystem.class, storageSystemId);
storageMap.put(storageSystemId, storage);
if (!storageSystemGuids.contains(storage.getNativeGuid())) {
storageSystemGuids.add(storage.getNativeGuid());
// check any storage is HDS as it may need extra discovery
if (storage.deviceIsType(DiscoveredDataObject.Type.hds)) {
isAnyHDSVolume = true;
}
}
}
volumeMap.get(vplexVolume).add(storageVolume);
}
}
_log.info(String.format("Request to create: %s virtual volume(s) %s", volumeMap.size(), volumeLabels));
long startTime = System.currentTimeMillis();
// If a new backend system is connected to a VPLEX and the VPLEX does not
// yet know about the system i.e., the system does not show up in the path
// /clusters/cluster-x/storage-elements/storage-arrays, and a user attempts
// to create a virtual volume, the request may fail because we cannot find
// the storage system. When the backend volume on the new system is created
// and exported to the VPLEX, the VPLEX will recognize new system. However,
// this may not occur immediately. So, when we go to create the vplex volume
// using that backend volume, we may not find that system and volume on the
// first try. We saw this in development. As such there was a retry loop
// added when finding the backend volumes in the discovery that is performed
// in the method to create the virtual volume.
//
// However changes for CTRL-12826 were merged on 7/31/2015 that circumvented
// that retry code. Changes were made to do the array re-discover here prior
// to virtual volume creation, rather than during virtual volume creation and
// false was passed to the create virtual volume routine for the discovery
// required flag. The newly added call does not do any kind of retry if the
// system is not found and so a failure will occur in the scenario described
// above. If a system is not found an exception is thrown. Now we will catch
// that exception and re-enable discovery in the volume creation routine.
// Essentially we revert to what was happening before the 12826 changes if there
// is an issue discovering the systems on the initial try here.
boolean discoveryRequired = false;
// Update for COP-36674, We Observe that for HDS system even after successful discovery the backend storage volume not found by
// VPLEX Intermittently and it may required rediscovery to find it.Making it configurable with default value set false.
boolean hdsRediscoveryConfigFlag = Boolean.valueOf(ControllerUtils.getPropertyValueFromCoordinator(coordinator, CONTROLLER_VPLEX_BACKEND_HDS_DISCOVERY_RETRY));
discoveryRequired = hdsRediscoveryConfigFlag && isAnyHDSVolume;
_log.debug("discoveryRequired: {} , hdsRediscoveryConfigFlag: {}, isAnyHDSVolume: {}", discoveryRequired, hdsRediscoveryConfigFlag, isAnyHDSVolume);
try {
client.rediscoverStorageSystems(storageSystemGuids);
} catch (Exception e) {
String warnMsg = String.format("Initial discovery of one or more of these backend systems %s failed: %s." + "Discovery is required during virtual volume creation", storageSystemGuids, e.getMessage());
_log.warn(warnMsg);
discoveryRequired = true;
}
// Now make a call to the VPlexAPIClient.createVirtualVolume for each vplex volume.
StringBuilder buf = new StringBuilder();
buf.append("Vplex: " + vplexURI + " created virtual volume(s): ");
boolean thinEnabled = false;
boolean searchAllClustersForStorageVolumes = ((clusterVarrayMap.keySet().size() > 1 || isDistributedVolume) ? true : false);
List<VPlexVirtualVolumeInfo> virtualVolumeInfos = new ArrayList<VPlexVirtualVolumeInfo>();
Map<String, Volume> vplexVolumeNameMap = new HashMap<String, Volume>();
List<VPlexClusterInfo> clusterInfoList = null;
for (Volume vplexVolume : volumeMap.keySet()) {
URI vplexVolumeId = vplexVolume.getId();
_log.info(String.format("Creating virtual volume: %s (%s)", vplexVolume.getLabel(), vplexVolumeId));
URI vplexVolumeVarrayURI = vplexVolume.getVirtualArray();
String clusterId = null;
for (Entry<String, Set<URI>> clusterEntry : clusterVarrayMap.entrySet()) {
if (clusterEntry.getValue().contains(vplexVolumeVarrayURI)) {
clusterId = clusterEntry.getKey();
}
}
List<VolumeInfo> vinfos = new ArrayList<VolumeInfo>();
for (Volume storageVolume : volumeMap.get(vplexVolume)) {
StorageSystem storage = storageMap.get(storageVolume.getStorageController());
List<String> itls = VPlexControllerUtils.getVolumeITLs(storageVolume);
VolumeInfo info = new VolumeInfo(storage.getNativeGuid(), storage.getSystemType(), storageVolume.getWWN().toUpperCase().replaceAll(":", ""), storageVolume.getNativeId(), storageVolume.getThinlyProvisioned().booleanValue(), itls);
if (storageVolume.getVirtualArray().equals(vplexVolumeVarrayURI)) {
// We always want the source backend volume identified first. It
// may not be first in the map as the map is derived from the
// VPLEX volume's associated volumes list which is an unordered
// StringSet.
vinfos.add(0, info);
} else {
vinfos.add(info);
}
if (info.getIsThinProvisioned()) {
// if either or both legs of distributed is thin, try for thin-enabled
// (or if local and the single backend volume is thin, try as well)
thinEnabled = true;
}
}
// Update rollback information.
rollbackData.add(vinfos);
_workflowService.storeStepData(stepId, volumeInfoStepKey, rollbackData);
InvokeTestFailure.internalOnlyInvokeTestFailure(InvokeTestFailure.ARTIFICIAL_FAILURE_045);
// Make a call to get cluster info
if (null == clusterInfoList) {
if (searchAllClustersForStorageVolumes) {
clusterInfoList = client.getClusterInfoDetails();
} else {
clusterInfoList = new ArrayList<VPlexClusterInfo>();
}
}
// Make the call to create a virtual volume. It is distributed if there are two (or more?)
// physical volumes.
boolean isDistributed = (vinfos.size() >= 2);
thinEnabled = thinEnabled && verifyVplexSupportsThinProvisioning(vplex);
VPlexVirtualVolumeInfo vvInfo = client.createVirtualVolume(vinfos, isDistributed, discoveryRequired, false, clusterId, clusterInfoList, false, thinEnabled, searchAllClustersForStorageVolumes);
// Note: according to client.createVirtualVolume, this will never be the case.
if (vvInfo == null) {
VPlexApiException ex = VPlexApiException.exceptions.cantFindRequestedVolume(vplexVolume.getLabel());
throw ex;
}
vplexVolumeNameMap.put(vvInfo.getName(), vplexVolume);
virtualVolumeInfos.add(vvInfo);
}
InvokeTestFailure.internalOnlyInvokeTestFailure(InvokeTestFailure.ARTIFICIAL_FAILURE_046);
Map<String, VPlexVirtualVolumeInfo> foundVirtualVolumes = client.findVirtualVolumes(clusterInfoList, virtualVolumeInfos);
if (!foundVirtualVolumes.isEmpty()) {
List<String> vplexVirtualCustomVolNames = new ArrayList();
for (Entry<String, Volume> entry : vplexVolumeNameMap.entrySet()) {
Volume vplexVolume = entry.getValue();
VPlexVirtualVolumeInfo vvInfo = foundVirtualVolumes.get(entry.getKey());
try {
// Now we try and rename the volume to the customized name. Note that if custom naming
// is disabled the custom name will not be generated and will be null.
// Create the VPLEX volume name custom configuration datasource and generate the
// custom volume name based on whether the volume is a local or distributed volume.
String hostOrClusterName = null;
URI computeResourceURI = computeResourceMap.get(vplexVolume.getId());
if (computeResourceURI != null) {
DataObject hostOrCluster = null;
if (URIUtil.isType(computeResourceURI, Cluster.class)) {
hostOrCluster = getDataObject(Cluster.class, computeResourceURI, _dbClient);
} else if (URIUtil.isType(computeResourceURI, Host.class)) {
hostOrCluster = getDataObject(Host.class, computeResourceURI, _dbClient);
}
if ((hostOrCluster != null) && ((vplexVolume.getPersonality() == null) || (vplexVolume.checkPersonality(Volume.PersonalityTypes.SOURCE)))) {
hostOrClusterName = hostOrCluster.getLabel();
}
}
if (CustomVolumeNamingUtils.isCustomVolumeNamingEnabled(customConfigHandler, vplex.getSystemType())) {
String customConfigName = CustomVolumeNamingUtils.getCustomConfigName(hostOrClusterName != null);
Project project = getDataObject(Project.class, vplexVolume.getProject().getURI(), _dbClient);
TenantOrg tenant = getDataObject(TenantOrg.class, vplexVolume.getTenant().getURI(), _dbClient);
DataSource customNameDataSource = CustomVolumeNamingUtils.getCustomConfigDataSource(project, tenant, vplexVolume.getLabel(), vvInfo.getWwn(), hostOrClusterName, dataSourceFactory, customConfigName, _dbClient);
if (customNameDataSource != null) {
String customVolumeName = CustomVolumeNamingUtils.getCustomName(customConfigHandler, customConfigName, customNameDataSource, vplex.getSystemType());
vvInfo = CustomVolumeNamingUtils.renameVolumeOnVPlex(vvInfo, customVolumeName, client);
// Update the label to match the custom name.
vplexVolume.setLabel(vvInfo.getName());
// Also, we update the name portion of the project and tenant URIs
// to reflect the custom name. This is necessary because the API
// to search for volumes by project, extracts the name portion of the
// project URI to get the volume name.
NamedURI namedURI = vplexVolume.getProject();
namedURI.setName(vvInfo.getName());
vplexVolume.setProject(namedURI);
namedURI = vplexVolume.getTenant();
namedURI.setName(vvInfo.getName());
vplexVolume.setTenant(namedURI);
vplexVirtualCustomVolNames.add(vvInfo.getName());
}
}
} catch (Exception e) {
_log.warn(String.format("Error renaming newly created VPLEX volume %s:%s", vplexVolume.getId(), vplexVolume.getLabel()), e);
}
buf.append(vvInfo.getName() + " ");
_log.info(String.format("Created virtual volume: %s path: %s size: %s", vvInfo.getName(), vvInfo.getPath(), vvInfo.getCapacityBytes()));
vplexVolume.setNativeId(vvInfo.getPath());
vplexVolume.setNativeGuid(vvInfo.getPath());
vplexVolume.setDeviceLabel(vvInfo.getName());
vplexVolume.setThinlyProvisioned(vvInfo.isThinEnabled());
checkThinEnabledResult(vvInfo, thinEnabled, _workflowService.getWorkflowFromStepId(stepId).getOrchTaskId());
vplexVolume.setWWN(vvInfo.getWwn());
// For Vplex virtual volumes set allocated capacity to 0 (cop-18608)
vplexVolume.setAllocatedCapacity(0L);
vplexVolume.setProvisionedCapacity(vvInfo.getCapacityBytes());
_dbClient.updateObject(vplexVolume);
// Record VPLEX volume created event.
createdVplexVolumeURIs.add(vplexVolume.getId());
recordBourneVolumeEvent(vplexVolume.getId(), OperationTypeEnum.CREATE_BLOCK_VOLUME.getEvType(true), Operation.Status.ready, OperationTypeEnum.CREATE_BLOCK_VOLUME.getDescription());
}
// Store Vplex volume name to the workflow, to be used in rollback method.
_workflowService.storeStepData(stepId, vplexVolumeInfoStepKey, vplexVirtualCustomVolNames);
}
if (foundVirtualVolumes.size() != vplexVolumeNameMap.size()) {
VPlexApiException ex = VPlexApiException.exceptions.cantFindAllRequestedVolume();
throw ex;
}
long elapsed = System.currentTimeMillis() - startTime;
_log.info(String.format("TIMER: %s virtual volume(s) %s create took %f seconds", volumeMap.size(), volumeLabels.toString(), (double) elapsed / (double) 1000));
WorkflowStepCompleter.stepSucceded(stepId);
} catch (VPlexApiException vae) {
_log.error("Exception creating Vplex Virtual Volume: " + vae.getMessage(), vae);
// not created.
for (URI vplexVolumeURI : vplexVolumeURIs) {
if (!createdVplexVolumeURIs.contains(vplexVolumeURI)) {
recordBourneVolumeEvent(vplexVolumeURI, OperationTypeEnum.CREATE_BLOCK_VOLUME.getEvType(false), Operation.Status.error, OperationTypeEnum.CREATE_BLOCK_VOLUME.getDescription());
}
}
WorkflowStepCompleter.stepFailed(stepId, vae);
} catch (Exception ex) {
_log.error("Exception creating Vplex Virtual Volume: " + ex.getMessage(), ex);
// not created.
for (URI vplexVolumeURI : vplexVolumeURIs) {
if (!createdVplexVolumeURIs.contains(vplexVolumeURI)) {
recordBourneVolumeEvent(vplexVolumeURI, OperationTypeEnum.CREATE_BLOCK_VOLUME.getEvType(false), Operation.Status.error, OperationTypeEnum.CREATE_BLOCK_VOLUME.getDescription());
}
}
String opName = ResourceOperationTypeEnum.CREATE_VIRTUAL_VOLUME.getName();
ServiceError serviceError = VPlexApiException.errors.createVirtualVolumesFailed(opName, ex);
WorkflowStepCompleter.stepFailed(stepId, serviceError);
}
}
use of com.emc.storageos.db.client.model.Project in project coprhd-controller by CoprHD.
the class VPlexDeviceController method createVirtualVolumeFromImportStep.
/**
* Create a Virtual Volume from an Imported Volume.
* There are three cases here:
* 1. We want to create a non-distributed virtual volume. In this case,
* there is an existingVolume, but newVolume == null.
* 2. We want to create a distributed virtual volume from an existing volume,
* and then add a mirror to a new volume (in the other varray).
* In this case, both existingVolume and newVolume are non-null.
* 3. We had an existing Virtual volume, and we only want to upgrade it
* to a distributed Virtual Volume (existingVolumeURI == null).
*
* @param vplexURI
* @param vplexVolumeURI
* @param existingVolumeURI
* @param newVolumeURI
* @param vplexSystemProject
* @param vplexSystemTenant
* @param newCosURI
* @param newLabel
* @param stepId
* @throws WorkflowException
*/
public void createVirtualVolumeFromImportStep(URI vplexURI, URI vplexVolumeURI, URI existingVolumeURI, URI newVolumeURI, URI vplexSystemProject, URI vplexSystemTenant, URI newCosURI, String newLabel, String transferSize, String stepId) throws WorkflowException {
try {
WorkflowStepCompleter.stepExecuting(stepId);
// Get the API client.
StorageSystem vplex = getDataObject(StorageSystem.class, vplexURI, _dbClient);
VPlexApiClient client = getVPlexAPIClient(_vplexApiFactory, vplex, _dbClient);
// Get the three volumes.
Volume vplexVolume = getDataObject(Volume.class, vplexVolumeURI, _dbClient);
Volume existingVolume = null;
Volume newVolume = null;
if (existingVolumeURI != null) {
existingVolume = getDataObject(Volume.class, existingVolumeURI, _dbClient);
}
if (newVolumeURI != null) {
newVolume = getDataObject(Volume.class, newVolumeURI, _dbClient);
}
VPlexVirtualVolumeInfo virtvinfo = null;
VolumeInfo vinfo = null;
// Make the call to create the (non-distributed) virtual volume.
if (existingVolume != null) {
StorageSystem array = getDataObject(StorageSystem.class, existingVolume.getStorageController(), _dbClient);
List<String> itls = VPlexControllerUtils.getVolumeITLs(existingVolume);
List<VolumeInfo> vinfos = new ArrayList<VolumeInfo>();
VirtualPool newVirtualPool = getDataObject(VirtualPool.class, newCosURI, _dbClient);
boolean thinEnabled = VirtualPool.ProvisioningType.Thin.toString().equalsIgnoreCase(newVirtualPool.getSupportedProvisioningType());
vinfo = new VolumeInfo(array.getNativeGuid(), array.getSystemType(), existingVolume.getWWN().toUpperCase().replaceAll(":", ""), existingVolume.getNativeId(), thinEnabled, itls);
vinfos.add(vinfo);
thinEnabled = thinEnabled && verifyVplexSupportsThinProvisioning(vplex);
virtvinfo = client.createVirtualVolume(vinfos, false, true, true, null, null, true, thinEnabled, true);
// Note: According to client.createVirtualVolume code, this will never be the case (null)
if (virtvinfo == null) {
String opName = ResourceOperationTypeEnum.CREATE_VVOLUME_FROM_IMPORT.getName();
ServiceError serviceError = VPlexApiException.errors.createVirtualVolumeFromImportStepFailed(opName);
WorkflowStepCompleter.stepFailed(stepId, serviceError);
return;
}
_log.info(String.format("Created virtual volume: %s path: %s thinEnabled: %b", virtvinfo.getName(), virtvinfo.getPath(), virtvinfo.isThinEnabled()));
checkThinEnabledResult(virtvinfo, thinEnabled, _workflowService.getWorkflowFromStepId(stepId).getOrchTaskId());
// not set.
if (newVolume != null) {
vplexVolume.setNativeId(virtvinfo.getPath());
vplexVolume.setNativeGuid(virtvinfo.getPath());
vplexVolume.setDeviceLabel(virtvinfo.getName());
vplexVolume.setThinlyProvisioned(virtvinfo.isThinEnabled());
_dbClient.updateObject(vplexVolume);
}
} else {
virtvinfo = client.findVirtualVolume(vplexVolume.getDeviceLabel(), vplexVolume.getNativeId());
}
// now create a mirror to the new volume.
if (newVolume != null) {
String clusterId = ConnectivityUtil.getVplexClusterForVarray(vplexVolume.getVirtualArray(), vplexVolume.getStorageController(), _dbClient);
StorageSystem array = getDataObject(StorageSystem.class, newVolume.getStorageController(), _dbClient);
List<String> itls = VPlexControllerUtils.getVolumeITLs(newVolume);
vinfo = new VolumeInfo(array.getNativeGuid(), array.getSystemType(), newVolume.getWWN().toUpperCase().replaceAll(":", ""), newVolume.getNativeId(), newVolume.getThinlyProvisioned().booleanValue(), itls);
// Add rollback data.
_workflowService.storeStepData(stepId, vinfo);
virtvinfo = client.upgradeVirtualVolumeToDistributed(virtvinfo, vinfo, true, clusterId, transferSize);
if (virtvinfo == null) {
String opName = ResourceOperationTypeEnum.UPGRADE_VPLEX_LOCAL_TO_DISTRIBUTED.getName();
ServiceError serviceError = VPlexApiException.errors.upgradeLocalToDistributedFailed(opName);
WorkflowStepCompleter.stepFailed(stepId, serviceError);
return;
}
}
// Update the virtual volume device label and native Id.
// Also make sure the WWN is set.
vplexVolume.setNativeId(virtvinfo.getPath());
vplexVolume.setNativeGuid(virtvinfo.getPath());
vplexVolume.setDeviceLabel(virtvinfo.getName());
vplexVolume.setThinlyProvisioned(virtvinfo.isThinEnabled());
vplexVolume.setWWN(virtvinfo.getWwn());
// If we are importing, we need to move the existing import volume to
// the system project/tenant, update its label, and set the new CoS.
Volume srcSideAssocVolume = null;
if (existingVolume != null) {
srcSideAssocVolume = existingVolume;
existingVolume.setProject(new NamedURI(vplexSystemProject, existingVolume.getLabel()));
existingVolume.setTenant(new NamedURI(vplexSystemTenant, existingVolume.getLabel()));
existingVolume.setLabel(newLabel);
existingVolume.setVirtualPool(newCosURI);
existingVolume.addInternalFlags(Flag.INTERNAL_OBJECT);
_dbClient.updateObject(existingVolume);
// If the VPLEX volume is being upgraded to distributed, it's provisioned
// should be set and does not change. However, when importing an existing
// volume to a VPLEX volume, we need to set the provisioned capacity
// of the VPLEX volume to the provisioned capacity of the existing volume.
vplexVolume.setProvisionedCapacity(existingVolume.getProvisionedCapacity());
// For Vplex virtual volumes set allocated capacity to 0 (cop-18608)
vplexVolume.setAllocatedCapacity(0L);
// For import associated with creating a VPLEX full copy, we need
// to add the copy to the list of copies for the source VPLEX volume.
// We only do this when the copy is successfully completed.
URI srcVplexVolumeURI = vplexVolume.getAssociatedSourceVolume();
if (!NullColumnValueGetter.isNullURI(srcVplexVolumeURI)) {
// Note that the associated source volume will be null if
// this is just a standard import of a non-VPLEX volume. It
// will be set in the case we use the import workflow to
// import a native copy to a VPLEX volume for the purpose
// of creating a full copy.
Volume srcVplexVolume = _dbClient.queryObject(Volume.class, srcVplexVolumeURI);
if (null != srcVplexVolume) {
StringSet srcVplexVolumeCopies = srcVplexVolume.getFullCopies();
if (srcVplexVolumeCopies == null) {
srcVplexVolumeCopies = new StringSet();
srcVplexVolume.setFullCopies(srcVplexVolumeCopies);
}
srcVplexVolumeCopies.add(vplexVolumeURI.toString());
_dbClient.updateObject(srcVplexVolume);
}
// Also, reflect the replica state in the vplex copy.
vplexVolume.setReplicaState(existingVolume.getReplicaState());
}
} else {
// and update the CoS.
for (String assocVolume : vplexVolume.getAssociatedVolumes()) {
try {
srcSideAssocVolume = _dbClient.queryObject(Volume.class, new URI(assocVolume));
srcSideAssocVolume.setVirtualPool(newCosURI);
_dbClient.updateObject(srcSideAssocVolume);
} catch (URISyntaxException ex) {
_log.error("Bad assocVolume URI: " + assocVolume, ex);
}
}
vplexVolume.getAssociatedVolumes().add(newVolumeURI.toString());
vplexVolume.setVirtualPool(newCosURI);
}
// created and we need to make sure it has the correct name.
try {
if ((CustomVolumeNamingUtils.isCustomVolumeNamingEnabled(customConfigHandler, vplex.getSystemType())) && (existingVolume != null)) {
// Create the VPLEX volume name custom configuration datasource and generate the
// custom volume name.
String customConfigName = CustomVolumeNamingUtils.getCustomConfigName(false);
Project project = getDataObject(Project.class, vplexVolume.getProject().getURI(), _dbClient);
TenantOrg tenant = getDataObject(TenantOrg.class, vplexVolume.getTenant().getURI(), _dbClient);
DataSource customNameDataSource = CustomVolumeNamingUtils.getCustomConfigDataSource(project, tenant, vplexVolume.getLabel(), vplexVolume.getWWN(), null, dataSourceFactory, customConfigName, _dbClient);
if (customNameDataSource != null) {
String customVolumeName = CustomVolumeNamingUtils.getCustomName(customConfigHandler, customConfigName, customNameDataSource, vplex.getSystemType());
virtvinfo = CustomVolumeNamingUtils.renameVolumeOnVPlex(virtvinfo, customVolumeName, client);
vplexVolume.setNativeId(virtvinfo.getPath());
vplexVolume.setNativeGuid(virtvinfo.getPath());
vplexVolume.setDeviceLabel(virtvinfo.getName());
vplexVolume.setLabel(virtvinfo.getName());
// Also, we update the name portion of the project and tenant URIs
// to reflect the custom name. This is necessary because the API
// to search for volumes by project, extracts the name portion of the
// project URI to get the volume name.
NamedURI namedURI = vplexVolume.getProject();
namedURI.setName(virtvinfo.getName());
vplexVolume.setProject(namedURI);
namedURI = vplexVolume.getTenant();
namedURI.setName(virtvinfo.getName());
vplexVolume.setTenant(namedURI);
}
}
} catch (Exception e) {
_log.warn(String.format("Error attempting to rename VPLEX volume %s", vplexVolumeURI), e);
}
// Update the volume.
_dbClient.updateObject(vplexVolume);
// Complete the workflow step.
WorkflowStepCompleter.stepSucceded(stepId);
} catch (VPlexApiException vae) {
if (existingVolumeURI != null) {
_log.error("Exception importing non-VPLEX volume to VPLEX: " + vae.getMessage(), vae);
} else {
_log.error("Exception upgrading a local VPLEX volume to distributed: " + vae.getMessage(), vae);
}
WorkflowStepCompleter.stepFailed(stepId, vae);
} catch (Exception ex) {
ServiceError serviceError;
if (existingVolumeURI != null) {
_log.error("Exception importing non-VPLEX volume to VPLEX: " + ex.getMessage(), ex);
String opName = ResourceOperationTypeEnum.IMPORT_BLOCK_VOLUME.getName();
serviceError = VPlexApiException.errors.importVolumeFailedException(opName, ex);
} else {
_log.error("Exception upgrading a local VPLEX volume to distributed: " + ex.getMessage(), ex);
String opName = ResourceOperationTypeEnum.UPGRADE_VPLEX_LOCAL_TO_DISTRIBUTED.getName();
serviceError = VPlexApiException.errors.upgradeLocalToDistributedFailedException(opName, ex);
}
WorkflowStepCompleter.stepFailed(stepId, serviceError);
}
}
use of com.emc.storageos.db.client.model.Project in project coprhd-controller by CoprHD.
the class BasePermissionsHelper method checkForActiveProjectAclsUsingUserGroup.
/**
* Checks whether the given the user group is present in any of the
* project's acls or not
*
* @param label to check if any project acls uses user group or not.
* @return set of URI's Projects that uses the user group.
*/
public Set<URI> checkForActiveProjectAclsUsingUserGroup(String label) {
Set<URI> projectsUsingUserGroup = null;
// Find all the configured project IDs based on the type.
List<URI> projectURIList = _dbClient.queryByType(Project.class, true);
if (projectURIList == null || !projectURIList.iterator().hasNext()) {
_log.warn("There are no projects configured.");
return projectsUsingUserGroup;
}
// Find all the configured project objects based on the given list of IDs.
List<Project> projects = _dbClient.queryObject(Project.class, projectURIList);
if (CollectionUtils.isEmpty(projects)) {
_log.error("Could not find the project objects for the Ids {}", projectURIList.toString());
return projectsUsingUserGroup;
}
projectsUsingUserGroup = new HashSet<URI>();
for (Project project : projects) {
if (project == null) {
_log.debug("Invalid project");
continue;
}
if (CollectionUtils.isEmpty(project.getAcls())) {
_log.debug("ACLs are not configured for project {}", project.getLabel());
continue;
}
Set<String> aclKeys = project.getAcls().keySet();
if (checkUserGroupWithPermissionKeys(label, aclKeys)) {
projectsUsingUserGroup.add(project.getId());
}
}
return projectsUsingUserGroup;
}
use of com.emc.storageos.db.client.model.Project in project coprhd-controller by CoprHD.
the class BasePermissionsHelper method getTenantIdFromProjectId.
/**
* Get tenant id from a project id retrieved from uri
*
* @param projectId
* @return
*/
public URI getTenantIdFromProjectId(String projectId, boolean idEmbeddedInURL) {
if (projectId == null) {
return null;
}
try {
URI id = URI.create(projectId);
Project ret = getObjectById(id, Project.class);
if (ret == null) {
if (idEmbeddedInURL) {
throw APIException.notFound.unableToFindEntityInURL(id);
} else {
throw APIException.badRequests.unableToFindEntity(id);
}
}
return ret.getTenantOrg().getURI();
} catch (DatabaseException ex) {
throw SecurityException.fatals.failedGettingTenant(ex);
}
}
use of com.emc.storageos.db.client.model.Project in project coprhd-controller by CoprHD.
the class FileOrchestrationUtils method getVNASServersOfStorageSystemAndVarrayOfVpool.
/**
* Get the list of virtual nas servers from storage system which are part of vpool and project
*
* @param dbClient
* @param storageSystemURI
* @param vpoolURI
* @param projectURI
* @return
*/
public static List<URI> getVNASServersOfStorageSystemAndVarrayOfVpool(DbClient dbClient, URI storageSystemURI, URI vpoolURI, URI projectURI) {
VirtualPool vpool = dbClient.queryObject(VirtualPool.class, vpoolURI);
Project project = null;
if (projectURI != null) {
project = dbClient.queryObject(Project.class, projectURI);
}
StringSet varraySet = vpool.getVirtualArrays();
URIQueryResultList vNasURIs = new URIQueryResultList();
List<URI> vNASURIList = new ArrayList<URI>();
dbClient.queryByConstraint(ContainmentConstraint.Factory.getStorageDeviceVirtualNasConstraint(storageSystemURI), vNasURIs);
Iterator<URI> vNasIter = vNasURIs.iterator();
while (vNasIter.hasNext()) {
URI vNasURI = vNasIter.next();
VirtualNAS vNas = dbClient.queryObject(VirtualNAS.class, vNasURI);
if (vNas != null && !vNas.getInactive()) {
// Dont pick the other project nas servers!!!
if (project != null && vNas.getAssociatedProjects() != null && !vNas.getAssociatedProjects().isEmpty()) {
if (!vNas.getAssociatedProjects().contains(project.getId().toString())) {
_log.info("vNas server {} assigned to other project, so ignoring this vNas server", vNas.getNasName());
continue;
}
}
StringSet vNASVarraySet = vNas.getAssignedVirtualArrays();
if (varraySet != null && !varraySet.isEmpty() && vNASVarraySet != null) {
vNASVarraySet.retainAll(varraySet);
if (!vNASVarraySet.isEmpty()) {
vNASURIList.add(vNas.getId());
}
}
}
}
return vNASURIList;
}
Aggregations