commands/job.py

   1 #!/usr/bin/env python
   2 #-*- coding:utf-8 -*-
   3 #  Copyright (C) 2010-2012  CEA/DEN
   4 #
   5 #  This library is free software; you can redistribute it and/or
   6 #  modify it under the terms of the GNU Lesser General Public
   7 #  License as published by the Free Software Foundation; either
   8 #  version 2.1 of the License.
   9 #
  10 #  This library is distributed in the hope that it will be useful,
  11 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 #  Lesser General Public License for more details.
  14 #
  15 #  You should have received a copy of the GNU Lesser General Public
  16 #  License along with this library; if not, write to the Free Software
  17 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18
  19 import os
  20
  21 import src
  22 import src.salomeTools
  23
  24 # Define all possible option for the make command :  sat make <options>
  25 parser = src.options.Options()
  26 parser.add_option('j', 'jobs_config', 'string', 'jobs_cfg',
  27                   _('Mandatory: The name of the config file that contains'
  28                   ' the jobs configuration'))
  29 parser.add_option('', 'name', 'string', 'job',
  30     _('Mandatory: The job name from which to execute commands.'), "")
  31
  32 def description():
  33     '''method that is called when salomeTools is called with --help option.
  34
  35     :return: The text to display for the job command description.
  36     :rtype: str
  37     '''
  38     return _("""\
  39 The job command executes the commands of the job defined in the jobs configuration file
  40
  41 example:
  42 >> sat job --jobs_config my_jobs --name my_job
  43 """)
  44
  45 def run(args, runner, logger):
  46     '''method that is called when salomeTools is called with job parameter.
  47     '''
  48
  49     # Parse the options
  50     (options, args) = parser.parse_args(args)
  51
  52     l_cfg_dir = runner.cfg.PATHS.JOBPATH
  53
  54     # Make sure the jobs_config option has been called
  55     if not options.jobs_cfg:
  56         message = _("The option --jobs_config is required\n")
  57         logger.write(src.printcolors.printcError(message))
  58         return 1
  59
  60     # Make sure the name option has been called
  61     if not options.job:
  62         message = _("The option --name is required\n")
  63         logger.write(src.printcolors.printcError(message))
  64         return 1
  65
  66     # Find the file in the directories
  67     found = False
  68     for cfg_dir in l_cfg_dir:
  69         file_jobs_cfg = os.path.join(cfg_dir, options.jobs_cfg)
  70         if not file_jobs_cfg.endswith('.pyconf'):
  71             file_jobs_cfg += '.pyconf'
  72
  73         if not os.path.exists(file_jobs_cfg):
  74             continue
  75         else:
  76             found = True
  77             break
  78
  79     if not found:
  80         msg = _("The file configuration %(name_file)s was not found."
  81                 "\nUse the --list option to get the possible files.")
  82         src.printcolors.printcError(msg)
  83         return 1
  84
  85     info = [
  86     (_("Platform"), runner.cfg.VARS.dist),
  87     (_("File containing the jobs configuration"), file_jobs_cfg)
  88     ]
  89     src.print_info(logger, info)
  90
  91     # Read the config that is in the file
  92     config_jobs = src.read_config_from_a_file(file_jobs_cfg)
  93
  94     # Find the job and its commands
  95     found = False
  96     for job in config_jobs.jobs:
  97         if job.name == options.job:
  98             commands = job.commands
  99             found = True
 100             break
 101     if not found:
 102         msg = _("Impossible to find the job \"%(job_name)s\" in "
 103                 "%(jobs_config_file)s" % {"job_name" : options.job,
 104                                           "jobs_config_file" : file_jobs_cfg})
 105         logger.write(src.printcolors.printcError(msg) + "\n")
 106         return 1
 107
 108     # Find the maximum length of the commands in order to format the display
 109     len_max_command = max([len(cmd) for cmd in commands])
 110
 111     # Loop over the commands and execute it
 112     res = 0
 113     nb_pass = 0
 114     for command in commands:
 115         specific_option = False
 116         # Determine if it is a sat command or a shell command
 117         cmd_exe = command.split(" ")[0] # first part
 118         if cmd_exe == "sat":
 119             # use the salomeTools parser to get the options of the command
 120             sat_parser = src.salomeTools.parser
 121             input_parser = src.remove_item_from_list(command.split(' ')[1:], "")
 122             (options, argus) = sat_parser.parse_args(input_parser)
 123             # Verify if there is a changed option
 124             for attr in dir(options):
 125                 if attr.startswith("__"):
 126                     continue
 127                 if options.__getattr__(attr) != None:
 128                     specific_option = True
 129             sat_command_name = argus[0]
 130             end_cmd = " ".join(argus[1:])
 131         else:
 132             sat_command_name = "shell"
 133             end_cmd = ["--command", command]
 134         # Do not change the options if no option was called in the command
 135         if not(specific_option):
 136             options = None
 137
 138         # Get dynamically the command function to call
 139         sat_command = runner.__getattr__(sat_command_name)
 140
 141         logger.write("Executing " +
 142                      src.printcolors.printcLabel(command) + " ", 3)
 143         logger.write("." * (len_max_command - len(command)) + " ", 3)
 144         logger.flush()
 145
 146         error = ""
 147         stack = ""
 148         # Execute the command
 149         code = sat_command(end_cmd,
 150                            options = options,
 151                            batch = True,
 152                            verbose = 0,
 153                            logger_add_link = logger)
 154
 155         # Print the status of the command
 156         if code == 0:
 157             nb_pass += 1
 158             logger.write('%s\n' % src.printcolors.printc(src.OK_STATUS), 3)
 159         else:
 160             if sat_command_name != "test":
 161                 res = 1
 162             logger.write('%s %s\n' % (src.printcolors.printc(src.KO_STATUS),
 163                                       error), 3)
 164             if len(stack) > 0:
 165                 logger.write('stack: %s\n' % stack, 3)
 166
 167     # Print the final state
 168     if res == 0:
 169         final_status = "OK"
 170     else:
 171         final_status = "KO"
 172
 173     logger.write(_("\nCommands: %(status)s (%(valid_result)d/%(nb_products)d)\n") % \
 174         { 'status': src.printcolors.printc(final_status),
 175           'valid_result': nb_pass,
 176           'nb_products': len(commands) }, 3)
 177
 178     return res