_("Optional: list all available applications."))
parser.add_option('', 'show_patchs', 'boolean', 'show_patchs',
_("Optional: synthetic list of all patches used in the application"))
+parser.add_option('', 'show_dependencies', 'boolean', 'show_dependencies',
+ _("Optional: list of product dependencies in the application"))
parser.add_option('', 'show_install', 'boolean', 'show_install',
_("Optional: synthetic list of all install directories in the application"))
parser.add_option('', 'show_properties', 'boolean', 'show_properties',
_("Optional: synthetic list of all properties used in the application"))
+parser.add_option('', 'check_system', 'boolean', 'check_system',
+ _("Optional: check if system products are installed"))
parser.add_option('c', 'copy', 'boolean', 'copy',
_("""Optional: copy a config file to the personal config files directory.
WARNING: the included files are not copied.
cfg.LOCAL.archive_dir = os.path.abspath( osJoin(cfg.VARS.salometoolsway, "..", "ARCHIVES"))
# if the sat tag was not set permanently by user
- if cfg.LOCAL.tag == None:
+ if cfg.LOCAL.tag == "unknown":
# get the tag with git, and store it
sat_version=src.system.git_describe(cfg.VARS.salometoolsway)
if sat_version == False:
"LICENCEPATH"]:
if PATH not in cfg.PROJECTS.projects[project]:
continue
- cfg.PATHS[PATH].append(cfg.PROJECTS.projects[project][PATH], "")
+ pathlist=cfg.PROJECTS.projects[project][PATH].split(":")
+ for path in pathlist:
+ cfg.PATHS[PATH].append(path, "")
# apply overwrite from command line if needed
for rule in self.get_command_line_overrides(options, ["PATHS"]):
if "opt_depend" in pinfo:
src.printcolors.print_value(logger, "optional", sorted(pinfo.opt_depend), 2)
+ if "build_depend" in pinfo:
+ src.printcolors.print_value(logger, "build depend on", sorted(pinfo.build_depend), 2)
+
+
# information on pyconf
logger.write("\n", 2)
logger.write(src.printcolors.printcLabel("configuration:") + "\n", 2)
logger.write(" " +
src.printcolors.printcWarning(_("no install dir")) +
"\n", 2)
+
+ src.printcolors.print_value(logger, "debug ", pinfo.debug, 2)
+ src.printcolors.print_value(logger, "verbose ", pinfo.verbose, 2)
+ src.printcolors.print_value(logger, "hpc ", pinfo.hpc, 2)
+ src.printcolors.print_value(logger, "dev ", pinfo.dev, 2)
+
else:
logger.write("\n", 2)
msg = _("This product does not compile")
else:
logger.write("No patchs found\n", 1)
+def check_install_system(config, logger):
+ '''Check the installation of all (declared) system products
+
+ :param config Config: the global configuration.
+ :param logger Logger: The logger instance to use for the display
+ '''
+ # get the command to use for checking the system dependencies
+ # (either rmp or apt)
+ check_cmd=src.system.get_pkg_check_cmd(config.VARS.dist_name)
+ logger.write("\nCheck the system dependencies declared in the application\n",1)
+ pkgmgr=check_cmd[0]
+ run_dep_ko=[] # list of missing run time dependencies
+ build_dep_ko=[] # list of missing compile time dependencies
+ for product in sorted(config.APPLICATION.products):
+ try:
+ product_info = src.product.get_product_config(config, product)
+ if src.product.product_is_native(product_info):
+ # if the product is native, get (in two dictionnaries the runtime and compile time
+ # system dependencies with the status (OK/KO)
+ run_pkg,build_pkg=src.product.check_system_dep(config.VARS.dist, check_cmd, product_info)
+ #logger.write("\n*** %s ***\n" % product, 1)
+ for pkg in run_pkg:
+ logger.write("\n - "+pkg + " : " + run_pkg[pkg], 1)
+ if "KO" in run_pkg[pkg]:
+ run_dep_ko.append(pkg)
+ for pkg in build_pkg:
+ logger.write("\n - "+pkg + " : " + build_pkg[pkg], 1)
+ if "KO" in build_pkg[pkg]:
+ build_dep_ko.append(pkg)
+ # logger.write(src.printcolors.printcInfo(" %s\n" % i), 1)
+
+ except Exception as e:
+ msg = "\nproblem with the check of system prerequisite %s\n%s\n" % (product, str(e))
+ logger.error(msg)
+ raise Exception(msg)
+
+ logger.write("\n\n",1)
+ if run_dep_ko:
+ msg="Some run time system dependencies are missing!\n"+\
+ "Please install them with %s before running salome" % pkgmgr
+ logger.warning(msg)
+ logger.write("missing run time dependencies : ",1)
+ for md in run_dep_ko:
+ logger.write(md+" ",1)
+ logger.write("\n\n")
+
+ if build_dep_ko:
+ msg="Some compile time system dependencies are missing!\n"+\
+ "Please install them with %s before compiling salome" % pkgmgr
+ logger.warning(msg)
+ logger.write("missing compile time dependencies : ",1)
+ for md in build_dep_ko:
+ logger.write(md+" ",1)
+ logger.write("\n\n")
+
+def show_dependencies(config, products, logger):
+ '''Prints dependencies of products in the application.
+
+ :param config Config: the global configuration.
+ :param logger Logger: The logger instance to use for the display
+ '''
+
+ from compile import get_dependencies_graph,depth_search_graph,find_path_graph
+ # Get the list of all application products, and create its dependency graph
+ all_products_infos = src.product.get_products_infos(config.APPLICATION.products,config)
+ all_products_graph=get_dependencies_graph(all_products_infos, compile_time=False)
+
+ products_list=[]
+ product_liste_name=""
+ if products is None:
+ products_list=config.APPLICATION.products
+ products_graph = all_products_graph
+ else:
+ # 1. Extend the list with all products that depends upon the given list of products
+ products_list=products
+ product_liste_name="_".join(products)
+ visited=[]
+ for p_name in products_list:
+ visited=depth_search_graph(all_products_graph, p_name, visited)
+ products_infos = src.product.get_products_infos(visited, config)
+ products_graph = get_dependencies_graph(products_infos, compile_time=False)
+
+ # 2. Extend the list with all the dependencies of the given list of products
+ children=[]
+ for n in all_products_graph:
+ # for all products (that are not in products_list):
+ # if we we find a path from the product to the product list,
+ # then we product is a child and we add it to the children list
+ if (n not in children) and (n not in products_list):
+ if find_path_graph(all_products_graph, n, products_list):
+ children = children + [n]
+ products_infos_rev = src.product.get_products_infos(children, config)
+ products_graph_rev = get_dependencies_graph(products_infos_rev, compile_time=False)
+
+ logger.write("Dependency graph (python format)\n%s\n" % products_graph, 3)
+
+ gv_file_name='%s_%s_dep.gv' % (config.VARS.application,product_liste_name)
+ logger.write("\nDependency graph (graphviz format) written in file %s\n" %
+ src.printcolors.printcLabel(gv_file_name), 3)
+ with open(gv_file_name,"w") as f:
+ f.write("digraph G {\n")
+ for p in products_graph:
+ for dep in products_graph[p]:
+ f.write ("\t%s -> %s\n" % (p,dep))
+ f.write("}\n")
+
+
+ if products is not None:
+ # if a list of products was given, produce also the reverse dependencies
+ gv_revfile_name='%s_%s_rev_dep.gv' % (config.VARS.application,product_liste_name)
+ logger.write("\nReverse dependency graph (graphviz format) written in file %s\n" %
+ src.printcolors.printcLabel(gv_revfile_name), 3)
+ with open(gv_revfile_name,"w") as rf:
+ rf.write("digraph G {\n")
+ for p in products_graph_rev:
+ for dep in products_graph_rev[p]:
+ rf.write ("\t%s -> %s\n" % (p,dep))
+ rf.write("}\n")
+
+ graph_cmd = "dot -Tpdf %s -o %s.pdf" % (gv_file_name,gv_file_name)
+ logger.write("\nTo generate a graph use dot tool : \n %s" %
+ src.printcolors.printcLabel(graph_cmd), 3)
+
def show_install_dir(config, logger):
'''Prints all the used installed directories in the application.
logger.write("\n", 2, False)
show_install_dir(runner.cfg, logger)
+ # case : give a synthetic view of all dependencies between products of the application
+ if options.show_dependencies:
+ src.check_config_has_application(runner.cfg)
+ # Print some informations
+ logger.write(_('List of run-time dependencies of the application %s, product by product\n') %
+ src.printcolors.printcLabel(runner.cfg.VARS.application), 3)
+ logger.write("\n", 2, False)
+ show_dependencies(runner.cfg, options.products, logger)
+
# case : give a synthetic view of all patches used in the application
if options.show_properties:
src.check_config_has_application(runner.cfg)
logger.write("\n", 2, False)
show_properties(runner.cfg, logger)
+ # check system prerequisites
+ if options.check_system:
+ check_install_system(runner.cfg, logger)
+ pass
