| #!/usr/bin/python |
| # |
| # Copyright (c) 2014 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import datetime as datetime_base |
| import logging |
| from datetime import datetime |
| |
| import common |
| |
| from autotest_lib.client.common_lib import global_config |
| from autotest_lib.client.common_lib import time_utils |
| from autotest_lib.server import utils |
| from autotest_lib.server.cros.dynamic_suite import reporting_utils |
| from autotest_lib.server.lib import status_history |
| from autotest_lib.utils import labellib |
| |
| CONFIG = global_config.global_config |
| |
| |
| class BoardNotAvailableError(utils.TestLabException): |
| """Raised when a board is not available in the lab.""" |
| |
| |
| class NotEnoughDutsError(utils.TestLabException): |
| """Rasied when the lab doesn't have the minimum number of duts.""" |
| |
| def __init__(self, board, pool, num_available, num_required, hosts): |
| """Initialize instance. |
| |
| Please pass arguments by keyword. |
| |
| @param board: Name of board. |
| @param pool: Name of pool. |
| @param num_available: Number of available hosts. |
| @param num_required: Number of hosts required. |
| @param hosts: Sequence of Host instances for given board and pool. |
| """ |
| self.board = board |
| self.pool = pool |
| self.num_available = num_available |
| self.num_required = num_required |
| self.hosts = hosts |
| self.bug_id = None |
| self.suite_name = None |
| self.build = None |
| |
| |
| def __repr__(self): |
| return ( |
| '<{cls} at 0x{id:x} with' |
| ' board={this.board!r},' |
| ' pool={this.pool!r},' |
| ' num_available={this.num_available!r},' |
| ' num_required={this.num_required!r},' |
| ' bug_id={this.bug_id!r},' |
| ' suite_name={this.suite_name!r},' |
| ' build={this.build!r}>' |
| .format(cls=type(self).__name__, id=id(self), this=self) |
| ) |
| |
| |
| def __str__(self): |
| msg_parts = [ |
| 'Not enough DUTs for board: {this.board}, pool: {this.pool};' |
| ' required: {this.num_required}, found: {this.num_available}' |
| ] |
| format_dict = {'this': self} |
| if self.bug_id is not None: |
| msg_parts.append('bug: {bug_url}') |
| format_dict['bug_url'] = reporting_utils.link_crbug(self.bug_id) |
| if self.suite_name is not None: |
| msg_parts.append('suite: {this.suite_name}') |
| if self.build is not None: |
| msg_parts.append('build: {this.build}') |
| return ', '.join(msg_parts).format(**format_dict) |
| |
| |
| def add_bug_id(self, bug_id): |
| """Add crbug id associated with this exception. |
| |
| @param bug_id crbug id whose str() value is used in a crbug URL. |
| """ |
| self.bug_id = bug_id |
| |
| |
| def add_suite_name(self, suite_name): |
| """Add name of test suite that needed the DUTs. |
| |
| @param suite_name Name of test suite. |
| """ |
| self.suite_name = suite_name |
| |
| |
| def add_build(self, build): |
| """Add name of build of job that needed the DUTs. |
| |
| @param build Name of build. |
| """ |
| self.build = build |
| |
| |
| class SimpleTimer(object): |
| """A simple timer used to periodically check if a deadline has passed.""" |
| |
| def _reset(self): |
| """Reset the deadline.""" |
| if not self.interval_hours or self.interval_hours < 0: |
| logging.error('Bad interval %s', self.interval_hours) |
| self.deadline = None |
| return |
| self.deadline = datetime.now() + datetime_base.timedelta( |
| hours=self.interval_hours) |
| |
| |
| def __init__(self, interval_hours=0.5): |
| """Initialize a simple periodic deadline timer. |
| |
| @param interval_hours: Interval of the deadline. |
| """ |
| self.interval_hours = interval_hours |
| self._reset() |
| |
| |
| def poll(self): |
| """Poll the timer to see if we've hit the deadline. |
| |
| This method resets the deadline if it has passed. If the deadline |
| hasn't been set, or the current time is less than the deadline, the |
| method returns False. |
| |
| @return: True if the deadline has passed, False otherwise. |
| """ |
| if not self.deadline or datetime.now() < self.deadline: |
| return False |
| self._reset() |
| return True |
| |
| |
| class JobTimer(object): |
| """Utility class capable of measuring job timeouts. |
| """ |
| |
| # Format used in datetime - string conversion. |
| time_format = '%m-%d-%Y [%H:%M:%S]' |
| |
| def __init__(self, job_created_time, timeout_mins): |
| """JobTimer constructor. |
| |
| @param job_created_time: float representing the time a job was |
| created. Eg: time.time() |
| @param timeout_mins: float representing the timeout in minutes. |
| """ |
| self.job_created_time = datetime.fromtimestamp(job_created_time) |
| self.timeout_hours = datetime_base.timedelta(hours=timeout_mins/60.0) |
| self.debug_output_timer = SimpleTimer(interval_hours=0.5) |
| self.past_halftime = False |
| |
| |
| @classmethod |
| def format_time(cls, datetime_obj): |
| """Get the string formatted version of the datetime object. |
| |
| @param datetime_obj: A datetime.datetime object. |
| Eg: datetime.datetime.now() |
| |
| @return: A formatted string containing the date/time of the |
| input datetime. |
| """ |
| return datetime_obj.strftime(cls.time_format) |
| |
| |
| def elapsed_time(self): |
| """Get the time elapsed since this job was created. |
| |
| @return: A timedelta object representing the elapsed time. |
| """ |
| return datetime.now() - self.job_created_time |
| |
| |
| def is_suite_timeout(self): |
| """Check if the suite timed out. |
| |
| @return: True if more than timeout_hours has elapsed since the suite job |
| was created. |
| """ |
| if self.elapsed_time() >= self.timeout_hours: |
| logging.info('Suite timed out. Started on %s, timed out on %s', |
| self.format_time(self.job_created_time), |
| self.format_time(datetime.now())) |
| return True |
| return False |
| |
| |
| def first_past_halftime(self): |
| """Check if we just crossed half time. |
| |
| This method will only return True once, the first time it is called |
| after a job's elapsed time is past half its timeout. |
| |
| @return True: If this is the first call of the method after halftime. |
| """ |
| if (not self.past_halftime and |
| self.elapsed_time() > self.timeout_hours/2): |
| self.past_halftime = True |
| return True |
| return False |
| |
| |
| class RPCHelper(object): |
| """A class to help diagnose a suite run through the rpc interface. |
| """ |
| |
| def __init__(self, rpc_interface): |
| """Constructor for rpc helper class. |
| |
| @param rpc_interface: An rpc object, eg: A RetryingAFE instance. |
| """ |
| self.rpc_interface = rpc_interface |
| |
| |
| def diagnose_pool(self, board, pool, time_delta_hours, limit=10): |
| """Log diagnostic information about a timeout for a board/pool. |
| |
| @param board: The board for which the current suite was run. |
| @param pool: The pool against which the current suite was run. |
| @param time_delta_hours: The time from which we should log information. |
| This is a datetime.timedelta object, as stored by the JobTimer. |
| @param limit: The maximum number of jobs per host, to log. |
| |
| @raises proxy.JSONRPCException: For exceptions thrown across the wire. |
| """ |
| end_time = datetime.now() |
| start_time = end_time - time_delta_hours |
| labels = labellib.LabelsMapping() |
| labels['board'] = board |
| labels['pool'] = pool |
| host_histories = status_history.HostJobHistory.get_multiple_histories( |
| self.rpc_interface, |
| time_utils.to_epoch_time(start_time), |
| time_utils.to_epoch_time(end_time), |
| labels.getlabels(), |
| ) |
| if not host_histories: |
| logging.error('No hosts found for board:%s in pool:%s', |
| board, pool) |
| return |
| status_map = { |
| status_history.UNUSED: 'Unused', |
| status_history.UNKNOWN: 'No job history', |
| status_history.WORKING: 'Working', |
| status_history.BROKEN: 'Failed repair' |
| } |
| for history in host_histories: |
| count = 0 |
| job_info ='' |
| for job in history: |
| start_time = ( |
| time_utils.epoch_time_to_date_string(job.start_time)) |
| job_info += ('%s %s started on: %s status %s\n' % |
| (job.id, job.name, start_time, job.job_status)) |
| count += 1 |
| if count >= limit: |
| break |
| host = history.host |
| logging.error('host: %s, status: %s, locked: %s ' |
| 'diagnosis: %s\n' |
| 'labels: %s\nLast %s jobs within %s:\n' |
| '%s', |
| history.hostname, host.status, host.locked, |
| status_map[history.last_diagnosis()[0]], |
| host.labels, limit, time_delta_hours, |
| job_info) |
| |
| |
| def check_dut_availability(self, board, pool, minimum_duts=0, skip_duts_check=False): |
| """Check if DUT availability for a given board and pool is less than |
| minimum. |
| |
| @param board: The board to check DUT availability. |
| @param pool: The pool to check DUT availability. |
| @param minimum_duts: Minimum Number of available machines required to |
| run the suite. Default is set to 0, which means do |
| not force the check of available machines before |
| running the suite. |
| @param skip_duts_check: If True, skip minimum available DUTs check. |
| @raise: NotEnoughDutsError if DUT availability is lower than minimum. |
| @raise: BoardNotAvailableError if no host found for requested |
| board/pool. |
| """ |
| if minimum_duts == 0: |
| return |
| |
| # TODO(ayatane): Replace label prefixes with constants in |
| # autotest_lib.server.constants |
| hosts = self.rpc_interface.get_hosts( |
| invalid=False, |
| multiple_labels=('pool:%s' % pool, 'board:%s' % board)) |
| if not hosts: |
| raise BoardNotAvailableError( |
| 'No hosts found for board:%s in pool:%s. The test lab ' |
| 'currently does not cover test for this board and pool.'% |
| (board, pool)) |
| |
| if skip_duts_check: |
| # Bypass minimum avilable DUTs check |
| logging.debug('skip_duts_check is on, do not enforce minimum DUTs check.') |
| return |
| |
| if len(hosts) < minimum_duts: |
| logging.debug('The total number of DUTs for %s in pool:%s is %d, ' |
| 'which is less than %d, the required minimum number of' |
| ' available DUTS', board, pool, len(hosts), |
| minimum_duts) |
| |
| available_hosts = 0 |
| for host in hosts: |
| if host.is_available(): |
| available_hosts += 1 |
| logging.debug('%d of %d DUTs are available for board %s pool %s.', |
| available_hosts, len(hosts), board, pool) |
| if available_hosts < minimum_duts: |
| raise NotEnoughDutsError( |
| board=board, |
| pool=pool, |
| num_available=available_hosts, |
| num_required=minimum_duts, |
| hosts=hosts) |
| |
| |
| def diagnose_job(self, job_id, instance_server): |
| """Diagnose a suite job. |
| |
| Logs information about the jobs that are still to run in the suite. |
| |
| @param job_id: The id of the suite job to get information about. |
| No meaningful information gets logged if the id is for a sub-job. |
| @param instance_server: The instance server. |
| Eg: cautotest, cautotest-cq, localhost. |
| """ |
| incomplete_jobs = self.rpc_interface.get_jobs( |
| parent_job_id=job_id, summary=True, |
| hostqueueentry__complete=False) |
| if incomplete_jobs: |
| logging.info('\n%s printing summary of incomplete jobs (%s):\n', |
| JobTimer.format_time(datetime.now()), |
| len(incomplete_jobs)) |
| for job in incomplete_jobs: |
| logging.info('%s: %s', job.testname[job.testname.rfind('/')+1:], |
| reporting_utils.link_job(job.id, instance_server)) |
| else: |
| logging.info('All jobs in suite have already completed.') |