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.*;
  38
  39 import static java.util.Collections.emptyList;
  40 import static java.util.stream.Collectors.toList;
  41 import static org.apache.commons.collections.CollectionUtils.isEmpty;
  42 import static org.apache.commons.collections.MapUtils.isEmpty;
  43 import static org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic.ANY_ORDER_COMMAND;
  44
  45 @org.springframework.stereotype.Component
  46 @Order(ANY_ORDER_COMMAND)
  47 public class PoliciesMergeCommand implements ComponentsGlobalMergeCommand, VspComponentsMergeCommand {
  48
  49     private static final Logger log = Logger.getLogger(PoliciesMergeCommand.class);
  50     private final ToscaOperationFacade toscaOperationFacade;
  51     private final ComponentsUtils componentsUtils;
  52
  53     public PoliciesMergeCommand(ToscaOperationFacade toscaOperationFacade, ComponentsUtils componentsUtils) {
  54         this.toscaOperationFacade = toscaOperationFacade;
  55         this.componentsUtils = componentsUtils;
  56     }
  57
  58     @Override
  59     public ActionStatus mergeComponents(Component prevComponent, Component currentComponent) {
  60         log.debug("#mergeComponents - merging user defined policies to current component {}", currentComponent.getUniqueId());
  61         if (isEmpty(prevComponent.getPolicies())) {
  62             return ActionStatus.OK;
  63         }
  64         Map<String, PolicyDefinition> policiesToMerge = resolvePoliciesForMerge(prevComponent, currentComponent);
  65         return associatePoliciesToComponent(currentComponent, policiesToMerge);
  66     }
  67
  68     private ActionStatus associatePoliciesToComponent(Component currentComponent, Map<String, PolicyDefinition> policiesToMerge) {
  69         log.debug("#associatePoliciesToComponent - associating {} policies into component {}", policiesToMerge.size(), currentComponent.getUniqueId());
  70         currentComponent.setPolicies(policiesToMerge);
  71         StorageOperationStatus associateResult = toscaOperationFacade.associatePoliciesToComponent(currentComponent.getUniqueId(), new ArrayList<>(policiesToMerge.values()));
  72         return componentsUtils.convertFromStorageResponse(associateResult);
  73     }
  74
  75     @Override
  76     public String description() {
  77         return "merge component policies";
  78     }
  79
  80     private Map<String, PolicyDefinition> resolvePoliciesForMerge(Component prevComponent, Component currentComponent) {
  81         Map<String, PolicyDefinition> policies = prevComponent.getPolicies();
  82         policies.values().forEach(policy -> updatePolicyTargets(policy, prevComponent, currentComponent));
  83         return policies;
  84     }
  85
  86     private void updatePolicyTargets(PolicyDefinition policy, Component prevComponent, Component currComponent) {
  87         log.debug("#updatePolicyTargets - updating policy {} targets for component {}", policy.getUniqueId(), currComponent.getUniqueId());
  88         if (isEmpty(policy.getTargets())) {
  89             return;
  90         }
  91         Map<PolicyTargetType, List<String>> targets =  buildPolicyTargetsMap(policy, prevComponent, currComponent);
  92         policy.setTargets(targets);
  93     }
  94
  95     private Map<PolicyTargetType, List<String>> buildPolicyTargetsMap(PolicyDefinition policy, Component prevComponent, Component currComponent) {
  96         List<String> componentInstanceTargets = resolveNewComponentInstanceTargets(policy, prevComponent, currComponent);
  97         List<String> groupTargets = resolveNewGroupTargets(policy, prevComponent, currComponent);
  98         Map<PolicyTargetType, List<String>> targets = new HashMap<>();
  99         targets.put(PolicyTargetType.COMPONENT_INSTANCES, componentInstanceTargets);
 100         targets.put(PolicyTargetType.GROUPS, groupTargets);
 101         return targets;
 102     }
 103
 104     private List<String> resolveNewComponentInstanceTargets(PolicyDefinition policy, Component prevComponent, Component currComponent) {
 105         List<String> prevCompInstanceTargets = policy.resolveComponentInstanceTargets();
 106         if (isEmpty(prevCompInstanceTargets)) {
 107             return emptyList();
 108         }
 109         return resolveInstanceTargetsByInstanceName(prevComponent, currComponent, prevCompInstanceTargets);
 110     }
 111
 112     private List<String> resolveNewGroupTargets(PolicyDefinition policy, Component prevComponent, Component currComponent) {
 113         List<String> prevGroupTargets = policy.resolveGroupTargets();
 114         if (isEmpty(prevGroupTargets)) {
 115             return emptyList();
 116         }
 117         return resolveGroupTargetsByInvariantName(prevComponent, currComponent, prevGroupTargets);
 118     }
 119
 120     private List<String> resolveInstanceTargetsByInstanceName(Component prevComponent, Component currComponent, List<String> prevCompInstanceTargets) {
 121         return prevCompInstanceTargets.stream()
 122                 .map(prevInstId -> resolveNewInstId(prevComponent, currComponent, prevInstId))
 123                 .filter(Optional::isPresent)
 124                 .map(Optional::get)
 125                 .collect(toList());
 126     }
 127
 128     private List<String> resolveGroupTargetsByInvariantName(Component prevComponent, Component currComponent, List<String> prevGroupTargets) {
 129         return prevGroupTargets.stream()
 130                 .map(prevGroupId -> resolveNewGroupId(prevComponent, currComponent, prevGroupId))
 131                 .filter(Optional::isPresent)
 132                 .map(Optional::get)
 133                 .collect(toList());
 134     }
 135
 136     private Optional<String> resolveNewInstId(Component prevCmpt, Component newCmpt, String prevInstanceId) {
 137         return prevCmpt.getComponentInstanceById(prevInstanceId)
 138                 .map(ComponentInstance::getName)
 139                 .flatMap(newCmpt::getComponentInstanceByName)
 140                 .map(ComponentInstance::getUniqueId);
 141     }
 142
 143     private Optional<String> resolveNewGroupId(Component prevCmpt, Component newCmpt, String prevGroupId) {
 144         return prevCmpt.getGroupById(prevGroupId)
 145                 .map(GroupDefinition::getInvariantName)
 146                 .flatMap(newCmpt::getGroupByInvariantName)
 147                 .map(GroupDefinition::getUniqueId);
 148     }
 149
 150 }