private final void option_req(final GearmanPacket packet, final ServerClient client) {
/*
* A client issues this to set an option for the connection in the
* job server. Returns a OPTION_RES packet on success, or an ERROR
* packet on failure.
*
* Arguments:
* - Name of the option to set. Possibilities are:
* "exceptions" - Forward WORK_EXCEPTION packets to the client.
*/
final byte[] option = packet.getArgumentData(0);
assert option != null;
final byte[] exceptions = new byte[] {'e', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n', 's'};
if (Arrays.equals(option, exceptions)) {
// exceptions option
client.setForwardsExceptions(true);
client.sendPacket(ServerStaticPackets.OPTION_RES_EXCEPTIONS, null /*TODO*/);
} else {
// unknown option
client.sendPacket(ServerStaticPackets.ERROR_UNKNOWN_OPTION, null /*TODO*/);
}
}
private final void get_status(final GearmanPacket packet, final ServerClient client) {
/*
* A client issues this to get status information for a submitted job.
*
* Arguments:
* - Job handle that was given in JOB_CREATED packet.
*/
final byte[] jobHandle = packet.getArgumentData(0);
assert jobHandle != null;
final ByteArray jobHandleBA = new ByteArray(jobHandle);
final ServerJob job = ServerJobAbstract.getJob(jobHandleBA);
if (job == null) {
// Send unknown job STATUS_RES packet
final byte[] unknown = new byte[] {'0'};
final GearmanPacket status_res =
new GearmanPacket(
Magic.RES, Type.STATUS_RES, jobHandle, unknown, unknown, unknown, unknown);
client.sendPacket(status_res, null /*TODO*/);
return;
}
final GearmanPacket status = job.createStatusResPacket();
client.sendPacket(status, null /*TODO*/);
}
private final void text_maxqueue(final String[] args, final ServerClient client) {
final byte[] funcName = args[1].getBytes(GearmanConstants.UTF_8);
if (funcName == null) {
client.sendPacket(ServerStaticPackets.TEXT_INCOMPLETE_ARGS, null /*TODO*/);
return;
}
final ByteArray funcNameBA = new ByteArray(funcName);
final String sizeStr = args[2];
if (sizeStr == null) {
client.sendPacket(ServerStaticPackets.TEXT_INCOMPLETE_ARGS, null /*TODO*/);
return;
}
final int size;
try {
size = Integer.parseInt(sizeStr);
} catch (NumberFormatException e) {
client.sendPacket(ServerStaticPackets.TEXT_OK, null /*TODO*/);
return;
}
/*
* FWIX CHANGE
*/
// final ServerFunction func = this.funcSet.getFunctionIfDefined(funcNameBA);
funcSet.setMaxQueueByName(funcNameBA, size);
}
private final void worker_time_status(final String[] args, final ServerClient client) {
synchronized (this.server.getClientSet()) {
for (ServerClient c : this.server.getClientSet())
client.sendPacket(c.getTimeStatus(), null /*TODO*/);
}
client.sendPacket(ServerStaticPackets.TEXT_DONE, null /*TODO*/);
}
private final void work_status(final GearmanPacket packet, final ServerClient client) {
/*
* This is sent to update the server (and any listening clients)
* of the status of a running job. The client should send these
* periodically for long running jobs to update the percentage
* complete. The job server should store this information so a client
* who issued a background command may retrieve it later with a
* GET_STATUS request.
*
* Arguments:
* - NULL byte terminated job handle.
* - NULL byte terminated percent complete numerator.
* - Percent complete denominator.
*/
final byte[] jobHandle = packet.getArgumentData(0);
assert jobHandle != null;
final ByteArray jobHandleBA = new ByteArray(jobHandle);
final byte[] num = packet.getArgumentData(1);
assert num != null;
final byte[] den = packet.getArgumentData(2);
assert den != null;
final ServerJob job = ServerJobAbstract.getJob(jobHandleBA);
if (job == null) {
client.sendPacket(ServerStaticPackets.ERROR_JOB_NOT_FOUND, null /*TODO*/);
} else {
packet.setMagic(Magic.RES);
job.setStatus(num, den);
job.sendPacket(packet);
}
}
private final void work_data(final GearmanPacket packet, final ServerClient client) {
/*
* This is sent to update the client with data from a running job. A
* client should use this when it needs to send updates, send partial
* results, or flush data during long running jobs. It can also be
* used to break up a result so the client does not need to buffer
* the entire result before sending in a WORK_COMPLETE packet.
*
* Arguments:
* - NULL byte terminated job handle.
* - Opaque data that is returned to the client.
*/
final byte[] jobHandle = packet.getArgumentData(0);
assert jobHandle != null;
final ByteArray jobHandleBA = new ByteArray(jobHandle);
final ServerJob job = ServerJobAbstract.getJob(jobHandleBA);
if (job == null) {
client.sendPacket(ServerStaticPackets.ERROR_JOB_NOT_FOUND, null /*TODO*/);
} else {
packet.setMagic(Magic.RES);
job.sendPacket(packet);
}
}
/**
* Called when a text-based packet is received. When a packet with type -1 is received, it's
* assumed to be a text-based packet. The first argument (The command argument in a text-based
* packet) is checked against the set of known commands. Then, the command is executed or an
* exception is returned to the client if the command is unknown.
*
* @param packet The received packet with a type of -1
* @param client The client who received the packet
*/
private final void text_packet(final GearmanPacket packet, final ServerClient client) {
final String pkt = new String(packet.toBytes(), GearmanConstants.UTF_8);
final String[] args = pkt.trim().split("[ \t]");
if (args[0].equalsIgnoreCase("workers")) {
text_workers(args, client);
return;
} else if (args[0].equalsIgnoreCase("status")) {
text_status(args, client);
return;
} else if (args[0].equalsIgnoreCase("maxqueue")) {
text_maxqueue(args, client);
return;
} else if (args[0].equalsIgnoreCase("shutdown")) {
text_shutdown(args, client);
return;
} else if (args[0].equalsIgnoreCase("version")) {
text_version(args, client);
return;
} else if (args[0].equalsIgnoreCase("throttle")) {
update_throttle(args, client);
return;
} else if (args[0].equalsIgnoreCase("memstats")) {
getMemStats(client);
return;
} else if (args[0].equalsIgnoreCase("workertime")) {
worker_time_status(args, client);
return;
} else {
client.sendPacket(ServerStaticPackets.TEXT_UNKNOWN_COMMAND, null /*TODO*/);
}
}
private final void echo_req(final GearmanPacket packet, final ServerClient client) {
/*
* When a job server receives this request, it simply generates a
* ECHO_RES packet with the data. This is primarily used for testing
* or debugging.
*
* Arguments:
* - Opaque data that is echoed back in response.
*/
packet.setMagic(Magic.RES);
client.sendPacket(packet, null /*TODO*/);
}
public void getMemStats(final ServerClient client) {
StringBuilder sb = new StringBuilder();
sb.append(Main.memUsed());
sb.append('\t');
sb.append(Main.getThreadCount());
sb.append('\t');
sb.append(Main.getActiveThreadCount());
sb.append('\t');
sb.append(Main.getUpTime());
sb.append('\n');
client.sendPacket(GearmanPacket.createTEXT(sb.toString()), null /*TODO*/);
return;
}
private final void work_fail(final GearmanPacket packet, final ServerClient client) {
/*
* This is to notify the server (and any listening clients) that
* the job failed.
*
* Arguments:
* - Job handle.
*/
final byte[] jobHandle = packet.getArgumentData(0);
assert jobHandle != null;
final ByteArray jobHandleBA = new ByteArray(jobHandle);
final ServerJob job = ServerJobAbstract.getJob(jobHandleBA);
if (job == null) {
client.sendPacket(ServerStaticPackets.ERROR_JOB_NOT_FOUND, null /*TODO*/);
} else {
job.workComplete(packet);
}
}
private final void work_exception(final GearmanPacket packet, final ServerClient client) {
/*
* This is to notify the server (and any listening clients) that
* the job failed with the given exception.
*
* Arguments:
* - NULL byte terminated job handle.
* - Opaque data that is returned to the client as an exception.
*/
// Note: The protocol states this packet notifies the server that the specified job
// has failed. However, the C server does not fail the Job. It is effectively a
// WORK_WARNING packet that is only sent to clients that have specified they want
// exceptions forwarded to them. This server will do the same as long as the C
// server does so.
/*
* This is sent to update the client with data from a running job. A
* client should use this when it needs to send updates, send partial
* results, or flush data during long running jobs. It can also be
* used to break up a result so the client does not need to buffer
* the entire result before sending in a WORK_COMPLETE packet.
*
* Arguments:
* - NULL byte terminated job handle.
* - Opaque data that is returned to the client.
*/
final byte[] jobHandle = packet.getArgumentData(0);
;
assert jobHandle != null;
final ByteArray jobHandleBA = new ByteArray(jobHandle);
final ServerJob job = ServerJobAbstract.getJob(jobHandleBA);
if (job == null) {
client.sendPacket(ServerStaticPackets.ERROR_JOB_NOT_FOUND, null /*TODO*/);
} else {
packet.setMagic(Magic.RES);
job.sendPacket(packet);
}
}
public void update_throttle(
final String[] args, final ServerClient client) { // String function, Integer throttle){
String function = args[1];
Integer throttle = 0;
StringBuilder sb = new StringBuilder();
if (args[2].equalsIgnoreCase("NOTHROTTLE")) {
System.out.println("REMOVE THROTTLE" + function);
Main.removeThrottle(function);
sb.append(function);
sb.append('\t');
sb.append("remove throttle");
sb.append('\n');
} else if (args[2].equalsIgnoreCase("KILL")) {
System.out.println("KILL FUNCTION");
RemoveClass remove = new RemoveClass(function);
Thread t = new Thread(remove);
t.start();
sb.append(function);
sb.append('\t');
sb.append("kill");
sb.append('\n');
} else {
throttle = Integer.parseInt(args[2]);
;
if (throttle != null && throttle >= 0) {
System.out.println("Putthing throttle: " + throttle + " for function " + function);
Main.setThrottle(function, throttle);
sb.append(function);
sb.append('\t');
sb.append(throttle);
sb.append('\n');
}
}
client.sendPacket(GearmanPacket.createTEXT(sb.toString()), null /*TODO*/);
return;
}
private final void work_complete(final GearmanPacket packet, final ServerClient client) {
/*
* This is to notify the server (and any listening clients) that
* the job completed successfully.
*
* Arguments:
* - NULL byte terminated job handle.
* - Opaque data that is returned to the client as a response.
*/
final byte[] jobHandle = packet.getArgumentData(0);
assert jobHandle != null;
final ByteArray jobHandleBA = new ByteArray(jobHandle);
final ServerJob job = ServerJobAbstract.getJob(jobHandleBA);
if (job == null) {
client.sendPacket(ServerStaticPackets.ERROR_JOB_NOT_FOUND, null /*TODO*/);
} else {
// Construct a WORK_COMPLETE response packet
client.jobCOmplete();
job.workComplete(packet);
}
}
/**
* Once a packet has been acquired from a client, it's processed here. The packet is processed in
* compliance with the gearman protocol.
*
* @param packet The packet sent by the client
* @param client The client associated with the client that sent the packet
*/
public final void execute(final GearmanPacket packet, final ServerClient client) {
switch (packet.getPacketType()) {
// Text Packets
case TEXT:
text_packet(packet, client);
return;
// Binary Packets
case CAN_DO:
can_do(packet, client);
return;
case CAN_DO_TIMEOUT:
can_do(packet, client);
return;
case CANT_DO:
cant_do(packet, client);
return;
case ECHO_REQ:
echo_req(packet, client);
return;
case GET_STATUS:
get_status(packet, client);
return;
case GRAB_JOB:
grab_job(packet, client);
return;
case GRAB_JOB_UNIQ:
grab_job_uniq(packet, client);
return;
case OPTION_REQ:
option_req(packet, client);
return;
case PRE_SLEEP:
pre_sleep(packet, client);
return;
case RESET_ABILITIES:
System.out.println("New worker has joined");
reset_abilities(packet, client);
return;
case SET_CLIENT_ID:
set_client_id(packet, client);
return;
case SUBMIT_JOB:
submit_job(packet, client, ServerJob.JobPriority.MID, false);
return;
case SUBMIT_JOB_BG:
submit_job(packet, client, ServerJob.JobPriority.MID, true);
return;
case SUBMIT_JOB_HIGH:
submit_job(packet, client, ServerJob.JobPriority.HIGH, false);
return;
case SUBMIT_JOB_HIGH_BG:
submit_job(packet, client, ServerJob.JobPriority.HIGH, true);
return;
case SUBMIT_JOB_LOW:
submit_job(packet, client, ServerJob.JobPriority.LOW, false);
return;
case SUBMIT_JOB_LOW_BG:
submit_job(packet, client, ServerJob.JobPriority.LOW, true);
return;
case WORK_COMPLETE:
work_complete(packet, client);
return;
case WORK_DATA:
case WORK_WARNING:
work_data(packet, client);
return;
case WORK_EXCEPTION:
work_exception(packet, client);
return;
case WORK_FAIL:
work_fail(packet, client);
return;
case WORK_STATUS:
work_status(packet, client);
return;
// Response Only Packets
case NOOP:
case JOB_CREATED:
case NO_JOB:
case ECHO_RES:
case ERROR:
case STATUS_RES:
case OPTION_RES:
case JOB_ASSIGN:
case JOB_ASSIGN_UNIQ:
// Packets Not Yet Implemented
case ALL_YOURS:
case SUBMIT_JOB_EPOCH:
case SUBMIT_JOB_SCHED:
client.sendPacket(ServerStaticPackets.ERROR_BAD_COMMAND, null /*TODO*/);
return;
// Unknown Command
default:
client.sendPacket(ServerStaticPackets.ERROR_BAD_COMMAND, null /*TODO*/);
return;
}
}
private final void text_version(final String[] args, final ServerClient client) {
client.sendPacket(ServerStaticPackets.TEXT_VERSION, null /*TODO*/);
}
