private void validateHighAvailability(String formName) {
    if (HighAvailability.isVplexDistributed(highAvailability)) {
      Validation.required(formName + ".haVirtualArray", haVirtualArray);
      if (ProtectionSystemTypes.isRecoverPoint(remoteProtection)) {
        if (BooleanUtils.isNotTrue(protectSourceSite) && BooleanUtils.isNotTrue(protectHASite)) {
          Validation.addError(
              formName + ".protectSourceSite", Messages.get("vpool.protectSourceSite.error"));
          Validation.addError(
              formName + ".protectHASite", Messages.get("vpool.protectHASite.error"));
        }
      }
    }

    if (!ProtectionSystemTypes.isRecoverPointOrNone(remoteProtection)) {
      Validation.addError(formName + ".remoteProtection", "vpool.remoteProtection.error.vplex");
    }
  }
  @Override
  public void validate(String formName) {
    super.validate(formName);

    if (this.expandable && this.maxContinuousCopies != null && this.maxContinuousCopies > 0) {
      Validation.addError(formName + ".expandable", "vpool.expandable.error.continousCopies");
      Validation.addError(
          formName + ".maxContinuousCopies", "vpool.continuousCopies.error.expandable");
    }

    // Recover point validation
    if (ProtectionSystemTypes.isRecoverPoint(remoteProtection)) {
      validateRecoverPoint(formName);
    }
    // SRDF validation
    else if (ProtectionSystemTypes.isSRDF(remoteProtection)) {
      validateSrdf(formName);
    }
    // High availability (vPlex) validation
    if (HighAvailability.isHighAvailability(highAvailability)) {
      validateHighAvailability(formName);
    }
  }
  private void validateRecoverPoint(String formName) {
    Validation.required(formName + ".rpJournalSize", rpJournalSize);
    if (!RPCopyForm.isValidJournalSize(rpJournalSize, rpJournalSizeUnit)) {
      Validation.addError(formName + ".rpJournalSize", "validation.invalid");
    }

    Set<String> varrayIds = Sets.newHashSet();
    Set<String> vpoolIds = Sets.newHashSet();

    boolean hasCopies = false;
    for (RPCopyForm rpCopy : rpCopies) {
      if (rpCopy != null && rpCopy.isEnabled()) {
        hasCopies = true;
        rpCopy.validate(formName + ".rpCopies");

        if (StringUtils.isNotBlank(rpCopy.virtualArray)) {
          if (!varrayIds.add(rpCopy.virtualArray)) {
            Validation.addError(formName + ".rpCopies", "rpCopy.virtualArray.error.duplicate");
          }
        }
        if (StringUtils.isNotBlank(rpCopy.virtualPool)) {
          vpoolIds.add(rpCopy.virtualPool);
        }
      }
    }
    if (!hasCopies) {
      Validation.required(formName + ".rpCopies", null);
    }

    // Extra validation when mixed with high availability
    if (HighAvailability.isHighAvailability(highAvailability)) {
      if (!Boolean.TRUE.equals(multiVolumeConsistency)) {
        Validation.addError(
            formName + ".multiVolumeConsistency", "vpool.rp.error.notMultiVolumeConsistent");
      }
    }
  }
 public ConnectedVirtualArraysCall highAvailabilityVirtualArrays() {
   boolean isHighAvailability = HighAvailability.isHighAvailability(highAvailability);
   List<URI> varrayIds = isHighAvailability ? uris(virtualArrays) : uris();
   return new ConnectedVirtualArraysCall(varrayIds, ConnectivityTypes.VPLEX);
 }
  private BlockVirtualPoolUpdateBuilder apply(BlockVirtualPoolUpdateBuilder builder) {
    applyCommon(builder);
    builder.setSnapshots(defaultInt(maxSnapshots));
    builder.setContinuousCopies(maxContinuousCopies, uri(continuousCopyVirtualPool));

    // Only allow updating these fields if not locked
    if (!isLocked()) {
      builder.setMinPaths(defaultInt(minPaths, 1));
      builder.setMaxPaths(defaultInt(maxPaths, 1));
      builder.setPathsPerInitiator(defaultInt(initiatorPaths, 1));
      builder.setAutoTieringPolicyName(autoTierPolicy);
      builder.setDriveType(driveType);
      builder.setExpandable(defaultBoolean(expandable));
      builder.setFastExpansion(defaultBoolean(fastExpansion));
      builder.setThinVolumePreAllocationPercentage(thinPreAllocationPercent);
      builder.setUniquePolicyNames(defaultBoolean(uniqueAutoTierPolicyNames));
      builder.setMultiVolumeConsistency(defaultBoolean(multiVolumeConsistency));
      builder.setRaidLevels(defaultSet(raidLevels));
      builder.setHostIOLimitBandwidth(defaultInt(hostIOLimitBandwidth, 0));
      builder.setHostIOLimitIOPs(defaultInt(hostIOLimitIOPs, 0));

      if (ProtectionSystemTypes.isRecoverPoint(remoteProtection)) {
        builder.setRecoverPointJournalSize(
            RPCopyForm.formatJournalSize(rpJournalSize, rpJournalSizeUnit));
        builder.setRecoverPointRemoteCopyMode(rpRemoteCopyMode);
        builder.setRecoverPointRpo(rpRpoValue, rpRpoType);
        Set<VirtualPoolProtectionVirtualArraySettingsParam> copies = Sets.newLinkedHashSet();
        for (RPCopyForm rpCopy : rpCopies) {
          if (rpCopy != null && rpCopy.isEnabled()) {
            copies.add(rpCopy.write());
          }
        }
        builder.setRecoverPointCopies(copies);
        builder.setJournalVarrayAndVpool(uri(sourceJournalVArray), uri(sourceJournalVPool));
      } else {
        builder.disableRecoverPoint();
      }

      if (ProtectionSystemTypes.isSRDF(remoteProtection)) {
        Set<VirtualPoolRemoteProtectionVirtualArraySettingsParam> copies = Sets.newHashSet();
        for (SrdfCopyForm srdfCopyForm : srdfCopies) {
          if (srdfCopyForm != null && srdfCopyForm.isEnabled()) {
            copies.add(srdfCopyForm.write(srdfCopyMode));
          }
        }
        builder.setRemoteCopies(copies);
      } else {
        builder.disableRemoteCopies();
      }

      if (HighAvailability.isHighAvailability(highAvailability)) {
        boolean activeProtectionAtHASite = BooleanUtils.isTrue(protectHASite);
        boolean metroPoint = false;
        if (BooleanUtils.isTrue(protectSourceSite) && BooleanUtils.isTrue(protectHASite)) {
          metroPoint = true;
          activeProtectionAtHASite =
              StringUtils.equalsIgnoreCase(activeSite, HighAvailability.VPLEX_HA);
          builder.setJournalVarrayAndVpool(uri(sourceJournalVArray), uri(sourceJournalVPool));
          builder.setStandByJournalVArrayVpool(uri(haJournalVArray), uri(haJournalVPool));
        } else {
          if (activeProtectionAtHASite) {
            builder.setJournalVarrayAndVpool(uri(haJournalVArray), uri(haJournalVPool));
          } else {
            builder.setJournalVarrayAndVpool(uri(sourceJournalVArray), uri(sourceJournalVPool));
          }
        }
        builder.setHighAvailability(
            highAvailability,
            enableAutoCrossConnExport,
            uri(haVirtualArray),
            uri(haVirtualPool),
            activeProtectionAtHASite,
            metroPoint);
      } else {
        builder.disableHighAvailability();
      }
    }

    return builder;
  }
  protected void doLoad(BlockVirtualPoolRestRep virtualPool) {
    loadCommon(virtualPool);
    minPaths = virtualPool.getMinPaths();
    maxPaths = virtualPool.getMaxPaths();
    initiatorPaths = virtualPool.getPathsPerInitiator();
    driveType = virtualPool.getDriveType();
    autoTierPolicy = virtualPool.getAutoTieringPolicyName();
    expandable = virtualPool.getExpandable();
    fastExpansion = virtualPool.getFastExpansion();
    multiVolumeConsistency = virtualPool.getMultiVolumeConsistent();
    thinPreAllocationPercent = virtualPool.getThinVolumePreAllocationPercentage();
    uniqueAutoTierPolicyNames = virtualPool.getUniquePolicyNames();
    raidLevels = defaultSet(virtualPool.getRaidLevels());
    hostIOLimitBandwidth = virtualPool.getHostIOLimitBandwidth();
    hostIOLimitIOPs = virtualPool.getHostIOLimitIOPs();

    VirtualPoolHighAvailabilityParam highAvailabilityType = virtualPool.getHighAvailability();
    if (highAvailabilityType != null
        && HighAvailability.isHighAvailability(highAvailabilityType.getType())) {
      highAvailability = highAvailabilityType.getType();
      if (highAvailability.equals(HighAvailability.VPLEX_LOCAL)) {
        protectSourceSite = true;
      }
      enableAutoCrossConnExport = highAvailabilityType.getAutoCrossConnectExport();
      if (highAvailabilityType.getHaVirtualArrayVirtualPool() != null) {
        haVirtualArray =
            asString(highAvailabilityType.getHaVirtualArrayVirtualPool().getVirtualArray());
        haVirtualPool =
            asString(highAvailabilityType.getHaVirtualArrayVirtualPool().getVirtualPool());

        Boolean activeProtectionAtHASite =
            Boolean.TRUE.equals(
                highAvailabilityType.getHaVirtualArrayVirtualPool().getActiveProtectionAtHASite());
        Boolean metroPoint = Boolean.TRUE.equals(highAvailabilityType.getMetroPoint());
        if (metroPoint) {
          protectSourceSite = true;
          protectHASite = true;
          if (activeProtectionAtHASite) {
            activeSite = HighAvailability.VPLEX_HA.toString();
          } else {
            activeSite = HighAvailability.VPLEX_SOURCE.toString();
            protectSourceSite = true;
          }
        } else {
          protectHASite = activeProtectionAtHASite;
          protectSourceSite = !protectHASite;
        }
      } else {
        protectSourceSite = true;
      }
    } else {
      protectSourceSite = true;
    }

    BlockVirtualPoolProtectionParam protection = virtualPool.getProtection();
    if (protection != null) {
      if (protection.getSnapshots() != null) {
        maxSnapshots = protection.getSnapshots().getMaxSnapshots();
      }
      if (protection.getContinuousCopies() != null) {
        maxContinuousCopies = protection.getContinuousCopies().getMaxMirrors();
        continuousCopyVirtualPool = asString(protection.getContinuousCopies().getVpool());
      }

      VirtualPoolProtectionRPParam recoverPoint = protection.getRecoverPoint();
      if (recoverPoint != null) {
        remoteProtection = ProtectionSystemTypes.RECOVERPOINT;
        ProtectionSourcePolicy sourcePolicy = recoverPoint.getSourcePolicy();
        if (sourcePolicy != null) {
          String journalSize = sourcePolicy.getJournalSize();
          rpJournalSizeUnit = RPCopyForm.parseJournalSizeUnit(journalSize);
          rpJournalSize =
              StringUtils.defaultIfBlank(
                  RPCopyForm.parseJournalSize(journalSize, rpJournalSizeUnit),
                  RPCopyForm.JOURNAL_SIZE_MIN);
          rpRemoteCopyMode = sourcePolicy.getRemoteCopyMode();
          rpRpoValue = sourcePolicy.getRpoValue();
          rpRpoType = sourcePolicy.getRpoType();
          if (protectHASite != null
              && protectSourceSite != null
              && protectHASite
              && protectSourceSite) {
            // Backend will take care of swapping
            // if(activeSite.equalsIgnoreCase(HighAvailability.VPLEX_SOURCE)){
            sourceJournalVArray = asString(sourcePolicy.getJournalVarray());
            sourceJournalVPool = asString(sourcePolicy.getJournalVpool());
            haJournalVArray = asString(sourcePolicy.getStandbyJournalVarray());
            haJournalVPool = asString(sourcePolicy.getStandbyJournalVpool());
          } else {
            if (protectHASite != null && protectHASite) {
              haJournalVArray = asString(sourcePolicy.getJournalVarray());
              haJournalVPool = asString(sourcePolicy.getJournalVpool());
            } else if (protectSourceSite != null && protectSourceSite) {
              sourceJournalVArray = asString(sourcePolicy.getJournalVarray());
              sourceJournalVPool = asString(sourcePolicy.getJournalVpool());
            }
          }
        }

        List<RPCopyForm> rpCopyForms = Lists.newArrayList();
        for (VirtualPoolProtectionVirtualArraySettingsParam copy : recoverPoint.getCopies()) {
          RPCopyForm rpCopy = new RPCopyForm();
          rpCopy.load(copy);
          rpCopyForms.add(rpCopy);
        }
        rpCopies = rpCopyForms.toArray(new RPCopyForm[0]);
        rpCopiesJson = new Gson().toJson(rpCopies);
      }
      VirtualPoolRemoteMirrorProtectionParam srdf = protection.getRemoteCopies();
      if (srdf != null) {
        remoteProtection = ProtectionSystemTypes.SRDF;

        List<SrdfCopyForm> copyForms = Lists.newArrayList();
        for (VirtualPoolRemoteProtectionVirtualArraySettingsParam copy :
            srdf.getRemoteCopySettings()) {
          srdfCopyMode = copy.getRemoteCopyMode();

          SrdfCopyForm srdfCopyForm = new SrdfCopyForm();
          srdfCopyForm.load(copy);
          copyForms.add(srdfCopyForm);
        }
        srdfCopies = copyForms.toArray(new SrdfCopyForm[0]);
        Gson gson = new Gson();
        srdfCopiesJson = gson.toJson(srdfCopies);
      } else {
        srdfCopiesJson = "[]";
      }
    }
  }