1 /*
2 * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.tools.sjavac.server;
27
28 import java.io.BufferedReader;
29 import java.io.File;
30 import java.io.IOException;
31 import java.io.InputStreamReader;
32 import java.io.OutputStreamWriter;
33 import java.io.PrintWriter;
34 import java.io.StringWriter;
35 import java.net.Socket;
36 import java.net.URI;
37 import java.net.URISyntaxException;
38 import java.util.ArrayList;
39 import java.util.Arrays;
40 import java.util.HashSet;
41 import java.util.List;
42 import java.util.Map;
43 import java.util.Set;
44 import java.util.concurrent.Future;
45
46 import javax.tools.JavaCompiler.CompilationTask;
47 import javax.tools.JavaFileObject;
48 import javax.tools.StandardJavaFileManager;
49
50 import com.sun.tools.javac.api.JavacTaskImpl;
51 import com.sun.tools.javac.util.Context;
52 import com.sun.tools.javac.util.ListBuffer;
53 import com.sun.tools.javac.util.Options;
54 import com.sun.tools.javac.util.StringUtils;
55 import com.sun.tools.sjavac.comp.AttrWithDeps;
56 import com.sun.tools.sjavac.comp.Dependencies;
57 import com.sun.tools.sjavac.comp.JavaCompilerWithDeps;
58 import com.sun.tools.sjavac.comp.JavacServiceImpl;
59 import com.sun.tools.sjavac.comp.ResolveWithDeps;
60 import com.sun.tools.sjavac.comp.SmartFileManager;
61
62 /**
63 * The compiler thread maintains a JavaCompiler instance and
64 * can receive a request from the client, perform the compilation
65 * requested and report back the results.
66 *
67 * * <p><b>This is NOT part of any supported API.
68 * If you write code that depends on this, you do so at your own
69 * risk. This code and its internal interfaces are subject to change
70 * or deletion without notice.</b></p>
71 */
72 public class CompilerThread implements Runnable {
73 private JavacServer javacServer;
74 private CompilerPool compilerPool;
75 private JavacServiceImpl javacServiceImpl;
76 private List<Future<?>> subTasks;
77
78 // Communicating over this socket.
79 private Socket socket;
80
81 // The necessary classes to do a compilation.
82 private com.sun.tools.javac.api.JavacTool compiler;
83 private StandardJavaFileManager fileManager;
84 private SmartFileManager smartFileManager;
85 private Context context;
86
87 // If true, then this thread is serving a request.
88 private boolean inUse = false;
89
90 CompilerThread(CompilerPool cp, JavacServiceImpl javacServiceImpl) {
91 compilerPool = cp;
92 javacServer = cp.getJavacServer();
93 this.javacServiceImpl = javacServiceImpl;
94 }
95
96 /**
97 * Execute a minor task, for example generating bytecodes and writing them to disk,
98 * that belong to a major compiler thread task.
99 */
100 public synchronized void executeSubtask(Runnable r) {
101 subTasks.add(compilerPool.executeSubtask(this, r));
102 }
103
104 /**
105 * Count the number of active sub tasks.
106 */
107 public synchronized int numActiveSubTasks() {
108 int c = 0;
109 for (Future<?> f : subTasks) {
110 if (!f.isDone() && !f.isCancelled()) {
111 c++;
112 }
113 }
114 return c;
115 }
116
117 /**
118 * Use this socket for the upcoming request.
119 */
120 public void setSocket(Socket s) {
121 socket = s;
122 }
123
124 /**
125 * Prepare the compiler thread for use. It is not yet started.
126 * It will be started by the executor service.
127 */
128 public synchronized void use() {
129 assert(!inUse);
130 inUse = true;
131 compiler = com.sun.tools.javac.api.JavacTool.create();
132 fileManager = compiler.getStandardFileManager(null, null, null);
133 smartFileManager = new SmartFileManager(fileManager);
134 context = new Context();
135 ResolveWithDeps.preRegister(context);
136 AttrWithDeps.preRegister(context);
137 JavaCompilerWithDeps.preRegister(context, javacServiceImpl);
138 subTasks = new ArrayList<>();
139 }
140
141 /**
142 * Prepare the compiler thread for idleness.
143 */
144 public synchronized void unuse() {
145 assert(inUse);
146 inUse = false;
147 compiler = null;
148 fileManager = null;
149 smartFileManager = null;
150 context = null;
151 subTasks = null;
152 }
153
154 /**
155 * Expect this key on the next line read from the reader.
156 */
157 private static boolean expect(BufferedReader in, String key) throws IOException {
158 String s = in.readLine();
159 if (s != null && s.equals(key)) {
160 return true;
161 }
162 return false;
163 }
164
165 // The request identifier, for example GENERATE_NEWBYTECODE
166 String id = "";
167
168 public String currentRequestId() {
169 return id;
170 }
171
172 PrintWriter stdout;
173 PrintWriter stderr;
174 int forcedExitCode = 0;
175
176 public void logError(String msg) {
177 stderr.println(msg);
178 forcedExitCode = -1;
179 }
180
181 /**
182 * Invoked by the executor service.
183 */
184 public void run() {
185 // Unique nr that identifies this request.
186 int thisRequest = compilerPool.startRequest();
187 long start = System.currentTimeMillis();
188 int numClasses = 0;
189 StringBuilder compiledPkgs = new StringBuilder();
190 use();
191
192 PrintWriter out = null;
193 try {
194 javacServer.log("<"+thisRequest+"> Connect from "+socket.getRemoteSocketAddress()+" activethreads="+compilerPool.numActiveRequests());
195 BufferedReader in = new BufferedReader(new InputStreamReader(
196 socket.getInputStream()));
197 out = new PrintWriter(new OutputStreamWriter(
198 socket.getOutputStream()));
199 if (!expect(in, JavacServer.PROTOCOL_COOKIE_VERSION)) {
200 javacServer.log("<"+thisRequest+"> Bad protocol from ip "+socket.getRemoteSocketAddress());
201 return;
202 }
203
204 String cookie = in.readLine();
205 if (cookie == null || !cookie.equals(""+javacServer.getCookie())) {
206 javacServer.log("<"+thisRequest+"> Bad cookie from ip "+socket.getRemoteSocketAddress());
207 return;
208 }
209 if (!expect(in, JavacServer.PROTOCOL_CWD)) {
210 return;
211 }
212 String cwd = in.readLine();
213 if (cwd == null)
214 return;
215 if (!expect(in, JavacServer.PROTOCOL_ID)) {
216 return;
217 }
218 id = in.readLine();
219 if (id == null)
220 return;
221 if (!expect(in, JavacServer.PROTOCOL_ARGS)) {
222 return;
223 }
224 ArrayList<String> the_options = new ArrayList<>();
225 ArrayList<File> the_classes = new ArrayList<>();
226 Iterable<File> path = Arrays.<File> asList(new File(cwd));
227
228 for (;;) {
229 String l = in.readLine();
230 if (l == null)
231 return;
232 if (l.equals(JavacServer.PROTOCOL_SOURCES_TO_COMPILE))
233 break;
234 if (l.startsWith("--server:"))
235 continue;
236 if (!l.startsWith("-") && l.endsWith(".java")) {
237 the_classes.add(new File(l));
238 numClasses++;
239 } else {
240 the_options.add(l);
241 }
242 continue;
243 }
244
245 // Load sources to compile
246 Set<URI> sourcesToCompile = new HashSet<>();
247 for (;;) {
248 String l = in.readLine();
249 if (l == null)
250 return;
251 if (l.equals(JavacServer.PROTOCOL_VISIBLE_SOURCES))
252 break;
253 try {
254 sourcesToCompile.add(new URI(l));
255 numClasses++;
256 } catch (URISyntaxException e) {
257 return;
258 }
259 }
260 // Load visible sources
261 Set<URI> visibleSources = new HashSet<>();
262 boolean fix_drive_letter_case =
263 StringUtils.toLowerCase(System.getProperty("os.name")).startsWith("windows");
264 for (;;) {
265 String l = in.readLine();
266 if (l == null)
267 return;
268 if (l.equals(JavacServer.PROTOCOL_END))
269 break;
270 try {
271 URI u = new URI(l);
272 if (fix_drive_letter_case) {
273 // Make sure the driver letter is lower case.
274 String s = u.toString();
275 if (s.startsWith("file:/") &&
276 Character.isUpperCase(s.charAt(6))) {
277 u = new URI("file:/"+Character.toLowerCase(s.charAt(6))+s.substring(7));
278 }
279 }
280 visibleSources.add(u);
281 } catch (URISyntaxException e) {
282 return;
283 }
284 }
285
286 // A completed request has been received.
287
288 // Now setup the actual compilation....
289 // First deal with explicit source files on cmdline and in at file.
290 ListBuffer<JavaFileObject> compilationUnits = new ListBuffer<>();
291 for (JavaFileObject i : fileManager.getJavaFileObjectsFromFiles(the_classes)) {
292 compilationUnits.append(i);
293 }
294 // Now deal with sources supplied as source_to_compile.
295 ListBuffer<File> sourcesToCompileFiles = new ListBuffer<>();
296 for (URI u : sourcesToCompile) {
297 sourcesToCompileFiles.append(new File(u));
298 }
299 for (JavaFileObject i : fileManager.getJavaFileObjectsFromFiles(sourcesToCompileFiles)) {
300 compilationUnits.append(i);
301 }
302 // Log the options to be used.
303 StringBuilder options = new StringBuilder();
304 for (String s : the_options) {
305 options.append(">").append(s).append("< ");
306 }
307 javacServer.log(id+" <"+thisRequest+"> options "+options.toString());
308
309 forcedExitCode = 0;
310 // Create a new logger.
311 StringWriter stdoutLog = new StringWriter();
312 StringWriter stderrLog = new StringWriter();
313 stdout = new PrintWriter(stdoutLog);
314 stderr = new PrintWriter(stderrLog);
315 com.sun.tools.javac.main.Main.Result rc = com.sun.tools.javac.main.Main.Result.OK;
316 try {
317 if (compilationUnits.size() > 0) {
318 smartFileManager.setVisibleSources(visibleSources);
319 smartFileManager.cleanArtifacts();
320 smartFileManager.setLog(stdout);
321
322 // Do the compilation!
323 CompilationTask task = compiler.getTask(stderr, smartFileManager, null, the_options, null, compilationUnits, context);
324 smartFileManager.setSymbolFileEnabled(!Options.instance(context).isSet("ignore.symbol.file"));
325 rc = ((JavacTaskImpl) task).doCall();
326
327 while (numActiveSubTasks()>0) {
328 try { Thread.sleep(1000); } catch (InterruptedException e) { }
329 }
330
331 smartFileManager.flush();
332 }
333 } catch (Exception e) {
334 stderr.println(e.getMessage());
335 forcedExitCode = -1;
336 }
337
338 // Send the response..
339 out.println(JavacServer.PROTOCOL_STDOUT);
340 out.print(stdoutLog);
341 out.println(JavacServer.PROTOCOL_STDERR);
342 out.print(stderrLog);
343 // The compilation is complete! And errors will have already been printed on out!
344 out.println(JavacServer.PROTOCOL_PACKAGE_ARTIFACTS);
345 Map<String,Set<URI>> pa = smartFileManager.getPackageArtifacts();
346 for (String aPkgName : pa.keySet()) {
347 out.println("+"+aPkgName);
348 Set<URI> as = pa.get(aPkgName);
349 for (URI a : as) {
350 out.println(" "+a.toString());
351 }
352 }
353 Dependencies deps = Dependencies.instance(context);
354 out.println(JavacServer.PROTOCOL_PACKAGE_DEPENDENCIES);
355 Map<String,Set<String>> pd = deps.getDependencies();
356 for (String aPkgName : pd.keySet()) {
357 out.println("+"+aPkgName);
358 Set<String> ds = pd.get(aPkgName);
359 // Everything depends on java.lang
360 if (!ds.contains(":java.lang")) ds.add(":java.lang");
361 for (String d : ds) {
362 out.println(" "+d);
363 }
364 }
365 out.println(JavacServer.PROTOCOL_PACKAGE_PUBLIC_APIS);
366 Map<String,String> pp = deps.getPubapis();
367 for (String aPkgName : pp.keySet()) {
368 out.println("+"+aPkgName);
369 String ps = pp.get(aPkgName);
370 // getPubapis added a space to each line!
371 out.println(ps);
372 compiledPkgs.append(aPkgName+" ");
373 }
374 out.println(JavacServer.PROTOCOL_SYSINFO);
375 out.println("num_cores=" + Runtime.getRuntime().availableProcessors());
376 out.println("max_memory=" + Runtime.getRuntime().maxMemory());
377 out.println(JavacServer.PROTOCOL_RETURN_CODE);
378
379 // Errors from sjavac that affect compilation status!
380 int rcv = rc.exitCode;
381 if (rcv == 0 && forcedExitCode != 0) {
382 rcv = forcedExitCode;
383 }
384 out.println("" + rcv);
385 out.println(JavacServer.PROTOCOL_END);
386 out.flush();
387 } catch (IOException e) {
388 e.printStackTrace();
389 } finally {
390 try {
391 if (out != null) out.close();
392 if (!socket.isClosed()) {
393 socket.close();
394 }
395 socket = null;
396 } catch (Exception e) {
397 javacServer.log("ERROR "+e);
398 e.printStackTrace();
399 }
400 compilerPool.stopRequest();
401 long duration = System.currentTimeMillis()-start;
402 javacServer.addBuildTime(duration);
403 float classpersec = ((float)numClasses)*(((float)1000.0)/((float)duration));
404 javacServer.log(id+" <"+thisRequest+"> "+compiledPkgs+" duration " + duration+ " ms num_classes="+numClasses+
405 " classpersec="+classpersec+" subtasks="+subTasks.size());
406 javacServer.flushLog();
407 unuse();
408 compilerPool.returnCompilerThread(this);
409 }
410 }
411 }
412