ModuleSettings.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2012-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.coreutils;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.logging.Level;

public class ModuleSettings {
 
    private final static Logger logger = Logger.getLogger(ModuleSettings.class.getName());
    private final static String MODULE_DIR_PATH = PlatformUtil.getUserConfigDirectory();
    private final static String SETTINGS_FILE_EXT = ".properties";
 
    /*
     * These SHOULD NOT be public and DO NOT belong in this file. They are being
     * retained only for the sake of backwards compatibility.
     */
    public static final String DEFAULT_CONTEXT = "GeneralContext"; //NON-NLS
    public static final String MAIN_SETTINGS = "Case"; //NON-NLS
    public static final String CURRENT_CASE_TYPE = "Current_Case_Type"; //NON-NLS

    public static synchronized boolean makeConfigFile(String moduleName) {
        if (!configExists(moduleName)) {
            File propPath = new File(getSettingsFilePath(moduleName));
            File parent = new File(propPath.getParent());
            if (!parent.exists()) {
                parent.mkdirs();
            }
            
            Properties props = new Properties();
            try {
                propPath.createNewFile();
                try (FileOutputStream fos = new FileOutputStream(propPath)) {
                    props.store(fos, "Created module settings file");
                }
            } catch (IOException ex) {
                logger.log(Level.SEVERE, String.format("Failed to create module settings file at %s)", propPath), ex); //NON-NLS
                return false;
            }
            return true;
        }
        return false;
    }

    public static synchronized boolean configExists(String moduleName) {
        return new File(getSettingsFilePath(moduleName)).exists();
    }

    public static synchronized boolean settingExists(String moduleName, String settingName) {
        if (!configExists(moduleName)) {
            return false;
        }
        
        try {
            Properties props = fetchProperties(moduleName);
            return (props.getProperty(settingName) != null);
        } catch (IOException ex) {
            logger.log(Level.SEVERE, String.format("Failed to get %s setting from module settings file at %s)", settingName, getSettingsFilePath(moduleName)), ex); //NON-NLS
            return false;
        }
    }

    static String getSettingsFilePath(String moduleName) {
        return Paths.get(MODULE_DIR_PATH, moduleName + SETTINGS_FILE_EXT).toString();
    }

    public static synchronized String getConfigSetting(String moduleName, String settingName) {
        if (!configExists(moduleName)) {
            makeConfigFile(moduleName);
        }
        
        try {
            Properties props = fetchProperties(moduleName);
            return props.getProperty(settingName);
        } catch (IOException ex) {
            logger.log(Level.SEVERE, String.format("Failed to get %s setting from module settings file at %s)", settingName, getSettingsFilePath(moduleName)), ex); //NON-NLS
            return null;
        }
    }

    public static synchronized Map<String, String> getConfigSettings(String moduleName) {
        if (!configExists(moduleName)) {
            makeConfigFile(moduleName);
        }
        
        try {
            Properties props = fetchProperties(moduleName);
            Set<String> keys = props.stringPropertyNames();
            Map<String, String> map = new HashMap<>();
            for (String s : keys) {
                map.put(s, props.getProperty(s));
            }
            return map;
        } catch (IOException ex) {
            logger.log(Level.SEVERE, String.format("Failed to get settings from module settings file at %s)", getSettingsFilePath(moduleName)), ex); //NON-NLS
            return null;
        }
    }

    public static synchronized void setConfigSettings(String moduleName, Map<String, String> settings) {
        if (!configExists(moduleName)) {
            makeConfigFile(moduleName);
        }
        
        try {
            Properties props = fetchProperties(moduleName);
            for (Map.Entry<String, String> kvp : settings.entrySet()) {
                props.setProperty(kvp.getKey(), kvp.getValue());
            }
            
            File path = new File(getSettingsFilePath(moduleName));
            try (FileOutputStream fos = new FileOutputStream(path)) {
                props.store(fos, "Set settings (batch)"); //NON-NLS
            }
        } catch (IOException ex) {
            logger.log(Level.SEVERE, String.format("Error writing to module settings file at %s)", getSettingsFilePath(moduleName)), ex); //NON-NLS
        }
    }

    public static synchronized void setConfigSetting(String moduleName, String settingName, String settingVal) {
        if (!configExists(moduleName)) {
            makeConfigFile(moduleName);
        }
        try {
            Properties props = fetchProperties(moduleName);
            props.setProperty(settingName, settingVal);
            File path = new File(getSettingsFilePath(moduleName));
            try (FileOutputStream fos = new FileOutputStream(path)) {
                props.store(fos, "Set " + settingName); //NON-NLS
            }
        } catch (IOException ex) {
            logger.log(Level.SEVERE, String.format("Error writing %s setting to module settings file at %s)", settingName, getSettingsFilePath(moduleName)), ex); //NON-NLS
        }
    }

    public static synchronized void removeProperty(String moduleName, String settingName) {
        try {
            if (getConfigSetting(moduleName, settingName) != null) {
                Properties props = fetchProperties(moduleName);
                props.remove(settingName);
                File path = new File(getSettingsFilePath(moduleName));
                try (FileOutputStream fos = new FileOutputStream(path)) {
                    props.store(fos, "Removed " + settingName); //NON-NLS
                }
            }
        } catch (IOException ex) {
            logger.log(Level.SEVERE, String.format("Error removing %s setting from module settings file at %s)", settingName, getSettingsFilePath(moduleName)), ex); //NON-NLS
        }
    }

    private static synchronized Properties fetchProperties(String moduleName) throws IOException {
        Properties props;
        try (InputStream inputStream = new FileInputStream(getSettingsFilePath(moduleName))) {
            props = new Properties();
            props.load(inputStream);
        }
        return props;
    }

    public static synchronized File getPropertyFile(String moduleName) {
        File configFile = null;
        if (configExists(moduleName)) {
            configFile = new File(getSettingsFilePath(moduleName));
        }
        return configFile;
    }

    private ModuleSettings() {
    }
 
}