platform_hardware_interfaces/scripts/list_hal_vts.py

#!/usr/bin/python3

"""
List VTS tests for each HAL by parsing module-info.json.

Example usage:

  # First, build modules-info.json
  m -j "${ANDROID_PRODUCT_OUT#$ANDROID_BUILD_TOP/}/module-info.json"

  # List with pretty-printed JSON. *IDL packages without a VTS module will show up
  # as keys with empty lists.
  ./list_hals_vts.py | python3 -m json.tool

  # List with CSV. *IDL packages without a VTS module will show up as a line with
  # empty value in the VTS module column.
  ./list_hals_vts.py --csv
"""

import argparse
import collections
import csv
import io
import json
import os
import logging
import pathlib
import re
import sys

PATH_PACKAGE_PATTERN = re.compile(
  r'^hardware/interfaces/(?P<path>(?:\w+/)*?)(?:aidl|(?P<version>\d+\.\d+))/.*')


class CriticalHandler(logging.StreamHandler):
  def emit(self, record):
    super(CriticalHandler, self).emit(record)
    if record.levelno >= logging.CRITICAL:
      sys.exit(1)


logger = logging.getLogger(__name__)
logger.addHandler(CriticalHandler())


def default_json():
  out = os.environ.get('ANDROID_PRODUCT_OUT')
  if not out: return None
  return os.path.join(out, 'module-info.json')


def infer_package(path):
  """
  Infer package from a relative path from build top where a VTS module lives.

  :param path: a path like 'hardware/interfaces/vibrator/aidl/vts'
  :return: The inferred *IDL package, e.g. 'android.hardware.vibrator'

  >>> infer_package('hardware/interfaces/automotive/sv/1.0/vts/functional')
  'android.hardware.automotive.sv@1.0'
  >>> infer_package('hardware/interfaces/vibrator/aidl/vts')
  'android.hardware.vibrator'
  """
  mo = re.match(PATH_PACKAGE_PATTERN, path)
  if not mo: return None
  package = 'android.hardware.' + ('.'.join(pathlib.Path(mo.group('path')).parts))
  if mo.group('version'):
    package += '@' + mo.group('version')
  return package


def load_modules_info(json_file):
  """
  :param json_file: The path to modules-info.json
  :return: a dictionary, where the keys are inferred *IDL package names, and
           values are a list of VTS modules with that inferred package name.
  """
  with open(json_file) as fp:
    root = json.load(fp)
    ret = collections.defaultdict(list)
    for module_name, module_info in root.items():
      if 'vts' not in module_info.get('compatibility_suites', []):
        continue
      for path in module_info.get('path', []):
        inferred_package = infer_package(path)
        if not inferred_package:
          continue
        ret[inferred_package].append(module_name)
    return ret


def add_missing_idl(vts_modules):
  top = os.environ.get("ANDROID_BUILD_TOP")
  interfaces = None
  if top:
    interfaces = os.path.join(top, "hardware", "interfaces")
  else:
    logger.warning("Missing ANDROID_BUILD_TOP")
    interfaces = "hardware/interfaces"
  if not os.path.isdir(interfaces):
    logger.error("Not adding missing *IDL modules because missing hardware/interfaces dir")
    return
  assert not interfaces.endswith(os.path.sep)
  for root, dirs, files in os.walk(interfaces):
    for dir in dirs:
      full_dir = os.path.join(root, dir)
      assert full_dir.startswith(interfaces)
      top_rel_dir = os.path.join('hardware', 'interfaces', full_dir[len(interfaces) + 1:])
      inferred_package = infer_package(top_rel_dir)
      if inferred_package is None:
        continue
      if inferred_package not in vts_modules:
        vts_modules[inferred_package] = []


def main():
  parser = argparse.ArgumentParser(__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
  parser.add_argument('json', metavar='module-info.json', default=default_json(), nargs='?')
  parser.add_argument('--csv', action='store_true', help='Print CSV. If not specified print JSON.')
  args = parser.parse_args()
  if not args.json:
    logger.critical('No module-info.json is specified or found.')
  vts_modules = load_modules_info(args.json)
  add_missing_idl(vts_modules)

  if args.csv:
    out = io.StringIO()
    writer = csv.writer(out, )
    writer.writerow(["package", "vts_module"])
    for package, modules in vts_modules.items():
      if not modules:
        writer.writerow([package, ""])
      for module in modules:
        writer.writerow([package, module])
    result = out.getvalue()
  else:
    result = json.dumps(vts_modules)

  print(result)


if __name__ == '__main__':
  main()