ui/src/main/java/org/akraino/validation/ui/client/nexus/NexusExecutorClient.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.client.nexus;
  17
  18 import java.io.IOException;
  19 import java.net.HttpURLConnection;
  20 import java.net.InetSocketAddress;
  21 import java.net.Proxy;
  22 import java.net.URL;
  23 import java.text.DateFormat;
  24 import java.text.ParseException;
  25 import java.text.SimpleDateFormat;
  26 import java.util.ArrayList;
  27 import java.util.Collections;
  28 import java.util.Comparator;
  29 import java.util.Date;
  30 import java.util.HashSet;
  31 import java.util.List;
  32 import java.util.Locale;
  33
  34 import javax.annotation.Nonnull;
  35
  36 import org.akraino.validation.ui.client.nexus.resources.RobotTestResult;
  37 import org.akraino.validation.ui.client.nexus.resources.Status;
  38 import org.akraino.validation.ui.client.nexus.resources.TestInfoYaml;
  39 import org.akraino.validation.ui.client.nexus.resources.WRobotNexusTestResult;
  40 import org.akraino.validation.ui.entity.Blueprint;
  41 import org.akraino.validation.ui.entity.BlueprintInstance;
  42 import org.akraino.validation.ui.entity.LabInfo;
  43 import org.akraino.validation.ui.entity.ValidationDbTestResult;
  44 import org.akraino.validation.ui.entity.WRobotDbTestResult;
  45 import org.akraino.validation.ui.service.DbAdapter;
  46 import org.apache.commons.httpclient.HttpException;
  47 import org.json.JSONException;
  48 import org.json.JSONObject;
  49 import org.json.XML;
  50 import org.jsoup.Jsoup;
  51 import org.jsoup.nodes.Document;
  52 import org.jsoup.nodes.Element;
  53 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
  54 import org.onap.portalsdk.core.onboarding.util.PortalApiProperties;
  55 import org.onap.portalsdk.core.web.support.UserUtils;
  56 import org.springframework.beans.factory.annotation.Autowired;
  57 import org.springframework.stereotype.Service;
  58
  59 import com.fasterxml.jackson.annotation.JsonInclude.Include;
  60 import com.fasterxml.jackson.core.JsonProcessingException;
  61 import com.fasterxml.jackson.databind.DeserializationFeature;
  62 import com.fasterxml.jackson.databind.ObjectMapper;
  63 import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
  64 import com.sun.jersey.api.client.Client;
  65 import com.sun.jersey.api.client.ClientResponse;
  66 import com.sun.jersey.api.client.WebResource;
  67 import com.sun.jersey.api.client.config.ClientConfig;
  68 import com.sun.jersey.api.client.config.DefaultClientConfig;
  69 import com.sun.jersey.api.json.JSONConfiguration;
  70 import com.sun.jersey.client.urlconnection.HttpURLConnectionFactory;
  71 import com.sun.jersey.client.urlconnection.URLConnectionClientHandler;
  72
  73 @Service
  74 public final class NexusExecutorClient {
  75
  76     @Autowired
  77     DbAdapter dbAdapter;
  78
  79     private static final EELFLoggerDelegate LOGGER = EELFLoggerDelegate.getLogger(NexusExecutorClient.class);
  80
  81     private final Client client;
  82     private final String baseurl;
  83
  84     public NexusExecutorClient() {
  85         this.baseurl = PortalApiProperties.getProperty("nexus_url");
  86         ClientConfig clientConfig = new DefaultClientConfig();
  87         clientConfig.getFeatures().put(JSONConfiguration.FEATURE_POJO_MAPPING, Boolean.TRUE);
  88         this.client = new Client(new URLConnectionClientHandler(new HttpURLConnectionFactory() {
  89             Proxy proxy = null;
  90
  91             @Override
  92             public HttpURLConnection getHttpURLConnection(URL url) throws IOException {
  93                 try {
  94                     String proxyIp = System.getenv("NEXUS_PROXY").substring(0,
  95                             System.getenv("NEXUS_PROXY").lastIndexOf(":"));
  96                     String proxyPort = System.getenv("NEXUS_PROXY")
  97                             .substring(System.getenv("NEXUS_PROXY").lastIndexOf(":") + 1);
  98                     proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyIp, Integer.parseInt(proxyPort)));
  99                     return (HttpURLConnection) url.openConnection(proxy);
 100                 } catch (Exception ex) {
 101                     return (HttpURLConnection) url.openConnection();
 102                 }
 103             }
 104         }), clientConfig);
 105     }
 106
 107     public String getBaseUrl() {
 108         return this.baseurl;
 109     }
 110
 111     public List<String> getResource(String endpoint)
 112             throws IndexOutOfBoundsException, HttpException, NullPointerException {
 113         List<String> resources = new ArrayList<String>();
 114         String nexusUrl = this.baseurl;
 115         if (endpoint != null) {
 116             nexusUrl = this.baseurl + "/" + endpoint;
 117         }
 118         LOGGER.info(EELFLoggerDelegate.applicationLogger, "Trying to get nexus resource: " + nexusUrl);
 119         WebResource webResource = this.client.resource(nexusUrl + "/");
 120         LOGGER.debug(EELFLoggerDelegate.debugLogger, "Request URI of get: " + webResource.getURI().toString());
 121         ClientResponse response = webResource.get(ClientResponse.class);
 122         if (response.getStatus() != 200) {
 123             throw new HttpException("Could not retrieve nexus resource " + nexusUrl + ". HTTP error code : "
 124                     + response.getStatus() + " and message: " + response.getEntity(String.class));
 125         }
 126         Document document = Jsoup.parse(response.getEntity(String.class));
 127         List<Element> elements = document.getElementsByTag("body").get(0).getElementsByTag("table").get(0)
 128                 .getElementsByTag("tbody").get(0).getElementsByTag("tr");
 129         for (int i = 2; i < elements.size(); i++) {
 130             String resource = elements.get(i).getElementsByTag("td").get(0).getElementsByTag("a").get(0).text();
 131             resource = resource.substring(0, resource.length() - 1);
 132             resources.add(resource);
 133         }
 134         return resources;
 135     }
 136
 137     public List<String> getResource(@Nonnull String endpoint1, @Nonnull String endpoint2)
 138             throws IndexOutOfBoundsException, HttpException, NullPointerException {
 139         String endpoint = endpoint1 + "/" + endpoint2;
 140         return this.getResource(endpoint);
 141     }
 142
 143     public List<String> getResource(@Nonnull String endpoint1, @Nonnull String endpoint2, @Nonnull String endpoint3)
 144             throws IndexOutOfBoundsException, HttpException, NullPointerException {
 145         String endpoint = endpoint1 + "/" + endpoint2 + "/" + endpoint3;
 146         return this.getResource(endpoint);
 147     }
 148
 149     public ValidationDbTestResult getResult(@Nonnull String name, @Nonnull String version, @Nonnull String siloText,
 150             @Nonnull String timestamp) throws IndexOutOfBoundsException, HttpException, NullPointerException {
 151         String nexusUrl = this.baseurl + "/" + siloText + "/" + "bluval_results/" + name + "/" + version;
 152         LOGGER.info(EELFLoggerDelegate.applicationLogger, "Trying to get validation nexus test result");
 153         WebResource webResource = this.client.resource(nexusUrl + "/");
 154         LOGGER.debug(EELFLoggerDelegate.debugLogger, "Request URI of get: " + webResource.getURI().toString());
 155         ClientResponse response = webResource.get(ClientResponse.class);
 156         if (response.getStatus() != 200) {
 157             throw new HttpException("Could not retrieve validation nexus test result. HTTP error code : "
 158                     + response.getStatus() + " and message: " + response.getEntity(String.class));
 159         }
 160         Document document = Jsoup.parse(response.getEntity(String.class));
 161         List<Element> elements = document.getElementsByTag("body").get(0).getElementsByTag("table").get(0)
 162                 .getElementsByTag("tbody").get(0).getElementsByTag("tr");
 163         Element element = findElementByTimestamp(elements.subList(2, elements.size()), timestamp);
 164         if (element == null) {
 165             return null;
 166         }
 167         ValidationDbTestResult vDbResult = new ValidationDbTestResult();
 168         Blueprint blueprint = new Blueprint();
 169         blueprint.setBlueprintName(name);
 170         BlueprintInstance blueInst = new BlueprintInstance();
 171         blueInst.setBlueprint(blueprint);
 172         blueInst.setVersion(version);
 173         vDbResult.setBlueprintInstance(blueInst);
 174         LabInfo lab = new LabInfo();
 175         lab.setSilo(siloText);
 176         vDbResult.setLab(lab);
 177         vDbResult.setTimestamp(timestamp);
 178         String lastModified = element.getElementsByTag("td").get(1).text();
 179         vDbResult.setDateStorage(lastModified);
 180         TestInfoYaml testInfo = getTestInfo(webResource.getURI().toString() + timestamp);
 181         if (testInfo != null) {
 182             if (testInfo.gettest_info().getLayer().equals("all")) {
 183                 vDbResult.setAllLayers(true);
 184             } else {
 185                 vDbResult.setAllLayers(false);
 186             }
 187             vDbResult.setOptional(testInfo.gettest_info().getOptional());
 188         }
 189         List<WRobotNexusTestResult> wTestResults = getWRobotTestResults(name, version, siloText, timestamp);
 190         if (wTestResults.size() < 1) {
 191             return null;
 192         }
 193         vDbResult.setResult(determineResult(wTestResults));
 194         List<WRobotDbTestResult> wDbResults = new ArrayList<WRobotDbTestResult>();
 195         for (WRobotNexusTestResult wTestResult : wTestResults) {
 196             try {
 197                 WRobotDbTestResult wDbResult = new WRobotDbTestResult();
 198                 wDbResult.setLayer(wTestResult.getLayer());
 199                 ObjectMapper mapper = new ObjectMapper();
 200                 wDbResult.setRobotTestResults(mapper.writeValueAsString(wTestResult.getRobotNexusTestResults()));
 201                 wDbResults.add(wDbResult);
 202             } catch (JsonProcessingException e) {
 203                 LOGGER.warn(EELFLoggerDelegate.auditLogger,
 204                         "Exception occured while processing JSON. " + UserUtils.getStackTrace(e));
 205             }
 206         }
 207         vDbResult.setWRobotDbTestResults(new HashSet<WRobotDbTestResult>(wDbResults));
 208         return vDbResult;
 209     }
 210
 211     public List<ValidationDbTestResult> getResults(@Nonnull String name, @Nonnull String version,
 212             @Nonnull String siloText, int noOfLastElements)
 213             throws IndexOutOfBoundsException, HttpException, NullPointerException {
 214         String nexusUrl = this.baseurl + "/" + siloText + "/" + "bluval_results/" + name + "/" + version;
 215         LOGGER.info(EELFLoggerDelegate.applicationLogger, "Trying to get validation Nexus test results");
 216         WebResource webResource = this.client.resource(nexusUrl + "/");
 217         LOGGER.debug(EELFLoggerDelegate.debugLogger, "Request URI of get: " + webResource.getURI().toString());
 218         ClientResponse response = webResource.get(ClientResponse.class);
 219         if (response.getStatus() != 200) {
 220             throw new HttpException("Could not retrieve validation Nexus test results. HTTP error code : "
 221                     + response.getStatus() + " and message: " + response.getEntity(String.class));
 222         }
 223         List<ValidationDbTestResult> vDbResults = new ArrayList<ValidationDbTestResult>();
 224         Document document = Jsoup.parse(response.getEntity(String.class));
 225         List<Element> elements = document.getElementsByTag("body").get(0).getElementsByTag("table").get(0)
 226                 .getElementsByTag("tbody").get(0).getElementsByTag("tr");
 227         elements = findLastElementsByDate(elements.subList(2, elements.size()), noOfLastElements);
 228         for (int i = 0; i < elements.size(); i++) {
 229             String timestamp = null;
 230             try {
 231                 timestamp = elements.get(i).getElementsByTag("td").get(0).getElementsByTag("a").get(0).text();
 232                 timestamp = timestamp.substring(0, timestamp.length() - 1);
 233                 ValidationDbTestResult vDbResult = dbAdapter.getValidationTestResult(siloText, timestamp);
 234                 if (vDbResult == null || vDbResult.getDateStorage() == null) {
 235                     ValidationDbTestResult vDbResult2 = this.getResult(name, version, siloText, timestamp);
 236                     if (vDbResult2 == null) {
 237                         continue;
 238                     }
 239                     vDbResults.add(vDbResult2);
 240                 } else {
 241                     // Just to avoid deletion of already received validation timestamp results
 242                     vDbResult = new ValidationDbTestResult();
 243                     Blueprint blueprint = new Blueprint();
 244                     blueprint.setBlueprintName(name);
 245                     BlueprintInstance blueInst = new BlueprintInstance();
 246                     blueInst.setBlueprint(blueprint);
 247                     blueInst.setVersion(version);
 248                     vDbResult.setBlueprintInstance(blueInst);
 249                     LabInfo lab = new LabInfo();
 250                     lab.setSilo(siloText);
 251                     vDbResult.setLab(lab);
 252                     vDbResult.setTimestamp(timestamp);
 253                     vDbResults.add(vDbResult);
 254                 }
 255             } catch (HttpException | IndexOutOfBoundsException | NullPointerException ex) {
 256                 LOGGER.warn(EELFLoggerDelegate.auditLogger, "Exception occured while retrieving timestamp : "
 257                         + timestamp + " result." + UserUtils.getStackTrace(ex));
 258             }
 259         }
 260         return vDbResults;
 261     }
 262
 263     public List<ValidationDbTestResult> getResults(@Nonnull String name, @Nonnull String version,
 264             @Nonnull String siloText, @Nonnull Date date)
 265             throws IndexOutOfBoundsException, HttpException, NullPointerException, ParseException {
 266         String nexusUrl = this.baseurl + "/" + siloText + "/" + "bluval_results/" + name + "/" + version;
 267         LOGGER.debug(EELFLoggerDelegate.applicationLogger, "Trying to get validation Nexus results based on date");
 268         WebResource webResource = this.client.resource(nexusUrl + "/");
 269         LOGGER.debug(EELFLoggerDelegate.debugLogger, "Request URI of get: " + webResource.getURI().toString());
 270         ClientResponse response = webResource.get(ClientResponse.class);
 271         if (response.getStatus() != 200) {
 272             throw new HttpException("Could not retrieve validation Nexus results based on date. HTTP error code : "
 273                     + response.getStatus() + " and message: " + response.getEntity(String.class));
 274         }
 275         List<ValidationDbTestResult> vDbResults = new ArrayList<ValidationDbTestResult>();
 276         Document document = Jsoup.parse(response.getEntity(String.class));
 277         List<Element> elements = document.getElementsByTag("body").get(0).getElementsByTag("table").get(0)
 278                 .getElementsByTag("tbody").get(0).getElementsByTag("tr");
 279         elements = findElementsBasedOnDate(elements.subList(2, elements.size()), date);
 280         for (int i = 0; i < elements.size(); i++) {
 281             try {
 282                 String timestamp = elements.get(i).getElementsByTag("td").get(0).getElementsByTag("a").get(0).text();
 283                 timestamp = timestamp.substring(0, timestamp.length() - 1);
 284                 ValidationDbTestResult vDbResult = this.getResult(name, version, siloText, timestamp);
 285                 if (vDbResult == null) {
 286                     continue;
 287                 }
 288                 vDbResults.add(vDbResult);
 289             } catch (HttpException | IndexOutOfBoundsException | NullPointerException ex) {
 290                 LOGGER.warn(EELFLoggerDelegate.auditLogger,
 291                         "Exception occured while retrieving timestamp results. " + UserUtils.getStackTrace(ex));
 292             }
 293         }
 294         return vDbResults;
 295     }
 296
 297     public ValidationDbTestResult getLastResultBasedOnOutcome(@Nonnull String name, @Nonnull String version,
 298             @Nonnull String siloText, List<String> layers, Boolean optional, boolean outcome)
 299             throws IndexOutOfBoundsException, HttpException, NullPointerException {
 300         String nexusUrl = this.baseurl + "/" + siloText + "/" + "bluval_results/" + name + "/" + version;
 301         LOGGER.info(EELFLoggerDelegate.applicationLogger, "Trying to get last result based on outcome");
 302         WebResource webResource = this.client.resource(nexusUrl + "/");
 303         LOGGER.debug(EELFLoggerDelegate.debugLogger, "Request URI of get: " + webResource.getURI().toString());
 304         ClientResponse response = webResource.get(ClientResponse.class);
 305         if (response.getStatus() != 200) {
 306             throw new HttpException("Could not retrieve last result based on outcome from Nexus. HTTP error code : "
 307                     + response.getStatus() + " and message: " + response.getEntity(String.class));
 308         }
 309         Document document = Jsoup.parse(response.getEntity(String.class));
 310         List<Element> elements = document.getElementsByTag("body").get(0).getElementsByTag("table").get(0)
 311                 .getElementsByTag("tbody").get(0).getElementsByTag("tr");
 312         elements = elements.subList(2, elements.size());
 313         if (elements.size() < 1) {
 314             return null;
 315         }
 316         DateFormat dateFormat = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
 317         Collections.sort(elements, new Comparator<Element>() {
 318             @Override
 319             public int compare(Element element1, Element element2) {
 320                 try {
 321                     return dateFormat.parse(element2.getElementsByTag("td").get(1).text())
 322                             .compareTo(dateFormat.parse(element1.getElementsByTag("td").get(1).text()));
 323                 } catch (ParseException e) {
 324                     LOGGER.error(EELFLoggerDelegate.errorLogger,
 325                             "Error when parsing date. " + UserUtils.getStackTrace(e));
 326                     return 0;
 327                 }
 328             }
 329         });
 330         for (Element element : elements) {
 331             try {
 332                 String elementTimestamp = element.getElementsByTag("td").get(0).getElementsByTag("a").get(0).text();
 333                 elementTimestamp = elementTimestamp.substring(0, elementTimestamp.length() - 1);
 334                 ValidationDbTestResult vDbResult = this.getResult(name, version, siloText, elementTimestamp);
 335                 if (vDbResult == null) {
 336                     continue;
 337                 }
 338                 if (vDbResult.getResult() != outcome) {
 339                     continue;
 340                 }
 341                 if (optional != null && vDbResult.getOptional() != optional) {
 342                     continue;
 343                 }
 344                 if (layers != null) {
 345                     List<String> storedLayers = new ArrayList<String>();
 346                     for (WRobotDbTestResult wRobot : vDbResult.getWRobotDbTestResults()) {
 347                         storedLayers.add(wRobot.getLayer());
 348                     }
 349                     if (!new HashSet<>(storedLayers).equals(new HashSet<>(layers))) {
 350                         continue;
 351                     }
 352                 }
 353                 return vDbResult;
 354             } catch (HttpException | IndexOutOfBoundsException | NullPointerException ex) {
 355                 LOGGER.warn(EELFLoggerDelegate.auditLogger,
 356                         "Error when trying to retrieve results. " + UserUtils.getStackTrace(ex));
 357             }
 358         }
 359         return null;
 360     }
 361
 362     public ValidationDbTestResult getLastResultBasedOnOutcome(@Nonnull String name, @Nonnull String version,
 363             @Nonnull String siloText, Boolean allLayers, Boolean optional, boolean outcome)
 364             throws IndexOutOfBoundsException, HttpException, NullPointerException {
 365         String nexusUrl = this.baseurl + "/" + siloText + "/" + "bluval_results/" + name + "/" + version;
 366         LOGGER.info(EELFLoggerDelegate.applicationLogger, "Trying to get last result based on outcome");
 367         WebResource webResource = this.client.resource(nexusUrl + "/");
 368         LOGGER.debug(EELFLoggerDelegate.debugLogger, "Request URI of get: " + webResource.getURI().toString());
 369         ClientResponse response = webResource.get(ClientResponse.class);
 370         if (response.getStatus() != 200) {
 371             throw new HttpException("Could not retrieve last result based on outcome from Nexus. HTTP error code : "
 372                     + response.getStatus() + " and message: " + response.getEntity(String.class));
 373         }
 374         Document document = Jsoup.parse(response.getEntity(String.class));
 375         List<Element> elements = document.getElementsByTag("body").get(0).getElementsByTag("table").get(0)
 376                 .getElementsByTag("tbody").get(0).getElementsByTag("tr");
 377         elements = elements.subList(2, elements.size());
 378         if (elements.size() < 1) {
 379             return null;
 380         }
 381         DateFormat dateFormat = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
 382         Collections.sort(elements, new Comparator<Element>() {
 383             @Override
 384             public int compare(Element element1, Element element2) {
 385                 try {
 386                     return dateFormat.parse(element2.getElementsByTag("td").get(1).text())
 387                             .compareTo(dateFormat.parse(element1.getElementsByTag("td").get(1).text()));
 388                 } catch (ParseException e) {
 389                     LOGGER.error(EELFLoggerDelegate.errorLogger,
 390                             "Error when parsing date. " + UserUtils.getStackTrace(e));
 391                     return 0;
 392                 }
 393             }
 394         });
 395         for (Element element : elements) {
 396             try {
 397                 String elementTimestamp = element.getElementsByTag("td").get(0).getElementsByTag("a").get(0).text();
 398                 elementTimestamp = elementTimestamp.substring(0, elementTimestamp.length() - 1);
 399                 ValidationDbTestResult vDbResult = this.getResult(name, version, siloText, elementTimestamp);
 400                 if (vDbResult == null) {
 401                     continue;
 402                 }
 403                 if (vDbResult.getResult() != outcome) {
 404                     continue;
 405                 }
 406                 if (optional != null && vDbResult.getOptional() != optional) {
 407                     continue;
 408                 }
 409                 if (allLayers != null && vDbResult.getAllLayers() != allLayers) {
 410                     continue;
 411                 }
 412                 return vDbResult;
 413             } catch (HttpException | IndexOutOfBoundsException | NullPointerException ex) {
 414                 LOGGER.warn(EELFLoggerDelegate.auditLogger,
 415                         "Error when trying to retrieve results. " + UserUtils.getStackTrace(ex));
 416             }
 417         }
 418         return null;
 419     }
 420
 421     public List<WRobotNexusTestResult> getWRobotTestResults(@Nonnull String name, @Nonnull String version,
 422             @Nonnull String siloText, @Nonnull String timestamp)
 423             throws IndexOutOfBoundsException, HttpException, NullPointerException {
 424         String nexusUrl = this.baseurl + "/" + siloText + "/" + "bluval_results/" + name + "/" + version + "/"
 425                 + timestamp + "/results";
 426         List<WRobotNexusTestResult> listOfWrappers = new ArrayList<WRobotNexusTestResult>();
 427         LOGGER.info(EELFLoggerDelegate.applicationLogger, "Trying to get the blueprint layers");
 428         WebResource webResource = this.client.resource(nexusUrl + "/");
 429         LOGGER.debug(EELFLoggerDelegate.debugLogger, "Request URI of get: " + webResource.getURI().toString());
 430         ClientResponse response = webResource.get(ClientResponse.class);
 431         if (response.getStatus() != 200) {
 432             throw new HttpException("Could not retrieve blueprint layers from Nexus. HTTP error code : "
 433                     + response.getStatus() + " and message: " + response.getEntity(String.class));
 434         }
 435         Document document = Jsoup.parse(response.getEntity(String.class));
 436         List<Element> elements = document.getElementsByTag("body").get(0).getElementsByTag("table").get(0)
 437                 .getElementsByTag("tr");
 438         for (int i = 2; i < elements.size(); i++) {
 439             try {
 440                 String layer = elements.get(i).getElementsByTag("td").get(0).getElementsByTag("a").get(0).text();
 441                 layer = layer.substring(0, layer.length() - 1);
 442                 if (layer.contains("test") || layer.contains("service") || layer.contains("home")) {
 443                     continue;
 444                 }
 445                 List<RobotTestResult> robotTestResults = getRobotTestResults(nexusUrl + "/" + layer);
 446                 if (robotTestResults.size() < 1) {
 447                     continue;
 448                 }
 449                 WRobotNexusTestResult wrapper = new WRobotNexusTestResult();
 450                 wrapper.setLayer(layer);
 451                 wrapper.setRobotNexusTestResults(robotTestResults);
 452                 listOfWrappers.add(wrapper);
 453             } catch (IndexOutOfBoundsException | HttpException | NullPointerException ex) {
 454                 LOGGER.warn(EELFLoggerDelegate.auditLogger,
 455                         "Exception occured while retrieving wrapped robot results. " + UserUtils.getStackTrace(ex));
 456             }
 457         }
 458         return listOfWrappers;
 459     }
 460
 461     private List<RobotTestResult> getRobotTestResults(String resultsUrl)
 462             throws IndexOutOfBoundsException, HttpException, NullPointerException {
 463         List<RobotTestResult> rTestResults = new ArrayList<RobotTestResult>();
 464         LOGGER.info(EELFLoggerDelegate.applicationLogger, "Trying to get test suites results");
 465         WebResource webResource = this.client.resource(resultsUrl + "/");
 466         LOGGER.debug(EELFLoggerDelegate.debugLogger, "Request URI of get: " + webResource.getURI().toString());
 467         ClientResponse response = webResource.get(ClientResponse.class);
 468         if (response.getStatus() != 200) {
 469             throw new HttpException("Could not retrieve test suites results from Nexus. HTTP error code : "
 470                     + response.getStatus() + " and message: " + response.getEntity(String.class));
 471         }
 472         Document document = Jsoup.parse(response.getEntity(String.class));
 473         List<Element> elements = document.getElementsByTag("body").get(0).getElementsByTag("table").get(0)
 474                 .getElementsByTag("tbody").get(0).getElementsByTag("tr");
 475         for (int i = 2; i < elements.size(); i++) {
 476             try {
 477                 String testSuiteName = elements.get(i).getElementsByTag("td").get(0).getElementsByTag("a").get(0)
 478                         .text();
 479                 testSuiteName = testSuiteName.substring(0, testSuiteName.length() - 1);
 480                 webResource = this.client.resource(resultsUrl + "/" + testSuiteName + "/output.xml");
 481                 LOGGER.debug(EELFLoggerDelegate.debugLogger, "Request URI of get: " + webResource.getURI().toString());
 482                 response = webResource.get(ClientResponse.class);
 483                 if (response.getStatus() != 200) {
 484                     throw new HttpException("Could not retrieve test suite result from Nexus. HTTP error code : "
 485                             + response.getStatus() + " and message: " + response.getEntity(String.class));
 486                 }
 487                 String result = response.getEntity(String.class);
 488                 JSONObject xmlJSONObj = XML.toJSONObject(result);
 489                 try {
 490                     ObjectMapper mapper = new ObjectMapper();
 491                     mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
 492                     mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
 493                     mapper.setSerializationInclusion(Include.NON_NULL);
 494                     RobotTestResult robotTestResult = mapper.readValue(xmlJSONObj.toString(), RobotTestResult.class);
 495                     robotTestResult.setName(testSuiteName);
 496                     rTestResults.add(robotTestResult);
 497                 } catch (Exception ex) {
 498                     LOGGER.error(EELFLoggerDelegate.errorLogger, "Exception occured while deserializing for resource "
 499                             + resultsUrl + " " + UserUtils.getStackTrace(ex));
 500                 }
 501             } catch (IOException | JSONException ex) {
 502                 LOGGER.warn(EELFLoggerDelegate.auditLogger, "Exception occured while retrieving robot results from "
 503                         + resultsUrl + " . " + UserUtils.getStackTrace(ex));
 504             }
 505         }
 506         return rTestResults;
 507     }
 508
 509     private boolean determineResult(List<WRobotNexusTestResult> wTestResults) {
 510         boolean result = true;
 511         for (WRobotNexusTestResult wTestResult : wTestResults) {
 512             for (RobotTestResult robotTestResult : wTestResult.getRobotNexusTestResults()) {
 513                 for (Status status : robotTestResult.getRobot().getStatistics().getTotal().getStat()) {
 514                     if (status.getContent().trim().equals("All Tests") && status.getFail() > 0) {
 515                         result = false;
 516                     }
 517                 }
 518             }
 519         }
 520         return result;
 521     }
 522
 523     private List<Element> findLastElementsByDate(List<Element> elements, int noOfLastElements) {
 524         if (elements.size() <= noOfLastElements) {
 525             return elements;
 526         }
 527         DateFormat dateFormat = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
 528         Collections.sort(elements, new Comparator<Element>() {
 529             @Override
 530             public int compare(Element element1, Element element2) {
 531                 try {
 532                     return dateFormat.parse(element2.getElementsByTag("td").get(1).text())
 533                             .compareTo(dateFormat.parse(element1.getElementsByTag("td").get(1).text()));
 534                 } catch (ParseException e) {
 535                     LOGGER.error(EELFLoggerDelegate.errorLogger,
 536                             "Error when parsing date. " + UserUtils.getStackTrace(e));
 537                     return 0;
 538                 }
 539             }
 540         });
 541         return elements.subList(0, noOfLastElements);
 542     }
 543
 544     private Element findElementByTimestamp(List<Element> elements, String timestamp) {
 545         for (Element element : elements) {
 546             String elementTimestamp = element.getElementsByTag("td").get(0).getElementsByTag("a").get(0).text();
 547             elementTimestamp = elementTimestamp.substring(0, elementTimestamp.length() - 1);
 548             if (elementTimestamp.equals(timestamp)) {
 549                 return element;
 550             }
 551         }
 552         return null;
 553     }
 554
 555     private List<Element> findElementsBasedOnDate(List<Element> elements, Date date) throws ParseException {
 556         DateFormat formatTime = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
 557         DateFormat formatNoTime = new SimpleDateFormat("EEE MMM dd zzz yyyy", Locale.US);
 558         List<Element> desiredElements = new ArrayList<Element>();
 559         for (Element element : elements) {
 560             String lastModified = element.getElementsByTag("td").get(1).text();
 561             if (formatNoTime.format(formatTime.parse(lastModified)).compareTo(formatNoTime.format(date)) == 0) {
 562                 desiredElements.add(element);
 563             }
 564         }
 565         return desiredElements;
 566     }
 567
 568     private TestInfoYaml getTestInfo(String timestampUrl) {
 569         LOGGER.info(EELFLoggerDelegate.applicationLogger, "Trying to get test info");
 570         WebResource webResource = this.client.resource(timestampUrl + "/results/test_info.yaml");
 571         LOGGER.debug(EELFLoggerDelegate.debugLogger, "Request URI of get: " + webResource.getURI().toString());
 572         ClientResponse response = webResource.get(ClientResponse.class);
 573         if (response.getStatus() != 200) {
 574             LOGGER.warn(EELFLoggerDelegate.auditLogger, "No test_info.yaml file was found");
 575             return null;
 576         }
 577         try {
 578             String testInfo = response.getEntity(String.class);
 579             ObjectMapper yamlReader = new ObjectMapper(new YAMLFactory());
 580             Object obj;
 581             obj = yamlReader.readValue(testInfo, Object.class);
 582             ObjectMapper mapper = new ObjectMapper();
 583             mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
 584             mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
 585             mapper.setSerializationInclusion(Include.NON_NULL);
 586             ObjectMapper jsonWriter = new ObjectMapper();
 587             return mapper.readValue(jsonWriter.writeValueAsString(obj), TestInfoYaml.class);
 588         } catch (IOException e) {
 589             LOGGER.error(EELFLoggerDelegate.errorLogger,
 590                     "Error when parsing test_info.yaml file. " + UserUtils.getStackTrace(e));
 591             return null;
 592         }
 593     }
 594 }