joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 1 | # Copyright (c) 2013 The Chromium OS Authors. All rights reserved. |
| 2 | # Use of this source code is governed by a BSD-style license that can be |
| 3 | # found in the LICENSE file. |
| 4 | |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 5 | import ConfigParser |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 6 | import datetime |
| 7 | import operator |
| 8 | import os |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 9 | import re |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 10 | import shutil |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 11 | import time |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 12 | import threading |
| 13 | |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 14 | import build_util |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 15 | import artifact_info |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 16 | import common_util |
| 17 | import devserver_constants |
| 18 | import downloader |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 19 | import gsutil_util |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 20 | import log_util |
| 21 | |
| 22 | # Module-local log function. |
| 23 | def _Log(message, *args): |
| 24 | return log_util.LogWithTag('XBUDDY', message, *args) |
| 25 | |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 26 | # xBuddy config constants |
| 27 | CONFIG_FILE = 'xbuddy_config.ini' |
| 28 | SHADOW_CONFIG_FILE = 'shadow_xbuddy_config.ini' |
| 29 | PATH_REWRITES = 'PATH_REWRITES' |
| 30 | GENERAL = 'GENERAL' |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 31 | |
Chris Sosa | c2abc72 | 2013-08-26 17:11:22 -0700 | [diff] [blame] | 32 | # Path for shadow config in chroot. |
| 33 | CHROOT_SHADOW_DIR = '/mnt/host/source/src/platform/dev' |
| 34 | |
joychen | 25d2597 | 2013-07-30 14:54:16 -0700 | [diff] [blame] | 35 | # XBuddy aliases |
| 36 | TEST = 'test' |
| 37 | BASE = 'base' |
| 38 | DEV = 'dev' |
| 39 | FULL = 'full_payload' |
| 40 | RECOVERY = 'recovery' |
| 41 | STATEFUL = 'stateful' |
| 42 | AUTOTEST = 'autotest' |
| 43 | |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 44 | # Local build constants |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 45 | ANY = "ANY" |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 46 | LATEST = "latest" |
| 47 | LOCAL = "local" |
| 48 | REMOTE = "remote" |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 49 | LOCAL_ALIASES = [ |
joychen | 25d2597 | 2013-07-30 14:54:16 -0700 | [diff] [blame] | 50 | TEST, |
| 51 | BASE, |
| 52 | DEV, |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 53 | FULL, |
| 54 | ANY, |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 55 | ] |
| 56 | |
| 57 | LOCAL_FILE_NAMES = [ |
| 58 | devserver_constants.TEST_IMAGE_FILE, |
| 59 | devserver_constants.BASE_IMAGE_FILE, |
| 60 | devserver_constants.IMAGE_FILE, |
joychen | 7c2054a | 2013-07-25 11:14:07 -0700 | [diff] [blame] | 61 | devserver_constants.UPDATE_FILE, |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 62 | ] |
| 63 | |
| 64 | LOCAL_ALIAS_TO_FILENAME = dict(zip(LOCAL_ALIASES, LOCAL_FILE_NAMES)) |
| 65 | |
| 66 | # Google Storage constants |
| 67 | GS_ALIASES = [ |
joychen | 25d2597 | 2013-07-30 14:54:16 -0700 | [diff] [blame] | 68 | TEST, |
| 69 | BASE, |
| 70 | RECOVERY, |
| 71 | FULL, |
| 72 | STATEFUL, |
| 73 | AUTOTEST, |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 74 | ] |
| 75 | |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 76 | GS_FILE_NAMES = [ |
| 77 | devserver_constants.TEST_IMAGE_FILE, |
| 78 | devserver_constants.BASE_IMAGE_FILE, |
| 79 | devserver_constants.RECOVERY_IMAGE_FILE, |
joychen | 7c2054a | 2013-07-25 11:14:07 -0700 | [diff] [blame] | 80 | devserver_constants.UPDATE_FILE, |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 81 | devserver_constants.STATEFUL_FILE, |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 82 | devserver_constants.AUTOTEST_DIR, |
| 83 | ] |
| 84 | |
| 85 | ARTIFACTS = [ |
| 86 | artifact_info.TEST_IMAGE, |
| 87 | artifact_info.BASE_IMAGE, |
| 88 | artifact_info.RECOVERY_IMAGE, |
| 89 | artifact_info.FULL_PAYLOAD, |
| 90 | artifact_info.STATEFUL_PAYLOAD, |
| 91 | artifact_info.AUTOTEST, |
| 92 | ] |
| 93 | |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 94 | GS_ALIAS_TO_FILENAME = dict(zip(GS_ALIASES, GS_FILE_NAMES)) |
| 95 | GS_ALIAS_TO_ARTIFACT = dict(zip(GS_ALIASES, ARTIFACTS)) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 96 | |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 97 | LATEST_OFFICIAL = "latest-official" |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 98 | |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 99 | RELEASE = "release" |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 100 | |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 101 | |
| 102 | class XBuddyException(Exception): |
| 103 | """Exception classes used by this module.""" |
| 104 | pass |
| 105 | |
| 106 | |
| 107 | # no __init__ method |
| 108 | #pylint: disable=W0232 |
| 109 | class Timestamp(): |
| 110 | """Class to translate build path strings and timestamp filenames.""" |
| 111 | |
| 112 | _TIMESTAMP_DELIMITER = 'SLASH' |
| 113 | XBUDDY_TIMESTAMP_DIR = 'xbuddy_UpdateTimestamps' |
| 114 | |
| 115 | @staticmethod |
| 116 | def TimestampToBuild(timestamp_filename): |
| 117 | return timestamp_filename.replace(Timestamp._TIMESTAMP_DELIMITER, '/') |
| 118 | |
| 119 | @staticmethod |
| 120 | def BuildToTimestamp(build_path): |
| 121 | return build_path.replace('/', Timestamp._TIMESTAMP_DELIMITER) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 122 | |
| 123 | @staticmethod |
| 124 | def UpdateTimestamp(timestamp_dir, build_id): |
| 125 | """Update timestamp file of build with build_id.""" |
| 126 | common_util.MkDirP(timestamp_dir) |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 127 | _Log("Updating timestamp for %s", build_id) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 128 | time_file = os.path.join(timestamp_dir, |
| 129 | Timestamp.BuildToTimestamp(build_id)) |
| 130 | with file(time_file, 'a'): |
| 131 | os.utime(time_file, None) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 132 | #pylint: enable=W0232 |
| 133 | |
| 134 | |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 135 | class XBuddy(build_util.BuildObject): |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 136 | """Class that manages image retrieval and caching by the devserver. |
| 137 | |
| 138 | Image retrieval by xBuddy path: |
| 139 | XBuddy accesses images and artifacts that it stores using an xBuddy |
| 140 | path of the form: board/version/alias |
| 141 | The primary xbuddy.Get call retrieves the correct artifact or url to where |
| 142 | the artifacts can be found. |
| 143 | |
| 144 | Image caching: |
| 145 | Images and other artifacts are stored identically to how they would have |
| 146 | been if devserver's stage rpc was called and the xBuddy cache replaces |
| 147 | build versions on a LRU basis. Timestamps are maintained by last accessed |
| 148 | times of representative files in the a directory in the static serve |
| 149 | directory (XBUDDY_TIMESTAMP_DIR). |
| 150 | |
| 151 | Private class members: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 152 | _true_values: used for interpreting boolean values |
| 153 | _staging_thread_count: track download requests |
| 154 | _timestamp_folder: directory with empty files standing in as timestamps |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 155 | for each image currently cached by xBuddy |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 156 | """ |
| 157 | _true_values = ['true', 't', 'yes', 'y'] |
| 158 | |
| 159 | # Number of threads that are staging images. |
| 160 | _staging_thread_count = 0 |
| 161 | # Lock used to lock increasing/decreasing count. |
| 162 | _staging_thread_count_lock = threading.Lock() |
| 163 | |
joychen | b0dfe55 | 2013-07-30 10:02:06 -0700 | [diff] [blame] | 164 | def __init__(self, manage_builds=False, board=None, **kwargs): |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 165 | super(XBuddy, self).__init__(**kwargs) |
joychen | b0dfe55 | 2013-07-30 10:02:06 -0700 | [diff] [blame] | 166 | |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 167 | self.config = self._ReadConfig() |
| 168 | self._manage_builds = manage_builds or self._ManageBuilds() |
| 169 | self._board = board or self.GetDefaultBoardID() |
joychen | b0dfe55 | 2013-07-30 10:02:06 -0700 | [diff] [blame] | 170 | _Log("Default board used by xBuddy: %s", self._board) |
joychen | b0dfe55 | 2013-07-30 10:02:06 -0700 | [diff] [blame] | 171 | |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 172 | self._timestamp_folder = os.path.join(self.static_dir, |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 173 | Timestamp.XBUDDY_TIMESTAMP_DIR) |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 174 | common_util.MkDirP(self._timestamp_folder) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 175 | |
| 176 | @classmethod |
| 177 | def ParseBoolean(cls, boolean_string): |
| 178 | """Evaluate a string to a boolean value""" |
| 179 | if boolean_string: |
| 180 | return boolean_string.lower() in cls._true_values |
| 181 | else: |
| 182 | return False |
| 183 | |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 184 | def _ReadConfig(self): |
| 185 | """Read xbuddy config from ini files. |
| 186 | |
| 187 | Reads the base config from xbuddy_config.ini, and then merges in the |
| 188 | shadow config from shadow_xbuddy_config.ini |
| 189 | |
| 190 | Returns: |
| 191 | The merged configuration. |
| 192 | Raises: |
| 193 | XBuddyException if the config file is missing. |
| 194 | """ |
| 195 | xbuddy_config = ConfigParser.ConfigParser() |
| 196 | config_file = os.path.join(self.devserver_dir, CONFIG_FILE) |
| 197 | if os.path.exists(config_file): |
| 198 | xbuddy_config.read(config_file) |
| 199 | else: |
| 200 | raise XBuddyException('%s not found' % (CONFIG_FILE)) |
| 201 | |
| 202 | # Read the shadow file if there is one. |
Chris Sosa | c2abc72 | 2013-08-26 17:11:22 -0700 | [diff] [blame] | 203 | if os.path.isdir(CHROOT_SHADOW_DIR): |
| 204 | shadow_config_file = os.path.join(CHROOT_SHADOW_DIR, SHADOW_CONFIG_FILE) |
| 205 | else: |
| 206 | shadow_config_file = os.path.join(self.devserver_dir, SHADOW_CONFIG_FILE) |
| 207 | |
| 208 | _Log('Using shadow config file stored at %s', shadow_config_file) |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 209 | if os.path.exists(shadow_config_file): |
| 210 | shadow_xbuddy_config = ConfigParser.ConfigParser() |
| 211 | shadow_xbuddy_config.read(shadow_config_file) |
| 212 | |
| 213 | # Merge shadow config in. |
| 214 | sections = shadow_xbuddy_config.sections() |
| 215 | for s in sections: |
| 216 | if not xbuddy_config.has_section(s): |
| 217 | xbuddy_config.add_section(s) |
| 218 | options = shadow_xbuddy_config.options(s) |
| 219 | for o in options: |
| 220 | val = shadow_xbuddy_config.get(s, o) |
| 221 | xbuddy_config.set(s, o, val) |
| 222 | |
| 223 | return xbuddy_config |
| 224 | |
| 225 | def _ManageBuilds(self): |
| 226 | """Checks if xBuddy is managing local builds using the current config.""" |
| 227 | try: |
| 228 | return self.ParseBoolean(self.config.get(GENERAL, 'manage_builds')) |
| 229 | except ConfigParser.Error: |
| 230 | return False |
| 231 | |
| 232 | def _Capacity(self): |
| 233 | """Gets the xbuddy capacity from the current config.""" |
| 234 | try: |
| 235 | return int(self.config.get(GENERAL, 'capacity')) |
| 236 | except ConfigParser.Error: |
| 237 | return 5 |
| 238 | |
| 239 | def _LookupAlias(self, alias, board): |
| 240 | """Given the full xbuddy config, look up an alias for path rewrite. |
| 241 | |
| 242 | Args: |
| 243 | alias: The xbuddy path that could be one of the aliases in the |
| 244 | rewrite table. |
| 245 | board: The board to fill in with when paths are rewritten. Can be from |
| 246 | the update request xml or the default board from devserver. |
| 247 | Returns: |
| 248 | If a rewrite is found, a string with the current board substituted in. |
| 249 | If no rewrite is found, just return the original string. |
| 250 | """ |
| 251 | if alias == '': |
| 252 | alias = 'update_default' |
| 253 | |
| 254 | try: |
| 255 | val = self.config.get(PATH_REWRITES, alias) |
| 256 | except ConfigParser.Error: |
| 257 | # No alias lookup found. Return original path. |
| 258 | return alias |
| 259 | |
| 260 | if not val.strip(): |
| 261 | # The found value was an empty string. |
| 262 | return alias |
| 263 | else: |
| 264 | # Fill in the board. |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 265 | rewrite = val.replace("BOARD", "%(board)s") % { |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 266 | 'board': board} |
| 267 | _Log("Path was rewritten to %s", rewrite) |
| 268 | return rewrite |
| 269 | |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 270 | def _LookupOfficial(self, board, suffix=RELEASE): |
| 271 | """Check LATEST-master for the version number of interest.""" |
| 272 | _Log("Checking gs for latest %s-%s image", board, suffix) |
| 273 | latest_addr = devserver_constants.GS_LATEST_MASTER % {'board':board, |
| 274 | 'suffix':suffix} |
| 275 | cmd = 'gsutil cat %s' % latest_addr |
| 276 | msg = 'Failed to find build at %s' % latest_addr |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 277 | # Full release + version is in the LATEST file. |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 278 | version = gsutil_util.GSUtilRun(cmd, msg) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 279 | |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 280 | return devserver_constants.IMAGE_DIR % {'board':board, |
| 281 | 'suffix':suffix, |
| 282 | 'version':version} |
| 283 | |
| 284 | def _LookupChannel(self, board, channel='stable'): |
| 285 | """Check the channel folder for the version number of interest.""" |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 286 | # Get all names in channel dir. Get 10 highest directories by version. |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 287 | _Log("Checking channel '%s' for latest '%s' image", channel, board) |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 288 | channel_dir = devserver_constants.GS_CHANNEL_DIR % {'channel':channel, |
| 289 | 'board':board} |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 290 | latest_version = gsutil_util.GetLatestVersionFromGSDir( |
| 291 | channel_dir, with_release=False) |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 292 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 293 | # Figure out release number from the version number. |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 294 | image_url = devserver_constants.IMAGE_DIR % { |
| 295 | 'board':board, |
| 296 | 'suffix':RELEASE, |
| 297 | 'version':'R*' + latest_version} |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 298 | image_dir = os.path.join(devserver_constants.GS_IMAGE_DIR, image_url) |
| 299 | |
| 300 | # There should only be one match on cros-image-archive. |
| 301 | full_version = gsutil_util.GetLatestVersionFromGSDir(image_dir) |
| 302 | |
| 303 | return devserver_constants.IMAGE_DIR % {'board':board, |
| 304 | 'suffix':RELEASE, |
| 305 | 'version':full_version} |
| 306 | |
| 307 | def _LookupVersion(self, board, version): |
| 308 | """Search GS image releases for the highest match to a version prefix.""" |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 309 | # Build the pattern for GS to match. |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 310 | _Log("Checking gs for latest '%s' image with prefix '%s'", board, version) |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 311 | image_url = devserver_constants.IMAGE_DIR % {'board':board, |
| 312 | 'suffix':RELEASE, |
| 313 | 'version':version + '*'} |
| 314 | image_dir = os.path.join(devserver_constants.GS_IMAGE_DIR, image_url) |
| 315 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 316 | # Grab the newest version of the ones matched. |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 317 | full_version = gsutil_util.GetLatestVersionFromGSDir(image_dir) |
| 318 | return devserver_constants.IMAGE_DIR % {'board':board, |
| 319 | 'suffix':RELEASE, |
| 320 | 'version':full_version} |
| 321 | |
| 322 | def _ResolveVersionToUrl(self, board, version): |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 323 | """Handle version aliases for remote payloads in GS. |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 324 | |
| 325 | Args: |
| 326 | board: as specified in the original call. (i.e. x86-generic, parrot) |
| 327 | version: as entered in the original call. can be |
| 328 | {TBD, 0. some custom alias as defined in a config file} |
| 329 | 1. latest |
| 330 | 2. latest-{channel} |
| 331 | 3. latest-official-{board suffix} |
| 332 | 4. version prefix (i.e. RX-Y.X, RX-Y, RX) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 333 | |
| 334 | Returns: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 335 | Location where the image dir is actually found on GS |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 336 | |
| 337 | """ |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 338 | # TODO(joychen): Convert separate calls to a dict + error out bad paths. |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 339 | |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 340 | # Only the last segment of the alias is variable relative to the rest. |
| 341 | version_tuple = version.rsplit('-', 1) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 342 | |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 343 | if re.match(devserver_constants.VERSION_RE, version): |
| 344 | # This is supposed to be a complete version number on GS. Return it. |
| 345 | return devserver_constants.IMAGE_DIR % {'board':board, |
| 346 | 'suffix':RELEASE, |
| 347 | 'version':version} |
| 348 | elif version == LATEST_OFFICIAL: |
| 349 | # latest-official --> LATEST build in board-release |
| 350 | return self._LookupOfficial(board) |
| 351 | elif version_tuple[0] == LATEST_OFFICIAL: |
| 352 | # latest-official-{suffix} --> LATEST build in board-{suffix} |
| 353 | return self._LookupOfficial(board, version_tuple[1]) |
| 354 | elif version == LATEST: |
| 355 | # latest --> latest build on stable channel |
| 356 | return self._LookupChannel(board) |
| 357 | elif version_tuple[0] == LATEST: |
| 358 | if re.match(devserver_constants.VERSION_RE, version_tuple[1]): |
| 359 | # latest-R* --> most recent qualifying build |
| 360 | return self._LookupVersion(board, version_tuple[1]) |
| 361 | else: |
| 362 | # latest-{channel} --> latest build within that channel |
| 363 | return self._LookupChannel(board, version_tuple[1]) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 364 | else: |
| 365 | # The given version doesn't match any known patterns. |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 366 | raise XBuddyException("Version %s unknown. Can't find on GS." % version) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 367 | |
joychen | 5260b9a | 2013-07-16 14:48:01 -0700 | [diff] [blame] | 368 | @staticmethod |
| 369 | def _Symlink(link, target): |
| 370 | """Symlinks link to target, and removes whatever link was there before.""" |
| 371 | _Log("Linking to %s from %s", link, target) |
| 372 | if os.path.lexists(link): |
| 373 | os.unlink(link) |
| 374 | os.symlink(target, link) |
| 375 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 376 | def _GetLatestLocalVersion(self, board): |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 377 | """Get the version of the latest image built for board by build_image |
| 378 | |
| 379 | Updates the symlink reference within the xBuddy static dir to point to |
| 380 | the real image dir in the local /build/images directory. |
| 381 | |
| 382 | Args: |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 383 | board: board that image was built for. |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 384 | |
| 385 | Returns: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 386 | The discovered version of the image. |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 387 | |
| 388 | Raises: |
| 389 | XBuddyException if neither test nor dev image was found in latest built |
| 390 | directory. |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 391 | """ |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 392 | latest_local_dir = self.GetLatestImageDir(board) |
joychen | b0dfe55 | 2013-07-30 10:02:06 -0700 | [diff] [blame] | 393 | if not latest_local_dir or not os.path.exists(latest_local_dir): |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 394 | raise XBuddyException('No builds found for %s. Did you run build_image?' % |
| 395 | board) |
| 396 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 397 | # Assume that the version number is the name of the directory. |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 398 | return os.path.basename(latest_local_dir.rstrip('/')) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 399 | |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 400 | @staticmethod |
| 401 | def _FindAny(local_dir): |
| 402 | """Returns the image_type for ANY given the local_dir.""" |
| 403 | dev_image = os.path.join(local_dir, devserver_constants.IMAGE_FILE) |
| 404 | test_image = os.path.join(local_dir, devserver_constants.TEST_IMAGE_FILE) |
| 405 | if os.path.exists(dev_image): |
| 406 | return 'dev' |
| 407 | |
| 408 | if os.path.exists(test_image): |
| 409 | return 'test' |
| 410 | |
| 411 | raise XBuddyException('No images found in %s' % local_dir) |
| 412 | |
| 413 | @staticmethod |
| 414 | def _InterpretPath(path): |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 415 | """Split and return the pieces of an xBuddy path name |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 416 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 417 | Args: |
| 418 | path: the path xBuddy Get was called with. |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 419 | |
| 420 | Return: |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 421 | tuple of (image_type, board, version) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 422 | |
| 423 | Raises: |
| 424 | XBuddyException: if the path can't be resolved into valid components |
| 425 | """ |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 426 | path_list = filter(None, path.split('/')) |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 427 | |
| 428 | # Required parts of path parsing. |
| 429 | try: |
| 430 | # Determine if image is explicitly local or remote. |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 431 | is_local = True |
| 432 | if path_list[0] in (REMOTE, LOCAL): |
joychen | 18737f3 | 2013-08-16 17:18:12 -0700 | [diff] [blame] | 433 | is_local = (path_list.pop(0) == LOCAL) |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 434 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 435 | # Set board. |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 436 | board = path_list.pop(0) |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 437 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 438 | # Set defaults. |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 439 | version = LATEST |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 440 | image_type = GS_ALIASES[0] |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 441 | except IndexError: |
| 442 | msg = "Specify at least the board in your xBuddy call. Your path: %s" |
| 443 | raise XBuddyException(msg % os.path.join(path_list)) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 444 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 445 | # Read as much of the xBuddy path as possible. |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 446 | try: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 447 | # Override default if terminal is a valid artifact alias or a version. |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 448 | terminal = path_list[-1] |
| 449 | if terminal in GS_ALIASES + LOCAL_ALIASES: |
| 450 | image_type = terminal |
| 451 | version = path_list[-2] |
| 452 | else: |
| 453 | version = terminal |
| 454 | except IndexError: |
| 455 | # This path doesn't have an alias or a version. That's fine. |
| 456 | _Log("Some parts of the path not specified. Using defaults.") |
| 457 | |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 458 | _Log("Get artifact '%s' in '%s/%s'. Locally? %s", |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 459 | image_type, board, version, is_local) |
| 460 | |
| 461 | return image_type, board, version, is_local |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 462 | |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 463 | def _SyncRegistryWithBuildImages(self): |
joychen | 5260b9a | 2013-07-16 14:48:01 -0700 | [diff] [blame] | 464 | """ Crawl images_dir for build_ids of images generated from build_image. |
| 465 | |
| 466 | This will find images and symlink them in xBuddy's static dir so that |
| 467 | xBuddy's cache can serve them. |
| 468 | If xBuddy's _manage_builds option is on, then a timestamp will also be |
| 469 | generated, and xBuddy will clear them from the directory they are in, as |
| 470 | necessary. |
| 471 | """ |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 472 | build_ids = [] |
| 473 | for b in os.listdir(self.images_dir): |
joychen | 5260b9a | 2013-07-16 14:48:01 -0700 | [diff] [blame] | 474 | # Ensure we have directories to track all boards in build/images |
| 475 | common_util.MkDirP(os.path.join(self.static_dir, b)) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 476 | board_dir = os.path.join(self.images_dir, b) |
| 477 | build_ids.extend(['/'.join([b, v]) for v |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 478 | in os.listdir(board_dir) if not v == LATEST]) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 479 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 480 | # Check currently registered images. |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 481 | for f in os.listdir(self._timestamp_folder): |
| 482 | build_id = Timestamp.TimestampToBuild(f) |
| 483 | if build_id in build_ids: |
| 484 | build_ids.remove(build_id) |
| 485 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 486 | # Symlink undiscovered images, and update timestamps if manage_builds is on. |
joychen | 5260b9a | 2013-07-16 14:48:01 -0700 | [diff] [blame] | 487 | for build_id in build_ids: |
| 488 | link = os.path.join(self.static_dir, build_id) |
| 489 | target = os.path.join(self.images_dir, build_id) |
| 490 | XBuddy._Symlink(link, target) |
| 491 | if self._manage_builds: |
| 492 | Timestamp.UpdateTimestamp(self._timestamp_folder, build_id) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 493 | |
| 494 | def _ListBuildTimes(self): |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 495 | """ Returns the currently cached builds and their last access timestamp. |
| 496 | |
| 497 | Returns: |
| 498 | list of tuples that matches xBuddy build/version to timestamps in long |
| 499 | """ |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 500 | # Update currently cached builds. |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 501 | build_dict = {} |
| 502 | |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 503 | for f in os.listdir(self._timestamp_folder): |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 504 | last_accessed = os.path.getmtime(os.path.join(self._timestamp_folder, f)) |
| 505 | build_id = Timestamp.TimestampToBuild(f) |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 506 | stale_time = datetime.timedelta(seconds=(time.time() - last_accessed)) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 507 | build_dict[build_id] = stale_time |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 508 | return_tup = sorted(build_dict.iteritems(), key=operator.itemgetter(1)) |
| 509 | return return_tup |
| 510 | |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 511 | def _Download(self, gs_url, artifact): |
| 512 | """Download the single artifact from the given gs_url.""" |
| 513 | with XBuddy._staging_thread_count_lock: |
| 514 | XBuddy._staging_thread_count += 1 |
| 515 | try: |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 516 | _Log("Downloading '%s' from '%s'", artifact, gs_url) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 517 | downloader.Downloader(self.static_dir, gs_url).Download( |
joychen | 18737f3 | 2013-08-16 17:18:12 -0700 | [diff] [blame] | 518 | [artifact], []) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 519 | finally: |
| 520 | with XBuddy._staging_thread_count_lock: |
| 521 | XBuddy._staging_thread_count -= 1 |
| 522 | |
| 523 | def _CleanCache(self): |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 524 | """Delete all builds besides the newest N builds""" |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 525 | if not self._manage_builds: |
| 526 | return |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 527 | cached_builds = [e[0] for e in self._ListBuildTimes()] |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 528 | _Log('In cache now: %s', cached_builds) |
| 529 | |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 530 | for b in range(self._Capacity(), len(cached_builds)): |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 531 | b_path = cached_builds[b] |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 532 | _Log("Clearing '%s' from cache", b_path) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 533 | |
| 534 | time_file = os.path.join(self._timestamp_folder, |
| 535 | Timestamp.BuildToTimestamp(b_path)) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 536 | os.unlink(time_file) |
| 537 | clear_dir = os.path.join(self.static_dir, b_path) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 538 | try: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 539 | # Handle symlinks, in the case of links to local builds if enabled. |
| 540 | if os.path.islink(clear_dir): |
joychen | 5260b9a | 2013-07-16 14:48:01 -0700 | [diff] [blame] | 541 | target = os.readlink(clear_dir) |
| 542 | _Log('Deleting locally built image at %s', target) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 543 | |
| 544 | os.unlink(clear_dir) |
joychen | 5260b9a | 2013-07-16 14:48:01 -0700 | [diff] [blame] | 545 | if os.path.exists(target): |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 546 | shutil.rmtree(target) |
| 547 | elif os.path.exists(clear_dir): |
joychen | 5260b9a | 2013-07-16 14:48:01 -0700 | [diff] [blame] | 548 | _Log('Deleting downloaded image at %s', clear_dir) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 549 | shutil.rmtree(clear_dir) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 550 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 551 | except Exception as err: |
| 552 | raise XBuddyException('Failed to clear %s: %s' % (clear_dir, err)) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 553 | |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 554 | def _GetFromGS(self, build_id, image_type, lookup_only): |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 555 | """Check if the artifact is available locally. Download from GS if not.""" |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 556 | gs_url = os.path.join(devserver_constants.GS_IMAGE_DIR, |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 557 | build_id) |
| 558 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 559 | # Stage image if not found in cache. |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 560 | file_name = GS_ALIAS_TO_FILENAME[image_type] |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 561 | file_loc = os.path.join(self.static_dir, build_id, file_name) |
| 562 | cached = os.path.exists(file_loc) |
| 563 | |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 564 | if not cached: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 565 | if not lookup_only: |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 566 | artifact = GS_ALIAS_TO_ARTIFACT[image_type] |
| 567 | self._Download(gs_url, artifact) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 568 | else: |
| 569 | _Log('Image already cached.') |
| 570 | |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 571 | def _GetArtifact(self, path_list, board, lookup_only=False): |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 572 | """Interpret an xBuddy path and return directory/file_name to resource. |
| 573 | |
| 574 | Returns: |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 575 | build_id to the directory |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 576 | file_name of the artifact |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 577 | |
| 578 | Raises: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 579 | XBuddyException: if the path could not be translated |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 580 | """ |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 581 | path = '/'.join(path_list) |
joychen | b0dfe55 | 2013-07-30 10:02:06 -0700 | [diff] [blame] | 582 | # Rewrite the path if there is an appropriate default. |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 583 | path = self._LookupAlias(path, board) |
joychen | b0dfe55 | 2013-07-30 10:02:06 -0700 | [diff] [blame] | 584 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 585 | # Parse the path. |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 586 | image_type, board, version, is_local = self._InterpretPath(path) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 587 | |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 588 | if is_local: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 589 | # Get a local image. |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 590 | if version == LATEST: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 591 | # Get the latest local image for the given board. |
| 592 | version = self._GetLatestLocalVersion(board) |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 593 | |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 594 | build_id = os.path.join(board, version) |
| 595 | artifact_dir = os.path.join(self.static_dir, build_id) |
| 596 | if image_type == ANY: |
| 597 | image_type = self._FindAny(artifact_dir) |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 598 | |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 599 | file_name = LOCAL_ALIAS_TO_FILENAME[image_type] |
| 600 | artifact_path = os.path.join(artifact_dir, file_name) |
| 601 | if not os.path.exists(artifact_path): |
| 602 | raise XBuddyException('Local %s artifact not in static_dir at %s' % |
| 603 | (image_type, artifact_path)) |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 604 | |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 605 | else: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 606 | # Get a remote image. |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 607 | if image_type not in GS_ALIASES: |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 608 | raise XBuddyException('Bad remote image type: %s. Use one of: %s' % |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 609 | (image_type, GS_ALIASES)) |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 610 | file_name = GS_ALIAS_TO_FILENAME[image_type] |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 611 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 612 | # Interpret the version (alias), and get gs address. |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 613 | build_id = self._ResolveVersionToUrl(board, version) |
| 614 | _Log('Found on GS: %s', build_id) |
| 615 | self._GetFromGS(build_id, image_type, lookup_only) |
joychen | f8f07e2 | 2013-07-12 17:45:51 -0700 | [diff] [blame] | 616 | |
joychen | c3944cb | 2013-08-19 10:42:07 -0700 | [diff] [blame] | 617 | return build_id, file_name |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 618 | |
| 619 | ############################ BEGIN PUBLIC METHODS |
| 620 | |
| 621 | def List(self): |
| 622 | """Lists the currently available images & time since last access.""" |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 623 | self._SyncRegistryWithBuildImages() |
| 624 | builds = self._ListBuildTimes() |
| 625 | return_string = '' |
| 626 | for build, timestamp in builds: |
| 627 | return_string += '<b>' + build + '</b> ' |
| 628 | return_string += '(time since last access: ' + str(timestamp) + ')<br>' |
| 629 | return return_string |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 630 | |
| 631 | def Capacity(self): |
| 632 | """Returns the number of images cached by xBuddy.""" |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 633 | return str(self._Capacity()) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 634 | |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 635 | def Translate(self, path_list, board): |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 636 | """Translates an xBuddy path to a real path to artifact if it exists. |
| 637 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 638 | Equivalent to the Get call, minus downloading and updating timestamps, |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 639 | |
joychen | 7c2054a | 2013-07-25 11:14:07 -0700 | [diff] [blame] | 640 | Returns: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 641 | build_id: Path to the image or update directory on the devserver. |
| 642 | e.g. 'x86-generic/R26-4000.0.0' |
| 643 | The returned path is always the path to the directory within |
| 644 | static_dir, so it is always the build_id of the image. |
| 645 | file_name: The file name of the artifact. Can take any of the file |
| 646 | values in devserver_constants. |
| 647 | e.g. 'chromiumos_test_image.bin' or 'update.gz' if the path list |
| 648 | specified 'test' or 'full_payload' artifacts, respectively. |
joychen | 7c2054a | 2013-07-25 11:14:07 -0700 | [diff] [blame] | 649 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 650 | Raises: |
| 651 | XBuddyException: if the path couldn't be translated |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 652 | """ |
| 653 | self._SyncRegistryWithBuildImages() |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 654 | build_id, file_name = self._GetArtifact(path_list, board, lookup_only=True) |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 655 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 656 | _Log('Returning path to payload: %s/%s', build_id, file_name) |
| 657 | return build_id, file_name |
joychen | 346531c | 2013-07-24 16:55:56 -0700 | [diff] [blame] | 658 | |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 659 | def Get(self, path_list): |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 660 | """The full xBuddy call, returns resource specified by path_list. |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 661 | |
| 662 | Please see devserver.py:xbuddy for full documentation. |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 663 | |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 664 | Args: |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 665 | path_list: [board, version, alias] as split from the xbuddy call url |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 666 | |
| 667 | Returns: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 668 | build_id: Path to the image or update directory on the devserver. |
| 669 | e.g. 'x86-generic/R26-4000.0.0' |
| 670 | The returned path is always the path to the directory within |
| 671 | static_dir, so it is always the build_id of the image. |
| 672 | file_name: The file name of the artifact. Can take any of the file |
| 673 | values in devserver_constants. |
| 674 | e.g. 'chromiumos_test_image.bin' or 'update.gz' if the path list |
| 675 | specified 'test' or 'full_payload' artifacts, respectively. |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 676 | |
| 677 | Raises: |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 678 | XBuddyException: if path is invalid |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 679 | """ |
joychen | 7df67f7 | 2013-07-18 14:21:12 -0700 | [diff] [blame] | 680 | self._SyncRegistryWithBuildImages() |
joychen | 562699a | 2013-08-13 15:22:14 -0700 | [diff] [blame] | 681 | build_id, file_name = self._GetArtifact(path_list, self._board) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 682 | |
joychen | 921e1fb | 2013-06-28 11:12:20 -0700 | [diff] [blame] | 683 | Timestamp.UpdateTimestamp(self._timestamp_folder, build_id) |
joychen | 3cb228e | 2013-06-12 12:13:13 -0700 | [diff] [blame] | 684 | #TODO (joyc): run in sep thread |
| 685 | self._CleanCache() |
| 686 | |
joychen | 121fc9b | 2013-08-02 14:30:30 -0700 | [diff] [blame] | 687 | _Log('Returning path to payload: %s/%s', build_id, file_name) |
| 688 | return build_id, file_name |