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



                           
                                  
                      
                         
                               
                                 
                        





                                            
                                           



                                                        
                                 


                                  

                               
                                  
                                                                              
 
                                 
                              
                                       
                              
                                     
                              
                               
                                           
                                           
 

                                                                   

                                 
 

                                                                                     

                                                                               
                                           
                                   


                                                
                                                  
                                                                   
                                               
                                               


                                                                         
                                                                   

                                 






                                   



                                                                            

                                   

                                                              
                                               
                                                                          
                                                                                

                                                      
                                                
                                               
                                                           

                         
                                


                                                                                             
                            
                                                                            
                                                    
                        
                                                                             
                                                     
                 



                                                                              
         
 
          
                                                   
           
 
                                                   

                               
 
                                               
                                                    
 
                                            
                                             
 
                                      
 
                                                 
                                                          
 
                                      
 
                                             
                                                
 
                                      
 
                                              
                                                  
 
                                      
 
                                                        
                                                               
 
                                      
 
                                               

                                                           
                                                                                  
                                                      
 
                                      
 
                                            
                                                      


                                      
                                                     
                                                             
 
                                      
 
                                                    
                                                             
 
                                      
 
                                      
                                            
 
                                      
 
                                                
                                                         
 
                                      
 
                                                 

                                           
                                      
 
                                               
                                                        
 
                                      
 
                                                       






                                                                                                   
 
                                      
 

                                                        
 
                                      
 
                                            
                                                
 
                                      
 
                                                    
                                                             


                                      
                                                  

                                                           
                                                                                              
                                                            
 

                                      
                                                         
                                                            


                                      
                                                                  
                                                                         


                                      
                                             
                                                                                        
                                                                              
                                                                          

                                                                                       

                                      
                                            

                                                           
                                                                                          
                                                        
 

                                      
                                                     



                                                        
                                                              
                                                                     


                                      
                                        
                                                           
                                                                                                       
                                                        

                                                     


                                      
                                          
                                                           
                                                                                                          
                                                        
                                 
 
                                      
                         
                 
 
                                            

                                                  
                                                   
                                
                                                    
                                      


                         
                                  


                                     


                 
          
                                                                                    

           
                                          

                                                                                
                                          
                                                                                
                                                      
                                                      

         
                                                                                     
                                                                      
 
                                      
                                                                                         

                                                                            

                                                                                        
                                                        
                                                                                                    
                                                                            
                                                                                                 

                                                                                               

                                                                                                    
                                                                                  

                                                                                                   

                                                                                                     
                                                                                  

                                                 



                                                                                                                       
                                                                                                       
                                                                          


                                         


                 
                                                   

                                                                                
                                          
                                                                                    
                                                      
                                                      
         


                                                                          
                                                                         
 



                                                                      

                                                                                       




                                                                                       

                                                                                          
                                                                

                                                                                             


                                                                                                         

                                                                                                         
                                                                                            

                                                                                                         
                                                                                             

                                                                                                            

                                                                                                           
                                                                                             

                                                         




                                                                                                                                                 
                                                          

                                                                                                         
                                                           

                                                                                               
                                                                                     






                                                                                         
                                                                                       
                                                             
                         
                 
         
 
                                                         

                                                                                
                                          

                                                                                 
                                                      
                                                      
         


                                                                    
                                                                                     



                                                                      

                                                                                    
                                                   
                                                                    






                                                                                                   
                                                                

                                                                                             




                                                                                                                
                                                                      


                                                                                                                                        
                                                                                                         


                                                                                                         

                                                                                                           
                                                                                                         

                                                         




                                                                                                                                             
                                                          

                                                                                                          
                                                           

                                                                                               
                                                                                                 






                                                                                  
                                                                                       
                                                                         


                         
 
                                                     

                                                                                
                                          

                                                                             
                                                      
                                                      
         


                                                                                  
                                                                                 
 



                                                                      

                                                                                






                                                                                               

                                                                                                 



                                                                                             
                                                                                                         



                                                                                                             

                                                                                                         
                                                                                                     
                                                                                           
                                                                                                            
                                                                                        


                                                                                                                    
                                                                                                     

                                                         

                                                                                             



                                                                                                                                              

                                                                                                           
                                                           

                                                                                               



                                                 
                                                                                            

                                                                               
                                                                                       
                                                                     


                         
 
                                               

                                                                                
                                          
                                                                                       
                                                     
                                                              
         


                                                                            
                                                                    
 
                                     
                                                                                        


                                                                          
                                                                                                

                                                                                             

                                                                                      
                                                                 

                                                                                                    

                                                                                                               
                                                                                     
                                                                                               
                                                                 



                                 
 
                                             

                                                                              
                                          
                                                                                   
                                                    
                                                          
         


                                                                          
                                                                  










                                                                                                    




                                                                                                            

                                                                                                  

                                                                                                 
                                                                                

                                                                                                  


                                                                                                       
                                                                                


                                                                                                  

                                                                                                                                     
                                                                                    
                                                                                                       
                                                                        




                                         
 
                                         

                                                                               
                                          
                                                                               
                                                     
                                                     
         
 
                                                                                    
                                                                    










                                                                                                    



                                                                                                    





                                                                               

                                                                                                              


                                                                                                            
                                                           

                                                                                                        
                                                                                 
                                                        


                                                                                                                  

                                                                                                        
                                                                                 

                                                 



                                                                                                                               
                                                  
                                                                                                        
                                                   
                                                         
                                                                                                       
                                                                         




                                         
 
                                        

                                                                              
                                          
                                                                              
                                                    
                                                    
         
 
                                                                                   
                                                                  











                                                                                                    















                                                                                                                                                  


                                                                                       
                                                                                            
                                                                                      
                                                                      


                                                         
















                                                                                                                       

                                                                     










                                                                                                                      
                                                                                
                                                        
                                                                                                        
                                                                                             

                                                                                                   
                                                                                

                                                 



                                                                                                                             
                                                  
                                                                                                    
                                                   
                                                                                                       
                                                                        
                                         









                                                                                                                     



                                 
 








                                                                              
 






                                                                                       

                                                                                               



                                                                                                    





























                                                                                                                                       

                                                                                






                                                                                                                                      
                                                                                








                                                                                                                        
                                         








                                                                                                                


                         

                             
 
                                             

                                                                                   
                                          
                                                                                   
                                                         
                                                         
         


                                                                          
                                                                            
 









                                                                                                      

                                                                                                 
                                                                             
                                                



                                                                                                                          
                                                                                                
                                                                                                       
                                                                             




                                         
 
                                     
                                          





                                               
                                            

                               



                                      
 
package ControllerWorker;

import java.io.IOException;
import java.lang.Thread;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.StringTokenizer;
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.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;

import org.apache.log4j.Logger;

public class Boot extends Thread {
	private static final Logger logger = ControllerWorkerMain.getLogger();

	private String eventName;
	private Boolean force;
	private Vector<Client> clients;
	private String bootOS;
	private final int updateRate;
	private long waitTime;
	private long scsavTime;
	private Vector<String> psWhitelist;
	private Vector<String> psBlacklist;

	private final GearmanJobServerConnection gearmanConnection;
	private GearmanClient gearmanClient;
	private Boolean finished;
	private Boolean error;

	public Boot(String eventName, Boolean force, Vector<Client> clients,
			String bootOS, int updateRate, long waitTime, long scsavTime,
			Vector<String> psWhitelist, Vector<String> psBlacklist,
			String gearmanServerAddress, int gearmanServerPort) {
		this.eventName = eventName;
		this.force = force;
		this.clients = clients;
		this.bootOS = bootOS;
		this.waitTime = waitTime * 1000;
		this.scsavTime = scsavTime * 1000;
		this.updateRate = updateRate; // updates per second
		this.psWhitelist = psWhitelist;
		this.psBlacklist = psBlacklist;
		gearmanConnection = new GearmanNIOJobServerConnection(
				gearmanServerAddress, gearmanServerPort);
		gearmanClient = new GearmanClientImpl();
		gearmanClient.addJobServer(this.gearmanConnection);
		finished = false;
		error = false;
	}

	public void run() {
		workerLoop();
	}

	private void workerLoop() {
		long beginTime;
		long timeTaken;
		long timeLeft;
		long updatePeriod = 1000000000L / updateRate; // nanoseconds
		Boolean run = true;
		while (run) {
			try {
				beginTime = System.nanoTime();
				run = update();
				timeTaken = System.nanoTime() - beginTime;
				timeLeft = (updatePeriod - timeTaken) / 1000000;
				if (timeLeft < 10)
					timeLeft = 10;
				sleep(timeLeft);
			} catch (Exception e) {
				logger.error(e.toString());
			}
		}
		finished = true;
		LinkedHashMap<String, Object> jsonData = new LinkedHashMap<String, Object>();
		jsonData.put("eventName", eventName);
		jsonData.put("type", "finishBootState");
		if (error) {
			logger.error("Booting of " + eventName + " failed");
			jsonData.put("error", true);
		} else {
			logger.info("Booting of " + eventName + " finished");
			jsonData.put("error", false);
		}
		String dataString = JSONValue.toJSONString(jsonData);
		GearmanJob job = GearmanJobImpl.createJob("status", dataString
				.getBytes(), "status" + eventName);
		gearmanClient.submit(job);
	}

	/*
	 * -------------- boot logik --------------
	 */

	private Boolean update() throws Exception {
		Date date;
		long timestamp;

		for (Client client : clients) {
			switch (client.getState()) {

			case CLIENT_UNKNOWN:
				ping(client);

				break;

			case CHECK_PING_PROGRESS:
				checkPingProgress(client);

				break;

			case CLIENT_IS_ALIVE:
				checkOS(client);

				break;

			case CLIENT_NOT_ALIVE:
				wakeOnLan(client);

				break;

			case CHECK_WAKE_ON_LAN_PROGRESS:
				checkWakeOnLanProgress(client);

				break;

			case MAGIC_PACKET_SENT:
				date = new Date();
				timestamp = date.getTime();
				client.addPingTime(ClientPingTime.WOL, timestamp);
				pingWakeOnLan(client);

				break;

			case PING_WOL_AGAIN:
				pingWakeOnLan(client);

				break;

			case CHECK_PING_WOL_PROGRESS:
				checkPingWolProgress(client);

				break;

			case CHECK_CHECKOS_PROGRESS:
				checkCheckosProgress(client);

				break;

			case WRONG_OS:
				who(client);

				break;

			case CHECK_WHO_PROGRESS:
				checkWhoProgress(client);

				break;

			case A_USER_IS_LOGGED_IN:
				ps(client);
				
				break;

			case CHECK_PS_PROGRESS:
				checkPsProgress(client);

				break;

			case USERPROCESSES_ARE_RUNNING:
				if (force) {
					logger.info(client.getIp() + " force is enabled");
					// is not working
					client.setState(ClientState.RESTART_CLIENT, gearmanClient);
				} else {
				    ls(client);
				}

				break;

			case CHECK_LS_PROGRESS:
				checkLsProgress(client);

				break;

			case RESTART_CLIENT:
				restart(client);

				break;

			case CHECK_RESTART_PROGRESS:
				checkRestartProgress(client);

				break;

			case RESTART_COMMAND_SENT:
				date = new Date();
				timestamp = date.getTime();
				client.addPingTime(ClientPingTime.RESTARTSHUTDOWN, timestamp);
				pingRestartShutdown(client);

				break;

			case PING_RESTART_SHUTDOWN_AGAIN:
				pingRestartShutdown(client);

				break;

			case CHECK_PING_RESTART_SHUTDOWN_PROGRESS:
				checkPingRestartShutdownProgress(client);

				break;

			case USER_IS_WORKING:
				logger.error(client.getIp() + " User has been working");
				client.setError("The user has been working.");
				// user has been working, go in errorState
				client.setState(ClientState.BOOT_ERROR, gearmanClient);

				break;

			case CLIENT_IS_DOWN:
				date = new Date();
				timestamp = date.getTime();
				client.addPingTime(ClientPingTime.RESTARTBOOT, timestamp);
				pingRestartBoot(client);

				break;

			case PING_RESTART_BOOT_AGAIN:
				pingRestartBoot(client);

				break;

			case CHECK_PING_RESTART_BOOT_PROGRESS:
				checkPingRestartBootProgress(client);

				break;

			case BOOT_ERROR:
				if (!client.isFinished()) {
					logger.error(client.getIp() + " Booting failed"); // errorState
					client.finish();
					error = true;
				}

				break;

			case BOOT_SUCCESS:
				if (!client.isFinished()) {
					logger.info(client.getIp() + " Booting finished"); // successState
					client.finish();
				}

				break;
			}
		}

		boolean allFinished = false;
		for (Client client : clients) {
			if (client.isFinished()) {
				allFinished = true;
			} else {
				allFinished = false;
				break;
			}
		}

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

	/*
	 * ------------------------- function declarations -------------------------
	 */

	private void ping(Client client) {
		GearmanJob job = GearmanJobImpl.createJob("ping", client.getIp()
				.getBytes(), "ping" + client.getId());
		gearmanClient.submit(job);
		client.setState(ClientState.CHECK_PING_PROGRESS, gearmanClient);
		client.addJob(ClientJob.PINGJOB, job);
		logger.info("ping " + client.getIp());
	}

	private void checkPingProgress(Client client) throws Exception, IOException {
		GearmanJob pingJob = client.getJob(ClientJob.PINGJOB);

		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.isEmpty()) {
					JSONObject resultObj = (JSONObject) JSONValue.parse(result);
					if (!resultObj.containsKey("err")) {
						String alive = resultObj.get("alive").toString();
						if (alive.equals("true")) {
							logger.info(client.getIp() + " alive");
							client.setState(ClientState.CLIENT_IS_ALIVE,
									gearmanClient);
							client.removeJob(pingJob);
						} else if (alive.equals("false")) {
							logger.info(client.getIp() + " not alive");
							client.setState(ClientState.CLIENT_NOT_ALIVE,
									gearmanClient);
							client.removeJob(pingJob);
						}
					} else {
						logger.error(client.getIp()
								+ " Cannot send the ping message.");
						client
								.setError("Sending the ping message has been failed.");
						client.setState(ClientState.BOOT_ERROR, gearmanClient);
						client.removeJob(pingJob);
					}
				}
			}
		}
	}

	private void pingWakeOnLan(Client client) {
		GearmanJob job = GearmanJobImpl.createJob("ping", client.getIp()
				.getBytes(), "ping" + client.getId());
		gearmanClient.submit(job);
		client.setState(ClientState.CHECK_PING_WOL_PROGRESS, gearmanClient);
		client.addJob(ClientJob.PINGJOB, job);
		logger.info("ping " + client.getIp());
	}

	private void checkPingWolProgress(Client client) throws Exception,
			IOException {
		GearmanJob pingJobWoL = client.getJob(ClientJob.PINGJOB);

		if (pingJobWoL != null) {
			Date currentDate = new Date();
			Long currentTimestamp = currentDate.getTime();
			// wait 2 min until WoL - Failed
			Long expectedTimestamp = client.getPingTime(ClientPingTime.WOL)
					+ waitTime;
			if (expectedTimestamp >= currentTimestamp) {
				GearmanJobStatus jobStatus = gearmanClient
						.getJobStatus(pingJobWoL);
				if (!jobStatus.isKnown() && pingJobWoL.isDone()) {
					GearmanJobResult pingJobRes = pingJobWoL.get();
					String result = ByteUtils.fromUTF8Bytes(pingJobRes
							.getResults());
					if (!result.isEmpty()) {
						JSONObject resultObj = (JSONObject) JSONValue
								.parse(result);
						if (!resultObj.containsKey("err")) {
							String alive = resultObj.get("alive").toString();
							if (alive.equals("true")) {
								logger.info(client.getIp()
										+ " is alive after WoL");
								// alive, go in successState
								client.setState(ClientState.BOOT_SUCCESS,
										gearmanClient);
								client.removeJob(pingJobWoL);
							} else if (alive.equals("false")) {
								logger.info("ping again " + client.getIp());
								client.setState(ClientState.PING_WOL_AGAIN,
										gearmanClient);
								client.removeJob(pingJobWoL);
							}
						} else {
							logger
									.error(client.getIp()
											+ " Cannot send the ping after wake on LAN message.");
							client
									.setError("Sending the ping after wake on LAN message has been failed.");
							/*
							 * sending the ping after wake on LAN message has
							 * been failed, go to errorState
							 */
							client.setState(ClientState.BOOT_ERROR,
									gearmanClient);
							client.removeJob(pingJobWoL);
						}
					}
				}
			} else {
				logger.error(client.getIp() + " is not alive after WoL");
				client.setError("The wake on LAN has been failed.");
				// not alive, go in errorState
				client.setState(ClientState.BOOT_ERROR, gearmanClient);
				client.removeJob(pingJobWoL);
			}
		}
	}

	private void pingRestartShutdown(Client client) {
		GearmanJob job = GearmanJobImpl.createJob("ping", client.getIp()
				.getBytes(), "ping" + client.getId());
		gearmanClient.submit(job);
		client.setState(ClientState.CHECK_PING_RESTART_SHUTDOWN_PROGRESS,
				gearmanClient);
		client.addJob(ClientJob.PINGJOB, job);
		logger.info("ping " + client.getIp());
	}

	private void checkPingRestartShutdownProgress(Client client)
			throws Exception, IOException {
		GearmanJob pingJobRestartShutdown = client.getJob(ClientJob.PINGJOB);
		if (pingJobRestartShutdown != null) {
			Date currentDate = new Date();
			Long currentTimestamp = currentDate.getTime();
			// wait 2 min until Restart - Failed
			Long expectedTimestamp = client
					.getPingTime(ClientPingTime.RESTARTSHUTDOWN)
					+ waitTime;
			if (expectedTimestamp >= currentTimestamp) {
				GearmanJobStatus jobStatus = gearmanClient
						.getJobStatus(pingJobRestartShutdown);
				if (!jobStatus.isKnown() && pingJobRestartShutdown.isDone()) {
					GearmanJobResult pingJobRestartRes = pingJobRestartShutdown
							.get();
					String result = ByteUtils.fromUTF8Bytes(pingJobRestartRes
							.getResults());
					if (!result.isEmpty()) {
						JSONObject resultObj = (JSONObject) JSONValue
								.parse(result);
						if (!resultObj.containsKey("err")) {
							String alive = resultObj.get("alive").toString();
							if (alive.equals("true")) {
								logger.info(client.getIp() + " is still alive");
								// still alive, ping again
								client
										.setState(
												ClientState.PING_RESTART_SHUTDOWN_AGAIN,
												gearmanClient);
								client.removeJob(pingJobRestartShutdown);
							} else if (alive.equals("false")) {
								logger.info(client.getIp() + " is down");
								// not alive, ping again
								client.setState(ClientState.CLIENT_IS_DOWN,
										gearmanClient);
								client.removeJob(pingJobRestartShutdown);
							}
						} else {
							logger
									.error(client.getIp()
											+ " Cannot send the ping after restart message.");
							client
									.setError("Sending the ping after restart message has been failed.");
							/*
							 * sending the ping after restart message has been
							 * failed
							 */
							client.setState(ClientState.BOOT_ERROR,
									gearmanClient);
							client.removeJob(pingJobRestartShutdown);
						}
					}
				}
			} else {
				logger.error(client.getIp() + " shutdown failed");
				client.setError("The shutdown has been failed.");
				// still alive, go in errorState
				client.setState(ClientState.BOOT_ERROR, gearmanClient);
				client.removeJob(pingJobRestartShutdown);
			}
		}
	}

	private void pingRestartBoot(Client client) {
		GearmanJob job = GearmanJobImpl.createJob("ping", client.getIp()
				.getBytes(), "ping" + client.getId());
		gearmanClient.submit(job);
		client.setState(ClientState.CHECK_PING_RESTART_BOOT_PROGRESS,
				gearmanClient);
		client.addJob(ClientJob.PINGJOB, job);
		logger.info("ping " + client.getIp());
	}

	private void checkPingRestartBootProgress(Client client) throws Exception,
			IOException {
		GearmanJob pingJobRestartBoot = client.getJob(ClientJob.PINGJOB);

		if (pingJobRestartBoot != null) {
			Date currentDate = new Date();
			Long currentTimestamp = currentDate.getTime();
			// wait 2 min until Restart - Failed
			Long expectedTimestamp = client
					.getPingTime(ClientPingTime.RESTARTBOOT)
					+ waitTime;
			if (expectedTimestamp >= currentTimestamp) {
				GearmanJobStatus jobStatus = gearmanClient
						.getJobStatus(pingJobRestartBoot);
				if (!jobStatus.isKnown() && pingJobRestartBoot.isDone()) {
					GearmanJobResult pingJobRestartRes = pingJobRestartBoot
							.get();
					String result = ByteUtils.fromUTF8Bytes(pingJobRestartRes
							.getResults());
					if (!result.isEmpty()) {
						JSONObject resultObj = (JSONObject) JSONValue
								.parse(result);
						if (!resultObj.containsKey("err")) {
							String alive = resultObj.get("alive").toString();
							if (alive.equals("true")) {
								logger.info(client.getIp()
										+ " is alive after restart");
								// alive, go to success state
								client.setState(ClientState.BOOT_SUCCESS,
										gearmanClient);
								client.removeJob(pingJobRestartBoot);
							} else if (alive.equals("false")) {
								logger.info("ping again " + client.getIp());
								// not alive, ping again
								client.setState(
										ClientState.PING_RESTART_BOOT_AGAIN,
										gearmanClient);
								client.removeJob(pingJobRestartBoot);
							}
						} else {
							logger
									.error(client.getIp()
											+ " Cannot send the ping after shutdown message.");
							client
									.setError("Sending the ping after shutdown message has been failed.");
							/*
							 * sending the ping after shutdown message has been
							 * failed
							 */
							client.setState(ClientState.BOOT_ERROR,
									gearmanClient);
						}
					}
				}
			} else {
				logger.error(client.getIp() + " is not alive after reboot");
				client.setError("The reboot has been failed.");
				// not alive, go in errorState
				client.setState(ClientState.BOOT_ERROR, gearmanClient);
				client.removeJob(pingJobRestartBoot);
			}
		}
	}

	private void wakeOnLan(Client client) {
		GearmanJob job = GearmanJobImpl.createJob("wol", client.getMac()
				.getBytes(), "wol" + client.getId());
		gearmanClient.submit(job);
		client.setState(ClientState.CHECK_WAKE_ON_LAN_PROGRESS, gearmanClient);
		client.addJob(ClientJob.WOLJOB, job);
		logger.info("wake on lan " + client.getMac());
	}

	private void checkWakeOnLanProgress(Client client) throws Exception,
			IOException {
		GearmanJob wolJob = client.getJob(ClientJob.WOLJOB);

		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.")) {
					logger.info(client.getMac() + " Magic packet sent.");
					client.setState(ClientState.MAGIC_PACKET_SENT,
							gearmanClient);
					client.removeJob(wolJob);
				} else {
					logger.error(client.getIp() + " Cannot send magic packet.");
					client
							.setError("Sending the magic packet has been failed.");
					// cannot send magic packet, go in errorState
					client.setState(ClientState.BOOT_ERROR, gearmanClient);
					client.removeJob(wolJob);
				}
			}
		}
	}

	private void checkOS(Client client) {
		GearmanJob job = GearmanJobImpl.createJob("os", client.getIp()
				.getBytes(), "os" + client.getId());
		gearmanClient.submit(job);
		client.setState(ClientState.CHECK_CHECKOS_PROGRESS, gearmanClient);
		client.addJob(ClientJob.OSJOB, job);
		logger.info("check OS " + client.getIp());
	}

	private void checkCheckosProgress(Client client) throws Exception,
			IOException {
		GearmanJob osJob = client.getJob(ClientJob.OSJOB);

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

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

				if (!result.isEmpty()) {
					JSONObject resultObj = (JSONObject) JSONValue.parse(result);
					if (!resultObj.containsKey("err")) {
						String clientBootOs = resultObj.get("Distributor ID")
								.toString()
								+ " " + resultObj.get("Release").toString();

						if (clientBootOs.equals(bootOS)) {
							logger.info(client.getIp() + " right OS");
							// right os, go to successState
							client.setState(ClientState.BOOT_SUCCESS,
									gearmanClient);
							client.removeJob(osJob);
						} else {
							logger.info(client.getIp() + " wrong OS");
							client
									.setState(ClientState.WRONG_OS,
											gearmanClient);
							client.removeJob(osJob);
						}
					} else {
						logger.error(client.getIp() + " Cannot check os");
						client
								.setError("The check for correct operating system has been failed.");
						// cannot check os, go in errorState
						client.setState(ClientState.BOOT_ERROR, gearmanClient);
						client.removeJob(osJob);
					}
				}
			}
		}
	}

	private void who(Client client) {
		GearmanJob job = GearmanJobImpl.createJob("who", client.getIp()
				.getBytes(), "who" + client.getId());
		gearmanClient.submit(job);
		client.setState(ClientState.CHECK_WHO_PROGRESS, gearmanClient);
		client.addJob(ClientJob.WHOJOB, job);
		logger.info("who " + client.getIp());
	}

	private void checkWhoProgress(Client client) throws Exception, IOException {
		GearmanJob whoJob = client.getJob(ClientJob.WHOJOB);

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

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

				if (!result.isEmpty()) {
					JSONObject resultObj = (JSONObject) JSONValue.parse(result);
					if (!resultObj.containsKey("err")) {
						String rawoutput = resultObj.get("rawoutput")
								.toString();
						StringTokenizer str = new StringTokenizer(rawoutput,
								" ");
						String user = "";
						if (str.hasMoreTokens()) {
							user = str.nextToken();
						}

						if (user.isEmpty()) {
							logger.info(client.getIp()
									+ " no user is logged in -CHECK PS-");
							/*
							 * no user is logged in, doing restart ----- didn´t
							 * work in test-pool, check ps
							 */
							client.setState(ClientState.A_USER_IS_LOGGED_IN,
									gearmanClient);
							client.removeJob(whoJob);
						} else {
							logger
									.info(client.getIp()
											+ " a user is logged in");
							client.setState(ClientState.A_USER_IS_LOGGED_IN,
									gearmanClient);
							client.removeJob(whoJob);
						}
					} else {
						logger.error(client.getIp()
								+ " Cannot check if a user is logged in.");
						client
								.setError("The check if a user is logged in has been failed.");
						/*
						 * cannot check if a user is logged in, go in errorState
						 */
						// client
						client.setState(ClientState.BOOT_ERROR, gearmanClient);
						client.removeJob(whoJob);
					}
				}
			}
		}
	}

	private void ps(Client client) {
		GearmanJob job = GearmanJobImpl.createJob("ps", client.getIp()
				.getBytes(), "ps" + client.getId());
		gearmanClient.submit(job);
		client.setState(ClientState.CHECK_PS_PROGRESS, gearmanClient);
		client.addJob(ClientJob.PSJOB, job);
		logger.info("ps " + client.getIp());
	}

	private void checkPsProgress(Client client) throws Exception, IOException {
		GearmanJob psJob = client.getJob(ClientJob.PSJOB);

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

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

				if (!result.isEmpty()) {
					JSONObject resultObj = (JSONObject) JSONValue.parse(result);
					if (!resultObj.containsKey("err")) {
						JSONArray ps = (JSONArray) resultObj.get("ps");
						HashMap<String, HashMap<String, Integer>> psMap = new HashMap<String, HashMap<String, Integer>>();

						for (Object obj : ps) {
							HashMap<String, Integer> psEntry = new HashMap<String, Integer>();
							JSONObject psLine = (JSONObject) obj;
							String cmd = psLine.get("cmd").toString();
							int pid = Integer.parseInt(psLine.get("pid")
									.toString());
							int ppid = Integer.parseInt(psLine.get("ppid")
									.toString());
							psEntry.put("pid", pid);
							psEntry.put("ppid", ppid);
							psMap.put(cmd, psEntry);
						}

						boolean whitelistFound = false;
						boolean blacklistFound = false;

						for (String blackEntry : psBlacklist) {
							if (psMap.containsKey(blackEntry)) {
								blacklistFound = true;
								break;
							}
						}

						for (String whiteEntry : psWhitelist) {
							if (psMap.containsKey(whiteEntry)) {
								HashMap<String, Integer> psEntry = psMap
										.get(whiteEntry);
								if (whiteEntry.equals("gnome-screensav")) {
									if (psEntry.get("ppid") != 1) {
										client.setScsavPID(psEntry.get("pid"));
										whitelistFound = true;
										break;
									}
								} else {
									client.setScsavPID(psEntry.get("pid"));
									whitelistFound = true;
									break;
								}
							}
						}

						if (blacklistFound) {
							if (whitelistFound) {
								logger.info(client.getIp()
										+ " processes are running");
								client.setState(
										ClientState.USERPROCESSES_ARE_RUNNING,
										gearmanClient);
							} else {
								logger.info(client.getIp() + " is working");
								client.setState(ClientState.USER_IS_WORKING,
										gearmanClient);
							}
							client.removeJob(psJob);
						} else {
							logger.info(client.getIp() + " is not working");
							// user is not working, doing restart
							client.setState(ClientState.RESTART_CLIENT,
									gearmanClient);
							client.removeJob(psJob);
						}
					} else {
						logger.error(client.getIp()
								+ " Cannot check if user is working.");
						client
								.setError("The check if a user is working has been failed.");
						/*
						 * cannot check if user is working, go in errorState
						 */
						client.setState(ClientState.BOOT_ERROR, gearmanClient);
						client.removeJob(psJob);
					}
				} else {
					logger.error(client.getIp()
							+ " Cannot check if user is working.");
					client
							.setError("The check if a user is working has been failed.");
					/*
					 * cannot check if user is working, go in errorState
					 */
					client.setState(ClientState.BOOT_ERROR, gearmanClient);
					client.removeJob(psJob);
				}
			}
		}
	}

	// screensaver check
	private void ls(Client client) {
		GearmanJob job = GearmanJobImpl.createJob("ls", client.getIp()
				.getBytes(), "ls" + client.getId());
		gearmanClient.submit(job);
		client.setState(ClientState.CHECK_LS_PROGRESS, gearmanClient);
		client.addJob(ClientJob.LSJOB, job);
		logger.info("ls " + client.getIp());
	}

	private void checkLsProgress(Client client) throws Exception, IOException {
		GearmanJob lsJob = client.getJob(ClientJob.LSJOB);

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

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

				if (!result.isEmpty()) {
					JSONObject resultObj = (JSONObject) JSONValue.parse(result);
					if (!resultObj.containsKey("err")) {
						JSONArray ls = (JSONArray) resultObj.get("ls");
						HashMap<String, Long> lsMap = new HashMap<String, Long>();

						for (Object obj : ls) {
							JSONObject lsLine = (JSONObject) obj;
							String name = lsLine.get("name").toString();
							SimpleDateFormat df = new SimpleDateFormat(
									"y-M-d H:m");
							Date date = df.parse(lsLine.get("date").toString()
									+ " " + lsLine.get("time").toString());
							long timestamp = date.getTime();
							lsMap.put(name, timestamp);
						}

						String scsavPID = Integer
								.toString(client.getScsavPID());
						long scsavTimestamp = lsMap.get(scsavPID);
						Date date = new Date();
						long currentTimestamp = date.getTime();
						long beetweenTimestamp = currentTimestamp
								- scsavTimestamp;

						if (beetweenTimestamp < scsavTime) {
							logger
									.info(client.getIp()
											+ " screensaver has been running shorter than "
											+ scsavTime / (1000 * 60)
											+ " minutes, user is working.");
							client.setState(ClientState.USER_IS_WORKING,
									gearmanClient);
							client.removeJob(lsJob);
						} else {
							logger
									.info(client.getIp()
											+ " screensaver has been running longer than "
											+ scsavTime / (1000 * 60)
											+ " minutes, user is not working.");
							client.setState(ClientState.RESTART_CLIENT,
									gearmanClient);
							client.removeJob(lsJob);
						}
					} else {
						logger.error(client.getIp()
								+ " Cannot check 'ls -al' of /proc/");
						client
								.setError("The check for screensaver has been failed.");
						// cannot check ls, go in errorState
						client.setState(ClientState.BOOT_ERROR, gearmanClient);
						client.removeJob(lsJob);
					}
				} else {
					logger.error(client.getIp()
							+ " Cannot check 'ls -al' of /proc/");
					client
							.setError("The check for screensaver has been failed.");
					// cannot check ls, go in errorState
					client.setState(ClientState.BOOT_ERROR, gearmanClient);
					client.removeJob(lsJob);
				}
			}
		}
	}

	// ------------------

	private void restart(Client client) {
		GearmanJob job = GearmanJobImpl.createJob("restart", client.getIp()
				.getBytes(), "restart" + client.getId());
		gearmanClient.submit(job);
		client.setState(ClientState.CHECK_RESTART_PROGRESS, gearmanClient);
		client.addJob(ClientJob.RESTARTJOB, job);
		logger.info("restart " + client.getIp());
	}

	private void checkRestartProgress(Client client) throws Exception,
			IOException {
		GearmanJob restartJob = client.getJob(ClientJob.RESTARTJOB);

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

			if (!jobStatus.isKnown() && restartJob.isDone()) {
				GearmanJobResult wolJobRes = restartJob.get();
				String result = ByteUtils.fromUTF8Bytes(wolJobRes.getResults());
				if (!result.isEmpty()) {
					JSONObject resultObj = (JSONObject) JSONValue.parse(result);
					if (!resultObj.containsKey("err")) {
						logger.info(client.getIp() + " Restart command sent");
						client.setState(ClientState.RESTART_COMMAND_SENT,
								gearmanClient);
						client.removeJob(restartJob);
					} else {
						logger.error(client.getIp()
								+ " Cannot send restart command");
						client
								.setError("Sending the restart command has been failed.");
						// cannot send restart command, go in errorState
						client.setState(ClientState.BOOT_ERROR, gearmanClient);
						client.removeJob(restartJob);
					}
				}
			}
		}
	}

	public Boolean isFinished() {
		return finished && !error;
	}

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

	public Vector<Client> getClients() {
		return clients;
	}

	public String getEventName() {
		return eventName;
	}
}