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);
}
