test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/devCI/ArtifactFromCsar.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.execute.devCI;
  22
  23 import java.io.File;
  24 import java.io.FileInputStream;
  25 import java.io.FileOutputStream;
  26 import java.io.IOException;
  27 import java.nio.file.DirectoryStream;
  28 import java.nio.file.Files;
  29 import java.nio.file.Path;
  30 import java.nio.file.Paths;
  31 import java.text.SimpleDateFormat;
  32 import java.util.Arrays;
  33 import java.util.Collection;
  34 import java.util.Collections;
  35 import java.util.HashMap;
  36 import java.util.LinkedList;
  37 import java.util.List;
  38 import java.util.Map;
  39 import java.util.UUID;
  40 import java.util.stream.Collectors;
  41 import java.util.zip.ZipEntry;
  42 import java.util.zip.ZipInputStream;
  43
  44 import org.apache.commons.codec.digest.DigestUtils;
  45 import org.apache.commons.io.FileUtils;
  46 import org.apache.commons.io.IOUtils;
  47 import org.openecomp.sdc.ci.tests.datatypes.GroupHeatMetaDefinition;
  48 import org.openecomp.sdc.ci.tests.datatypes.HeatMetaFirstLevelDefinition;
  49 import org.openecomp.sdc.ci.tests.datatypes.TypeHeatMetaDefinition;
  50 import org.openecomp.sdc.ci.tests.utils.CsarParserUtils;
  51
  52 public class ArtifactFromCsar {
  53
  54
  55         public static void main(String[] args) throws Exception {
  56                 // TODO Auto-generated method stub
  57                 String zipFile = "C:\\Users\\rp955r\\Documents\\InTesting\\resource-CivfonboardedFdnt2f792348-csar.csar";
  58
  59 //              Map<String, Object> combinedMap = combineHeatArtifacstWithFolderArtifacsToMap(zipFile);
  60
  61                 Map<String, Object> vfcArtifacts = ArtifactFromCsar.getVFCArtifacts(zipFile);
  62
  63                 System.out.println("1234o");
  64         }
  65
  66         public static Map<String, Object> combineHeatArtifacstWithFolderArtifacsToMap(String pathToCsar) throws Exception {
  67                 return combineHeatArtifacstWithFolderArtifacsToMap(pathToCsar, "output");
  68         }
  69
  70         public static Map<String, Object> combineHeatArtifacstWithFolderArtifacsToMap(String pathToCsar, String outputCsar) throws Exception {
  71                 File csarFile = new File(pathToCsar);
  72
  73
  74                 File dir = new File(csarFile.getParent() + File.separator + outputCsar);
  75                         dir.mkdir();
  76                         if(!dir.exists()) {
  77                 }
  78
  79                 String outputFolder = dir.getPath();
  80                 unZip(pathToCsar, outputFolder);
  81                 File directory = new File(outputFolder + File.separator + "Artifacts" + File.separator );
  82
  83                 Map<String, Object> artifactsMap = combineHeatArtifacstWithFolderArtifacsToMap(getMapArtifactFromFolderStructure(directory), getDeploymentArtifactListFromHeatMeta(csarFile, directory));
  84                 FileUtils.cleanDirectory(new File(outputFolder));
  85
  86                 return artifactsMap;
  87         }
  88
  89         public static Map<String, Object> getVFCArtifacts(String pathToCsar) throws Exception{
  90                 String outputFolder = unzipCsarFile(pathToCsar);
  91                 File directory = new File(outputFolder + File.separator + "Artifacts" + File.separator );
  92                 Map<String, Object> artifactsMap = getMapArtifactFromFolderStructure(directory);
  93                 cleanFolders(outputFolder);
  94
  95                 return artifactsMap;
  96         }
  97
  98         private static Map<String, Object> combineHeatArtifacstWithFolderArtifacsToMap(Map<String, Object> map, List<HeatMetaFirstLevelDefinition> rlist) {
  99                 if(map.get("Deployment") != null) {
 100                         rlist.addAll((Collection<? extends HeatMetaFirstLevelDefinition>) map.get("Deployment"));
 101                 }
 102                 map.put("Deployment", rlist);
 103                 return map;
 104         }
 105
 106         private static List<HeatMetaFirstLevelDefinition> getDeploymentArtifactListFromHeatMeta(File pathToCsar, File directory) throws Exception {
 107                 List<HeatMetaFirstLevelDefinition> artifactList = new LinkedList<HeatMetaFirstLevelDefinition>();
 108
 109                 List<TypeHeatMetaDefinition> listTypeHeatMetaDefinition = CsarParserUtils.getListTypeHeatMetaDefinition(pathToCsar);
 110
 111             for(TypeHeatMetaDefinition typeHeatMetaDefinition : listTypeHeatMetaDefinition){
 112                 for(GroupHeatMetaDefinition groupHeatMetaDefinition : typeHeatMetaDefinition.getGroupHeatMetaDefinition()){
 113                         artifactList.addAll(groupHeatMetaDefinition.getArtifactList());
 114                 }
 115             }
 116
 117             List<HeatMetaFirstLevelDefinition> listArtifactWithTypesByList = getListArtifactWithTypesByList(directory, artifactList);
 118                 return listArtifactWithTypesByList;
 119 //          return artifactList;
 120
 121         }
 122
 123         private static Map<String, Object> getMapArtifactFromFolderStructure(File pathToArtifactFolder) throws IOException {
 124
 125                 Map<String, Object> map = new HashMap<String, Object>();
 126
 127
 128                 final Path dir = Paths.get(pathToArtifactFolder.getPath());
 129                 final DirectoryStream<Path> dirStream = Files.newDirectoryStream(dir);
 130
 131                 dirStream.forEach(currFile -> {
 132                         File file = currFile.toFile();
 133                                 if (file.isDirectory()) {
 134                                         System.out.println(file.getName());
 135                                         if(file.getName().toLowerCase().equals("deployment") || file.getName().toLowerCase().equals("informational")) {
 136                                                 map.put(file.getName(), getListArtifactWithTypes(file));
 137                                         } else {
 138                                                 try {
 139                                                         map.put(file.getName(), getMapArtifactFromFolderStructure(file));
 140                                                 } catch (IOException e) {
 141                                                         // TODO Auto-generated catch block
 142                                                         e.printStackTrace();
 143                                                 }
 144                                         }
 145                                 }
 146                 });
 147
 148                 dirStream.close();
 149
 150
 151
 152 //
 153 //              File[] fileList = pathToArtifactFolder.listFiles();
 154 //              for(File file: fileList) {
 155 //                      if (file.isDirectory()) {
 156 //
 157 //                              System.out.println(file.getName());
 158 //                              if(file.getName().equals("Deployment") || file.getName().equals("Informational")) {
 159 //                                      map.put(file.getName(), getListArtifactWithTypes(file));
 160 //                              } else {
 161 //                                      map.put(file.getName(), getMapArtifactFromFolderStructure(file));
 162 //                              }
 163 //                      }
 164 //              }
 165                 return map;
 166         }
 167
 168
 169
 170         private static List<HeatMetaFirstLevelDefinition> getListArtifactWithTypes(File folderPath) {
 171                 List<HeatMetaFirstLevelDefinition> artifactList = new LinkedList<HeatMetaFirstLevelDefinition>();
 172
 173                 File[] fileList = folderPath.listFiles();
 174
 175                 for(File file: fileList) {
 176                         File[] artifacts = file.listFiles();
 177
 178                         for(File artifact: artifacts) {
 179 //                              HeatMetaFirstLevelDefinition heatMetaFirstLevelDefinition = new HeatMetaFirstLevelDefinition(file.getName(), artifact.getName());
 180                                 HeatMetaFirstLevelDefinition heatMetaFirstLevelDefinition = new HeatMetaFirstLevelDefinition(artifact.getName(), file.getName(), crunchifyGetMd5ForFile(artifact));
 181                                 artifactList.add(heatMetaFirstLevelDefinition);
 182                         }
 183                 }
 184
 185                 return artifactList;
 186         }
 187
 188         private static List<HeatMetaFirstLevelDefinition> getListArtifactWithTypesByList(File folderPath, List<HeatMetaFirstLevelDefinition> artifactLogicList) {
 189
 190
 191                 File[] fileList = folderPath.listFiles();
 192
 193
 194
 195                 for (HeatMetaFirstLevelDefinition heatMetaFirstLevelDefinition : artifactLogicList) {
 196
 197                         String fileName = heatMetaFirstLevelDefinition.getFileName();
 198
 199                         for (File fileFromFolder : fileList) {
 200                                 if ( fileFromFolder.getName().equals(fileName)){
 201                                         heatMetaFirstLevelDefinition.setCheckSum(crunchifyGetMd5ForFile(fileFromFolder));
 202                                 }
 203
 204                         }
 205                  }
 206
 207                 return artifactLogicList;
 208         }
 209
 210         public static String crunchifyGetMd5ForFile(File crunchifyFile) {
 211                 String crunchifyValue = null;
 212                 FileInputStream crunchifyInputStream = null;
 213                 try {
 214                         crunchifyInputStream = new FileInputStream(crunchifyFile);
 215
 216                         // md5Hex converts an array of bytes into an array of characters representing the hexadecimal values of each byte in order.
 217                         // The returned array will be double the length of the passed array, as it takes two characters to represent any given byte.
 218                         crunchifyValue = DigestUtils.md5Hex(IOUtils.toByteArray(crunchifyInputStream));
 219                 } catch (IOException e) {
 220                         e.printStackTrace();
 221                 } finally {
 222                         IOUtils.closeQuietly(crunchifyInputStream);
 223                 }
 224                 return crunchifyValue;
 225         }
 226
 227         public static void unZip(String zipFile, String outputFolder) {
 228                 byte[] buffer = new byte[1024];
 229
 230              try{
 231                 File folder = new File(outputFolder);
 232
 233                 if(!folder.exists()){
 234                         folder.mkdir();
 235                 }
 236
 237                 ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFile));
 238                 ZipEntry ze = zis.getNextEntry();
 239
 240                 while(ze!=null){
 241
 242                    String fileName = ze.getName();
 243                    File newFile = new File(outputFolder + File.separator + fileName);
 244
 245                    if(ze.isDirectory()) {
 246                            newFile.mkdir();
 247                            ze = zis.getNextEntry();
 248                            continue;
 249                    }
 250
 251                     new File(newFile.getParent()).mkdirs();
 252                     FileOutputStream fos = new FileOutputStream(newFile);
 253
 254                     int len;
 255                     while ((len = zis.read(buffer)) > 0) {
 256                         fos.write(buffer, 0, len);
 257                     }
 258
 259                     fos.close();
 260                     ze = zis.getNextEntry();
 261                 }
 262
 263                 zis.closeEntry();
 264                 zis.close();
 265
 266             } catch (IOException ex) {
 267                ex.printStackTrace();
 268             }
 269
 270         }
 271
 272     private static void cleanFolders(String outputFolder) throws IOException {
 273                 System.gc();
 274                 FileUtils.cleanDirectory(new File(outputFolder));
 275                 FileUtils.deleteDirectory(new File(outputFolder));
 276         }
 277
 278     private static String unzipCsarFile(String pathToCsar) {
 279                 File csarFile = new File(pathToCsar);
 280
 281
 282                 File dir = new File(csarFile.getParent() + File.separator + "output-" + UUID.randomUUID());
 283                 if(!dir.exists()) {
 284                         dir.mkdirs();
 285                 }
 286
 287                 String outputFolder = dir.getPath();
 288                 ArtifactFromCsar.unZip(pathToCsar, outputFolder);
 289                 return outputFolder;
 290         }
 291
 292         public static String[] getArtifactNamesFromCsar(String path, String csarFile) throws Exception {
 293                 Map<String, Object> combinedMap = combineHeatArtifacstWithFolderArtifacsToMap(path + csarFile);
 294                 LinkedList<HeatMetaFirstLevelDefinition> deploymentArtifacts = ((LinkedList<HeatMetaFirstLevelDefinition>) combinedMap.get("Deployment"));
 295                 List<String> artifactNamesList = deploymentArtifacts.stream().map(e -> e.getFileName()).collect(Collectors.toList());
 296                 Object[] artifactNamesObjectArr = artifactNamesList.toArray();
 297                 String[] artifactNamesFromFile = Arrays.copyOf(artifactNamesObjectArr, artifactNamesObjectArr.length, String[].class);
 298                 return artifactNamesFromFile;
 299         }
 300
 301 }