ui-ci/src/main/java/org/openecomp/sdc/ci/tests/businesslogic/ArtifactBusinessLogic.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.businesslogic;
  22
  23 import com.clearspring.analytics.util.Pair;
  24 import com.google.gson.Gson;
  25 import org.openecomp.sdc.be.datatypes.elements.HeatParameterDataDefinition;
  26 import org.openecomp.sdc.be.model.ArtifactDefinition;
  27 import org.openecomp.sdc.ci.tests.datatypes.HeatAndHeatEnvNamesPair;
  28 import org.openecomp.sdc.ci.tests.datatypes.HeatMetaFirstLevelDefinition;
  29 import org.openecomp.sdc.ci.tests.datatypes.HeatWithParametersDefinition;
  30 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  31 import org.openecomp.sdc.ci.tests.execute.devCI.ArtifactFromCsar;
  32 import org.openecomp.sdc.ci.tests.pages.HomePage;
  33 import org.openecomp.sdc.ci.tests.utilities.FileHandling;
  34
  35 import java.io.File;
  36 import java.io.IOException;
  37 import java.util.*;
  38 import java.util.Map.Entry;
  39
  40 import static org.junit.Assert.assertTrue;
  41
  42 public class ArtifactBusinessLogic {
  43
  44         private final static String[] okFileExtensions = new String[] {"yaml", "yml", "env"};
  45         private static final String PARAMETERS = "parameters";
  46         private static final String DEPLOYMENT = "Deployment";
  47
  48         public static synchronized Map<String, File> createEnvFilesListFromCsar(String vspName, String filePath) throws Exception{
  49                 Map<String, File> generatedEnvFiles = new HashMap<>();
  50                 File csarFile= HomePage.downloadVspCsarToDefaultDirectory(vspName);
  51                 FileHandling.unzip(csarFile.toString(), filePath);
  52                 List<File> yamlList = getHeatFilesCreatedFromCsar(csarFile, filePath);
  53                 Map<String, HeatAndHeatEnvNamesPair> filesPairMap = getFilesPairMap(yamlList);
  54                 generatedEnvFiles = generateDefaultEnvFiles(filesPairMap, filePath);
  55                 return generatedEnvFiles;
  56         }
  57
  58         public static synchronized List<File> getHeatFilesCreatedFromCsar(File pathToDirectory, String filePath) throws Exception {
  59                 List<File> fileList = new ArrayList<>();
  60                 String artifactsFilePath = filePath + "Artifacts" + File.separator;
  61                 List<File> fileListFromArtifactsDirectory = FileHandling.getHeatAndHeatEnvArtifactsFromZip(new File(artifactsFilePath), okFileExtensions);
  62                 Map<String, Object> combinedMap = ArtifactFromCsar.combineHeatArtifacstWithFolderArtifacsToMap(pathToDirectory.toString());
  63                 LinkedList<HeatMetaFirstLevelDefinition> deploymentArtifacts = (LinkedList<HeatMetaFirstLevelDefinition>) combinedMap.get(DEPLOYMENT);
  64                 for(HeatMetaFirstLevelDefinition deploymentArtifact : deploymentArtifacts){
  65                         String type = deploymentArtifact.getType();
  66                         if(type.equals(ArtifactTypeEnum.HEAT.getType()) ||
  67                            type.equals(ArtifactTypeEnum.HEAT_ENV.getType()) ||
  68                            type.equals(ArtifactTypeEnum.HEAT_VOL.getType()) ||
  69                            type.equals(ArtifactTypeEnum.HEAT_NET.getType())){
  70                                 File file = new File(artifactsFilePath + deploymentArtifact.getFileName());
  71                                 if(fileListFromArtifactsDirectory.contains(file)){
  72                                         fileList.add(file);
  73                                 }else{
  74                                         assertTrue("File " + file + " does not exist", false);
  75                                 }
  76                         }
  77                 }
  78                 return fileList;
  79         }
  80         public static synchronized Map<String, HeatAndHeatEnvNamesPair> getFilesPairMap(List<File> generatedEnvFiles) {
  81
  82                 Map<String, HeatAndHeatEnvNamesPair> heatAndHeatEnvPairs= new HashMap<>();
  83                 for(File file : generatedEnvFiles){
  84                         String[] fileName = file.getName().split("\\.");
  85                         String currentKey = fileName[0];
  86                         String currentExtension = fileName[1];
  87                         HeatAndHeatEnvNamesPair pair;
  88                         if(!heatAndHeatEnvPairs.containsKey(currentKey)){
  89                                 pair = new HeatAndHeatEnvNamesPair();
  90                                 heatAndHeatEnvPairs.put(currentKey, pair);
  91                         }else{
  92                                 pair = heatAndHeatEnvPairs.get(currentKey);
  93                         }
  94                         setFileToPair(file, currentExtension, pair);
  95                 }
  96                 return heatAndHeatEnvPairs;
  97         }
  98
  99         /**
 100          * The method fill list of HeatWithParametersDefinition parameters
 101          * @param deploymentArtifacts
 102          * @return
 103          */
 104         public static synchronized List<HeatWithParametersDefinition> extractHeatWithParametersDefinition(Map<String, ArtifactDefinition> deploymentArtifacts) {
 105
 106                 List<HeatWithParametersDefinition> heatAndEnvLabelList = new ArrayList<>();
 107
 108                 for (Entry<String, ArtifactDefinition> artifactDefinitionChild : deploymentArtifacts.entrySet()){
 109                         if(artifactDefinitionChild.getValue().getArtifactType().equals(ArtifactTypeEnum.HEAT_ENV.getType())){
 110                                 for(Entry<String, ArtifactDefinition> artifactDefinitionParent : deploymentArtifacts.entrySet()){
 111                                         if(artifactDefinitionChild.getValue().getGeneratedFromId().equals(artifactDefinitionParent.getValue().getUniqueId())){
 112                                                 String heatLabel = artifactDefinitionParent.getValue().getArtifactLabel();
 113                                                 String heatArtifactType = artifactDefinitionParent.getValue().getArtifactType();
 114                                                 String heatArtifactDisplayName = artifactDefinitionParent.getValue().getArtifactDisplayName();
 115                                                 List<HeatParameterDataDefinition> heatParameterDefinition = artifactDefinitionParent.getValue().getHeatParameters();
 116                                                 String heatEnvLabel = artifactDefinitionChild.getValue().getArtifactLabel();
 117                                                 String heatEnvArtifactType = artifactDefinitionChild.getValue().getArtifactType();
 118                                                 heatAndEnvLabelList.add(new HeatWithParametersDefinition(heatLabel, heatEnvLabel, heatArtifactType, heatEnvArtifactType, heatArtifactDisplayName, heatParameterDefinition));
 119                                                 break;
 120                                         }
 121                                 }
 122                         }
 123                 }
 124                 return heatAndEnvLabelList;
 125         }
 126
 127
 128         public static synchronized void setFileToPair(File file, String currentExtension, HeatAndHeatEnvNamesPair pair) {
 129                 if(!currentExtension.equals("env")){
 130                         pair.setHeatFileName(file);
 131                 }else{
 132                         pair.setHeatEnvFileName(file);
 133                 }
 134         }
 135
 136         public static synchronized Map<String, File> generateDefaultEnvFiles(Map<String, HeatAndHeatEnvNamesPair> filesPairMap, String filePath) throws Exception {
 137
 138                 Map<String, File> generatedEnvFilesMap = new HashMap<>();
 139                 for(Entry<String, HeatAndHeatEnvNamesPair> pair : filesPairMap.entrySet()){
 140                         Map<String, Pair<String, Object>> envParametersMap = getEnvParametersMap(pair);
 141                         File generatedEnvFile = createEnvFile(envParametersMap, new File(filePath + pair.getKey() + ".env"));
 142                         generatedEnvFilesMap.put(pair.getKey(), generatedEnvFile);
 143                 }
 144                 return generatedEnvFilesMap;
 145         }
 146
 147         public static synchronized File createEnvFile(Map<String, Pair<String, Object>> envParametersMap, File fileToWrite) throws IOException {
 148
 149                 FileHandling.writeToFile(fileToWrite, PARAMETERS+":", 0);
 150                 FileHandling.writeToFile(fileToWrite, envParametersMap, 2);
 151                 return fileToWrite;
 152         }
 153
 154         public static synchronized Map<String, Pair<String, Object>> getEnvParametersMap(Entry<String, HeatAndHeatEnvNamesPair> pair) throws Exception {
 155                 File heatFileName = pair.getValue().getHeatFileName();
 156                 File heatEnvFileName = pair.getValue().getHeatEnvFileName();
 157                 Map<String, Pair<String, Object>> envParametersMap = new HashMap<>();
 158                 fillParametersMapFromHeatFile(heatFileName, envParametersMap);
 159                 fillParametersMapFromHeatEnvFile(heatEnvFileName, envParametersMap);
 160                 return envParametersMap;
 161         }
 162
 163         public static synchronized void fillParametersMapFromHeatEnvFile(File heatEnvFileName, Map<String, Pair<String, Object>> envParametersMap) throws Exception {
 164                 if(heatEnvFileName != null){
 165                         Map<String, Object> mapHeatEnvFileParameters = FileHandling.parseYamlFileToMapByPattern(heatEnvFileName, PARAMETERS);
 166                         for (Map.Entry<String, Object> parameter : mapHeatEnvFileParameters.entrySet()){
 167                                 String key = parameter.getKey();
 168                                 Pair<String, Object> pair;
 169                                 if(envParametersMap.containsKey(key)){
 170                                         if(envParametersMap.get(key).left.equals("string") && parameter.getValue() != null){
 171                                                 pair = Pair.create(envParametersMap.get(key).left, "\"" + parameter.getValue() + "\"");
 172                                         }else if(envParametersMap.get(key).left.equals("string") && parameter.getValue() == null){
 173                                                 pair = Pair.create(envParametersMap.get(key).left, "");
 174                                         }else if(parameter.getValue() == null) {
 175                                                 pair = Pair.create(envParametersMap.get(key).left, "");
 176                                         } else if(envParametersMap.get(key).left.equals("json") && parameter.getValue() != null){
 177                                                 String pairValue = "";
 178                                                 Gson gson = new Gson();
 179                                                 if(parameter.getValue() instanceof java.util.LinkedHashMap){
 180                                                         pairValue = gson.toJson(parameter.getValue());
 181                                                 }
 182                                                 pair = Pair.create(envParametersMap.get(key).left, pairValue );
 183
 184                                         }else if(envParametersMap.get(key).left.equals("json") && parameter.getValue() == null){
 185                                                 pair = Pair.create(envParametersMap.get(key).left, "");
 186                                         }else{
 187                                                 pair = Pair.create(envParametersMap.get(key).left, parameter.getValue());
 188                                         }
 189                                         envParametersMap.put(key, pair);
 190                                 }
 191                         }
 192                 }
 193         }
 194
 195         @SuppressWarnings("unchecked")
 196         public static synchronized void fillParametersMapFromHeatFile(File heatFileName, Map<String, Pair<String, Object>> envParametersMap) throws Exception {
 197                 Map<String, Object> mapHeatFileParameters = FileHandling.parseYamlFileToMapByPattern(heatFileName, PARAMETERS);
 198                 for (Map.Entry<String, Object> parameter : mapHeatFileParameters.entrySet()){
 199                         Map<String, Object> value = (Map<String, Object>) parameter.getValue();
 200                         Pair<String, Object> pair;
 201                         if(value.get("type").toString().equals("string") && value.get("default") != null ){
 202                                 pair = Pair.create(value.get("type").toString(), "\"" + value.get("default") + "\"");
 203                         }else if(value.get("type").toString().equals("string") && value.get("default") == null){
 204                                 pair = Pair.create(value.get("type").toString(), "");
 205                         }else if(value.get("default") == null){
 206                                 pair = Pair.create(value.get("type").toString(), "");
 207                         }else{
 208                                 pair = Pair.create(value.get("type").toString(), value.get("default"));
 209                         }
 210                         envParametersMap.put(parameter.getKey(), pair);
 211                 }
 212         }
 213
 214 }