diff options
Diffstat (limited to 'catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/policy/PoliciesMergeCommand.java')
-rw-r--r-- | catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/policy/PoliciesMergeCommand.java | 130 |
1 files changed, 130 insertions, 0 deletions
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/policy/PoliciesMergeCommand.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/policy/PoliciesMergeCommand.java new file mode 100644 index 0000000000..e57317f165 --- /dev/null +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/policy/PoliciesMergeCommand.java @@ -0,0 +1,130 @@ +package org.openecomp.sdc.be.components.merge.policy; + +import org.openecomp.sdc.be.components.merge.ComponentsGlobalMergeCommand; +import org.openecomp.sdc.be.components.merge.VspComponentsMergeCommand; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType; +import org.openecomp.sdc.be.impl.ComponentsUtils; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentInstance; +import org.openecomp.sdc.be.model.GroupDefinition; +import org.openecomp.sdc.be.model.PolicyDefinition; +import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.springframework.core.annotation.Order; + +import java.util.*; + +import static java.util.Collections.emptyList; +import static java.util.stream.Collectors.toList; +import static org.apache.commons.collections.CollectionUtils.isEmpty; +import static org.apache.commons.collections.MapUtils.isEmpty; +import static org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic.ANY_ORDER_COMMAND; + +@org.springframework.stereotype.Component +@Order(ANY_ORDER_COMMAND) +public class PoliciesMergeCommand implements ComponentsGlobalMergeCommand, VspComponentsMergeCommand { + + private static final Logger log = Logger.getLogger(PoliciesMergeCommand.class); + private final ToscaOperationFacade toscaOperationFacade; + private final ComponentsUtils componentsUtils; + + public PoliciesMergeCommand(ToscaOperationFacade toscaOperationFacade, ComponentsUtils componentsUtils) { + this.toscaOperationFacade = toscaOperationFacade; + this.componentsUtils = componentsUtils; + } + + @Override + public ActionStatus mergeComponents(Component prevComponent, Component currentComponent) { + log.debug("#mergeComponents - merging user defined policies to current component {}", currentComponent.getUniqueId()); + if (isEmpty(prevComponent.getPolicies())) { + return ActionStatus.OK; + } + Map<String, PolicyDefinition> policiesToMerge = resolvePoliciesForMerge(prevComponent, currentComponent); + return associatePoliciesToComponent(currentComponent, policiesToMerge); + } + + private ActionStatus associatePoliciesToComponent(Component currentComponent, Map<String, PolicyDefinition> policiesToMerge) { + log.debug("#associatePoliciesToComponent - associating {} policies into component {}", policiesToMerge.size(), currentComponent.getUniqueId()); + currentComponent.setPolicies(policiesToMerge); + StorageOperationStatus associateResult = toscaOperationFacade.associatePoliciesToComponent(currentComponent.getUniqueId(), new ArrayList<>(policiesToMerge.values())); + return componentsUtils.convertFromStorageResponse(associateResult); + } + + @Override + public String description() { + return "merge component policies"; + } + + private Map<String, PolicyDefinition> resolvePoliciesForMerge(Component prevComponent, Component currentComponent) { + Map<String, PolicyDefinition> policies = prevComponent.getPolicies(); + policies.values().forEach(policy -> updatePolicyTargets(policy, prevComponent, currentComponent)); + return policies; + } + + private void updatePolicyTargets(PolicyDefinition policy, Component prevComponent, Component currComponent) { + log.debug("#updatePolicyTargets - updating policy {} targets for component {}", policy.getUniqueId(), currComponent.getUniqueId()); + if (isEmpty(policy.getTargets())) { + return; + } + Map<PolicyTargetType, List<String>> targets = buildPolicyTargetsMap(policy, prevComponent, currComponent); + policy.setTargets(targets); + } + + private Map<PolicyTargetType, List<String>> buildPolicyTargetsMap(PolicyDefinition policy, Component prevComponent, Component currComponent) { + List<String> componentInstanceTargets = resolveNewComponentInstanceTargets(policy, prevComponent, currComponent); + List<String> groupTargets = resolveNewGroupTargets(policy, prevComponent, currComponent); + Map<PolicyTargetType, List<String>> targets = new HashMap<>(); + targets.put(PolicyTargetType.COMPONENT_INSTANCES, componentInstanceTargets); + targets.put(PolicyTargetType.GROUPS, groupTargets); + return targets; + } + + private List<String> resolveNewComponentInstanceTargets(PolicyDefinition policy, Component prevComponent, Component currComponent) { + List<String> prevCompInstanceTargets = policy.resolveComponentInstanceTargets(); + if (isEmpty(prevCompInstanceTargets)) { + return emptyList(); + } + return resolveInstanceTargetsByInstanceName(prevComponent, currComponent, prevCompInstanceTargets); + } + + private List<String> resolveNewGroupTargets(PolicyDefinition policy, Component prevComponent, Component currComponent) { + List<String> prevGroupTargets = policy.resolveGroupTargets(); + if (isEmpty(prevGroupTargets)) { + return emptyList(); + } + return resolveGroupTargetsByInvariantName(prevComponent, currComponent, prevGroupTargets); + } + + private List<String> resolveInstanceTargetsByInstanceName(Component prevComponent, Component currComponent, List<String> prevCompInstanceTargets) { + return prevCompInstanceTargets.stream() + .map(prevInstId -> resolveNewInstId(prevComponent, currComponent, prevInstId)) + .filter(Optional::isPresent) + .map(Optional::get) + .collect(toList()); + } + + private List<String> resolveGroupTargetsByInvariantName(Component prevComponent, Component currComponent, List<String> prevGroupTargets) { + return prevGroupTargets.stream() + .map(prevGroupId -> resolveNewGroupId(prevComponent, currComponent, prevGroupId)) + .filter(Optional::isPresent) + .map(Optional::get) + .collect(toList()); + } + + private Optional<String> resolveNewInstId(Component prevCmpt, Component newCmpt, String prevInstanceId) { + return prevCmpt.getComponentInstanceById(prevInstanceId) + .map(ComponentInstance::getName) + .flatMap(newCmpt::getComponentInstanceByName) + .map(ComponentInstance::getUniqueId); + } + + private Optional<String> resolveNewGroupId(Component prevCmpt, Component newCmpt, String prevGroupId) { + return prevCmpt.getGroupById(prevGroupId) + .map(GroupDefinition::getInvariantName) + .flatMap(newCmpt::getGroupByInvariantName) + .map(GroupDefinition::getUniqueId); + } + +} |