summaryrefslogblamecommitdiffstats
path: root/gearman/controllerWorker/ControllerWorker/Boot.java
blob: 74aa8284022b919e38e3ece5539e69539b0f12c3 (plain) (tree)
1
2
3
4
5
6
7



                           
                                               

                         





                                            
                                           



                                                        


                                  
                                  


                               
                                 


                                        
 









                                                                   

                                                   
                                                                                  






                                                                           
                                                           
                 
                                      







                                                                                 






                                   

                                   

                                                              
                                               
                                                                          
                                                                                






                                                       
                                     
                                                       

         
                                                                           
                                                                  
                                            
 



                                                                          
                                                                
 
                                               
 

                                             
 
                                      
 
                               
                                                                            
 
                                                      

                                                                                  
 



                                                                                                  
 



                                                                                                         
 
                                                                                   
                                                                                                         

                                                                                                 

                                                                                                             

                                                                                                     


                                                         
                                 
 
                                      
 

                                            
 
                                      
 

                                                  
 
                                      
 
                               
                                                                          
                                                     

                                                                                  
 



                                                                                                 
 
                                                                                          

                                                                                                                   

                                                                                                     

                                                 
                                 
 
                                      
 
                               
 
                                      
 
                               
 

                                      
 


                                                        
                                                   
                                                  
                                
                                                    


                         
                                  


                                     





                                                                  
 

                                                                                       
                                          
 

                                                        
 





                                                                  
 

                                                                                       
                                          
 

                                                               
 





                                                                  
 

                                                                                      
                                          
 

                                                       
 

                                                       
 































                                                                  




                                               
                                         
         
 
package ControllerWorker;

import java.io.IOException;
import java.lang.Thread;
import java.util.concurrent.ExecutionException;
import java.util.HashMap;
import java.util.Vector;

import org.gearman.client.GearmanClient;
import org.gearman.client.GearmanClientImpl;
import org.gearman.client.GearmanJob;
import org.gearman.client.GearmanJobImpl;
import org.gearman.client.GearmanJobResult;
import org.gearman.client.GearmanJobStatus;
import org.gearman.common.GearmanJobServerConnection;
import org.gearman.common.GearmanNIOJobServerConnection;
import org.gearman.util.ByteUtils;

import org.json.simple.JSONObject;
import org.json.simple.JSONValue;

public class Boot extends Thread {
	private long beginTime;
	private long timeTaken;
	private long timeLeft;
	private Boolean finished;
	private Boolean error;
	private final int updateRate;
	private final long updatePeriod;

	private HashMap<Integer, GearmanJob> pingJobs;
	private HashMap<Integer, GearmanJob> wolJobs;
	private HashMap<Integer, GearmanJob> sshJobs;
	private HashMap<Integer, Integer> status;
	private HashMap<Integer, Integer> errors;

	private Vector<HashMap<String, String>> clients;

	private final GearmanJobServerConnection gearmanConnection;
	private GearmanClient gearmanClient;

	public Boot(String serverAddress, int port,
			Vector<HashMap<String, String>> clients, int updateRate) {
		this.gearmanConnection = new GearmanNIOJobServerConnection(
				serverAddress, port);
		this.gearmanClient = new GearmanClientImpl();
		gearmanClient.addJobServer(this.gearmanConnection);
		this.clients = clients;
		for (HashMap<String, String> client : clients) {
			int clientID = Integer.parseInt(client.get("id"));
			status.put(clientID, 0); // no work
		}
		this.finished = false;
		this.error = false;
		this.pingJobs = new HashMap<Integer, GearmanJob>();
		this.wolJobs = new HashMap<Integer, GearmanJob>();
		this.sshJobs = new HashMap<Integer, GearmanJob>();
		this.status = new HashMap<Integer, Integer>();
		this.errors = new HashMap<Integer, Integer>();
		this.updateRate = updateRate; // updates per second
		this.updatePeriod = 1000000000L / this.updateRate; // nanoseconds
	}

	public void run() {
		workerLoop();
	}

	private void workerLoop() {
		Boolean run = true;
		while (run) {
			try {
				beginTime = System.nanoTime();
				run = update();
				timeTaken = System.nanoTime() - beginTime;
				timeLeft = (updatePeriod - timeTaken) / 1000000;
				if (timeLeft < 10)
					timeLeft = 10;
				Thread.sleep(timeLeft);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		this.finished = true;
		System.out.println("Booting finished");
	}

	private Boolean update() throws IllegalStateException, IOException,
			InterruptedException, ExecutionException {
		Boolean allFinished = false;

		for (HashMap<String, String> client : clients) {
			String ipAddress = client.get("ip");
			String macAddress = client.get("mac");
			int clientID = Integer.parseInt(client.get("id"));
			int clientStatus = status.get(clientID);

			switch (clientStatus) {

			case 0:
				ping(client);

				break;

			case 1:
				GearmanJob pingJob = pingJobs.get(clientID);

				if (pingJob != null) {
					GearmanJobStatus jobStatus = gearmanClient
							.getJobStatus(pingJob);

					if (!jobStatus.isKnown() && pingJob.isDone()) {
						GearmanJobResult pingJobRes = pingJob.get();
						String result = ByteUtils.fromUTF8Bytes(pingJobRes
								.getResults());

						if (result != "") {
							JSONObject resultObj = (JSONObject) JSONValue
									.parse(result);
							String alive = resultObj.get("alive").toString();

							if (alive.equals("true")) {
								System.out.println(ipAddress + " alive");
								status.put(clientID, 2); // alive
								pingJobs.remove(clientID);
							} else {
								System.out.println(ipAddress + " not alive");
								status.put(clientID, 3); // not alive
								pingJobs.remove(clientID);
							}
						}
					}
				}

				break;

			case 2:
				ssh(client);

				break;

			case 3:
				wakeOnLan(client);

				break;

			case 4:
				GearmanJob wolJob = wolJobs.get(clientID);
				if (wolJob != null) {
					GearmanJobStatus jobStatus = gearmanClient
							.getJobStatus(wolJob);

					if (!jobStatus.isKnown() && wolJob.isDone()) {
						GearmanJobResult wolJobRes = wolJob.get();
						String result = ByteUtils.fromUTF8Bytes(wolJobRes
								.getResults());

						if (result.equals("Magic packet send.")) {
							System.out
									.println(macAddress + "Magic packet send");
							status.put(clientID, 5); // magic packet send
							wolJobs.remove(clientID);
						}
					}
				}

				break;

			case 5:

				break;

			case 6:

				break;
			}

			if (clientStatus == 20) {
				allFinished = true;
			} else if (clientStatus == 19) {
				allFinished = true;
				this.error = true;
			} else {
				allFinished = false;
			}
		}

		if (allFinished) {
			return false;
		} else {
			return true;
		}
	}

	private void ping(HashMap<String, String> client) {
		String ipAddress = client.get("ip");
		int clientID = Integer.parseInt(client.get("id"));

		GearmanJob job = GearmanJobImpl.createJob("ping", ipAddress.getBytes(),
				"ping" + clientID);
		gearmanClient.submit(job);

		status.put(clientID, 1); // ping started
		pingJobs.put(clientID, job);

		System.out.println("ping " + ipAddress);
	}

	private void wakeOnLan(HashMap<String, String> client) {
		String macAddress = client.get("mac");
		int clientID = Integer.parseInt(client.get("id"));

		GearmanJob job = GearmanJobImpl.createJob("wol", macAddress.getBytes(),
				"wol" + clientID);
		gearmanClient.submit(job);

		status.put(clientID, 4); // wake on lan started
		wolJobs.put(clientID, job);

		System.out.println("wake on lan " + macAddress);
	}

	private void ssh(HashMap<String, String> client) {
		String ipAddress = client.get("ip");
		int clientID = Integer.parseInt(client.get("id"));

		GearmanJob job = GearmanJobImpl.createJob("ssh", ipAddress.getBytes(),
				"ssh" + clientID);
		gearmanClient.submit(job);

		status.put(clientID, 6); // ssh started
		sshJobs.put(clientID, job);

		System.out.println("ssh " + ipAddress);
	}

	public Vector<HashMap<String, String>> getClients() {
		return clients;
	}

	public GearmanClient getGearmanClient() {
		return gearmanClient;
	}

	public GearmanJobServerConnection getGearmanConnection() {
		return gearmanConnection;
	}

	public HashMap<Integer, GearmanJob> getPingJobs() {
		return pingJobs;
	}

	public HashMap<Integer, GearmanJob> getWolJobs() {
		return wolJobs;
	}

	public HashMap<Integer, GearmanJob> getSshJobs() {
		return sshJobs;
	}

	public HashMap<Integer, Integer> getStatus() {
		return status;
	}

	public HashMap<Integer, Integer> getErrors() {
		return errors;
	}

	public Boolean isFinished() {
		return finished;
	}

	public Boolean isFinishedWithErrors() {
		return finished && error;
	}
}