mbligh | 6203ace | 2007-10-04 21:54:24 +0000 | [diff] [blame] | 1 | #!/usr/bin/python -u |
mbligh | 1ffd5dc | 2008-11-25 13:24:05 +0000 | [diff] [blame] | 2 | # Copyright 2007-2008 Martin J. Bligh <mbligh@google.com>, Google Inc. |
mbligh | 82648e5 | 2008-11-20 16:54:25 +0000 | [diff] [blame] | 3 | # Released under the GPL v2 |
mbligh | dcd57a8 | 2007-07-11 23:06:47 +0000 | [diff] [blame] | 4 | |
mbligh | c8949b8 | 2007-07-23 16:33:58 +0000 | [diff] [blame] | 5 | """ |
Aviv Keshet | de6bb19 | 2013-01-30 16:17:22 -0800 | [diff] [blame] | 6 | Run a control file through the server side engine |
mbligh | dcd57a8 | 2007-07-11 23:06:47 +0000 | [diff] [blame] | 7 | """ |
mbligh | 1ffd5dc | 2008-11-25 13:24:05 +0000 | [diff] [blame] | 8 | |
mbligh | a5f5e54 | 2009-12-30 16:57:49 +0000 | [diff] [blame] | 9 | import sys, os, re, traceback, signal, time, logging, getpass |
mbligh | 1ffd5dc | 2008-11-25 13:24:05 +0000 | [diff] [blame] | 10 | |
mbligh | f5427bb | 2008-04-09 15:55:57 +0000 | [diff] [blame] | 11 | import common |
mbligh | 9ff89cd | 2009-09-03 20:28:17 +0000 | [diff] [blame] | 12 | |
Dan Shi | a1ecd5c | 2013-06-06 11:21:31 -0700 | [diff] [blame] | 13 | from autotest_lib.client.common_lib import control_data |
| 14 | from autotest_lib.client.common_lib import global_config |
| 15 | require_atfork = global_config.global_config.get_config_value( |
mbligh | cb8cb33 | 2009-09-03 21:08:56 +0000 | [diff] [blame] | 16 | 'AUTOSERV', 'require_atfork_module', type=bool, default=True) |
| 17 | |
Dan Shi | a1ecd5c | 2013-06-06 11:21:31 -0700 | [diff] [blame] | 18 | |
mbligh | cb8cb33 | 2009-09-03 21:08:56 +0000 | [diff] [blame] | 19 | try: |
| 20 | import atfork |
| 21 | atfork.monkeypatch_os_fork_functions() |
| 22 | import atfork.stdlib_fixer |
| 23 | # Fix the Python standard library for threading+fork safety with its |
| 24 | # internal locks. http://code.google.com/p/python-atfork/ |
| 25 | import warnings |
| 26 | warnings.filterwarnings('ignore', 'logging module already imported') |
| 27 | atfork.stdlib_fixer.fix_logging_module() |
| 28 | except ImportError, e: |
| 29 | from autotest_lib.client.common_lib import global_config |
| 30 | if global_config.global_config.get_config_value( |
| 31 | 'AUTOSERV', 'require_atfork_module', type=bool, default=False): |
| 32 | print >>sys.stderr, 'Please run utils/build_externals.py' |
| 33 | print e |
| 34 | sys.exit(1) |
mbligh | 9ff89cd | 2009-09-03 20:28:17 +0000 | [diff] [blame] | 35 | |
Dan Shi | a1ecd5c | 2013-06-06 11:21:31 -0700 | [diff] [blame] | 36 | from autotest_lib.server import frontend |
showard | 75cdfee | 2009-06-10 17:40:41 +0000 | [diff] [blame] | 37 | from autotest_lib.server import server_logging_config |
showard | 043c62a | 2009-06-10 19:48:57 +0000 | [diff] [blame] | 38 | from autotest_lib.server import server_job, utils, autoserv_parser, autotest |
Dan Shi | a1ecd5c | 2013-06-06 11:21:31 -0700 | [diff] [blame] | 39 | from autotest_lib.server import utils as server_utils |
| 40 | |
showard | 75cdfee | 2009-06-10 17:40:41 +0000 | [diff] [blame] | 41 | from autotest_lib.client.common_lib import pidfile, logging_manager |
Dan Shi | a1ecd5c | 2013-06-06 11:21:31 -0700 | [diff] [blame] | 42 | from autotest_lib.site_utils.graphite import stats |
mbligh | 92c0fc2 | 2008-11-20 16:52:23 +0000 | [diff] [blame] | 43 | |
Alex Miller | f1af17e | 2013-01-09 22:50:32 -0800 | [diff] [blame] | 44 | def log_alarm(signum, frame): |
| 45 | logging.error("Received SIGALARM. Ignoring and continuing on.") |
Alex Miller | 0528d6f | 2013-01-11 10:49:48 -0800 | [diff] [blame] | 46 | sys.exit(1) |
Alex Miller | f1af17e | 2013-01-09 22:50:32 -0800 | [diff] [blame] | 47 | |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 48 | def run_autoserv(pid_file_manager, results, parser): |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 49 | # send stdin to /dev/null |
| 50 | dev_null = os.open(os.devnull, os.O_RDONLY) |
| 51 | os.dup2(dev_null, sys.stdin.fileno()) |
| 52 | os.close(dev_null) |
mbligh | dbf3761 | 2007-11-24 19:38:11 +0000 | [diff] [blame] | 53 | |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 54 | # Create separate process group |
| 55 | os.setpgrp() |
mbligh | 1d42d4e | 2007-11-05 22:42:00 +0000 | [diff] [blame] | 56 | |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 57 | # Implement SIGTERM handler |
mbligh | c229956 | 2009-07-02 19:00:36 +0000 | [diff] [blame] | 58 | def handle_sigterm(signum, frame): |
Simran Basi | 9d9b729 | 2013-10-16 16:44:07 -0700 | [diff] [blame] | 59 | logging.debug('Received SIGTERM') |
mbligh | ff7d61f | 2008-12-22 14:53:35 +0000 | [diff] [blame] | 60 | if pid_file_manager: |
| 61 | pid_file_manager.close_file(1, signal.SIGTERM) |
Simran Basi | 49e21e6 | 2013-10-17 12:40:33 -0700 | [diff] [blame] | 62 | logging.debug('Finished writing to pid_file. Killing process.') |
Simran Basi | d6b8377 | 2014-01-06 16:31:30 -0800 | [diff] [blame] | 63 | # TODO (sbasi) - remove the time.sleep when crbug.com/302815 is solved. |
| 64 | # This sleep allows the pending output to be logged before the kill |
| 65 | # signal is sent. |
| 66 | time.sleep(.1) |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 67 | os.killpg(os.getpgrp(), signal.SIGKILL) |
mbligh | faf0cd4 | 2007-11-19 16:00:24 +0000 | [diff] [blame] | 68 | |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 69 | # Set signal handler |
mbligh | c229956 | 2009-07-02 19:00:36 +0000 | [diff] [blame] | 70 | signal.signal(signal.SIGTERM, handle_sigterm) |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 71 | |
Simran Basi | d6b8377 | 2014-01-06 16:31:30 -0800 | [diff] [blame] | 72 | # faulthandler is only needed to debug in the Lab and is not avaliable to |
| 73 | # be imported in the chroot as part of VMTest, so Try-Except it. |
| 74 | try: |
| 75 | import faulthandler |
| 76 | faulthandler.register(signal.SIGTERM, all_threads=True, chain=True) |
| 77 | logging.debug('faulthandler registered on SIGTERM.') |
| 78 | except ImportError: |
| 79 | pass |
| 80 | |
David Rochberg | 8a60d1e | 2011-02-01 14:22:07 -0500 | [diff] [blame] | 81 | # Ignore SIGTTOU's generated by output from forked children. |
| 82 | signal.signal(signal.SIGTTOU, signal.SIG_IGN) |
| 83 | |
Alex Miller | f1af17e | 2013-01-09 22:50:32 -0800 | [diff] [blame] | 84 | # If we received a SIGALARM, let's be loud about it. |
| 85 | signal.signal(signal.SIGALRM, log_alarm) |
| 86 | |
mbligh | a5f5e54 | 2009-12-30 16:57:49 +0000 | [diff] [blame] | 87 | # Server side tests that call shell scripts often depend on $USER being set |
| 88 | # but depending on how you launch your autotest scheduler it may not be set. |
| 89 | os.environ['USER'] = getpass.getuser() |
| 90 | |
mbligh | cce191f | 2008-09-19 20:31:03 +0000 | [diff] [blame] | 91 | if parser.options.machines: |
| 92 | machines = parser.options.machines.replace(',', ' ').strip().split() |
| 93 | else: |
| 94 | machines = [] |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 95 | machines_file = parser.options.machines_file |
mbligh | b2bea30 | 2008-07-24 20:25:57 +0000 | [diff] [blame] | 96 | label = parser.options.label |
mbligh | 374f341 | 2009-05-13 21:29:45 +0000 | [diff] [blame] | 97 | group_name = parser.options.group_name |
mbligh | b2bea30 | 2008-07-24 20:25:57 +0000 | [diff] [blame] | 98 | user = parser.options.user |
| 99 | client = parser.options.client |
| 100 | server = parser.options.server |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 101 | install_before = parser.options.install_before |
mbligh | b2bea30 | 2008-07-24 20:25:57 +0000 | [diff] [blame] | 102 | install_after = parser.options.install_after |
| 103 | verify = parser.options.verify |
| 104 | repair = parser.options.repair |
showard | 45ae819 | 2008-11-05 19:32:53 +0000 | [diff] [blame] | 105 | cleanup = parser.options.cleanup |
Alex Miller | cb79ba7 | 2013-05-29 14:43:00 -0700 | [diff] [blame] | 106 | provision = parser.options.provision |
Dan Shi | 07e09af | 2013-04-12 09:31:29 -0700 | [diff] [blame] | 107 | reset = parser.options.reset |
Alex Miller | 667b5f2 | 2014-02-28 15:33:39 -0800 | [diff] [blame^] | 108 | job_labels = parser.options.job_labels |
mbligh | b2bea30 | 2008-07-24 20:25:57 +0000 | [diff] [blame] | 109 | no_tee = parser.options.no_tee |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 110 | parse_job = parser.options.parse_job |
mbligh | e7d9c60 | 2009-07-02 19:02:33 +0000 | [diff] [blame] | 111 | execution_tag = parser.options.execution_tag |
| 112 | if not execution_tag: |
| 113 | execution_tag = parse_job |
jadmanski | fbc1f0a | 2008-07-09 14:12:54 +0000 | [diff] [blame] | 114 | host_protection = parser.options.host_protection |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 115 | ssh_user = parser.options.ssh_user |
| 116 | ssh_port = parser.options.ssh_port |
| 117 | ssh_pass = parser.options.ssh_pass |
jadmanski | def0c3c | 2009-03-25 20:07:10 +0000 | [diff] [blame] | 118 | collect_crashinfo = parser.options.collect_crashinfo |
mbligh | e0cbc91 | 2010-03-11 18:03:07 +0000 | [diff] [blame] | 119 | control_filename = parser.options.control_filename |
Scott Zawalski | 91493c8 | 2013-01-25 16:15:20 -0500 | [diff] [blame] | 120 | test_retry = parser.options.test_retry |
beeps | cb6f1e2 | 2013-06-28 19:14:10 -0700 | [diff] [blame] | 121 | verify_job_repo_url = parser.options.verify_job_repo_url |
Christopher Wiley | f594c5e | 2013-07-03 18:25:30 -0700 | [diff] [blame] | 122 | skip_crash_collection = parser.options.skip_crash_collection |
Aviv Keshet | 18ee314 | 2013-08-12 15:01:51 -0700 | [diff] [blame] | 123 | ssh_verbosity = int(parser.options.ssh_verbosity) |
Fang Deng | 6cc20de | 2013-09-06 15:47:32 -0700 | [diff] [blame] | 124 | ssh_options = parser.options.ssh_options |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 125 | |
mbligh | b2bea30 | 2008-07-24 20:25:57 +0000 | [diff] [blame] | 126 | # can't be both a client and a server side test |
| 127 | if client and server: |
Eric Li | 861b2d5 | 2011-02-04 14:50:35 -0800 | [diff] [blame] | 128 | parser.parser.error("Can not specify a test as both server and client!") |
mbligh | b2bea30 | 2008-07-24 20:25:57 +0000 | [diff] [blame] | 129 | |
Alex Miller | cb79ba7 | 2013-05-29 14:43:00 -0700 | [diff] [blame] | 130 | if provision and client: |
| 131 | parser.parser.error("Cannot specify provisioning and client!") |
| 132 | |
| 133 | is_special_task = (verify or repair or cleanup or collect_crashinfo or |
Dan Shi | 07e09af | 2013-04-12 09:31:29 -0700 | [diff] [blame] | 134 | provision or reset) |
Alex Miller | cb79ba7 | 2013-05-29 14:43:00 -0700 | [diff] [blame] | 135 | if len(parser.args) < 1 and not is_special_task: |
Eric Li | 861b2d5 | 2011-02-04 14:50:35 -0800 | [diff] [blame] | 136 | parser.parser.error("Missing argument: control file") |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 137 | |
Aviv Keshet | 18ee314 | 2013-08-12 15:01:51 -0700 | [diff] [blame] | 138 | if ssh_verbosity > 0: |
| 139 | # ssh_verbosity is an integer between 0 and 3, inclusive |
| 140 | ssh_verbosity_flag = '-' + 'v' * ssh_verbosity |
Fang Deng | d1c2b73 | 2013-08-20 12:59:46 -0700 | [diff] [blame] | 141 | else: |
| 142 | ssh_verbosity_flag = '' |
Aviv Keshet | 18ee314 | 2013-08-12 15:01:51 -0700 | [diff] [blame] | 143 | |
showard | 45ae819 | 2008-11-05 19:32:53 +0000 | [diff] [blame] | 144 | # We have a control file unless it's just a verify/repair/cleanup job |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 145 | if len(parser.args) > 0: |
| 146 | control = parser.args[0] |
| 147 | else: |
| 148 | control = None |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 149 | |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 150 | if machines_file: |
| 151 | machines = [] |
| 152 | for m in open(machines_file, 'r').readlines(): |
| 153 | # remove comments, spaces |
| 154 | m = re.sub('#.*', '', m).strip() |
| 155 | if m: |
| 156 | machines.append(m) |
| 157 | print "Read list of machines from file: %s" % machines_file |
| 158 | print ','.join(machines) |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 159 | |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 160 | if machines: |
| 161 | for machine in machines: |
| 162 | if not machine or re.search('\s', machine): |
Eric Li | 861b2d5 | 2011-02-04 14:50:35 -0800 | [diff] [blame] | 163 | parser.parser.error("Invalid machine: %s" % str(machine)) |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 164 | machines = list(set(machines)) |
| 165 | machines.sort() |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 166 | |
mbligh | 374f341 | 2009-05-13 21:29:45 +0000 | [diff] [blame] | 167 | if group_name and len(machines) < 2: |
Eric Li | 861b2d5 | 2011-02-04 14:50:35 -0800 | [diff] [blame] | 168 | parser.parser.error("-G %r may only be supplied with more than one machine." |
mbligh | 374f341 | 2009-05-13 21:29:45 +0000 | [diff] [blame] | 169 | % group_name) |
mbligh | 374f341 | 2009-05-13 21:29:45 +0000 | [diff] [blame] | 170 | |
Christopher Wiley | 8a91f23 | 2013-07-09 11:02:27 -0700 | [diff] [blame] | 171 | kwargs = {'group_name': group_name, 'tag': execution_tag, |
| 172 | 'disable_sysinfo': parser.options.disable_sysinfo} |
mbligh | e0cbc91 | 2010-03-11 18:03:07 +0000 | [diff] [blame] | 173 | if control_filename: |
| 174 | kwargs['control_filename'] = control_filename |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 175 | job = server_job.server_job(control, parser.args[1:], results, label, |
| 176 | user, machines, client, parse_job, |
Fang Deng | d1c2b73 | 2013-08-20 12:59:46 -0700 | [diff] [blame] | 177 | ssh_user, ssh_port, ssh_pass, |
Aviv Keshet | c5947fa | 2013-09-04 14:06:29 -0700 | [diff] [blame] | 178 | ssh_verbosity_flag, ssh_options, |
| 179 | test_retry, **kwargs) |
showard | 75cdfee | 2009-06-10 17:40:41 +0000 | [diff] [blame] | 180 | job.logging.start_logging() |
mbligh | 4608b00 | 2010-01-05 18:22:35 +0000 | [diff] [blame] | 181 | job.init_parser() |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 182 | |
mbligh | 161fe6f | 2008-06-19 16:26:04 +0000 | [diff] [blame] | 183 | # perform checks |
| 184 | job.precheck() |
| 185 | |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 186 | # run the job |
| 187 | exit_code = 0 |
| 188 | try: |
mbligh | 332000a | 2009-06-08 16:47:28 +0000 | [diff] [blame] | 189 | try: |
| 190 | if repair: |
Alex Miller | 667b5f2 | 2014-02-28 15:33:39 -0800 | [diff] [blame^] | 191 | job.repair(host_protection, job_labels) |
mbligh | 332000a | 2009-06-08 16:47:28 +0000 | [diff] [blame] | 192 | elif verify: |
Alex Miller | 667b5f2 | 2014-02-28 15:33:39 -0800 | [diff] [blame^] | 193 | job.verify(job_labels) |
Alex Miller | cb79ba7 | 2013-05-29 14:43:00 -0700 | [diff] [blame] | 194 | elif provision: |
Alex Miller | 667b5f2 | 2014-02-28 15:33:39 -0800 | [diff] [blame^] | 195 | job.provision(job_labels) |
Dan Shi | 07e09af | 2013-04-12 09:31:29 -0700 | [diff] [blame] | 196 | elif reset: |
Alex Miller | 667b5f2 | 2014-02-28 15:33:39 -0800 | [diff] [blame^] | 197 | job.reset(job_labels) |
mbligh | 332000a | 2009-06-08 16:47:28 +0000 | [diff] [blame] | 198 | else: |
jadmanski | def0c3c | 2009-03-25 20:07:10 +0000 | [diff] [blame] | 199 | job.run(cleanup, install_before, install_after, |
beeps | cb6f1e2 | 2013-06-28 19:14:10 -0700 | [diff] [blame] | 200 | verify_job_repo_url=verify_job_repo_url, |
Christopher Wiley | f594c5e | 2013-07-03 18:25:30 -0700 | [diff] [blame] | 201 | only_collect_crashinfo=collect_crashinfo, |
| 202 | skip_crash_collection=skip_crash_collection) |
mbligh | 332000a | 2009-06-08 16:47:28 +0000 | [diff] [blame] | 203 | finally: |
| 204 | while job.hosts: |
| 205 | host = job.hosts.pop() |
| 206 | host.close() |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 207 | except: |
jadmanski | 27b37ea | 2008-10-29 23:54:31 +0000 | [diff] [blame] | 208 | exit_code = 1 |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 209 | traceback.print_exc() |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 210 | |
mbligh | ff7d61f | 2008-12-22 14:53:35 +0000 | [diff] [blame] | 211 | if pid_file_manager: |
| 212 | pid_file_manager.num_tests_failed = job.num_tests_failed |
| 213 | pid_file_manager.close_file(exit_code) |
jadmanski | e0dffc3 | 2008-12-15 17:30:30 +0000 | [diff] [blame] | 214 | job.cleanup_parser() |
showard | 21baa45 | 2008-10-21 00:08:39 +0000 | [diff] [blame] | 215 | |
jadmanski | 27b37ea | 2008-10-29 23:54:31 +0000 | [diff] [blame] | 216 | sys.exit(exit_code) |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 217 | |
| 218 | |
| 219 | def main(): |
Dan Shi | a1ecd5c | 2013-06-06 11:21:31 -0700 | [diff] [blame] | 220 | # White list of tests with run time measurement enabled. |
| 221 | measure_run_time_tests_names = global_config.global_config.get_config_value( |
| 222 | 'AUTOSERV', 'measure_run_time_tests', type=str) |
| 223 | if measure_run_time_tests_names: |
| 224 | measure_run_time_tests = [t.strip() for t in |
| 225 | measure_run_time_tests_names.split(',')] |
| 226 | else: |
| 227 | measure_run_time_tests = [] |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 228 | # grab the parser |
| 229 | parser = autoserv_parser.autoserv_parser |
mbligh | a5cb406 | 2009-02-17 15:53:39 +0000 | [diff] [blame] | 230 | parser.parse_args() |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 231 | |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 232 | if len(sys.argv) == 1: |
| 233 | parser.parser.print_help() |
| 234 | sys.exit(1) |
mbligh | a6f1308 | 2008-06-05 23:53:46 +0000 | [diff] [blame] | 235 | |
showard | 75cdfee | 2009-06-10 17:40:41 +0000 | [diff] [blame] | 236 | if parser.options.no_logging: |
| 237 | results = None |
| 238 | else: |
| 239 | results = parser.options.results |
mbligh | 80e1eba | 2008-11-19 00:26:18 +0000 | [diff] [blame] | 240 | if not results: |
| 241 | results = 'results.' + time.strftime('%Y-%m-%d-%H.%M.%S') |
| 242 | results = os.path.abspath(results) |
showard | 566d3c0 | 2010-01-12 18:57:01 +0000 | [diff] [blame] | 243 | resultdir_exists = False |
| 244 | for filename in ('control.srv', 'status.log', '.autoserv_execute'): |
| 245 | if os.path.exists(os.path.join(results, filename)): |
| 246 | resultdir_exists = True |
mbligh | 4608b00 | 2010-01-05 18:22:35 +0000 | [diff] [blame] | 247 | if not parser.options.use_existing_results and resultdir_exists: |
mbligh | 80e1eba | 2008-11-19 00:26:18 +0000 | [diff] [blame] | 248 | error = "Error: results directory already exists: %s\n" % results |
| 249 | sys.stderr.write(error) |
| 250 | sys.exit(1) |
mbligh | a788dc4 | 2009-03-26 21:10:16 +0000 | [diff] [blame] | 251 | |
| 252 | # Now that we certified that there's no leftover results dir from |
| 253 | # previous jobs, lets create the result dir since the logging system |
| 254 | # needs to create the log file in there. |
| 255 | if not os.path.isdir(results): |
| 256 | os.makedirs(results) |
showard | 75cdfee | 2009-06-10 17:40:41 +0000 | [diff] [blame] | 257 | |
| 258 | logging_manager.configure_logging( |
| 259 | server_logging_config.ServerLoggingConfig(), results_dir=results, |
showard | 10d8417 | 2009-06-18 23:16:50 +0000 | [diff] [blame] | 260 | use_console=not parser.options.no_tee, |
| 261 | verbose=parser.options.verbose, |
| 262 | no_console_prefix=parser.options.no_console_prefix) |
showard | 75cdfee | 2009-06-10 17:40:41 +0000 | [diff] [blame] | 263 | if results: |
mbligh | a788dc4 | 2009-03-26 21:10:16 +0000 | [diff] [blame] | 264 | logging.info("Results placed in %s" % results) |
mbligh | 1071763 | 2008-11-19 00:21:57 +0000 | [diff] [blame] | 265 | |
mbligh | 4608b00 | 2010-01-05 18:22:35 +0000 | [diff] [blame] | 266 | # wait until now to perform this check, so it get properly logged |
| 267 | if parser.options.use_existing_results and not resultdir_exists: |
| 268 | logging.error("No existing results directory found: %s", results) |
| 269 | sys.exit(1) |
| 270 | |
Aviv Keshet | 5c40ec6 | 2013-08-20 12:11:12 -0700 | [diff] [blame] | 271 | logging.debug('autoserv command was: %s', ' '.join(sys.argv)) |
mbligh | 4608b00 | 2010-01-05 18:22:35 +0000 | [diff] [blame] | 272 | |
mbligh | 80e1eba | 2008-11-19 00:26:18 +0000 | [diff] [blame] | 273 | if parser.options.write_pidfile: |
mbligh | 4608b00 | 2010-01-05 18:22:35 +0000 | [diff] [blame] | 274 | pid_file_manager = pidfile.PidFileManager(parser.options.pidfile_label, |
| 275 | results) |
jadmanski | d5ab8c5 | 2008-12-03 16:27:07 +0000 | [diff] [blame] | 276 | pid_file_manager.open_file() |
mbligh | ff7d61f | 2008-12-22 14:53:35 +0000 | [diff] [blame] | 277 | else: |
| 278 | pid_file_manager = None |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 279 | |
jadmanski | f22fea8 | 2008-11-26 20:57:07 +0000 | [diff] [blame] | 280 | autotest.BaseAutotest.set_install_in_tmpdir( |
| 281 | parser.options.install_in_tmpdir) |
| 282 | |
Dan Shi | a1ecd5c | 2013-06-06 11:21:31 -0700 | [diff] [blame] | 283 | timer = None |
| 284 | try: |
| 285 | # Take the first argument as control file name, get the test name from |
| 286 | # the control file. If the test name exists in the list of tests with |
| 287 | # run time measurement enabled, start a timer to begin measurement. |
| 288 | if (len(parser.args) > 0 and parser.args[0] != '' and |
| 289 | parser.options.machines): |
Dan Shi | bbc1613 | 2013-07-09 16:23:59 -0700 | [diff] [blame] | 290 | try: |
| 291 | test_name = control_data.parse_control(parser.args[0], |
| 292 | raise_warnings=True).name |
| 293 | except control_data.ControlVariableException: |
| 294 | logging.debug('Failed to retrieve test name from control file.') |
| 295 | test_name = None |
Dan Shi | a1ecd5c | 2013-06-06 11:21:31 -0700 | [diff] [blame] | 296 | if test_name in measure_run_time_tests: |
| 297 | machines = parser.options.machines.replace(',', ' ' |
| 298 | ).strip().split() |
| 299 | afe = frontend.AFE() |
| 300 | board = server_utils.get_board_from_afe(machines[0], afe) |
| 301 | timer = stats.Timer('autoserv_run_time.%s.%s' % |
| 302 | (board, test_name)) |
| 303 | timer.start() |
| 304 | except control_data.ControlVariableException as e: |
| 305 | logging.error(str(e)) |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 306 | exit_code = 0 |
| 307 | try: |
| 308 | try: |
mbligh | 1071763 | 2008-11-19 00:21:57 +0000 | [diff] [blame] | 309 | run_autoserv(pid_file_manager, results, parser) |
Aviv Keshet | 5c40ec6 | 2013-08-20 12:11:12 -0700 | [diff] [blame] | 310 | except SystemExit as e: |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 311 | exit_code = e.code |
Aviv Keshet | 5c40ec6 | 2013-08-20 12:11:12 -0700 | [diff] [blame] | 312 | if exit_code: |
| 313 | logging.exception(e) |
| 314 | except Exception as e: |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 315 | # If we don't know what happened, we'll classify it as |
| 316 | # an 'abort' and return 1. |
Aviv Keshet | 5c40ec6 | 2013-08-20 12:11:12 -0700 | [diff] [blame] | 317 | logging.exception(e) |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 318 | exit_code = 1 |
| 319 | finally: |
mbligh | ff7d61f | 2008-12-22 14:53:35 +0000 | [diff] [blame] | 320 | if pid_file_manager: |
| 321 | pid_file_manager.close_file(exit_code) |
Dan Shi | a1ecd5c | 2013-06-06 11:21:31 -0700 | [diff] [blame] | 322 | if timer: |
| 323 | timer.stop() |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 324 | sys.exit(exit_code) |
mbligh | faf0cd4 | 2007-11-19 16:00:24 +0000 | [diff] [blame] | 325 | |
mbligh | bb42185 | 2008-03-11 22:36:16 +0000 | [diff] [blame] | 326 | |
mbligh | a46678d | 2008-05-01 20:00:01 +0000 | [diff] [blame] | 327 | if __name__ == '__main__': |
jadmanski | 0afbb63 | 2008-06-06 21:10:57 +0000 | [diff] [blame] | 328 | main() |