1#!/usr/bin/env python
2
3import sys
4import __builtin__
5import subprocess
6import os
7import argparse
8
9# python puts the program's directory path in sys.path[0].  In other words,
10# the user ordinarily has no way to override python's choice of a module from
11# its own dir.  We want to have that ability in our environment.  However, we
12# don't want to break any established python modules that depend on this
13# behavior.  So, we'll save the value from sys.path[0], delete it, import our
14# modules and then restore sys.path to its original value.
15
16save_path_0 = sys.path[0]
17del sys.path[0]
18
19from gen_print import *
20from gen_valid import *
21from gen_arg import *
22from gen_plug_in import *
23from gen_cmd import *
24from gen_misc import *
25
26# Restore sys.path[0].
27sys.path.insert(0, save_path_0)
28# I use this variable in calls to print_var.
29hex = 1
30
31# Create parser object to process command line parameters and args.
32
33# Create parser object.
34parser = argparse.ArgumentParser(
35    usage='%(prog)s [OPTIONS]',
36    description="%(prog)s will process the plug-in packages passed to it."
37                + "  A plug-in package is essentially a directory containing"
38                + " one or more call point programs.  Each of these call point"
39                + " programs must have a prefix of \"cp_\".  When calling"
40                + " %(prog)s, a user must provide a call_point parameter"
41                + " (described below).  For each plug-in package passed,"
42                + " %(prog)s will check for the presence of the specified call"
43                + " point program in the plug-in directory.  If it is found,"
44                + " %(prog)s will run it.  It is the responsibility of the"
45                + " caller to set any environment variables needed by the call"
46                + " point programs.\n\nAfter each call point program"
47                + " has been run, %(prog)s will print the following values in"
48                + " the following formats for use by the calling program:\n"
49                + "  failed_plug_in_name:               <failed plug-in value,"
50                + " if any>\n  shell_rc:                          "
51                + "<shell return code value of last call point program - this"
52                + " will be printed in hexadecimal format.  Also, be aware"
53                + " that if a call point program returns a value it will be"
54                + " shifted left 2 bytes (e.g. rc of 2 will be printed as"
55                + " 0x00000200).  That is because the rightmost byte is"
56                + " reserved for errors in calling the call point program"
57                + " rather than errors generated by the call point program.>",
58    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
59    prefix_chars='-+')
60
61# Create arguments.
62parser.add_argument(
63    'plug_in_dir_paths',
64    nargs='?',
65    default="",
66    help=plug_in_dir_paths_help_text + default_string)
67
68parser.add_argument(
69    '--call_point',
70    default="setup",
71    required=True,
72    help='The call point program name.  This value must not include the'
73         + ' "cp_" prefix.  For each plug-in package passed to this program,'
74         + ' the specified call_point program will be called if it exists in'
75         + ' the plug-in directory.' + default_string)
76
77parser.add_argument(
78    '--allow_shell_rc',
79    default="0x00000000",
80    help='The user may supply a value other than zero to indicate an'
81         + ' acceptable non-zero return code.  For example, if this value'
82         + ' equals 0x00000200, it means that for each plug-in call point that'
83         + ' runs, a 0x00000200 will not be counted as a failure.  See note'
84         + ' above regarding left-shifting of return codes.' + default_string)
85
86parser.add_argument(
87    '--stop_on_plug_in_failure',
88    default=1,
89    type=int,
90    choices=[1, 0],
91    help='If this parameter is set to 1, this program will stop and return '
92         + 'non-zero if the call point program from any plug-in directory '
93         + 'fails.  Conversely, if it is set to false, this program will run '
94         + 'the call point program from each and every plug-in directory '
95         + 'regardless of their return values.  Typical example cases where '
96         + 'you\'d want to run all plug-in call points regardless of success '
97         + 'or failure would be "cleanup" or "ffdc" call points.')
98
99parser.add_argument(
100    '--stop_on_non_zero_rc',
101    default=0,
102    type=int,
103    choices=[1, 0],
104    help='If this parm is set to 1 and a plug-in call point program returns '
105         + 'a valid non-zero return code (see "allow_shell_rc" parm above),'
106         + ' this program will stop processing and return 0 (success).  Since'
107         + ' this constitutes a successful exit, this would normally be used'
108         + ' where the caller wishes to stop processing if one of the plug-in'
109         + ' directory call point programs returns a special value indicating'
110         + ' that some special case has been found.  An example might be in'
111         + ' calling some kind of "check_errl" call point program.  Such a'
112         + ' call point program might return a 2 (i.e. 0x00000200) to indicate'
113         + ' that a given error log entry was found in an "ignore" list and is'
114         + ' therefore to be ignored.  That being the case, no other'
115         + ' "check_errl" call point program would need to be called.'
116         + default_string)
117
118parser.add_argument(
119    '--mch_class',
120    default="obmc",
121    help=mch_class_help_text + default_string)
122
123# The stock_list will be passed to gen_get_options.  We populate it with the
124# names of stock parm options we want.  These stock parms are pre-defined by
125# gen_get_options.
126stock_list = [("test_mode", 0), ("quiet", 1), ("debug", 0)]
127
128
129def exit_function(signal_number=0,
130                  frame=None):
131    r"""
132    Execute whenever the program ends normally or with the signals that we
133    catch (i.e. TERM, INT).
134    """
135
136    dprint_executing()
137    dprint_var(signal_number)
138
139    qprint_pgm_footer()
140
141
142def signal_handler(signal_number, frame):
143    r"""
144    Handle signals.  Without a function to catch a SIGTERM or SIGINT, our
145    program would terminate immediately with return code 143 and without
146    calling our exit_function.
147    """
148
149    # Our convention is to set up exit_function with atexit.registr() so
150    # there is no need to explicitly call exit_function from here.
151
152    dprint_executing()
153
154    # Calling exit prevents us from returning to the code that was running
155    # when we received the signal.
156    exit(0)
157
158
159def validate_parms():
160    r"""
161    Validate program parameters, etc.  Return True or False accordingly.
162    """
163
164    if not valid_value(call_point):
165        return False
166
167    global allow_shell_rc
168    if not valid_integer(allow_shell_rc):
169        return False
170
171    # Convert to hex string for consistency in printout.
172    allow_shell_rc = "0x%08x" % int(allow_shell_rc, 0)
173    set_pgm_arg(allow_shell_rc)
174
175    gen_post_validation(exit_function, signal_handler)
176
177    return True
178
179
180def run_pgm(plug_in_dir_path,
181            call_point,
182            allow_shell_rc):
183    r"""
184    Run the call point program in the given plug_in_dir_path.  Return the
185    following:
186    rc                              The return code - 0 = PASS, 1 = FAIL.
187    shell_rc                        The shell return code returned by
188                                    process_plug_in_packages.py.
189    failed_plug_in_name             The failed plug in name (if any).
190
191    Description of arguments:
192    plug_in_dir_path                The directory path where the call_point
193                                    program may be located.
194    call_point                      The call point (e.g. "setup").  This
195                                    program will look for a program named
196                                    "cp_" + call_point in the
197                                    plug_in_dir_path.  If no such call point
198                                    program is found, this function returns an
199                                    rc of 0 (i.e. success).
200    allow_shell_rc                  The user may supply a value other than
201                                    zero to indicate an acceptable non-zero
202                                    return code.  For example, if this value
203                                    equals 0x00000200, it means that for each
204                                    plug-in call point that runs, a 0x00000200
205                                    will not be counted as a failure.  See
206                                    note above regarding left-shifting of
207                                    return codes.
208    """
209
210    global autoscript
211
212    rc = 0
213    failed_plug_in_name = ""
214    shell_rc = 0x00000000
215
216    plug_in_name = os.path.basename(os.path.normpath(plug_in_dir_path))
217    cp_prefix = "cp_"
218    plug_in_pgm_path = plug_in_dir_path + cp_prefix + call_point
219    if not os.path.exists(plug_in_pgm_path):
220        # No such call point in this plug in dir path.  This is legal so we
221        # return 0, etc.
222        return rc, shell_rc, failed_plug_in_name
223
224    print("------------------------------------------------- Starting plug-"
225          + "in -----------------------------------------------")
226
227    print_timen("Running " + plug_in_name + "/" + cp_prefix + call_point + ".")
228    if autoscript:
229        stdout = 1 - quiet
230        if AUTOBOOT_OPENBMC_NICKNAME != "":
231            autoscript_prefix = AUTOBOOT_OPENBMC_NICKNAME + "."
232        else:
233            autoscript_prefix = ""
234        autoscript_prefix += plug_in_name + ".cp_" + call_point
235        status_dir_path =\
236            add_trailing_slash(os.environ.get("STATUS_DIR_PATH",
237                                              os.environ['HOME']
238                                              + "/autoipl/status/"))
239        status_file_name = autoscript_prefix + "." + file_date_time_stamp() \
240            + ".status"
241        autoscript_subcmd = "autoscript --status_dir_path=" + status_dir_path\
242            + " --status_file_name=" + status_file_name\
243            + " --quiet=1 --show_url=y --prefix=" +\
244            autoscript_prefix + " --stdout=" + str(stdout) + " -- "
245    else:
246        autoscript_subcmd = ""
247
248    cmd_buf = "PATH=" + plug_in_dir_path.rstrip("/") + ":${PATH} ; " +\
249        autoscript_subcmd + cp_prefix + call_point
250    print_issuing(cmd_buf)
251
252    sub_proc = subprocess.Popen(cmd_buf, shell=True)
253    sub_proc.communicate()
254    shell_rc = sub_proc.returncode
255    # Shift to left.
256    shell_rc *= 0x100
257    if shell_rc != 0 and shell_rc != allow_shell_rc:
258        rc = 1
259        failed_plug_in_name = plug_in_name + "/" + cp_prefix + call_point
260    if shell_rc != 0:
261        failed_plug_in_name = plug_in_name + "/" + cp_prefix + call_point
262    if failed_plug_in_name != "" and autoscript and not stdout:
263        shell_cmd("cat " + status_dir_path + status_file_name, quiet=1,
264                  print_output=1)
265
266    print("------------------------------------------------- Ending plug-in"
267          + " -------------------------------------------------")
268    if failed_plug_in_name != "":
269        print_var(failed_plug_in_name)
270    print_var(shell_rc, hex)
271
272    return rc, shell_rc, failed_plug_in_name
273
274
275def main():
276    r"""
277    This is the "main" function.  The advantage of having this function vs
278    just doing this in the true mainline is that you can:
279    - Declare local variables
280    - Use "return" instead of "exit".
281    - Indent 4 chars like you would in any function.
282    This makes coding more consistent, i.e. it's easy to move code from here
283    into a function and vice versa.
284    """
285
286    if not gen_get_options(parser, stock_list):
287        return False
288
289    if not validate_parms():
290        return False
291
292    qprint_pgm_header()
293
294    # Access program parameter globals.
295    global plug_in_dir_paths
296    global mch_class
297    global allow_shell_rc
298    global stop_on_plug_in_failure
299    global stop_on_non_zero_rc
300
301    plug_in_packages_list = return_plug_in_packages_list(plug_in_dir_paths,
302                                                         mch_class)
303
304    qpvar(plug_in_packages_list)
305    qprint("\n")
306
307    allow_shell_rc = int(allow_shell_rc, 0)
308    shell_rc = 0
309    failed_plug_in_name = ""
310
311    # If the autoscript program is present, we will use it to direct call point
312    # program output to a separate status file.  This keeps the output of the
313    # main program (i.e. OBMC Boot Test) cleaner and yet preserves call point
314    # output if it is needed for debug.
315    global autoscript
316    global AUTOBOOT_OPENBMC_NICKNAME
317    autoscript = 0
318    AUTOBOOT_OPENBMC_NICKNAME = ""
319    rc, out_buf = cmd_fnc("which autoscript", quiet=1, print_output=0,
320                          show_err=0)
321    if rc == 0:
322        autoscript = 1
323        AUTOBOOT_OPENBMC_NICKNAME = os.environ.get("AUTOBOOT_OPENBMC_NICKNAME",
324                                                   "")
325    ret_code = 0
326    for plug_in_dir_path in plug_in_packages_list:
327        rc, shell_rc, failed_plug_in_name = \
328            run_pgm(plug_in_dir_path, call_point, allow_shell_rc)
329        if rc != 0:
330            ret_code = 1
331            if stop_on_plug_in_failure:
332                break
333        if shell_rc != 0 and stop_on_non_zero_rc:
334            qprint_time("Stopping on non-zero shell return code as requested"
335                        + " by caller.\n")
336            break
337
338    if ret_code == 0:
339        return True
340    else:
341        print_error("At least one plug-in failed.\n")
342        return False
343
344
345# Main
346
347if not main():
348    exit(1)
349