[RFC] netx: add support for parsing and saving deployment.config files
Deepak Bhole
dbhole at redhat.com
Tue Oct 26 14:37:57 PDT 2010
* Omair Majid <omajid at redhat.com> [2010-10-25 09:42]:
> On 10/21/2010 05:39 PM, Deepak Bhole wrote:
> >* Omair Majid<omajid at redhat.com> [2010-10-21 17:26]:
> >>On 10/21/2010 05:05 PM, Deepak Bhole wrote:
> >>>* Omair Majid<omajid at redhat.com> [2010-10-18 11:48]:
> >>>>Hi,
> >>>>
> >>>>As described on [1], The Java Plug-in and Java Web Start support
> >>>>using various deployment.properties and deployment.config files to
> >>>>set behaviour of these tools. The patch adds support for parsing and
> >>>>saving these files to netx. This patch does not actually use any of
> >>>>these settings; it just adds support so other parts of netx can
> >>>>start using them.
> >>>>
> >>>>This was filed as a bug by someone against the original netx project [2].
> >>>>
> >>>>Any comments or concerns?
> >>>>
> >>>>Thanks,
> >>>>Omair
> >>>>
> >>>>[1] http://download.oracle.com/javase/1.5.0/docs/guide/deployment/deployment-guide/properties.html
> >>>>[2] http://sourceforge.net/tracker/?func=detail&aid=2832947&group_id=72541&atid=534854
> >>>
> >>><snip>
> >>>
> >>>>+
> >>>>+ /**
> >>>>+ * Loads properties properties file, if one exists
> >>>>+ *
> >>>
> >>>Minor typo above.
> >>
> >>Fixed.
> >>
> >>>
> >>>>+ * @param type the ConfigType to load
> >>>>+ * @param file the File to load Properties from
> >>>
> >>><snip>
> >>>
> >>>>+ /* exit if there is a fatal exception loading the configuration */
> >>>>+ if (isApplication) {
> >>>>+ System.out.println(getMessage("RConfigurationError"));
> >>>>+ System.exit(-1);
> >>>
> >>>
> >>>Is there a reason you chose negative exit code? NetX uses +1 everywhere
> >>>else.
> >>>
> >>
> >>Ah, I didnt see that netx uses 1. I have fixed it now.
> >>
> >>Thanks for reviewing the patch. Area there other issues I should fix?
> >>
> >
> >Nope, rest looks fine. Ok for commit to HEAD.
> >
>
> Thanks for the review Deepak. Here is a a slightly updated version
> that I plan to commit. I made a few minor tweaks to make this class
> easier to use.
>
> 1. The class is now final and public so it can be used by other
> packages not part of net.sourceforge.jnlp.runtime
> 2. I renamed the methods so they make more sense. "save" and "load"
> are now used for saving and loading the configuration respectively.
> 3. Security checks have been added for getProperty(),
> getPropertyNames() and setProperty().
>
save() should have an access check as well, as someone could call it and
then parse the exception error message to figure out user.home. A check
for file read access to the userPropertiesFile should be adequate.
load() doesn't need to have it as there is no chain that ends up
outputting file names, but it would still be a good idea to add a check
there in case someone adds an output somewhere without realizing it.
After above changes, ok for HEAD.
Cheers,
Deepak
> Ok to commit?
>
> Thanks,
> Omair
> diff -r eb998ed0ab1a netx/net/sourceforge/jnlp/ShortcutDesc.java
> --- a/netx/net/sourceforge/jnlp/ShortcutDesc.java Fri Oct 22 10:44:12 2010 -0400
> +++ b/netx/net/sourceforge/jnlp/ShortcutDesc.java Mon Oct 25 08:35:41 2010 -0400
> @@ -18,6 +18,18 @@
>
> public final class ShortcutDesc {
>
> + /** Never create a shortcut */
> + public static final String SHORTCUT_NEVER = "NEVER";
> + /** Always create a shortcut */
> + public static final String SHORTCUT_ALWAYS = "ALWAYS";
> + /** Always ask user whether to create a shortcut */
> + public static final String SHORTCUT_ASK_ALWAYS = "ASK_USER";
> + /** Ask user but only if jnlp file wants a shortcut */
> + public static final String SHORTCUT_ASK_IF_HINTED = "ASK_IF_HINTED";
> + /** Create a desktop shortcut if the jnlp asks for it */
> + public static final String SHORTCUT_ALWAYS_IF_HINTED = "ALWAYS_IF_HINTED";
> + public static final String SHORTCUT_DEFAULT = SHORTCUT_ASK_IF_HINTED;
> +
> /** the application wants to be placed on the desktop */
> private boolean onDesktop = false;
>
> diff -r eb998ed0ab1a netx/net/sourceforge/jnlp/runtime/DeploymentConfiguration.java
> --- /dev/null Thu Jan 01 00:00:00 1970 +0000
> +++ b/netx/net/sourceforge/jnlp/runtime/DeploymentConfiguration.java Mon Oct 25 08:35:41 2010 -0400
> @@ -0,0 +1,594 @@
> +// Copyright (C) 2010 Red Hat, Inc.
> +//
> +// This library is free software; you can redistribute it and/or
> +// modify it under the terms of the GNU Lesser General Public
> +// License as published by the Free Software Foundation; either
> +// version 2.1 of the License, or (at your option) any later version.
> +//
> +// This library 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
> +// Lesser General Public License for more details.
> +//
> +// You should have received a copy of the GNU Lesser General Public
> +// License along with this library; if not, write to the Free Software
> +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
> +
> +
> +package net.sourceforge.jnlp.runtime;
> +
> +import java.io.BufferedOutputStream;
> +import java.io.BufferedReader;
> +import java.io.File;
> +import java.io.FileOutputStream;
> +import java.io.FileReader;
> +import java.io.IOException;
> +import java.io.OutputStream;
> +import java.io.PrintStream;
> +import java.io.Reader;
> +import java.net.MalformedURLException;
> +import java.net.URL;
> +import java.util.HashMap;
> +import java.util.Map;
> +import java.util.Properties;
> +import java.util.Set;
> +
> +import javax.naming.ConfigurationException;
> +
> +import net.sourceforge.jnlp.ShortcutDesc;
> +
> +/**
> + * Manages the various properties and configuration related to deployment.
> + *
> + * See:
> + * http://download.oracle.com/javase/1.5.0/docs/guide/deployment/deployment-guide/properties.html
> + */
> +public final class DeploymentConfiguration {
> +
> + /**
> + * Represents a value for a configuration. Provides methods to get the value
> + * as well as marking the value as locked.
> + */
> + private final class ConfigValue {
> +
> + private String value;
> + private boolean locked;
> +
> + ConfigValue(String value) {
> + this(value, false);
> + }
> +
> + ConfigValue(String value, boolean locked) {
> + this.value = value;
> + this.locked = locked;
> + }
> +
> + ConfigValue(ConfigValue other) {
> + this(other.value, other.locked);
> + }
> +
> + String get() {
> + return value;
> + }
> +
> + /**
> + * Note that setting the value is not enforced - it is the caller's
> + * responsibility to check if a value is locked or not before setting a
> + * new value
> + *
> + * @param value the new value
> + */
> + void set(String value) {
> + this.value = value;
> + }
> +
> + /**
> + * @return true if the value has been marked as locked
> + */
> + boolean isLocked() {
> + return locked;
> + }
> +
> + /**
> + * Mark a value as locked
> + * @param locked
> + */
> + void setLocked(boolean locked) {
> + this.locked = locked;
> + }
> + }
> +
> + public static final String DEPLOYMENT_DIR = ".netx";
> + public static final String DEPLOYMENT_CONFIG = "deployment.config";
> + public static final String DEPLOYMENT_PROPERTIES = "deployment.properties";
> +
> + public static final String DEPLOYMENT_COMMENT = "Netx deployment configuration";
> +
> + public static final int JNLP_ASSOCIATION_NEVER = 0;
> + public static final int JNLP_ASSOCIATION_NEW_ONLY = 1;
> + public static final int JNLP_ASSOCIATION_ASK_USER = 2;
> + public static final int JNLP_ASSOCIATION_REPLACE_ASK = 3;
> +
> + /*
> + * FIXME these should be moved into JavaConsole, but there is a strange
> + * dependency in the build system. First all of netx is built. Then the
> + * plugin is built. So we cannot refer to plugin code in here :(
> + */
> + public static final String CONSOLE_HIDE = "HIDE";
> + public static final String CONSOLE_SHOW = "SHOW";
> + public static final String CONSOLE_DISABLE = "DISABLE";
> + public static final String CONSOLE_DEFAULT = CONSOLE_DISABLE;
> +
> + /* FIXME these should be moved into the proxy class */
> + public static final int PROXY_TYPE_UNKNOWN = -1;
> + public static final int PROXY_TYPE_NONE = 0;
> + public static final int PROXY_TYPE_MANUAL = 1;
> + public static final int PROXY_TYPE_AUTO = 2;
> + public static final int PROXY_TYPE_BROWSER = 3;
> +
> + public enum ConfigType {
> + System, User
> + }
> +
> + /** is it mandatory to load the system properties? */
> + private boolean systemPropertiesMandatory = false;
> +
> + /** The system's deployment.config file */
> + private File systemPropertiesFile = null;
> + /** The user's deployment.config file */
> + private File userPropertiesFile = null;
> +
> + /** the current deployment properties */
> + private Map<String, ConfigValue> currentConfiguration;
> +
> + /** the deployment properties that cannot be changed */
> + private Map<String, ConfigValue> unchangeableConfiguration;
> +
> + public DeploymentConfiguration() {
> + unchangeableConfiguration = new HashMap<String, ConfigValue>();
> + currentConfiguration = new HashMap<String, ConfigValue>();
> + }
> +
> + /**
> + * Initialize this deployment configuration by reading configuration files.
> + * Generally, it will try to continue and ignore errors it finds (such as file not found).
> + *
> + * @throws DeploymentException if it encounters a fatal error.
> + */
> + public void load() throws ConfigurationException {
> + Map<String, ConfigValue> initialProperties = loadDefaultProperties();
> +
> + Map<String, ConfigValue> systemProperties = null;
> +
> + /*
> + * First, try to read the system's deployment.config file to find if
> + * there is a system-level deployment.poperties file
> + */
> +
> + File systemConfigFile = findSystemConfigFile();
> + if (systemConfigFile != null) {
> + if (loadSystemConfiguration(systemConfigFile)) {
> + if (JNLPRuntime.isDebug()) {
> + System.out.println("System level " + DEPLOYMENT_CONFIG + " is mandatory: " + systemPropertiesMandatory);
> + }
> + /* Second, read the System level deployment.properties file */
> + systemProperties = loadProperties(ConfigType.System, systemPropertiesFile,
> + systemPropertiesMandatory);
> + }
> + if (systemProperties != null) {
> + mergeMaps(initialProperties, systemProperties);
> + }
> + }
> +
> + /* need a copy of the original when we have to save */
> + unchangeableConfiguration = new HashMap<String, ConfigValue>();
> + Set<String> keys = initialProperties.keySet();
> + for (String key : keys) {
> + unchangeableConfiguration.put(key, new ConfigValue(initialProperties.get(key)));
> + }
> +
> + /*
> + * Third, read the user's deployment.properties file
> + */
> + userPropertiesFile = new File(System.getProperty("user.home") + File.separator + ".netx"
> + + File.separator + DEPLOYMENT_PROPERTIES);
> + Map<String, ConfigValue> userProperties = loadProperties(ConfigType.User, userPropertiesFile,
> + false);
> + if (userProperties != null) {
> + mergeMaps(initialProperties, userProperties);
> + }
> +
> + currentConfiguration = initialProperties;
> + }
> +
> + /**
> + * Get the value for the given key
> + *
> + * @param key the property key
> + * @return the value for the key, or null if it can not be found
> + */
> + public String getProperty(String key) {
> + SecurityManager sm = System.getSecurityManager();
> + if (sm != null) {
> + if (userPropertiesFile != null) {
> + sm.checkRead(userPropertiesFile.toString());
> + }
> + }
> + return currentConfiguration.get(key).get();
> + }
> +
> + /**
> + * @return a Set containing all the property names
> + */
> + Set<String> getAllPropertyNames() {
> + SecurityManager sm = System.getSecurityManager();
> + if (sm != null) {
> + if (userPropertiesFile != null) {
> + sm.checkRead(userPropertiesFile.toString());
> + }
> + }
> + return currentConfiguration.keySet();
> + }
> +
> + /**
> + * Sets the value of corresponding to the key. If the value has been marked
> + * as locked, it is not changed
> + *
> + * @param key the key
> + * @param value the value to be associated with the key
> + */
> + public void setProperty(String key, String value) {
> + SecurityManager sm = System.getSecurityManager();
> + if (sm != null) {
> + if (userPropertiesFile != null) {
> + sm.checkRead(userPropertiesFile.toString());
> + }
> + }
> +
> + ConfigValue currentValue = currentConfiguration.get(key);
> + if (currentValue != null) {
> + if (!currentValue.isLocked()) {
> + currentValue.set(value);
> + }
> + } else {
> + currentValue = new ConfigValue(value);
> + currentConfiguration.put(key, currentValue);
> + }
> + }
> +
> + /**
> + * Loads the default properties for deployment
> + */
> + private Map<String, ConfigValue> loadDefaultProperties() {
> +
> + final String SYSTEM_HOME = System.getProperty("java.home");
> + final String SYSTEM_SECURITY = SYSTEM_HOME + File.separator + "lib" + File.separator
> + + "security";
> +
> + final String USER_HOME = System.getProperty("user.home") + File.separator + DEPLOYMENT_DIR;
> + final String USER_SECURITY = USER_HOME + File.separator + "security";
> +
> + /*
> + * This is more or less a straight copy from the deployment
> + * configuration page, with occasional replacements of "" or no-defaults
> + * with null
> + */
> +
> + String[][] defaults = new String[][] {
> + /* infrastructure */
> + { "deployment.user.cachedir", USER_HOME + File.separator + "cache" },
> + { "deployment.system.cachedir", null },
> + { "deployment.user.logdir", USER_HOME + File.separator + "log" },
> + { "deployment.user.tmp", USER_HOME + File.separator + "tmp" },
> + /* certificates and policy files */
> + { "deployment.user.security.policy", "file://" + USER_SECURITY + File.separator + "java.policy" },
> + { "deployment.user.security.trusted.cacerts", USER_SECURITY + File.separator + "trusted.cacerts" },
> + { "deployment.user.security.trusted.jssecacerts", USER_SECURITY + File.separator + "trusted.jssecacerts" },
> + { "deployment.user.security.trusted.certs", USER_SECURITY + File.separator + "trusted.certs" },
> + { "deployment.user.security.trusted.jssecerts", USER_SECURITY + File.separator + "trusted.jssecerts"},
> + { "deployment.user.security.trusted.clientauthcerts", USER_SECURITY + File.separator + "trusted.clientcerts" },
> + { "deployment.system.security.policy", null },
> + { "deployment.system.security.cacerts", SYSTEM_SECURITY + File.separator + "cacerts" },
> + { "deployment.system.security.jssecacerts", SYSTEM_SECURITY + File.separator + "jssecacerts" },
> + { "deployment.system.security.trusted.certs", SYSTEM_SECURITY + File.separator + "trusted.certs" },
> + { "deployment.system.security.trusted.jssecerts", SYSTEM_SECURITY + File.separator + "trusted.jssecerts" },
> + { "deployment.system.security.trusted.clientautcerts", SYSTEM_SECURITY + File.separator + "trusted.clientcerts" },
> + /* security access and control */
> + { "deployment.security.askgrantdialog.show", String.valueOf(true) },
> + { "deployment.security.askgrantdialog.notinca", String.valueOf(true) },
> + { "deployment.security.notinca.warning", String.valueOf(true) },
> + { "deployment.security.expired.warning", String.valueOf(true) },
> + { "deployment.security.jsse.hostmismatch.warning", String.valueOf(true) },
> + { "deployment.security.trusted.policy", null },
> + { "deployment.security.sandbox.awtwarningwindow", String.valueOf(true) },
> + { "deployment.security.sandbox.jnlp.enhanced", String.valueOf(true) },
> + { "deployment.security.authenticator", String.valueOf(true) },
> + /* networking */
> + { "deployment.proxy.type", String.valueOf(PROXY_TYPE_BROWSER) },
> + { "deployment.proxy.same", String.valueOf(false) },
> + { "deployment.proxy.auto.config.url", null },
> + { "deployment.proxy.bypass.list", null },
> + { "deployment.proxy.bypass.local", null },
> + { "deployment.proxy.http.host", null },
> + { "deployment.proxy.http.port", null },
> + { "deployment.proxy.https.host", null },
> + { "deployment.proxy.https.port", null },
> + { "deployment.proxy.ftp.host", null },
> + { "deployment.proxy.ftp.port", null },
> + { "deployment.proxy.socks.host", null },
> + { "deployment.proxy.socks.port", null },
> + { "deployment.proxy.override.hosts", null },
> + /* cache and optional package repository */
> + { "deployment.cache.max.size", String.valueOf("-1") },
> + { "deployment.cache.jarcompresson", String.valueOf(0) },
> + { "deployment.javapi.cache.enabled", String.valueOf(false) },
> + /* java console */
> + { "deployment.console.startup.mode", CONSOLE_HIDE },
> + /* tracing and logging */
> + { "deployment.trace", String.valueOf(false) },
> + { "deployment.log", String.valueOf(false) },
> + /* JNLP association */
> + { "deployment.javaws.associations", String.valueOf(JNLP_ASSOCIATION_ASK_USER) },
> + /* desktop integration */
> + { "deployment.javaws.shortcut", ShortcutDesc.SHORTCUT_ASK_IF_HINTED },
> + /* jre selection */
> + { "deployment.javaws.installURL", "" },
> + /* jre management */
> + { "deployment.javaws.autodownload", "" },
> + /* browser selection */
> + { "deployment.browser.path", "" },
> + /* check for update timeout */
> + { "deployment.javaws.update.timeout", String.valueOf(500) }
> + };
> +
> + HashMap<String, ConfigValue> result = new HashMap<String, ConfigValue>();
> + for (int i = 0; i < defaults.length; i++) {
> + String key = defaults[i][0];
> + String actualValue = defaults[i][1];
> + boolean locked = false;
> + ConfigValue value = new ConfigValue(actualValue, locked);
> + result.put(key, value);
> + }
> +
> + return result;
> + }
> +
> + /**
> + * @return the location of system-level deployment.config file, or null if none can be found
> + */
> + private File findSystemConfigFile() {
> + File etcFile = new File(File.separator + "etc" + File.separator + ".java" + File.separator
> + + "deployment" + File.separator + DEPLOYMENT_CONFIG);
> + if (etcFile.isFile()) {
> + return etcFile;
> + }
> +
> + File jreFile = new File(System.getProperty("java.home") + File.separator + "lib"
> + + File.separator + DEPLOYMENT_CONFIG);
> + if (jreFile.isFile()) {
> + return jreFile;
> + }
> +
> + return null;
> + }
> +
> + /**
> + * Reads the system configuration file and sets the relevant
> + * system-properties related variables
> + */
> + private boolean loadSystemConfiguration(File configFile) {
> +
> + if (JNLPRuntime.isDebug()) {
> + System.out.println("Loading system configuation from: " + configFile);
> + }
> +
> + Map<String, ConfigValue> systemConfiguration = new HashMap<String, ConfigValue>();
> + try {
> + systemConfiguration = parsePropertiesFile(configFile);
> + } catch (IOException e) {
> + if (JNLPRuntime.isDebug()) {
> + System.out.println("No System level " + DEPLOYMENT_PROPERTIES + " found.");
> + }
> + return false;
> + }
> +
> + /*
> + * at this point, we have read the system deployment.config file
> + * completely
> + */
> +
> + try {
> + String urlString = systemConfiguration.get("deployment.system.config").get();
> + if (urlString == null) {
> + if (JNLPRuntime.isDebug()) {
> + System.out.println("No System level " + DEPLOYMENT_PROPERTIES + " found.");
> + }
> + return false;
> + }
> + URL url = new URL(urlString);
> + if (url.getProtocol().equals("file")) {
> + systemPropertiesFile = new File(url.getFile());
> + if (JNLPRuntime.isDebug()) {
> + System.out.println("Using System level" + DEPLOYMENT_PROPERTIES + ": "
> + + systemPropertiesFile);
> + }
> + ConfigValue mandatory = systemConfiguration.get("deployment.system.config.mandatory");
> + systemPropertiesMandatory = Boolean.valueOf(mandatory == null? null: mandatory.get());
> + return true;
> + } else {
> + if (JNLPRuntime.isDebug()) {
> + System.out.println("Remote + " + DEPLOYMENT_PROPERTIES + " not supported");
> + }
> + return false;
> + }
> + } catch (MalformedURLException e) {
> + if (JNLPRuntime.isDebug()) {
> + System.out.println("Invalid url for " + DEPLOYMENT_PROPERTIES);
> + }
> + return false;
> + }
> + }
> +
> + /**
> + * Loads the properties file, if one exists
> + *
> + * @param type the ConfigType to load
> + * @param file the File to load Properties from
> + * @param mandatory indicates if reading this file is mandatory
> + *
> + * @throws ConfigurationException if the file is mandatory but cannot be read
> + */
> + private Map<String, ConfigValue> loadProperties(ConfigType type, File file, boolean mandatory)
> + throws ConfigurationException {
> + if (file == null || !file.isFile()) {
> + if (JNLPRuntime.isDebug()) {
> + System.out.println("No " + type.toString() + " level " + DEPLOYMENT_PROPERTIES + " found.");
> + }
> + if (!mandatory) {
> + return null;
> + } else {
> + throw new ConfigurationException();
> + }
> + }
> +
> + if (JNLPRuntime.isDebug()) {
> + System.out.println("Loading " + type.toString() + " level properties from: " + file);
> + }
> + try {
> + return parsePropertiesFile(file);
> + } catch (IOException e) {
> + return null;
> + }
> + }
> +
> +
> + /**
> + * Saves all properties that are not part of default or system properties
> + *
> + * @throws IOException
> + */
> + public void save() throws IOException {
> + if (JNLPRuntime.isDebug()) {
> + System.out.println("Saving properties into " + userPropertiesFile.toString());
> + }
> + Properties toSave = new Properties();
> +
> + for (String key : currentConfiguration.keySet()) {
> + String oldValue = unchangeableConfiguration.get(key) == null ? null
> + : unchangeableConfiguration.get(key).get();
> + String newValue = currentConfiguration.get(key) == null ? null : currentConfiguration
> + .get(key).get();
> + if (oldValue == null && newValue == null) {
> + continue;
> + } else if (oldValue == null && newValue != null) {
> + toSave.setProperty(key, newValue);
> + } else if (oldValue != null && newValue == null) {
> + toSave.setProperty(key, newValue);
> + } else { // oldValue != null && newValue != null
> + if (!oldValue.equals(newValue)) {
> + toSave.setProperty(key, newValue);
> + }
> + }
> + }
> +
> + File backupPropertiesFile = new File(userPropertiesFile.toString() + ".old");
> + if (userPropertiesFile.isFile()) {
> + if (!userPropertiesFile.renameTo(backupPropertiesFile)) {
> + throw new IOException("Error saving backup copy of " + userPropertiesFile);
> + }
> + }
> +
> + userPropertiesFile.getParentFile().mkdirs();
> + OutputStream out = new BufferedOutputStream(new FileOutputStream(userPropertiesFile));
> + try {
> + toSave.store(out, DEPLOYMENT_COMMENT);
> + } finally {
> + out.close();
> + }
> + }
> +
> + /**
> + * Reads a properties file and returns a map representing the properties
> + *
> + * @param propertiesFile the file to read Properties from
> + * @param destination the map to which all the properties should be added
> + * @throws IOException if an IO problem occurs
> + */
> + private Map<String, ConfigValue> parsePropertiesFile(File propertiesFile) throws IOException {
> + Map<String, ConfigValue> result = new HashMap<String, ConfigValue>();
> +
> + Properties properties = new Properties();
> +
> + Reader reader = new BufferedReader(new FileReader(propertiesFile));
> + try {
> + properties.load(reader);
> + } finally {
> + reader.close();
> + }
> +
> + Set<String> keys = properties.stringPropertyNames();
> + for (String key : keys) {
> + if (key.endsWith(".locked")) {
> + String realKey = key.substring(0, key.length() - ".locked".length());
> + ConfigValue configValue = result.get(realKey);
> + if (configValue == null) {
> + configValue = new ConfigValue(null, true);
> + result.put(realKey, configValue);
> + } else {
> + configValue.setLocked(true);
> + }
> + } else {
> + /* when parsing a properties we set value without checking if it is locked or not */
> + String newValue = properties.getProperty(key);
> + ConfigValue configValue = result.get(key);
> + if (configValue == null) {
> + configValue = new ConfigValue(newValue);
> + result.put(key, configValue);
> + } else {
> + configValue.set(newValue);
> + }
> + }
> + }
> + return result;
> + }
> +
> + /**
> + * Merges two maps while respecting whether the values have been locked or
> + * not. All values from srcMap are put into finalMap, replacing values in
> + * finalMap if necessary, unless the value is present and marked as locked
> + * in finalMap
> + *
> + * @param finalMap the destination for putting values
> + * @param srcMap the source for reading key value pairs
> + */
> + private void mergeMaps(Map<String, ConfigValue> finalMap, Map<String, ConfigValue> srcMap) {
> + for (String key: srcMap.keySet()) {
> + ConfigValue configValue = finalMap.get(key);
> + if (configValue == null) {
> + configValue = srcMap.get(key);
> + finalMap.put(key, configValue);
> + } else {
> + if (!configValue.isLocked()) {
> + configValue.set(srcMap.get(key).get());
> + }
> + }
> + }
> + }
> +
> + /**
> + * Dumps the configuration to the PrintStream
> + *
> + * @param config a map of key,value pairs representing the configuration to
> + * dump
> + * @param out the PrintStream to write data to
> + */
> + private static void dumpConfiguration(Map<String, ConfigValue> config, PrintStream out) {
> + System.out.println("KEY: VALUE [Locked]");
> +
> + for (String key : config.keySet()) {
> + ConfigValue value = config.get(key);
> + out.println("'" + key + "': '" + value.get() + "'"
> + + (value.isLocked() ? " [LOCKED]" : ""));
> + }
> + }
> +}
More information about the distro-pkg-dev
mailing list