Search in sources :

Example 6 with CGRequestParams

use of com.emc.storageos.recoverpoint.requests.CGRequestParams in project coprhd-controller by CoprHD.

the class RecoverPointClientIntegrationTest method recreateCGCDPOnly.

public void recreateCGCDPOnly() throws RecoverPointException {
    RecoverPointVolumeProtectionInfo protectionInfo = null;
    try {
        protectionInfo = rpClient.getProtectionInfoForVolume(BourneRPTestProdLUN1WWN);
    } catch (RecoverPointException e) {
        logger.info("Ignore getProtectionInfoForVolume error");
    }
    if (protectionInfo != null) {
        logger.info("Delete previous CG (if it exists)");
        rpClient.deleteCG(protectionInfo);
    }
    logger.info("Create the CG with one replication set");
    // CreateCGRequestParams createCGParams = CreateCGParamsHelper(true, false, 2);
    CGRequestParams createCGParams = createCGParamsHelper(true, false, 1);
    rpClient.createCG(createCGParams, false, false);
}
Also used : RecoverPointVolumeProtectionInfo(com.emc.storageos.recoverpoint.responses.RecoverPointVolumeProtectionInfo) RecoverPointException(com.emc.storageos.recoverpoint.exceptions.RecoverPointException) CGRequestParams(com.emc.storageos.recoverpoint.requests.CGRequestParams)

Example 7 with CGRequestParams

use of com.emc.storageos.recoverpoint.requests.CGRequestParams in project coprhd-controller by CoprHD.

the class RPDeviceController method addStepsForCreateVolumes.

@Override
public String addStepsForCreateVolumes(Workflow workflow, String waitFor, List<VolumeDescriptor> volumeDescriptors, String taskId) throws InternalException {
    // Just grab a legit target volume that already has an assigned protection controller.
    // This will work for all operations, adding, removing, vpool change, etc.
    List<VolumeDescriptor> protectionControllerDescriptors = VolumeDescriptor.filterByType(volumeDescriptors, new VolumeDescriptor.Type[] { VolumeDescriptor.Type.RP_TARGET, VolumeDescriptor.Type.RP_VPLEX_VIRT_TARGET, VolumeDescriptor.Type.RP_EXISTING_PROTECTED_SOURCE, VolumeDescriptor.Type.RP_JOURNAL, VolumeDescriptor.Type.RP_VPLEX_VIRT_JOURNAL }, new VolumeDescriptor.Type[] {});
    // If there are no RP volumes, just return
    if (protectionControllerDescriptors.isEmpty()) {
        _log.info("No RP Steps required");
        return waitFor;
    }
    _log.info("Adding RP steps for create volumes");
    // Determine if this operation only involves adding additional journal capacity
    boolean isJournalAdd = false;
    List<VolumeDescriptor> journalDescriptors = VolumeDescriptor.filterByType(protectionControllerDescriptors, new VolumeDescriptor.Type[] { VolumeDescriptor.Type.RP_JOURNAL, VolumeDescriptor.Type.RP_VPLEX_VIRT_JOURNAL }, new VolumeDescriptor.Type[] {});
    if (!journalDescriptors.isEmpty()) {
        for (VolumeDescriptor journDesc : journalDescriptors) {
            if (journDesc.getCapabilitiesValues().getAddJournalCapacity()) {
                isJournalAdd = true;
                break;
            }
        }
    }
    // Grab any volume from the list so we can grab the protection system, which will be the same for all volumes.
    Volume volume = _dbClient.queryObject(Volume.class, protectionControllerDescriptors.get(0).getVolumeURI());
    ProtectionSystem rpSystem = _dbClient.queryObject(ProtectionSystem.class, volume.getProtectionController());
    // Get only the RP volumes from the descriptors.
    List<VolumeDescriptor> volumeDescriptorsTypeFilter = VolumeDescriptor.filterByType(volumeDescriptors, new VolumeDescriptor.Type[] { VolumeDescriptor.Type.RP_SOURCE, VolumeDescriptor.Type.RP_JOURNAL, VolumeDescriptor.Type.RP_TARGET, VolumeDescriptor.Type.RP_EXISTING_SOURCE, VolumeDescriptor.Type.RP_EXISTING_PROTECTED_SOURCE, VolumeDescriptor.Type.RP_VPLEX_VIRT_SOURCE, VolumeDescriptor.Type.RP_VPLEX_VIRT_TARGET, VolumeDescriptor.Type.RP_VPLEX_VIRT_JOURNAL }, new VolumeDescriptor.Type[] {});
    // If there are no RP volumes, just return
    if (volumeDescriptorsTypeFilter.isEmpty()) {
        return waitFor;
    }
    String lastStep = waitFor;
    try {
        List<VolumeDescriptor> existingProtectedSourceDescriptors = VolumeDescriptor.filterByType(volumeDescriptors, new VolumeDescriptor.Type[] { VolumeDescriptor.Type.RP_EXISTING_PROTECTED_SOURCE }, new VolumeDescriptor.Type[] {});
        boolean executeCreateSteps = true;
        if (!existingProtectedSourceDescriptors.isEmpty() || isJournalAdd) {
            executeCreateSteps = false;
        }
        addExportVolumesSteps(workflow, volumeDescriptorsTypeFilter, waitFor, rpSystem, taskId);
        // Handle creation or updating of the Consistency Group (moved from the Export Workflow)
        // Get the CG Params based on the volume descriptors
        CGRequestParams params = this.getCGRequestParams(volumeDescriptors, rpSystem);
        updateCGParams(params);
        if (isJournalAdd) {
            lastStep = addAddJournalVolumesToCGStep(workflow, volumeDescriptors, params, rpSystem, taskId);
            return lastStep;
        }
        if (executeCreateSteps) {
            _log.info("Adding steps for Create/Update CG...");
            lastStep = addCreateOrUpdateCGStep(workflow, volumeDescriptors, params, rpSystem, taskId);
            lastStep = addPostVolumeCreateSteps(workflow, volumeDescriptors, rpSystem, taskId);
        } else {
            _log.info("Adding steps for Modifying CG...");
            lastStep = addModifyCGStep(workflow, volumeDescriptors, params, rpSystem, taskId);
        }
    } catch (Exception e) {
        doFailAddStep(volumeDescriptorsTypeFilter, taskId, e);
        throw e;
    }
    return lastStep;
}
Also used : VolumeDescriptor(com.emc.storageos.blockorchestrationcontroller.VolumeDescriptor) Volume(com.emc.storageos.db.client.model.Volume) CGRequestParams(com.emc.storageos.recoverpoint.requests.CGRequestParams) ProtectionSystem(com.emc.storageos.db.client.model.ProtectionSystem) InternalException(com.emc.storageos.svcs.errorhandling.resources.InternalException) InternalServerErrorException(com.emc.storageos.svcs.errorhandling.resources.InternalServerErrorException) ControllerException(com.emc.storageos.volumecontroller.ControllerException) LockRetryException(com.emc.storageos.locking.LockRetryException) FunctionalAPIActionFailedException_Exception(com.emc.fapiclient.ws.FunctionalAPIActionFailedException_Exception) URISyntaxException(java.net.URISyntaxException) WorkflowException(com.emc.storageos.workflow.WorkflowException) DatabaseException(com.emc.storageos.db.exceptions.DatabaseException) DeviceControllerException(com.emc.storageos.exceptions.DeviceControllerException) FunctionalAPIInternalError_Exception(com.emc.fapiclient.ws.FunctionalAPIInternalError_Exception) CoordinatorException(com.emc.storageos.coordinator.exceptions.CoordinatorException) RecoverPointException(com.emc.storageos.recoverpoint.exceptions.RecoverPointException)

Example 8 with CGRequestParams

use of com.emc.storageos.recoverpoint.requests.CGRequestParams in project coprhd-controller by CoprHD.

the class RPDeviceController method getCGRequestParams.

/**
 * Create the RP Client consistency group request object based on the incoming prepared volumes.
 *
 * @param volumeDescriptors
 *            volume descriptor objects
 * @param rpSystem
 * @return RP request to create CG
 * @throws DatabaseException
 */
private CGRequestParams getCGRequestParams(List<VolumeDescriptor> volumeDescriptors, ProtectionSystem rpSystem) throws DatabaseException {
    _log.info("Creating CG Request param...");
    // Maps of replication set request objects, where the key is the rset name itself
    Map<String, CreateRSetParams> rsetParamsMap = new HashMap<String, CreateRSetParams>();
    // Maps of the copy request objects, where the key is the copy name itself
    Map<String, CreateCopyParams> copyParamsMap = new HashMap<String, CreateCopyParams>();
    // The parameters we need at the CG Level that we can only get from looking at the Volumes
    Project project = null;
    String cgName = null;
    Set<String> productionCopies = new HashSet<String>();
    BlockConsistencyGroup cg = null;
    String copyMode = null;
    String rpoType = null;
    Long rpoValue = null;
    int maxNumberOfSnapShots = 0;
    Map<URI, Volume> volumeMap = new HashMap<URI, Volume>();
    // Sort the volume descriptors using the natural order of the enum.
    // In this case sort as:
    // SOURCE, TARGET, JOURNAL
    // We want SOURCE volumes to be processed first below to populate the
    // productionCopies in order.
    VolumeDescriptor.sortByType(volumeDescriptors);
    // Next create all of the request objects we need
    for (VolumeDescriptor volumeDescriptor : volumeDescriptors) {
        Volume volume = null;
        if (volumeMap.containsKey(volumeDescriptor.getVolumeURI())) {
            volume = volumeMap.get(volumeDescriptor.getVolumeURI());
        } else {
            volume = _dbClient.queryObject(Volume.class, volumeDescriptor.getVolumeURI());
            volumeMap.put(volume.getId(), volume);
        }
        boolean isMetroPoint = RPHelper.isMetroPointVolume(_dbClient, volume);
        boolean isRPSource = RPHelper.isRPSource(volumeDescriptor);
        boolean isRPTarget = RPHelper.isRPTarget(volumeDescriptor);
        boolean extraParamsGathered = false;
        if (volumeDescriptor.getCapabilitiesValues() != null) {
            maxNumberOfSnapShots = volumeDescriptor.getCapabilitiesValues().getRPMaxSnaps();
        }
        // Set up the source and target volumes in their respective replication sets
        if (isRPSource || isRPTarget) {
            // Gather the extra params we need (once is sufficient)
            if (isRPSource && !extraParamsGathered) {
                project = _dbClient.queryObject(Project.class, volume.getProject());
                cg = _dbClient.queryObject(BlockConsistencyGroup.class, volumeDescriptor.getCapabilitiesValues().getBlockConsistencyGroup());
                cgName = cg.getCgNameOnStorageSystem(rpSystem.getId());
                if (cgName == null) {
                    cgName = CG_NAME_PREFIX + cg.getLabel();
                }
                copyMode = volumeDescriptor.getCapabilitiesValues().getRpCopyMode();
                rpoType = volumeDescriptor.getCapabilitiesValues().getRpRpoType();
                rpoValue = volumeDescriptor.getCapabilitiesValues().getRpRpoValue();
                // Flag so we only grab this information once
                extraParamsGathered = true;
            }
            if (isMetroPoint && isRPSource) {
                // we need to handle metropoint request a bit differently.
                // since the same metro volume will be part of 2 (production) copies in the replication set,
                // we need to fetch the correct internal site names and other site related parameters from the
                // backing volume.
                StringSet backingVolumes = volume.getAssociatedVolumes();
                if (null == backingVolumes || backingVolumes.isEmpty()) {
                    _log.error("VPLEX volume {} has no backend volumes.", volume.forDisplay());
                    throw InternalServerErrorException.internalServerErrors.noAssociatedVolumesForVPLEXVolume(volume.forDisplay());
                }
                for (String backingVolumeStr : backingVolumes) {
                    Volume backingVolume = _dbClient.queryObject(Volume.class, URI.create(backingVolumeStr));
                    CreateVolumeParams volumeParams = populateVolumeParams(volume.getId(), volume.getStorageController(), backingVolume.getVirtualArray(), backingVolume.getInternalSiteName(), true, backingVolume.getRpCopyName(), RPHelper.getRPWWn(volume.getId(), _dbClient), maxNumberOfSnapShots);
                    _log.info(String.format("Creating RSet Param for MetroPoint RP PROD - VOLUME: [%s] Name: [%s]", backingVolume.getLabel(), volume.getRSetName()));
                    populateRsetsMap(rsetParamsMap, volumeParams, volume);
                    productionCopies.add(backingVolume.getRpCopyName());
                }
            } else {
                CreateVolumeParams volumeParams = populateVolumeParams(volume.getId(), volume.getStorageController(), volume.getVirtualArray(), volume.getInternalSiteName(), isRPSource, volume.getRpCopyName(), RPHelper.getRPWWn(volume.getId(), _dbClient), maxNumberOfSnapShots);
                String type = isRPSource ? "PROD" : "TARGET";
                _log.info(String.format("Creating RSet Param for RP %s - VOLUME: [%s] Name: [%s]", type, volume.getLabel(), volume.getRSetName()));
                populateRsetsMap(rsetParamsMap, volumeParams, volume);
                if (isRPSource) {
                    productionCopies.add(volume.getRpCopyName());
                }
            }
        }
        // Set up the journal volumes in the copy objects
        if (volumeDescriptor.getType().equals(VolumeDescriptor.Type.RP_JOURNAL) || volumeDescriptor.getType().equals(VolumeDescriptor.Type.RP_VPLEX_VIRT_JOURNAL)) {
            if (cgName == null) {
                project = _dbClient.queryObject(Project.class, volume.getProject());
                cg = _dbClient.queryObject(BlockConsistencyGroup.class, volumeDescriptor.getCapabilitiesValues().getBlockConsistencyGroup());
                cgName = cg.getCgNameOnStorageSystem(rpSystem.getId());
                if (cgName == null) {
                    cgName = CG_NAME_PREFIX + cg.getLabel();
                }
            }
            CreateVolumeParams volumeParams = populateVolumeParams(volume.getId(), volume.getStorageController(), volume.getVirtualArray(), volume.getInternalSiteName(), RPHelper.isProductionJournal(productionCopies, volume), volume.getRpCopyName(), RPHelper.getRPWWn(volume.getId(), _dbClient), maxNumberOfSnapShots);
            String key = volume.getRpCopyName();
            _log.info(String.format("Creating Copy Param for RP JOURNAL: VOLUME - [%s] Name: [%s]", volume.getLabel(), key));
            if (copyParamsMap.containsKey(key)) {
                copyParamsMap.get(key).getJournals().add(volumeParams);
            } else {
                CreateCopyParams copyParams = new CreateCopyParams();
                copyParams.setName(key);
                copyParams.setJournals(new ArrayList<CreateVolumeParams>());
                copyParams.getJournals().add(volumeParams);
                copyParamsMap.put(key, copyParams);
            }
        }
    }
    // Set up the CG Request
    CGRequestParams cgParams = new CGRequestParams();
    cgParams.setCopies(new ArrayList<CreateCopyParams>());
    cgParams.getCopies().addAll(copyParamsMap.values());
    cgParams.setRsets(new ArrayList<CreateRSetParams>());
    cgParams.getRsets().addAll(rsetParamsMap.values());
    cgParams.setCgName(cgName);
    cgParams.setCgUri(cg.getId());
    cgParams.setProject(project.getId());
    cgParams.setTenant(project.getTenantOrg().getURI());
    CGPolicyParams policyParams = new CGPolicyParams();
    policyParams.setCopyMode(copyMode);
    policyParams.setRpoType(rpoType);
    policyParams.setRpoValue(rpoValue);
    cgParams.setCgPolicy(policyParams);
    _log.info(String.format("CG Request param complete:%n %s", cgParams));
    return cgParams;
}
Also used : VolumeDescriptor(com.emc.storageos.blockorchestrationcontroller.VolumeDescriptor) CreateRSetParams(com.emc.storageos.recoverpoint.requests.CreateRSetParams) HashMap(java.util.HashMap) NamedURI(com.emc.storageos.db.client.model.NamedURI) URI(java.net.URI) AlternateIdConstraint(com.emc.storageos.db.client.constraint.AlternateIdConstraint) ContainmentConstraint(com.emc.storageos.db.client.constraint.ContainmentConstraint) Constraint(com.emc.storageos.db.client.constraint.Constraint) CreateVolumeParams(com.emc.storageos.recoverpoint.requests.CreateVolumeParams) BlockConsistencyGroup(com.emc.storageos.db.client.model.BlockConsistencyGroup) UpdateCGPolicyParams(com.emc.storageos.recoverpoint.requests.UpdateCGPolicyParams) CGPolicyParams(com.emc.storageos.recoverpoint.requests.CGPolicyParams) Project(com.emc.storageos.db.client.model.Project) Volume(com.emc.storageos.db.client.model.Volume) StringSet(com.emc.storageos.db.client.model.StringSet) CGRequestParams(com.emc.storageos.recoverpoint.requests.CGRequestParams) CreateCopyParams(com.emc.storageos.recoverpoint.requests.CreateCopyParams) HashSet(java.util.HashSet)

Aggregations

CGRequestParams (com.emc.storageos.recoverpoint.requests.CGRequestParams)8 RecoverPointException (com.emc.storageos.recoverpoint.exceptions.RecoverPointException)6 FunctionalAPIActionFailedException_Exception (com.emc.fapiclient.ws.FunctionalAPIActionFailedException_Exception)4 FunctionalAPIInternalError_Exception (com.emc.fapiclient.ws.FunctionalAPIInternalError_Exception)4 CoordinatorException (com.emc.storageos.coordinator.exceptions.CoordinatorException)4 ProtectionSystem (com.emc.storageos.db.client.model.ProtectionSystem)4 DatabaseException (com.emc.storageos.db.exceptions.DatabaseException)4 DeviceControllerException (com.emc.storageos.exceptions.DeviceControllerException)4 LockRetryException (com.emc.storageos.locking.LockRetryException)4 InternalException (com.emc.storageos.svcs.errorhandling.resources.InternalException)4 InternalServerErrorException (com.emc.storageos.svcs.errorhandling.resources.InternalServerErrorException)4 ControllerException (com.emc.storageos.volumecontroller.ControllerException)4 WorkflowException (com.emc.storageos.workflow.WorkflowException)4 URISyntaxException (java.net.URISyntaxException)4 VolumeDescriptor (com.emc.storageos.blockorchestrationcontroller.VolumeDescriptor)3 NamedURI (com.emc.storageos.db.client.model.NamedURI)3 URI (java.net.URI)3 ArrayList (java.util.ArrayList)3 AlternateIdConstraint (com.emc.storageos.db.client.constraint.AlternateIdConstraint)2 Constraint (com.emc.storageos.db.client.constraint.Constraint)2