| # Copyright (c) 2011 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. |
| |
| """Wrap everything we do with builds in a dash class.""" |
| |
| import commands |
| import json |
| import logging |
| import os |
| import re |
| import time |
| import urllib |
| |
| import dash_util |
| |
| # String resources. |
| from dash_strings import BUILDTIME_PREFIX |
| from dash_strings import LOCAL_TMP_DIR |
| from dash_strings import WGET_CMD |
| |
| |
| class BuildInfo(object): |
| """Data and functions from build log.""" |
| |
| class __impl: |
| """Nested class implements code wrapped by singleton.""" |
| |
| def __init__(self): |
| # Store build entries as {started_time, finished_time, chrome_version} |
| # indexed by board and build#. |
| self._build_time_cache = {} |
| self._formatted_time_cache = {} |
| self._chrome_version_cache = {} |
| self._chrome_parse = re.compile( |
| "^Started chromeos-base/chromeos-chrome-([\d]{1,3}\.[\d]{1,3}\.[\d]{1,3}\.[\d]{1,3})_rc.*", re.M) |
| |
| def GetChromeVersion(self, board, build): |
| # Get the string w.x.y.z Chrome version and a zzzz svn revision. |
| self.FetchBuildInfo(board, build) |
| return self._build_time_cache[board][build]['chrome_version'] |
| |
| def GetStartedTime(self, board, build): |
| # This is a float - seconds since the epoch. |
| self.FetchBuildInfo(board, build) |
| return self._build_time_cache[board][build]['started_time'] |
| |
| def GetFinishedTime(self, board, build): |
| # This is a float - seconds since the epoch. |
| self.FetchBuildInfo(board, build) |
| return self._build_time_cache[board][build]['finished_time'] |
| |
| def GetElapsedTime(self, board, build): |
| # This is a float. |
| return ( |
| self.GetFinishedTime(board, build) - |
| self.GetStartedTime(board, build)) |
| |
| def GetFormattedTime(self, time_seconds, short=None): |
| if short: |
| # Formatted as: Wed 09/08 12:37. |
| result = time.strftime('%a %m/%d %H:%M', time.localtime(time_seconds)) |
| else: |
| # Formatted as: Wed Sep 8 12:37:56 2010. |
| result = time.ctime(time_seconds) |
| return result |
| |
| def GetFormattedStartedTime(self, board, build, short=None): |
| return self.GetFormattedTime( |
| self.GetStartedTime(board, build), short) |
| |
| def GetFormattedFinishedTime(self, board, build, short=None): |
| return self.GetFormattedTime( |
| self.GetFinishedTime(board, build), short) |
| |
| def GetFormattedElapsedTime(self, board, build, short=None): |
| time_seconds = self.GetElapsedTime(board, build) |
| if short: |
| # Formatted as: 06:16:12. |
| result = time.strftime('%H:%M:%S', time.gmtime(time_seconds)) |
| else: |
| # Formatted as: 04 hrs, 27 mins, 03 secs. |
| result = time.strftime( |
| '%H hrs, %M mins, %S secs', time.gmtime(time_seconds)) |
| return result |
| |
| def GetFormattedBuildTimes(self, board, build): |
| """Perf optimize on the pattern on repeat/retrieval of all.""" |
| time_key = (board, build) |
| if time_key in self._formatted_time_cache: |
| return self._formatted_time_cache[time_key] |
| result = (self.GetFormattedStartedTime(board, build), |
| self.GetFormattedFinishedTime(board, build), |
| self.GetFormattedElapsedTime(board, build), |
| self.GetFormattedFinishedTime(board, build, True)) |
| self._formatted_time_cache[time_key] = result |
| return result |
| |
| def FetchChromeVersion(self, full_build): |
| """Grab the Chrome version from the chromeos-images version map.""" |
| chromeos_build = full_build.split('_')[-1].split('-')[0] |
| if chromeos_build in self._chrome_version_cache: |
| return self._chrome_version_cache[chromeos_build] |
| map_file = os.path.join(os.path.abspath(os.path.dirname(__file__)), |
| 'chromeos-chrome-version.json') |
| if not os.path.exists(map_file): |
| return (None, None) |
| chrome_versions = json.load(open(map_file)) |
| if not chrome_versions or not chromeos_build in chrome_versions: |
| return (None, None) |
| dot_version = chrome_versions[chromeos_build] |
| omaha_url = 'http://omahaproxy.appspot.com/revision?version=%s' % ( |
| dot_version) |
| omaha_wget = '%s "%s"' % (WGET_CMD, omaha_url) |
| svn_revision = commands.getoutput(omaha_wget) |
| results = (dot_version, svn_revision) |
| self._chrome_version_cache[chromeos_build] = results |
| return results |
| |
| def GetCacheFilename(self, board, build, dir=True): |
| filename = '%s%s_%s' % (BUILDTIME_PREFIX, board, build) |
| if dir: |
| return '%s/%s' % (LOCAL_TMP_DIR, filename) |
| else: |
| return filename |
| |
| def FetchBuildInfo(self, board, build): |
| """Load start_time, end_time into memory from file cache or web lookup.""" |
| # Use an in-memory cache (dictionary) for repeats. |
| board_builds = self._build_time_cache.setdefault(board, {}) |
| build_keys = board_builds.setdefault(build, {}) |
| if not build_keys: |
| build_keys['started_time'] = 0.0 |
| build_keys['finished_time'] = 0.0 |
| build_keys['chrome_version'] = [None, None] |
| |
| build_log_json = None |
| cache_filename = self.GetCacheFilename(board, build) |
| if os.path.isfile(cache_filename): |
| f = open(cache_filename, 'r') |
| build_log_text = f.read() |
| if build_log_text: |
| build_log_json = json.loads(build_log_text) |
| f.close() |
| else: |
| if not os.path.exists(LOCAL_TMP_DIR): |
| os.makedirs(LOCAL_TMP_DIR, 0755) |
| dash_util.SaveHTML(cache_filename, '') |
| |
| def PruneTmpFiles(self, dash_view): |
| """Remove cached build_time data that is no longer useful.""" |
| |
| build_set = set() |
| for board in dash_view.GetBoardTypes(): |
| for build in dash_view.GetBoardtypeBuilds(board): |
| build_set.add(unicode(self.GetCacheFilename(board, build, False))) |
| files_set = set(os.listdir(LOCAL_TMP_DIR)) |
| for f in files_set - build_set: |
| if f.find(BUILDTIME_PREFIX) > -1: |
| logging.info('Pruning %s from %s.', f, LOCAL_TMP_DIR) |
| os.remove('%s/%s' % (LOCAL_TMP_DIR, f)) |
| |
| def ShowCache(self): |
| logging.debug("*") |
| logging.debug("*BUILDINFO CACHE***************") |
| logging.debug("*") |
| for board, build_times in self._build_time_cache.iteritems(): |
| for build, time_info in build_times.iteritems(): |
| logging.debug(" %s: %s: %s ~ %s (%s).", |
| board, build, |
| time_info['started_time'], |
| time_info['finished_time'], |
| time_info['chrome_version']) |
| |
| # Instance reference for singleton behavior. |
| __instance = None |
| __refs = 0 |
| |
| def __init__(self): |
| if BuildInfo.__instance is None: |
| BuildInfo.__instance = BuildInfo.__impl() |
| |
| self.__dict__["_BuildInfo__instance"] = BuildInfo.__instance |
| BuildInfo.__refs += 1 |
| |
| def __del__(self): |
| BuildInfo.__refs -= 1 |
| if not BuildInfo.__instance is None and BuildInfo.__refs == 0: |
| BuildInfo.__instance.ShowCache() |
| del BuildInfo.__instance |
| BuildInfo.__instance = None |
| |
| def __getattr__(self, attr): |
| return getattr(BuildInfo.__instance, attr) |
| |
| def __setattr__(self, attr, value): |
| return setattr(BuildInfo.__instance, attr, value) |
