# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
import os
+import pprint as PP
+import src.debug as DBG
-batch_header="""@echo off
+bat_header="""\
+@echo off
rem The following variables are used only in case of a sat package
set out_dir_Path=%~dp0
"""
-bash_header="""#!/bin/bash
+bash_header="""\
+#!/bin/bash
##########################################################################
#
#### cleandup ###
}
# The 3 following variables are used only in case of a sat package
-export out_dir_Path=`dirname "${BASH_SOURCE[0]}"`
+export out_dir_Path=$(cd $(dirname ${BASH_SOURCE[0]});pwd)
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
###########################################################################
"""
+cfg_header="""\
+[SALOME Configuration]
+"""
-cfgForPy_header='''# a generated SALOME Configuration file in python syntax from "sat application %s"
-'''
+Launcher_header="""\
+# a generated SALOME Configuration file using python syntax
+"""
-##
-# 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 shell == "bash":
return BashFileEnviron(output, environ)
- if shell == "batch":
- return BatchFileEnviron(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: a potential additional environment.
+ """
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 = []
if environ is not None:
+ #if str(type(environ)) == "<type 'instance'>":
+ if id(environ) == id(os.environ):
+ DBG.tofix("set %s environ as python os.environ, are you sure it is safe ?" % self.__class__.__name__, True)
self.environ = environ
else:
- self.environ = os.environ
+ DBG.tofix("set %s environ as COPY of python os.environ, are you sure it is safe ?" % self.__class__.__name__, True)
+ self.environ = dict(os.environ) #make a copy cvw 180320
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):
+ """\
+ 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.set(key, self.get(key) + sep + value)
if (key, sep) not in self.toclean:
self.toclean.append((key, sep))
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)
else:
self.append_value(key, value, 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
+ """
self.set(key, value + sep + self.get(key))
if (key, sep) not in self.toclean:
self.toclean.append((key, sep))
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)
else:
self.prepend_value(key, value, sep)
def is_defined(self, key):
+ """\
+ Check if the key exists in the environment
+
+ :param key str: the environment variable to check
+ """
return (key in self.environ)
-
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):
+ """\
+ Get the value of the environment variable "key"
+
+ :param key str: the environment variable
+ """
return '${%s}' % key
def command_value(self, key, command):
- raise NotImplementedError("command_value is not implement for this shell!")
+ """\
+ Get the value given by the system command "command"
+ and put it in the environment variable key.
+ Has to be overwritten in the derived classes
+ This can be seen as a virtual method
+
+ :param key str: the environment variable
+ :param command str: the command to execute
+ """
+ raise NotImplementedError("command_value is not implement "
+ "for this shell!")
def finish(self, required=True):
+ """Add a final instruction in the out file (in case of file generation)
+
+ :param required bool: Do nothing if required is False
+ """
for (key, sep) in self.toclean:
if sep != ' ':
self.output.write('clean %s "%s"\n' % (key, sep))
-##
-# 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):
+ """\
+ Get the value given by the system command "command"
+ and put it in the environment variable key.
+ Has to be overwritten in the derived classes
+ This can be seen as a virtual method
+
+ :param key str: the environment variable
+ :param command str: the command to execute
+ """
self.output.write('export %s=$(%s)\n' % (key, command))
def finish(self, required=True):
+ """Add a final instruction in the out file (in case of file generation)
+
+ :param required bool: Do nothing if required is False
+ """
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):
+ """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, value))
self.environ[key] = value
def command_value(self, key, command):
+ """\
+ Get the value given by the system command "command"
+ and put it in the environment variable key.
+ Has to be overwritten in the derived classes
+ This can be seen as a virtual method
+
+ :param key str: the environment variable
+ :param command str: the command to execute
+ """
self.output.write('%s > tmp.txt\n' % (command))
self.output.write('set /p %s =< tmp.txt\n' % (key))
def finish(self, required=True):
+ """\
+ Add a final instruction in the out file (in case of file generation)
+ In the particular windows case, do nothing
+
+ :param required bool: Do nothing if required is False
+ """
return
-##
-# Base class for cfg environment file.
-class FileCfg:
+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 _do_init(self, output, environ=None):
+ 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[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 command_value(self, key, command):
+ """\
+ Get the value given by the system command "command"
+ and put it in the environment variable key.
+ Has to be overwritten in the derived classes
+ This can be seen as a virtual method
+
+ :param key str: the environment variable
+ :param command str: the command to execute
+ """
+ raise NotImplementedError("command_value is not implement "
+ "for salome context files!")
+
+ 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
+ """
+ self.output.write('ADD_TO_%s: %s\n' % (key, value))
+
+ 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)
+
+ def finish(self, required=True):
+ """Add a final instruction in the out file (in case of file generation)
+
+ :param required bool: Do nothing if required is False
+ """
+ return
+
+def special_path_separator(name):
+ """\
+ TCLLIBPATH, TKLIBPATH, PV_PLUGIN_PATH environments variables need
+ some exotic path separator.
+ This function gives the separator regarding the name of the variable
+ to append or prepend.
+
+ :param name str: The name of the variable to find the separator
+ """
+ special_blanks_keys=["TCLLIBPATH", "TKLIBPATH"]
+ special_semicolon_keys=["PV_PLUGIN_PATH"]
+ res=os.pathsep
+ if name in special_blanks_keys: res=" "
+ if name in special_semicolon_keys: res=";"
+ return res
+
+class LauncherFileEnviron:
+ """\
+ 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.output = output
self.toclean = []
if environ is not None:
self.environ = environ
else:
self.environ = os.environ
- if not self.environ.has_key("PATH"):
+ # Initialize some variables
+ if not "PATH" in self.environ.keys():
self.environ["PATH"]=""
- if not self.environ.has_key("LD_LIBRARY_PATH"):
+ if not "LD_LIBRARY_PATH" in self.environ.keys():
self.environ["LD_LIBRARY_PATH"]=""
- if not self.environ.has_key("PYTHONPATH"):
+ if not "PYTHONPATH" in self.environ.keys():
self.environ["PYTHONPATH"]=""
- if not self.environ.has_key("TCLLIBPATH"):
+ if not "TCLLIBPATH" in self.environ.keys():
self.environ["TCLLIBPATH"]=""
- if not self.environ.has_key("TKLIBPATH"):
+ if not "TKLIBPATH" in self.environ.keys():
self.environ["TKLIBPATH"]=""
+ # four whitespaces for first indentation in a python script
+ self.indent=" "
+ self.prefix="context."
+ self.setVarEnv="setVariable"
+
+ self.begin=self.indent+self.prefix
+ self.output.write(Launcher_header)
+ self.specialKeys={"PATH": "Path",
+ "LD_LIBRARY_PATH": "LdLibraryPath",
+ "PYTHONPATH": "PythonPath"}
+
+ def change_to_launcher(self, value):
+ res=value
+ return res
def add_line(self, number):
+ """Add some empty lines in the launcher file
+
+ :param number int: the number of lines to add
+ """
self.output.write("\n" * number)
- 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=":"):
+ """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 self.is_defined(key) :
self.add(key, value)
else :
self.set(key, value)
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)
else:
self.append_value(key, value, sep)
def prepend_value(self, key, value, 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 self.is_defined(key) :
self.add(key, value)
else :
self.set(key, value)
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)
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!")
+ """Check if the key exists in the environment
+
+ :param key str: the environment variable to check
+ """
+ return key in self.environ.keys()
def get(self, key):
- return '${%s}' % key
-
- def command_value(self, key, command):
- raise NotImplementedError("command_value is not implement for file .cfg!")
-
- 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")
- pass
-
-
-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)
-
- self.indent=" " # four whitespaces for first indentation in a python script
- self.prefix="context."
- self.setVarEnv="setVariable"
+ """Get the value of the environment variable "key"
- self.begin=self.indent+self.prefix
- self.output.write((cfgForPy_header) % config['VARS']['product'])
- self.specialKeys={"PATH": "Path", "LD_LIBRARY_PATH": "LdLibraryPath", "PYTHONPATH": "PythonPath"}
-
- def changeToCfg(self, value):
- res=value
- return res
+ :param key str: the environment variable
+ """
+ return '${%s}' % key
def set(self, key, value):
- self.output.write(self.begin+self.setVarEnv+'(r"%s", r"%s", overwrite=True)\n' % (key, self.changeToCfg(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(self.begin+self.setVarEnv+
+ '(r"%s", r"%s", overwrite=True)\n' %
+ (key, self.change_to_launcher(value)))
self.environ[key] = value
-
- def add(self, key, value):
+
+ def add(self, key, value):
+ """prepend value to key using sep
+
+ :param key str: the environment variable to prepend
+ :param value str: the value to prepend to key
+ """
if key in self.specialKeys.keys():
- self.output.write(self.begin+'addTo%s(r"%s")\n' % (self.specialKeys[key], self.changeToCfg(value)))
+ self.output.write(self.begin+'addTo%s(r"%s")\n' %
+ (self.specialKeys[key],
+ self.change_to_launcher(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))
+ sep=special_path_separator(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.output.write(self.begin+'addToSpecial(r"%s", r"%s")\n'
+ % (key, self.change_to_launcher(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))
+ """\
+ 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
+ """
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
+ self.output.write(self.begin+
+ self.setVarEnv+
+ '(r"%s", r"%s", overwrite=True)\n' % (key, out))
def add_comment(self, comment):
+ # Special comment in case of the distène licence
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>')))
+ self.output.write(self.indent+
+ "#"+
+ self.prefix+
+ self.setVarEnv+
+ '(r"%s", r"%s", overwrite=True)\n' %
+ ('DISTENE_LICENSE_FILE',
+ self.change_to_launcher(
+ 'Use global envvar: DLIM8VAR')))
+ self.output.write(self.indent+
+ "#"+
+ self.prefix+
+ self.setVarEnv+
+ '(r"%s", r"%s", overwrite=True)\n' %
+ ('DLIM8VAR',
+ self.change_to_launcher(
+ '<your licence>')))
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")
+ self.output.write(self.indent+"#[%s]\n" %
+ comment.split("setting environ for ")[1])
return
+
self.output.write(self.indent+"# %s\n" % comment)
-
\ No newline at end of file
+
+ def finish(self, required=True):
+ """\
+ 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
+ """
+ return
+
+class ScreenEnviron(FileEnviron):
+ def __init__(self, output, environ=None):
+ self._do_init(output, environ)
+ self.defined = {}
+
+ def add_line(self, number):
+ pass
+
+ def add_comment(self, comment):
+ pass
+
+ 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 self.defined.has_key(name)
+
+ 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 command_value(self, key, command):
+ pass
+
+ def run_env_script(self, module, script):
+ self.write("load", script, "", sign="")
+
+# The SALOME launcher template
+withProfile = """\
+#! /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] = [ 'BIN_KERNEL_INSTALL_DIR' ]
+ os.environ['ABSOLUTE_APPLI_PATH'] = 'KERNEL_INSTALL_DIR'
+
+ # define folder to store omniorb config (initially in virtual application folder)
+ try:
+ from salomeContextUtils import setOmniOrbUserPath
+ setOmniOrbUserPath()
+ except Exception, 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
+ SalomeContext.addToSpecial=addToSpecial
+ 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)
+
+ context.setVariable(r"PRODUCT_ROOT_DIR", out_dir_Path, overwrite=True)
+ # here your local standalone environment
+
+ 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)
+#
+def addToSpecial(self, name, value, pathSep=None):
+ # add special dangerous cases: TCLLIBPATH PV_PLUGIN_PATH etc...
+ # http://computer-programming-forum.com/57-tcl/1dfddc136afccb94.htm
+ # TCLLIBPATH: Tcl treats the contents of that variable as a list. Be happy, for you can now use drive letters on windows.
+ if value == '':
+ return
+
+ specialBlanksKeys=["TCLLIBPATH", "TKLIBPATH"]
+ specialSemicolonKeys=["PV_PLUGIN_PATH"]
+ res=os.pathsep
+ if name in specialBlanksKeys: res=" "
+ if name in specialSemicolonKeys: res=";"
+
+ if pathSep==None:
+ sep=res
+ else:
+ sep=pathSep
+ value = os.path.expandvars(value) # expand environment variables
+ self.getLogger().debug("Add to %s: %s", name, value)
+ env = os.getenv(name, None)
+ if env is None:
+ os.environ[name] = value
+ else:
+ os.environ[name] = value + sep + env #explicitely or not special path separator ?whitespace, semicolon?
+
+if __name__ == "__main__":
+ args = sys.argv[1:]
+ main(args)
+#
+"""
+
+withProfile3 = """\
+#! /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] = [ 'BIN_KERNEL_INSTALL_DIR' ]
+ os.environ['ABSOLUTE_APPLI_PATH'] = '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
+ SalomeContext.addToSpecial=addToSpecial
+ 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)
+
+ context.setVariable(r"PRODUCT_ROOT_DIR", out_dir_Path, overwrite=True)
+ # here your local standalone environment
+
+ 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)
+#
+def addToSpecial(self, name, value, pathSep=None):
+ # add special dangerous cases: TCLLIBPATH PV_PLUGIN_PATH etc...
+ # http://computer-programming-forum.com/57-tcl/1dfddc136afccb94.htm
+ # TCLLIBPATH: Tcl treats the contents of that variable as a list. Be happy, for you can now use drive letters on windows.
+ if value == '':
+ return
+
+ specialBlanksKeys=["TCLLIBPATH", "TKLIBPATH"]
+ specialSemicolonKeys=["PV_PLUGIN_PATH"]
+ res=os.pathsep
+ if name in specialBlanksKeys: res=" "
+ if name in specialSemicolonKeys: res=";"
+
+ if pathSep==None:
+ sep=res
+ else:
+ sep=pathSep
+ value = os.path.expandvars(value) # expand environment variables
+ self.getLogger().debug("Add to %s: %s", name, value)
+ env = os.getenv(name, None)
+ if env is None:
+ os.environ[name] = value
+ else:
+ os.environ[name] = value + sep + env #explicitely or not special path separator ?whitespace, semicolon?
+
+if __name__ == "__main__":
+ args = sys.argv[1:]
+ main(args)
+#
+"""
+
