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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.components.merge.policy;
  22
  23 import org.openecomp.sdc.be.components.merge.ComponentsGlobalMergeCommand;
  24 import org.openecomp.sdc.be.components.merge.VspComponentsMergeCommand;
  25 import org.openecomp.sdc.be.dao.api.ActionStatus;
  26 import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType;
  27 import org.openecomp.sdc.be.impl.ComponentsUtils;
  28 import org.openecomp.sdc.be.model.Component;
  29 import org.openecomp.sdc.be.model.ComponentInstance;
  30 import org.openecomp.sdc.be.model.GroupDefinition;
  31 import org.openecomp.sdc.be.model.PolicyDefinition;
  32 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  33 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  34 import org.openecomp.sdc.common.log.wrappers.Logger;
  35 import org.springframework.core.annotation.Order;
  36
  37 import java.util.ArrayList;
  38 import java.util.HashMap;
  39 import java.util.List;
  40 import java.util.Map;
  41 import java.util.Optional;
  42
  43 import static java.util.Collections.emptyList;
  44 import static java.util.stream.Collectors.toList;
  45 import static org.apache.commons.collections.CollectionUtils.isEmpty;
  46 import static org.apache.commons.collections.MapUtils.isEmpty;
  47 import static org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic.ANY_ORDER_COMMAND;
  48
  49 @org.springframework.stereotype.Component
  50 @Order(ANY_ORDER_COMMAND)
  51 public class PoliciesMergeCommand implements ComponentsGlobalMergeCommand, VspComponentsMergeCommand {
  52
  53     private static final Logger log = Logger.getLogger(PoliciesMergeCommand.class);
  54     private final ToscaOperationFacade toscaOperationFacade;
  55     private final ComponentsUtils componentsUtils;
  56
  57     public PoliciesMergeCommand(ToscaOperationFacade toscaOperationFacade, ComponentsUtils componentsUtils) {
  58         this.toscaOperationFacade = toscaOperationFacade;
  59         this.componentsUtils = componentsUtils;
  60     }
  61
  62     @Override
  63     public ActionStatus mergeComponents(Component prevComponent, Component currentComponent) {
  64         log.debug("#mergeComponents - merging user defined policies to current component {}", currentComponent.getUniqueId());
  65         if (isEmpty(prevComponent.getPolicies())) {
  66             return ActionStatus.OK;
  67         }
  68         Map<String, PolicyDefinition> policiesToMerge = resolvePoliciesForMerge(prevComponent, currentComponent);
  69         return associatePoliciesToComponent(currentComponent, policiesToMerge);
  70     }
  71
  72     private ActionStatus associatePoliciesToComponent(Component currentComponent, Map<String, PolicyDefinition> policiesToMerge) {
  73         log.debug("#associatePoliciesToComponent - associating {} policies into component {}", policiesToMerge.size(), currentComponent.getUniqueId());
  74         currentComponent.setPolicies(policiesToMerge);
  75         StorageOperationStatus associateResult = toscaOperationFacade.associatePoliciesToComponent(currentComponent.getUniqueId(), new ArrayList<>(policiesToMerge.values()));
  76         return componentsUtils.convertFromStorageResponse(associateResult);
  77     }
  78
  79     @Override
  80     public String description() {
  81         return "merge component policies";
  82     }
  83
  84     private Map<String, PolicyDefinition> resolvePoliciesForMerge(Component prevComponent, Component currentComponent) {
  85         Map<String, PolicyDefinition> policies = prevComponent.getPolicies();
  86         policies.values().forEach(policy -> updatePolicyTargets(policy, prevComponent, currentComponent));
  87         return policies;
  88     }
  89
  90     private void updatePolicyTargets(PolicyDefinition policy, Component prevComponent, Component currComponent) {
  91         log.debug("#updatePolicyTargets - updating policy {} targets for component {}", policy.getUniqueId(), currComponent.getUniqueId());
  92         if (isEmpty(policy.getTargets())) {
  93             return;
  94         }
  95         Map<PolicyTargetType, List<String>> targets =  buildPolicyTargetsMap(policy, prevComponent, currComponent);
  96         policy.setTargets(targets);
  97     }
  98
  99     private Map<PolicyTargetType, List<String>> buildPolicyTargetsMap(PolicyDefinition policy, Component prevComponent, Component currComponent) {
 100         List<String> componentInstanceTargets = resolveNewComponentInstanceTargets(policy, prevComponent, currComponent);
 101         List<String> groupTargets = resolveNewGroupTargets(policy, prevComponent, currComponent);
 102         Map<PolicyTargetType, List<String>> targets = new HashMap<>();
 103         targets.put(PolicyTargetType.COMPONENT_INSTANCES, componentInstanceTargets);
 104         targets.put(PolicyTargetType.GROUPS, groupTargets);
 105         return targets;
 106     }
 107
 108     private List<String> resolveNewComponentInstanceTargets(PolicyDefinition policy, Component prevComponent, Component currComponent) {
 109         List<String> prevCompInstanceTargets = policy.resolveComponentInstanceTargets();
 110         if (isEmpty(prevCompInstanceTargets)) {
 111             return emptyList();
 112         }
 113         return resolveInstanceTargetsByInstanceName(prevComponent, currComponent, prevCompInstanceTargets);
 114     }
 115
 116     private List<String> resolveNewGroupTargets(PolicyDefinition policy, Component prevComponent, Component currComponent) {
 117         List<String> prevGroupTargets = policy.resolveGroupTargets();
 118         if (isEmpty(prevGroupTargets)) {
 119             return emptyList();
 120         }
 121         return resolveGroupTargetsByInvariantName(prevComponent, currComponent, prevGroupTargets);
 122     }
 123
 124     private List<String> resolveInstanceTargetsByInstanceName(Component prevComponent, Component currComponent, List<String> prevCompInstanceTargets) {
 125         return prevCompInstanceTargets.stream()
 126                 .map(prevInstId -> resolveNewInstId(prevComponent, currComponent, prevInstId))
 127                 .filter(Optional::isPresent)
 128                 .map(Optional::get)
 129                 .collect(toList());
 130     }
 131
 132     private List<String> resolveGroupTargetsByInvariantName(Component prevComponent, Component currComponent, List<String> prevGroupTargets) {
 133         return prevGroupTargets.stream()
 134                 .map(prevGroupId -> resolveNewGroupId(prevComponent, currComponent, prevGroupId))
 135                 .filter(Optional::isPresent)
 136                 .map(Optional::get)
 137                 .collect(toList());
 138     }
 139
 140     private Optional<String> resolveNewInstId(Component prevCmpt, Component newCmpt, String prevInstanceId) {
 141         return prevCmpt.getComponentInstanceById(prevInstanceId)
 142                 .map(ComponentInstance::getName)
 143                 .flatMap(newCmpt::getComponentInstanceByName)
 144                 .map(ComponentInstance::getUniqueId);
 145     }
 146
 147     private Optional<String> resolveNewGroupId(Component prevCmpt, Component newCmpt, String prevGroupId) {
 148         return prevCmpt.getGroupById(prevGroupId)
 149                 .map(GroupDefinition::getInvariantName)
 150                 .flatMap(newCmpt::getGroupByInvariantName)
 151                 .map(GroupDefinition::getUniqueId);
 152     }
 153
 154 }