| #!/usr/bin/python |
| |
| import os |
| import re |
| import platform |
| import string |
| |
| # ----------------------------------------------------------------------- |
| # 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. |
| # ----------------------------------------------------------------------- |
| |
| class PropertiesException(Exception): |
| def __init__(self, msg): |
| self.msg = msg |
| |
| def __str__(self): |
| return repr(self.msg) |
| |
| class Property: |
| def __init__(self, k, v, c): |
| self.k = k # key |
| self.v = v # value |
| self.c = c # comments |
| self.orig_v = v |
| |
| def reset(self): |
| self.v = self.orig_v |
| |
| def __str__(self): |
| return str(self.k) + '=' + str(self.v) |
| |
| class Properties: |
| def __init__(self): |
| self.props = {} |
| self.builtin = {} |
| |
| self.keys = [] |
| self.comments = [] |
| |
| # |
| # Create builtins corresponding to some of the java properties. |
| # |
| # We allow expansion on java system properties. It's obviously not possible to |
| # do most of them but these guys may have a use e.g. to put ducc_ling into |
| # architecture-specific places. |
| # |
| (system, node, release, version, machine, processor) = platform.uname() |
| if ( system == 'Darwin' ): |
| self.builtin['os.arch'] = 'x86_64' |
| self.builtin['os.name'] = 'Mac OS X' |
| elif ( system == 'Linux' ): |
| if ( machine == 'ppc64' ): |
| self.builtin['os.arch'] = 'ppc64' |
| self.builtin['os.name'] = 'Linux' |
| elif ( machine == 'x86_64' ): |
| self.builtin['os.arch'] = 'amd64' |
| self.builtin['os.name'] = 'Linux' |
| elif ( machine == 'ppc64le' ): |
| self.builtin['os.arch'] = 'ppc64le' |
| self.builtin['os.name'] = 'Linux' |
| |
| |
| # |
| # Expand all ${} values. The search order is: |
| # 1 look in this properties file |
| # 2 look in the environment |
| # 3 look in a subset of the Java system properties (os.name & os.arch) |
| # |
| def do_subst(self, st): |
| key = None |
| p = re.compile("\\$\\{[a-zA-Z0-9_\\.\\-]+\\}") |
| ndx = 0 |
| |
| response = st.strip() |
| m = p.search(response, ndx) |
| while ( m != None ): |
| key = m.group()[2:-1] |
| |
| |
| val = None |
| if ( self.has_key(key) ): |
| val = self.get(key) |
| elif ( os.environ.has_key(key) ): |
| val = os.environ[key] |
| elif (self.builtin.has_key(key) ): |
| val = self.builtin[key] |
| |
| if ( val != None ): |
| response = string.replace(response, m.group() , val) |
| ndx = m.start()+1 |
| m = p.search(response, ndx) |
| |
| return response |
| |
| def mkitem(self, line): |
| # |
| # First deal with line comments so we can preserve them on write |
| # |
| if ( line.startswith('#') ): |
| self.comments.append(line) |
| return False |
| |
| if ( line.startswith('//') ): |
| self.comments.append(line) |
| return False |
| |
| if ( line == '' ): |
| return False |
| |
| # |
| # Now strip off embedded comments, these are lost, but they're not valid |
| # for java props anyway. |
| # |
| ndx = line.find('#') # remove comments - like the java DuccProperties |
| if ( ndx >= 0 ): |
| line = line[0:ndx] # strip the comment |
| ndx = line.find('//') # remove comments - like the java DuccProperties |
| if ( ndx >= 0 ): |
| line = line[0:ndx] # strip the comment |
| line = line.strip() # clear leading and trailing whitespace |
| |
| if ( line == '' ): |
| return |
| |
| mobj = re.search('[ =:]+', line) |
| if ( mobj ): |
| key = line[:mobj.start()].strip() |
| val = line[mobj.end():].strip() |
| # print 'NEXT', mobj.start(), 'END', mobj.end(), 'KEY', key, 'VAL', val |
| # val = self.do_subst(val) # we'll do lazy subst on get instead |
| self.props[key] = Property(key, val, self.comments) |
| if ( key in self.keys ): |
| self.keys.remove(key) |
| self.keys.append(key) |
| self.comments = [] |
| else: |
| self.props[line] = Property(line, '', self.comments) |
| self.keys.append(line) |
| self.comments = [] |
| |
| # |
| # Load reads a properties file and adds it contents to the |
| # hash. It may be called several times; each call updates |
| # the internal has, thus building it up. The input file is |
| # in the form of a java-like properties file. |
| # |
| def load(self, propsfile): |
| if ( not os.path.exists(propsfile) ): |
| raise PropertiesException(propsfile + ' does not exist and cannot be loaded.') |
| |
| f = open(propsfile); |
| for line in f: |
| self.mkitem(line.strip()) |
| f.close() |
| |
| # read a jar manifest into a properties entity |
| def load_from_manifest(self, jarfile): |
| z = zipfile.ZipFile(jarfile) |
| items = z.read('META-INF/MANIFEST.MF').split('\n') |
| for item in items: |
| self.mkitem(item) |
| |
| # |
| # Try to load a properties file. Just be silent if it doesn't exist. |
| # |
| def load_if_exists(self, propsfile): |
| if ( os.path.exists(propsfile) ): |
| return self.load(propsfile) |
| |
| # |
| # Put something into the hash with an optional comment |
| # |
| def put(self, key, value, comment=[]): |
| self.props[key] = Property(key, value, comment) |
| self.keys.append(key) |
| |
| # |
| # Put a Property object into the map |
| # |
| def put_property(self, p): |
| self.props[p.k] = p |
| self.keys.append(p.k) |
| |
| # |
| # Get a value from the hash |
| # |
| def get(self, key): |
| if ( self.props.has_key(key) ): |
| return self.do_subst(self.props[key].v) # we'll do lazy subst on get instead |
| return None |
| |
| # |
| # Get a Property object for manipulation (k, v, comment) |
| # |
| def get_property(self, key): |
| if ( self.props.has_key(key) ): |
| return self.props[key] # note no expansion. |
| return None |
| |
| # |
| # Remove an item if it exists |
| # |
| def delete(self, key): |
| if ( self.props.has_key(key) ): |
| del self.props[key] |
| self.keys.remove(key) |
| |
| # |
| # Write the has as a Java-like properties file |
| # |
| def write(self, propsfile): |
| f = open(propsfile, 'w') |
| for k in self.keys: |
| p = self.props[k] |
| v = p.v |
| c = p.c |
| for cc in c: |
| f.write(cc + '\n') |
| f.write(k + ' = ' + str(v) + '\n\n') |
| |
| f.close() |
| |
| # |
| # return a shallow copy of the dictionary |
| # |
| def copy_dictionary(self): |
| return self.props.copy() |
| |
| # |
| # Return the entries (Property list) in the dictionary |
| # |
| def items(self): |
| return self.props.items() |
| |
| # |
| # The keys, in the order as defined in the input file |
| # |
| def get_keys(self): |
| return self.keys |
| |
| # |
| # check to see if the key exists in the dictionary |
| # |
| def has_key(self, key): |
| return self.props.has_key(key) |
| |
| # |
| # Return the length of the dictionary |
| # |
| def __len__(self): |
| return len(self.props) |
