@Override
  public void exportGroupDelete(URI storageURI, URI exportGroupURI, String token) throws Exception {
    ExportOrchestrationTask taskCompleter = new ExportOrchestrationTask(exportGroupURI, token);
    try {
      ExportGroup exportGroup = _dbClient.queryObject(ExportGroup.class, exportGroupURI);
      StorageSystem storage = _dbClient.queryObject(StorageSystem.class, storageURI);

      List<ExportMask> masks = ExportMaskUtils.getExportMasks(_dbClient, exportGroup, storageURI);
      if (masks != null && !masks.isEmpty()) {
        Workflow workflow =
            _workflowService.getNewWorkflow(
                MaskingWorkflowEntryPoints.getInstance(), "exportGroupDelete", true, token);

        Map<URI, Integer> volumeMap =
            ExportUtils.getExportGroupVolumeMap(_dbClient, storage, exportGroup);
        List<URI> volumeURIs = new ArrayList<>(volumeMap.keySet());
        List<URI> initiatorURIs = StringSetUtil.stringSetToUriList(exportGroup.getInitiators());
        Map<URI, Map<URI, Integer>> exportMaskToVolumeCount =
            ExportMaskUtils.mapExportMaskToVolumeShareCount(_dbClient, volumeURIs, initiatorURIs);

        for (ExportMask exportMask : masks) {
          List<URI> exportGroupURIs = new ArrayList<>();
          if (!ExportUtils.isExportMaskShared(_dbClient, exportMask.getId(), exportGroupURIs)) {
            log.info(
                String.format("Adding step to delete ExportMask %s", exportMask.getMaskName()));
            generateExportMaskDeleteWorkflow(
                workflow, null, storage, exportGroup, exportMask, null);
          } else {
            Map<URI, Integer> volumeToExportGroupCount =
                exportMaskToVolumeCount.get(exportMask.getId());
            List<URI> volumesToRemove = new ArrayList<>();
            for (URI uri : volumeMap.keySet()) {
              if (volumeToExportGroupCount == null) {
                continue;
              }
              // Remove the volume only if it is not shared with
              // more than 1 ExportGroup
              Integer numExportGroupsVolumeIsIn = volumeToExportGroupCount.get(uri);
              if (numExportGroupsVolumeIsIn != null && numExportGroupsVolumeIsIn == 1) {
                volumesToRemove.add(uri);
              }
            }
            if (!volumesToRemove.isEmpty()) {
              log.info(
                  String.format(
                      "Adding step to remove volumes %s from ExportMask %s",
                      Joiner.on(',').join(volumesToRemove), exportMask.getMaskName()));
              generateExportMaskRemoveVolumesWorkflow(
                  workflow, null, storage, exportGroup, exportMask, volumesToRemove, null);
            }
          }
        }

        String successMessage =
            String.format(
                "ExportGroup delete successfully completed for StorageArray %s",
                storage.getLabel());
        workflow.executePlan(taskCompleter, successMessage);
      } else {
        taskCompleter.ready(_dbClient);
      }
    } catch (DeviceControllerException dex) {
      taskCompleter.error(
          _dbClient,
          DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation(
              "exportGroupDelete", dex.getMessage()));
    } catch (Exception ex) {
      _log.error("ExportGroup Orchestration failed.", ex);
      taskCompleter.error(
          _dbClient,
          DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation(
              "exportGroupDelete", ex.getMessage()));
    }
  }
  @Override
  public void exportGroupCreate(
      URI storageURI,
      URI exportGroupURI,
      List<URI> initiatorURIs,
      Map<URI, Integer> volumeMap,
      String token)
      throws Exception {
    ExportOrchestrationTask taskCompleter = new ExportOrchestrationTask(exportGroupURI, token);
    try {
      ExportGroup exportGroup = _dbClient.queryObject(ExportGroup.class, exportGroupURI);
      StorageSystem storage = _dbClient.queryObject(StorageSystem.class, storageURI);

      if (initiatorURIs != null && !initiatorURIs.isEmpty()) {
        // Set up workflow steps.
        Workflow workflow =
            _workflowService.getNewWorkflow(
                MaskingWorkflowEntryPoints.getInstance(), "exportGroupCreate", true, token);

        // Create a mapping of ExportMasks to Add Volumes to or
        // add to a list of new Exports to create
        Map<URI, Map<URI, Integer>> exportMaskToVolumesToAdd = new HashMap<>();
        List<URI> newInitiators = new ArrayList<>();
        List<Initiator> initiators = _dbClient.queryObject(Initiator.class, initiatorURIs);
        for (Initiator initiator : initiators) {
          List<ExportMask> exportMasks = ExportUtils.getInitiatorExportMasks(initiator, _dbClient);
          if (exportMasks == null || exportMasks.isEmpty()) {
            newInitiators.add(initiator.getId());
          } else {
            for (ExportMask exportMask : exportMasks) {
              exportMaskToVolumesToAdd.put(exportMask.getId(), volumeMap);
            }
          }
        }

        Map<String, List<URI>> computeResourceToInitiators =
            mapInitiatorsToComputeResource(exportGroup, newInitiators);
        log.info(
            String.format(
                "Need to create ExportMasks for these compute resources %s",
                Joiner.on(',').join(computeResourceToInitiators.entrySet())));
        // ExportMask that need to be newly create. That is, the initiators in
        // this ExportGroup create do not already exist on the system, hence
        // there aren't any already existing ExportMask for them
        for (Map.Entry<String, List<URI>> toCreate : computeResourceToInitiators.entrySet()) {
          generateExportMaskCreateWorkflow(
              workflow, null, storage, exportGroup, toCreate.getValue(), volumeMap, token);
        }

        log.info(
            String.format(
                "Need to add volumes for these ExportMasks %s",
                exportMaskToVolumesToAdd.entrySet()));
        // There are some existing ExportMasks for the initiators in the request.
        // For these, we want to reuse the ExportMask and add volumes to them.
        // These ExportMasks would be created by the system. ScaleIO has no
        // concept ExportMasks.
        for (Map.Entry<URI, Map<URI, Integer>> toAddVolumes : exportMaskToVolumesToAdd.entrySet()) {
          ExportMask exportMask = _dbClient.queryObject(ExportMask.class, toAddVolumes.getKey());
          generateExportMaskAddVolumesWorkflow(
              workflow, null, storage, exportGroup, exportMask, toAddVolumes.getValue());
        }

        String successMessage =
            String.format(
                "ExportGroup successfully applied for StorageArray %s", storage.getLabel());
        workflow.executePlan(taskCompleter, successMessage);
      } else {
        taskCompleter.ready(_dbClient);
      }
    } catch (DeviceControllerException dex) {
      taskCompleter.error(
          _dbClient,
          DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation(
              "exportGroupCreate", dex.getMessage()));
    } catch (Exception ex) {
      _log.error("ExportGroup Orchestration failed.", ex);
      taskCompleter.error(
          _dbClient,
          DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation(
              "exportGroupCreate", ex.getMessage()));
    }
  }
  @Override
  public void exportGroupRemoveVolumes(
      URI storageURI, URI exportGroupURI, List<URI> volumeURIs, String token) throws Exception {
    /*
     * foreach volume in list
     * foreach initiator in ExportGroup
     * if volume not used in another ExportGroup with same initiator
     * scli unmap --volume volid --sdc initiator.sdcid
     */
    ExportOrchestrationTask taskCompleter = new ExportOrchestrationTask(exportGroupURI, token);
    try {
      ExportGroup exportGroup = _dbClient.queryObject(ExportGroup.class, exportGroupURI);
      StorageSystem storage = _dbClient.queryObject(StorageSystem.class, storageURI);

      List<ExportMask> masks = ExportMaskUtils.getExportMasks(_dbClient, exportGroup, storageURI);
      if (masks != null && !masks.isEmpty()) {
        // Set up workflow steps.
        Workflow workflow =
            _workflowService.getNewWorkflow(
                MaskingWorkflowEntryPoints.getInstance(), "exportGroupRemoveVolumes", true, token);

        // Generate a list of Initiators
        List<URI> initiatorURIs = StringSetUtil.stringSetToUriList(exportGroup.getInitiators());
        Map<URI, List<URI>> exportToRemoveVolumesList = new HashMap<>();
        // Generate a mapping of volume URIs to the # of
        // ExportGroups that it is associated with
        Map<URI, Map<URI, Integer>> exportMaskToVolumeCount =
            ExportMaskUtils.mapExportMaskToVolumeShareCount(_dbClient, volumeURIs, initiatorURIs);

        // Generate a mapping of the ExportMask URI to a list volumes to
        // remove from that ExportMask
        for (ExportMask exportMask : masks) {
          Map<URI, Integer> volumeToCountMap = exportMaskToVolumeCount.get(exportMask.getId());
          if (volumeToCountMap == null) {
            continue;
          }
          for (Map.Entry<URI, Integer> it : volumeToCountMap.entrySet()) {
            URI volumeURI = it.getKey();
            Integer numberOfExportGroupsVolumesIsIn = it.getValue();
            if (numberOfExportGroupsVolumesIsIn == 1) {
              List<URI> volumesToRemove = exportToRemoveVolumesList.get(exportMask.getId());
              if (volumesToRemove == null) {
                volumesToRemove = new ArrayList<>();
                exportToRemoveVolumesList.put(exportMask.getId(), volumesToRemove);
              }
              volumesToRemove.add(volumeURI);
            }
          }
        }

        // With the mapping of ExportMask to list of volume URIs,
        // generate a step to remove the volumes from the ExportMask
        for (Map.Entry<URI, List<URI>> entry : exportToRemoveVolumesList.entrySet()) {
          ExportMask exportMask = _dbClient.queryObject(ExportMask.class, entry.getKey());
          log.info(
              String.format(
                  "Adding step to remove volumes %s from ExportMask %s",
                  Joiner.on(',').join(entry.getValue()), exportMask.getMaskName()));
          generateExportMaskRemoveVolumesWorkflow(
              workflow, null, storage, exportGroup, exportMask, entry.getValue(), null);
        }

        String successMessage =
            String.format(
                "ExportGroup remove volumes successfully applied for StorageArray %s",
                storage.getLabel());
        workflow.executePlan(taskCompleter, successMessage);
      } else {
        taskCompleter.ready(_dbClient);
      }
    } catch (DeviceControllerException dex) {
      taskCompleter.error(
          _dbClient,
          DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation(
              "exportGroupRemoveVolumes", dex.getMessage()));
    } catch (Exception ex) {
      _log.error("ExportGroup Orchestration failed.", ex);
      taskCompleter.error(
          _dbClient,
          DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation(
              "exportGroupRemoveVolumes", ex.getMessage()));
    }
  }
  @Override
  public void exportGroupAddVolumes(
      URI storageURI, URI exportGroupURI, Map<URI, Integer> volumeMap, String token)
      throws Exception {
    /*
     * foreach volume in list
     * foreach initiator in ExportGroup
     * scli map --volume volid --sdc initiator.sdcid
     */
    ExportOrchestrationTask taskCompleter = new ExportOrchestrationTask(exportGroupURI, token);
    try {
      ExportGroup exportGroup = _dbClient.queryObject(ExportGroup.class, exportGroupURI);
      StorageSystem storage = _dbClient.queryObject(StorageSystem.class, storageURI);

      List<URI> initiatorURIs = StringSetUtil.stringSetToUriList(exportGroup.getInitiators());
      if (initiatorURIs != null && !initiatorURIs.isEmpty()) {
        // Set up workflow steps.
        Workflow workflow =
            _workflowService.getNewWorkflow(
                MaskingWorkflowEntryPoints.getInstance(), "exportGroupAddVolumes", true, token);

        // Create a mapping of ExportMasks to Add Volumes to or
        // add to a list of new Exports to create
        Map<URI, Map<URI, Integer>> exportMaskToVolumesToAdd = new HashMap<>();
        List<URI> initiatorsToPlace = new ArrayList<>(initiatorURIs);

        // Need to figure out which ExportMasks to add volumes to.
        for (ExportMask exportMask :
            ExportMaskUtils.getExportMasks(_dbClient, exportGroup, storageURI)) {
          if (exportMask.hasAnyInitiators()) {
            exportMaskToVolumesToAdd.put(exportMask.getId(), volumeMap);
            for (String uriString : exportMask.getInitiators()) {
              URI initiatorURI = URI.create(uriString);
              initiatorsToPlace.remove(initiatorURI);
            }
          }
        }

        Map<String, List<URI>> computeResourceToInitiators =
            mapInitiatorsToComputeResource(exportGroup, initiatorsToPlace);
        log.info(
            String.format(
                "Need to create ExportMasks for these compute resources %s",
                Joiner.on(',').join(computeResourceToInitiators.entrySet())));
        // ExportMask that need to be newly create because we just added
        // volumes from 'storage' StorageSystem to this ExportGroup
        for (Map.Entry<String, List<URI>> toCreate : computeResourceToInitiators.entrySet()) {
          generateExportMaskCreateWorkflow(
              workflow, null, storage, exportGroup, toCreate.getValue(), volumeMap, token);
        }

        log.info(
            String.format(
                "Need to add volumes for these ExportMasks %s",
                exportMaskToVolumesToAdd.entrySet()));
        // We already know about the ExportMask, so we just add volumes to it
        for (Map.Entry<URI, Map<URI, Integer>> toAddVolumes : exportMaskToVolumesToAdd.entrySet()) {
          ExportMask exportMask = _dbClient.queryObject(ExportMask.class, toAddVolumes.getKey());
          generateExportMaskAddVolumesWorkflow(
              workflow, null, storage, exportGroup, exportMask, toAddVolumes.getValue());
        }

        String successMessage =
            String.format(
                "ExportGroup add volumes successfully applied for StorageArray %s",
                storage.getLabel());
        workflow.executePlan(taskCompleter, successMessage);
      } else {
        taskCompleter.ready(_dbClient);
      }
    } catch (DeviceControllerException dex) {
      taskCompleter.error(
          _dbClient,
          DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation(
              "exportGroupAddVolumes", dex.getMessage()));
    } catch (Exception ex) {
      _log.error("ExportGroup Orchestration failed.", ex);
      taskCompleter.error(
          _dbClient,
          DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation(
              "exportGroupAddVolumes", ex.getMessage()));
    }
  }
  @Override
  public void exportGroupRemoveInitiators(
      URI storageURI, URI exportGroupURI, List<URI> initiatorURIs, String token) throws Exception {
    /*
     * foreach ScaleOI volume in ExportGroup
     * foreach initiator in list
     * if volume not used in another ExportGroup with same initiator
     * scli unmap --volume volid --sdc initiator.sdcid
     */
    ExportOrchestrationTask taskCompleter = new ExportOrchestrationTask(exportGroupURI, token);
    try {
      ExportGroup exportGroup = _dbClient.queryObject(ExportGroup.class, exportGroupURI);
      StorageSystem storage = _dbClient.queryObject(StorageSystem.class, storageURI);

      if (initiatorURIs != null
          && !initiatorURIs.isEmpty()
          && exportGroup.getExportMasks() != null) {
        // Set up workflow steps.
        Workflow workflow =
            _workflowService.getNewWorkflow(
                MaskingWorkflowEntryPoints.getInstance(),
                "exportGroupRemoveInitiators",
                true,
                token);

        // Create a mapping of ExportMask URI to initiators to remove
        Map<URI, List<URI>> exportToInitiatorsToRemove = new HashMap<>();
        Map<URI, List<URI>> exportToVolumesToRemove = new HashMap<>();
        Map<URI, Integer> volumeMap = null;
        for (String exportMaskURIStr : exportGroup.getExportMasks()) {
          URI exportMaskURI = URI.create(exportMaskURIStr);
          ExportMask exportMask = _dbClient.queryObject(ExportMask.class, exportMaskURI);
          if (exportMask == null) {
            continue;
          }
          for (URI initiatorURI : initiatorURIs) {
            Initiator initiator = _dbClient.queryObject(Initiator.class, initiatorURI);
            if (initiator == null || !exportMask.hasInitiator(initiatorURI.toString())) {
              continue;
            }
            if (ExportUtils.getInitiatorExportGroups(initiator, _dbClient).size() == 1) {
              List<URI> initiators = exportToInitiatorsToRemove.get(exportGroupURI);
              if (initiators == null) {
                initiators = new ArrayList<>();
                exportToInitiatorsToRemove.put(exportMaskURI, initiators);
              }
              initiators.add(initiatorURI);
            } else {
              if (volumeMap == null) {
                volumeMap = ExportUtils.getExportGroupVolumeMap(_dbClient, storage, exportGroup);
              }
              List<URI> volumeURIs = exportToVolumesToRemove.get(exportGroupURI);
              if (volumeURIs == null) {
                volumeURIs = new ArrayList<>();
                exportToVolumesToRemove.put(exportMaskURI, volumeURIs);
              }
              for (URI volumeURI : volumeMap.keySet()) {
                // Only add to the remove list for the ExportMask if
                // the EM is not being shared with another ExportGroup
                Integer count =
                    ExportUtils.getNumberOfExportGroupsWithVolume(initiator, volumeURI, _dbClient);
                if (count == 1) {
                  volumeURIs.add(volumeURI);
                }
              }
            }
          }
        }

        // Generate the remove initiators steps for the entries that were determined above
        for (Map.Entry<URI, List<URI>> toRemoveInits : exportToInitiatorsToRemove.entrySet()) {
          ExportMask exportMask = _dbClient.queryObject(ExportMask.class, toRemoveInits.getKey());
          if (exportMask != null) {
            List<URI> removeInitURIs = toRemoveInits.getValue();
            List<String> exportMaskInitiatorURIs = new ArrayList<>(exportMask.getInitiators());
            for (URI uri : removeInitURIs) {
              exportMaskInitiatorURIs.remove(uri.toString());
            }
            if (exportMaskInitiatorURIs.isEmpty()) {
              log.info(
                  String.format("Adding step to delete ExportMask %s", exportMask.getMaskName()));
              generateExportMaskDeleteWorkflow(
                  workflow, null, storage, exportGroup, exportMask, null);
            } else {
              log.info(
                  String.format(
                      "Adding step to remove initiators %s from ExportMask %s",
                      Joiner.on(',').join(removeInitURIs), exportMask.getMaskName()));
              generateExportMaskRemoveInitiatorsWorkflow(
                  workflow, null, storage, exportGroup, exportMask, removeInitURIs, true);
            }
          }
        }

        // Generate the remove volume for those cases where we remove initiators
        // from an ExportGroup that contains more than one host/initiator
        for (Map.Entry<URI, List<URI>> toRemoveVols : exportToVolumesToRemove.entrySet()) {
          ExportMask exportMask = _dbClient.queryObject(ExportMask.class, toRemoveVols.getKey());
          List<URI> removeVolumeURIs = toRemoveVols.getValue();
          if (exportMask != null && !removeVolumeURIs.isEmpty()) {
            List<String> exportMaskVolumeURIs = new ArrayList<>(exportMask.getVolumes().keySet());
            for (URI uri : removeVolumeURIs) {
              exportMaskVolumeURIs.remove(uri.toString());
            }
            if (exportMaskVolumeURIs.isEmpty()) {
              log.info(
                  String.format("Adding step to delete ExportMask %s", exportMask.getMaskName()));
              generateExportMaskDeleteWorkflow(
                  workflow, null, storage, exportGroup, exportMask, null);
            } else {
              log.info(
                  String.format(
                      "Adding step to remove volumes %s from ExportMask %s",
                      Joiner.on(',').join(removeVolumeURIs), exportMask.getMaskName()));
              generateExportMaskRemoveVolumesWorkflow(
                  workflow, null, storage, exportGroup, exportMask, removeVolumeURIs, null);
            }
          }
        }

        String successMessage =
            String.format(
                "ExportGroup remove initiators successfully applied for StorageArray %s",
                storage.getLabel());
        workflow.executePlan(taskCompleter, successMessage);
      } else {
        taskCompleter.ready(_dbClient);
      }
    } catch (DeviceControllerException dex) {
      taskCompleter.error(
          _dbClient,
          DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation(
              "exportGroupRemoveInitiators", dex.getMessage()));
    } catch (Exception ex) {
      _log.error("ExportGroup Orchestration failed.", ex);
      taskCompleter.error(
          _dbClient,
          DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation(
              "exportGroupRemoveInitiators", ex.getMessage()));
    }
  }
  @Override
  public void exportGroupAddInitiators(
      URI storageURI, URI exportGroupURI, List<URI> initiatorURIs, String token) throws Exception {
    /*
     * foreach ExportGroup.volume
     * if ScaleIO volume
     * foreach initiator
     * scli map --volume volid --sdc initiator.sdcid
     */
    ExportOrchestrationTask taskCompleter = new ExportOrchestrationTask(exportGroupURI, token);
    try {
      ExportGroup exportGroup = _dbClient.queryObject(ExportGroup.class, exportGroupURI);
      StorageSystem storage = _dbClient.queryObject(StorageSystem.class, storageURI);

      if (initiatorURIs != null && !initiatorURIs.isEmpty()) {
        // Set up workflow steps.
        Workflow workflow =
            _workflowService.getNewWorkflow(
                MaskingWorkflowEntryPoints.getInstance(), "exportGroupAddInitiators", true, token);

        Map<String, URI> portNameToInitiatorURI = new HashMap<>();
        List<URI> hostURIs = new ArrayList<>();
        List<String> portNames = new ArrayList<>();
        // Populate the portNames and the mapping of the portNames to Initiator URIs
        processInitiators(exportGroup, initiatorURIs, portNames, portNameToInitiatorURI, hostURIs);

        Map<URI, Integer> volumesToAdd =
            ExportUtils.getExportGroupVolumeMap(_dbClient, storage, exportGroup);
        List<URI> initiatorURIsToPlace = new ArrayList<>(initiatorURIs);
        Map<String, List<URI>> computeResourceToInitiators =
            mapInitiatorsToComputeResource(exportGroup, initiatorURIs);
        Set<URI> partialMasks = new HashSet<>();
        Map<String, Set<URI>> initiatorToExport =
            determineInitiatorToExportMaskPlacements(
                exportGroup,
                storageURI,
                computeResourceToInitiators,
                Collections.EMPTY_MAP,
                portNameToInitiatorURI,
                partialMasks);
        Map<URI, List<URI>> exportToInitiators =
            toExportMaskToInitiatorURIs(initiatorToExport, portNameToInitiatorURI);
        for (Map.Entry<URI, List<URI>> toAddInitiators : exportToInitiators.entrySet()) {
          ExportMask exportMask = _dbClient.queryObject(ExportMask.class, toAddInitiators.getKey());
          if (exportMask == null || exportMask.getInactive()) {
            continue;
          }
          for (URI toAddInitiator : toAddInitiators.getValue()) {
            if (!exportMask.hasInitiator(toAddInitiator.toString())) {
              log.info(
                  String.format(
                      "Add step to add initiator %s to ExportMask %s",
                      toAddInitiator.toString(), exportMask.getMaskName()));
              generateExportMaskAddInitiatorsWorkflow(
                  workflow,
                  null,
                  storage,
                  exportGroup,
                  exportMask,
                  toAddInitiators.getValue(),
                  null,
                  null);
            } else if (volumesToAdd != null && volumesToAdd.size() > 0) {
              log.info(
                  String.format(
                      "Add step to add volumes %s to ExportMask %s",
                      Joiner.on(',').join(volumesToAdd.entrySet()), exportMask.getMaskName()));
              generateExportMaskAddVolumesWorkflow(
                  workflow, null, storage, exportGroup, exportMask, volumesToAdd);
            }
            initiatorURIsToPlace.remove(toAddInitiator);
          }
        }

        // If there are any new initiators that weren't already known to the system
        // previously, add them now.
        if (!initiatorURIsToPlace.isEmpty() && volumesToAdd != null) {
          Map<String, List<URI>> newComputeResources =
              mapInitiatorsToComputeResource(exportGroup, initiatorURIsToPlace);
          log.info(
              String.format(
                  "Need to create ExportMasks for these compute resources %s",
                  Joiner.on(',').join(newComputeResources.entrySet())));
          for (Map.Entry<String, List<URI>> toCreate : newComputeResources.entrySet()) {
            generateExportMaskCreateWorkflow(
                workflow, null, storage, exportGroup, toCreate.getValue(), volumesToAdd, null);
          }
        }

        String successMessage =
            String.format(
                "ExportGroup add initiators successfully applied for StorageArray %s",
                storage.getLabel());
        workflow.executePlan(taskCompleter, successMessage);
      } else {
        taskCompleter.ready(_dbClient);
      }
    } catch (DeviceControllerException dex) {
      taskCompleter.error(
          _dbClient,
          DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation(
              "exportGroupAddInitiators", dex.getMessage()));
    } catch (Exception ex) {
      _log.error("ExportGroup Orchestration failed.", ex);
      taskCompleter.error(
          _dbClient,
          DeviceControllerErrors.scaleio.encounteredAnExceptionFromScaleIOOperation(
              "exportGroupAddInitiators", ex.getMessage()));
    }
  }
  /**
   * Create storage level masking components to support the requested ExportGroup object. This
   * operation will be flexible enough to take into account initiators that are in some already
   * existent in some StorageGroup. In such a case, the underlying masking component will be
   * "adopted" by the ExportGroup. Further operations against the "adopted" mask will only allow for
   * addition and removal of those initiators/volumes that were added by a Bourne request. Existing
   * initiators/volumes will be maintained.
   *
   * @param storageURI - URI referencing underlying storage array
   * @param exportGroupURI - URI referencing Bourne-level masking, ExportGroup
   * @param initiatorURIs - List of Initiator URIs
   * @param volumeMap - Map of Volume URIs to requested Integer URI
   * @param token - Identifier for operation
   * @throws Exception
   */
  @Override
  public void exportGroupCreate(
      URI storageURI,
      URI exportGroupURI,
      List<URI> initiatorURIs,
      Map<URI, Integer> volumeMap,
      String token)
      throws Exception {
    ExportOrchestrationTask taskCompleter = null;
    try {
      BlockStorageDevice device = getDevice();
      ExportGroup exportGroup = _dbClient.queryObject(ExportGroup.class, exportGroupURI);
      StorageSystem storage = _dbClient.queryObject(StorageSystem.class, storageURI);
      taskCompleter = new ExportOrchestrationTask(exportGroupURI, token);

      if (initiatorURIs != null && !initiatorURIs.isEmpty()) {
        _log.info("export_create: initiator list non-empty");

        // Set up workflow steps.
        Workflow workflow =
            _workflowService.getNewWorkflow(
                MaskingWorkflowEntryPoints.getInstance(), "exportGroupCreate", true, token);

        // Create two steps, one for Zoning, one for the ExportGroup actions.
        // This step is for zoning. It is not specific to a single
        // NetworkSystem, as it will look at all the initiators and targets and compute
        // the zones required (which might be on multiple NetworkSystems.)

        boolean createdSteps =
            determineExportGroupCreateSteps(
                workflow,
                null,
                device,
                storage,
                exportGroup,
                initiatorURIs,
                volumeMap,
                false,
                token);

        String zoningStep =
            generateDeviceSpecificZoningCreateWorkflow(
                workflow, EXPORT_GROUP_MASKING_TASK, exportGroup, null, volumeMap);

        if (createdSteps && null != zoningStep) {
          // Execute the plan and allow the WorkflowExecutor to fire the
          // taskCompleter.
          String successMessage =
              String.format(
                  "ExportGroup successfully applied for StorageArray %s", storage.getLabel());
          workflow.executePlan(taskCompleter, successMessage);
        }
      } else {
        _log.info("export_create: initiator list");
        taskCompleter.ready(_dbClient);
      }
    } catch (DeviceControllerException dex) {
      if (taskCompleter != null) {
        taskCompleter.error(
            _dbClient,
            DeviceControllerException.errors.vmaxExportGroupCreateError(dex.getMessage()));
      }
    } catch (Exception ex) {
      _log.error("ExportGroup Orchestration failed.", ex);
      // TODO add service code here
      if (taskCompleter != null) {
        ServiceError serviceError =
            DeviceControllerException.errors.jobFailedMsg(ex.getMessage(), ex);
        taskCompleter.error(_dbClient, serviceError);
      }
    }
  }