@Test
public void testPersistObject() throws Exception {
_logger.info("Starting persist CatalogService test");
CatalogService model = new CatalogService();
model.setId(URIUtil.createId(CatalogService.class));
model.setLabel("foo");
model.setApprovalRequired(true);
model.setBaseService("my service");
URI ewUri = URIUtil.createId(ExecutionWindow.class);
NamedURI ewId = new NamedURI(ewUri, "ewId");
model.setDefaultExecutionWindowId(ewId);
model.setDescription("my desc");
model.setExecutionWindowRequired(true);
model.setImage("my image");
model.setMaxSize(42);
model.setTitle("my title");
save(model);
model = findById(model.getId());
Assert.assertNotNull(model);
Assert.assertEquals("foo", model.getLabel());
Assert.assertEquals(true, model.getApprovalRequired());
Assert.assertEquals("my service", model.getBaseService());
Assert.assertEquals(ewId, model.getDefaultExecutionWindowId());
Assert.assertEquals("my desc", model.getDescription());
Assert.assertEquals(true, model.getExecutionWindowRequired());
Assert.assertEquals("my image", model.getImage());
Assert.assertEquals(new Integer(42), model.getMaxSize());
Assert.assertEquals("my title", model.getTitle());
}
/**
* Creates the BlockObject BlockSnapshot data.
*
* @param name
* @param numSnapshots
* @throws Exception
*/
private void prepareBlockSnapshotData(String name, int numSnapshots) throws Exception {
// Create the volume for the snapshots
Volume volume = new Volume();
URI volumeURI = URIUtil.createId(Volume.class);
StorageSystem storageSystem = createStorageSystem(false);
volume.setId(volumeURI);
volume.setStorageController(storageSystem.getId());
String volName = "blockSnapshotVolume";
volume.setLabel(volName);
BlockConsistencyGroup cg =
createBlockConsistencyGroup(
"blockSnapshotConsistencyGroup", storageSystem.getId(), Types.LOCAL.name(), true);
volume.setConsistencyGroup(cg.getId());
_dbClient.createObject(volume);
for (int i = 1; i <= numSnapshots; i++) {
BlockSnapshot blockSnapshot = new BlockSnapshot();
URI blockSnapshotURI = URIUtil.createId(BlockSnapshot.class);
blockSnapshotURIs.add(blockSnapshotURI);
blockSnapshot.setId(blockSnapshotURI);
blockSnapshot.setLabel(name + i);
blockSnapshot.setSnapsetLabel(name + i);
blockSnapshot.setParent(new NamedURI(volume.getId(), name + i));
blockSnapshot.addConsistencyGroup(cg.getId().toString());
_dbClient.createObject(blockSnapshot);
}
}
@Before
public void setup() {
_context = new ClassPathXmlApplicationContext("metering-vnxfile-context.xml");
try {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/dbutils-conf.xml");
_dbClient = (DbClientImpl) ctx.getBean("dbclient");
_dbClient = Cassandraforplugin.returnDBClient();
final TenantOrg tenantorg = new TenantOrg();
tenantorg.setId(URIUtil.createId(TenantOrg.class));
tenantorg.setLabel("some org");
tenantorg.setParentTenant(
new NamedURI(URIUtil.createId(TenantOrg.class), tenantorg.getLabel()));
_logger.info("TenantOrg :" + tenantorg.getId());
_dbClient.persistObject(tenantorg);
final Project proj = new Project();
proj.setId(URIUtil.createId(Project.class));
proj.setLabel("some name");
proj.setTenantOrg(new NamedURI(tenantorg.getId(), proj.getLabel()));
_logger.info("Project :" + proj.getId());
_logger.info("TenantOrg-Proj :" + proj.getTenantOrg());
_dbClient.persistObject(proj);
final FileShare fileShare = new FileShare();
fileShare.setId(URIUtil.createId(FileShare.class));
fileShare.setLabel("some fileshare");
fileShare.setNativeGuid("CELERRA+" + serialNumber);
fileShare.setVirtualPool(URIUtil.createId(VirtualPool.class));
fileShare.setProject(new NamedURI(proj.getId(), fileShare.getLabel()));
fileShare.setCapacity(12500L);
_dbClient.persistObject(fileShare);
} catch (final Exception ioEx) {
_logger.error("Exception occurred while persisting objects in db {}", ioEx.getMessage());
_logger.error(ioEx.getMessage(), ioEx);
}
}
/**
* Prepare the RecoverPoint only volumes and associated consistency group data.
*
* @throws Exception
*/
private void prepareRPConsistencyGroupDataWithStaleVolumes() throws Exception {
String cg2Name = "rpCg2";
// Create the RecoverPoint BlockConsistencyGroup that will be shared by all the
// RP volumes.
BlockConsistencyGroup rpCg = createBlockConsistencyGroup(cg2Name, null, Types.RP.name(), true);
// Save the CG references for migration verification.
rpConsistencyGroupURI2 = rpCg.getId();
// Create the ProtectionSet that the RP volumes will belong to.
ProtectionSet cg2ps = createProtectionSet("rpCg2ProtectionSet", projectURI);
// Create all the RP volumes
List<Volume> rpCg2Volumes = createRpVolumes("rpCg2VolumeA", 2, cg2ps, false);
rpCg2Volumes.addAll(createRpVolumes("rpCg2VolumeB", 2, cg2ps, false));
// Add the RP volumes to the RP consistency group
addVolumesToBlockConsistencyGroup(rpCg.getId(), rpCg2Volumes);
// Add the RP volumes to the protection set
addVolumesToProtectionSet(cg2ps.getId(), rpCg2Volumes);
// Add stale volume references
URI staleVolumeURI1 = URIUtil.createId(Volume.class);
URI staleVolumeURI2 = URIUtil.createId(Volume.class);
ProtectionSet ps = _dbClient.queryObject(ProtectionSet.class, cg2ps.getId());
StringSet vols = ps.getVolumes();
vols.add(staleVolumeURI1.toString());
vols.add(staleVolumeURI2.toString());
staleProtectionSetURI2 = cg2ps.getId();
staleProtectionSetVolumeURIs.add(staleVolumeURI1.toString());
staleProtectionSetVolumeURIs.add(staleVolumeURI2.toString());
_dbClient.persistObject(ps);
}
/**
* Prepares and persists the Project/Tenant data.
*
* @throws Exception
*/
private void prepareProjectData() throws Exception {
TenantOrg tenantOrg = new TenantOrg();
URI tenantOrgURI = URIUtil.createId(TenantOrg.class);
tenantOrg.setId(tenantOrgURI);
_dbClient.createObject(tenantOrg);
Project proj = new Project();
projectURI = URIUtil.createId(Project.class);
String projectLabel = "project";
proj.setId(projectURI);
proj.setLabel(projectLabel);
proj.setTenantOrg(new NamedURI(tenantOrgURI, projectLabel));
_dbClient.createObject(proj);
}
/**
* 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;
}
/**
* Prepare the ViPR BlockSnapshotSession instance for the pass BlockSnapshot instance.
*
* @param snapshot A reference to the snapshot.
* @return A reference to the newly created snapshot session.
*/
private BlockSnapshotSession prepareSnapshotSession(BlockSnapshot snapshot) {
s_logger.info("Prepare BlockSnapshotSession for snapshot {}", snapshot.getId());
BlockSnapshotSession snapshotSession = new BlockSnapshotSession();
URI snapSessionURI = URIUtil.createId(BlockSnapshotSession.class);
snapshotSession.setId(snapSessionURI);
snapshotSession.setSessionLabel(getSessionLabelFromSettingsInstance(snapshot));
URI cgURI = snapshot.getConsistencyGroup();
if (NullColumnValueGetter.isNullURI(cgURI)) {
snapshotSession.setParent(snapshot.getParent());
snapshotSession.setLabel(snapshot.getLabel());
} else {
snapshotSession.setConsistencyGroup(cgURI);
snapshotSession.setLabel(snapshot.getSnapsetLabel());
Volume parent = getDbClient().queryObject(Volume.class, snapshot.getParent());
if (parent != null) {
snapshotSession.setReplicationGroupInstance(parent.getReplicationGroupInstance());
snapshotSession.setSessionSetName(parent.getReplicationGroupInstance());
}
}
snapshotSession.setProject(snapshot.getProject());
snapshotSession.setStorageController(snapshot.getStorageController());
snapshotSession.setSessionInstance(snapshot.getSettingsInstance());
StringSet linkedTargets = new StringSet();
linkedTargets.add(snapshot.getId().toString());
snapshotSession.setLinkedTargets(linkedTargets);
return snapshotSession;
}
/**
* Creates a new vCenter data center.
*
* @param id the URN of the parent vCenter
* @param createParam the details of the data center
* @prereq none
* @brief Create vCenter data center
* @return the details of the vCenter data center, including its id and link, when creation
* completes successfully.
* @throws DatabaseException when a database error occurs.
*/
@POST
@Consumes({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
@Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
@CheckPermission(roles = {Role.SYSTEM_ADMIN, Role.TENANT_ADMIN})
@Path("/{id}/vcenter-data-centers")
public VcenterDataCenterRestRep createVcenterDataCenter(
@PathParam("id") URI id, VcenterDataCenterCreate createParam) throws DatabaseException {
Vcenter vcenter = queryObject(Vcenter.class, id, false);
checkDuplicateChildName(
id,
VcenterDataCenter.class,
DATAOBJECT_NAME_FIELD,
"vcenter",
createParam.getName(),
_dbClient);
VcenterDataCenter datacenter = new VcenterDataCenter();
datacenter.setId(URIUtil.createId(VcenterDataCenter.class));
datacenter.setLabel(createParam.getName());
datacenter.setVcenter(id);
if (vcenter.getTenantCreated()) {
datacenter.setTenant(_permissionsHelper.getTenant(vcenter.getAcls()));
} else {
datacenter.setTenant(NullColumnValueGetter.getNullURI());
}
_dbClient.createObject(datacenter);
auditOp(OperationTypeEnum.CREATE_VCENTER_DATACENTER, true, null, datacenter.auditParameters());
return map(datacenter);
}
/**
* Creates the consistency group used by the BlockObjects.
*
* @param name
* @return
*/
private BlockConsistencyGroup createBlockConsistencyGroup(
String name, URI storageSystem, String type, boolean setType) {
BlockConsistencyGroup cg = new BlockConsistencyGroup();
URI cgURI = URIUtil.createId(BlockConsistencyGroup.class);
cg.setId(cgURI);
cg.setLabel(name);
cg.setStorageController(storageSystem);
if (type.equals(Types.LOCAL.name())) {
// Set the 'old' field value so it can be migrated
cg.setDeviceName("localArrayDeviceName");
} else if (type.equals(Types.VPLEX.name())) {
// Set the 'old' field value so it can be migrated
cg.setDeviceName("vplexDeviceName");
} else if (type.equals(Types.RP.name())) {
// Set the 'old' field value so it can be migrated.
cg.setDeviceName("rpDeviceName");
} else if (type.equals(Types.SRDF.name())) {
// Set the 'old' field value so it can be migrated
cg.setDeviceName("srdfDeviceName");
}
if (setType) {
cg.setType(type);
}
// Set the 'old' field value so it can be migrated
_dbClient.createObject(cg);
return cg;
}
/** {@inheritDoc} */
@Override
public List<BlockObject> getAllSourceObjectsForFullCopyRequest(BlockObject fcSourceObj) {
// Treats full copies of snapshots as is done in base class.
if (URIUtil.isType(fcSourceObj.getId(), BlockSnapshot.class)) {
return super.getAllSourceObjectsForFullCopyRequest(fcSourceObj);
}
// By default, if the passed volume is in a consistency group
// all volumes in the consistency group should be copied.
List<BlockObject> fcSourceObjList = new ArrayList<BlockObject>();
URI cgURI = fcSourceObj.getConsistencyGroup();
if (!NullColumnValueGetter.isNullURI(cgURI)) {
BlockConsistencyGroup cg = _dbClient.queryObject(BlockConsistencyGroup.class, cgURI);
// If there is no corresponding native CG for the VPLEX
// CG, then this is a CG created prior to 2.2 and in this
// case we want full copies treated like snapshots, which
// is only create a copy of the passed object.
if (!cg.checkForType(Types.LOCAL)) {
fcSourceObjList.add(fcSourceObj);
} else {
fcSourceObjList.addAll(getActiveCGVolumes(cg));
}
} else {
fcSourceObjList.add(fcSourceObj);
}
return fcSourceObjList;
}
@Override
protected void prepareData() throws Exception {
DbClient dbClient = getDbClient();
ComputeImage image1 = new ComputeImage();
image1.setId(URIUtil.createId(ComputeImage.class));
image1.setLabel(IMAGE_NAME_WITH_PWD);
image1.setImageUrl(urlWithPwd);
dbClient.createObject(image1);
ComputeImage image2 = new ComputeImage();
image2.setId(URIUtil.createId(ComputeImage.class));
image2.setLabel(IMAGE_NAME_WITHOUT_PWD);
image2.setImageUrl(urlWithoutPwd);
dbClient.createObject(image2);
}
/**
* Prepares a ProtectionSet with volume references to volumes that do not exist in the DB.
*
* @throws Exception
*/
private void prepareProtectionSetWithAllStaleVolumes() throws Exception {
String cgName = "staleVolumeTest";
ProtectionSet protectionSet = createProtectionSet(cgName, projectURI);
staleProtectionSetURI = protectionSet.getId();
URI volumeURI1 = URIUtil.createId(Volume.class);
URI volumeURI2 = URIUtil.createId(Volume.class);
URI volumeURI3 = URIUtil.createId(Volume.class);
StringSet volumes = new StringSet();
volumes.add(volumeURI1.toString());
volumes.add(volumeURI2.toString());
volumes.add(volumeURI3.toString());
protectionSet.setVolumes(volumes);
_dbClient.persistObject(protectionSet);
}
/**
* Creates the consistency group used by the BlockObjects.
*
* @param name
* @return
*/
private BlockConsistencyGroup createBareBlockConsistencyGroup(String name) {
BlockConsistencyGroup cg = new BlockConsistencyGroup();
URI cgURI = URIUtil.createId(BlockConsistencyGroup.class);
emptyCgURI = cgURI;
cg.setId(cgURI);
cg.setLabel(name);
_dbClient.createObject(cg);
return cg;
}
private void createFileShare() {
// prepare FileShare objects for migration
FileShare fs = new FileShare();
fs.setId(URIUtil.createId(FileShare.class));
fs.setLabel("fileshare test");
dbClient.createObject(fs);
}
/**
* Convenience method to create a ProtectionSet.
*
* @param cgName
* @param projectURI
* @return
* @throws Exception
*/
private ProtectionSet createProtectionSet(String cgName, URI projectURI) throws Exception {
ProtectionSet protectionSet = new ProtectionSet();
URI protectionSetURI = URIUtil.createId(ProtectionSet.class);
protectionSet.setId(protectionSetURI);
protectionSet.setLabel("ViPR-" + cgName);
protectionSet.setProtectionId("790520997");
protectionSet.setProtectionStatus("ENABLED");
protectionSet.setProject(projectURI);
protectionSet.setProtectionSystem(protectionSystemURI);
_dbClient.createObject(protectionSet);
return protectionSet;
}
@SuppressWarnings("deprecation")
@Override
protected void prepareData() throws Exception {
// Create a virtual array.
VirtualArray varray = new VirtualArray();
varrayURI = URIUtil.createId(VirtualArray.class);
varray.setId(varrayURI);
_dbClient.createObject(varray);
// Create a network and set the virtual array.
Network network = new Network();
network.setId(URIUtil.createId(Network.class));
network.setLabel("NetworkWithVarray");
network.setVirtualArray(varrayURI);
_dbClient.createObject(network);
// Create another network without a virtual array.
network = new Network();
network.setId(URIUtil.createId(Network.class));
network.setLabel("NetworkWithoutVArray");
_dbClient.createObject(network);
}
/**
* Creates the BlockObject BlockMirror data.
*
* @param name
* @param numBlockMirrors
* @throws Exception
*/
private void prepareBlockMirrorData(String name, int numBlockMirrors) throws Exception {
BlockConsistencyGroup cg =
createBlockConsistencyGroup("blockMirrorConsistencyGroup", null, Types.LOCAL.name(), true);
for (int i = 1; i <= numBlockMirrors; i++) {
BlockMirror blockMirror = new BlockMirror();
URI blockMirrorURI = URIUtil.createId(BlockMirror.class);
blockMirrorURIs.add(blockMirrorURI);
blockMirror.setId(blockMirrorURI);
blockMirror.setLabel(name + i);
// Set the 'old' field value so it can be migrated
blockMirror.addConsistencyGroup(cg.getId().toString());
_dbClient.createObject(blockMirror);
}
}
private CatalogService createWithLabel(String label) {
CatalogService model = new CatalogService();
model.setLabel(label);
model.setApprovalRequired(true);
model.setBaseService("my service");
URI ewUri = URIUtil.createId(ExecutionWindow.class);
NamedURI ewId = new NamedURI(ewUri, "ewId");
model.setDefaultExecutionWindowId(ewId);
model.setDescription("my desc");
model.setExecutionWindowRequired(true);
model.setImage("my image");
model.setMaxSize(42);
model.setTitle("my title");
return model;
}
/**
* creates snapshot objects
*
* @param numSnapshots
* @param volume
* @param name snapshot name
*/
public void addSnapshots(
int numSnapshots, Volume volume, BlockConsistencyGroup cg, ProtectionSet ps, String name) {
for (int i = 1; i <= numSnapshots; i++) {
BlockSnapshot blockSnapshot = new BlockSnapshot();
URI blockSnapshotURI = URIUtil.createId(BlockSnapshot.class);
blockSnapshotURIs.add(blockSnapshotURI);
blockSnapshot.setId(blockSnapshotURI);
blockSnapshot.setLabel(name + i);
blockSnapshot.setSnapsetLabel(name + i);
blockSnapshot.setParent(new NamedURI(volume.getId(), name + i));
blockSnapshot.addConsistencyGroup(cg.getId().toString());
blockSnapshot.setProtectionSet(ps.getId());
_dbClient.createObject(blockSnapshot);
}
}
/**
* Convenience method that creates the BlockObject Volume data.
*
* @param volumeName
* @param numTargets
*/
private List<Volume> createBlockVolumes(String volumeName, int numVolumes, URI storageSystem) {
List<Volume> volumes = new ArrayList<Volume>();
for (int i = 1; i <= numVolumes; i++) {
Volume volume = new Volume();
URI volumeURI = URIUtil.createId(Volume.class);
blockVolumeURIs.add(volumeURI);
volume.setId(volumeURI);
volume.setLabel(volumeName + i);
volume.setStorageController(storageSystem);
_dbClient.createObject(volume);
volumes.add(volume);
}
return volumes;
}
/** {@inheritDoc} */
@Override
public void validateFullCopyCreateRequest(List<BlockObject> fcSourceObjList, int count) {
if (fcSourceObjList.size() > 0) {
URI fcSourceObjURI = fcSourceObjList.get(0).getId();
if (URIUtil.isType(fcSourceObjURI, BlockSnapshot.class)) {
// Currently you cannot create a full copy of a VPLEX snapshot.
throw APIException.badRequests.cantCreateFullCopyForVPlexSnapshot();
} else {
// Call super first.
super.validateFullCopyCreateRequest(fcSourceObjList, count);
// Platform specific checks.
for (BlockObject fcSourceObj : fcSourceObjList) {
Volume fcSourceVolume = (Volume) fcSourceObj;
StorageSystem system =
_dbClient.queryObject(StorageSystem.class, fcSourceVolume.getStorageController());
if (DiscoveredDataObject.Type.vplex.name().equals(system.getSystemType())) {
// If the volume is a VPLEX volume, then we need to be sure that
// storage pool of the source backend volume of the VPLEX volume,
// which is volume used to create the native full copy, supports
// full copy.
Volume srcBackendVolume =
VPlexUtil.getVPLEXBackendVolume(fcSourceVolume, true, _dbClient, true);
StoragePool storagePool =
_dbClient.queryObject(StoragePool.class, srcBackendVolume.getPool());
verifyFullCopySupportedForStoragePool(storagePool);
// If the full copy source is itself a full copy, it is not
// detached, and the native full copy i.e., the source side
// backend volume, is VNX, then creating a full copy of the
// volume will fail. As such, we prevent it.
if ((BlockFullCopyUtils.isVolumeFullCopy(fcSourceVolume, _dbClient))
&& (!BlockFullCopyUtils.isFullCopyDetached(fcSourceVolume, _dbClient))) {
URI backendSystemURI = srcBackendVolume.getStorageController();
StorageSystem backendSystem =
_dbClient.queryObject(StorageSystem.class, backendSystemURI);
if (DiscoveredDataObject.Type.vnxblock.name().equals(backendSystem.getSystemType())) {
throw APIException.badRequests.cantCreateFullCopyOfVPlexFullCopyUsingVNX();
}
}
}
}
}
}
}
/**
* Convenience method that creates a StorageSystem.
*
* @param isVplex true if a VPlex storage system is to be created, false otherwise.
* @return
*/
private StorageSystem createStorageSystem(boolean isVplex) {
StorageSystem ss = new StorageSystem();
URI storageSystemId = URIUtil.createId(StorageSystem.class);
ss.setId(storageSystemId);
if (isVplex) {
ss.setLabel("VPLEX+FNM00114300288:FNM00114600001");
ss.setNativeGuid("VPLEX+FNM00114300288:FNM00114600001");
ss.setSystemType("vplex");
} else {
ss.setLabel("SYMMETRIX+000195701573");
ss.setNativeGuid("SYMMETRIX+000195701573");
ss.setSystemType("vmax");
}
_dbClient.createObject(ss);
return ss;
}
/**
* Creates a new instance of vcenter.
*
* @param tenant the vcenter parent tenant organization
* @param param the input parameter containing the vcenter attributes
* @return an instance of {@link Vcenter}
*/
protected Vcenter createNewVcenter(TenantOrg tenant, VcenterParam param) {
Vcenter vcenter = new Vcenter();
vcenter.setId(URIUtil.createId(Vcenter.class));
addVcenterAclIfTenantAdmin(tenant, vcenter);
populateVcenterData(vcenter, param);
if (isSystemAdmin()) {
// Since, the creating user is either SysAdmin make the tenantCreated
// flag to false.
vcenter.setTenantCreated(Boolean.FALSE);
} else {
// Since the creating user is a TenantAdmin, just make the vCenter
// as a tenant created resource by default. When the SecAdmin or
// SysAdmin adds any new tenant then the vCenter will be shared
// across those tenants.
_log.debug("Tenant admin creates the vCenter {}", param.getName());
vcenter.setTenantCreated(Boolean.TRUE);
}
return vcenter;
}
/**
* Creates an instance of new storage port and associates it with the storage system.
*
* @param portNetworkId
* @param transportType
*/
private void create(String portNetworkId, String transportType) {
logger.info(
"Start create storage port for portNetworkId={}" + " and transportType={}",
portNetworkId,
transportType);
StorageHADomain adapter = CinderUtils.getStorageAdapter(storageSystem, dbClient);
StoragePort port = new StoragePort();
port.setId(URIUtil.createId(StoragePort.class));
port.setStorageDevice(storageSystem.getId());
String portName = generatePortName();
logger.debug("New storage port name is = {}", portName);
String nativeGuid =
NativeGUIDGenerator.generateNativeGuid(storageSystem, portName, NativeGUIDGenerator.PORT);
port.setNativeGuid(nativeGuid);
port.setPortNetworkId(portNetworkId);
port.setStorageHADomain(adapter.getId());
port.setRegistrationStatus(DiscoveredDataObject.RegistrationStatus.REGISTERED.toString());
// always treat it as a frontend port
port.setPortType(PortType.frontend.name());
port.setOperationalStatus(OperationalStatus.OK.toString());
port.setTransportType(transportType);
port.setLabel(portName);
port.setPortName(portName);
port.setPortGroup("Cinder-PortGroup");
port.setCompatibilityStatus(CompatibilityStatus.COMPATIBLE.name());
port.setDiscoveryStatus(DiscoveryStatus.VISIBLE.name());
dbClient.createObject(port);
// Add it to the new ports list
newStoragePortsList.add(port);
// Add it to the local list
allStoragePortsList.add(port);
logger.info(
"End create storage port for portNetworkId={}" + " and transportType={}",
portNetworkId,
transportType);
}
/** Create RP BlockConsistencyGroup objects for each ProtectionSet. */
private void createRpBlockConsistencyGroups() {
DbClient dbClient = this.getDbClient();
List<URI> protectionSetURIs = dbClient.queryByType(ProtectionSet.class, false);
Iterator<ProtectionSet> protectionSets =
dbClient.queryIterativeObjects(ProtectionSet.class, protectionSetURIs);
while (protectionSets.hasNext()) {
ProtectionSet ps = protectionSets.next();
Project project = dbClient.queryObject(Project.class, ps.getProject());
BlockConsistencyGroup cg = new BlockConsistencyGroup();
cg.setId(URIUtil.createId(BlockConsistencyGroup.class));
cg.setLabel(ps.getLabel());
cg.setDeviceName(ps.getLabel());
cg.setType(BlockConsistencyGroup.Types.RP.toString());
cg.setProject(new NamedURI(project.getId(), ps.getLabel()));
cg.setTenant(new NamedURI(project.getTenantOrg().getURI(), ps.getLabel()));
dbClient.createObject(cg);
log.debug(
"Created ConsistencyGroup (id={}) based on ProtectionSet (id={})",
cg.getId().toString(),
ps.getId().toString());
// Organize the volumes by replication set
for (String protectionVolumeID : ps.getVolumes()) {
URI uri = URI.create(protectionVolumeID);
Volume protectionVolume = dbClient.queryObject(Volume.class, uri);
protectionVolume.addConsistencyGroup(cg.getId().toString());
dbClient.persistObject(protectionVolume);
log.debug(
"Volume (id={}) added to ConsistencyGroup (id={})",
protectionVolume.getId().toString(),
cg.getId().toString());
}
}
}
/**
* Convenience method that creates VPlex volumes.
*
* @param name
* @param numberOfVols
* @param storageSystem
* @return
*/
private List<Volume> createVPlexVolumes(String name, int numberOfVols, URI storageSystem) {
List<Volume> volumes = new ArrayList<Volume>();
for (int i = 1; i <= numberOfVols; i++) {
Volume vplexVolume = new Volume();
URI vplexVolumeUri = URIUtil.createId(Volume.class);
vplexVolumeURIs.add(vplexVolumeUri);
vplexVolume.setId(vplexVolumeUri);
vplexVolume.setLabel(name + i);
vplexVolume.setNativeId(
"/clusters/cluster-1/virtual-volumes/device_V000195701573-01E7F_vol" + i);
vplexVolume.setStorageController(storageSystem);
StringSet associatedVolumes = new StringSet();
associatedVolumes.add("associatedVol1");
vplexVolume.setAssociatedVolumes(associatedVolumes);
volumes.add(vplexVolume);
}
return volumes;
}
/**
* create StoragePort Record, if not present already, else update only the properties.
*
* @param port
* @param portInstance
* @throws URISyntaxException
* @throws IOException
*/
private StoragePort createStoragePort(
StoragePort port,
CIMInstance portInstance,
AccessProfile profile,
StorageHADomain haDomain,
boolean flag,
String transportType,
StorageSystem device)
throws URISyntaxException, IOException {
boolean newPort = false;
if (null == port) {
newPort = true;
port = new StoragePort();
port.setId(URIUtil.createId(StoragePort.class));
// if true, then its FC Port or else its Ethernet, PORTID
// or ethernet will be updated later in ProtocolEndPoint Processor
if (flag) {
port.setPortNetworkId(
WWNUtility.getWWNWithColons(getCIMPropertyValue(portInstance, PORTID)));
}
port.setStorageDevice(profile.getSystemId());
String portNativeGuid = NativeGUIDGenerator.generateNativeGuid(_dbClient, port);
port.setNativeGuid(portNativeGuid);
port.setLabel(portNativeGuid);
port.setPortGroup(haDomain.getAdapterName());
port.setStorageHADomain(haDomain.getId());
}
setPortType(port, portInstance);
port.setTransportType(transportType);
port.setPortName(getCIMPropertyValue(portInstance, PORTNAME));
port.setCompatibilityStatus(DiscoveredDataObject.CompatibilityStatus.COMPATIBLE.name());
port.setDiscoveryStatus(DiscoveredDataObject.DiscoveryStatus.VISIBLE.name());
UnsignedInteger16[] operationalStatusCodes =
(UnsignedInteger16[]) portInstance.getPropertyValue(OPERATIONALSTATUS);
OperationalStatus operationalStatus = getPortOperationalStatus(operationalStatusCodes);
if (OperationalStatus.NOT_OK.equals(operationalStatus)) {
_logger.info(
"StoragePort {} operationalStatus is NOT_OK. operationalStatusCodes collected from SMI-S :{}",
port.getId(),
operationalStatusCodes);
} else {
_logger.debug("operationalStatusCodes :{}", operationalStatusCodes);
// there can be multiple statuses. {OK, Online}, {OK, Stopped}
if (operationalStatusCodes != null
&& operationalStatusCodes.length > 1
&& Arrays.asList(operationalStatusCodes).contains(stopped_code)) {
_logger.info(
"StoragePort {} operational status is {OK, Stopped}. operationalStatusCodes :{}",
port.getId(),
operationalStatusCodes);
}
}
port.setOperationalStatus(operationalStatus.name());
String portSpeed = getCIMPropertyValue(portInstance, SPEED);
if (null != portSpeed) {
// SMI returns port speed in bits per sec ?? Is this always true?
Long portSpeedInBitsPerSec = Long.parseLong(portSpeed);
Long portSpeedInGbps = portSpeedInBitsPerSec / GB;
port.setPortSpeed(portSpeedInGbps);
}
setCompatibilityByACLXFlag(device, portInstance, port);
if (flag) {
if (newPort) {
_logger.info("Creating port - {}:{}", port.getLabel(), port.getNativeGuid());
_newPortList.add(port);
} else {
_logger.info("Updating port - {}:{}", port.getLabel(), port.getNativeGuid());
_updatePortList.add(port);
}
}
;
return port;
}
/**
* 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;
}
/**
* Creates the RP source volume/journal and the specified number of target/journal volumes.
*
* @param volumeName
* @param numTargets
*/
private List<Volume> createRpVolumes(
String volumeName, int numTargets, ProtectionSet protectionSet, boolean isRpVPlex) {
List<Volume> volumes = new ArrayList<Volume>();
StringSet associatedVolumes = new StringSet();
associatedVolumes.add("associatedVol1");
StorageSystem storageSystem = null;
if (isRpVPlex) {
storageSystem = createStorageSystem(true);
} else {
storageSystem = createStorageSystem(false);
}
String rsetName = "RSet-" + volumeName;
Volume sourceVolume = new Volume();
URI sourceVolumeURI = URIUtil.createId(Volume.class);
volumes.add(sourceVolume);
sourceVolume.setId(sourceVolumeURI);
sourceVolume.setLabel(volumeName);
sourceVolume.setPersonality(Volume.PersonalityTypes.SOURCE.toString());
sourceVolume.setRSetName(rsetName);
sourceVolume.setProtectionSet(new NamedURI(protectionSet.getId(), sourceVolume.getLabel()));
sourceVolume.setStorageController(storageSystem.getId());
if (isRpVPlex) {
sourceVolume.setAssociatedVolumes(associatedVolumes);
sourceVolume.setNativeId(
"/clusters/cluster-1/virtual-volumes/device_V000195701573-01E7A_vol");
// Create a VPLEX ViPR BlockConsistencyGroup for the source volume
BlockConsistencyGroup sourceVolumeCg =
createBlockConsistencyGroup(
sourceVolume.getLabel() + "-CG", storageSystem.getId(), Types.VPLEX.name(), true);
addVolumeToBlockConsistencyGroup(sourceVolumeCg.getId(), sourceVolume);
rpVplexVolumeToCgMapping.put(sourceVolumeURI, sourceVolumeCg.getId());
} else {
rpVolumeURIs.add(sourceVolumeURI);
}
_dbClient.createObject(sourceVolume);
Volume sourceVolumeJournal = new Volume();
URI sourceVolumeJournalURI = URIUtil.createId(Volume.class);
volumes.add(sourceVolumeJournal);
sourceVolumeJournal.setId(sourceVolumeJournalURI);
sourceVolumeJournal.setLabel(volumeName + RP_SRC_JOURNAL_APPEND);
sourceVolumeJournal.setPersonality(Volume.PersonalityTypes.METADATA.toString());
sourceVolumeJournal.setProtectionSet(
new NamedURI(protectionSet.getId(), sourceVolumeJournal.getLabel()));
sourceVolumeJournal.setStorageController(storageSystem.getId());
if (isRpVPlex) {
sourceVolumeJournal.setAssociatedVolumes(associatedVolumes);
sourceVolumeJournal.setNativeId(
"/clusters/cluster-1/virtual-volumes/device_V000195701573-01E7B_vol");
// Create a VPLEX ViPR BlockConsistencyGroup for the source journal volume
BlockConsistencyGroup sourceVolumeJournalCg =
createBlockConsistencyGroup(
sourceVolumeJournal.getLabel() + "-CG",
storageSystem.getId(),
Types.VPLEX.name(),
true);
addVolumeToBlockConsistencyGroup(sourceVolumeJournalCg.getId(), sourceVolumeJournal);
rpVplexVolumeToCgMapping.put(sourceVolumeJournalURI, sourceVolumeJournalCg.getId());
} else {
rpVolumeURIs.add(sourceVolumeJournalURI);
}
_dbClient.createObject(sourceVolumeJournal);
for (int i = 1; i <= numTargets; i++) {
Volume sourceVolumeTarget = new Volume();
URI sourceVolumeTargetURI = URIUtil.createId(Volume.class);
volumes.add(sourceVolumeTarget);
sourceVolumeTarget.setId(sourceVolumeTargetURI);
sourceVolumeTarget.setLabel(volumeName + RP_TGT_APPEND + "vArray" + i);
sourceVolumeTarget.setPersonality(Volume.PersonalityTypes.TARGET.toString());
sourceVolumeTarget.setRSetName(rsetName);
sourceVolumeTarget.setProtectionSet(
new NamedURI(protectionSet.getId(), sourceVolumeTarget.getLabel()));
sourceVolumeTarget.setStorageController(storageSystem.getId());
if (isRpVPlex) {
sourceVolumeTarget.setAssociatedVolumes(associatedVolumes);
sourceVolumeTarget.setNativeId(
"/clusters/cluster-2/virtual-volumes/device_V000195701573-01E7C_vol" + i);
// Create a VPLEX ViPR BlockConsistencyGroup for the target volume
BlockConsistencyGroup sourceVolumeTargetCg =
createBlockConsistencyGroup(
sourceVolumeTarget.getLabel() + "-CG",
storageSystem.getId(),
Types.VPLEX.name(),
true);
addVolumeToBlockConsistencyGroup(sourceVolumeTargetCg.getId(), sourceVolumeTarget);
rpVplexVolumeToCgMapping.put(sourceVolumeTargetURI, sourceVolumeTargetCg.getId());
} else {
rpVolumeURIs.add(sourceVolumeTargetURI);
}
_dbClient.createObject(sourceVolumeTarget);
Volume sourceVolumeTargetJournal = new Volume();
URI sourceVolumeTargetJournalURI = URIUtil.createId(Volume.class);
volumes.add(sourceVolumeTargetJournal);
sourceVolumeTargetJournal.setId(sourceVolumeTargetJournalURI);
sourceVolumeTargetJournal.setLabel(volumeName + RP_TGT_JOURNAL_APPEND + "vArray" + i);
sourceVolumeTargetJournal.setPersonality(Volume.PersonalityTypes.METADATA.toString());
sourceVolumeTargetJournal.setProtectionSet(
new NamedURI(protectionSet.getId(), sourceVolumeTargetJournal.getLabel()));
sourceVolumeTargetJournal.setStorageController(storageSystem.getId());
if (isRpVPlex) {
sourceVolumeTargetJournal.setAssociatedVolumes(associatedVolumes);
sourceVolumeTargetJournal.setNativeId(
"/clusters/cluster-2/virtual-volumes/device_V000195701573-01ED_vol" + i);
// Create a VPLEX ViPR BlockConsistencyGroup for the source target journal volume
BlockConsistencyGroup sourceVolumeTargetJournalCg =
createBlockConsistencyGroup(
sourceVolumeTargetJournal.getLabel() + "-CG",
storageSystem.getId(),
Types.VPLEX.name(),
true);
addVolumeToBlockConsistencyGroup(
sourceVolumeTargetJournalCg.getId(), sourceVolumeTargetJournal);
rpVplexVolumeToCgMapping.put(
sourceVolumeTargetJournalURI, sourceVolumeTargetJournalCg.getId());
} else {
rpVolumeURIs.add(sourceVolumeTargetJournalURI);
}
_dbClient.createObject(sourceVolumeTargetJournal);
}
return volumes;
}
/**
* Prepares the ProtectionSystem data.
*
* @throws Exception
*/
private void prepareProtectionSystemData() throws Exception {
ProtectionSystem protectionSystem = new ProtectionSystem();
protectionSystemURI = URIUtil.createId(ProtectionSystem.class);
protectionSystem.setId(protectionSystemURI);
_dbClient.createObject(protectionSystem);
}
