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