internal DistributedResourceManager(Uri localUri) { Handler = new DistributedResourceHandler(); LocalUri = UriTemplates.CreateResourcesUri(localUri); ServiceHost = RemoteConnection.CreateHost(LocalUri, typeof(IDistributedResourceService), Handler); ServiceHost.Open(); }
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(); }
public ClientServerConnection(IPAddress localIp, IPAddress serverIp, int serverPort) : base(localIp, serverIp, serverPort) { Logging.WriteLog("Connecting to server on " + ServerUri); DistributedTaskLibraryHost = RemoteConnection.CreateHost(UriTemplates.CreateLibrariesUri(LocalUri), typeof(IDistributedTaskLibraryService), typeof(DistributedTaskLibraryService)); DistributedTaskLibraryHost.Open(); try { var registration = RemoteConnection.CreateProxy <IClientRegistrationService>(UriTemplates.CreateClientRegistrationUri(ServerUri)); registration.Connect(LocalUri); } catch (Exception e) { DistributedTaskLibraryHost.Close(); Dispose(); throw new NoServerConnectionException(); } ConnectionControl = new ConnectionControl(this, ServerUri); }
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 Connection(IPAddress localIp, IPAddress serverIp, int serverPort) { bool hostCreated = false; while (!hostCreated) { try { LocalUri = RemoteConnection.CreateUri(localIp, Port++); CheckConnectionHost = RemoteConnection.CreateHost(UriTemplates.CreateCheckConnectionUri(LocalUri), typeof(ICheckConnection), typeof(CheckConnection)); CheckConnectionHost.Open(); hostCreated = true; } catch { } } ServerUri = RemoteConnection.CreateUri(serverIp, serverPort); }
private void Control() { var service = RemoteConnection.CreateProxy <ICheckConnection>(UriTemplates.CreateCheckConnectionUri(ServerUri)); while (Connected) { try { service.Check(); } catch { Connected = false; } Thread.Sleep(TimeOut); } if (!Disconnected) { Logging.WriteLog("Connection lost"); Connection.Dispose(); } }
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 ConnectionMeasuring(Uri connection) { CheckedConnection = UriTemplates.CreateCheckConnectionUri(connection); }
public void Close() { var registration = RemoteConnection.CreateProxy <IClientRegistrationService>(UriTemplates.CreateClientRegistrationUri(ServerUri)); registration.Disconnect(LocalUri); DistributedTaskLibraryHost.Close(); ConnectionControl.Disconnect(); Dispose(); }
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 ClientTask(int id, Uri server, Uri client) { Id = id; Client = client; Server = UriTemplates.CreateTasksUri(server); }
public void Close() { var registration = RemoteConnection.CreateProxy <IWorkerRegistrationService>(UriTemplates.CreateWorkerRegistrationUri(ServerUri)); registration.Disconnect(LocalUri); ConnectionControl.Disconnect(); TasksServiceHost.Close(); PerformanceServiceHost.Close(); Dispose(); }
public int GetPerformance(Uri ClientUri) { var service = RemoteConnection.CreateProxy <IWorkerPerformanceService>(UriTemplates.CreatePerformanceUri(WorkerUri)); int machinePerformance = service.GetPerformance(); return(machinePerformance / Connections.Where(connection => connection.ClientUri == ClientUri).First().Connection); }
public void Control() { List <Uri> removedClientConnections = new List <Uri>(); List <Uri> removedWorkerConnections = new List <Uri>(); while (WorkerConnections.Count != 0 && ClientConnections.Count != 0) { removedWorkerConnections.Clear(); removedClientConnections.Clear(); lock (WorkerConnections) { foreach (Uri connection in WorkerConnections) { try { var service = RemoteConnection.CreateProxy <ICheckConnection>(UriTemplates.CreateCheckConnectionUri(connection)); service.Check(); } catch { removedWorkerConnections.Add(connection); } } lock (Server.Workers) { foreach (Uri connection in removedWorkerConnections) { WorkerConnections.Remove(connection); Server.Workers.Remove(Server.Workers.Find(info => info.WorkerUri == connection)); } } } lock (ClientConnections) { foreach (Uri connection in ClientConnections) { try { var service = RemoteConnection.CreateProxy <ICheckConnection>(UriTemplates.CreateCheckConnectionUri(connection)); service.Check(); } catch { removedClientConnections.Add(connection); } } lock (Server.Clients) { foreach (Uri connection in removedClientConnections) { ClientConnections.Remove(connection); Server.Clients.Remove(Server.Clients.Find(uri => uri == connection)); } if (Server.Clients.Count == 0) { Server.CloseClientConnection(); } } } Thread.Sleep(TimeOut); } }
public int CreateTask(DistributedTaskLibrary distributedLibrary) { int taskId = -1; var Service = RemoteConnection.CreateProxy <IDistributedTaskLibraryService>(UriTemplates.CreateLibrariesUri(distributedLibrary.Holder)); lock (Locker) { File.WriteAllBytes("temp", Service.Get(distributedLibrary.Files[0])); var assembly = Assembly.LoadFrom("temp"); Type processType = assembly.GetTypes().Where(type => type.Name == distributedLibrary.ProcessTypeName).First(); for (int i = 0; i < Tasks.Count; i++) { if (Tasks[i].Process == processType) { taskId = i; break; } } } if (taskId == -1) { int i = 1; string folder; if (!Directory.Exists(Folder)) { Directory.CreateDirectory(Folder); } while (Directory.Exists(folder = (Folder + "/" + "task" + i))) { i++; } Directory.CreateDirectory(folder); List <string> files = new List <string>(); foreach (string filename in distributedLibrary.Files) { string name = folder + "/" + new DirectoryInfo(filename).Name; File.WriteAllBytes(name, Service.Get(filename)); files.Add(name); } Tasks.Add(new TaskLibrary(files, distributedLibrary.ProcessTypeName)); taskId = Tasks.Count - 1; Save(); } 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); }