/// <inheritdoc />
public void Stop()
{
lock (this)
{
if (_fullyStopped)
{
return;
}
IsRunning = false;
// see PipelineExecution_Thread, basically we release for every thread
// so every thread is able to stop
// when stopping, every thread consumes exactly one semaphore
_queuedSemaphore.Release(Executors.Length);
foreach (var executor in Executors)
{
executor.Join();
}
_fullyStopped = true;
}
LifeCycleEvent?.Invoke(this, new ExecutorLifeCycleEventArgs(ExecutorLifeCycleEventType.Stop));
}
private void OnLifeCycleEvent(CancellationTokenSource cancellationToken, LifeCycleEvent evt)
{
// Dispose data and signal workflow completed
if (evt is WorkflowCompleted)
{
DisposeData();
_resetEvent.Set();
return;
}
// Ignore other lifecycle events which aren't related to user cancellation
if (!cancellationToken.IsCancellationRequested)
{
return;
}
var data = (WorkflowData)GetWorkflow().Data;
if (data.ProgressBar != null)
{
data.ProgressBar.Message = $"Cancelled after rendering {data.RenderedCount} images";
}
_host.TerminateWorkflow(evt.WorkflowInstanceId);
DisposeData();
_resetEvent.Set();
}
/// <inheritdoc />
/// <summary>
/// This method assigns the given pipeline once (i.e. cannot be changed afterwards), and creates and starts the threads.
/// Calling this method a second time will be ignored.
/// </summary>
public void Initialize(IEnumerable <IDataPipelineOrBuilder> pipeline)
{
lock (this)
{
if (Initialized)
{
return;
}
Pipeline = pipeline ?? throw new ArgumentNullException(nameof(pipeline));
IsRunning = true;
for (int i = 0; i < Executors.Length; i++)
{
Executors[i] = new Thread(PipelineExecution_Thread);
Executors[i].Start();
}
Initialized = true;
}
Log.Info("Executor has been initialized.");
LifeCycleEvent?.Invoke(this, new ExecutorLifeCycleEventArgs(ExecutorLifeCycleEventType.Initialize));
}
private static void Host_OnLifeCycleEvent(LifeCycleEvent evt)
{
// TODO: logging
// ..
Console.WriteLine($"{evt.EventTimeUtc}, {evt.GetType().Name}");
}
/// <inheritdoc />
public bool Add(IFileSource fileSource)
{
if (fileSource == null)
{
throw new ArgumentNullException(nameof(fileSource));
}
lock (this)
{
if (!IsRunning)
{
return(false);
}
lock (ActiveFileSources)
{
if (!TryAddConflicting(fileSource))
{
if (!PendingFileSources.TryAdd(fileSource))
{
return(false);
}
_queuedSemaphore.Release();
}
}
}
LifeCycleEvent?.Invoke(this,
new ExecutorLifeCycleEventArgs(ExecutorLifeCycleEventType.SourceAdded, fileSource));
return(true);
}
public void PublishNotification(LifeCycleEvent evt)
{
if (_outbox.IsAddingCompleted || !_workflowOptions.EnableLifeCycleEventsPublisher)
{
return;
}
_outbox.Add(evt);
}
public void PublishNotification(LifeCycleEvent evt)
{
if (_outbox.IsAddingCompleted)
{
return;
}
_outbox.Add(evt);
}
public async Task PublishNotification(LifeCycleEvent evt)
{
if (_subscriber == null)
{
throw new InvalidOperationException();
}
var data = JsonConvert.SerializeObject(evt, _serializerSettings);
await _subscriber.PublishAsync(_channel, data);
}
public async Task PublishNotification(LifeCycleEvent evt)
{
var payload = JsonConvert.SerializeObject(evt, _serializerSettings);
var message = new Message(Encoding.Default.GetBytes(payload))
{
Label = evt.Reference
};
await _topicClient.SendAsync(message);
}
private void Host_OnLifeCycleEvent(LifeCycleEvent evt)
{
if (evt is WorkflowCompleted)
{
var type = evt as WorkflowCompleted;
_workflowDataMappings.TryRemove(type.WorkflowInstanceId, out string id);
var file = Path.Combine(_fileConfig.OutputFolder, type.WorkflowInstanceId + ".txt");
using (StreamReader sr = new StreamReader(file, Encoding.GetEncoding("big5")))
{
var line = sr.ReadLine();
_rLogger.WriteDebug($"執行結束 {id}：{line}");
}
_fileWatcher.MoveToBackupFolder(file);
Console.WriteLine($"Life cycle type: {nameof(WorkflowCompleted)}, workflow id {type.WorkflowInstanceId}");
}
else if (evt is WorkflowError)
{
var type = evt as WorkflowError;
_workflowDataMappings.TryRemove(type.WorkflowInstanceId, out string id);
Console.WriteLine($"Life cycle type: {nameof(WorkflowError)}, workflow id {type.WorkflowInstanceId}, message: {type.Message}, step: {type.StepId}, ExecutionPointerId: {type.ExecutionPointerId}");
}
//else if (evt is WorkflowSuspended)
//{
// var type = evt as WorkflowSuspended;
// Console.WriteLine($"Life cycle type: {nameof(WorkflowSuspended)}, workflow id {type.WorkflowInstanceId}");
//} else if (evt is WorkflowStarted)
//{
// var type = evt as WorkflowStarted;
// Console.WriteLine($"Life cycle type: {nameof(WorkflowStarted)}, workflow id {type.WorkflowInstanceId}");
//}
//else if (evt is WorkflowResumed)
//{
// var type = evt as WorkflowResumed;
// Console.WriteLine($"Life cycle type: {nameof(WorkflowResumed)}, workflow id {type.WorkflowInstanceId}");
//}
//else if (evt is WorkflowTerminated)
//{
// var type = evt as WorkflowTerminated;
// Console.WriteLine($"Life cycle type: {nameof(WorkflowTerminated)}, workflow id {type.WorkflowInstanceId}");
//}
//else if (evt is StepCompleted)
//{
// var type = evt as StepCompleted;
// Console.WriteLine($"Life cycle type: {nameof(StepCompleted)}, workflow id {type.WorkflowInstanceId}, step: {type.StepId}, ExecutionPointerId: {type.ExecutionPointerId}");
//}
//else if (evt is StepStarted)
//{
// var type = evt as StepStarted;
// Console.WriteLine($"Life cycle type: {nameof(StepStarted)}, workflow id {type.WorkflowInstanceId}, step: {type.StepId}, ExecutionPointerId: {type.ExecutionPointerId}");
//}
}
private void NotifySubscribers(LifeCycleEvent evt)
{
foreach (var subscriber in _subscribers)
{
try
{
subscriber(evt);
}
catch (Exception ex)
{
_logger.LogWarning(default(EventId), ex, $"Error on event subscriber: {ex.Message}");
}
}
}
public Task PublishNotification(LifeCycleEvent evt)
{
Task.Run(() =>
{
foreach (var subscriber in _subscribers)
{
try
{
subscriber(evt);
}
catch (Exception ex)
{
_logger.LogWarning(default(EventId), ex, $"Error on event subscriber: {ex.Message}");
}
}
});
return(Task.CompletedTask);
}
public async Task PublishNotification(LifeCycleEvent evt)
{
using (var stream = new MemoryStream())
{
var writer = new StreamWriter(stream);
_serializer.Serialize(writer, evt);
writer.Flush();
var response = await _client.PutRecordAsync(new PutRecordRequest()
{
StreamName = _streamName,
PartitionKey = evt.WorkflowInstanceId,
Data = stream
});
//if (response.HttpStatusCode != System.Net.HttpStatusCode.OK)
//{
// _logger.LogWarning($"Failed to send event to Kinesis {response.HttpStatusCode}");
//}
}
}
/// <summary>
/// This method actually processes the sources, invokes all required events, and handles errors.
/// </summary>
/// <param name="source">The source that will be executed.</param>
protected virtual void ProcessSource(IFileSource source)
{
LifeCycleEvent?.Invoke(this,
new ExecutorLifeCycleEventArgs(ExecutorLifeCycleEventType.SourceExecutionStart, source));
Log.DebugFormat("Starting to process {0}.", source);
bool error = false;
foreach (var p in Pipeline)
{
try
{
p.Build().Execute(source);
}
catch (Exception e)
{
error = true;
IsRunning = !DieOnException; // prevent new sources from being added (if DieOnException)
LifeCycleEvent?.Invoke(this, new ExecutorLifeCycleEventArgs(p, source, e));
Log.WarnFormat("Source {0} has thrown an exception.", source);
if (AbortPipelineOnError)
{
break;
}
}
}
LifeCycleEvent?.Invoke(this,
new ExecutorLifeCycleEventArgs(ExecutorLifeCycleEventType.SourceExecutionFinished, source));
if (error && DieOnException)
{
Log.Warn("Executor is about to stop due to an exception ...");
new Thread(Stop).Start(); // call stop from another thread, so that it won't cause a deadlock.
}
}
public void HandleLifeCycleEvent(LifeCycleEvent evt)
{
OnLifeCycleEvent?.Invoke(evt);
}
internal void WireupAutomaticEvents ()
{
Type cacheKey = this.GetType ();
Hashtable eventMethodCache = EventMethodCache;
ArrayList eventMethodList = eventMethodCache == null ? null : (ArrayList) eventMethodCache [cacheKey];
if (eventMethodList == null) {
eventMethodList = new ArrayList ();
if (!SupportAutoEvents || !AutoEventWireup)
return;
Type thisType = typeof (TemplateControl);
Type voidType = typeof (void);
Type [] DefaultParams = new Type [] {
typeof (object),
typeof (EventArgs) };
LifeCycleEvent[] _pageEvents = new LifeCycleEvent[] {
LifeCycleEvent.PreInit,
LifeCycleEvent.PreLoad,
LifeCycleEvent.LoadComplete,
LifeCycleEvent.PreRenderComplete,
LifeCycleEvent.SaveStateComplete,
LifeCycleEvent.InitComplete
};
List<LifeCycleEvent> pageEvents = new List<LifeCycleEvent>(_pageEvents);
bool isPage = Page.GetType().IsAssignableFrom(GetType());
for (int i = 0; i < methodNames.Length; i++) {
// Don't look for page-only events in non-page controls.
if (!isPage && pageEvents.Contains((LifeCycleEvent)i))
continue;
string methodName = methodNames [i];
MethodInfo method;
bool noParams = false;
Type type = GetType ();
do {
method = type.GetMethod (methodName, bflags, null, DefaultParams, null);
if (method != null) {
break;
}
type = type.BaseType;
}
while (type != thisType);
if (method == null) {
type = GetType ();
do {
method = type.GetMethod (methodName, bflags, null, Type.EmptyTypes, null);
if (method != null) {
noParams = true;
break;
}
type = type.BaseType;
}
while (type != thisType);
if (method == null)
continue;
}
if (method.ReturnType != voidType)
continue;
eventMethodList.Add (new EventMethodMap ((LifeCycleEvent) i, method, noParams));
}
// We copy to not lock
Hashtable newEventMethodCache = eventMethodCache == null ? new Hashtable () : (Hashtable) eventMethodCache.Clone ();
newEventMethodCache [cacheKey] = eventMethodList;
EventMethodCache = newEventMethodCache;
}
foreach (EventMethodMap eventMethod in eventMethodList) {
EventHandler handler = eventMethod.NoParameters ?
new NoParamsInvoker (this, eventMethod.Method).FakeDelegate :
(EventHandler)Delegate.CreateDelegate (typeof (EventHandler), this, eventMethod.Method);
object eventKey = EventKeys [(int) eventMethod.EventKeyIndex];
Delegate existing = Events [eventKey];
if (existing != null && handler.Equals(existing))
continue;
switch (eventMethod.EventKeyIndex) {
case LifeCycleEvent.Init:
Init += handler;
break;
#if NET_2_0
case LifeCycleEvent.PreInit:
((Page)this).PreInit += handler;
break;
case LifeCycleEvent.PreLoad:
((Page) this).PreLoad += handler;
break;
case LifeCycleEvent.LoadComplete:
((Page) this).LoadComplete += handler;
break;
case LifeCycleEvent.PreRenderComplete:
((Page) this).PreRenderComplete += handler;
break;
case LifeCycleEvent.SaveStateComplete:
((Page) this).SaveStateComplete += handler;
break;
case LifeCycleEvent.InitComplete:
((Page) this).InitComplete += handler;
break;
#endif
case LifeCycleEvent.Load:
Load += handler;
break;
case LifeCycleEvent.DataBinding:
DataBinding += handler;
break;
case LifeCycleEvent.PreRender:
PreRender += handler;
break;
case LifeCycleEvent.Disposed:
Disposed += handler;
break;
case LifeCycleEvent.Unload:
Unload += handler;
break;
case LifeCycleEvent.Error:
Error += handler;
break;
case LifeCycleEvent.AbortTransaction:
AbortTransaction += handler;
break;
case LifeCycleEvent.CommitTransaction:
CommitTransaction += handler;
break;
}
}
}
public EventMethodMap (LifeCycleEvent EventKeyIndex, MethodInfo Method, bool NoParameters)
{
this.EventKeyIndex = EventKeyIndex;
this.Method = Method;
this.NoParameters = NoParameters;
}
public EventMethodMap(LifeCycleEvent EventKeyIndex, MethodInfo Method, bool NoParameters)
{
this.EventKeyIndex = EventKeyIndex;
this.Method = Method;
this.NoParameters = NoParameters;
}
internal void WireupAutomaticEvents()
{
Type cacheKey = this.GetType();
Hashtable eventMethodCache = EventMethodCache;
ArrayList eventMethodList = eventMethodCache == null ? null : (ArrayList)eventMethodCache [cacheKey];
if (eventMethodList == null)
{
eventMethodList = new ArrayList();
if (!SupportAutoEvents || !AutoEventWireup)
{
return;
}
Type thisType = typeof(TemplateControl);
Type voidType = typeof(void);
Type [] DefaultParams = new Type [] {
typeof(object),
typeof(EventArgs)
};
LifeCycleEvent[] _pageEvents = new LifeCycleEvent[] {
LifeCycleEvent.PreInit,
LifeCycleEvent.PreLoad,
LifeCycleEvent.LoadComplete,
LifeCycleEvent.PreRenderComplete,
LifeCycleEvent.SaveStateComplete,
LifeCycleEvent.InitComplete
};
List <LifeCycleEvent> pageEvents = new List <LifeCycleEvent>(_pageEvents);
bool isPage = Page.GetType().IsAssignableFrom(GetType());
for (int i = 0; i < methodNames.Length; i++)
{
// Don't look for page-only events in non-page controls.
if (!isPage && pageEvents.Contains((LifeCycleEvent)i))
{
continue;
}
string methodName = methodNames [i];
MethodInfo method;
bool noParams = false;
Type type = GetType();
do
{
method = type.GetMethod(methodName, bflags, null, DefaultParams, null);
if (method != null)
{
break;
}
type = type.BaseType;
}while (type != thisType);
if (method == null)
{
type = GetType();
do
{
method = type.GetMethod(methodName, bflags, null, Type.EmptyTypes, null);
if (method != null)
{
noParams = true;
break;
}
type = type.BaseType;
}while (type != thisType);
if (method == null)
{
continue;
}
}
if (method.ReturnType != voidType)
{
continue;
}
eventMethodList.Add(new EventMethodMap((LifeCycleEvent)i, method, noParams));
}
// We copy to not lock
Hashtable newEventMethodCache = eventMethodCache == null ? new Hashtable() : (Hashtable)eventMethodCache.Clone();
newEventMethodCache [cacheKey] = eventMethodList;
EventMethodCache = newEventMethodCache;
}
foreach (EventMethodMap eventMethod in eventMethodList)
{
EventHandler handler = eventMethod.NoParameters ?
new NoParamsInvoker(this, eventMethod.Method).FakeDelegate :
(EventHandler)Delegate.CreateDelegate(typeof(EventHandler), this, eventMethod.Method);
object eventKey = EventKeys [(int)eventMethod.EventKeyIndex];
Delegate existing = Events [eventKey];
if (existing != null && handler.Equals(existing))
{
continue;
}
switch (eventMethod.EventKeyIndex)
{
case LifeCycleEvent.Init:
Init += handler;
break;
#if NET_2_0
case LifeCycleEvent.PreInit:
((Page)this).PreInit += handler;
break;
case LifeCycleEvent.PreLoad:
((Page)this).PreLoad += handler;
break;
case LifeCycleEvent.LoadComplete:
((Page)this).LoadComplete += handler;
break;
case LifeCycleEvent.PreRenderComplete:
((Page)this).PreRenderComplete += handler;
break;
case LifeCycleEvent.SaveStateComplete:
((Page)this).SaveStateComplete += handler;
break;
case LifeCycleEvent.InitComplete:
((Page)this).InitComplete += handler;
break;
#endif
case LifeCycleEvent.Load:
Load += handler;
break;
case LifeCycleEvent.DataBinding:
DataBinding += handler;
break;
case LifeCycleEvent.PreRender:
PreRender += handler;
break;
case LifeCycleEvent.Disposed:
Disposed += handler;
break;
case LifeCycleEvent.Unload:
Unload += handler;
break;
case LifeCycleEvent.Error:
Error += handler;
break;
case LifeCycleEvent.AbortTransaction:
AbortTransaction += handler;
break;
case LifeCycleEvent.CommitTransaction:
CommitTransaction += handler;
break;
}
}
}
public void PublishNotification(LifeCycleEvent evt)
{
_outbox.Enqueue(evt);
}
/// <summary>
/// Execute a lifecycle event with given parameters.
/// </summary>
/// <param name="eventType">The type of the event.</param>
protected virtual void ExecuteEvent(SchedulerLifeCycleEventType eventType)
{
LifeCycleEvent?.Invoke(this, new SchedulerLifeCycleEventArgs(IsRunning, eventType));
}
/// <summary>
/// Execute a lifecycle event with given parameters.
/// </summary>
/// <param name="eventType">The type of the event.</param>
/// <param name="source">The source that is processed by this event. May be <code>null</code>.</param>
protected virtual void ExecuteEvent(SchedulerLifeCycleEventType eventType, IFileSource source = null)
{
LifeCycleEvent?.Invoke(this, new SchedulerLifeCycleEventArgs(IsRunning, source, eventType));
}
