| #!/usr/bin/env python2 |
| # Copyright 2020 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 logging |
| |
| import common |
| import base |
| from autotest_lib.server.cros.storage import storage_validate as storage |
| |
| |
| DUT_STORAGE_STATE_PREFIX = 'storage_state' |
| SERVO_USB_STATE_PREFIX = 'servo_usb_state' |
| VERIFY_STATE_NORMAL = 'NORMAL' |
| VERIFY_STATE_ACCEPTABLE = 'ACCEPTABLE' |
| VERIFY_STATE_NEED_REPLACEMENT = 'NEED_REPLACEMENT' |
| VERIFY_STATE_UNKNOWN = 'UNKNOWN' |
| |
| |
| class VerifyDutStorage(base._BaseDUTVerifier): |
| """Verify the state of the storage on the DUT |
| |
| The process to determine the type of storage and read metrics |
| of usage and EOL(end-of-life) information to determine the |
| state. |
| Supported storage types: MMS, NVME, SSD. |
| Possible states are: |
| UNKNOWN - not access to the DUT, not determine type of storage, |
| not information to determine metrics |
| NORMAL - the storage is in good shape and will work stable |
| device will work stable. (supported for all types) |
| ACCEPTABLE - the storage almost used all resources, device will |
| work stable but it is better be ready for replacement |
| device will work stable. (supported by MMS, NVME) |
| NEED_REPLACEMENT - the storage broken or worn off the life limit |
| device can work by not stable and can cause the |
| flakiness on the tests. (supported by all types) |
| """ |
| def _verify(self): |
| try: |
| validator = storage.StorageStateValidator(self.get_host()) |
| storage_type = validator.get_type() |
| logging.debug('Detected storage type: %s', storage_type) |
| storage_state = validator.get_state() |
| logging.debug('Detected storage state: %s', storage_state) |
| state = self.convert_state(storage_state) |
| if state: |
| self._set_host_info_state(DUT_STORAGE_STATE_PREFIX, state) |
| except Exception as e: |
| raise base.AuditError('Exception during getting state of' |
| ' storage %s' % str(e)) |
| |
| def convert_state(self, state): |
| """Mapping state from validator to verifier""" |
| if state == storage.STORAGE_STATE_NORMAL: |
| return VERIFY_STATE_NORMAL |
| if state == storage.STORAGE_STATE_WARNING: |
| return VERIFY_STATE_ACCEPTABLE |
| if state == storage.STORAGE_STATE_CRITICAL: |
| return VERIFY_STATE_NEED_REPLACEMENT |
| return None |
| |
| |
| class VerifyServoUsb(base._BaseServoVerifier): |
| """Verify the state of the USB-drive on the Servo |
| |
| The process to determine by checking the USB-drive on having any |
| bad sectors on it. |
| Possible states are: |
| UNKNOWN - not access to the device or servo, not available |
| software on the servo. |
| NORMAL - the device available for testing and not bad sectors. |
| was found on it, device will work stable |
| NEED_REPLACEMENT - the device available for testing and |
| some bad sectors were found on it. The device can |
| work but cause flakiness in the tests or repair process. |
| |
| """ |
| def _verify(self): |
| state = VERIFY_STATE_UNKNOWN |
| # implementation will come later |
| self._set_host_info_state(SERVO_USB_STATE_PREFIX, state) |