/*
* 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);
}
}
}