public Server(IPAddress serverIp) { Workers = new List <WorkerInfo>(); Clients = new List <Uri>(); TaskService = new ServerTaskService(this); ClientRegistrationService = new ClientRegistrationService(this); WorkerRegistrationService = new WorkerRegistrationService(this); ConnectionControl = new ServerConnectionControl(this); TaskLibraryManager = new TaskLibraryManager(); TaskLibraryManager.Load(); bool hostCreated = false; while (!hostCreated) { try { ServerUri = RemoteConnection.CreateUri(serverIp, Port++); CheckConnectionHost = RemoteConnection.CreateHost(UriTemplates.CreateCheckConnectionUri(ServerUri), typeof(ICheckConnection), typeof(CheckConnection)); hostCreated = true; } catch { } } TaskServiceHost = RemoteConnection.CreateHost(UriTemplates.CreateTasksUri(ServerUri), typeof(IServerTaskService), TaskService); ClientRegistrationHost = RemoteConnection.CreateHost(UriTemplates.CreateClientRegistrationUri(ServerUri), typeof(IClientRegistrationService), ClientRegistrationService); WorkerRegistrationHost = RemoteConnection.CreateHost(UriTemplates.CreateWorkerRegistrationUri(ServerUri), typeof(IWorkerRegistrationService), WorkerRegistrationService); TaskLibraryHost = RemoteConnection.CreateHost(UriTemplates.CreateLibrariesUri(ServerUri), typeof(IDistributedTaskLibraryService), typeof(DistributedTaskLibraryService)); CheckConnectionHost = RemoteConnection.CreateHost(UriTemplates.CreateCheckConnectionUri(ServerUri), typeof(ICheckConnection), typeof(CheckConnection)); CheckConnectionHost.Open(); WorkerRegistrationHost.Open(); TaskLibraryHost.Open(); }
private async Task <DistributedResource> ExecuteAsync(Uri clientUri, Uri workerUri, DistributedResource resource, int taskId) { return(await Task.Run(() => { DistributedResource result = null; try { var service = RemoteConnection.CreateProxy <IWorkerTaskService>(UriTemplates.CreateTasksUri(workerUri)); result = service.ExecuteTask(taskId, resource); } catch { result = null; } result = Execute(clientUri, taskId, resource); return result; })); }
public ClientTask CreateTask(String typename, List <string> filenames) { if (Disposed) { throw new NoServerConnectionException(); } else { var libraries = new DistributedTaskLibrary(LocalUri, filenames, typename); var service = RemoteConnection.CreateProxy <IServerTaskService>(UriTemplates.CreateTasksUri(ServerUri)); int taskid = 0; try { taskid = service.CreateTask(libraries); } catch { throw new ServerUnavailableException(); } return(new ClientTask(taskid, ServerUri, LocalUri)); } }
public void Connect(Uri workerUri) { var workerInfo = new WorkerInfo(workerUri); var service = RemoteConnection.CreateProxy <IWorkerTaskService>(UriTemplates.CreateTasksUri(workerUri)); foreach (Uri client in Server.Clients) { workerInfo.Connections.Add(new ConnectionInfo(client, service.CheckConnection(client))); } for (int i = 0; i < Server.TaskLibraryManager.Tasks.Count; i++) { workerInfo.Tasks.Add(i, service.CreateTask(Server.TaskLibraryManager.Tasks[i].CreateDistributedTaskLibrary(Server.ServerUri))); } lock (Server.Workers) { if (Server.Workers.Count == 0) { Server.OpenClientConnection(); } Server.Workers.Add(workerInfo); } Server.ConnectionControl.AddWorkerConnection(workerUri); Logging.WriteLog("Worker on " + workerUri + " connected"); }
public WorkerServerConnection(IPAddress localIp, IPAddress serverIp, int port) : base(localIp, serverIp, port) { Logging.WriteLog("Connecting to server on " + ServerUri); PerformanceService = new WorkerPerformanceService(); PerformanceServiceHost = RemoteConnection.CreateHost(UriTemplates.CreatePerformanceUri(LocalUri), typeof(IWorkerPerformanceService), PerformanceService); PerformanceServiceHost.Open(); TasksService = new WorkerTaskService(LocalUri); TasksServiceHost = RemoteConnection.CreateHost(UriTemplates.CreateTasksUri(LocalUri), typeof(IWorkerTaskService), TasksService); TasksServiceHost.Open(); var registation = RemoteConnection.CreateProxy <IWorkerRegistrationService>(UriTemplates.CreateWorkerRegistrationUri(ServerUri)); try { registation.Connect(LocalUri); } catch (Exception e) { TasksServiceHost.Close(); PerformanceServiceHost.Close(); Dispose(); throw new NoServerConnectionException(); } ConnectionControl = new ConnectionControl(this, ServerUri); }
public ClientTask(int id, Uri server, Uri client) { Id = id; Client = client; Server = UriTemplates.CreateTasksUri(server); }
public void Connect(Uri localuri) { lock (Server.Clients) { Server.Clients.Add(localuri); } lock (Server.Workers) { foreach (WorkerInfo workerinfo in Server.Workers) { if (!workerinfo.Connections.Select <ConnectionInfo, Uri>(connection => connection.ClientUri).Contains(localuri)) { var service = RemoteConnection.CreateProxy <IWorkerTaskService>(UriTemplates.CreateTasksUri(workerinfo.WorkerUri)); workerinfo.Connections.Add(new ConnectionInfo(localuri, service.CheckConnection(localuri))); } } } Server.ConnectionControl.AddClientConnection(localuri); Logging.WriteLog("Client on " + localuri + " connected"); }
public int CreateTask(DistributedTaskLibrary libraries) { Logging.WriteLog("Request for creating new library was received"); int taskId = Server.TaskLibraryManager.CreateTask(libraries); DistributedTaskLibrary distributedLibrary = Server.TaskLibraryManager.Tasks[taskId].CreateDistributedTaskLibrary(Server.ServerUri); List <int> list = new List <int>(); lock (Server.Workers) { foreach (WorkerInfo workerInfo in Server.Workers) { if (!workerInfo.Tasks.Keys.ToList().Contains(taskId)) { var service = RemoteConnection.CreateProxy <IWorkerTaskService>(UriTemplates.CreateTasksUri(workerInfo.WorkerUri)); workerInfo.Tasks.Add(taskId, service.CreateTask(distributedLibrary)); } } } return(taskId); }
public DistributedResource Execute(Uri clientUri, int taskId, DistributedResource resource) { Logging.WriteLog("Request for executing task on single resource was received"); DistributedResource result = null; int trycount = TryCount; do { WorkerInfo workerInfo = null; lock (Server.Workers) { List <int> performance = Server.Workers.Select <WorkerInfo, int>(worker => worker.GetPerformance(clientUri)).ToList(); if (performance.Count != 0) { workerInfo = Server.Workers[performance.FindIndex(perform => perform == performance.Max())]; var service = RemoteConnection.CreateProxy <IWorkerTaskService>(UriTemplates.CreateTasksUri(workerInfo.WorkerUri)); try { result = service.ExecuteTask(workerInfo.Tasks[taskId], resource); trycount--; } catch { } } } }while (result == null && Server.Workers.Count != 0 && trycount > 0); return(result); }