Examples with RPRecommendation com.emc.storageos.volumecontroller.RPRecommendation used on opensource projects

Example 6 with RPRecommendation

use of com.emc.storageos.volumecontroller.RPRecommendation in project coprhd-controller by CoprHD.

the class PlacementTests method testPlacementRpMetropointCdp.

/*
     * MetroPoint placement - 2 local copies, one on each side
     * 
     * NOTE: Force negative MP CDP test by following instructions labeled with "NEGATIVE-TEST"
     */
@Test
public void testPlacementRpMetropointCdp() {
    String[] vmax1FE = { "50:FE:FE:FE:FE:FE:FE:00", "50:FE:FE:FE:FE:FE:FE:01" };
    String[] vmax1BE = { "50:BE:BE:BE:BE:BE:BE:00", "50:BE:BE:BE:BE:BE:BE:01" };
    String[] vmax2FE = { "51:FE:FE:FE:FE:FE:FE:00", "51:FE:FE:FE:FE:FE:FE:01" };
    String[] vmax2BE = { "51:BE:BE:BE:BE:BE:BE:00", "51:BE:BE:BE:BE:BE:BE:01" };
    String[] vmax3FE = { "52:FE:FE:FE:FE:FE:FE:00", "52:FE:FE:FE:FE:FE:FE:01" };
    String[] vmax3BE = { "52:BE:BE:BE:BE:BE:BE:00", "52:BE:BE:BE:BE:BE:BE:01" };
    String[] vnx1FE = { "60:FE:FE:FE:FE:FE:FE:00", "60:FE:FE:FE:FE:FE:FE:01" };
    String[] vnx1BE = { "60:BE:BE:BE:BE:BE:BE:00", "60:BE:BE:BE:BE:BE:BE:01" };
    String[] vnx2FE = { "61:FE:FE:FE:FE:FE:FE:00", "61:FE:FE:FE:FE:FE:FE:01" };
    String[] vnx2BE = { "61:BE:BE:BE:BE:BE:BE:00", "62:BE:BE:BE:BE:BE:BE:01" };
    String[] vnx3FE = { "62:FE:FE:FE:FE:FE:FE:00", "62:FE:FE:FE:FE:FE:FE:01" };
    String[] vnx3BE = { "62:BE:BE:BE:BE:BE:BE:00", "62:BE:BE:BE:BE:BE:BE:01" };
    String[] rp1FE = { "53:FE:FE:FE:FE:FE:FE:00", "53:FE:FE:FE:FE:FE:FE:01" };
    String[] rp2FE = { "54:FE:FE:FE:FE:FE:FE:00", "54:FE:FE:FE:FE:FE:FE:01" };
    String[] rp3FE = { "55:FE:FE:FE:FE:FE:FE:00", "55:FE:FE:FE:FE:FE:FE:01" };
    // vplex1 cluster1
    String[] vplex11FE = { "FE:FE:FE:FE:FE:FE:FE:00", "FE:FE:FE:FE:FE:FE:FE:01" };
    String[] vplex11BE = { "BE:BE:BE:BE:BE:BE:BE:00", "BE:BE:BE:BE:BE:BE:BE:01" };
    // vplex1 cluster2
    String[] vplex12FE = { "FE:FE:FE:FE:FE:FE:FE:02", "FE:FE:FE:FE:FE:FE:FE:03" };
    String[] vplex12BE = { "BE:BE:BE:BE:BE:BE:BE:02", "BE:BE:BE:BE:BE:BE:BE:03" };
    // vplex2 cluster1
    String[] vplex21FE = { "FE:FE:FE:FE:FE:FE:FE:04", "FE:FE:FE:FE:FE:FE:FE:05" };
    String[] vplex21BE = { "BE:BE:BE:BE:BE:BE:BE:04", "BE:BE:BE:BE:BE:BE:BE:05" };
    // Create 3 Virtual Arrays
    VirtualArray srcVarray = PlacementTestUtils.createVirtualArray(_dbClient, "srcVarray");
    VirtualArray haVarray = PlacementTestUtils.createVirtualArray(_dbClient, "haVarray");
    VirtualArray activeTgtVarray = PlacementTestUtils.createVirtualArray(_dbClient, "activeTgtVarray");
    VirtualArray standbyTgtVarray = PlacementTestUtils.createVirtualArray(_dbClient, "standbyTgtVarray");
    // Create Journal Varrays
    VirtualArray srcJournalVarray = PlacementTestUtils.createVirtualArray(_dbClient, "srcJournalVarray");
    VirtualArray haJournalVarray = PlacementTestUtils.createVirtualArray(_dbClient, "haJournalVarray");
    VirtualArray tgtJournalVarray = PlacementTestUtils.createVirtualArray(_dbClient, "tgtJournalVarray");
    // Create network for VPLEX source side
    StringSet sourceConnectedVa = new StringSet();
    sourceConnectedVa.add(srcVarray.getId().toString());
    sourceConnectedVa.add(activeTgtVarray.getId().toString());
    sourceConnectedVa.add(srcJournalVarray.getId().toString());
    // create network for VPLEX HA side
    StringSet haConnectedVa = new StringSet();
    haConnectedVa.add(haVarray.getId().toString());
    haConnectedVa.add(standbyTgtVarray.getId().toString());
    haConnectedVa.add(haJournalVarray.getId().toString());
    Network sourceNetwork = PlacementTestUtils.createNetwork(_dbClient, vplex11FE, "VSAN", "FC+BROCADE", sourceConnectedVa);
    PlacementTestUtils.addEndpoints(_dbClient, sourceNetwork, vplex11BE);
    PlacementTestUtils.addEndpoints(_dbClient, sourceNetwork, rp1FE);
    PlacementTestUtils.addEndpoints(_dbClient, sourceNetwork, rp3FE);
    PlacementTestUtils.addEndpoints(_dbClient, sourceNetwork, vmax1FE);
    PlacementTestUtils.addEndpoints(_dbClient, sourceNetwork, vmax1BE);
    PlacementTestUtils.addEndpoints(_dbClient, sourceNetwork, vmax3FE);
    PlacementTestUtils.addEndpoints(_dbClient, sourceNetwork, vmax3BE);
    PlacementTestUtils.addEndpoints(_dbClient, sourceNetwork, vnx1FE);
    PlacementTestUtils.addEndpoints(_dbClient, sourceNetwork, vnx1BE);
    PlacementTestUtils.addEndpoints(_dbClient, sourceNetwork, vnx3FE);
    PlacementTestUtils.addEndpoints(_dbClient, sourceNetwork, vnx3BE);
    Network haNetwork = PlacementTestUtils.createNetwork(_dbClient, vplex12FE, "VSAN", "FC+BROCADE", haConnectedVa);
    PlacementTestUtils.addEndpoints(_dbClient, haNetwork, vplex12BE);
    PlacementTestUtils.addEndpoints(_dbClient, haNetwork, rp2FE);
    PlacementTestUtils.addEndpoints(_dbClient, haNetwork, vmax2FE);
    PlacementTestUtils.addEndpoints(_dbClient, haNetwork, vmax2BE);
    PlacementTestUtils.addEndpoints(_dbClient, haNetwork, vnx2FE);
    PlacementTestUtils.addEndpoints(_dbClient, haNetwork, vnx2BE);
    // Create 3 storage systems
    StorageSystem vmaxStorageSystem1 = PlacementTestUtils.createStorageSystem(_dbClient, "vmax", "vmax1");
    StorageSystem vmaxStorageSystem2 = PlacementTestUtils.createStorageSystem(_dbClient, "vmax", "vmax2");
    StorageSystem vmaxStorageSystem3 = PlacementTestUtils.createStorageSystem(_dbClient, "vmax", "vmax3");
    StorageSystem vnxStorageSystem1 = PlacementTestUtils.createStorageSystem(_dbClient, "vnxblock", "vnx1");
    StorageSystem vnxStorageSystem2 = PlacementTestUtils.createStorageSystem(_dbClient, "vnxblock", "vnx2");
    StorageSystem vnxStorageSystem3 = PlacementTestUtils.createStorageSystem(_dbClient, "vnxblock", "vnx3");
    // Create two front-end storage ports VMAX1
    List<StoragePort> vmax1Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vmax1FE.length; i++) {
        vmax1Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vmaxStorageSystem1, sourceNetwork, vmax1FE[i], srcVarray, StoragePort.PortType.frontend.name(), "portGroupvmax1" + i, "FE0+FC0" + i));
    }
    // Create two front-end storage ports VMAX1
    vmax1Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vmax1BE.length; i++) {
        vmax1Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vmaxStorageSystem1, sourceNetwork, vmax1BE[i], srcVarray, StoragePort.PortType.backend.name(), "portGroupvmax1" + i, "BE0+FC0" + i));
    }
    // Create two front-end storage ports VMAX2
    List<StoragePort> vmax2Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vmax2FE.length; i++) {
        vmax2Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vmaxStorageSystem2, haNetwork, vmax2FE[i], haVarray, StoragePort.PortType.frontend.name(), "portGroupvmax2" + i, "D0+FC0" + i));
    }
    for (int i = 0; i < vmax2FE.length; i++) {
        vmax2Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vmaxStorageSystem2, haNetwork, vmax2FE[i], standbyTgtVarray, StoragePort.PortType.frontend.name(), "portGroupvmax2" + i, "D0+FC0" + i));
    }
    // Create two front-end storage ports VMAX3
    List<StoragePort> vmax3Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vmax3FE.length; i++) {
        vmax3Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vmaxStorageSystem3, sourceNetwork, vmax3FE[i], srcVarray, StoragePort.PortType.frontend.name(), "portGroupvmax3" + i, "E0+FC0" + i));
    }
    // Create two front-end storage ports VNX1
    List<StoragePort> vnx1Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vnx1FE.length; i++) {
        vnx1Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vnxStorageSystem1, sourceNetwork, vnx1FE[i], srcJournalVarray, StoragePort.PortType.frontend.name(), "portGroupvnx1" + i, "C1+FC1" + i));
    }
    // Create two front-end storage ports VNX2
    List<StoragePort> vnx2Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vnx2FE.length; i++) {
        vnx2Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vnxStorageSystem2, sourceNetwork, vnx2FE[i], haJournalVarray, StoragePort.PortType.frontend.name(), "portGroupvnx2" + i, "D1+FC1" + i));
    }
    // Create two front-end storage ports VNX3
    List<StoragePort> vnx3Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vnx1FE.length; i++) {
        vnx3Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vnxStorageSystem3, sourceNetwork, vnx3FE[i], tgtJournalVarray, StoragePort.PortType.frontend.name(), "portGroupvnx3" + i, "E1+FC1" + i));
    }
    // Create 2 VPLEX storage systems
    StorageSystem vplexStorageSystem1 = PlacementTestUtils.createStorageSystem(_dbClient, "vplex", "vplex1");
    StorageSystem vplexStorageSystem2 = PlacementTestUtils.createStorageSystem(_dbClient, "vplex", "vplex2");
    // Create two back-end storage ports VPLEX1cluster1
    List<StoragePort> fePorts1 = new ArrayList<StoragePort>();
    for (int i = 0; i < vplex11FE.length; i++) {
        fePorts1.add(PlacementTestUtils.createStoragePort(_dbClient, vplexStorageSystem1, sourceNetwork, vplex11FE[i], srcVarray, StoragePort.PortType.frontend.name(), "portGroupFE1-" + (i + 1), "A0+FC0" + i));
    }
    // Create two back-end storage ports VPLEX1cluster1
    List<StoragePort> bePorts1 = new ArrayList<StoragePort>();
    for (int i = 0; i < vplex11BE.length; i++) {
        bePorts1.add(PlacementTestUtils.createStoragePort(_dbClient, vplexStorageSystem1, sourceNetwork, vplex11BE[i], srcVarray, StoragePort.PortType.backend.name(), "portGroupBE1-" + (i + 1), "B0+FC0" + i));
    }
    // Create two front-end storage ports VPLEX1cluster2
    List<StoragePort> fePorts2 = new ArrayList<StoragePort>();
    for (int i = 0; i < vplex12FE.length; i++) {
        fePorts2.add(PlacementTestUtils.createStoragePort(_dbClient, vplexStorageSystem1, haNetwork, vplex12FE[i], haVarray, StoragePort.PortType.frontend.name(), "portGroupFE2-" + (i + 1), "F0+FC0" + i));
    }
    // Create two back-end storage ports VPLEX1cluster2
    List<StoragePort> bePorts2 = new ArrayList<StoragePort>();
    for (int i = 0; i < vplex12BE.length; i++) {
        bePorts2.add(PlacementTestUtils.createStoragePort(_dbClient, vplexStorageSystem1, haNetwork, vplex12BE[i], haVarray, StoragePort.PortType.backend.name(), "portGroupBE2-" + (i + 1), "G0+FC0" + i));
    }
    // List<StoragePort> fePorts3 = new ArrayList<StoragePort>();
    for (int i = 0; i < vplex21FE.length; i++) {
        fePorts1.add(PlacementTestUtils.createStoragePort(_dbClient, vplexStorageSystem2, sourceNetwork, vplex21FE[i], activeTgtVarray, StoragePort.PortType.frontend.name(), "portGroupFE3-" + (i + 1), "H0+FC0" + i));
    }
    // List<StoragePort> bePorts3 = new ArrayList<StoragePort>();
    for (int i = 0; i < vplex21BE.length; i++) {
        bePorts1.add(PlacementTestUtils.createStoragePort(_dbClient, vplexStorageSystem2, sourceNetwork, vplex21BE[i], activeTgtVarray, StoragePort.PortType.backend.name(), "portGroupBE3-" + (i + 1), "I0+FC0" + i));
    }
    // Create RP system
    AbstractChangeTrackingSet<String> wwnSite1 = new StringSet();
    for (int i = 0; i < rp1FE.length; i++) {
        wwnSite1.add(rp1FE[i]);
    }
    StringSetMap initiatorsSiteMap = new StringSetMap();
    initiatorsSiteMap.put("site1", wwnSite1);
    AbstractChangeTrackingSet<String> wwnSite2 = new StringSet();
    for (int i = 0; i < rp2FE.length; i++) {
        wwnSite2.add(rp2FE[i]);
    }
    initiatorsSiteMap.put("site2", wwnSite2);
    AbstractChangeTrackingSet<String> wwnSite3 = new StringSet();
    for (int i = 0; i < rp3FE.length; i++) {
        wwnSite3.add(rp3FE[i]);
    }
    initiatorsSiteMap.put("site3", wwnSite3);
    StringSet storageSystems = new StringSet();
    storageSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site1", "vplex1cluster1"));
    storageSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site1", vnxStorageSystem1.getSerialNumber()));
    storageSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site1", vmaxStorageSystem1.getSerialNumber()));
    // ////////////////////////////////////////////////////////////////
    // NEGATIVE-TEST Step 1/2:
    // Change vmaxStorageSystem3 and vnxStorageSystem3 to site3 visibility below.
    // What this will do is allow site1 to place to site3 as a REMOTE copy but will be invalid for a
    // MP CDP setup as there is no LOCAL copy on the Active Source side.
    // 
    // Need to ensure that the VPLEX is not fronting the Storage Systems, see Step 2/2.
    // 
    // Result: Placement should exhaust it's options and fail.
    // ////////////////////////////////////////////////////////////////
    storageSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site1", vnxStorageSystem3.getSerialNumber()));
    storageSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site1", vmaxStorageSystem3.getSerialNumber()));
    storageSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site2", "vplex1cluster2"));
    storageSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site2", vnxStorageSystem2.getSerialNumber()));
    storageSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site2", vmaxStorageSystem2.getSerialNumber()));
    StringSetMap rpVisibleSystems = new StringSetMap();
    StringSet storageIds = new StringSet();
    storageIds.add(vplexStorageSystem1.getId().toString());
    storageIds.add(vmaxStorageSystem1.getId().toString());
    storageIds.add(vnxStorageSystem1.getId().toString());
    storageIds.add(vmaxStorageSystem3.getId().toString());
    storageIds.add(vnxStorageSystem3.getId().toString());
    rpVisibleSystems.put("site1", storageIds);
    StringSet storageIds2 = new StringSet();
    storageIds2.add(vplexStorageSystem1.getId().toString());
    storageIds2.add(vmaxStorageSystem2.getId().toString());
    storageIds2.add(vnxStorageSystem2.getId().toString());
    rpVisibleSystems.put("site2", storageIds2);
    StringMap siteVolCap = new StringMap();
    siteVolCap.put("site1", "3221225472");
    siteVolCap.put("site2", "3221225472");
    StringMap siteVolCnt = new StringMap();
    siteVolCnt.put("site1", "10");
    siteVolCnt.put("site2", "10");
    ProtectionSystem rpSystem = PlacementTestUtils.createProtectionSystem(_dbClient, "rp", "rp1", "site1", "site2", "site3", "IP", initiatorsSiteMap, storageSystems, rpVisibleSystems, Long.valueOf("3221225472"), Long.valueOf("2"), siteVolCap, siteVolCnt);
    // RP Site Array objects
    RPSiteArray rpSiteArray1 = new RPSiteArray();
    rpSiteArray1.setId(URI.create("rsa1"));
    rpSiteArray1.setStorageSystem(URI.create("vplex1"));
    rpSiteArray1.setRpInternalSiteName("site1");
    rpSiteArray1.setRpProtectionSystem(rpSystem.getId());
    _dbClient.createObject(rpSiteArray1);
    RPSiteArray rpSiteArray2 = new RPSiteArray();
    rpSiteArray2.setId(URI.create("rsa2"));
    rpSiteArray2.setStorageSystem(URI.create("vplex1"));
    rpSiteArray2.setRpInternalSiteName("site2");
    rpSiteArray2.setRpProtectionSystem(rpSystem.getId());
    _dbClient.createObject(rpSiteArray2);
    RPSiteArray rpSiteArray3 = new RPSiteArray();
    rpSiteArray3.setId(URI.create("rsa3"));
    rpSiteArray3.setStorageSystem(URI.create("vplex2"));
    rpSiteArray3.setRpInternalSiteName("site3");
    rpSiteArray3.setRpProtectionSystem(rpSystem.getId());
    _dbClient.createObject(rpSiteArray3);
    // Create a storage pool for vmax1
    StoragePool srcPool1 = PlacementTestUtils.createStoragePool(_dbClient, srcVarray, vmaxStorageSystem1, "SrcPool1", "SrcPool1", Long.valueOf(SIZE_GB * 75), Long.valueOf(SIZE_GB * 150), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax1
    StoragePool srcPool2 = PlacementTestUtils.createStoragePool(_dbClient, srcVarray, vmaxStorageSystem1, "SrcPool2", "SrcPool2", Long.valueOf(SIZE_GB * 75), Long.valueOf(SIZE_GB * 150), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax1
    StoragePool srcPool3 = PlacementTestUtils.createStoragePool(_dbClient, srcVarray, vmaxStorageSystem1, "SrcPool3", "SrcPool3", Long.valueOf(SIZE_GB * 200), Long.valueOf(SIZE_GB * 200), 100, 100, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax2
    StoragePool haPool4 = PlacementTestUtils.createStoragePool(_dbClient, haVarray, vmaxStorageSystem2, "HaPool4", "HaPool4", Long.valueOf(SIZE_GB * 1024), Long.valueOf(SIZE_GB * 1024 * 1024), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax2
    StoragePool haPool5 = PlacementTestUtils.createStoragePool(_dbClient, haVarray, vmaxStorageSystem2, "HaPool5", "HaPool5", Long.valueOf(SIZE_GB * 300), Long.valueOf(SIZE_GB * 300), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax2
    // StoragePool haPool6 = PlacementTestUtils.createStoragePool(_dbClient, haVarray, vmaxStorageSystem2, "Hapool6", "HaPool6",
    // Long.valueOf(1024 * 1024 * 1), Long.valueOf(1024 * 1024 * 1), 100, 100,
    // StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    StoragePool haPool6 = PlacementTestUtils.createStoragePool(_dbClient, haVarray, vmaxStorageSystem3, "Hapool6", "HaPool6", Long.valueOf(SIZE_GB * 100), Long.valueOf(SIZE_GB * 300), 100, 100, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax3
    StoragePool tgtPool7 = PlacementTestUtils.createStoragePool(_dbClient, srcVarray, vmaxStorageSystem3, "TgtPool7", "TgtPool7", Long.valueOf(SIZE_GB * 300), Long.valueOf(SIZE_GB * 300), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax3
    StoragePool tgtPool8 = PlacementTestUtils.createStoragePool(_dbClient, haVarray, vmaxStorageSystem3, "Tgtpool8", "TgtPool8", Long.valueOf(SIZE_GB * 300), Long.valueOf(SIZE_GB * 300), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vnx1
    StoragePool sjPool9 = PlacementTestUtils.createStoragePool(_dbClient, srcJournalVarray, vnxStorageSystem1, "Sjpool9", "SjPool9", Long.valueOf(SIZE_GB * 1024), Long.valueOf(SIZE_GB * 1024 * 1024), 100, 100, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vnx1
    StoragePool hajPool10 = PlacementTestUtils.createStoragePool(_dbClient, haJournalVarray, vnxStorageSystem2, "HaJpool10", "HaJPool10", Long.valueOf(SIZE_GB * 1024), Long.valueOf(SIZE_GB * 1024 * 1024), 100, 100, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vnx1
    StoragePool tjPool11 = PlacementTestUtils.createStoragePool(_dbClient, tgtJournalVarray, vnxStorageSystem3, "Tjpool11", "TjPool11", Long.valueOf(SIZE_GB * 1024), Long.valueOf(SIZE_GB * 1024 * 1024), 100, 100, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create HA vpool
    // haPool6 should never be selected by placement
    VirtualPool haVpool = new VirtualPool();
    haVpool.setId(URI.create("urn:storageos:VirtualPool:11111111-2222-3333-4444-555555555555:vdc1"));
    haVpool.setLabel("haVpool");
    haVpool.setType("block");
    haVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    haVpool.setDriveType(SupportedDriveTypes.FC.name());
    haVpool.setHighAvailability(VirtualPool.HighAvailabilityType.vplex_local.name());
    StringSet matchedPools = new StringSet();
    matchedPools.add(haPool4.getId().toString());
    matchedPools.add(haPool5.getId().toString());
    haVpool.setMatchedStoragePools(matchedPools);
    StringSet virtualArrays1 = new StringSet();
    virtualArrays1.add(haVarray.getId().toString());
    haVpool.setVirtualArrays(virtualArrays1);
    haVpool.setUseMatchedPools(true);
    _dbClient.createObject(haVpool);
    // Create HA Journal Vpool
    VirtualPool haJournalVpool = new VirtualPool();
    haJournalVpool.setId(URI.create("haJournalVpool"));
    haJournalVpool.setLabel("haJournalVpool");
    haJournalVpool.setType("block");
    haJournalVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    // haJournalVpool.setHighAvailability(VirtualPool.HighAvailabilityType.vplex_local.name()); //Uncomment this line to fail placement.
    // haJournalVpool doesnt have a storagesystem that VPLEX can see
    haJournalVpool.setDriveType(SupportedDriveTypes.FC.name());
    matchedPools = new StringSet();
    matchedPools.add(hajPool10.getId().toString());
    haJournalVpool.setMatchedStoragePools(matchedPools);
    StringSet haJournalVarrays = new StringSet();
    haJournalVarrays.add(haJournalVarray.getId().toString());
    haJournalVpool.setVirtualArrays(haJournalVarrays);
    haJournalVpool.setUseMatchedPools(true);
    _dbClient.createObject(haJournalVpool);
    // Create tgt journal vpool
    VirtualPool tgtJournalVpool = new VirtualPool();
    tgtJournalVpool.setId(URI.create("tgtJournalVpool"));
    tgtJournalVpool.setLabel("tgtJournalVpool");
    tgtJournalVpool.setType("block");
    tgtJournalVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    tgtJournalVpool.setDriveType(SupportedDriveTypes.FC.name());
    matchedPools = new StringSet();
    matchedPools.add(tjPool11.getId().toString());
    tgtJournalVpool.setMatchedStoragePools(matchedPools);
    StringSet tgtJournalVarrays = new StringSet();
    tgtJournalVarrays.add(tgtJournalVarray.getId().toString());
    tgtJournalVpool.setVirtualArrays(tgtJournalVarrays);
    tgtJournalVpool.setUseMatchedPools(true);
    _dbClient.createObject(tgtJournalVpool);
    // Create src journal vpool
    VirtualPool srcJournalVpool = new VirtualPool();
    srcJournalVpool.setId(URI.create("srcJournalVpool"));
    srcJournalVpool.setLabel("srcJournalVpool");
    srcJournalVpool.setType("block");
    srcJournalVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    srcJournalVpool.setDriveType(SupportedDriveTypes.FC.name());
    matchedPools = new StringSet();
    matchedPools.add(sjPool9.getId().toString());
    srcJournalVpool.setMatchedStoragePools(matchedPools);
    StringSet srcJournalVarrays = new StringSet();
    srcJournalVarrays.add(srcJournalVarray.getId().toString());
    srcJournalVpool.setVirtualArrays(srcJournalVarrays);
    srcJournalVpool.setUseMatchedPools(true);
    _dbClient.createObject(srcJournalVpool);
    // Create RP MetroPoint active target vpool
    VirtualPool mpActiveTgtVpool = new VirtualPool();
    mpActiveTgtVpool.setId(URI.create("mpTargetVpool"));
    mpActiveTgtVpool.setLabel("mpTargetVpool");
    mpActiveTgtVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    mpActiveTgtVpool.setDriveType(SupportedDriveTypes.FC.name());
    // ////////////////////////////////////////////////////////////////
    // NEGATIVE-TEST Step 2/2:
    // Comment out the below setHighAvailability() line so that this vpool is not
    // fronted by the VPLEX and will need to rely on the Storage System connectivity.
    // 
    // Result: Placement should exhaust it's options and fail.
    // ////////////////////////////////////////////////////////////////
    mpActiveTgtVpool.setHighAvailability(VirtualPool.HighAvailabilityType.vplex_local.name());
    matchedPools = new StringSet();
    matchedPools.add(tgtPool7.getId().toString());
    matchedPools.add(tgtPool8.getId().toString());
    mpActiveTgtVpool.setMatchedStoragePools(matchedPools);
    mpActiveTgtVpool.setUseMatchedPools(true);
    StringSet activeTgtVarrays = new StringSet();
    activeTgtVarrays.add(srcVarray.getId().toString());
    mpActiveTgtVpool.setVirtualArrays(activeTgtVarrays);
    _dbClient.createObject(mpActiveTgtVpool);
    // Create RP MetroPoint standby target vpool
    VirtualPool mpStandbyTgtVpool = new VirtualPool();
    mpStandbyTgtVpool.setId(URI.create("mpStandbyTargetVpool"));
    mpStandbyTgtVpool.setLabel("mpStandbyTargetVpool");
    mpStandbyTgtVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    mpStandbyTgtVpool.setDriveType(SupportedDriveTypes.FC.name());
    // mpTgtVpool.setHighAvailability(VirtualPool.HighAvailabilityType.vplex_local.name());
    matchedPools = new StringSet();
    // matchedPools.add(tgtPool7.getId().toString());
    matchedPools.add(haPool4.getId().toString());
    mpStandbyTgtVpool.setMatchedStoragePools(matchedPools);
    mpStandbyTgtVpool.setUseMatchedPools(true);
    StringSet standbyTgtVarrays = new StringSet();
    standbyTgtVarrays.add(haVarray.getId().toString());
    mpStandbyTgtVpool.setVirtualArrays(standbyTgtVarrays);
    _dbClient.createObject(mpStandbyTgtVpool);
    // Create a RP VPLEX virtual pool
    // srcPool3 should never be chosen during placement
    VirtualPool mpSrcVpool = new VirtualPool();
    mpSrcVpool.setId(URI.create("mpSrcVpool"));
    mpSrcVpool.setLabel("mpSrcVpool");
    mpSrcVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    mpSrcVpool.setDriveType(SupportedDriveTypes.FC.name());
    mpSrcVpool.setHighAvailability(VirtualPool.HighAvailabilityType.vplex_distributed.name());
    matchedPools = new StringSet();
    matchedPools.add(srcPool1.getId().toString());
    matchedPools.add(srcPool2.getId().toString());
    mpSrcVpool.setMatchedStoragePools(matchedPools);
    mpSrcVpool.setUseMatchedPools(true);
    mpSrcVpool.setJournalVarray(srcJournalVarray.getId().toString());
    mpSrcVpool.setJournalVpool(srcJournalVpool.getId().toString());
    mpSrcVpool.setStandbyJournalVarray(haJournalVarray.getId().toString());
    mpSrcVpool.setStandbyJournalVpool(haJournalVpool.getId().toString());
    mpSrcVpool.setJournalSize("2X");
    StringMap vavpMap = new StringMap();
    vavpMap.put(haVarray.getId().toString(), haVpool.getId().toString());
    mpSrcVpool.setHaVarrayVpoolMap(vavpMap);
    mpSrcVpool.setMetroPoint(true);
    // Active Source Local Target
    VpoolProtectionVarraySettings activeProtectionSettings = new VpoolProtectionVarraySettings();
    activeProtectionSettings.setVirtualPool(mpActiveTgtVpool.getId());
    activeProtectionSettings.setJournalVpool(mpActiveTgtVpool.getId());
    activeProtectionSettings.setId(URI.create("activeProtectionSettings"));
    _dbClient.createObject(activeProtectionSettings);
    // Standby Source Local Target
    VpoolProtectionVarraySettings standbyProtectionSettings = new VpoolProtectionVarraySettings();
    standbyProtectionSettings.setVirtualPool(mpStandbyTgtVpool.getId());
    standbyProtectionSettings.setJournalVpool(mpStandbyTgtVpool.getId());
    standbyProtectionSettings.setId(URI.create("standbyProtectionSettings"));
    _dbClient.createObject(standbyProtectionSettings);
    // Define the targets
    StringMap protectionVarray = new StringMap();
    protectionVarray.put(srcVarray.getId().toString(), activeProtectionSettings.getId().toString());
    protectionVarray.put(haVarray.getId().toString(), standbyProtectionSettings.getId().toString());
    mpSrcVpool.setProtectionVarraySettings(protectionVarray);
    mpSrcVpool.setRpCopyMode("SYNCHRONOUS");
    mpSrcVpool.setRpRpoType("MINUTES");
    mpSrcVpool.setRpRpoValue(Long.valueOf("5"));
    StringSet srcVarrays = new StringSet();
    srcVarrays.add(srcVarray.getId().toString());
    mpSrcVpool.setVirtualArrays(srcVarrays);
    _dbClient.createObject(mpSrcVpool);
    // Create Tenant
    TenantOrg tenant = new TenantOrg();
    tenant.setId(URI.create("tenant"));
    _dbClient.createObject(tenant);
    // Create a project object
    Project project = new Project();
    project.setId(URI.create("project"));
    project.setLabel("project");
    project.setTenantOrg(new NamedURI(tenant.getId(), project.getLabel()));
    _dbClient.createObject(project);
    // Create block consistency group
    BlockConsistencyGroup cg = new BlockConsistencyGroup();
    cg.setProject(new NamedURI(project.getId(), project.getLabel()));
    cg.setId(URI.create("blockCG"));
    _dbClient.createObject(cg);
    // Create capabilities
    VirtualPoolCapabilityValuesWrapper capabilities = PlacementTestUtils.createCapabilities("10GB", 13, cg);
    // Run single volume placement: Run 10 times to make sure pool6 never comes up for source and pool9 for target.
    for (int i = 0; i < 10; i++) {
        List recommendations = PlacementTestUtils.invokePlacement(_dbClient, _coordinator, srcVarray, project, mpSrcVpool, capabilities);
        assertNotNull(recommendations);
        assertTrue(!recommendations.isEmpty());
        assertNotNull(recommendations.get(0));
        RPProtectionRecommendation rec = (RPProtectionRecommendation) recommendations.get(0);
        for (RPRecommendation rpRec : rec.getSourceRecommendations()) {
            assertNotNull(rpRec.getVirtualArray());
            assertNotNull(rpRec.getVirtualPool());
            assertNotNull(rpRec.getInternalSiteName());
            assertNotNull(rpRec.getSourceStorageSystem());
            assertNotNull(rpRec.getSourceStoragePool());
            assertTrue("site1".equals(rpRec.getInternalSiteName()));
            assertTrue(vmaxStorageSystem1.getId().toString().equals(rpRec.getSourceStorageSystem().toString()));
            assertTrue((srcPool1.getId().toString().equals(rpRec.getSourceStoragePool().toString())) || (srcPool2.getId().toString().equals(rpRec.getSourceStoragePool().toString())) || (srcPool3.getId().toString().equals(rpRec.getSourceStoragePool().toString())));
            assertNotNull(rpRec.getVirtualVolumeRecommendation());
            assertNotNull(rpRec.getVirtualVolumeRecommendation().getVPlexStorageSystem());
            assertTrue("vplex1".equals(rpRec.getVirtualVolumeRecommendation().getVPlexStorageSystem().toString()));
            assertNotNull(rpRec.getHaRecommendation());
            assertNotNull(rpRec.getHaRecommendation().getInternalSiteName());
            assertTrue("vplex1".equals(rpRec.getHaRecommendation().getVirtualVolumeRecommendation().getVPlexStorageSystem().toString()));
            assertTrue("site2".equals(rpRec.getHaRecommendation().getInternalSiteName()));
            assertTrue(haVarray.getId().toString().equals(rpRec.getHaRecommendation().getVirtualArray().toString()));
            assertTrue("urn:storageos:VirtualPool:11111111-2222-3333-4444-555555555555:vdc1".equals(rpRec.getHaRecommendation().getVirtualPool().getId().toString()));
            assertTrue(vmaxStorageSystem2.getId().toString().equals(rpRec.getHaRecommendation().getSourceStorageSystem().toString()));
            assertTrue((haPool4.getId().toString().equals(rpRec.getHaRecommendation().getSourceStoragePool().toString())) || (haPool5.getId().toString().equals(rpRec.getHaRecommendation().getSourceStoragePool().toString())) || (haPool6.getId().toString().equals(rpRec.getHaRecommendation().getSourceStoragePool().toString())));
            assertNotNull(rpRec.getTargetRecommendations());
            assertTrue(!rpRec.getTargetRecommendations().isEmpty());
            for (RPRecommendation targetRec : rpRec.getTargetRecommendations()) {
                assertNotNull(targetRec.getInternalSiteName());
                assertNotNull(targetRec.getVirtualArray());
                assertNotNull(targetRec.getVirtualPool());
                assertNotNull(targetRec.getSourceStorageSystem());
                assertNotNull(targetRec.getSourceStoragePool());
                if (VirtualPool.vPoolSpecifiesHighAvailability(mpActiveTgtVpool)) {
                    assertNotNull(targetRec.getVirtualVolumeRecommendation());
                    assertNotNull(targetRec.getVirtualVolumeRecommendation().getVPlexStorageSystem());
                    assertTrue(vplexStorageSystem1.getId().toString().equals(targetRec.getVirtualVolumeRecommendation().getVPlexStorageSystem().toString()));
                    assertTrue(vmaxStorageSystem3.getId().toString().equals(targetRec.getSourceStorageSystem().toString()));
                    assertTrue(srcVarray.getId().toString().equals(targetRec.getVirtualArray().toString()));
                    assertTrue("site1".equals(targetRec.getInternalSiteName()));
                    assertTrue(mpActiveTgtVpool.getId().toString().equals(targetRec.getVirtualPool().getId().toString()));
                    assertTrue((tgtPool7.getId().toString().equals(targetRec.getSourceStoragePool().toString())) || (tgtPool8.getId().toString().equals(targetRec.getSourceStoragePool().toString())));
                }
                if (VirtualPool.vPoolSpecifiesHighAvailability(mpStandbyTgtVpool)) {
                    assertNotNull(targetRec.getVirtualVolumeRecommendation());
                    assertNotNull(targetRec.getVirtualVolumeRecommendation().getVPlexStorageSystem());
                    assertTrue(vplexStorageSystem2.getId().toString().equals(targetRec.getVirtualVolumeRecommendation().getVPlexStorageSystem().toString()));
                    assertTrue(vmaxStorageSystem3.getId().toString().equals(targetRec.getSourceStorageSystem().toString()));
                    assertTrue(standbyTgtVarray.getId().toString().equals(targetRec.getVirtualArray().toString()));
                    assertTrue("site2".equals(targetRec.getInternalSiteName()));
                    assertTrue(mpActiveTgtVpool.getId().toString().equals(targetRec.getVirtualPool().getId().toString()));
                    assertTrue((tgtPool7.getId().toString().equals(targetRec.getSourceStoragePool().toString())) || (tgtPool8.getId().toString().equals(targetRec.getSourceStoragePool().toString())));
                }
            }
        }
        // Source journal
        assertNotNull(rec.getSourceJournalRecommendation());
        assertNotNull(rec.getSourceJournalRecommendation().getInternalSiteName());
        assertNotNull(rec.getSourceJournalRecommendation().getSourceStoragePool());
        assertNotNull(rec.getSourceJournalRecommendation().getSourceStorageSystem());
        assertNotNull(rec.getSourceJournalRecommendation().getVirtualArray());
        assertNotNull(rec.getSourceJournalRecommendation().getVirtualPool());
        assertTrue("site1".equals(rec.getSourceJournalRecommendation().getInternalSiteName()));
        assertTrue(vnxStorageSystem1.getId().toString().equals(rec.getSourceJournalRecommendation().getSourceStorageSystem().toString()));
        assertTrue((sjPool9.getId().toString().equals(rec.getSourceJournalRecommendation().getSourceStoragePool().toString())));
        if (VirtualPool.vPoolSpecifiesHighAvailability(srcJournalVpool)) {
            assertNotNull(rec.getSourceJournalRecommendation().getVirtualVolumeRecommendation());
            assertNotNull(rec.getSourceJournalRecommendation().getVirtualVolumeRecommendation().getVPlexStorageSystem());
            assertTrue(vplexStorageSystem1.getId().toString().equals(rec.getSourceJournalRecommendation().getVirtualVolumeRecommendation().getVPlexStorageSystem()));
        }
        // Source HA journal
        assertNotNull(rec.getStandbyJournalRecommendation());
        assertNotNull(rec.getStandbyJournalRecommendation().getInternalSiteName());
        assertNotNull(rec.getStandbyJournalRecommendation().getSourceStoragePool());
        assertNotNull(rec.getStandbyJournalRecommendation().getSourceStorageSystem());
        assertNotNull(rec.getStandbyJournalRecommendation().getVirtualArray());
        assertNotNull(rec.getStandbyJournalRecommendation().getVirtualPool());
        assertTrue("site2".equals(rec.getStandbyJournalRecommendation().getInternalSiteName()));
        assertTrue(vnxStorageSystem2.getId().toString().equals(rec.getStandbyJournalRecommendation().getSourceStorageSystem().toString()));
        assertTrue((hajPool10.getId().toString().equals(rec.getStandbyJournalRecommendation().getSourceStoragePool().toString())));
        if (VirtualPool.vPoolSpecifiesHighAvailability(haJournalVpool)) {
            assertNotNull(rec.getStandbyJournalRecommendation().getVirtualVolumeRecommendation());
            assertNotNull(rec.getStandbyJournalRecommendation().getVirtualVolumeRecommendation().getVPlexStorageSystem());
            assertTrue(vplexStorageSystem1.getId().toString().equals(rec.getStandbyJournalRecommendation().getVirtualVolumeRecommendation().getVPlexStorageSystem()));
        }
        // TargetJournal
        assertNotNull(rec.getTargetJournalRecommendations());
        assertTrue(!rec.getTargetJournalRecommendations().isEmpty());
        for (RPRecommendation targetJournalRec : rec.getTargetJournalRecommendations()) {
            assertNotNull(targetJournalRec);
            assertNotNull(targetJournalRec.getInternalSiteName());
            assertNotNull(targetJournalRec.getSourceStoragePool());
            assertNotNull(targetJournalRec.getSourceStorageSystem());
            assertNotNull(targetJournalRec.getVirtualArray());
            assertNotNull(targetJournalRec.getVirtualPool());
            if (targetJournalRec.getVirtualArray().toString().equals(srcVarray.getId().toString())) {
                assertTrue("site1".equals(targetJournalRec.getInternalSiteName()));
                assertTrue(mpActiveTgtVpool.getId().toString().equals(targetJournalRec.getVirtualPool().getId().toString()));
                assertTrue((tgtPool7.getId().toString().equals(targetJournalRec.getSourceStoragePool().toString())) || haPool4.getId().toString().equals(targetJournalRec.getSourceStoragePool().toString()));
                assertTrue(vmaxStorageSystem3.getId().toString().equals(targetJournalRec.getSourceStorageSystem().toString()));
                if (VirtualPool.vPoolSpecifiesHighAvailability(mpActiveTgtVpool)) {
                    assertNotNull(targetJournalRec.getVirtualVolumeRecommendation());
                    assertNotNull(targetJournalRec.getVirtualVolumeRecommendation().getVPlexStorageSystem());
                    assertTrue(vplexStorageSystem1.getId().toString().equals(targetJournalRec.getVirtualVolumeRecommendation().getVPlexStorageSystem().toString()));
                }
            }
            if (targetJournalRec.getVirtualArray().toString().equals(haVarray.getId().toString())) {
                assertTrue("site2".equals(targetJournalRec.getInternalSiteName()));
                assertTrue(mpStandbyTgtVpool.getId().toString().equals(targetJournalRec.getVirtualPool().getId().toString()));
                assertTrue((haPool4.getId().toString().equals(targetJournalRec.getSourceStoragePool().toString())));
                assertTrue(vmaxStorageSystem2.getId().toString().equals(targetJournalRec.getSourceStorageSystem().toString()));
                if (VirtualPool.vPoolSpecifiesHighAvailability(mpStandbyTgtVpool)) {
                    assertNotNull(targetJournalRec.getVirtualVolumeRecommendation());
                    assertNotNull(targetJournalRec.getVirtualVolumeRecommendation().getVPlexStorageSystem());
                    assertTrue(vplexStorageSystem2.getId().toString().equals(targetJournalRec.getVirtualVolumeRecommendation().getVPlexStorageSystem().toString()));
                }
            }
        }
        _log.info(String.format("Placement results (#%s) : \n %s", i, rec.toString(_dbClient)));
    }
    _log.info("### PASS ###");
}

Example 7 with RPRecommendation

use of com.emc.storageos.volumecontroller.RPRecommendation in project coprhd-controller by CoprHD.

the class PlacementTests method testPlacementRpXIONoVplex.

/**
 * RP placement tests with XIO (no VPLEX)
 */
@Test
public void testPlacementRpXIONoVplex() {
    String[] xio1FE = { "50:FE:FE:FE:FE:FE:FE:00", "50:FE:FE:FE:FE:FE:FE:01" };
    String[] xio2FE = { "51:FE:FE:FE:FE:FE:FE:00", "51:FE:FE:FE:FE:FE:FE:01" };
    String[] xio3FE = { "52:FE:FE:FE:FE:FE:FE:00", "52:FE:FE:FE:FE:FE:FE:01" };
    String[] xio4FE = { "53:FE:FE:FE:FE:FE:FE:00", "53:FE:FE:FE:FE:FE:FE:01" };
    String[] xio5FE = { "54:FE:FE:FE:FE:FE:FE:00", "54:FE:FE:FE:FE:FE:FE:01" };
    String[] xio6FE = { "55:FE:FE:FE:FE:FE:FE:00", "55:FE:FE:FE:FE:FE:FE:01" };
    String[] rp1FE = { "56:FE:FE:FE:FE:FE:FE:00", "56:FE:FE:FE:FE:FE:FE:01" };
    String[] rp2FE = { "57:FE:FE:FE:FE:FE:FE:00", "57:FE:FE:FE:FE:FE:FE:01" };
    // Create 2 Virtual Arrays
    VirtualArray varray1 = PlacementTestUtils.createVirtualArray(_dbClient, "varray1");
    VirtualArray varray2 = PlacementTestUtils.createVirtualArray(_dbClient, "varray2");
    // Create 2 Networks
    StringSet connVA = new StringSet();
    connVA.add(varray1.getId().toString());
    Network network1 = PlacementTestUtils.createNetwork(_dbClient, rp1FE, "VSANSite1", "FC+BROCADE+FE", connVA);
    connVA = new StringSet();
    connVA.add(varray2.getId().toString());
    Network network2 = PlacementTestUtils.createNetwork(_dbClient, rp2FE, "VSANSite2", "FC+CISCO+FE", connVA);
    // Create 6 storage systems
    StorageSystem storageSystem1 = PlacementTestUtils.createStorageSystem(_dbClient, "xtremio", "xtremio1");
    StorageSystem storageSystem2 = PlacementTestUtils.createStorageSystem(_dbClient, "xtremio", "xtremio2");
    StorageSystem storageSystem3 = PlacementTestUtils.createStorageSystem(_dbClient, "xtremio", "xtremio3");
    StorageSystem storageSystem4 = PlacementTestUtils.createStorageSystem(_dbClient, "xtremio", "xtremio4");
    StorageSystem storageSystem5 = PlacementTestUtils.createStorageSystem(_dbClient, "xtremio", "xtremio5");
    StorageSystem storageSystem6 = PlacementTestUtils.createStorageSystem(_dbClient, "xtremio", "xtremio6");
    // Create two front-end storage ports XIO1
    List<StoragePort> xio1Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < xio1FE.length; i++) {
        xio1Ports.add(PlacementTestUtils.createStoragePort(_dbClient, storageSystem1, network1, xio1FE[i], varray1, StoragePort.PortType.frontend.name(), "portGroupSite1xio1" + i, "C0+FC0" + i));
    }
    // Create two front-end storage ports XIO2
    List<StoragePort> xio2Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < xio2FE.length; i++) {
        xio2Ports.add(PlacementTestUtils.createStoragePort(_dbClient, storageSystem2, network1, xio2FE[i], varray1, StoragePort.PortType.frontend.name(), "portGroupSite1xio2" + i, "D0+FC0" + i));
    }
    // Create two front-end storage ports XIO3
    List<StoragePort> xio3Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < xio3FE.length; i++) {
        xio3Ports.add(PlacementTestUtils.createStoragePort(_dbClient, storageSystem3, network1, xio3FE[i], varray1, StoragePort.PortType.frontend.name(), "portGroupSite1xio3" + i, "E0+FC0" + i));
    }
    // Create two front-end storage ports XIO4
    List<StoragePort> xio4Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < xio4FE.length; i++) {
        xio4Ports.add(PlacementTestUtils.createStoragePort(_dbClient, storageSystem4, network2, xio4FE[i], varray2, StoragePort.PortType.frontend.name(), "portGroupSite2xio4" + i, "F0+FC0" + i));
    }
    // Create two front-end storage ports XIO5
    List<StoragePort> xio5Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < xio5FE.length; i++) {
        xio5Ports.add(PlacementTestUtils.createStoragePort(_dbClient, storageSystem5, network2, xio5FE[i], varray2, StoragePort.PortType.frontend.name(), "portGroupSite2xio5" + i, "G0+FC0" + i));
    }
    // Create two front-end storage ports XIO6
    List<StoragePort> xio6Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < xio6FE.length; i++) {
        xio6Ports.add(PlacementTestUtils.createStoragePort(_dbClient, storageSystem6, network2, xio6FE[i], varray2, StoragePort.PortType.frontend.name(), "portGroupSite2xio6" + i, "H0+FC0" + i));
    }
    // Create RP system
    AbstractChangeTrackingSet<String> wwnSite1 = new StringSet();
    for (int i = 0; i < rp1FE.length; i++) {
        wwnSite1.add(rp1FE[i]);
    }
    StringSetMap initiatorsSiteMap = new StringSetMap();
    initiatorsSiteMap.put("site1", wwnSite1);
    AbstractChangeTrackingSet<String> wwnSite2 = new StringSet();
    for (int i = 0; i < rp2FE.length; i++) {
        wwnSite2.add(rp2FE[i]);
    }
    initiatorsSiteMap.put("site2", wwnSite2);
    StringSet storSystems = new StringSet();
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site1", storageSystem1.getSerialNumber()));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site1", storageSystem2.getSerialNumber()));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site1", storageSystem3.getSerialNumber()));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site2", storageSystem4.getSerialNumber()));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site2", storageSystem5.getSerialNumber()));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site2", storageSystem6.getSerialNumber()));
    StringMap siteVolCap = new StringMap();
    siteVolCap.put("site1", "3221225472");
    siteVolCap.put("site2", "3221225472");
    StringMap siteVolCnt = new StringMap();
    siteVolCnt.put("site1", "10");
    siteVolCnt.put("site2", "10");
    ProtectionSystem rpSystem = PlacementTestUtils.createProtectionSystem(_dbClient, "rp", "rp1", "site1", "site2", null, "IP", initiatorsSiteMap, storSystems, null, Long.valueOf("3221225472"), Long.valueOf("2"), siteVolCap, siteVolCnt);
    // RP Site Array objects
    RPSiteArray rpSiteArray1 = new RPSiteArray();
    rpSiteArray1.setId(URI.create("rsa1"));
    rpSiteArray1.setStorageSystem(URI.create("xtremio1"));
    rpSiteArray1.setRpInternalSiteName("site1");
    rpSiteArray1.setRpProtectionSystem(rpSystem.getId());
    _dbClient.createObject(rpSiteArray1);
    RPSiteArray rpSiteArray2 = new RPSiteArray();
    rpSiteArray2.setId(URI.create("rsa2"));
    rpSiteArray2.setStorageSystem(URI.create("xtremio2"));
    rpSiteArray2.setRpInternalSiteName("site1");
    rpSiteArray2.setRpProtectionSystem(rpSystem.getId());
    _dbClient.createObject(rpSiteArray2);
    RPSiteArray rpSiteArray3 = new RPSiteArray();
    rpSiteArray3.setId(URI.create("rsa3"));
    rpSiteArray3.setStorageSystem(URI.create("xtremio3"));
    rpSiteArray3.setRpInternalSiteName("site1");
    rpSiteArray3.setRpProtectionSystem(rpSystem.getId());
    _dbClient.createObject(rpSiteArray3);
    RPSiteArray rpSiteArray4 = new RPSiteArray();
    rpSiteArray4.setId(URI.create("rsa4"));
    rpSiteArray4.setStorageSystem(URI.create("xtremio4"));
    rpSiteArray4.setRpInternalSiteName("site2");
    rpSiteArray4.setRpProtectionSystem(rpSystem.getId());
    _dbClient.createObject(rpSiteArray4);
    RPSiteArray rpSiteArray5 = new RPSiteArray();
    rpSiteArray5.setId(URI.create("rsa5"));
    rpSiteArray5.setStorageSystem(URI.create("xtremio5"));
    rpSiteArray5.setRpInternalSiteName("site2");
    rpSiteArray5.setRpProtectionSystem(rpSystem.getId());
    _dbClient.createObject(rpSiteArray5);
    RPSiteArray rpSiteArray6 = new RPSiteArray();
    rpSiteArray6.setId(URI.create("rsa6"));
    rpSiteArray6.setStorageSystem(URI.create("xtremio6"));
    rpSiteArray6.setRpInternalSiteName("site2");
    rpSiteArray6.setRpProtectionSystem(rpSystem.getId());
    _dbClient.createObject(rpSiteArray6);
    // Create a storage pool for xio1
    StoragePool pool1 = PlacementTestUtils.createStoragePool(_dbClient, varray1, storageSystem1, "pool1", "Pool1", Long.valueOf(1024 * 1024 * 10), Long.valueOf(1024 * 1024 * 10), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for xio2
    StoragePool pool2 = PlacementTestUtils.createStoragePool(_dbClient, varray1, storageSystem2, "pool2", "Pool2", Long.valueOf(1024 * 1024 * 10), Long.valueOf(1024 * 1024 * 10), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for xio3
    StoragePool pool3 = PlacementTestUtils.createStoragePool(_dbClient, varray1, storageSystem3, "pool3", "Pool3", Long.valueOf(1024 * 1024 * 1), Long.valueOf(1024 * 1024 * 1), 100, 100, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for xio4
    StoragePool pool4 = PlacementTestUtils.createStoragePool(_dbClient, varray2, storageSystem4, "pool4", "Pool4", Long.valueOf(1024 * 1024 * 10), Long.valueOf(1024 * 1024 * 10), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for xio5
    StoragePool pool5 = PlacementTestUtils.createStoragePool(_dbClient, varray2, storageSystem5, "pool5", "Pool5", Long.valueOf(1024 * 1024 * 10), Long.valueOf(1024 * 1024 * 10), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for xio6
    StoragePool pool6 = PlacementTestUtils.createStoragePool(_dbClient, varray2, storageSystem6, "pool6", "Pool6", Long.valueOf(1024 * 1024 * 1), Long.valueOf(1024 * 1024 * 1), 100, 100, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a RP virtual pool
    VirtualPool rpVpool = new VirtualPool();
    rpVpool.setId(URI.create("rpVpool"));
    rpVpool.setLabel("rpVpool");
    rpVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    rpVpool.setDriveType(SupportedDriveTypes.FC.name());
    VpoolProtectionVarraySettings protectionSettings = new VpoolProtectionVarraySettings();
    protectionSettings.setVirtualPool(URI.create("vpool"));
    protectionSettings.setId(URI.create("protectionSettings"));
    _dbClient.createObject(protectionSettings);
    List<VpoolProtectionVarraySettings> protectionSettingsList = new ArrayList<VpoolProtectionVarraySettings>();
    protectionSettingsList.add(protectionSettings);
    StringMap protectionVarray = new StringMap();
    protectionVarray.put(varray2.getId().toString(), protectionSettingsList.get(0).getId().toString());
    rpVpool.setProtectionVarraySettings(protectionVarray);
    rpVpool.setRpCopyMode("SYNCHRONOUS");
    rpVpool.setRpRpoType("MINUTES");
    rpVpool.setRpRpoValue(Long.valueOf("5"));
    StringSet matchedPools = new StringSet();
    matchedPools.add(pool1.getId().toString());
    matchedPools.add(pool2.getId().toString());
    matchedPools.add(pool3.getId().toString());
    rpVpool.setMatchedStoragePools(matchedPools);
    rpVpool.setUseMatchedPools(true);
    StringSet virtualArrays1 = new StringSet();
    virtualArrays1.add(varray1.getId().toString());
    rpVpool.setVirtualArrays(virtualArrays1);
    _dbClient.createObject(rpVpool);
    // Create a virtual pool
    VirtualPool vpool = new VirtualPool();
    vpool.setId(URI.create("vpool"));
    vpool.setLabel("vpool");
    vpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    vpool.setDriveType(SupportedDriveTypes.FC.name());
    matchedPools = new StringSet();
    matchedPools.add(pool4.getId().toString());
    matchedPools.add(pool5.getId().toString());
    matchedPools.add(pool6.getId().toString());
    vpool.setMatchedStoragePools(matchedPools);
    vpool.setUseMatchedPools(true);
    StringSet virtualArrays2 = new StringSet();
    virtualArrays2.add(varray2.getId().toString());
    vpool.setVirtualArrays(virtualArrays2);
    _dbClient.createObject(vpool);
    // Create Tenant
    TenantOrg tenant = new TenantOrg();
    tenant.setId(URI.create("tenant"));
    _dbClient.createObject(tenant);
    // Create a project object
    Project project = new Project();
    project.setId(URI.create("project"));
    project.setLabel("project");
    project.setTenantOrg(new NamedURI(tenant.getId(), project.getLabel()));
    _dbClient.createObject(project);
    // Create block consistency group
    BlockConsistencyGroup cg = new BlockConsistencyGroup();
    cg.setProject(new NamedURI(project.getId(), project.getLabel()));
    cg.setId(URI.create("blockCG"));
    _dbClient.createObject(cg);
    // Create capabilities
    VirtualPoolCapabilityValuesWrapper capabilities = PlacementTestUtils.createCapabilities("2GB", 1, cg);
    // Run single volume placement: Run 10 times to make sure pool3 never comes up for source and pool6 for target.
    for (int i = 0; i < 10; i++) {
        List recommendations = PlacementTestUtils.invokePlacement(_dbClient, _coordinator, varray1, project, rpVpool, capabilities);
        assertNotNull(recommendations);
        assertTrue(!recommendations.isEmpty());
        assertNotNull(recommendations.get(0));
        RPProtectionRecommendation rec = (RPProtectionRecommendation) recommendations.get(0);
        assertNotNull(rec.getSourceRecommendations());
        assertTrue(!rec.getSourceRecommendations().isEmpty());
        assertNotNull(rec.getProtectionDevice());
        assertNotNull(rec.getPlacementStepsCompleted().name());
        assertTrue("rp1".equals(rec.getProtectionDevice().toString()));
        for (RPRecommendation sourceRec : rec.getSourceRecommendations()) {
            assertNotNull(sourceRec);
            assertNotNull(sourceRec.getInternalSiteName());
            assertNotNull(sourceRec.getSourceStorageSystem());
            assertNotNull(sourceRec.getSourceStoragePool());
            assertTrue(sourceRec.getVirtualArray().toString().equals("varray1"));
            assertTrue("site1".equals(sourceRec.getInternalSiteName()));
            assertTrue("xtremio2".equals(sourceRec.getSourceStorageSystem().toString()));
            assertTrue(("pool2".equals(sourceRec.getSourceStoragePool().toString())) || ("pool1".equals(sourceRec.getSourceStoragePool().toString())));
            assertNotNull(sourceRec.getTargetRecommendations());
            assertTrue(!sourceRec.getTargetRecommendations().isEmpty());
            for (RPRecommendation targetRec : sourceRec.getTargetRecommendations()) {
                assertNotNull(targetRec.getSourceStoragePool());
                assertTrue("xtremio4".equals(targetRec.getSourceStorageSystem().toString()));
                assertTrue("site2".equals(targetRec.getInternalSiteName()));
                assertTrue(targetRec.getVirtualArray().toString().equals("varray2"));
                assertTrue("pool4".equals(targetRec.getSourceStoragePool().toString()) || "pool5".equals(targetRec.getSourceStoragePool().toString()));
            }
        }
        // source journal
        assertNotNull(rec.getSourceJournalRecommendation());
        assertNotNull(rec.getSourceJournalRecommendation().getSourceStoragePool());
        assertTrue(("pool2".equals(rec.getSourceJournalRecommendation().getSourceStoragePool().toString())) || ("pool1".equals(rec.getSourceJournalRecommendation().getSourceStoragePool().toString())));
        // target journal
        assertNotNull(rec.getTargetJournalRecommendations());
        assertTrue(!rec.getTargetJournalRecommendations().isEmpty());
        for (RPRecommendation targetJournalRec : rec.getTargetJournalRecommendations()) {
            assertNotNull(targetJournalRec.getSourceStoragePool());
            assertTrue(targetJournalRec.getVirtualArray().toString().equals("varray2"));
            assertTrue("pool4".equals(targetJournalRec.getSourceStoragePool().toString()) || "pool5".equals(targetJournalRec.getSourceStoragePool().toString()) || "pool6".equals(targetJournalRec.getSourceStoragePool().toString()));
            assertTrue("site2".equals(targetJournalRec.getInternalSiteName()));
            assertTrue("xtremio4".equals(targetJournalRec.getSourceStorageSystem().toString()) || "xtremio5".equals(targetJournalRec.getSourceStorageSystem().toString()) || "xtremio6".equals(targetJournalRec.getSourceStorageSystem().toString()));
        }
        _log.info(rec.toString(_dbClient));
    }
}

Example 8 with RPRecommendation

use of com.emc.storageos.volumecontroller.RPRecommendation in project coprhd-controller by CoprHD.

the class PlacementTests method testPlacementRpMetropointCrr.

/**
 * Metropoint placement - Single remote copy
 */
@Test
public void testPlacementRpMetropointCrr() {
    String[] vmax1FE = { "50:FE:FE:FE:FE:FE:FE:00", "50:FE:FE:FE:FE:FE:FE:01" };
    String[] vmax1BE = { "50:BE:BE:BE:BE:BE:BE:00", "50:BE:BE:BE:BE:BE:BE:01" };
    String[] vmax2FE = { "51:FE:FE:FE:FE:FE:FE:00", "51:FE:FE:FE:FE:FE:FE:01" };
    String[] vmax2BE = { "51:BE:BE:BE:BE:BE:BE:00", "51:BE:BE:BE:BE:BE:BE:01" };
    String[] vmax3FE = { "52:FE:FE:FE:FE:FE:FE:00", "52:FE:FE:FE:FE:FE:FE:01" };
    String[] vmax3BE = { "52:BE:BE:BE:BE:BE:BE:00", "52:BE:BE:BE:BE:BE:BE:01" };
    String[] vnx1FE = { "60:FE:FE:FE:FE:FE:FE:00", "60:FE:FE:FE:FE:FE:FE:01" };
    String[] vnx1BE = { "60:BE:BE:BE:BE:BE:BE:00", "60:BE:BE:BE:BE:BE:BE:01" };
    String[] vnx2FE = { "61:FE:FE:FE:FE:FE:FE:00", "61:FE:FE:FE:FE:FE:FE:01" };
    String[] vnx2BE = { "61:BE:BE:BE:BE:BE:BE:00", "62:BE:BE:BE:BE:BE:BE:01" };
    String[] vnx3FE = { "62:FE:FE:FE:FE:FE:FE:00", "62:FE:FE:FE:FE:FE:FE:01" };
    String[] vnx3BE = { "62:BE:BE:BE:BE:BE:BE:00", "62:BE:BE:BE:BE:BE:BE:01" };
    String[] rp1FE = { "53:FE:FE:FE:FE:FE:FE:00", "53:FE:FE:FE:FE:FE:FE:01" };
    String[] rp2FE = { "54:FE:FE:FE:FE:FE:FE:00", "54:FE:FE:FE:FE:FE:FE:01" };
    String[] rp3FE = { "55:FE:FE:FE:FE:FE:FE:00", "55:FE:FE:FE:FE:FE:FE:01" };
    // vplex1 cluster1
    String[] vplex1FE = { "FE:FE:FE:FE:FE:FE:FE:00", "FE:FE:FE:FE:FE:FE:FE:01" };
    String[] vplex1BE = { "BE:BE:BE:BE:BE:BE:BE:00", "BE:BE:BE:BE:BE:BE:BE:01" };
    // vplex1 cluster2
    String[] vplex2FE = { "FE:FE:FE:FE:FE:FE:FE:02", "FE:FE:FE:FE:FE:FE:FE:03" };
    String[] vplex2BE = { "BE:BE:BE:BE:BE:BE:BE:02", "BE:BE:BE:BE:BE:BE:BE:03" };
    // vplex2 cluster1
    String[] vplex3FE = { "FE:FE:FE:FE:FE:FE:FE:04", "FE:FE:FE:FE:FE:FE:FE:05" };
    String[] vplex3BE = { "BE:BE:BE:BE:BE:BE:BE:04", "BE:BE:BE:BE:BE:BE:BE:05" };
    // Create 3 Virtual Arrays
    VirtualArray srcVarray = PlacementTestUtils.createVirtualArray(_dbClient, "srcVarray");
    VirtualArray haVarray = PlacementTestUtils.createVirtualArray(_dbClient, "haVarray");
    VirtualArray tgtVarray = PlacementTestUtils.createVirtualArray(_dbClient, "tgtVarray");
    // Create Journal Varrays
    VirtualArray srcJournalVarray = PlacementTestUtils.createVirtualArray(_dbClient, "srcJournalVarray");
    VirtualArray haJournalVarray = PlacementTestUtils.createVirtualArray(_dbClient, "haJournalVarray");
    VirtualArray tgtJournalVarray = PlacementTestUtils.createVirtualArray(_dbClient, "tgtJournalVarray");
    // Create 1 Network
    StringSet connVA = new StringSet();
    connVA.add(srcVarray.getId().toString());
    connVA.add(haVarray.getId().toString());
    connVA.add(tgtVarray.getId().toString());
    connVA.add(srcJournalVarray.getId().toString());
    connVA.add(haJournalVarray.getId().toString());
    connVA.add(tgtJournalVarray.getId().toString());
    Network network = PlacementTestUtils.createNetwork(_dbClient, vplex1FE, "VSAN", "FC+BROCADE", connVA);
    PlacementTestUtils.addEndpoints(_dbClient, network, vplex3BE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vplex3FE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vplex1BE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vplex1FE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vplex2BE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vplex2FE);
    PlacementTestUtils.addEndpoints(_dbClient, network, rp1FE);
    PlacementTestUtils.addEndpoints(_dbClient, network, rp2FE);
    PlacementTestUtils.addEndpoints(_dbClient, network, rp3FE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vmax1FE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vmax1BE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vmax2FE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vmax2BE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vmax3FE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vmax3BE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vnx1FE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vnx1BE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vnx2FE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vnx2BE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vnx3FE);
    PlacementTestUtils.addEndpoints(_dbClient, network, vnx3BE);
    // Create 3 storage systems
    StorageSystem vmaxStorageSystem1 = PlacementTestUtils.createStorageSystem(_dbClient, "vmax", "vmax1");
    StorageSystem vmaxStorageSystem2 = PlacementTestUtils.createStorageSystem(_dbClient, "vmax", "vmax2");
    StorageSystem vmaxStorageSystem3 = PlacementTestUtils.createStorageSystem(_dbClient, "vmax", "vmax3");
    StorageSystem vnxStorageSystem1 = PlacementTestUtils.createStorageSystem(_dbClient, "vnxblock", "vnx1");
    StorageSystem vnxStorageSystem2 = PlacementTestUtils.createStorageSystem(_dbClient, "vnxblock", "vnx2");
    StorageSystem vnxStorageSystem3 = PlacementTestUtils.createStorageSystem(_dbClient, "vnxblock", "vnx3");
    // Create 2 VPLEX storage systems
    StorageSystem vplexStorageSystem1 = PlacementTestUtils.createStorageSystem(_dbClient, "vplex", "vplex1");
    StorageSystem vplexStorageSystem2 = PlacementTestUtils.createStorageSystem(_dbClient, "vplex", "vplex2");
    // Create two front-end storage ports VMAX1
    List<StoragePort> vmax1Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vmax1FE.length; i++) {
        vmax1Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vmaxStorageSystem1, network, vmax1FE[i], srcVarray, StoragePort.PortType.frontend.name(), "portGroupvmax1" + i, "C0+FC0" + i));
    }
    // Create two front-end storage ports VMAX2
    List<StoragePort> vmax2Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vmax2FE.length; i++) {
        vmax2Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vmaxStorageSystem2, network, vmax2FE[i], haVarray, StoragePort.PortType.frontend.name(), "portGroupvmax2" + i, "D0+FC0" + i));
    }
    // Create two front-end storage ports VMAX3
    List<StoragePort> vmax3Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vmax3FE.length; i++) {
        vmax3Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vmaxStorageSystem3, network, vmax3FE[i], tgtVarray, StoragePort.PortType.frontend.name(), "portGroupvmax3" + i, "E0+FC0" + i));
    }
    // Create two front-end storage ports VNX1
    List<StoragePort> vnx1Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vnx1FE.length; i++) {
        vnx1Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vnxStorageSystem1, network, vnx1FE[i], srcJournalVarray, StoragePort.PortType.frontend.name(), "portGroupvnx1" + i, "C1+FC1" + i));
    }
    // Create two front-end storage ports VNX2
    List<StoragePort> vnx2Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vnx2FE.length; i++) {
        vnx2Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vnxStorageSystem2, network, vnx2FE[i], haJournalVarray, StoragePort.PortType.frontend.name(), "portGroupvnx2" + i, "D1+FC1" + i));
    }
    // Create two front-end storage ports VNX3
    List<StoragePort> vnx3Ports = new ArrayList<StoragePort>();
    for (int i = 0; i < vnx1FE.length; i++) {
        vnx3Ports.add(PlacementTestUtils.createStoragePort(_dbClient, vnxStorageSystem3, network, vnx3FE[i], tgtJournalVarray, StoragePort.PortType.frontend.name(), "portGroupvnx3" + i, "E1+FC1" + i));
    }
    // Create two back-end storage ports VPLEX1cluster1
    List<StoragePort> fePorts1 = new ArrayList<StoragePort>();
    for (int i = 0; i < vplex1FE.length; i++) {
        fePorts1.add(PlacementTestUtils.createStoragePort(_dbClient, vplexStorageSystem1, network, vplex1FE[i], srcVarray, StoragePort.PortType.frontend.name(), "portGroupFE1-" + (i + 1), "A0+FC0" + i));
    }
    // Create two back-end storage ports VPLEX1cluster1
    List<StoragePort> bePorts1 = new ArrayList<StoragePort>();
    for (int i = 0; i < vplex1BE.length; i++) {
        bePorts1.add(PlacementTestUtils.createStoragePort(_dbClient, vplexStorageSystem1, network, vplex1BE[i], srcVarray, StoragePort.PortType.backend.name(), "portGroupBE1-" + (i + 1), "B0+FC0" + i));
    }
    // Create two front-end storage ports VPLEX1cluster2
    List<StoragePort> fePorts2 = new ArrayList<StoragePort>();
    for (int i = 0; i < vplex2FE.length; i++) {
        fePorts2.add(PlacementTestUtils.createStoragePort(_dbClient, vplexStorageSystem1, network, vplex2FE[i], haVarray, StoragePort.PortType.frontend.name(), "portGroupFE2-" + (i + 1), "F0+FC0" + i));
    }
    // Create two back-end storage ports VPLEX1cluster2
    List<StoragePort> bePorts2 = new ArrayList<StoragePort>();
    for (int i = 0; i < vplex2BE.length; i++) {
        bePorts2.add(PlacementTestUtils.createStoragePort(_dbClient, vplexStorageSystem1, network, vplex2BE[i], haVarray, StoragePort.PortType.backend.name(), "portGroupBE2-" + (i + 1), "G0+FC0" + i));
    }
    // Create two front-end storage ports VPLEX2cluster1
    List<StoragePort> fePorts3 = new ArrayList<StoragePort>();
    for (int i = 0; i < vplex3FE.length; i++) {
        fePorts3.add(PlacementTestUtils.createStoragePort(_dbClient, vplexStorageSystem2, network, vplex3FE[i], tgtVarray, StoragePort.PortType.frontend.name(), "portGroupFE3-" + (i + 1), "H0+FC0" + i));
    }
    // Create two back-end storage ports VPLEX2cluster1
    List<StoragePort> bePorts3 = new ArrayList<StoragePort>();
    for (int i = 0; i < vplex3BE.length; i++) {
        bePorts3.add(PlacementTestUtils.createStoragePort(_dbClient, vplexStorageSystem2, network, vplex3BE[i], tgtVarray, StoragePort.PortType.backend.name(), "portGroupBE3-" + (i + 1), "I0+FC0" + i));
    }
    // Create RP system
    AbstractChangeTrackingSet<String> wwnSite1 = new StringSet();
    for (int i = 0; i < rp1FE.length; i++) {
        wwnSite1.add(rp1FE[i]);
    }
    StringSetMap initiatorsSiteMap = new StringSetMap();
    initiatorsSiteMap.put("site1", wwnSite1);
    AbstractChangeTrackingSet<String> wwnSite2 = new StringSet();
    for (int i = 0; i < rp2FE.length; i++) {
        wwnSite2.add(rp2FE[i]);
    }
    initiatorsSiteMap.put("site2", wwnSite2);
    AbstractChangeTrackingSet<String> wwnSite3 = new StringSet();
    for (int i = 0; i < rp3FE.length; i++) {
        wwnSite3.add(rp3FE[i]);
    }
    initiatorsSiteMap.put("site3", wwnSite3);
    StringSet storSystems = new StringSet();
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site1", "vplex1cluster1"));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site1", vnxStorageSystem1.getSerialNumber()));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site1", vmaxStorageSystem1.getSerialNumber()));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site2", "vplex1cluster2"));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site2", vnxStorageSystem2.getSerialNumber()));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site2", vmaxStorageSystem2.getSerialNumber()));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site3", "vplex2cluster1"));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site3", vnxStorageSystem3.getSerialNumber()));
    storSystems.add(ProtectionSystem.generateAssociatedStorageSystem("site3", vmaxStorageSystem3.getSerialNumber()));
    StringSetMap rpVisibleSystems = new StringSetMap();
    StringSet storageIds = new StringSet();
    storageIds.add(vplexStorageSystem1.getId().toString());
    storageIds.add(vmaxStorageSystem1.getId().toString());
    storageIds.add(vnxStorageSystem1.getId().toString());
    rpVisibleSystems.put("site1", storageIds);
    StringSet storageIds2 = new StringSet();
    storageIds2.add(vplexStorageSystem1.getId().toString());
    storageIds2.add(vmaxStorageSystem2.getId().toString());
    storageIds2.add(vnxStorageSystem2.getId().toString());
    rpVisibleSystems.put("site2", storageIds2);
    StringSet storageIds3 = new StringSet();
    storageIds3.add(vplexStorageSystem2.getId().toString());
    storageIds3.add(vmaxStorageSystem3.getId().toString());
    storageIds3.add(vnxStorageSystem3.getId().toString());
    rpVisibleSystems.put("site3", storageIds3);
    StringMap siteVolCap = new StringMap();
    siteVolCap.put("site1", "3221225472");
    siteVolCap.put("site2", "3221225472");
    siteVolCap.put("site3", "3221225472");
    StringMap siteVolCnt = new StringMap();
    siteVolCnt.put("site1", "10");
    siteVolCnt.put("site2", "10");
    siteVolCnt.put("site3", "10");
    ProtectionSystem rpSystem = PlacementTestUtils.createProtectionSystem(_dbClient, "rp", "rp1", "site1", "site2", "site3", "IP", initiatorsSiteMap, storSystems, rpVisibleSystems, Long.valueOf("3221225472"), Long.valueOf("2"), siteVolCap, siteVolCnt);
    // RP Site Array objects
    RPSiteArray rpSiteArray1 = new RPSiteArray();
    rpSiteArray1.setId(URI.create("rsa1"));
    rpSiteArray1.setStorageSystem(URI.create("vplex1"));
    rpSiteArray1.setRpInternalSiteName("site1");
    rpSiteArray1.setRpProtectionSystem(rpSystem.getId());
    _dbClient.createObject(rpSiteArray1);
    RPSiteArray rpSiteArray2 = new RPSiteArray();
    rpSiteArray2.setId(URI.create("rsa2"));
    rpSiteArray2.setStorageSystem(URI.create("vplex1"));
    rpSiteArray2.setRpInternalSiteName("site2");
    rpSiteArray2.setRpProtectionSystem(rpSystem.getId());
    _dbClient.createObject(rpSiteArray2);
    RPSiteArray rpSiteArray3 = new RPSiteArray();
    rpSiteArray3.setId(URI.create("rsa3"));
    rpSiteArray3.setStorageSystem(URI.create("vplex2"));
    rpSiteArray3.setRpInternalSiteName("site3");
    rpSiteArray3.setRpProtectionSystem(rpSystem.getId());
    _dbClient.createObject(rpSiteArray3);
    // Create a storage pool for vmax1
    StoragePool srcPool1 = PlacementTestUtils.createStoragePool(_dbClient, srcVarray, vmaxStorageSystem1, "SrcPool1", "SrcPool1", Long.valueOf(1024 * 1024 * 10), Long.valueOf(1024 * 1024 * 10), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax1
    StoragePool srcPool2 = PlacementTestUtils.createStoragePool(_dbClient, srcVarray, vmaxStorageSystem1, "SrcPool2", "SrcPool2", Long.valueOf(1024 * 1024 * 10), Long.valueOf(1024 * 1024 * 10), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax1
    StoragePool srcPool3 = PlacementTestUtils.createStoragePool(_dbClient, srcVarray, vmaxStorageSystem1, "SrcPool3", "SrcPool3", Long.valueOf(1024 * 1024 * 1), Long.valueOf(1024 * 1024 * 1), 100, 100, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax2
    StoragePool haPool4 = PlacementTestUtils.createStoragePool(_dbClient, haVarray, vmaxStorageSystem2, "HaPool4", "HaPool4", Long.valueOf(1024 * 1024 * 1024), Long.valueOf(1024 * 1024 * 10), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax2
    StoragePool haPool5 = PlacementTestUtils.createStoragePool(_dbClient, haVarray, vmaxStorageSystem2, "HaPool5", "HaPool5", Long.valueOf(1024 * 1024 * 10), Long.valueOf(1024 * 1024 * 10), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax2
    StoragePool haPool6 = PlacementTestUtils.createStoragePool(_dbClient, haVarray, vmaxStorageSystem2, "Hapool6", "HaPool6", Long.valueOf(1024 * 1024 * 1), Long.valueOf(1024 * 1024 * 1), 100, 100, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax3
    StoragePool tgtPool7 = PlacementTestUtils.createStoragePool(_dbClient, tgtVarray, vmaxStorageSystem3, "TgtPool7", "TgtPool7", Long.valueOf(1024 * 1024 * 30), Long.valueOf(1024 * 1024 * 10), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vmax3
    StoragePool tgtPool8 = PlacementTestUtils.createStoragePool(_dbClient, tgtVarray, vmaxStorageSystem3, "Tgtpool8", "TgtPool8", Long.valueOf(1024 * 1024 * 30), Long.valueOf(1024 * 1024 * 10), 300, 300, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vnx1
    StoragePool sjPool9 = PlacementTestUtils.createStoragePool(_dbClient, srcJournalVarray, vnxStorageSystem1, "Sjpool9", "SjPool9", Long.valueOf(1024 * 1024 * 1024 * 1), Long.valueOf(1024 * 1024 * 1024 * 1), 100, 100, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vnx1
    StoragePool hajPool10 = PlacementTestUtils.createStoragePool(_dbClient, haJournalVarray, vnxStorageSystem2, "HaJpool10", "HaJPool10", Long.valueOf(1024 * 1024 * 1024), Long.valueOf(1024 * 1024 * 1024 * 1), 100, 100, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create a storage pool for vnx1
    StoragePool tjPool11 = PlacementTestUtils.createStoragePool(_dbClient, tgtJournalVarray, vnxStorageSystem3, "Tjpool11", "TjPool11", Long.valueOf(1024 * 1024 * 1024 * 1), Long.valueOf(1024 * 1024 * 1024 * 1), 100, 100, StoragePool.SupportedResourceTypes.THIN_ONLY.toString());
    // Create HA vpool
    // haPool6 should never be selected by placement
    VirtualPool haVpool = new VirtualPool();
    haVpool.setId(URI.create("urn:storageos:VirtualPool:11111111-2222-3333-4444-555555555555:vdc1"));
    haVpool.setLabel("haVpool");
    haVpool.setType("block");
    haVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    haVpool.setDriveType(SupportedDriveTypes.FC.name());
    haVpool.setHighAvailability(VirtualPool.HighAvailabilityType.vplex_local.name());
    StringSet matchedPools = new StringSet();
    matchedPools.add(haPool4.getId().toString());
    matchedPools.add(haPool5.getId().toString());
    haVpool.setMatchedStoragePools(matchedPools);
    StringSet virtualArrays1 = new StringSet();
    virtualArrays1.add(haVarray.getId().toString());
    haVpool.setVirtualArrays(virtualArrays1);
    haVpool.setUseMatchedPools(true);
    _dbClient.createObject(haVpool);
    // Create HA Journal Vpool
    VirtualPool haJournalVpool = new VirtualPool();
    haJournalVpool.setId(URI.create("haJournalVpool"));
    haJournalVpool.setLabel("haJournalVpool");
    haJournalVpool.setType("block");
    haJournalVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    // haJournalVpool.setHighAvailability(VirtualPool.HighAvailabilityType.vplex_local.name()); //Uncomment this line to fail placement.
    // haJournalVpool doesnt have a storagesystem that VPLEX can see
    haJournalVpool.setDriveType(SupportedDriveTypes.FC.name());
    matchedPools = new StringSet();
    matchedPools.add(hajPool10.getId().toString());
    haJournalVpool.setMatchedStoragePools(matchedPools);
    StringSet haJournalVarrays = new StringSet();
    haJournalVarrays.add(haJournalVarray.getId().toString());
    haJournalVpool.setVirtualArrays(haJournalVarrays);
    haJournalVpool.setUseMatchedPools(true);
    _dbClient.createObject(haJournalVpool);
    // Create tgt journal vpool
    VirtualPool tgtJournalVpool = new VirtualPool();
    tgtJournalVpool.setId(URI.create("tgtJournalVpool"));
    tgtJournalVpool.setLabel("tgtJournalVpool");
    tgtJournalVpool.setType("block");
    tgtJournalVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    tgtJournalVpool.setDriveType(SupportedDriveTypes.FC.name());
    matchedPools = new StringSet();
    matchedPools.add(tjPool11.getId().toString());
    tgtJournalVpool.setMatchedStoragePools(matchedPools);
    StringSet tgtJournalVarrays = new StringSet();
    tgtJournalVarrays.add(tgtJournalVarray.getId().toString());
    tgtJournalVpool.setVirtualArrays(tgtJournalVarrays);
    tgtJournalVpool.setUseMatchedPools(true);
    _dbClient.createObject(tgtJournalVpool);
    // Create src journal vpool
    VirtualPool srcJournalVpool = new VirtualPool();
    srcJournalVpool.setId(URI.create("srcJournalVpool"));
    srcJournalVpool.setLabel("srcJournalVpool");
    srcJournalVpool.setType("block");
    srcJournalVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    srcJournalVpool.setDriveType(SupportedDriveTypes.FC.name());
    matchedPools = new StringSet();
    matchedPools.add(sjPool9.getId().toString());
    srcJournalVpool.setMatchedStoragePools(matchedPools);
    StringSet srcJournalVarrays = new StringSet();
    srcJournalVarrays.add(srcJournalVarray.getId().toString());
    srcJournalVpool.setVirtualArrays(srcJournalVarrays);
    srcJournalVpool.setUseMatchedPools(true);
    _dbClient.createObject(srcJournalVpool);
    // Create RP MetroPoint target vpool
    VirtualPool mpTgtVpool = new VirtualPool();
    mpTgtVpool.setId(URI.create("mpTargetVpool"));
    mpTgtVpool.setLabel("mpTargetVpool");
    mpTgtVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    mpTgtVpool.setDriveType(SupportedDriveTypes.FC.name());
    // mpTgtVpool.setHighAvailability(VirtualPool.HighAvailabilityType.vplex_local.name());
    matchedPools = new StringSet();
    matchedPools.add(tgtPool7.getId().toString());
    matchedPools.add(tgtPool8.getId().toString());
    mpTgtVpool.setMatchedStoragePools(matchedPools);
    mpTgtVpool.setUseMatchedPools(true);
    StringSet tgtVarrays = new StringSet();
    tgtVarrays.add(tgtVarray.getId().toString());
    mpTgtVpool.setVirtualArrays(tgtVarrays);
    _dbClient.createObject(mpTgtVpool);
    // Create a RP VPLEX virtual pool
    // srcPool3 should never be chosen during placement
    VirtualPool mpSrcVpool = new VirtualPool();
    mpSrcVpool.setId(URI.create("mpSrcVpool"));
    mpSrcVpool.setLabel("mpSrcVpool");
    mpSrcVpool.setSupportedProvisioningType(VirtualPool.ProvisioningType.Thin.name());
    mpSrcVpool.setDriveType(SupportedDriveTypes.FC.name());
    mpSrcVpool.setHighAvailability(VirtualPool.HighAvailabilityType.vplex_distributed.name());
    matchedPools = new StringSet();
    matchedPools.add(srcPool1.getId().toString());
    matchedPools.add(srcPool2.getId().toString());
    mpSrcVpool.setMatchedStoragePools(matchedPools);
    mpSrcVpool.setUseMatchedPools(true);
    mpSrcVpool.setJournalVarray(srcJournalVarray.getId().toString());
    mpSrcVpool.setJournalVpool(srcJournalVpool.getId().toString());
    mpSrcVpool.setStandbyJournalVarray(haJournalVarray.getId().toString());
    mpSrcVpool.setStandbyJournalVpool(haJournalVpool.getId().toString());
    mpSrcVpool.setJournalSize("2X");
    StringMap vavpMap = new StringMap();
    vavpMap.put(haVarray.getId().toString(), haVpool.getId().toString());
    mpSrcVpool.setHaVarrayVpoolMap(vavpMap);
    mpSrcVpool.setMetroPoint(true);
    VpoolProtectionVarraySettings protectionSettings = new VpoolProtectionVarraySettings();
    protectionSettings.setVirtualPool(mpTgtVpool.getId());
    protectionSettings.setId(URI.create("protectionSettings"));
    protectionSettings.setJournalVarray(tgtJournalVarray.getId());
    protectionSettings.setJournalVpool(tgtJournalVpool.getId());
    mpSrcVpool.setHaVarrayConnectedToRp(haVarray.getId().toString());
    _dbClient.createObject(protectionSettings);
    List<VpoolProtectionVarraySettings> protectionSettingsList = new ArrayList<VpoolProtectionVarraySettings>();
    protectionSettingsList.add(protectionSettings);
    StringMap protectionVarray = new StringMap();
    protectionVarray.put(tgtVarray.getId().toString(), protectionSettingsList.get(0).getId().toString());
    mpSrcVpool.setProtectionVarraySettings(protectionVarray);
    mpSrcVpool.setRpCopyMode("SYNCHRONOUS");
    mpSrcVpool.setRpRpoType("MINUTES");
    mpSrcVpool.setRpRpoValue(Long.valueOf("5"));
    StringSet srcVarrays = new StringSet();
    srcVarrays.add(srcVarray.getId().toString());
    mpSrcVpool.setVirtualArrays(srcVarrays);
    _dbClient.createObject(mpSrcVpool);
    // Create Tenant
    TenantOrg tenant = new TenantOrg();
    tenant.setId(URI.create("tenant"));
    _dbClient.createObject(tenant);
    // Create a project object
    Project project = new Project();
    project.setId(URI.create("project"));
    project.setLabel("project");
    project.setTenantOrg(new NamedURI(tenant.getId(), project.getLabel()));
    _dbClient.createObject(project);
    // Create block consistency group
    BlockConsistencyGroup cg = new BlockConsistencyGroup();
    cg.setProject(new NamedURI(project.getId(), project.getLabel()));
    cg.setId(URI.create("blockCG"));
    _dbClient.createObject(cg);
    // Create capabilities
    VirtualPoolCapabilityValuesWrapper capabilities = PlacementTestUtils.createCapabilities("2GB", 8, cg);
    // Run single volume placement: Run 10 times to make sure pool6 never comes up for source and pool9 for target.
    for (int i = 0; i < 10; i++) {
        List recommendations = PlacementTestUtils.invokePlacement(_dbClient, _coordinator, srcVarray, project, mpSrcVpool, capabilities);
        assertNotNull(recommendations);
        assertTrue(!recommendations.isEmpty());
        assertNotNull(recommendations.get(0));
        RPProtectionRecommendation rec = (RPProtectionRecommendation) recommendations.get(0);
        for (RPRecommendation rpRec : rec.getSourceRecommendations()) {
            assertNotNull(rpRec.getVirtualArray());
            assertNotNull(rpRec.getVirtualPool());
            assertNotNull(rpRec.getInternalSiteName());
            assertNotNull(rpRec.getSourceStorageSystem());
            assertNotNull(rpRec.getSourceStoragePool());
            assertTrue("site1".equals(rpRec.getInternalSiteName()));
            assertTrue(vmaxStorageSystem1.getId().toString().equals(rpRec.getSourceStorageSystem().toString()));
            assertTrue((srcPool1.getId().toString().equals(rpRec.getSourceStoragePool().toString())) || (srcPool2.getId().toString().equals(rpRec.getSourceStoragePool().toString())) || (srcPool3.getId().toString().equals(rpRec.getSourceStoragePool().toString())));
            assertNotNull(rpRec.getVirtualVolumeRecommendation());
            assertNotNull(rpRec.getVirtualVolumeRecommendation().getVPlexStorageSystem());
            assertTrue("vplex1".equals(rpRec.getVirtualVolumeRecommendation().getVPlexStorageSystem().toString()));
            assertNotNull(rpRec.getHaRecommendation());
            assertNotNull(rpRec.getHaRecommendation().getInternalSiteName());
            assertTrue("vplex1".equals(rpRec.getHaRecommendation().getVirtualVolumeRecommendation().getVPlexStorageSystem().toString()));
            assertTrue("site2".equals(rpRec.getHaRecommendation().getInternalSiteName()));
            assertTrue(haVarray.getId().toString().equals(rpRec.getHaRecommendation().getVirtualArray().toString()));
            assertTrue("urn:storageos:VirtualPool:11111111-2222-3333-4444-555555555555:vdc1".equals(rpRec.getHaRecommendation().getVirtualPool().getId().toString()));
            assertTrue(vmaxStorageSystem2.getId().toString().equals(rpRec.getHaRecommendation().getSourceStorageSystem().toString()));
            assertTrue((haPool4.getId().toString().equals(rpRec.getHaRecommendation().getSourceStoragePool().toString())) || (haPool5.getId().toString().equals(rpRec.getHaRecommendation().getSourceStoragePool().toString())) || (haPool6.getId().toString().equals(rpRec.getHaRecommendation().getSourceStoragePool().toString())));
            assertNotNull(rpRec.getTargetRecommendations());
            assertTrue(!rpRec.getTargetRecommendations().isEmpty());
            for (RPRecommendation targetRec : rpRec.getTargetRecommendations()) {
                assertNotNull(targetRec.getInternalSiteName());
                assertNotNull(targetRec.getVirtualArray());
                assertNotNull(targetRec.getVirtualPool());
                assertNotNull(targetRec.getSourceStorageSystem());
                assertNotNull(targetRec.getSourceStoragePool());
                if (VirtualPool.vPoolSpecifiesHighAvailability(mpTgtVpool)) {
                    assertNotNull(targetRec.getVirtualVolumeRecommendation());
                    assertNotNull(targetRec.getVirtualVolumeRecommendation().getVPlexStorageSystem());
                    assertTrue(vplexStorageSystem2.getId().toString().equals(targetRec.getVirtualVolumeRecommendation().getVPlexStorageSystem()));
                }
                assertTrue(vmaxStorageSystem3.getId().toString().equals(targetRec.getSourceStorageSystem().toString()));
                assertTrue(tgtVarray.getId().toString().equals(targetRec.getVirtualArray().toString()));
                assertTrue("site3".equals(targetRec.getInternalSiteName()));
                assertTrue(mpTgtVpool.getId().toString().equals(targetRec.getVirtualPool().getId().toString()));
                assertTrue((tgtPool7.getId().toString().equals(targetRec.getSourceStoragePool().toString())) || (tgtPool8.getId().toString().equals(targetRec.getSourceStoragePool().toString())));
            }
        }
        // Source journal
        assertNotNull(rec.getSourceJournalRecommendation());
        assertNotNull(rec.getSourceJournalRecommendation().getInternalSiteName());
        assertNotNull(rec.getSourceJournalRecommendation().getSourceStoragePool());
        assertNotNull(rec.getSourceJournalRecommendation().getSourceStorageSystem());
        assertNotNull(rec.getSourceJournalRecommendation().getVirtualArray());
        assertNotNull(rec.getSourceJournalRecommendation().getVirtualPool());
        assertTrue("site1".equals(rec.getSourceJournalRecommendation().getInternalSiteName()));
        assertTrue(vnxStorageSystem1.getId().toString().equals(rec.getSourceJournalRecommendation().getSourceStorageSystem().toString()));
        assertTrue((sjPool9.getId().toString().equals(rec.getSourceJournalRecommendation().getSourceStoragePool().toString())));
        if (VirtualPool.vPoolSpecifiesHighAvailability(srcJournalVpool)) {
            assertNotNull(rec.getSourceJournalRecommendation().getVirtualVolumeRecommendation());
            assertNotNull(rec.getSourceJournalRecommendation().getVirtualVolumeRecommendation().getVPlexStorageSystem());
            assertTrue(vplexStorageSystem1.getId().toString().equals(rec.getSourceJournalRecommendation().getVirtualVolumeRecommendation().getVPlexStorageSystem()));
        }
        // Source HA journal
        assertNotNull(rec.getStandbyJournalRecommendation());
        assertNotNull(rec.getStandbyJournalRecommendation().getInternalSiteName());
        assertNotNull(rec.getStandbyJournalRecommendation().getSourceStoragePool());
        assertNotNull(rec.getStandbyJournalRecommendation().getSourceStorageSystem());
        assertNotNull(rec.getStandbyJournalRecommendation().getVirtualArray());
        assertNotNull(rec.getStandbyJournalRecommendation().getVirtualPool());
        assertTrue("site2".equals(rec.getStandbyJournalRecommendation().getInternalSiteName()));
        assertTrue(vnxStorageSystem2.getId().toString().equals(rec.getStandbyJournalRecommendation().getSourceStorageSystem().toString()));
        assertTrue((hajPool10.getId().toString().equals(rec.getStandbyJournalRecommendation().getSourceStoragePool().toString())));
        if (VirtualPool.vPoolSpecifiesHighAvailability(haJournalVpool)) {
            assertNotNull(rec.getStandbyJournalRecommendation().getVirtualVolumeRecommendation());
            assertNotNull(rec.getStandbyJournalRecommendation().getVirtualVolumeRecommendation().getVPlexStorageSystem());
            assertTrue(vplexStorageSystem1.getId().toString().equals(rec.getStandbyJournalRecommendation().getVirtualVolumeRecommendation().getVPlexStorageSystem()));
        }
        // TargetJournal
        assertNotNull(rec.getTargetJournalRecommendations());
        assertTrue(!rec.getTargetJournalRecommendations().isEmpty());
        for (RPRecommendation targetJournalRec : rec.getTargetJournalRecommendations()) {
            assertNotNull(targetJournalRec);
            assertNotNull(targetJournalRec.getInternalSiteName());
            assertNotNull(targetJournalRec.getSourceStoragePool());
            assertNotNull(targetJournalRec.getSourceStorageSystem());
            assertNotNull(targetJournalRec.getVirtualArray());
            assertNotNull(targetJournalRec.getVirtualPool());
            assertTrue("site3".equals(targetJournalRec.getInternalSiteName()));
            assertTrue(vnxStorageSystem3.getId().toString().equals(targetJournalRec.getSourceStorageSystem().toString()));
            assertTrue((tjPool11.getId().toString().equals(targetJournalRec.getSourceStoragePool().toString())));
            if (VirtualPool.vPoolSpecifiesHighAvailability(tgtJournalVpool)) {
                assertNotNull(targetJournalRec.getVirtualVolumeRecommendation());
                assertNotNull(targetJournalRec.getVirtualVolumeRecommendation().getVPlexStorageSystem());
                assertTrue(vplexStorageSystem2.getId().toString().equals(targetJournalRec.getVirtualVolumeRecommendation().getVPlexStorageSystem()));
            }
        }
        _log.info(String.format("Placement results (#%s) : \n %s", i, rec.toString(_dbClient)));
    }
    _log.info("### PASS ###");
}

Example 9 with RPRecommendation

use of com.emc.storageos.volumecontroller.RPRecommendation in project coprhd-controller by CoprHD.

the class RecoverPointScheduler method findSolution.

/**
 * Placement method that assembles recommendation objects based on the vpool and protection varrays.
 * Recursive: peels off one protectionVarray to hopefully assemble one Protection object within the recommendation object, then calls
 * itself
 * with the remainder of the protectionVarrays. If it fails to find a Protection for that protectionVarray, it returns failure and puts
 * the
 * protectionVarray back on the list.
 *
 * @param rpProtectionRecommendation - Top level RP recommendation
 * @param sourceRecommendation - Source Recommendation against which we need to find the solution for targets
 * @param varray - Source Virtual Array
 * @param vpool - Source Virtual Pool
 * @param targetVarrays - List of protection Virtual Arrays
 * @param capabilities - Virtual Pool capabilities
 * @param requestedCount - Resource count desired
 * @param isMetroPoint - Boolean indicating whether this is MetroPoint
 * @param activeSourceRecommendation - Primary Recommendation in case of MetroPoint. This field is null except for when we are finding
 *            solution for MP standby
 * @param project - Project
 * @return - True if protection solution was found, false otherwise.
 */
private boolean findSolution(RPProtectionRecommendation rpProtectionRecommendation, RPRecommendation sourceRecommendation, VirtualArray varray, VirtualPool vpool, List<VirtualArray> targetVarrays, VirtualPoolCapabilityValuesWrapper capabilities, int requestedCount, boolean isMetroPoint, RPRecommendation activeSourceRecommendation, Project project) {
    if (targetVarrays.isEmpty()) {
        _log.info("RP Placement : Could not find target solution because there are no protection virtual arrays specified.");
        return false;
    }
    // Find the virtual pool that applies to this protection virtual array
    // We are recursively calling into "findSolution", so pop the next protectionVarray off the top of the
    // passed in list of protectionVarrays. This protectionVarray will be removed from the list before
    // recursively calling back into the method (in the case that we do not find a solution).
    VirtualArray targetVarray = targetVarrays.get(0);
    placementStatus.getProcessedProtectionVArrays().put(targetVarray.getId(), true);
    // Find the correct target vpool. It is either implicitly the same as the source vpool or has been
    // explicitly set by the user.
    VpoolProtectionVarraySettings protectionSettings = RPHelper.getProtectionSettings(vpool, targetVarray, dbClient);
    // If there was no vpool specified with the protection settings, use the base vpool for this varray.
    VirtualPool targetVpool = vpool;
    if (protectionSettings.getVirtualPool() != null) {
        targetVpool = dbClient.queryObject(VirtualPool.class, protectionSettings.getVirtualPool());
    }
    _log.info("RP Placement : Determining placement on protection varray : " + targetVarray.getLabel());
    // Find matching pools for the protection varray
    VirtualPoolCapabilityValuesWrapper newCapabilities = new VirtualPoolCapabilityValuesWrapper(capabilities);
    newCapabilities.put(VirtualPoolCapabilityValuesWrapper.RESOURCE_COUNT, requestedCount);
    List<Recommendation> targetPoolRecommendations = new ArrayList<Recommendation>();
    // If MP remote target is specified, fetch the target recommendation from the active when looking at the standby side.
    if (isMetroPoint && activeSourceRecommendation != null && isMetroPointProtectionSpecified(activeSourceRecommendation, ProtectionType.REMOTE)) {
        StringBuffer unusedTargets = new StringBuffer();
        Recommendation targetPoolRecommendation = new Recommendation();
        for (RPRecommendation targetRec : activeSourceRecommendation.getTargetRecommendations()) {
            if (targetVarray.getId().equals(targetRec.getVirtualArray())) {
                targetPoolRecommendation.setSourceStoragePool(targetRec.getSourceStoragePool());
                targetPoolRecommendation.setSourceStorageSystem(targetRec.getSourceStorageSystem());
                targetPoolRecommendations.add(targetPoolRecommendation);
                break;
            } else {
                unusedTargets.append(targetRec.getVirtualArray().toString());
                unusedTargets.append(" ");
            }
        }
        // we need to kick out and continue on.
        if (targetPoolRecommendations.isEmpty()) {
            _log.warn(String.format("RP Placement : Could not find a MetroPoint CRR Solution because the" + " Active and Standby Copies could not find a common Target varray. " + "Active Target varrays [ %s] - Standby Target varray [ %s ]. " + "Reason: This might not be a MetroPoint CRR config. Please check the vpool config and " + "the RecoverPoint Protection System for the connectivity of the varrays.", unusedTargets.toString(), targetVarray.getId()));
            return false;
        }
    } else {
        // Get target pool recommendations. Each recommendation also specifies the resource
        // count that the pool can satisfy based on the size requested.
        targetPoolRecommendations = getRecommendedPools(rpProtectionRecommendation, targetVarray, targetVpool, null, null, newCapabilities, RPHelper.TARGET, null);
        if (targetPoolRecommendations.isEmpty()) {
            _log.error(String.format("RP Placement : No matching storage pools found for the source varray: [%s]. " + "There are no storage pools that match the passed vpool parameters and protocols and/or there are no pools that have " + "enough capacity to hold at least one resource of the requested size.", varray.getLabel()));
            throw APIException.badRequests.noMatchingStoragePoolsForVpoolAndVarray(vpool.getLabel(), varray.getLabel());
        }
    }
    // Find the correct target journal varray. It is either implicitly the same as the target varray or has been
    // explicitly set by the user.
    VirtualArray targetJournalVarray = targetVarray;
    if (!NullColumnValueGetter.isNullURI(protectionSettings.getJournalVarray())) {
        targetJournalVarray = dbClient.queryObject(VirtualArray.class, protectionSettings.getJournalVarray());
    }
    // Find the correct target journal vpool. It is either implicitly the same as the target vpool or has been
    // explicitly set by the user.
    VirtualPool targetJournalVpool = targetVpool;
    if (!NullColumnValueGetter.isNullURI(protectionSettings.getJournalVpool())) {
        targetJournalVpool = dbClient.queryObject(VirtualPool.class, protectionSettings.getJournalVpool());
    }
    Iterator<Recommendation> targetPoolRecommendationsIter = targetPoolRecommendations.iterator();
    while (targetPoolRecommendationsIter.hasNext()) {
        Recommendation targetPoolRecommendation = targetPoolRecommendationsIter.next();
        StoragePool candidateTargetPool = dbClient.queryObject(StoragePool.class, targetPoolRecommendation.getSourceStoragePool());
        List<String> associatedStorageSystems = getCandidateTargetVisibleStorageSystems(rpProtectionRecommendation.getProtectionDevice(), targetVarray, sourceRecommendation.getInternalSiteName(), candidateTargetPool, VirtualPool.vPoolSpecifiesHighAvailability(targetVpool));
        if (associatedStorageSystems.isEmpty()) {
            _log.info(String.format("RP Placement : Solution cannot be found using target pool %s" + " there is no connectivity to rp cluster sites.", candidateTargetPool.getLabel()));
            continue;
        }
        // We want to find an internal site name that isn't already in the solution
        for (String associatedStorageSystem : associatedStorageSystems) {
            String targetInternalSiteName = ProtectionSystem.getAssociatedStorageSystemSiteName(associatedStorageSystem);
            URI targetStorageSystemURI = ConnectivityUtil.findStorageSystemBySerialNumber(ProtectionSystem.getAssociatedStorageSystemSerialNumber(associatedStorageSystem), dbClient, StorageSystemType.BLOCK);
            ProtectionType protectionType = null;
            if (!sourceRecommendation.containsTargetInternalSiteName(targetInternalSiteName)) {
                // MetroPoint has been specified so process the MetroPoint targets accordingly.
                if (isMetroPoint) {
                    if (targetInternalSiteName.equals(sourceRecommendation.getInternalSiteName())) {
                        // A local protection candidate.
                        if (isMetroPointProtectionSpecified(sourceRecommendation, ProtectionType.LOCAL)) {
                            // so continue onto the next candidate RP site.
                            continue;
                        }
                        // Add the local protection
                        protectionType = ProtectionType.LOCAL;
                    } else {
                        if (isMetroPointProtectionSpecified(sourceRecommendation, ProtectionType.REMOTE)) {
                            // candidate RP site.
                            continue;
                        } else {
                            if (activeSourceRecommendation != null) {
                                String primaryTargetInternalSiteName = getMetroPointRemoteTargetRPSite(rpProtectionRecommendation);
                                if (primaryTargetInternalSiteName != null && !targetInternalSiteName.equals(primaryTargetInternalSiteName)) {
                                    // site but the same as the primary target site.
                                    continue;
                                }
                            }
                            // Add the remote protection
                            protectionType = ProtectionType.REMOTE;
                        }
                    }
                }
            }
            // Check to make sure the RP site is connected to the varray
            URI protectionSystemURI = rpProtectionRecommendation.getProtectionDevice();
            if (!isRpSiteConnectedToVarray(targetStorageSystemURI, protectionSystemURI, targetInternalSiteName, targetVarray)) {
                _log.info(String.format("RP Placement: Disqualified RP site [%s] because its initiators are not in a network " + "configured for use by the virtual array [%s]", targetInternalSiteName, targetVarray.getLabel()));
                continue;
            }
            // Maybe make a topology check in here? Or is the source topology check enough?
            StorageSystem targetStorageSystem = dbClient.queryObject(StorageSystem.class, targetStorageSystemURI);
            ProtectionSystem ps = dbClient.queryObject(ProtectionSystem.class, protectionSystemURI);
            String rpSiteName = (ps.getRpSiteNames() != null) ? ps.getRpSiteNames().get(targetInternalSiteName) : "";
            _log.info(String.format("RP Placement : Choosing RP Site %s (%s) for target on varray [%s](%s)", rpSiteName, targetInternalSiteName, targetVarray.getLabel(), targetVarray.getId()));
            // Construct the target recommendation object
            _log.info(String.format("RP Placement : Build RP Target Recommendation..."));
            RPRecommendation targetRecommendation = buildRpRecommendation(associatedStorageSystem, targetVarray, targetVpool, candidateTargetPool, newCapabilities, requestedCount, targetInternalSiteName, targetStorageSystemURI, targetStorageSystem.getSystemType(), ps);
            if (targetRecommendation == null) {
                // No Target Recommendation found, so continue.
                _log.warn(String.format("RP Placement : Could not create Target Recommendation using [%s], continuing...", associatedStorageSystem));
                continue;
            }
            _log.info(String.format("RP Placement : RP Target Recommendation %s %n", targetRecommendation.toString(dbClient, ps, 1)));
            if (protectionType != null) {
                targetRecommendation.setProtectionType(protectionType);
            }
            // First Determine if journal recommendation need to be computed. It might have already been done.
            boolean isJournalPlacedForVarray = false;
            for (RPRecommendation targetJournalRec : rpProtectionRecommendation.getTargetJournalRecommendations()) {
                if (targetJournalRec.getVirtualArray().equals(targetJournalVarray.getId())) {
                    isJournalPlacedForVarray = true;
                }
            }
            // Build the target journal recommendation
            if (!isJournalPlacedForVarray) {
                _log.info(String.format("RP Placement : Build RP Target Journal Recommendation..."));
                RPRecommendation targetJournalRecommendation = buildJournalRecommendation(rpProtectionRecommendation, targetInternalSiteName, protectionSettings.getJournalSize(), targetJournalVarray, targetJournalVpool, ps, newCapabilities, capabilities.getResourceCount(), null, false);
                if (targetJournalRecommendation == null) {
                    // No Target Journal Recommendation found, so continue.
                    _log.warn(String.format("RP Placement : Could not create Target Journal Recommendation using [%s], continuing...", associatedStorageSystem));
                    continue;
                }
                _log.info(String.format("RP Placement : RP Target Journal Recommendation %s %n", targetJournalRecommendation.toString(dbClient, ps, 1)));
                rpProtectionRecommendation.getTargetJournalRecommendations().add(targetJournalRecommendation);
            } else {
                _log.info(String.format("RP Placement : RP Target Journal already placed."));
            }
            // the Target Recommendation.
            if (sourceRecommendation.getTargetRecommendations() == null) {
                sourceRecommendation.setTargetRecommendations(new ArrayList<RPRecommendation>());
            }
            sourceRecommendation.getTargetRecommendations().add(targetRecommendation);
            // Set the placement status to reference either the primary or secondary.
            PlacementStatus tmpPlacementStatus = placementStatus;
            if (activeSourceRecommendation != null) {
                tmpPlacementStatus = secondaryPlacementStatus;
            }
            // At this point we have found a target storage pool accessible to the protection vPool and protection vArray
            // that can be protected by an rp cluster site that is part of the same rp system that can protect the source storage pool
            rpProtectionRecommendation.setPlacementStepsCompleted(PlacementProgress.IDENTIFIED_SOLUTION_FOR_SUBSET_OF_TARGETS);
            if (tmpPlacementStatus.isBestSolutionToDate(rpProtectionRecommendation)) {
                tmpPlacementStatus.setLatestInvalidRecommendation(rpProtectionRecommendation);
            }
            if (isMetroPoint) {
                if (rpProtectionRecommendation.getSourceRecommendations() != null && getProtectionVarrays(rpProtectionRecommendation).size() == targetVarrays.size()) {
                    finalizeTargetPlacement(rpProtectionRecommendation, tmpPlacementStatus);
                    return true;
                }
            } else if (targetVarrays.size() == 1) {
                finalizeTargetPlacement(rpProtectionRecommendation, tmpPlacementStatus);
                return true;
            }
            // Find a solution based on this recommendation object and the remaining target arrays
            // Make a new protection varray list
            List<VirtualArray> remainingVarrays = new ArrayList<VirtualArray>();
            remainingVarrays.addAll(targetVarrays);
            remainingVarrays.remove(targetVarray);
            if (!remainingVarrays.isEmpty()) {
                _log.info("RP placement: Calling find solution on the next virtual array : " + remainingVarrays.get(0).getLabel() + " Current virtual array: " + targetVarray.getLabel());
            } else {
                _log.info("RP Placement : Solution cannot be found, will try again with different pool combination");
                return false;
            }
            if (!this.findSolution(rpProtectionRecommendation, sourceRecommendation, varray, vpool, remainingVarrays, newCapabilities, requestedCount, isMetroPoint, activeSourceRecommendation, project)) {
                // Remove the current recommendation and try the next site name, pool, etc.
                _log.info("RP Placement: Solution for remaining virtual arrays couldn't be found. " + "Trying different solution (if available) for varray: " + targetVarray.getLabel());
            } else {
                // We found a good solution
                _log.info("RP Placement: Solution for remaining virtual arrays was found. Returning to caller. Virtual Array : " + targetVarray.getLabel());
                return true;
            }
        }
    }
    // If we get here, the recommendation object never got a new protection object, and we just return false,
    // which will move onto the next possibility (in the case of a recursive call)
    _log.info("RP Placement : Solution cannot be found, will try again with different pool combination");
    return false;
}

Example 10 with RPRecommendation

use of com.emc.storageos.volumecontroller.RPRecommendation in project coprhd-controller by CoprHD.

the class RecoverPointScheduler method buildRpRecommendationFromExistingVolume.

/**
 * Build the RP Recommendation using an existing volume found in the CG.
 *
 * @param volume Existing volume to use
 * @param vpool The current vpool for the volume
 * @param capabilities The capabilities map
 * @param journalSize Size of the journal (only needed for journals, null otherwise)
 * @return Fully formed RP Recommendation formed from resources of the existing CG
 */
private RPRecommendation buildRpRecommendationFromExistingVolume(Volume volume, VirtualPool vpool, VirtualPoolCapabilityValuesWrapper capabilities, Long journalSize) {
    // Build the recommendation
    RPRecommendation rec = new RPRecommendation();
    rec.setVirtualPool(vpool);
    rec.setVirtualArray(volume.getVirtualArray());
    rec.setSourceStoragePool(volume.getPool());
    rec.setSourceStorageSystem(volume.getStorageController());
    rec.setInternalSiteName(volume.getInternalSiteName());
    rec.setRpCopyName(volume.getRpCopyName());
    rec.setSize((journalSize == null) ? capabilities.getSize() : journalSize);
    rec.setResourceCount(capabilities.getResourceCount());
    // Build VPLEX recommendation if specified
    if (VirtualPool.vPoolSpecifiesHighAvailability(vpool)) {
        VPlexRecommendation vplexRec = new VPlexRecommendation();
        vplexRec.setVirtualPool(vpool);
        vplexRec.setVirtualArray(volume.getVirtualArray());
        vplexRec.setVPlexStorageSystem(volume.getStorageController());
        // Always force count to 1 for a VPLEX rec for RP. VPLEX uses
        // these recs and they are invoked one at a time even
        // in a multi-volume request.
        vplexRec.setResourceCount(1);
        if (null == volume.getAssociatedVolumes() || volume.getAssociatedVolumes().isEmpty()) {
            _log.error("VPLEX volume {} has no backend volumes.", volume.forDisplay());
            throw InternalServerErrorException.internalServerErrors.noAssociatedVolumesForVPLEXVolume(volume.forDisplay());
        }
        for (String backingVolumeId : volume.getAssociatedVolumes()) {
            Volume backingVolume = dbClient.queryObject(Volume.class, URI.create(backingVolumeId));
            if (backingVolume.getVirtualArray().equals(volume.getVirtualArray())) {
                rec.setSourceStoragePool(backingVolume.getPool());
                rec.setSourceStorageSystem(backingVolume.getStorageController());
                vplexRec.setSourceStoragePool(backingVolume.getPool());
                vplexRec.setSourceStorageSystem(backingVolume.getStorageController());
            } else {
                if (journalSize == null) {
                    // Build HA recommendation if specified and this is not a VPLEX Journal.
                    // VPLEX Journals are always forced to VPLEX Local so we would not
                    // build a HA rec for it.
                    RPRecommendation haRec = new RPRecommendation();
                    VirtualPool haVpool = dbClient.queryObject(VirtualPool.class, backingVolume.getVirtualPool());
                    haRec.setVirtualPool(haVpool);
                    haRec.setVirtualArray(backingVolume.getVirtualArray());
                    haRec.setSourceStoragePool(backingVolume.getPool());
                    haRec.setSourceStorageSystem(backingVolume.getStorageController());
                    haRec.setResourceCount(capabilities.getResourceCount());
                    haRec.setSize(capabilities.getSize());
                    haRec.setInternalSiteName(backingVolume.getInternalSiteName());
                    haRec.setRpCopyName(backingVolume.getRpCopyName());
                    VPlexRecommendation haVPlexRec = new VPlexRecommendation();
                    haVPlexRec.setVirtualPool(haRec.getVirtualPool());
                    haVPlexRec.setVirtualArray(haRec.getVirtualArray());
                    haVPlexRec.setVPlexStorageSystem(volume.getStorageController());
                    haVPlexRec.setSourceStoragePool(haRec.getSourceStoragePool());
                    haVPlexRec.setSourceStorageSystem(haRec.getSourceStorageSystem());
                    // Always force count to 1 for a VPLEX rec for RP. VPLEX uses
                    // these recs and they are invoked one at a time even
                    // in a multi-volume request.
                    haVPlexRec.setResourceCount(1);
                    haRec.setVirtualVolumeRecommendation(haVPlexRec);
                    rec.setHaRecommendation(haRec);
                }
            }
        }
        rec.setVirtualVolumeRecommendation(vplexRec);
    }
    return rec;
}