vid-app-common/src/main/java/org/onap/vid/asdc/parser/ToscaParserImpl2.java

   1 package org.onap.vid.asdc.parser;
   2
   3 import org.onap.vid.asdc.beans.Service;
   4 import org.onap.vid.model.*;
   5 import org.openecomp.sdc.tosca.parser.api.ISdcCsarHelper;
   6 import org.openecomp.sdc.tosca.parser.exceptions.SdcToscaParserException;
   7 import org.openecomp.sdc.tosca.parser.impl.FilterType;
   8 import org.openecomp.sdc.tosca.parser.impl.SdcToscaParserFactory;
   9 import org.openecomp.sdc.tosca.parser.impl.SdcTypes;
  10 import org.openecomp.sdc.toscaparser.api.*;
  11 import org.openecomp.sdc.toscaparser.api.parameters.Input;
  12
  13 import java.nio.file.Path;
  14 import java.util.*;
  15 import java.util.stream.Collectors;
  16
  17 import static java.util.stream.Collectors.toMap;
  18
  19 public class ToscaParserImpl2 {
  20
  21
  22         public class Constants {
  23                 public final static String uuid = "UUID";
  24                 public final static String description = "description";
  25                 public final static String serviceType = "serviceType";
  26         public final static String serviceRole = "serviceRole";
  27         public final static String ecompGeneratedNaming = "ecompGeneratedNaming";
  28
  29         public final static String customizationUUID = "customizationUUID";
  30                 public final static String vfModuleModelVersion = "vfModuleModelVersion";
  31                 public final static String vfModuleModelCustomizationUUID = "vfModuleModelCustomizationUUID";
  32                 public final static String volume_group = "volume_group";
  33                 public final static String vfModuleModelInvariantUUID = "vfModuleModelInvariantUUID";
  34                 public final static String vfModuleModelUUID = "vfModuleModelUUID";
  35                 public final static String invariantUUID = "invariantUUID";
  36                 public final static String version = "version";
  37                 public final static String name = "name";
  38                 public final static String category = "category";
  39                 public final static String vfModuleModelName = "vfModuleModelName";
  40                 public final static String getInput = "get_input";
  41
  42                 public final static String instantiationType = "instantiationType";
  43         //Instantiation Types
  44         public final static String both = "Both";
  45         public final static String macro = "Macro";
  46         public final static String aLaCarte = "A-La-Carte";
  47         public final static String clientConfig = "ClientConfig";
  48
  49
  50         }
  51
  52         public ToscaParserImpl2() {
  53
  54     }
  55
  56     public ServiceModel  makeServiceModel(Path path, Service asdcServiceMetadata) throws Exception {
  57         ServiceModel serviceModel = new ServiceModel();
  58         SdcToscaParserFactory factory = SdcToscaParserFactory.getInstance();
  59         ISdcCsarHelper sdcCsarHelper = factory.getSdcCsarHelper(path.toFile().getAbsolutePath(),false);
  60         serviceModel.setService(extractServiceFromCsar(asdcServiceMetadata, sdcCsarHelper));
  61
  62         serviceModel.setVolumeGroups(extractVolumeGroups(sdcCsarHelper));
  63         serviceModel.setVfModules(extractVfModuleFromCsar(sdcCsarHelper));
  64         serviceModel.setVnfs(extractVnfsFromCsar(serviceModel,sdcCsarHelper));
  65         serviceModel.setConfigurations(extractPortMirroringConfigFromCsar(sdcCsarHelper));
  66         serviceModel.setServiceProxies(extractServiceProxyFromCsar(sdcCsarHelper));
  67         serviceModel.setNetworks(extractNetworksFromCsar(sdcCsarHelper));
  68         serviceModel.setPnfs(extractPnfsFromCsar(sdcCsarHelper));
  69         return serviceModel;
  70     }
  71
  72     private  org.onap.vid.model.Service extractServiceFromCsar(Service asdcServiceMetadata, ISdcCsarHelper csarHelper) throws SdcToscaParserException {
  73         org.onap.vid.model.Service service = new  org.onap.vid.model.Service();
  74
  75         service.setName(csarHelper.getServiceMetadata().getValue(Constants.name));
  76         service.setCategory(csarHelper.getServiceMetadata().getValue(Constants.category));
  77         service.setInvariantUuid(csarHelper.getServiceMetadata().getValue(Constants.invariantUUID));
  78         service.setUuid(csarHelper.getServiceMetadata().getValue(Constants.uuid));
  79         service.setVersion(asdcServiceMetadata.getVersion());
  80         service.setDescription(csarHelper.getServiceMetadata().getValue(Constants.description));
  81         service.setInputs(inputsListToInputsMap(csarHelper.getServiceInputs()));
  82         service.setServiceEcompNaming(csarHelper.getServiceMetadata().getValue(Constants.ecompGeneratedNaming));
  83         service.setServiceType(csarHelper.getServiceMetadata().getValue(Constants.serviceType));
  84         service.setServiceRole(csarHelper.getServiceMetadata().getValue(Constants.serviceRole));
  85         service.setInstantiationType(validateInstantiationType(csarHelper));
  86         return service;
  87     }
  88
  89
  90     private Map<String, VNF> extractVnfsFromCsar(ServiceModel serviceModel,ISdcCsarHelper csarHelper) {
  91         List<NodeTemplate> nodeTemplates = csarHelper.getServiceVfList();
  92         Map<String, VNF> vnfsMaps = new HashMap<String, VNF>();
  93
  94         for (NodeTemplate nodeTemplate : nodeTemplates) {
  95             VNF vnf = new VNF();
  96             populateNodeFromNodeTemplate(nodeTemplate, csarHelper, vnf);
  97
  98             vnf.setModelCustomizationName(nodeTemplate.getName());
  99             Map<String, VfModule> vfModuleHashMap = getVfModulesFromVF(csarHelper, vnf.getCustomizationUuid());
 100             vnf.setVfModules(vfModuleHashMap);
 101
 102             Map<String, VolumeGroup> volumeGroupMap = getVolumeGroupsFromVF(csarHelper, vnf.getCustomizationUuid());
 103             vnf.setVolumeGroups(volumeGroupMap);
 104
 105             vnfsMaps.put(nodeTemplate.getName(), vnf);
 106         }
 107         return vnfsMaps;
 108     }
 109
 110     private Map<String, PortMirroringConfig> extractPortMirroringConfigFromCsar(ISdcCsarHelper csarHelper) {
 111         List<NodeTemplate> nodeTemplates = csarHelper.getServiceNodeTemplateBySdcType(SdcTypes.CONFIGURATION);
 112         Map<String, PortMirroringConfig> configMaps = new HashMap<>();
 113
 114         for (NodeTemplate nodeTemplate : nodeTemplates) {
 115             PortMirroringConfig pmConfig = new PortMirroringConfig();
 116             populateNodeFromNodeTemplate(nodeTemplate, csarHelper, pmConfig);
 117
 118             pmConfig.setModelCustomizationName(nodeTemplate.getName());
 119             pmConfig.setRequirementAssignments(nodeTemplate.getRequirements());
 120             setSourceAndCollectorProxyNodes(csarHelper, pmConfig, nodeTemplate);
 121
 122             configMaps.put(nodeTemplate.getName(), pmConfig);
 123         }
 124
 125         return configMaps;
 126         }
 127
 128     private Map<String, ServiceProxy> extractServiceProxyFromCsar(ISdcCsarHelper csarHelper) {
 129         List<NodeTemplate> nodeTemplates = csarHelper.getServiceNodeTemplateBySdcType(SdcTypes.SERVICE_PROXY);
 130         Map<String, ServiceProxy> serviceProxies = new HashMap<>();
 131         for (NodeTemplate nodeTemplate: nodeTemplates) {
 132             ServiceProxy serviceProxy = new ServiceProxy();
 133             populateNodeFromNodeTemplate(nodeTemplate, csarHelper, serviceProxy);
 134
 135             Map<String, String> metadata = nodeTemplate.getMetaData().getAllProperties();
 136             serviceProxy.setSourceModelUuid(metadata.get("sourceModelUuid"));
 137             serviceProxy.setSourceModelInvariant(metadata.get("sourceModelInvariant"));
 138             serviceProxy.setSourceModelName(metadata.get("sourceModelName"));
 139
 140             serviceProxies.put(nodeTemplate.getName(), serviceProxy);
 141         }
 142
 143         return serviceProxies;
 144     }
 145
 146         private void setSourceAndCollectorProxyNodes(ISdcCsarHelper csarHelper, PortMirroringConfig portMirroringConfig, NodeTemplate nodeTemplate) {
 147             RequirementAssignments requirementAssignments = nodeTemplate.getRequirements();
 148
 149         List<String> sourceNodes = getRequirementsNodesNames(requirementAssignments.getRequirementsByName("source").getAll());
 150         portMirroringConfig.setSourceNodes(sourceNodes);
 151
 152         List<String> collectorNodes = getRequirementsNodesNames(requirementAssignments.getRequirementsByName("collector").getAll());
 153         if (!collectorNodes.isEmpty()) { // vprobe
 154             portMirroringConfig.setCollectorNodes(collectorNodes);
 155         } else { // pprobe - configuration by policy
 156             String collectorNodeName = csarHelper.getNodeTemplatePropertyLeafValue(nodeTemplate, "collector_node");
 157             if (collectorNodeName != null) {
 158                 portMirroringConfig.setCollectorNodes(Arrays.asList(collectorNodeName));
 159                 portMirroringConfig.setConfigurationByPolicy(true);
 160             }
 161         }
 162     }
 163
 164     private List<String> getRequirementsNodesNames(List<RequirementAssignment> requirements) {
 165
 166         List<String> requirementsNodes = new ArrayList<>();
 167         if (requirements != null && requirements.size() > 0) {
 168             requirementsNodes =  requirements.stream().map(RequirementAssignment::getNodeTemplateName).collect(Collectors.toList());
 169         }
 170
 171         return requirementsNodes;
 172     }
 173
 174     Map<String, VfModule> getVfModulesFromVF(ISdcCsarHelper csarHelper, String vfUuid) {
 175         List<Group> vfModulesByVf = csarHelper.getVfModulesByVf(vfUuid);
 176         return vfModulesByVf.stream()
 177                 .collect(toMap(Group::getName, this::populateVfModuleFromGroup));
 178     }
 179
 180     Map<String, VolumeGroup> getVolumeGroupsFromVF(ISdcCsarHelper csarHelper, String vfCustomizationUuid) {
 181         List<Group> vfModulesByVf = csarHelper.getVfModulesByVf(vfCustomizationUuid);
 182         return vfModulesByVf.stream()
 183                 .filter((group -> isVolumeGroup(group)))
 184                 .collect(toMap(Group::getName, this::populateVolumeGroupFromGroup));
 185     }
 186
 187     private static Boolean isVolumeGroup(Group group) {
 188         return Boolean.valueOf(group.getPropertyValue(Constants.volume_group).toString());
 189     }
 190
 191     private Map<String, Network> extractNetworksFromCsar(ISdcCsarHelper csarHelper) {
 192         List<NodeTemplate> nodeTemplates = csarHelper.getServiceVlList();
 193         Map<String, Network> networksMap = new HashMap<String, Network>();
 194
 195         for (NodeTemplate nodeTemplate : nodeTemplates) {
 196             Network newNetwork = new Network();
 197             populateNodeFromNodeTemplate(nodeTemplate, csarHelper, newNetwork);
 198             newNetwork.setModelCustomizationName(nodeTemplate.getName());
 199             networksMap.put(nodeTemplate.getName(), newNetwork);
 200         }
 201         return networksMap;
 202         }
 203
 204         private Map<String,Node> extractPnfsFromCsar(ISdcCsarHelper csarHelper) {
 205         List<NodeTemplate> nodeTemplates = csarHelper.getServiceNodeTemplateBySdcType(SdcTypes.PNF);
 206         HashMap<String, Node> pnfHashMap = new HashMap<>();
 207
 208         for (NodeTemplate nodeTemplate : nodeTemplates) {
 209             Node pnf = new Node();
 210             populateNodeFromNodeTemplate(nodeTemplate, csarHelper, pnf);
 211             pnfHashMap.put(nodeTemplate.getName(), pnf);
 212         }
 213         return pnfHashMap;
 214     }
 215
 216     private Map<String, VfModule> extractVfModuleFromCsar(ISdcCsarHelper csarHelper) {
 217         List<NodeTemplate> serviceVfList = csarHelper.getServiceVfList();
 218         HashMap<String, VfModule> vfModuleHashMap = new HashMap<>();
 219
 220         for (NodeTemplate nodeTemplate : serviceVfList) {
 221             Map<String, VfModule> nodeTemplateVfModule =
 222                     getVfModulesFromVF(csarHelper, nodeTemplate.getMetaData().getValue(Constants.customizationUUID));
 223             vfModuleHashMap.putAll(nodeTemplateVfModule);
 224         }
 225         return vfModuleHashMap;
 226     }
 227
 228     private Map<String, VolumeGroup> extractVolumeGroups(ISdcCsarHelper csarHelper) {
 229         HashMap<String, VolumeGroup> volumeGroupHashMap = new HashMap<>();
 230         for (NodeTemplate nodeTemplate : csarHelper.getServiceVfList()) {
 231             Map<String, VolumeGroup> nodeTemplateVolumeGroups =
 232                     getVolumeGroupsFromVF(csarHelper, csarHelper.getNodeTemplateCustomizationUuid(nodeTemplate));
 233             volumeGroupHashMap.putAll(nodeTemplateVolumeGroups);
 234         }
 235         return volumeGroupHashMap;
 236     }
 237
 238     private Map<String, org.onap.vid.asdc.beans.tosca.Input> inputsListToInputsMap(List<org.openecomp.sdc.toscaparser.api.parameters.Input> inputList) {
 239         Map<String, org.onap.vid.asdc.beans.tosca.Input> inputs = new HashMap<>();
 240         for (org.openecomp.sdc.toscaparser.api.parameters.Input input : inputList) {
 241             inputs.put(input.getName(), convertInput(input, new org.onap.vid.asdc.beans.tosca.Input()));
 242         }
 243         return inputs;
 244     }
 245
 246     private Node populateNodeFromNodeTemplate(NodeTemplate nodeTemplate, ISdcCsarHelper csarHelper, Node newNode) {
 247         newNode.setCustomizationUuid(csarHelper.getNodeTemplateCustomizationUuid(nodeTemplate));
 248         newNode.setDescription(nodeTemplate.getMetaData().getValue(Constants.description));
 249         newNode.setInvariantUuid(nodeTemplate.getMetaData().getValue(Constants.invariantUUID));
 250         newNode.setUuid(nodeTemplate.getMetaData().getValue(Constants.uuid));
 251         newNode.setName(nodeTemplate.getMetaData().getValue(Constants.name));
 252         newNode.setVersion(nodeTemplate.getMetaData().getValue(Constants.version));
 253         newNode.setInputs(extractInputsAndCommandsForNodeTemplate(nodeTemplate, csarHelper, newNode));
 254         newNode.setType(nodeTemplate.getMetaData().getValue("type"));
 255         Map<String, String> propertiesMap = setPropertiesOfVnf(nodeTemplate.getPropertiesObjects());
 256         newNode.setProperties(propertiesMap);
 257         return newNode;
 258     }
 259
 260     private VfModule populateVfModuleFromGroup(Group group){
 261         VfModule vfModule = new VfModule();
 262
 263         vfModule.setVersion(group.getMetadata().getValue(Constants.vfModuleModelVersion));
 264         vfModule.setCustomizationUuid(group.getMetadata().getValue(Constants.vfModuleModelCustomizationUUID));
 265         vfModule.setModelCustomizationName(group.getMetadata().getValue(Constants.vfModuleModelName));
 266         vfModule.setName(group.getMetadata().getValue(Constants.vfModuleModelName));
 267         vfModule.setVolumeGroupAllowed(isVolumeGroup(group));
 268         vfModule.setDescription(group.getDescription());
 269         vfModule.setInvariantUuid(group.getMetadata().getValue(Constants.vfModuleModelInvariantUUID));
 270         vfModule.setUuid(group.getMetadata().getValue(Constants.vfModuleModelUUID));
 271         return vfModule;
 272     }
 273
 274     private VolumeGroup populateVolumeGroupFromGroup(Group group){
 275         VolumeGroup volumeGroup = new VolumeGroup();
 276         volumeGroup.setDescription(group.getDescription());
 277         volumeGroup.setInvariantUuid(group.getMetadata().getValue(Constants.vfModuleModelInvariantUUID));
 278         volumeGroup.setName(group.getMetadata().getValue(Constants.vfModuleModelName));
 279         volumeGroup.setModelCustomizationName(group.getMetadata().getValue(Constants.vfModuleModelName));
 280         volumeGroup.setVersion(group.getMetadata().getValue(Constants.vfModuleModelVersion));
 281         volumeGroup.setUuid(group.getMetadata().getValue(Constants.vfModuleModelUUID));
 282         volumeGroup.setCustomizationUuid(group.getMetadata().getValue(Constants.vfModuleModelCustomizationUUID));
 283
 284         return volumeGroup;
 285     }
 286
 287
 288     private Map<String, org.onap.vid.asdc.beans.tosca.Input> extractInputsAndCommandsForNodeTemplate(NodeTemplate nodeTemplate, ISdcCsarHelper csarHelper, Node newNode){
 289         Map<String, org.onap.vid.asdc.beans.tosca.Input> inputMap = new HashMap<>();
 290         Map<String, CommandProperty> commandPropertyMap = new HashMap<>();
 291
 292         List<Input> inputs = csarHelper.getServiceInputs();
 293         Map<String, String> properties  = csarHelper.filterNodeTemplatePropertiesByValue(nodeTemplate, FilterType.CONTAINS, Constants.getInput);
 294         for (Map.Entry<String, String> property : properties.entrySet()) {
 295             String inputKey = property.getValue();
 296             String key = extractInputValue(inputKey);
 297             for (Input input: inputs){
 298                 if(input.getName().equals(key)){
 299                     org.onap.vid.asdc.beans.tosca.Input localInput = new org.onap.vid.asdc.beans.tosca.Input();
 300                     localInput = convertInput(input, localInput);
 301                     String name = property.getKey();
 302                     commandPropertyMap.put(name, extractCommands(name, key));
 303                     inputMap.put(name, localInput);
 304                 }
 305             }
 306         }
 307         newNode.setCommands(commandPropertyMap);
 308         return inputMap;
 309     }
 310
 311     private String extractInputValue(String inputKey) {
 312         return inputKey.substring(inputKey.indexOf(":") + 1);
 313     }
 314
 315     private org.onap.vid.asdc.beans.tosca.Input convertInput(Input parserInput, org.onap.vid.asdc.beans.tosca.Input localInput){
 316         localInput.setDefault(parserInput.getDefault());
 317         localInput.setDescription(parserInput.getDescription());
 318         localInput.setRequired(parserInput.isRequired());
 319         localInput.setType(parserInput.getType());
 320         localInput.setConstraints(parserInput.getConstraints());
 321 //        localInput.setentry_schema()
 322         return localInput;
 323     }
 324
 325     private CommandProperty extractCommands(String displayName, String inputName){
 326         CommandProperty commandProperty = new CommandProperty();
 327         commandProperty.setDisplayName(displayName);
 328         commandProperty.setCommand(Constants.getInput);
 329         commandProperty.setInputName(inputName);
 330         return commandProperty;
 331     }
 332
 333     private Map<String, String> setPropertiesOfVnf(List<Property> properties) {
 334         Map<String, String> propertiesMap = new HashMap<String, String>();
 335         for (Property property : properties) {
 336             propertiesMap.put(property.getName(), property.getValue().toString());
 337         }
 338         return propertiesMap;
 339     }
 340
 341     private String validateInstantiationType(ISdcCsarHelper csarHelper){
 342         String instantiationType = csarHelper.getServiceMetadata().getValue(Constants.instantiationType);
 343         String validatedInstantiationType = Constants.clientConfig;
 344         if(instantiationType != null && !instantiationType.isEmpty()){
 345             if(instantiationType.equalsIgnoreCase(Constants.macro) || instantiationType.equalsIgnoreCase(Constants.both))
 346                 validatedInstantiationType = Constants.macro;
 347             else if(instantiationType.equalsIgnoreCase(Constants.aLaCarte))
 348                 validatedInstantiationType = Constants.aLaCarte;
 349         }
 350         return validatedInstantiationType;
 351     }
 352
 353
 354 }