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 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 ConnectionMeasuring(Uri connection)
{
CheckedConnection = UriTemplates.CreateCheckConnectionUri(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);
}
}
