1 #! /usr/bin/env python3
2 # Copyright (C) 2013-2021 CEA/DEN, EDF R&D, OPEN CASCADE
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License, or (at your option) any later version.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
26 from parseConfigFile import parseConfigFile
34 from salomeContextUtils import SalomeContextException
38 Usage: salome [command] [options] [--config=<file,folder,...>]
42 start Start a new SALOME instance. Start a single SALOME_Session_Server_No_Server
43 process with environment relevant to the application and hosting all servants in it.
44 context Initialize SALOME context. Current environment is extended.
45 shell Initialize SALOME context, attached to the last created SALOME
46 instance if any, and executes scripts passed as command arguments.
47 User works in a Shell terminal. SALOME environment is set but
48 application is not started.
49 test Run SALOME tests.
50 info Display some information about SALOME.
51 doc <module(s)> Show online module documentation (if available).
52 Module names must be separated by blank characters.
53 help Show this message.
54 remote run command in SALOME environment from remote call, ssh or rsh.
55 withsession Start a new SWS SALOME instance with multiple servers hosting all servants.
56 connect In SWS context, Connect a Python console to the active SALOME instance.
57 kill <port(s)> In SWS context, Terminate SALOME instances running on given ports for current user.
58 Port numbers must be separated by blank characters.
59 killall Terminate *all* SALOME running SWS instances for current user.
60 Do not start a new one.
62 If no command is given, default is start.
66 Use salome <command> --help to show help on command. Available for the
67 following commands: start, shell, connect, test, info.
69 --config=<file,folder,...>
70 ==========================
71 Initialize SALOME context from a list of context files and/or a list
72 of folders containing context files. The list is comma-separated, without
80 The SalomeContext class in an API to configure SALOME context then
81 start SALOME using a single python command.
86 Initialize context from a list of configuration files
87 identified by their names.
88 These files should be in appropriate .cfg format.
90 def __init__(self, configFileNames=0):
91 self.getLogger().setLevel(logging.INFO)
92 #it could be None explicitly (if user use multiples setVariable...for standalone)
93 if configFileNames is None:
95 configFileNames = configFileNames or []
96 if len(configFileNames) == 0:
97 raise SalomeContextException("No configuration files given")
99 reserved=['PATH', 'DYLD_FALLBACK_LIBRARY_PATH', 'DYLD_LIBRARY_PATH', 'LD_LIBRARY_PATH', 'PYTHONPATH', 'MANPATH', 'PV_PLUGIN_PATH', 'INCLUDE', 'LIBPATH', 'SALOME_PLUGINS_PATH', 'LIBRARY_PATH', 'QT_PLUGIN_PATH']
100 for filename in configFileNames:
101 basename, extension = os.path.splitext(filename)
102 if extension == ".cfg":
103 self.__setContextFromConfigFile(filename, reserved)
105 self.getLogger().error("Unrecognized extension for configuration file: %s", filename)
108 def __loadEnvModules(self, env_modules):
109 modulecmd = os.getenv('LMOD_CMD')
111 raise SalomeContextException("Module environment not present")
114 out, err = subprocess.Popen([modulecmd, "python", "load"] + env_modules, stdout=subprocess.PIPE).communicate()
115 exec(out) # define specific environment variables
117 raise SalomeContextException("Failed to load env modules: %s ..." % ' '.join(env_modules))
121 def runSalome(self, args):
123 # Run this module as a script, in order to use appropriate Python interpreter
124 # according to current path (initialized from context files).
125 env_modules_option = "--with-env-modules="
126 env_modules_l = [x for x in args if x.startswith(env_modules_option)]
128 env_modules = env_modules_l[-1][len(env_modules_option):].split(',')
129 self.__loadEnvModules(env_modules)
130 args = [x for x in args if not x.startswith(env_modules_option)]
132 env_modules = os.getenv("SALOME_ENV_MODULES", None)
134 self.__loadEnvModules(env_modules.split(','))
136 absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH','')
137 env_copy = os.environ.copy()
138 selfBytes= pickle.dumps(self, protocol=0)
139 argsBytes= pickle.dumps(args, protocol=0)
140 proc = subprocess.Popen(['python3', os.path.join(absoluteAppliPath,"bin","salome","salomeContext.py"), selfBytes.decode('latin1'), argsBytes.decode('latin1')], shell=False, close_fds=True, env=env_copy)
141 out, err = proc.communicate()
142 return out, err, proc.returncode
145 """Append value to PATH environment variable"""
146 def addToPath(self, value):
147 self.addToVariable('PATH', value)
150 """Append value to LD_LIBRARY_PATH environment variable"""
151 def addToLdLibraryPath(self, value):
152 if sys.platform == 'win32':
153 self.addToVariable('PATH', value)
154 elif sys.platform == 'darwin':
155 if "LAPACK" in value:
156 self.addToVariable('DYLD_FALLBACK_LIBRARY_PATH', value)
158 self.addToVariable('DYLD_LIBRARY_PATH', value)
160 self.addToVariable('LD_LIBRARY_PATH', value)
163 """Append value to DYLD_LIBRARY_PATH environment variable"""
164 def addToDyldLibraryPath(self, value):
165 self.addToVariable('DYLD_LIBRARY_PATH', value)
168 """Append value to PYTHONPATH environment variable"""
169 def addToPythonPath(self, value):
170 self.addToVariable('PYTHONPATH', value)
173 """Set environment variable to value"""
174 def setVariable(self, name, value, overwrite=False):
175 env = os.getenv(name, '')
176 if env and not overwrite:
177 self.getLogger().error("Environment variable already existing (and not overwritten): %s=%s", name, value)
181 self.getLogger().debug("Overwriting environment variable: %s=%s", name, value)
183 value = os.path.expandvars(value) # expand environment variables
184 self.getLogger().debug("Set environment variable: %s=%s", name, value)
185 os.environ[name] = value
188 def setDefaultValue(self, name, value):
189 """ Set environment variable only if it is undefined."""
190 env = os.getenv(name, '')
192 value = os.path.expandvars(value) # expand environment variables
193 self.getLogger().debug("Set environment variable: %s=%s", name, value)
194 os.environ[name] = value
196 """Unset environment variable"""
197 def unsetVariable(self, name):
198 if os.environ.has_key(name):
202 """Append value to environment variable"""
203 def addToVariable(self, name, value, separator=os.pathsep):
207 value = os.path.expandvars(value) # expand environment variables
208 self.getLogger().debug("Add to %s: %s", name, value)
209 env = os.getenv(name, None)
211 os.environ[name] = value
213 os.environ[name] = value + separator + env
216 ###################################
217 # This begins the private section #
218 ###################################
220 def __parseArguments(self, args):
221 if len(args) == 0 or args[0].startswith("-"):
227 availableCommands = {
228 'start' : '_sessionless',
229 'withsession' : '_runAppli',
230 'context' : '_setContext',
231 'shell' : '_runSession',
232 'remote' : '_runRemote',
233 'connect' : '_runConsole',
235 'killall' : '_killAll',
236 'test' : '_runTests',
237 'info' : '_showInfo',
240 'coffee' : '_makeCoffee',
244 if command not in availableCommands:
248 return availableCommands[command], options
253 Args consist in a mandatory command followed by optional parameters.
254 See usage for details on commands.
256 def _startSalome(self, args):
260 from setenv import add_path
261 absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH')
262 path = os.path.realpath(os.path.join(absoluteAppliPath, "bin", "salome"))
263 add_path(path, "PYTHONPATH")
264 path = os.path.realpath(os.path.join(absoluteAppliPath, "bin", "salome", "appliskel"))
265 add_path(path, "PYTHONPATH")
270 command, options = self.__parseArguments(args)
274 if args and args[0] in ["-h","--help","help"]:
277 # try to default to "start" command
278 command = "_sessionless"
281 res = getattr(self, command)(options) # run appropriate method
283 except SystemExit as ex:
285 self.getLogger().error("SystemExit %s in method %s.", ex.code, command)
287 except SalomeContextException as e:
288 self.getLogger().error(e)
291 self.getLogger().error("Unexpected error:")
293 traceback.print_exc()
297 def __setContextFromConfigFile(self, filename, reserved=None):
298 mesa_root_dir = "MESA_ROOT_DIR"
302 configInfo = parseConfigFile(filename, reserved)
303 unsetVars = configInfo.unsetVariables
304 configVars = configInfo.outputVariables
305 reservedDict = configInfo.reservedValues
306 defaultValues = configInfo.defaultValues
307 except SalomeContextException as e:
309 self.getLogger().error(msg)
313 for var in unsetVars:
314 self.unsetVariable(var)
317 if "MESA_GL_VERSION_OVERRIDE" in os.environ:
318 configVarsDict = {k:v for (k,v) in configVars}
319 if mesa_root_dir in configVarsDict:
320 path_to_mesa_lib = os.path.join(configVarsDict[mesa_root_dir],"lib")
321 if os.name == "posix":
322 self.addToVariable("LD_LIBRARY_PATH",path_to_mesa_lib)
324 self.addToVariable("PATH",path_to_mesa_lib)
327 for reserved in reservedDict:
328 a = [_f for _f in reservedDict[reserved] if _f] # remove empty elements
329 a = [ os.path.realpath(x) for x in a ]
330 reformattedVals = os.pathsep.join(a)
331 if reserved in ["INCLUDE", "LIBPATH"]:
332 self.addToVariable(reserved, reformattedVals, separator=' ')
334 self.addToVariable(reserved, reformattedVals)
338 for key,val in configVars:
339 self.setVariable(key, val, overwrite=True)
342 for key,val in defaultValues:
343 self.setDefaultValue(key, val)
346 pythonpath = os.getenv('PYTHONPATH','').split(os.pathsep)
347 pythonpath = [ os.path.realpath(x) for x in pythonpath ]
348 sys.path[:0] = pythonpath
351 def _runAppli(self, args=None):
354 # Initialize SALOME environment
355 sys.argv = ['runSalomeOld'] + args
357 setenv.main(True, exeName="salome withsession")
360 runSalomeOld.runSalome()
364 def _sessionless(self, args=None):
367 sys.argv = ['runSalome'] + args
368 import runSalomeNoServer
369 runSalomeNoServer.main()
372 def _setContext(self, args=None):
373 salome_context_set = os.getenv("SALOME_CONTEXT_SET")
374 if salome_context_set:
376 print("*** SALOME context has already been set.")
377 print("*** Enter 'exit' (only once!) to leave SALOME context.")
381 os.environ["SALOME_CONTEXT_SET"] = "yes"
383 print("*** SALOME context is now set.")
384 print("*** Enter 'exit' (only once!) to leave SALOME context.")
387 if sys.platform == 'win32':
391 proc = subprocess.Popen(cmd, shell=False, close_fds=True)
393 return proc.returncode
396 def _runSession(self, args=None):
399 sys.argv = ['runSession'] + args
401 params, args = runSession.configureSession(args, exe="salome shell")
403 sys.argv = ['runSession'] + args
407 return runSession.runSession(params, args)
410 def _runRemote(self, args=None):
413 # complete salome environment
414 sys.argv = ['runRemote']
419 return runRemote.runRemote(args)
422 def _runConsole(self, args=None):
425 # Initialize SALOME environment
426 sys.argv = ['runConsole']
431 return runConsole.connect(args)
434 def _kill(self, args=None):
439 print("Port number(s) not provided to command: salome kill <port(s)>")
446 if os.getenv("NSHOST") == "no_host":
447 os.unsetenv("NSHOST")
449 if sys.platform == "win32":
450 proc = subprocess.Popen([os.getenv("PYTHONBIN"), "-m", "killSalomeWithPort", str(port)])
452 proc = subprocess.Popen(["killSalomeWithPort.py", str(port)])
457 def _killAll(self, unused=None):
458 sys.argv = ['killAll']
461 if os.getenv("NSHOST") == "no_host":
462 os.unsetenv("NSHOST")
464 import PortManager # mandatory
466 ports = PortManager.getBusyPorts()['this']
470 if sys.platform == "win32":
471 proc = subprocess.Popen([os.getenv("PYTHONBIN"), "-m", "killSalomeWithPort", str(port)])
473 proc = subprocess.Popen(["killSalomeWithPort.py", str(port)])
476 # :TODO: should be declared obsolete
477 from killSalome import killAllPorts
480 from addToKillList import killList
485 def _runTests(self, args=None):
488 sys.argv = ['runTests']
493 return runTests.runTests(args, exe="salome test")
496 def _showSoftwareVersions(self, softwares=None):
497 config = configparser.SafeConfigParser()
498 absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH')
499 filename = os.path.join(absoluteAppliPath, "sha1_collections.txt")
502 with open(filename) as f:
505 software, version, sha1 = line.split()
506 versions[software.upper()] = version
507 if len(software) > max_len:
508 max_len = len(software)
514 for soft in softwares:
515 if soft.upper() in versions:
516 print(soft.upper().rjust(max_len), versions[soft.upper()])
519 od = collections.OrderedDict(sorted(versions.items()))
520 for name, version in od.items():
521 print(name.rjust(max_len), versions[name])
524 def _showInfo(self, args=None):
528 usage = "Usage: salome info [options]"
530 Display some information about SALOME.\n
531 Available options are:
532 -p,--ports Show the list of busy ports (running SALOME instances).
533 -s,--softwares [software(s)] Show the list and versions of SALOME softwares.
534 Software names must be separated by blank characters.
535 If no software is given, show version of all softwares.
536 -v,--version Show running SALOME version.
537 -h,--help Show this message.
542 if "-h" in args or "--help" in args:
543 print(usage + epilog)
546 if "-p" in args or "--ports" in args:
548 ports = PortManager.getBusyPorts()
549 this_ports = ports['this']
550 other_ports = ports['other']
551 if this_ports or other_ports:
552 print("SALOME instances are running on the following ports:")
554 print(" This application:", this_ports)
556 print(" No SALOME instances of this application")
558 print(" Other applications:", other_ports)
560 print(" No SALOME instances of other applications")
562 print("No SALOME instances are running")
564 if "-s" in args or "--softwares" in args:
566 index = args.index("-s")
568 index = args.index("--softwares")
570 while indexEnd < len(args) and args[indexEnd][0] != "-":
571 indexEnd = indexEnd + 1
572 self._showSoftwareVersions(softwares=args[index+1:indexEnd])
574 if "-v" in args or "--version" in args:
575 print("Running with python", platform.python_version())
576 return self._sessionless(["--version"])
581 def _showDoc(self, args=None):
587 print("Module(s) not provided to command: salome doc <module(s)>")
590 appliPath = os.getenv("ABSOLUTE_APPLI_PATH")
592 raise SalomeContextException("Unable to find application path. Please check that the variable ABSOLUTE_APPLI_PATH is set.")
593 baseDir = os.path.join(appliPath, "share", "doc", "salome")
594 for module in modules:
595 docfile = os.path.join(baseDir, "gui", module.upper(), "index.html")
596 if not os.path.isfile(docfile):
597 docfile = os.path.join(baseDir, "tui", module.upper(), "index.html")
598 if not os.path.isfile(docfile):
599 docfile = os.path.join(baseDir, "dev", module.upper(), "index.html")
600 if os.path.isfile(docfile):
601 out, err = subprocess.Popen(["xdg-open", docfile]).communicate()
603 print("Online documentation is not accessible for module:", module)
605 def _usage(self, unused=None):
609 def _makeCoffee(self, unused=None):
612 print(" ___...(-------)-....___")
613 print(" .-\"\" ) ( \"\"-.")
614 print(" .-\'``\'|-._ ) _.-|")
615 print(" / .--.| `\"\"---...........---\"\"` |")
619 print(" `\\ `\\ | |")
620 print(" `\\ `| SALOME |")
621 print(" _/ /\\ 4 EVER /")
622 print(" (__/ \\ <3 /")
623 print(" _..---\"\"` \\ /`\"\"---.._")
624 print(" .-\' \\ / \'-.")
625 print(" : `-.__ __.-\' :")
626 print(" : ) \"\"---...---\"\" ( :")
627 print(" \'._ `\"--...___...--\"` _.\'")
628 print(" \\\"\"--..__ __..--\"\"/")
629 print(" \'._ \"\"\"----.....______.....----\"\"\" _.\'")
630 print(" `\"\"--..,,_____ _____,,..--\"\"`")
631 print(" `\"\"\"----\"\"\"`")
633 print(" SALOME is working for you; what else?")
637 def _getCar(self, unused=None):
638 print(" _____________")
639 print(" ..---:::::::-----------. ::::;;.")
640 print(" .\'\"\"\"\"\"\" ;; \\ \":.")
641 print(" .\'\' ; \\ \"\\__.")
642 print(" .\' ;; ; \\\\\";")
643 print(" .\' ; _____; \\\\/")
644 print(" .\' :; ;\" \\ ___:\'.")
645 print(" .\'--........................... : = ____:\" \\ \\")
646 print(" ..-\"\" \"\"\"\' o\"\"\" ; ; :")
647 print(" .--\"\" .----- ..----... _.- --. ..-\" ; ; ; ;")
648 print(" .\"\"_- \"--\"\"-----\'\"\" _-\" .-\"\" ; ; .-.")
649 print(" .\' .\' SALOME .\" .\" ; ; /. |")
650 print(" /-./\' 4 EVER <3 .\" / _.. ; ; ;;;|")
651 print(" : ;-.______ / _________==. /_ \\ ; ; ;;;;")
652 print(" ; / | \"\"\"\"\"\"\"\"\"\"\".---.\"\"\"\"\"\"\" : /\" \". |; ; _; ;;;")
653 print(" /\"-/ | / / / / ;|; ;-\" | ;\';")
654 print(":- : \"\"\"----______ / / ____. . .\"\'. ;; .-\"..T\" .")
655 print("\'. \" ___ \"\": \'\"\"\"\"\"\"\"\"\"\"\"\"\"\" . ; ; ;; ;.\" .\" \'--\"")
656 print(" \", __ \"\"\" \"\"---... :- - - - - - - - - \' \' ; ; ; ;;\" .\"")
657 print(" /. ; \"\"\"---___ ; ; ; ;|.\"\"")
658 print(" : \": \"\"\"----. .-------. ; ; ; ;:")
659 print(" \\ \'--__ \\ \\ \\ / | ; ;;")
660 print(" \'-.. \"\"\"\"---___ : .______..\\ __/..-\"\"| ; ; ;")
661 print(" \"\"--.. \"\"\"--\" m l s . \". . ;")
662 print(" \"\"------... ..--\"\" \" :")
663 print(" \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\" \\ /")
666 print(" Drive your simulation properly with SALOME!")
670 # Add the following two methods since logger is not pickable
671 # Ref: http://stackoverflow.com/questions/2999638/how-to-stop-attributes-from-being-pickled-in-python
672 def __getstate__(self):
673 d = dict(self.__dict__)
674 if hasattr(self, '_logger'):
678 def __setstate__(self, d):
679 self.__dict__.update(d) # I *think* this is a safe way to do it
681 # Excluding self._logger from pickle operation imply using the following method to access logger
683 if not hasattr(self, '_logger'):
684 self._logger = logging.getLogger(__name__)
685 #self._logger.setLevel(logging.DEBUG)
686 #self._logger.setLevel(logging.WARNING)
687 self._logger.setLevel(logging.ERROR)
691 if __name__ == "__main__":
692 if len(sys.argv) == 3:
693 context = pickle.loads(sys.argv[1].encode('latin1'))
694 args = pickle.loads(sys.argv[2].encode('latin1'))
696 status = context._startSalome(args)