ui/src/main/java/org/akraino/validation/ui/service/IntegratedResultService.java

   1 /*
   2  * Copyright (c) 2019 AT&T Intellectual Property. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License"); you may
   5  * not use this file except in compliance with the License. You may obtain
   6  * a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  13  * implied. See the License for the specific language governing
  14  * permissions and limitations under the License.
  15  */
  16 package org.akraino.validation.ui.service;
  17
  18 import java.io.IOException;
  19 import java.security.KeyManagementException;
  20 import java.security.NoSuchAlgorithmException;
  21 import java.text.DateFormat;
  22 import java.text.ParseException;
  23 import java.text.SimpleDateFormat;
  24 import java.util.ArrayList;
  25 import java.util.Collections;
  26 import java.util.Comparator;
  27 import java.util.Date;
  28 import java.util.HashSet;
  29 import java.util.List;
  30 import java.util.Locale;
  31 import java.util.Set;
  32
  33 import javax.annotation.Nonnull;
  34
  35 import org.akraino.validation.ui.client.nexus.NexusExecutorClient;
  36 import org.akraino.validation.ui.client.nexus.resources.ValidationNexusTestResult;
  37 import org.akraino.validation.ui.data.BlueprintLayer;
  38 import org.akraino.validation.ui.data.Lab;
  39 import org.akraino.validation.ui.data.SubmissionData;
  40 import org.akraino.validation.ui.entity.LabInfo;
  41 import org.akraino.validation.ui.entity.LabSilo;
  42 import org.akraino.validation.ui.entity.ValidationDbTestResult;
  43 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
  44 import org.onap.portalsdk.core.web.support.UserUtils;
  45 import org.springframework.beans.factory.annotation.Autowired;
  46 import org.springframework.stereotype.Service;
  47 import org.springframework.transaction.annotation.Transactional;
  48
  49 import com.fasterxml.jackson.core.JsonParseException;
  50 import com.fasterxml.jackson.databind.JsonMappingException;
  51 import com.sun.jersey.api.client.ClientHandlerException;
  52 import com.sun.jersey.api.client.UniformInterfaceException;
  53
  54 @Service
  55 @Transactional
  56 public class IntegratedResultService {
  57
  58     private static final EELFLoggerDelegate LOGGER = EELFLoggerDelegate.getLogger(IntegratedResultService.class);
  59
  60     @Autowired
  61     private DbSubmissionAdapter submissionService;
  62
  63     @Autowired
  64     private SiloService siloService;
  65
  66     @Autowired
  67     NexusExecutorClient nexusService;
  68
  69     @Autowired
  70     LabService labService;
  71
  72     @Autowired
  73     DbResultAdapter dbAdapter;
  74
  75     public List<Lab> getLabsFromNexus()
  76             throws JsonParseException, JsonMappingException, KeyManagementException, ClientHandlerException,
  77             UniformInterfaceException, NoSuchAlgorithmException, IOException, IllegalArgumentException, ParseException {
  78         List<Lab> labs = new ArrayList<Lab>();
  79         for (String cLabSilo : nexusService.getResource(null)) {
  80             for (LabSilo silo : siloService.getSilos()) {
  81                 if (silo.getSilo().equals(cLabSilo)) {
  82                     labs.add(silo.getLab().getLab());
  83                 }
  84             }
  85         }
  86         return labs;
  87     }
  88
  89     public List<String> getBlueprintNamesOfLabFromNexus(@Nonnull Lab lab)
  90             throws JsonParseException, JsonMappingException, KeyManagementException, ClientHandlerException,
  91             UniformInterfaceException, NoSuchAlgorithmException, IOException, IllegalArgumentException, ParseException {
  92         String siloText = null;
  93         for (LabSilo silo : siloService.getSilos()) {
  94             if (silo.getLab().getLab().equals(lab)) {
  95                 siloText = silo.getSilo();
  96             }
  97         }
  98         if (siloText == null) {
  99             throw new IllegalArgumentException("Could not retrieve blueprint names of lab : " + lab.toString());
 100         }
 101         List<String> blueprintNames = new ArrayList<String>();
 102         List<String> cBlueprintNames = nexusService.getResource(siloText);
 103         for (String cBlueprintName : cBlueprintNames) {
 104             if (!cBlueprintName.equals("job")) {
 105                 blueprintNames.add(cBlueprintName);
 106             }
 107         }
 108         return blueprintNames;
 109     }
 110
 111     public List<String> getBlueprintVersionsFromNexus(@Nonnull String name, @Nonnull Lab lab)
 112             throws JsonParseException, JsonMappingException, KeyManagementException, ClientHandlerException,
 113             UniformInterfaceException, NoSuchAlgorithmException, IOException, IllegalArgumentException, ParseException {
 114         String siloText = null;
 115         for (LabSilo silo : siloService.getSilos()) {
 116             if (silo.getLab().getLab().equals(lab)) {
 117                 siloText = silo.getSilo();
 118             }
 119         }
 120         if (siloText == null) {
 121             throw new IllegalArgumentException("Could not retrieve silo of the lab : " + lab.toString());
 122         }
 123         return nexusService.getResource(siloText, name);
 124     }
 125
 126     public List<String> getBlueprintTimeStampsFromNexus(@Nonnull String name, @Nonnull String version, @Nonnull Lab lab)
 127             throws JsonParseException, JsonMappingException, KeyManagementException, ClientHandlerException,
 128             UniformInterfaceException, NoSuchAlgorithmException, IOException, ParseException {
 129         String siloText = null;
 130         for (LabSilo silo : siloService.getSilos()) {
 131             if (silo.getLab().getLab().equals(lab)) {
 132                 siloText = silo.getSilo();
 133             }
 134         }
 135         if (siloText == null) {
 136             throw new IllegalArgumentException("Could not retrieve silo of the lab : " + lab.toString());
 137         }
 138         return nexusService.getResource(siloText, name, version);
 139     }
 140
 141     public List<ValidationNexusTestResult> getResultsFromNexus(@Nonnull String name, @Nonnull String version,
 142             @Nonnull Lab lab, int noTimestamps)
 143                     throws JsonParseException, JsonMappingException, KeyManagementException, ClientHandlerException,
 144                     UniformInterfaceException, NoSuchAlgorithmException, IOException, IllegalArgumentException, ParseException {
 145         String siloText = null;
 146         for (LabSilo silo : siloService.getSilos()) {
 147             if (silo.getLab().getLab().equals(lab)) {
 148                 siloText = silo.getSilo();
 149             }
 150         }
 151         if (siloText == null) {
 152             throw new IllegalArgumentException("Could not retrieve silo of the lab : " + lab.toString());
 153         }
 154         return nexusService.getResults(name, version, siloText, noTimestamps);
 155     }
 156
 157     public ValidationNexusTestResult getResultFromNexus(@Nonnull String name, @Nonnull String version, @Nonnull Lab lab,
 158             @Nonnull String timestamp) throws JsonParseException, JsonMappingException, IOException,
 159     KeyManagementException, ClientHandlerException, UniformInterfaceException, NoSuchAlgorithmException,
 160     NullPointerException, ParseException {
 161         String siloText = null;
 162         for (LabSilo silo : siloService.getSilos()) {
 163             if (silo.getLab().getLab().equals(lab)) {
 164                 siloText = silo.getSilo();
 165             }
 166         }
 167         if (siloText == null) {
 168             throw new IllegalArgumentException("Could not retrieve silo of the lab : " + lab.toString());
 169         }
 170         return nexusService.getResult(name, version, siloText, timestamp);
 171     }
 172
 173     public ValidationNexusTestResult getLastResultBasedOnOutcomeFromNexus(@Nonnull String name, @Nonnull String version,
 174             @Nonnull Lab lab, Boolean allLayers, Boolean optional, boolean outcome)
 175                     throws JsonParseException, JsonMappingException, KeyManagementException, ClientHandlerException,
 176                     UniformInterfaceException, NoSuchAlgorithmException, NullPointerException, IOException, ParseException {
 177         String siloText = null;
 178         for (LabSilo silo : siloService.getSilos()) {
 179             if (silo.getLab().getLab().equals(lab)) {
 180                 siloText = silo.getSilo();
 181             }
 182         }
 183         if (siloText == null) {
 184             throw new IllegalArgumentException("Lab does not exist: " + lab.toString());
 185         }
 186         return nexusService.getLastResultBasedOnOutcome(name, version, siloText, allLayers, optional, outcome);
 187     }
 188
 189     public ValidationNexusTestResult getLastResultBasedOnOutcomeFromNexus(@Nonnull String name, @Nonnull String version,
 190             @Nonnull Lab lab, @Nonnull List<BlueprintLayer> layers, Boolean optional, boolean outcome)
 191                     throws JsonParseException, JsonMappingException, KeyManagementException, ClientHandlerException,
 192                     UniformInterfaceException, NoSuchAlgorithmException, NullPointerException, IOException, ParseException {
 193         String siloText = null;
 194         for (LabSilo silo : siloService.getSilos()) {
 195             if (silo.getLab().getLab().equals(lab)) {
 196                 siloText = silo.getSilo();
 197             }
 198         }
 199         if (siloText == null) {
 200             throw new IllegalArgumentException("Lab does not exist: " + lab.toString());
 201         }
 202         return nexusService.getLastResultBasedOnOutcome(name, version, siloText, layers, optional, outcome);
 203     }
 204
 205     public List<ValidationNexusTestResult> getBasedOnDateFromNexus(@Nonnull String name, @Nonnull String version,
 206             @Nonnull Lab lab, @Nonnull Date date)
 207                     throws JsonParseException, JsonMappingException, IOException, ParseException, KeyManagementException,
 208                     ClientHandlerException, UniformInterfaceException, NoSuchAlgorithmException, NullPointerException {
 209         String siloText = null;
 210         for (LabSilo silo : siloService.getSilos()) {
 211             if (silo.getLab().getLab().equals(lab)) {
 212                 siloText = silo.getSilo();
 213             }
 214         }
 215         if (siloText == null) {
 216             throw new IllegalArgumentException("Lab does not exist: " + lab.toString());
 217         }
 218         return nexusService.getResults(name, version, siloText, date);
 219     }
 220
 221     public Set<Lab> getLabsFromDb() {
 222         Set<Lab> labs = new HashSet<Lab>();
 223         for (ValidationDbTestResult result : dbAdapter.getValidationTestResults()) {
 224             labs.add(result.getLab().getLab());
 225         }
 226         return labs;
 227     }
 228
 229     public Set<String> getBlueprintNamesOfLabFromDb(Lab lab) {
 230         Set<String> blueprintNames = new HashSet<String>();
 231         for (ValidationDbTestResult result : dbAdapter.getValidationTestResults()) {
 232             if (result.getLab().getLab().equals(lab)) {
 233                 blueprintNames.add(result.getBlueprintName());
 234             }
 235         }
 236         return blueprintNames;
 237     }
 238
 239     public Set<String> getBlueprintVersionsFromDb(String name, Lab lab) {
 240         Set<String> blueprintVersions = new HashSet<String>();
 241         for (ValidationDbTestResult result : dbAdapter.getValidationTestResults()) {
 242             if (result.getLab().getLab().equals(lab) && result.getBlueprintName().equals(name)) {
 243                 blueprintVersions.add(result.getVersion());
 244             }
 245         }
 246         return blueprintVersions;
 247     }
 248
 249     public ValidationNexusTestResult getResults(@Nonnull String submissionId)
 250             throws JsonParseException, JsonMappingException, KeyManagementException, ClientHandlerException,
 251             UniformInterfaceException, NoSuchAlgorithmException, IOException, NullPointerException, ParseException {
 252         SubmissionData submissionData = submissionService.getSubmissionData(submissionId);
 253         ValidationNexusTestResult vNexusResult = dbAdapter.readResultFromDb(submissionId);
 254         return vNexusResult == null
 255                 ? this.getResultFromNexus(submissionData.getValidationNexusTestResult().getBlueprintName(),
 256                         submissionData.getValidationNexusTestResult().getVersion(),
 257                         submissionData.getTimeslot().getLab().getLab(),
 258                         submissionData.getValidationNexusTestResult().getTimestamp())
 259                         : vNexusResult;
 260     }
 261
 262     public ValidationNexusTestResult getResult(@Nonnull String name, @Nonnull String version, @Nonnull Lab lab,
 263             @Nonnull String timestamp)
 264                     throws JsonParseException, JsonMappingException, KeyManagementException, ClientHandlerException,
 265                     UniformInterfaceException, NoSuchAlgorithmException, NullPointerException, IOException, ParseException {
 266         LabInfo actualLabInfo = labService.getLab(lab);
 267         if (actualLabInfo == null) {
 268             return null;
 269         }
 270         ValidationNexusTestResult vNexusResult = dbAdapter.readResultFromDb(lab, timestamp);
 271         return vNexusResult == null ? this.getResultFromNexus(name, version, lab, timestamp) : vNexusResult;
 272     }
 273
 274     public ValidationNexusTestResult getLastResultBasedOnOutcome(@Nonnull String name, @Nonnull String version,
 275             @Nonnull Lab lab, Boolean allLayers, Boolean optional, boolean outcome)
 276                     throws JsonParseException, JsonMappingException, KeyManagementException, ClientHandlerException,
 277                     UniformInterfaceException, NoSuchAlgorithmException, IOException, NullPointerException, ParseException {
 278         LabInfo actualLabInfo = labService.getLab(lab);
 279         if (actualLabInfo == null) {
 280             return null;
 281         }
 282         List<ValidationNexusTestResult> vNexusResults = dbAdapter.readResultFromDb(name, version, lab, null, allLayers,
 283                 optional, outcome);
 284         if (vNexusResults != null) {
 285             vNexusResults.removeIf(entry -> entry.getDateOfStorage() == null);
 286             DateFormat dateFormat = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
 287             Collections.sort(vNexusResults, new Comparator<ValidationNexusTestResult>() {
 288                 @Override
 289                 public int compare(ValidationNexusTestResult vNexusResult1, ValidationNexusTestResult vNexusResult2) {
 290                     try {
 291                         return dateFormat.parse(vNexusResult2.getDateOfStorage())
 292                                 .compareTo(dateFormat.parse(vNexusResult1.getDateOfStorage()));
 293                     } catch (ParseException e) {
 294                         LOGGER.error(EELFLoggerDelegate.errorLogger,
 295                                 "Error when parsing date. " + UserUtils.getStackTrace(e));
 296                         return 0;
 297                     }
 298                 }
 299             });
 300             return vNexusResults.get(0);
 301         }
 302         return this.getLastResultBasedOnOutcomeFromNexus(name, version, lab, allLayers, optional, outcome);
 303     }
 304
 305     public ValidationNexusTestResult getLastResultBasedOnOutcome(@Nonnull String name, @Nonnull String version,
 306             @Nonnull Lab lab, List<BlueprintLayer> layers, Boolean optional, boolean outcome)
 307                     throws JsonParseException, JsonMappingException, KeyManagementException, ClientHandlerException,
 308                     UniformInterfaceException, NoSuchAlgorithmException, IOException, NullPointerException, ParseException {
 309         LabInfo actualLabInfo = labService.getLab(lab);
 310         if (actualLabInfo == null) {
 311             return null;
 312         }
 313         List<ValidationNexusTestResult> vNexusResults = dbAdapter.readResultFromDb(name, version, lab, layers, null,
 314                 optional, outcome);
 315         if (vNexusResults != null) {
 316             vNexusResults.removeIf(entry -> entry.getDateOfStorage() == null);
 317             DateFormat dateFormat = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
 318             Collections.sort(vNexusResults, new Comparator<ValidationNexusTestResult>() {
 319                 @Override
 320                 public int compare(ValidationNexusTestResult vNexusResult1, ValidationNexusTestResult vNexusResult2) {
 321                     try {
 322                         return dateFormat.parse(vNexusResult2.getDateOfStorage())
 323                                 .compareTo(dateFormat.parse(vNexusResult1.getDateOfStorage()));
 324                     } catch (ParseException e) {
 325                         LOGGER.error(EELFLoggerDelegate.errorLogger,
 326                                 "Error when parsing date. " + UserUtils.getStackTrace(e));
 327                         return 0;
 328                     }
 329                 }
 330             });
 331             return vNexusResults.get(0);
 332         }
 333         return this.getLastResultBasedOnOutcomeFromNexus(name, version, lab, layers, optional, outcome);
 334     }
 335
 336 }