@Component
 public class WorkflowActionBBFailure {
 
+    private static final String DEACTIVATE_FABRIC_CONFIGURATION_FLOW = "DeactivateFabricConfigurationBB";
+    private static final String UNASSIGN_FABRIC_CONFIGURATION_FLOW = "UnassignFabricConfigurationBB";
     private static final Logger logger = LoggerFactory.getLogger(WorkflowActionBBFailure.class);
     public static final String ROLLBACK_TARGET_STATE = "rollbackTargetState";
     @Autowired
                 String rollbackTargetState = (String) execution.getVariable(ROLLBACK_TARGET_STATE);
                 request.setRequestStatus(rollbackTargetState);
             } else if (isRollbackFailure) {
+                if (ebb != null && ebb.getBuildingBlock() != null && ebb.getBuildingBlock().getBpmnFlowName() != null) {
+                    String flowName = ebb.getBuildingBlock().getBpmnFlowName();
+                    if (DEACTIVATE_FABRIC_CONFIGURATION_FLOW.equalsIgnoreCase(flowName)
+                            || UNASSIGN_FABRIC_CONFIGURATION_FLOW.equalsIgnoreCase(flowName)) {
+                        String statusMessage = String.format(
+                                "%s Warning: The vf-module is active but configuration was not removed completely for one or more VMs.",
+                                request.getStatusMessage());
+                        request.setStatusMessage(statusMessage);
+                    }
+                }
                 Optional<String> rollbackErrorMsgOp = retrieveErrorMessage(execution);
                 if (rollbackErrorMsgOp.isPresent()) {
                     rollbackErrorMsg = rollbackErrorMsgOp.get();
 
             rollbackFlowsFiltered.addAll(rollbackFlows);
             if ("RollbackToAssigned".equals(handlingCode) || ROLLBACKTOCREATED.equals(handlingCode)) {
                 for (int i = 0; i < rollbackFlows.size(); i++) {
-                    if (rollbackFlows.get(i).getBuildingBlock().getBpmnFlowName().contains("Unassign")) {
+                    if (rollbackFlows.get(i).getBuildingBlock().getBpmnFlowName().contains("Unassign") && !rollbackFlows
+                            .get(i).getBuildingBlock().getBpmnFlowName().contains("FabricConfiguration")) {
                         rollbackFlowsFiltered.remove(rollbackFlows.get(i));
                     } else if (rollbackFlows.get(i).getBuildingBlock().getBpmnFlowName().contains("Delete")
                             && ROLLBACKTOCREATED.equals(handlingCode)) {
 
 import org.onap.so.bpmn.BaseTaskTest;
 import org.onap.so.bpmn.core.WorkflowException;
 import org.onap.so.bpmn.servicedecomposition.bbobjects.Customer;
+import org.onap.so.bpmn.servicedecomposition.entities.BuildingBlock;
+import org.onap.so.bpmn.servicedecomposition.entities.ExecuteBuildingBlock;
 import org.onap.so.constants.Status;
 import org.onap.so.db.request.beans.InfraActiveRequests;
 
         assertEquals(Status.FAILED.toString(), req.getRequestStatus());
     }
 
+    @Test
+    public void updateRequestStatusToFailedRollbackFabric() {
+        ExecuteBuildingBlock ebb = new ExecuteBuildingBlock();
+        BuildingBlock bb = new BuildingBlock();
+        bb.setBpmnFlowName("UnassignFabricConfigurationBB");
+        ebb.setBuildingBlock(bb);
+        execution.setVariable("buildingBlock", ebb);
+        execution.setVariable("mso-request-id", "123");
+        execution.setVariable("isRollbackComplete", false);
+        execution.setVariable("isRollback", true);
+        InfraActiveRequests req = new InfraActiveRequests();
+        req.setStatusMessage("PINC failure.");
+        WorkflowException wfe = new WorkflowException("processKey123", 1, "error in rollback");
+        execution.setVariable("WorkflowException", wfe);
+        doReturn(req).when(requestsDbClient).getInfraActiveRequestbyRequestId("123");
+        doNothing().when(requestsDbClient).updateInfraActiveRequests(isA(InfraActiveRequests.class));
+        workflowActionBBFailure.updateRequestStatusToFailed(execution);
+        String errorMsg = (String) execution.getVariable("RollbackErrorMessage");
+        assertEquals("error in rollback", errorMsg);
+        assertEquals(
+                "PINC failure. Warning: The vf-module is active but configuration was not removed completely for one or more VMs.",
+                req.getStatusMessage());
+        assertEquals(Status.FAILED.toString(), req.getRequestStatus());
+    }
+
     @Test
     public void updateRequestStatusToRolledback() {
         execution.setVariable("mso-request-id", "123");
 
         assertEquals(1, ebbs.size());
     }
 
+    @Test
+    public void rollbackExecutionRollbackToAssignedWithFabricTest() {
+        execution.setVariable("isRollback", false);
+        execution.setVariable("handlingCode", "RollbackToAssigned");
+        List<ExecuteBuildingBlock> flowsToExecute = new ArrayList();
+        ExecuteBuildingBlock ebb1 = new ExecuteBuildingBlock();
+        BuildingBlock bb1 = new BuildingBlock();
+        bb1.setBpmnFlowName("AssignVfModuleBB");
+        ebb1.setBuildingBlock(bb1);
+        flowsToExecute.add(ebb1);
+        ExecuteBuildingBlock ebb2 = new ExecuteBuildingBlock();
+        BuildingBlock bb2 = new BuildingBlock();
+        bb2.setBpmnFlowName("CreateVfModuleBB");
+        ebb2.setBuildingBlock(bb2);
+        flowsToExecute.add(ebb2);
+        ExecuteBuildingBlock ebb3 = new ExecuteBuildingBlock();
+        BuildingBlock bb3 = new BuildingBlock();
+        bb3.setBpmnFlowName("ActivateVfModuleBB");
+        ebb3.setBuildingBlock(bb3);
+        flowsToExecute.add(ebb3);
+        ExecuteBuildingBlock ebb4 = new ExecuteBuildingBlock();
+        BuildingBlock bb4 = new BuildingBlock();
+        bb4.setBpmnFlowName("AssignFabricConfigurationBB");
+        ebb4.setBuildingBlock(bb4);
+        flowsToExecute.add(ebb4);
+        ExecuteBuildingBlock ebb5 = new ExecuteBuildingBlock();
+        BuildingBlock bb5 = new BuildingBlock();
+        bb5.setBpmnFlowName("ActivateFabricConfigurationBB");
+        ebb5.setBuildingBlock(bb5);
+        flowsToExecute.add(ebb5);
+
+        execution.setVariable("flowsToExecute", flowsToExecute);
+        execution.setVariable("gCurrentSequence", 5);
+
+        workflowActionBBTasks.rollbackExecutionPath(execution);
+        List<ExecuteBuildingBlock> ebbs = (List<ExecuteBuildingBlock>) execution.getVariable("flowsToExecute");
+        assertEquals(0, execution.getVariable("gCurrentSequence"));
+        assertEquals(4, ebbs.size());
+        assertEquals("DeactivateFabricConfigurationBB", ebbs.get(0).getBuildingBlock().getBpmnFlowName());
+        assertEquals("UnassignFabricConfigurationBB", ebbs.get(1).getBuildingBlock().getBpmnFlowName());
+        assertEquals("DeactivateVfModuleBB", ebbs.get(2).getBuildingBlock().getBpmnFlowName());
+        assertEquals("DeleteVfModuleBB", ebbs.get(3).getBuildingBlock().getBpmnFlowName());
+
+    }
+
     @Test
     public void rollbackExecutionRollbackToCreatedTest() {
         execution.setVariable("isRollback", false);