655 lines
19 KiB
C#
655 lines
19 KiB
C#
using Sarand.Net.Standard.Base.App;
|
|
using Sarand.Net.Standard.Base.Core;
|
|
using Sarand.Net.Standard.Base.Tasks;
|
|
using Sarand.Net.Standard.Base.Utils;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace Sarand.Net.Standard.Base.Procs
|
|
{
|
|
public abstract class SaProcess_Base : SacsDisposable
|
|
{
|
|
// --- Definitions ---
|
|
|
|
public enum InterruptionReason
|
|
{
|
|
None = 0,
|
|
ManualRequest,
|
|
CancellationRequested,
|
|
OperationCanceledException,
|
|
}
|
|
|
|
public sealed class InterruptionData
|
|
{
|
|
internal InterruptionData(InterruptionReason reason)
|
|
{
|
|
Reason = reason;
|
|
RequestedAt = DateTime.Now;
|
|
}
|
|
|
|
public InterruptionReason Reason { get; }
|
|
public DateTime RequestedAt { get; }
|
|
}
|
|
|
|
[Serializable]
|
|
public class InProgressException : Exception
|
|
{
|
|
public InProgressException() { }
|
|
public InProgressException(string message) : base(message) { }
|
|
public InProgressException(string message, Exception inner) : base(message, inner) { }
|
|
}
|
|
|
|
// --- Option Selection ---
|
|
|
|
// Process options and groups - for configuration of process to run.
|
|
// See Sarand.Win.Forms.Utility.SaForm_SelectOptions.
|
|
public class OptionData
|
|
{
|
|
public OptionData(TypeCodeDesc option)
|
|
{
|
|
Option = option;
|
|
}
|
|
public TypeCodeDesc Option { get; set; }
|
|
public String Notes { get; set; } = "";
|
|
public bool Selected { get; set; } = false;
|
|
}
|
|
public class GroupData
|
|
{
|
|
public GroupData(TypeCodeDesc optionGroup)
|
|
{
|
|
OptionGroup = optionGroup;
|
|
}
|
|
public TypeCodeDesc OptionGroup { get; set; }
|
|
public List<OptionData> Options { get; } = new List<OptionData>();
|
|
public bool ExclusiveOptions { get; set; } = false;
|
|
public bool Selected { get; set; } = false;
|
|
}
|
|
|
|
// --- Configuration ---
|
|
public enum ProcessType
|
|
{
|
|
Unknown = 0,
|
|
ImportData,
|
|
ExportData,
|
|
ImportExportData,
|
|
Other,
|
|
}
|
|
public class Config
|
|
{
|
|
protected Config()
|
|
{
|
|
}
|
|
/// <summary>Identifies the type of process.</summary>
|
|
public ProcessType ProcessType { get; set; } = ProcessType.Unknown;
|
|
/// <summary>Is the process to be run in 'Test' mode.</summary>
|
|
public bool TestProcess { get; set; } = SacsSystem.DebugMode;
|
|
/// <summary>Process imports data.</summary>
|
|
public bool Import { get { return ProcessType == ProcessType.ImportData || ProcessType == ProcessType.ImportExportData; } }
|
|
/// <summary>Process exports data.</summary>
|
|
public bool Export { get { return ProcessType == ProcessType.ExportData || ProcessType == ProcessType.ImportExportData; } }
|
|
/// <summary>Can the process be interrupted?</summary>
|
|
public bool AllowInterruption { get; set; } = true;
|
|
/// <summary>Confirm when interruption is requested.</summary>
|
|
public bool ConfirmInterruption { get; set; } = true;
|
|
/// <summary>Automated processes must not display desktop coponents - popup messages etc.</summary>
|
|
public bool Automated { get; set; } = false;
|
|
}
|
|
|
|
// --- Process Control ---
|
|
|
|
public class ProcessMessage
|
|
{
|
|
public ProcessMessage(String message, SaMessageLevel level = SaMessageLevel.Info)
|
|
{
|
|
this.Message = message;
|
|
this.Level = level;
|
|
}
|
|
public String Message { get; }
|
|
public SaMessageLevel Level { get; }
|
|
public int Instances { get; internal set; }
|
|
}
|
|
|
|
private class ProcessControlData
|
|
{
|
|
// --- Interruption ---
|
|
|
|
private class InterruptState
|
|
{
|
|
public readonly Object lockable = new object();
|
|
private InterruptionData interruption = null;
|
|
public bool IsInterrupted { get { lock (lockable) { return interruption != null; } } }
|
|
public InterruptionData Interruption { get { lock (lockable) { return interruption; } } }
|
|
public void Clear()
|
|
{
|
|
lock (lockable)
|
|
interruption = null;
|
|
}
|
|
public void Set(InterruptionReason reason)
|
|
{
|
|
lock (lockable)
|
|
{
|
|
if (interruption == null)
|
|
interruption = new InterruptionData(reason);
|
|
}
|
|
}
|
|
}
|
|
private InterruptState interruption { get; } = new InterruptState();
|
|
public bool IsInterrupted { get { return interruption.IsInterrupted; } }
|
|
public InterruptionData Interruption { get { return interruption.Interruption; } }
|
|
public void ClearInterruption() { interruption.Clear(); }
|
|
public void SetInterrupted() { interruption.Set(InterruptionReason.ManualRequest); }
|
|
public void SetInterrupted(InterruptionReason reason) { interruption.Set(reason); }
|
|
public void SetInterruptedByCancellation() { interruption.Set(InterruptionReason.CancellationRequested); }
|
|
public void SetInterruptedByOperationCanceledException() { interruption.Set(InterruptionReason.OperationCanceledException); }
|
|
|
|
// --- Messages ---
|
|
|
|
private class ProcessMessagesData
|
|
{
|
|
public readonly Object lockable = new object();
|
|
public List<ProcessMessage> messages { get; } = new List<ProcessMessage>();
|
|
}
|
|
private ProcessMessagesData processMessages { get; } = new ProcessMessagesData();
|
|
/// <summary>Convert the message levele to one of the 3 values used with Process Messages: Info, Warning, Error.</summary>
|
|
public static SaMessageLevel GetLevel(SaMessageLevel level)
|
|
{
|
|
if (level == SaMessageLevel.Error || level == SaMessageLevel.Fatal || level == SaMessageLevel.Exception)
|
|
level = SaMessageLevel.Error;
|
|
else if (level == SaMessageLevel.Warning)
|
|
level = SaMessageLevel.Warning;
|
|
else
|
|
level = SaMessageLevel.Info;
|
|
return level;
|
|
}
|
|
/// <summary>Add a message of the specified level (Info, Warning, Error).</summary>
|
|
public bool AddProcessMessage(String message, SaMessageLevel level)
|
|
{
|
|
message = StringUtil.TrimWhitespace(message);
|
|
if (StringUtil.IsBlank(message)) return false;
|
|
level = GetLevel(level);
|
|
lock (processMessages.lockable)
|
|
{
|
|
ProcessMessage procMsg = processMessages.messages.Find(item => item.Message.EqualsCI(message) && item.Level == level);
|
|
// Duplicate messages increment the 'Instances' value.
|
|
if (procMsg != null)
|
|
procMsg.Instances++;
|
|
// Otherwise add a new message to the list.
|
|
else processMessages.messages.Add(new ProcessMessage(message, level));
|
|
}
|
|
return true;
|
|
}
|
|
/// <summary>Are there any message of the specified level (Info, Warning, Error).</summary>
|
|
public bool HasProcessMessages(SaMessageLevel level)
|
|
{
|
|
lock (processMessages.lockable)
|
|
return processMessages.messages.Exists(item => item.Level == GetLevel(level));
|
|
}
|
|
/// <summary>Get the first message of the specified level (Info, Warning, Error).</summary>
|
|
public String GetProcessMessage(SaMessageLevel level)
|
|
{
|
|
lock (processMessages.lockable)
|
|
return processMessages.messages.Find(item => item.Level == GetLevel(level))?.Message ?? "";
|
|
}
|
|
/// <summary>Return all process messages.</summary>
|
|
public List<ProcessMessage> GetProcessMessages()
|
|
{
|
|
List<ProcessMessage> messages = new List<ProcessMessage>();
|
|
lock (processMessages.lockable)
|
|
messages.AddRange(processMessages.messages);
|
|
return messages;
|
|
}
|
|
/// <summary>Return all process messages of the specified Level (Info, Warning, Error).</summary>
|
|
public List<ProcessMessage> GetProcessMessages(SaMessageLevel level)
|
|
{
|
|
List<ProcessMessage> messages = new List<ProcessMessage>();
|
|
lock (processMessages.lockable)
|
|
messages.AddRange(processMessages.messages.FindAll(item => item.Level == GetLevel(level)));
|
|
return messages;
|
|
}
|
|
/// <summary>Clear process messages.</summary>
|
|
public void ClearProcessMessages()
|
|
{
|
|
lock (processMessages.lockable)
|
|
processMessages.messages.Clear();
|
|
}
|
|
|
|
// --- Task Data ---
|
|
|
|
private SacsTaskData taskData = null;
|
|
public SacsTaskData TaskData { get { return taskData; } set { if (taskData != null) taskData.Dispose(); taskData = value; } }
|
|
public bool DetachTaskData(SacsTaskData expected)
|
|
{
|
|
if (!Object.ReferenceEquals(taskData, expected)) return false;
|
|
taskData = null;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// --- Data Members ---
|
|
private Config config;
|
|
private ProcessControlData Control { get; } = new ProcessControlData();
|
|
|
|
// --- Construction ---
|
|
protected SaProcess_Base(Config config)
|
|
{
|
|
this.config = config;
|
|
}
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (disposing)
|
|
{
|
|
AsyncProcessData asyncData;
|
|
lock (AsyncLock)
|
|
{
|
|
asyncData = AsyncData;
|
|
if (asyncData == null)
|
|
Control.TaskData = null;
|
|
}
|
|
// A running worker owns its task data until it exits.
|
|
asyncData?.RequestCancellation();
|
|
}
|
|
}
|
|
|
|
// --- State ---
|
|
public bool DebugMode { get { return SacsSystem.DebugMode; } }
|
|
public bool Processing { get; protected set; } = false;
|
|
public bool ProcessEnded { get; protected set; } = false;
|
|
public DateTime StartedAt { get; private set; } = DateTime.MinValue;
|
|
public DateTime FinishedAt { get; private set; } = DateTime.MinValue;
|
|
public int ElapsedSecs
|
|
{
|
|
get
|
|
{
|
|
if (DateUtil.IsValid(StartedAt))
|
|
return (int)((DateUtil.IsValid(FinishedAt) ? FinishedAt : DateTime.Now) - StartedAt).TotalSeconds;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// --- Process Metadata ---
|
|
/// <summary>Process caption.</summary>
|
|
public abstract String ProcessDescription { get; }
|
|
/// <summary>Process comments - to be displayed with process selection.</summary>
|
|
public virtual List<String> ProcessComments { get { return new List<String>(); } }
|
|
/// <summary>Processing statistics.</summary>
|
|
public virtual List<StringPair> ProcessingStatistics { get { return new List<StringPair>(); } }
|
|
|
|
// --- Asynchronous Execution ---
|
|
private class AsyncProcessData : SacsDisposable
|
|
{
|
|
private readonly Object CancellationLock = new object();
|
|
|
|
public AsyncProcessData(SacsTaskData taskData, ProcessControlData control)
|
|
{
|
|
this.TaskData = taskData;
|
|
this.Control = control;
|
|
}
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (disposing)
|
|
{
|
|
lock (CancellationLock)
|
|
TaskData.Dispose();
|
|
}
|
|
}
|
|
public Task Task { get; set; }
|
|
public SacsTaskData TaskData { get; }
|
|
private ProcessControlData Control { get; }
|
|
public bool RequestCancellation()
|
|
{
|
|
lock (CancellationLock)
|
|
{
|
|
if (!TaskData.CanBeCancelled)
|
|
return false;
|
|
Control.SetInterruptedByCancellation();
|
|
return TaskData.TriggerCancellation();
|
|
}
|
|
}
|
|
}
|
|
private readonly Object AsyncLock = new object();
|
|
private AsyncProcessData AsyncData { get; set; }
|
|
private bool InlineRunActive { get; set; }
|
|
private TaskCompletionSource<Boolean> InlineCompletion { get; set; }
|
|
public bool IsAsync { get { lock (AsyncLock) { return AsyncData != null; } } }
|
|
private bool IsRunActive
|
|
{
|
|
get { return AsyncData != null || InlineRunActive; }
|
|
}
|
|
private void ClearAsyncData(AsyncProcessData asyncData)
|
|
{
|
|
bool clear = false;
|
|
lock (AsyncLock)
|
|
{
|
|
// Only the task that owns the current state may clear it.
|
|
if (Object.ReferenceEquals(AsyncData, asyncData))
|
|
{
|
|
Control.DetachTaskData(asyncData.TaskData);
|
|
AsyncData = null;
|
|
clear = true;
|
|
}
|
|
}
|
|
// Dispose outside the lifecycle lock. Disposal waits for any cancellation callback.
|
|
if (clear)
|
|
asyncData.Dispose();
|
|
}
|
|
/// <summary>
|
|
/// Run the process asynchronously.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
/// <exception cref="InProgressException">If process is already running.</exception>
|
|
public async Task RunAsync()
|
|
{
|
|
AsyncProcessData asyncData;
|
|
lock (AsyncLock)
|
|
{
|
|
if (IsRunActive)
|
|
throw new InProgressException();
|
|
|
|
SacsTaskData taskData = new SacsTaskData();
|
|
Control.TaskData = taskData;
|
|
// Construct before starting so the process state is visible atomically.
|
|
asyncData = new AsyncProcessData(taskData, Control);
|
|
Task task = new Task(() =>
|
|
{
|
|
try
|
|
{
|
|
// Execute the process.
|
|
RunProcessCore(false);
|
|
}
|
|
finally
|
|
{
|
|
// The worker owns its state until it has actually terminated.
|
|
ClearAsyncData(asyncData);
|
|
}
|
|
});
|
|
asyncData.Task = task;
|
|
AsyncData = asyncData;
|
|
task.Start();
|
|
}
|
|
await asyncData.Task;
|
|
}
|
|
|
|
// --- Inline Execution ---
|
|
public bool RunProcess()
|
|
{
|
|
lock (AsyncLock)
|
|
{
|
|
if (IsRunActive)
|
|
throw new InProgressException();
|
|
InlineRunActive = true;
|
|
InlineCompletion = new TaskCompletionSource<Boolean>(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
}
|
|
|
|
try
|
|
{
|
|
return RunProcessCore(true);
|
|
}
|
|
finally
|
|
{
|
|
TaskCompletionSource<Boolean> inlineCompletion;
|
|
lock (AsyncLock)
|
|
{
|
|
InlineRunActive = false;
|
|
inlineCompletion = InlineCompletion;
|
|
InlineCompletion = null;
|
|
}
|
|
inlineCompletion?.TrySetResult(true);
|
|
}
|
|
}
|
|
private bool RunProcessCore(bool clearTaskData)
|
|
{
|
|
// Prepare process.
|
|
bool runProcess = false;
|
|
Reset();
|
|
if (Control.TaskData == null)
|
|
Control.TaskData = new SacsTaskData();
|
|
Processing = true;
|
|
StartedAt = DateTime.Now;
|
|
|
|
// Process starting.
|
|
try
|
|
{
|
|
// Notify start of process and log/ignore exceptions.
|
|
InvokeProcessStarting();
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
Control.SetInterruptedByOperationCanceledException();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
String msg = ExceptionUtil.GetErrorStateMessage(exc);
|
|
AddErrorMessage(msg);
|
|
SaLogger.Error($"{SysUtil.Fn} ProcessStarting: {msg}{exc.GetStackEntries(6).Concat("", "\n\tat ")}", true);
|
|
}
|
|
|
|
// Process running.
|
|
try
|
|
{
|
|
// Run process.
|
|
runProcess = Run();
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
Control.SetInterruptedByOperationCanceledException();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
String msg = ExceptionUtil.GetErrorStateMessage(exc);
|
|
AddErrorMessage(msg);
|
|
SaLogger.Error($"{SysUtil.Fn} " + msg + exc.GetStackEntries(6).Concat("", "\n\tat "), true);
|
|
}
|
|
finally
|
|
{
|
|
// Processing completed.
|
|
FinishedAt = DateTime.Now;
|
|
Processing = false;
|
|
ProcessEnded = true;
|
|
if (clearTaskData)
|
|
Control.TaskData = null;
|
|
}
|
|
|
|
// Process completed.
|
|
try
|
|
{
|
|
// Notify completion of process and log/ignore exceptions.
|
|
InvokeProcessCompleted();
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
Control.SetInterruptedByOperationCanceledException();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
String msg = ExceptionUtil.GetErrorStateMessage(exc);
|
|
AddErrorMessage(msg);
|
|
SaLogger.Error($"{SysUtil.Fn} ProcessCompleted: {msg}{exc.GetStackEntries(6).Concat("", "\n\tat ")}", true);
|
|
}
|
|
return runProcess;
|
|
}
|
|
protected abstract bool Run();
|
|
|
|
// --- Cancellation ---
|
|
|
|
/// <returns>True if no process is running or the process stopped within the timeout.</returns>
|
|
public async Task<bool> StopProcessAsync(int timeout = 50)
|
|
{
|
|
AsyncProcessData asyncData;
|
|
Task inlineCompletion;
|
|
lock (AsyncLock)
|
|
{
|
|
asyncData = AsyncData;
|
|
inlineCompletion = InlineCompletion?.Task;
|
|
}
|
|
if (asyncData == null && inlineCompletion == null)
|
|
return true;
|
|
|
|
Task processTask;
|
|
if (asyncData != null)
|
|
{
|
|
// Cancellation may invoke callbacks synchronously, so request it outside AsyncLock.
|
|
// Cancellation is cooperative; retain the process state until the worker exits.
|
|
asyncData.RequestCancellation();
|
|
processTask = asyncData.Task;
|
|
}
|
|
else
|
|
{
|
|
if (!Interrupt())
|
|
return false;
|
|
processTask = inlineCompletion;
|
|
}
|
|
if (await Task.WhenAny(processTask, Task.Delay(Math.Max(20, timeout))) != processTask)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
await processTask;
|
|
return true;
|
|
}
|
|
|
|
// --- Processing Events ---
|
|
|
|
// Processing Starting.
|
|
public class ProcessStartingEventArgs : EventArgs { }
|
|
public event EventHandler<ProcessStartingEventArgs> OnProcessStarting;
|
|
protected virtual void InvokeProcessStarting()
|
|
{
|
|
if (OnProcessStarting != null)
|
|
{
|
|
ProcessStartingEventArgs args = new ProcessStartingEventArgs();
|
|
OnProcessStarting(this, args);
|
|
}
|
|
}
|
|
|
|
// Process Info Updated.
|
|
public class ProgressInfoUpdatedEventArgs : EventArgs
|
|
{
|
|
public List<String> ProgressInfo { get; } = new List<string>();
|
|
}
|
|
public event EventHandler<ProgressInfoUpdatedEventArgs> OnProgressInfoUpdated;
|
|
protected virtual void InvokeProgressInfoUpdated(List<String> progressInfo)
|
|
{
|
|
if (OnProgressInfoUpdated != null)
|
|
{
|
|
ProgressInfoUpdatedEventArgs args = new ProgressInfoUpdatedEventArgs();
|
|
args.ProgressInfo.AddRange(progressInfo);
|
|
OnProgressInfoUpdated(this, args);
|
|
}
|
|
}
|
|
|
|
// Processing Completed.
|
|
public class ProcessCompletedEventArgs : EventArgs { }
|
|
public event EventHandler<ProcessCompletedEventArgs> OnProcessCompleted;
|
|
protected virtual void InvokeProcessCompleted()
|
|
{
|
|
if (OnProcessCompleted != null)
|
|
{
|
|
ProcessCompletedEventArgs args = new ProcessCompletedEventArgs();
|
|
OnProcessCompleted(this, args);
|
|
}
|
|
}
|
|
|
|
// --- Process State ---
|
|
public bool OK
|
|
{
|
|
get
|
|
{
|
|
if (HasErrorMessage()) return false;
|
|
if (IsInterrupted) return false;
|
|
return true;
|
|
}
|
|
}
|
|
private void Reset()
|
|
{
|
|
Control.ClearProcessMessages();
|
|
Control.ClearInterruption();
|
|
ProcessEnded = false;
|
|
StartedAt = DateTime.MinValue;
|
|
FinishedAt = DateTime.MinValue;
|
|
}
|
|
|
|
// --- Progress Reporting ---
|
|
protected void SetProgressInfo(String progressInfo)
|
|
{
|
|
SetProgressInfo(StringListUtil.CreateList(progressInfo));
|
|
}
|
|
protected void SetProgressInfo(List<String> progressInfo)
|
|
{
|
|
InvokeProgressInfoUpdated(progressInfo);
|
|
}
|
|
|
|
// --- Process Messages ---
|
|
/// <summary>Add a message of the specified level (Info, Warning, Error).</summary>
|
|
protected void AddMessage(String message, SaMessageLevel level)
|
|
{
|
|
if (Control.AddProcessMessage(message, level))
|
|
SaLogger.Log(GetType().Name + " " + message, ProcessControlData.GetLevel(level));
|
|
}
|
|
protected void AddInfoMessage(String message)
|
|
{
|
|
AddMessage(message, SaMessageLevel.Info);
|
|
}
|
|
protected void AddWarningMessage(String message)
|
|
{
|
|
AddMessage(message, SaMessageLevel.Warning);
|
|
}
|
|
/// <summary>Add the error message and always return false.</summary>
|
|
protected bool AddErrorMessage(String message)
|
|
{
|
|
AddMessage(message, SaMessageLevel.Error);
|
|
return false;
|
|
}
|
|
/// <summary>Are there any error messages.</summary>
|
|
public bool HasErrorMessage()
|
|
{
|
|
return Control.HasProcessMessages(SaMessageLevel.Error);
|
|
}
|
|
/// <summary>Get the first error message.</summary>
|
|
public String GetErrorMessage()
|
|
{
|
|
return Control.GetProcessMessage(SaMessageLevel.Error);
|
|
}
|
|
/// <summary>Return all process messages.</summary>
|
|
public List<ProcessMessage> GetProcessMessages()
|
|
{
|
|
return Control.GetProcessMessages();
|
|
}
|
|
/// <summary>Return all process messages of the specified Level (Info, Warning, Error).</summary>
|
|
public List<ProcessMessage> GetProcessMessages(SaMessageLevel level)
|
|
{
|
|
return Control.GetProcessMessages(level);
|
|
}
|
|
/// <summary>Clear process messages.</summary>
|
|
public void ClearProcessMessages()
|
|
{
|
|
Control.ClearProcessMessages();
|
|
}
|
|
|
|
// --- Interruption ---
|
|
public bool IsInterrupted
|
|
{
|
|
get { return Control.IsInterrupted || (Control.TaskData?.IsCancellationRequested ?? false); }
|
|
}
|
|
public InterruptionData Interruption { get { return Control.Interruption; } }
|
|
public bool Interrupt()
|
|
{
|
|
if (!config.AllowInterruption)
|
|
{
|
|
SaLogger.Warn("SacsProcess.Interrupt() Interruptions not allowed in " + this.GetType().Name);
|
|
return false;
|
|
}
|
|
if (config.ConfirmInterruption && !IsInterruptionConfirmed()) return false;
|
|
Control.SetInterrupted();
|
|
return true;
|
|
}
|
|
protected virtual bool IsInterruptionConfirmed()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// --- The End ---
|
|
}
|
|
}
|