/**
* Notification that a message has been received. If we just connected, we'll do a quick handshake
* to verify the client, then we just pass the rest on our our output panel.
*
* @param message the message that was received.
*/
public void messageReceived(MessageObject message) {
lastMessageReceived = message;
if (waitingOnHandshakeCompletion) // are we still handshaking?
{
if (ProtocolConstants.HANDSHAKE_CLIENT.equalsIgnoreCase(message.getMessage())) {
waitingOnHandshakeCompletion = false; // we've received what we expected
hasCompletedConnection = true; // and we're now connected
if (message.getData() != null) {
killGradleServerPort = (Integer) message.getData();
killGradleClientProcotol = new KillGradleClientProtocol();
killGradleClient = new ClientProcess(killGradleClientProcotol);
killGradleClient.start(killGradleServerPort);
handShakeCompleted();
} else {
addStatus("Invalid handshaking. Missing port number. Stopping connection");
server.sendMessage("?", "Invalid client handshake protocol!");
closeConnection();
}
} else {
addStatus("Invalid handshaking. Stopping connection");
server.sendMessage("?", "Invalid client handshake protocol!");
closeConnection();
}
} else // otherwise, its just a normal message, the protocol should handle it.
{
try {
handleMessageReceived(message);
} catch (Throwable e) {
logger.error("Problem while handing message :\n" + message, e);
}
}
}
/**
* When this is called, execute the given request.
*
* @param request the request to execute.
*/
public void execute(final Request request) {
// mark this request as being currently executed
currentlyExecutingRequests.add(request);
notifyAboutToExecuteRequest(request);
// I'm just putting these in temp variables for easier debugging
File currentDirectory = getCurrentDirectory();
File gradleHomeDirectory = getGradleHomeDirectory();
File customGradleExecutor = getCustomGradleExecutor();
// the protocol handles the command line to launch gradle and messaging between us and said
// externally launched gradle.
ProcessLauncherServer.Protocol serverProtocol =
request.createServerProtocol(
logLevel,
stackTraceLevel,
currentDirectory,
gradleHomeDirectory,
customGradleExecutor);
// the server kicks off gradle as an external process and manages the communication with said
// process
ProcessLauncherServer server = new ProcessLauncherServer(serverProtocol);
request.setProcessLauncherServer(server);
// we need to know when this command is finished executing so we can mark it as complete and
// notify any observers.
server.addServerObserver(
new ProcessLauncherServer.ServerObserver() {
public void clientExited(int result, String output) {
currentlyExecutingRequests.remove(request);
notifyRequestExecutionComplete(request, result, output);
}
public void serverExited() {}
},
false);
server.start();
}
/**
* Notification that the client has shutdown. Note: this can occur before communciations has ever
* started. You SHOULD get this notification before receiving serverExited, even if the client
* fails to launch or locks up.
*
* @param returnCode the return code of the client application
* @param output the standard error and standard output of the client application
*/
public void clientExited(int returnCode, String output) {
server.requestShutdown();
boolean wasPremature = false;
String message;
if (!hasCompletedConnection) // if we never connected, report it
{
message = "Failed to connect to gradle process for command '" + commandLine + "'\n" + output;
wasPremature = true;
} else if (!hasReceivedBuildCompleteNotification) // this may happen if the client doesn't
// execute properly or it was killed/canceled.
// This is just so we don't lose our output
// (which may yeild clues to the problem).
{
message = output;
wasPremature = true;
} else {
message = output;
}
reportClientExit(wasPremature, returnCode, message);
}
/** Notification that the connection was accepted by the client. */
public void connectionAccepted() {
// let's make sure we're talking to the right client with some tiny handshaking.
server.sendMessage(ProtocolConstants.HANDSHAKE_TYPE, ProtocolConstants.HANDSHAKE_SERVER);
continueConnection = true;
waitingOnHandshakeCompletion = true;
}