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