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 import org.apache.commons.collections4.MapUtils;
  22 import org.openecomp.sdc.logging.api.Logger;
  23 import org.openecomp.sdc.logging.api.LoggerFactory;
  24 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  25 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  26 import org.openecomp.sdc.tosca.services.DataModelUtil;
  27 import org.openecomp.sdc.tosca.services.ToscaUtil;
  28 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  29 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionData;
  30 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  31 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData;
  32 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  33 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData;
  34
  35 import java.util.ArrayList;
  36 import java.util.Collection;
  37 import java.util.HashMap;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.Objects;
  41
  42 /**
  43  * Utility class for consolidation data collection helper methods.
  44  */
  45 public class UnifiedCompositionUtil {
  46
  47   protected static Logger logger = LoggerFactory.getLogger(UnifiedCompositionUtil.class);
  48
  49   private UnifiedCompositionUtil() {
  50     //Hiding the implicit public constructor
  51   }
  52
  53   /**
  54    * Gets all ports per port type, which are connected to the computes from the input
  55    * computeTemplateConsolidationDataCollection.
  56    *
  57    * @param computeTemplateConsolidationDataCollection collection of compute template
  58    *                                                   consolidation data
  59    * @return set of port ids, per port type
  60    */
  61   static Map<String, List<String>> collectAllPortsFromEachTypesFromComputes(
  62       Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationDataCollection) {
  63     Map<String, List<String>> portTypeToIds = new HashMap<>();
  64
  65     for (ComputeTemplateConsolidationData compute : computeTemplateConsolidationDataCollection) {
  66       Map<String, List<String>> ports = compute.getPorts();
  67       if (!MapUtils.isEmpty(ports)) {
  68         addPortsToMap(portTypeToIds, ports);
  69       }
  70     }
  71
  72     return portTypeToIds;
  73   }
  74
  75   static ListMultimap<String, SubInterfaceTemplateConsolidationData>
  76         collectAllSubInterfacesOfEachTypesFromPorts(Collection<PortTemplateConsolidationData>
  77                                                     portTemplateConsolidationDataCollection) {
  78     ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfaceDataByType = ArrayListMultimap.create();
  79     for (PortTemplateConsolidationData port : portTemplateConsolidationDataCollection) {
  80       port.copyMappedInto(subInterfaceDataByType);
  81     }
  82     return subInterfaceDataByType;
  83   }
  84
  85   private static void addPortsToMap(Map<String, List<String>> portTypeToIds,
  86                                     Map<String, List<String>> ports) {
  87     for (Map.Entry<String, List<String>> portTypeToIdEntry : ports.entrySet()) {
  88       portTypeToIds.putIfAbsent(portTypeToIdEntry.getKey(), new ArrayList<>());
  89       portTypeToIds.get(portTypeToIdEntry.getKey()).addAll(portTypeToIdEntry.getValue());
  90     }
  91   }
  92
  93   static String getComputeTypeSuffix(ServiceTemplate serviceTemplate,
  94                                       String computeNodeTemplateId) {
  95     NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
  96     if (Objects.nonNull(computeNodeTemplate)) {
  97       return getComputeTypeSuffix(computeNodeTemplate.getType());
  98     }
  99     return null;
 100   }
 101
 102   public static String getNewComputeNodeTemplateId(ServiceTemplate serviceTemplate, String computeNodeTemplateId) {
 103     return getComputeTypeSuffix(serviceTemplate, computeNodeTemplateId);
 104   }
 105
 106   static String getComputeTypeSuffix(String computeType) {
 107     return DataModelUtil.getNamespaceSuffix(computeType);
 108   }
 109
 110   public static ComputeTemplateConsolidationData getConnectedComputeConsolidationData(
 111       List<UnifiedCompositionData> unifiedCompositionDataList,
 112       String portNodeTemplateId) {
 113     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 114       if (Objects.isNull(unifiedCompositionData.getComputeTemplateConsolidationData().getPorts())) {
 115         continue;
 116       }
 117       Collection<List<String>> portsCollection =
 118           unifiedCompositionData.getComputeTemplateConsolidationData().getPorts().values();
 119       for (List<String> portIdList : portsCollection) {
 120         if (portIdList.contains(portNodeTemplateId)) {
 121           return unifiedCompositionData.getComputeTemplateConsolidationData();
 122         }
 123       }
 124     }
 125     return null;
 126   }
 127
 128   //The ID should be <vm_type>_<port_type> or <vm_type>_<portNodeTemplateId>
 129   public static String getNewPortNodeTemplateId(
 130       String portNodeTemplateId,
 131       String connectedComputeNodeType,
 132       ComputeTemplateConsolidationData computeTemplateConsolidationData) {
 133
 134     StringBuilder newPortNodeTemplateId = new StringBuilder();
 135     String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId);
 136     newPortNodeTemplateId.append(DataModelUtil.getNamespaceSuffix(connectedComputeNodeType));
 137     if (computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
 138       //single port
 139       newPortNodeTemplateId.append("_").append(portNodeTemplateId);
 140     } else {
 141       //consolidation port
 142       newPortNodeTemplateId.append("_").append(portType);
 143     }
 144     return newPortNodeTemplateId.toString();
 145   }
 146
 147   public static String getNewSubInterfaceNodeTemplateId(ServiceTemplate serviceTemplate,
 148                                                   String connectedComputeNodeType,
 149                                                   ComputeTemplateConsolidationData computeTemplateConsolidationData,
 150                                                   SubInterfaceTemplateConsolidationData
 151                                                             subInterfaceTemplateConsolidationData,
 152                                                   TranslationContext context) {
 153     //The ID should be <vm_type>_<portType/NodetemplateId>_<subInterface_type>
 154     // or <vm_type>_<portType/NodetemplateId>_<subInterfaceNodeTemplateId>
 155     StringBuilder newSubInterfaceNodeTemplateId = new StringBuilder();
 156     newSubInterfaceNodeTemplateId.append(getNewPortNodeTemplateId(subInterfaceTemplateConsolidationData
 157         .getParentPortNodeTemplateId(), connectedComputeNodeType, computeTemplateConsolidationData));
 158     PortTemplateConsolidationData portTemplateConsolidationData =
 159         getSubInterfacePortTemplateConsolidationData(serviceTemplate, subInterfaceTemplateConsolidationData, context);
 160     NodeTemplate subInterfaceNodeTemplate =
 161         DataModelUtil.getNodeTemplate(serviceTemplate, subInterfaceTemplateConsolidationData.getNodeTemplateId());
 162     if (Objects.nonNull(portTemplateConsolidationData)) {
 163         String subInterfaceSuffix = (portTemplateConsolidationData.isSubInterfaceNodeTemplateIdParameter(subInterfaceNodeTemplate.getType()))?
 164               //If there are more than one subinterfaces with same type use node template id
 165               subInterfaceTemplateConsolidationData.getNodeTemplateId():
 166                     //Add sub interface type since we have only one subinterface per type
 167                      getSubInterfaceTypeSuffix(subInterfaceNodeTemplate.getType());
 168         newSubInterfaceNodeTemplateId.append("_").append(subInterfaceSuffix);
 169         return newSubInterfaceNodeTemplateId.toString();
 170       }
 171     return subInterfaceTemplateConsolidationData.getNodeTemplateId();
 172   }
 173
 174   static PortTemplateConsolidationData getSubInterfacePortTemplateConsolidationData(ServiceTemplate serviceTemplate,
 175                                                                                SubInterfaceTemplateConsolidationData
 176                                                                                    subInterfaceTemplateConsolidationData,
 177                                                                                      TranslationContext context) {
 178     FilePortConsolidationData filePortConsolidationData = context.getConsolidationData().getPortConsolidationData()
 179         .getFilePortConsolidationData(ToscaUtil.getServiceTemplateFileName(serviceTemplate));
 180     PortTemplateConsolidationData portTemplateConsolidationData = null;
 181     if (filePortConsolidationData != null) {
 182       portTemplateConsolidationData = filePortConsolidationData
 183           .getPortTemplateConsolidationData(subInterfaceTemplateConsolidationData.getParentPortNodeTemplateId());
 184     }
 185     return portTemplateConsolidationData;
 186   }
 187
 188   static String getSubInterfaceTypeSuffix(String nodeType) {
 189     return DataModelUtil.getNamespaceSuffix(nodeType);
 190   }
 191
 192   public static List<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationDataList(
 193       UnifiedCompositionData unifiedCompositionData) {
 194     return unifiedCompositionData.getSubInterfaceTemplateConsolidationDataList() == null ? new
 195         ArrayList<>() : unifiedCompositionData.getSubInterfaceTemplateConsolidationDataList();
 196   }
 197
 198 }