| #!/usr/bin/env python3.8 |
| # Copyright 2020 The Fuchsia Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| """A helper script for CTS dependency verification. |
| |
| The Compatibility Test Suite (CTS) has strict rules on GN dependencies. A CTS target may only depend |
| on other CTS targets and carefully selected dependencies listed in ALLOWED_CTS_DEPS. |
| |
| The CTS creates a CTS file for each CTS target at GN gen time. This CTS file is used to indicate |
| that a target is acceptable in CTS. Each CTS target verifies its own dependencies using this script. |
| If a dependency does not have a CTS file, the script will look for that fully qualified dependency |
| in ALLOWED_CTS_DEPS. If it does have a CTS file, verification of that target will be deferred such |
| that the target may verify its own dependencies. |
| """ |
| |
| import argparse |
| import json |
| import os |
| import re |
| import sys |
| |
| CTS_EXTENSION = '.this_is_cts' |
| |
| |
| class VerifyCtsDeps: |
| """Helper class to verify GN dependencies in CTS. |
| |
| Args: |
| root_build_dir (string): An absolute path to the GN's $root_build_dir. |
| cts_file (string): The path to (including) the file to be generated. |
| invoker_label (string): The label of the invoker of cts_element. |
| deps (list(string)): A list of fully qualified GN labels. |
| allowed_cts_deps(list(string)): A list of allowed deps found in //sdk/cts/allowed_cts_deps.gni" |
| allowed_cts_dirs(list(string)): A list of allowed directories found in //sdk/cts/allowed_cts_dirs.gni" |
| sdk_manifests(list(string)): A list of absolute paths to SDK manifest files. |
| |
| Raises: ValueError if any parameter is empty, if root_build_dir does not exist, or if the sdk_manifests do not exist. |
| """ |
| |
| def __init__(self, root_build_dir, cts_file, invoker_label, deps, |
| allowed_cts_deps, allowed_cts_dirs, sdk_manifests): |
| if root_build_dir and os.path.exists(root_build_dir): |
| self.root_build_dir = root_build_dir |
| else: |
| raise ValueError('root_build_dir cannot be empty and must exist.') |
| |
| if cts_file: |
| self.cts_file = cts_file |
| else: |
| raise ValueError('cts_file cannot be empty.') |
| |
| if invoker_label: |
| self.invoker_label = invoker_label |
| else: |
| raise ValueError('invoker_label cannot be empty.') |
| |
| if deps: |
| self.deps = deps |
| else: |
| raise ValueError('deps cannot be empty.') |
| |
| if allowed_cts_deps: |
| self.allowed_cts_deps = allowed_cts_deps |
| else: |
| raise ValueError('allowed_cts_deps cannot be empty') |
| |
| if allowed_cts_dirs: |
| self.allowed_cts_dirs = allowed_cts_dirs |
| else: |
| raise ValueError('allowed_cts_dirs cannot be empty') |
| |
| if sdk_manifests: |
| for manifest in sdk_manifests: |
| if not os.path.isfile(manifest): |
| raise ValueError('manifest %s does not exist' % manifest) |
| self.sdk_manifests = sdk_manifests |
| else: |
| raise ValueError('sdk_manifests cannot be empty') |
| |
| def get_file_path(self, dep): |
| """Returns the path to a CTS file. |
| |
| Args: |
| dep (string): A GN label. |
| |
| Returns: |
| A string containing the absolute path to the target's CTS file. |
| """ |
| |
| # Remove the leading slashes from the label. |
| dep = dep[2:] |
| |
| # Get the target_name from the label. |
| if ':' in dep: |
| # zircon/public/lib/zxtest:zxtest |
| dep, target_name = dep.split(':') |
| elif '/' in dep: |
| # zircon/public/lib/zxtest |
| _, target_name = dep.rsplit('/', 1) |
| else: |
| # sdk |
| target_name = dep |
| |
| return self.root_build_dir + '/cts/' + dep + '/' + target_name + CTS_EXTENSION |
| |
| def verify_deps(self): |
| """Verifies the element's dependencies are allowed in CTS. |
| |
| CTS has strict dependency rules. All dependencies must be in ALLOWED_CTS_DEPS or be CTS |
| targets themselves. |
| |
| Returns: |
| A list of labels that are unaccepted in CTS. The list will be empty if all deps are allowed. |
| """ |
| unaccepted_deps = [] |
| for dep in self.deps: |
| dep_found = False |
| |
| if dep in self.allowed_cts_deps or os.path.exists( |
| self.get_file_path(dep)): |
| dep_found = True |
| else: |
| # Dep isn't in the allow list and a CTS file doesn't exist. Check if |
| # all targets in dep's directory are allowed (//third_party/dart-pkg/pub/*). |
| for allowed_dir in self.allowed_cts_dirs: |
| pattern = re.compile(allowed_dir) |
| if pattern.match(dep): |
| dep_found = True |
| |
| # Check if dep is an SDK target. |
| if not dep_found: |
| dep_found = self.verify_dep_in_sdk(dep) |
| |
| if not dep_found: |
| unaccepted_deps.append(dep) |
| |
| return unaccepted_deps |
| |
| def verify_dep_in_sdk(self, dep): |
| """Verifies that a dependency is released in an SDK. |
| |
| Looks for the dependency in the the list of SDK manifests. |
| |
| Returns: |
| A boolean determining whether the dependency is released in an SDK. |
| """ |
| |
| sdk_atom_labels = {} |
| for sdk_manifest in self.sdk_manifests: |
| try: |
| with open(sdk_manifest, 'r') as manifest: |
| data = json.load(manifest) |
| except json.JSONDecodeError: |
| continue |
| for atom in data['atoms']: |
| # SDK atoms are appended with one of the following and a |
| # toolchain, so we want to ignore them to match against the |
| # provided label. |
| match_label = re.compile("(?:(_sdk)|(_sdk_manifest)|(_sdk_legacy))\(.*\)") |
| label = re.sub(match_label, '', atom['gn-label']) |
| sdk_atom_labels[label] = atom['category'] |
| |
| return dep in sdk_atom_labels and sdk_atom_labels[dep] in [ 'partner', 'public' ] |
| |
| def create_cts_dep_file(self): |
| """Create a CTS file containing the verified dependencies. |
| |
| Should only be run after dependencies are verified using verify_deps. |
| """ |
| target_gen_dir, _ = self.cts_file.rsplit('/', 1) |
| if not os.path.exists(target_gen_dir): |
| os.makedirs(target_gen_dir) |
| |
| with open(self.cts_file, 'w') as f: |
| for dep in self.deps: |
| f.write('%s\n' % dep) |
| |
| |
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| '--root_build_dir', |
| required=True, |
| help='Path to the GN $root_build_dir. The default is //out/default.') |
| parser.add_argument( |
| '--output', |
| required=True, |
| help='The path to (including) the file to be generated.') |
| parser.add_argument( |
| '--invoker_label', |
| required=True, |
| help='The label of the invoker of cts_element.') |
| parser.add_argument( |
| '--deps', |
| nargs='+', |
| required=True, |
| help= |
| 'A list of at least one GN label representing the target\'s dependencies.' |
| ) |
| parser.add_argument( |
| '--allowed_cts_deps', |
| nargs='+', |
| required=True, |
| help='The list of allowed CTS dependencies in allowed_cts_deps.gni') |
| parser.add_argument( |
| '--allowed_cts_dirs', |
| nargs='+', |
| required=True, |
| help= |
| 'The list of allowed CTS dependency directories in allowed_cts_deps.gni' |
| ) |
| parser.add_argument( |
| '--sdk_manifests', |
| nargs='+', |
| required=True, |
| help='The list of paths to public and partner SDK manifests') |
| args = parser.parse_args() |
| try: |
| cts_element = VerifyCtsDeps( |
| args.root_build_dir, args.output, args.invoker_label, args.deps, |
| args.allowed_cts_deps, args.allowed_cts_dirs, args.sdk_manifests) |
| except ValueError as e: |
| print('ValueError: %s' % e) |
| return 1 |
| |
| unaccepted_deps = cts_element.verify_deps() |
| if not unaccepted_deps: |
| cts_element.create_cts_dep_file() |
| else: |
| print( |
| 'The following dependencies of "%s" are not allowed in CTS: %s' % |
| (args.invoker_label, unaccepted_deps)) |
| return 1 |
| |
| return 0 |
| |
| |
| if __name__ == '__main__': |
| sys.exit(main()) |
