1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
#!/usr/bin/env python3
# Copyright 2020 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Wraps the turbine jar and expands @FileArgs."""
import argparse
import functools
import logging
import os
import sys
import time
import zipfile
import javac_output_processor
from util import build_utils
import action_helpers # build_utils adds //build to sys.path.
import zip_helpers
def ProcessJavacOutput(output, target_name):
output_processor = javac_output_processor.JavacOutputProcessor(target_name)
lines = output_processor.Process(output.split('\n'))
return '\n'.join(lines)
def main(argv):
build_utils.InitLogging('TURBINE_DEBUG')
argv = build_utils.ExpandFileArgs(argv[1:])
parser = argparse.ArgumentParser()
action_helpers.add_depfile_arg(parser)
parser.add_argument('--target-name', help='Fully qualified GN target name.')
parser.add_argument(
'--turbine-jar-path', required=True, help='Path to the turbine jar file.')
parser.add_argument(
'--java-srcjars',
action='append',
help='List of srcjars to include in compilation.')
parser.add_argument('--classpath', action='append', help='Classpath to use.')
parser.add_argument(
'--processors',
action='append',
help='GN list of annotation processor main classes.')
parser.add_argument(
'--processorpath',
action='append',
help='GN list of jars that comprise the classpath used for Annotation '
'Processors.')
parser.add_argument(
'--processor-args',
action='append',
help='key=value arguments for the annotation processors.')
parser.add_argument('--jar-path', help='Jar output path.', required=True)
parser.add_argument(
'--generated-jar-path',
required=True,
help='Output path for generated source files.')
parser.add_argument('--warnings-as-errors',
action='store_true',
help='Treat all warnings as errors.')
parser.add_argument('--kotlin-jar-path',
help='Kotlin jar to be merged into the output jar.')
options, unknown_args = parser.parse_known_args(argv)
options.classpath = action_helpers.parse_gn_list(options.classpath)
options.processorpath = action_helpers.parse_gn_list(options.processorpath)
options.processors = action_helpers.parse_gn_list(options.processors)
options.java_srcjars = action_helpers.parse_gn_list(options.java_srcjars)
files = []
for arg in unknown_args:
# Interpret a path prefixed with @ as a file containing a list of sources.
if arg.startswith('@'):
files.extend(build_utils.ReadSourcesList(arg[1:]))
elif arg.startswith('-'):
parser.error('Unknown flag: ' + arg)
else:
files.append(arg)
# Turbine does not complain about missing classpath files. Missing files can
# result in misleading compile errors though, so do an upfront check.
classpath_jars = options.classpath + options.processorpath
missing_jars = [p for p in classpath_jars if not os.path.exists(p)]
if missing_jars:
sys.stderr.write('One or more classpath .jar files does not exist:\n')
sys.stderr.write('\n'.join(missing_jars) + '\n')
sys.exit(1)
# The target's .sources file contains both Java and Kotlin files. We use
# compile_kt.py to compile the Kotlin files to .class and header jars.
# Turbine is run only on .java files.
java_files = [f for f in files if f.endswith('.java')]
cmd = build_utils.JavaCmd() + [
'-classpath', options.turbine_jar_path, 'com.google.turbine.main.Main'
]
javac_cmd = ['--release', '17']
# Turbine reads lists from command line args by consuming args until one
# starts with double dash (--). Thus command line args should be grouped
# together and passed in together.
if options.processors:
cmd += ['--processors']
cmd += options.processors
if options.processorpath:
cmd += ['--processorpath']
cmd += options.processorpath
if options.processor_args:
for arg in options.processor_args:
javac_cmd.extend(['-A%s' % arg])
if options.classpath:
cmd += ['--classpath']
cmd += options.classpath
if options.java_srcjars:
cmd += ['--source_jars']
cmd += options.java_srcjars
if java_files:
# Use jar_path to ensure paths are relative (needed for rbe).
files_rsp_path = options.jar_path + '.java_files_list.txt'
with open(files_rsp_path, 'w', encoding='utf-8') as f:
f.write('\n'.join(java_files))
# Pass source paths as response files to avoid extremely long command
# lines that are tedius to debug.
cmd += ['--sources']
cmd += ['@' + files_rsp_path]
cmd += ['--javacopts']
cmd += javac_cmd
cmd += ['--'] # Terminate javacopts
# Use AtomicOutput so that output timestamps are not updated when outputs
# are not changed.
with action_helpers.atomic_output(options.jar_path) as output_jar, \
action_helpers.atomic_output(options.generated_jar_path) as gensrc_jar:
cmd += ['--output', output_jar.name, '--gensrc_output', gensrc_jar.name]
process_javac_output_partial = functools.partial(
ProcessJavacOutput, target_name=options.target_name)
logging.debug('Command: %s', cmd)
start = time.time()
try:
build_utils.CheckOutput(cmd,
print_stdout=True,
stdout_filter=process_javac_output_partial,
stderr_filter=process_javac_output_partial,
fail_on_output=options.warnings_as_errors)
except build_utils.CalledProcessError as e:
# Do not output stacktrace as it takes up space on gerrit UI, forcing
# you to click though to find the actual compilation error. It's never
# interesting to see the Python stacktrace for a Java compilation error.
sys.stderr.write(e.output)
sys.exit(1)
end = time.time() - start
logging.info('Header compilation took %ss', end)
if options.kotlin_jar_path:
with zipfile.ZipFile(output_jar.name, 'a') as out_zip:
path_transform = lambda p: p if p.endswith('.class') else None
zip_helpers.merge_zips(out_zip, [options.kotlin_jar_path],
path_transform=path_transform)
if options.depfile:
# GN already knows of the java files, so avoid listing individual java files
# in the depfile.
action_helpers.write_depfile(options.depfile, options.jar_path,
classpath_jars)
if __name__ == '__main__':
sys.exit(main(sys.argv))
|
