catalog-be/src/main/java/org/openecomp/sdc/be/impl/ForwardingPathUtils.java

   1 package org.openecomp.sdc.be.impl;
   2
   3
   4 import com.google.common.collect.HashMultimap;
   5 import com.google.common.collect.SetMultimap;
   6 import org.apache.commons.collections.CollectionUtils;
   7 import org.javatuples.Pair;
   8 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
   9 import org.openecomp.sdc.be.components.merge.instance.DataForMergeHolder;
  10 import org.openecomp.sdc.be.datamodel.NameIdPair;
  11 import org.openecomp.sdc.be.datamodel.NameIdPairWrapper;
  12 import org.openecomp.sdc.be.datamodel.ServiceRelations;
  13 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
  14 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
  15 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  16 import org.openecomp.sdc.be.model.CapabilityDefinition;
  17 import org.openecomp.sdc.be.model.Component;
  18 import org.openecomp.sdc.be.model.ComponentInstance;
  19 import org.openecomp.sdc.be.model.Service;
  20
  21 import java.util.*;
  22 import java.util.stream.Collectors;
  23
  24 public class ForwardingPathUtils {
  25
  26     public static final String FORWARDING_PATH_NODE_NAME = "Forwarding Path";
  27     public static final String FORWARDER_CAPABILITY = "org.openecomp.capabilities.Forwarder";
  28
  29
  30     public ServiceRelations convertServiceToServiceRelations(Service service) {
  31         ServiceRelations serviceRelations = new ServiceRelations();
  32         List<ComponentInstance> componentInstances = service.getComponentInstances();
  33         if (componentInstances == null || componentInstances.isEmpty()) {
  34             return serviceRelations;
  35         }
  36         Set<NameIdPairWrapper> relations = new HashSet<>();
  37         //@todo get all capabilities and requirements.
  38         SetMultimap<NameIdPair, NameIdPair> nodeToCP = HashMultimap.create();
  39         componentInstances.forEach(ci -> initNodeToCP(ci, nodeToCP));
  40         handleRelDef(relations, nodeToCP);
  41         serviceRelations.setRelations(relations);
  42         return serviceRelations;
  43     }
  44
  45     private void initNodeToCP(ComponentInstance ci, SetMultimap<NameIdPair, NameIdPair> nodeToCP) {
  46         if (ci.getCapabilities() == null){
  47             return;
  48         }
  49         Set<CapabilityDefinition> capabilities = ci.getCapabilities().values().stream().flatMap(Collection::stream).collect(Collectors.toSet());
  50         if (!CollectionUtils.isNotEmpty(capabilities)) {
  51             return;
  52         }
  53         Set<CapabilityDefinition> forwarderCapabilities = capabilities.stream().filter(capabilityDefinition -> capabilityDefinition.getType().equals(FORWARDER_CAPABILITY)).collect(Collectors.toSet());
  54         if (!CollectionUtils.isNotEmpty(forwarderCapabilities)) {
  55             return;
  56         }
  57         NameIdPair node = new NameIdPair(ci.getName(), ci.getName());
  58         forwarderCapabilities.forEach(fc -> {
  59             NameIdPair capability = new NameIdPair(fc.getName(), fc.getName(), fc.getOwnerId());
  60             nodeToCP.put(node, capability);
  61          });
  62
  63     }
  64
  65
  66     private void handleRelDef(Set<NameIdPairWrapper> relations, SetMultimap<NameIdPair, NameIdPair> nodeToCP) {
  67         nodeToCP.keySet().forEach(fromNode -> {
  68             NameIdPairWrapper nameIdPairWrapper = new NameIdPairWrapper();
  69             nameIdPairWrapper.init(fromNode);
  70             if (!relations.contains(nameIdPairWrapper)) {
  71                 relations.add(nameIdPairWrapper);
  72                 Collection<NameIdPair> fromCps = nodeToCP.get(fromNode);
  73                 fromCps.forEach(fromCP -> handleFromCp(nodeToCP, nameIdPairWrapper));
  74             }
  75         });
  76
  77     }
  78
  79     private void handleFromCp(SetMultimap<NameIdPair, NameIdPair> nodeToCP, NameIdPairWrapper wrapper) {
  80         Map<NameIdPair, Set<NameIdPair>> options = toMap(nodeToCP);
  81
  82         Set<NameIdPair> cpOptions = options.get(wrapper.getNameIdPair());
  83         List<NameIdPairWrapper> wrappers = cpOptions.stream().map(this::createWrapper).collect(Collectors.toList());
  84         wrappers.forEach(cpOptionWrapper -> {
  85             org.openecomp.sdc.be.datamodel.NameIdPair data = wrapper.getData();
  86             data.addWrappedData(cpOptionWrapper);
  87         });
  88     }
  89
  90     private NameIdPairWrapper createWrapper(NameIdPair cpOption) {
  91         NameIdPairWrapper nameIdPairWrapper = new NameIdPairWrapper();
  92         nameIdPairWrapper.init(new NameIdPair(cpOption));
  93         return nameIdPairWrapper;
  94     }
  95
  96
  97     private Map<NameIdPair, Set<NameIdPair>> toMap(SetMultimap<NameIdPair, NameIdPair> nodeToCP) {
  98         Map<NameIdPair, Set<NameIdPair>> retVal = new HashMap<>();
  99         nodeToCP.asMap().forEach((nameIdPair, nameIdPairs) -> retVal.put(nameIdPair, new HashSet<>(nameIdPairs)));
 100         return retVal;
 101     }
 102
 103
 104     protected ResponseFormatManager getResponseFormatManager() {
 105         return ResponseFormatManager.getInstance();
 106     }
 107
 108     public Set<String> findForwardingPathNamesToDeleteOnComponentInstanceDeletion(Service containerService,
 109         String componentInstanceId) {
 110         return findForwardingPathToDeleteOnCIDeletion(containerService, componentInstanceId).values().stream()
 111             .map(ForwardingPathDataDefinition::getName).collect(Collectors.toSet());
 112     }
 113
 114     private Map<String, ForwardingPathDataDefinition> findForwardingPathToDeleteOnCIDeletion(Service containerService,
 115         String componentInstanceId) {
 116         return containerService.getForwardingPaths().entrySet().stream()
 117             .filter(entry -> elementContainsCI(entry, componentInstanceId))
 118             .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
 119     }
 120
 121     private boolean elementContainsCI(Map.Entry<String, ForwardingPathDataDefinition> fpEntry,
 122         String componentInstanceId) {
 123         return fpEntry.getValue().getPathElements()
 124             .getListToscaDataDefinition().stream()
 125             .anyMatch(element -> elementContainsCI(element, componentInstanceId));
 126     }
 127
 128     private boolean elementContainsCI(ForwardingPathElementDataDefinition elementDataDefinitions,
 129         String componentInstanceId) {
 130         return elementDataDefinitions.getFromNode().equals(componentInstanceId)
 131             || elementDataDefinitions.getToNode().equals(componentInstanceId);
 132     }
 133
 134     public Pair<Map<String, ForwardingPathDataDefinition>, Map<String, ForwardingPathDataDefinition>> updateForwardingPathOnVersionChange(
 135         Service containerService, DataForMergeHolder dataHolder,
 136         Component updatedContainerComponent, String newInstanceId) {
 137         Map<String, ForwardingPathDataDefinition> updated = containerService.getForwardingPaths().entrySet().stream()
 138             .filter(entry -> elementContainsCIAndForwarder(entry.getValue(), dataHolder.getOrigComponentInstId(), updatedContainerComponent))
 139             .collect(Collectors.toMap(Map.Entry::getKey,
 140                 entry ->  updateCI(entry.getValue(), dataHolder.getOrigComponentInstId(),newInstanceId)));
 141         Map<String, ForwardingPathDataDefinition> deleted = containerService.getForwardingPaths().entrySet().stream()
 142             .filter(entry -> elementContainsCIAndDoesNotContainForwarder(entry.getValue(),  dataHolder.getOrigComponentInstId(), updatedContainerComponent))
 143             .collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue));
 144         return new Pair<>(updated, deleted);
 145     }
 146
 147     public Set<String> getForwardingPathsToBeDeletedOnVersionChange(
 148         Service containerService, DataForMergeHolder dataHolder, Component updatedContainerComponent) {
 149         return containerService.getForwardingPaths().entrySet().stream()
 150           .filter(entry -> elementContainsCIAndDoesNotContainForwarder(entry.getValue(),
 151               dataHolder.getOrigComponentInstId(), updatedContainerComponent))
 152            .map(entry -> entry.getValue().getUniqueId()).collect( Collectors.toSet());
 153     }
 154
 155     private ForwardingPathDataDefinition updateCI(ForwardingPathDataDefinition inFP, String oldCI, String newCI) {
 156         ForwardingPathDataDefinition retVal = new ForwardingPathDataDefinition(inFP);
 157         List<ForwardingPathElementDataDefinition> fpList = retVal.getPathElements().getListToscaDataDefinition()
 158             .stream().map(element -> updateElement(element, oldCI, newCI)).collect(Collectors.toList());
 159         retVal.setPathElements(new ListDataDefinition<>(fpList));
 160         return retVal;
 161     }
 162
 163     private ForwardingPathElementDataDefinition updateElement(ForwardingPathElementDataDefinition element, String oldCI,
 164         String newCI) {
 165         ForwardingPathElementDataDefinition retVal = new ForwardingPathElementDataDefinition(element);
 166         if (retVal.getFromNode().equals(oldCI)) {
 167             retVal.setFromNode(newCI);
 168         }
 169         if (retVal.getToNode().equals(oldCI)) {
 170             retVal.setToNode(newCI);
 171         }
 172         if (Objects.equals(retVal.getToCPOriginId(),oldCI )) {
 173             retVal.setToCPOriginId(newCI);
 174         }
 175         if (Objects.equals(retVal.getFromCPOriginId(),oldCI)) {
 176             retVal.setFromCPOriginId(newCI);
 177         }
 178         return retVal;
 179     }
 180
 181     private boolean elementContainsCIAndForwarder(ForwardingPathDataDefinition forwardingPathDataDefinition,
 182         String oldCIId, Component newCI) {
 183         return forwardingPathDataDefinition.getPathElements()
 184             .getListToscaDataDefinition().stream()
 185             .anyMatch(element -> elementContainsCIAndForwarder(element, oldCIId, newCI));
 186     }
 187
 188     private boolean elementContainsCIAndForwarder(ForwardingPathElementDataDefinition elementDataDefinitions,
 189         String oldCIId, Component newCI) {
 190         return (elementDataDefinitions.getFromNode().equals(oldCIId) && ciContainsForwarder(newCI,
 191             elementDataDefinitions.getFromCP()))
 192             || (elementDataDefinitions.getToNode().equals(oldCIId) && ciContainsForwarder(newCI,
 193             elementDataDefinitions.getToCP()));
 194     }
 195
 196     private boolean ciContainsForwarder(Component newCI, String capabilityID) {
 197         if (newCI.getCapabilities() == null){
 198             return false;
 199         }
 200         return newCI.getCapabilities().values()
 201             .stream()
 202             .flatMap(List::stream)
 203             .anyMatch(c -> c.getName().equals(capabilityID));
 204     }
 205
 206     private boolean elementContainsCIAndDoesNotContainForwarder(
 207         ForwardingPathDataDefinition forwardingPathDataDefinition,
 208         String oldCIId, Component newCI) {
 209         return forwardingPathDataDefinition.getPathElements()
 210             .getListToscaDataDefinition().stream()
 211             .anyMatch(element -> elementContainsCIAndDoesNotContainForwarder(element, oldCIId, newCI));
 212     }
 213
 214     private boolean elementContainsCIAndDoesNotContainForwarder(
 215         ForwardingPathElementDataDefinition elementDataDefinitions,
 216         String oldCIId, Component newCI) {
 217         return (elementDataDefinitions.getFromNode().equals(oldCIId) && !ciContainsForwarder(newCI,
 218             elementDataDefinitions.getFromCP()))
 219             || (elementDataDefinitions.getToNode().equals(oldCIId) && !ciContainsForwarder(newCI,
 220             elementDataDefinitions.getToCP()));
 221     }
 222
 223
 224     public Set<ForwardingPathDataDefinition> updateComponentInstanceName(Collection<ForwardingPathDataDefinition> forwardingPathDataDefinitions,
 225         String oldName, String newName){
 226         return  forwardingPathDataDefinitions.stream().filter(fp -> shouldRenameCI(fp,oldName)).
 227             map(forwardingPathDataDefinition -> renamePathCI(forwardingPathDataDefinition,oldName,newName))
 228             .collect(Collectors.toSet());
 229
 230     }
 231
 232     public boolean shouldRenameCI(ForwardingPathDataDefinition forwardingPathDataDefinitions,
 233         String oldName){
 234         return forwardingPathDataDefinitions.getPathElements().getListToscaDataDefinition().stream()
 235             .anyMatch(pe -> pe.getToNode().equals(oldName) || pe.getFromNode().equals(oldName));
 236     }
 237
 238     public ForwardingPathDataDefinition renamePathCI(ForwardingPathDataDefinition forwardingPathDataDefinitions,
 239         String oldName, String newName){
 240         forwardingPathDataDefinitions.getPathElements().getListToscaDataDefinition().stream()
 241             .forEach(pe -> renamePathCI(pe,oldName, newName));
 242         return forwardingPathDataDefinitions;
 243     }
 244
 245     public void renamePathCI(ForwardingPathElementDataDefinition pathElementDataDefinition,
 246         String oldName, String newName){
 247         if (pathElementDataDefinition.getFromNode().equals(oldName)){
 248             pathElementDataDefinition.setFromNode(newName);
 249         }
 250         if(pathElementDataDefinition.getToNode().equals(oldName)){
 251             pathElementDataDefinition.setToNode(newName);
 252         }
 253
 254     }
 255 }