# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
import os
+import pprint as PP
+import src.debug as DBG
+import src.architecture
+import src.environment
-batch_header="""@echo off
-
-rem The following variables are used only in case of a sat package
-set out_dir_Path=%~dp0
-set PRODUCT_OUT_DIR=%out_dir_Path%
-set prereq_install_Path=%out_dir_Path%\PREREQUISITES\INSTALL
-set prereq_build_Path=%out_dir_Path%\PREREQUISITES\BUILD
-"""
-
-
-bash_header="""#!/bin/bash
-##########################################################################
-#
-#### cleandup ###
-# cleanup a path (first parameter) from duplicated entries;
-# second parameter is the separator
-cleandup() {
-out_var=`echo $1 | awk -v sep=$2 '{ \\
- na = split($1,a,sep); \\
- k=0; \\
- for(i=0;i<=na;i++) { \\
- found=0; \\
- for(j=0;j<k;j++) { \\
- if(a[i]==aa[j]) \\
- { \\
- found=1; \\
- break; \\
- }; \\
- }; \\
- if(found==0) { \\
- aa[k++]=a[i]; \\
- }; \\
- }; \\
- ORS=sep; \\
- for(i=0;i<k;i++) { \\
- print aa[i]; \\
- } \\
- }' | sed -e 's|\\(.*\\)$1|\\1|g' -e 's|^[:;]||' -e 's|[:;]$||'`
-echo $out_var
-}
-### clean ###
-clean ()
-{
-xenv=`printenv $1`
-out_var=`cleandup $xenv $2`
-export $1=$out_var
-}
-
-# The 3 following variables are used only in case of a sat package
-export out_dir_Path=`dirname "${BASH_SOURCE[0]}"`
-export PRODUCT_OUT_DIR=${out_dir_Path}
-export PRODUCT_ROOT_DIR=${PRODUCT_OUT_DIR}
-export prereq_install_Path=${out_dir_Path}/PREREQUISITES/INSTALL
-export prereq_build_Path=${out_dir_Path}/PREREQUISITES/BUILD
-
-###########################################################################
-"""
-
-
-cfgForPy_header='''# a generated SALOME Configuration file in python syntax from "sat application %s"
-'''
-
-##
-# Instantiate correct FileEnvironment sub-class.
-def get_file_environ(output, shell, environ=None, config=None):
+def get_file_environ(output, shell, environ=None):
+ """Instantiate correct FileEnvironment sub-class.
+
+ :param output file: the output file stream.
+ :param shell str: the type of shell syntax to use.
+ :param environ dict: a potential additional environment.
+ """
+ if environ == None:
+ environ=src.environment.Environ({})
if shell == "bash":
return BashFileEnviron(output, environ)
- if shell == "batch":
- return BatchFileEnviron(output, environ)
+ if shell == "tcl":
+ return TclFileEnviron(output, environ)
+ if shell == "bat":
+ return BatFileEnviron(output, environ)
if shell == "cfgForPy":
- return CfgForPyFileEnviron(output, environ, config)
+ return LauncherFileEnviron(output, environ)
+ if shell == "cfg":
+ return ContextFileEnviron(output, environ)
raise Exception("FileEnviron: Unknown shell = %s" % shell)
-##
-# Base class for shell environment.
-class FileEnviron:
+class FileEnviron(object):
+ """\
+ Base class for shell environment
+ """
def __init__(self, output, environ=None):
+ """\
+ Initialization
+
+ :param output file: the output file stream.
+ :param environ dict: SalomeEnviron.
+ """
self._do_init(output, environ)
+ def __repr__(self):
+ """\
+ easy non exhaustive quick resume for debug print"""
+ res = {
+ "output" : self.output,
+ "environ" : self.environ,
+ }
+ return "%s(\n%s\n)" % (self.__class__.__name__, PP.pformat(res))
+
+
def _do_init(self, output, environ=None):
+ """\
+ Initialization
+
+ :param output file: the output file stream.
+ :param environ dict: a potential additional environment.
+ """
self.output = output
- self.toclean = []
+ self.init_path=True # by default we initialise all paths, except PATH
if environ is not None:
self.environ = environ
else:
- self.environ = os.environ
+ self.environ = src.environment.Environ({})
def add_line(self, number):
+ """\
+ Add some empty lines in the shell file
+
+ :param number int: the number of lines to add
+ """
self.output.write("\n" * number)
def add_comment(self, comment):
+ """\
+ Add a comment in the shell file
+
+ :param comment str: the comment to add
+ """
self.output.write("# %s\n" % comment)
def add_echo(self, text):
+ """\
+ Add a "echo" in the shell file
+
+ :param text str: the text to echo
+ """
self.output.write('echo %s"\n' % text)
def add_warning(self, warning):
+ """\
+ Add a warning "echo" in the shell file
+
+ :param warning str: the text to echo
+ """
self.output.write('echo "WARNING %s"\n' % warning)
def append_value(self, key, value, sep=os.pathsep):
- self.set(key, self.get(key) + sep + value)
- if (key, sep) not in self.toclean:
- self.toclean.append((key, sep))
+ """\
+ append value to key using sep,
+ if value contains ":" or ";" then raise error
+
+ :param key str: the environment variable to append
+ :param value str: the value to append to key
+ :param sep str: the separator string
+ """
+ # check that value so no contain the system separator
+ separator=os.pathsep
+ if separator in value:
+ raise Exception("FileEnviron append key '%s' value '%s' contains forbidden character '%s'" % (key, value, separator))
+ do_append=True
+ if self.environ.is_defined(key):
+ value_list = self.environ.get(key).split(sep)
+ if self.environ._expandvars(value) in value_list:
+ do_append=False # value is already in key path : we don't append it again
+
+ if do_append:
+ self.environ.append_value(key, value,sep)
+ self.set(key, self.get(key) + sep + value)
def append(self, key, value, sep=os.pathsep):
+ """\
+ 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):
- self.append_value(key, sep.join(value), sep)
+ for v in value:
+ self.append_value(key, v, sep)
else:
self.append_value(key, value, sep)
def prepend_value(self, key, value, sep=os.pathsep):
- self.set(key, value + sep + self.get(key))
- if (key, sep) not in self.toclean:
- self.toclean.append((key, sep))
+ """\
+ prepend value to key using sep,
+ if value contains ":" or ";" then raise error
+
+ :param key str: the environment variable to prepend
+ :param value str: the value to prepend to key
+ :param sep str: the separator string
+ """
+ # check that value so no contain the system separator
+ separator=os.pathsep
+ if separator in value:
+ raise Exception("FileEnviron append key '%s' value '%s' contains forbidden character '%s'" % (key, value, separator))
+
+ do_not_prepend=False
+ if self.environ.is_defined(key):
+ value_list = self.environ.get(key).split(sep)
+ exp_val=self.environ._expandvars(value)
+ if exp_val in value_list:
+ do_not_prepend=True
+ if not do_not_prepend:
+ self.environ.prepend_value(key, value,sep)
+ self.set(key, value + sep + self.get(key))
def prepend(self, key, value, sep=os.pathsep):
+ """\
+ 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):
- self.prepend_value(key, sep.join(value), sep)
+ for v in reversed(value): # prepend list, first item at last to stay first
+ self.prepend_value(key, v, sep)
else:
self.prepend_value(key, value, sep)
def is_defined(self, key):
- return (key in self.environ)
-
+ """\
+ Check if the key exists in the environment
+
+ :param key str: the environment variable to check
+ """
+ return self.environ.is_defined(key)
def set(self, key, value):
+ """\
+ Set the environment variable 'key' to value 'value'
+
+ :param key str: the environment variable to set
+ :param value str: the value
+ """
raise NotImplementedError("set is not implement for this shell!")
def get(self, key):
- return '${%s}' % key
+ """\
+ Get the value of the environment variable "key"
+
+ :param key str: the environment variable
+ """
+ if src.architecture.is_windows():
+ return '%' + key + '%'
+ else:
+ return '${%s}' % key
+
+ def get_value(self, key):
+ """Get the real value of the environment variable "key"
+ It can help env scripts
+ :param key str: the environment variable
+ """
+ return self.environ.get_value(key)
+
+ def finish(self):
+ """Add a final instruction in the out file (in case of file generation)
+
+ :param required bool: Do nothing if required is False
+ """
+ return
+
+ def set_no_init_path(self):
+ """Set the no initialisation mode for all paths.
+ By default only PATH is not reinitialised. All others paths are
+ (LD_LIBRARY_PATH, PYTHONPATH, ...)
+ After the call to these function ALL PATHS ARE NOT REINITIALISED.
+ There initial value is inherited from the environment
+ """
+ self.init_path=False
+
+ def value_filter(self, value):
+ res=value
+ return res
+
+
+class TclFileEnviron(FileEnviron):
+ """\
+ Class for tcl shell.
+ """
+ def __init__(self, output, environ=None):
+ """Initialization
+
+ :param output file: the output file stream.
+ :param environ dict: a potential additional environment.
+ """
+ self._do_init(output, environ)
+ self.output.write(tcl_header.replace("<module_name>",
+ self.environ.get("sat_product_name")))
+ self.output.write("\nset software %s\n" % self.environ.get("sat_product_name") )
+ self.output.write("set version %s\n" % self.environ.get("sat_product_version") )
+ root=os.path.join(self.environ.get("sat_product_base_path"),
+ "apps",
+ self.environ.get("sat_product_base_name"),
+ "$software",
+ "$version")
+ self.output.write("set root %s\n" % root)
+ modules_to_load=self.environ.get("sat_product_load_depend")
+ if len(modules_to_load)>0:
+ # write module load commands for product dependencies
+ self.output.write("\n")
+ for module_to_load in modules_to_load.split(";"):
+ self.output.write(module_to_load+"\n")
+
+ def set(self, key, value):
+ """Set the environment variable "key" to value "value"
+
+ :param key str: the environment variable to set
+ :param value str: the value
+ """
+ self.output.write('setenv %s "%s"\n' % (key, value))
+ self.environ.set(key, value)
+
+ def get(self, key):
+ """\
+ Get the value of the environment variable "key"
+
+ :param key str: the environment variable
+ """
+ return self.environ.get(key)
- def command_value(self, key, command):
- raise NotImplementedError("command_value is not implement for this shell!")
+ def append_value(self, key, value, sep=os.pathsep):
+ """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
+ """
+ if sep==os.pathsep:
+ self.output.write('append-path %s %s\n' % (key, value))
+ else:
+ self.output.write('append-path --delim=\%c %s %s\n' % (sep, key, value))
- def finish(self, required=True):
- for (key, sep) in self.toclean:
- if sep != ' ':
- self.output.write('clean %s "%s"\n' % (key, sep))
+ def prepend_value(self, key, value, sep=os.pathsep):
+ """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 sep==os.pathsep:
+ self.output.write('prepend-path %s %s\n' % (key, value))
+ else:
+ self.output.write('prepend-path --delim=\%c %s %s\n' % (sep, key, value))
-##
-# Class for bash shell.
+
class BashFileEnviron(FileEnviron):
+ """\
+ Class for bash shell.
+ """
def __init__(self, output, environ=None):
+ """Initialization
+
+ :param output file: the output file stream.
+ :param environ dict: a potential additional environment.
+ """
self._do_init(output, environ)
self.output.write(bash_header)
def set(self, key, value):
+ """Set the environment variable "key" to value "value"
+
+ :param key str: the environment variable to set
+ :param value str: the value
+ """
self.output.write('export %s="%s"\n' % (key, value))
- self.environ[key] = value
-
- def command_value(self, key, command):
- self.output.write('export %s=$(%s)\n' % (key, command))
+ self.environ.set(key, value)
+
- def finish(self, required=True):
- if not required:
- return
- FileEnviron.finish(self, required)
-##
-# Class for Windows batch shell.
-class BatchFileEnviron(FileEnviron):
+class BatFileEnviron(FileEnviron):
+ """\
+ for Windows batch shell.
+ """
def __init__(self, output, environ=None):
+ """Initialization
+
+ :param output file: the output file stream.
+ :param environ dict: a potential additional environment.
+ """
self._do_init(output, environ)
- self.output.write(batch_header)
+ self.output.write(bat_header)
def add_comment(self, comment):
+ """Add a comment in the shell file
+
+ :param comment str: the comment to add
+ """
self.output.write("rem %s\n" % comment)
def get(self, key):
+ """Get the value of the environment variable "key"
+
+ :param key str: the environment variable
+ """
return '%%%s%%' % key
def set(self, key, value):
- self.output.write('set %s=%s\n' % (key, value))
- self.environ[key] = value
+ """Set the environment variable "key" to value "value"
+
+ :param key str: the environment variable to set
+ :param value str: the value
+ """
+ self.output.write('set %s=%s\n' % (key, self.value_filter(value)))
+ self.environ.set(key, value)
- def command_value(self, key, command):
- self.output.write('%s > tmp.txt\n' % (command))
- self.output.write('set /p %s =< tmp.txt\n' % (key))
- def finish(self, required=True):
- return
+class ContextFileEnviron(FileEnviron):
+ """Class for a salome context configuration file.
+ """
+ def __init__(self, output, environ=None):
+ """Initialization
+
+ :param output file: the output file stream.
+ :param environ dict: a potential additional environment.
+ """
+ self._do_init(output, environ)
+ self.output.write(cfg_header)
+
+ def set(self, key, value):
+ """Set the environment variable "key" to value "value"
+
+ :param key str: the environment variable to set
+ :param value str: the value
+ """
+ self.output.write('%s="%s"\n' % (key, value))
+ self.environ.set(key, value)
+
+ def get(self, key):
+ """Get the value of the environment variable "key"
+
+ :param key str: the environment variable
+ """
+ return '%({0})s'.format(key)
+
+ def add_echo(self, text):
+ """Add a comment
+
+ :param text str: the comment to add
+ """
+ self.add_comment(text)
+
+ def add_warning(self, warning):
+ """Add a warning
+
+ :param text str: the warning to add
+ """
+ self.add_comment("WARNING %s" % warning)
+
+ def prepend_value(self, key, value, sep=os.pathsep):
+ """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
+ """
+ do_append=True
+ if self.environ.is_defined(key):
+ value_list = self.environ.get(key).split(sep)
+ #value cannot be expanded (unlike bash/bat case) - but it doesn't matter.
+ if value in value_list:
+ do_append=False # value is already in key path : we don't append it again
+
+ if do_append:
+ self.environ.append_value(key, value,sep)
+ self.output.write('ADD_TO_%s: %s\n' % (key, value))
-##
-# Base class for cfg environment file.
-class FileCfg:
+ def append_value(self, key, value, sep=os.pathsep):
+ """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
+ """
+ self.prepend_value(key, value)
+
+
+class LauncherFileEnviron(FileEnviron):
+ """\
+ Class to generate a launcher file script
+ (in python syntax) SalomeContext API
+ """
def __init__(self, output, environ=None):
+ """Initialization
+
+ :param output file: the output file stream.
+ :param environ dict: a potential additional environment.
+ """
self._do_init(output, environ)
+ self.python_version=self.environ.get("sat_python_version")
+ self.bin_kernel_root_dir=self.environ.get("sat_bin_kernel_install_dir")
- def _do_init(self, output, environ=None):
- self.output = output
- self.toclean = []
- if environ is not None:
- self.environ = environ
+ # four whitespaces for first indentation in a python script
+ self.indent=" "
+ self.prefix="context."
+ self.setVarEnv="setVariable"
+ self.begin=self.indent+self.prefix
+
+ # write the begining of launcher file.
+ # choose the template version corresponding to python version
+ # and substitute BIN_KERNEL_INSTALL_DIR (the path to salomeContext.py)
+ if self.python_version == 2:
+ launcher_header=launcher_header2
else:
- self.environ = os.environ
- if not self.environ.has_key("PATH"):
- self.environ["PATH"]=""
- if not self.environ.has_key("LD_LIBRARY_PATH"):
- self.environ["LD_LIBRARY_PATH"]=""
- if not self.environ.has_key("PYTHONPATH"):
- self.environ["PYTHONPATH"]=""
- if not self.environ.has_key("TCLLIBPATH"):
- self.environ["TCLLIBPATH"]=""
- if not self.environ.has_key("TKLIBPATH"):
- self.environ["TKLIBPATH"]=""
+ launcher_header=launcher_header3
+ # in case of Windows OS, Python scripts are not executable. PyExe ?
+ if src.architecture.is_windows():
+ launcher_header = launcher_header.replace("#! /usr/bin/env python3",'')
+ self.output.write(launcher_header\
+ .replace("BIN_KERNEL_INSTALL_DIR", self.bin_kernel_root_dir))
+ # for these path, we use specialired functions in salomeContext api
+ self.specialKeys={"PATH": "Path",
+ "LD_LIBRARY_PATH": "LdLibraryPath",
+ "PYTHONPATH": "PythonPath"}
- def add_line(self, number):
- self.output.write("\n" * number)
+ # we do not want to reinitialise PATH.
+ # for that we make sure PATH is in self.environ
+ # and therefore we will not use setVariable for PATH
+ if not self.environ.is_defined("PATH"):
+ self.environ.set("PATH","")
- def add_comment(self, comment):
- self.output.write("# %s\n" % comment)
def add_echo(self, text):
+ """Add a comment
+
+ :param text str: the comment to add
+ """
self.output.write('# %s"\n' % text)
def add_warning(self, warning):
+ """Add a warning
+
+ :param text str: the warning to add
+ """
self.output.write('# "WARNING %s"\n' % warning)
- def append_value(self, key, value, sep=":"):
- if self.is_defined(key) :
- self.add(key, value)
- else :
+ def append_value(self, key, value, sep=os.pathsep):
+ """append value to key using sep,
+ if value contains ":" or ";" then raise error
+
+ :param key str: the environment variable to prepend
+ :param value str: the value to prepend to key
+ :param sep str: the separator string
+ """
+ # check that value so no contain the system separator
+ separator=os.pathsep
+ msg="LauncherFileEnviron append key '%s' value '%s' contains forbidden character '%s'"
+ if separator in value:
+ raise Exception(msg % (key, value, separator))
+
+ if (self.init_path and (not self.environ.is_defined(key))):
+ # reinitialisation mode set to true (the default)
+ # for the first occurrence of key, we set it.
+ # therefore key will not be inherited from environment
self.set(key, value)
+ return
+
+ # in all other cases we use append (except if value is already the key
+ do_append=True
+ if self.environ.is_defined(key):
+ value_list = self.environ.get(key).split(sep)
+ # rem : value cannot be expanded (unlike bash/bat case) - but it doesn't matter.
+ if value in value_list:
+ do_append=False # value is already in key path : we don't append it again
+
+ if do_append:
+ self.environ.append_value(key, value,sep) # register value in self.environ
+ if key in self.specialKeys.keys():
+ #for these special keys we use the specific salomeContext function
+ self.output.write(self.begin+'addTo%s(r"%s")\n' %
+ (self.specialKeys[key], self.value_filter(value)))
+ else:
+ # else we use the general salomeContext addToVariable function
+ self.output.write(self.indent+'appendPath(r"%s", r"%s",separator="%s")\n'
+ % (key, self.value_filter(value), sep))
def append(self, key, value, sep=":"):
+ """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):
- self.append_value(key, sep.join(value), sep)
+ for v in value:
+ self.append_value(key, v, sep)
else:
self.append_value(key, value, sep)
- def prepend_value(self, key, value, sep=":"):
- if self.is_defined(key) :
- self.add(key, value)
- else :
+ def prepend_value(self, key, value, sep=os.pathsep):
+ """prepend value to key using sep,
+ if value contains ":" or ";" then raise error
+
+ :param key str: the environment variable to prepend
+ :param value str: the value to prepend to key
+ :param sep str: the separator string
+ """
+ # check that value so no contain the system separator
+ separator=os.pathsep
+ msg="LauncherFileEnviron append key '%s' value '%s' contains forbidden character '%s'"
+ if separator in value:
+ raise Exception(msg % (key, value, separator))
+
+ if (self.init_path and (not self.environ.is_defined(key))):
+ # reinitialisation mode set to true (the default)
+ # for the first occurrence of key, we set it.
+ # therefore key will not be inherited from environment
self.set(key, value)
+ return
+ # in all other cases we use append (except if value is already the key
+ do_append=True
+ if self.environ.is_defined(key):
+ value_list = self.environ.get(key).split(sep)
+ # rem : value cannot be expanded (unlike bash/bat case) - but it doesn't matter.
+ if value in value_list:
+ do_append=False # value is already in key path : we don't append it again
+
+ if do_append:
+ self.environ.append_value(key, value,sep) # register value in self.environ
+ if key in self.specialKeys.keys():
+ #for these special keys we use the specific salomeContext function
+ self.output.write(self.begin+'addTo%s(r"%s")\n' %
+ (self.specialKeys[key], self.value_filter(value)))
+ else:
+ # else we use the general salomeContext addToVariable function
+ self.output.write(self.begin+'addToVariable(r"%s", r"%s",separator="%s")\n'
+ % (key, self.value_filter(value), sep))
+
def prepend(self, key, value, sep=":"):
+ """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):
- self.prepend_value(key, sep.join(value), sep)
+ for v in value:
+ self.prepend_value(key, v, sep)
else:
self.prepend_value(key, value, sep)
- def is_defined(self, key):
- return self.environ.has_key(key)
def set(self, key, value):
- raise NotImplementedError("set is not implement for file .cfg!")
+ """Set the environment variable "key" to value "value"
+
+ :param key str: the environment variable to set
+ :param value str: the value
+ """
+ self.output.write(self.begin+self.setVarEnv+
+ '(r"%s", r"%s", overwrite=True)\n' %
+ (key, self.value_filter(value)))
+ self.environ.set(key,value)
+
- def get(self, key):
- return '${%s}' % key
+ def add_comment(self, comment):
+ # Special comment in case of the DISTENE licence
+ if comment=="DISTENE license":
+ self.output.write(self.indent+
+ "#"+
+ self.prefix+
+ self.setVarEnv+
+ '(r"%s", r"%s", overwrite=True)\n' %
+ ('DISTENE_LICENSE_FILE', 'Use global envvar: DLIM8VAR'))
+ self.output.write(self.indent+
+ "#"+
+ self.prefix+
+ self.setVarEnv+
+ '(r"%s", r"%s", overwrite=True)\n' %
+ ('DLIM8VAR', '<your licence>'))
+ return
+ if "setting environ for" in comment:
+ self.output.write(self.indent+"#[%s]\n" %
+ comment.split("setting environ for ")[1])
+ return
+
+ self.output.write(self.indent+"# %s\n" % comment)
+
+ def finish(self):
+ """\
+ Add a final instruction in the out file (in case of file generation)
+ In the particular launcher case, do nothing
+
+ :param required bool: Do nothing if required is False
+ """
+ if self.python_version == 2:
+ launcher_tail=launcher_tail_py2
+ else:
+ launcher_tail=launcher_tail_py3
+ self.output.write(launcher_tail)
+ return
+
+class ScreenEnviron(FileEnviron):
+ def __init__(self, output, environ=None):
+ self._do_init(output, environ)
+ self.defined = {}
+
+ def add_line(self, number):
+ pass
- def command_value(self, key, command):
- raise NotImplementedError("command_value is not implement for file .cfg!")
+ def add_comment(self, comment):
+ pass
- def finish(self, required=True):
- #for (key, sep) in self.toclean:
- # if sep != ' ':
- # self.output.write('clean %s "%s"\n' % (key, sep))
- #self.output.write("# finish\n")
+ def add_echo(self, text):
pass
+ def add_warning(self, warning):
+ pass
+
+ def write(self, command, name, value, sign="="):
+ import src
+ self.output.write(" %s%s %s %s %s\n" % \
+ (src.printcolors.printcLabel(command),
+ " " * (12 - len(command)),
+ src.printcolors.printcInfo(name), sign, value))
+
+ def is_defined(self, name):
+ return name in self.defined
+
+ def get(self, name):
+ return "${%s}" % name
+
+ def set(self, name, value):
+ self.write("set", name, value)
+ self.defined[name] = value
+
+ def prepend(self, name, value, sep=":"):
+ if isinstance(value, list):
+ value = sep.join(value)
+ value = value + sep + self.get(name)
+ self.write("prepend", name, value)
+
+ def append(self, name, value, sep=":"):
+ if isinstance(value, list):
+ value = sep.join(value)
+ value = self.get(name) + sep + value
+ self.write("append", name, value)
+
+ def run_env_script(self, module, script):
+ self.write("load", script, "", sign="")
-def specialPathSeparator(name):
- """TCLLIBPATH, TKLIBPATH, PV_PLUGIN_PATH environments variables needs some exotic path separator"""
- specialBlanksKeys=["TCLLIBPATH", "TKLIBPATH"]
- specialSemicolonKeys=["PV_PLUGIN_PATH"]
- res=os.pathsep
- if name in specialBlanksKeys: res=" "
- if name in specialSemicolonKeys: res=";"
- return res
-##
#
-##
-# Class for generate a cfg file script (in python syntax) SalomeContext API.
-class CfgForPyFileEnviron(FileCfg):
- def __init__(self, output, environ=None, config=None):
- self.config=config
- self._do_init(output, environ)
+# Headers
+#
+bat_header="""\
+@echo off
- self.indent=" " # four whitespaces for first indentation in a python script
- self.prefix="context."
- self.setVarEnv="setVariable"
-
- self.begin=self.indent+self.prefix
- self.output.write((cfgForPy_header) % config['VARS']['product'])
- self.specialKeys={"PATH": "Path", "LD_LIBRARY_PATH": "LdLibraryPath", "PYTHONPATH": "PythonPath"}
+rem The following variables are used only in case of a sat package
+set out_dir_Path=%~dp0
+"""
- def changeToCfg(self, value):
- res=value
- return res
+tcl_header="""\
+#%Module -*- tcl -*-
+#
+# <module_name> module for use with 'environment-modules' package
+#
+"""
- def set(self, key, value):
- self.output.write(self.begin+self.setVarEnv+'(r"%s", r"%s", overwrite=True)\n' % (key, self.changeToCfg(value)))
- self.environ[key] = value
+bash_header="""\
+#!/bin/bash
+##########################################################################
+#
+# This line is used only in case of a sat package
+export out_dir_Path=$(cd $(dirname ${BASH_SOURCE[0]});pwd)
- def add(self, key, value):
- if key in self.specialKeys.keys():
- self.output.write(self.begin+'addTo%s(r"%s")\n' % (self.specialKeys[key], self.changeToCfg(value)))
- self.environ[key]+=":"+value
- return
- sep=specialPathSeparator(key)
- self.output.write(self.indent+'#temporary solution!!! have to be defined in API a ?dangerous? addToSpecial(r"%s", r"%s")\n' % (key, value))
- #pathsep not precised because do not know future os launch?
- self.output.write(self.begin+'addToSpecial(r"%s", r"%s")\n' % (key, self.changeToCfg(value)))
- self.environ[key]+=sep+value #here yes we know os for current execution
-
- def command_value(self, key, command):
- #self.output.write('%s=`%s`\n' % (key, command))
- self.output.write(self.indent+'#`%s`\n' % command)
-
- import shlex, subprocess
- args = shlex.split(command)
- res=subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- out, __ = res.communicate()
- self.output.write(self.begin+self.setVarEnv+'(r"%s", r"%s", overwrite=True)\n' % (key, out))
- pass
+###########################################################################
+"""
+
+cfg_header="""\
+[SALOME Configuration]
+"""
+
+launcher_header2="""\
+#! /usr/bin/env python
+
+################################################################
+# WARNING: this file is automatically generated by SalomeTools #
+# WARNING: and so could be overwritten at any time. #
+################################################################
+
+import os
+import sys
+import subprocess
+
+
+# Add the pwdPath to able to run the launcher after unpacking a package
+# Used only in case of a salomeTools package
+out_dir_Path=os.path.dirname(os.path.realpath(__file__))
+
+# Preliminary work to initialize path to SALOME Python modules
+def __initialize():
+
+ sys.path[:0] = [ r'BIN_KERNEL_INSTALL_DIR' ] # to get salomeContext
+
+ # define folder to store omniorb config (initially in virtual application folder)
+ try:
+ from salomeContextUtils import setOmniOrbUserPath
+ setOmniOrbUserPath()
+ except Exception as e:
+ print(e)
+ sys.exit(1)
+# End of preliminary work
+
+# salome doc only works for virtual applications. Therefore we overwrite it with this function
+def _showDoc(modules):
+ for module in modules:
+ modulePath = os.getenv(module+"_ROOT_DIR")
+ if modulePath != None:
+ baseDir = os.path.join(modulePath, "share", "doc", "salome")
+ docfile = os.path.join(baseDir, "gui", module.upper(), "index.html")
+ if not os.path.isfile(docfile):
+ docfile = os.path.join(baseDir, "tui", module.upper(), "index.html")
+ if not os.path.isfile(docfile):
+ docfile = os.path.join(baseDir, "dev", module.upper(), "index.html")
+ if os.path.isfile(docfile):
+ out, err = subprocess.Popen(["xdg-open", docfile]).communicate()
+ else:
+ print ("Online documentation is not accessible for module:", module)
+ else:
+ print (module+"_ROOT_DIR not found!")
+
+def main(args):
+ # Identify application path then locate configuration files
+ __initialize()
+
+ if args == ['--help']:
+ from salomeContext import usage
+ usage()
+ sys.exit(0)
+
+
+ # Create a SalomeContext which parses configFileNames to initialize environment
+ try:
+ from salomeContext import SalomeContext, SalomeContextException
+ context = SalomeContext(None)
+
+ # Here set specific variables, if needed
+ # context.addToPath('mypath')
+ # context.addToLdLibraryPath('myldlibrarypath')
+ # context.addToPythonPath('mypythonpath')
+ # context.setVariable('myvarname', 'value')
+
+ # Logger level error
+ context.getLogger().setLevel(40)
+"""
+
+launcher_header3="""\
+#! /usr/bin/env python3
+
+################################################################
+# WARNING: this file is automatically generated by SalomeTools #
+# WARNING: and so could be overwritten at any time. #
+################################################################
+
+import os
+import sys
+import subprocess
+
+
+# Add the pwdPath to able to run the launcher after unpacking a package
+# Used only in case of a salomeTools package
+out_dir_Path=os.path.dirname(os.path.realpath(__file__))
+
+# Preliminary work to initialize path to SALOME Python modules
+def __initialize():
+
+ sys.path[:0] = [ r'BIN_KERNEL_INSTALL_DIR' ]
+
+ # define folder to store omniorb config (initially in virtual application folder)
+ try:
+ from salomeContextUtils import setOmniOrbUserPath
+ setOmniOrbUserPath()
+ except Exception as e:
+ print(e)
+ sys.exit(1)
+# End of preliminary work
+
+# salome doc only works for virtual applications. Therefore we overwrite it with this function
+def _showDoc(modules):
+ for module in modules:
+ modulePath = os.getenv(module+"_ROOT_DIR")
+ if modulePath != None:
+ baseDir = os.path.join(modulePath, "share", "doc", "salome")
+ docfile = os.path.join(baseDir, "gui", module.upper(), "index.html")
+ if not os.path.isfile(docfile):
+ docfile = os.path.join(baseDir, "tui", module.upper(), "index.html")
+ if not os.path.isfile(docfile):
+ docfile = os.path.join(baseDir, "dev", module.upper(), "index.html")
+ if os.path.isfile(docfile):
+ out, err = subprocess.Popen(["xdg-open", docfile]).communicate()
+ else:
+ print("Online documentation is not accessible for module:", module)
+ else:
+ print(module+"_ROOT_DIR not found!")
+
+def main(args):
+ # Identify application path then locate configuration files
+ __initialize()
+
+ if args == ['--help']:
+ from salomeContext import usage
+ usage()
+ sys.exit(0)
+
+ #from salomeContextUtils import getConfigFileNames
+ #configFileNames, args, unexisting = getConfigFileNames( args, checkExistence=True )
+ #if len(unexisting) > 0:
+ # print("ERROR: unexisting configuration file(s): " + ', '.join(unexisting))
+ # sys.exit(1)
+
+ # Create a SalomeContext which parses configFileNames to initialize environment
+ try:
+ from salomeContext import SalomeContext, SalomeContextException
+ context = SalomeContext(None)
+
+ # Here set specific variables, if needed
+ # context.addToPath('mypath')
+ # context.addToLdLibraryPath('myldlibrarypath')
+ # context.addToPythonPath('mypythonpath')
+ # context.setVariable('myvarname', 'value')
+
+ # Logger level error
+ context.getLogger().setLevel(40)
+"""
+
+launcher_tail_py2="""\
+ if len(args) >1 and args[0]=='doc':
+ _showDoc(args[1:])
+ return
+
+ # Start SALOME, parsing command line arguments
+ out, err, status = context.runSalome(args)
+ sys.exit(status)
+
+ except SalomeContextException, e:
+ import logging
+ logging.getLogger("salome").error(e)
+ sys.exit(1)
+#
+# salomeContext only prepend variables, we use our own appendPath when required
+def appendPath(name, value, separator=os.pathsep):
+ if value == '':
+ return
+
+ value = os.path.expandvars(value) # expand environment variables
+ env = os.getenv(name, None)
+ if env is None:
+ os.environ[name] = value
+ else:
+ os.environ[name] = env + separator + value
+
+
+if __name__ == "__main__":
+ args = sys.argv[1:]
+ main(args)
+#
+"""
+
+launcher_tail_py3="""\
+ if len(args) >1 and args[0]=='doc':
+ _showDoc(args[1:])
+ return
+
+ # Start SALOME, parsing command line arguments
+ out, err, status = context.runSalome(args)
+ sys.exit(status)
+
+ except SalomeContextException as e:
+ import logging
+ logging.getLogger("salome").error(e)
+ sys.exit(1)
+
+# salomeContext only prepend variables, we use our own appendPath when required
+def appendPath(name, value, separator=os.pathsep):
+ if value == '':
+ return
+
+ value = os.path.expandvars(value) # expand environment variables
+ env = os.getenv(name, None)
+ if env is None:
+ os.environ[name] = value
+ else:
+ os.environ[name] = env + separator + value
+
+
+if __name__ == "__main__":
+ args = sys.argv[1:]
+ main(args)
+#
+"""
+
- def add_comment(self, comment):
- if comment=="DISTENE license":
- self.output.write(self.indent+"#"+self.prefix+self.setVarEnv+'(r"%s", r"%s", overwrite=True)\n' % ('DISTENE_LICENSE_FILE', self.changeToCfg('Use global envvar: DLIM8VAR')))
- self.output.write(self.indent+"#"+self.prefix+self.setVarEnv+'(r"%s", r"%s", overwrite=True)\n' % ('DISTENE_LICENCE_FILE_FOR_MGCLEANER', self.changeToCfg('<path to your license>')))
- self.output.write(self.indent+"#"+self.prefix+self.setVarEnv+'(r"%s", r"%s", overwrite=True)\n' % ('DISTENE_LICENCE_FILE_FOR_YAMS', self.changeToCfg('<path to your license>')))
- return
- if "setting environ for" in comment:
- self.output.write(self.indent+"#[%s]\n" % comment.split("setting environ for ")[1])
- return
- if "PRODUCT environment" in comment:
- self.output.write(self.indent+"#[SALOME Configuration]\n\n")
- self.output.write(self.indent+"# PRODUCT environment\n")
- tmp=","
- for i in self.config['PRODUCT']['modules']: tmp+=i+','
- self.output.write(self.indent+"#only for information:\n")
- self.output.write(self.indent+'#'+self.setVarEnv+'("SALOME_MODULES", r"%s", overwrite=True)\n\n' % tmp[1:-1])
- try:
- #tmp1=self.config['APPLI']['module_appli']
- #tmp2=self.config.TOOLS.common.module_info[tmp1].install_dir
- tmp3=self.config.APPLI.module_appli_install_dir
- relpath=os.path.relpath("/",os.getenv("HOME"))
- tmp=relpath[0:-1]+tmp3
- self.output.write(self.indent+"#only for information: ${APPLI} is preset and have to be relative to $HOME\n")
- self.output.write(self.indent+'#'+self.setVarEnv+'("APPLI", r"%s", overwrite=True)\n\n' % tmp)
- except:
- self.output.write(self.indent+"#only for information: ${APPLI} is by default\n")
- return
- self.output.write(self.indent+"# %s\n" % comment)
-
\ No newline at end of file