make/langtools/tools/javacserver/server/Server.java - toolchain/jdk/jdk21 - Git at Google

 /*
  * Copyright (c) 2011, 2022, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package javacserver.server;

 import java.io.BufferedReader;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.PrintStream;
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.SocketException;
 import java.nio.file.Path;
 import java.util.Optional;
 import java.util.Random;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.spi.ToolProvider;
 import javacserver.shared.PortFile;
 import javacserver.shared.Protocol;
 import javacserver.shared.Result;
 import javacserver.util.LazyInitFileLog;
 import javacserver.util.Log;
 import javacserver.util.LoggingOutputStream;
 import javacserver.util.Util;

 /**
  * Start a new server main thread, that will listen to incoming connection requests from the client,
  * and dispatch these on to worker threads in a thread pool, running javac.
  */
 public class Server {
     private ServerSocket serverSocket;
     private PortFile portFile;
     private PortFileMonitor portFileMonitor;
     private IdleMonitor idleMonitor;
     private CompilerThreadPool compilerThreadPool;

     // Set to false break accept loop
     final AtomicBoolean keepAcceptingRequests = new AtomicBoolean();

     // For logging server internal (non request specific) errors.
     private static LazyInitFileLog errorLog;

     public static void main(String... args) {
         initLogging();

         try {
             PortFile portFile = getPortFileFromArguments(args);
             if (portFile == null) {
                 System.exit(Result.CMDERR.exitCode);
                 return;
             }

             Server server = new Server(portFile);
             if (!server.start()) {
                 System.exit(Result.ERROR.exitCode);
             } else {
                 System.exit(Result.OK.exitCode);
             }
         } catch (IOException | InterruptedException ex) {
             ex.printStackTrace();
             System.exit(Result.ERROR.exitCode);
         }
     }

     private static void initLogging() {
         // Under normal operation, all logging messages generated server-side
         // are due to compilation requests. These logging messages should
         // be relayed back to the requesting client rather than written to the
         // server log. The only messages that should be written to the server
         // log (in production mode) should be errors,
         errorLog = new LazyInitFileLog("server.log");
         Log.setLogForCurrentThread(errorLog);
         Log.setLogLevel(Log.Level.ERROR); // should be set to ERROR.

         // Make sure no exceptions go under the radar
         Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
             restoreServerErrorLog();
             Log.error(e);
         });

         // Inevitably someone will try to print messages using System.{out,err}.
         // Make sure this output also ends up in the log.
         System.setOut(new PrintStream(new LoggingOutputStream(System.out, Log.Level.INFO, "[stdout] ")));
         System.setErr(new PrintStream(new LoggingOutputStream(System.err, Log.Level.ERROR, "[stderr] ")));
     }

     private static PortFile getPortFileFromArguments(String[] args) {
         if (args.length != 1) {
             Log.error("javacserver daemon incorrectly called");
             return null;
         }
         String portfilename = args[0];
         PortFile portFile = new PortFile(portfilename);
         return portFile;
     }

     public Server(PortFile portFile) throws FileNotFoundException {
         this.portFile = portFile;
     }

     /**
      * Start the daemon, unless another one is already running, in which it returns
      * false and exits immediately.
      */
     private boolean start() throws IOException, InterruptedException {
         // The port file is locked and the server port and cookie is written into it.
         portFile.lock();
         portFile.getValues();
         if (portFile.containsPortInfo()) {
             Log.debug("javacserver daemon not started because portfile exists!");
             portFile.unlock();
             return false;
         }

         serverSocket = new ServerSocket();
         InetAddress localhost = InetAddress.getByName(null);
         serverSocket.bind(new InetSocketAddress(localhost, 0));

         // At this point the server accepts connections, so it is  now safe
         // to publish the port / cookie information

         // The secret cookie shared between server and client through the port file.
         // Used to prevent clients from believing that they are communicating with
         // an old server when a new server has started and reused the same port as
         // an old server.
         long myCookie = new Random().nextLong();
         portFile.setValues(serverSocket.getLocalPort(), myCookie);
         portFile.unlock();

         portFileMonitor = new PortFileMonitor(portFile, this::shutdownServer);
         portFileMonitor.start();
         compilerThreadPool = new CompilerThreadPool();
         idleMonitor = new IdleMonitor(this::shutdownServer);

         Log.debug("javacserver daemon started. Accepting connections...");
         Log.debug("    port: " + serverSocket.getLocalPort());
         Log.debug("    time: " + new java.util.Date());
         Log.debug("    poolsize: " + compilerThreadPool.poolSize());

         keepAcceptingRequests.set(true);
         do {
             try {
                 Socket socket = serverSocket.accept();
                  // Handle each incoming request in a separate thread. This is just for socket communication,
                  // the actual compilation will be done by the threadpool.
                 Thread requestHandler = new Thread(() -> handleRequest(socket));
                 requestHandler.start();
             } catch (SocketException se) {
                 // Caused by serverSocket.close() and indicates shutdown
             }
         } while (keepAcceptingRequests.get());

         Log.debug("Shutting down.");

         // No more connections accepted. If any client managed to connect after
         // the accept() was interrupted but before the server socket is closed
         // here, any attempt to read or write to the socket will result in an
         // IOException on the client side.

         // Shut down
         idleMonitor.shutdown();
         compilerThreadPool.shutdown();

         return true;
     }

     private void handleRequest(Socket socket) {
         try (BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
              PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
             try {
                 idleMonitor.startCall();

                 // Set up logging for this thread. Stream back logging messages to
                 // client on the format "level:msg".
                 Log.setLogForCurrentThread(new Protocol.ProtocolLog(out));

                 String[] args = Protocol.readCommand(in);

                 // If there has been any internal errors, notify client
                 checkInternalErrorLog();

                 // Perform compilation. This will call runCompiler() on a
                 // thread in the thread pool
                 int exitCode = compilerThreadPool.dispatchCompilation(args);
                 Protocol.sendExitCode(out, exitCode);

                 // Check for internal errors again.
                 checkInternalErrorLog();
             } finally {
                 idleMonitor.endCall();
             }
         } catch (Exception ex) {
             // Not much to be done at this point. The client side request
             // code will most likely throw an IOException and the
             // compilation will fail.
             Log.error(ex);
         } finally {
             Log.setLogForCurrentThread(null);
         }
     }

     public static int runCompiler(Log log, String[] args) {
         Log.setLogForCurrentThread(log);

         // Direct logging to our byte array stream.
         StringWriter strWriter = new StringWriter();
         PrintWriter printWriter = new PrintWriter(strWriter);

         // Compile
         Optional<ToolProvider> tool = ToolProvider.findFirst("javac");
         if (tool.isEmpty()) {
             Log.error("Can't find tool javac");
             return Result.ERROR.exitCode;
         }
         int exitcode = tool.get().run(printWriter, printWriter, args);

         // Process compiler output (which is always errors)
         printWriter.flush();
         Util.getLines(strWriter.toString()).forEach(Log::error);

         return exitcode;
     }

     private void checkInternalErrorLog() {
         Path errorLogPath = errorLog.getLogDestination();
         if (errorLogPath != null) {
             Log.error("Server has encountered an internal error. See " + errorLogPath.toAbsolutePath()
                     + " for details.");
         }
     }

     public static void restoreServerErrorLog() {
         Log.setLogForCurrentThread(errorLog);
     }

     public void shutdownServer(String quitMsg) {
         if (!keepAcceptingRequests.compareAndSet(true, false)) {
             // Already stopped, no need to shut down again
             return;
         }

         Log.debug("Quitting: " + quitMsg);

         portFileMonitor.shutdown(); // No longer any need to monitor port file

         // Unpublish port before shutting down socket to minimize the number of
         // failed connection attempts
         try {
             portFile.delete();
         } catch (IOException | InterruptedException e) {
             Log.error(e);
         }
         try {
             serverSocket.close();
         } catch (IOException e) {
             Log.error(e);
         }
     }
 }
	/*
	* Copyright (c) 2011, 2022, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javacserver.server;

	import java.io.BufferedReader;
	import java.io.FileNotFoundException;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.io.PrintStream;
	import java.io.PrintWriter;
	import java.io.StringWriter;
	import java.net.InetAddress;
	import java.net.InetSocketAddress;
	import java.net.ServerSocket;
	import java.net.Socket;
	import java.net.SocketException;
	import java.nio.file.Path;
	import java.util.Optional;
	import java.util.Random;
	import java.util.concurrent.atomic.AtomicBoolean;
	import java.util.spi.ToolProvider;
	import javacserver.shared.PortFile;
	import javacserver.shared.Protocol;
	import javacserver.shared.Result;
	import javacserver.util.LazyInitFileLog;
	import javacserver.util.Log;
	import javacserver.util.LoggingOutputStream;
	import javacserver.util.Util;

	/**
	* Start a new server main thread, that will listen to incoming connection requests from the client,
	* and dispatch these on to worker threads in a thread pool, running javac.
	*/
	public class Server {
	private ServerSocket serverSocket;
	private PortFile portFile;
	private PortFileMonitor portFileMonitor;
	private IdleMonitor idleMonitor;
	private CompilerThreadPool compilerThreadPool;

	// Set to false break accept loop
	final AtomicBoolean keepAcceptingRequests = new AtomicBoolean();

	// For logging server internal (non request specific) errors.
	private static LazyInitFileLog errorLog;

	public static void main(String... args) {
	initLogging();

	try {
	PortFile portFile = getPortFileFromArguments(args);
	if (portFile == null) {
	System.exit(Result.CMDERR.exitCode);
	return;
	}

	Server server = new Server(portFile);
	if (!server.start()) {
	System.exit(Result.ERROR.exitCode);
	} else {
	System.exit(Result.OK.exitCode);
	}
	} catch (IOException \| InterruptedException ex) {
	ex.printStackTrace();
	System.exit(Result.ERROR.exitCode);
	}
	}

	private static void initLogging() {
	// Under normal operation, all logging messages generated server-side
	// are due to compilation requests. These logging messages should
	// be relayed back to the requesting client rather than written to the
	// server log. The only messages that should be written to the server
	// log (in production mode) should be errors,
	errorLog = new LazyInitFileLog("server.log");
	Log.setLogForCurrentThread(errorLog);
	Log.setLogLevel(Log.Level.ERROR); // should be set to ERROR.

	// Make sure no exceptions go under the radar
	Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
	restoreServerErrorLog();
	Log.error(e);
	});

	// Inevitably someone will try to print messages using System.{out,err}.
	// Make sure this output also ends up in the log.
	System.setOut(new PrintStream(new LoggingOutputStream(System.out, Log.Level.INFO, "[stdout] ")));
	System.setErr(new PrintStream(new LoggingOutputStream(System.err, Log.Level.ERROR, "[stderr] ")));
	}

	private static PortFile getPortFileFromArguments(String[] args) {
	if (args.length != 1) {
	Log.error("javacserver daemon incorrectly called");
	return null;
	}
	String portfilename = args[0];
	PortFile portFile = new PortFile(portfilename);
	return portFile;
	}

	public Server(PortFile portFile) throws FileNotFoundException {
	this.portFile = portFile;
	}

	/**
	* Start the daemon, unless another one is already running, in which it returns
	* false and exits immediately.
	*/
	private boolean start() throws IOException, InterruptedException {
	// The port file is locked and the server port and cookie is written into it.
	portFile.lock();
	portFile.getValues();
	if (portFile.containsPortInfo()) {
	Log.debug("javacserver daemon not started because portfile exists!");
	portFile.unlock();
	return false;
	}

	serverSocket = new ServerSocket();
	InetAddress localhost = InetAddress.getByName(null);
	serverSocket.bind(new InetSocketAddress(localhost, 0));

	// At this point the server accepts connections, so it is now safe
	// to publish the port / cookie information

	// The secret cookie shared between server and client through the port file.
	// Used to prevent clients from believing that they are communicating with
	// an old server when a new server has started and reused the same port as
	// an old server.
	long myCookie = new Random().nextLong();
	portFile.setValues(serverSocket.getLocalPort(), myCookie);
	portFile.unlock();

	portFileMonitor = new PortFileMonitor(portFile, this::shutdownServer);
	portFileMonitor.start();
	compilerThreadPool = new CompilerThreadPool();
	idleMonitor = new IdleMonitor(this::shutdownServer);

	Log.debug("javacserver daemon started. Accepting connections...");
	Log.debug(" port: " + serverSocket.getLocalPort());
	Log.debug(" time: " + new java.util.Date());
	Log.debug(" poolsize: " + compilerThreadPool.poolSize());

	keepAcceptingRequests.set(true);
	do {
	try {
	Socket socket = serverSocket.accept();
	// Handle each incoming request in a separate thread. This is just for socket communication,
	// the actual compilation will be done by the threadpool.
	Thread requestHandler = new Thread(() -> handleRequest(socket));
	requestHandler.start();
	} catch (SocketException se) {
	// Caused by serverSocket.close() and indicates shutdown
	}
	} while (keepAcceptingRequests.get());

	Log.debug("Shutting down.");

	// No more connections accepted. If any client managed to connect after
	// the accept() was interrupted but before the server socket is closed
	// here, any attempt to read or write to the socket will result in an
	// IOException on the client side.

	// Shut down
	idleMonitor.shutdown();
	compilerThreadPool.shutdown();

	return true;
	}

	private void handleRequest(Socket socket) {
	try (BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
	PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
	try {
	idleMonitor.startCall();

	// Set up logging for this thread. Stream back logging messages to
	// client on the format "level:msg".
	Log.setLogForCurrentThread(new Protocol.ProtocolLog(out));

	String[] args = Protocol.readCommand(in);

	// If there has been any internal errors, notify client
	checkInternalErrorLog();

	// Perform compilation. This will call runCompiler() on a
	// thread in the thread pool
	int exitCode = compilerThreadPool.dispatchCompilation(args);
	Protocol.sendExitCode(out, exitCode);

	// Check for internal errors again.
	checkInternalErrorLog();
	} finally {
	idleMonitor.endCall();
	}
	} catch (Exception ex) {
	// Not much to be done at this point. The client side request
	// code will most likely throw an IOException and the
	// compilation will fail.
	Log.error(ex);
	} finally {
	Log.setLogForCurrentThread(null);
	}
	}

	public static int runCompiler(Log log, String[] args) {
	Log.setLogForCurrentThread(log);

	// Direct logging to our byte array stream.
	StringWriter strWriter = new StringWriter();
	PrintWriter printWriter = new PrintWriter(strWriter);

	// Compile
	Optional<ToolProvider> tool = ToolProvider.findFirst("javac");
	if (tool.isEmpty()) {
	Log.error("Can't find tool javac");
	return Result.ERROR.exitCode;
	}
	int exitcode = tool.get().run(printWriter, printWriter, args);

	// Process compiler output (which is always errors)
	printWriter.flush();
	Util.getLines(strWriter.toString()).forEach(Log::error);

	return exitcode;
	}

	private void checkInternalErrorLog() {
	Path errorLogPath = errorLog.getLogDestination();
	if (errorLogPath != null) {
	Log.error("Server has encountered an internal error. See " + errorLogPath.toAbsolutePath()
	+ " for details.");
	}
	}

	public static void restoreServerErrorLog() {
	Log.setLogForCurrentThread(errorLog);
	}

	public void shutdownServer(String quitMsg) {
	if (!keepAcceptingRequests.compareAndSet(true, false)) {
	// Already stopped, no need to shut down again
	return;
	}

	Log.debug("Quitting: " + quitMsg);

	portFileMonitor.shutdown(); // No longer any need to monitor port file

	// Unpublish port before shutting down socket to minimize the number of
	// failed connection attempts
	try {
	portFile.delete();
	} catch (IOException \| InterruptedException e) {
	Log.error(e);
	}
	try {
	serverSocket.close();
	} catch (IOException e) {
	Log.error(e);
	}
	}
	}