Edit File: parser.py
#! /usr/bin/python -tt import re import urlparse import urlgrabber import os.path import Errors _KEYCRE = re.compile(r"\$(\w+)") def varReplace(raw, vars): '''Perform variable replacement @param raw: String to perform substitution on. @param vars: Dictionary of variables to replace. Key is variable name (without $ prefix). Value is replacement string. @return: Input raw string with substituted values. ''' if not vars: return raw done = [] # Completed chunks to return while raw: m = _KEYCRE.search(raw) if not m: done.append(raw) break # Determine replacement value (if unknown variable then preserve # original) varname = m.group(1).lower() replacement = vars.get(varname, m.group()) start, end = m.span() done.append(raw[:start]) # Keep stuff leading up to token done.append(replacement) # Append replacement value raw = raw[end:] # Continue with remainder of string return ''.join(done) class ConfigPreProcessor: """ ConfigParser Include Pre-Processor File-like Object capable of pre-processing include= lines for a ConfigParser. The readline function expands lines matching include=(url) into lines from the url specified. Includes may occur in included files as well. Suggested Usage:: cfg = ConfigParser.ConfigParser() fileobj = confpp( fileorurl ) cfg.readfp(fileobj) """ def __init__(self, configfile, vars=None): # put the vars away in a helpful place self._vars = vars # used to track the current ini-section self._section = None # set some file-like object attributes for ConfigParser # these just make confpp look more like a real file object. self.mode = 'r' # first make configfile a url even if it points to # a local file scheme = urlparse.urlparse(configfile)[0] if scheme == '': # check it to make sure it's not a relative file url if configfile[0] != '/': try: rootdir = os.getcwd() + "/" except: rootdir = "/" configfile = rootdir + configfile url = 'file://' + configfile else: url = configfile # these are used to maintain the include stack and check # for recursive/duplicate includes self._incstack = [] self._alreadyincluded = [] # _pushfile will return None if he couldn't open the file fo = self._pushfile( url ) if fo is None: raise Errors.ConfigError, 'Error accessing file: %s' % url def readline( self, size=0 ): """ Implementation of File-Like Object readline function. This should be the only function called by ConfigParser according to the python docs. We maintain a stack of real FLOs and delegate readline calls to the FLO on top of the stack. When EOF occurs on the topmost FLO, it is popped off the stack and the next FLO takes over. include= lines found anywhere cause a new FLO to be opened and pushed onto the top of the stack. Finally, we return EOF when the bottom-most (configfile arg to __init__) FLO returns EOF. Very Technical Pseudo Code:: def confpp.readline() [this is called by ConfigParser] open configfile, push on stack while stack has some stuff on it line = readline from file on top of stack pop and continue if line is EOF if line starts with 'include=' then error if file is recursive or duplicate otherwise open file, push on stack continue else return line return EOF """ # set line to EOF initially. line='' while len(self._incstack) > 0: # peek at the file like object on top of the stack fo = self._incstack[-1] line = fo.readline() if len(line) > 0: m = re.match( r'\s*include\s*=\s*(?P<url>.*)', line ) if m: url = m.group('url') if len(url) == 0: raise Errors.ConfigError, \ 'Error parsing config %s: include must specify file to include.' % (self.name) else: # whooohoo a valid include line.. push it on the stack url = varReplace(url, self._vars) fo = self._pushfile( url ) else: # check if the current line starts a new section secmatch = re.match( r'\s*\[(?P<section>.*)\]', line ) if secmatch: self._section = secmatch.group('section') # line didn't match include=, just return it as is # for the ConfigParser break else: # the current file returned EOF, pop it off the stack. self._popfile() # if the section is prefixed by a space then it is breaks iniparser/configparser # so fix it broken_sec_match = re.match(r'\s+\[(?P<section>.*)\]', line) if broken_sec_match: line = line.lstrip() # at this point we have a line from the topmost file on the stack # or EOF if the stack is empty return varReplace(line, self._vars) def _absurl( self, url ): """ Returns an absolute url for the (possibly) relative url specified. The base url used to resolve the missing bits of url is the url of the file currently being included (i.e. the top of the stack). """ if len(self._incstack) == 0: # it's the initial config file. No base url to resolve against. return url else: return urlparse.urljoin( self.geturl(), url ) def _pushfile( self, url ): """ Opens the url specified, pushes it on the stack, and returns a file like object. Returns None if the url has previously been included. If the file can not be opened this function exits. """ # absolutize this url using the including files url # as a base url. absurl = self._absurl(url) # get the current section to add it to the included # url's name. includetuple = (absurl, self._section) # check if this has previously been included. if self._isalreadyincluded(includetuple): return None try: fo = urlgrabber.grabber.urlopen(absurl) except urlgrabber.grabber.URLGrabError, e: fo = None if fo is not None: self.name = absurl self._incstack.append( fo ) self._alreadyincluded.append(includetuple) else: raise Errors.ConfigError, \ 'Error accessing file for config %s' % (absurl) return fo def _popfile( self ): """ Pop a file off the stack signaling completion of including that file. """ fo = self._incstack.pop() fo.close() if len(self._incstack) > 0: self.name = self._incstack[-1].geturl() else: self.name = None def _isalreadyincluded( self, tuple ): """ Checks if the tuple describes an include that was already done. This does not necessarily have to be recursive """ for etuple in self._alreadyincluded: if etuple == tuple: return 1 return 0 def geturl(self): return self.name