asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/validator/executers/ArtifactValidatorExecuter.java

   1 package org.openecomp.sdc.asdctool.impl.validator.executers;
   2
   3 import java.io.BufferedWriter;
   4 import java.io.FileOutputStream;
   5 import java.io.IOException;
   6 import java.io.OutputStreamWriter;
   7 import java.io.Writer;
   8 import java.util.ArrayList;
   9 import java.util.Collection;
  10 import java.util.HashMap;
  11 import java.util.HashSet;
  12 import java.util.List;
  13 import java.util.Map;
  14 import java.util.Optional;
  15 import java.util.Set;
  16 import java.util.stream.Collectors;
  17
  18 import org.openecomp.sdc.asdctool.impl.validator.config.ValidationConfigManager;
  19 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  20 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  21 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  22 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  23 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  24 import org.openecomp.sdc.be.model.ArtifactDefinition;
  25 import org.openecomp.sdc.be.model.Component;
  26 import org.openecomp.sdc.be.model.ComponentParametersView;
  27 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  28 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  29 import org.slf4j.Logger;
  30 import org.slf4j.LoggerFactory;
  31 import org.springframework.beans.factory.annotation.Autowired;
  32
  33 import fj.data.Either;
  34
  35 public class ArtifactValidatorExecuter {
  36
  37     @Autowired
  38     protected TitanDao titanDao;
  39
  40     @Autowired
  41     private ToscaOperationFacade toscaOperationFacade;
  42     private static Logger log = LoggerFactory.getLogger(ArtifactValidatorExecuter.class.getName());
  43
  44     protected String name;
  45
  46     public void setName(String name) {
  47         this.name = name;
  48     }
  49
  50     public String getName() {
  51         return name;
  52     }
  53
  54     public Map<String, List<Component>> getVerticesToValidate(VertexTypeEnum type,
  55                                                               Map<GraphPropertyEnum, Object> hasProps) {
  56
  57         Map<String, List<Component>> result = new HashMap<>();
  58         Either<List<GraphVertex>, TitanOperationStatus> resultsEither = titanDao.getByCriteria(type, hasProps);
  59         if (resultsEither.isRight()) {
  60             System.out.println("getVerticesToValidate failed " + resultsEither.right().value());
  61             return result;
  62         }
  63         System.out.println("getVerticesToValidate: " + resultsEither.left().value().size() + " vertices to scan");
  64         List<GraphVertex> componentsList = resultsEither.left().value();
  65         componentsList.forEach(vertex -> {
  66             String ivariantUuid = (String)vertex.getMetadataProperty(GraphPropertyEnum.INVARIANT_UUID);
  67             if (!result.containsKey(ivariantUuid)) {
  68                 result.put(ivariantUuid, new ArrayList<>());
  69             }
  70             List<Component> compList = result.get(ivariantUuid);
  71
  72             ComponentParametersView filter = new ComponentParametersView(true);
  73             filter.setIgnoreArtifacts(false);
  74
  75             Either<Component, StorageOperationStatus> toscaElement
  76                 = toscaOperationFacade.getToscaElement(vertex.getUniqueId(), filter);
  77             if (toscaElement.isRight()) {
  78                 System.out.println("getVerticesToValidate: failed to find element"
  79                     + vertex.getUniqueId() + " staus is" + toscaElement.right().value());
  80             } else {
  81                 compList.add(toscaElement.left().value());
  82             }
  83         });
  84         return result;
  85     }
  86
  87     public boolean validate(Map<String, List<Component>> vertices) {
  88         boolean result = true;
  89         long time = System.currentTimeMillis();
  90         String fileName = ValidationConfigManager.getOutputFilePath() + this.getName() + "_" + time + ".csv";
  91
  92         try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName), "utf-8"))) {
  93             writer.write("name, UUID, invariantUUID, state, version\n");
  94             Collection<List<Component>> collection = vertices.values();
  95             for (List<Component> compList: collection) {
  96                 Set<String> artifactEsId = new HashSet<>();
  97                 for (Component component: compList) {
  98                     Map<String, ArtifactDefinition> toscaArtifacts = component.getToscaArtifacts();
  99                     Optional<ArtifactDefinition> op = toscaArtifacts.values()
 100                         .stream().filter(a -> artifactEsId.contains(a.getEsId())).findAny();
 101                     if (op.isPresent()) {
 102                         result = false;
 103                         writeModuleResultToFile(writer, compList);
 104                         writer.flush();
 105                         break;
 106                     } else {
 107                         artifactEsId.addAll(toscaArtifacts.values()
 108                             .stream().map(ArtifactDefinition::getEsId).collect(Collectors.toList()));
 109                     }
 110                 }
 111             }
 112         } catch (Exception e) {
 113             log.info("Failed to fetch vf resources ", e);
 114             return false;
 115         } finally {
 116             titanDao.commit();
 117         }
 118         return result;
 119     }
 120
 121     private void writeModuleResultToFile(Writer writer, List<Component> components) {
 122         try {
 123             // "service name, service id, state, version
 124             for (Component component: components ) {
 125                 StringBuilder sb = new StringBuilder(component.getName());
 126                 sb.append(",").append(component.getUniqueId())
 127                     .append(",").append(component.getInvariantUUID())
 128                     .append(",").append(component.getLifecycleState())
 129                     .append(",").append(component.getVersion())
 130                     .append("\n");
 131
 132                 writer.write(sb.toString());
 133             }
 134         } catch (IOException e) {
 135             log.debug("Cannot write module result to file", e);
 136         }
 137     }
 138 }