catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperations.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.model.jsontitan.operations;
  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.Map.Entry;
  28 import java.util.Optional;
  29 import java.util.UUID;
  30 import java.util.stream.Collectors;
  31
  32 import org.apache.commons.collections.MapUtils;
  33 import org.apache.commons.lang3.tuple.ImmutableTriple;
  34 import org.apache.commons.lang3.tuple.Triple;
  35 import org.apache.tinkerpop.gremlin.structure.Direction;
  36 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  37 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  38 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  39 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  40 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  41 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  42 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  43 import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition;
  44 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  45 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  46 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  47 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
  48 import org.openecomp.sdc.be.model.ArtifactDefinition;
  49 import org.openecomp.sdc.be.model.HeatParameterDefinition;
  50 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  51 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
  52 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  53 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  54 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  55 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
  56 import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
  57 import org.slf4j.Logger;
  58 import org.slf4j.LoggerFactory;
  59 import org.slf4j.MDC;
  60
  61 import fj.data.Either;
  62
  63 @org.springframework.stereotype.Component("artifacts-operations")
  64
  65 public class ArtifactsOperations extends BaseOperation {
  66         private static Logger log = LoggerFactory.getLogger(ArtifactsOperations.class.getName());
  67
  68         public Either<ArtifactDefinition, StorageOperationStatus> addArifactToComponent(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type, boolean failIfExist, String instanceId) {
  69
  70                 String artifactId = artifactInfo.getUniqueId();
  71                 if (artifactId == null && artifactInfo.getEsId() != null) {
  72                         artifactId = artifactInfo.getEsId();
  73                 }
  74                 Either<ArtifactDataDefinition, StorageOperationStatus> status = updateArtifactOnGraph(parentId, artifactInfo, type, artifactId, instanceId, false, false);
  75                 if (status.isRight()) {
  76
  77                         log.debug("Failed to update artifact {} of {} {}. status is {}", artifactInfo.getArtifactName(), type.getName(), parentId, status.right().value());
  78                         BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("Update Artifact", artifactInfo.getArtifactName(), String.valueOf(status.right().value()));
  79                         return Either.right(status.right().value());
  80                 } else {
  81
  82                         ArtifactDataDefinition artifactData = status.left().value();
  83
  84                         ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(artifactInfo, artifactData);
  85                         log.debug("The returned ArtifactDefintion is {}", artifactDefResult);
  86                         return Either.left(artifactDefResult);
  87                 }
  88
  89         }
  90
  91         public Either<ArtifactDefinition, StorageOperationStatus> updateArifactOnResource(ArtifactDefinition artifactInfo, String id, String artifactId, NodeTypeEnum type, String instanceId) {
  92
  93                 Either<ArtifactDataDefinition, StorageOperationStatus> status = updateArtifactOnGraph(id, artifactInfo, type, artifactId, instanceId, true, false);
  94                 if (status.isRight()) {
  95
  96                         log.debug("Failed to update artifact {} of {} {}. status is {}", artifactInfo.getArtifactName(), type.getName(), id, status.right().value());
  97                         BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("Update Artifact", artifactInfo.getArtifactName(), String.valueOf(status.right().value()));
  98                         return Either.right(status.right().value());
  99                 } else {
 100
 101                         ArtifactDataDefinition artifactData = status.left().value();
 102
 103                         ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(artifactInfo, artifactData);
 104                         log.debug("The returned ArtifactDefintion is {}", artifactDefResult);
 105                         return Either.left(artifactDefResult);
 106                 }
 107         }
 108
 109         public Either<Boolean, StorageOperationStatus> isCloneNeeded(String parentId, ArtifactDefinition artifactInfo, NodeTypeEnum type) {
 110                 ArtifactGroupTypeEnum groupType = artifactInfo.getArtifactGroupType();
 111
 112                 Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(groupType, type);
 113                 EdgeLabelEnum edgeLabelEnum = triple.getLeft();
 114                 return super.isCloneNeeded(parentId, edgeLabelEnum);
 115         }
 116
 117         public Either<ArtifactDefinition, StorageOperationStatus> getArtifactById(String parentId, String id) {
 118                 return getArtifactById(parentId, id, null, null);
 119         }
 120
 121         public Either<ArtifactDefinition, StorageOperationStatus> getArtifactById(String parentId, String id, ComponentTypeEnum componentType, String containerId) {
 122                 Either<ArtifactDefinition, StorageOperationStatus> result = null;
 123                 ArtifactDataDefinition foundArtifact = null;
 124                 if (componentType != null && componentType == ComponentTypeEnum.RESOURCE_INSTANCE) {
 125                         foundArtifact = getInstanceArtifactByLabelAndId(parentId, id, containerId, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 126                         if (foundArtifact == null) {
 127                                 foundArtifact = getInstanceArtifactByLabelAndId(parentId, id, containerId, EdgeLabelEnum.INSTANCE_ARTIFACTS);
 128                         }
 129                 }
 130                 if (foundArtifact == null) {
 131                         foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 132                 }
 133                 if (foundArtifact == null) {
 134                         foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.TOSCA_ARTIFACTS);
 135                 }
 136
 137                 if (foundArtifact == null) {
 138                         foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.ARTIFACTS);
 139                 }
 140
 141                 if (foundArtifact == null) {
 142                         foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.SERVICE_API_ARTIFACTS);
 143                 }
 144
 145                 if (foundArtifact == null) {
 146                         result = Either.right(StorageOperationStatus.NOT_FOUND);
 147                         return result;
 148                 }
 149
 150                 ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(null, foundArtifact);
 151                 return Either.left(artifactDefResult);
 152
 153         }
 154
 155         public Either<ArtifactDefinition, StorageOperationStatus> removeArifactFromResource(String id, String artifactId, NodeTypeEnum type, boolean deleteMandatoryArtifact) {
 156                 Either<ArtifactDefinition, StorageOperationStatus> status = removeArtifactOnGraph(id, artifactId, type, deleteMandatoryArtifact);
 157
 158                 if (status.isRight()) {
 159
 160                         log.debug("Failed to delete artifact {} of resource {}", artifactId, id);
 161
 162                         BeEcompErrorManager.getInstance().logBeFailedDeleteNodeError("Delete Artifact", artifactId, String.valueOf(status.right().value()));
 163                         return Either.right(status.right().value());
 164                 } else {
 165
 166                         return Either.left(status.left().value());
 167                 }
 168         }
 169
 170         public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType, ArtifactGroupTypeEnum groupType, String instanceId) {
 171
 172                 Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(groupType, parentType);
 173                 EdgeLabelEnum edgeLabelEnum = triple.getLeft();
 174
 175                 Either<Map<String, ArtifactDefinition>, TitanOperationStatus> foundArtifact = null;
 176                 Map<String, ArtifactDefinition> resMap = new HashMap<>();
 177                 foundArtifact = getArtifactByLabel(parentId, instanceId, edgeLabelEnum);
 178                 if (foundArtifact.isRight()) {
 179                         log.debug("Failed to find artifact in component {} with label {} ", parentId, edgeLabelEnum);
 180                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(foundArtifact.right().value()));
 181                 }
 182
 183                 resMap.putAll(foundArtifact.left().value());
 184
 185                 return Either.left(resMap);
 186         }
 187
 188         /**
 189          * @param parentId   the id of the instance container
 190          * @param instanceId the id of the instance of which to return its artifacts
 191          * @return instance and instance deployment artifacts mapped by artifact label name
 192          */
 193         public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getAllInstanceArtifacts(String parentId, String instanceId) {
 194                 Map<String, ArtifactDataDefinition> resMap = new HashMap<>();
 195                 Either<Map<String, ArtifactDataDefinition>, TitanOperationStatus> instArtifacts = getInstanceArtifactsByLabel(parentId, instanceId, EdgeLabelEnum.INSTANCE_ARTIFACTS);
 196                 if (instArtifacts.isRight()) {
 197                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(instArtifacts.right().value()));
 198                 }
 199                 Either<Map<String, ArtifactDataDefinition>, TitanOperationStatus> deployInstArtifacts = getInstanceArtifactsByLabel(parentId, instanceId, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 200                 if (deployInstArtifacts.isRight()) {
 201                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deployInstArtifacts.right().value()));
 202                 }
 203                 resMap.putAll(instArtifacts.left().value());
 204                 resMap.putAll(deployInstArtifacts.left().value());
 205                 return Either.left(convertArtifactMapToArtifactDefinitionMap(resMap));
 206         }
 207
 208         public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifacts(String parentId) {
 209
 210                 Either<Map<String, ArtifactDefinition>, TitanOperationStatus> foundArtifact = null;
 211                 Map<String, ArtifactDefinition> resMap = new HashMap<>();
 212                 foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.ARTIFACTS);
 213                 if (foundArtifact.isLeft()) {
 214                         resMap.putAll(foundArtifact.left().value());
 215
 216                 }
 217                 foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 218                 if (foundArtifact.isLeft()) {
 219                         resMap.putAll(foundArtifact.left().value());
 220
 221                 }
 222                 foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.TOSCA_ARTIFACTS);
 223                 if (foundArtifact.isLeft()) {
 224                         resMap.putAll(foundArtifact.left().value());
 225
 226                 }
 227
 228                 return Either.left(resMap);
 229
 230         }
 231
 232         public Either<ArtifactDefinition, StorageOperationStatus> removeArtifactOnGraph(String id, String artifactId, NodeTypeEnum type, boolean deleteMandatoryArtifact) {
 233
 234                 Either<ArtifactDefinition, StorageOperationStatus> artifactData = this.getArtifactById(id, artifactId);
 235                 if (artifactData.isRight()) {
 236                         log.debug("Failed to find artifact in component {} with id {} ", id, artifactId);
 237                         return Either.right(artifactData.right().value());
 238                 }
 239                 ArtifactDataDefinition artifactDefinition = artifactData.left().value();
 240                 boolean isMandatory = false;
 241                 if ((artifactDefinition.getMandatory() || artifactDefinition.getServiceApi()) && !deleteMandatoryArtifact) {
 242                         // return Either.left(artifactData.left().value());
 243                         isMandatory = true;
 244                 }
 245
 246                 Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(artifactDefinition.getArtifactGroupType(), type);
 247                 EdgeLabelEnum edgeLabelEnum = triple.getLeft();
 248                 VertexTypeEnum vertexTypeEnum = triple.getRight();
 249
 250                 if (!isMandatory) {
 251                         StorageOperationStatus status = deleteToscaDataElement(id, edgeLabelEnum, vertexTypeEnum, artifactDefinition.getArtifactLabel(), JsonPresentationFields.ARTIFACT_LABEL);
 252                         if (status != StorageOperationStatus.OK)
 253                                 return Either.right(status);
 254                 }
 255
 256                 return Either.left(artifactData.left().value());
 257
 258         }
 259
 260         public void updateUUID(ArtifactDataDefinition artifactData, String oldChecksum, String oldVesrion, boolean isUpdate, EdgeLabelEnum edgeLabel) {
 261                 if (oldVesrion == null || oldVesrion.isEmpty())
 262                         oldVesrion = "0";
 263
 264                 String currentChecksum = artifactData.getArtifactChecksum();
 265
 266                 if (isUpdate) {
 267                         ArtifactTypeEnum type = ArtifactTypeEnum.findType(artifactData.getArtifactType());
 268                         switch (type) {
 269                                 case HEAT_ENV:
 270                                         if (edgeLabel == EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS) {
 271                                                 generateUUID(artifactData, oldVesrion);
 272                                         } else {
 273                                                 updateVersionAndDate(artifactData, oldVesrion);
 274                                         }
 275                                         break;
 276                                 case HEAT:
 277                                 case HEAT_NET:
 278                                 case HEAT_VOL:
 279                                         generateUUID(artifactData, oldVesrion);
 280                                         break;
 281                                 default:
 282                                         if (oldChecksum == null || oldChecksum.isEmpty()) {
 283                                                 if (currentChecksum != null) {
 284                                                         generateUUID(artifactData, oldVesrion);
 285                                                 }
 286                                         } else if ((currentChecksum != null && !currentChecksum.isEmpty()) && !oldChecksum.equals(currentChecksum)) {
 287                                                 generateUUID(artifactData, oldVesrion);
 288                                         }
 289                                         break;
 290                         }
 291                 } else {
 292                         if (oldChecksum == null || oldChecksum.isEmpty()) {
 293                                 if (currentChecksum != null) {
 294                                         generateUUID(artifactData, oldVesrion);
 295                                 }
 296                         } else if ((currentChecksum != null && !currentChecksum.isEmpty()) && !oldChecksum.equals(currentChecksum)) {
 297                                 generateUUID(artifactData, oldVesrion);
 298                         }
 299                 }
 300         }
 301
 302         // @TODO add implementation
 303
 304         public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType) {
 305                 return null;
 306         }
 307
 308         public Either<ArtifactDefinition, StorageOperationStatus> addHeatEnvArtifact(ArtifactDefinition artifactHeatEnv, ArtifactDefinition artifactHeat, String componentId, NodeTypeEnum parentType, boolean failIfExist, String instanceId) {
 309                 artifactHeatEnv.setGeneratedFromId(artifactHeat.getUniqueId());
 310                 return addArifactToComponent(artifactHeatEnv, componentId, parentType, failIfExist, instanceId);
 311         }
 312
 313         public Either<ArtifactDefinition, StorageOperationStatus> getHeatArtifactByHeatEnvId(String parentId, ArtifactDefinition heatEnv, NodeTypeEnum parentType, String containerId, ComponentTypeEnum componentType) {
 314                 String id = heatEnv.getGeneratedFromId();
 315                 ComponentTypeEnum compType;
 316                 switch (parentType) {
 317                         case ResourceInstance:
 318                                 compType = ComponentTypeEnum.RESOURCE_INSTANCE;
 319                                 break;
 320                         default:
 321                                 compType = componentType;
 322                 }
 323                 return getArtifactById(parentId, id, compType, containerId);
 324         }
 325
 326         public Either<ArtifactDefinition, StorageOperationStatus> updateHeatEnvArtifact(String id, ArtifactDefinition artifactEnvInfo, String artifactId, String newArtifactId, NodeTypeEnum type, String instanceId) {
 327
 328                 Either<Map<String, ArtifactDefinition>, TitanOperationStatus> artifactsEither = getArtifactByLabel(id, instanceId, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 329                 if (artifactsEither.isRight()) {
 330                         log.debug("Failed to find artifacts in component {} with id {} ", id, artifactsEither.right().value());
 331                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(artifactsEither.right().value()));
 332                 }
 333
 334                 Map<String, ArtifactDefinition> artifacts = artifactsEither.left().value();
 335                 List<ArtifactDefinition> envList = artifacts.values().stream().filter(a -> a.getGeneratedFromId() != null && a.getGeneratedFromId().equals(artifactId)).collect(Collectors.toList());
 336                 if (envList != null && !envList.isEmpty()) {
 337                         envList.forEach(a -> {
 338                                 a.setGeneratedFromId(newArtifactId);
 339                                 updateArifactOnResource(a, id, a.getUniqueId(), type, instanceId);
 340
 341                         });
 342
 343                 }
 344                 return Either.left(artifactEnvInfo);
 345         }
 346
 347         public Either<ArtifactDefinition, StorageOperationStatus> updateHeatEnvPlaceholder(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type) {
 348                 return updateArifactOnResource(artifactInfo, parentId, artifactInfo.getUniqueId(), type, null);
 349         }
 350
 351         // public Either<List<HeatParameterDefinition>, StorageOperationStatus> getHeatParamsForEnv(ArtifactDefinition heatEnvArtifact, String parentId) {
 352         // return null;
 353         // }
 354
 355         ///////////////////////////////////////////// private methods ////////////////////////////////////////////////////
 356
 357         protected ArtifactDefinition convertArtifactDataToArtifactDefinition(ArtifactDefinition artifactInfo, ArtifactDataDefinition artifactDefResult) {
 358                 log.debug("The object returned after create property is {}", artifactDefResult);
 359
 360                 ArtifactDefinition propertyDefResult = new ArtifactDefinition(artifactDefResult);
 361                 if (artifactInfo != null)
 362                         propertyDefResult.setPayload(artifactInfo.getPayloadData());
 363
 364                 List<HeatParameterDefinition> parameters = new ArrayList<HeatParameterDefinition>();
 365                 /*
 366                  * StorageOperationStatus heatParametersOfNode = heatParametersOperation.getHeatParametersOfNode(NodeTypeEnum.ArtifactRef, artifactDefResult.getUniqueId().toString(), parameters); if ((heatParametersOfNode.equals(StorageOperationStatus.OK))
 367                  * && !parameters.isEmpty()) { propertyDefResult.setHeatParameters(parameters); }
 368                  */
 369                 return propertyDefResult;
 370         }
 371
 372         private ArtifactDataDefinition getInstanceArtifactByLabelAndId(String parentId, String id, String containerId, EdgeLabelEnum edgeLabelEnum) {
 373                 ArtifactDataDefinition foundArtifact = null;
 374                 Either<Map<String, MapArtifactDataDefinition>, TitanOperationStatus> artifactsEither = getDataFromGraph(containerId, edgeLabelEnum);
 375                 if (artifactsEither.isRight()) {
 376                         log.debug("failed to fetch {} for tosca element with id {}, error {}", edgeLabelEnum, containerId, artifactsEither.right().value());
 377                         return null;
 378                 }
 379
 380                 Map<String, MapArtifactDataDefinition> artifacts = artifactsEither.left().value();
 381
 382                 MapArtifactDataDefinition artifactsPerInstance = artifacts.get(parentId);
 383                 if (artifactsPerInstance == null) {
 384                         log.debug("failed to fetch artifacts for instance {} in tosca element with id {}, error {}", parentId, containerId, artifactsEither.right().value());
 385                         return null;
 386                 }
 387                 Optional<ArtifactDataDefinition> op = artifactsPerInstance.getMapToscaDataDefinition().values().stream().filter(p -> p.getUniqueId().equals(id)).findAny();
 388                 if (op.isPresent()) {
 389                         foundArtifact = op.get();
 390                 }
 391                 return foundArtifact;
 392         }
 393
 394         private ArtifactDataDefinition getArtifactByLabelAndId(String parentId, String id, EdgeLabelEnum edgeLabelEnum) {
 395                 ArtifactDataDefinition foundArtifact = null;
 396                 Either<Map<String, ArtifactDataDefinition>, TitanOperationStatus> artifactsEither = getDataFromGraph(parentId, edgeLabelEnum);
 397                 if (artifactsEither.isRight()) {
 398                         log.debug("failed to fetch {} for tosca element with id {}, error {}", edgeLabelEnum, parentId, artifactsEither.right().value());
 399                         return null;
 400                 }
 401
 402                 Map<String, ArtifactDataDefinition> artifacts = artifactsEither.left().value();
 403                 Optional<ArtifactDataDefinition> op = artifacts.values().stream().filter(p -> p.getUniqueId().equals(id)).findAny();
 404                 if (op.isPresent()) {
 405                         foundArtifact = op.get();
 406                 }
 407                 return foundArtifact;
 408         }
 409
 410         private Either<Map<String, ArtifactDefinition>, TitanOperationStatus> getArtifactByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) {
 411                 Either<Map<String, ArtifactDataDefinition>, TitanOperationStatus> artifactsEither = getArtifactsDataByLabel(parentId, instanceId, edgeLabelEnum);
 412                 if (artifactsEither.isRight()) {
 413                         log.debug("failed to fetch {} for tosca element with id {}, error {}", edgeLabelEnum, parentId, artifactsEither.right().value());
 414                         return Either.right(artifactsEither.right().value());
 415                 }
 416                 Map<String, ArtifactDataDefinition> artifactDataMap = artifactsEither.left().value();
 417                 return Either.left(convertArtifactMapToArtifactDefinitionMap(artifactDataMap));
 418         }
 419
 420         private Either<Map<String, ArtifactDataDefinition>, TitanOperationStatus> getArtifactsDataByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) {
 421                 return edgeLabelEnum.isInstanceArtifactsLabel() ? getInstanceArtifactsByLabel(parentId, instanceId, edgeLabelEnum) : getDataFromGraph(parentId, edgeLabelEnum);
 422         }
 423
 424         private Map<String, ArtifactDefinition> convertArtifactMapToArtifactDefinitionMap(Map<String, ArtifactDataDefinition> artifactDataMap) {
 425                 Map<String, ArtifactDefinition> artMap = new HashMap<>();
 426                 if (artifactDataMap != null && !artifactDataMap.isEmpty()) {
 427                         artMap = artifactDataMap.entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> convertArtifactDataToArtifactDefinition(null, e.getValue())));
 428                 }
 429                 return artMap;
 430         }
 431
 432         private Either<Map<String, ArtifactDataDefinition>, TitanOperationStatus> getInstanceArtifactsByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) {
 433                 Either<Map<String, MapArtifactDataDefinition>, TitanOperationStatus> resultEither = getDataFromGraph(parentId, edgeLabelEnum);
 434                 if (resultEither.isRight()) {
 435                         log.debug("failed to fetch {} for tosca element with id {}, error {}", edgeLabelEnum, parentId, resultEither.right().value());
 436                         return Either.right(resultEither.right().value());
 437                 }
 438                 Map<String, MapArtifactDataDefinition> mapArtifacts = resultEither.left().value();
 439                 MapArtifactDataDefinition artifactPerInstance = mapArtifacts.get(instanceId);
 440                 return artifactPerInstance != null ? Either.left(artifactPerInstance.getMapToscaDataDefinition()) : Either.left(new HashMap<>());
 441         }
 442
 443         private Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> getEdgeLabelEnumFromArtifactGroupType(ArtifactGroupTypeEnum groupType, NodeTypeEnum nodeType) {
 444                 EdgeLabelEnum edgeLabelEnum;
 445                 VertexTypeEnum vertexTypeEnum;
 446                 Boolean isDeepElement = false;
 447                 /*
 448                  * if (nodeType == NodeTypeEnum.ResourceInstance) { edgeLabelEnum = EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS; vertexTypeEnum = VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS; isDeepElement = true; } else {
 449                  */
 450                 switch (groupType) {
 451                         case TOSCA:
 452                                 edgeLabelEnum = EdgeLabelEnum.TOSCA_ARTIFACTS;
 453                                 vertexTypeEnum = VertexTypeEnum.TOSCA_ARTIFACTS;
 454                                 break;
 455                         case DEPLOYMENT:
 456                                 if (nodeType == NodeTypeEnum.ResourceInstance) {
 457                                         edgeLabelEnum = EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS;
 458                                         vertexTypeEnum = VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS;
 459                                         isDeepElement = true;
 460                                 } else {
 461                                         edgeLabelEnum = EdgeLabelEnum.DEPLOYMENT_ARTIFACTS;
 462                                         vertexTypeEnum = VertexTypeEnum.DEPLOYMENT_ARTIFACTS;
 463                                 }
 464                                 break;
 465                         case SERVICE_API:
 466                                 edgeLabelEnum = EdgeLabelEnum.SERVICE_API_ARTIFACTS;
 467                                 vertexTypeEnum = VertexTypeEnum.SERVICE_API_ARTIFACTS;
 468                                 break;
 469                         default:
 470                                 if (nodeType == NodeTypeEnum.ResourceInstance) {
 471                                         edgeLabelEnum = EdgeLabelEnum.INSTANCE_ARTIFACTS;
 472                                         vertexTypeEnum = VertexTypeEnum.INSTANCE_ARTIFACTS;
 473                                         isDeepElement = true;
 474                                 } else {
 475                                         edgeLabelEnum = EdgeLabelEnum.ARTIFACTS;
 476                                         vertexTypeEnum = VertexTypeEnum.ARTIFACTS;
 477                                 }
 478                                 break;
 479                 }
 480                 // }
 481                 return new ImmutableTriple<EdgeLabelEnum, Boolean, VertexTypeEnum>(edgeLabelEnum, isDeepElement, vertexTypeEnum);
 482
 483         }
 484
 485         public Either<ArtifactDataDefinition, StorageOperationStatus> updateArtifactOnGraph(String componentId, ArtifactDefinition artifactInfo, NodeTypeEnum type, String artifactId, String instanceId, boolean isUpdate, boolean isDeletePlaceholder) {
 486                 Either<ArtifactDataDefinition, StorageOperationStatus> res = null;
 487                 ArtifactDataDefinition artifactToUpdate = new ArtifactDataDefinition(artifactInfo);
 488                 ArtifactGroupTypeEnum groupType = artifactInfo.getArtifactGroupType();
 489
 490                 Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(groupType, type);
 491                 EdgeLabelEnum edgeLabelEnum = triple.getLeft();
 492                 VertexTypeEnum vertexTypeEnum = triple.getRight();
 493
 494                 Either<Boolean, StorageOperationStatus> isNeedToCloneEither = isCloneNeeded(componentId, edgeLabelEnum);
 495                 if (isNeedToCloneEither.isRight()) {
 496                         log.debug("Failed check is clone needed {}", componentId);
 497                         return Either.right(isNeedToCloneEither.right().value());
 498
 499                 }
 500                 boolean isNeedToClone = isNeedToCloneEither.left().value();
 501
 502                 if (artifactId == null || isNeedToClone) {
 503                         String uniqueId;
 504                         if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) {
 505                                 uniqueId = UniqueIdBuilder.buildPropertyUniqueId(componentId, artifactToUpdate.getArtifactLabel());
 506                         } else {
 507                                 uniqueId = UniqueIdBuilder.buildInstanceArtifactUniqueId(componentId, instanceId, artifactToUpdate.getArtifactLabel());
 508                         }
 509                         artifactToUpdate.setUniqueId(uniqueId);
 510                         if (!isDeletePlaceholder)
 511                                 artifactToUpdate.setEsId(uniqueId);
 512                 } else
 513                         artifactToUpdate.setUniqueId(artifactId);
 514
 515                 Map<String, ArtifactDataDefinition> artifacts = new HashMap<>();
 516                 Map<String, MapArtifactDataDefinition> artifactInst = null;
 517                 if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) {
 518
 519                         Either<Map<String, ArtifactDataDefinition>, TitanOperationStatus> artifactsEither = this.getDataFromGraph(componentId, edgeLabelEnum);
 520
 521                         if (artifactsEither.isLeft() && artifactsEither.left().value() != null && !artifactsEither.left().value().isEmpty()) {
 522                                 artifacts = artifactsEither.left().value();
 523                                 if (isNeedToClone && artifacts != null) {
 524                                         artifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE));
 525                                 }
 526                         }
 527                 } else {
 528
 529                         Either<Map<String, MapArtifactDataDefinition>, TitanOperationStatus> artifactsEither = this.getDataFromGraph(componentId, edgeLabelEnum);
 530                         if (artifactsEither.isLeft()) {
 531                                 artifactInst = artifactsEither.left().value();
 532                                 if (isNeedToClone && artifactInst != null) {
 533                                         artifactInst.values().forEach(ma -> ma.getMapToscaDataDefinition().values().forEach(a -> a.setDuplicated(Boolean.TRUE)));
 534                                 }
 535                                 MapArtifactDataDefinition artifatcsOnInstance = artifactInst.get(instanceId);
 536                                 if (artifatcsOnInstance != null) {
 537                                         artifacts = artifatcsOnInstance.getMapToscaDataDefinition();
 538                                 }
 539                         }
 540                 }
 541                 String oldChecksum = null;
 542                 String oldVersion = null;
 543                 if (artifacts != null && artifacts.containsKey(artifactInfo.getArtifactLabel())) {
 544                         ArtifactDataDefinition oldArtifactData = artifacts.get(artifactInfo.getArtifactLabel());
 545                         oldChecksum = oldArtifactData.getArtifactChecksum();
 546                         oldVersion = oldArtifactData.getArtifactVersion();
 547                         //duplicated flag didn't receive from UI, take from DB
 548                         artifactToUpdate.setDuplicated(oldArtifactData.getDuplicated());
 549
 550                         if (isNeedToClone)
 551                                 artifactToUpdate.setDuplicated(Boolean.FALSE);
 552                         else {
 553                                 if (artifactToUpdate.getDuplicated()) {
 554                                         String uniqueId = "";
 555                                         if(type != NodeTypeEnum.ResourceInstance)
 556                                                 uniqueId = UniqueIdBuilder.buildPropertyUniqueId(componentId, artifactToUpdate.getArtifactLabel());
 557                                         else
 558                                                 uniqueId = UniqueIdBuilder.buildInstanceArtifactUniqueId(componentId, instanceId, artifactToUpdate.getArtifactLabel());
 559
 560                                         artifactToUpdate.setUniqueId(uniqueId);
 561                                         if (!isDeletePlaceholder)
 562                                                 artifactToUpdate.setEsId(uniqueId);
 563                                         artifactToUpdate.setDuplicated(Boolean.FALSE);
 564                                 }
 565                         }
 566                 }
 567                 updateUUID(artifactToUpdate, oldChecksum, oldVersion, isUpdate, edgeLabelEnum);
 568
 569                 if (artifactInfo.getPayloadData() == null) {
 570                         if (!artifactToUpdate.getMandatory() || artifactToUpdate.getEsId() != null) {
 571                                 artifactToUpdate.setEsId(artifactToUpdate.getUniqueId());
 572                         }
 573                 } else {
 574                         if (artifactToUpdate.getEsId() == null) {
 575                                 artifactToUpdate.setEsId(artifactToUpdate.getUniqueId());
 576                         }
 577                 }
 578
 579                 StorageOperationStatus status = StorageOperationStatus.OK;
 580                 if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) {
 581                         List<ArtifactDataDefinition> toscaDataList = new ArrayList<>();
 582                         toscaDataList.add(artifactToUpdate);
 583
 584                         if (isNeedToClone && artifacts != null) {
 585                                 artifacts.values().stream().filter(a -> !a.getArtifactLabel().equals(artifactToUpdate.getArtifactLabel())).forEach(a -> toscaDataList.add(a));
 586                         }
 587                         status = updateToscaDataOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataList, JsonPresentationFields.ARTIFACT_LABEL);
 588                 } else {
 589                         List<ArtifactDataDefinition> toscaDataList = new ArrayList<>();
 590                         toscaDataList.add(artifactToUpdate);
 591                         List<String> pathKeys = new ArrayList<>();
 592                         pathKeys.add(instanceId);
 593                         if (isNeedToClone) {
 594                                 MapArtifactDataDefinition artifatcsOnInstance = artifactInst.get(instanceId);
 595                                 if (artifatcsOnInstance != null) {
 596                                         artifacts = artifatcsOnInstance.getMapToscaDataDefinition();
 597                                         artifacts.put(artifactToUpdate.getArtifactLabel(), artifactToUpdate);
 598                                 }
 599
 600                                 for (Entry<String, MapArtifactDataDefinition> e : artifactInst.entrySet()) {
 601                                         List<ArtifactDataDefinition> toscaDataListPerInst = e.getValue().getMapToscaDataDefinition().values().stream().collect(Collectors.toList());
 602                                         List<String> pathKeysPerInst = new ArrayList<>();
 603                                         pathKeysPerInst.add(e.getKey());
 604                                         status = updateToscaDataDeepElementsOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataListPerInst, pathKeysPerInst, JsonPresentationFields.ARTIFACT_LABEL);
 605                                         if (status != StorageOperationStatus.OK) {
 606                                                 log.debug("Failed to update atifacts group for instance {} in component {} edge type {} error {}", instanceId, componentId, edgeLabelEnum, status);
 607                                                 res = Either.right(status);
 608                                                 break;
 609                                         }
 610                                 }
 611                         } else {
 612                                 status = updateToscaDataDeepElementsOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataList, pathKeys, JsonPresentationFields.ARTIFACT_LABEL);
 613                         }
 614                 }
 615                 if (status == StorageOperationStatus.OK)
 616                         res = Either.left(artifactToUpdate);
 617                 else
 618                         res = Either.right(status);
 619                 return res;
 620         }
 621
 622         public void generateUUID(ArtifactDataDefinition artifactData, String oldVesrion) {
 623
 624                 UUID uuid = UUID.randomUUID();
 625                 artifactData.setArtifactUUID(uuid.toString());
 626                 MDC.put("serviceInstanceID", uuid.toString());
 627                 updateVersionAndDate(artifactData, oldVesrion);
 628         }
 629
 630         private void updateVersionAndDate(ArtifactDataDefinition artifactData, String oldVesrion) {
 631                 if (artifactData.getArtifactChecksum() != null) {
 632                         long time = System.currentTimeMillis();
 633                         artifactData.setPayloadUpdateDate(time);
 634                 }
 635                 int newVersion = new Integer(oldVesrion).intValue();
 636                 newVersion++;
 637                 artifactData.setArtifactVersion(String.valueOf(newVersion));
 638         }
 639
 640         private boolean validateParentType(NodeTypeEnum type) {
 641                 boolean isValid = false;
 642                 switch (type) {
 643                         case Resource:
 644                         case InterfaceOperation:
 645                         case Service:
 646                         case ResourceInstance:
 647                                 isValid = true;
 648                                 break;
 649                         default:
 650                                 log.debug("Not supported node type for artifact relation : {} ", type);
 651                 }
 652                 return isValid;
 653         }
 654
 655         public Either<ArtifactDataDefinition, StorageOperationStatus> removeArtifactOnGraph(ArtifactDefinition artifactFromGraph, String componentId, String instanceId, NodeTypeEnum type, boolean deleteMandatoryArtifact) {
 656
 657                 Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(artifactFromGraph.getArtifactGroupType(), type);
 658                 EdgeLabelEnum edgeLabelEnum = triple.getLeft();
 659                 VertexTypeEnum vertexTypeEnum = triple.getRight();
 660
 661                 if (deleteMandatoryArtifact || !(artifactFromGraph.getMandatory() || artifactFromGraph.getServiceApi())) {
 662                         StorageOperationStatus status;
 663                         if (triple.getMiddle()) {
 664                                 List<String> pathKeys = new ArrayList<>();
 665                                 pathKeys.add(instanceId);
 666                                 status = deleteToscaDataDeepElement(componentId, edgeLabelEnum, vertexTypeEnum, artifactFromGraph.getArtifactLabel(), pathKeys, JsonPresentationFields.ARTIFACT_LABEL);
 667                         } else {
 668                                 status = deleteToscaDataElement(componentId, edgeLabelEnum, vertexTypeEnum, artifactFromGraph.getArtifactLabel(), JsonPresentationFields.ARTIFACT_LABEL);
 669                         }
 670                         if (status != StorageOperationStatus.OK)
 671                                 return Either.right(status);
 672                 }
 673                 return Either.left(artifactFromGraph);
 674
 675         }
 676
 677         public Either<ArtifactDataDefinition, StorageOperationStatus> deleteArtifactWithClonnigOnGraph(String componentId, ArtifactDefinition artifactToDelete, NodeTypeEnum type, String instanceId, boolean deleteMandatoryArtifact) {
 678
 679                 Either<ArtifactDataDefinition, StorageOperationStatus> result = null;
 680                 Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(artifactToDelete.getArtifactGroupType(), type);
 681                 EdgeLabelEnum edgeLabel = triple.getLeft();
 682                 VertexTypeEnum vertexLabel = triple.getRight();
 683
 684                 Boolean deleteElement = deleteMandatoryArtifact || !(artifactToDelete.getMandatory() || artifactToDelete.getServiceApi());
 685                 Map<String, ToscaDataDefinition> artifacts = null;
 686                 GraphVertex parentVertex = null;
 687                 Either<Map<String, ToscaDataDefinition>, TitanOperationStatus> getArtifactsRes = null;
 688
 689                 Either<GraphVertex, TitanOperationStatus> getToscaElementRes = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse);
 690                 if (getToscaElementRes.isRight()) {
 691                         CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get tosca element {} upon getting tosca data from graph. Status is {}. ", componentId, getToscaElementRes.right().value());
 692                         result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementRes.right().value()));
 693                 }
 694                 if (result == null) {
 695                         parentVertex = getToscaElementRes.left().value();
 696                         getArtifactsRes = this.getDataFromGraph(parentVertex, edgeLabel);
 697                         if (getArtifactsRes.isRight()) {
 698                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getArtifactsRes.right().value()));
 699                         }
 700                 }
 701                 if (result == null) {
 702                         artifacts = getArtifactsRes.left().value();
 703                         if (triple.getMiddle()) {
 704                                 artifacts.values().forEach(ma -> ((MapArtifactDataDefinition) ma).getMapToscaDataDefinition().values().forEach(a -> a.setDuplicated(Boolean.TRUE)));
 705                                 MapArtifactDataDefinition artifatcsOnInstance = (MapArtifactDataDefinition) artifacts.get(instanceId);
 706                                 if (artifatcsOnInstance != null && deleteElement) {
 707                                         artifatcsOnInstance.getMapToscaDataDefinition().remove(artifactToDelete.getArtifactLabel());
 708                                 }
 709                         } else {
 710                                 if (deleteElement) {
 711                                         artifacts.remove(artifactToDelete.getArtifactLabel());
 712                                 }
 713                                 artifacts.values().stream().forEach(a -> ((ArtifactDataDefinition) a).setDuplicated(Boolean.TRUE));
 714                         }
 715                         artifactToDelete.setDuplicated(Boolean.TRUE);
 716                 }
 717                 if (artifacts != null) {
 718                         TitanOperationStatus status = titanDao.deleteEdgeByDirection(parentVertex, Direction.OUT, edgeLabel);
 719                         if (status != TitanOperationStatus.OK) {
 720                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
 721                         } else if (MapUtils.isNotEmpty(artifacts)) {
 722                                 Either<GraphVertex, StorageOperationStatus> assosiateRes = assosiateElementToData(parentVertex, vertexLabel, edgeLabel, artifacts);
 723                                 if (assosiateRes.isRight()) {
 724                                         result = Either.right(result.right().value());
 725                                 }
 726                         }
 727                 }
 728                 if (result == null) {
 729                         result = Either.left(artifactToDelete);
 730                 }
 731                 return result;
 732         }
 733
 734 }