public DistributedResource ExecuteTask(int taskId, DistributedResource resource)
{
if (Disposed)
{
throw new ObjectDisposedException(this.ToString());
}
else
{
try
{
Logging.WriteLog("Request for executing task was received");
TaskLibrary task = TaskManager.Tasks[taskId];
var stream = new MemoryStream(resource.Get());
var serializer = new DataContractSerializer(task.InputData);
object input = null;
input = serializer.ReadObject(stream);
var process = Activator.CreateInstance(task.Process);
MethodInfo method = task.Process.GetMethod("Execute");
object executeResult = method.Invoke(process, new object[] { input });
DistributedResource result = null;
lock (ResourceManager)
{
result = ResourceManager.CreateDistributedResource(executeResult);
}
return(result);
}
catch
{
return(null);
}
}
}
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);
}
public V Execute(T data)
{
if (!Disposed)
{
DividedResource dividedResource = DividedResourceManager.CreateDividedResource(data);
try
{
List <DistributedComputingResult> distributedResults = null;
try
{
distributedResults = Task.ExecuteTask(dividedResource);
}
catch
{
throw new NoServerConnectionException();
}
if (distributedResults == null)
{
throw new TaskException();
}
List <V> results = new List <V>();
var serializer = new DataContractSerializer(typeof(V));
foreach (DistributedComputingResult distributedResult in distributedResults)
{
bool read = false;
DistributedResource resource = distributedResult.Result;
while (!read)
{
try
{
byte[] array = resource.Get();
results.Add((V)serializer.ReadObject(new MemoryStream(array)));
distributedResult.Result.Dispose();
read = true;
}
catch (Exception e)
{
resource = Task.Execute(distributedResult.Data);
if (resource == null)
{
throw new NoServerConnectionException();
}
}
}
}
return(new Compiler().CompileResult(results));
}
finally
{
dividedResource.Dispose();
}
}
else
{
throw new ObjectDisposedException(this.ToString());
}
}
public DistributedResource Execute(DistributedResource resource)
{
try
{
var service = RemoteConnection.CreateProxy <IServerTaskService>(Server);
return(service.Execute(Client, Id, resource));
}
catch
{
throw new NoServerConnectionException();
}
}
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;
}));
}
