import sys
import src
+import src.debug as DBG
+import pprint as PP
class Environ:
- '''Class to manage the environment context
- '''
+ """\
+ Class to manage the environment context
+ """
def __init__(self, environ=None):
- '''Initialization. If the environ argument is passed, the environment
+ """Initialization. If the environ argument is passed, the environment
will be add to it, else it is the external environment.
:param environ dict:
- '''
+ """
if environ is not None:
self.environ = environ
else:
self.environ = os.environ
def __repr__(self):
- """easy non exhaustive quick resume for debug print
- """
- res={}
- res["environ"]=self.environ
- return self.__class__.__name__ + str(res)[0:-1] + " ...etc...}"
+ """easy non exhaustive quick resume for debug print"""
+ return "%s(\n%s\n)" % (self.__class__.__name__, PP.pformat(self.environ))
def _expandvars(self, value):
- '''replace some $VARIABLE into its actual value in the environment
+ """\
+ replace some $VARIABLE into its actual value in the environment
:param value str: the string to be replaced
:return: the replaced variable
:rtype: str
- '''
+ """
if "$" in value:
# The string.Template class is a string class
# for supporting $-substitutions
return value
def append_value(self, key, value, sep=os.pathsep):
- '''append value to key using sep
+ """\
+ append value to key using sep
:param key str: the environment variable to append
:param value str: the value to append to key
:param sep str: the separator string
- '''
+ """
# check if the key is already in the environment
if key in self.environ:
value_list = self.environ[key].split(sep)
self.set(key, value)
def append(self, key, value, sep=os.pathsep):
- '''Same as append_value but the value argument can be a list
+ """\
+ Same as append_value but the value argument can be a list
:param key str: the environment variable to append
:param value str or list: the value(s) to append to key
:param sep str: the separator string
- '''
+ """
if isinstance(value, list):
for v in value:
self.append_value(key, v, sep)
self.append_value(key, value, sep)
def prepend_value(self, key, value, sep=os.pathsep):
- '''prepend value to key using sep
+ """\
+ prepend value to key using sep
:param key str: the environment variable to prepend
:param value str: the value to prepend to key
:param sep str: the separator string
- '''
+ """
if key in self.environ:
value_list = self.environ[key].split(sep)
if not value in value_list:
self.set(key, value)
def prepend(self, key, value, sep=os.pathsep):
- '''Same as prepend_value but the value argument can be a list
+ """\
+ Same as prepend_value but the value argument can be a list
:param key str: the environment variable to prepend
:param value str or list: the value(s) to prepend to key
:param sep str: the separator string
- '''
+ """
if isinstance(value, list):
for v in value:
self.prepend_value(key, v, sep)
self.prepend_value(key, value, sep)
def is_defined(self, key):
- '''Check if the key exists in the environment
+ """\
+ Check if the key exists in the environment
:param key str: the environment variable to check
- '''
+ """
return key in self.environ.keys()
def set(self, key, value):
- '''Set the environment variable "key" to value "value"
+ """\
+ Set the environment variable "key" to value "value"
:param key str: the environment variable to set
:param value str: the value
- '''
+ """
self.environ[key] = self._expandvars(value)
def get(self, key):
- '''Get the value of the environment variable "key"
+ """\
+ Get the value of the environment variable "key"
:param key str: the environment variable
- '''
+ """
if key in self.environ:
return self.environ[key]
else:
return ""
def command_value(self, key, command):
- '''Get the value given by the system command "command"
- and put it in the environment variable key
+ """\
+ Get the value given by the system command "command"
+ and put it in the environment variable key
:param key str: the environment variable
:param command str: the command to execute
- '''
+ """
value = subprocess.Popen(command,
shell=True,
stdout=subprocess.PIPE,
class SalomeEnviron:
- """Class to manage the environment of SALOME.
+ """\
+ Class to manage the environment of SALOME.
"""
-
def __init__(self,
cfg,
environ,
forBuild=False,
for_package=None,
enable_simple_env_script = True):
- '''Initialization.
+ """\
+ Initialization.
:param cfg Config: the global config
:param environ Environ: the Environ instance where
else a build one
:param for_package str: If not None, produce a relative environment
designed for a package.
- '''
+ """
self.environ = environ
self.cfg = cfg
self.forBuild = forBuild
self.silent = False
def __repr__(self):
- """easy non exhaustive quick resume for debug print"""
- res={}
- res["environ"]=str(self.environ)
- res["forBuild"]=self.forBuild
- return self.__class__.__name__ + str(res)[0:-1] + " ...etc...}"
+ """easy almost exhaustive quick resume for debug print"""
+ res = {
+ "environ" : self.environ,
+ "forBuild" : self.forBuild,
+ "for_package" : self.for_package,
+ }
+ return "%s(\n%s\n)" % (self.__class__.__name__, PP.pformat(res))
def append(self, key, value, sep=os.pathsep):
- '''append value to key using sep
+ """\
+ append value to key using sep
:param key str: the environment variable to append
:param value str: the value to append to key
:param sep str: the separator string
- '''
+ """
return self.environ.append(key, value, sep)
def prepend(self, key, value, sep=os.pathsep):
- '''prepend value to key using sep
+ """\
+ prepend value to key using sep
:param key str: the environment variable to prepend
:param value str: the value to prepend to key
:param sep str: the separator string
- '''
+ """
return self.environ.prepend(key, value, sep)
def is_defined(self, key):
- '''Check if the key exists in the environment
+ """\
+ Check if the key exists in the environment
:param key str: the environment variable to check
- '''
+ """
return self.environ.is_defined(key)
def get(self, key):
- '''Get the value of the environment variable "key"
+ """\
+ Get the value of the environment variable "key"
:param key str: the environment variable
- '''
+ """
return self.environ.get(key)
def set(self, key, value):
- '''Set the environment variable "key" to value "value"
+ """\
+ Set the environment variable "key" to value "value"
:param key str: the environment variable to set
:param value str: the value
- '''
+ """
# check if value needs to be evaluated
if value is not None and value.startswith("`") and value.endswith("`"):
res = subprocess.Popen("echo %s" % value,
return self.environ.set(key, value)
def dump(self, out):
- """Write the environment to out
+ """\
+ Write the environment to out
:param out file: the stream where to write the environment
"""
out.write("%s=%s\n" % (k, value))
def add_line(self, nb_line):
- """Add empty lines to the out stream (in case of file generation)
+ """\
+ Add empty lines to the out stream (in case of file generation)
:param nb_line int: the number of empty lines to add
"""
self.environ.add_line(nb_line)
def add_comment(self, comment):
- """Add a commentary to the out stream (in case of file generation)
+ """\
+ Add a commentary to the out stream (in case of file generation)
:param comment str: the commentary to add
"""
self.environ.add_comment(comment)
def add_warning(self, warning):
- """Add a warning to the out stream (in case of file generation)
+ """\
+ Add a warning to the out stream (in case of file generation)
:param warning str: the warning to add
"""
self.environ.add_warning(warning)
def finish(self, required):
- """Add a final instruction in the out file (in case of file generation)
+ """\
+ Add a final instruction in the out file (in case of file generation)
:param required bool: Do nothing if required is False
"""
self.environ.finish(required)
def set_python_libdirs(self):
- """Set some generic variables for python library paths
- """
+ """Set some generic variables for python library paths"""
ver = self.get('PYTHON_VERSION')
self.set('PYTHON_LIBDIR0', os.path.join('lib',
'python' + ver,
self.python_lib1 = self.get('PYTHON_LIBDIR1')
def get_names(self, lProducts):
- """Get the products name to add in SALOME_MODULES environment variable
- It is the name of the product, except in the case where the is a
- component name. And it has to be in SALOME_MODULES variable only
- if the product has the property has_salome_hui = "yes"
+ """\
+ Get the products name to add in SALOME_MODULES environment variable
+ It is the name of the product, except in the case where the is a
+ component name. And it has to be in SALOME_MODULES variable only
+ if the product has the property has_salome_hui = "yes"
:param lProducts list: List of products to potentially add
"""
return lProdName
def set_application_env(self, logger):
- """Sets the environment defined in the APPLICATION file.
+ """\
+ Sets the environment defined in the APPLICATION file.
:param logger Logger: The logger instance to display messages
"""
+ # add variable PRODUCT_ROOT_DIR as $workdir in APPLICATION.environ section if not present
+ try:
+ tmp = self.cfg.APPLICATION.environ.PRODUCT_ROOT_DIR
+ except:
+ self.cfg.APPLICATION.environ.PRODUCT_ROOT_DIR = src.pyconf.Reference(self.cfg, src.pyconf.DOLLAR, "workdir")
+ DBG.write("set_application_env add default Config.APPLICATION.environ.PRODUCT_ROOT_DIR", self.cfg.APPLICATION.environ)
+
# Set the variables defined in the "environ" section
if 'environ' in self.cfg.APPLICATION:
- self.add_comment("APPLICATION environment")
+ # we write PRODUCT environment it in order to conform to
+ # parseConfigFile.py
+ self.add_comment("PRODUCT environment")
self.load_cfg_environment(self.cfg.APPLICATION.environ)
if self.forBuild and "build" in self.cfg.APPLICATION.environ:
self.load_cfg_environment(self.cfg.APPLICATION.environ.build)
self.add_line(1)
def set_salome_minimal_product_env(self, product_info, logger):
- """Sets the minimal environment for a SALOME product.
- xxx_ROOT_DIR and xxx_SRC_DIR
+ """\
+ Sets the minimal environment for a SALOME product.
+ xxx_ROOT_DIR and xxx_SRC_DIR
:param product_info Config: The product description
:param logger Logger: The logger instance to display messages
"""
# set root dir
+ DBG.write("set_salome_minimal_product_env", product_info)
root_dir = product_info.name + "_ROOT_DIR"
if not self.is_defined(root_dir):
if 'install_dir' in product_info and product_info.install_dir:
product_info.name))
def set_salome_generic_product_env(self, pi):
- """Sets the generic environment for a SALOME product.
+ """\
+ Sets the generic environment for a SALOME product.
:param pi Config: The product description
"""
self.prepend('PYTHONPATH', l)
def set_cpp_env(self, product_info):
- """Sets the generic environment for a SALOME cpp product.
+ """\
+ Sets the generic environment for a SALOME cpp product.
:param product_info Config: The product description
"""
self.prepend('PYTHONPATH', l)
def load_cfg_environment(self, cfg_env):
- """Loads environment defined in cfg_env
+ """\
+ Loads environment defined in cfg_env
:param cfg_env Config: A config containing an environment
"""
self.set(env_def, val)
def set_a_product(self, product, logger):
- """Sets the environment of a product.
+ """\
+ Sets the environment of a product.
:param product str: The product name
:param logger Logger: The logger instance to display messages
def run_env_script(self, product_info, logger=None, native=False):
- """Runs an environment script.
+ """\
+ Runs an environment script.
:param product_info Config: The product description
:param logger Logger: The logger instance to display messages
traceback.print_exc()
def run_simple_env_script(self, script_path, logger=None):
- """Runs an environment script. Same as run_env_script, but with a
- script path as parameter.
+ """\
+ Runs an environment script. Same as run_env_script, but with a
+ script path as parameter.
:param script_path str: a path to an environment script
:param logger Logger: The logger instance to display messages
traceback.print_exc()
def set_products(self, logger, src_root=None):
- """Sets the environment for all the products.
+ """\
+ Sets the environment for all the products.
:param logger Logger: The logger instance to display messages
:param src_root src: the application working directory
self.finish(False)
def set_full_environ(self, logger, env_info):
- """Sets the full environment for products
- specified in env_info dictionary.
+ """\
+ Sets the full environment for products
+ specified in env_info dictionary.
:param logger Logger: The logger instance to display messages
:param env_info list: the list of products
"""
+ DBG.write("set_full_environ for", env_info)
+ # DBG.write("set_full_environ config", self.cfg.APPLICATION.environ, True)
# set product environ
self.set_application_env(logger)
self.set_a_product(product, logger)
class FileEnvWriter:
- """Class to dump the environment to a file.
+ """\
+ Class to dump the environment to a file.
"""
def __init__(self, config, logger, out_dir, src_root, env_info=None):
- '''Initialization.
+ """\
+ Initialization.
:param cfg Config: the global config
:param logger Logger: The logger instance to display messages
:param out_dir str: The directory path where t put the output files
:param src_root str: The application working directory
:param env_info str: The list of products to add in the files.
- '''
+ """
self.config = config
self.logger = logger
self.out_dir = out_dir
self.env_info = env_info
def write_env_file(self, filename, forBuild, shell, for_package = None):
- """Create an environment file.
+ """\
+ Create an environment file.
:param filename str: the file path
:param forBuild bool: if true, the build environment
additional_env = {},
for_package = None,
with_commercial = True):
- """Append to current opened aFile a cfgForPy
- environment (SALOME python launcher).
+ """\
+ Append to current opened aFile a cfgForPy
+ environment (SALOME python launcher).
:param filename str: the file path
:param additional_env dict: a dictionary of additional variables
env.finish(True)
class Shell:
- """Definition of a Shell.
+ """\
+ Definition of a Shell.
"""
def __init__(self, name, extension):
- '''Initialization.
+ """\
+ Initialization.
:param name str: the shell name
:param extension str: the shell extension
- '''
+ """
self.name = name
self.extension = extension
def load_environment(config, build, logger):
- """Loads the environment (used to run the tests, for example).
+ """\
+ Loads the environment (used to run the tests, for example).
:param config Config: the global config
:param build bool: build environement if True
