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    # filter third_party part info, sort by longest path match
126    third_party_info = [x for x in path_parts_info.items() if x[0].find('third_party') != -1]
127    third_party_info.reverse()
128    for dep in args.deps:
129        dep_path = get_path_from_label(dep)
130        if dep_path.find('third_party/rust/crates') != -1 or dep_path.find('vendor/open_source') != -1:
131            continue
132        if dep_path.find('third_party') != -1:
133            dep_part = get_dep_part(dep_path, third_party_info)
134            tips_info = "{} depend part {}, need set part deps {} info to".format(
135                args.target_path, dep, dep_part)
136            check_third_party_deps(args, dep_part, parts_deps_info, tips_info, third_deps_allow_list)
137            continue
138
139        match_flag = False
140        for pattern in part_pattern:
141            if dep_path.startswith(pattern):
142                match_flag = True
143                break
144        if match_flag is False:
145            message = "deps validation part_name: '{}', target: '{}', dep: '{}' failed!!!".format(
146                args.part_name, args.target_path, dep)
147            if args.target_path in deps_allow_list:
148                print(f"[0/0] WARNING:{message}")
149            else:
150                raise Exception(message)
151
152
153def check(args) -> list:
154    depfiles = []
155    # ignore test related parts
156    part_allow_set = {'libc-test', 'libc-test-lib', 'libc-gtest-lib'}
157    if args.part_name in part_allow_set:
158        return depfiles
159
160    compile_standard_allow_file = args.compile_standard_allow_file
161    compile_standard_allow_info = read_json_file(compile_standard_allow_file)
162    parts_path_info, path_parts_info = load_part_info(depfiles)
163
164    part_pattern = get_part_pattern(args.part_name, parts_path_info, path_parts_info, depfiles)
165    if not part_pattern:
166        gn_allow_list = compile_standard_allow_info.get("gn_part_or_subsystem_error", [])
167        message = "part_name: '{}' path is not exist, please check target: '{}'".format(
168            args.part_name, args.target_path)
169        if args.target_path in gn_allow_list:
170            print(f"[0/0] {message}")
171            return depfiles
172        else:
173            raise Exception(message)
174
175    check_part_deps(args, part_pattern, path_parts_info, compile_standard_allow_info, depfiles)
176
177    return depfiles
178
179
180def main():
181    parser = argparse.ArgumentParser()
182    parser.add_argument('--deps', nargs='*', required=True)
183    parser.add_argument('--part-name', required=True)
184    parser.add_argument('--target-path', required=True)
185    args = parser.parse_args()
186
187    check(args)
188
189    return 0
190
191
192if __name__ == '__main__':
193    sys.exit(main())
194