/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.apache.ode.utils;
import org.apache.commons.collections.map.MultiKeyMap;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.lang.StringUtils;
import javax.xml.namespace.QName;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.*;
import java.util.Properties;
import java.util.regex.Pattern;
/**
* This class load a list of regular property files (order matters). The main feature is that property can
* be chained in three levels. Then when querying for a property, if it's not found in the deepest level,
* the parent will be queryed and so on.
* <p/>
* A prefix must be defined to discriminate the property name and the level-1, level-2 names. The default prefix is {@link #ODE_PREFFIX}.
* <p/>
* Properties must respect the following pattern: [level1.[level2.]prefix.]property
* <p/>
* A concrete use case could be the definition of properties for wsdl services and ports.
* <br/>Level 0 would be: values common to all services and ports.
* <br/>Level 1: values common to a given service.
* <br/>Level 2: values common to a given port.
* <p/>
* For instance, if the property file looks like this:
* <pre>
*alias.foo_ns=http://foo.com
*
* timeout=40000
* a_namespace_with_no_alias_defined.film-service.port-of-cannes.ode.timeout=50000
* <p/>
* max-redirects=30
* foo_ns.brel-service.ode.max-redirects=40
* foo_ns.brel-service.port-of-amsterdam.ode.max-redirects=60
* </pre>
* The following values may be expected:
* <pre>
* getProperty("max-redirects") => 30
* getProperty("http://foo.com", "brel-service", "max-redirects") => 40
* getProperty("http://foo.com", "brel-service", "port-of-amsterdam", "max-redirects") => 60
* <p/>
* getProperty("a_namespace_with_no_alias_defined", "film-service", "timeout") => 40000
* getProperty("a_namespace_with_no_alias_defined", "film-service", "port-of-cannes", "timeout") => 50000
* getProperty("http://foo.com", "port-of-amsterdam", "timeout") => 40000
* </pre>
* <p/>
* <p>
* Values may contain some environment variables. For instance, message=You're using ${java.version}.
* <p/>
* <p>
* If a property name ends with ".file" or ".path", the assumption is made that the associated value is a path and as such is resolved against the path of the file it was loaded from.
* </p>
* Assigned properties must not start with 'system.' or 'env.'. These prefix are reserved to access system properties and environment variables.
*
* @author <a href="mailto:midon@intalio.com">Alexis Midon</a>
*/
public class HierarchicalProperties {
private static final Log log = LogFactory.getLog(HierarchicalProperties.class);
public static final String ODE_PREFFIX = "ode";
private File[] files;
private String prefix;
private String dotted_prefix;
/*
This map contains ChainedMap instances chained according to the (qualified) service and/or port they are associated with.
All ChainedMap instances has a common parent.
The ChainedMap instances are chained to each others so that if a property is not found for [service, port],
the ChainedMap associated to [service] will be queried, and if still not found, then the common parent.
The ChainedMap instance common to all services and ports is associated to the [null, null] key.
ChainedMap instance common to all ports of a given service is associated to [service, null].
ChainedMap instance of a given service, port couple is associated to [service, port].
The ChainedMap instances contain string values as loaded from the filesystem.
*/
private MultiKeyMap hierarchicalMap = new MultiKeyMap();
// map used to cache immutable versions of the maps
private transient MultiKeyMap cacheOfImmutableMaps = new MultiKeyMap();
/**
* @param files the property file to be loaded. The file may not exist.
* But if the file exists it has to be a file (not a directory), otherwhise an IOException is thrown. Files will be loaded in the given order.
* @param prefix the property prefix
* @throws IOException
*/
public HierarchicalProperties(File[] files, String prefix) throws IOException {
this.files = files;
this.prefix = prefix;
this.dotted_prefix = "." + prefix + ".";
loadFiles();
}
public HierarchicalProperties(File[] files) throws IOException {
this(files, ODE_PREFFIX);
}
public HierarchicalProperties(File file, String prefix) throws IOException {
this(new File[]{file}, prefix);
}
public HierarchicalProperties(File file) throws IOException {
this(new File[]{file}, ODE_PREFFIX);
}
public HierarchicalProperties(List<File> propFiles) throws IOException {
this(propFiles.toArray(new File[propFiles.size()]), ODE_PREFFIX);
}
/**
* Clear all existing content, then read the file and parse each property. Simply logs a message and returns if the file does not exist.
*
* @throws IOException if the file is a Directory
*/
public void loadFiles() throws IOException {
// #1. clear all existing content
clear();
// #3. put the root map
initRoot();
for (File file : files) {
Properties props = loadFile(file);
if(!props.isEmpty()) processProperties(props, file);
}
replacePlaceholders();
}
private ChainedMap initRoot() {
ChainedMap root = new ChainedMap();
hierarchicalMap.put(null, null, root);
return root;
}
private void processProperties(Properties props, File file) throws IOException {
validatePropertyNames(props, file);
Map<String, String> nsByAlias = collectAliases(props, file);
// #4. process each property
for (Iterator it = props.entrySet().iterator(); it.hasNext();) {
Map.Entry e = (Map.Entry) it.next();
String key = (String) e.getKey();
String value = (String) e.getValue();
// parse the property name
String[] info = parseProperty(key);
String nsalias = info[0];
String service = info[1];
String port = info[2];
String targetedProperty = info[3];
QName qname = null;
if (nsalias != null) {
qname = new QName(nsByAlias.get(nsalias) != null ? nsByAlias.get(nsalias) : nsalias, service);
}
// get the map associated to this port
ChainedMap p = (ChainedMap) hierarchicalMap.get(qname, port);
if (p == null) {
// create it if necessary
// get the associated service map
ChainedMap s = (ChainedMap) hierarchicalMap.get(qname, null);
if (s == null) {
// create the service map if necessary, the parent is the root map.
s = new ChainedMap(getRootMap());
// put it in the multi-map
hierarchicalMap.put(qname, null, s);
}
// create the map itself and link it to the service map
p = new ChainedMap(s);
// put it in the multi-map
hierarchicalMap.put(qname, port, p);
}
if(targetedProperty.endsWith(".file") || targetedProperty.endsWith(".path")){
String absolutePath = file.toURI().resolve(value).getPath();
if(log.isDebugEnabled()) log.debug("path: "+value+" resolved into: "+absolutePath);
value = absolutePath;
}
// save the key/value in its chained map
if(log.isDebugEnabled()) log.debug("New property: "+targetedProperty+" -> "+value);
p.put(targetedProperty, value);
}
}
private Properties loadFile(File file) throws IOException {
Properties props = new Properties();
if (!file.exists()) {
if (log.isDebugEnabled()) log.debug("File does not exist [" + file + "]");
return props;
}
// #2. read the file
FileInputStream fis = new FileInputStream(file);
try {
if (log.isDebugEnabled()) log.debug("Loading property file: " + file);
props.load(fis);
} finally {
fis.close();
}
return props;
}
private Map<String, String> collectAliases(Properties props, File file) {
// gather all aliases
Map<String, String> nsByAlias = new HashMap<String, String>();
// replace env variable by their values and collect namespace aliases
for (Iterator it = props.entrySet().iterator(); it.hasNext();) {
Map.Entry e = (Map.Entry) it.next();
String key = (String) e.getKey();
String value = (String) e.getValue();
if (key.startsWith("alias.")) {
// we found an namespace alias
final String alias = key.substring("alias.".length(), key.length());
if (log.isDebugEnabled()) log.debug("Alias found: " + alias + " -> " + value);
if (nsByAlias.containsKey(alias) && value.equals(nsByAlias.get(alias)))
throw new RuntimeException("Same alias used twice for 2 different namespaces! file=" + file + ", alias=" + alias);
nsByAlias.put(alias, value);
// remove the pair from the Properties
it.remove();
}
}
return nsByAlias;
}
private void validatePropertyNames(Properties props, File file) {
List invalids = new ArrayList();
for (Iterator<Object> it = props.keySet().iterator(); it.hasNext();) {
String name = (String) it.next();
if(name.startsWith("system.") || name.startsWith("env.")) invalids.add(name);
}
if(!invalids.isEmpty()){
throw new IllegalArgumentException("Property files cannot define properties starting with 'system.' nor 'env.' File="+file+". Invalid names="+StringUtils.join(invalids, ","));
}
}
private void replacePlaceholders() {
Pattern systemProperty = Pattern.compile("\\$\\{system\\.([^\\}]+)\\}");
Pattern environmentVariable = Pattern.compile("\\$\\{env\\.([^\\}]+)\\}");
Pattern localPlaceholder = Pattern.compile("\\$\\{([^\\}]+)\\}");
for (Iterator it = hierarchicalMap.values().iterator(); it.hasNext();) {
Map properties = ((ChainedMap) it.next()).child;
for (Iterator it1 = properties.entrySet().iterator(); it1.hasNext();) {
Map.Entry e = (Map.Entry) it1.next();
// /!\ replacement values themselves might contain placeholders. So always retrieve the value from the map entry
e.setValue(SystemUtils.replaceProperties((String) e.getValue(), localPlaceholder, getRootMap().child));
e.setValue(SystemUtils.replaceProperties((String) e.getValue(), systemProperty, System.getProperties()));
e.setValue(SystemUtils.replaceProperties((String) e.getValue(), environmentVariable, System.getenv()));
}
}
}
/**
* Clear all content. If {@link #loadFiles()} is not invoked later, all returned values will be null.
*/
public void clear() {
hierarchicalMap.clear();
cacheOfImmutableMaps.clear();
}
protected ChainedMap getRootMap() {
Object o = hierarchicalMap.get(null, null);
if (o == null) {
o = initRoot();
}
return (ChainedMap) o;
}
public Map getProperties(String serviceNamespaceURI, String serviceLocalPart) {
return getProperties(new QName(serviceNamespaceURI, serviceLocalPart));
}
/**
* @param service
* @return a map containing all the properties for the given service.
* @see #getProperties(String, String)
*/
public Map getProperties(QName service) {
return getProperties(service, null);
}
public Map getProperties(String serviceNamespaceURI, String serviceLocalPart, String port) {
return getProperties(new QName(serviceNamespaceURI, serviceLocalPart), port);
}
/**
* Return a map containing all the properties for the given port. The map is an immutable snapshot of the properties.
* Meaning that futur changes to the properties will NOT be reflected in the returned map.
*
* @param service
* @param port
* @return a map containing all the properties for the given port
*/
public Map getProperties(QName service, String port) {
// no need to go further if no properties
if (hierarchicalMap.isEmpty()) return Collections.EMPTY_MAP;
// else check the cache of ChainedMap already converted into immutable maps
Map cachedMap = (Map) this.cacheOfImmutableMaps.get(service, port);
if (cachedMap != null) {
return cachedMap;
}
// else get the corresponding ChainedMap and convert it into a Map
ChainedMap cm = (ChainedMap) hierarchicalMap.get(service, port);
// if this port is not explicitly mentioned in the multimap, get the default values.
if (cm == null) {
cm = (ChainedMap) hierarchicalMap.get(service, null);
if (cm == null) {
// return the cached version of the root map
return getProperties((QName) null, null);
}
}
Map snapshotMap = new HashMap(cm.size() * 15 / 10);
for (Object key : cm.keySet()) {
snapshotMap.put(key, cm.get(key));
}
snapshotMap = Collections.unmodifiableMap(snapshotMap);
// put it in cache to avoid creating one map at each invocation
this.cacheOfImmutableMaps.put(service, port, snapshotMap);
return snapshotMap;
}
public String getProperty(String property) {
return (String) getRootMap().get(property);
}
public String getProperty(String serviceNamespaceURI, String serviceLocalPart, String property) {
return getProperty(new QName(serviceNamespaceURI, serviceLocalPart), property);
}
public String getProperty(QName service, String property) {
return getProperty(service, null, property);
}
public String getProperty(String serviceNamespaceURI, String serviceLocalPart, String port, String property) {
return getProperty(new QName(serviceNamespaceURI, serviceLocalPart), port, property);
}
public String getProperty(QName service, String port, String property) {
return (String) getProperties(service, port).get(property);
}
public String getPrefix() {
return prefix;
}
private String[] parseProperty(String property) {
// aliaas ns, service, port, targeted property
String[] res = new String[4];
int index = property.indexOf(dotted_prefix);
if (index <= 0) {
// assume there is no service/port prefixed, no need to go further
res[3] = property;
} else {
res[3] = property.substring(index + dotted_prefix.length()); // targeted property
String prefix = property.substring(0, index);
String[] t = prefix.split("\\.");
if (t.length != 2 && t.length != 3) {
throw new IllegalArgumentException("Invalid property name:" + property + " Expected pattern: [nsalias.service.[port.]" + prefix + ".]property");
}
if (t.length >= 2) {
res[0] = t[0]; // ns alias
res[1] = t[1]; // service name
}
if (t.length > 2) {
res[2] = t[2]; // port name
}
}
return res;
}
/**
* Link two Maps instances in a parent-child relation. Meaning that if a key is looked up but not found on the child,
* then the key will be looked up on the parent map.
* <br/>The raison d'etre of this class is to the {@link #keySet()} method. This methods returns a set of <strong>all</strong> the keys contained in the child and the parent.
* That's the main reason to not used the {@link java.util.Properties} class (which offers access to child keys only).
* <p/>The child has an immutable view of the parent map. Methods {@link #clear()} and {@link #remove(Object)}
* throw {@link UnsupportedOperationException}. Methods {@link #put(Object, Object)} and {@link #putAll(java.util.Map)} impacts only the child map.
* <br/>Methods {@link #clearLocally()}
* <p/>
* This class does NOT implement the {@link java.util.Map} interface because methods {@link java.util.Map#entrySet()} },
* {@link java.util.Map#values()} and {@link java.util.Map#keySet()} would NOT be backed by the Map itself.
* <br/> Contributions welcome to implement that part.
*
* @author <a href="mailto:midon@intalio.com">Alexis Midon</a>
*/
private static class ChainedMap {
private ChainedMap parent;
private Map child;
public ChainedMap() {
parent = null;
child = new HashMap();
}
public ChainedMap(ChainedMap parent) {
this.parent = parent;
this.child = new HashMap();
}
public ChainedMap getParent() {
return parent;
}
public void setParent(ChainedMap parent) {
this.parent = parent;
}
/**
* Perfom a look up on the child map only.
*/
public Object getLocally(Object key) {
return child.get(key);
}
/**
* Clear the child map only, the parent map is not altered.
*/
public void clearLocally() {
child.clear();
}
/**
* Perform a look up for the given key on the child map, and if not found then perform the look up on the parent map.
*
* @param key
* @return
*/
public Object get(Object key) {
Object lv = getLocally(key);
if (lv != null) return lv;
else if (parent != null) return parent.get(key);
return null;
}
/**
* Put this pair in the child map.
*/
public Object put(Object key, Object value) {
if (key == null) throw new NullPointerException("Null keys forbidden!");
return child.put(key, value);
}
/**
* Put these pairs in the child map.
*/
public void putAll(Map t) {
for (Object e : t.entrySet()) {
put(((Map.Entry) e).getKey(), ((Map.Entry) e).getValue());
}
}
/**
* @throws UnsupportedOperationException
* @see #clearLocally()
*/
public void clear() {
throw new UnsupportedOperationException();
}
/**
* @throws UnsupportedOperationException
*/
public Object remove(Object key) {
throw new UnsupportedOperationException();
}
/**
* @return true if the child map is empty AND the parent map is null or empty as well.
* <pre>child.isEmpty() && (parent == null || parent.isEmpty());</pre>
*/
public boolean isEmpty() {
return child.isEmpty() && (parent == null || parent.isEmpty());
}
/**
* @return true if the child map contains this key OR the parent map is not null and contains this key.
* <pre>child.containsKey(key) || (parent != null && parent.containsKey(key));</pre>
*/
public boolean containsKey(Object key) {
if (key == null) throw new NullPointerException("Null keys forbidden!");
return child.containsKey(key) || (parent != null && parent.containsKey(key));
}
/**
* @return true if the child map contains this value OR the parent is not null
* <pre>child.containsValue(value) || (parent != null && parent.containsValue(value));</pre>
*/
public boolean containsValue(Object value) {
return child.containsValue(value) || (parent != null && parent.containsValue(value));
}
public int size() {
return keySet().size();
}
/**
* @return a new set instance merging all keys contained in the child and parent maps. <strong>The returned set is not backed by the maps.</strong>
* Any references to the returned sets are hold at the holder's own risks. This breaks the general {@link java.util.Map#entrySet()} contract.
*/
public Set keySet() {
HashSet s = new HashSet(child.keySet());
if (parent != null) s.addAll(parent.keySet());
return s;
}
}
}