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