catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/ForwardingPathToscaUtil.java

   1 package org.openecomp.sdc.be.tosca.utils;
   2
   3 import fj.data.Either;
   4 import org.apache.commons.collections.MapUtils;
   5 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
   6 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
   7 import org.openecomp.sdc.be.model.CapabilityDefinition;
   8 import org.openecomp.sdc.be.model.Component;
   9 import org.openecomp.sdc.be.model.ComponentInstance;
  10 import org.openecomp.sdc.be.model.Service;
  11 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  12 import org.openecomp.sdc.be.tosca.CapabilityRequirementConverter;
  13 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
  14 import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
  15
  16 import java.util.*;
  17 import java.util.Collection;
  18
  19 /**
  20  * @author KATYR
  21  * @since November 19, 2017
  22  */
  23
  24 public class ForwardingPathToscaUtil {
  25     public static final String FORWARDS_TO_TOSCA_NAME =
  26             "org.openecomp.relationships.ForwardsTo";
  27     public static final String PROTOCOL = "protocol";
  28     public static final String PORTS_RANGE = "target_range";
  29     public static final String FORWARDER = "forwarder";
  30
  31     public static void addForwardingPaths(Service service, Map<String, ToscaNodeTemplate>
  32             nodeTemplates, CapabilityRequirementConverter capabiltyRequirementConvertor, Map<String, Component> originComponents, ToscaOperationFacade toscaOperationFacade) {
  33         for (String forwardingPathName : service.getForwardingPaths().keySet()) {
  34             ToscaNodeTemplate forwardingPathNodeTemplate =
  35                     new ToscaNodeTemplate();
  36             final ForwardingPathDataDefinition path =
  37                     service.getForwardingPaths().get(forwardingPathName);
  38             forwardingPathNodeTemplate.setType(path.getToscaResourceName());
  39
  40             if (Objects.nonNull(path.getDescription())) {
  41                 forwardingPathNodeTemplate.setDescription(path
  42                         .getDescription());
  43             }
  44             Map<String, Object> props = new HashMap<>();
  45             if (Objects.nonNull(path.getDestinationPortNumber())) {
  46                 props.put(PORTS_RANGE, Collections.singletonList(path.getDestinationPortNumber()));
  47             }
  48             if (Objects.nonNull(path.getProtocol())) {
  49                 props.put(PROTOCOL, path.getProtocol());
  50             }
  51             if (MapUtils.isNotEmpty(props)) {
  52                 forwardingPathNodeTemplate.setProperties(props);
  53             }
  54
  55             final List<ForwardingPathElementDataDefinition> pathElements =
  56                     path.getPathElements()
  57                             .getListToscaDataDefinition();
  58             forwardingPathNodeTemplate.setRequirements(convertPathElementsToRequirements(pathElements,
  59                     service, capabiltyRequirementConvertor, originComponents, toscaOperationFacade));
  60
  61             nodeTemplates.put(path.getName(), forwardingPathNodeTemplate);
  62         }
  63
  64     }
  65
  66     private static List<Map<String, ToscaTemplateRequirement>> convertPathElementsToRequirements(
  67             List<ForwardingPathElementDataDefinition> pathElements, Service service, CapabilityRequirementConverter capabiltyRequirementConvertor, Map<String, Component> originComponents, ToscaOperationFacade toscaOperationFacade) {
  68         List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
  69         for (int i = 0; i <= pathElements.size() -1 ; i++) {
  70                 final ForwardingPathElementDataDefinition element = pathElements.get(i);
  71                 toscaRequirements.add(handleSingleReq(fetchCPName(service, element.getFromNode(), element.getFromCP(), capabiltyRequirementConvertor, originComponents, toscaOperationFacade), fetchNodeName(service, element.getFromNode())));
  72                 if ( i == pathElements.size() -1) {
  73                     toscaRequirements.add(handleSingleReq(fetchCPName(service, element.getToNode(), element.getToCP(), capabiltyRequirementConvertor, originComponents, toscaOperationFacade), fetchNodeName(service, element
  74                             .getToNode())));
  75                 }
  76        }
  77         return toscaRequirements;
  78
  79     }
  80
  81     private static String fetchNodeName(Service service, String nodeId) {
  82         if (service.getComponentInstanceByName(nodeId).isPresent()) {
  83             return service.getComponentInstanceByName(nodeId).get().getName();
  84         } else {
  85             return "";
  86         }
  87     }
  88
  89
  90     private static Map<String, ToscaTemplateRequirement> handleSingleReq(
  91             String fromCP, String fromNode) {
  92         Map<String, ToscaTemplateRequirement> toscaReqMap = new HashMap<>();
  93         ToscaTemplateRequirement firstReq = new ToscaTemplateRequirement();
  94         firstReq.setRelationship(FORWARDS_TO_TOSCA_NAME); //todo
  95         firstReq.setCapability(fromCP);
  96         firstReq.setNode(fromNode);
  97         toscaReqMap.put(FORWARDER, firstReq);
  98
  99         return toscaReqMap;
 100     }
 101
 102     /**
 103      * @todo handle errors.
 104      */
 105     private static String fetchCPName(Service service, String nodeID, String cpName, CapabilityRequirementConverter capabiltyRequirementConvertor, Map<String, Component> originComponents, ToscaOperationFacade toscaOperationFacade) {
 106         Optional<ComponentInstance> componentInstance = service.getComponentInstanceByName(nodeID);
 107         ComponentInstance componentInstanceVal = componentInstance.get();
 108         String name = componentInstanceVal.getNormalizedName();
 109         Component component = originComponents.get(componentInstanceVal.getComponentUid());
 110         if(componentInstanceVal.getIsProxy()){
 111             component = originComponents.get(componentInstanceVal.getSourceModelUid());
 112             if (component == null) {
 113                 component = toscaOperationFacade.getToscaFullElement(componentInstanceVal.getSourceModelUid()).left().value();
 114             }
 115
 116         }
 117         CapabilityDefinition capability = componentInstanceVal.getCapabilities().values().stream().flatMap(Collection::stream)
 118                 .filter(capabilityDefinition -> capabilityDefinition.getName().equals(cpName)).findAny().get();
 119         List<String> path = capability.getPath();
 120         List<String> reducedPath = new ArrayList<>(path);
 121         reducedPath.remove(reducedPath.size() - 1);
 122         Either<String, Boolean> stringBooleanEither = capabiltyRequirementConvertor.buildSubstitutedName(originComponents, component, reducedPath, capability.getName(), null);
 123         return name + "." + stringBooleanEither.left().value();
 124     }
 125 }