asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1707/DistributionStatusUpdate.java

   1 package org.openecomp.sdc.asdctool.impl.migration.v1707;
   2
   3 import java.util.EnumMap;
   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.stream.Collectors;
   9
  10 import org.apache.commons.collections.MapUtils;
  11 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  12 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  13 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  14 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  15 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  16 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  17 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  18 import org.openecomp.sdc.be.model.ComponentParametersView;
  19 import org.openecomp.sdc.be.model.DistributionStatusEnum;
  20 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  21 import org.openecomp.sdc.be.model.Service;
  22 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  23 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  24 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27 import org.springframework.beans.factory.annotation.Autowired;
  28 import org.springframework.stereotype.Component;
  29
  30 import fj.data.Either;
  31
  32 @Component("distributionStatusUpdate")
  33 public class DistributionStatusUpdate {
  34         private static Logger LOGGER = LoggerFactory.getLogger(DistributionStatusUpdate.class);
  35
  36         @Autowired
  37     private ToscaOperationFacade toscaOperationFacade;
  38         @Autowired
  39     private TitanDao titanDao;
  40
  41
  42         public boolean migrate() {
  43                 boolean result = true;
  44                 Either<Map<GraphVertex, org.openecomp.sdc.be.model.Service>, StorageOperationStatus> getAllServiceComponentsRes = getAllServiceComponents();
  45                 if(getAllServiceComponentsRes.isRight()){
  46                         result = false;
  47                 }
  48                 if(result && MapUtils.isNotEmpty(getAllServiceComponentsRes.left().value())){
  49                         updateDistributionStatusFromMetadata(getAllServiceComponentsRes.left().value());
  50                         updateDistributionStatusToNotDistributed(getAllServiceComponentsRes.left().value());
  51                 }
  52
  53                 toscaOperationFacade.commit();
  54
  55                 return result;
  56         }
  57
  58
  59         private void updateDistributionStatusToNotDistributed(Map<GraphVertex, org.openecomp.sdc.be.model.Service> components) {
  60
  61                 Map<GraphVertex, org.openecomp.sdc.be.model.Service> filteredComponents = components.entrySet()
  62                                 .stream()
  63                                 .filter(e -> e.getValue().getLifecycleState() != LifecycleStateEnum.CERTIFIED)
  64                                 .collect(Collectors.toMap(e -> e.getKey(), e -> (Service)e.getValue()));
  65
  66                 Service service;
  67                 Either<GraphVertex, TitanOperationStatus> updateResponse;
  68                 GraphVertex metadataV;
  69
  70                 for(Entry<GraphVertex, Service> currComponent : filteredComponents.entrySet()){
  71                         metadataV = currComponent.getKey();
  72                         service = currComponent.getValue();
  73                         try {
  74                                 metadataV.addMetadataProperty(GraphPropertyEnum.DISTRIBUTION_STATUS, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
  75                                 updateResponse = titanDao.updateVertex(metadataV);
  76
  77                                 if (updateResponse.isRight()) {
  78                                         LOGGER.debug("failed to updateDistributionStatusToNotDistributed service  {} error {}", service.getUniqueId(), updateResponse.right().value());
  79                                 }
  80
  81                         } catch (Exception e) {
  82                                 LOGGER.debug("failed to updateDistributionStatusToNotDistributed service  {} error {}", service.getUniqueId(), e.toString());
  83                         }
  84                 }
  85         }
  86
  87         private void updateDistributionStatusFromMetadata(Map<GraphVertex, org.openecomp.sdc.be.model.Service> components) {
  88                 Service service;
  89                 String statusFromMetadata;
  90                 Either<GraphVertex, TitanOperationStatus> updateResponse;
  91                 GraphVertex metadataV;
  92
  93                 for(Entry<GraphVertex, Service> currComponent : components.entrySet()){
  94                         metadataV = currComponent.getKey();
  95                         service = currComponent.getValue();
  96                         try {
  97                                 statusFromMetadata = (String) metadataV.getJsonMetadataField(JsonPresentationFields.DISTRIBUTION_STATUS);
  98                                 metadataV.addMetadataProperty(GraphPropertyEnum.DISTRIBUTION_STATUS, statusFromMetadata);
  99                                 updateResponse = titanDao.updateVertex(metadataV);
 100
 101                                 if (updateResponse.isRight()) {
 102                                         LOGGER.debug("failed to updateDistributionStatusFromMetadata service  {} error {}", service.getUniqueId(), updateResponse.right().value());
 103                                 }
 104
 105                         } catch (Exception e) {
 106                                 LOGGER.debug("failed to read distribution status of service {} error {}", service.getUniqueId(), e.toString());
 107                         }
 108
 109                 }
 110         }
 111
 112
 113         public Either<Map<GraphVertex, org.openecomp.sdc.be.model.Service>, StorageOperationStatus> getAllServiceComponents() {
 114
 115                 Map<GraphVertex, org.openecomp.sdc.be.model.Service> components = new HashMap<>();
 116                 Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 117                 Map<GraphPropertyEnum, Object> propertiesNotMatch = new EnumMap<>(GraphPropertyEnum.class);
 118                 propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 119                 propertiesNotMatch.put(GraphPropertyEnum.IS_DELETED, true);
 120                 Either<List<GraphVertex>, TitanOperationStatus> getVerticiesRes = toscaOperationFacade.getTitanDao().getByCriteria(null, propertiesToMatch, propertiesNotMatch, JsonParseFlagEnum.ParseAll);
 121
 122                 if (getVerticiesRes.isRight() && getVerticiesRes.right().value() != TitanOperationStatus.NOT_FOUND) {
 123                         LOGGER.debug("Failed to fetch all service components. Status is {}", getVerticiesRes.right().value());
 124                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticiesRes.right().value()));
 125                 }
 126                 if(getVerticiesRes.isLeft()){
 127                         List<GraphVertex> componentVerticies = getVerticiesRes.left().value();
 128                         for (GraphVertex componentV : componentVerticies) {
 129                                 ComponentParametersView filters = new ComponentParametersView(true);
 130                                 Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> getComponentsRes = toscaOperationFacade.getToscaElement(componentV.getUniqueId(), filters);
 131                                 if (getComponentsRes.isRight()) {
 132                                         return Either.right(getComponentsRes.right().value());
 133                                 }
 134                                 components.put(componentV, (Service) getComponentsRes.left().value());
 135                         }
 136                 }
 137                 return Either.left(components);
 138         }
 139
 140 }