prebuilt_hashes/dump_hals_for_release.py

#!/usr/bin/env python
#
# Copyright (C) 2018 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

"""
Dump new HIDL types that are introduced in each dessert release.
"""

from __future__ import print_function

import argparse
import collections
import json
import os
import re

class Globals:
    pass

class Constants:
    CURRENT = 'current'
    HAL_PATH_PATTERN = r'/((?:[a-zA-Z_][a-zA-Z0-9_]*/)*)(\d+\.\d+)/([a-zA-Z_][a-zA-Z0-9_]*).hal'
    CURRENT_TXT_PATTERN = r'(?:.*/)?([0-9]+|current).txt'

def trim_trailing_comments(line):
    idx = line.find('#')
    if idx < 0: return line
    return line[0:idx]

def strip_begin(s, prefix):
    if s.startswith(prefix):
        return strip_begin(s[len(prefix):], prefix)
    return s

def strip_end(s, suffix):
    if s.endswith(suffix):
        return strip_end(s[0:-len(suffix)], suffix)
    return s

def get_interfaces(file_name):
    with open(file_name) as file:
        for line in file:
            line_tokens = trim_trailing_comments(line).strip().split()
            if not line_tokens:
                continue
            assert len(line_tokens) == 2, \
                "Unrecognized line in file {}:\n{}".format(file_name, line)
            yield line_tokens[1]

def api_level_to_int(api_level):
    try:
        if api_level == Constants.CURRENT: return float('inf')
        return int(api_level)
    except ValueError:
        return None

def get_interfaces_from_package_root(package, root):
    root = strip_end(root, '/')
    for dirpath, _, filenames in os.walk(root, topdown=False):
        dirpath = strip_begin(dirpath, root)
        for filename in filenames:
            filepath = os.path.join(dirpath, filename)
            mo = re.match(Constants.HAL_PATH_PATTERN, filepath)
            if not mo:
                continue
            yield '{}.{}@{}::{}'.format(
                package, mo.group(1).strip('/').replace('/', '.'), mo.group(2), mo.group(3))

def filter_out(iterable):
    return iterable if not Globals.filter_out else filter(
        lambda s: all(re.search(pattern, s) is None for pattern in Globals.filter_out),
        iterable)

def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--pretty', help='Print pretty JSON', action='store_true')
    parser.add_argument('--package-root', metavar='PACKAGE:PATH', nargs='*',
        help='package root of current directory, e.g. android.hardware:hardware/interfaces')
    parser.add_argument('--filter-out', metavar='REGEX', nargs='*',
        help='A regular expression that filters out interfaces.')
    parser.add_argument('hashes', metavar='FILE', nargs='*',
        help='Locations of current.txt for each release.')
    parser.parse_args(namespace=Globals)

    interfaces_for_level = dict()

    for filename in Globals.hashes or tuple():
        mo = re.match(Constants.CURRENT_TXT_PATTERN, filename)
        assert mo is not None, \
            'Input hash file names must have the format {} but is {}'.format(Constants.CURRENT_TXT_PATTERN, filename)

        api_level = mo.group(1)
        assert api_level_to_int(api_level) is not None

        if api_level not in interfaces_for_level:
            interfaces_for_level[api_level] = set()
        interfaces_for_level[api_level].update(filter_out(get_interfaces(filename)))

    for package_root in Globals.package_root or tuple():
        tup = package_root.split(':')
        assert len(tup) == 2, \
            '--package-root must have the format PACKAGE:PATH, but is {}'.format(package_root)
        if Constants.CURRENT not in interfaces_for_level:
            interfaces_for_level[Constants.CURRENT] = set()
        interfaces_for_level[Constants.CURRENT].update(filter_out(get_interfaces_from_package_root(*tup)))

    seen_interfaces = set()
    new_interfaces_for_level = collections.OrderedDict()
    for level, interfaces in sorted(interfaces_for_level.items(), key=lambda tup: api_level_to_int(tup[0])):
        if level != Constants.CURRENT:
            removed_interfaces = seen_interfaces - interfaces
            assert not removed_interfaces, \
                "The following interfaces are removed from API level {}:\n{}".format(
                    level, removed_interfaces)
        new_interfaces_for_level[level] = sorted(interfaces - seen_interfaces)
        seen_interfaces.update(interfaces)

    print(json.dumps(new_interfaces_for_level,
        separators=None if Globals.pretty else (',',':'),
        indent=4 if Globals.pretty else None))

if __name__ == '__main__':
    main()