path: root/src/org/gnunet/util/Configuration.java

/*
     This file is part of GNUnet.
     (C) 2009 Christian Grothoff (and other contributing authors)

     GNUnet is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published
     by the Free Software Foundation; either version 2, or (at your
     option) any later version.

     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with GNUnet; see the file COPYING.  If not, write to the
     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */

package org.gnunet.util;

import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;
import com.google.common.io.Files;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Configuration management.
 *
 * @author Florian Dold
 */
public class Configuration {
    public static class ParsingError extends RuntimeException {
        ParsingError(String msg) {
            super(msg);
        }

        ParsingError(String msg, final Throwable t) {
            super(msg, t);
        }
    }

    private static final Logger logger = LoggerFactory
            .getLogger(Configuration.class);

    private static Pattern section = Pattern.compile("\\[(.*?)\\]");
    private static Pattern tag = Pattern.compile("(\\S+?)\\s*=(.*?)");
    private static Pattern whitspace = Pattern.compile("\\s*");

    // rows are sections, colums are options
    private final Table<String, String, String> sections = HashBasedTable.create();

    private final Map<String, Set<String>> sectionSources = new HashMap<String, Set<String>>(20);

    /**
     * Start with an empty configuration.
     */
    public Configuration() {
    }


    /**
     * Expand an expression of the form "$FOO/BAR" to "DIRECTORY/BAR" where
     * either in the "PATHS" section or the environment "FOO" is set to
     * "DIRECTORY".
     *
     * @param orig string to $-expand
     * @return $-expanded string
     */
    public String expandDollar(String orig) {
        Map<String, String> env = System.getenv();
        for (final Map.Entry<String, String> e : env.entrySet()) {
            orig = orig.replace("$" + e.getKey(), e.getValue());
        }

        for (final Map.Entry<String, String> e : sections.row("PATHS").entrySet()) {
            orig = orig.replace("$" + e.getKey(), e.getValue());
        }
        return orig;
    }

    /**
     * Returns all configuration options in a section.
     *
     * @param s the section of interest
     * @return an unmodifiable view of the section.
     */
    public Map<String, String> getSection(String s) {
        Map<String, String> m = sections.row(s);
        return Collections.unmodifiableMap(m);
    }

    /**
     * Returns the names of all non-empty sections
     *
     * @return set of non-empty section names
     */
    public Set<String> getSections() {
        return sections.rowKeySet();
    }

    /**
     * Get a configuration value that should be in a set of predefined strings
     *
     * @param section section of interest
     * @param option  option of interest
     * @param choices list of legal values
     * @return matching value from choices
     */
    public String getValueChoice(String section, String option,
                                 Iterable<String> choices) {
        String value = getValueString(section, option);
        if (value == null) {
            throw new ParsingError(String.format(
                    "Failure in configuration section %s: value not found",
                    section));
        }
        for (String c : choices) {
            if (c.equals(value)) {
                return value;
            }
        }
        throw new ParsingError(String.format(
                "Failure in configuration section %s: invalid value", section));
    }


    /**
     * Get a configuration value that should be a number
     *
     * @param section section of interest
     * @param option  option of interest
     * @return null if value not in configuration, the option's value otherwise
     */
    public long getValueNumer(String section, String option) {
        String num_str = getValueString(section, option);
        if (num_str == null) {
            logSectionSources(section);
            throw new ParsingError("Failure in configuration section "
                    + section + " option " + option + ": value empty");
        }
        try {
            return Long.parseLong(num_str);
        } catch (NumberFormatException e) {
            throw new ParsingError("Failure in configuration section "
                    + section + " option " + option + ": " + e.getMessage(), e);
        }
    }

    private void logSectionSources(String section) {
        Set<String> sources = sectionSources.get(section);
        if (sources == null) {
            logger.info("No sources for section '{}'", section);
        } else {
            logger.info("Sources for section '{}': {}", section, sources);
        }
    }

    /**
     * Set an option to a string value in a section.
     *
     * @param section section of interest
     * @param option  option of interest
     * @return value
     */
    public String getValueString(String section, String option) {
        ensureSectionExists(section);
        return sections.get(section, option);
    }

    /**
     * Gets a configuration value that should be in a set of {"YES","NO"}.
     *
     * @param section section of interest
     * @param option  option of interest
     * @return true, false, null
     */
    public boolean getValueYesNo(String section, String option) {
        final String v = getValueChoice(section, option,
                Arrays.asList("YES", "NO"));
        if (v == null) {
            Set<String> sources = sectionSources.get(section);
            if (sources == null) {
                logger.info("No sources for section '{}'", section);
            } else {
                logger.info("Sources for section '{}': {}", section, sources);
            }
            throw new ParsingError(String.format(
                    "Failure in configuration section '%s': option '%s' not found",
                    section, option));
        }
        if (v.equals("YES")) {
            return true;
        }
        if (v.equals("NO")) {
            return false;
        }
        throw new ParsingError(
                "Configuration error: value not recognized as YES or NO");
    }

    /**
     * Tests if we have a value for a particular option.
     *
     * @param section section of interest
     * @param option  option of interest
     * @return true if so, false of not
     */
    public boolean haveValue(String section, String option) {
        return sections.contains(section, option);
    }

    /**
     * Parse a configuration file, add all of the options in the file to the
     * configuration environment.
     *
     * @param filename name of the configuration file
     */
    public void parse(String filename) {
        filename = replaceHome(filename);

        String current_section = "";

        Iterator<String> it;

        try {
            List<String> lines = Files.readLines(new File(filename), Charset.defaultCharset());
            it = lines.iterator();
        } catch (IOException e) {
            throw new ParsingError("Cannot read configuration file '" + filename + "'");
        }

        int lineNumer = 1;

        while (it.hasNext()) {
            String line = it.next();
            // strip comment
            line = line.split("#")[0];
            Matcher m;

            if ((m = tag.matcher(line)).matches()) {
                String option = m.group(1).trim();
                String value = m.group(2).trim();

                if (value.length() != 0 && value.charAt(0) == '"') {
                    int pos = value.indexOf('"', 1);
                    if (pos == -1) {
                        logger.warn("incorrecly quoted config value");
                        continue;
                    }
                    value = value.substring(1, pos);
                }
                setValueString(current_section, option, value);
            } else if ((m = section.matcher(line)).matches()) {
                current_section = m.group(1).trim();
                if (sectionSources.containsKey(current_section)) {
                    sectionSources.get(current_section).add(filename);
                } else {
                    sectionSources.put(current_section, new HashSet<String>(Collections.singleton(filename)));
                }
            } else if (whitspace.matcher(line).matches()) {
                // whitespace is ok
            } else {
                logger.warn(String.format("skipped unreadable line %s in configuration file '%s': '%s'", lineNumer,
                        filename, line));
            }

            lineNumer++;
        }
    }

    private String replaceHome(String filename) {
        String home = System.getenv("HOME");
        return home != null ? filename.replace("~", home) : filename;
    }

    /**
     * Remove the given section and all options in it.
     */
    public void removeSection(String section) {
        sections.row(section).clear();
    }

    /**
     * Set an option to a string value in a section.
     *
     * @param section section of interest
     * @param option  option of interest
     * @param value   value to set
     */
    public void setValueNumber(String section, String option,
                               long value) {
        setValueString(section, option, "" + value);
    }

    /**
     * Set an option to a string value in a section.
     *
     * @param section section of interest
     * @param option  option of interest
     * @param value   value to set
     */
    public void setValueString(String section, String option,
                               String value) {
        sections.put(section, option, value);
    }

    /**
     * Write configuration file.
     *
     * @param filename where to write the configuration
     */
    public void write(String filename) throws IOException {
        BufferedWriter w = new BufferedWriter(new FileWriter(new File(
                filename)));
        for (String section : sections.rowKeySet()) {
            w.write("["+section+"]");
            w.newLine();
            for (Map.Entry<String,String> e : sections.row(section).entrySet()) {
                w.write(e.getKey() + " = " + e.getValue());
                w.newLine();
            }
        }
        w.close();
    }


    public void loadDefaults() {
        Collection<File> dirs = new ArrayList<File>(5);
        dirs.add(new File("/usr/share/gnunet/config.d/"));
        dirs.add(new File("/usr/local/share/gnunet/config.d/"));
        String pfx = System.getenv("GNUNET_PREFIX");
        if (pfx != null) {
            dirs.add(new File(pfx, "share/gnunet/config.d/"));
            dirs.add(new File(pfx, "config.d/"));
            dirs.add(new File(pfx, "gnunet/config.d/"));
        }
        for (File dir : dirs) {
            if (dir.exists() && dir.isDirectory()) {
                File[] files = dir.listFiles();
                if (files == null) {
                    continue;
                }
                for (File f : files) {
                    parse(f.getAbsolutePath());
                }
            }
        }
    }

    private void ensureSectionExists(String section) {
        if (!sections.containsRow(section)) {
            throw new ConfigurationException("Required section '" + section + "' not in configuration");
        }
    }

    public static class ConfigurationException extends RuntimeException {
        public ConfigurationException(String string) {
            super(string);
        }
    }
}