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