asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/internal/tool/DeleteComponentHandler.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.openecomp.sdc.asdctool.impl.internal.tool;
  21
  22 import org.janusgraph.core.JanusGraphVertex;
  23 import fj.data.Either;
  24 import org.apache.tinkerpop.gremlin.structure.Direction;
  25 import org.apache.tinkerpop.gremlin.structure.Edge;
  26 import org.apache.tinkerpop.gremlin.structure.Vertex;
  27 import org.openecomp.sdc.asdctool.utils.ConsoleWriter;
  28 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  29 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  30 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  31 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  32 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  33 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  34 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTypeOperation;
  35 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.TopologyTemplateOperation;
  36 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaElementOperation;
  37 import org.openecomp.sdc.common.log.wrappers.Logger;
  38 import org.springframework.beans.factory.annotation.Autowired;
  39 import org.springframework.stereotype.Component;
  40
  41 import java.io.IOException;
  42 import java.util.Iterator;
  43 import java.util.Map;
  44 import java.util.Scanner;
  45
  46 @Component("deleteComponentHandler")
  47 public class DeleteComponentHandler extends CommonInternalTool{
  48     @Autowired
  49     private JanusGraphDao janusGraphDao;
  50     @Autowired
  51     private NodeTypeOperation nodeTypeOperation;
  52     @Autowired
  53     private TopologyTemplateOperation topologyTemplateOperation;
  54
  55
  56     private static Logger log = Logger.getLogger(DeleteComponentHandler.class.getName());
  57
  58
  59     public DeleteComponentHandler(){
  60         super("delete");
  61     }
  62     public void deleteComponent(String id, Scanner scanner) {
  63         JanusGraphOperationStatus status = JanusGraphOperationStatus.OK;
  64         GraphVertex metadataVertex = janusGraphDao.getVertexById(id).either(l -> l, r -> null);
  65         if (metadataVertex != null) {
  66             status = handleComponent(scanner, metadataVertex);
  67         } else {
  68             ConsoleWriter.dataLine("No vertex for id", id);
  69         }
  70         if (status == JanusGraphOperationStatus.OK) {
  71             janusGraphDao.commit();
  72         } else {
  73             janusGraphDao.rollback();
  74         }
  75     }
  76
  77     private JanusGraphOperationStatus handleComponent(Scanner scanner, GraphVertex metadataVertex) {
  78         Map<GraphPropertyEnum, Object> metadataProperties = metadataVertex.getMetadataProperties();
  79         JanusGraphOperationStatus status = JanusGraphOperationStatus.OK;
  80         printComponentInfo(metadataProperties);
  81
  82         Iterator<Edge> edges = metadataVertex.getVertex().edges(Direction.OUT, EdgeLabelEnum.VERSION.name());
  83         if (edges != null && edges.hasNext()) {
  84             ConsoleWriter.dataLine("\ncomponent is not latest version and cannot be deleted");
  85         } else {
  86             ConsoleWriter.dataLine("\ncomponent is latest .");
  87             if (isReferenceExist(metadataVertex)) {
  88                 ConsoleWriter.dataLine("\nExist reference on component ( istance, proxy or allotted). Component cannot be deleted");
  89             } else {
  90                 ConsoleWriter.dataLine("\nNo references. Try to delete (yes/no)?");
  91                 String input = scanner.nextLine();
  92                 if (input.equalsIgnoreCase("yes")) {
  93                     status = handleComponent(metadataVertex);
  94                 }
  95             }
  96         }
  97         return status;
  98     }
  99
 100     private JanusGraphOperationStatus handleComponent(GraphVertex metadataVertex) {
 101         ToscaElementOperation toscaElementOperation = getOperationByLabel(metadataVertex);
 102         Iterator<Edge> edges = metadataVertex.getVertex().edges(Direction.IN, EdgeLabelEnum.VERSION.name());
 103         if (edges != null && edges.hasNext()) {
 104             JanusGraphOperationStatus status = updatePreviousVersion(metadataVertex, edges);
 105             if ( status != JanusGraphOperationStatus.OK ){
 106                 return status;
 107             }
 108         }
 109         toscaElementOperation.deleteToscaElement(metadataVertex)
 110              .left()
 111              .map(l -> {
 112                  ConsoleWriter.dataLine("\nDeleted");
 113                  report(metadataVertex);
 114                  return JanusGraphOperationStatus.OK;
 115              })
 116              .right()
 117              .map(r-> {
 118                  ConsoleWriter.dataLine("\nFailed to delete. see log file");
 119                  return r;
 120              });
 121         return JanusGraphOperationStatus.OK;
 122     }
 123
 124     private JanusGraphOperationStatus updatePreviousVersion(GraphVertex metadataVertex, Iterator<Edge> edges) {
 125         Edge edge = edges.next();
 126         JanusGraphVertex prevVersionVertex = (JanusGraphVertex) edge.outVertex();
 127         // check if previous version is deleted
 128         Boolean isDeleted = (Boolean) janusGraphDao.getProperty(prevVersionVertex, GraphPropertyEnum.IS_DELETED.getProperty());
 129         if (isDeleted != null && isDeleted) {
 130             ConsoleWriter.dataLine("\nPrevoius version is marked as deleted. Component cannot be deleted");
 131             return JanusGraphOperationStatus.GENERAL_ERROR;
 132         }
 133         // update highest property for previous version
 134         JanusGraphOperationStatus status = updateStateOfPreviuosVersion(prevVersionVertex);
 135         if ( JanusGraphOperationStatus.OK != status ){
 136             return status;
 137         }
 138
 139         // connect to catalog or archive
 140         return connectToCatalogAndArchive(metadataVertex, prevVersionVertex);
 141     }
 142
 143     private JanusGraphOperationStatus updateStateOfPreviuosVersion(JanusGraphVertex prevVersionVertex) {
 144         String prevId = (String) janusGraphDao.getProperty(prevVersionVertex, GraphPropertyEnum.UNIQUE_ID.getProperty());
 145         Either<GraphVertex, JanusGraphOperationStatus> prevGraphVertex = janusGraphDao.getVertexById(prevId);
 146         GraphVertex prevVertex = prevGraphVertex.left().value();
 147         prevVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 148         janusGraphDao.updateVertex(prevVertex);
 149
 150         Iterator<Edge> edgesIter = prevVersionVertex.edges(Direction.IN, EdgeLabelEnum.LAST_STATE.name());
 151         if ( edgesIter.hasNext() ) {
 152             Edge lastStateEdge = edgesIter.next();
 153             Vertex lastModifier = lastStateEdge.outVertex();
 154             JanusGraphOperationStatus
 155                 replaceRes = janusGraphDao
 156                 .replaceEdgeLabel(lastModifier, prevVersionVertex, lastStateEdge, EdgeLabelEnum.LAST_STATE, EdgeLabelEnum.STATE);
 157             if (replaceRes != JanusGraphOperationStatus.OK) {
 158                 log.info("Failed to replace label from {} to {}. status = {}", EdgeLabelEnum.LAST_STATE, EdgeLabelEnum.STATE, replaceRes);
 159                 ConsoleWriter.dataLine("\nFailed to replace LAST_STATE edge . Failed to delete");
 160                 return JanusGraphOperationStatus.GENERAL_ERROR;
 161             }
 162         }
 163         return JanusGraphOperationStatus.OK;
 164     }
 165
 166
 167     private JanusGraphOperationStatus connectToCatalogAndArchive(GraphVertex metadataVertex, JanusGraphVertex prevVersionVertex) {
 168
 169         JanusGraphOperationStatus
 170             status = connectByLabel(metadataVertex, prevVersionVertex, EdgeLabelEnum.CATALOG_ELEMENT, VertexTypeEnum.CATALOG_ROOT);
 171         if ( status == JanusGraphOperationStatus.OK ){
 172             status = connectByLabel(metadataVertex, prevVersionVertex, EdgeLabelEnum.ARCHIVE_ELEMENT, VertexTypeEnum.ARCHIVE_ROOT);
 173         }
 174         return status;
 175     }
 176
 177     private JanusGraphOperationStatus connectByLabel(GraphVertex metadataVertex, JanusGraphVertex prevVersionVertex, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexlabel) {
 178         Iterator<Edge> edgesToCatalog = metadataVertex.getVertex().edges(Direction.IN, edgeLabel.name());
 179         if ( edgesToCatalog != null && edgesToCatalog.hasNext() ){
 180             //exist edge move to prev version
 181             Either<GraphVertex, JanusGraphOperationStatus> catalog = janusGraphDao.getVertexByLabel(vertexlabel);
 182             if (catalog.isRight()) {
 183                 log.debug("Failed to fetch {} vertex, error {}", vertexlabel, catalog.right().value());
 184                 return catalog.right().value();
 185             }
 186             GraphVertex catalogV = catalog.left().value();
 187             Edge edge = edgesToCatalog.next();
 188             return janusGraphDao.createEdge(catalogV.getVertex(), prevVersionVertex, edgeLabel, edge );
 189         }
 190         return JanusGraphOperationStatus.OK;
 191     }
 192
 193     private boolean isReferenceExist(GraphVertex metadataVertex) {
 194         return existEdgeByLabel(metadataVertex, EdgeLabelEnum.INSTANCE_OF) || existEdgeByLabel(metadataVertex, EdgeLabelEnum.PROXY_OF) || existEdgeByLabel(metadataVertex, EdgeLabelEnum.ALLOTTED_OF);
 195     }
 196
 197     private boolean existEdgeByLabel(GraphVertex metadataVertex, EdgeLabelEnum label) {
 198         Iterator<Edge> edges = metadataVertex.getVertex().edges(Direction.IN, label.name());
 199         return (edges != null && edges.hasNext());
 200     }
 201
 202     private ToscaElementOperation getOperationByLabel(GraphVertex metadataVertex) {
 203         VertexTypeEnum label = metadataVertex.getLabel();
 204         if (label == VertexTypeEnum.NODE_TYPE) {
 205             return nodeTypeOperation;
 206         } else {
 207             return topologyTemplateOperation;
 208         }
 209     }
 210
 211     private void report(GraphVertex metadataVertex) {
 212         try {
 213             getReportWriter().report(metadataVertex.getMetadataProperties());
 214         } catch (IOException e) {
 215             ConsoleWriter.dataLine("\nFailed to created report file.");
 216         }
 217     }
 218
 219
 220
 221
 222 }