Inheritance diagram for EnvConfig.Control.Environment:

Collaboration diagram for EnvConfig.Control.Environment:

Public Member Functions
def	__init__

def	vars

def	var (self, name)

def	search

def	declare (self, name, vartype, local)

def	append (self, name, value)

def	prepend (self, name, value)

def	set (self, name, value)

def	default (self, name, value)

def	unset

def	remove

def	remove_regexp (self, name, value)

def	searchFile (self, filename, varName)

def	loadXML

def	startXMLinput (self)

def	finishXMLinput

def	writeToFile

def	writeToXMLFile (self, fileName)

def	presetFromSystem (self)

def	process (self)

def	__getitem__ (self, key)

def	__setitem__ (self, key, value)

def	__delitem__ (self, key)

def	__iter__ (self)

def	__contains__ (self, item)

def	__len__ (self)

Public Attributes
	log

	separator

	searchPath

	actions

	variables

	loadFromSystem

	asWriter

	writer

	loadedFiles

Private Member Functions
def	_locate

def	_guessType (self, varname)

def	_concatenate (self, value)

def	_writeVarToXML

Private Attributes
	_fileDirStack

Detailed Description

object to hold settings of environment

Definition at line 13 of file Control.py.

Constructor & Destructor Documentation

def EnvConfig.Control.Environment.__init__	(	self,
		loadFromSystem = `True`,
		useAsWriter = `False`,
		searchPath = `None`
	)

Initial variables to be pushed and setup

append switch between append and prepend for initial variables.
loadFromSystem causes variable`s system value to be loaded on first encounter.
If useAsWriter == True than every change to variables is recorded to XML file.
reportLevel sets the level of messaging.

Definition at line 16 of file Control.py.

     def __init__(self, loadFromSystem=True, useAsWriter=False, searchPath=None):
         '''Initial variables to be pushed and setup
 
         append switch between append and prepend for initial variables.
         loadFromSystem causes variable`s system value to be loaded on first encounter.
         If useAsWriter == True than every change to variables is recorded to XML file.
         reportLevel sets the level of messaging.
         '''
         self.log = logging.getLogger('Environment')
 
         self.separator = ':'
 
         # Prepeare the internal search path for xml files (used by 'include' elements)
         if searchPath is None:
             self.searchPath = []
         else:
             self.searchPath = list(searchPath)
 
         def addToSearchPath(n, _1, _2):
             '''
             Add entries to the search path expanding variables inside.
             '''
             entries = Variable.List('_SEARCH_PATH')
             entries.set(n, os.pathsep, environment=self.variables)
             self.searchPath.extend(entries)
 
         self.actions = {}
         self.actions['include'] = lambda n, c, h: self.loadXML(self._locate(n, c, h))
         self.actions['append'] = lambda n, v, _: self.append(n, v)
         self.actions['prepend'] = lambda n, v, _: self.prepend(n, v)
         self.actions['set'] = lambda n, v, _: self.set(n, v)
         self.actions['unset'] = lambda n, v, _: self.unset(n, v)
         self.actions['default'] = lambda n, v, _: self.default(n, v)
         self.actions['remove'] = lambda n, v, _: self.remove(n, v)
         self.actions['remove-regexp'] = lambda n, v, _: self.remove_regexp(n, v)
         self.actions['declare'] = self.declare
         self.actions['search_path'] = addToSearchPath
 
         self.variables = {}
 
         self.loadFromSystem = loadFromSystem
         self.asWriter = useAsWriter
         if useAsWriter:
             self.writer = xmlModule.XMLFile()
             self.startXMLinput()
 
         self.loadedFiles = set()
 
         # Prepare the stack for the directory of the loaded file(s)
         self._fileDirStack = []
         # Note: cannot use self.declare() because we do not want to write out
         #       the changes to ${.}
         dot = Variable.Scalar('.', local=True)
         dot.expandVars = False
         dot.set('')
         self.variables['.'] = dot
 
 

Member Function Documentation

def EnvConfig.Control.Environment.__contains__	(	self,
		item
	)

Definition at line 376 of file Control.py.

     def __contains__(self, item):
         return item in self.variables.keys()
 

def EnvConfig.Control.Environment.__delitem__	(	self,
		key
	)

Definition at line 369 of file Control.py.

     def __delitem__(self, key):
         del self.variables[key]
 

def EnvConfig.Control.Environment.__getitem__	(	self,
		key
	)

Definition at line 360 of file Control.py.

     def __getitem__(self, key):
         return self.variables[key]
 

def EnvConfig.Control.Environment.__iter__ ( self )

Definition at line 372 of file Control.py.

     def __iter__(self):
         for i in self.variables:
             yield i
 

def EnvConfig.Control.Environment.__len__ ( self )

Definition at line 379 of file Control.py.

     def __len__(self):
         return len(self.variables.keys())
 

def EnvConfig.Control.Environment.__setitem__	(	self,
		key,
		value
	)

Definition at line 363 of file Control.py.

     def __setitem__(self, key, value):
         if key in self.variables.keys():
             self.log.warning('Addition canceled because of duplicate entry. Var: "%s" value: "%s".', key, value)
         else:
             self.append(key, value)
 

def EnvConfig.Control.Environment._concatenate	(	self,
		value
	)

private

Returns a variable string with separator separator from the values list

Definition at line 344 of file Control.py.

     def _concatenate(self, value):
         '''Returns a variable string with separator separator from the values list'''
         stri = ""
         for it in value:
             stri += it + self.separator
         stri = stri[0:len(stri)-1]
         return stri
 
 

def EnvConfig.Control.Environment._guessType	(	self,
		varname
	)

private

Guess the type of the variable from its name: if the name contains
'PATH' or 'DIRS', then the variable is a list, otherwise it is a scalar.

Definition at line 136 of file Control.py.

     def _guessType(self, varname):
         '''
         Guess the type of the variable from its name: if the name contains
         'PATH' or 'DIRS', then the variable is a list, otherwise it is a scalar.
         '''
         varname = varname.upper() # make the comparison case insensitive
         if 'PATH' in varname or 'DIRS' in varname:
             return 'list'
         else:
             return 'scalar'
 

def EnvConfig.Control.Environment._locate	(	self,
		filename,
		caller = `None`,
		hints = `None`
	)

private

Find 'filename' in the internal search path.

Definition at line 74 of file Control.py.

     def _locate(self, filename, caller=None, hints=None):
         '''
         Find 'filename' in the internal search path.
         '''
         from os.path import isabs, isfile, join, dirname, normpath, abspath
         if isabs(filename):
             return filename
 
         self.log.debug('looking for %s', filename)
         if hints is None:
             hints = []
         elif type(hints) is str:
             hints = hints.split(self.separator)
 
         if caller:
             calldir = dirname(caller)
             localfile = join(calldir, filename)
             self.log.debug('trying %s', localfile)
             if isfile(localfile):
                 self.log.debug('OK (local file)')
                 return localfile
             # allow for relative hints
             hints = [join(calldir, hint) for hint in hints]
 
         sp = EnvConfig.path + self.searchPath + hints
         def candidates():
             for d in sp:
                 f = normpath(join(d, filename))
                 self.log.debug('trying %s', f)
                 yield f
         try:
             f = (abspath(f) for f in candidates() if isfile(f)).next()
             self.log.debug('OK')
             return f
         except StopIteration:
             from errno import ENOENT
             raise OSError(ENOENT, 'cannot find file in %r' % sp, filename)
 

def EnvConfig.Control.Environment._writeVarToXML	(	self,
		name,
		action,
		value,
		vartype = `'list'`,
		local = `'false'`
	)

private

Writes single variable to XML file.

Definition at line 353 of file Control.py.

     def _writeVarToXML(self, name, action, value, vartype='list', local='false'):
         '''Writes single variable to XML file.'''
         if isinstance(value, list):
             value = self._concatenate(value)
         self.writer.writeVar(name, action, value, vartype, local)
 
 

def EnvConfig.Control.Environment.append	(	self,
		name,
		value
	)

Appends to an existing variable.

Definition at line 181 of file Control.py.

     def append(self, name, value):
         '''Appends to an existing variable.'''
         if self.asWriter:
             self._writeVarToXML(name, 'append', value)
         else:
             if name not in self.variables:
                 self.declare(name, self._guessType(name), False)
             self.variables[name].append(value, self.separator, self.variables)
 

def EnvConfig.Control.Environment.declare	(	self,
		name,
		vartype,
		local
	)

Creates an instance of new variable. It loads values from the OS if the variable is not local.

Definition at line 147 of file Control.py.

     def declare(self, name, vartype, local):
         '''Creates an instance of new variable. It loads values from the OS if the variable is not local.'''
         if self.asWriter:
             self._writeVarToXML(name, 'declare', '', vartype, local)
 
         if not isinstance(local, bool):
             if str(local).lower() == 'true':
                 local = True
             else:
                 local = False
 
         if name in self.variables.keys():
             if self.variables[name].local != local:
                 raise Variable.EnvError(name, 'redeclaration')
             else:
                 if vartype.lower() == "list":
                     if not isinstance(self.variables[name],Variable.List):
                         raise Variable.EnvError(name, 'redeclaration')
                 else:
                     if not isinstance(self.variables[name],Variable.Scalar):
                         raise Variable.EnvError(name, 'redeclaration')
 
         if vartype.lower() == "list":
             a = Variable.List(name, local)
         else:
             a = Variable.Scalar(name, local)
 
         if self.loadFromSystem and not local and name in os.environ:
             a.expandVars = False # disable var expansion when importing from the environment
             a.set(os.environ[name], os.pathsep, environment=self.variables)
             a.expandVars = True
 
         self.variables[name] = a
 

def EnvConfig.Control.Environment.default	(	self,
		name,
		value
	)

Sets a single variable only if it is not already set!

Definition at line 209 of file Control.py.

     def default(self, name, value):
         '''Sets a single variable only if it is not already set!'''
         name = str(name)
         if self.asWriter:
             self._writeVarToXML(name, 'default', value)
         else:
             # Here it is different from the other actions because after a 'declare'
             # we cannot tell if the variable was already set or not.
             # FIXME: improve declare() to allow for a default.
             if name not in self.variables:
                 if self._guessType(name) == 'list':
                     v = Variable.List(name, False)
                 else:
                     v = Variable.Scalar(name, False)
                 if self.loadFromSystem and name in os.environ:
                     v.set(os.environ[name], os.pathsep, environment=self.variables)
                 else:
                     v.set(value, self.separator, environment=self.variables)
                 self.variables[name] = v
             else:
                 v = self.variables[name]
                 if not v.val:
                     v.set(value, self.separator, environment=self.variables)
 

def EnvConfig.Control.Environment.finishXMLinput	(	self,
		outputFile = `''`
	)

Finishes input of XML file and closes the file.

Definition at line 290 of file Control.py.

     def finishXMLinput(self, outputFile = ''):
         '''Finishes input of XML file and closes the file.'''
         self.writer.writeToFile(outputFile)
 
 

def EnvConfig.Control.Environment.loadXML	(	self,
		fileName = `None`,
		namespace = `'EnvSchema'`
	)

Loads XML file for input variables.

Definition at line 260 of file Control.py.

     def loadXML(self, fileName=None, namespace='EnvSchema'):
         '''Loads XML file for input variables.'''
         XMLfile = xmlModule.XMLFile()
         fileName = self._locate(fileName)
         if fileName in self.loadedFiles:
             self.log.debug('ignore %s: already loaded', fileName)
             return # ignore recursion
         self.log.debug('loading %s', fileName)
         self.loadedFiles.add(fileName)
         dot = self.variables['.']
         # push the previous value of ${.} onto the stack...
         self._fileDirStack.append(dot.value())
         # ... and update the variable
         dot.set(os.path.dirname(fileName))
         variables = XMLfile.variable(fileName, namespace=namespace)
         for i, (action, args) in enumerate(variables):
             if action not in self.actions:
                 self.log.error('Node {0}: No action taken with var "{1}". Probably wrong action argument: "{2}".'.format(i, args[0], action))
             else:
                 self.actions[action](*args) # pylint: disable=W0142
         # restore the old value of ${.}
         dot.set(self._fileDirStack.pop())
         # ensure that a change of ${.} in the file is reverted when exiting it
         self.variables['.'] = dot
 

def EnvConfig.Control.Environment.prepend	(	self,
		name,
		value
	)

Prepends to an existing variable, or create a new one.

Definition at line 190 of file Control.py.

     def prepend(self, name, value):
         '''Prepends to an existing variable, or create a new one.'''
         if self.asWriter:
             self._writeVarToXML(name, 'prepend', value)
         else:
             if name not in self.variables:
                 self.declare(name, self._guessType(name), False)
             self.variables[name].prepend(value, self.separator, self.variables)
 

def EnvConfig.Control.Environment.presetFromSystem ( self )

Loads all variables from the current system settings.

Definition at line 331 of file Control.py.

     def presetFromSystem(self):
         '''Loads all variables from the current system settings.'''
         for k, v in os.environ.items():
             if k not in self.variables:
                 self.set(k, v)
 

def EnvConfig.Control.Environment.process ( self )

Call the variable processors on all the variables.

Definition at line 337 of file Control.py.

     def process(self):
         '''
         Call the variable processors on all the variables.
         '''
         for v in self.variables.values():
             v.val = v.process(v.val, self.variables)
 

def EnvConfig.Control.Environment.remove	(	self,
		name,
		value,
		regexp = `False`
	)

Remove value from variable.

Definition at line 241 of file Control.py.

     def remove(self, name, value, regexp=False):
         '''Remove value from variable.'''
         if self.asWriter:
             self._writeVarToXML(name, 'remove', value)
         else:
             if name not in self.variables:
                 self.declare(name, self._guessType(name), False)
             self.variables[name].remove(value, self.separator, regexp)
 

def EnvConfig.Control.Environment.remove_regexp	(	self,
		name,
		value
	)

Definition at line 250 of file Control.py.

     def remove_regexp(self, name, value):
         self.remove(name, value, True)

def EnvConfig.Control.Environment.search	(	self,
		varName,
		expr,
		regExp = `False`
	)

Searches in a variable for a value.

Definition at line 132 of file Control.py.

     def search(self, varName, expr, regExp=False):
         '''Searches in a variable for a value.'''
         return self.variables[varName].search(expr, regExp)
 

def EnvConfig.Control.Environment.searchFile	(	self,
		filename,
		varName
	)

Searches for appearance of variable in a file.

Definition at line 254 of file Control.py.

     def searchFile(self, filename, varName):
         '''Searches for appearance of variable in a file.'''
         XMLFile = xmlModule.XMLFile()
         variable = XMLFile.variable(filename, name=varName)
         return variable
 

def EnvConfig.Control.Environment.set	(	self,
		name,
		value
	)

Sets a single variable - overrides any previous value!

Definition at line 199 of file Control.py.

     def set(self, name, value):
         '''Sets a single variable - overrides any previous value!'''
         name = str(name)
         if self.asWriter:
             self._writeVarToXML(name, 'set', value)
         else:
             if name not in self.variables:
                 self.declare(name, self._guessType(name), False)
             self.variables[name].set(value, self.separator, self.variables)
 

def EnvConfig.Control.Environment.startXMLinput ( self )

Renew writer for new input.

Definition at line 285 of file Control.py.

     def startXMLinput(self):
         '''Renew writer for new input.'''
         self.writer.resetWriter()
 
 

def EnvConfig.Control.Environment.unset	(	self,
		name,
		value = `None`
	)

Unsets a single variable to an empty value - overrides any previous value!

Definition at line 233 of file Control.py.

     def unset(self, name, value=None):# pylint: disable=W0613
         '''Unsets a single variable to an empty value - overrides any previous value!'''
         if self.asWriter:
             self._writeVarToXML(name, 'unset', '')
         else:
             if name in self.variables:
                 del self.variables[name]
 

def EnvConfig.Control.Environment.var	(	self,
		name
	)

Gets a single variable. If not available then tries to load from system.

Definition at line 125 of file Control.py.

     def var(self, name):
         '''Gets a single variable. If not available then tries to load from system.'''
         if name in self.variables:
             return self.variables[name]
         else:
             return os.environ[name]
 

def EnvConfig.Control.Environment.vars	(	self,
		strings = `True`
	)

returns dictionary of all variables optionally converted to string

Definition at line 112 of file Control.py.

     def vars(self, strings=True):
         '''returns dictionary of all variables optionally converted to string'''
         if strings:
             return dict([(n, v.value(True))
                          for n, v in self.variables.items()
                          if n != '.'])
         else:
             # clone the dictionary to remove the internal special var '.'
             vars_ = dict(self.variables)
             if '.' in vars_:
                 del vars_['.']
             return vars_
 

def EnvConfig.Control.Environment.writeToFile	(	self,
		fileName,
		shell = `'sh'`
	)

Creates an output file with a specified name to be used for setting variables by sourcing this file

Definition at line 295 of file Control.py.

     def writeToFile(self, fileName, shell='sh'):
         '''Creates an output file with a specified name to be used for setting variables by sourcing this file'''
         f = open(fileName, 'w')
         if shell == 'sh':
             f.write('#!/bin/bash\n')
             for variable in self.variables:
                 if not self[variable].local:
                     f.write('export ' +variable+'='+self[variable].value(True, os.pathsep)+'\n')
         elif shell == 'csh':
             f.write('#!/bin/csh\n')
             for variable in self.variables:
                 if not self[variable].local:
                     f.write('setenv ' +variable+' '+self[variable].value(True, os.pathsep)+'\n')
         else:
             f.write('')
             f.write('REM This is an enviroment settings file generated on '+strftime("%a, %d %b %Y %H:%M:%S\n", gmtime()))
             for variable in self.variables:
                 if not self[variable].local:
                     f.write('set '+variable+'='+self[variable].value(True, os.pathsep)+'\n')
 
         f.close()
 
 

def EnvConfig.Control.Environment.writeToXMLFile	(	self,
		fileName
	)

Writes the current state of environment to a XML file.

NOTE: There is no trace of actions taken, variables are written with a set action only.

Definition at line 318 of file Control.py.

     def writeToXMLFile(self, fileName):
         '''Writes the current state of environment to a XML file.
 
         NOTE: There is no trace of actions taken, variables are written with a set action only.
         '''
         writer = xmlModule.XMLFile()
         for varName in self.variables:
             if varName == '.':
                 continue # this is an internal transient variable
             writer.writeVar(varName, 'set', self.variables[varName].value(True, self.separator))
         writer.writeToFile(fileName)
 
 

Member Data Documentation

EnvConfig.Control.Environment._fileDirStack

private

Definition at line 65 of file Control.py.

EnvConfig.Control.Environment.actions

Definition at line 42 of file Control.py.

EnvConfig.Control.Environment.asWriter

Definition at line 57 of file Control.py.

EnvConfig.Control.Environment.loadedFiles

Definition at line 62 of file Control.py.

EnvConfig.Control.Environment.loadFromSystem

Definition at line 56 of file Control.py.

EnvConfig.Control.Environment.log

Definition at line 24 of file Control.py.

EnvConfig.Control.Environment.searchPath

Definition at line 30 of file Control.py.

EnvConfig.Control.Environment.separator

Definition at line 26 of file Control.py.

EnvConfig.Control.Environment.variables

Definition at line 54 of file Control.py.

EnvConfig.Control.Environment.writer

Definition at line 59 of file Control.py.

The documentation for this class was generated from the following file:

InstallArea/x86_64-slc6-gcc49-opt/scripts/EnvConfig/Control.py

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation