salome.kernel 9.14.0__cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

salome/kernel/runSalome_impl.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2022-2024  CEA, EDF, OPEN CASCADE
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+## @package runSalome
+# \brief Module that provides services to launch SALOME
+#
+
+import sys, os, string, glob, time, pickle, re
+import setenv
+from .server import process_id, Server
+import json
+import subprocess
+from salome.kernel.salomeContextUtils import ScriptAndArgsObjectEncoder
+import runSalomeNoServer
+from salome.kernel import runSalomeCommon
+import platform
+from salome.kernel.launchConfigureParser import verbosity_nam, on_demand_nam
+import logging
+logger = logging.getLogger()
+
+# -----------------------------------------------------------------------------
+
+from killSalome import killAllPorts
+
+def kill_salome(args):
+    """
+    Kill servers from previous SALOME executions, if needed;
+    depending on args 'killall' or 'portkill', kill all executions,
+    or only execution on the same CORBA port
+    """
+
+    if args['killall']:
+        killAllPorts()
+#
+# -----------------------------------------------------------------------------
+
+def startGUI(clt):
+    """Salome Session Graphic User Interface activation"""
+    from . import Engines
+    from . import SALOME
+    from . import SALOMEDS
+    from . import SALOME_ModuleCatalog
+    from . import SALOME_Session_idl
+    session=clt.waitNS("/Kernel/Session",SALOME.Session)
+    session.GetInterface()
+
+# -----------------------------------------------------------------------------
+
+def startSalome(args, modules_list, modules_root_dir):
+    """Launch all SALOME servers requested by args"""
+    init_time = os.times()
+
+    logger.debug("startSalome : {} ".format(args))
+
+    ior_fakens_filename = None
+
+    # Launch  Session Server (to show splash ASAP)
+    #
+
+    if args["gui"] and not args['launcher_only']:
+        mySessionServ = runSalomeNoServer.NoSessionServer(args,args['modules'],modules_root_dir)
+        mySessionServ.setpath(modules_list,modules_root_dir)
+        mySessionServ.run()
+        ior_fakens_filename = mySessionServ.iorfakens
+        logger.debug("Rendez-vous file for to retrieve IOR of session is \"{}\"".format(ior_fakens_filename))
+
+    end_time = os.times()
+
+    #
+    # Wait until Session Server is registered in naming service
+    #
+    logger.debug("Start SALOME, elapsed time : %5.1f seconds"% (end_time[4] - init_time[4]))
+
+    #
+    # additional external python interpreters
+    #
+    nbaddi=0
+
+    try:
+        if 'interp' in args:
+            nbaddi = args['interp']
+    except Exception:
+        import traceback
+        traceback.print_exc()
+        logger.error("-------------------------------------------------------------")
+        logger.error("-- to get an external python interpreter:runSalome --interp=1")
+        logger.error("-------------------------------------------------------------")
+
+    logger.debug("additional external python interpreters: {}".format(nbaddi))
+    if nbaddi:
+        for i in range(nbaddi):
+            anInterp=runSalomeCommon.InterpServer(args)
+            anInterp.run()
+
+    # set PYTHONINSPECT variable (python interpreter in interactive mode)
+    if args['pinter']:
+        os.environ["PYTHONINSPECT"]="1"
+        try:
+            import readline
+        except ImportError:
+            pass
+
+    return ior_fakens_filename
+
+# -----------------------------------------------------------------------------
+
+def useSalome(args, modules_list, modules_root_dir):
+    """
+    Launch all SALOME servers requested by args,
+    save list of process, give info to user,
+    show registered objects in Naming Service.
+    """
+    global process_id
+    ior_fakens_filename = None
+    try:
+        ior_fakens_filename = startSalome(args, modules_list, modules_root_dir)
+    except Exception:
+        import traceback
+        traceback.print_exc()
+        logger.error("--- Error during Salome launch ---")
+
+    # print(process_id)
+
+    from addToKillList import addToKillList
+    from killSalomeWithPort import getPiDict
+
+    filedict = getPiDict(args['port'])
+    for pid, cmd in list(process_id.items()):
+        addToKillList(pid, cmd, args['port'])
+        pass
+
+    logger.debug("""
+    Saving of the dictionary of Salome processes in %s
+    To kill SALOME processes from a console (kill all sessions from all ports):
+      python killSalome.py
+    To kill SALOME from the present interpreter, if it is not closed :
+      killLocalPort()      --> kill this session
+                               (use CORBA port from args of runSalome)
+      givenPortKill(port)  --> kill a specific session with given CORBA port
+      killAllPorts()       --> kill all sessions
+
+    runSalome, with --killall option, starts with killing
+    the processes resulting from the previous execution.
+    """%filedict)
+
+    return ior_fakens_filename
+
+def execScript(script_path):
+    print('executing', script_path)
+    sys.path.insert(0, os.path.realpath(os.path.dirname(script_path)))
+    exec(compile(open(script_path).read(), script_path, 'exec'),globals())
+    del sys.path[0]
+
+# -----------------------------------------------------------------------------
+
+def main(exeName=None):
+    """Salome launch as a main application"""
+    keep_env = not os.getenv('SALOME_PLEASE_SETUP_ENVIRONMENT_AS_BEFORE')
+    args, modules_list, modules_root_dir = setenv.get_config(exeName=exeName, keepEnvironment=keep_env)
+    runSalomeCommon.setVerbose(args[verbosity_nam])
+
+    kill_salome(args)
+    # --
+
+    # Setup extension's env in salome on demand case
+    if args[on_demand_nam]:
+        import runSalomeOnDemand
+        runSalomeOnDemand.set_ext_env()
+        # Reset up module_list and modules_root_dir, if we dont want to define SalomeAppConfig on salome.py.
+        # We must remove the "else" on "if os.sys.platform == 'win32':" in launcheConfigureParser.py too.
+        args, _, __ = setenv.get_config(exeName=exeName, keepEnvironment=keep_env)
+
+    setenv.set_env(args, modules_list, modules_root_dir, keepEnvironment=keep_env)
+    ior_fakens_filename = useSalome(args, modules_list, modules_root_dir)
+    # Management of -t <script.py>
+    toimport = []
+    env = os.environ
+    if 'gui' in args and 'session_gui' in args:
+        if not args['gui'] or not args['session_gui']:
+            if 'study_hdf' in args:
+                toopen = args['study_hdf']
+                if toopen:
+                    os.environ["PATH_TO_STUDY_FILE_TO_INITIATE"] = toopen
+                    logger.debug("An input Study has been specified {} -> pass it with PATH_TO_STUDY_FILE_TO_INITIATE env var".format(toopen))
+            if 'pyscript' in args:
+                toimport = args['pyscript']
+    from salome.kernel.salomeContextUtils import formatScriptsAndArgs
+    from salome.kernel.addToKillList_impl import addToKillList
+    command = formatScriptsAndArgs(toimport, escapeSpaces=True)
+    if command:
+        logger.debug("Launching following shell command : {}".format(str(command)))
+        proc = subprocess.Popen(command, shell=True, env = env)
+        addToKillList(proc.pid, command)
+        res = proc.wait()
+        if res: sys.exit(1)
+    return args, ior_fakens_filename
+
+# -----------------------------------------------------------------------------
+
+def foreGround(args, ior_fakens_filename):
+    # --
+    import os
+    gui_detected = False
+    dt = 0.1
+    nbtot = 200
+    nb = 0
+    if ior_fakens_filename is None:
+        logger.warn("No file set to host IOR of the fake naming server")
+        return
+    if not os.path.exists(ior_fakens_filename):
+        logger.warn("No file {} set to host IOR of the fake naming server does not exit !")
+        return
+    import CORBA
+    #import Engines
+    from . import SALOME
+    from time import sleep
+    orb = CORBA.ORB_init([''], CORBA.ORB_ID)
+    ior_fakens = None
+    session = None
+    while True:
+        try:
+            ior_fakens = orb.string_to_object(open(ior_fakens_filename).read())
+            session = orb.string_to_object(ior_fakens.Resolve("/Kernel/Session").decode())
+        except Exception:
+            pass
+        if ( session is not None ) and (not CORBA.is_nil(session)):
+            try:
+                os.remove(ior_fakens_filename)
+                logger.debug("File {} has been removed".format(ior_fakens_filename))
+            except:
+                pass
+            logger.debug("Session in child process has been found ! yeah ! {}".format(str(session)))
+            break
+        sleep(dt)
+        nb += 1
+        logger.debug("Unfortunately Session not found into {} : Sleep and retry. {}/{}".format(ior_fakens_filename,nb,nbtot))
+        if nb == nbtot:
+            break
+
+    if session is None:
+        logger.debug("Couldn't find /Kernel/Session in the child process. Return.")
+        return
+
+    nb = 0
+    # --
+    # Wait until gui is arrived
+    # tmax = nbtot * dt
+    # --
+    session_pid = None
+    while 1:
+        try:
+            status = session.GetStatSession()
+            gui_detected = status.activeGUI
+            session_pid = session.getPID()
+            logger.debug("Process of the session under monitoring {}".format(session_pid))
+        except Exception:
+            pass
+        if gui_detected:
+            break
+        sleep(dt)
+        nb += 1
+        if nb == nbtot:
+            break
+        pass
+    # --
+    if not gui_detected:
+        logger.debug("Couldn't find active GUI in the current session. Return.")
+        return
+    # --
+    from .salome_utils import getPortNumber
+    port = getPortNumber()
+    # --
+    dt = 1.0
+    try:
+        while 1:
+            try:
+                status = session.GetStatSession()
+                assert status.activeGUI
+            except Exception:
+                logger.debug("Process of the session under monitoring {} has vanished !".format(session_pid))
+                break
+            from time import sleep
+            sleep(dt)
+            pass
+        pass
+    except KeyboardInterrupt:
+        logger.debug("Keyboard requested : killing all process attached to port {}".format(port))
+    finally:
+        from killSalomeWithPort import killProcessSSL
+        killProcessSSL(port,[session_pid])
+    return
+#
+
+def runSalome():
+    args, ior_fakens_filename = main()
+    # --
+    test = args['gui'] and args['session_gui']
+    test = test and not args[on_demand_nam]
+    test = test or args['wake_up_session']
+    # --
+    # The next test covers the --pinter option or if var PYTHONINSPECT is set
+    # --
+    test = test and not os.environ.get('PYTHONINSPECT')
+    # --
+    # The next test covers the python -i $KERNEL_ROOT_DIR/bin/salome/runSalome.py case
+    # --
+    try:
+        from ctypes import POINTER, c_int, cast, pythonapi
+        iflag_ptr = cast(pythonapi.Py_InteractiveFlag, POINTER(c_int))
+        test = test and not iflag_ptr.contents.value
+    except Exception:
+        pass
+    # --
+#    test = test and os.getenv("SALOME_TEST_MODE", "0") != "1"
+    test = test and args['foreground']
+    # --
+    if test:
+        from time import sleep
+        sleep(3.0)
+        foreGround(args, ior_fakens_filename)
+        pass
+    pass
+#

salome/kernel/runSession.py

@@ -0,0 +1,360 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import os
+import sys
+from optparse import OptionParser
+from .NSparam_impl import getNSparams
+import socket
+import subprocess
+import re
+from pathlib import Path
+from .salomeContextUtils import getScriptsAndArgs, formatScriptsAndArgs, getShortAndExtraArgs
+from .salome_utils import getUserName, getShortHostName
+
+# Use to display newlines (\n) in epilog
+class MyParser(OptionParser):
+    def format_epilog(self, formatter):
+        return self.epilog
+#
+
+class SessionParameters:
+  def __init__(self, mode, port, machine, user, directory):
+    self.mode = mode
+    self.port = port
+    self.machine = machine
+    self.user = user
+    self.directory = directory
+  #
+  def __repr__(self):
+    msg = "\n# Session Parameters:\n"
+    msg += "     * mode: %s\n"%self.mode
+    msg += "     * port: %s\n"%self.port
+    msg += "     * machine: %s\n"%self.machine
+    msg += "     * user: %s\n"%self.user
+    msg += "     * directory: %s\n"%self.directory
+    return msg
+  #
+#
+
+def configureSession(args=None, exe=None):
+  if args is None:
+    args = []
+  if exe:
+      usage = "Usage: %s [options] [command] [-- <extra>]"%exe
+  else:
+      usage = "Usage: %prog [options] [command] [-- <extra>]"
+  epilog  = """\n
+If command is not given a shell is opened; else execute the given command.\n
+* Command may be an executable script or program, either identified by its
+  full path or located in a directory pointed by a system variable (e.g.
+  PATH).\n
+* Command may also be a series of Python scripts with arguments:
+  [PYTHON_FILE [args] [PYTHON_FILE [args]...]]
+Python file arguments, if any, must be comma-separated (without blank
+  characters) and prefixed by "args:" keyword (without quotes).
+For example:
+       salome shell hello.py add.py args:1,2 hello.py args:you
+will successively say hello, add 1+2, and say hello to you.\n
+The double dash (--) syntax indicates an extra command to be run "as is". It
+  allows calling a extern program or system command with options and
+  arguments, using the syntax: -- <program> [options] [arguments].
+For example:
+       salome shell -- ls -l *.py
+       salome shell -- python -tt hello.py
+\n
+If PORT and MACHINE are not given, try to connect to the last active session
+  on the local machine.
+If PORT and MACHINE are given, try to connect to the remote session associated
+  with PORT on MACHINE.
+If MACHINE is not given, try to connect to the session associated to PORT on
+  the local machine.
+If PORT is not given, try to connect to the remote session associated to port
+  2810 on MACHINE.\n
+If MACHINE is remote, the following options MUST be provided:
+     * DIRECTORY: The full path to the salome command on remote machine.
+     * USER: The user on the computer to connect to.\n
+In case of remote call, syntax "out:res1,res2,..." can be used to get results
+  from remote machine.
+For example:
+       salome shell -m remotemachine -p 2810 -u myself -d /full/path/to/salome
+  concatenate.py args:file1.txt,file2.txt out:result.txt
+User "myself" connects to remotemachine to run the script concatenate.py in
+  a SALOME session on port 2810; the script takes two input parameters and
+  produces one result file.\n
+"""
+  parser = MyParser(usage=usage, epilog=epilog)
+  parser.add_option("-p", "--port", metavar="<port>", default=0,
+                    action="store", type="string", dest="port",
+                    help="The port to connect to."
+                    )
+  parser.add_option("-m", "--machine", metavar="<machine>", default=0,
+                    action="store", type="string", dest="host",
+                    help="The machine to connect to."
+                    )
+  parser.add_option('-d', '--directory', dest="directory", default=None,
+                    help="[Remote mode] The full path to the salome command on remote machine."
+                    )
+  parser.add_option('-u', '--user', dest="user", default=None,
+                    help="[Remote mode] The user on the computer to connect to."
+                    )
+
+  parser.add_option('-l', '--launcher', dest="launcher", default=None,
+                    help="[Remote mode] The machine and the port to connect to."
+                    )
+
+  short_args, extra_args = getShortAndExtraArgs(args)
+  try:
+    (options, args) = parser.parse_args(short_args)
+  except Exception as e:
+    print(e)
+    return None, []
+
+  port = options.port
+  host = options.host
+  launcher = options.launcher
+  if launcher is not None:
+    pos = launcher.find(":")
+    if pos != -1:
+      host = launcher[0:pos]
+      port = launcher[pos+1:]
+
+  # :GLITCH: this code defines specific environment variables (OMNIORB_CONFIG, NSPORT,
+  # NSHOST) which are later used by other modules. Working, but not really "safe"...
+  if not port:
+    if not host:
+      # neither MACHINE nor PORT are given
+      # --- set omniORB configuration to current session if any
+      omniorbUserPath = os.environ['OMNIORB_USER_PATH']
+      fileOmniConfig = omniorbUserPath + '/.omniORB_' + getUserName() + '_last.cfg'
+      if os.path.isfile(fileOmniConfig):
+        os.environ['OMNIORB_CONFIG'] = fileOmniConfig
+        # --- set environment variables for port and hostname of NamingService
+        host, port = getNSparams()
+        try:
+            # keep short name for host, for a correct comparison with getShortHostName() later
+            host=host.split('.')[0]
+        except Exception:
+            pass
+      else:
+        # No running session
+        host = "no_host"
+        port = "no_port"
+    else:
+      # only MACHINE is given
+      port = '2810'
+      _writeConfigFile(port, host)
+    #
+  else:
+    if not host:
+      # only PORT is given
+      host = getShortHostName()
+    # both MACHINE and PORT are given
+    _writeConfigFile(port, host)
+  #
+  os.environ['NSPORT'] = port
+  os.environ['NSHOST'] = host
+
+  # determine running mode, that is either 'local' or 'remote'
+  here = getShortHostName()
+  mode = "local"
+  if host != here and host != "localhost" and host != "no_host" and launcher is None:
+    mode="remote"
+    pass
+  params = SessionParameters(mode, port, host, options.user, options.directory)
+  return params, args+extra_args
+#
+
+# --- set the OMNIORB_CONFIG file and environment relative to this run of SALOME
+def _writeConfigFile(port, host):
+  path = os.environ['OMNIORB_USER_PATH']
+  kwargs = {'with_username' : getUserName()}
+
+  from ORBConfigFile import writeORBConfigFile
+  [ filename, msgSize ] = writeORBConfigFile(path, host, port, kwargs)
+
+  os.environ['OMNIORB_CONFIG'] = filename
+#
+
+# command looks like a Bash command-line:
+# script1.py [args] ; script2.py [args] ; ...
+def __runLocalSession(command):
+  if command:
+    sep = ";"
+    if sys.platform == "win32":
+      sep= "&"
+    command = command.split(sep)
+    outmsg = []
+    errmsg = []
+    for cmd in command:
+      single_cmd = cmd.strip().split(' ')
+      any_error = False
+      error_code = 1
+      try:
+        proc = subprocess.Popen(single_cmd)
+        (stdoutdata, stderrdata) = proc.communicate() # Wait for process to terminate
+        if stdoutdata:
+          outmsg.append(stdoutdata)
+        if stderrdata:
+          errmsg.append(stderrdata)
+
+        if proc.returncode != 0:
+          any_error = True
+          error_code = proc.returncode
+      except Exception:
+          any_error = True
+          pass
+
+      if any_error:
+        errmsg.append("Error raised when executing command: %s\n"%cmd)
+        if outmsg:
+          sys.stdout.write("".join(outmsg))
+        if errmsg:
+          sys.stderr.write("".join(errmsg))
+        sys.exit(error_code)
+
+    return 0
+  else:
+    absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH','')
+    if sys.platform == "win32":
+      cmd = ["cmd", "/K", "set PROMPT=[SALOME] $P$G"]
+    else:
+      bashrc = Path( absoluteAppliPath ) / "bin" / "salome" / "appli" / ".bashrc"
+      cmd = ["/bin/bash",  "--rcfile", bashrc.as_posix() ]
+    proc = subprocess.Popen(cmd, shell=False, close_fds=True)
+    proc.communicate()
+    return proc.returncode
+#
+
+def __copyFiles(user, machine, script, infiles, outfiles):
+  """Modify script, copy files to remote computer and return lists of copied files."""
+
+  namescript = os.path.basename(script)
+  import getpass
+  logname = getpass.getuser()
+  tmp_script = "/tmp/%s_%s_%s" % (logname, os.getpid(), namescript)
+  with open(script, 'r') as fscript:
+    script_text = fscript.read()
+
+  list_infiles = []
+  list_outfiles = []
+  n = 0
+  for infile in infiles:
+    # generate a temporary file name
+    namefile = os.path.basename(infile)
+    tmp_file = "/tmp/%s_%s_i%s_%s" % (logname, os.getpid(), n, namefile)
+
+    # modify the salome script
+    script_text = re.sub(infile, tmp_file, script_text)
+
+    # copy the infile to the remote server
+    cmd = "scp %s %s@%s:%s" % (infile, user, machine, tmp_file)
+    print("[  SCP  ]", cmd)
+    os.system(cmd)
+
+    list_infiles.append(tmp_file)
+    n = n + 1
+  #
+  n = 0
+  for outfile in outfiles:
+    # generate a temporary file name
+    namefile = os.path.basename(outfile)
+    tmp_file = "/tmp/%s_%s_o%s_%s" % (logname, os.getpid(), n, namefile)
+
+    # modify the salome script
+    script_text = re.sub(outfile, tmp_file, script_text)
+
+    list_outfiles.append(tmp_file)
+    n = n + 1
+  #
+
+  with open(tmp_script,'w') as fscript:
+    fscript.write(script_text)
+
+  # copy the salome script on the remote server
+  cmd = "scp %s %s@%s:%s" % (tmp_script, user, machine, tmp_script)
+  print("[  SCP  ]", cmd)
+  os.system(cmd)
+
+  return list_infiles, list_outfiles, tmp_script
+#
+
+# sa_obj is a ScriptAndArgs object (from salomeContextUtils)
+def __runRemoteSession(sa_obj, params):
+  if not params.user:
+    print("ERROR: The user login on remote machine MUST be given.")
+    return 1
+  if not params.directory:
+    print("ERROR: The remote directory MUST be given.")
+    return 1
+
+  # sa_obj.script may be 'python script.py' --> only process .py file
+  header = " ".join(sa_obj.script.split()[:-1])
+  script = sa_obj.script.split()[-1]
+
+  tmp_in, tmp_out, tmp_script = __copyFiles(params.user, params.machine, script, sa_obj.args or [], sa_obj.out or [])
+
+  # execute command on the remote SALOME application
+  command = "%s/salome shell" % (params.directory)
+  if params.port:
+    command += " -p %s "%params.port
+  command += " %s %s args:%s"%(header, tmp_script, ",".join(tmp_in))
+  # salome shell command must run in a login shell because of module function
+  command = "ssh %s@%s -t 'bash -l -c \"%s\"'" % (params.user, params.machine, command)
+  print('[  SSH   ] ' + command)
+  os.system(command)
+
+  # Get remote files and clean
+  temp_files = tmp_in + tmp_out + [tmp_script]
+
+  # get the outfiles
+  for outfile in (sa_obj.out or []):
+    remote_outfile = tmp_out.pop(0)
+    command = "scp %s@%s:%s %s" %(params.user, params.machine, remote_outfile, outfile)
+    print("[  SCP  ] " + command)
+    os.system(command)
+
+  # clean temporary files
+  command = "ssh %s@%s \\rm -f %s" % (params.user, params.machine, " ".join(temp_files))
+  print('[  SSH   ] ' + command)
+  os.system(command)
+  os.remove(tmp_script)
+
+  return 0
+#
+
+def runSession(params, args):
+  scriptArgs = getScriptsAndArgs(args)
+
+  if params.mode == "local":
+    command = formatScriptsAndArgs(scriptArgs)
+    return __runLocalSession(command)
+
+  elif params.mode == "remote":
+    any_error = 0
+    for sa_obj in scriptArgs:
+      ok = __runRemoteSession(sa_obj, params)
+      if not ok:
+        any_error = 1
+    return any_error
+#