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