openecomp-be/lib/openecomp-sdc-vendor-software-product-lib/openecomp-sdc-vendor-software-product-core/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/filedatastructuremodule/ManifestCreatorNamingConventionImpl.java

   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.sdc.vendorsoftwareproduct.services.impl.filedatastructuremodule;
  18
  19 import org.apache.commons.collections4.CollectionUtils;
  20 import org.openecomp.core.utilities.file.FileContentHandler;
  21 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
  22 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
  23 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  24 import org.openecomp.sdc.vendorsoftwareproduct.services.HeatFileAnalyzer;
  25 import org.openecomp.sdc.vendorsoftwareproduct.services.filedatastructuremodule.ManifestCreator;
  26 import org.openecomp.sdc.vendorsoftwareproduct.types.candidateheat.AnalyzedZipHeatFiles;
  27 import org.openecomp.sdc.vendorsoftwareproduct.types.candidateheat.Constants;
  28 import org.openecomp.sdc.vendorsoftwareproduct.types.candidateheat.FilesDataStructure;
  29 import org.openecomp.sdc.vendorsoftwareproduct.types.candidateheat.Module;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32
  33 import java.util.*;
  34 import java.util.regex.Pattern;
  35
  36 public class ManifestCreatorNamingConventionImpl implements ManifestCreator {
  37   protected static final Logger logger =
  38       LoggerFactory.getLogger(ManifestCreatorNamingConventionImpl.class);
  39   @Override
  40   public Optional<ManifestContent> createManifest(
  41       VspDetails vspDetails, FilesDataStructure filesDataStructure) {
  42     if (Objects.isNull(filesDataStructure)) {
  43       return Optional.empty();
  44     }
  45
  46     List<FileData> fileDataList = new ArrayList<>();
  47     addModulesToManifestFileDataList(filesDataStructure, fileDataList);
  48     addNestedToManifest(filesDataStructure, fileDataList);
  49     addArtifactsToManifestFileDataList(filesDataStructure, fileDataList);
  50     ManifestContent manifestContent = createManifest(vspDetails, fileDataList);
  51     return Optional.of(manifestContent);
  52   }
  53
  54   private void addNestedToManifest(
  55       FilesDataStructure filesDataStructure, List<FileData> fileDataList) {
  56     if (CollectionUtils.isNotEmpty(filesDataStructure.getNested())) {
  57       for (String nested : filesDataStructure.getNested()) {
  58         fileDataList.add(createBaseFileData(FileData.Type.HEAT, nested));
  59       }
  60     }
  61   }
  62
  63   @Override
  64   public Optional<ManifestContent> createManifest(VspDetails vspDetails,
  65                                                   FileContentHandler fileContentHandler,
  66                                                   AnalyzedZipHeatFiles analyzedZipHeatFiles) {
  67     logger.info("Trying to generate manifest");
  68     if (Objects.isNull(fileContentHandler)
  69         || CollectionUtils.isEmpty(fileContentHandler.getFileList())) {
  70       logger.info("fileContentHandler or filesList is empty. ManifestContent will not be created");
  71       return Optional.empty();
  72     }
  73
  74     Map<String, byte[]> files = fileContentHandler.getFiles();
  75
  76     List<FileData> fileDataList =
  77         createFileDataListFromZipFiles(fileContentHandler, files,
  78             analyzedZipHeatFiles.getFilesNotEligbleForModules());
  79     ManifestContent manifestContent = createManifest(vspDetails, fileDataList);
  80
  81     return Optional.of(manifestContent);
  82   }
  83
  84   private ManifestContent createManifest(VspDetails vspDetails, List<FileData> fileDataList) {
  85     ManifestContent manifestContent = new ManifestContent();
  86     manifestContent.setName(vspDetails.getName());
  87     manifestContent.setDescription(vspDetails.getDescription());
  88     manifestContent
  89         .setVersion(vspDetails.getVersion() == null ? null : vspDetails.getVersion().toString());
  90     // vsp version, need to check in confluence
  91     manifestContent.setData(fileDataList);
  92     return manifestContent;
  93   }
  94
  95   private List<FileData> createFileDataListFromZipFiles(FileContentHandler fileContentHandler,
  96                                                         Map<String, byte[]> files,
  97                                                         Collection<String> filesNotEligibleForModules) {
  98
  99     Set<String> processedFiles = new HashSet<>();
 100     List<FileData> fileDataList = new ArrayList<>();
 101     for (String fileName : files.keySet()) {
 102       if (processedFiles.contains(fileName)) {
 103         continue;
 104       }
 105       if (isFileBaseFile(fileName)) {
 106         fileDataList
 107             .add(createModuleFileData(
 108                 fileName, true, processedFiles, fileContentHandler.getFileList(), fileDataList));
 109       } else if (isFileModuleFile(fileName, filesNotEligibleForModules)) {
 110         fileDataList
 111             .add(createModuleFileData(
 112                 fileName, false, processedFiles, fileContentHandler.getFileList(), fileDataList));
 113       } else {
 114         if (HeatFileAnalyzer.isYamlFile(fileName)) {
 115           fileDataList.add(createBasicFileData(fileName, FileData.Type.HEAT, null));
 116         } else if (HeatFileAnalyzer.isEnvFile(fileName)) {
 117           fileDataList.add(createBasicFileData(fileName, FileData.Type.HEAT_ENV, null));
 118         } else {
 119           fileDataList.add(createBasicFileData(fileName, FileData.Type.OTHER, null));
 120         }
 121       }
 122     }
 123     return fileDataList;
 124   }
 125
 126   private boolean isFileModuleFile(String fileName, Collection<String> filesCannotBeModule) {
 127     return !filesCannotBeModule.contains(fileName);
 128   }
 129
 130   @Override
 131   public boolean isFileBaseFile(String fileName) {
 132     return Pattern.matches(Constants.BASE_HEAT_REGEX, fileName) && !isVolFile(fileName);
 133   }
 134
 135
 136   private void addArtifactsToManifestFileDataList(
 137       FilesDataStructure filesDataStructure, List<FileData> fileDataList) {
 138     Collection<String> forArtifacts = CollectionUtils
 139         .union(filesDataStructure.getArtifacts(), filesDataStructure.getUnassigned());
 140     if (CollectionUtils.isNotEmpty(forArtifacts)) {
 141       for (String artifact : forArtifacts) {
 142         fileDataList.add(createBaseFileData(FileData.Type.OTHER, artifact));
 143       }
 144     }
 145   }
 146
 147   private void addModulesToManifestFileDataList(
 148       FilesDataStructure filesDataStructure, List<FileData> fileDataList) {
 149     if (CollectionUtils.isNotEmpty(filesDataStructure.getModules())) {
 150       for (Module module : filesDataStructure.getModules()) {
 151         FileData fileData = createBaseFileData(FileData.Type.HEAT, module.getYaml());
 152         fileData.setBase(module.getIsBase());
 153         addEnv(module, fileData);
 154         addVolume(module, fileData);
 155         fileDataList.add(fileData);
 156       }
 157     }
 158   }
 159
 160   private void addEnv(Module module, FileData fileData) {
 161     if (Objects.nonNull(module.getEnv())) {
 162       FileData env = createBaseFileData(FileData.Type.HEAT_ENV, module.getEnv());
 163       fileData.addFileData(env);
 164     }
 165   }
 166
 167   private void addVolume(Module module, FileData fileData) {
 168     String volModule = module.getVol();
 169     if (Objects.nonNull(volModule)) {
 170       FileData vol = createBaseFileData(FileData.Type.HEAT_VOL, volModule);
 171       if (Objects.nonNull(module.getVolEnv())) {
 172         vol.addFileData(createBaseFileData(FileData.Type.HEAT_ENV, module.getVolEnv()));
 173       }
 174       fileData.addFileData(vol);
 175     }
 176   }
 177
 178   private FileData createBaseFileData(FileData.Type heat, String yaml) {
 179     FileData fileData = new FileData();
 180     fileData.setType(heat);
 181     fileData.setFile(yaml);
 182     return fileData;
 183   }
 184
 185   private FileData createModuleFileData(
 186       String moduleFileName, boolean isBase, Set<String> processedFiles,
 187       Set<String> fileNames, List<FileData> fileDataList) {
 188     FileData moduleFileData = createBasicFileData(moduleFileName, FileData.Type.HEAT, isBase);
 189     Optional<String> volFile = fetchRelatedVolume(moduleFileName, fileNames);
 190     volFile.ifPresent(vol -> {
 191       markFileAsProcessed(vol, processedFiles);
 192       removeFromFileDataListIfAlreadyProcessed(fileDataList, vol);
 193       FileData volFileData = createBasicFileData(vol, FileData.Type.HEAT_VOL, null);
 194       Optional<String> envFile = fetchRelatedEnv(vol, fileNames);
 195       envFile.ifPresent(env -> {
 196         markFileAsProcessed(env, processedFiles);
 197         removeFromFileDataListIfAlreadyProcessed(fileDataList, env);
 198         FileData envFileData = createBasicFileData(env, FileData.Type.HEAT_ENV, null);
 199         volFileData.addFileData(envFileData);
 200       });
 201       moduleFileData.addFileData(volFileData);
 202     });
 203     Optional<String> envFile = fetchRelatedEnv(moduleFileName, fileNames);
 204     envFile.ifPresent(env -> {
 205       markFileAsProcessed(env, processedFiles);
 206       FileData envFileData = createBasicFileData(env, FileData.Type.HEAT_ENV, null);
 207       moduleFileData.addFileData(envFileData);
 208     });
 209     return moduleFileData;
 210   }
 211
 212   private void removeFromFileDataListIfAlreadyProcessed(List<FileData> fileDataList, String vol) {
 213     fileDataList.removeIf(fileData -> fileData.getFile().equals(vol));
 214   }
 215
 216   private FileData createBasicFileData(String fileName, FileData.Type type, Boolean isBase) {
 217     FileData fileData = new FileData();
 218     if (isBase != null) {
 219       fileData.setBase(isBase);
 220     }
 221     fileData.setType(type);
 222     fileData.setFile(fileName);
 223     return fileData;
 224   }
 225
 226   private Optional<String> fetchRelatedEnv(String fileName, Set<String> fileNames) {
 227     String envFileName
 228         = fileName.substring(0, fileName.lastIndexOf(".")) + Constants.ENV_FILE_EXTENSION;
 229     return fileNames.contains(envFileName) ? Optional.of(envFileName) : Optional.empty();
 230   }
 231
 232   private Optional<String> fetchRelatedVolume(String fileName, Set<String> fileNames) {
 233
 234     String volFile1stExt =
 235         extractVolFileName(fileName, ".yaml");
 236     String volFile2ndExt =
 237         extractVolFileName(fileName, ".yml");
 238
 239     if (fileNames.contains(volFile1stExt)) {
 240       return Optional.of(volFile1stExt);
 241     }
 242     if (fileNames.contains(volFile2ndExt)) {
 243       return Optional.of(volFile2ndExt);
 244     }
 245     return Optional.empty();
 246   }
 247
 248   private String extractVolFileName(String fileName, String fileExt) {
 249     return fileName.substring(
 250         0, fileName.lastIndexOf("."))
 251         + Constants.VOL_FILE_NAME_SUFFIX + fileExt;
 252   }
 253
 254
 255   private boolean isVolFile(String fileName) {
 256     return fileName
 257         .endsWith(
 258             Constants.VOL_FILE_NAME_SUFFIX + ".yaml")
 259         || fileName.endsWith(Constants.VOL_FILE_NAME_SUFFIX + ".yml");
 260   }
 261
 262
 263   private void markFileAsProcessed(String fileName, Set<String> processedFiles) {
 264     processedFiles.add(fileName);
 265   }
 266 }