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

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