2 * Copyright (c) 2019 AT&T Intellectual Property. All rights reserved.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 package org.akraino.validation.ui.service;
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;
33 import javax.annotation.Nonnull;
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;
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;
56 public class IntegratedResultService {
58 private static final EELFLoggerDelegate LOGGER = EELFLoggerDelegate.getLogger(IntegratedResultService.class);
61 private DbSubmissionAdapter submissionService;
64 private SiloService siloService;
67 NexusExecutorClient nexusService;
70 LabService labService;
73 DbResultAdapter dbAdapter;
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());
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();
98 if (siloText == null) {
99 throw new IllegalArgumentException("Could not retrieve blueprint names of lab : " + lab.toString());
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);
108 return blueprintNames;
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();
120 if (siloText == null) {
121 throw new IllegalArgumentException("Could not retrieve silo of the lab : " + lab.toString());
123 return nexusService.getResource(siloText, name);
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();
135 if (siloText == null) {
136 throw new IllegalArgumentException("Could not retrieve silo of the lab : " + lab.toString());
138 return nexusService.getResource(siloText, name, version);
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();
151 if (siloText == null) {
152 throw new IllegalArgumentException("Could not retrieve silo of the lab : " + lab.toString());
154 return nexusService.getResults(name, version, siloText, noTimestamps);
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();
167 if (siloText == null) {
168 throw new IllegalArgumentException("Could not retrieve silo of the lab : " + lab.toString());
170 return nexusService.getResult(name, version, siloText, timestamp);
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();
183 if (siloText == null) {
184 throw new IllegalArgumentException("Lab does not exist: " + lab.toString());
186 return nexusService.getLastResultBasedOnOutcome(name, version, siloText, allLayers, optional, outcome);
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();
199 if (siloText == null) {
200 throw new IllegalArgumentException("Lab does not exist: " + lab.toString());
202 return nexusService.getLastResultBasedOnOutcome(name, version, siloText, layers, optional, outcome);
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();
215 if (siloText == null) {
216 throw new IllegalArgumentException("Lab does not exist: " + lab.toString());
218 return nexusService.getResults(name, version, siloText, date);
221 public Set<Lab> getLabsFromDb() {
222 Set<Lab> labs = new HashSet<Lab>();
223 for (ValidationDbTestResult result : dbAdapter.getValidationTestResults()) {
224 labs.add(result.getLab().getLab());
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());
236 return blueprintNames;
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());
246 return blueprintVersions;
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())
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) {
270 ValidationNexusTestResult vNexusResult = dbAdapter.readResultFromDb(lab, timestamp);
271 return vNexusResult == null ? this.getResultFromNexus(name, version, lab, timestamp) : vNexusResult;
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) {
282 List<ValidationNexusTestResult> vNexusResults = dbAdapter.readResultFromDb(name, version, lab, null, allLayers,
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>() {
289 public int compare(ValidationNexusTestResult vNexusResult1, ValidationNexusTestResult vNexusResult2) {
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));
300 return vNexusResults.get(0);
302 return this.getLastResultBasedOnOutcomeFromNexus(name, version, lab, allLayers, optional, outcome);
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) {
313 List<ValidationNexusTestResult> vNexusResults = dbAdapter.readResultFromDb(name, version, lab, layers, null,
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>() {
320 public int compare(ValidationNexusTestResult vNexusResult1, ValidationNexusTestResult vNexusResult2) {
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));
331 return vNexusResults.get(0);
333 return this.getLastResultBasedOnOutcomeFromNexus(name, version, lab, layers, optional, outcome);