ConfigDeserializer.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2020 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * 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 org.sleuthkit.autopsy.integrationtesting.config;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.CollectionType;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import org.sleuthkit.autopsy.coreutils.Logger;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.collections.CollectionUtils;
import org.sleuthkit.autopsy.integrationtesting.PathUtil;

public class ConfigDeserializer {

    private static final String JSON_EXT = "json";
    private static final Logger logger = Logger.getLogger(ConfigDeserializer.class.getName());
    private static final ObjectMapper mapper = new ObjectMapper();

    // The following are the keys that must be provided as arguments (prefixed with 'integration-test.')
    // A config file key must be specifed or at least the test suites path, and output path.
    // If a config specifying the EnvConfig json exists, specify this path to load it
    private static final String CONFIG_FILE_KEY = "configFile";
    // expecting properties are marked as "integration-test.propVal"
    private static final String INTEGRATION_TEST_NAMESPACE = "integration-test";

    public EnvConfig getEnvConfigFromSysProps() throws IOException, IllegalStateException {
        String configFileKey = String.join(".", INTEGRATION_TEST_NAMESPACE, CONFIG_FILE_KEY);
        if (System.getProperty(configFileKey) != null) {
            // try to load from file if value is present
            String fileLoc = System.getProperty(configFileKey);
            File envConfigFile = new File(fileLoc);
            if (envConfigFile.exists()) {
                return getEnvConfig(envConfigFile);
            } else {
                throw new IllegalStateException(String.format("No file exists at %s", fileLoc));
            }
        } else {
            // otherwise, try to load from properties
            try {
                Map<String, Object> integrationProperties = getOrCreate(getSysPropsMap(), INTEGRATION_TEST_NAMESPACE);
                return validate(null, convertToObj(integrationProperties, EnvConfig.class));
            } catch (IllegalStateException ex) {
                throw new IllegalStateException("EnvConfig could not be determined from system property values", ex);
            }
        }
    }

    private Map<String, Object> getSysPropsMap() {
        Map<String, Object> mapToRet = new HashMap<>();

        for (String key : System.getProperties().stringPropertyNames()) {
            String value = System.getProperty(key);

            String[] keyPieces = key.split("\\.");
            Map<String, Object> mapToAddTo = mapToRet;
            for (int i = 0; i < keyPieces.length - 1; i++) {
                mapToAddTo = getOrCreate(mapToAddTo, keyPieces[i]);
            }

            mapToAddTo.put(keyPieces[keyPieces.length - 1], value);
        }

        return mapToRet;
    }

    private static class StringObjMap extends HashMap<String, Object> {

        private static final long serialVersionUID = 1L;

        StringObjMap() {
        }

    }

    private Map<String, Object> getOrCreate(Map<String, Object> parent, String key) {
        Object child = parent.get(key);
        if (child instanceof StringObjMap) {
            return (StringObjMap) child;
        } else {
            Map<String, Object> toRet = new StringObjMap();
            parent.put(key, toRet);
            return toRet;
        }
    }

    public <T> T convertToObj(Map<String, Object> toConvert, Type clazz) {
        GsonBuilder builder = new GsonBuilder();
        Gson gson = builder.create();
        JsonElement jsonElement = gson.toJsonTree(toConvert);
        return gson.fromJson(jsonElement, clazz);
    }

    public IntegrationTestConfig getIntegrationTestConfig() throws IOException, IllegalStateException {
        EnvConfig envConfig = getEnvConfigFromSysProps();
        String testSuiteConfigPath = PathUtil.getAbsolutePath(envConfig.getWorkingDirectory(), envConfig.getRootTestSuitesPath());

        return new IntegrationTestConfig(
                getTestSuiteConfigs(new File(testSuiteConfigPath)),
                envConfig
        );
    }

    public EnvConfig getEnvConfig(File envConfigFile) throws IOException, IllegalStateException {
        EnvConfig config = mapper.readValue(envConfigFile, EnvConfig.class);
        return validate(envConfigFile, config);
    }

    private EnvConfig validate(File envConfigFile, EnvConfig config) throws IllegalStateException {
        // set working directory based off of parent of envConfigFile if that parent exists
        if (config.getWorkingDirectory() == null && envConfigFile != null && envConfigFile.getParentFile() != null) {
            config.setWorkingDirectory(envConfigFile.getParentFile().getAbsolutePath());
        }

        // env config should be non-null after validation
        if (config == null
                || StringUtils.isBlank(config.getRootCaseOutputPath())
                || StringUtils.isBlank(config.getRootTestOutputPath())) {
            throw new IllegalStateException("EnvConfig must have the root case output path and the root test output path set.");
        }

        return config;
    }

    public List<TestSuiteConfig> getTestSuiteConfig(File rootDirectory, File configFile) {
        try {
            JsonNode root = mapper.readTree(configFile);
            if (root.isArray()) {
                // Define a collection type of List<TestSuiteConfig> for the purposes of json deserialization.
                CollectionType listClass = mapper.getTypeFactory().constructCollectionType(List.class,
                        TestSuiteConfig.class
                );

                // This suppresses compiler warning for this cast.
                @SuppressWarnings("unchecked")
                List<TestSuiteConfig> testSuites = (List<TestSuiteConfig>) mapper.readValue(mapper.treeAsTokens(root), listClass);

                return validate(rootDirectory, configFile, testSuites);
            } else {
                return validate(rootDirectory, configFile, Arrays.asList(mapper.treeToValue(root, TestSuiteConfig.class
                )));
            }
        } catch (IOException ex) {
            logger.log(Level.WARNING, "Unable to read test suite config at " + configFile.getPath(), ex);
            return Collections.emptyList();
        }
    }

    public List<TestSuiteConfig> getTestSuiteConfigs(File fileOrDirectory) {
        if (fileOrDirectory.isDirectory()) {
            Collection<File> jsonFiles = FileUtils.listFiles(fileOrDirectory, new String[]{JSON_EXT}, true);
            return jsonFiles.stream()
                    .flatMap((file) -> getTestSuiteConfig(fileOrDirectory, file).stream())
                    .collect(Collectors.toList());
        } else if (fileOrDirectory.isFile()) {
            return getTestSuiteConfig(fileOrDirectory, fileOrDirectory);
        }

        logger.log(Level.WARNING, "Unable to read file at: {0}", fileOrDirectory);
        return Collections.emptyList();
    }

    private List<TestSuiteConfig> validate(File rootDirectory, File file, List<TestSuiteConfig> testSuites) {
        return IntStream.range(0, testSuites.size())
                .mapToObj(idx -> validate(rootDirectory, file, idx, testSuites.get(idx)))
                .filter(c -> c != null)
                .collect(Collectors.toList());
    }

    private TestSuiteConfig validate(File rootDirectory, File file, int index, TestSuiteConfig config) {
        if (config == null
                || StringUtils.isBlank(config.getName())
                || config.getCaseTypes() == null
                || CollectionUtils.isEmpty(config.getDataSources())
                || config.getIntegrationTests() == null) {

            logger.log(Level.WARNING, String.format("Item in %s at index %d must contain a valid 'name', 'caseTypes', 'dataSources', and 'integrationTests'", file.toString(), index));
            return null;
        }

        if (config.getRelativeOutputPath() == null) {
            // taken from https://stackoverflow.com/questions/204784/how-to-construct-a-relative-path-in-java-from-two-absolute-paths-or-urls
            String relative = rootDirectory.toURI().relativize(file.toURI()).getPath();
            if (relative.endsWith("." + JSON_EXT)) {
                relative = relative.substring(0, relative.length() - ("." + JSON_EXT).length());
            }
            config.setRelativeOutputPath(relative);
        }

        return config;
    }
}