# Copyright 2017 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.
|
|
"""This module provides standard functions for working with Autotest labels.
|
|
There are two types of labels, plain ("webcam") or keyval
|
("pool:suites"). Most of this module's functions work with keyval
|
labels.
|
|
Most users should use LabelsMapping, which provides a dict-like
|
interface for working with keyval labels.
|
|
This module also provides functions for working with cros version
|
strings, which are common keyval label values.
|
"""
|
|
import collections
|
import re
|
|
|
class Key(object):
|
"""Enum for keyval label keys."""
|
CROS_VERSION = 'cros-version'
|
CROS_ANDROID_VERSION = 'cheets-version'
|
FIRMWARE_RW_VERSION = 'fwrw-version'
|
FIRMWARE_RO_VERSION = 'fwro-version'
|
|
|
class LabelsMapping(collections.MutableMapping):
|
"""dict-like interface for working with labels.
|
|
The constructor takes an iterable of labels, either plain or keyval.
|
Plain labels are saved internally and ignored except for converting
|
back to string labels. Keyval labels are exposed through a
|
dict-like interface (pop(), keys(), items(), etc. are all
|
supported).
|
|
When multiple keyval labels share the same key, the first one wins.
|
|
The one difference from a dict is that setting a key to None will
|
delete the corresponding keyval label, since it does not make sense
|
for a keyval label to have a None value. Prefer using del or pop()
|
instead of setting a key to None.
|
|
LabelsMapping has one method getlabels() for converting back to
|
string labels.
|
"""
|
|
def __init__(self, str_labels=()):
|
self._plain_labels = []
|
self._keyval_map = collections.OrderedDict()
|
for str_label in str_labels:
|
self._add_label(str_label)
|
|
@classmethod
|
def from_host(cls, host):
|
"""Create instance using a frontend.afe.models.Host object."""
|
return cls(l.name for l in host.labels.all())
|
|
def _add_label(self, str_label):
|
"""Add a label string to the internal map or plain labels list."""
|
try:
|
keyval_label = parse_keyval_label(str_label)
|
except ValueError:
|
self._plain_labels.append(str_label)
|
else:
|
if keyval_label.key not in self._keyval_map:
|
self._keyval_map[keyval_label.key] = keyval_label.value
|
|
def __getitem__(self, key):
|
return self._keyval_map[key]
|
|
def __setitem__(self, key, val):
|
if val is None:
|
self.pop(key, None)
|
else:
|
self._keyval_map[key] = val
|
|
def __delitem__(self, key):
|
del self._keyval_map[key]
|
|
def __iter__(self):
|
return iter(self._keyval_map)
|
|
def __len__(self):
|
return len(self._keyval_map)
|
|
def getlabels(self):
|
"""Return labels as a list of strings."""
|
str_labels = self._plain_labels[:]
|
keyval_labels = (KeyvalLabel(key, value)
|
for key, value in self.iteritems())
|
str_labels.extend(format_keyval_label(label)
|
for label in keyval_labels)
|
return str_labels
|
|
|
_KEYVAL_LABEL_SEP = ':'
|
|
|
KeyvalLabel = collections.namedtuple('KeyvalLabel', 'key, value')
|
|
|
def parse_keyval_label(str_label):
|
"""Parse a string as a KeyvalLabel.
|
|
If the argument is not a valid keyval label, ValueError is raised.
|
"""
|
key, value = str_label.split(_KEYVAL_LABEL_SEP, 1)
|
return KeyvalLabel(key, value)
|
|
|
def format_keyval_label(keyval_label):
|
"""Format a KeyvalLabel as a string."""
|
return _KEYVAL_LABEL_SEP.join(keyval_label)
|
|
|
CrosVersion = collections.namedtuple(
|
'CrosVersion', 'group, board, milestone, version, rc')
|
|
|
_CROS_VERSION_REGEX = (
|
r'^'
|
r'(?P<group>[a-z0-9_-]+)'
|
r'/'
|
r'(?P<milestone>R[0-9]+)'
|
r'-'
|
r'(?P<version>[0-9.]+)'
|
r'(-(?P<rc>rc[0-9]+))?'
|
r'$'
|
)
|
|
_CROS_BOARD_FROM_VERSION_REGEX = (
|
r'^'
|
r'(trybot-)?'
|
r'(?P<board>[a-z_-]+)-(release|paladin|pre-cq|test-ap|toolchain)'
|
r'/R.*'
|
r'$'
|
)
|
|
|
def parse_cros_version(version_string):
|
"""Parse a string as a CrosVersion.
|
|
If the argument is not a valid cros version, ValueError is raised.
|
Example cros version string: 'lumpy-release/R27-3773.0.0-rc1'
|
"""
|
match = re.search(_CROS_VERSION_REGEX, version_string)
|
if match is None:
|
raise ValueError('Invalid cros version string: %r' % version_string)
|
parts = match.groupdict()
|
match = re.search(_CROS_BOARD_FROM_VERSION_REGEX, version_string)
|
if match is None:
|
raise ValueError('Invalid cros version string: %r. Failed to parse '
|
'board.' % version_string)
|
parts['board'] = match.group('board')
|
return CrosVersion(**parts)
|
|
|
def format_cros_version(cros_version):
|
"""Format a CrosVersion as a string."""
|
if cros_version.rc is not None:
|
return '{group}/{milestone}-{version}-{rc}'.format(
|
**cros_version._asdict())
|
else:
|
return '{group}/{milestone}-{version}'.format(**cros_version._asdict())
|
