gerrit.onap Code Review - sdc.git/blob

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