from src import ElementTree as etree
import src
+from src.versionMinorMajorPatch import MinorMajorPatch as MMP
parser = src.options.Options()
parser.add_option('n', 'name', 'string', 'name',
- _('The name of the application (default is APPLI.name or runAppli)'))
+ _('Optional: The name of the application (default is APPLICATION.virtual_app.name or '
+ 'runAppli)'))
parser.add_option('c', 'catalog', 'string', 'catalog',
- _('The resources catalog to use'))
+ _('Optional: The resources catalog to use'))
parser.add_option('t', 'target', 'string', 'target',
- _('The directory where to create the application (default is PRODUCT.out_dir)'))
+ _('Optional: The directory where to create the application (default is '
+ 'APPLICATION.workdir)'))
parser.add_option('', 'gencat', 'string', 'gencat',
- _("""Create a resources catalog for the specified machines (separated with ',')
-\tNOTICE: this command will ssh to retrieve information to each machine in the list"""))
+ _("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('m', 'module', 'list2', 'modules',
- _("module(s) to include in the application"))
+ _("Optional: the restricted list of module(s) to include in the "
+ "application"))
+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"))
##
# Creates an alias for runAppli.
##
# Creates the config file to create an application with the list of modules.
-def create_config_file(config, modules, env_file, logger):
- if len(modules) == 0:
- modules = config.APPLICATION.products
+def create_config_file(config, modules, env_files, logger):
samples = ""
if 'SAMPLES' in config.APPLICATION.products:
f = open(config_file, "w")
f.write('<application>\n')
- f.write('<prerequisites path="%s"/>\n' % env_file)
+ for env_file in env_files:
+ if env_file.endswith("cfg"):
+ f.write('<context path="%s"/>\n' % env_file)
+ else:
+ f.write('<prerequisites path="%s"/>\n' % env_file)
+
f.write('<resources path="CatalogResources.xml"/>\n')
f.write('<modules>\n')
flagline = False
for m in modules:
mm = src.product.get_product_config(config, m)
- if src.product.module_is_smesh_plugin(mm):
+ # do not include in virtual application application module!
+ if src.get_property_in_product_cfg(mm, "is_salome_application") == "yes":
+ continue
+ # do not include products that do not compile
+ if not src.product.product_compiles(mm):
+ continue
+ #obsolete?
+ if src.product.product_is_smesh_plugin(mm):
continue
- if 'install_dir' in mm and bool(mm.install_dir) :
- if src.product.module_is_cpp(mm):
+ if 'install_dir' in mm and bool(mm.install_dir):
+ if src.product.product_is_cpp(mm):
# cpp module
for aa in src.product.get_product_components(mm):
- install_dir = os.path.join(config.APPLICATION.workdir,
- "INSTALL")
+ install_dir=os.path.join(config.APPLICATION.workdir,
+ config.INTERNAL.config.install_dir)
mp = os.path.join(install_dir, aa)
flagline = add_module_to_appli(f,
aa,
##
# Customizes the application by editing SalomeApp.xml.
def customize_app(config, appli_dir, logger):
- if 'configure' not in config.APPLI \
- or len(config.APPLI.configure) == 0:
+ if 'configure' not in config.APPLICATION.virtual_app \
+ or len(config.APPLICATION.virtual_app.configure) == 0:
return
# shortcut to get an element (section or parameter) from parent.
assert document is not None, "document tag not found"
logger.write("\n", 4)
- for section_name in config.APPLI.configure:
- for parameter_name in config.APPLI.configure[section_name]:
- parameter_value = config.APPLI.configure[section_name][parameter_name]
+ for section_name in config.APPLICATION.virtual_app.configure:
+ for parameter_name in config.APPLICATION.virtual_app.configure[section_name]:
+ parameter_value = config.APPLICATION.virtual_app.configure[section_name][parameter_name]
logger.write(" configure: %s/%s = %s\n" % (section_name,
parameter_name,
parameter_value), 4)
script = os.path.join(install_KERNEL_dir, "bin", "salome", "appli_gen.py")
if not os.path.exists(script):
raise src.SatException(_("KERNEL is not installed"))
-
- # Add SALOME python in the environment in order to avoid python version
+
+ # Add SALOME python in the environment in order to avoid python version
# problems at appli_gen.py call
- if 'Python' in config.APPLICATIONS.products:
+ if 'Python' in config.APPLICATION.products:
envi = src.environment.SalomeEnviron(config,
src.environment.Environ(
dict(os.environ)),
True)
envi.set_a_product('Python', logger)
-
+
command = "python %s --prefix=%s --config=%s" % (script,
appli_dir,
config_file)
shell=True,
cwd=target_dir,
env=envi.environ.environ,
- stdout=logger.log_file,
+ stdout=logger.logTxtFile,
stderr=subprocess.STDOUT)
-
+
if res != 0:
raise src.SatException(_("Cannot create application, code = %d\n") % res)
##
# Creates a SALOME application.
def create_application(config, appli_dir, catalog, logger, display=True):
-
- # check modules to add to installation
- modules = []
- if 'modules' in config.APPLI:
- modules = config.APPLI.modules
- # add prerequisites for the module and its dependencies
- products = {}
- for module in modules:
- prelist = config.TOOLS.common.module_info[module].pre_depend
- for prereq in prelist:
- # add prerequisites define in module_info AND product.prerequis
- if prereq in config.PRODUCT.prerequis and not prerequis.has_key(prereq):
- prerequis[prereq] = config.PRODUCT.prerequis[prereq]
-
- if len(modules) == 0:
- modules = src.get_cfg_param(config.PRODUCT, "all_modules", config.PRODUCT.modules)
- prerequis = config.PRODUCT.prerequis
-
- env_info = { 'modules': modules, 'prerequis': prerequis }
-
- cmd_old, cmd_new = "", ""
+
+ SALOME_modules = get_SALOME_modules(config)
warn = ['KERNEL', 'GUI']
if display:
for w in warn:
- if w not in env_info['modules']:
+ if w not in SALOME_modules:
msg = _("WARNING: module %s is required to create application\n") % w
logger.write(src.printcolors.printcWarning(msg), 2)
- # old way for application
- retcode = generate_launch_file_old(config, appli_dir, catalog, logger, env_info=env_info)
- if retcode == 0:
- cmd_old = src.printcolors.printcLabel("%s/runAppli" % appli_dir)
+ # generate the launch file
+ retcode = generate_launch_file(config,
+ appli_dir,
+ catalog,
+ logger,
+ SALOME_modules)
- # new way for application
- VersionSalome = src.get_salome_version(config)
-
- if VersionSalome >= 751 :
- filename = generate_launch_file(config, appli_dir, catalog, logger, env_info)
- cmd_new = src.printcolors.printcLabel(filename)
+ if retcode == 0:
+ cmd = src.printcolors.printcLabel("%s/salome" % appli_dir)
if display:
logger.write("\n", 3, False)
logger.write(_("To launch the application, type:\n"), 3, False)
- if len(cmd_old) > 0:
- logger.write(" %s" % (cmd_old), 3, False)
- logger.write("\n", 3, False)
- if len(cmd_new) > 0:
- logger.write(" %s (%s)" % (cmd_new, _("new command")), 3, False)
- logger.write("\n", 3, False)
+ logger.write(" %s" % (cmd), 3, False)
+ logger.write("\n", 3, False)
return retcode
+def get_SALOME_modules(config):
+ l_modules = []
+ for product in config.APPLICATION.products:
+ product_info = src.product.get_product_config(config, product)
+ if (src.product.product_is_salome(product_info) or
+ src.product.product_is_generated(product_info)):
+ l_modules.append(product)
+ return l_modules
+
##
# Obsolescent way of creating the application.
# This method will use appli_gen to create the application directory.
-def generate_launch_file_old(config, appli_dir, catalog, logger, env_info=None):
+def generate_launch_file(config, appli_dir, catalog, logger, l_SALOME_modules):
retcode = -1
if len(catalog) > 0 and not os.path.exists(catalog):
raise IOError(_("Catalog not found: %s") % catalog)
-
+
write_step(logger, _("Creating environment files"))
status = src.KO_STATUS
+
+ # build the application (the name depends upon salome version
+ env_file = os.path.join(config.APPLICATION.workdir, "env_launch")
+ VersionSalome = src.get_salome_version(config)
+ if VersionSalome>=MMP([8,2,0]):
+ # for salome 8+ we use a salome context file for the virtual app
+ app_shell=["cfg", "bash"]
+ env_files=[env_file+".cfg", env_file+".sh"]
+ else:
+ app_shell=["bash"]
+ env_files=[env_file+".sh"]
+
try:
import environ
# generate only shells the user wants (by default bash, csh, batch)
- # the environ command will only generate file compatible with the current system.
- shells = src.get_cfg_param(config.TOOLS.environ,
- "shells",
- [ "bash", "batch"])
+ # the environ command will only generate file compatible
+ # with the current system.
environ.write_all_source_files(config,
logger,
- silent=True,
- shells=shells)
+ shells=app_shell,
+ silent=True)
status = src.OK_STATUS
finally:
logger.write(src.printcolors.printc(status) + "\n", 2, False)
- # build the application
- env_file = os.path.join(config.PRODUCT.out_dir, "env_launch.sh")
+
write_step(logger, _("Building application"), level=2)
- cf = create_config_file(config, env_info['modules'], env_file, logger)
+ cf = create_config_file(config, l_SALOME_modules, env_files, logger)
# create the application directory
os.makedirs(appli_dir)
return retcode
-##
-# Generates a launcher that sources Salome's python and calls original launcher
-def generate_sourcing_launcher(config, appli_dir, logger) :
-
- # Rename original launcher
- launcher_name = os.path.join( appli_dir,
- "bin",
- "salome",
- config.APPLI.launch_alias_name )
- original_launcher = launcher_name + "-original"
- os.rename( launcher_name, original_launcher )
-
- # Open new launcher
- f = open(launcher_name, "w")
-
- # Write the set up of the environment
- env = src.environment.SalomeEnviron( config,
- src.fileEnviron.get_file_environ(
- f,
- "bash",
- {},
- config))
- env.set_a_product( "Python", logger)
-
- # Write the call to the original launcher
- f.write( "\n\n")
- f.write( "# This is the call to the original launcher\n")
- f.write( original_launcher + " $*" )
- f.write( "\n\n")
-
- # Write the cleaning of the environment
- env.finish(True)
-
- # Close new launcher
- f.close()
- os.chmod(launcher_name, stat.S_IRWXU| stat.S_IRWXG| stat.S_IRWXO) # 0777
-
-##
-# New method to create an application
-def generate_launch_file(config,
- appli_dir,
- catalog,
- logger,
- env_info=None):
-
- out_dir = config.PRODUCT.out_dir
-
- basefilename = config.APPLI.name
- if "launch_alias_name" in config.APPLI :
- basefilename = config.APPLI.launch_alias_name
- filename = os.path.join(appli_dir, "bin/salome", basefilename)
- if os.path.exists(filename): os.remove(filename)
- before, after = src.fileEnviron.withProfile.split(
- "# here your local standalone environment\n")
-
- # create an environment file writer
- writer = src.environment.FileEnvWriter(config,
- logger,
- out_dir,
- src_root=None,
- single_dir=False,
- env_info=env_info)
- #writer.silent = False
-
- # create the command file
- launch_file = open(filename, "w")
- launch_file.write(before)
- writer.write_cfgForPy_file(launch_file)
- launch_file.write(after)
- launch_file.close()
- os.chmod(filename, stat.S_IRWXU| stat.S_IRWXG| stat.S_IRWXO) # 0777
-
- # If native python < 2.6, write a launcher that sources Salome's
- # python before calling the original launcher
- if config.VARS.python < "2.6" :
- generate_sourcing_launcher(config, appli_dir, logger)
-
- return filename
-
##
# Generates the catalog from a list of machines.
user = getpass.getuser()
catfile = src.get_tmp_filename(config, "CatalogResources.xml")
- catalog = file(catfile, "w")
- catalog.write("<!DOCTYPE ResourcesCatalog>\n<resources>\n")
- for k in machines:
- logger.write(" ssh %s " % (k + " ").ljust(20, '.'), 4)
- logger.flush()
-
- 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:
- logger.write(src.printcolors.printc(src.KO_STATUS) + "\n", 4)
- logger.write(" " + src.printcolors.printcWarning(p.stderr.read()),
- 2)
- else:
- 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")
- 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:
+ 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()
+
+ 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:
+ logger.write(src.printcolors.printc(src.KO_STATUS) + "\n", 4)
+ logger.write(" " + src.printcolors.printcWarning(p.stderr.read()),
+ 2)
+ else:
+ 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
##################################################
# Describes the command
def description():
'''method that is called when salomeTools is called with --help option.
-
+
:return: The text to display for the application command description.
:rtype: str
'''
- return _("""The application command creates a SALOME application.\n"""
- """WARNING: it works only for SALOME 6. Use the "launcher" """
- """command for newer versions of SALOME""")
+ return _("The application command creates a SALOME application.\n"
+ "WARNING: it works only for SALOME 6. Use the \"launcher\" "
+ "command for newer versions of SALOME\n\nexample:\nsat application"
+ " SALOME-6.6.0")
##
# Runs the command.
'''method that is called when salomeTools is called with application
parameter.
'''
-
+
(options, args) = parser.parse_args(args)
# check for product
application = src.printcolors.printcLabel(runner.cfg.VARS.application)
logger.write(_("Building application for %s\n") % application, 1)
- # if section APPLI does not exists create one
- if "APPLI" not in runner.cfg:
- msg = _("The section APPLI is not defined in the product.")
+ # if section APPLICATION.virtual_app does not exists create one
+ if "virtual_app" not in runner.cfg.APPLICATION:
+ msg = _("The section APPLICATION.virtual_app is not defined in the product. Use sat launcher in state")
logger.write(src.printcolors.printcError(msg), 1)
+ logger.write("\n", 1)
return 1
# get application dir
# set list of modules
if options.modules:
- runner.cfg.APPLI['modules'] = options.modules
+ runner.cfg.APPLICATION.virtual_app['modules'] = options.modules
+
+ # activate mesa use in the generated application
+ if options.use_mesa:
+ src.activate_mesa_property(runner.cfg)
# set name and application_name
if options.name:
- runner.cfg.APPLI['name'] = options.name
- runner.cfg.APPLI['application_name'] = options.name + "_appdir"
-
- application_name = src.get_cfg_param(runner.cfg.APPLI,
+ runner.cfg.APPLICATION.virtual_app['name'] = options.name
+ runner.cfg.APPLICATION.virtual_app['application_name'] = options.name + "_appdir"
+
+ application_name = src.get_cfg_param(runner.cfg.APPLICATION.virtual_app,
"application_name",
- runner.cfg.APPLI.name + "_appdir")
+ runner.cfg.APPLICATION.virtual_app.name + "_appdir")
appli_dir = os.path.join(target_dir, application_name)
src.printcolors.print_value(logger,
catalog_src = options.gencat
catalog = generate_catalog(options.gencat.split(","),
runner.cfg,logger)
- elif 'catalog' in runner.cfg.APPLI:
+ elif 'catalog' in runner.cfg.APPLICATION.virtual_app:
# use catalog specified in the product
- if runner.cfg.APPLI.catalog.endswith(".xml"):
+ if runner.cfg.APPLICATION.virtual_app.catalog.endswith(".xml"):
# catalog as a file
- catalog = runner.cfg.APPLI.catalog
+ catalog = runner.cfg.APPLICATION.virtual_app.catalog
else:
# catalog as a list of computers
- catalog_src = runner.cfg.APPLI.catalog
+ catalog_src = runner.cfg.APPLICATION.virtual_app.catalog
mlist = filter(lambda l: len(l.strip()) > 0,
- runner.cfg.APPLI.catalog.split(","))
+ runner.cfg.APPLICATION.virtual_app.catalog.split(","))
if len(mlist) > 0:
- catalog = generate_catalog(runner.cfg.APPLI.catalog.split(","),
+ catalog = generate_catalog(runner.cfg.APPLICATION.virtual_app.catalog.split(","),
runner.cfg, logger)
# display which catalog is used
logger.write("\n", 3, False)
return retcode
-