PropertyFileConfigurationSource.java

package org.stagemonitor.configuration.source;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.stagemonitor.util.IOUtils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * Loads a properties file from classpath. Falls back to loading from file system.
 */
public final class PropertyFileConfigurationSource extends AbstractConfigurationSource {

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

	private final String location;
	private Properties properties;
	private File file;
	private boolean writeable;

	public PropertyFileConfigurationSource(String location) {
		this.location = location;
		try {
			this.file = IOUtils.getFile(location);
			this.writeable = file.canWrite();
		} catch (Exception e) {
			this.writeable = false;
		}
		reload();
	}

	@Override
	public void reload() {
		properties = getProperties(location);
		if (properties == null) {
			logger.warn("Could not load {}", location);
			properties = new Properties();
		}
	}

	@Override
	public boolean isSavingPersistent() {
		return true;
	}

	@Override
	public String getName() {
		return location;
	}

	public static boolean isPresent(String location) {
		return getProperties(location) != null;
	}

	private static Properties getProperties(String location) {
		if (location == null) {
			return null;
		}
		Properties props = getFromClasspath(location);
		if (props == null) {
			props = getFromFileSystem(location);
		}
		return props;
	}

	private static Properties getFromClasspath(String classpathLocation) {
		final Properties props = new Properties();
		InputStream resourceStream = PropertyFileConfigurationSource.class.getClassLoader().getResourceAsStream(classpathLocation);
		if (resourceStream != null) {
			try {
				props.load(resourceStream);
				return props;
			} catch (IOException e) {
				logger.warn(e.getMessage() + " (this exception is ignored)", e);
			} finally {
				try {
					resourceStream.close();
				} catch (IOException e) {
					logger.warn(e.getMessage() + " (this exception is ignored)", e);
				}
			}
		}
		return null;
	}

	private static Properties getFromFileSystem(String location) {
		Properties props = new Properties();
		InputStream input = null;
		try {
			input = new FileInputStream(location);
			props.load(input);
			return props;
		} catch (FileNotFoundException ex) {
			return null;
		} catch (IOException e) {
			logger.warn(e.getMessage() + " (this exception is ignored)", e);
		} finally {
			if (input != null) {
				try {
					input.close();
				} catch (IOException e) {
					logger.warn(e.getMessage() + " (this exception is ignored)", e);
				}
			}
		}
		return null;
	}

	@Override
	public String getValue(String key) {
		return properties.getProperty(key);
	}

	@Override
	public boolean isSavingPossible() {
		return writeable;
	}

	@Override
	public void save(String key, String value) throws IOException {
		if (file != null) {
			synchronized (this) {
				properties.put(key, value);
				final FileOutputStream out = new FileOutputStream(file);
				properties.store(out, null);
				out.flush();
				out.close();
			}
		} else {
			throw new IOException(location + " is not writeable");
		}
	}

}