gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.asdctool.impl.migration.v1707.jsonmodel;
   2
   3 import fj.data.Either;
   4 import org.apache.tinkerpop.gremlin.structure.Edge;
   5 import org.openecomp.sdc.asdctool.impl.migration.MigrationMsg;
   6 import org.openecomp.sdc.asdctool.impl.migration.v1707.MigrationUtils;
   7 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
   8 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
   9 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  10 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  11 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  12 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  13 import org.openecomp.sdc.be.model.Component;
  14 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  15 import org.slf4j.Logger;
  16 import org.slf4j.LoggerFactory;
  17
  18 import javax.annotation.Resource;
  19 import java.util.Collections;
  20 import java.util.HashMap;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.stream.Collectors;
  24
  25 public abstract class VersionMigration<T extends Component>  {
  26
  27     private static Logger LOGGER = LoggerFactory.getLogger(VersionMigration.class);
  28
  29     @Resource(name = "titan-generic-dao-migration")
  30     private TitanGenericDao titanGenericDaoMigration;
  31
  32     @Resource(name = "titan-dao")
  33     private TitanDao titanDao;
  34
  35     public boolean buildComponentsVersionChain(List<T> components) {
  36         Map<String, List<T>> componentsByInvariant = components.stream().filter(c -> c.getInvariantUUID() != null).collect(Collectors.groupingBy(Component::getInvariantUUID));
  37         for (List<T> componentsList : componentsByInvariant.values()) {
  38             boolean versionChainBuilt = buildVersionChainForInvariant(componentsList);
  39             if (!versionChainBuilt) {
  40                 titanDao.rollback();
  41                 return false;
  42             }
  43             titanDao.commit();
  44         }
  45         return true;
  46     }
  47
  48     private boolean buildVersionChainForInvariant(List<T> components) {
  49         sortComponentsByVersion(components);
  50         for (int i = 0; i < components.size() -1; i++) {
  51             String lowerVersionUid = components.get(i).getUniqueId();
  52             String higherVersionUid = components.get(i + 1).getUniqueId();
  53             boolean versionCreated = createVersionRelationIfNotExist(lowerVersionUid, higherVersionUid);
  54             if (!versionCreated) {
  55                 return false;
  56             }
  57         }
  58         return true;
  59     }
  60
  61     private void sortComponentsByVersion(List<T> components) {
  62         Collections.sort(components, (o1, o2) -> Double.valueOf(o1.getVersion()).compareTo(Double.valueOf(o2.getVersion())));
  63     }
  64
  65     private boolean createVersionRelationIfNotExist(String fromUid, String toUid) {
  66         Either<Boolean, TitanOperationStatus> isVersionExists = isVersionExists(fromUid, toUid);
  67         return isVersionExists.either(versionExists -> versionExists || createVersionRelation(fromUid, toUid),
  68                                errorStatus -> MigrationUtils.handleError(MigrationMsg.FAILED_TO_RETRIEVE_VERSION_RELATION.getMessage(fromUid, toUid, isVersionExists.right().value().name())));
  69     }
  70
  71     private boolean createVersionRelation(String fromUid, String toUid) {
  72         LOGGER.debug(String.format("creating version edge between vertex %s and vertex %s", fromUid, toUid));
  73         Either<GraphVertex, TitanOperationStatus> fromVertex = titanDao.getVertexById(fromUid);
  74         Either<GraphVertex, TitanOperationStatus> toVertex = titanDao.getVertexById(toUid);
  75         if (toVertex.isLeft() && fromVertex.isLeft()) {
  76             TitanOperationStatus versionCreated = titanDao.createEdge(fromVertex.left().value(), toVertex.left().value(), EdgeLabelEnum.VERSION, new HashMap<>());
  77             return versionCreated == TitanOperationStatus.OK;
  78         }
  79         return MigrationUtils.handleError(String.format("could not create version edge between vertex %s and vertex %s.", fromUid, toUid));
  80     }
  81
  82     private Either<Boolean, TitanOperationStatus> isVersionExists(String fromUid, String toUid) {
  83         LOGGER.debug(String.format("checking if version edge between vertex %s and vertex %s already exist", fromUid, toUid));
  84         String uidKey = UniqueIdBuilder.getKeyByNodeType(getNodeTypeEnum());
  85         Either<Edge, TitanOperationStatus> edgeByVertices = titanGenericDaoMigration.getEdgeByVerticies(uidKey, fromUid, uidKey, toUid, EdgeLabelEnum.VERSION.name());
  86         if (isNotFoundStatus(edgeByVertices)) {
  87             return Either.left(false);
  88         }
  89         return edgeByVertices.bimap(foundEdge -> true,
  90                                     error -> error);
  91     }
  92
  93     private boolean isNotFoundStatus(Either<Edge, TitanOperationStatus> edgeByVertices) {
  94         return edgeByVertices.isRight() && edgeByVertices.right().value() == TitanOperationStatus.NOT_FOUND;
  95     }
  96
  97     abstract NodeTypeEnum getNodeTypeEnum();
  98 }