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