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