#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Copyright (c) 2022 Huawei Device Co., Ltd. # 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. import os import json import re import argparse from prettytable import PrettyTable, ALL def get_args(): parser = argparse.ArgumentParser(add_help=True) parser.add_argument( "-p", "--project_path", default=r"./", type=str, help="root path of project. default: ./", ) parser.add_argument( "-t", "--check_target", type=str, choices=["component_codec", "component_sdk", "sdk_codec"], required=True, help="the target to be compared", ) parser.add_argument( "-b", "--bundles", nargs="*", type=str, help="option take effect only when the check_target is component_codec. allow multiple json file. " "default: all bundle.json file", ) args = parser.parse_args() return args def list_to_multiline(target_list: list): return str(target_list).lstrip("[").rstrip("]").replace(", ", "\n") def convert_set_to_sorted_list(target_set) -> list: return sorted(list(target_set)) def add_dict_as_table_row(f_table: PrettyTable, d_dict: dict, out_converter=list_to_multiline) -> None: s_keys = convert_set_to_sorted_list(d_dict.keys()) for i, k in enumerate(s_keys): f_table.add_row([i + 1, k, out_converter(convert_set_to_sorted_list(d_dict.get(k)))]) def bundle_syscap_post_handler(syscap: str) -> str: return syscap.split('=')[0].strip() def read_value_from_json(filepath: str, key_hierarchy: tuple, result_dict: dict, post_handler=None ) -> None: if os.path.exists(filepath) is False: print('error: file "{}" not exist.'.format(filepath)) return if not os.path.isfile(filepath): print('error: "{}" is not a file.') return with open(filepath, 'r', encoding='utf-8') as f: data = json.load(f) for key in key_hierarchy: try: data = data[key] except KeyError: return finally: pass data = [post_handler(x) for x in data if len(x) != 0 and not x.isspace()] if len(data) != 0: result_dict[filepath] = data def collect_syscap_from_codec(filepath: str, pattern: str = r'{"(.*)"') -> tuple: """ 从syscap_define.h收集syscap :param filepath: 文件的路径 :param pattern: 匹配syscap的规则 :return: syscap_define.h中声明的syscap集合 """ array_syscap_set = set() array_syscap_dict = dict() ptrn = re.compile(pattern) with open(filepath, "r") as f: content = f.read() array_syscap_set.update(re.findall(ptrn, content)) array_syscap_dict[filepath] = list() for v in array_syscap_set: array_syscap_dict.get(filepath).append(v) return array_syscap_set, array_syscap_dict def collect_syscap_from_component(project_path: str, black_dirs: tuple, key_heirarchy: tuple, bundles: list = None, ) -> tuple: """ 从部件的bundle.json中收集syscap :param project_path: 项目根路径 :param black_dirs: 根路径下的一级目录的黑名单，不扫描这些bundle.json下面的内容 :param key_heirarchy: bundle.json中syscap所在的key的元组 :param bundles: 指定的bundle.json :return: syscap_set，文件名和其syscap list组成的dict """ result_dict = dict() if bundles is None: search_dir_list = [ os.path.join(project_path, x) for x in os.listdir(project_path) if os.path.isdir(os.path.join(project_path, x)) and x not in black_dirs ] for folder in search_dir_list: output = os.popen("find {} -name bundle.json".format(folder)) for line in output: line = line.strip() read_value_from_json(line, key_heirarchy, result_dict, post_handler=bundle_syscap_post_handler) else: for bundle in bundles: read_value_from_json(bundle, key_heirarchy, result_dict, post_handler=bundle_syscap_post_handler) result_set = set() for v in result_dict.values(): result_set.update(v) return result_set, result_dict def sdk_syscap_post_handler(syscap: str) -> str: return syscap.strip().lstrip("*").lstrip().lstrip("*@syscap").strip() def collect_syscap_from_sdk(ts_path: str, pattern: str = r"\* *@syscap +((?i)SystemCapability\..*)", post_handler=None ) -> tuple: """ 从sdk下的*.d.ts中收集syscap :param ts_path: ts文件的所在路径 :param pattern: 匹配syscap的pattern :param post_handler: 对匹配到的syscap进行后置处理 :return: syscap_set，和由文件名、syscap list组成的dict """ ts_list = list() for item in os.listdir(ts_path): file_path = os.path.join(ts_path, item) if file_path.endswith(".d.ts") and os.path.isfile(file_path): ts_list.append(file_path) syscap_dict = dict() ptrn = re.compile(pattern) for ts in ts_list: with open(ts, 'r') as f: content = f.read() sub_syscap_list = re.findall(ptrn, content) sub_syscap_set = set() for syscap in sub_syscap_list: sub_syscap_set.add(post_handler(syscap)) syscap_dict[ts] = sub_syscap_set syscap_set = set() for v in syscap_dict.values(): syscap_set.update(v) return syscap_set, syscap_dict def find_files_containes_value(value_set: set, file_values_dict: dict) -> dict: """ 查看包含指定值的文件 :param value_set: 指定值 :param file_values_dict: 文件和值组成的dict :return: 值和文件组成的dict """ value_files_dict = dict() for v in value_set: filename_set = set() for file in file_values_dict.keys(): if v in file_values_dict[file]: filename_set.add(file) if 0 != len(filename_set): value_files_dict[v] = filename_set return value_files_dict def mutual_diff(a_set: set, b_set: set) -> tuple: return a_set.difference(b_set), b_set.difference(a_set) def print_inconsistent(diff_set: set, a_name: str, b_name: str, table: PrettyTable, value_file_dict: dict) -> None: table.clear() if len(diff_set) != 0: table.field_names = ["index", "SysCap only in {}".format(a_name), "Files"] add_dict_as_table_row(table, value_file_dict) elif len(diff_set) == 0: table.field_names = ["All SysCap in {} have been Covered by {}".format(a_name, b_name)] print(table) print() def print_consistent(a_diff_b_set: set, b_diff_a_set: set, table: PrettyTable, a_name: str, b_name: str) -> bool: if len(a_diff_b_set) == 0 and len(b_diff_a_set) == 0: table.field_names = ["{} and {} are Consistent".format(a_name, b_name)] print(table) print() return True return False def print_check_result(a_diff_b_set: set, b_diff_a_set: set, a_name: str, b_name: str, a_value_file_dict: dict, b_value_file_dict: dict, ) -> None: f_table = PrettyTable() f_table.hrules = ALL consistent_flag = print_consistent(a_diff_b_set, b_diff_a_set, f_table, a_name, b_name) if not consistent_flag: print_inconsistent(a_diff_b_set, a_name, b_name, f_table, a_value_file_dict) print_inconsistent(b_diff_a_set, b_name, a_name, f_table, b_value_file_dict) def check_component_and_codec(project_path, syscap_define_path: str, component_black_dirs: tuple, bundle_key_heirarchy: tuple, bundles=None): component_syscap_set, component_syscap_dict = collect_syscap_from_component( project_path, black_dirs=component_black_dirs, key_heirarchy=bundle_key_heirarchy, bundles=bundles ) array_syscap_set, array_syscap_dict = collect_syscap_from_codec(syscap_define_path) component_diff_array, array_diff_component = mutual_diff(component_syscap_set, array_syscap_set) value_component_dict = find_files_containes_value( component_diff_array, component_syscap_dict ) value_h_dict = find_files_containes_value(array_diff_component, array_syscap_dict) print_check_result(component_diff_array, array_diff_component, a_name="Component", b_name="Codec", a_value_file_dict=value_component_dict, b_value_file_dict=value_h_dict) def check_component_and_sdk(project_path, component_black_dirs: tuple, component_key_heirarchy: tuple, sdk_path: str): component_syscap_set, component_syscap_dict = collect_syscap_from_component( project_path, black_dirs=component_black_dirs, key_heirarchy=component_key_heirarchy ) ts_syscap_set, ts_syscap_dict = collect_syscap_from_sdk(ts_path=sdk_path, post_handler=sdk_syscap_post_handler) component_diff_ts, ts_diff_component = mutual_diff(component_syscap_set, ts_syscap_set) value_ts_dict = find_files_containes_value(ts_diff_component, ts_syscap_dict) value_component_dict = find_files_containes_value( component_diff_ts, component_syscap_dict ) print_check_result(component_diff_ts, ts_diff_component, a_name="Component", b_name="SDK", a_value_file_dict=value_component_dict, b_value_file_dict=value_ts_dict) def check_sdk_and_codec(syscap_define_path: str, sdk_path: str) -> None: ts_syscap_set, ts_syscap_dict = collect_syscap_from_sdk(ts_path=sdk_path, post_handler=sdk_syscap_post_handler) array_syscap_set, array_syscap_dict = collect_syscap_from_codec(syscap_define_path) ts_diff_array, array_diff_ts = mutual_diff(ts_syscap_set, array_syscap_set) value_ts_dict = find_files_containes_value(ts_diff_array, ts_syscap_dict) value_h_dict = find_files_containes_value(array_diff_ts, array_syscap_dict) print_check_result(ts_diff_array, array_diff_ts, a_name="SDK", b_name="Codec", a_value_file_dict=value_ts_dict, b_value_file_dict=value_h_dict) def main(): args = get_args() project_path = args.project_path check_target = args.check_target bundles = args.bundles syscap_define_path = os.path.join(project_path, "developtools", "syscap_codec", "include", "syscap_define.h") ts_path = os.path.join(project_path, "interface", "sdk-js", "api") component_black_dirs = ("out",) bundle_syscap_heirarchy = ("component", "syscap") if (bundles is not None or (bundles is not None and len(bundles) != 0)) and check_target != "component_codec": print("error: --bundles could only be used with -t component_codec") return if "component_sdk" == check_target: check_component_and_sdk(project_path, component_black_dirs, bundle_syscap_heirarchy, sdk_path=ts_path) elif "sdk_codec" == check_target: check_sdk_and_codec(syscap_define_path=syscap_define_path, sdk_path=ts_path) elif "component_codec" == check_target: if bundles is not None and len(bundles) == 0: print(r"error: '--bundles' parameter is specified, but has no value") else: check_component_and_codec(project_path, syscap_define_path, component_black_dirs=component_black_dirs, bundle_key_heirarchy=bundle_syscap_heirarchy, bundles=bundles) if __name__ == "__main__": main()