catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/policy/PoliciesMergeCommand.java

   1 package org.openecomp.sdc.be.components.merge.policy;
   2
   3 import org.openecomp.sdc.be.components.merge.ComponentsGlobalMergeCommand;
   4 import org.openecomp.sdc.be.components.merge.VspComponentsMergeCommand;
   5 import org.openecomp.sdc.be.dao.api.ActionStatus;
   6 import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType;
   7 import org.openecomp.sdc.be.impl.ComponentsUtils;
   8 import org.openecomp.sdc.be.model.Component;
   9 import org.openecomp.sdc.be.model.ComponentInstance;
  10 import org.openecomp.sdc.be.model.GroupDefinition;
  11 import org.openecomp.sdc.be.model.PolicyDefinition;
  12 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  13 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  14 import org.openecomp.sdc.common.log.wrappers.Logger;
  15 import org.springframework.core.annotation.Order;
  16
  17 import java.util.*;
  18
  19 import static java.util.Collections.emptyList;
  20 import static java.util.stream.Collectors.toList;
  21 import static org.apache.commons.collections.CollectionUtils.isEmpty;
  22 import static org.apache.commons.collections.MapUtils.isEmpty;
  23 import static org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic.ANY_ORDER_COMMAND;
  24
  25 @org.springframework.stereotype.Component
  26 @Order(ANY_ORDER_COMMAND)
  27 public class PoliciesMergeCommand implements ComponentsGlobalMergeCommand, VspComponentsMergeCommand {
  28
  29     private static final Logger log = Logger.getLogger(PoliciesMergeCommand.class);
  30     private final ToscaOperationFacade toscaOperationFacade;
  31     private final ComponentsUtils componentsUtils;
  32
  33     public PoliciesMergeCommand(ToscaOperationFacade toscaOperationFacade, ComponentsUtils componentsUtils) {
  34         this.toscaOperationFacade = toscaOperationFacade;
  35         this.componentsUtils = componentsUtils;
  36     }
  37
  38     @Override
  39     public ActionStatus mergeComponents(Component prevComponent, Component currentComponent) {
  40         log.debug("#mergeComponents - merging user defined policies to current component {}", currentComponent.getUniqueId());
  41         if (isEmpty(prevComponent.getPolicies())) {
  42             return ActionStatus.OK;
  43         }
  44         Map<String, PolicyDefinition> policiesToMerge = resolvePoliciesForMerge(prevComponent, currentComponent);
  45         return associatePoliciesToComponent(currentComponent, policiesToMerge);
  46     }
  47
  48     private ActionStatus associatePoliciesToComponent(Component currentComponent, Map<String, PolicyDefinition> policiesToMerge) {
  49         log.debug("#associatePoliciesToComponent - associating {} policies into component {}", policiesToMerge.size(), currentComponent.getUniqueId());
  50         currentComponent.setPolicies(policiesToMerge);
  51         StorageOperationStatus associateResult = toscaOperationFacade.associatePoliciesToComponent(currentComponent.getUniqueId(), new ArrayList<>(policiesToMerge.values()));
  52         return componentsUtils.convertFromStorageResponse(associateResult);
  53     }
  54
  55     @Override
  56     public String description() {
  57         return "merge component policies";
  58     }
  59
  60     private Map<String, PolicyDefinition> resolvePoliciesForMerge(Component prevComponent, Component currentComponent) {
  61         Map<String, PolicyDefinition> policies = prevComponent.getPolicies();
  62         policies.values().forEach(policy -> updatePolicyTargets(policy, prevComponent, currentComponent));
  63         return policies;
  64     }
  65
  66     private void updatePolicyTargets(PolicyDefinition policy, Component prevComponent, Component currComponent) {
  67         log.debug("#updatePolicyTargets - updating policy {} targets for component {}", policy.getUniqueId(), currComponent.getUniqueId());
  68         if (isEmpty(policy.getTargets())) {
  69             return;
  70         }
  71         Map<PolicyTargetType, List<String>> targets =  buildPolicyTargetsMap(policy, prevComponent, currComponent);
  72         policy.setTargets(targets);
  73     }
  74
  75     private Map<PolicyTargetType, List<String>> buildPolicyTargetsMap(PolicyDefinition policy, Component prevComponent, Component currComponent) {
  76         List<String> componentInstanceTargets = resolveNewComponentInstanceTargets(policy, prevComponent, currComponent);
  77         List<String> groupTargets = resolveNewGroupTargets(policy, prevComponent, currComponent);
  78         Map<PolicyTargetType, List<String>> targets = new HashMap<>();
  79         targets.put(PolicyTargetType.COMPONENT_INSTANCES, componentInstanceTargets);
  80         targets.put(PolicyTargetType.GROUPS, groupTargets);
  81         return targets;
  82     }
  83
  84     private List<String> resolveNewComponentInstanceTargets(PolicyDefinition policy, Component prevComponent, Component currComponent) {
  85         List<String> prevCompInstanceTargets = policy.resolveComponentInstanceTargets();
  86         if (isEmpty(prevCompInstanceTargets)) {
  87             return emptyList();
  88         }
  89         return resolveInstanceTargetsByInstanceName(prevComponent, currComponent, prevCompInstanceTargets);
  90     }
  91
  92     private List<String> resolveNewGroupTargets(PolicyDefinition policy, Component prevComponent, Component currComponent) {
  93         List<String> prevGroupTargets = policy.resolveGroupTargets();
  94         if (isEmpty(prevGroupTargets)) {
  95             return emptyList();
  96         }
  97         return resolveGroupTargetsByInvariantName(prevComponent, currComponent, prevGroupTargets);
  98     }
  99
 100     private List<String> resolveInstanceTargetsByInstanceName(Component prevComponent, Component currComponent, List<String> prevCompInstanceTargets) {
 101         return prevCompInstanceTargets.stream()
 102                 .map(prevInstId -> resolveNewInstId(prevComponent, currComponent, prevInstId))
 103                 .filter(Optional::isPresent)
 104                 .map(Optional::get)
 105                 .collect(toList());
 106     }
 107
 108     private List<String> resolveGroupTargetsByInvariantName(Component prevComponent, Component currComponent, List<String> prevGroupTargets) {
 109         return prevGroupTargets.stream()
 110                 .map(prevGroupId -> resolveNewGroupId(prevComponent, currComponent, prevGroupId))
 111                 .filter(Optional::isPresent)
 112                 .map(Optional::get)
 113                 .collect(toList());
 114     }
 115
 116     private Optional<String> resolveNewInstId(Component prevCmpt, Component newCmpt, String prevInstanceId) {
 117         return prevCmpt.getComponentInstanceById(prevInstanceId)
 118                 .map(ComponentInstance::getName)
 119                 .flatMap(newCmpt::getComponentInstanceByName)
 120                 .map(ComponentInstance::getUniqueId);
 121     }
 122
 123     private Optional<String> resolveNewGroupId(Component prevCmpt, Component newCmpt, String prevGroupId) {
 124         return prevCmpt.getGroupById(prevGroupId)
 125                 .map(GroupDefinition::getInvariantName)
 126                 .flatMap(newCmpt::getGroupByInvariantName)
 127                 .map(GroupDefinition::getUniqueId);
 128     }
 129
 130 }