environ=src.environment.Environ({})
if shell == "bash":
return BashFileEnviron(output, environ)
+ if shell == "tcl":
+ return TclFileEnviron(output, environ)
if shell == "bat":
return BatFileEnviron(output, environ)
if shell == "cfgForPy":
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
- #print "\nCNC append_value value is already set!! key=%s, val=%s value_list=%s\n" % (key,self.environ._expandvars(value), value_list)
if do_append:
self.environ.append_value(key, value,sep)
exp_val=self.environ._expandvars(value)
if exp_val in value_list:
do_not_prepend=True
- #print "\nCNC prepend_value value is already set!! key=%s, val=%s value_list=%s\n" % (key,exp_val, value_list)
if not do_not_prepend:
self.environ.prepend_value(key, value,sep)
self.set(key, value + sep + self.get(key))
:param key str: the environment variable
"""
- return '${%s}' % key
+ 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"
def value_filter(self, value):
res=value
- # on windows platform, replace / by \
- if src.architecture.is_windows():
- res = value.replace("/","\\")
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 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 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 BashFileEnviron(FileEnviron):
"""\
Class for bash shell.
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")
- self.app_root_dir=self.environ.get("sat_app_root_dir")
# four whitespaces for first indentation in a python script
self.indent=" "
launcher_header=launcher_header2
else:
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))
"""
self.output.write('# "WARNING %s"\n' % warning)
- def append_value(self, key, value, sep=":"):
+ 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 append
- :param value str: the value to append to key
+ :param key str: the environment variable to prepend
+ :param value str: the value to prepend to key
:param sep str: the separator string
"""
- # append is not defined in context api
- self.prepend_value(key, value)
+ # 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
def add_comment(self, comment):
- # Special comment in case of the distène licence
+ # Special comment in case of the DISTENE licence
if comment=="DISTENE license":
self.output.write(self.indent+
"#"+
set out_dir_Path=%~dp0
"""
+tcl_header="""\
+#%Module -*- tcl -*-
+#
+# <module_name> module for use with 'environment-modules' package
+#
+"""
bash_header="""\
#!/bin/bash
+if [ "$BASH" = "" ]
+then
+ # check that the user is not using another shell
+ echo
+ echo "Warning! SALOME environment not initialized"
+ echo "You must run this script in a bash shell."
+ echo "As you are using another shell. Please first run: bash"
+ echo
+fi
##########################################################################
#
# This line is used only in case of a sat package
import os
import sys
import subprocess
-
+import os.path
# Add the pwdPath to able to run the launcher after unpacking a package
# Used only in case of a salomeTools package
# Preliminary work to initialize path to SALOME Python modules
def __initialize():
- sys.path[:0] = [ 'BIN_KERNEL_INSTALL_DIR' ] # to get salomeContext
+ sys.path[:0] = [ r'BIN_KERNEL_INSTALL_DIR' ] # to get salomeContext
# define folder to store omniorb config (initially in virtual application folder)
try:
if os.path.isfile(docfile):
out, err = subprocess.Popen(["xdg-open", docfile]).communicate()
else:
- print "Online documentation is not accessible for module:", module
+ print ("Online documentation is not accessible for module:", module)
else:
- print module+"_ROOT_DIR not found!"
+ print (module+"_ROOT_DIR not found!")
def main(args):
# Identify application path then locate configuration files
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:
import os
import sys
import subprocess
-
+import os.path
# Add the pwdPath to able to run the launcher after unpacking a package
# Used only in case of a salomeTools package
# Preliminary work to initialize path to SALOME Python modules
def __initialize():
- sys.path[:0] = [ 'BIN_KERNEL_INSTALL_DIR' ]
+ sys.path[:0] = [ r'BIN_KERNEL_INSTALL_DIR' ]
# define folder to store omniorb config (initially in virtual application folder)
try:
"""
launcher_tail_py2="""\
+ #[hook to integrate in launcher additionnal user modules]
+
+ # Load all files extra.env.d/*.py and call the module's init routine]
+
+ extradir=out_dir_Path + r"/extra.env.d"
+
+ if os.path.exists(extradir):
+ import imp
+ sys.path.insert(0, os.path.join(os.getcwd(), extradir))
+ for filename in sorted(
+ filter(lambda x: os.path.isfile(os.path.join(extradir, x)),
+ os.listdir(extradir))):
+
+ if filename.endswith(".py"):
+ f = os.path.join(extradir, filename)
+ module_name = os.path.splitext(os.path.basename(f))[0]
+ fp, path, desc = imp.find_module(module_name)
+ module = imp.load_module(module_name, fp, path, desc)
+ module.init(context, out_dir_Path)
+
+ #[manage salome doc command]
if len(args) >1 and args[0]=='doc':
_showDoc(args[1:])
return
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:]
"""
launcher_tail_py3="""\
+ #[hook to integrate in launcher additionnal user modules]
+
+ # Load all files extra.env.d/*.py and call the module's init routine]
+
+ extradir=out_dir_Path + r"/extra.env.d"
+
+ if os.path.exists(extradir):
+ import imp
+ sys.path.insert(0, os.path.join(os.getcwd(), extradir))
+ for filename in sorted(
+ filter(lambda x: os.path.isfile(os.path.join(extradir, x)),
+ os.listdir(extradir))):
+
+ if filename.endswith(".py"):
+ f = os.path.join(extradir, filename)
+ module_name = os.path.splitext(os.path.basename(f))[0]
+ fp, path, desc = imp.find_module(module_name)
+ module = imp.load_module(module_name, fp, path, desc)
+ module.init(context, out_dir_Path)
+
+ #[manage salome doc command]
if len(args) >1 and args[0]=='doc':
_showDoc(args[1:])
return
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:]