1 files changed, 169 insertions, 0 deletions
diff --git a/dcaedt_be/src/main/java/org/onap/sdc/dcae/composition/impl/CompositionBusinessLogic.java b/dcaedt_be/src/main/java/org/onap/sdc/dcae/composition/impl/CompositionBusinessLogic.java
new file mode 100644
index 0000000..e81ffe0
--- /dev/null
+++ b/dcaedt_be/src/main/java/org/onap/sdc/dcae/composition/impl/CompositionBusinessLogic.java
@@ -0,0 +1,169 @@
+package org.onap.sdc.dcae.composition.impl;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import org.onap.sdc.common.onaplog.Enums.LogLevel;
+import org.onap.sdc.dcae.composition.restmodels.CreateMcResponse;
+import org.onap.sdc.dcae.composition.restmodels.VfcmtData;
+import org.onap.sdc.dcae.composition.restmodels.sdc.Artifact;
+import org.onap.sdc.dcae.composition.restmodels.sdc.ResourceDetailed;
+import org.onap.sdc.dcae.composition.restmodels.sdc.ResourceInstance;
+import org.onap.sdc.dcae.composition.restmodels.sdc.ServiceDetailed;
+import org.onap.sdc.dcae.composition.util.DcaeBeConstants;
+import org.onap.sdc.dcae.enums.ArtifactType;
+import org.onap.sdc.dcae.enums.LifecycleOperationType;
+import org.onap.sdc.dcae.errormng.ActionStatus;
+import org.onap.sdc.dcae.errormng.ErrConfMgr;
+import org.onap.sdc.dcae.utils.Normalizers;
+import org.onap.sdc.dcae.utils.SdcRestClientUtils;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Component;
+import org.springframework.util.Base64Utils;
+import org.springframework.util.CollectionUtils;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+
+@Component
+public class CompositionBusinessLogic extends BaseBusinessLogic {
+
+    private static final String CREATE_DESC = "creating new artifact blueprint on the service vfi";
+    private static final String UPDATE_DESC = "updating artifact blueprint on the service vfi";
+
+    public CreateMcResponse getDataAndComposition(String vfcmtUuid, String requestId) throws IOException {
+        ResourceDetailed vfcmt = sdcRestClient.getResource(vfcmtUuid, requestId);
+        Artifact composition = fetchCdump(vfcmt, requestId);
+        return buildVfcmtAndCdumpResponse(new VfcmtData(vfcmt), composition.getPayloadData());
+    }
+
+    // 1806 US399018 update composition - assumes an artifact already exists (create mode flag for backward compatibility)
+    public ResponseEntity saveComposition(String userId, String vfcmtUuid, String updatedPayload, String requestId, boolean allowCreateNew) {
+
+        boolean undoCheckoutOnFailure = false;
+        ResourceDetailed vfcmt = null;
+        try {
+            vfcmt = sdcRestClient.getResource(vfcmtUuid, requestId);
+            Artifact artifactData = findCdumpArtifactData(vfcmt);
+            if (null == artifactData && !allowCreateNew) {
+                debugLogger.log(LogLevel.DEBUG, this.getClass().getName(), "Composition not found on vfcmt {}", vfcmt.getUuid());
+                return ErrConfMgr.INSTANCE.buildErrorResponse(ActionStatus.MISSING_TOSCA_FILE, "", vfcmt.getName());
+            }
+            if (DcaeBeConstants.LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT != DcaeBeConstants.LifecycleStateEnum.findState(vfcmt.getLifecycleState())) {
+                vfcmt = sdcRestClient.changeResourceLifecycleState(userId, vfcmt.getUuid(), LifecycleOperationType.CHECKOUT.name(), null, requestId);
+                undoCheckoutOnFailure = true;
+            }
+            if (null == artifactData) {
+                artifactData = SdcRestClientUtils.generateDeploymentArtifact("creating composition file", DcaeBeConstants.Composition.fileNames.COMPOSITION_YML, ArtifactType.DCAE_TOSCA.name(), "composition", updatedPayload.getBytes());
+                debugLogger.log(LogLevel.DEBUG, this.getClass().getName(), "creating new composition artifact for MC: {}", vfcmt.getUuid());
+                sdcRestClient.createResourceArtifact(userId, vfcmt.getUuid(), artifactData, requestId);
+            } else {
+                debugLogger.log(LogLevel.DEBUG, this.getClass().getName(), "updating composition artifact for MC: {}", vfcmt.getUuid());
+                artifactData.setDescription("updating composition");
+                artifactData.setPayloadData(Base64Utils.encodeToString(updatedPayload.getBytes()));
+                sdcRestClient.updateResourceArtifact(userId, vfcmt.getUuid(), artifactData, requestId);
+            }
+            return new ResponseEntity<>(sdcRestClient.changeResourceLifecycleState(userId, vfcmt.getUuid(), LifecycleOperationType.CHECKIN.name(), "auto checkin after save composition", requestId), HttpStatus.OK);
+        } catch (Exception e) {
+            errLogger.log(LogLevel.ERROR, this.getClass().getName(), "Save composition failed: {}", e);
+            if(undoCheckoutOnFailure) {
+                rollBack(userId, vfcmt, requestId);
+            }
+            return ErrConfMgr.INSTANCE.handleException(e, ErrConfMgr.ApiType.SAVE_CDUMP);
+        }
+    }
+
+    public Artifact submitComposition(String userId, String context, VfcmtData vfcmtData, String resultBlueprintCreation, String requestId) throws JsonProcessingException {
+
+        // get service / find vfi
+        ServiceDetailed service = sdcRestClient.getAssetMetadata(context, vfcmtData.getServiceUuid(), requestId);
+        ResourceInstance vfi = findVfiOnService(service, vfcmtData.getVfiName());
+        if(null == vfi){
+            errLogger.log(LogLevel.ERROR, this.getClass().getName(), "VF instance {} not found on service {}", vfcmtData.getVfiName(), vfcmtData.getServiceUuid());
+            return null;
+        }
+        // look for existing blueprint details
+		//1802,1806 US412711 - Allow multiple BP from the same flow type on a single VFi - identify existing blueprint by name - for backward compatibility
+		String artifactName = generateBlueprintFileName(vfcmtData.getFlowType(), vfcmtData.getName());
+        Artifact blueprintArtifact = findExistingBlueprint(vfi, artifactName);
+
+        // save blueprint as instance artifact
+        // create mode
+        if(null == blueprintArtifact) {
+			String artifactLabel = "blueprint-".concat(vfcmtData.getFlowType()).concat("-").concat(Normalizers.normalizeComponentName(vfcmtData.getName()));
+            debugLogger.log(LogLevel.DEBUG, this.getClass().getName(), "Service {} does not consist {} ----> createMode", vfcmtData.getServiceUuid(), artifactLabel);
+            blueprintArtifact = SdcRestClientUtils.generateDeploymentArtifact(CREATE_DESC, artifactName , ArtifactType.DCAE_INVENTORY_BLUEPRINT.name(), artifactLabel, resultBlueprintCreation.getBytes());
+            blueprintArtifact = sdcRestClient.createInstanceArtifact(userId, context, vfcmtData.getServiceUuid(), Normalizers.normalizeComponentInstanceName(vfcmtData.getVfiName()), blueprintArtifact, requestId);
+            // update mode
+        } else {
+            blueprintArtifact = updateBlueprint(userId, context, vfcmtData.getServiceUuid(), vfcmtData.getVfiName(), blueprintArtifact, resultBlueprintCreation, requestId);
+            // TODO should this be safe?
+            //1806 US390018 - remove reference to previous version
+            deletePreviousReference(userId, context, service, vfcmtData, requestId);
+        }
+        //1806 US374593 - certify VFCMT after BP generation
+        certifyVfcmt(userId, vfcmtData, requestId);
+        return blueprintArtifact;
+    }
+
+
+    private Artifact updateBlueprint(String userId, String context, String serviceUuid, String vfiName, Artifact blueprintArtifact, String payload, String requestId) throws JsonProcessingException {
+        debugLogger.log(LogLevel.DEBUG, this.getClass().getName(), "Found that service {} already consist of {} ----> updateMode", serviceUuid, blueprintArtifact.getArtifactLabel());
+        blueprintArtifact.setDescription(UPDATE_DESC);
+        blueprintArtifact.setPayloadData(Base64Utils.encodeToString(payload.getBytes()));
+        return sdcRestClient.updateInstanceArtifact(userId, context, serviceUuid, Normalizers.normalizeComponentInstanceName(vfiName), blueprintArtifact, requestId);
+    }
+
+	private Artifact findExistingBlueprint(ResourceInstance vfi, String artifactName) {
+		return CollectionUtils.isEmpty(vfi.getArtifacts()) ? null : vfi.getArtifacts().stream()
+				.filter(p -> Normalizers.normalizeArtifactLabel(artifactName).equals(Normalizers.normalizeArtifactLabel(p.getArtifactName())))
+				.findAny()
+				.orElse(null);
+	}
+
+    //TODO should this be safe or throw?
+    private void deletePreviousReference(String userId, String context, ServiceDetailed service, VfcmtData newReferencedMc, String requestId) {
+    	String normalizedInstanceName = Normalizers.normalizeComponentInstanceName(newReferencedMc.getVfiName());
+        List<String> vfiRefs = sdcRestClient.getMonitoringReferences(context, service.getUuid(), service.getVersion(), requestId).get(normalizedInstanceName);
+        if (null != vfiRefs && 1 < vfiRefs.size()) {
+            debugLogger.log(LogLevel.DEBUG, this.getClass().getName(), "Found {} external monitoring references for vfi {} on service {}:{}", vfiRefs.size(), newReferencedMc.getVfiName(), service.getUuid(), vfiRefs);
+            Collections.synchronizedList(vfiRefs).parallelStream()
+                    .filter(p -> !newReferencedMc.getUuid().equals(p))
+                    .filter(p -> newReferencedMc.getInvariantUUID().equals(sdcRestClient.getResource(p, requestId).getInvariantUUID()))
+                    .forEach(id -> sdcRestClient.deleteExternalMonitoringReference(userId, context, service.getUuid(), normalizedInstanceName, id, requestId));
+        } else {
+			// this shouldn't happen - there should be at least two references registered to the vfi
+            debugLogger.log(LogLevel.WARN, this.getClass().getName(), "Sum Ting Wong. References found: {}", vfiRefs);
+        }
+    }
+
+    private void certifyVfcmt(String userId, VfcmtData vfcmt, String requestId) {
+        String state = vfcmt.getLifecycleState();
+        if(null == state) {
+            debugLogger.log(LogLevel.ERROR, this.getClass().getName(), "Couldn't read Vfcmt lifecycle state");
+            return;
+        }
+        DcaeBeConstants.LifecycleStateEnum lifeCycleState = DcaeBeConstants.LifecycleStateEnum.findState(state);
+        if(null == lifeCycleState) {
+            debugLogger.log(LogLevel.ERROR, this.getClass().getName(), "Undefined lifecycle state: {}", state);
+            return;
+        }
+        try{
+            switch (lifeCycleState){
+            case NOT_CERTIFIED_CHECKOUT:
+                sdcRestClient.changeResourceLifecycleState(userId, vfcmt.getUuid(), LifecycleOperationType.CHECKIN.name(), "check in VFCMT after blueprint successful submission", requestId);
+                sdcRestClient.changeResourceLifecycleState(userId, vfcmt.getUuid(), LifecycleOperationType.CERTIFY.name(), "certify VFCMT after blueprint successful submission", requestId);
+                break;
+            case NOT_CERTIFIED_CHECKIN:
+                sdcRestClient.changeResourceLifecycleState(userId, vfcmt.getUuid(), LifecycleOperationType.CERTIFY.name(), "certify VFCMT after blueprint successful submission", requestId);
+                break;
+            default:
+            }
+        }
+        catch (Exception e){
+            //informative only. no message to user (TBA)
+            debugLogger.log(LogLevel.ERROR, this.getClass().getName(), "Error occurred during vfcmt lifecycle operation: {}", e);
+        }
+    }
+
+}