openecomp-be/lib/openecomp-heat-lib/src/main/java/org/openecomp/sdc/heat/services/tree/HeatTreeManager.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.heat.services.tree;
  22
  23 import org.openecomp.core.utilities.file.FileContentHandler;
  24 import org.openecomp.core.utilities.file.FileUtils;
  25 import org.openecomp.core.utilities.json.JsonUtil;
  26 import org.openecomp.core.utilities.yaml.YamlUtil;
  27 import org.openecomp.core.validation.types.GlobalValidationContext;
  28 import org.openecomp.sdc.common.utils.AsdcCommon;
  29 import org.openecomp.sdc.datatypes.error.ErrorMessage;
  30 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
  31 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
  32 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  33 import org.openecomp.sdc.heat.datatypes.structure.Artifact;
  34 import org.openecomp.sdc.heat.datatypes.structure.HeatStructureTree;
  35 import org.openecomp.sdc.heat.services.HeatStructureUtil;
  36
  37 import org.slf4j.Logger;
  38 import org.slf4j.LoggerFactory;
  39
  40 import java.io.InputStream;
  41 import java.util.HashMap;
  42 import java.util.HashSet;
  43 import java.util.List;
  44 import java.util.Map;
  45 import java.util.Set;
  46
  47 /**
  48  * The type Heat tree manager.
  49  */
  50 public class HeatTreeManager {
  51
  52   private static Logger logger = LoggerFactory.getLogger(HeatTreeManager.class);
  53
  54
  55   private FileContentHandler heatContentMap = new FileContentHandler();
  56   private byte[] manifest;
  57   private HeatStructureTree tree = new HeatStructureTree();
  58   private Map<String, HeatStructureTree> fileTreeRef = new HashMap<>();
  59   private Map<String, Artifact> artifactRef = new HashMap<>();
  60   private Map<String, Artifact> candidateOrphanArtifacts = new HashMap<>();
  61   private Map<String, HeatStructureTree> nestedFiles = new HashMap<>();
  62   private Map<HeatStructureTree, HeatStructureTree> volumeFileToParent = new HashMap<>();
  63   private Map<HeatStructureTree, HeatStructureTree> networkFileToParent = new HashMap<>();
  64   private Set<String> manifestFiles = new HashSet<>();
  65
  66   /**
  67    * Add file.
  68    *
  69    * @param fileName the file name
  70    * @param content  the content
  71    */
  72   public void addFile(String fileName, InputStream content) {
  73     if (fileName.equals(AsdcCommon.MANIFEST_NAME)) {
  74       manifest = FileUtils.toByteArray(content);
  75
  76     } else {
  77       heatContentMap.addFile(fileName, content);
  78     }
  79   }
  80
  81   /**
  82    * Create tree.
  83    */
  84   public void createTree() {
  85     if (manifest == null) {
  86       logger.error("Missing manifest file in the zip.");
  87       return;
  88     }
  89     ManifestContent manifestData =
  90         JsonUtil.json2Object(new String(manifest), ManifestContent.class);
  91     scanTree(null, manifestData.getData());
  92     addNonNestedVolumeNetworkToTree(volumeFileToParent, nestedFiles.keySet(), true);
  93     addNonNestedVolumeNetworkToTree(networkFileToParent, nestedFiles.keySet(), false);
  94     handleOrphans();
  95
  96     tree = fileTreeRef.get(AsdcCommon.PARENT);
  97   }
  98
  99   private void handleOrphans() {
 100     tree = fileTreeRef.get(AsdcCommon.PARENT);
 101     candidateOrphanArtifacts.entrySet().stream()
 102         .forEach(entry -> tree.addArtifactToArtifactList(entry.getValue()));
 103     nestedFiles
 104         .values()
 105         .stream()
 106         .filter(heatStructureTree -> tree.getHEAT().contains(heatStructureTree))
 107         .forEach(heatStructureTree -> tree.getHEAT().remove(heatStructureTree));
 108
 109     heatContentMap.getFileList().stream().filter(fileName -> !manifestFiles.contains(fileName))
 110         .forEach(fileName -> addTreeOther(fileName));
 111   }
 112
 113   private void addTreeOther(String fileName) {
 114     if (tree.getOther() == null) {
 115       tree.setOther(new HashSet<>());
 116     }
 117     HeatStructureTree other = new HeatStructureTree(fileName, false);
 118     fileTreeRef.put(fileName, other);
 119     tree.getOther().add(other);
 120   }
 121
 122
 123   private void handleHeatContentReference(String filename, HeatStructureTree fileHeatStructureTree,
 124                                           GlobalValidationContext globalContext) {
 125
 126     String fileName = fileHeatStructureTree.getFileName();
 127     InputStream fileContent = this.heatContentMap.getFileContent(fileName);
 128     if (fileContent == null) {
 129       return; // file exist in manifest but does not exist in zip
 130     }
 131     try {
 132       HeatOrchestrationTemplate hot =
 133           new YamlUtil().yamlToObject(fileContent, HeatOrchestrationTemplate.class);
 134
 135       Set<String> nestedSet = HeatStructureUtil.getNestedFiles(filename, hot, globalContext);
 136       addHeatNestedFiles(fileHeatStructureTree, nestedSet);
 137
 138       Set<String> artifactSet = HeatStructureUtil.getArtifactFiles(filename, hot, globalContext);
 139       addHeatArtifactFiles(fileHeatStructureTree, artifactSet);
 140     } catch (Exception ignore) { /* invalid yaml no need to process reference */ }
 141   }
 142
 143   private void addHeatArtifactFiles(HeatStructureTree fileHeatStructureTree,
 144                                     Set<String> artifactSet) {
 145     Artifact artifact;
 146     for (String artifactName : artifactSet) {
 147       FileData.Type type =
 148           candidateOrphanArtifacts.get(artifactName) != null ? candidateOrphanArtifacts
 149               .get(artifactName).getType() : null;
 150       artifact = new Artifact(artifactName, type);
 151       artifactRef.put(artifactName, artifact);
 152       candidateOrphanArtifacts.remove(artifactName);
 153       fileHeatStructureTree.addArtifactToArtifactList(artifact);
 154     }
 155   }
 156
 157
 158   private void addHeatNestedFiles(HeatStructureTree fileHeatStructureTree, Set<String> nestedSet) {
 159     HeatStructureTree childHeatStructureTree;
 160     for (String nestedName : nestedSet) {
 161       childHeatStructureTree = fileTreeRef.get(nestedName);
 162       if (childHeatStructureTree == null) {
 163         childHeatStructureTree = new HeatStructureTree();
 164         childHeatStructureTree.setFileName(nestedName);
 165         fileTreeRef.put(nestedName, childHeatStructureTree);
 166       }
 167       fileHeatStructureTree.addHeatStructureTreeToNestedHeatList(childHeatStructureTree);
 168       nestedFiles.put(childHeatStructureTree.getFileName(), childHeatStructureTree);
 169     }
 170   }
 171
 172
 173   /**
 174    * Add errors.
 175    *
 176    * @param validationErrors the validation errors
 177    */
 178   public void addErrors(Map<String, List<ErrorMessage>> validationErrors) {
 179
 180     validationErrors.entrySet().stream().filter(entry -> {
 181       return fileTreeRef.get(entry.getKey()) != null;
 182     }).forEach(entry -> entry.getValue().stream().forEach(error ->
 183         fileTreeRef.get(entry.getKey()).addErrorToErrorsList(error)));
 184
 185     validationErrors.entrySet().stream().filter(entry -> {
 186       return artifactRef.get(entry.getKey()) != null;
 187     }).forEach(entry -> artifactRef.get(entry.getKey()).setErrors(entry.getValue()));
 188
 189   }
 190
 191   /**
 192    * Scan tree.
 193    *
 194    * @param parent the parent
 195    * @param data   the data
 196    */
 197   public void scanTree(String parent, List<FileData> data) {
 198     String fileName;
 199     FileData.Type type;
 200     HeatStructureTree parentHeatStructureTree;
 201     HeatStructureTree fileHeatStructureTree;
 202     HeatStructureTree childHeatStructureTree;
 203     Artifact artifact;
 204     if (parent == null) {
 205       parentHeatStructureTree = new HeatStructureTree();
 206       fileTreeRef.put(AsdcCommon.PARENT, parentHeatStructureTree);
 207     } else {
 208       parentHeatStructureTree = fileTreeRef.get(parent);
 209     }
 210
 211     for (FileData fileData : data) {
 212       fileName = fileData.getFile();
 213       manifestFiles.add(fileName);
 214       type = fileData.getType();
 215
 216       if (FileData.Type.HEAT.equals(type)) {
 217         fileHeatStructureTree = fileTreeRef.get(fileName);
 218         if (fileHeatStructureTree == null) {
 219           fileHeatStructureTree = new HeatStructureTree();
 220           fileTreeRef.put(fileName, fileHeatStructureTree);
 221         }
 222         fileHeatStructureTree.setFileName(fileName);
 223         fileHeatStructureTree.setBase(fileData.getBase());
 224         fileHeatStructureTree.setType(type);
 225         handleHeatContentReference(null, fileHeatStructureTree, null);
 226         parentHeatStructureTree.addHeatToHEATList(fileHeatStructureTree);
 227         if (fileData.getData() != null) {
 228           scanTree(fileName, fileData.getData());
 229         }
 230       } else {
 231         childHeatStructureTree = new HeatStructureTree();
 232         childHeatStructureTree.setFileName(fileName);
 233         childHeatStructureTree.setBase(fileData.getBase());
 234         childHeatStructureTree.setType(type);
 235         fileTreeRef.put(childHeatStructureTree.getFileName(), childHeatStructureTree);
 236
 237         if (type == null) {
 238           parentHeatStructureTree.addOtherToOtherList(childHeatStructureTree);
 239         } else if (FileData.Type.HEAT_NET.equals(type)) {
 240           //  parentHeatStructureTree.addNetworkToNetworkList(childHeatStructureTree);
 241           networkFileToParent.put(childHeatStructureTree, parentHeatStructureTree);
 242           if (fileData.getData() != null) {
 243             scanTree(fileName, fileData.getData());
 244           }
 245
 246         } else if (FileData.Type.HEAT_VOL.equals(type)) {
 247           // parentHeatStructureTree.addVolumeFileToVolumeList(childHeatStructureTree);
 248           volumeFileToParent.put(childHeatStructureTree, parentHeatStructureTree);
 249           if (fileData.getData() != null) {
 250             scanTree(fileName, fileData.getData());
 251           }
 252         } else if (FileData.Type.HEAT_ENV.equals(type)) {
 253           if (parentHeatStructureTree != null && parentHeatStructureTree.getFileName() != null) {
 254             parentHeatStructureTree.setEnv(childHeatStructureTree);
 255           } else {
 256             if (parentHeatStructureTree.getOther() == null) {
 257               parentHeatStructureTree.setOther(new HashSet<>());
 258             }
 259             parentHeatStructureTree.getOther().add(childHeatStructureTree);
 260           }
 261         } else {
 262           artifact = new Artifact(fileName, type);
 263           if (!artifactRef.keySet().contains(fileName)) {
 264             artifactRef.put(fileName, artifact);
 265             candidateOrphanArtifacts.put(fileName, artifact);
 266           }
 267         }
 268       }
 269     }
 270   }
 271
 272
 273   private void addNonNestedVolumeNetworkToTree(
 274       Map<HeatStructureTree, HeatStructureTree> netVolToParent, Set<String> nestedFileNames,
 275       boolean isVolume) {
 276     for (Map.Entry<HeatStructureTree, HeatStructureTree> entry : netVolToParent.entrySet()) {
 277       HeatStructureTree netOrVolNode = entry.getKey();
 278       HeatStructureTree parent = entry.getValue();
 279       if (!nestedFileNames.contains(netOrVolNode.getFileName())) {
 280         if (isVolume) {
 281           parent.addVolumeFileToVolumeList(netOrVolNode);
 282         } else {
 283           parent.addNetworkToNetworkList(netOrVolNode);
 284         }
 285       }
 286     }
 287   }
 288
 289
 290   /**
 291    * Gets tree.
 292    *
 293    * @return the tree
 294    */
 295   public HeatStructureTree getTree() {
 296     return tree;
 297   }
 298 }