path: root/src/main/java/com/android/vts/servlet/ShowTreeServlet.java

/*
 * Copyright (c) 2017 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you
 * may not use this file except in compliance with the License. You may
 * obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

package com.android.vts.servlet;

import com.android.vts.entity.DeviceInfoEntity;
import com.android.vts.entity.ProfilingPointRunEntity;
import com.android.vts.entity.TestCaseRunEntity;
import com.android.vts.entity.TestEntity;
import com.android.vts.entity.TestRunEntity;
import com.android.vts.proto.VtsReportMessage.TestCaseResult;
import com.android.vts.util.DatastoreHelper;
import com.android.vts.util.FilterUtil;
import com.android.vts.util.TestRunDetails;
import com.android.vts.util.TestRunMetadata;
import com.google.appengine.api.datastore.DatastoreService;
import com.google.appengine.api.datastore.DatastoreServiceFactory;
import com.google.appengine.api.datastore.Entity;
import com.google.appengine.api.datastore.Key;
import com.google.appengine.api.datastore.KeyFactory;
import com.google.appengine.api.datastore.Query;
import com.google.appengine.api.datastore.Query.Filter;
import com.google.appengine.api.datastore.Query.SortDirection;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet for handling requests to load individual tables.
 */
public class ShowTreeServlet extends BaseServlet {

  private static final String TABLE_JSP = "WEB-INF/jsp/show_tree.jsp";
  // Error message displayed on the webpage is tableName passed is null.
  private static final String TABLE_NAME_ERROR = "Error : Table name must be passed!";
  private static final String PROFILING_DATA_ALERT = "No profiling data was found.";
  private static final int MAX_RESULT_COUNT = 60;
  private static final int MAX_PREFETCH_COUNT = 10;

  @Override
  public PageType getNavParentType() {
    return PageType.TOT;
  }

  @Override
  public List<Page> getBreadcrumbLinks(HttpServletRequest request) {
    List<Page> links = new ArrayList<>();
    String testName = request.getParameter("testName");
    links.add(new Page(PageType.TREE, testName, "?testName=" + testName));
    return links;
  }

  /**
   * Get the test run details for a test run.
   *
   * @param metadata The metadata for the test run whose details will be fetched.
   * @return The TestRunDetails object for the provided test run.
   */
  public static TestRunDetails processTestDetails(TestRunMetadata metadata) {
    DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
    TestRunDetails details = new TestRunDetails();
    List<Key> gets = new ArrayList<>();
    for (long testCaseId : metadata.testRun.getTestCaseIds()) {
      gets.add(KeyFactory.createKey(TestCaseRunEntity.KIND, testCaseId));
    }
    Map<Key, Entity> entityMap = datastore.get(gets);
    for (int i = 0; i < 1; i++) {
      for (Key key : entityMap.keySet()) {
        TestCaseRunEntity testCaseRun = TestCaseRunEntity.fromEntity(entityMap.get(key));
        if (testCaseRun == null) {
          continue;
        }
        details.addTestCase(testCaseRun);
      }
    }
    return details;
  }

  @Override
  public void doGetHandler(HttpServletRequest request, HttpServletResponse response)
      throws IOException {
    boolean unfiltered = request.getParameter("unfiltered") != null;
    boolean showPresubmit = request.getParameter("showPresubmit") != null;
    boolean showPostsubmit = request.getParameter("showPostsubmit") != null;
    Long startTime = null; // time in microseconds
    Long endTime = null; // time in microseconds
    DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
    RequestDispatcher dispatcher = null;

    // message to display if profiling point data is not available
    String profilingDataAlert = "";

    if (request.getParameter("testName") == null) {
      request.setAttribute("testName", TABLE_NAME_ERROR);
      return;
    }
    String testName = request.getParameter("testName");

    if (request.getParameter("startTime") != null) {
      String time = request.getParameter("startTime");
      try {
        startTime = Long.parseLong(time);
        startTime = startTime > 0 ? startTime : null;
      } catch (NumberFormatException e) {
        startTime = null;
      }
    }
    if (request.getParameter("endTime") != null) {
      String time = request.getParameter("endTime");
      try {
        endTime = Long.parseLong(time);
        endTime = endTime > 0 ? endTime : null;
      } catch (NumberFormatException e) {
        endTime = null;
      }
    }

    // If no params are specified, set to default of postsubmit-only.
    if (!(showPresubmit || showPostsubmit)) {
      showPostsubmit = true;
    }

    // If unfiltered, set showPre- and Post-submit to true for accurate UI.
    if (unfiltered) {
      showPostsubmit = true;
      showPresubmit = true;
    }

    // Add result names to list
    List<String> resultNames = new ArrayList<>();
    for (TestCaseResult r : TestCaseResult.values()) {
      resultNames.add(r.name());
    }

    SortDirection dir = SortDirection.DESCENDING;
    if (startTime != null && endTime == null) {
      dir = SortDirection.ASCENDING;
    }
    Key testKey = KeyFactory.createKey(TestEntity.KIND, testName);

    Filter typeFilter = FilterUtil.getTestTypeFilter(showPresubmit, showPostsubmit, unfiltered);
    Filter testFilter =
        FilterUtil.getTimeFilter(
            testKey, TestRunEntity.KIND, startTime, endTime, typeFilter);

    Map<String, String[]> parameterMap = request.getParameterMap();
    List<Filter> userTestFilters = FilterUtil.getUserTestFilters(parameterMap);
    userTestFilters.add(0, testFilter);
    Filter userDeviceFilter = FilterUtil.getUserDeviceFilter(parameterMap);

    List<TestRunMetadata> testRunMetadata = new ArrayList<>();
    Map<Key, TestRunMetadata> metadataMap = new HashMap<>();
    Key minKey = null;
    Key maxKey = null;
    List<Key> gets =
        FilterUtil.getMatchingKeys(
            testKey,
            TestRunEntity.KIND,
            userTestFilters,
            userDeviceFilter,
            dir,
            MAX_RESULT_COUNT);
    Map<Key, Entity> entityMap = datastore.get(gets);
    for (Key key : gets) {
      if (!entityMap.containsKey(key)) {
        continue;
      }
      TestRunEntity testRunEntity = TestRunEntity.fromEntity(entityMap.get(key));
      if (testRunEntity == null) {
        continue;
      }
      if (minKey == null || key.compareTo(minKey) < 0) {
        minKey = key;
      }
      if (maxKey == null || key.compareTo(maxKey) > 0) {
        maxKey = key;
      }
      TestRunMetadata metadata = new TestRunMetadata(testName, testRunEntity);
      testRunMetadata.add(metadata);
      metadataMap.put(key, metadata);
    }

    List<String> profilingPointNames = new ArrayList<>();
    if (minKey != null && maxKey != null) {
      Filter deviceFilter =
          FilterUtil.getDeviceTimeFilter(
              testKey, TestRunEntity.KIND, minKey.getId(), maxKey.getId());
      Query deviceQuery =
          new Query(DeviceInfoEntity.KIND)
              .setAncestor(testKey)
              .setFilter(deviceFilter)
              .setKeysOnly();
      List<Key> deviceGets = new ArrayList<>();
      for (Entity device :
          datastore
              .prepare(deviceQuery)
              .asIterable(DatastoreHelper.getLargeBatchOptions())) {
        if (metadataMap.containsKey(device.getParent())) {
          deviceGets.add(device.getKey());
        }
      }
      Map<Key, Entity> devices = datastore.get(deviceGets);
      for (Key key : devices.keySet()) {
        if (!metadataMap.containsKey(key.getParent())) {
          continue;
        }
        DeviceInfoEntity device = DeviceInfoEntity.fromEntity(devices.get(key));
        if (device == null) {
          continue;
        }
        TestRunMetadata metadata = metadataMap.get(key.getParent());
        metadata.addDevice(device);
      }

      Filter profilingFilter =
          FilterUtil.getProfilingTimeFilter(
              testKey, TestRunEntity.KIND, minKey.getId(), maxKey.getId());

      Set<String> profilingPoints = new HashSet<>();
      Query profilingPointQuery =
          new Query(ProfilingPointRunEntity.KIND)
              .setAncestor(testKey)
              .setFilter(profilingFilter)
              .setKeysOnly();
      for (Entity e : datastore.prepare(profilingPointQuery).asIterable()) {
        profilingPoints.add(e.getKey().getName());
      }

      if (profilingPoints.size() == 0) {
        profilingDataAlert = PROFILING_DATA_ALERT;
      }
      profilingPointNames.addAll(profilingPoints);
      profilingPointNames.sort(Comparator.naturalOrder());
    }

    testRunMetadata.sort(
        (t1, t2) ->
            new Long(t2.testRun.getStartTimestamp()).compareTo(t1.testRun.getStartTimestamp()));
    List<JsonObject> testRunObjects = new ArrayList<>();

    int prefetchCount = 0;
    for (TestRunMetadata metadata : testRunMetadata) {
      if (metadata.testRun.getFailCount() > 0 && prefetchCount < MAX_PREFETCH_COUNT) {
        // process
        metadata.addDetails(processTestDetails(metadata));
        ++prefetchCount;
      }
      testRunObjects.add(metadata.toJson());
    }

    int[] topBuildResultCounts = null;
    String topBuild = "";
    if (testRunMetadata.size() > 0) {
      TestRunMetadata firstRun = testRunMetadata.get(0);
      topBuild = firstRun.getDeviceInfo();
      endTime = firstRun.testRun.getStartTimestamp();
      TestRunDetails topDetails = firstRun.getDetails();
      if (topDetails == null) {
        topDetails = processTestDetails(firstRun);
      }
      topBuildResultCounts = topDetails.resultCounts;

      TestRunMetadata lastRun = testRunMetadata.get(testRunMetadata.size() - 1);
      startTime = lastRun.testRun.getStartTimestamp();
    }

    FilterUtil.setAttributes(request, parameterMap);

    request.setAttribute("testName", request.getParameter("testName"));

    request.setAttribute("error", profilingDataAlert);

    request.setAttribute("profilingPointNames", profilingPointNames);
    request.setAttribute("resultNames", resultNames);
    request.setAttribute("resultNamesJson", new Gson().toJson(resultNames));
    request.setAttribute("testRuns", new Gson().toJson(testRunObjects));

    // data for pie chart
    request.setAttribute("topBuildResultCounts", new Gson().toJson(topBuildResultCounts));
    request.setAttribute("topBuildId", topBuild);
    request.setAttribute("startTime", new Gson().toJson(startTime));
    request.setAttribute("endTime", new Gson().toJson(endTime));
    request.setAttribute(
        "hasNewer",
        new Gson().toJson(DatastoreHelper.hasNewer(testKey, TestRunEntity.KIND, endTime)));
    request.setAttribute(
        "hasOlder",
        new Gson()
            .toJson(DatastoreHelper.hasOlder(testKey, TestRunEntity.KIND, startTime)));
    request.setAttribute("unfiltered", unfiltered);
    request.setAttribute("showPresubmit", showPresubmit);
    request.setAttribute("showPostsubmit", showPostsubmit);

    request.setAttribute("branches", new Gson().toJson(DatastoreHelper.getAllBranches()));
    request.setAttribute("devices", new Gson().toJson(DatastoreHelper.getAllBuildFlavors()));

    dispatcher = request.getRequestDispatcher(TABLE_JSP);
    try {
      dispatcher.forward(request, response);
    } catch (ServletException e) {
      logger.log(Level.SEVERE, "Servlet Exception caught : " + e.toString());
    }
  }
}