gerrit.onap Code Review - sdc.git/blob

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