catalog-be/src/main/java/org/openecomp/sdc/be/info/ArtifactTemplateInfo.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.be.info;
  22
  23 import java.util.ArrayList;
  24 import java.util.HashMap;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.Set;
  28
  29 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  30 import org.openecomp.sdc.be.config.ConfigurationManager;
  31 import org.openecomp.sdc.be.config.Configuration.ArtifactTypeConfig;
  32 import org.openecomp.sdc.be.dao.api.ActionStatus;
  33 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  34 import org.openecomp.sdc.be.impl.ComponentsUtils;
  35 import org.openecomp.sdc.be.model.ArtifactType;
  36 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  37 import org.openecomp.sdc.exception.ResponseFormat;
  38 import org.slf4j.Logger;
  39 import org.slf4j.LoggerFactory;
  40
  41 import com.google.gson.Gson;
  42 import com.google.gson.JsonObject;
  43
  44 import fj.data.Either;
  45
  46 public class ArtifactTemplateInfo {
  47         public static final String TYPE = "type";
  48         public static final String FILE_NAME = "fileName";
  49         public static final String ENV = "env";
  50         public static final String IS_BASE = "isBase";
  51
  52         private static final String CSAR_HEAT = "HEAT";
  53         private static final String CSAR_ARTIFACT = "artifacts";
  54         private static final String CSAR_NETWORK = "network";
  55         private static final String CSAR_VOLUME = "volume";
  56         private static final String CSAR_NESTED = "nested";
  57         private static final Object DESC = "description";
  58         private static Logger log = LoggerFactory.getLogger(ArtifactTemplateInfo.class.getName());
  59         String type;
  60         String fileName;
  61         String env;
  62         boolean isBase;
  63         String groupName;
  64         String description;
  65
  66         List<ArtifactTemplateInfo> relatedArtifactsInfo;
  67         private static Gson gson = new Gson();
  68
  69         public ArtifactTemplateInfo() {
  70                 super();
  71         }
  72
  73         public ArtifactTemplateInfo(String type, String fileName, String env, List<ArtifactTemplateInfo> relatedArtifactsInfo) {
  74                 super();
  75                 this.type = type;
  76                 this.fileName = fileName;
  77                 this.env = env;
  78                 this.relatedArtifactsInfo = relatedArtifactsInfo;
  79         }
  80
  81         public String getType() {
  82                 return type;
  83         }
  84
  85         public void setType(String type) {
  86                 this.type = type;
  87         }
  88
  89         public String getFileName() {
  90                 return fileName;
  91         }
  92
  93         public void setFileName(String fileName) {
  94                 this.fileName = fileName;
  95         }
  96
  97         public String getEnv() {
  98                 return env;
  99         }
 100
 101         public void setEnv(String env) {
 102                 this.env = env;
 103         }
 104
 105         public List<ArtifactTemplateInfo> getRelatedArtifactsInfo() {
 106                 return relatedArtifactsInfo;
 107         }
 108
 109         public void setRelatedArtifactsInfo(List<ArtifactTemplateInfo> relatedArtifactsInfo) {
 110                 this.relatedArtifactsInfo = relatedArtifactsInfo;
 111         }
 112
 113         public String getGroupName() {
 114                 return groupName;
 115         }
 116
 117         public void setGroupName(String groupName) {
 118                 this.groupName = groupName;
 119         }
 120
 121         public boolean isBase() {
 122                 return isBase;
 123         }
 124
 125         public void setBase(boolean isBase) {
 126                 this.isBase = isBase;
 127         }
 128
 129         public String getDescription() {
 130                 return description;
 131         }
 132
 133         public void setDescription(String description) {
 134                 this.description = description;
 135         }
 136
 137         @Override
 138         public String toString() {
 139                 return "ArtifactTemplateInfo [type=" + type + ", fileName=" + fileName + ", env=" + env + ", isBase=" + isBase + ", groupName=" + groupName + ", description=" + description + ", relatedArtifactsInfo=" + relatedArtifactsInfo + "]";
 140         }
 141
 142         public static Either<ArtifactTemplateInfo, ResponseFormat> createArtifactTemplateInfoFromJson(ComponentsUtils componentsUtils, String type, Map<String, Object> o, List<ArtifactTemplateInfo> createdArtifactTemplateInfoList,
 143                         ArtifactTemplateInfo parentArtifact) {
 144                 String content = gson.toJson(o);
 145                 JsonObject jsonElement = new JsonObject();
 146                 ArtifactTemplateInfo resourceInfo = new ArtifactTemplateInfo();
 147
 148                 jsonElement = gson.fromJson(content, jsonElement.getClass());
 149
 150                 Map<String, Object> artifactTemplateMap = componentsUtils.parseJsonToObject(jsonElement.toString(), HashMap.class);
 151                 if (artifactTemplateMap.containsKey(TYPE))
 152                         resourceInfo.setType((String) artifactTemplateMap.get(TYPE));
 153                 if (artifactTemplateMap.containsKey(FILE_NAME))
 154                         resourceInfo.setFileName((String) artifactTemplateMap.get(FILE_NAME));
 155                 if (artifactTemplateMap.containsKey(IS_BASE))
 156                         resourceInfo.setBase((Boolean) artifactTemplateMap.get(IS_BASE));
 157                 if (artifactTemplateMap.containsKey(ENV)) {
 158                         Object envObj = artifactTemplateMap.get(ENV);
 159                         String envStr = "";
 160                         if (envObj instanceof String) {
 161                                 envStr = (String) envObj;
 162                         } else if (envObj instanceof Map) {
 163                                 Map envMap = (Map) envObj;
 164                                 if (envMap.containsKey(FILE_NAME)) {
 165                                         envStr = (String) envMap.get(FILE_NAME);
 166                                 }
 167                         }
 168                         resourceInfo.setEnv(envStr);
 169                 }
 170                 if (artifactTemplateMap.containsKey(DESC)) {
 171                         resourceInfo.setDescription((String) artifactTemplateMap.get(DESC));
 172                 } else {
 173                         resourceInfo.setDescription((String) artifactTemplateMap.get(FILE_NAME));
 174                 }
 175
 176                 boolean artifactTypeExist = false;
 177                 String correctType = type;
 178                 if (type.equalsIgnoreCase(CSAR_NESTED))
 179                         correctType = ArtifactTypeEnum.HEAT_NESTED.getType();
 180                 else if ((type.equalsIgnoreCase(CSAR_VOLUME)))
 181                         correctType = ArtifactTypeEnum.HEAT_VOL.getType();
 182                 else if ((type.equalsIgnoreCase(CSAR_NETWORK)))
 183                         correctType = ArtifactTypeEnum.HEAT_NET.getType();
 184                 else if ((type.equalsIgnoreCase(CSAR_ARTIFACT)))
 185                         correctType = ArtifactTypeEnum.HEAT_ARTIFACT.getType();
 186                 else if ((type.equalsIgnoreCase(CSAR_HEAT)))
 187                         correctType = ArtifactTypeEnum.HEAT.getType();
 188                 else
 189                         correctType = ArtifactTypeEnum.OTHER.getType();
 190                 Either<List<ArtifactType>, ActionStatus> allArtifactTypes = getDeploymentArtifactTypes(NodeTypeEnum.Resource);
 191
 192                 if (allArtifactTypes.isRight()) {
 193                         BeEcompErrorManager.getInstance().logBeInvalidConfigurationError("Artifact Upload / Update", "artifactTypes", allArtifactTypes.right().value().name());
 194                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.FAILED_RETRIVE_ARTIFACTS_TYPES));
 195                 }
 196
 197                 for (ArtifactType artType : allArtifactTypes.left().value()) {
 198
 199                         if (artType.getName().contains(correctType)) {
 200                                 resourceInfo.type = artType.getName();
 201                                 artifactTypeExist = true;
 202                                 break;
 203                         }
 204                 }
 205
 206                 if (!artifactTypeExist) {
 207                         BeEcompErrorManager.getInstance().logBeInvalidTypeError("Artifact", "-Not supported artifact type ", correctType);
 208                         log.debug("Not supported artifact type = {}" , correctType);
 209                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED, correctType));
 210                 }
 211
 212                 Either<Boolean, ResponseFormat> eitherNeedToCreate = validateEnv(componentsUtils, createdArtifactTemplateInfoList, resourceInfo);
 213                 if (eitherNeedToCreate.isRight())
 214                         return Either.right(eitherNeedToCreate.right().value());
 215                 eitherNeedToCreate = validateParentType(componentsUtils, resourceInfo, parentArtifact);
 216                 if (eitherNeedToCreate.isRight())
 217                         return Either.right(eitherNeedToCreate.right().value());
 218                 eitherNeedToCreate = validateIsAlreadyExist(componentsUtils, resourceInfo, createdArtifactTemplateInfoList, parentArtifact);
 219                 if (eitherNeedToCreate.isRight())
 220                         return Either.right(eitherNeedToCreate.right().value());
 221                 Set<String> keys = o.keySet();
 222                 for (String key : keys) {
 223                         if (o.get(key) instanceof List) {
 224                                 List<Map<String, Object>> artifList = (List<Map<String, Object>>) o.get(key);
 225                                 for (Map<String, Object> relatedArtifactsMap : artifList) {
 226                                         Either<ArtifactTemplateInfo, ResponseFormat> relatedArtifact = ArtifactTemplateInfo.createArtifactTemplateInfoFromJson(componentsUtils, key, relatedArtifactsMap, createdArtifactTemplateInfoList, resourceInfo);
 227                                         if (relatedArtifact.isRight())
 228                                                 return relatedArtifact;
 229                                         if (resourceInfo.relatedArtifactsInfo == null)
 230                                                 resourceInfo.relatedArtifactsInfo = new ArrayList<ArtifactTemplateInfo>();
 231                                         resourceInfo.relatedArtifactsInfo.add(relatedArtifact.left().value());
 232                                 }
 233                         }
 234                 }
 235                 return Either.left(resourceInfo);
 236         }
 237
 238         private static Either<Boolean, ResponseFormat> validateIsAlreadyExist(ComponentsUtils componentsUtils, ArtifactTemplateInfo resourceInfo, List<ArtifactTemplateInfo> createdArtifactTemplateInfoList, ArtifactTemplateInfo parentArtifact) {
 239
 240                 if (parentArtifact == null) {
 241                         if (createdArtifactTemplateInfoList == null || createdArtifactTemplateInfoList.isEmpty())
 242                                 return Either.left(true);
 243                         for (ArtifactTemplateInfo createdArtifact : createdArtifactTemplateInfoList) {
 244                                 if (createdArtifact.getType().equalsIgnoreCase(resourceInfo.getType()) && createdArtifact.getFileName().equalsIgnoreCase(resourceInfo.getFileName())) {
 245                                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_ALRADY_EXIST_IN_MASTER_IN_CSAR, resourceInfo.getFileName(), createdArtifact.type));
 246                                 }
 247                         }
 248                         return Either.left(true);
 249                 } else {
 250                         List<ArtifactTemplateInfo> relatedArtifacts = parentArtifact.getRelatedArtifactsInfo();
 251                         if (relatedArtifacts == null || relatedArtifacts.isEmpty())
 252                                 return Either.left(true);
 253                         for (ArtifactTemplateInfo relatedArtifact : relatedArtifacts) {
 254                                 if (relatedArtifact.getType().equalsIgnoreCase(resourceInfo.getType())) {
 255                                         if (relatedArtifact.getFileName().equalsIgnoreCase(resourceInfo.getFileName())) {
 256                                                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_ALRADY_EXIST_IN_MASTER_IN_CSAR, resourceInfo.getFileName(), parentArtifact.getFileName()));
 257                                         }
 258                                 }
 259                         }
 260                         return Either.left(true);
 261                 }
 262         }
 263
 264         private static Either<Boolean, ResponseFormat> validateParentType(ComponentsUtils componentsUtils, ArtifactTemplateInfo resourceInfo, ArtifactTemplateInfo parentArtifact) {
 265
 266                 if (parentArtifact == null)
 267                         return Either.left(true);
 268                 if (resourceInfo.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_ARTIFACT.getType()))
 269                         return Either.left(true);
 270                 if (resourceInfo.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType()) && parentArtifact != null) {
 271                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_VALID_IN_MASTER, resourceInfo.getFileName(), resourceInfo.getType(), parentArtifact.getFileName(), parentArtifact.getType()));
 272                 }
 273                 if ((resourceInfo.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_NET.getType()) || resourceInfo.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType()))
 274                                 && !parentArtifact.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType())) {
 275                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_VALID_IN_MASTER, resourceInfo.getFileName(), resourceInfo.getType(), parentArtifact.getFileName(), parentArtifact.getType()));
 276                 }
 277                 if (parentArtifact.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_NESTED.getType())) {
 278                         if (resourceInfo.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_ARTIFACT.getType()) || resourceInfo.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_NESTED.getType())) {
 279                                 return Either.left(true);
 280                         }
 281                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_VALID_IN_MASTER, resourceInfo.getFileName(), resourceInfo.getType(), parentArtifact.getFileName(), parentArtifact.getType()));
 282                 }
 283                 if (parentArtifact.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType()) && resourceInfo.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType())) {
 284                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_VALID_IN_MASTER, resourceInfo.getFileName(), resourceInfo.getType(), parentArtifact.getFileName(), parentArtifact.getType()));
 285                 }
 286
 287                 if (parentArtifact.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType())) {
 288                         return Either.left(true);
 289                 }
 290                 return Either.left(true);
 291         }
 292
 293         private static Either<Boolean, ResponseFormat> validateEnv(ComponentsUtils componentsUtils, List<ArtifactTemplateInfo> createdArtifactTemplateInfoList, ArtifactTemplateInfo resourceInfo) {
 294
 295                 if (createdArtifactTemplateInfoList == null || createdArtifactTemplateInfoList.isEmpty())
 296                         return Either.left(true);
 297                 if (resourceInfo.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_NESTED.getType()) || resourceInfo.getType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_ARTIFACT.getType()))
 298                         return Either.left(true);
 299                 for (ArtifactTemplateInfo createdArtifactTemplateInfo : createdArtifactTemplateInfoList) {
 300                         // check if artifact with this name already parsed. If parsed check
 301                         // env name. it must be the same.
 302                         if (resourceInfo.getFileName().equalsIgnoreCase(createdArtifactTemplateInfo.getFileName())) {
 303                                 if ((resourceInfo.getEnv() == null || resourceInfo.getEnv().isEmpty()) && (createdArtifactTemplateInfo.getEnv() != null && !createdArtifactTemplateInfo.getEnv().isEmpty())) {
 304                                         log.debug("Artifact  file with name {} type{}  already parsed but with env {}", resourceInfo.getFileName(), resourceInfo.getType(), createdArtifactTemplateInfo.getEnv());
 305                                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_VALID_ENV, resourceInfo.getFileName(), resourceInfo.getType(), resourceInfo.getEnv(), createdArtifactTemplateInfo.getEnv()));
 306                                 }
 307                                 if (resourceInfo.getEnv() != null && !resourceInfo.getEnv().isEmpty() && createdArtifactTemplateInfo.getEnv() != null && !createdArtifactTemplateInfo.getEnv().isEmpty()
 308                                                 && !createdArtifactTemplateInfo.getEnv().equalsIgnoreCase(resourceInfo.getEnv())) {
 309                                         log.debug("Artifact  file with name {} type{} env {} already parsed but with env {}", resourceInfo.getFileName(), resourceInfo.getType(), resourceInfo.getEnv(), createdArtifactTemplateInfo.getEnv());
 310                                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_VALID_ENV, resourceInfo.getFileName(), resourceInfo.getType(), resourceInfo.getEnv(), createdArtifactTemplateInfo.getEnv()));
 311                                 }
 312                                 if ((resourceInfo.getEnv() != null && !resourceInfo.getEnv().isEmpty()) && (createdArtifactTemplateInfo.getEnv() == null || createdArtifactTemplateInfo.getEnv().isEmpty())) {
 313                                         log.debug("Artifact  file with name {} type{} env {} already parsed but with env {}", resourceInfo.getFileName(), resourceInfo.getType(), resourceInfo.getEnv(), createdArtifactTemplateInfo.getEnv());
 314                                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_VALID_ENV, resourceInfo.getFileName(), resourceInfo.getType(), resourceInfo.getEnv(), createdArtifactTemplateInfo.getEnv()));
 315                                 }
 316                         }
 317                         List<ArtifactTemplateInfo> relatedArtifacts = createdArtifactTemplateInfo.getRelatedArtifactsInfo();
 318                         Either<Boolean, ResponseFormat> status = validateEnv(componentsUtils, relatedArtifacts, resourceInfo);
 319                         if (status.isRight())
 320                                 return status;
 321                 }
 322                 return Either.left(true);
 323         }
 324
 325         private static Either<List<ArtifactType>, ActionStatus> getDeploymentArtifactTypes(NodeTypeEnum parentType) {
 326
 327                 Map<String, ArtifactTypeConfig> deploymentArtifacts = null;
 328                 List<ArtifactType> artifactTypes = new ArrayList<ArtifactType>();
 329
 330                 if (parentType.equals(NodeTypeEnum.Service)) {
 331                         deploymentArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration().getServiceDeploymentArtifacts();
 332                 } else {
 333                         deploymentArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration().getResourceDeploymentArtifacts();
 334                 }
 335                 if (deploymentArtifacts != null) {
 336                         for (String artifactType : deploymentArtifacts.keySet()) {
 337                                 ArtifactType artifactT = new ArtifactType();
 338                                 artifactT.setName(artifactType);
 339                                 artifactTypes.add(artifactT);
 340                         }
 341                         return Either.left(artifactTypes);
 342                 } else {
 343                         return Either.right(ActionStatus.GENERAL_ERROR);
 344                 }
 345
 346         }
 347
 348         public static int compareByGroupName(ArtifactTemplateInfo art1, ArtifactTemplateInfo art2) {
 349                 return art1.isBase ? (art2.isBase ? 0 : -1) : (art2.isBase ? 1 : 0);
 350         }
 351
 352 }