/// <summary>
/// Méthode de réception des objets de transfert de données permettant d'initialiser un TaskExecutor avec le nom de la méthode reçue dans l'objet de transfert
/// </summary>
/// <param name="input">Objet de transfert contenant la méthode</param>
/// <param name="node">Noeud emetteur</param>
public override void ProcessInput(DataInput input, Node node)
{
Logger.Write($"Traitement en cours pour : {input.Method}.");
TaskExecutor executor = WorkerFactory.GetWorker(input.Method);
if (!input.Method.Equals(IdentMethod) && !input.Method.Equals(GetCpuMethod))
{
// Creation d'une nouvelle task
Tasks.TryAdd(input.NodeTaskId, new Task(input.NodeTaskId, NodeState.Wait));
Results.TryAdd(input.NodeTaskId, new ConcurrentBag <object>());
}
object res = executor.DoWork(input);
if (res != null)
{
DataInput resp = new DataInput()
{
ClientGuid = input.ClientGuid,
NodeGuid = NodeGuid,
TaskId = input.TaskId,
NodeTaskId = input.NodeTaskId,
Method = input.Method,
Data = res,
MsgType = MessageType.Response
};
SendData(node, resp);
}
}
/// <summary>
/// Méthode d'écoute de fin d'exécution des BackgroundWorkers
/// </summary>
/// <param name="sender">BackgroundWorker emetteur</param>
/// <param name="e">résultat de fin de traitement</param>
protected void WorkerEndProcess(object sender, RunWorkerCompletedEventArgs e)
{
// Manage if e.Error != null
Tuple <int, DataInput, int> data = (Tuple <int, DataInput, int>)e.Result;
DataInput resp = data.Item2;
UpdateWorkerTaskStatus(data.Item1, data.Item2.NodeTaskId, NodeState.Finish);
UpdateResult(resp.Data, data.Item2.NodeTaskId, data.Item1);
if (TaskIsCompleted(resp.NodeTaskId))
{
Logger.Write($"Traitement terminé pour {data.Item2.Method}.");
Logger.Write(@"Résultat envoyé à l'orchestrateur.");
IReducer reducer = WorkerFactory.GetWorker(resp.Method).Reducer;
object result = reducer.Reduce(GetResultFromTaskId(resp.NodeTaskId));
resp.Data = result;
SendData(Orch, resp);
}
else
{
double progression = GetWorkersProgression(data.Item2.NodeTaskId, data.Item3);
DataInput status = new DataInput()
{
ClientGuid = data.Item2.ClientGuid,
NodeGuid = NodeGuid,
MsgType = MessageType.Call,
Method = TaskStatusMethod,
TaskId = data.Item2.TaskId,
NodeTaskId = data.Item2.NodeTaskId,
Data = new Tuple <NodeState, object>(NodeState.Work, progression)
};
SendData(Orch, status);
}
}
/// <summary>
/// Méthode de démarrage du traitement métier par l'attribution de la méthode demandé à un TaskExecutor
/// </summary>
/// <param name="input">Objet de transfert contenant la méthode et la donnée</param>
/// <returns></returns>
private object DnaQuantStarter(DataInput input)
{
Logger.Write(@"Démarrage de la fonction DNAQuantProcess.");
//Thread.Sleep(1000 * input.NodeTaskId);
TaskExecutor executor = WorkerFactory.GetWorker(input.Method);
List <Tuple <int, char[]> > list = (List <Tuple <int, char[]> >)executor.Mapper.Map(input.Data, Environment.ProcessorCount);
foreach (Tuple <int, char[]> t in list)
{
LaunchBgForWork(DnaQuantProcess, PrepareData(input, t), list.Count);
}
return(null);
}
static void Main(string[] args)
{
var parser = new ArgParser();
var parameters = parser.GetParameters(_args);
var factory = new WorkerFactory();
IProblem worker = (IProblem)factory.GetWorker(parameters.Problem);
worker.Solve(parameters.Input);
Console.WriteLine("Press any key to quit");
Console.ReadKey();
}
/// <summary>
/// Méthode chargée de transmettre un traitement à un mapper par le biais d'un TaskExecutor
/// </summary>
/// <param name="input">Objet de transfert contenant la donnée</param>
private void LazyNodeTranfert(DataInput input)
{
int newTaskId = LastTaskId;
CreateClientTask(input, newTaskId);
ConcurrentBag <object> emptyResult = new ConcurrentBag <object>();
Results.TryAdd(newTaskId, emptyResult);
TaskExecutor executor = WorkerFactory.GetWorker(input.Method);
// On récupère le résultat du map
IMapper mapper = executor.Mapper;
LaunchMapping(mapper, input, newTaskId);
}
/// <summary>
/// Méthode de gestion des traitements envoyés et reçus avec MapReduce
/// </summary>
/// <param name="input">Objet de transfert</param>
/// <returns></returns>
protected object ProcessMapReduce(DataInput input)
{
Logger.Write($"Traitement en cours pour la méthode {input.Method}");
TaskExecutor executor = WorkerFactory.GetWorker(input.Method);
switch (input.MsgType)
{
case MessageType.Call:
LazyNodeTranfert(input);
break;
case MessageType.Response:
PrepareReduce(input, executor);
break;
}
return(null);
}
/// <summary>
/// Méthode d'exécution d'un TaskExecutor avec la méthode reçue dans l'objet de transfert
/// </summary>
/// <param name="input">Objet de transfert contenant la méthode</param>
/// <param name="node">Noeud emetteur</param>
public override void ProcessInput(DataInput input, Node node)
{
TaskExecutor executor = WorkerFactory.GetWorker(input.Method);
object res = executor.DoWork(input);
if (res == null)
{
return;
}
DataInput resp = new DataInput()
{
ClientGuid = input.ClientGuid,
NodeGuid = NodeGuid,
TaskId = input.TaskId,
Method = input.Method,
Data = res,
MsgType = MessageType.Response
};
SendData(node, resp);
}
/// <summary>
/// Gère la reception des demandes contenues dans l'objet de transfert depuis un noeud
/// </summary>
/// <param name="input">objet de transfert</param>
/// <param name="node">noeud emetteur</param>
public override void ProcessInput(DataInput input, Node node)
{
TaskExecutor executor = WorkerFactory.GetWorker(input.Method);
if (MethodIsNotInfra(input.Method) && input.MsgType == MessageType.Response)
{
ViewModelLocator.VmlMonitorUcStatic.RefreshStateFromTaskResult(input);
}
object res = executor.DoWork(input);
if (res != null)
{
DataInput resp = new DataInput()
{
ClientGuid = input.ClientGuid,
NodeGuid = NodeGuid,
TaskId = input.TaskId,
Method = input.Method,
Data = res,
MsgType = MessageType.Response
};
SendData(node, resp);
}
}
