Replace Chrome OS code names with board names to avoid checking multiple codenames for the same recovery image.

Author: horstle

lib/inputstreamhelper/config.py

@@ -84,53 +84,22 @@
 # https://www.chromium.org/chromium-os/developer-information-for-chrome-os-devices
 # https://chromiumdash.appspot.com/serving-builds?deviceCategory=Chrome%20OS
 # Last updated: 2023-03-24
-CHROMEOS_RECOVERY_ARM_HWIDS = [
-    'BOB',
-    'BURNET',
-    'COACHZ',
-    'COZMO',
-    'DAMU',
-    'DOJO-EJPG',
-    'DRUWL',
-    'DUMO',
-    'ELM',
-    'ESCHE',
-    'FENNEL',
-    'FENNEL14',
-    'HANA',
-    'HAYATO-YLRO',
-    'HOMESTAR-MBLE',
-    'JUNIPER-HVPU',
-    'KAKADU-WFIQ',
-    'KAPPA',
-    'KAPPA-EWFK',
-    'KATSU',
-    'KENZO-IGRW',
-    'KEVIN',
-    'KODAMA',
-    'KRANE-ZDKS',
-    'MAKOMO-UTTX',
-    'PICO-EXEM',
-    'QUACKINGSTICK',
-    'SCARLET',
-    'SPHERION',
-    'TOMATO-LYVN',
-    'WILLOW-TFIY',
-    'WORMDINGLER-JQAO',
+CHROMEOS_RECOVERY_ARM_BNAMES = [
+    'asurada',
+    'bob',
+    'cherry',
+    'elm',
+    'hana',
+    'jacuzzi',
+    'kevin',
+    'kukui',
+    'scarlet',
+    'strongbad',
 ]
 
-CHROMEOS_RECOVERY_ARM64_HWIDS = [
-    'KINGOFTOWN-KDDA',
-    'LAZOR',
-    'LIMOZEEN',
-    'MAGNETON-LCKC',
-    'PAZQUEL-HGNV',
-    'PAZQUEL-OPNA',
-    'POMPOM-MZVS',
-    'RUSTY-ZNCE',
-    'STEELIX-VZSZ',
-    'TENTACOOL-ZLJE',
-    'TENTACRUEL-VAFH',
+CHROMEOS_RECOVERY_ARM64_BNAMES = [
+    'corsola',
+    'trogdor',
 ]
 
 MINIMUM_INPUTSTREAM_VERSION_ARM64 = {

lib/inputstreamhelper/widevine/arm.py

@@ -17,47 +17,44 @@ def select_best_chromeos_image(devices):
     log(0, 'Find best ARM image to use from the Chrome OS recovery.json')
 
     if userspace64():
-        arm_hwids = config.CHROMEOS_RECOVERY_ARM64_HWIDS
+        arm_bnames = config.CHROMEOS_RECOVERY_ARM64_BNAMES
     else:
-        arm_hwids = config.CHROMEOS_RECOVERY_ARM_HWIDS
+        arm_bnames = config.CHROMEOS_RECOVERY_ARM_BNAMES
 
-    arm_hwids = [h for arm_hwid in arm_hwids for h in ['^{} '.format(arm_hwid), '^{}-.*'.format(arm_hwid), '^{}.*'.format(arm_hwid)]]
     best = None
     for device in devices:
         # Select ARM hardware only
-        for arm_hwid in arm_hwids:
-            if arm_hwid in device['hwidmatch']:
-                hwid = arm_hwid
+        for arm_bname in arm_bnames:
+            if arm_bname == device['file'].split('_')[2]:
+                device['boardname'] = arm_bname  # add this new entry to avoid extracting it from the filename all the time
                 break  # We found an ARM device, rejoice !
         else:
             continue  # Not ARM, skip this device
 
-        device['hwid'] = hwid
-
         # Select the first ARM device
         if best is None:
             best = device
             continue  # Go to the next device
 
-        # Skip identical hwid
-        if hwid == best['hwid']:
+        # Skip identical boardname
+        if device['boardname'] == best['boardname']:
             continue
 
         # Select the newest version
         if parse_version(device['version']) > parse_version(best['version']):
-            log(0, '{device[hwid]} ({device[version]}) is newer than {best[hwid]} ({best[version]})',
+            log(0, '{device[boardname]} ({device[version]}) is newer than {best[boardname]} ({best[version]})',
                 device=device,
                 best=best)
             best = device
 
         # Select the smallest image (disk space requirement)
         elif parse_version(device['version']) == parse_version(best['version']):
-            if int(device['filesize']) + int(device['zipfilesize']) < int(best['filesize']) + int(best['zipfilesize']):
-                log(0, '{device[hwid]} ({device_size}) is smaller than {best[hwid]} ({best_size})',
+            if int(device['zipfilesize']) < int(best['zipfilesize']):
+                log(0, '{device[boardname]} ({device_size}) is smaller than {best[boardname]} ({best_size})',
                     device=device,
+                    device_size=int(device['zipfilesize']),
                     best=best,
-                    device_size=int(device['filesize']) + int(device['zipfilesize']),
-                    best_size=int(best['filesize']) + int(best['zipfilesize']))
+                    best_size=int(best['zipfilesize']))
                 best = device
 
     return best
@@ -96,7 +93,7 @@ def install_widevine_arm(backup_path):
                       localize(30018, diskspace=sizeof_fmt(required_diskspace)))
             return False
 
-        log(2, 'Downloading ChromeOS image for Widevine: {hwid} ({version})'.format(**arm_device))
+        log(2, 'Downloading ChromeOS image for Widevine: {boardname} ({version})'.format(**arm_device))
         url = arm_device['url']
 
         extracted = dl_extract_widevine(url, backup_path, arm_device)

tests/checkchromeos.py

@@ -4,7 +4,7 @@
 from __future__ import absolute_import, division, print_function, unicode_literals
 from xml.etree import ElementTree as ET
 import requests
-from lib.inputstreamhelper.config import CHROMEOS_RECOVERY_ARM_HWIDS, CHROMEOS_RECOVERY_ARM64_HWIDS
+from lib.inputstreamhelper.config import CHROMEOS_RECOVERY_ARM_BNAMES, CHROMEOS_RECOVERY_ARM64_BNAMES, CHROMEOS_RECOVERY_URL
 
 
 class OutdatedException(Exception):
@@ -33,9 +33,8 @@ def get_devices():
             device[keys[num]] = None
             if value.text:
                 device[keys[num]] = value.text.strip()
-            elif value.find('a') is not None:
-                if value.find('a').text is not None:
-                    device[keys[num]] = value.find('a').text.strip()
+            elif value.find('a') is not None and value.find('a').text is not None:
+                device[keys[num]] = value.find('a').text.strip()
         devices.append(device)
     return devices
 
@@ -61,8 +60,7 @@ def get_serves():
 
 def get_recoveries():
     """Get Chrome OS recovery items as json object"""
-    url = 'https://dl.google.com/dl/edgedl/chromeos/recovery/recovery.json'
-    response = requests.get(url, timeout=10)
+    response = requests.get(CHROMEOS_RECOVERY_URL, timeout=10)
     response.raise_for_status()
     recoveries = response.json()
     return recoveries
@@ -98,33 +96,33 @@ def get_smallest():
     return smallest
 
 
-def check_hwids():
-    """Check if hardware id's in inputstreamhelper.config are up to date"""
+def check_boardnames():
+    """Check if boardnames in inputstreamhelper.config are up to date"""
     compatibles = get_compatibles()
-    hwids = []
+    bnames = []
     messages = []
     for compatible in compatibles:
-        hwid = compatible.get('hwidmatch').strip('^.*-').split(' ')[0]
-        if hwid not in hwids:
-            hwids.append(hwid)
+        bname = compatible.get('file').split('_')[2]
+        if bname not in bnames:
+            bnames.append(bname)
 
-    for item in CHROMEOS_RECOVERY_ARM_HWIDS + CHROMEOS_RECOVERY_ARM64_HWIDS:
-        if item not in hwids:
+    for item in CHROMEOS_RECOVERY_ARM_BNAMES + CHROMEOS_RECOVERY_ARM64_BNAMES:
+        if item not in bnames:
             messages.append('{} is end-of-life, consider removing it from inputstreamhelper config'.format(item))
-    for item in hwids:
-        if item not in CHROMEOS_RECOVERY_ARM_HWIDS + CHROMEOS_RECOVERY_ARM64_HWIDS:
+    for item in bnames:
+        if item not in CHROMEOS_RECOVERY_ARM_BNAMES + CHROMEOS_RECOVERY_ARM64_BNAMES:
             messages.append('{} is missing, please add it to inputstreamhelper config'.format(item))
     if messages:
         raise OutdatedException(messages)
 
     smallest = get_smallest()
-    hwid = smallest.get('hwidmatch').strip('^.*-').split(' ')[0]
-    print('Chrome OS hardware id\'s are up to date, current smallest recovery image is {}'.format(hwid))
+    bname = smallest.get('file').split('_')[2]
+    print('Chrome OS boardnames are up to date, current smallest recovery image is {}'.format(bname))
 
 
 def run():
     """Main function"""
-    check_hwids()
+    check_boardnames()
 
 
 if __name__ == '__main__':