Merge "WorkflowAction, traverseAAIService refactoring stage 1"
authorLukasz Muszkieta <lukasz.muszkieta@nokia.com>
Mon, 6 Jul 2020 15:11:35 +0000 (15:11 +0000)
committerGerrit Code Review <gerrit@onap.org>
Mon, 6 Jul 2020 15:11:35 +0000 (15:11 +0000)
1  2 
bpmn/so-bpmn-tasks/src/main/java/org/onap/so/bpmn/infrastructure/workflow/tasks/WorkflowAction.java

@@@ -144,7 -144,6 +144,7 @@@ public class WorkflowAction 
      private static final String VOLUMEGROUP_DELETE_PATTERN = "(Un|De)(.*)Volume(.*)";
      private static final String VOLUMEGROUP_CREATE_PATTERN = "(A|C)(.*)Volume(.*)";
      private static final String CONTROLLER = "Controller";
 +    private static final String DEFAULT_CLOUD_OWNER = "org.onap.so.cloud-owner";
  
      @Autowired
      protected BBInputSetup bbInputSetup;
      private WorkflowActionExtractResourcesAAI workflowActionUtils;
      @Autowired
      private VrfValidation vrfValidation;
 -
      @Autowired
      private Environment environment;
 -    private String defaultCloudOwner = "org.onap.so.cloud-owner";
  
      public void setBbInputSetupUtils(BBInputSetupUtils bbInputSetupUtils) {
          this.bbInputSetupUtils = bbInputSetupUtils;
                                  cloudOwner, serviceType);
                      }
                      Resource resourceKey = getResourceKey(sIRequest, resourceType);
 -                    if (isConfiguration(orchFlows) && !requestAction.equalsIgnoreCase(CREATEINSTANCE)) {
 -                        List<ExecuteBuildingBlock> configBuildingBlocks = getConfigBuildingBlocks(
 -                                new ConfigBuildingBlocksDataObject().setsIRequest(sIRequest).setOrchFlows(orchFlows)
 -                                        .setRequestId(requestId).setResourceKey(resourceKey).setApiVersion(apiVersion)
 -                                        .setResourceId(resourceId).setRequestAction(requestAction).setaLaCarte(true)
 -                                        .setVnfType(vnfType).setWorkflowResourceIds(workflowResourceIds)
 -                                        .setRequestDetails(requestDetails).setExecution(execution));
 -
 -                        flowsToExecute.addAll(configBuildingBlocks);
 -                    }
 -                    orchFlows = orchFlows.stream().filter(item -> !item.getFlowName().contains(FABRIC_CONFIGURATION))
 -                            .collect(Collectors.toList());
  
                      if ((requestAction.equalsIgnoreCase(REPLACEINSTANCE)
                              || requestAction.equalsIgnoreCase(REPLACEINSTANCERETAINASSIGNMENTS))
                                          .setResourceId(resourceId).setRequestAction(requestAction).setaLaCarte(true)
                                          .setVnfType(vnfType).setWorkflowResourceIds(workflowResourceIds)
                                          .setRequestDetails(requestDetails).setExecution(execution));
 -                    }
 -                    for (OrchestrationFlow orchFlow : orchFlows) {
 -                        ExecuteBuildingBlock ebb = buildExecuteBuildingBlock(orchFlow, requestId, resourceKey,
 -                                apiVersion, resourceId, requestAction, true, vnfType, workflowResourceIds,
 -                                requestDetails, false, null, null, false);
 -                        flowsToExecute.add(ebb);
 +                        for (OrchestrationFlow orchFlow : orchFlows) {
 +                            if (orchFlow.getFlowName().contains(CONFIGURATION)) {
 +                                List<OrchestrationFlow> configOrchFlows = new ArrayList<>();
 +                                configOrchFlows.add(orchFlow);
 +                                List<ExecuteBuildingBlock> configBuildingBlocks =
 +                                        getConfigBuildingBlocks(new ConfigBuildingBlocksDataObject()
 +                                                .setsIRequest(sIRequest).setOrchFlows(configOrchFlows)
 +                                                .setRequestId(requestId).setResourceKey(resourceKey)
 +                                                .setApiVersion(apiVersion).setResourceId(resourceId)
 +                                                .setRequestAction(requestAction).setaLaCarte(true).setVnfType(vnfType)
 +                                                .setWorkflowResourceIds(workflowResourceIds)
 +                                                .setRequestDetails(requestDetails).setExecution(execution));
 +                                flowsToExecute.addAll(configBuildingBlocks);
 +                            } else {
 +                                ExecuteBuildingBlock ebb = buildExecuteBuildingBlock(orchFlow, requestId, resourceKey,
 +                                        apiVersion, resourceId, requestAction, true, vnfType, workflowResourceIds,
 +                                        requestDetails, false, null, null, false);
 +                                flowsToExecute.add(ebb);
 +                            }
 +                        }
 +                    } else {
 +                        if (isConfiguration(orchFlows) && !requestAction.equalsIgnoreCase(CREATEINSTANCE)) {
 +                            List<ExecuteBuildingBlock> configBuildingBlocks =
 +                                    getConfigBuildingBlocks(new ConfigBuildingBlocksDataObject().setsIRequest(sIRequest)
 +                                            .setOrchFlows(orchFlows).setRequestId(requestId).setResourceKey(resourceKey)
 +                                            .setApiVersion(apiVersion).setResourceId(resourceId)
 +                                            .setRequestAction(requestAction).setaLaCarte(true).setVnfType(vnfType)
 +                                            .setWorkflowResourceIds(workflowResourceIds)
 +                                            .setRequestDetails(requestDetails).setExecution(execution));
 +
 +                            flowsToExecute.addAll(configBuildingBlocks);
 +                        }
 +                        orchFlows =
 +                                orchFlows.stream().filter(item -> !item.getFlowName().contains(FABRIC_CONFIGURATION))
 +                                        .collect(Collectors.toList());
 +
 +                        for (OrchestrationFlow orchFlow : orchFlows) {
 +                            ExecuteBuildingBlock ebb = buildExecuteBuildingBlock(orchFlow, requestId, resourceKey,
 +                                    apiVersion, resourceId, requestAction, true, vnfType, workflowResourceIds,
 +                                    requestDetails, false, null, null, false);
 +                            flowsToExecute.add(ebb);
 +                        }
                      }
                  } else {
                      boolean foundRelated = false;
                          if (sIRequest.getRequestDetails().getRequestParameters().getUserParams() != null) {
                              List<Map<String, Object>> userParams =
                                      sIRequest.getRequestDetails().getRequestParameters().getUserParams();
 -                            for (Map<String, Object> params : userParams) {
 -                                if (params.containsKey(USERPARAMSERVICE)) {
 -                                    containsService = true;
 -                                }
 -                            }
 +                            containsService =
 +                                    userParams.stream().anyMatch(param -> param.containsKey(USERPARAMSERVICE));
                              if (containsService) {
                                  traverseUserParamsService(execution, resourceList, sIRequest, requestAction);
                              }
                          if (sIRequest.getRequestDetails().getRequestParameters().getUserParams() != null) {
                              List<Map<String, Object>> userParams =
                                      sIRequest.getRequestDetails().getRequestParameters().getUserParams();
 -                            for (Map<String, Object> params : userParams) {
 -                                if (params.containsKey(USERPARAMSERVICE)) {
 -                                    containsService = true;
 -                                }
 -                            }
 +                            containsService =
 +                                    userParams.stream().anyMatch(param -> param.containsKey(USERPARAMSERVICE));
                          }
                          if (containsService) {
                              foundRelated = traverseUserParamsService(execution, resourceList, sIRequest, requestAction);
                      } else {
                          buildAndThrowException(execution, "Current Macro Request is not supported");
                      }
 -                    String foundObjects = "";
 +                    StringBuilder foundObjects = new StringBuilder();
                      for (WorkflowType type : WorkflowType.values()) {
 -                        foundObjects = foundObjects + type + " - " + resourceList.stream()
 -                                .filter(x -> type.equals(x.getResourceType())).collect(Collectors.toList()).size()
 -                                + "    ";
 +                        foundObjects.append(type).append(" - ").append(
 +                                (int) resourceList.stream().filter(x -> type.equals(x.getResourceType())).count())
 +                                .append("    ");
                      }
 -                    logger.info("Found {}", foundObjects);
 +                    logger.info("Found {}", foundObjects.toString());
  
                      if (orchFlows == null || orchFlows.isEmpty()) {
                          orchFlows = queryNorthBoundRequestCatalogDb(execution, requestAction, resourceType, isALaCarte,
                      // By default, enable homing at VNF level for CREATEINSTANCE and ASSIGNINSTANCE
                      if (resourceType == WorkflowType.SERVICE
                              && (requestAction.equals(CREATEINSTANCE) || requestAction.equals(ASSIGNINSTANCE))
 -                            && !resourceList.stream().filter(x -> WorkflowType.VNF.equals(x.getResourceType()))
 -                                    .collect(Collectors.toList()).isEmpty()) {
 +                            && resourceList.stream().anyMatch(x -> WorkflowType.VNF.equals(x.getResourceType()))) {
                          execution.setVariable("homing", true);
                          execution.setVariable("calledHoming", false);
                      }
                          sIRequest.getRequestDetails().getRequestParameters().getUserParams();
                  for (Map<String, Object> params : userParams) {
                      if (params.containsKey(HOMINGSOLUTION)) {
 -                        if ("none".equals(params.get(HOMINGSOLUTION))) {
 -                            execution.setVariable("homing", false);
 -                        } else {
 -                            execution.setVariable("homing", true);
 -                        }
 +                        execution.setVariable("homing", !"none".equals(params.get(HOMINGSOLUTION)));
                      }
                  }
              }
              return cloudConfiguration.getCloudOwner();
          }
          logger.warn("cloud owner value not found in request details, it will be set as default");
 -        return environment.getProperty(defaultCloudOwner);
 +        return environment.getProperty(DEFAULT_CLOUD_OWNER);
      }
  
      protected <T> List<T> getRelatedResourcesInVfModule(String vnfId, String vfModuleId, Class<T> resultClass,
          String vfModuleId = dataObj.getWorkflowResourceIds().getVfModuleId();
  
          String vnfCustomizationUUID = bbInputSetupUtils.getAAIGenericVnf(vnfId).getModelCustomizationId();
 -        String vfModuleCustomizationUUID = "";
 +        String vfModuleCustomizationUUID;
          org.onap.aai.domain.yang.VfModule aaiVfModule = bbInputSetupUtils.getAAIVfModule(vnfId, vfModuleId);
  
          if (aaiVfModule == null) {
          boolean rebuildVolumeGroups = false;
          if (dataObj.getRequestDetails().getRequestParameters() != null
                  && dataObj.getRequestDetails().getRequestParameters().getRebuildVolumeGroups() != null) {
 -            rebuildVolumeGroups =
 -                    dataObj.getRequestDetails().getRequestParameters().getRebuildVolumeGroups().booleanValue();
 +            rebuildVolumeGroups = dataObj.getRequestDetails().getRequestParameters().getRebuildVolumeGroups();
          }
  
          Optional<VolumeGroup> volumeGroupFromVfModule =
          }
          Relationships relationships = relationshipsOp.get();
          List<AAIResultWrapper> vnfcResultWrappers = relationships.getByType(AAIObjectType.VNFC);
 -        if (vnfcResultWrappers.size() > 1 || vnfcResultWrappers.isEmpty()) {
 +        if (vnfcResultWrappers.size() != 1) {
              logger.debug("Too many vnfcs or no vnfc found that are related to configuration");
          }
          Optional<Vnfc> vnfcOp = vnfcResultWrappers.get(0).asBean(Vnfc.class);
              logger.debug(pair.getValue0() + ", " + pair.getValue1());
          }
  
 -        Arrays.stream(WorkflowType.values()).filter(type -> !type.equals(WorkflowType.SERVICE)).forEach(type -> {
 -            resourceList.stream().filter(resource -> type.equals(resource.getResourceType()))
 -                    .forEach(resource -> updateWorkflowResourceIds(flowsToExecute, type, resource.getResourceId(),
 -                            retrieveAAIResourceId(aaiResourceIds, type), null, serviceInstanceId));
 -        });
 +        Arrays.stream(WorkflowType.values()).filter(type -> !type.equals(WorkflowType.SERVICE))
 +                .forEach(type -> resourceList.stream().filter(resource -> type.equals(resource.getResourceType()))
 +                        .forEach(resource -> updateWorkflowResourceIds(flowsToExecute, type, resource.getResourceId(),
 +                                retrieveAAIResourceId(aaiResourceIds, type), null, serviceInstanceId)));
      }
  
      private String retrieveAAIResourceId(List<Pair<WorkflowType, String>> aaiResourceIds, WorkflowType resource) {
  
      private void generateResourceIds(List<ExecuteBuildingBlock> flowsToExecute, List<Resource> resourceList,
              String serviceInstanceId) {
 -        Arrays.stream(WorkflowType.values()).filter(type -> !type.equals(WorkflowType.SERVICE)).forEach(type -> {
 -            resourceList.stream().filter(resource -> type.equals(resource.getResourceType()))
 -                    .forEach(resource -> updateWorkflowResourceIds(flowsToExecute, type, resource.getResourceId(), null,
 -                            resource.getVirtualLinkKey(), serviceInstanceId));
 -        });
 +        Arrays.stream(WorkflowType.values()).filter(type -> !type.equals(WorkflowType.SERVICE))
 +                .forEach(type -> resourceList.stream().filter(resource -> type.equals(resource.getResourceType()))
 +                        .forEach(resource -> updateWorkflowResourceIds(flowsToExecute, type, resource.getResourceId(),
 +                                null, resource.getVirtualLinkKey(), serviceInstanceId)));
      }
  
      protected void updateWorkflowResourceIds(List<ExecuteBuildingBlock> flowsToExecute, WorkflowType resourceType,
      }
  
      private boolean isNetworkCollectionInTheResourceList(List<Resource> resourceList) {
 -        return !(resourceList.stream().filter(x -> WorkflowType.NETWORKCOLLECTION == x.getResourceType())
 -                .collect(Collectors.toList()).isEmpty());
 +        return resourceList.stream().anyMatch(x -> WorkflowType.NETWORKCOLLECTION == x.getResourceType());
      }
  
      private boolean isVnfCustomizationsInTheService(org.onap.so.db.catalog.beans.Service service) {
              org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance serviceInstanceMSO =
                      bbInputSetup.getExistingServiceInstance(serviceInstanceAAI);
              resourceList.add(new Resource(WorkflowType.SERVICE, serviceInstanceMSO.getServiceInstanceId(), false));
-             if (serviceInstanceMSO.getVnfs() != null) {
-                 for (org.onap.so.bpmn.servicedecomposition.bbobjects.GenericVnf vnf : serviceInstanceMSO.getVnfs()) {
-                     aaiResourceIds.add(new Pair<>(WorkflowType.VNF, vnf.getVnfId()));
-                     resourceList.add(new Resource(WorkflowType.VNF, vnf.getVnfId(), false));
-                     if (vnf.getVfModules() != null) {
-                         for (VfModule vfModule : vnf.getVfModules()) {
-                             aaiResourceIds.add(new Pair<>(WorkflowType.VFMODULE, vfModule.getVfModuleId()));
-                             Resource resource = new Resource(WorkflowType.VFMODULE, vfModule.getVfModuleId(), false);
-                             resource.setBaseVfModule(vfModule.getModelInfoVfModule().getIsBaseBoolean());
-                             resourceList.add(resource);
-                         }
-                     }
-                     if (vnf.getVolumeGroups() != null) {
-                         for (org.onap.so.bpmn.servicedecomposition.bbobjects.VolumeGroup volumeGroup : vnf
-                                 .getVolumeGroups()) {
-                             aaiResourceIds.add(new Pair<>(WorkflowType.VOLUMEGROUP, volumeGroup.getVolumeGroupId()));
-                             resourceList
-                                     .add(new Resource(WorkflowType.VOLUMEGROUP, volumeGroup.getVolumeGroupId(), false));
-                         }
-                     }
-                 }
-             }
+             traverseServiceInstanceMSOVnfs(resourceList, aaiResourceIds, serviceInstanceMSO);
              if (serviceInstanceMSO.getNetworks() != null) {
                  for (org.onap.so.bpmn.servicedecomposition.bbobjects.L3Network network : serviceInstanceMSO
                          .getNetworks()) {
          }
      }
  
+     private void traverseServiceInstanceMSOVnfs(List<Resource> resourceList,
+             List<Pair<WorkflowType, String>> aaiResourceIds,
+             org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance serviceInstanceMSO) {
+         if (serviceInstanceMSO.getVnfs() == null) {
+             return;
+         }
+         for (org.onap.so.bpmn.servicedecomposition.bbobjects.GenericVnf vnf : serviceInstanceMSO.getVnfs()) {
+             aaiResourceIds.add(new Pair<>(WorkflowType.VNF, vnf.getVnfId()));
+             resourceList.add(new Resource(WorkflowType.VNF, vnf.getVnfId(), false));
+             traverseVnfModules(resourceList, aaiResourceIds, vnf);
+             if (vnf.getVolumeGroups() != null) {
+                 for (org.onap.so.bpmn.servicedecomposition.bbobjects.VolumeGroup volumeGroup : vnf.getVolumeGroups()) {
+                     aaiResourceIds.add(new Pair<>(WorkflowType.VOLUMEGROUP, volumeGroup.getVolumeGroupId()));
+                     resourceList.add(new Resource(WorkflowType.VOLUMEGROUP, volumeGroup.getVolumeGroupId(), false));
+                 }
+             }
+         }
+     }
+     private void traverseVnfModules(List<Resource> resourceList, List<Pair<WorkflowType, String>> aaiResourceIds,
+             org.onap.so.bpmn.servicedecomposition.bbobjects.GenericVnf vnf) {
+         if (vnf.getVfModules() == null) {
+             return;
+         }
+         for (VfModule vfModule : vnf.getVfModules()) {
+             aaiResourceIds.add(new Pair<>(WorkflowType.VFMODULE, vfModule.getVfModuleId()));
+             Resource resource = new Resource(WorkflowType.VFMODULE, vfModule.getVfModuleId(), false);
+             resource.setBaseVfModule(vfModule.getModelInfoVfModule().getIsBaseBoolean());
+             resourceList.add(resource);
+         }
+     }
      private void traverseAAIVnf(DelegateExecution execution, List<Resource> resourceList, String serviceId,
              String vnfId, List<Pair<WorkflowType, String>> aaiResourceIds) {
          try {
                                              foundVfModuleOrVG = true;
                                              Resource resource = new Resource(WorkflowType.VFMODULE,
                                                      vfModuleCustomization.getModelCustomizationUUID(), false);
 -                                            if (vfModuleCustomization.getVfModule().getIsBase() != null
 -                                                    && vfModuleCustomization.getVfModule().getIsBase()) {
 -                                                resource.setBaseVfModule(true);
 -                                            } else {
 -                                                resource.setBaseVfModule(false);
 -                                            }
 +                                            resource.setBaseVfModule(
 +                                                    vfModuleCustomization.getVfModule().getIsBase() != null
 +                                                            && vfModuleCustomization.getVfModule().getIsBase());
                                              resourceList.add(resource);
                                              if (vfModule.getModelInfo() != null
                                                      && vfModule.getModelInfo().getModelCustomizationUuid() != null) {
                          true, false);
              } else if (orchFlow.getFlowName().contains(VFMODULE) || (orchFlow.getFlowName().contains(CONTROLLER)
                      && (VFMODULE).equalsIgnoreCase(orchFlow.getBpmnScope()))) {
 -                List<Resource> vfModuleResourcesSorted = null;
 +                List<Resource> vfModuleResourcesSorted;
                  if (requestAction.equals(CREATEINSTANCE) || requestAction.equals(ASSIGNINSTANCE)
                          || requestAction.equals("activateInstance")) {
                      vfModuleResourcesSorted = sortVfModulesByBaseFirst(resourceList.stream()
                      vfModuleResourcesSorted = sortVfModulesByBaseLast(resourceList.stream()
                              .filter(x -> WorkflowType.VFMODULE == x.getResourceType()).collect(Collectors.toList()));
                  }
 -                for (int i = 0; i < vfModuleResourcesSorted.size(); i++) {
 -                    flowsToExecute.add(buildExecuteBuildingBlock(orchFlow, requestId, vfModuleResourcesSorted.get(i),
 -                            apiVersion, resourceId, requestAction, false, vnfType, workflowResourceIds, requestDetails,
 -                            false, null, null, false));
 +                for (Resource resource : vfModuleResourcesSorted) {
 +                    flowsToExecute.add(buildExecuteBuildingBlock(orchFlow, requestId, resource, apiVersion, resourceId,
 +                            requestAction, false, vnfType, workflowResourceIds, requestDetails, false, null, null,
 +                            false));
                  }
              } else if (orchFlow.getFlowName().contains(VOLUMEGROUP)) {
                  if (requestAction.equalsIgnoreCase(REPLACEINSTANCE)
                  new BuildingBlock().setBpmnFlowName(orchFlow.getFlowName()).setMsoId(UUID.randomUUID().toString())
                          .setIsVirtualLink(isVirtualLink).setVirtualLinkKey(virtualLinkKey)
                          .setKey(Optional.ofNullable(resource).map(Resource::getResourceId).orElse(""));
 -        Optional.ofNullable(orchFlow.getBpmnAction()).ifPresent(action -> buildingBlock.setBpmnAction(action));
 -        Optional.ofNullable(orchFlow.getBpmnScope()).ifPresent(scope -> buildingBlock.setBpmnScope(scope));
 +        Optional.ofNullable(orchFlow.getBpmnAction()).ifPresent(buildingBlock::setBpmnAction);
 +        Optional.ofNullable(orchFlow.getBpmnScope()).ifPresent(buildingBlock::setBpmnScope);
  
          if (resource != null
                  && (orchFlow.getFlowName().contains(VOLUMEGROUP) && (requestAction.equalsIgnoreCase(REPLACEINSTANCE)
                  .setRequestDetails(requestDetails);
  
          if (resource != null && (isConfiguration || resource.getResourceType().equals(WorkflowType.CONFIGURATION))) {
 -            ConfigurationResourceKeys configurationResourceKeys = new ConfigurationResourceKeys();
 -            Optional.ofNullable(vnfcName).ifPresent(name -> configurationResourceKeys.setVnfcName(name));
 -            configurationResourceKeys.setCvnfcCustomizationUUID(resource.getCvnfModuleCustomizationId());
 -            configurationResourceKeys.setVfModuleCustomizationUUID(resource.getVfModuleCustomizationId());
 -            configurationResourceKeys.setVnfResourceCustomizationUUID(resource.getVnfCustomizationId());
 +            ConfigurationResourceKeys configurationResourceKeys = getConfigurationResourceKeys(resource, vnfcName);
              executeBuildingBlock.setConfigurationResourceKeys(configurationResourceKeys);
          }
          return executeBuildingBlock;
      }
  
 +    private ConfigurationResourceKeys getConfigurationResourceKeys(Resource resource, String vnfcName) {
 +        ConfigurationResourceKeys configurationResourceKeys = new ConfigurationResourceKeys();
 +        Optional.ofNullable(vnfcName).ifPresent(configurationResourceKeys::setVnfcName);
 +        configurationResourceKeys.setCvnfcCustomizationUUID(resource.getCvnfModuleCustomizationId());
 +        configurationResourceKeys.setVfModuleCustomizationUUID(resource.getVfModuleCustomizationId());
 +        configurationResourceKeys.setVnfResourceCustomizationUUID(resource.getVnfCustomizationId());
 +        return configurationResourceKeys;
 +    }
 +
      protected List<OrchestrationFlow> queryNorthBoundRequestCatalogDb(DelegateExecution execution, String requestAction,
              WorkflowType resourceName, boolean aLaCarte, String cloudOwner) {
          return this.queryNorthBoundRequestCatalogDb(execution, requestAction, resourceName, aLaCarte, cloudOwner, "");
      protected List<OrchestrationFlow> queryNorthBoundRequestCatalogDb(DelegateExecution execution, String requestAction,
              WorkflowType resourceName, boolean aLaCarte, String cloudOwner, String serviceType) {
          List<OrchestrationFlow> listToExecute = new ArrayList<>();
 -        NorthBoundRequest northBoundRequest = null;
 +        NorthBoundRequest northBoundRequest;
          if (serviceType.equalsIgnoreCase(SERVICE_TYPE_TRANSPORT)
                  || serviceType.equalsIgnoreCase(SERVICE_TYPE_BONDING)) {
              northBoundRequest =
      }
  
      protected String validateServiceResourceIdInAAI(String generatedResourceId, String instanceName,
 -            RequestDetails reqDetails) throws DuplicateNameException, MultipleObjectsFoundException {
 +            RequestDetails reqDetails) throws DuplicateNameException {
          String globalCustomerId = reqDetails.getSubscriberInfo().getGlobalSubscriberId();
          String serviceType = reqDetails.getRequestParameters().getSubscriptionServiceType();
          if (instanceName != null) {
      }
  
      protected String validateVnfResourceIdInAAI(String generatedResourceId, String instanceName,
 -            RequestDetails reqDetails, WorkflowResourceIds workflowResourceIds)
 -            throws DuplicateNameException, MultipleObjectsFoundException {
 +            RequestDetails reqDetails, WorkflowResourceIds workflowResourceIds) throws DuplicateNameException {
          Optional<GenericVnf> vnf = bbInputSetupUtils
                  .getRelatedVnfByNameFromServiceInstance(workflowResourceIds.getServiceInstanceId(), instanceName);
          if (vnf.isPresent()) {
      }
  
      protected String validateVolumeGroupResourceIdInAAI(String generatedResourceId, String instanceName,
 -            RequestDetails reqDetails, WorkflowResourceIds workflowResourceIds)
 -            throws DuplicateNameException, MultipleObjectsFoundException {
 +            RequestDetails reqDetails, WorkflowResourceIds workflowResourceIds) throws DuplicateNameException {
          Optional<VolumeGroup> volumeGroup =
                  bbInputSetupUtils.getRelatedVolumeGroupByNameFromVnf(workflowResourceIds.getVnfId(), instanceName);
          if (volumeGroup.isPresent()) {
      }
  
      protected String validateConfigurationResourceIdInAAI(String generatedResourceId, String instanceName,
 -            RequestDetails reqDetails, WorkflowResourceIds workflowResourceIds)
 -            throws DuplicateNameException, MultipleObjectsFoundException {
 +            RequestDetails reqDetails, WorkflowResourceIds workflowResourceIds) throws DuplicateNameException {
          Optional<org.onap.aai.domain.yang.Configuration> configuration =
                  bbInputSetupUtils.getRelatedConfigurationByNameFromServiceInstance(
                          workflowResourceIds.getServiceInstanceId(), instanceName);