path: root/src/main/java/com/android/vts/api/TestDataForDevServlet.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.api;

import com.android.vts.entity.BranchEntity;
import com.android.vts.entity.BuildTargetEntity;
import com.android.vts.entity.CodeCoverageEntity;
import com.android.vts.entity.CoverageEntity;
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.TestPlanEntity;
import com.android.vts.entity.TestPlanRunEntity;
import com.android.vts.entity.TestRunEntity;
import com.android.vts.entity.TestStatusEntity;
import com.android.vts.entity.TestStatusEntity.TestCaseReference;
import com.android.vts.entity.TestSuiteFileEntity;
import com.android.vts.entity.TestSuiteResultEntity;
import com.google.appengine.api.datastore.DatastoreFailureException;
import com.google.appengine.api.datastore.DatastoreService;
import com.google.appengine.api.datastore.DatastoreServiceFactory;
import com.google.appengine.api.datastore.DatastoreTimeoutException;
import com.google.appengine.api.datastore.Entity;
import com.google.appengine.api.datastore.EntityNotFoundException;
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.Transaction;
import com.google.appengine.api.users.User;
import com.google.appengine.api.users.UserService;
import com.google.appengine.api.users.UserServiceFactory;
import com.google.appengine.api.utils.SystemProperty;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.file.FileSystems;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Random;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.IntStream;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/** Servlet for handling requests to add mock data in datastore. */
public class TestDataForDevServlet extends HttpServlet {
    protected static final Logger logger = Logger.getLogger(TestDataForDevServlet.class.getName());

    /** Google Cloud Storage project's default directory name for suite test result files */
    private static String GCS_SUITE_TEST_FOLDER_NAME;

    /** datastore instance to save the test data into datastore through datastore library. */
    private DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
    /**
     * Gson is a Java library that can be used to convert Java Objects into their JSON
     * representation. It can also be used to convert a JSON string to an equivalent Java object.
     */
    private Gson gson = new GsonBuilder().create();

    /** System Configuration Property class */
    protected Properties systemConfigProp = new Properties();

    @Override
    public void init(ServletConfig cfg) throws ServletException {
        super.init(cfg);

        try {
            InputStream defaultInputStream =
                    TestDataForDevServlet.class
                            .getClassLoader()
                            .getResourceAsStream("config.properties");
            systemConfigProp.load(defaultInputStream);

            GCS_SUITE_TEST_FOLDER_NAME = systemConfigProp.getProperty("gcs.suiteTestFolderName");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * TestReportData class for mapping test-report-data.json. This internal class's each fields
     * will be automatically mapped to test-report-data.json file through Gson
     */
    private class TestReportDataObject {
        private List<Test> testList;

        private class Test {
            private List<TestRun> testRunList;

            private class TestRun {
                private String testName;
                private int type;
                private long startTimestamp;
                private long endTimestamp;
                private String testBuildId;
                private String hostName;
                private long passCount;
                private long failCount;
                private boolean hasCoverage;
                private long coveredLineCount;
                private long totalLineCount;
                private List<Long> testCaseIds;
                private List<Long> failingTestcaseIds;
                private List<Integer> failingTestcaseOffsets;
                private List<String> links;

                private List<Coverage> coverageList;
                private List<Profiling> profilingList;
                private List<TestCaseRun> testCaseRunList;
                private List<DeviceInfo> deviceInfoList;
                private List<BuildTarget> buildTargetList;
                private List<Branch> branchList;

                private class Coverage {
                    private String group;
                    private long coveredLineCount;
                    private long totalLineCount;
                    private String filePath;
                    private String projectName;
                    private String projectVersion;
                    private List<Long> lineCoverage;
                }

                private class Profiling {
                    private String name;
                    private int type;
                    private int regressionMode;
                    private List<String> labels;
                    private List<Long> values;
                    private String xLabel;
                    private String yLabel;
                    private List<String> options;
                }

                private class TestCaseRun {
                    private List<String> testCaseNames;
                    private List<Integer> results;
                }

                private class DeviceInfo {
                    private String branch;
                    private String product;
                    private String buildFlavor;
                    private String buildId;
                    private String abiBitness;
                    private String abiName;
                }

                private class BuildTarget {
                    private String targetName;
                }

                private class Branch {
                    private String branchName;
                }
            }
        }

        @Override
        public String toString() {
            return "(" + testList + ")";
        }
    }

    private class TestPlanReportDataObject {
        private List<TestPlan> testPlanList;

        private class TestPlan {

            private String testPlanName;
            private List<String> testModules;
            private List<Long> testTimes;
        }

        @Override
        public String toString() {
            return "(" + testPlanList + ")";
        }
    }

    private Map<String, Object> generateSuiteTestData(
            HttpServletRequest request, HttpServletResponse response) {
        Map<String, Object> resultMap = new HashMap<>();
        String fileSeparator = FileSystems.getDefault().getSeparator();
        Random rand = new Random();
        List<String> branchList = Arrays.asList("master", "oc_mr", "oc");
        List<String> targetList =
                Arrays.asList(
                        "sailfish-userdebug",
                        "marlin-userdebug",
                        "taimen-userdebug",
                        "walleye-userdebug",
                        "aosp_arm_a-userdebug");
        branchList.forEach(
                branch ->
                        targetList.forEach(
                                target ->
                                        IntStream.range(0, 10)
                                                .forEach(
                                                        idx -> {
                                                            String year =
                                                                    String.format(
                                                                            "%04d", 2010 + idx);
                                                            String month =
                                                                    String.format(
                                                                            "%02d",
                                                                            rand.nextInt(12));
                                                            String day =
                                                                    String.format(
                                                                            "%02d",
                                                                            rand.nextInt(30));
                                                            String fileName =
                                                                    String.format(
                                                                            "%02d%02d%02d.bin",
                                                                            rand.nextInt(23) + 1,
                                                                            rand.nextInt(59) + 1,
                                                                            rand.nextInt(59) + 1);

                                                            List<String> pathList =
                                                                    Arrays.asList(
                                                                            GCS_SUITE_TEST_FOLDER_NAME
                                                                                            == ""
                                                                                    ? "suite_result"
                                                                                    : GCS_SUITE_TEST_FOLDER_NAME,
                                                                            year,
                                                                            month,
                                                                            day,
                                                                            fileName);

                                                            Path pathInfo =
                                                                    Paths.get(
                                                                            String.join(
                                                                                    fileSeparator,
                                                                                    pathList));

                                                            TestSuiteFileEntity
                                                                    newTestSuiteFileEntity =
                                                                            new TestSuiteFileEntity(
                                                                                    pathInfo
                                                                                            .toString());

                                                            com.googlecode.objectify.Key<
                                                                    TestSuiteFileEntity>
                                                                    testSuiteFileParent =
                                                                            com.googlecode.objectify
                                                                                    .Key.create(
                                                                                    TestSuiteFileEntity
                                                                                            .class,
                                                                                    newTestSuiteFileEntity
                                                                                            .getFilePath());


                                                            TestSuiteResultEntity
                                                                    testSuiteResultEntity =
                                                                            new TestSuiteResultEntity(
                                                                                    testSuiteFileParent,
                                                                                    Instant.now()
                                                                                            .minus(
                                                                                                    rand
                                                                                                            .nextInt(
                                                                                                                    100),
                                                                                                    ChronoUnit
                                                                                                            .DAYS)
                                                                                            .getEpochSecond(),
                                                                                    Instant.now()
                                                                                            .minus(
                                                                                                    rand
                                                                                                            .nextInt(
                                                                                                                    100),
                                                                                                    ChronoUnit
                                                                                                            .DAYS)
                                                                                            .getEpochSecond(),
                                                                                    1,
                                                                                    idx / 2 == 0
                                                                                            ? false
                                                                                            : true,
                                                                                    pathInfo
                                                                                            .toString(),
                                                                                    idx / 2 == 0
                                                                                            ? "/error/infra/log"
                                                                                            : "",
                                                                                    "Test Place Name -"
                                                                                            + idx,
                                                                                    "Suite Test Plan",
                                                                                    "Suite Version "
                                                                                            + idx,
                                                                                    "Suite Test Name",
                                                                                    "Suite Build Number "
                                                                                            + idx,
                                                                                    rand.nextInt(),
                                                                                    rand.nextInt(),
                                                                                    branch,
                                                                                    target,
                                                                                    Long.toString(
                                                                                            Math
                                                                                                    .abs(
                                                                                                            rand
                                                                                                                    .nextLong())),
                                                                                    "Build System Fingerprint "
                                                                                            + idx,
                                                                                    "Build Vendor Fingerprint "
                                                                                            + idx,
                                                                                    rand.nextInt(),
                                                                                    rand.nextInt());

                                                            testSuiteResultEntity.save(newTestSuiteFileEntity);
                                                        })));
        resultMap.put("result", "successfully generated!");
        return resultMap;
    }

    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String requestUri = request.getRequestURI();
        String requestArgs = request.getQueryString();

        Map<String, Object> resultMap = new HashMap<>();
        String pathInfo = requestUri.replace("/api/test_data/", "");
        switch (pathInfo) {
            case "suite":
                resultMap = this.generateSuiteTestData(request, response);
                break;
            default:
                throw new IllegalArgumentException("Invalid path info of URL");
        }

        String json = new Gson().toJson(resultMap);
        response.setStatus(HttpServletResponse.SC_OK);
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");
        response.getWriter().write(json);
    }

    /** Add mock data to local dev datastore. */
    @Override
    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws IOException {
        if (SystemProperty.environment.value() == SystemProperty.Environment.Value.Production) {
            response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
            return;
        }

        UserService userService = UserServiceFactory.getUserService();
        User currentUser = userService.getCurrentUser();

        String pathInfo = request.getPathInfo();
        String[] pathParts = pathInfo.split("/");
        if (pathParts.length > 1) {
            // Read the json output
            Reader postJsonReader = new InputStreamReader(request.getInputStream());
            Gson gson = new GsonBuilder().create();

            String testType = pathParts[1];
            if (testType.equalsIgnoreCase("report")) {
                TestReportDataObject trdObj =
                        gson.fromJson(postJsonReader, TestReportDataObject.class);
                logger.log(Level.INFO, "trdObj => " + trdObj);
                trdObj.testList.forEach(
                        test -> {
                            test.testRunList.forEach(
                                    testRun -> {
                                        TestEntity testEntity = new TestEntity(testRun.testName);

                                        Key testRunKey =
                                                KeyFactory.createKey(
                                                        testEntity.getOldKey(),
                                                        TestRunEntity.KIND,
                                                        testRun.startTimestamp);

                                        List<TestCaseReference> failingTestCases =
                                                new ArrayList<>();
                                        for (int idx = 0;
                                                idx < testRun.failingTestcaseIds.size();
                                                idx++) {
                                            failingTestCases.add(
                                                    new TestCaseReference(
                                                            testRun.failingTestcaseIds.get(idx),
                                                            testRun.failingTestcaseOffsets.get(
                                                                    idx)));
                                        }

                                        TestStatusEntity testStatusEntity =
                                                new TestStatusEntity(
                                                        testRun.testName,
                                                        testRun.startTimestamp,
                                                        (int) testRun.passCount,
                                                        failingTestCases.size(),
                                                        failingTestCases);
                                        datastore.put(testStatusEntity.toEntity());

                                        testRun.coverageList.forEach(
                                                testRunCoverage -> {
                                                    CoverageEntity coverageEntity =
                                                            new CoverageEntity(
                                                                    testRunKey,
                                                                    testRunCoverage.group,
                                                                    testRunCoverage
                                                                            .coveredLineCount,
                                                                    testRunCoverage.totalLineCount,
                                                                    testRunCoverage.filePath,
                                                                    testRunCoverage.projectName,
                                                                    testRunCoverage.projectVersion,
                                                                    testRunCoverage.lineCoverage);
                                                    datastore.put(coverageEntity.toEntity());
                                                });

                                        testRun.profilingList.forEach(
                                                testRunProfile -> {
                                                    ProfilingPointRunEntity profilingEntity =
                                                            new ProfilingPointRunEntity(
                                                                    testRunKey,
                                                                    testRunProfile.name,
                                                                    testRunProfile.type,
                                                                    testRunProfile.regressionMode,
                                                                    testRunProfile.labels,
                                                                    testRunProfile.values,
                                                                    testRunProfile.xLabel,
                                                                    testRunProfile.yLabel,
                                                                    testRunProfile.options);
                                                    datastore.put(profilingEntity.toEntity());
                                                });

                                        TestCaseRunEntity testCaseEntity = new TestCaseRunEntity();
                                        testRun.testCaseRunList.forEach(
                                                testCaseRun -> {
                                                    for (int idx = 0;
                                                            idx < testCaseRun.testCaseNames.size();
                                                            idx++) {
                                                        testCaseEntity.addTestCase(
                                                                testCaseRun.testCaseNames.get(idx),
                                                                testCaseRun.results.get(idx));
                                                    }
                                                });
                                        datastore.put(testCaseEntity.toEntity());

                                        testRun.deviceInfoList.forEach(
                                                deviceInfo -> {
                                                    DeviceInfoEntity deviceInfoEntity =
                                                            new DeviceInfoEntity(
                                                                    testRunKey,
                                                                    deviceInfo.branch,
                                                                    deviceInfo.product,
                                                                    deviceInfo.buildFlavor,
                                                                    deviceInfo.buildId,
                                                                    deviceInfo.abiBitness,
                                                                    deviceInfo.abiName);
                                                    ;
                                                    datastore.put(deviceInfoEntity.toEntity());
                                                });

                                        testRun.buildTargetList.forEach(
                                                buildTarget -> {
                                                    BuildTargetEntity buildTargetEntity =
                                                            new BuildTargetEntity(
                                                                    buildTarget.targetName);
                                                    buildTargetEntity.save();
                                                });

                                        testRun.branchList.forEach(
                                                branch -> {
                                                    BranchEntity branchEntity =
                                                            new BranchEntity(branch.branchName);
                                                    branchEntity.save();
                                                });

                                        boolean hasCodeCoverage =
                                                testRun.totalLineCount > 0
                                                        && testRun.coveredLineCount >= 0;
                                        TestRunEntity testRunEntity =
                                                new TestRunEntity(
                                                        testEntity.getOldKey(),
                                                        testRun.type,
                                                        testRun.startTimestamp,
                                                        testRun.endTimestamp,
                                                        testRun.testBuildId,
                                                        testRun.hostName,
                                                        testRun.passCount,
                                                        testRun.failCount,
                                                        hasCodeCoverage,
                                                        testRun.testCaseIds,
                                                        testRun.links);
                                        datastore.put(testRunEntity.toEntity());

                                        CodeCoverageEntity codeCoverageEntity =
                                                new CodeCoverageEntity(
                                                        testRunEntity.getKey(),
                                                        testRun.coveredLineCount,
                                                        testRun.totalLineCount);
                                        datastore.put(codeCoverageEntity.toEntity());

                                        Entity newTestEntity = testEntity.toEntity();

                                        Transaction txn = datastore.beginTransaction();
                                        try {
                                            // Check if test already exists in the datastore
                                            try {
                                                Entity oldTest =
                                                        datastore.get(testEntity.getOldKey());
                                                TestEntity oldTestEntity =
                                                        TestEntity.fromEntity(oldTest);
                                                if (oldTestEntity == null
                                                        || !oldTestEntity.equals(testEntity)) {
                                                    datastore.put(newTestEntity);
                                                }
                                            } catch (EntityNotFoundException e) {
                                                datastore.put(newTestEntity);
                                            }
                                            txn.commit();

                                        } catch (ConcurrentModificationException
                                                | DatastoreFailureException
                                                | DatastoreTimeoutException e) {
                                            logger.log(
                                                    Level.WARNING,
                                                    "Retrying test run insert: "
                                                            + newTestEntity.getKey());
                                        } finally {
                                            if (txn.isActive()) {
                                                logger.log(
                                                        Level.WARNING,
                                                        "Transaction rollback forced for run: "
                                                                + testRunEntity.getKey());
                                                txn.rollback();
                                            }
                                        }
                                    });
                        });
            } else {
                TestPlanReportDataObject tprdObj =
                        gson.fromJson(postJsonReader, TestPlanReportDataObject.class);
                tprdObj.testPlanList.forEach(
                        testPlan -> {
                            Entity testPlanEntity =
                                    new TestPlanEntity(testPlan.testPlanName).toEntity();
                            List<Key> testRunKeys = new ArrayList<>();
                            for (int idx = 0; idx < testPlan.testModules.size(); idx++) {
                                String test = testPlan.testModules.get(idx);
                                long time = testPlan.testTimes.get(idx);
                                Key parentKey = KeyFactory.createKey(TestEntity.KIND, test);
                                Key testRunKey =
                                        KeyFactory.createKey(parentKey, TestRunEntity.KIND, time);
                                testRunKeys.add(testRunKey);
                            }
                            Map<Key, Entity> testRuns = datastore.get(testRunKeys);
                            long passCount = 0;
                            long failCount = 0;
                            long startTimestamp = -1;
                            long endTimestamp = -1;
                            String testBuildId = null;
                            long type = 0;
                            Set<DeviceInfoEntity> devices = new HashSet<>();
                            for (Key testRunKey : testRuns.keySet()) {
                                TestRunEntity testRun =
                                        TestRunEntity.fromEntity(testRuns.get(testRunKey));
                                if (testRun == null) {
                                    continue; // not a valid test run
                                }
                                passCount += testRun.getPassCount();
                                failCount += testRun.getFailCount();
                                if (startTimestamp < 0 || testRunKey.getId() < startTimestamp) {
                                    startTimestamp = testRunKey.getId();
                                }
                                if (endTimestamp < 0 || testRun.getEndTimestamp() > endTimestamp) {
                                    endTimestamp = testRun.getEndTimestamp();
                                }
                                type = testRun.getType();
                                testBuildId = testRun.getTestBuildId();
                                Query deviceInfoQuery =
                                        new Query(DeviceInfoEntity.KIND).setAncestor(testRunKey);
                                for (Entity deviceInfoEntity :
                                        datastore.prepare(deviceInfoQuery).asIterable()) {
                                    DeviceInfoEntity device =
                                            DeviceInfoEntity.fromEntity(deviceInfoEntity);
                                    if (device == null) {
                                        continue; // invalid entity
                                    }
                                    devices.add(device);
                                }
                            }
                            if (startTimestamp < 0 || testBuildId == null || type == 0) {
                                logger.log(
                                        Level.WARNING,
                                        "Couldn't infer test run information from runs.");
                                return;
                            }
                            TestPlanRunEntity testPlanRun =
                                    new TestPlanRunEntity(
                                            testPlanEntity.getKey(),
                                            testPlan.testPlanName,
                                            type,
                                            startTimestamp,
                                            endTimestamp,
                                            testBuildId,
                                            passCount,
                                            failCount,
                                            0L,
                                            0L,
                                            testRunKeys);

                            // Create the device infos.
                            for (DeviceInfoEntity device : devices) {
                                datastore.put(
                                        device.copyWithParent(testPlanRun.getOfyKey()).toEntity());
                            }
                            datastore.put(testPlanRun.toEntity());

                            Transaction txn = datastore.beginTransaction();
                            try {
                                // Check if test already exists in the database
                                try {
                                    datastore.get(testPlanEntity.getKey());
                                } catch (EntityNotFoundException e) {
                                    datastore.put(testPlanEntity);
                                }
                                txn.commit();
                            } catch (ConcurrentModificationException
                                    | DatastoreFailureException
                                    | DatastoreTimeoutException e) {
                                logger.log(
                                        Level.WARNING,
                                        "Retrying test plan insert: " + testPlanEntity.getKey());
                            } finally {
                                if (txn.isActive()) {
                                    logger.log(
                                            Level.WARNING,
                                            "Transaction rollback forced for plan run: "
                                                    + testPlanRun.key);
                                    txn.rollback();
                                }
                            }
                        });
            }
        } else {
            logger.log(Level.WARNING, "URL path parameter is omitted!");
        }

        response.setStatus(HttpServletResponse.SC_OK);
    }
}