Salome HOME
decode pip version
[tools/sat.git] / commands / launcher.py
index aaea98d2e5e5636c90579a00799653928819bb7a..ea7cc82136738a343d63a2ecde9c1becc34f72f4 100644 (file)
@@ -31,7 +31,10 @@ parser = src.options.Options()
 parser.add_option('n', 'name', 'string', 'name', _('Optional: The name of the'
                   ' launcher (default is APPLICATION.profile.launcher_name)'))
 parser.add_option('e', 'exe', 'string', 'path_exe', _('Use this option to generate a launcher which sets'
-                  ' the environment and call the executable given as argument (its relative path)'))
+                  ' the environment and call the executable given as argument'
+                  ' (its relative path to application workdir, or an exe name present in appli PATH)'))
+parser.add_option('p', 'products', 'list2', 'products',
+    _("Optional: Includes only the specified products."))
 parser.add_option('c', 'catalog', 'string', 'catalog',
                   _('Optional: The resources catalog to use'))
 parser.add_option('', 'gencat', 'string', 'gencat',
@@ -47,88 +50,13 @@ parser.add_option('', 'no_path_init', 'boolean', 'no_path_init',
                    "user's environment)\n\tUse no_path_init option to suppress the reinitilisation"
                    " of every paths (LD_LIBRARY_PATH, PYTHONPATH, ...)"))
 
-def generate_exe_launch_file(config,
-                             logger,
-                             launcher_name,
-                             pathlauncher,
-                             path_exe,
-                             display=True,
-                             additional_env={},
-                             no_path_init=False):
-    '''Generates the launcher file.
-    
-    :param config Config: The global configuration
-    :param logger Logger: The logger instance to use for the display 
-                          and logging
-    :param launcher_name str: The name of the launcher to generate
-    :param pathlauncher str: The path to the launcher to generate
-    :param path_exe str: The path of the executable to use
-    :param display boolean: If False, do not print anything in the terminal
-    :param additional_env dict: The dict giving additional 
-                                environment variables
-    :return: The launcher file path.
-    :rtype: str
-    '''
-    # build absolute path of exe and check it
-    exepath=os.path.join(config.APPLICATION.workdir, path_exe)
-    if not os.path.exists(exepath):
-        raise src.SatException(_("cannot find executable given : %s" % exepath))
-        
-    # build the launcher path, delete it if it exists
-    filepath = os.path.join(pathlauncher, launcher_name)
-    if os.path.exists(filepath):
-        os.remove(filepath)
-
-    # select the shell for the launcher (bast/bat)
-    # and build the command used to launch the exe
-    if src.architecture.is_windows():
-        shell="bat"
-        cmd="\n\nrem Launch exe with user arguments\n%s " % exepath + "%*"
-    else:
-        shell="bash"
-        cmd="\n\n# Launch exe with user arguments\n%s $*" % exepath
-
-    # the writer to generate the launcher
-    writer = src.environment.FileEnvWriter(config,
-                                           logger,
-                                           pathlauncher,
-                                           src_root=None,
-                                           env_info=None)
-
-    # Display some information
-    if display:
-        logger.write(_("Generating exe launcher for %s :\n") % 
-                     src.printcolors.printcLabel(config.VARS.application), 1)
-        logger.write("  %s\n" % src.printcolors.printcLabel(filepath), 1)
-
-    # Write the environment in the launcher...
-    writer.write_env_file(filepath, 
-                          False,  # for launch
-                          shell,
-                          additional_env=additional_env,
-                          no_path_init=no_path_init)
-
-    # ... and append the launch of the exe
-    with open(filepath, "a") as exe_launcher:
-        exe_launcher.write(cmd)
-
-    # change the rights in order to make the file executable for everybody
-    os.chmod(filepath,
-             stat.S_IRUSR |
-             stat.S_IRGRP |
-             stat.S_IROTH |
-             stat.S_IWUSR |
-             stat.S_IXUSR |
-             stat.S_IXGRP |
-             stat.S_IXOTH)
-
-    return filepath
-
 
 def generate_launch_file(config,
                          logger,
                          launcher_name,
                          pathlauncher,
+                         path_exe,
+                         env_info,
                          display=True,
                          additional_env={},
                          no_path_init=False):
@@ -138,70 +66,99 @@ def generate_launch_file(config,
     :param logger Logger: The logger instance to use for the display 
                           and logging
     :param launcher_name str: The name of the launcher to generate
+    :param path_exe str: The executable to use (either a relative path to 
+                         application workdir, or an exe name in the path)
     :param pathlauncher str: The path to the launcher to generate
     :param display boolean: If False, do not print anything in the terminal
     :param additional_env dict: The dict giving additional 
                                 environment variables
+    :param env_info str: The list of products to add in the files.
     :return: The launcher file path.
     :rtype: str
     '''
-    # Compute the default launcher path if it is not provided in pathlauncher
-    # parameter
+    # build the launcher path, delete it if it exists
     filepath = os.path.join(pathlauncher, launcher_name)
-
-    # Remove the file if it exists in order to replace it
     if os.path.exists(filepath):
         os.remove(filepath)
+    kernel_root_dir=None
+    cmd=None
+    salome_application_name=None
+    app_root_dir=None
 
+    if path_exe:
+        #case of a launcher based upon an executable
+        
+        if os.path.basename(path_exe) != path_exe:
+            # for a relative (to workdir) path 
+            # build absolute path of exe and check it
+            exepath=os.path.join(config.APPLICATION.workdir, path_exe)
+            if not os.path.exists(exepath):
+                raise src.SatException(_("cannot find executable given : %s" % exepath))
+        else:
+            exepath=path_exe 
+
+        # select the shell for the launcher (bast/bat)
+        # and build the command used to launch the exe
+        if src.architecture.is_windows():
+            shell="bat"
+            cmd="\n\nrem Launch exe with user arguments\n%s " % exepath + "%*"
+        else:
+            shell="bash"
+            cmd='\n\n# Launch exe with user arguments\n%s "$*"' % exepath
 
-    # get KERNEL bin installation path 
-    # (in order for the launcher to get python salomeContext API)
-    kernel_cfg = src.product.get_product_config(config, "KERNEL")
-    if not src.product.check_installation(config, kernel_cfg):
-        raise src.SatException(_("KERNEL is not installed"))
-    kernel_root_dir = kernel_cfg.install_dir
-
-    # set kernel bin dir (considering fhs property)
-    if src.get_property_in_product_cfg(kernel_cfg, "fhs"):
-        bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin") 
     else:
-        bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin","salome") 
+        #case of a salome python2/3 launcher
+        shell="cfgForPy"
+
+        # get KERNEL bin installation path 
+        # (in order for the launcher to get python salomeContext API)
+        kernel_cfg = src.product.get_product_config(config, "KERNEL")
+        if not src.product.check_installation(config, kernel_cfg):
+            raise src.SatException(_("KERNEL is not installed"))
+        kernel_root_dir = kernel_cfg.install_dir
+        # set kernel bin dir (considering fhs property)
+        if src.get_property_in_product_cfg(kernel_cfg, "fhs"):
+            bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin") 
+        else:
+            bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin","salome") 
+
+        # Add two sat variables used by fileEnviron to choose the right launcher header 
+        # and do substitutions
+        additional_env['sat_bin_kernel_install_dir'] = bin_kernel_install_dir
+        if "python3" in config.APPLICATION and config.APPLICATION.python3 == "yes":
+            additional_env['sat_python_version'] = 3
+        else:
+            additional_env['sat_python_version'] = 2
 
     # check if the application contains an application module
     l_product_info = src.product.get_products_infos(config.APPLICATION.products.keys(),
                                                     config)
-    salome_application_name="Not defined" 
     for prod_name, prod_info in l_product_info:
         # look for a salome application
         if src.get_property_in_product_cfg(prod_info, "is_salome_application") == "yes":
-            salome_application_name=prod_info.install_dir
+            # if user choose -p option (env_info not None), the set appli name only if product was selected.
+            if env_info == None or ( prod_name in env_info):
+                salome_application_name=prod_info.install_dir
             continue
 
     # if the application contains an application module, we set ABSOLUTE_APPLI_PATH to it.
     # if not we set it to KERNEL_INSTALL_DIR, which is sufficient, except for salome test
-    if salome_application_name == "Not defined":
-        app_root_dir=kernel_root_dir
-    else:
+    if salome_application_name:
         app_root_dir=salome_application_name
-
-    # Add two sat variables used by fileEnviron to choose the right launcher header 
-    # and do substitutions
-    additional_env['sat_bin_kernel_install_dir'] = bin_kernel_install_dir
-    if "python3" in config.APPLICATION and config.APPLICATION.python3 == "yes":
-        additional_env['sat_python_version'] = 3
-    else:
-        additional_env['sat_python_version'] = 2
+    elif kernel_root_dir:
+        app_root_dir=kernel_root_dir
 
     # Add the APPLI and ABSOLUTE_APPLI_PATH variable
     additional_env['APPLI'] = filepath
-    additional_env['ABSOLUTE_APPLI_PATH'] = app_root_dir
+    if app_root_dir:
+        additional_env['ABSOLUTE_APPLI_PATH'] = app_root_dir
 
     # create an environment file writer
     writer = src.environment.FileEnvWriter(config,
                                            logger,
                                            pathlauncher,
-                                           src_root=None,
-                                           env_info=None)
+                                           None,
+                                           env_info)
 
     # Display some information
     if display:
@@ -213,10 +170,16 @@ def generate_launch_file(config,
     # Write the launcher
     writer.write_env_file(filepath, 
                           False,  # for launch
-                          "cfgForPy",
+                          shell,
                           additional_env=additional_env,
                           no_path_init=no_path_init)
     
+
+    # ... and append the launch of the exe 
+    if cmd:
+        with open(filepath, "a") as exe_launcher:
+            exe_launcher.write(cmd)
+
     # change the rights in order to make the file executable for everybody
     os.chmod(filepath,
              stat.S_IRUSR |
@@ -253,57 +216,55 @@ def generate_catalog(machines, config, logger):
 
     # Create the catalog path
     catfile = src.get_tmp_filename(config, "CatalogResources.xml")
-    catalog = file(catfile, "w")
-    
-    # Write into it
-    catalog.write("<!DOCTYPE ResourcesCatalog>\n<resources>\n")
-    for k in machines:
-        if not src.architecture.is_windows(): 
-            logger.write("    ssh %s " % (k + " ").ljust(20, '.'), 4)
-            logger.flush()
-
-            # Verify that the machine is accessible
-            ssh_cmd = 'ssh -o "StrictHostKeyChecking no" %s %s' % (k, cmd)
-            p = subprocess.Popen(ssh_cmd, shell=True,
-                    stdin=subprocess.PIPE,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE)
-            p.wait()
-
-            machine_access = (p.returncode == 0) 
-            if not machine_access: # The machine is not accessible
-                logger.write(src.printcolors.printc(src.KO_STATUS) + "\n", 4)
-                logger.write("    " + 
-                             src.printcolors.printcWarning(p.stderr.read()), 2)
-            else:
-                # The machine is accessible, write the corresponding section on
-                # the xml file
-                logger.write(src.printcolors.printc(src.OK_STATUS) + "\n", 4)
-                lines = p.stdout.readlines()
-                freq = lines[0][:-1].split(':')[-1].split('.')[0].strip()
-                nb_proc = len(lines) -1
-                memory = lines[-1].split(':')[-1].split()[0].strip()
-                memory = int(memory) / 1000
-
-        catalog.write("    <machine\n")
-        catalog.write("        protocol=\"ssh\"\n")
-        catalog.write("        nbOfNodes=\"1\"\n")
-        catalog.write("        mode=\"interactif\"\n")
-        catalog.write("        OS=\"LINUX\"\n")
-
-        if (not src.architecture.is_windows()) and machine_access :
-            catalog.write("        CPUFreqMHz=\"%s\"\n" % freq)
-            catalog.write("        nbOfProcPerNode=\"%s\"\n" % nb_proc)
-            catalog.write("        memInMB=\"%s\"\n" % memory)
-
-        catalog.write("        userName=\"%s\"\n" % user)
-        catalog.write("        name=\"%s\"\n" % k)
-        catalog.write("        hostname=\"%s\"\n" % k)
-        catalog.write("    >\n")
-        catalog.write("    </machine>\n")
-
-    catalog.write("</resources>\n")
-    catalog.close()
+    with open(catfile, 'w') as catalog:
+        # Write into it
+        catalog.write("<!DOCTYPE ResourcesCatalog>\n<resources>\n")
+        for k in machines:
+            if not src.architecture.is_windows(): 
+                logger.write("    ssh %s " % (k + " ").ljust(20, '.'), 4)
+                logger.flush()
+
+                # Verify that the machine is accessible
+                ssh_cmd = 'ssh -o "StrictHostKeyChecking no" %s %s' % (k, cmd)
+                p = subprocess.Popen(ssh_cmd, shell=True,
+                        stdin=subprocess.PIPE,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE)
+                p.wait()
+
+                machine_access = (p.returncode == 0) 
+                if not machine_access: # The machine is not accessible
+                    logger.write(src.printcolors.printc(src.KO_STATUS) + "\n", 4)
+                    logger.write("    " + 
+                                 src.printcolors.printcWarning(p.stderr.read()), 2)
+                else:
+                    # The machine is accessible, write the corresponding section on
+                    # the xml file
+                    logger.write(src.printcolors.printc(src.OK_STATUS) + "\n", 4)
+                    lines = p.stdout.readlines()
+                    freq = lines[0][:-1].split(':')[-1].split('.')[0].strip()
+                    nb_proc = len(lines) -1
+                    memory = lines[-1].split(':')[-1].split()[0].strip()
+                    memory = int(memory) / 1000
+
+            catalog.write("    <machine\n")
+            catalog.write("        protocol=\"ssh\"\n")
+            catalog.write("        nbOfNodes=\"1\"\n")
+            catalog.write("        mode=\"interactif\"\n")
+            catalog.write("        OS=\"LINUX\"\n")
+
+            if (not src.architecture.is_windows()) and machine_access :
+                catalog.write("        CPUFreqMHz=\"%s\"\n" % freq)
+                catalog.write("        nbOfProcPerNode=\"%s\"\n" % nb_proc)
+                catalog.write("        memInMB=\"%s\"\n" % memory)
+
+            catalog.write("        userName=\"%s\"\n" % user)
+            catalog.write("        name=\"%s\"\n" % k)
+            catalog.write("        hostname=\"%s\"\n" % k)
+            catalog.write("    >\n")
+            catalog.write("    </machine>\n")
+
+        catalog.write("</resources>\n")
     return catfile
 
 def copy_catalog(config, catalog_path):
@@ -347,6 +308,14 @@ def run(args, runner, logger):
     src.check_config_has_application( runner.cfg )
     
     # Determine the launcher name (from option, profile section or by default "salome")
+    if options.products is None:
+        environ_info = None
+    else:
+        # add products specified by user (only products 
+        # included in the application)
+        environ_info = filter(lambda l:
+                              l in runner.cfg.APPLICATION.products.keys(),
+                              options.products)
     if options.name:
         launcher_name = options.name
     else:
@@ -375,21 +344,18 @@ def run(args, runner, logger):
     if options.use_mesa:
         src.activate_mesa_property(runner.cfg)
 
+    # option -e has precedence over section profile
+    if not options.path_exe and src.get_launcher_exe(runner.cfg):
+        options.path_exe=src.get_launcher_exe(runner.cfg)
+
     # Generate the launcher
-    if options.path_exe:
-        generate_exe_launch_file(runner.cfg,
-                                 logger,
-                                 launcher_name,
-                                 launcher_path,
-                                 options.path_exe,
-                                 additional_env = additional_environ,
-                                 no_path_init = no_path_initialisation )
-    else:
-        launcherPath = generate_launch_file(runner.cfg,
-                                            logger,
-                                            launcher_name,
-                                            launcher_path,
-                                            additional_env = additional_environ,
-                                            no_path_init = no_path_initialisation )
+    generate_launch_file(runner.cfg,
+                         logger,
+                         launcher_name,
+                         launcher_path,
+                         options.path_exe,
+                         additional_env = additional_environ,
+                         env_info=environ_info,
+                         no_path_init = no_path_initialisation )
 
     return 0