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

Example 1 with BlockConsistencyGroup

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

the class RPDeviceController method upgradeRPVPlexToMetroPoint.

/**
 * Upgrades a RP+VPLEX CG to MetroPoint by adding a standby journal to the HA side.
 *
 * Prerequisite: All RSets(volumes) in the CG must have had their HA sides already exported to RP in VPLEX.
 *
 * @param sourceVolume
 *            A single source volume from the CG, we only need one.
 * @param rpSystem
 *            The rpSystem we're using
 */
private void upgradeRPVPlexToMetroPoint(Volume sourceVolume, VirtualPool newVpool, VirtualPool oldVpool, ProtectionSystem rpSystem) {
    // Grab the new standby journal from the CG
    String standbyCopyName = RPHelper.getStandbyProductionCopyName(_dbClient, sourceVolume);
    List<Volume> existingStandbyJournals = RPHelper.findExistingJournalsForCopy(_dbClient, sourceVolume.getConsistencyGroup(), standbyCopyName);
    if (existingStandbyJournals.isEmpty()) {
        _log.error(String.format("Could not find standby journal during upgrade to MetroPoint operation. " + "Expected to find a new standby journal for RP copy [%s]", standbyCopyName));
        throw RecoverPointException.exceptions.cannotFindJournal(String.format("for RP copy [%s]", standbyCopyName));
    }
    Volume standbyProdJournal = existingStandbyJournals.get(0);
    // Add new standby journal
    if (standbyProdJournal != null) {
        _log.info(String.format("Upgrade RP+VPLEX CG to MetroPoint by adding new standby journal [%s] to the CG", standbyProdJournal.getLabel()));
        RecoverPointClient rp = RPHelper.getRecoverPointClient(rpSystem);
        RecoverPointVolumeProtectionInfo protectionInfo = rp.getProtectionInfoForVolume(RPHelper.getRPWWn(sourceVolume.getId(), _dbClient));
        _log.info(String.format("RecoverPointVolumeProtectionInfo [%s] retrieved", protectionInfo.getRpProtectionName()));
        RPCopyRequestParams copyParams = new RPCopyRequestParams();
        copyParams.setCopyVolumeInfo(protectionInfo);
        List<CreateVolumeParams> journaVols = new ArrayList<CreateVolumeParams>();
        CreateVolumeParams journalVolParams = new CreateVolumeParams();
        journalVolParams.setWwn(RPHelper.getRPWWn(standbyProdJournal.getId(), _dbClient));
        journalVolParams.setInternalSiteName(standbyProdJournal.getInternalSiteName());
        journaVols.add(journalVolParams);
        CreateCopyParams standbyProdCopyParams = new CreateCopyParams();
        standbyProdCopyParams.setName(standbyProdJournal.getRpCopyName());
        standbyProdCopyParams.setJournals(journaVols);
        _log.info(String.format("Adding standby journal [%s] to teh RP CG...", standbyProdJournal.getLabel()));
        // TODO BH - Empty, not sure why we need this
        List<CreateRSetParams> rSets = new ArrayList<CreateRSetParams>();
        rp.addStandbyProductionCopy(standbyProdCopyParams, null, rSets, copyParams);
        _log.info("Standby journal added successfully.");
        // TODO Add new Targets if they exist ??
        // Next we need to update the vpool reference of any existing related volumes
        // that were referencing the old vpool.
        // We'll start by getting all source volumes from the ViPR CG
        BlockConsistencyGroup viprCG = _dbClient.queryObject(BlockConsistencyGroup.class, sourceVolume.getConsistencyGroup());
        List<Volume> allSourceVolumesInCG = BlockConsistencyGroupUtils.getActiveVplexVolumesInCG(viprCG, _dbClient, Volume.PersonalityTypes.SOURCE);
        for (Volume sourceVol : allSourceVolumesInCG) {
            // For each source volume, we'll get all the related volumes (Targets, Journals, Backing volumes for
            // VPLEX...etc)
            Set<Volume> allRelatedVolumes = RPHelper.getAllRelatedVolumesForSource(sourceVol.getId(), _dbClient, true, true);
            // If it is, update the reference and persist the change.
            for (Volume rpRelatedVol : allRelatedVolumes) {
                if (rpRelatedVol.getVirtualPool().equals(oldVpool.getId())) {
                    rpRelatedVol.setVirtualPool(newVpool.getId());
                    _dbClient.updateObject(rpRelatedVol);
                    _log.info(String.format("Volume [%s] has had its virtual pool updated to [%s].", rpRelatedVol.getLabel(), newVpool.getLabel()));
                }
            }
        }
    }
}

Example 2 with BlockConsistencyGroup

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

the class RPDeviceController method cgCreateStep.

/**
 * Workflow step method for creating/updating a consistency group.
 *
 * @param rpSystemId
 *            RP system Id
 * @param recommendation
 *            parameters needed to create the CG
 * @param token
 *            the task
 * @return
 * @throws InternalException
 */
public boolean cgCreateStep(URI rpSystemId, List<VolumeDescriptor> volumeDescriptors, String token) throws InternalException {
    RecoverPointClient rp;
    CGRequestParams cgParams = null;
    boolean metropoint = false;
    boolean lockException = false;
    try {
        // Get only the RP volumes from the descriptors.
        List<VolumeDescriptor> sourceVolumeDescriptors = VolumeDescriptor.filterByType(volumeDescriptors, new VolumeDescriptor.Type[] { VolumeDescriptor.Type.RP_SOURCE, VolumeDescriptor.Type.RP_EXISTING_SOURCE, VolumeDescriptor.Type.RP_VPLEX_VIRT_SOURCE }, new VolumeDescriptor.Type[] {});
        WorkflowStepCompleter.stepExecuting(token);
        ProtectionSystem rpSystem = _dbClient.queryObject(ProtectionSystem.class, rpSystemId);
        URI cgId = volumeDescriptors.iterator().next().getCapabilitiesValues().getBlockConsistencyGroup();
        boolean attachAsClean = true;
        for (VolumeDescriptor sourceVolumedescriptor : sourceVolumeDescriptors) {
            Volume sourceVolume = _dbClient.queryObject(Volume.class, sourceVolumedescriptor.getVolumeURI());
            metropoint = RPHelper.isMetroPointVolume(_dbClient, sourceVolume);
            // if this is a change vpool, attachAsClean should be false so that source and target are synchronized
            if (VolumeDescriptor.Type.RP_EXISTING_SOURCE.equals(sourceVolumedescriptor.getType())) {
                attachAsClean = false;
            }
        }
        // Build the CG Request params
        cgParams = getCGRequestParams(volumeDescriptors, rpSystem);
        updateCGParams(cgParams);
        // Validate the source/target volumes before creating a CG.
        validateCGVolumes(volumeDescriptors);
        rp = RPHelper.getRecoverPointClient(rpSystem);
        // Scan the rp sites for volume visibility
        rp.waitForVolumesToBeVisible(cgParams);
        // Before acquiring a lock on the CG we need to ensure that the
        // CG is created. If it hasn't, then the first CGRequestParams
        // to be allowed to pass through needs to have the journals
        // defined.
        // 
        // NOTE: The CG may not yet be created on the RP protection system and
        // that's OK since this might be the first request going in.
        waitForCGToBeCreated(cgId, cgParams);
        // lock around create and delete operations on the same CG
        List<String> lockKeys = new ArrayList<String>();
        lockKeys.add(ControllerLockingUtil.getConsistencyGroupStorageKey(_dbClient, cgId, rpSystem.getId()));
        boolean lockAcquired = _workflowService.acquireWorkflowStepLocks(token, lockKeys, LockTimeoutValue.get(LockType.RP_CG));
        if (!lockAcquired) {
            lockException = true;
            throw DeviceControllerException.exceptions.failedToAcquireLock(lockKeys.toString(), String.format("Create or add volumes to RP consistency group id: %s", cgId.toString()));
        }
        RecoverPointCGResponse response = null;
        // The CG already exists if it contains volumes and is of type RP
        _log.info("Submitting RP Request: " + cgParams);
        BlockConsistencyGroup cg = _dbClient.queryObject(BlockConsistencyGroup.class, cgId);
        // Check to see if the CG has been created in ViPR and on the RP protection system
        boolean cgAlreadyExists = rpCGExists(cg, rp, cgParams.getCgName(), rpSystem.getId());
        if (cgAlreadyExists) {
            // cg exists in both the ViPR db and on the RP system
            _log.info(String.format("RP CG [%s] already exists, adding replication set(s) to it...", cgParams.getCgName()));
            response = rp.addReplicationSetsToCG(cgParams, metropoint, attachAsClean);
        } else {
            _log.info(String.format("RP CG [%s] does not already exist, creating it now and adding replication set(s) to it...", cgParams.getCgName()));
            response = rp.createCG(cgParams, metropoint, attachAsClean);
            // "Turn-on" the consistency group
            cg = _dbClient.queryObject(BlockConsistencyGroup.class, cgParams.getCgUri());
            cg.addSystemConsistencyGroup(rpSystemId.toString(), cgParams.getCgName());
            cg.addConsistencyGroupTypes(Types.RP.name());
        }
        // At this point, always clear the journal provisioning lock on the
        // CG for any concurrent orders that may come in.
        cg.setJournalProvisioningLock(0L);
        _dbClient.updateObject(cg);
        setVolumeConsistencyGroup(volumeDescriptors, cgParams.getCgUri());
        // If this was a vpool Update, now is a good time to update the vpool and Volume information
        if (VolumeDescriptor.getVirtualPoolChangeVolume(volumeDescriptors) != null) {
            Volume volume = _dbClient.queryObject(Volume.class, VolumeDescriptor.getVirtualPoolChangeVolume(volumeDescriptors));
            URI newVpoolURI = getVirtualPoolChangeNewVirtualPool(volumeDescriptors);
            volume.setVirtualPool(newVpoolURI);
            volume.setPersonality(Volume.PersonalityTypes.SOURCE.toString());
            volume.setAccessState(Volume.VolumeAccessState.READWRITE.name());
            volume.setLinkStatus(Volume.LinkStatus.IN_SYNC.name());
            volume.setProtectionController(rpSystemId);
            _dbClient.updateObject(volume);
            // We might need to update the vpools of the backing volumes if this is an RP+VPLEX
            // or MetroPoint change vpool.
            VPlexUtil.updateVPlexBackingVolumeVpools(volume, newVpoolURI, _dbClient);
            // Record Audit operation. (virtualpool change only)
            AuditBlockUtil.auditBlock(_dbClient, OperationTypeEnum.CHANGE_VOLUME_VPOOL, true, AuditLogManager.AUDITOP_END, token);
        }
        // Create the ProtectionSet to contain the CG UID (which is truly unique to the protection system)
        if (response.getCgId() != null) {
            List<ProtectionSet> protectionSets = CustomQueryUtility.queryActiveResourcesByConstraint(_dbClient, ProtectionSet.class, AlternateIdConstraint.Factory.getConstraint(ProtectionSet.class, "protectionId", response.getCgId().toString()));
            ProtectionSet protectionSet = null;
            if (protectionSets.isEmpty()) {
                // A protection set corresponding to the CG does not exist so we need to create one
                protectionSet = createProtectionSet(rpSystem, cgParams, response.getCgId());
            } else {
                // Update the existing protection set. We will only have 1 protection set
                // get the first one.
                protectionSet = protectionSets.get(0);
                protectionSet = updateProtectionSet(protectionSet, cgParams);
            }
            _dbClient.updateObject(protectionSet);
        }
        // Set the CG last created time to now.
        rpSystem.setCgLastCreatedTime(Calendar.getInstance());
        _dbClient.updateObject(rpSystem);
        // Update the workflow state.
        WorkflowStepCompleter.stepSucceded(token);
        // collect and update the protection system statistics to account for
        // the newly created CG.
        _log.info("Collecting RP statistics post CG create.");
        collectRPStatistics(rpSystem);
    } catch (Exception e) {
        if (lockException) {
            List<URI> volUris = VolumeDescriptor.getVolumeURIs(volumeDescriptors);
            ServiceError serviceError = DeviceControllerException.errors.createVolumesAborted(volUris.toString(), e);
            doFailCgCreateStep(volumeDescriptors, cgParams, rpSystemId, token);
            stepFailed(token, serviceError, "cgCreateStep");
        } else {
            doFailCgCreateStep(volumeDescriptors, cgParams, rpSystemId, token);
            stepFailed(token, e, "cgCreateStep");
        }
        return false;
    }
    return true;
}

Example 3 with BlockConsistencyGroup

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

the class RPHelper method cgSourceVolumesContainsAll.

/**
 * Determine if the consistency group's source volumes are represented in the volumeIDs list.
 * Used to figure out if we can perform full CG operations or just partial CG operations.
 *
 * @param dbClient db client
 * @param consistencyGroupUri the BlockConsistencyGroup ID
 * @param volumeIDs volume IDs
 * @return true if volumeIDs contains all of the source volumes in the protection set
 */
public static boolean cgSourceVolumesContainsAll(DbClient dbClient, URI consistencyGroupUri, Collection<URI> volumeIDs) {
    boolean cgSourceVolumesContainsAll = false;
    if (consistencyGroupUri != null) {
        // find all source volumes.
        List<URI> sourceVolumeIDs = new ArrayList<URI>();
        BlockConsistencyGroup cg = dbClient.queryObject(BlockConsistencyGroup.class, consistencyGroupUri);
        _log.info("Inspecting consisency group: " + cg.getLabel() + " to see if request contains all source volumes");
        List<Volume> sourceVolumes = getCgSourceVolumes(consistencyGroupUri, dbClient);
        if (sourceVolumes != null) {
            for (Volume srcVolume : sourceVolumes) {
                sourceVolumeIDs.add(srcVolume.getId());
            }
        }
        // go through all volumes sent in, remove any volumes you find in the source list.
        sourceVolumeIDs.removeAll(volumeIDs);
        if (!sourceVolumeIDs.isEmpty()) {
            _log.info("Found that the volumes requested do not contain all source volumes in the consistency group, namely: " + Joiner.on(',').join(sourceVolumeIDs));
        } else {
            _log.info("Found that all of the source volumes in the consistency group are in the request.");
            cgSourceVolumesContainsAll = true;
        }
    }
    return cgSourceVolumesContainsAll;
}

Example 4 with BlockConsistencyGroup

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

the class VPlexUtil method isVolumeInIngestedCG.

/**
 * Check if the volume is in an ingested VPlex consistency group
 *
 * @param volume The volume to be checked on
 * @param dbClient
 * @return true or false
 */
public static boolean isVolumeInIngestedCG(Volume volume, DbClient dbClient) {
    boolean result = false;
    URI cgUri = volume.getConsistencyGroup();
    if (!NullColumnValueGetter.isNullURI(cgUri)) {
        BlockConsistencyGroup cg = dbClient.queryObject(BlockConsistencyGroup.class, cgUri);
        if (cg != null) {
            if (!cg.getTypes().contains(Types.LOCAL.toString()) && !cg.getTypes().contains(Types.SRDF.toString())) {
                result = true;
            }
        }
    }
    return result;
}

Example 5 with BlockConsistencyGroup

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

the class ControllerLockingUtil method getConsistencyGroupStorageKey.

/**
 * Make a consistencyGroup / storageSystem duple key.
 *
 * @param cgURI
 *            -- consistencyGroup may not exist but cgURI must be non NULL
 * @param storageURI
 *            (could be a Protection System or null)
 * @return
 */
public static String getConsistencyGroupStorageKey(DbClient dbClient, URI cgURI, URI storageURI) {
    BlockConsistencyGroup consistencyGroup = dbClient.queryObject(BlockConsistencyGroup.class, cgURI);
    String storageKey = getStorageKey(dbClient, storageURI);
    if (consistencyGroup != null) {
        return consistencyGroup.getLabel().replaceAll("\\s", "") + DELIMITER + storageKey;
    } else {
        return cgURI.toString() + DELIMITER + storageKey;
    }
}