/// <summary> /// Costruisce una rappresentazione in formato stringa delle informazioni principali sul task specificato. /// </summary> /// <param name="tm">le informazioni relative al task</param> /// <returns>una rappresentazione in formato stringa delle informazioni principali sul task</returns> private string BuildTaskDescriptionString(TaskMetadata tm) { StringBuilder str = new StringBuilder(); if (tm != null) { str.Append("Source: " + tm.PathToSourceFile); str.Append(Environment.NewLine); str.Append("Target: " + tm.PathToTargetFile); str.Append(Environment.NewLine); str.Append("Component: class = " + tm.TaskPerformerClassName + ", version = " + tm.TaskPerformerClassVersion); str.Append(Environment.NewLine); str.Append("Ready: " + tm.ReadyTime.ToString()); str.Append(Environment.NewLine); str.Append("Starting: " + tm.StartingTime.ToString()); str.Append(Environment.NewLine); str.Append("Completion: " + tm.CompletionTime.ToString()); str.Append(Environment.NewLine); str.Append("State: " + tm.State.ToString()); str.Append(Environment.NewLine); str.Append("Errors: " + tm.Errors.Count); } return(str.ToString()); }
/// <summary> /// Restituisce una copia di questo oggetto. /// </summary> /// <returns>una copia di questo oggetto</returns> public static TaskMetadata Copy(TaskMetadata tm) { TaskMetadata copy = new TaskMetadata(null, null, null, null) { TaskPerformerClassName = string.Copy(tm.TaskPerformerClassName), TaskPerformerClassVersion = string.Copy(tm.TaskPerformerClassVersion), PathToSourceFile = string.Copy(tm.PathToSourceFile), PathToTargetFile = string.Copy(tm.PathToTargetFile), State = tm.State, ReadyTime = tm.ReadyTime, StartingTime = tm.StartingTime, CompletionTime = tm.CompletionTime, Errors = new List <TaskErrorInfo>(tm.Errors.Count) }; foreach (TaskErrorInfo error in tm.Errors) { copy.Errors.Add(TaskErrorInfo.Copy(error)); } return(copy); }
/// <summary> /// Restituisce il tempo impiegato per elaborare il task descritto dai metadati specificati. /// </summary> /// <param name="tm">i metadati relativi al task</param> /// <returns>il tempo impiegato per elaborare il task</returns> /// <remarks> /// Se l'oggetto contenente i metadati è null oppure se in essi non sono stati impostati l'istante /// di completamento dell'elaborazione e/o l'istante di inizio dell'elaborazione, viene restituito /// il valore TimeSpan.Zero. /// </remarks> public TimeSpan GetProcessingTime(TaskMetadata tm) { if (tm != null && tm.CompletionTime.HasValue && tm.StartingTime.HasValue) { DateTime t1 = tm.StartingTime.Value; DateTime t2 = tm.CompletionTime.Value; if (t2 > t1) { return t2.Subtract(t1); } } return TimeSpan.Zero; }
/// <summary> /// Prova ad ottenere l'oggetto contenente i metadati del task associati all'identificativo specificato. /// Restituisce true se tale identificativo specificato esiste ed in tal caso assegna in output l'oggetto /// con i metadati richiesti. Altrimenti, se l'identificativo specificato non esiste, restituisce false e /// imposta l'output a null. /// </summary> /// <param name="id">l'identificativo associato al task richiesto</param> /// <param name="tm">l'oggetto contenente i metadati richiesti</param> /// <returns>true, se esiste l'oggetto con i metadati cercati, altrimenti false</returns> /// <remarks> /// I metadati del task specificato vengono copiati nell'oggetto restituito. /// </remarks> public bool TryGetUserTask(string id, out TaskMetadata tm) { lock (m_PendingTasksLocker) { TaskMetadata temp; if (m_PendingTasks.TryGetTask(id, out temp) && temp != null) { tm = TaskMetadata.Copy(temp); return(true); } } tm = null; return(false); }
/// <summary> /// Schedula il task specificato per l'esecuzione e imposta in output l'identificativo assegnato, /// restituendo true se l'oggetto contenente i metadati specificati è diverso da null. Altrimenti, /// cioè se l'oggetto specificato è null, l'identificativo viene impostato a null e questo metodo /// restituisce false, non potendo schedulare un task null. /// </summary> /// <param name="tm">i metadati del task da schedulare per l'elaborazione</param> /// <param name="id">l'identificativo assegnato al task</param> /// <returns>true se il task specificato è stato schedulato, altrimenti false</returns> public bool InsertUserTask(TaskMetadata tm, out string id) { if (tm != null) { string newId; lock (m_PendingTasksLocker) { m_PendingTasks.InsertTask(tm, out newId); } id = newId; Task.Factory.StartNew(() => ExecuteTask(newId), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default); return(true); } id = null; return(false); }
/// <summary> /// Schedula il task specificato per l'esecuzione e imposta in output l'identificativo assegnato, /// restituendo true se l'oggetto contenente i metadati specificati è diverso da null. Altrimenti, /// cioè se l'oggetto specificato è null, l'identificativo viene impostato a null e questo metodo /// restituisce false, non potendo schedulare un task null. /// </summary> /// <param name="tm">i metadati del task da schedulare per l'elaborazione</param> /// <param name="id">l'identificativo assegnato al task</param> /// <returns>true se il task specificato è stato schedulato, altrimenti false</returns> public bool InsertUserTask(TaskMetadata tm, out string id) { if (tm != null) { string newId; lock (m_PendingTasksLocker) { m_PendingTasks.InsertTask(tm, out newId); } id = newId; Task.Factory.StartNew(() => ExecuteTask(newId), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default); return true; } id = null; return false; }
/// <summary> /// Prova a mettere il task specificato in coda per l'elaborazione associandolo all'identificativo specificato /// e restituisce true se l'inserimento viene completate con successo. In caso contrario, restituisce false ed /// imposta l'errore esplicativo. /// </summary> /// <param name="tm">i metadati relativi al task di cui è stata richiesta l'elaborazione</param> /// <param name="taskRequestId">l'identificativo univoco della richiesta di elaborazione</param> /// <param name="error">l'eventuale errore impostato qualora si dovessero verificare dei problemi</param> /// <returns>true se non si verificano errori durante l'accodamento del task, altrimenti false</returns> /// <remarks> /// Se il task viene accodato con successo, l'oggetto dedicato all'eventuale errore è impostato al valore null, /// altrimenti al suo interno vengono impostati il codice d'errore e un identificativo univoco sul server, /// oltre ad effettuare il logging dell'errore. /// </remarks> public bool TryQueueTask(TaskMetadata tm, string taskRequestId, out ServiceFault error) { bool result; string taskProcId; if (m_TaskScheduler.InsertUserTask(tm, out taskProcId)) { if (TryInsertIdPair(taskRequestId, taskProcId)) { WriteToLog("TryQueueTask: task scheduled with request id = {0}, processing id = {1}.", taskRequestId, taskProcId); error = null; result = true; } else { string errorDetails = "TryQueueTask: unable to insert task identifiers within table: " + string.Format("request id = {0}, processing id = {1}.", taskRequestId, taskProcId); HandleError(errorDetails, ServiceFaultCode.InternalError, out error); result = false; } } else { HandleError("TryQueueTask: unable to queue a new task.", ServiceFaultCode.InternalError, out error); result = false; } return result; }
/// <summary> /// Verifica che i metadati del task associato all'identificativo specificato siano esistenti ed eventualmente /// li copia in output e restituisce true. In caso contrario restituisce false ed imposta i metadati in output /// al valore null e un errore esplicativo. /// </summary> /// <param name="taskRequestId">l'identificativo univoco della richiesta di elaborazione</param> /// <param name="tm">la copia dei metadati relativi al task di cui è stata richiesta l'elaborazione</param> /// <param name="error">l'eventuale errore impostato qualora si dovessero verificare dei problemi</param> /// <returns>true se non si verificano errori durante il recupero dei metadati, altrimenti false</returns> /// <remarks> /// Se i metadati richiesti vengono trovati, l'oggetto dedicato all'eventuale errore è impostato al valore null, /// altrimenti al suo interno vengono impostati il codice d'errore e un identificativo univoco sul server, oltre /// ad effettuare il logging dell'errore. /// </remarks> public bool TryGetUserTask(string taskRequestId, out TaskMetadata tm, out ServiceFault error) { string taskProcId; if (!TryGetProcessingId(taskRequestId, out taskProcId)) { string errorDetails = string.Format("TryGetUserTask: unable to find processing id for request id = {0}.", taskRequestId); HandleError(errorDetails, ServiceFaultCode.TaskResultsNotFound, out error); tm = null; return false; } if (!m_TaskScheduler.TryGetUserTask(taskProcId, out tm)) { string errorDetails = "TryGetUserTask: unable to find task for " + string.Format("request id = {0}, processing id = {1}.", taskRequestId, taskProcId); HandleError(errorDetails, ServiceFaultCode.TaskResultsNotFound, out error); tm = null; return false; } error = null; return true; }
/// <summary> /// Costruisce una rappresentazione in formato stringa delle informazioni principali sul task specificato. /// </summary> /// <param name="tm">le informazioni relative al task</param> /// <returns>una rappresentazione in formato stringa delle informazioni principali sul task</returns> private string BuildTaskDescriptionString(TaskMetadata tm) { StringBuilder str = new StringBuilder(); if (tm != null) { str.Append("Source: " + tm.PathToSourceFile); str.Append(Environment.NewLine); str.Append("Target: " + tm.PathToTargetFile); str.Append(Environment.NewLine); str.Append("Component: class = " + tm.TaskPerformerClassName + ", version = " + tm.TaskPerformerClassVersion); str.Append(Environment.NewLine); str.Append("Ready: " + tm.ReadyTime.ToString()); str.Append(Environment.NewLine); str.Append("Starting: " + tm.StartingTime.ToString()); str.Append(Environment.NewLine); str.Append("Completion: " + tm.CompletionTime.ToString()); str.Append(Environment.NewLine); str.Append("State: " + tm.State.ToString()); str.Append(Environment.NewLine); str.Append("Errors: " + tm.Errors.Count); } return str.ToString(); }
/// <summary> /// Prova ad ottenere l'oggetto contenente i metadati del task associati all'identificativo specificato. /// Restituisce true se tale identificativo specificato esiste ed in tal caso assegna in output l'oggetto /// con i metadati richiesti. Altrimenti, se l'identificativo specificato non esiste, restituisce false e /// imposta l'output a null. /// </summary> /// <param name="id">l'identificativo associato al task richiesto</param> /// <param name="tm">l'oggetto contenente i metadati richiesti</param> /// <returns>true, se esiste l'oggetto con i metadati cercati, altrimenti false</returns> /// <remarks> /// I metadati del task specificato vengono copiati nell'oggetto restituito. /// </remarks> public bool TryGetUserTask(string id, out TaskMetadata tm) { lock (m_PendingTasksLocker) { TaskMetadata temp; if (m_PendingTasks.TryGetTask(id, out temp) && temp != null) { tm = TaskMetadata.Copy(temp); return true; } } tm = null; return false; }
/// <summary> /// Restituisce una copia di questo oggetto. /// </summary> /// <returns>una copia di questo oggetto</returns> public static TaskMetadata Copy(TaskMetadata tm) { TaskMetadata copy = new TaskMetadata(null, null, null, null) { TaskPerformerClassName = string.Copy(tm.TaskPerformerClassName), TaskPerformerClassVersion = string.Copy(tm.TaskPerformerClassVersion), PathToSourceFile = string.Copy(tm.PathToSourceFile), PathToTargetFile = string.Copy(tm.PathToTargetFile), State = tm.State, ReadyTime = tm.ReadyTime, StartingTime = tm.StartingTime, CompletionTime = tm.CompletionTime, Errors = new List<TaskErrorInfo>(tm.Errors.Count) }; foreach (TaskErrorInfo error in tm.Errors) { copy.Errors.Add(TaskErrorInfo.Copy(error)); } return copy; }
/// <summary> /// Permette il trasferimento dei dati relativi al task da elaborare ed imposta una stringa contenente /// l'identificativo univoco associato alla richiesta di elaborazione, necessario per ottenere in seguito /// i risultati dell'elaborazione. /// </summary> /// <param name="data">i dati relativi al task di cui si richiede l'elaborazione</param> /// <param name="id">l'identificativo associato alla richiesta di elaborazione</param> public void SubmitData(TaskData data, out string id) { m_Container.WriteToLog("SubmitData: receiving data, name = {0}.", data.Name); ServiceFault fault = null; // Genera un ID univoco da associare alla richiesta. string taskRequestId; if (!m_Container.TryGetRandomId(out taskRequestId, out fault)) { throw new FaultException<ServiceFault>(fault); } m_Container.WriteToLog("SubmitData: task request id = {0}.", taskRequestId); string tdFilePath = m_Container.GetTaskDataFilePath(); // task data file path // Salva i dati ricevuti sul task da elaborare. if (!m_Container.TrySaveDataToFile(data.Contents, tdFilePath, out fault)) { throw new FaultException<ServiceFault>(fault); } m_Container.WriteToLog("SubmitData: task request id = {0}, file saved to {1}.", taskRequestId, tdFilePath); // Verifica che la risorsa sia disponibile. string className, classVersion; if (!m_Container.TrySearchResource(tdFilePath, out className, out classVersion, out fault)) { throw new FaultException<ServiceFault>(fault); } string trFilePath = m_Container.GetTaskResultsFilePath(); // task results file path // Prepara il task da elaborare. TaskMetadata tm = new TaskMetadata(className, classVersion, tdFilePath, trFilePath); tm.UpdateOnReady(DateTime.Now); // Inserisce il task in coda allo scheduler. if (!m_Container.TryQueueTask(tm, taskRequestId, out fault)) { throw new FaultException<ServiceFault>(fault); } m_Container.WriteToLog("SubmitData: task scheduled with request id = {0}, target file = {1}.", taskRequestId, trFilePath); id = taskRequestId; }