/// <summary> /// This function is called before submit so that /// the client can get a reference to the master /// worker/tracker to which to submit jobs. /// </summary> /// <param name="entryURL"></param> /// <param name="entryServiceName"></param> public void SetupWorkerChannel(string entryURL, string entryServiceName) { workerService = (WorkerService)Factory.Instance.GetService( typeof(WorkerService), entryURL); // catch this on console if (workerService == null) { throw new RemotingException("error: cannot locate worker!"); } workerService.AddWorker(workerService); }
private System.Timers.Timer createCheckFaultyWorkerTimer(WorkerService worker) { System.Timers.Timer newTimer = new System.Timers.Timer(); int workerId = worker.Id; newTimer.Elapsed += (sender, args) => { OnFaultyWorkerTimeExpiredEvent(newTimer, new FaultyWorkerEventArgs(workerId)); }; newTimer.Interval = TIME_TO_WAIT_FOR_WORKER_LIFEMSG; newTimer.Enabled = true; return newTimer; }
public OverseenWorker(WorkerService service, System.Timers.Timer lifeproofTimer) { this.WorkerId = service.Id; this.Service = service; this.LifeproofTimer = lifeproofTimer; this.Assignment = null; }
/// <summary> /// Method used by the worker to let this tracker know /// that it's alive, resetting the timer in the process. /// </summary> /// <param name="workerURL"></param> /// <returns>This service master tracker.</returns> public WorkerService ReceiveLifeproof(int workerId, WorkerService proofWorker) { //logger.Log("Received lifeproof from: W" + workerId); // if worker recovered, or re-linked from a crashed MasterTracker, reuse it. AddWorker(proofWorker); foreach (OverseenWorker worker in manager.ListWorkers) { if (worker.WorkerId == workerId) { // Resets the timer for this worker if (worker.LifeproofTimer != null) { worker.LifeproofTimer.Stop(); try { worker.LifeproofTimer.Start(); } catch (Exception) { continue; } } } } return GetMasterTracker(); }
public void SetMasterTrackerFather(WorkerService service) { worker.SetMasterTrackerFather(service); }
private void SendLifeproof(object tracker) { WorkerService masterTracker = (WorkerService)tracker; try { SetMasterTrackerFather(masterTracker.ReceiveLifeproof(id, service)); //logger.Log("Sent lifeproof to W" + masterTrackerId); if (lifeProofTimer != null) { lifeProofTimer.Stop(); lifeProofTimer.Start(); } else { lifeProofTimer = createSendLifeproofTimer(masterTracker); } } catch (Exception) { logger.Log("Master Tracker not responding!"); if (masterTrackerId != -1) { service.WorkerFailureHandle(new WorkerService.FaultyWorkerEventArgs(masterTrackerId)); } try { lifeProofTimer.Dispose(); } catch (Exception) { // some error goes here when timer was already disposed??? } if (masterTrackerFather != null) { masterTrackerService = masterTrackerFather; masterTrackerFather = null; try { SetMasterTrackerFather(masterTrackerService.ReceiveLifeproof(id, service)); } finally { lifeProofTimer = createSendLifeproofTimer(masterTrackerService); } } } }
/// <summary> /// This method is called by the workers when they are created /// so that the tracker can keep track them. /// </summary> /// <param name="newWorker"></param> public void AddWorker(WorkerService newWorker, bool isPropagate = false) { worker.PropagateWorker(newWorker); // check if it already contains this worker if (manager.Exists(newWorker.Id)) { return; } if (!isPropagate) { newWorker.SetMasterTracker(this); newWorker.SetMasterTrackerFather(GetMasterTracker()); System.Timers.Timer newTimer = createCheckFaultyWorkerTimer(newWorker); // Finally, add the new worker to the list manager.AddOverseenWorker(new OverseenWorker(newWorker, newTimer)); } else { manager.AddOverseenWorker(new OverseenWorker(newWorker, null)); } logger.Log("Received new worker notification from W" + newWorker.Id); // Let the other workers know about this new worker foreach (OverseenWorker otherWorker in manager.ListWorkers) { if (otherWorker.WorkerId != id) { WorkerService otherWorkerService = otherWorker.Service; otherWorkerService.ReceiveNewWorkerUpdate(otherWorker); } } // Update the new worker with the list of workers in the network newWorker.ReceiveCurrentWorkerList(manager.ListWorkers); }
private void notifyMasterTracker(string entryURL) { WorkerService tracker = (WorkerService)Factory.Instance.GetService( typeof(WorkerService), entryURL); tracker.AddWorker(this.service); masterTrackerFather = tracker.GetMasterTracker(); lifeProofTimer = createSendLifeproofTimer(masterTrackerService); }
private System.Timers.Timer createSendLifeproofTimer(WorkerService tracker) { System.Timers.Timer newTimer = new System.Timers.Timer(); newTimer.Elapsed += (sender, args) => { SendLifeproof(tracker); }; newTimer.Interval = TIME_BETWEEN_LIFEPROOFS; newTimer.Enabled = true; return newTimer; }
private void setupService() { string serviceName = Constants.WORKER_SERVICE_NAME; service = new WorkerService(this); if (Factory.Instance.CreateService(port, serviceName, service, typeof(WorkerService), serviceURL)) { logger.Log("I'm a new worker at " + serviceURL); workerThread = new Thread(new ThreadStart(WorkerJob)); workerThread.Start(); } else { logger.Log("Can'start worker at " + serviceURL); } }
// --------------------------------------- IWorker Implementation // public bool IsMasterTracker() { try { if (masterTrackerService != null) { masterTrackerService.ProbeObject(); } } catch (Exception) { masterTrackerService = masterTrackerFather; masterTrackerFather = null; return IsMasterTracker(); } return masterTrackerService == null; }
public void PropagateWorker(WorkerService worker) { if (masterTrackerService != null) { Factory.Instance.SafelyUseService(masterTrackerService, (service) => { service.AddWorker(worker, true); }); } }
public void SetMasterTrackerFather(WorkerService service) { this.masterTrackerFather = service; }
public void SetMasterTracker(WorkerService service) { this.masterTrackerService = service; try { masterTrackerId = service.Id; } catch (Exception) { masterTrackerId = -1; } }