コード例 #1
0
  /**
   * Re-validate the ExportMask
   *
   * <p>This is required to be done as the ExportMask gets updated by reading the cinder export
   * volume response.
   *
   * @param varrayURI
   * @param initiatorPortMap
   * @param mask
   * @param invalidMasks
   * @param directorToInitiatorIds
   * @param idToInitiatorMap
   * @param dbClient
   * @param portWwnToClusterMap
   */
  public void updateZoningMapAndvalidateExportMask(
      URI varrayURI,
      Map<URI, List<StoragePort>> initiatorPortMap,
      URI exportMaskURI,
      Map<String, Set<String>> directorToInitiatorIds,
      Map<String, Initiator> idToInitiatorMap,
      Map<String, String> portWwnToClusterMap,
      StorageSystem vplex,
      StorageSystem array,
      String clusterId,
      String stepId) {

    try {
      WorkflowStepCompleter.stepExecuting(stepId);
      // Export Mask is updated, read it from DB
      ExportMask exportMask = _dbClient.queryObject(ExportMask.class, exportMaskURI);

      // First step would be to update the zoning map based on the connectivity
      updateZoningMap(initiatorPortMap, directorToInitiatorIds, exportMask);

      boolean passed =
          VPlexBackEndOrchestratorUtil.validateExportMask(
              varrayURI,
              initiatorPortMap,
              exportMask,
              null,
              directorToInitiatorIds,
              idToInitiatorMap,
              _dbClient,
              portWwnToClusterMap);

      if (!passed) {
        // Mark this mask as inactive, so that we dont pick it in the next iteration
        exportMask.setInactive(Boolean.TRUE);
        _dbClient.persistObject(exportMask);

        _log.error("Export Mask is not suitable for VPLEX to backend storage system");
        WorkflowStepCompleter.stepFailed(
            stepId,
            VPlexApiException.exceptions.couldNotFindValidArrayExportMask(
                vplex.getNativeGuid(), array.getNativeGuid(), clusterId));
        throw VPlexApiException.exceptions.couldNotFindValidArrayExportMask(
            vplex.getNativeGuid(), array.getNativeGuid(), clusterId);
      }

      WorkflowStepCompleter.stepSucceded(stepId);

    } catch (Exception ex) {
      _log.error("Failed to validate export mask for cinder: ", ex);
      VPlexApiException vplexex =
          DeviceControllerExceptions.vplex.failedToValidateExportMask(exportMaskURI.toString(), ex);
      WorkflowStepCompleter.stepFailed(stepId, vplexex);
    }
  }
コード例 #2
0
  /**
   * Checks the UnManaged Volume's policy with vPool's policy.
   *
   * @param vPool the vPool
   * @param autoTierPolicyId the auto tier policy id on unmanaged volume
   * @param system the system
   * @return true, if matching, false otherwise
   */
  public static boolean checkVPoolValidForUnManagedVolumeAutoTieringPolicy(
      VirtualPool vPool, String autoTierPolicyId, StorageSystem system) {

    _log.debug("Policy Id: {}, vPool: {}", autoTierPolicyId, vPool);
    boolean policyMatching = false;
    String policyIdfromVPool = vPool.getAutoTierPolicyName();
    if (autoTierPolicyId != null) {
      if (policyIdfromVPool != null) {
        if (vPool.getUniquePolicyNames()
            || DiscoveredDataObject.Type.vnxblock.name().equalsIgnoreCase(system.getSystemType())) {
          // Unique Policy names field will not be set for VNX. vPool will have policy name, not the
          // policy's nativeGuid
          policyIdfromVPool =
              NativeGUIDGenerator.generateAutoTierPolicyNativeGuid(
                  system.getNativeGuid(),
                  policyIdfromVPool,
                  NativeGUIDGenerator.getTieringPolicyKeyForSystem(system));
          _log.debug("Policy Id generated: {}", policyIdfromVPool);
        }
        if (autoTierPolicyId.equalsIgnoreCase(policyIdfromVPool)) {
          policyMatching = true;
        }
      }
    } else if ((policyIdfromVPool == null) || (policyIdfromVPool.equalsIgnoreCase("none"))) {
      // if policy is not set in both unmanaged volume and vPool. Note
      // that the value in the vpool could be set to "none".
      policyMatching = true;
    }

    // Default policy for VNX - match volume with default policy to vPool with no policy as well
    if (!policyMatching
        && DiscoveredDataObject.Type.vnxblock.name().equalsIgnoreCase(system.getSystemType())) {
      if (autoTierPolicyId != null
          && autoTierPolicyId.contains(VnxFastPolicy.DEFAULT_START_HIGH_THEN_AUTOTIER.name())
          && policyIdfromVPool == null) {
        policyMatching = true;
      }
    }

    // Default policy for HDS - match volume with default policy to vPool with no policy as well
    if (!policyMatching
        && DiscoveredDataObject.Type.hds.name().equalsIgnoreCase(system.getSystemType())) {
      if (autoTierPolicyId != null
          && autoTierPolicyId.contains(HitachiTieringPolicy.All.name())
          && policyIdfromVPool == null) {
        policyMatching = true;
      }
    }

    return policyMatching;
  }
コード例 #3
0
  /**
   * Filters supported vPools in UnManaged Volume based on Auto-Tiering Policy.
   *
   * @param unManagedVolume the UnManaged volume
   * @param policyName the policy name associated with UnManaged volume
   * @param system the system
   * @param dbClient the db client
   */
  public static void filterSupportedVpoolsBasedOnTieringPolicy(
      UnManagedVolume unManagedVolume, String policyName, StorageSystem system, DbClient dbClient) {

    StringSetMap unManagedVolumeInformation = unManagedVolume.getVolumeInformation();
    StringSet supportedVpoolURIs =
        unManagedVolumeInformation.get(SupportedVolumeInformation.SUPPORTED_VPOOL_LIST.toString());
    List<String> vPoolsToRemove = new ArrayList<String>();
    if (supportedVpoolURIs != null) {
      Iterator<String> itr = supportedVpoolURIs.iterator();
      while (itr.hasNext()) {
        String uri = itr.next();
        VirtualPool vPool = dbClient.queryObject(VirtualPool.class, URI.create(uri));
        if (vPool != null && !vPool.getInactive()) {
          // generate unmanaged volume's policyId
          String autoTierPolicyId =
              NativeGUIDGenerator.generateAutoTierPolicyNativeGuid(
                  system.getNativeGuid(),
                  policyName,
                  NativeGUIDGenerator.getTieringPolicyKeyForSystem(system));
          if (!checkVPoolValidForUnManagedVolumeAutoTieringPolicy(
              vPool, autoTierPolicyId, system)) {
            String msg =
                "Removing vPool %s from SUPPORTED_VPOOL_LIST in UnManagedVolume %s "
                    + "since Auto-tiering Policy %s in UnManaged Volume does not match with vPool's (%s)";
            _log.info(
                String.format(
                    msg,
                    new Object[] {
                      uri, unManagedVolume.getId(), autoTierPolicyId, vPool.getAutoTierPolicyName()
                    }));
            vPoolsToRemove.add(uri);
          }
        } else {
          // remove Inactive vPool URI
          vPoolsToRemove.add(uri);
        }
      }
    }
    for (String uri : vPoolsToRemove) { // UnManagedVolume object is persisted by caller
      supportedVpoolURIs.remove(uri);
    }
  }
コード例 #4
0
  /**
   * Discovers the RP CGs and all the volumes therein. It updates/creates the UnManagedProtectionSet
   * objects and updates (if it exists) the UnManagedVolume objects with RP information needed for
   * ingestion
   *
   * @param accessProfile access profile
   * @param dbClient db client
   * @param partitionManager partition manager
   * @throws Exception
   */
  public void discoverUnManagedObjects(
      AccessProfile accessProfile, DbClient dbClient, PartitionManager partitionManager)
      throws Exception {

    this.partitionManager = partitionManager;

    log.info("Started discovery of UnManagedVolumes for system {}", accessProfile.getSystemId());
    ProtectionSystem protectionSystem =
        dbClient.queryObject(ProtectionSystem.class, accessProfile.getSystemId());
    if (protectionSystem == null) {
      log.error(
          "Discovery is not run!  Protection System not found: " + accessProfile.getSystemId());
      return;
    }

    RecoverPointClient rp = RPHelper.getRecoverPointClient(protectionSystem);

    unManagedCGsInsert = new ArrayList<UnManagedProtectionSet>();
    unManagedCGsUpdate = new ArrayList<UnManagedProtectionSet>();
    unManagedVolumesToDelete = new ArrayList<UnManagedVolume>();
    unManagedVolumesToUpdateByWwn = new HashMap<String, UnManagedVolume>();
    unManagedCGsReturnedFromProvider = new HashSet<URI>();

    // Get all of the consistency groups (and their volumes) from RP
    Set<GetCGsResponse> cgs = rp.getAllCGs();

    if (cgs == null) {
      log.warn("No CGs were found on protection system: " + protectionSystem.getLabel());
      return;
    }

    // This section of code allows us to cache XIO native GUID to workaround an issue
    // with RP's understanding of XIO volume WWNs (128-bit) and the rest of the world's
    // understanding of the XIO volume WWN once it's exported (64-bit)
    Map<String, String> rpWwnToNativeWwn = new HashMap<String, String>();
    List<URI> storageSystemIds = dbClient.queryByType(StorageSystem.class, true);
    List<String> storageNativeIdPrefixes = new ArrayList<String>();
    if (storageSystemIds != null) {
      Iterator<StorageSystem> storageSystemsItr =
          dbClient.queryIterativeObjects(StorageSystem.class, storageSystemIds);
      while (storageSystemsItr.hasNext()) {
        StorageSystem storageSystem = storageSystemsItr.next();
        if (storageSystem.getSystemType().equalsIgnoreCase(Type.xtremio.name())) {
          storageNativeIdPrefixes.add(storageSystem.getNativeGuid());
        }
      }
    }

    for (GetCGsResponse cg : cgs) {
      try {
        log.info("Processing returned CG: " + cg.getCgName());
        boolean newCG = false;

        // UnManagedProtectionSet native GUID is protection system GUID + consistency group ID
        String nativeGuid = protectionSystem.getNativeGuid() + Constants.PLUS + cg.getCgId();

        // First check to see if this protection set is already part of our managed DB
        if (null != DiscoveryUtils.checkProtectionSetExistsInDB(dbClient, nativeGuid)) {
          log.info(
              "Protection Set "
                  + nativeGuid
                  + " already is managed by ViPR, skipping unmanaged discovery");
          continue;
        }

        // Now check to see if the unmanaged CG exists in the database
        UnManagedProtectionSet unManagedProtectionSet =
            DiscoveryUtils.checkUnManagedProtectionSetExistsInDB(dbClient, nativeGuid);

        if (null == unManagedProtectionSet) {
          log.info("Creating new unmanaged protection set for CG: " + cg.getCgName());
          unManagedProtectionSet = new UnManagedProtectionSet();
          unManagedProtectionSet.setId(URIUtil.createId(UnManagedProtectionSet.class));
          unManagedProtectionSet.setNativeGuid(nativeGuid);
          unManagedProtectionSet.setProtectionSystemUri(protectionSystem.getId());

          StringSet protectionId = new StringSet();
          protectionId.add("" + cg.getCgId());
          unManagedProtectionSet.putCGInfo(
              SupportedCGInformation.PROTECTION_ID.toString(), protectionId);

          // Default MP to false until proven otherwise
          unManagedProtectionSet
              .getCGCharacteristics()
              .put(
                  UnManagedProtectionSet.SupportedCGCharacteristics.IS_MP.name(),
                  Boolean.FALSE.toString());

          newCG = true;
        } else {
          log.info(
              "Found existing unmanaged protection set for CG: "
                  + cg.getCgName()
                  + ", using "
                  + unManagedProtectionSet.getId().toString());
        }

        unManagedCGsReturnedFromProvider.add(unManagedProtectionSet.getId());

        // Update the fields for the CG
        unManagedProtectionSet.setCgName(cg.getCgName());
        unManagedProtectionSet.setLabel(cg.getCgName());

        // Indicate whether the CG is in a healthy state or not to ingest.
        unManagedProtectionSet
            .getCGCharacteristics()
            .put(
                UnManagedProtectionSet.SupportedCGCharacteristics.IS_HEALTHY.name(),
                cg.getCgState().equals(GetCGStateResponse.HEALTHY)
                    ? Boolean.TRUE.toString()
                    : Boolean.FALSE.toString());

        // Indicate whether the CG is sync or async
        unManagedProtectionSet
            .getCGCharacteristics()
            .put(
                UnManagedProtectionSet.SupportedCGCharacteristics.IS_SYNC.name(),
                cg.getCgPolicy().synchronous ? Boolean.TRUE.toString() : Boolean.FALSE.toString());

        // Fill in RPO type and value information
        StringSet rpoType = new StringSet();
        rpoType.add(cg.getCgPolicy().rpoType);
        unManagedProtectionSet.putCGInfo(SupportedCGInformation.RPO_TYPE.toString(), rpoType);

        StringSet rpoValue = new StringSet();
        rpoValue.add(cg.getCgPolicy().rpoValue.toString());
        unManagedProtectionSet.putCGInfo(SupportedCGInformation.RPO_VALUE.toString(), rpoValue);

        if (null == cg.getCopies()) {
          log.info("Protection Set " + nativeGuid + " does not contain any copies.  Skipping...");
          continue;
        }
        if (null == cg.getRsets()) {
          log.info(
              "Protection Set "
                  + nativeGuid
                  + " does not contain any replication sets.  Skipping...");
          continue;
        }

        // clean up the existing journal and replicationsets info in the unmanaged protection set,
        // so that updated info is populated
        if (!newCG) {
          cleanUpUnManagedResources(
              unManagedProtectionSet, unManagedVolumesToUpdateByWwn, dbClient);
        }

        // Now map UnManagedVolume objects to the journal and rset (sources/targets) and put RP
        // fields in them
        Map<String, String> rpCopyAccessStateMap = new HashMap<String, String>();

        mapCgJournals(
            unManagedProtectionSet,
            cg,
            rpCopyAccessStateMap,
            rpWwnToNativeWwn,
            storageNativeIdPrefixes,
            dbClient);

        mapCgSourceAndTargets(
            unManagedProtectionSet,
            cg,
            rpCopyAccessStateMap,
            rpWwnToNativeWwn,
            storageNativeIdPrefixes,
            dbClient);

        if (newCG) {
          unManagedCGsInsert.add(unManagedProtectionSet);
        } else {
          unManagedCGsUpdate.add(unManagedProtectionSet);
        }
      } catch (Exception ex) {
        log.error("Error processing RP CG {}", cg.getCgName(), ex);
      }
    }

    handlePersistence(dbClient, false);
    cleanUp(protectionSystem, dbClient);
  }