gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.asdctool.impl.migration.v1707.jsonmodel;
   2
   3 import com.thinkaurelius.titan.core.TitanVertex;
   4 import fj.data.Either;
   5 import org.apache.tinkerpop.gremlin.structure.Direction;
   6 import org.apache.tinkerpop.gremlin.structure.Edge;
   7 import org.apache.tinkerpop.gremlin.structure.Property;
   8 import org.apache.tinkerpop.gremlin.structure.Vertex;
   9 import org.openecomp.sdc.asdctool.impl.migration.MigrationMsg;
  10 import org.openecomp.sdc.asdctool.impl.migration.v1707.MigrationUtils;
  11 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  12 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  13 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  14 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  15 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  16 import org.openecomp.sdc.be.resources.data.UserData;
  17 import org.slf4j.Logger;
  18 import org.slf4j.LoggerFactory;
  19
  20 import javax.annotation.Resource;
  21 import java.util.ArrayList;
  22 import java.util.List;
  23 import java.util.stream.Collectors;
  24
  25 import static fj.data.List.list;
  26
  27 public class UserStatesMigration extends JsonModelMigration<Edge> {
  28
  29     private static final String MIGRATING_USER_ID = "jh0003";
  30     private static final int OUT_VERTEX_INDEX = 0;
  31     private static final int IN_VERTEX_INDEX = 1;
  32     private static Logger LOGGER = LoggerFactory.getLogger(UserStatesMigration.class);
  33
  34     @Resource(name = "titan-generic-dao")
  35     private TitanGenericDao genericDao;
  36
  37     @Resource(name = "titan-generic-dao-migration")
  38     private TitanGenericDao genericDaoMigration;
  39
  40     @Override
  41     public String description() {
  42         return "migrate user states";
  43     }
  44
  45
  46     @Override
  47     public boolean migrate() {
  48 //        return removeMigratingUserStates() && super.migrate();
  49         return super.migrate();
  50     }
  51
  52     @Override
  53     Either<List<Edge>, TitanOperationStatus> getElementsToMigrate() {
  54         LOGGER.debug("fetching user states edges from old graph");
  55         return genericDao.getAll(NodeTypeEnum.User, UserData.class)
  56                          .left().bind(this::getEdgesForUsers);
  57     }
  58
  59     @Override
  60     Either<Edge, TitanOperationStatus> getElementFromNewGraph(Edge edge) {
  61         LOGGER.debug("finding user state edge in new graph");
  62         Vertex outVertex = edge.outVertex();
  63         String outVertexUIDKey = getVertexUniqueId(outVertex);
  64         String outVertexUIDValue = outVertex.property(outVertexUIDKey).value().toString();
  65
  66         Vertex inVertex = edge.inVertex();
  67         String inVertexUIDKey = getVertexUniqueId(inVertex);
  68         String inVertexUIDValue = inVertex.property(inVertexUIDKey).value().toString();
  69
  70         return genericDaoMigration.getEdgeByVerticies(outVertexUIDKey, outVertexUIDValue, inVertexUIDKey, inVertexUIDValue, edge.label());
  71     }
  72
  73     @Override
  74     Either<Edge, TitanOperationStatus> save(Edge userState) {
  75         Either<InOutVertices, TitanOperationStatus> titanVertices = findEdgeInOutVerticesInNewGraph(userState);
  76         return titanVertices.left().bind(inOutVertices -> genericDaoMigration.copyEdge(inOutVertices.getOutVertex(), inOutVertices.getInVertex(), userState));
  77     }
  78
  79     @Override
  80     TitanOperationStatus getNotFoundErrorStatus() {
  81         return TitanOperationStatus.NOT_FOUND;
  82     }
  83
  84 //    private boolean removeMigratingUserStates() {
  85 //        Either<UserData, TitanOperationStatus> migratingUser = genericDaoMigration.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), MIGRATING_USER_ID, UserData.class);
  86 //        return migratingUser.either(user -> deleteAllEdges(user, Direction.OUT),
  87 //                                    errorStatus -> MigrationUtils.handleError(MigrationMsg.FAILED_TO_RETRIEVE_MIGRATION_USER.getMessage(MIGRATING_USER_ID, errorStatus.name())));
  88 //    }
  89
  90     private Either<List<Edge>, TitanOperationStatus> getEdgesForUsers(List<UserData> users) {
  91         List<Edge> edges = new ArrayList<>();
  92         for (UserData user : users) {
  93             Either<List<Edge>, TitanOperationStatus> edgesForNode = genericDao.getEdgesForNode(user, Direction.OUT);
  94             if (edgesForNode.isRight()) {
  95                 TitanOperationStatus errorStatus = edgesForNode.right().value();
  96                 LOGGER.error(MigrationMsg.FAILED_TO_RETRIEVE_USER_STATES.getMessage(user.getEmail(), errorStatus.name()));
  97                 return Either.right(errorStatus);
  98             }
  99             edges.addAll(edgesForNode.left().value());
 100         }
 101         return Either.left(ignoreProductEdges(edges));
 102     }
 103
 104     private List<Edge> ignoreProductEdges(List<Edge> edges) {
 105         return edges.stream().filter(edge -> !isInEdgeOfProductType(edge.inVertex())).collect(Collectors.toList());
 106     }
 107
 108     private boolean isInEdgeOfProductType(Vertex inVertex) {
 109         Property<Object> nodeLabelProperty = inVertex.property(GraphPropertiesDictionary.LABEL.getProperty());
 110         return nodeLabelProperty != null && nodeLabelProperty.value().equals(NodeTypeEnum.Product.getName());
 111     }
 112
 113     private String getVertexUniqueId(Vertex vertex) {
 114         String nodeLabel = vertex.property(GraphPropertiesDictionary.LABEL.getProperty()).value().toString();
 115         return UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.getByName(nodeLabel));
 116     }
 117
 118     private Either<InOutVertices, TitanOperationStatus> findEdgeInOutVerticesInNewGraph(Edge userEdge) {
 119         Either<TitanVertex, TitanOperationStatus> outVertex = getMigratedVertexByOldVertex(userEdge.outVertex());
 120         Either<TitanVertex, TitanOperationStatus> inVertex = getMigratedVertexByOldVertex(userEdge.inVertex());
 121         return Either.sequenceLeft(list(outVertex, inVertex)).left().map(InOutVertices::new);
 122     }
 123
 124     private Either<TitanVertex, TitanOperationStatus> getMigratedVertexByOldVertex(Vertex vertex) {
 125         String vertexUniqueId = getVertexUniqueId(vertex);
 126         LOGGER.debug(String.format("fetching vertex %s from new graph", vertexUniqueId));
 127         return genericDaoMigration.getVertexByProperty(vertexUniqueId, vertex.property(vertexUniqueId).value())
 128                                    .right().map(err -> MigrationUtils.handleError(err, String.format("could not find vertex %s in new graph.", vertexUniqueId)))  ;
 129     }
 130
 131 //    private boolean deleteAllEdges(UserData userData, Direction direction) {
 132 //        Either<List<Edge>, TitanOperationStatus> edgesForNode = genericDaoMigration.getEdgesForNode(userData, direction);
 133 //        if (edgesForNode.isRight()) {
 134 //            LOGGER.error(MigrationMsg.FAILED_TO_RETRIEVE_MIGRATION_USER_STATES.getMessage(MIGRATING_USER_ID, edgesForNode.right().value().name()));
 135 //            return false;
 136 //        }
 137 //        edgesForNode.left().value().forEach(Edge::remove);
 138 //        return true;
 139 //    }
 140
 141     private class InOutVertices {
 142         private TitanVertex outVertex;
 143         private TitanVertex inVertex;
 144
 145         InOutVertices(fj.data.List<TitanVertex> inOutVertices) {
 146             outVertex = inOutVertices.index(OUT_VERTEX_INDEX);
 147             inVertex = inOutVertices.index(IN_VERTEX_INDEX);
 148         }
 149
 150         TitanVertex getOutVertex() {
 151             return outVertex;
 152         }
 153
 154         TitanVertex getInVertex() {
 155             return inVertex;
 156         }
 157     }
 158
 159 }