X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=nokiav2%2Fdriver%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Fvfc%2Fnfvo%2Fdriver%2Fvnfm%2Fsvnfm%2Fnokia%2Fvnfm%2FLifecycleManager.java;h=d543f3ce33bf15f3824491489a6313e63e0253ee;hb=876a4acf6f2e8264bb82e960e9aa886799c4bdb1;hp=e835e35c045a20c0ae2e229e7f92c3426ff31000;hpb=b17042b955489d8a023d09abad5436ff9b900dc3;p=vfc%2Fnfvo%2Fdriver%2Fvnfm%2Fsvnfm.git

diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/LifecycleManager.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/LifecycleManager.java
index e835e35c..d543f3ce 100644
--- a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/LifecycleManager.java
+++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/LifecycleManager.java
@@ -21,12 +21,12 @@ import com.google.gson.Gson;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
-import com.nokia.cbam.lcm.v32.ApiException;
 import com.nokia.cbam.lcm.v32.model.*;
 import com.nokia.cbam.lcm.v32.model.ScaleDirection;
 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.IGrantManager;
 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
+import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.UserVisibleError;
 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
 import org.onap.vnfmdriver.model.*;
 import org.onap.vnfmdriver.model.VimInfo;
@@ -44,6 +44,9 @@ import java.util.concurrent.Executors;
 import static com.google.common.base.Splitter.on;
 import static com.google.common.collect.Iterables.find;
 import static com.google.common.collect.Lists.newArrayList;
+import static com.google.common.collect.Sets.newHashSet;
+import static com.nokia.cbam.lcm.v32.model.InstantiationState.INSTANTIATED;
+import static com.nokia.cbam.lcm.v32.model.OperationStatus.FINISHED;
 import static com.nokia.cbam.lcm.v32.model.OperationType.INSTANTIATE;
 import static com.nokia.cbam.lcm.v32.model.VimInfo.VimInfoTypeEnum.*;
 import static java.lang.Integer.parseInt;
@@ -51,7 +54,7 @@ import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.*;
 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions;
 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
-import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.ILifecycleChangeNotificationManager.*;
+import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager.NEWEST_OPERATIONS_FIRST;
 import static org.slf4j.LoggerFactory.getLogger;
 import static org.springframework.util.StringUtils.isEmpty;
 
@@ -62,6 +65,11 @@ import static org.springframework.util.StringUtils.isEmpty;
 public class LifecycleManager {
     public static final String ONAP_CSAR_ID = "onapCsarId";
     public static final long OPERATION_STATUS_POLLING_INTERVAL_IN_MS = 5000L;
+    /**
+     * The key of the CBAM VNF extension for the identifier of the VNFM in ONAP
+     */
+    public static final String EXTERNAL_VNFM_ID = "externalVnfmId";
+    public static final String SCALE_OPERATION_NAME = "scale";
     private static Logger logger = getLogger(LifecycleManager.class);
     private final CatalogManager catalogManager;
     private final IGrantManager grantManager;
@@ -85,10 +93,18 @@ public class LifecycleManager {
         this.catalogManager = catalogManager;
     }
 
+    /**
+     * @param vimId the VIM identifier
+     * @return the name of the region
+     */
     public static String getRegionName(String vimId) {
         return newArrayList(on(SEPARATOR).split(vimId)).get(1);
     }
 
+    /**
+     * @param vimId the VIM identifier
+     * @return the owner of the cloud
+     */
     public static String getCloudOwner(String vimId) {
         return newArrayList(on(SEPARATOR).split(vimId)).get(0);
     }
@@ -97,6 +113,71 @@ public class LifecycleManager {
         return find(NEWEST_OPERATIONS_FIRST.sortedCopy(operationExecutions), op -> INSTANTIATE.equals(op.getOperationType()));
     }
 
+    /**
+     * Create the VNF. It consists of the following steps
+     * <ul>
+     * <li>upload the VNF package to CBAM package (if not already there)</li>
+     * <li>create the VNF on CBAM</li>
+     * <li>modify attributes of the VNF (add onapCsarId field)</li>
+     * </ul>
+     * The rollback of the failed operation is not implemented
+     * <ul>
+     * <li>delete the VNF if error occurs before instantiation</li>
+     * <li>terminate & delete VNF if error occurs after instantiation</li>
+     * </ul>
+     *
+     * @param vnfmId      the identifier of the VNFM
+     * @param csarId      the identifier of the VNF package
+     * @param vnfName     the name of the VNF
+     * @param description the description of the VNF
+     * @return the VNF creation result
+     */
+    public VnfCreationResult create(String vnfmId, String csarId, String vnfName, String description) {
+        logOperationInput("not yet specified", "creation", csarId);
+        try {
+            CatalogAdapterVnfpackage cbamPackage = catalogManager.preparePackageInCbam(vnfmId, csarId);
+            CreateVnfRequest vnfCreateRequest = new CreateVnfRequest();
+            vnfCreateRequest.setVnfdId(cbamPackage.getVnfdId());
+            vnfCreateRequest.setName(vnfName);
+            vnfCreateRequest.setDescription(description);
+            com.nokia.cbam.lcm.v32.model.VnfInfo vnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsPost(vnfCreateRequest, NOKIA_LCM_API_VERSION).blockingFirst();
+            addVnfdIdToVnfModifyableAttributeExtensions(vnfmId, vnfInfo.getId(), csarId);
+            return new VnfCreationResult(vnfInfo, cbamPackage.getVnfdId());
+        } catch (Exception e) {
+            throw buildFatalFailure(logger, "Unable to create the VNF", e);
+        }
+    }
+
+    private void logOperationInput(String vnfId, String operationName, Object payload) {
+        if (logger.isInfoEnabled()) {
+            logger.info("Starting {} operation on VNF with {} identifier with {} parameter", operationName, vnfId, new Gson().toJson(payload));
+        }
+    }
+
+    /**
+     * Instantiate the VNF
+     *
+     * @param vnfmId               the identifier of the VNFM
+     * @param request              the VNF instantiation request
+     * @param httpResponse         the HTTP response that corresponds to the VNF instantiation request
+     * @param additionalParameters additional parameters
+     * @param vnfId                thr identifier of the VNF
+     * @param vnfdId               the identifier of the VNF package in CBAM
+     * @return the instantiation response
+     */
+    public VnfInstantiateResponse instantiate(String vnfmId, VnfInstantiateRequest request, HttpServletResponse httpResponse, AdditionalParameters additionalParameters, String vnfId, String vnfdId) {
+        logOperationInput(vnfId, "instantiation", request);
+        validateVimType(additionalParameters.getVimType());
+        VnfInstantiateResponse response = new VnfInstantiateResponse();
+        response.setVnfInstanceId(vnfId);
+        String vimId = getVimId(request.getAdditionalParam());
+        JobInfo spawnJob = scheduleExecution(vnfId, httpResponse, "instantiate", jobInfo ->
+                instantiateVnf(vnfmId, request, additionalParameters, vnfdId, vnfId, vimId, jobInfo)
+        );
+        response.setJobId(spawnJob.getJobId());
+        return response;
+    }
+
     /**
      * Instantiate (VF-C terminology) the VNF. It consists of the following steps
      * <ul>
@@ -120,77 +201,62 @@ public class LifecycleManager {
      * @param httpResponse the HTTP response
      * @return the instantiation response
      */
-    public VnfInstantiateResponse instantiate(String vnfmId, VnfInstantiateRequest request, HttpServletResponse httpResponse) {
-        logger.info("Additional parameters for instantiation: " + new Gson().toJson(request.getAdditionalParam()));
-        AdditionalParams additionalParams = convertInstantiationAdditionalParams(request.getVnfPackageId(), request.getAdditionalParam());
-        validateVimType(additionalParams);
-        CatalogAdapterVnfpackage cbamPackage = catalogManager.preparePackageInCbam(vnfmId, request.getVnfPackageId());
-        try {
-            CreateVnfRequest vnfCreateRequest = new CreateVnfRequest();
-            vnfCreateRequest.setVnfdId(cbamPackage.getId());
-            vnfCreateRequest.setName(request.getVnfInstanceName());
-            vnfCreateRequest.setDescription(request.getVnfInstanceDescription());
-            com.nokia.cbam.lcm.v32.model.VnfInfo vnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsPost(vnfCreateRequest, NOKIA_LCM_API_VERSION);
-            VnfInstantiateResponse response = new VnfInstantiateResponse();
-            response.setVnfInstanceId(vnfInfo.getId());
-            //FIXME the vimId should be send during grant response (VFC-604)
-            String vimId = getVimId(request.getAdditionalParam());
-            addVnfdIdToVnfModifyableAttributeExtensions(vnfmId, vnfInfo.getId(), request.getVnfPackageId());
-            JobInfo spawnJob = scheduleExecution(vnfInfo.getId(), httpResponse, "instantiate", (jobInfo) -> {
-                String vnfdContent = catalogManager.getCbamVnfdContent(vnfmId, cbamPackage.getId());
-                GrantVNFResponseVim vim = grantManager.requestGrantForInstantiate(vnfmId, vnfInfo.getId(), vimId, request.getVnfPackageId(), additionalParams.getInstantiationLevel(), vnfdContent, jobInfo.getJobId());
-                if (vim.getVimId() == null) {
-                    fatalFailure(logger, "VF-C did not send VIM identifier in grant response");
-                }
-                VimInfo vimInfo = vimInfoProvider.getVimInfo(vim.getVimId());
-                InstantiateVnfRequest instantiationRequest = new InstantiateVnfRequest();
-                addExernalLinksToRequest(request.getExtVirtualLink(), additionalParams, instantiationRequest, vimId);
-                switch (additionalParams.getVimType()) {
-                    case OPENSTACK_V2_INFO:
-                        instantiationRequest.getVims().add(buildOpenStackV2INFO(vimId, vim, vimInfo));
-                        break;
-                    case OPENSTACK_V3_INFO:
-                        instantiationRequest.getVims().add(buildOpenStackV3INFO(vimId, additionalParams, vim, vimInfo));
-                        break;
-                    case VMWARE_VCLOUD_INFO:
-                        instantiationRequest.getVims().add(buildVcloudInfo(vimId, vim, vimInfo));
-                        break;
-                }
-                instantiationRequest.setFlavourId(getFlavorId(vnfdContent));
-                instantiationRequest.setComputeResourceFlavours(additionalParams.getComputeResourceFlavours());
-                instantiationRequest.setGrantlessMode(true);
-                instantiationRequest.setInstantiationLevelId(additionalParams.getInstantiationLevel());
-                instantiationRequest.setSoftwareImages(additionalParams.getSoftwareImages());
-                instantiationRequest.setZones(additionalParams.getZones());
-                instantiationRequest.setExtManagedVirtualLinks(additionalParams.getExtManagedVirtualLinks());
-                for (ExtVirtualLinkData extVirtualLinkData : additionalParams.getExtVirtualLinks()) {
-                    instantiationRequest.addExtVirtualLinksItem(extVirtualLinkData);
-                }
-                JsonObject root = new Gson().toJsonTree(jobInfo).getAsJsonObject();
-                if (additionalParams.getAdditionalParams() != null && !isEmpty(additionalParams.getAdditionalParams().toString())) {
-                    for (Map.Entry<String, JsonElement> item : new Gson().toJsonTree(additionalParams.getAdditionalParams()).getAsJsonObject().entrySet()) {
-                        root.add(item.getKey(), item.getValue());
-                    }
-                }
-                instantiationRequest.setAdditionalParams(root);
-                OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdInstantiatePost(vnfInfo.getId(), instantiationRequest, NOKIA_LCM_API_VERSION);
-                waitForOperationToFinish(vnfmId, vnfInfo.getId(), operationExecution.getId(), jobInfo.getJobId());
-            });
-            response.setJobId(spawnJob.getJobId());
-            return response;
-        } catch (Exception e) {
-            throw fatalFailure(logger, "Unable to create the VNF", e);
+    public VnfInstantiateResponse createAndInstantiate(String vnfmId, VnfInstantiateRequest request, HttpServletResponse httpResponse) {
+        AdditionalParameters additionalParameters = convertInstantiationAdditionalParams(request.getVnfPackageId(), request.getAdditionalParam());
+        validateVimType(additionalParameters.getVimType());
+        VnfCreationResult creationResult = create(vnfmId, request.getVnfDescriptorId(), request.getVnfInstanceName(), request.getVnfInstanceDescription());
+        return instantiate(vnfmId, request, httpResponse, additionalParameters, creationResult.vnfInfo.getId(), creationResult.vnfdId);
+    }
+
+    private void instantiateVnf(String vnfmId, VnfInstantiateRequest request, AdditionalParameters additionalParameters, String vnfdId, String vnfId, String vimId, JobInfo jobInfo) {
+        String vnfdContent = catalogManager.getCbamVnfdContent(vnfmId, vnfdId);
+        GrantVNFResponseVim vim = grantManager.requestGrantForInstantiate(vnfmId, vnfId, vimId, request.getVnfPackageId(), additionalParameters.getInstantiationLevel(), vnfdContent, jobInfo.getJobId());
+        if (vim.getVimId() == null) {
+            throw buildFatalFailure(logger, "VF-C did not send VIM identifier in grant response");
+        }
+        VimInfo vimInfo = vimInfoProvider.getVimInfo(vim.getVimId());
+        InstantiateVnfRequest instantiationRequest = new InstantiateVnfRequest();
+        addExternalLinksToRequest(request.getExtVirtualLink(), additionalParameters, instantiationRequest, vimId);
+        instantiationRequest.getVims().add(addVim(additionalParameters, vimId, vim, vimInfo));
+        instantiationRequest.setFlavourId(getFlavorId(vnfdContent));
+        instantiationRequest.setComputeResourceFlavours(additionalParameters.getComputeResourceFlavours());
+        instantiationRequest.setGrantlessMode(true);
+        instantiationRequest.setInstantiationLevelId(additionalParameters.getInstantiationLevel());
+        instantiationRequest.setSoftwareImages(additionalParameters.getSoftwareImages());
+        instantiationRequest.setZones(additionalParameters.getZones());
+        instantiationRequest.setExtManagedVirtualLinks(additionalParameters.getExtManagedVirtualLinks());
+        for (ExtVirtualLinkData extVirtualLinkData : additionalParameters.getExtVirtualLinks()) {
+            instantiationRequest.addExtVirtualLinksItem(extVirtualLinkData);
+        }
+        JsonObject root = new Gson().toJsonTree(jobInfo).getAsJsonObject();
+        if (additionalParameters.getAdditionalParams() != null) {
+            for (Map.Entry<String, JsonElement> item : new Gson().toJsonTree(additionalParameters.getAdditionalParams()).getAsJsonObject().entrySet()) {
+                root.add(item.getKey(), item.getValue());
+            }
+        } else {
+            logger.warn("No additional parameters were specified for the operation");
+        }
+        instantiationRequest.setAdditionalParams(root);
+        OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdInstantiatePost(vnfId, instantiationRequest, NOKIA_LCM_API_VERSION).blockingFirst();
+        waitForOperationToFinish(vnfmId, vnfId, operationExecution.getId());
+    }
+
+    private com.nokia.cbam.lcm.v32.model.VimInfo addVim(AdditionalParameters additionalParameters, String vimId, GrantVNFResponseVim vim, VimInfo vimInfo) {
+        if (additionalParameters.getVimType() == OPENSTACK_V2_INFO) {
+            return buildOpenStackV2INFO(vimId, vim, vimInfo);
+
+        } else if (additionalParameters.getVimType() == OPENSTACK_V3_INFO) {
+            return buildOpenStackV3INFO(vimId, additionalParameters, vim, vimInfo);
+
+        } else {
+            //OTHER VIM TYPE is not possible
+            return buildVcloudInfo(vimId, vimInfo);
         }
     }
 
-    private void validateVimType(AdditionalParams additionalParams) {
-        switch (additionalParams.getVimType()) {
-            case OPENSTACK_V2_INFO:
-            case OPENSTACK_V3_INFO:
-            case VMWARE_VCLOUD_INFO:
-                break;
-            default:
-                throw fatalFailure(logger, "Only " + OPENSTACK_V2_INFO + ", " + OPENSTACK_V3_INFO + " and " + VMWARE_VCLOUD_INFO + " is the supported VIM types");
+    private void validateVimType(com.nokia.cbam.lcm.v32.model.VimInfo.VimInfoTypeEnum vimType) {
+        if (com.nokia.cbam.lcm.v32.model.VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO.equals(vimType)) {
+            throw buildFatalFailure(logger, "Only " + OPENSTACK_V2_INFO + ", " + OPENSTACK_V3_INFO + " and " + VMWARE_VCLOUD_INFO + " is the supported VIM types");
         }
     }
 
@@ -198,13 +264,13 @@ public class LifecycleManager {
         return childElement(new Gson().toJsonTree(additionalParams).getAsJsonObject(), "vimId").getAsString();
     }
 
-    private AdditionalParams convertInstantiationAdditionalParams(String csarId, Object additionalParams) {
+    private AdditionalParameters convertInstantiationAdditionalParams(String csarId, Object additionalParams) {
         JsonObject vnfParameters = child(child(new Gson().toJsonTree(additionalParams).getAsJsonObject(), "inputs"), "vnfs");
         if (!vnfParameters.has(csarId)) {
-            throw fatalFailure(logger, "The additional parameter section does not contain setting for VNF with " + csarId + " CSAR id");
+            throw buildFatalFailure(logger, "The additional parameter section does not contain setting for VNF with " + csarId + " CSAR id");
         }
         JsonElement additionalParamsForVnf = vnfParameters.get(csarId);
-        return new Gson().fromJson(additionalParamsForVnf, AdditionalParams.class);
+        return new Gson().fromJson(additionalParamsForVnf, AdditionalParameters.class);
     }
 
     private String getFlavorId(String vnfdContent) {
@@ -214,14 +280,14 @@ public class LifecycleManager {
         return childElement(deploymentFlavorProperties, "flavour_id").getAsString();
     }
 
-    private Set<String> getAcceptableOperationParameters(String vnfdContent, String categroryOfOperation, String operationName) {
+    private Set<Map.Entry<String, JsonElement>> getAcceptableOperationParameters(String vnfdContent, String categroryOfOperation, String operationName) {
         JsonObject root = new Gson().toJsonTree(new Yaml().load(vnfdContent)).getAsJsonObject();
         JsonObject interfaces = child(child(child(root, "topology_template"), "substitution_mappings"), "interfaces");
         JsonObject additionalParameters = child(child(child(child(interfaces, categroryOfOperation), operationName), "inputs"), "additional_parameters");
-        return additionalParameters.keySet();
+        return additionalParameters.entrySet();
     }
 
-    private void addExernalLinksToRequest(List<ExtVirtualLinkInfo> extVirtualLinks, AdditionalParams additionalParams, InstantiateVnfRequest instantiationRequest, String vimId) {
+    private void addExternalLinksToRequest(List<ExtVirtualLinkInfo> extVirtualLinks, AdditionalParameters additionalParameters, InstantiateVnfRequest instantiationRequest, String vimId) {
         for (ExtVirtualLinkInfo extVirtualLink : extVirtualLinks) {
             ExtVirtualLinkData cbamExternalVirtualLink = new ExtVirtualLinkData();
             cbamExternalVirtualLink.setVimId(vimId);
@@ -230,7 +296,7 @@ public class LifecycleManager {
             cbamExternalVirtualLink.setExtVirtualLinkId(extVirtualLink.getVlInstanceId());
             cbamExternalVirtualLink.getExtCps().add(ecp);
             ecp.setCpdId(extVirtualLink.getCpdId());
-            List<NetworkAddress> addresses = additionalParams.getExternalConnectionPointAddresses().get(extVirtualLink.getCpdId());
+            List<NetworkAddress> addresses = additionalParameters.getExternalConnectionPointAddresses().get(extVirtualLink.getCpdId());
             ecp.setAddresses(addresses);
             instantiationRequest.addExtVirtualLinksItem(cbamExternalVirtualLink);
         }
@@ -249,20 +315,20 @@ public class LifecycleManager {
         request.getExtensions().add(externalVnfmIdProperty);
         request.setVnfConfigurableProperties(null);
         try {
-            OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdPatch(vnfId, request, NOKIA_LCM_API_VERSION);
-            waitForOperationToFinish(vnfmId, vnfId, operationExecution.getId(), NOKIA_LCM_API_VERSION);
-        } catch (ApiException e) {
-            throw fatalFailure(logger, "Unable to set the " + ONAP_CSAR_ID + " property on the VNF", e);
+            OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdPatch(vnfId, request, NOKIA_LCM_API_VERSION).blockingFirst();
+            waitForOperationToFinish(vnfmId, vnfId, operationExecution.getId());
+        } catch (Exception e) {
+            throw buildFatalFailure(logger, "Unable to set the " + ONAP_CSAR_ID + " property on the VNF", e);
         }
     }
 
-    private OPENSTACKV3INFO buildOpenStackV3INFO(String vimId, AdditionalParams additionalParams, GrantVNFResponseVim vim, org.onap.vnfmdriver.model.VimInfo vimInfo) {
+    private OPENSTACKV3INFO buildOpenStackV3INFO(String vimId, AdditionalParameters additionalParameters, GrantVNFResponseVim vim, org.onap.vnfmdriver.model.VimInfo vimInfo) {
         OPENSTACKV3INFO openstackv3INFO = new OPENSTACKV3INFO();
         openstackv3INFO.setVimInfoType(OPENSTACK_V3_INFO);
         OpenStackAccessInfoV3 accessInfov3 = new OpenStackAccessInfoV3();
         openstackv3INFO.accessInfo(accessInfov3);
         accessInfov3.setPassword(vimInfo.getPassword());
-        accessInfov3.setDomain(additionalParams.getDomain());
+        accessInfov3.setDomain(additionalParameters.getDomain());
         accessInfov3.setProject(vim.getAccessInfo().getTenant());
         accessInfov3.setRegion(getRegionName(vimId));
         accessInfov3.setUsername(vimInfo.getUserName());
@@ -271,6 +337,9 @@ public class LifecycleManager {
         if (!isEmpty(vimInfo.getSslInsecure())) {
             interfaceInfoV3.setSkipCertificateVerification(Boolean.parseBoolean(vimInfo.getSslInsecure()));
             interfaceInfoV3.setSkipCertificateHostnameCheck(Boolean.parseBoolean(vimInfo.getSslInsecure()));
+        } else {
+            interfaceInfoV3.setSkipCertificateHostnameCheck(true);
+            interfaceInfoV3.setSkipCertificateVerification(true);
         }
         if (!interfaceInfoV3.isSkipCertificateVerification()) {
             interfaceInfoV3.setTrustedCertificates(new ArrayList<>());
@@ -296,6 +365,9 @@ public class LifecycleManager {
         if (!isEmpty(vimInfo.getSslInsecure())) {
             interfaceEndpoint.setSkipCertificateHostnameCheck(Boolean.parseBoolean(vimInfo.getSslInsecure()));
             interfaceEndpoint.setSkipCertificateVerification(Boolean.parseBoolean(vimInfo.getSslInsecure()));
+        } else {
+            interfaceEndpoint.setSkipCertificateHostnameCheck(true);
+            interfaceEndpoint.setSkipCertificateVerification(true);
         }
         interfaceEndpoint.setEndpoint(vimInfo.getUrl());
         if (!interfaceEndpoint.isSkipCertificateVerification()) {
@@ -309,7 +381,7 @@ public class LifecycleManager {
         return openstackv2INFO;
     }
 
-    private VMWAREVCLOUDINFO buildVcloudInfo(String vimId, GrantVNFResponseVim vim, org.onap.vnfmdriver.model.VimInfo vimInfo) {
+    private VMWAREVCLOUDINFO buildVcloudInfo(String vimId, org.onap.vnfmdriver.model.VimInfo vimInfo) {
         VMWAREVCLOUDINFO vcloudInfo = new VMWAREVCLOUDINFO();
         vcloudInfo.setVimInfoType(VMWARE_VCLOUD_INFO);
         VCloudAccessInfo accessInfo = new VCloudAccessInfo();
@@ -321,6 +393,9 @@ public class LifecycleManager {
         if (!isEmpty(vimInfo.getSslInsecure())) {
             interfaceEndpoint.setSkipCertificateHostnameCheck(Boolean.parseBoolean(vimInfo.getSslInsecure()));
             interfaceEndpoint.setSkipCertificateVerification(Boolean.parseBoolean(vimInfo.getSslInsecure()));
+        } else {
+            interfaceEndpoint.setSkipCertificateHostnameCheck(true);
+            interfaceEndpoint.setSkipCertificateVerification(true);
         }
         interfaceEndpoint.setEndpoint(vimInfo.getUrl());
         if (!interfaceEndpoint.isSkipCertificateVerification()) {
@@ -349,9 +424,10 @@ public class LifecycleManager {
      * @return the job for polling the progress of the termination
      */
     public JobInfo terminateVnf(String vnfmId, String vnfId, VnfTerminateRequest request, HttpServletResponse httpResponse) {
-        return scheduleExecution(vnfId, httpResponse, "terminate", (jobInfo) -> {
+        logOperationInput(vnfId, "termination", request);
+        return scheduleExecution(vnfId, httpResponse, "terminate", jobInfo -> {
             TerminateVnfRequest cbamRequest = new TerminateVnfRequest();
-            cbamRequest.setAdditionalParams(jobInfo);
+            //cbamRequest.setAdditionalParams(jobInfo);
             if (request.getTerminationType() == null) {
                 cbamRequest.setTerminationType(TerminationType.FORCEFUL);
             } else {
@@ -362,34 +438,34 @@ public class LifecycleManager {
                     cbamRequest.setTerminationType(TerminationType.FORCEFUL);
                 }
             }
-            com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION);
-            switch (vnf.getInstantiationState()) {
-                case INSTANTIATED:
-                    String vimId = getVimIdFromInstantiationRequest(vnfmId, vnf);
-                    grantManager.requestGrantForTerminate(vnfmId, vnfId, vimId, getVnfdIdFromModifyableAttributes(vnf), vnf, jobInfo.getJobId());
-                    OperationExecution terminationOperation = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdTerminatePost(vnfId, cbamRequest, NOKIA_LCM_API_VERSION);
-                    OperationExecution finishedOperation = waitForOperationToFinish(vnfmId, vnfId, terminationOperation.getId(), jobInfo.getJobId());
-                    switch (finishedOperation.getStatus()) {
-                        case FINISHED:
-                            notificationManager.waitForTerminationToBeProcessed(finishedOperation.getId());
-                            logger.info("Deleting VNF with " + vnfId);
-                            cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdDelete(vnfId, NOKIA_LCM_API_VERSION);
-                            logger.info("VNF with " + vnfId + " has been deleted");
-                            break;
-                        default:
-                            logger.error("Unable to terminate VNF the operation did not finish with success");
-                    }
-                    break;
-                case NOT_INSTANTIATED:
-                    cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdDelete(vnfId, NOKIA_LCM_API_VERSION);
-                    break;
+            com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst();
+            if (vnf.getInstantiationState() == INSTANTIATED) {
+                terminateVnf(vnfmId, vnfId, jobInfo, cbamRequest, vnf);
+            } else {
+                cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdDelete(vnfId, NOKIA_LCM_API_VERSION);
             }
         });
     }
 
-    private String getVimIdFromInstantiationRequest(String vnfmId, com.nokia.cbam.lcm.v32.model.VnfInfo vnf) throws ApiException {
+    private void terminateVnf(String vnfmId, String vnfId, JobInfo jobInfo, TerminateVnfRequest cbamRequest, com.nokia.cbam.lcm.v32.model.VnfInfo vnf) {
+        String vimId = getVimIdFromInstantiationRequest(vnfmId, vnf);
+        grantManager.requestGrantForTerminate(vnfmId, vnfId, vimId, getVnfdIdFromModifyableAttributes(vnf), vnf, jobInfo.getJobId());
+        OperationExecution terminationOperation = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdTerminatePost(vnfId, cbamRequest, NOKIA_LCM_API_VERSION).blockingFirst();
+        OperationExecution finishedOperation = waitForOperationToFinish(vnfmId, vnfId, terminationOperation.getId());
+        if (finishedOperation.getStatus() == FINISHED) {
+            notificationManager.waitForTerminationToBeProcessed(finishedOperation.getId());
+            logger.info("Deleting VNF with {}", vnfId);
+            cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdDelete(vnfId, NOKIA_LCM_API_VERSION);
+            logger.info("VNF with {} has been deleted", vnfId);
+
+        } else {
+            logger.error("Unable to terminate VNF the operation did not finish with success");
+        }
+    }
+
+    private String getVimIdFromInstantiationRequest(String vnfmId, com.nokia.cbam.lcm.v32.model.VnfInfo vnf) {
         OperationExecution lastInstantiation = findLastInstantiation(vnf.getOperationExecutions());
-        Object operationParameters = cbamRestApiProvider.getCbamOperationExecutionApi(vnfmId).operationExecutionsOperationExecutionIdOperationParamsGet(lastInstantiation.getId(), NOKIA_LCM_API_VERSION);
+        Object operationParameters = cbamRestApiProvider.getCbamOperationExecutionApi(vnfmId).operationExecutionsOperationExecutionIdOperationParamsGet(lastInstantiation.getId(), NOKIA_LCM_API_VERSION).blockingFirst();
         JsonObject root = new Gson().toJsonTree(operationParameters).getAsJsonObject();
         return childElement(childElement(root, "vims").getAsJsonArray().get(0).getAsJsonObject(), "id").getAsString();
     }
@@ -405,7 +481,7 @@ public class LifecycleManager {
      */
     public VnfInfo queryVnf(String vnfmId, String vnfId) {
         try {
-            com.nokia.cbam.lcm.v32.model.VnfInfo cbamVnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION);
+            com.nokia.cbam.lcm.v32.model.VnfInfo cbamVnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst();
             VnfInfo vnfInfo = new VnfInfo();
             vnfInfo.setVersion(cbamVnfInfo.getVnfSoftwareVersion());
             vnfInfo.setVnfInstanceId(vnfId);
@@ -418,8 +494,8 @@ public class LifecycleManager {
             vnfInfo.setVnfStatus("ACTIVE");
             vnfInfo.setVnfType("Kuku");
             return vnfInfo;
-        } catch (ApiException e) {
-            throw fatalFailure(logger, "Unable to query VNF (" + vnfId + ")", e);
+        } catch (Exception e) {
+            throw buildFatalFailure(logger, "Unable to query VNF (" + vnfId + ")", e);
         }
     }
 
@@ -441,29 +517,44 @@ public class LifecycleManager {
      * @return the job for tracking the scale
      */
     public JobInfo scaleVnf(String vnfmId, String vnfId, VnfScaleRequest request, HttpServletResponse httpResponse) {
-        logger.info("Scale VNF " + vnfId + " " + new Gson().toJson(request));
-        return scheduleExecution(vnfId, httpResponse, "scale", (jobInfo) -> {
-            ScaleVnfRequest cbamRequest = new ScaleVnfRequest();
-            cbamRequest.setAspectId(request.getAspectId());
-            cbamRequest.setNumberOfSteps(Integer.valueOf(request.getNumberOfSteps()));
-            cbamRequest.setType(convert(request.getType()));
-            com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION);
-            JsonObject root = new Gson().toJsonTree(jobInfo).getAsJsonObject();
-            com.nokia.cbam.lcm.v32.model.VnfInfo cbamVnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION);
-            String vnfdContent = catalogManager.getCbamVnfdContent(vnfmId, cbamVnfInfo.getVnfdId());
-            Set<String> acceptableOperationParameters = getAcceptableOperationParameters(vnfdContent, "Basic", "scale");
-            if (request.getAdditionalParam() != null) {
-                for (Map.Entry<String, JsonElement> item : new Gson().toJsonTree(request.getAdditionalParam()).getAsJsonObject().entrySet()) {
-                    if (acceptableOperationParameters.contains(item.getKey())) {
-                        root.add(item.getKey(), item.getValue());
+        logOperationInput(vnfId, SCALE_OPERATION_NAME, request);
+        return scheduleExecution(vnfId, httpResponse, SCALE_OPERATION_NAME, new AsynchronousExecution() {
+            @Override
+            public void execute(JobInfo jobInfo) {
+                ScaleVnfRequest cbamRequest = new ScaleVnfRequest();
+                cbamRequest.setAspectId(request.getAspectId());
+                cbamRequest.setNumberOfSteps(Integer.valueOf(request.getNumberOfSteps()));
+                cbamRequest.setType(convert(request.getType()));
+                com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst();
+                JsonObject root = new Gson().toJsonTree(jobInfo).getAsJsonObject();
+                com.nokia.cbam.lcm.v32.model.VnfInfo cbamVnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst();
+                String vnfdContent = catalogManager.getCbamVnfdContent(vnfmId, cbamVnfInfo.getVnfdId());
+                Set<Map.Entry<String, JsonElement>> acceptableOperationParameters = getAcceptableOperationParameters(vnfdContent, "Basic", SCALE_OPERATION_NAME);
+                buildAdditionalParameters(request, root, acceptableOperationParameters);
+                cbamRequest.setAdditionalParams(root);
+                grantManager.requestGrantForScale(vnfmId, vnfId, getVimIdFromInstantiationRequest(vnfmId, vnf), getVnfdIdFromModifyableAttributes(vnf), request, jobInfo.getJobId());
+                OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdScalePost(vnfId, cbamRequest, NOKIA_LCM_API_VERSION).blockingFirst();
+                waitForOperationToFinish(vnfmId, vnfId, operationExecution.getId());
+            }
+        });
+    }
+
+    private void buildAdditionalParameters(VnfScaleRequest request, JsonObject root, Set<Map.Entry<String, JsonElement>> acceptableOperationParameters) {
+        if (request.getAdditionalParam() != null) {
+            for (Map.Entry<String, JsonElement> item : new Gson().toJsonTree(request.getAdditionalParam()).getAsJsonObject().entrySet()) {
+                boolean found = false;
+                for (Map.Entry<String, JsonElement> acceptableOperationParameter : acceptableOperationParameters) {
+                    if (acceptableOperationParameter.getKey().equals(item.getKey())) {
+                        found = true;
                     }
                 }
+                if (found) {
+                    root.add(item.getKey(), item.getValue());
+                }
             }
-            cbamRequest.setAdditionalParams(root);
-            grantManager.requestGrantForScale(vnfmId, vnfId, getVimIdFromInstantiationRequest(vnfmId, vnf), getVnfdIdFromModifyableAttributes(vnf), request, jobInfo.getJobId());
-            OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdScalePost(vnfId, cbamRequest, NOKIA_LCM_API_VERSION);
-            waitForOperationToFinish(vnfmId, vnfId, operationExecution.getId(), jobInfo.getJobId());
-        });
+        } else {
+            logger.warn("No additional parameters were passed for scaling");
+        }
     }
 
     /**
@@ -473,21 +564,24 @@ public class LifecycleManager {
      * @param vnfId        the identifier of the VNF
      * @param request      the heal request
      * @param httpResponse the HTTP response
+     * @param vnfcId       the identifer of thr VNFC to be healed
      * @return the job for tracking the heal
      */
-    public JobInfo healVnf(String vnfmId, String vnfId, VnfHealRequest request, HttpServletResponse httpResponse) {
-        return scheduleExecution(vnfId, httpResponse, "heal", (job) -> {
+    public JobInfo healVnf(String vnfmId, String vnfId, VnfHealRequest request, Optional<String> vnfcId, HttpServletResponse httpResponse) {
+        logOperationInput(vnfId, "heal", request);
+        return scheduleExecution(vnfId, httpResponse, "heal", job -> {
             HealVnfRequest cbamHealRequest = new HealVnfRequest();
             Map<String, String> additionalParams = new HashMap<>();
             additionalParams.put("vmName", request.getAffectedvm().getVmname());
             additionalParams.put("action", request.getAction());
             additionalParams.put("jobId", job.getJobId());
+            additionalParams.put("vnfcId", vnfcId.orElse("unknown"));
             cbamHealRequest.setAdditionalParams(additionalParams);
-            com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION);
+            com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst();
             String vimId = getVimIdFromInstantiationRequest(vnfmId, vnf);
             grantManager.requestGrantForHeal(vnfmId, vnfId, vimId, getVnfdIdFromModifyableAttributes(vnf), request, job.getJobId());
-            OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdHealPost(vnfId, cbamHealRequest, NOKIA_LCM_API_VERSION);
-            waitForOperationToFinish(vnfmId, vnfId, operationExecution.getId(), job.getJobId());
+            OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdHealPost(vnfId, cbamHealRequest, NOKIA_LCM_API_VERSION).blockingFirst();
+            waitForOperationToFinish(vnfmId, vnfId, operationExecution.getId());
         });
     }
 
@@ -506,22 +600,20 @@ public class LifecycleManager {
                 logger.error(msg, e);
                 //the job can only be signaled to be finished after the error is logged
                 jobManager.jobFinished(jobInfo.getJobId());
-                throw new RuntimeException(msg, e);
+                throw new UserVisibleError(msg, e);
             }
             jobManager.jobFinished(jobInfo.getJobId());
         });
         return jobInfo;
     }
 
-    private OperationExecution waitForOperationToFinish(String vnfmId, String vnfId, String operationExecutionId, String jobId) {
+    private OperationExecution waitForOperationToFinish(String vnfmId, String vnfId, String operationExecutionId) {
         while (true) {
             try {
-                OperationExecution operationExecution = find(cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdOperationExecutionsGet(vnfId, NOKIA_LCM_API_VERSION), opEx -> operationExecutionId.equals(opEx.getId()));
-                switch (operationExecution.getStatus()) {
-                    case FINISHED:
-                    case FAILED:
-                        logger.debug("Operation finished with " + operationExecution.getId());
-                        return operationExecution;
+                OperationExecution operationExecution = find(cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdOperationExecutionsGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst(), opEx -> operationExecutionId.equals(opEx.getId()));
+                if (hasOperationFinished(operationExecution)) {
+                    logger.debug("Operation finished with " + operationExecution.getId());
+                    return operationExecution;
                 }
             } catch (Exception e) {
                 //swallow exception and retry
@@ -531,7 +623,27 @@ public class LifecycleManager {
         }
     }
 
+    private boolean hasOperationFinished(OperationExecution operationExecution) {
+        return newHashSet(FINISHED, OperationStatus.FAILED).contains(operationExecution.getStatus());
+    }
+
+    @FunctionalInterface
     private interface AsynchronousExecution {
-        void execute(JobInfo job) throws Exception;
+        void execute(JobInfo job);
+    }
+
+    public static class VnfCreationResult {
+        private final com.nokia.cbam.lcm.v32.model.VnfInfo vnfInfo;
+        private final String vnfdId;
+
+        VnfCreationResult(com.nokia.cbam.lcm.v32.model.VnfInfo vnfInfo, String vnfdId) {
+            this.vnfInfo = vnfInfo;
+            this.vnfdId = vnfdId;
+        }
+
+        public com.nokia.cbam.lcm.v32.model.VnfInfo getVnfInfo() {
+            return vnfInfo;
+        }
+
     }
 }