gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.translator.services.heattotosca;
  18
  19 import com.google.common.collect.ArrayListMultimap;
  20 import com.google.common.collect.ListMultimap;
  21
  22 import java.util.ArrayList;
  23 import java.util.Collection;
  24 import java.util.Collections;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.Objects;
  29 import java.util.Optional;
  30
  31 import org.apache.commons.collections4.MapUtils;
  32 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  33 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  34 import org.openecomp.sdc.tosca.services.DataModelUtil;
  35 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  36 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionData;
  37 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  38 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  39 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData;
  40
  41 /**
  42  * Utility class for consolidation data collection helper methods.
  43  */
  44 public class UnifiedCompositionUtil {
  45
  46   private UnifiedCompositionUtil() {
  47     //Hiding the implicit public constructor
  48   }
  49
  50   /**
  51    * Gets all ports per port type, which are connected to the computes from the input
  52    * computeTemplateConsolidationDataCollection.
  53    *
  54    * @param computeTemplateConsolidationDataCollection collection of compute template
  55    *                                                   consolidation data
  56    * @return set of port ids, per port type
  57    */
  58   static Map<String, List<String>> collectAllPortsFromEachTypesFromComputes(
  59       Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationDataCollection) {
  60     Map<String, List<String>> portTypeToIds = new HashMap<>();
  61
  62     for (ComputeTemplateConsolidationData compute : computeTemplateConsolidationDataCollection) {
  63       Map<String, List<String>> ports = compute.getPorts();
  64       if (!MapUtils.isEmpty(ports)) {
  65         addPortsToMap(portTypeToIds, ports);
  66       }
  67     }
  68
  69     return portTypeToIds;
  70   }
  71
  72   static ListMultimap<String, SubInterfaceTemplateConsolidationData>
  73         collectAllSubInterfacesOfEachTypesFromPorts(Collection<PortTemplateConsolidationData>
  74                                                     portTemplateConsolidationDataCollection) {
  75     ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfaceDataByType = ArrayListMultimap.create();
  76     for (PortTemplateConsolidationData port : portTemplateConsolidationDataCollection) {
  77       port.copyMappedInto(subInterfaceDataByType);
  78     }
  79     return subInterfaceDataByType;
  80   }
  81
  82   private static void addPortsToMap(Map<String, List<String>> portTypeToIds,
  83                                     Map<String, List<String>> ports) {
  84     for (Map.Entry<String, List<String>> portTypeToIdEntry : ports.entrySet()) {
  85       portTypeToIds.putIfAbsent(portTypeToIdEntry.getKey(), new ArrayList<>());
  86       portTypeToIds.get(portTypeToIdEntry.getKey()).addAll(portTypeToIdEntry.getValue());
  87     }
  88   }
  89
  90   static String getComputeTypeSuffix(ServiceTemplate serviceTemplate,
  91                                       String computeNodeTemplateId) {
  92     NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
  93     if (Objects.nonNull(computeNodeTemplate)) {
  94       return getComputeTypeSuffix(computeNodeTemplate.getType());
  95     }
  96     return null;
  97   }
  98
  99   public static String getNewComputeNodeTemplateId(ServiceTemplate serviceTemplate, String computeNodeTemplateId) {
 100     return getComputeTypeSuffix(serviceTemplate, computeNodeTemplateId);
 101   }
 102
 103   static String getComputeTypeSuffix(String computeType) {
 104     return DataModelUtil.getNamespaceSuffix(computeType);
 105   }
 106
 107   public static ComputeTemplateConsolidationData getConnectedComputeConsolidationData(
 108       List<UnifiedCompositionData> unifiedCompositionDataList,
 109       String portNodeTemplateId) {
 110     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 111       if (Objects.isNull(unifiedCompositionData.getComputeTemplateConsolidationData().getPorts())) {
 112         continue;
 113       }
 114       Collection<List<String>> portsCollection =
 115           unifiedCompositionData.getComputeTemplateConsolidationData().getPorts().values();
 116       for (List<String> portIdList : portsCollection) {
 117         if (portIdList.contains(portNodeTemplateId)) {
 118           return unifiedCompositionData.getComputeTemplateConsolidationData();
 119         }
 120       }
 121     }
 122     return null;
 123   }
 124
 125   //The ID should be <vm_type>_<port_type> or <vm_type>_<portNodeTemplateId>
 126   public static String getNewPortNodeTemplateId(
 127       String portNodeTemplateId,
 128       String connectedComputeNodeType,
 129       ComputeTemplateConsolidationData computeTemplateConsolidationData) {
 130
 131     StringBuilder newPortNodeTemplateId = new StringBuilder();
 132     String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId);
 133     newPortNodeTemplateId.append(DataModelUtil.getNamespaceSuffix(connectedComputeNodeType));
 134     if (computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
 135       //single port
 136       newPortNodeTemplateId.append("_").append(portNodeTemplateId);
 137     } else {
 138       //consolidation port
 139       newPortNodeTemplateId.append("_").append(portType);
 140     }
 141     return newPortNodeTemplateId.toString();
 142   }
 143
 144   public static String getNewSubInterfaceNodeTemplateId(ServiceTemplate serviceTemplate,
 145                                                   String connectedComputeNodeType,
 146                                                   ComputeTemplateConsolidationData computeTemplateConsolidationData,
 147                                                   SubInterfaceTemplateConsolidationData
 148                                                             subInterfaceTemplateConsolidationData,
 149                                                   TranslationContext context) {
 150     //The ID should be <vm_type>_<portType/NodetemplateId>_<subInterface_type>
 151     // or <vm_type>_<portType/NodetemplateId>_<subInterfaceNodeTemplateId>
 152     StringBuilder newSubInterfaceNodeTemplateId = new StringBuilder();
 153     newSubInterfaceNodeTemplateId.append(getNewPortNodeTemplateId(subInterfaceTemplateConsolidationData
 154         .getParentPortNodeTemplateId(), connectedComputeNodeType, computeTemplateConsolidationData));
 155     Optional<PortTemplateConsolidationData> portTemplateConsolidationData =
 156         subInterfaceTemplateConsolidationData.getParentPortTemplateConsolidationData(serviceTemplate, context);
 157     NodeTemplate subInterfaceNodeTemplate =
 158         DataModelUtil.getNodeTemplate(serviceTemplate, subInterfaceTemplateConsolidationData.getNodeTemplateId());
 159     if (portTemplateConsolidationData.isPresent()) {
 160       String subInterfaceSuffix = getSubInterfaceSuffix(portTemplateConsolidationData.get(),
 161           subInterfaceNodeTemplate, subInterfaceTemplateConsolidationData);
 162       newSubInterfaceNodeTemplateId.append("_").append(subInterfaceSuffix);
 163       return newSubInterfaceNodeTemplateId.toString();
 164     }
 165     return subInterfaceTemplateConsolidationData.getNodeTemplateId();
 166   }
 167
 168   static String getSubInterfaceTypeSuffix(String nodeType) {
 169     return DataModelUtil.getNamespaceSuffix(nodeType);
 170   }
 171
 172   public static List<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationDataList(
 173       UnifiedCompositionData unifiedCompositionData) {
 174     return unifiedCompositionData.getSubInterfaceTemplateConsolidationDataList() == null ? Collections.emptyList() :
 175         unifiedCompositionData.getSubInterfaceTemplateConsolidationDataList();
 176   }
 177
 178   private static String getSubInterfaceSuffix(PortTemplateConsolidationData portTemplateConsolidationData,
 179                                               NodeTemplate subInterfaceNodeTemplate,
 180                                               SubInterfaceTemplateConsolidationData
 181                                                   subInterfaceTemplateConsolidationData) {
 182     if (portTemplateConsolidationData.isSubInterfaceNodeTemplateIdParameter(subInterfaceNodeTemplate.getType())) {
 183       //If there are more than one subinterfaces with same type use node template id
 184       return subInterfaceTemplateConsolidationData.getNodeTemplateId();
 185     }
 186     //Add sub interface type since we have only one subinterface per type
 187     return getSubInterfaceTypeSuffix(subInterfaceNodeTemplate.getType());
 188   }
 189
 190     public static Map<String, List<String>> collectAllPortsOfEachTypeFromComputes(
 191                                                              List<UnifiedCompositionData> unifiedCompositionDataList) {
 192         Map<String, List<String>> portIdsPerPortType = new HashMap<>();
 193         unifiedCompositionDataList
 194                 .forEach(unifiedCompositionData ->
 195                                  unifiedCompositionData.getComputeTemplateConsolidationData()
 196                                                        .collectAllPortsOfEachTypeFromCompute(portIdsPerPortType));
 197
 198         return portIdsPerPortType;
 199     }
 200 }