| #!/usr/bin/python -u |
| # Copyright 2007-2008 Martin J. Bligh <mbligh@google.com>, Google Inc. |
| # Released under the GPL v2 |
| |
| """ |
| Run a control file through the server side engine |
| """ |
| |
| import datetime |
| import contextlib |
| import getpass |
| import logging |
| import os |
| import re |
| import shutil |
| import signal |
| import socket |
| import sys |
| import traceback |
| import time |
| import urllib2 |
| |
| import common |
| from autotest_lib.client.bin.result_tools import utils as result_utils |
| from autotest_lib.client.bin.result_tools import view as result_view |
| from autotest_lib.client.common_lib import control_data |
| from autotest_lib.client.common_lib import enum |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib import global_config |
| from autotest_lib.client.common_lib import host_queue_entry_states |
| from autotest_lib.client.common_lib import host_states |
| from autotest_lib.server import results_mocker |
| from autotest_lib.server.cros.dynamic_suite import suite |
| |
| try: |
| from chromite.lib import metrics |
| from chromite.lib import cloud_trace |
| except ImportError: |
| from autotest_lib.client.common_lib import utils as common_utils |
| metrics = common_utils.metrics_mock |
| import mock |
| cloud_trace = mock.MagicMock() |
| |
| _CONFIG = global_config.global_config |
| |
| # Number of seconds to wait before returning if testing mode is enabled |
| TESTING_MODE_SLEEP_SECS = 1 |
| |
| |
| from autotest_lib.server import frontend |
| from autotest_lib.server import server_logging_config |
| from autotest_lib.server import server_job, utils, autoserv_parser, autotest |
| from autotest_lib.server import utils as server_utils |
| from autotest_lib.server import site_utils |
| from autotest_lib.server.cros.dynamic_suite import frontend_wrappers |
| from autotest_lib.site_utils import job_directories |
| from autotest_lib.site_utils import lxc |
| from autotest_lib.site_utils.lxc import utils as lxc_utils |
| from autotest_lib.client.common_lib import pidfile, logging_manager |
| |
| |
| # Control segment to stage server-side package. |
| STAGE_SERVER_SIDE_PACKAGE_CONTROL_FILE = server_job._control_segment_path( |
| 'stage_server_side_package') |
| |
| # Command line to start servod in a moblab. |
| START_SERVOD_CMD = 'sudo start servod BOARD=%s PORT=%s' |
| STOP_SERVOD_CMD = 'sudo stop servod' |
| |
| _AUTOTEST_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), '..')) |
| _CONTROL_FILE_FROM_CONTROL_NAME = 'control.from_control_name' |
| |
| _LXC_JOB_FOLDER = 'lxc_job_folder' |
| |
| def log_alarm(signum, frame): |
| logging.error("Received SIGALARM. Ignoring and continuing on.") |
| sys.exit(1) |
| |
| |
| def _get_machines(parser): |
| """Get a list of machine names from command line arg -m or a file. |
| |
| @param parser: Parser for the command line arguments. |
| |
| @return: A list of machine names from command line arg -m or the |
| machines file specified in the command line arg -M. |
| """ |
| if parser.options.machines: |
| machines = parser.options.machines.replace(',', ' ').strip().split() |
| else: |
| machines = [] |
| machines_file = parser.options.machines_file |
| if machines_file: |
| machines = [] |
| for m in open(machines_file, 'r').readlines(): |
| # remove comments, spaces |
| m = re.sub('#.*', '', m).strip() |
| if m: |
| machines.append(m) |
| logging.debug('Read list of machines from file: %s', machines_file) |
| logging.debug('Machines: %s', ','.join(machines)) |
| |
| if machines: |
| for machine in machines: |
| if not machine or re.search('\s', machine): |
| parser.parser.error("Invalid machine: %s" % str(machine)) |
| machines = list(set(machines)) |
| machines.sort() |
| return machines |
| |
| |
| def _stage_ssp(parser, resultsdir): |
| """Stage server-side package. |
| |
| This function calls a control segment to stage server-side package based on |
| the job and autoserv command line option. The detail implementation could |
| be different for each host type. Currently, only CrosHost has |
| stage_server_side_package function defined. |
| The script returns None if no server-side package is available. However, |
| it may raise exception if it failed for reasons other than artifact (the |
| server-side package) not found. |
| |
| @param parser: Command line arguments parser passed in the autoserv process. |
| @param resultsdir: Folder to store results. This could be different from |
| parser.options.results: parser.options.results can be set to None |
| for results to be stored in a temp folder. resultsdir can be None |
| for autoserv run requires no logging. |
| |
| @return: url to the autotest server-side package. None in case of errors. |
| """ |
| machines_list = _get_machines(parser) |
| machines_list = server_job.get_machine_dicts( |
| machine_names=machines_list, |
| store_dir=os.path.join(resultsdir, parser.options.host_info_subdir), |
| in_lab=parser.options.lab, |
| use_shadow_store=not parser.options.local_only_host_info, |
| host_attributes=parser.options.host_attributes, |
| ) |
| |
| namespace = {'machines': machines_list, |
| 'isolate_hash': parser.options.isolate, |
| 'image': parser.options.test_source_build} |
| script_locals = {} |
| execfile(STAGE_SERVER_SIDE_PACKAGE_CONTROL_FILE, namespace, script_locals) |
| ssp_url = script_locals['ssp_url'] |
| if not ssp_url: |
| logging.error('Failed to stage SSP package: %s', |
| script_locals['error_msg']) |
| logging.error('This job will fail later, when attempting to run with' |
| ' SSP') |
| return ssp_url |
| |
| |
| def _run_with_ssp(job, container_id, job_id, results, parser, ssp_url, |
| machines): |
| """Run the server job with server-side packaging. |
| |
| @param job: The server job object. |
| @param container_id: ID of the container to run the test. |
| @param job_id: ID of the test job. |
| @param results: Folder to store results. This could be different from |
| parser.options.results: |
| parser.options.results can be set to None for results to be |
| stored in a temp folder. |
| results can be None for autoserv run requires no logging. |
| @param parser: Command line parser that contains the options. |
| @param ssp_url: url of the staged server-side package. |
| @param machines: A list of machines to run the test. |
| """ |
| if not ssp_url: |
| job.record('FAIL', None, None, |
| 'Failed to stage server-side package') |
| raise error.AutoservError('Failed to stage server-side package') |
| |
| bucket = lxc.ContainerBucket() |
| control = (parser.args[0] if len(parser.args) > 0 and parser.args[0] != '' |
| else None) |
| try: |
| dut_name = machines[0] if len(machines) >= 1 else None |
| test_container = bucket.setup_test(container_id, job_id, ssp_url, |
| results, control=control, |
| job_folder=_LXC_JOB_FOLDER, |
| dut_name=dut_name, |
| isolate_hash=parser.options.isolate) |
| except Exception as e: |
| job.record('FAIL', None, None, |
| 'Failed to setup container for test: %s. Check logs in ' |
| 'ssp_logs folder for more details.' % e) |
| raise |
| |
| args = sys.argv[:] |
| args.remove('--require-ssp') |
| # --parent_job_id is only useful in autoserv running in host, not in |
| # container. Include this argument will cause test to fail for builds before |
| # CL 286265 was merged. |
| if '--parent_job_id' in args: |
| index = args.index('--parent_job_id') |
| args.remove('--parent_job_id') |
| # Remove the actual parent job id in command line arg. |
| del args[index] |
| |
| # A dictionary of paths to replace in the command line. Key is the path to |
| # be replaced with the one in value. |
| paths_to_replace = {} |
| # Replace the control file path with the one in container. |
| if control: |
| container_control_filename = os.path.join( |
| lxc.CONTROL_TEMP_PATH, os.path.basename(control)) |
| paths_to_replace[control] = container_control_filename |
| # Update result directory with the one in container. |
| container_result_dir = os.path.join(lxc.RESULT_DIR_FMT % _LXC_JOB_FOLDER) |
| if parser.options.results: |
| paths_to_replace[parser.options.results] = container_result_dir |
| args = [paths_to_replace.get(arg, arg) for arg in args] |
| |
| # Apply --use-existing-results, results directory is aready created and |
| # mounted in container. Apply this arg to avoid exception being raised. |
| if not '--use-existing-results' in args: |
| args.append('--use-existing-results') |
| |
| # Make sure autoserv running in container using a different pid file. |
| if not '--pidfile-label' in args: |
| args.extend(['--pidfile-label', 'container_autoserv']) |
| |
| cmd_line = ' '.join(["'%s'" % arg if ' ' in arg else arg for arg in args]) |
| logging.info('Run command in container: %s', cmd_line) |
| success = False |
| try: |
| test_container.attach_run(cmd_line) |
| success = True |
| except Exception as e: |
| # If the test run inside container fails without generating any log, |
| # write a message to status.log to help troubleshooting. |
| debug_files = os.listdir(os.path.join(results, 'debug')) |
| if not debug_files: |
| job.record('FAIL', None, None, |
| 'Failed to run test inside the container: %s. Check ' |
| 'logs in ssp_logs folder for more details.' % e) |
| raise |
| finally: |
| metrics.Counter( |
| 'chromeos/autotest/experimental/execute_job_in_ssp').increment( |
| fields={'success': success}) |
| test_container.destroy() |
| |
| |
| def correct_results_folder_permission(results): |
| """Make sure the results folder has the right permission settings. |
| |
| For tests running with server-side packaging, the results folder has the |
| owner of root. This must be changed to the user running the autoserv |
| process, so parsing job can access the results folder. |
| TODO(dshi): crbug.com/459344 Remove this function when test container can be |
| unprivileged container. |
| |
| @param results: Path to the results folder. |
| |
| """ |
| if not results: |
| return |
| |
| utils.run('sudo -n chown -R %s "%s"' % (os.getuid(), results)) |
| utils.run('sudo -n chgrp -R %s "%s"' % (os.getgid(), results)) |
| |
| |
| def _start_servod(machine): |
| """Try to start servod in moblab if it's not already running or running with |
| different board or port. |
| |
| @param machine: Name of the dut used for test. |
| """ |
| if not utils.is_moblab(): |
| return |
| |
| logging.debug('Trying to start servod.') |
| try: |
| afe = frontend.AFE() |
| board = server_utils.get_board_from_afe(machine, afe) |
| hosts = afe.get_hosts(hostname=machine) |
| servo_host = hosts[0].attributes.get('servo_host', None) |
| servo_port = hosts[0].attributes.get('servo_port', 9999) |
| if not servo_host in ['localhost', '127.0.0.1']: |
| logging.warn('Starting servod is aborted. The dut\'s servo_host ' |
| 'attribute is not set to localhost.') |
| return |
| except (urllib2.HTTPError, urllib2.URLError): |
| # Ignore error if RPC failed to get board |
| logging.error('Failed to get board name from AFE. Start servod is ' |
| 'aborted') |
| return |
| |
| try: |
| pid = utils.run('pgrep servod').stdout |
| cmd_line = utils.run('ps -fp %s' % pid).stdout |
| if ('--board %s' % board in cmd_line and |
| '--port %s' % servo_port in cmd_line): |
| logging.debug('Servod is already running with given board and port.' |
| ' There is no need to restart servod.') |
| return |
| logging.debug('Servod is running with different board or port. ' |
| 'Stopping existing servod.') |
| utils.run('sudo stop servod') |
| except error.CmdError: |
| # servod is not running. |
| pass |
| |
| try: |
| utils.run(START_SERVOD_CMD % (board, servo_port)) |
| logging.debug('Servod is started') |
| except error.CmdError as e: |
| logging.error('Servod failed to be started, error: %s', e) |
| |
| |
| def _control_path_on_disk(control_name): |
| """Find the control file corresponding to the given control name, on disk. |
| |
| @param control_name: NAME attribute of the control file to fetch. |
| @return: Path to the control file. |
| """ |
| cf_getter = suite.create_fs_getter(_AUTOTEST_ROOT) |
| control_name_predicate = suite.test_name_matches_pattern_predicate( |
| '^%s$' % control_name) |
| tests = suite.find_and_parse_tests(cf_getter, control_name_predicate) |
| if not tests: |
| raise error.AutoservError( |
| 'Failed to find any control files with NAME %s' % control_name) |
| if len(tests) > 1: |
| logging.error('Found more than one control file with NAME %s: %s', |
| control_name, [t.path for t in tests]) |
| raise error.AutoservError( |
| 'Found more than one control file with NAME %s' % control_name) |
| return tests[0].path |
| |
| |
| def _stage_control_file(control_name, results_dir): |
| """Stage the control file to execute from local autotest checkout. |
| |
| @param control_name: Name of the control file to stage. |
| @param results_dir: Results directory to stage the control file into. |
| @return: Absolute path to the staged control file. |
| """ |
| control_path = _control_path_on_disk(control_name) |
| new_control = os.path.join(results_dir, _CONTROL_FILE_FROM_CONTROL_NAME) |
| shutil.copy2(control_path, new_control) |
| return new_control |
| |
| |
| def run_autoserv(pid_file_manager, results, parser, ssp_url, use_ssp): |
| """Run server job with given options. |
| |
| @param pid_file_manager: PidFileManager used to monitor the autoserv process |
| @param results: Folder to store results. |
| @param parser: Parser for the command line arguments. |
| @param ssp_url: Url to server-side package. |
| @param use_ssp: Set to True to run with server-side packaging. |
| """ |
| # send stdin to /dev/null |
| dev_null = os.open(os.devnull, os.O_RDONLY) |
| os.dup2(dev_null, sys.stdin.fileno()) |
| os.close(dev_null) |
| |
| # Create separate process group if the process is not a process group |
| # leader. This allows autoserv process to keep running after the caller |
| # process (drone manager call) exits. |
| if os.getpid() != os.getpgid(0): |
| os.setsid() |
| |
| # Container name is predefined so the container can be destroyed in |
| # handle_sigterm. |
| job_or_task_id = job_directories.get_job_id_or_task_id( |
| parser.options.results) |
| container_id = lxc.ContainerId(job_or_task_id, time.time(), os.getpid()) |
| |
| # Implement SIGTERM handler |
| def handle_sigterm(signum, frame): |
| logging.debug('Received SIGTERM') |
| if pid_file_manager: |
| pid_file_manager.close_file(1, signal.SIGTERM) |
| logging.debug('Finished writing to pid_file. Killing process.') |
| |
| # Update results folder's file permission. This needs to be done ASAP |
| # before the parsing process tries to access the log. |
| if use_ssp and results: |
| correct_results_folder_permission(results) |
| |
| # TODO (sbasi) - remove the time.sleep when crbug.com/302815 is solved. |
| # This sleep allows the pending output to be logged before the kill |
| # signal is sent. |
| time.sleep(.1) |
| if use_ssp: |
| logging.debug('Destroy container %s before aborting the autoserv ' |
| 'process.', container_id) |
| try: |
| bucket = lxc.ContainerBucket() |
| container = bucket.get_container(container_id) |
| if container: |
| container.destroy() |
| else: |
| logging.debug('Container %s is not found.', container_id) |
| except: |
| # Handle any exception so the autoserv process can be aborted. |
| logging.exception('Failed to destroy container %s.', |
| container_id) |
| # Try to correct the result file permission again after the |
| # container is destroyed, as the container might have created some |
| # new files in the result folder. |
| if results: |
| correct_results_folder_permission(results) |
| |
| os.killpg(os.getpgrp(), signal.SIGKILL) |
| |
| # Set signal handler |
| signal.signal(signal.SIGTERM, handle_sigterm) |
| |
| # faulthandler is only needed to debug in the Lab and is not avaliable to |
| # be imported in the chroot as part of VMTest, so Try-Except it. |
| try: |
| import faulthandler |
| faulthandler.register(signal.SIGTERM, all_threads=True, chain=True) |
| logging.debug('faulthandler registered on SIGTERM.') |
| except ImportError: |
| sys.exc_clear() |
| |
| # Ignore SIGTTOU's generated by output from forked children. |
| signal.signal(signal.SIGTTOU, signal.SIG_IGN) |
| |
| # If we received a SIGALARM, let's be loud about it. |
| signal.signal(signal.SIGALRM, log_alarm) |
| |
| # Server side tests that call shell scripts often depend on $USER being set |
| # but depending on how you launch your autotest scheduler it may not be set. |
| os.environ['USER'] = getpass.getuser() |
| |
| label = parser.options.label |
| group_name = parser.options.group_name |
| user = parser.options.user |
| client = parser.options.client |
| server = parser.options.server |
| verify = parser.options.verify |
| repair = parser.options.repair |
| cleanup = parser.options.cleanup |
| provision = parser.options.provision |
| reset = parser.options.reset |
| job_labels = parser.options.job_labels |
| no_tee = parser.options.no_tee |
| execution_tag = parser.options.execution_tag |
| ssh_user = parser.options.ssh_user |
| ssh_port = parser.options.ssh_port |
| ssh_pass = parser.options.ssh_pass |
| collect_crashinfo = parser.options.collect_crashinfo |
| control_filename = parser.options.control_filename |
| verify_job_repo_url = parser.options.verify_job_repo_url |
| skip_crash_collection = parser.options.skip_crash_collection |
| ssh_verbosity = int(parser.options.ssh_verbosity) |
| ssh_options = parser.options.ssh_options |
| no_use_packaging = parser.options.no_use_packaging |
| in_lab = bool(parser.options.lab) |
| |
| # can't be both a client and a server side test |
| if client and server: |
| parser.parser.error("Can not specify a test as both server and client!") |
| |
| if provision and client: |
| parser.parser.error("Cannot specify provisioning and client!") |
| |
| is_special_task = (verify or repair or cleanup or collect_crashinfo or |
| provision or reset) |
| use_client_trampoline = False |
| if parser.options.control_name: |
| if use_ssp: |
| # When use_ssp is True, autoserv will be re-executed inside a |
| # container preserving the --control-name argument. Control file |
| # will be staged inside the rexecuted autoserv. |
| control = None |
| else: |
| try: |
| control = _stage_control_file(parser.options.control_name, |
| results) |
| except error.AutoservError as e: |
| logging.info("Using client trampoline because of: %s", e) |
| control = parser.options.control_name |
| use_client_trampoline = True |
| |
| elif parser.args: |
| control = parser.args[0] |
| else: |
| if not is_special_task: |
| parser.parser.error("Missing argument: control file") |
| control = None |
| |
| if ssh_verbosity > 0: |
| # ssh_verbosity is an integer between 0 and 3, inclusive |
| ssh_verbosity_flag = '-' + 'v' * ssh_verbosity |
| else: |
| ssh_verbosity_flag = '' |
| |
| machines = _get_machines(parser) |
| if group_name and len(machines) < 2: |
| parser.parser.error('-G %r may only be supplied with more than one ' |
| 'machine.' % group_name) |
| |
| job_kwargs = { |
| 'control': control, |
| 'args': parser.args[1:], |
| 'resultdir': results, |
| 'label': label, |
| 'user': user, |
| 'machines': machines, |
| 'machine_dict_list': server_job.get_machine_dicts( |
| machine_names=machines, |
| store_dir=os.path.join(results, |
| parser.options.host_info_subdir), |
| in_lab=in_lab, |
| use_shadow_store=not parser.options.local_only_host_info, |
| host_attributes=parser.options.host_attributes, |
| ), |
| 'client': client, |
| 'ssh_user': ssh_user, |
| 'ssh_port': ssh_port, |
| 'ssh_pass': ssh_pass, |
| 'ssh_verbosity_flag': ssh_verbosity_flag, |
| 'ssh_options': ssh_options, |
| 'group_name': group_name, |
| 'tag': execution_tag, |
| 'disable_sysinfo': parser.options.disable_sysinfo, |
| 'in_lab': in_lab, |
| 'use_client_trampoline': use_client_trampoline, |
| } |
| if parser.options.parent_job_id: |
| job_kwargs['parent_job_id'] = int(parser.options.parent_job_id) |
| if control_filename: |
| job_kwargs['control_filename'] = control_filename |
| job = server_job.server_job(**job_kwargs) |
| |
| job.logging.start_logging() |
| |
| # perform checks |
| job.precheck() |
| |
| # run the job |
| exit_code = 0 |
| auto_start_servod = _CONFIG.get_config_value( |
| 'AUTOSERV', 'auto_start_servod', type=bool, default=False) |
| |
| site_utils.SetupTsMonGlobalState('autoserv', indirect=False, |
| short_lived=True) |
| try: |
| try: |
| if repair: |
| if auto_start_servod and len(machines) == 1: |
| _start_servod(machines[0]) |
| job.repair(job_labels) |
| elif verify: |
| job.verify(job_labels) |
| elif provision: |
| job.provision(job_labels) |
| elif reset: |
| job.reset(job_labels) |
| elif cleanup: |
| job.cleanup(job_labels) |
| else: |
| if auto_start_servod and len(machines) == 1: |
| _start_servod(machines[0]) |
| if use_ssp: |
| try: |
| _run_with_ssp(job, container_id, job_or_task_id, |
| results, parser, ssp_url, machines) |
| finally: |
| # Update the ownership of files in result folder. |
| correct_results_folder_permission(results) |
| else: |
| if collect_crashinfo: |
| # Update the ownership of files in result folder. If the |
| # job to collect crashinfo was running inside container |
| # (SSP) and crashed before correcting folder permission, |
| # the result folder might have wrong permission setting. |
| try: |
| correct_results_folder_permission(results) |
| except: |
| # Ignore any error as the user may not have root |
| # permission to run sudo command. |
| pass |
| metric_name = ('chromeos/autotest/experimental/' |
| 'autoserv_job_run_duration') |
| f = {'in_container': utils.is_in_container(), |
| 'success': False} |
| with metrics.SecondsTimer(metric_name, fields=f) as c: |
| job.run(verify_job_repo_url=verify_job_repo_url, |
| only_collect_crashinfo=collect_crashinfo, |
| skip_crash_collection=skip_crash_collection, |
| job_labels=job_labels, |
| use_packaging=(not no_use_packaging)) |
| c['success'] = True |
| |
| finally: |
| job.close() |
| # Special task doesn't run parse, so result summary needs to be |
| # built here. |
| if results and (repair or verify or reset or cleanup or provision): |
| # Throttle the result on the server side. |
| try: |
| result_utils.execute( |
| results, control_data.DEFAULT_MAX_RESULT_SIZE_KB) |
| except: |
| logging.exception( |
| 'Non-critical failure: Failed to throttle results ' |
| 'in directory %s.', results) |
| # Build result view and report metrics for result sizes. |
| site_utils.collect_result_sizes(results) |
| except: |
| exit_code = 1 |
| traceback.print_exc() |
| finally: |
| metrics.Flush() |
| |
| sys.exit(exit_code) |
| |
| |
| # Job breakdown statuses |
| _hs = host_states.Status |
| _qs = host_queue_entry_states.Status |
| _status_list = [ |
| _qs.QUEUED, _qs.RESETTING, _qs.VERIFYING, |
| _qs.PROVISIONING, _hs.REPAIRING, _qs.CLEANING, |
| _qs.RUNNING, _qs.GATHERING, _qs.PARSING] |
| _JOB_OVERHEAD_STATUS = enum.Enum(*_status_list, string_values=True) |
| |
| |
| def get_job_status(options): |
| """Returns the HQE Status for this run. |
| |
| @param options: parser options. |
| """ |
| s = _JOB_OVERHEAD_STATUS |
| task_mapping = { |
| 'reset': s.RESETTING, 'verify': s.VERIFYING, |
| 'provision': s.PROVISIONING, 'repair': s.REPAIRING, |
| 'cleanup': s.CLEANING, 'collect_crashinfo': s.GATHERING} |
| match = [task for task in task_mapping if getattr(options, task, False)] |
| return task_mapping[match[0]] if match else s.RUNNING |
| |
| |
| def _require_ssp_from_control(control_name): |
| """Read the value of REQUIRE_SSP from test control file. |
| |
| This reads the control file from the prod checkout of autotest and uses that |
| to determine whether to even stage the SSP package on a devserver. |
| |
| This means: |
| [1] Any change in REQUIRE_SSP directive in a test requires a prod-push to go |
| live. |
| [2] This function may find that the control file does not exist but the SSP |
| package may contain the test file. This function conservatively returns True |
| in that case. |
| |
| This function is called very early in autoserv, before logging is setup. |
| """ |
| if not control_name: |
| return True |
| try: |
| path = _control_path_on_disk(control_name) |
| except error.AutoservError as e: |
| sys.stderr.write("autoserv: Could not determine control file path," |
| " assuming we need SSP: %s\n" % e) |
| sys.stderr.flush() |
| return True |
| if not os.path.isfile(path): |
| return True |
| control = control_data.parse_control(path) |
| # There must be explicit directive in the control file to disable SSP. |
| if not control or control.require_ssp is None: |
| return True |
| return control.require_ssp |
| |
| |
| def main(): |
| start_time = datetime.datetime.now() |
| parser = autoserv_parser.autoserv_parser |
| parser.parse_args() |
| |
| if len(sys.argv) == 1: |
| parser.parser.print_help() |
| sys.exit(1) |
| |
| if parser.options.no_logging: |
| results = None |
| else: |
| results = parser.options.results |
| if not results: |
| results = 'results.' + time.strftime('%Y-%m-%d-%H.%M.%S') |
| results = os.path.abspath(results) |
| resultdir_exists = False |
| for filename in ('control.srv', 'status.log', '.autoserv_execute'): |
| if os.path.exists(os.path.join(results, filename)): |
| resultdir_exists = True |
| if not parser.options.use_existing_results and resultdir_exists: |
| error = "Error: results directory already exists: %s\n" % results |
| sys.stderr.write(error) |
| sys.exit(1) |
| |
| # Now that we certified that there's no leftover results dir from |
| # previous jobs, lets create the result dir since the logging system |
| # needs to create the log file in there. |
| if not os.path.isdir(results): |
| os.makedirs(results) |
| |
| if parser.options.require_ssp: |
| # This is currently only used for skylab (i.e., when --control-name is |
| # used). |
| use_ssp = _require_ssp_from_control(parser.options.control_name) |
| else: |
| use_ssp = False |
| |
| |
| if use_ssp: |
| log_dir = os.path.join(results, 'ssp_logs') if results else None |
| if log_dir and not os.path.exists(log_dir): |
| os.makedirs(log_dir) |
| else: |
| log_dir = results |
| |
| logging_manager.configure_logging( |
| server_logging_config.ServerLoggingConfig(), |
| results_dir=log_dir, |
| use_console=not parser.options.no_tee, |
| verbose=parser.options.verbose, |
| no_console_prefix=parser.options.no_console_prefix) |
| |
| logging.debug('autoserv is running in drone %s.', socket.gethostname()) |
| logging.debug('autoserv command was: %s', ' '.join(sys.argv)) |
| logging.debug('autoserv parsed options: %s', parser.options) |
| |
| if use_ssp: |
| ssp_url = _stage_ssp(parser, results) |
| else: |
| ssp_url = None |
| |
| if results: |
| logging.info("Results placed in %s" % results) |
| |
| # wait until now to perform this check, so it get properly logged |
| if (parser.options.use_existing_results and not resultdir_exists and |
| not utils.is_in_container()): |
| logging.error("No existing results directory found: %s", results) |
| sys.exit(1) |
| |
| if parser.options.write_pidfile and results: |
| pid_file_manager = pidfile.PidFileManager(parser.options.pidfile_label, |
| results) |
| pid_file_manager.open_file() |
| else: |
| pid_file_manager = None |
| |
| autotest.Autotest.set_install_in_tmpdir( |
| parser.options.install_in_tmpdir) |
| |
| exit_code = 0 |
| # TODO(beeps): Extend this to cover different failure modes. |
| # Testing exceptions are matched against labels sent to autoserv. Eg, |
| # to allow only the hostless job to run, specify |
| # testing_exceptions: test_suite in the shadow_config. To allow both |
| # the hostless job and dummy_Pass to run, specify |
| # testing_exceptions: test_suite,dummy_Pass. You can figure out |
| # what label autoserv is invoked with by looking through the logs of a test |
| # for the autoserv command's -l option. |
| testing_exceptions = _CONFIG.get_config_value( |
| 'AUTOSERV', 'testing_exceptions', type=list, default=[]) |
| test_mode = _CONFIG.get_config_value( |
| 'AUTOSERV', 'testing_mode', type=bool, default=False) |
| test_mode = (results_mocker and test_mode and not |
| any([ex in parser.options.label |
| for ex in testing_exceptions])) |
| is_task = (parser.options.verify or parser.options.repair or |
| parser.options.provision or parser.options.reset or |
| parser.options.cleanup or parser.options.collect_crashinfo) |
| |
| trace_labels = { |
| 'job_id': job_directories.get_job_id_or_task_id( |
| parser.options.results) |
| } |
| trace = cloud_trace.SpanStack( |
| labels=trace_labels, |
| global_context=parser.options.cloud_trace_context) |
| trace.enabled = parser.options.cloud_trace_context_enabled == 'True' |
| try: |
| try: |
| if test_mode: |
| # The parser doesn't run on tasks anyway, so we can just return |
| # happy signals without faking results. |
| if not is_task: |
| machine = parser.options.results.split('/')[-1] |
| |
| # TODO(beeps): The proper way to do this would be to |
| # refactor job creation so we can invoke job.record |
| # directly. To do that one needs to pipe the test_name |
| # through run_autoserv and bail just before invoking |
| # the server job. See the comment in |
| # puppylab/results_mocker for more context. |
| results_mocker.ResultsMocker( |
| 'unknown-test', parser.options.results, machine |
| ).mock_results() |
| return |
| else: |
| with trace.Span(get_job_status(parser.options)): |
| run_autoserv(pid_file_manager, results, parser, ssp_url, |
| use_ssp) |
| except SystemExit as e: |
| exit_code = e.code |
| if exit_code: |
| logging.exception('Uncaught SystemExit with code %s', exit_code) |
| except Exception: |
| # If we don't know what happened, we'll classify it as |
| # an 'abort' and return 1. |
| logging.exception('Uncaught Exception, exit_code = 1.') |
| exit_code = 1 |
| finally: |
| if pid_file_manager: |
| pid_file_manager.close_file(exit_code) |
| sys.exit(exit_code) |
| |
| |
| if __name__ == '__main__': |
| main() |
