gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2017 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.core.impl;
  18
  19 import static org.openecomp.core.converter.datatypes.Constants.ONAP_INDEX;
  20 import static org.openecomp.core.converter.datatypes.Constants.capabilities;
  21 import static org.openecomp.core.converter.datatypes.Constants.definitionsDir;
  22 import static org.openecomp.core.converter.datatypes.Constants.globalStName;
  23 import static org.openecomp.core.converter.datatypes.Constants.globalSubstitution;
  24 import static org.openecomp.core.converter.datatypes.Constants.inputs;
  25 import static org.openecomp.core.converter.datatypes.Constants.mainStName;
  26 import static org.openecomp.core.converter.datatypes.Constants.manifestFileName;
  27 import static org.openecomp.core.converter.datatypes.Constants.metadataFile;
  28 import static org.openecomp.core.converter.datatypes.Constants.nodeType;
  29 import static org.openecomp.core.converter.datatypes.Constants.openecompHeatIndex;
  30 import static org.openecomp.core.converter.datatypes.Constants.outputs;
  31 import static org.openecomp.core.converter.datatypes.Constants.requirements;
  32 import static org.openecomp.core.impl.GlobalSubstitutionServiceTemplate.GLOBAL_SUBSTITUTION_SERVICE_FILE_NAME;
  33 import static org.openecomp.core.impl.GlobalSubstitutionServiceTemplate.HEAT_INDEX_IMPORT_FILE;
  34 import static org.openecomp.core.impl.GlobalSubstitutionServiceTemplate.ONAP_INDEX_IMPORT_FILE;
  35
  36 import org.apache.commons.collections.MapUtils;
  37 import org.openecomp.core.converter.ServiceTemplateReaderService;
  38 import org.openecomp.core.converter.ToscaConverter;
  39 import org.openecomp.core.converter.datatypes.Constants;
  40 import org.openecomp.core.converter.datatypes.CsarFileTypes;
  41 import org.openecomp.core.converter.errors.SubstitutionMappingsConverterErrorBuilder;
  42 import org.openecomp.core.impl.services.ServiceTemplateReaderServiceImpl;
  43 import org.openecomp.core.utilities.file.FileContentHandler;
  44 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
  45 import org.openecomp.sdc.common.errors.CoreException;
  46 import org.openecomp.sdc.common.errors.ErrorCategory;
  47 import org.openecomp.sdc.common.errors.ErrorCode;
  48 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  49 import org.openecomp.sdc.tosca.datatypes.model.ArtifactDefinition;
  50 import org.openecomp.sdc.tosca.datatypes.model.CapabilityAssignment;
  51 import org.openecomp.sdc.tosca.datatypes.model.Import;
  52 import org.openecomp.sdc.tosca.datatypes.model.InterfaceDefinition;
  53 import org.openecomp.sdc.tosca.datatypes.model.NodeFilter;
  54 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  55 import org.openecomp.sdc.tosca.datatypes.model.NodeType;
  56 import org.openecomp.sdc.tosca.datatypes.model.ParameterDefinition;
  57 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  58 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  59 import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping;
  60 import org.openecomp.sdc.tosca.services.DataModelUtil;
  61 import org.openecomp.sdc.tosca.services.ToscaUtil;
  62 import org.openecomp.sdc.translator.services.heattotosca.globaltypes.GlobalTypesGenerator;
  63 import org.yaml.snakeyaml.error.YAMLException;
  64
  65 import java.io.ByteArrayInputStream;
  66 import java.io.File;
  67 import java.io.IOException;
  68 import java.util.ArrayList;
  69 import java.util.Collection;
  70 import java.util.HashMap;
  71 import java.util.List;
  72 import java.util.Map;
  73 import java.util.Objects;
  74 import java.util.Optional;
  75 import java.util.jar.Manifest;
  76 import java.util.regex.Pattern;
  77
  78 public class ToscaConverterImpl implements ToscaConverter {
  79
  80     public ToscaConverterImpl() {
  81
  82     }
  83
  84     @Override
  85     public ToscaServiceModel convert(FileContentHandler fileContentHandler)
  86         throws IOException {
  87         Map<String, byte[]> csarFiles = new HashMap<>(fileContentHandler.getFiles());
  88         ToscaServiceModel toscaServiceModel = new ToscaServiceModel();
  89         Map<String, ServiceTemplate> serviceTemplates = new HashMap<>();
  90         FileContentHandler artifacts = new FileContentHandler();
  91         GlobalSubstitutionServiceTemplate gsst = new GlobalSubstitutionServiceTemplate();
  92         for (Map.Entry<String, byte[]> fileEntry : csarFiles.entrySet()) {
  93             CsarFileTypes fileType = getFileType(fileEntry.getKey());
  94             switch (fileType) {
  95                 case mainServiceTemplate:
  96                     handleServiceTemplate(mainStName, fileEntry.getKey(), csarFiles, serviceTemplates);
  97                     break;
  98
  99                 case globalServiceTemplate:
 100                     handleServiceTemplate(globalStName, fileEntry.getKey(), csarFiles, serviceTemplates);
 101                     break;
 102
 103                 case externalFile:
 104                     artifacts.addFile(
 105                         getConcreteArtifactFileName(fileEntry.getKey()), fileEntry.getValue());
 106                     break;
 107
 108                 case definitionsFile:
 109                     handleDefintionTemplate(fileEntry.getKey(), csarFiles, gsst);
 110                     break;
 111             }
 112         }
 113         handleMetadataFile(csarFiles);
 114         updateToscaServiceModel(toscaServiceModel, serviceTemplates, artifacts, gsst, csarFiles);
 115         return toscaServiceModel;
 116     }
 117
 118     private void handleMetadataFile(Map<String, byte[]> csarFiles) {
 119         byte[] bytes = csarFiles.remove(metadataFile);
 120         if (bytes != null) {
 121             csarFiles.put(metadataFile + ".original", bytes);
 122         }
 123     }
 124
 125     private void handleDefintionTemplate(String key, Map<String, byte[]> csarFiles,
 126                                          GlobalSubstitutionServiceTemplate gsst) {
 127         try {
 128             ServiceTemplateReaderService readerService = new ServiceTemplateReaderServiceImpl(csarFiles.get(key));
 129             if (readerService == null) {
 130                 return;
 131             }
 132             Object nodeTypes = readerService.getNodeTypes();
 133             if (nodeTypes instanceof Map) {
 134                 Map<String, NodeType> nodeTypeMap = (Map<String, NodeType>) nodeTypes;
 135                 gsst.appendNodes(nodeTypeMap);
 136             }
 137         } catch (YAMLException ye) {
 138             throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 139                 .withMessage("Invalid YAML content in file " + key)
 140                 .withCategory(ErrorCategory.APPLICATION).build(), ye);
 141         }
 142     }
 143
 144     private String getConcreteArtifactFileName(String fileName){
 145         int artifactIndex = fileName.indexOf(CsarFileTypes.Artifacts.name());
 146         if(artifactIndex < 0){
 147             return fileName;
 148         }
 149
 150         int artifactDirectoryIndex =
 151             artifactIndex + CsarFileTypes.Artifacts.name().length() + 1;
 152         return fileName.substring(artifactDirectoryIndex);
 153     }
 154
 155     private void updateToscaServiceModel(ToscaServiceModel toscaServiceModel,
 156                                          Map<String, ServiceTemplate> serviceTemplates,
 157                                          FileContentHandler externalFilesHandler,
 158                                          GlobalSubstitutionServiceTemplate globalSubstitutionServiceTemplate,
 159                                          Map<String, byte[]> csarFiles) {
 160         Collection<ServiceTemplate> globalServiceTemplates =
 161             GlobalTypesGenerator.getGlobalTypesServiceTemplate(OnboardingTypesEnum.CSAR).values();
 162         addGlobalServiceTemplates(globalServiceTemplates, serviceTemplates);
 163         toscaServiceModel.setEntryDefinitionServiceTemplate(mainStName);
 164         toscaServiceModel.setServiceTemplates(serviceTemplates);
 165         externalFilesHandler.addFile(metadataFile + ".original",
 166             csarFiles.get(metadataFile + ".original"));
 167         toscaServiceModel.setArtifactFiles(externalFilesHandler);
 168
 169         if(MapUtils.isNotEmpty(globalSubstitutionServiceTemplate.getNode_types())) {
 170             serviceTemplates
 171                 .put(GLOBAL_SUBSTITUTION_SERVICE_FILE_NAME, globalSubstitutionServiceTemplate);
 172         }
 173     }
 174
 175     private void addGlobalServiceTemplates(Collection<ServiceTemplate> globalServiceTemplates,
 176                                            Map<String, ServiceTemplate> serviceTemplates) {
 177         for (ServiceTemplate serviceTemplate : globalServiceTemplates) {
 178             serviceTemplates.put(ToscaUtil.getServiceTemplateFileName(serviceTemplate), serviceTemplate);
 179         }
 180     }
 181
 182     private void handleServiceTemplate(String serviceTemplateName,
 183                                        String fileName, Map<String, byte[]> csarFiles,
 184                                        Map<String, ServiceTemplate> serviceTemplates) {
 185         Optional<ServiceTemplate> serviceTemplate =
 186             getServiceTemplateFromCsar(fileName, csarFiles);
 187         serviceTemplate.ifPresent(
 188             serviceTemplateValue -> addServiceTemplate(serviceTemplateName, serviceTemplateValue,
 189                 serviceTemplates));
 190     }
 191
 192     private void addServiceTemplate(String serviceTemplateName,
 193                                     ServiceTemplate serviceTemplate,
 194                                     Map<String, ServiceTemplate> serviceTemplates) {
 195         serviceTemplates.put(serviceTemplateName, serviceTemplate);
 196     }
 197
 198     private Optional<byte[]> getManifestContent(Map<String, byte[]> csarFiles) {
 199         for (Map.Entry<String, byte[]> csarFileEntry : csarFiles.entrySet()) {
 200             if (csarFileEntry.getKey().contains(manifestFileName)) {
 201                 return Optional.of(csarFileEntry.getValue());
 202             }
 203         }
 204
 205         return Optional.empty();
 206     }
 207
 208     private Optional<ServiceTemplate> getServiceTemplateFromCsar(String fileName,
 209                                                                  Map<String, byte[]> csarFiles) {
 210         byte[] fileContent = csarFiles.get(fileName);
 211         ServiceTemplate serviceTemplate = convertServiceTemplate(fileName, fileContent);
 212
 213         return Optional.of(serviceTemplate);
 214     }
 215
 216     private ServiceTemplate convertServiceTemplate(String serviceTemplateName,
 217                                                    byte[] fileContent) {
 218         ServiceTemplate serviceTemplate = new ServiceTemplate();
 219         try {
 220             ServiceTemplateReaderService readerService =
 221                 new ServiceTemplateReaderServiceImpl(fileContent);
 222             convertMetadata(serviceTemplateName, serviceTemplate, readerService);
 223             convertToscaVersion(serviceTemplate, readerService);
 224             convertImports(serviceTemplate);
 225             convertNodeTypes(serviceTemplate, readerService);
 226             convertTopologyTemplate(serviceTemplate, readerService);
 227
 228         } catch (YAMLException ye) {
 229             throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 230                 .withMessage("Invalid YAML content in file" + serviceTemplateName)
 231                 .withCategory(ErrorCategory.APPLICATION).build(), ye);
 232         }
 233
 234
 235         return serviceTemplate;
 236     }
 237
 238     private void convertToscaVersion(ServiceTemplate serviceTemplate,
 239                                      ServiceTemplateReaderService readerService) {
 240         Object toscaVersion = readerService.getToscaVersion();
 241         serviceTemplate.setTosca_definitions_version((String) toscaVersion);
 242     }
 243
 244     private void convertImports(ServiceTemplate serviceTemplate) {
 245         serviceTemplate.setImports(new ArrayList<>());
 246         serviceTemplate.getImports()
 247             .add(createImportMap(openecompHeatIndex, HEAT_INDEX_IMPORT_FILE));
 248         serviceTemplate.getImports().add(createImportMap(ONAP_INDEX, ONAP_INDEX_IMPORT_FILE));
 249         serviceTemplate.getImports().add(createImportMap(globalSubstitution, globalStName));
 250
 251     }
 252
 253     private Map<String, Import> createImportMap(String key, String fileName) {
 254         Map<String, Import> importMap = new HashMap<>();
 255         Import anImport = new Import();
 256         anImport.setFile(fileName);
 257         importMap.put(key, anImport);
 258
 259         return importMap;
 260     }
 261
 262     private void convertMetadata(String serviceTemplateName,
 263                                  ServiceTemplate serviceTemplate,
 264                                  ServiceTemplateReaderService readerService) {
 265         Map<String, Object> metadataToConvert = (Map<String, Object>) readerService.getMetadata();
 266         Map<String, String> finalMetadata = new HashMap<>();
 267
 268         if (MapUtils.isNotEmpty(metadataToConvert)) {
 269             for (Map.Entry<String, Object> metadataEntry : metadataToConvert.entrySet()) {
 270                 if (Objects.isNull(metadataEntry.getValue()) ||
 271                     !(metadataEntry.getValue() instanceof String)) {
 272                     continue;
 273                 }
 274                 finalMetadata.put(metadataEntry.getKey(), (String) metadataEntry.getValue());
 275             }
 276         }
 277
 278         finalMetadata.put("template_name", getTemplateNameFromStName(serviceTemplateName));
 279         serviceTemplate.setMetadata(finalMetadata);
 280     }
 281
 282     private void convertNodeTypes(ServiceTemplate serviceTemplate, ServiceTemplateReaderService readerService) {
 283         Map<String, Object> nodeTypes = (Map<String, Object>) readerService.getNodeTypes();
 284         if (MapUtils.isEmpty(nodeTypes)) {
 285             return;
 286         }
 287
 288         for (Map.Entry<String, Object> nodeTypeEntry : nodeTypes.entrySet()) {
 289             Optional<NodeType> nodeType = ToscaConverterUtil
 290                 .createObjectFromClass(nodeTypeEntry.getKey(), nodeTypeEntry.getValue(),
 291                     NodeType.class);
 292
 293             nodeType.ifPresent(nodeTypeValue -> DataModelUtil
 294                 .addNodeType(serviceTemplate, nodeTypeEntry.getKey(), nodeTypeValue));
 295         }
 296     }
 297
 298     private void convertTopologyTemplate(ServiceTemplate serviceTemplate,
 299                                          ServiceTemplateReaderService readerService) {
 300
 301         convertInputs(serviceTemplate, readerService);
 302         convertNodeTemplates(serviceTemplate, readerService);
 303         convertOutputs(serviceTemplate, readerService);
 304         convertSubstitutionMappings(serviceTemplate, readerService);
 305     }
 306
 307     private void convertInputs(ServiceTemplate serviceTemplate,
 308                                ServiceTemplateReaderService readerService) {
 309         Map<String, Object> inputs = readerService.getInputs();
 310         addInputsOrOutputsToServiceTemplate(serviceTemplate, inputs, Constants.inputs);
 311     }
 312
 313     private void convertOutputs(ServiceTemplate serviceTemplate,
 314                                 ServiceTemplateReaderService readerService) {
 315         Map<String, Object> outputs = readerService.getOutputs();
 316         addInputsOrOutputsToServiceTemplate(serviceTemplate, outputs, Constants.outputs);
 317     }
 318
 319     private void addInputsOrOutputsToServiceTemplate(ServiceTemplate serviceTemplate,
 320                                                      Map<String, Object> mapToConvert,
 321                                                      String inputsOrOutputs) {
 322         if (MapUtils.isEmpty(mapToConvert)) {
 323             return;
 324         }
 325
 326         for (Map.Entry<String, Object> entry : mapToConvert.entrySet()) {
 327             Optional<ParameterDefinition> parameterDefinition =
 328                 ToscaConverterUtil.createObjectFromClass(
 329                     entry.getKey(), entry.getValue(), ParameterDefinition.class);
 330
 331             parameterDefinition.ifPresent(parameterDefinitionValue -> {
 332                 Optional<Object> defaultValue =
 333                     ToscaConverterUtil.getDefaultValue(entry.getValue(), parameterDefinition.get());
 334                 defaultValue.ifPresent(parameterDefinitionValue::set_default);
 335                 addToServiceTemplateAccordingToSection(
 336                     serviceTemplate, inputsOrOutputs, entry.getKey(), parameterDefinition.get());
 337             } );
 338         }
 339     }
 340
 341     private void addToServiceTemplateAccordingToSection(ServiceTemplate serviceTemplate,
 342                                                         String inputsOrOutputs,
 343                                                         String parameterId,
 344                                                         ParameterDefinition parameterDefinition) {
 345         switch (inputsOrOutputs) {
 346             case inputs:
 347                 DataModelUtil
 348                     .addInputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
 349                 break;
 350             case outputs:
 351                 DataModelUtil
 352                     .addOutputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
 353         }
 354     }
 355
 356     private void convertNodeTemplates(ServiceTemplate serviceTemplate,
 357                                       ServiceTemplateReaderService readerService) {
 358         Map<String, Object> nodeTemplates = readerService.getNodeTemplates();
 359         if (MapUtils.isEmpty(nodeTemplates)) {
 360             return;
 361         }
 362
 363         for (Map.Entry<String, Object> nodeTemplateEntry : nodeTemplates.entrySet()) {
 364             NodeTemplate nodeTemplate = convertNodeTemplate(nodeTemplateEntry.getValue());
 365             DataModelUtil.addNodeTemplate(serviceTemplate, nodeTemplateEntry.getKey(), nodeTemplate);
 366         }
 367     }
 368
 369     private void convertSubstitutionMappings(ServiceTemplate serviceTemplate,
 370                                              ServiceTemplateReaderService readerService) {
 371         Map<String, Object> substitutionMappings = readerService.getSubstitutionMappings();
 372         if (MapUtils.isEmpty(substitutionMappings)) {
 373             return;
 374         }
 375         SubstitutionMapping substitutionMapping = convertSubstitutionMappings(substitutionMappings);
 376         DataModelUtil.addSubstitutionMapping(serviceTemplate, substitutionMapping);
 377     }
 378
 379     private SubstitutionMapping convertSubstitutionMappings(Map<String, Object> substitutionMappings) {
 380         SubstitutionMapping substitutionMapping = new SubstitutionMapping();
 381
 382         substitutionMapping.setNode_type((String) substitutionMappings.get(nodeType));
 383         substitutionMapping.setCapabilities(
 384             convertSubstitutionMappingsSections(capabilities, substitutionMappings.get(capabilities)));
 385         substitutionMapping.setRequirements(
 386             convertSubstitutionMappingsSections(requirements, substitutionMappings.get(requirements)));
 387
 388         return substitutionMapping;
 389     }
 390
 391     private Map<String, List<String>> convertSubstitutionMappingsSections(String sectionName,
 392                                                                           Object sectionToConvert) {
 393
 394         if(Objects.isNull(sectionToConvert)){
 395             return null;
 396         }
 397
 398         if(!(sectionToConvert instanceof Map)) {
 399             throw new CoreException(
 400                 new SubstitutionMappingsConverterErrorBuilder(
 401                     sectionName, sectionToConvert.getClass().getSimpleName()).build());
 402         }
 403
 404         return convertSection(sectionToConvert);
 405     }
 406
 407     private Map<String, List<String>> convertSection(Object sectionToConvert) {
 408
 409         Map<String, Object> sectionAsMap = (Map<String, Object>)sectionToConvert;
 410         Map<String, List<String>> convertedSection = new HashMap<>();
 411
 412         if (MapUtils.isEmpty(sectionAsMap)) {
 413             return null;
 414         }
 415
 416         for (Map.Entry<String, Object> entry : sectionAsMap.entrySet()) {
 417             if (entry.getValue() instanceof List) {
 418                 convertedSection.put(entry.getKey(), (List<String>) entry.getValue());
 419             }
 420         }
 421
 422         return convertedSection;
 423     }
 424
 425     private CsarFileTypes getFileType(String fileName) {
 426         if (isMainServiceTemplate(fileName)) {
 427             return CsarFileTypes.mainServiceTemplate;
 428         } else if (isGlobalServiceTemplate(fileName)) {
 429             return CsarFileTypes.globalServiceTemplate;
 430         } else if (isDefinitions(fileName)) {
 431             return CsarFileTypes.definitionsFile;
 432         } else if (isMetadataFile(fileName)) {
 433             return CsarFileTypes.toscaMetadata;
 434         }
 435         return CsarFileTypes.externalFile;
 436     }
 437
 438     private Optional<Manifest> getCsarManifest(Map<String, byte[]> csarFiles) throws IOException {
 439         Optional<byte[]> manifestContent = getManifestContent(csarFiles);
 440
 441         if (manifestContent.isPresent()) {
 442             ByteArrayInputStream byteInputStream = new ByteArrayInputStream(manifestContent.get());
 443
 444             return Optional.of(new Manifest(byteInputStream));
 445         }
 446
 447         return Optional.empty();
 448     }
 449
 450     private NodeTemplate convertNodeTemplate(Object candidateNodeTemplate) {
 451         NodeTemplate nodeTemplate = new NodeTemplate();
 452
 453         Map<String, Object> nodeTemplateAsMap = (Map<String, Object>) candidateNodeTemplate;
 454         nodeTemplate.setArtifacts((Map<String, ArtifactDefinition>) nodeTemplateAsMap.get("artifacts"));
 455         nodeTemplate.setAttributes((Map<String, Object>) nodeTemplateAsMap.get("attributes"));
 456         nodeTemplate.setCopy((String) nodeTemplateAsMap.get("copy"));
 457         nodeTemplate.setDescription((String) nodeTemplateAsMap.get("description"));
 458         nodeTemplate.setDirectives((List<String>) nodeTemplateAsMap.get("directives"));
 459         nodeTemplate.setInterfaces(
 460             (Map<String, InterfaceDefinition>) nodeTemplateAsMap.get("interfaces"));
 461         nodeTemplate.setNode_filter((NodeFilter) nodeTemplateAsMap.get("node_filter"));
 462         nodeTemplate.setProperties((Map<String, Object>) nodeTemplateAsMap.get("properties"));
 463         nodeTemplate.setRequirements(
 464             (List<Map<String, RequirementAssignment>>) nodeTemplateAsMap.get("requirements"));
 465         nodeTemplate.setType((String) nodeTemplateAsMap.get("type"));
 466         nodeTemplate.setCapabilities(
 467             convertCapabilities((Map<String, Object>) nodeTemplateAsMap.get("capabilities")));
 468
 469         return nodeTemplate;
 470     }
 471
 472     private List<Map<String, CapabilityAssignment>> convertCapabilities(Map<String, Object> capabilities) {
 473         List<Map<String, CapabilityAssignment>> convertedCapabilities = new ArrayList<>();
 474         if (MapUtils.isEmpty(capabilities)) {
 475             return null;
 476         }
 477         for (Map.Entry<String, Object> capabilityAssignmentEntry : capabilities.entrySet()) {
 478             Map<String, CapabilityAssignment> tempMap = new HashMap<>();
 479             Optional<CapabilityAssignment> capabilityAssignment = ToscaConverterUtil.createObjectFromClass
 480                 (capabilityAssignmentEntry.getKey(), capabilityAssignmentEntry.getValue(),
 481                     CapabilityAssignment.class);
 482
 483             capabilityAssignment.ifPresent(capabilityAssignmentValue -> {
 484                 tempMap.put(capabilityAssignmentEntry.getKey(), capabilityAssignmentValue);
 485                 convertedCapabilities.add(tempMap);
 486                 }
 487             );
 488
 489         }
 490         return convertedCapabilities;
 491     }
 492
 493
 494     private boolean isMainServiceTemplate(String fileName) {
 495         return fileName.endsWith(mainStName);
 496     }
 497
 498     private boolean isMetadataFile(String fileName) {
 499         return fileName.equals(metadataFile);
 500     }
 501
 502     private boolean isGlobalServiceTemplate(String fileName) {
 503         return fileName.endsWith(globalStName);
 504     }
 505
 506     private boolean isDefinitions(String fileName) {
 507         return fileName.startsWith(definitionsDir);
 508     }
 509
 510     private String getTemplateNameFromStName(String serviceTemplateName) {
 511         String fileNameWithoutDirectories;
 512         fileNameWithoutDirectories = getFileNameWithoutDirectories(serviceTemplateName);
 513         return fileNameWithoutDirectories.split("ServiceTemplate")[0];
 514     }
 515
 516     private String getFileNameWithoutDirectories(String serviceTemplateName) {
 517         String fileNameWithoutDirectories;
 518         if (serviceTemplateName.contains("/")) {
 519             String[] split = serviceTemplateName.split("/");
 520             fileNameWithoutDirectories = split[split.length - 1];
 521         } else if (serviceTemplateName.contains(File.separator)) {
 522             String[] split = serviceTemplateName.split(Pattern.quote(File.separator));
 523             fileNameWithoutDirectories = split[split.length - 1];
 524         } else {
 525             fileNameWithoutDirectories = serviceTemplateName;
 526         }
 527         return fileNameWithoutDirectories;
 528     }
 529 }