import stat
import src
+import src.debug as DBG
parser = src.options.Options()
_("Optional: Create a resources catalog for the specified machines "
"(separated with ',') \n\tNOTICE: this command will ssh to retrieve"
" information to each machine in the list"))
+parser.add_option('', 'use_mesa', 'boolean', 'use_mesa',
+ _("Optional: Create a launcher that will use mesa products\n\t"
+ "It can be usefull whan salome is used on a remote machine through ssh"))
def generate_launch_file(config,
logger,
- env_info=None,
- pathlauncher=None,
+ launcher_name,
+ pathlauncher,
display=True,
additional_env={}):
'''Generates the launcher file.
:param config Config: The global configuration
:param logger Logger: The logger instance to use for the display
and logging
- :param env_info str: The list of products to add in the files.
+ :param launcher_name str: The name of the launcher to generate
:param pathlauncher str: The path to the launcher to generate
- :param src_root str: The path to the directory where the sources are
: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
'''
- # Get the application directory and the profile directory
- out_dir = config.APPLICATION.workdir
- profile = config.APPLICATION.profile
- profile_install_dir = get_profile_dir(config)
# Compute the default launcher path if it is not provided in pathlauncher
# parameter
- if pathlauncher is None:
- if platform.system() == "Windows" :
- filepath = os.path.join( os.path.join( profile_install_dir,
- 'bin',
- 'salome' ),
- profile['launcher_name'] )
- else:
- filepath = os.path.join( out_dir,
- profile['launcher_name'] )
- else:
- filepath = os.path.join(pathlauncher, profile['launcher_name'])
+ filepath = os.path.join(pathlauncher, launcher_name)
# Remove the file if it exists in order to replace it
if os.path.exists(filepath):
# Add the APPLI variable
additional_env['APPLI'] = filepath
- # Get the launcher template
- withProfile = src.fileEnviron.withProfile.replace( "PROFILE_INSTALL_DIR",
- profile_install_dir )
- before, after = withProfile.split(
- "# here your local standalone environment\n")
+
+
+ # 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(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")
+
+ # 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
+ 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:
+ app_root_dir=salome_application_name
+
+ # Get the launcher template (python3 or python2)
+ if "python3" in config.APPLICATION and config.APPLICATION.python3 == "yes":
+ withProfile = src.fileEnviron.withProfile3\
+ .replace("BIN_KERNEL_INSTALL_DIR", bin_kernel_install_dir)\
+ .replace("KERNEL_INSTALL_DIR", app_root_dir)
+ else:
+ withProfile = src.fileEnviron.withProfile\
+ .replace("BIN_KERNEL_INSTALL_DIR", bin_kernel_install_dir)\
+ .replace("KERNEL_INSTALL_DIR", app_root_dir)
+
+ before, after = withProfile.split("# here your local standalone environment\n")
# create an environment file writer
writer = src.environment.FileEnvWriter(config,
logger,
- out_dir,
+ pathlauncher,
src_root=None,
- env_info=env_info)
+ env_info=None)
# Display some information
if display:
stat.S_IXOTH)
return filepath
-def generate_launch_link(config,
- logger,
- launcherPath,
- pathlauncher=None,
- display=True,
- packageLauncher=False):
- '''Generates the launcher link that sources Python
- and call the actual launcher.
-
- :param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
- and logging
- :param launcherPath str: The path to the launcher to call
- :param pathlauncher str: The path to the launcher (link) to generate
- :param display boolean: If False, do not print anything in the terminal
- :param packageLauncher boolean: if True, use a relative path (for package)
- :return: The launcher link file path.
- :rtype: str
- '''
- if pathlauncher is None:
- # Make an executable file that sources python, then launch the launcher
- # produced by generate_launch_file method
- sourceLauncher = os.path.join(config.APPLICATION.workdir,
- config.APPLICATION.profile.launcher_name)
- else:
- sourceLauncher = os.path.join(pathlauncher,
- config.APPLICATION.profile.launcher_name)
-
- # Change the extension for the windows case
- if platform.system() == "Windows" :
- sourceLauncher += '.bat'
-
- # display some information
- if display:
- logger.write(_("\nGenerating the executable that sources"
- " python and runs the launcher :\n") , 1)
- logger.write(" %s\n" %src.printcolors.printcLabel(sourceLauncher), 1)
-
- # open the file to write
- f = open(sourceLauncher, "w")
-
- # Write the set up of the environment
- if platform.system() == "Windows" :
- shell = 'bat'
- else:
- shell = 'bash'
-
- # Write the Python environment files
- env = src.environment.SalomeEnviron( config,
- src.fileEnviron.get_file_environ( f, shell, config ) )
- env.set_a_product( "Python", logger)
-
- # Write the call to the original launcher
- f.write( "\n\n")
- if packageLauncher:
- cmd = os.path.join('${out_dir_Path}', launcherPath)
- else:
- cmd = launcherPath
-
- if platform.system() == "Windows" :
- cmd = 'python ' + cmd + ' %*'
- else:
- cmd = cmd + ' $*'
-
- f.write( cmd )
- f.write( "\n\n")
-
- # Write the cleaning of the environment
- env.finish(True)
-
- # Close new launcher
- f.close()
- os.chmod(sourceLauncher,
- stat.S_IRUSR |
- stat.S_IRGRP |
- stat.S_IROTH |
- stat.S_IWUSR |
- stat.S_IWGRP |
- stat.S_IWOTH |
- stat.S_IXUSR |
- stat.S_IXGRP |
- stat.S_IXOTH)
- return sourceLauncher
def generate_catalog(machines, config, logger):
"""Generates an xml catalog file from a list of machines.
# Write into it
catalog.write("<!DOCTYPE ResourcesCatalog>\n<resources>\n")
for k in machines:
- 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()
-
- if p.returncode != 0: # 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():
+ 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(" 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()
# Verify the existence of the file
if not os.path.exists(catalog_path):
raise IOError(_("Catalog not found: %s") % catalog_path)
- # Compute the location where to copy the file
- profile_dir = get_profile_dir(config)
- new_catalog_path = os.path.join(profile_dir, "CatalogResources.xml")
+ # Get the application directory and copy catalog inside
+ out_dir = config.APPLICATION.workdir
+ new_catalog_path = os.path.join(out_dir, "CatalogResources.xml")
# Do the copy
shutil.copy(catalog_path, new_catalog_path)
additional_environ = {'USER_CATALOG_RESOURCES_FILE' : new_catalog_path}
return additional_environ
-def get_profile_dir(config):
- """Get the profile directory from the config
-
- :param config Config: The global configuration
- :return: The profile install directory
- :rtype: Str
- """
- profile_name = config.APPLICATION.profile.product
- profile_info = src.product.get_product_config(config, profile_name)
- return profile_info.install_dir
-
-def finish_profile_install(config, launcherPath):
- """Add some symlinks required for SALOME
-
- :param config Config: The global configuration
- :param launcherPath str: the launcher file path
- """
- # Create a USERS directory
- profile_dir = get_profile_dir(config)
- user_dir = os.path.join(profile_dir, 'USERS')
- if not os.path.exists(user_dir):
- os.makedirs(user_dir)
- # change rights of USERS directory
- os.chmod(user_dir,
- stat.S_IRUSR |
- stat.S_IRGRP |
- stat.S_IROTH |
- stat.S_IWUSR |
- stat.S_IWGRP |
- stat.S_IWOTH |
- stat.S_IXUSR |
- stat.S_IXGRP |
- stat.S_IXOTH)
- # create a link in root directory to the launcher
- if platform.system() != "Windows" :
- link_path = os.path.join(config.APPLICATION.workdir, 'salome')
- if not os.path.exists(link_path):
- try:
- os.symlink(launcherPath, link_path)
- except OSError:
- os.remove(link_path)
- os.symlink(launcherPath, link_path)
-
- link_path = os.path.join(profile_dir, 'salome')
- relativeLauncherPath = "../../salome"
- try:
- os.symlink(relativeLauncherPath, link_path)
- except OSError:
- os.remove(link_path)
- os.symlink(relativeLauncherPath, link_path)
##################################################
# Verify that the command was called with an application
src.check_config_has_application( runner.cfg )
- # Verify that the APPLICATION section has a profile section
- src.check_config_has_profile( runner.cfg )
-
- # Verify that the profile is installed
- if not src.product.check_installation(
- src.product.get_product_config(
- runner.cfg,
- runner.cfg.APPLICATION.profile.product)):
- msg = _("The profile of the application is not correctly installed.")
- logger.write(src.printcolors.printcError(msg), 1)
- return 1
-
- # Change the name of the file to create
- # if the corresponding option was called
+ # Determine the launcher name (from option, profile section or by default "salome")
if options.name:
- runner.cfg.APPLICATION.profile['launcher_name'] = options.name
+ launcher_name = options.name
+ else:
+ launcher_name = src.get_launcher_name(runner.cfg)
+
+ # set the launcher path
+ launcher_path = runner.cfg.APPLICATION.workdir
# Copy a catalog if the option is called
additional_environ = {}
logger)
additional_environ = copy_catalog(runner.cfg, catalog_path)
+ # activate mesa use in the generated launcher
+ if options.use_mesa:
+ src.activate_mesa_property(runner.cfg)
+
# Generate the launcher
launcherPath = generate_launch_file( runner.cfg,
logger,
+ launcher_name,
+ launcher_path,
additional_env = additional_environ )
- if platform.system() == "Windows" :
- # Create the link (bash file that sources python and then call
- # the actual launcher) to the launcher
- generate_launch_link( runner.cfg, logger, launcherPath)
-
- # Add some links
- finish_profile_install(runner.cfg, launcherPath)
-
return 0