blob: 8b3345e86080fdb6eab65401b141a49acb713be7 [file] [log] [blame]
sakal67e414c2017-09-05 00:16:15 -07001#!/usr/bin/env python
2
3# Copyright 2016 The WebRTC project authors. All Rights Reserved.
4#
5# Use of this source code is governed by a BSD-style license
6# that can be found in the LICENSE file in the root of the source
7# tree. An additional intellectual property rights grant can be found
8# in the file PATENTS. All contributing project authors may
9# be found in the AUTHORS file in the root of the source tree.
Artem Titarenkoa9719482018-12-11 17:00:04 +010010"""Generates license markdown for a prebuilt version of WebRTC.
sakal67e414c2017-09-05 00:16:15 -070011
Artem Titarenkoa9719482018-12-11 17:00:04 +010012Licenses are taken from dependent libraries which are determined by
13GN desc command `gn desc` on all targets specified via `--target` argument.
14
15One can see all dependencies by invoking this command:
16$ gn.py desc --all --format=json <out_directory> <target> | python -m json.tool
17(see "deps" subarray)
18
19Libraries are mapped to licenses via LIB_TO_LICENSES_DICT dictionary.
20
21"""
sakal67e414c2017-09-05 00:16:15 -070022
23import sys
24
25import argparse
26import cgi
27import json
28import logging
29import os
30import re
31import subprocess
32
Artem Titarenkoa9719482018-12-11 17:00:04 +010033# Third_party library to licences mapping. Keys are names of the libraries
34# (right after the `third_party/` prefix)
sakal67e414c2017-09-05 00:16:15 -070035LIB_TO_LICENSES_DICT = {
Mirko Bonadeiafe72172018-04-13 11:11:52 +020036 'abseil-cpp': ['third_party/abseil-cpp/LICENSE'],
Oleksandr Iakovenko10b63612019-08-28 09:41:26 +020037 'android_ndk': ['third_party/android_ndk/NOTICE'],
Mirko Bonadeid9b62d32019-03-29 09:51:04 +010038 'android_sdk': ['third_party/android_sdk/LICENSE'],
Yves Gerey2f385d22019-11-20 12:10:08 +010039 'auto': ['third_party/android_deps/libs/'
40 'com_google_auto_service_auto_service/LICENSE'],
Sami Kalliomäkie7fac682018-03-20 16:32:49 +010041 'bazel': ['third_party/bazel/LICENSE'],
sakal67e414c2017-09-05 00:16:15 -070042 'boringssl': ['third_party/boringssl/src/LICENSE'],
Yves Gerey2f385d22019-11-20 12:10:08 +010043 'errorprone': ['third_party/android_deps/libs/'
44 'com_google_errorprone_error_prone_core/LICENSE'],
Oleh Prypind42acbb2018-01-15 20:13:16 +010045 'fiat': ['third_party/boringssl/src/third_party/fiat/LICENSE'],
Edward Lemur5c24c672017-11-06 20:29:00 +010046 'guava': ['third_party/guava/LICENSE'],
sakal67e414c2017-09-05 00:16:15 -070047 'ijar': ['third_party/ijar/LICENSE'],
48 'jsoncpp': ['third_party/jsoncpp/LICENSE'],
49 'libc++': ['buildtools/third_party/libc++/trunk/LICENSE.TXT'],
50 'libc++abi': ['buildtools/third_party/libc++abi/trunk/LICENSE.TXT'],
51 'libevent': ['base/third_party/libevent/LICENSE'],
52 'libjpeg_turbo': ['third_party/libjpeg_turbo/LICENSE.md'],
53 'libsrtp': ['third_party/libsrtp/LICENSE'],
54 'libvpx': ['third_party/libvpx/source/libvpx/LICENSE'],
55 'libyuv': ['third_party/libyuv/LICENSE'],
sakal67e414c2017-09-05 00:16:15 -070056 'opus': ['third_party/opus/src/COPYING'],
Alessio Bazzicaffb8c8c2019-04-01 10:19:25 +020057 'pffft': ['third_party/pffft/LICENSE'],
sakal67e414c2017-09-05 00:16:15 -070058 'protobuf': ['third_party/protobuf/LICENSE'],
Alessio Bazzicaa5b90382018-05-07 09:29:54 +000059 'rnnoise': ['third_party/rnnoise/COPYING'],
sakal67e414c2017-09-05 00:16:15 -070060 'usrsctp': ['third_party/usrsctp/LICENSE'],
Artem Titov29835992018-08-07 11:50:54 +020061 'webrtc': ['LICENSE'],
Mirko Bonadeife48ee92018-03-20 16:43:23 +010062 'zlib': ['third_party/zlib/LICENSE'],
Artem Titova76af0c2018-07-23 17:38:12 +020063 'base64': ['rtc_base/third_party/base64/LICENSE'],
Artem Titove41c4332018-07-25 15:04:28 +020064 'sigslot': ['rtc_base/third_party/sigslot/LICENSE'],
Artem Titov8ff433a2018-07-24 13:42:22 +020065 'portaudio': ['modules/third_party/portaudio/LICENSE'],
Artem Titov8a838fd2018-07-24 15:37:09 +020066 'fft': ['modules/third_party/fft/LICENSE'],
Artem Titove095b812018-07-25 12:10:22 +020067 'g711': ['modules/third_party/g711/LICENSE'],
Artem Titov52b90002018-07-25 13:13:44 +020068 'g722': ['modules/third_party/g722/LICENSE'],
Artem Titov333a5052018-07-25 16:56:18 +020069 'fft4g': ['common_audio/third_party/fft4g/LICENSE'],
Artem Titov29835992018-08-07 11:50:54 +020070 'spl_sqrt_floor': ['common_audio/third_party/spl_sqrt_floor/LICENSE'],
sakal67e414c2017-09-05 00:16:15 -070071
72 # Compile time dependencies, no license needed:
73 'yasm': [],
Yura Yaroshevich29c36b22018-06-12 19:59:02 +030074 'ow2_asm': [],
sakal67e414c2017-09-05 00:16:15 -070075}
76
Artem Titarenkoa9719482018-12-11 17:00:04 +010077# Third_party library _regex_ to licences mapping. Keys are regular expression
78# with names of the libraries (right after the `third_party/` prefix)
79LIB_REGEX_TO_LICENSES_DICT = {
80 'android_deps:android_support_annotations.*': [
81 'third_party/android_deps/libs/' +
82 'com_android_support_support_annotations/LICENSE'
83 ],
84
85 # Internal dependencies, licenses are already included by other dependencies
86 'android_deps:com_android_support_support_annotations.*': [],
87}
88
89
90def FindSrcDirPath():
91 """Returns the abs path to the src/ dir of the project."""
92 src_dir = os.path.dirname(os.path.abspath(__file__))
93 while os.path.basename(src_dir) != 'src':
94 src_dir = os.path.normpath(os.path.join(src_dir, os.pardir))
95 return src_dir
96
97
sakal67e414c2017-09-05 00:16:15 -070098SCRIPT_DIR = os.path.dirname(os.path.realpath(sys.argv[0]))
Mirko Bonadeid8665442018-09-04 12:17:27 +020099WEBRTC_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, os.pardir, os.pardir))
100SRC_DIR = FindSrcDirPath()
101sys.path.append(os.path.join(SRC_DIR, 'build'))
Henrik Kjellanderec57e052017-10-17 21:36:01 +0200102import find_depot_tools
103
Artem Titarenkoa9719482018-12-11 17:00:04 +0100104THIRD_PARTY_LIB_SIMPLE_NAME_REGEX = r'^.*/third_party/([\w\-+]+).*$'
105THIRD_PARTY_LIB_REGEX_TEMPLATE = r'^.*/third_party/%s$'
106
sakal67e414c2017-09-05 00:16:15 -0700107
108class LicenseBuilder(object):
109
Artem Titarenkoa9719482018-12-11 17:00:04 +0100110 def __init__(self,
111 buildfile_dirs,
112 targets,
113 lib_to_licenses_dict=None,
114 lib_regex_to_licenses_dict=None):
115 if lib_to_licenses_dict is None:
116 lib_to_licenses_dict = LIB_TO_LICENSES_DICT
117
118 if lib_regex_to_licenses_dict is None:
119 lib_regex_to_licenses_dict = LIB_REGEX_TO_LICENSES_DICT
120
sakal67e414c2017-09-05 00:16:15 -0700121 self.buildfile_dirs = buildfile_dirs
122 self.targets = targets
Artem Titarenkoa9719482018-12-11 17:00:04 +0100123 self.lib_to_licenses_dict = lib_to_licenses_dict
124 self.lib_regex_to_licenses_dict = lib_regex_to_licenses_dict
125
126 self.common_licenses_dict = self.lib_to_licenses_dict.copy()
127 self.common_licenses_dict.update(self.lib_regex_to_licenses_dict)
sakal67e414c2017-09-05 00:16:15 -0700128
129 @staticmethod
Artem Titarenkoa9719482018-12-11 17:00:04 +0100130 def _ParseLibraryName(dep):
131 """Returns library name after third_party
sakal67e414c2017-09-05 00:16:15 -0700132
133 Input one of:
134 //a/b/third_party/libname:c
135 //a/b/third_party/libname:c(//d/e/f:g)
136 //a/b/third_party/libname/c:d(//e/f/g:h)
137
Artem Titarenkoa9719482018-12-11 17:00:04 +0100138 Outputs libname or None if this is not a third_party dependency.
sakal67e414c2017-09-05 00:16:15 -0700139 """
Artem Titarenkoa9719482018-12-11 17:00:04 +0100140 groups = re.match(THIRD_PARTY_LIB_SIMPLE_NAME_REGEX, dep)
141 return groups.group(1) if groups else None
142
143 def _ParseLibrary(self, dep):
144 """Returns library simple or regex name that matches `dep` after third_party
145
146 This method matches `dep` dependency against simple names in
147 LIB_TO_LICENSES_DICT and regular expression names in
148 LIB_REGEX_TO_LICENSES_DICT keys
149
150 Outputs matched dict key or None if this is not a third_party dependency.
151 """
152 libname = LicenseBuilder._ParseLibraryName(dep)
153
154 for lib_regex in self.lib_regex_to_licenses_dict:
155 if re.match(THIRD_PARTY_LIB_REGEX_TEMPLATE % lib_regex, dep):
156 return lib_regex
157
158 return libname
sakal67e414c2017-09-05 00:16:15 -0700159
160 @staticmethod
161 def _RunGN(buildfile_dir, target):
Henrik Kjellanderec57e052017-10-17 21:36:01 +0200162 cmd = [
Artem Titarenkoa9719482018-12-11 17:00:04 +0100163 sys.executable,
164 os.path.join(find_depot_tools.DEPOT_TOOLS_PATH, 'gn.py'),
165 'desc',
166 '--all',
167 '--format=json',
168 os.path.abspath(buildfile_dir),
169 target,
Henrik Kjellanderec57e052017-10-17 21:36:01 +0200170 ]
Artem Titarenkoa9719482018-12-11 17:00:04 +0100171 logging.debug('Running: %r', cmd)
Mirko Bonadeid8665442018-09-04 12:17:27 +0200172 output_json = subprocess.check_output(cmd, cwd=WEBRTC_ROOT)
Artem Titarenkoa9719482018-12-11 17:00:04 +0100173 logging.debug('Output: %s', output_json)
sakal67e414c2017-09-05 00:16:15 -0700174 return output_json
175
Artem Titarenkoa9719482018-12-11 17:00:04 +0100176 def _GetThirdPartyLibraries(self, buildfile_dir, target):
sakal67e414c2017-09-05 00:16:15 -0700177 output = json.loads(LicenseBuilder._RunGN(buildfile_dir, target))
178 libraries = set()
Artem Titarenkoa9719482018-12-11 17:00:04 +0100179 for described_target in output.values():
180 third_party_libs = (
181 self._ParseLibrary(dep) for dep in described_target['deps'])
182 libraries |= set(lib for lib in third_party_libs if lib)
sakal67e414c2017-09-05 00:16:15 -0700183 return libraries
184
185 def GenerateLicenseText(self, output_dir):
186 # Get a list of third_party libs from gn. For fat libraries we must consider
187 # all architectures, hence the multiple buildfile directories.
188 third_party_libs = set()
189 for buildfile in self.buildfile_dirs:
190 for target in self.targets:
Artem Titarenkoa9719482018-12-11 17:00:04 +0100191 third_party_libs |= self._GetThirdPartyLibraries(buildfile, target)
sakal67e414c2017-09-05 00:16:15 -0700192 assert len(third_party_libs) > 0
193
Artem Titarenkoa9719482018-12-11 17:00:04 +0100194 missing_licenses = third_party_libs - set(self.common_licenses_dict.keys())
sakal67e414c2017-09-05 00:16:15 -0700195 if missing_licenses:
Artem Titarenkoa9719482018-12-11 17:00:04 +0100196 error_msg = 'Missing licenses for following third_party targets: %s' % \
197 ', '.join(missing_licenses)
sakal67e414c2017-09-05 00:16:15 -0700198 logging.error(error_msg)
199 raise Exception(error_msg)
200
201 # Put webrtc at the front of the list.
202 license_libs = sorted(third_party_libs)
203 license_libs.insert(0, 'webrtc')
204
Artem Titarenkoa9719482018-12-11 17:00:04 +0100205 logging.info('List of licenses: %s', ', '.join(license_libs))
sakal67e414c2017-09-05 00:16:15 -0700206
207 # Generate markdown.
208 output_license_file = open(os.path.join(output_dir, 'LICENSE.md'), 'w+')
209 for license_lib in license_libs:
Artem Titarenkoa9719482018-12-11 17:00:04 +0100210 if len(self.common_licenses_dict[license_lib]) == 0:
211 logging.info('Skipping compile time or internal dependency: %s',
212 license_lib)
213 continue # Compile time dependency
sakal67e414c2017-09-05 00:16:15 -0700214
215 output_license_file.write('# %s\n' % license_lib)
216 output_license_file.write('```\n')
Artem Titarenkoa9719482018-12-11 17:00:04 +0100217 for path in self.common_licenses_dict[license_lib]:
Mirko Bonadeid8665442018-09-04 12:17:27 +0200218 license_path = os.path.join(WEBRTC_ROOT, path)
sakal67e414c2017-09-05 00:16:15 -0700219 with open(license_path, 'r') as license_file:
220 license_text = cgi.escape(license_file.read(), quote=True)
221 output_license_file.write(license_text)
222 output_license_file.write('\n')
223 output_license_file.write('```\n\n')
224
225 output_license_file.close()
226
227
228def main():
229 parser = argparse.ArgumentParser(description='Generate WebRTC LICENSE.md')
Artem Titarenkoa9719482018-12-11 17:00:04 +0100230 parser.add_argument(
231 '--verbose', action='store_true', default=False, help='Debug logging.')
232 parser.add_argument(
233 '--target',
234 required=True,
235 action='append',
236 default=[],
237 help='Name of the GN target to generate a license for')
238 parser.add_argument('output_dir', help='Directory to output LICENSE.md to.')
239 parser.add_argument(
240 'buildfile_dirs',
241 nargs='+',
242 help='Directories containing gn generated ninja files')
sakal67e414c2017-09-05 00:16:15 -0700243 args = parser.parse_args()
244
245 logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO)
246
247 builder = LicenseBuilder(args.buildfile_dirs, args.target)
248 builder.GenerateLicenseText(args.output_dir)
249
250
251if __name__ == '__main__':
252 sys.exit(main())