Switch over BBRollback to use DB lookups.

Issue-ID: SO-3793

Use feature provided by SO-3720.

Signed-off-by: Oleg Mitsura <oleg.mitsura@amdocs.com>
Change-Id: I31f2c00df738c37d04e5ad901dd94c9c6d4b147e

2 files changed, 173 insertions, 74 deletions

diff --git a/bpmn/so-bpmn-tasks/src/main/java/org/onap/so/bpmn/infrastructure/workflow/tasks/WorkflowActionBBTasks.java b/bpmn/so-bpmn-tasks/src/main/java/org/onap/so/bpmn/infrastructure/workflow/tasks/WorkflowActionBBTasks.java
index b76cf1eb5f..ed41270da9 100644
--- a/bpmn/so-bpmn-tasks/src/main/java/org/onap/so/bpmn/infrastructure/workflow/tasks/WorkflowActionBBTasks.java
+++ b/bpmn/so-bpmn-tasks/src/main/java/org/onap/so/bpmn/infrastructure/workflow/tasks/WorkflowActionBBTasks.java
@@ -23,6 +23,7 @@ package org.onap.so.bpmn.infrastructure.workflow.tasks;
 import java.sql.Timestamp;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.UUID;
 import java.util.stream.Collectors;
@@ -49,6 +50,7 @@ import org.onap.so.bpmn.servicedecomposition.entities.ExecuteBuildingBlock;
 import org.onap.so.bpmn.servicedecomposition.entities.WorkflowResourceIds;
 import org.onap.so.bpmn.servicedecomposition.tasks.BBInputSetupUtils;
 import org.onap.so.client.exception.ExceptionBuilder;
+import org.onap.so.db.catalog.beans.BuildingBlockRollback;
 import org.onap.so.db.catalog.beans.CvnfcConfigurationCustomization;
 import org.onap.so.db.catalog.client.CatalogDbClient;
 import org.onap.so.db.request.beans.InfraActiveRequests;
@@ -80,6 +82,9 @@ public class WorkflowActionBBTasks {
     private static final String VFMODULE = "VfModule";
     private static final String CONFIGURATION_PATTERN = "(Ad|De)(.*)FabricConfiguration(.*)";
     protected String maxRetries = "mso.rainyDay.maxRetries";
+    private static final String ROLLBACK_TO_ASSIGNED = "RollbackToAssigned";
+    private static final String UNASSIGN = "Unassign";
+    private static final String DELETE = "Delete";
     private static final Logger logger = LoggerFactory.getLogger(WorkflowActionBBTasks.class);
 
     @Autowired
@@ -299,94 +304,98 @@ public class WorkflowActionBBTasks {
     public void rollbackExecutionPath(DelegateExecution execution) {
         final String action = (String) execution.getVariable(BBConstants.G_ACTION);
         final String resourceName = (String) execution.getVariable("resourceName");
-        if (!(boolean) execution.getVariable("isRollback")) {
-            List<ExecuteBuildingBlock> flowsToExecute =
-                    (List<ExecuteBuildingBlock>) execution.getVariable("flowsToExecute");
+        if ((boolean) execution.getVariable("isRollback")) {
+            workflowAction.buildAndThrowException(execution,
+                    "Rollback has already been called. Cannot rollback a request that is currently in the rollback state.");
+        }
+        List<ExecuteBuildingBlock> flowsToExecute =
+                (List<ExecuteBuildingBlock>) execution.getVariable("flowsToExecute");
 
-            List<ExecuteBuildingBlock> flowsToExecuteChangeBBs = flowsToExecute.stream()
-                    .filter(buildingBlock -> buildingBlock.getBuildingBlock().getBpmnFlowName().startsWith("Change"))
-                    .collect(Collectors.toList());
+        List<ExecuteBuildingBlock> flowsToExecuteChangeBBs = flowsToExecute.stream()
+                .filter(buildingBlock -> buildingBlock.getBuildingBlock().getBpmnFlowName().startsWith("Change"))
+                .collect(Collectors.toList());
+        List<ExecuteBuildingBlock> rollbackFlows = new ArrayList<>();
+        int currentSequence = (int) execution.getVariable(BBConstants.G_CURRENT_SEQUENCE);
+        int listSize = flowsToExecute.size();
+        List<BuildingBlockRollback> bbRollbackList = catalogDbClient.getBuildingBlockRollbackEntries();
 
-            List<ExecuteBuildingBlock> rollbackFlows = new ArrayList<>();
-            int currentSequence = (int) execution.getVariable(BBConstants.G_CURRENT_SEQUENCE);
-            int listSize = flowsToExecute.size();
+        for (int i = listSize - 1; i >= 0; i--) {
+            if (i > currentSequence - 1) {
+                flowsToExecute.remove(i);
+            } else {
+                // filter bbRollbackList for bbrollback, and check if action exists, then filter by action
+                BuildingBlock bb = flowsToExecute.get(i).getBuildingBlock();
+                String flowName = bb.getBpmnFlowName();
+                String scope = Objects.toString(bb.getBpmnScope(), "");
+                String bbAction = Objects.toString(bb.getBpmnAction(), "");
+                ExecuteBuildingBlock currentBB = (ExecuteBuildingBlock) execution.getVariable("buildingBlock");
 
-            for (int i = listSize - 1; i >= 0; i--) {
-                if (i > currentSequence - 1) {
-                    flowsToExecute.remove(i);
-                } else {
-                    String flowName = flowsToExecute.get(i).getBuildingBlock().getBpmnFlowName();
-                    if (flowName.startsWith("Assign")) {
-                        flowName = flowName.replaceFirst("Assign", "Unassign");
-                    } else if (flowName.startsWith("Create")) {
-                        flowName = flowName.replaceFirst("Create", "Delete");
-                    } else if (flowName.startsWith("Activate")) {
-                        flowName = flowName.replaceFirst("Activate", "Deactivate");
-                    } else if (flowName.startsWith("Add")) {
-                        flowName = flowName.replaceFirst("Add", "Delete");
-                    } else if (flowName.startsWith("VNF")) {
-                        if (flowName.startsWith("VNFSet")) {
-                            flowName = flowName.replaceFirst("VNFSet", "VNFUnset");
-                        } else if (flowName.startsWith("VNFLock")) {
-                            flowName = flowName.replaceFirst("VNFLock", "VNFUnlock");
-                        } else if (flowName.startsWith("VNFStop")) {
-                            flowName = flowName.replaceFirst("VNFStop", "VNFStart");
-                        } else if (flowName.startsWith("VNFQuiesce")) {
-                            flowName = flowName.replaceFirst("VNFQuiesce", "VNFResume");
-                        } else {
-                            continue;
-                        }
-                    } else {
-                        continue;
+                List<BuildingBlockRollback> filteredList = bbRollbackList.stream()
+                        .filter(k -> k.getBuildingBlockName().equals((flowName))).collect(Collectors.toList());
+                Optional<BuildingBlockRollback> matchedBBRollback =
+                        "".equals(bbAction) ? filteredList.stream().findFirst()
+                                : filteredList.stream().filter(k -> bbAction.equals(k.getAction())).findFirst();
+                if (matchedBBRollback.isPresent()) {
+                    final BuildingBlockRollback buildingBlockRollbackItem = matchedBBRollback.get();
+                    String rollbackFlow = buildingBlockRollbackItem.getRollbackBuildingBlockName();
+                    flowsToExecute.get(i).getBuildingBlock().setBpmnFlowName(rollbackFlow);
+                    // if we have an action, search the filtered list for the bbrollback that matches the given action.
+                    if (null != buildingBlockRollbackItem.getRollbackAction()) {
+                        logger.info("Setting rollback_action {} for BB: {} action: {}",
+                                buildingBlockRollbackItem.getRollbackAction(),
+                                buildingBlockRollbackItem.getBuildingBlockName(),
+                                buildingBlockRollbackItem.getAction());
+                        flowsToExecute.get(i).getBuildingBlock()
+                                .setBpmnAction(buildingBlockRollbackItem.getRollbackAction());
                     }
-                    flowsToExecute.get(i).getBuildingBlock().setBpmnFlowName(flowName);
                     rollbackFlows.add(flowsToExecute.get(i));
                 }
             }
+        }
 
-            String handlingCode = (String) execution.getVariable(HANDLINGCODE);
-            List<ExecuteBuildingBlock> rollbackFlowsFiltered = new ArrayList<>(rollbackFlows);
-            if ("RollbackToAssigned".equals(handlingCode) || ROLLBACKTOCREATED.equals(handlingCode)
-                    || ROLLBACKTOCREATEDNOCONFIGURATION.equals(handlingCode)) {
-                for (ExecuteBuildingBlock rollbackFlow : rollbackFlows) {
-                    if (rollbackFlow.getBuildingBlock().getBpmnFlowName().contains("Unassign")
-                            && !rollbackFlow.getBuildingBlock().getBpmnFlowName().contains("FabricConfiguration")) {
-                        rollbackFlowsFiltered.remove(rollbackFlow);
-                    } else if (rollbackFlow.getBuildingBlock().getBpmnFlowName().contains("Delete")
-                            && ((!rollbackFlow.getBuildingBlock().getBpmnFlowName().contains("FabricConfiguration")
-                                    && (ROLLBACKTOCREATED.equals(handlingCode)
-                                            || ROLLBACKTOCREATEDNOCONFIGURATION.equals(handlingCode)))
-                                    || (rollbackFlow.getBuildingBlock().getBpmnFlowName()
-                                            .contains("FabricConfiguration")
-                                            && ROLLBACKTOCREATEDNOCONFIGURATION.equals(handlingCode)))) {
-                        rollbackFlowsFiltered.remove(rollbackFlow);
-                    }
+        String handlingCode = (String) execution.getVariable(HANDLINGCODE);
+        List<ExecuteBuildingBlock> rollbackFlowsFiltered = new ArrayList<>(rollbackFlows);
+        if (ROLLBACK_TO_ASSIGNED.equals(handlingCode) || ROLLBACKTOCREATED.equals(handlingCode)
+                || ROLLBACKTOCREATEDNOCONFIGURATION.equals(handlingCode)) {
+            for (ExecuteBuildingBlock rollbackFlow : rollbackFlows) {
+                if (rollbackFlow.getBuildingBlock().getBpmnFlowName().contains(UNASSIGN)
+                        && !rollbackFlow.getBuildingBlock().getBpmnFlowName().contains(FABRIC_CONFIGURATION)) {
+                    rollbackFlowsFiltered.remove(rollbackFlow);
+                } else if (rollbackFlow.getBuildingBlock().getBpmnFlowName().contains(DELETE)
+                        && ((!rollbackFlow.getBuildingBlock().getBpmnFlowName().contains(FABRIC_CONFIGURATION)
+                                && (ROLLBACKTOCREATED.equals(handlingCode)
+                                        || ROLLBACKTOCREATEDNOCONFIGURATION.equals(handlingCode)))
+                                || (rollbackFlow.getBuildingBlock().getBpmnFlowName().contains(FABRIC_CONFIGURATION)
+                                        && ROLLBACKTOCREATEDNOCONFIGURATION.equals(handlingCode)))) {
+                    rollbackFlowsFiltered.remove(rollbackFlow);
                 }
             }
+        }
 
-            List<ExecuteBuildingBlock> rollbackFlowsFilteredNonChangeBBs = new ArrayList<>();
-            if (action.equals(REPLACEINSTANCE) && resourceName.equals(VFMODULE)) {
-                for (ExecuteBuildingBlock executeBuildingBlock : rollbackFlowsFiltered) {
-                    if (!executeBuildingBlock.getBuildingBlock().getBpmnFlowName().startsWith("Change")) {
-                        rollbackFlowsFilteredNonChangeBBs.add(executeBuildingBlock);
-                    }
+        List<ExecuteBuildingBlock> rollbackFlowsFilteredNonChangeBBs = new ArrayList<>();
+        if (action.equals(REPLACEINSTANCE) && resourceName.equals(VFMODULE)) {
+            for (ExecuteBuildingBlock executeBuildingBlock : rollbackFlowsFiltered) {
+                if (!executeBuildingBlock.getBuildingBlock().getBpmnFlowName().startsWith("Change")) {
+                    rollbackFlowsFilteredNonChangeBBs.add(executeBuildingBlock);
                 }
-                rollbackFlowsFiltered.clear();
-                rollbackFlowsFiltered.addAll(flowsToExecuteChangeBBs);
-                rollbackFlowsFiltered.addAll(rollbackFlowsFilteredNonChangeBBs);
             }
-
-            workflowActionBBFailure.updateRequestErrorStatusMessage(execution);
-            execution.setVariable("isRollbackNeeded", !rollbackFlows.isEmpty());
-            execution.setVariable("flowsToExecute", rollbackFlowsFiltered);
-            execution.setVariable(HANDLINGCODE, "PreformingRollback");
-            execution.setVariable("isRollback", true);
-            execution.setVariable(BBConstants.G_CURRENT_SEQUENCE, 0);
-            execution.setVariable(RETRY_COUNT, 0);
-        } else {
-            workflowAction.buildAndThrowException(execution,
-                    "Rollback has already been called. Cannot rollback a request that is currently in the rollback state.");
+            rollbackFlowsFiltered.clear();
+            rollbackFlowsFiltered.addAll(flowsToExecuteChangeBBs);
+            rollbackFlowsFiltered.addAll(rollbackFlowsFilteredNonChangeBBs);
         }
+
+        logger.info("List of BuildingBlocks to execute for rollback");
+        rollbackFlowsFiltered.forEach(item -> {
+            logger.info(item.getBuildingBlock().getBpmnFlowName());
+        });
+
+        workflowActionBBFailure.updateRequestErrorStatusMessage(execution);
+        execution.setVariable("isRollbackNeeded", !rollbackFlows.isEmpty());
+        execution.setVariable("flowsToExecute", rollbackFlowsFiltered);
+        execution.setVariable(HANDLINGCODE, "PreformingRollback");
+        execution.setVariable("isRollback", true);
+        execution.setVariable(BBConstants.G_CURRENT_SEQUENCE, 0);
+        execution.setVariable(RETRY_COUNT, 0);
     }
 
     protected void updateInstanceId(DelegateExecution execution) {
diff --git a/bpmn/so-bpmn-tasks/src/test/java/org/onap/so/bpmn/infrastructure/workflow/tasks/WorkflowActionBBTasksTest.java b/bpmn/so-bpmn-tasks/src/test/java/org/onap/so/bpmn/infrastructure/workflow/tasks/WorkflowActionBBTasksTest.java
index cbb746d514..2e4d99f9c6 100644
--- a/bpmn/so-bpmn-tasks/src/test/java/org/onap/so/bpmn/infrastructure/workflow/tasks/WorkflowActionBBTasksTest.java
+++ b/bpmn/so-bpmn-tasks/src/test/java/org/onap/so/bpmn/infrastructure/workflow/tasks/WorkflowActionBBTasksTest.java
@@ -35,6 +35,8 @@ import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
@@ -64,6 +66,7 @@ import org.onap.so.bpmn.servicedecomposition.entities.BuildingBlock;
 import org.onap.so.bpmn.servicedecomposition.entities.ConfigurationResourceKeys;
 import org.onap.so.bpmn.servicedecomposition.entities.ExecuteBuildingBlock;
 import org.onap.so.bpmn.servicedecomposition.entities.WorkflowResourceIds;
+import org.onap.so.db.catalog.beans.BuildingBlockRollback;
 import org.onap.so.db.catalog.beans.ConfigurationResource;
 import org.onap.so.db.catalog.beans.CvnfcConfigurationCustomization;
 import org.onap.so.db.catalog.beans.VnfResourceCustomization;
@@ -109,6 +112,11 @@ public class WorkflowActionBBTasksTest extends BaseTaskTest {
     private DelegateExecution mockExecution;
 
     @Before
+    public void initCatalogDBRollbackTable() {
+        when(catalogDbClient.getBuildingBlockRollbackEntries()).thenReturn(getRollbackBuildingBlockList());
+    }
+
+    @Before
     public void before() throws Exception {
         execution = new DelegateExecutionFake();
         ServiceInstance servInstance = new ServiceInstance();
@@ -614,6 +622,52 @@ public class WorkflowActionBBTasksTest extends BaseTaskTest {
     }
 
     @Test
+    public void rollbackExecutionRollbackControllerExecutionBBTest() {
+        execution.setVariable("isRollback", false);
+        execution.setVariable("handlingCode", "Rollback");
+        execution.setVariable("requestAction", EMPTY_STRING);
+        execution.setVariable("resourceName", EMPTY_STRING);
+        List<ExecuteBuildingBlock> flowsToExecute = new ArrayList<>();
+        BuildingBlock buildingBlock1 = new BuildingBlock().setBpmnFlowName("AssignServiceInstanceBB");
+        ExecuteBuildingBlock ebb1 = new ExecuteBuildingBlock().setBuildingBlock(buildingBlock1);
+        flowsToExecute.add(ebb1);
+
+        BuildingBlock buildingBlock2 = new BuildingBlock().setBpmnFlowName("AssignNetworkBB");
+        ExecuteBuildingBlock ebb2 = new ExecuteBuildingBlock().setBuildingBlock(buildingBlock2);
+        flowsToExecute.add(ebb2);
+
+        BuildingBlock buildingBlock3 = new BuildingBlock().setBpmnFlowName("AssignVnfBB");
+        ExecuteBuildingBlock ebb3 = new ExecuteBuildingBlock().setBuildingBlock(buildingBlock3);
+        flowsToExecute.add(ebb3);
+
+        BuildingBlock buildingBlock4 = new BuildingBlock().setBpmnFlowName("AssignVfModuleBB");
+        ExecuteBuildingBlock ebb4 = new ExecuteBuildingBlock().setBuildingBlock(buildingBlock4);
+        flowsToExecute.add(ebb4);
+
+        BuildingBlock buildingBlock5 = new BuildingBlock().setBpmnFlowName("ControllerExecutionBB");
+        buildingBlock5.setBpmnScope("vnf");
+        buildingBlock5.setBpmnAction("config-assign");
+        ExecuteBuildingBlock ebb5 = new ExecuteBuildingBlock().setBuildingBlock(buildingBlock5);
+        flowsToExecute.add(ebb5);
+
+        BuildingBlock buildingBlock6 = new BuildingBlock().setBpmnFlowName("CreateVfModuleBB");
+        ExecuteBuildingBlock ebb6 = new ExecuteBuildingBlock().setBuildingBlock(buildingBlock6);
+        flowsToExecute.add(ebb6);
+
+        execution.setVariable("flowsToExecute", flowsToExecute);
+        execution.setVariable("gCurrentSequence", 5);
+
+        workflowActionBBTasks.rollbackExecutionPath(execution);
+        List<ExecuteBuildingBlock> ebbs = (List<ExecuteBuildingBlock>) execution.getVariable("flowsToExecute");
+        BuildingBlock bb = ebbs.get(0).getBuildingBlock();
+        assertEquals("ControllerExecutionBB", bb.getBpmnFlowName());
+        assertEquals("vnf", bb.getBpmnScope());
+        assertEquals("config-unassign", bb.getBpmnAction());
+        assertEquals(0, execution.getVariable("gCurrentSequence"));
+        assertEquals(5, ebbs.size());
+    }
+
+    @Test
     public void postProcessingExecuteBBActivateVfModuleNotReplaceInstanceTest() throws CloneNotSupportedException {
         WorkflowResourceIds workflowResourceIds = new WorkflowResourceIds();
         workflowResourceIds.setServiceInstanceId("1");
@@ -1061,4 +1115,40 @@ public class WorkflowActionBBTasksTest extends BaseTaskTest {
         execution.setVariable("homing", false);
         execution.setVariable("calledHoming", false);
     }
+
+    private List<BuildingBlockRollback> getRollbackBuildingBlockList() {
+        List<BuildingBlockRollback> rollbackBBList = Collections.unmodifiableList(Arrays.asList(
+                new BuildingBlockRollback(1, "ActivateNetworkBB", null, "DeactivateNetworkBB", null),
+                new BuildingBlockRollback(2, "ActivatePnfBB", null, "DeactivatePnfBB", null),
+                new BuildingBlockRollback(3, "ActivateServiceInstanceBB", null, "DeactivateServiceInstanceBB", null),
+                new BuildingBlockRollback(4, "ActivateVfModuleBB", null, "DeactivateVfModuleBB", null),
+                new BuildingBlockRollback(5, "ActivateVnfBB", null, "DeactivateVnfBB", null),
+                new BuildingBlockRollback(6, "ActivateVolumeGroupBB", null, "DeactivateVolumeGroupBB", null),
+                new BuildingBlockRollback(7, "AssignNetworkBB", null, "UnassignNetworkBB", null),
+                new BuildingBlockRollback(8, "AssignServiceInstanceBB", null, "UnassignServiceInstanceBB", null),
+                new BuildingBlockRollback(9, "AssignVfModuleBB", null, "UnassignVfModuleBB", null),
+                new BuildingBlockRollback(10, "AssignVnfBB", null, "UnassignVnfBB", null),
+                new BuildingBlockRollback(11, "AssignVolumeGroupBB", null, "UnassignVolumeGroupBB", null),
+                new BuildingBlockRollback(12, "ControllerExecutionBB", "config-assign", "ControllerExecutionBB",
+                        "config-unassign"),
+                new BuildingBlockRollback(13, "ControllerExecutionBB", "config-deploy", "ControllerExecutionBB",
+                        "config-undeploy"),
+                new BuildingBlockRollback(14, "ControllerExecutionBB", "service-config-deploy", "ControllerExecutionBB",
+                        "service-config-undeploy"),
+                new BuildingBlockRollback(15, "CreateNetworkBB", null, "DeleteNetworkBB", null),
+                new BuildingBlockRollback(16, "CreateNetworkCollectionBB", null, "DeleteNetworkCollectionBB", null),
+                new BuildingBlockRollback(17, "CreateVfModuleBB", null, "DeleteVfModuleBB", null),
+                new BuildingBlockRollback(18, "CreateVolumeGroupBB", null, "DeleteVolumeGroupBB", null),
+                new BuildingBlockRollback(19, "VNFSetInMaintFlagActivity", null, "VNFUnsetInMaintFlagActivity", null),
+                new BuildingBlockRollback(20, "VNFSetClosedLoopDisabledFlagActivity", null,
+                        "VNFUnsetClosedLoopDisabledFlagActivity", null),
+                new BuildingBlockRollback(21, "VNFLockActivity", null, "VNFUnlockActivity", null),
+                new BuildingBlockRollback(22, "VNFStopActivity", null, "VNFStartActivity", null),
+                new BuildingBlockRollback(23, "VNFQuiesceTrafficActivity", null, "VNFResumeTrafficActivity", null),
+                new BuildingBlockRollback(24, "EtsiVnfInstantiateBB", null, "EtsiVnfDeleteBB", null),
+                // AddFabricConfigurationBB this does not seem to be present as a bpmn in Guilin
+                new BuildingBlockRollback(25, "AddFabricConfigurationBB", null, "DeleteFabricConfigurationBB", null)));
+        return rollbackBBList;
+    }
+
 }