1#!/usr/bin/env python
2# -*- coding: utf-8 -*-
3# Copyright (c) 2021 Huawei Device Co., Ltd.
4# Licensed under the Apache License, Version 2.0 (the "License");
5# you may not use this file except in compliance with the License.
6# You may obtain a copy of the License at
7#
8#     http://www.apache.org/licenses/LICENSE-2.0
9#
10# Unless required by applicable law or agreed to in writing, software
11# distributed under the License is distributed on an "AS IS" BASIS,
12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13# See the License for the specific language governing permissions and
14# limitations under the License.
15
16import os
17import sys
18import argparse
19
20
21sys.path.append(
22    os.path.dirname(os.path.dirname(os.path.dirname(
23        os.path.abspath(__file__)))))
24from scripts.util.file_utils import read_json_file  # noqa: E402
25
26
27def check_third_party_deps(args, dep_part: str, parts_deps_info: dict, _tips_info: dict, third_deps_allow_list: list):
28    """check whether the three-party dependency is in the part declaration"""
29    if args.part_name == dep_part:
30        return
31    part_deps_info = parts_deps_info.get(args.part_name)
32    if not part_deps_info:
33        _warning_info = f"{_tips_info} {args.part_name}."
34    elif not part_deps_info.get('third_party') or \
35        not dep_part in part_deps_info.get('third_party'):
36        _warning_info = f"{_tips_info} {part_deps_info.get('build_config_file')}."
37    else:
38        _warning_info = ""
39
40    if _warning_info != "":
41        if args.target_path in third_deps_allow_list:
42            print(f"[0/0] WARNING: {_warning_info}")
43        else:
44            raise Exception(_warning_info)
45
46    return
47
48
49def load_part_info(depfiles: list):
50    """load part path info from parts_info"""
51    # load parts path info file
52    parts_path_file = 'build_configs/parts_info/parts_path_info.json'
53    parts_path_info = read_json_file(parts_path_file)
54    if parts_path_info is None:
55        raise Exception("read pre_build parts_path_info failed.")
56    depfiles.append(parts_path_file)
57
58    # load path to parts info file
59    path_parts_file = 'build_configs/parts_info/path_to_parts.json'
60    path_parts_info = read_json_file(path_parts_file)
61    if path_parts_info is None:
62        raise Exception("read pre_build path to parts failed.")
63    depfiles.append(path_parts_file)
64
65    return parts_path_info, path_parts_info
66
67
68def get_path_from_label(label: str):
69    """get part path from target label, the format is //path:module"""
70    return label.lstrip('//').split(':')[0]
71
72
73def get_path_from_module_list(cur_part_name: str, depfiles:list) -> str:
74    parts_module_lists = []
75    parts_modules_file = "build_configs/parts_info/parts_modules_info.json"
76    parts_modules_info = read_json_file(parts_modules_file)
77    if parts_modules_info is None:
78        raise Exception("read pre_build parts module info failed.")
79    depfiles.append(parts_modules_file)
80
81    for parts_module in parts_modules_info.get("parts"):
82        if parts_module.get("part_name") == cur_part_name:
83            parts_module_lists = parts_module["module_list"]
84            break
85    parts_path = [get_path_from_label(x) for x in parts_module_lists]
86
87    return parts_path
88
89
90def get_part_pattern(cur_part_name: str, parts_path_info: dict, path_parts_info: dict, depfiles: list) -> list:
91    """get all part path from part info"""
92    part_pattern = []
93    part_path = parts_path_info.get(cur_part_name)
94    if part_path is None:
95        return part_pattern
96
97    path_to_part = path_parts_info.get(part_path)
98    if len(path_to_part) == 1:
99        part_pattern.append(part_path)
100    else:
101        part_pattern.extend(get_path_from_module_list(cur_part_name, depfiles))
102
103    return part_pattern
104
105
106def get_dep_part(dep_path: str, third_part_info: dict) -> str:
107    """gets the part by the longest path match"""
108    for part_info in third_part_info:
109        path = part_info[0]
110        part = part_info[1][0]
111        if dep_path.find(path) != -1:
112            return part
113    return ""
114
115
116def check_part_deps(args, part_pattern: str, path_parts_info: dict, compile_standard_allow_info: dict, depfiles: list):
117    deps_allow_list = compile_standard_allow_info.get("deps_added_external_part_module", [])
118    third_deps_allow_list = compile_standard_allow_info.get("third_deps_bundle_not_add", [])
119    parts_deps_file = 'build_configs/parts_info/parts_deps.json'
120    parts_deps_info = read_json_file(parts_deps_file)
121    if parts_deps_info is None:
122        raise Exception("read pre_build parts_deps failed.")
123    depfiles.append(parts_deps_file)
124
125    parts_src_flag_file = "build_configs/parts_src_flag.json"
126    parts_src_info = read_json_file(parts_src_flag_file)
127    third_party_allow_list = os.path.join(args.source_root_dir, "out/products_ext/third_party_allow_list.json")
128    if not os.path.exists(third_party_allow_list):
129        third_party_allow_list = os.path.join(args.source_root_dir, "build/third_party_allow_list.json")
130    third_party_allow_info = read_json_file(third_party_allow_list)
131
132    # filter third_party part info, sort by longest path match
133    third_party_info = [x for x in path_parts_info.items() if x[0].find('third_party') != -1]
134    third_party_info.reverse()
135    for dep in args.deps:
136        dep_path = get_path_from_label(dep)
137        if dep_path.find('third_party/rust/crates') != -1:
138            continue
139        if dep_path.find('third_party') != -1:
140            dep_part = get_dep_part(dep_path, third_party_info)
141
142            if dep_part not in parts_src_info and dep_part in third_party_allow_info:
143                print(f"[0/0] WARNING: deps third_party '{dep_part}' not configured in part config json, "
144                    f"target: '{args.target_path}', deps: '{dep}'")
145            elif dep_part not in parts_src_info and dep_part not in third_party_allow_info:
146                raise Exception(
147                    f"deps third_party '{dep_part}' not configured in part config json, "
148                    f"target: '{args.target_path}', deps: '{dep}'")
149
150            tips_info = "{} depend part {}, need set part deps {} info to".format(
151                args.target_path, dep, dep_part)
152            check_third_party_deps(args, dep_part, parts_deps_info, tips_info, third_deps_allow_list)
153            continue
154
155        match_flag = False
156        for pattern in part_pattern:
157            if dep_path.startswith(pattern):
158                match_flag = True
159                break
160        if match_flag is False:
161            message = "deps validation part_name: '{}', target: '{}', dep: '{}' failed!!!".format(
162                args.part_name, args.target_path, dep)
163            if args.target_path in deps_allow_list:
164                print(f"[0/0] WARNING:{message}")
165            else:
166                raise Exception(message)
167
168
169def check(args) -> list:
170    depfiles = []
171    # ignore test related parts
172    part_allow_set = {'libc-test', 'libc-test-lib', 'libc-gtest-lib'}
173    if args.part_name in part_allow_set:
174        return depfiles
175
176    compile_standard_allow_file = args.compile_standard_allow_file
177    compile_standard_allow_info = read_json_file(compile_standard_allow_file)
178    parts_path_info, path_parts_info = load_part_info(depfiles)
179
180    part_pattern = get_part_pattern(args.part_name, parts_path_info, path_parts_info, depfiles)
181    if not part_pattern:
182        gn_allow_list = compile_standard_allow_info.get("gn_part_or_subsystem_error", [])
183        message = "part_name: '{}' path is not exist, please check target: '{}'".format(
184            args.part_name, args.target_path)
185        if args.target_path in gn_allow_list:
186            print(f"[0/0] {message}")
187            return depfiles
188        else:
189            raise Exception(message)
190
191    check_part_deps(args, part_pattern, path_parts_info, compile_standard_allow_info, depfiles)
192
193    return depfiles
194
195
196def main():
197    parser = argparse.ArgumentParser()
198    parser.add_argument('--deps', nargs='*', required=True)
199    parser.add_argument('--part-name', required=True)
200    parser.add_argument('--target-path', required=True)
201    parser.add_argument('--source-root-dir', required=True)
202    args = parser.parse_args()
203
204    check(args)
205
206    return 0
207
208
209if __name__ == '__main__':
210    sys.exit(main())
211