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