Derek Beckett | 5fb683c | 2020-08-19 15:24:13 -0700 | [diff] [blame^] | 1 | # Lint as: python2, python3 |
Alex Miller | 0516e4c | 2013-06-03 18:07:48 -0700 | [diff] [blame] | 2 | # Copyright (c) 2013 The Chromium OS Authors. All rights reserved. |
| 3 | # Use of this source code is governed by a BSD-style license that can be |
| 4 | # found in the LICENSE file. |
| 5 | |
Allen Li | 606673f | 2017-02-21 18:41:13 -0800 | [diff] [blame] | 6 | import collections |
Richard Barnette | 6c2b70a | 2017-01-26 13:40:51 -0800 | [diff] [blame] | 7 | import re |
Dan Shi | 7279a5a | 2016-04-07 11:04:28 -0700 | [diff] [blame] | 8 | import sys |
Allen Li | aaabda8 | 2017-02-21 18:27:38 -0800 | [diff] [blame] | 9 | import warnings |
Alex Miller | 0516e4c | 2013-06-03 18:07:48 -0700 | [diff] [blame] | 10 | |
| 11 | import common |
Fang Deng | af30e7c | 2014-11-15 13:57:03 -0800 | [diff] [blame] | 12 | from autotest_lib.server.cros import provision_actionables as actionables |
Allen Li | 89711f7 | 2017-02-21 18:21:52 -0800 | [diff] [blame] | 13 | from autotest_lib.utils import labellib |
| 14 | from autotest_lib.utils.labellib import Key |
Alex Miller | 0516e4c | 2013-06-03 18:07:48 -0700 | [diff] [blame] | 15 | |
| 16 | |
| 17 | ### Constants for label prefixes |
Allen Li | 89711f7 | 2017-02-21 18:21:52 -0800 | [diff] [blame] | 18 | CROS_VERSION_PREFIX = Key.CROS_VERSION |
Rohit Makasana | df0a3a3 | 2017-06-30 13:55:18 -0700 | [diff] [blame] | 19 | CROS_ANDROID_VERSION_PREFIX = Key.CROS_ANDROID_VERSION |
Allen Li | 89711f7 | 2017-02-21 18:21:52 -0800 | [diff] [blame] | 20 | FW_RW_VERSION_PREFIX = Key.FIRMWARE_RW_VERSION |
| 21 | FW_RO_VERSION_PREFIX = Key.FIRMWARE_RO_VERSION |
Mary Ruthven | 7a3b15d | 2019-09-17 18:45:10 -0700 | [diff] [blame] | 22 | FW_CR50_RW_VERSION_PREFIX = Key.FIRMWARE_CR50_RW_VERSION |
Alex Miller | 0516e4c | 2013-06-03 18:07:48 -0700 | [diff] [blame] | 23 | |
Rohit Makasana | df0a3a3 | 2017-06-30 13:55:18 -0700 | [diff] [blame] | 24 | # So far the word cheets is only way to distinguish between ARC and Android |
| 25 | # build. |
Jacob Kopczynski | 92082ea | 2018-07-09 13:49:55 -0700 | [diff] [blame] | 26 | _CROS_ANDROID_BUILD_REGEX = r'.+/cheets.*/P?([0-9]+|LATEST)' |
Richard Barnette | 6c2b70a | 2017-01-26 13:40:51 -0800 | [diff] [blame] | 27 | |
Dan Shi | e44f9c0 | 2016-02-18 13:25:05 -0800 | [diff] [blame] | 28 | # Special label to skip provision and run reset instead. |
| 29 | SKIP_PROVISION = 'skip_provision' |
| 30 | |
Rohit Makasana | df0a3a3 | 2017-06-30 13:55:18 -0700 | [diff] [blame] | 31 | # Postfix -cheetsth to distinguish ChromeOS build during Cheets provisioning. |
| 32 | CHEETS_SUFFIX = '-cheetsth' |
| 33 | |
Namyoon Woo | 5f89466 | 2019-11-15 15:23:23 -0800 | [diff] [blame] | 34 | # ChromeOS image archive server address |
| 35 | CROS_IMAGE_ARCHIVE = 'gs://chromeos-image-archive' |
| 36 | |
| 37 | # ChromeOS firmware branch directory name. %s is for a (base)board name. |
| 38 | FW_BRANCH_GLOB = 'firmware-%s-[0-9]*.B-firmwarebranch' |
Richard Barnette | 71854c7 | 2018-03-30 14:22:09 -0700 | [diff] [blame] | 39 | |
Allen Li | 606673f | 2017-02-21 18:41:13 -0800 | [diff] [blame] | 40 | _Action = collections.namedtuple('_Action', 'name, value') |
| 41 | |
| 42 | |
| 43 | def _get_label_action(str_label): |
| 44 | """Get action represented by the label. |
| 45 | |
| 46 | This is used for determine actions to perform based on labels, for |
| 47 | example for provisioning or repair. |
| 48 | |
| 49 | @param str_label: label string |
| 50 | @returns: _Action instance |
| 51 | """ |
| 52 | try: |
| 53 | keyval_label = labellib.parse_keyval_label(str_label) |
| 54 | except ValueError: |
| 55 | return _Action(str_label, None) |
| 56 | else: |
| 57 | return _Action(keyval_label.key, keyval_label.value) |
| 58 | |
| 59 | |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 60 | ### Helpers to convert value to label |
Richard Barnette | 6c2b70a | 2017-01-26 13:40:51 -0800 | [diff] [blame] | 61 | def get_version_label_prefix(image): |
| 62 | """ |
| 63 | Determine a version label prefix from a given image name. |
| 64 | |
| 65 | Parses `image` to determine what kind of image it refers |
| 66 | to, and returns the corresponding version label prefix. |
| 67 | |
| 68 | Known version label prefixes are: |
| 69 | * `CROS_VERSION_PREFIX` for Chrome OS version strings. |
| 70 | These images have names like `cave-release/R57-9030.0.0`. |
Rohit Makasana | df0a3a3 | 2017-06-30 13:55:18 -0700 | [diff] [blame] | 71 | * `CROS_ANDROID_VERSION_PREFIX` for Chrome OS Android version strings. |
| 72 | These images have names like `git_nyc-arc/cheets_x86-user/3512523`. |
Richard Barnette | 6c2b70a | 2017-01-26 13:40:51 -0800 | [diff] [blame] | 73 | |
| 74 | @param image: The image name to be parsed. |
| 75 | @returns: A string that is the prefix of version labels for the type |
| 76 | of image identified by `image`. |
| 77 | |
| 78 | """ |
Richard Barnette | 66eb19d | 2018-04-30 23:46:52 +0000 | [diff] [blame] | 79 | if re.match(_CROS_ANDROID_BUILD_REGEX, image, re.I): |
Rohit Makasana | df0a3a3 | 2017-06-30 13:55:18 -0700 | [diff] [blame] | 80 | return CROS_ANDROID_VERSION_PREFIX |
Richard Barnette | 6c2b70a | 2017-01-26 13:40:51 -0800 | [diff] [blame] | 81 | else: |
| 82 | return CROS_VERSION_PREFIX |
| 83 | |
| 84 | |
| 85 | def image_version_to_label(image): |
| 86 | """ |
| 87 | Return a version label appropriate to the given image name. |
| 88 | |
| 89 | The type of version label is as determined described for |
| 90 | `get_version_label_prefix()`, meaning the label will identify a |
Richard Barnette | 17fa7c4 | 2018-04-26 00:33:11 +0000 | [diff] [blame] | 91 | CrOS or Android version. |
Richard Barnette | 6c2b70a | 2017-01-26 13:40:51 -0800 | [diff] [blame] | 92 | |
| 93 | @param image: The image name to be parsed. |
| 94 | @returns: A string that is the appropriate label name. |
| 95 | |
| 96 | """ |
| 97 | return get_version_label_prefix(image) + ':' + image |
| 98 | |
| 99 | |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 100 | def fwro_version_to_label(image): |
Dan Shi | 9cb0eec | 2014-06-03 09:04:50 -0700 | [diff] [blame] | 101 | """ |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 102 | Returns the proper label name for a RO firmware build of |image|. |
Tom Wai-Hong Tam | 2d00cb2 | 2016-01-08 06:40:50 +0800 | [diff] [blame] | 103 | |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 104 | @param image: A string of the form 'lumpy-release/R28-3993.0.0' |
| 105 | @returns: A string that is the appropriate label name. |
Tom Wai-Hong Tam | 2d00cb2 | 2016-01-08 06:40:50 +0800 | [diff] [blame] | 106 | |
| 107 | """ |
Allen Li | aaabda8 | 2017-02-21 18:27:38 -0800 | [diff] [blame] | 108 | warnings.warn('fwro_version_to_label is deprecated', stacklevel=2) |
| 109 | keyval_label = labellib.KeyvalLabel(Key.FIRMWARE_RO_VERSION, image) |
| 110 | return labellib.format_keyval_label(keyval_label) |
Tom Wai-Hong Tam | 2d00cb2 | 2016-01-08 06:40:50 +0800 | [diff] [blame] | 111 | |
| 112 | |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 113 | def fwrw_version_to_label(image): |
| 114 | """ |
| 115 | Returns the proper label name for a RW firmware build of |image|. |
Dan Shi | 9cb0eec | 2014-06-03 09:04:50 -0700 | [diff] [blame] | 116 | |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 117 | @param image: A string of the form 'lumpy-release/R28-3993.0.0' |
| 118 | @returns: A string that is the appropriate label name. |
Dan Shi | 9cb0eec | 2014-06-03 09:04:50 -0700 | [diff] [blame] | 119 | |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 120 | """ |
Allen Li | aaabda8 | 2017-02-21 18:27:38 -0800 | [diff] [blame] | 121 | warnings.warn('fwrw_version_to_label is deprecated', stacklevel=2) |
| 122 | keyval_label = labellib.KeyvalLabel(Key.FIRMWARE_RW_VERSION, image) |
| 123 | return labellib.format_keyval_label(keyval_label) |
Dan Shi | 9cb0eec | 2014-06-03 09:04:50 -0700 | [diff] [blame] | 124 | |
| 125 | |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 126 | class _SpecialTaskAction(object): |
Alex Miller | 0516e4c | 2013-06-03 18:07:48 -0700 | [diff] [blame] | 127 | """ |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 128 | Base class to give a template for mapping labels to tests. |
Alex Miller | 0516e4c | 2013-06-03 18:07:48 -0700 | [diff] [blame] | 129 | """ |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 130 | |
Dan Shi | 7279a5a | 2016-04-07 11:04:28 -0700 | [diff] [blame] | 131 | # A dictionary mapping labels to test names. |
| 132 | _actions = {} |
Alex Miller | 0516e4c | 2013-06-03 18:07:48 -0700 | [diff] [blame] | 133 | |
Dan Shi | 7279a5a | 2016-04-07 11:04:28 -0700 | [diff] [blame] | 134 | # The name of this special task to be used in output. |
| 135 | name = None; |
Alex Miller | 0516e4c | 2013-06-03 18:07:48 -0700 | [diff] [blame] | 136 | |
Dan Shi | 7279a5a | 2016-04-07 11:04:28 -0700 | [diff] [blame] | 137 | # Some special tasks require to run before others, e.g., ChromeOS image |
| 138 | # needs to be updated before firmware provision. List `_priorities` defines |
| 139 | # the order of each label prefix. An element with a smaller index has higher |
| 140 | # priority. Not listed ones have the lowest priority. |
| 141 | # This property should be overriden in subclass to define its own priorities |
| 142 | # across available label prefixes. |
| 143 | _priorities = [] |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 144 | |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 145 | |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 146 | @classmethod |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 147 | def acts_on(cls, label): |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 148 | """ |
| 149 | Returns True if the label is a label that we recognize as something we |
| 150 | know how to act on, given our _actions. |
| 151 | |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 152 | @param label: The label as a string. |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 153 | @returns: True if there exists a test to run for this label. |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 154 | """ |
Allen Li | 95e930a | 2017-02-21 18:31:18 -0800 | [diff] [blame] | 155 | action = _get_label_action(label) |
| 156 | return action.name in cls._actions |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 157 | |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 158 | |
| 159 | @classmethod |
Allen Li | 2115458 | 2017-02-22 18:00:42 -0800 | [diff] [blame] | 160 | def run_task_actions(cls, job, host, labels): |
| 161 | """ |
| 162 | Run task actions on host that correspond to the labels. |
| 163 | |
| 164 | Emits status lines for each run test, and INFO lines for each |
| 165 | skipped label. |
| 166 | |
| 167 | @param job: A job object from a control file. |
| 168 | @param host: The host to run actions on. |
| 169 | @param labels: The list of job labels to work on. |
| 170 | @raises: SpecialTaskActionException if a test fails. |
| 171 | """ |
Allen Li | d575f64 | 2017-05-23 13:07:28 -0700 | [diff] [blame] | 172 | unactionable = cls._filter_unactionable_labels(labels) |
Allen Li | 2115458 | 2017-02-22 18:00:42 -0800 | [diff] [blame] | 173 | for label in unactionable: |
| 174 | job.record('INFO', None, cls.name, |
| 175 | "Can't %s label '%s'." % (cls.name, label)) |
| 176 | |
Allen Li | d575f64 | 2017-05-23 13:07:28 -0700 | [diff] [blame] | 177 | for action_item, value in cls._actions_and_values_iter(labels): |
Allen Li | 2115458 | 2017-02-22 18:00:42 -0800 | [diff] [blame] | 178 | success = action_item.execute(job=job, host=host, value=value) |
| 179 | if not success: |
| 180 | raise SpecialTaskActionException() |
| 181 | |
| 182 | |
| 183 | @classmethod |
Allen Li | d575f64 | 2017-05-23 13:07:28 -0700 | [diff] [blame] | 184 | def _actions_and_values_iter(cls, labels): |
| 185 | """Return sorted action and value pairs to run for labels. |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 186 | |
Allen Li | d575f64 | 2017-05-23 13:07:28 -0700 | [diff] [blame] | 187 | @params: An iterable of label strings. |
| 188 | @returns: A generator of Actionable and value pairs. |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 189 | """ |
Allen Li | d575f64 | 2017-05-23 13:07:28 -0700 | [diff] [blame] | 190 | actionable = cls._filter_actionable_labels(labels) |
| 191 | keyval_mapping = labellib.LabelsMapping(actionable) |
| 192 | sorted_names = sorted(keyval_mapping, key=cls._get_action_priority) |
| 193 | for name in sorted_names: |
| 194 | action_item = cls._actions[name] |
| 195 | value = keyval_mapping[name] |
| 196 | yield action_item, value |
| 197 | |
| 198 | |
| 199 | @classmethod |
| 200 | def _filter_unactionable_labels(cls, labels): |
| 201 | """ |
| 202 | Return labels that we cannot act on. |
| 203 | |
| 204 | @param labels: A list of strings of labels. |
| 205 | @returns: A set of unactionable labels |
| 206 | """ |
| 207 | return {label for label in labels |
| 208 | if not (label == SKIP_PROVISION or cls.acts_on(label))} |
| 209 | |
| 210 | |
| 211 | @classmethod |
| 212 | def _filter_actionable_labels(cls, labels): |
| 213 | """ |
| 214 | Return labels that we can act on. |
| 215 | |
| 216 | @param labels: A list of strings of labels. |
| 217 | @returns: A set of actionable labels |
| 218 | """ |
| 219 | return {label for label in labels if cls.acts_on(label)} |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 220 | |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 221 | |
Alex Miller | aa77200 | 2014-04-10 17:51:21 -0700 | [diff] [blame] | 222 | @classmethod |
| 223 | def partition(cls, labels): |
| 224 | """ |
| 225 | Filter a list of labels into two sets: those labels that we know how to |
| 226 | act on and those that we don't know how to act on. |
| 227 | |
| 228 | @param labels: A list of strings of labels. |
| 229 | @returns: A tuple where the first element is a set of unactionable |
| 230 | labels, and the second element is a set of the actionable |
| 231 | labels. |
| 232 | """ |
Allen Li | 5b62312 | 2017-02-22 17:42:02 -0800 | [diff] [blame] | 233 | unactionable = set() |
| 234 | actionable = set() |
Alex Miller | aa77200 | 2014-04-10 17:51:21 -0700 | [diff] [blame] | 235 | |
| 236 | for label in labels: |
Dan Shi | e44f9c0 | 2016-02-18 13:25:05 -0800 | [diff] [blame] | 237 | if label == SKIP_PROVISION: |
| 238 | # skip_provision is neither actionable or a capability label. |
| 239 | # It doesn't need any handling. |
| 240 | continue |
| 241 | elif cls.acts_on(label): |
Allen Li | 5b62312 | 2017-02-22 17:42:02 -0800 | [diff] [blame] | 242 | actionable.add(label) |
Alex Miller | aa77200 | 2014-04-10 17:51:21 -0700 | [diff] [blame] | 243 | else: |
Allen Li | 5b62312 | 2017-02-22 17:42:02 -0800 | [diff] [blame] | 244 | unactionable.add(label) |
Rohit Makasana | c4eacc9 | 2017-09-06 13:49:38 -0700 | [diff] [blame] | 245 | |
Allen Li | 5b62312 | 2017-02-22 17:42:02 -0800 | [diff] [blame] | 246 | return unactionable, actionable |
Alex Miller | aa77200 | 2014-04-10 17:51:21 -0700 | [diff] [blame] | 247 | |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 248 | |
Dan Shi | 7279a5a | 2016-04-07 11:04:28 -0700 | [diff] [blame] | 249 | @classmethod |
Allen Li | d575f64 | 2017-05-23 13:07:28 -0700 | [diff] [blame] | 250 | def _get_action_priority(cls, name): |
| 251 | """Return priority for the action with the given name.""" |
| 252 | if name in cls._priorities: |
| 253 | return cls._priorities.index(name) |
| 254 | else: |
Derek Beckett | 5fb683c | 2020-08-19 15:24:13 -0700 | [diff] [blame^] | 255 | return sys.maxsize |
Dan Shi | 7279a5a | 2016-04-07 11:04:28 -0700 | [diff] [blame] | 256 | |
| 257 | |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 258 | class Verify(_SpecialTaskAction): |
Alex Miller | 0516e4c | 2013-06-03 18:07:48 -0700 | [diff] [blame] | 259 | """ |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 260 | Tests to verify that the DUT is in a sane, known good state that we can run |
| 261 | tests on. Failure to verify leads to running Repair. |
Alex Miller | 0516e4c | 2013-06-03 18:07:48 -0700 | [diff] [blame] | 262 | """ |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 263 | |
| 264 | _actions = { |
Fang Deng | af30e7c | 2014-11-15 13:57:03 -0800 | [diff] [blame] | 265 | 'modem_repair': actionables.TestActionable('cellular_StaleModemReboot'), |
Don Garrett | 6f7e800 | 2015-07-23 22:45:37 +0000 | [diff] [blame] | 266 | # TODO(crbug.com/404421): set rpm action to power_RPMTest after the RPM |
| 267 | # is stable in lab (destiny). The power_RPMTest failure led to reset job |
| 268 | # failure and that left dut in Repair Failed. Since the test will fail |
| 269 | # anyway due to the destiny lab issue, and test retry will retry the |
| 270 | # test in another DUT. |
| 271 | # This change temporarily disable the RPM check in reset job. |
| 272 | # Another way to do this is to remove rpm dependency from tests' control |
| 273 | # file. That will involve changes on multiple control files. This one |
| 274 | # line change here is a simple temporary fix. |
| 275 | 'rpm': actionables.TestActionable('dummy_PassServer'), |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 276 | } |
| 277 | |
| 278 | name = 'verify' |
| 279 | |
| 280 | |
| 281 | class Provision(_SpecialTaskAction): |
| 282 | """ |
| 283 | Provisioning runs to change the configuration of the DUT from one state to |
| 284 | another. It will only be run on verified DUTs. |
| 285 | """ |
| 286 | |
Dan Shi | 7279a5a | 2016-04-07 11:04:28 -0700 | [diff] [blame] | 287 | # ChromeOS update must happen before firmware install, so the dut has the |
| 288 | # correct ChromeOS version label when firmware install occurs. The ChromeOS |
| 289 | # version label is used for firmware update to stage desired ChromeOS image |
| 290 | # on to the servo USB stick. |
| 291 | _priorities = [CROS_VERSION_PREFIX, |
Rohit Makasana | df0a3a3 | 2017-06-30 13:55:18 -0700 | [diff] [blame] | 292 | CROS_ANDROID_VERSION_PREFIX, |
Dan Shi | 7279a5a | 2016-04-07 11:04:28 -0700 | [diff] [blame] | 293 | FW_RO_VERSION_PREFIX, |
Mary Ruthven | 7a3b15d | 2019-09-17 18:45:10 -0700 | [diff] [blame] | 294 | FW_RW_VERSION_PREFIX, |
| 295 | FW_CR50_RW_VERSION_PREFIX] |
Dan Shi | 7279a5a | 2016-04-07 11:04:28 -0700 | [diff] [blame] | 296 | |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 297 | # TODO(milleral): http://crbug.com/249555 |
| 298 | # Create some way to discover and register provisioning tests so that we |
| 299 | # don't need to hand-maintain a list of all of them. |
| 300 | _actions = { |
Fang Deng | 9d54874 | 2015-02-03 11:35:02 -0800 | [diff] [blame] | 301 | CROS_VERSION_PREFIX: actionables.TestActionable( |
| 302 | 'provision_AutoUpdate', |
| 303 | extra_kwargs={'disable_sysinfo': False, |
| 304 | 'disable_before_test_sysinfo': False, |
| 305 | 'disable_before_iteration_sysinfo': True, |
| 306 | 'disable_after_test_sysinfo': True, |
| 307 | 'disable_after_iteration_sysinfo': True}), |
Rohit Makasana | df0a3a3 | 2017-06-30 13:55:18 -0700 | [diff] [blame] | 308 | CROS_ANDROID_VERSION_PREFIX : actionables.TestActionable( |
Rohit Makasana | 37f5cf0 | 2017-06-08 17:21:25 -0700 | [diff] [blame] | 309 | 'provision_CheetsUpdate'), |
Tom Wai-Hong Tam | 9a23761 | 2016-01-08 03:41:46 +0800 | [diff] [blame] | 310 | FW_RO_VERSION_PREFIX: actionables.TestActionable( |
Fang Deng | af30e7c | 2014-11-15 13:57:03 -0800 | [diff] [blame] | 311 | 'provision_FirmwareUpdate'), |
Tom Wai-Hong Tam | 9a23761 | 2016-01-08 03:41:46 +0800 | [diff] [blame] | 312 | FW_RW_VERSION_PREFIX: actionables.TestActionable( |
| 313 | 'provision_FirmwareUpdate', |
Dan Shi | 61e407c | 2016-04-08 14:21:07 -0700 | [diff] [blame] | 314 | extra_kwargs={'rw_only': True, |
| 315 | 'tag': 'rw_only'}), |
Mary Ruthven | 7a3b15d | 2019-09-17 18:45:10 -0700 | [diff] [blame] | 316 | FW_CR50_RW_VERSION_PREFIX: actionables.TestActionable( |
| 317 | 'provision_Cr50TOT') |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 318 | } |
| 319 | |
| 320 | name = 'provision' |
| 321 | |
| 322 | |
| 323 | class Cleanup(_SpecialTaskAction): |
| 324 | """ |
| 325 | Cleanup runs after a test fails to try and remove artifacts of tests and |
| 326 | ensure the DUT will be in a sane state for the next test run. |
| 327 | """ |
| 328 | |
| 329 | _actions = { |
Fang Deng | af30e7c | 2014-11-15 13:57:03 -0800 | [diff] [blame] | 330 | 'cleanup-reboot': actionables.RebootActionable(), |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 331 | } |
| 332 | |
| 333 | name = 'cleanup' |
| 334 | |
| 335 | |
Allen Li | 28c303c | 2019-01-04 16:56:26 -0800 | [diff] [blame] | 336 | # TODO(ayatane): This class doesn't do anything. It's safe to remove |
| 337 | # after all references to it are removed (after some buffer time to be |
| 338 | # safe, like a few release cycles). |
Alex Miller | 1968edf | 2014-02-27 18:11:36 -0800 | [diff] [blame] | 339 | class Repair(_SpecialTaskAction): |
| 340 | """ |
| 341 | Repair runs when one of the other special tasks fails. It should be able |
| 342 | to take a component of the DUT that's in an unknown state and restore it to |
| 343 | a good state. |
| 344 | """ |
| 345 | |
| 346 | _actions = { |
| 347 | } |
| 348 | |
| 349 | name = 'repair' |
| 350 | |
| 351 | |
Alex Miller | aa77200 | 2014-04-10 17:51:21 -0700 | [diff] [blame] | 352 | # TODO(milleral): crbug.com/364273 |
| 353 | # Label doesn't really mean label in this context. We're putting things into |
| 354 | # DEPENDENCIES that really aren't DEPENDENCIES, and we should probably stop |
| 355 | # doing that. |
| 356 | def is_for_special_action(label): |
| 357 | """ |
| 358 | If any special task handles the label specially, then we're using the label |
| 359 | to communicate that we want an action, and not as an actual dependency that |
| 360 | the test has. |
| 361 | |
| 362 | @param label: A string label name. |
| 363 | @return True if any special task handles this label specially, |
| 364 | False if no special task handles this label. |
| 365 | """ |
| 366 | return (Verify.acts_on(label) or |
| 367 | Provision.acts_on(label) or |
| 368 | Cleanup.acts_on(label) or |
Dan Shi | e44f9c0 | 2016-02-18 13:25:05 -0800 | [diff] [blame] | 369 | Repair.acts_on(label) or |
| 370 | label == SKIP_PROVISION) |
Alex Miller | 0516e4c | 2013-06-03 18:07:48 -0700 | [diff] [blame] | 371 | |
| 372 | |
Prathmesh Prabhu | 2c7471d | 2016-11-15 20:19:57 +0000 | [diff] [blame] | 373 | def join(provision_type, provision_value): |
| 374 | """ |
| 375 | Combine the provision type and value into the label name. |
| 376 | |
| 377 | @param provision_type: One of the constants that are the label prefixes. |
| 378 | @param provision_value: A string of the value for this provision type. |
| 379 | @returns: A string that is the label name for this (type, value) pair. |
| 380 | |
| 381 | >>> join(CROS_VERSION_PREFIX, 'lumpy-release/R27-3773.0.0') |
| 382 | 'cros-version:lumpy-release/R27-3773.0.0' |
| 383 | |
| 384 | """ |
| 385 | return '%s:%s' % (provision_type, provision_value) |
| 386 | |
| 387 | |
Alex Miller | 667b5f2 | 2014-02-28 15:33:39 -0800 | [diff] [blame] | 388 | class SpecialTaskActionException(Exception): |
| 389 | """ |
| 390 | Exception raised when a special task fails to successfully run a test that |
| 391 | is required. |
| 392 | |
| 393 | This is also a literally meaningless exception. It's always just discarded. |
| 394 | """ |