private void HeartTripped(SchedulingEventArg arg)
{
try
{
State = TaskExecutionType.Running;
LastRun = DateTime.Now;
using (var factory =
new ChannelFactory <TChanel>(CurrentBinding(_executionSchema.BindingSchema),
new EndpointAddress(_executionSchema.Uri)))
{
TChanel channel = factory.CreateChannel();
typeof(TChanel)
.InvokeMember(_executionSchema.MethodName, BindingFlags.Default | BindingFlags.InvokeMethod,
null, channel, null);
}
State = TaskExecutionType.Succeed;
}
catch
{
State = TaskExecutionType.Failure;
}
finally
{
LastDuration = _heart.LastDuration;
CountLaunches++;
if (_executionSchema.LaunchesLimit == CountLaunches)
{
arg.Interval = -1;
}
else
{
NextRun = DateTime.Now.Add(TimeSpan.FromSeconds(_executionSchema.Period));
}
}
}
private void InstanceTripped(SchedulingEventArg arg)
{
lock (_heart)
{
Sheduler sheduler = null;
using (
ISession session =
NHibernateHelper.SessionManager.GetSessionFor <WebEnvironmentFiact>().SessionFactory.OpenSession()
)
{
try
{
sheduler = session.Get <TSheduler>(_id);
if (sheduler == null)
{
arg.Interval = -1;
return;
}
if (_cancelTokSource != null)
{
arg.Interval = -1;
return;
}
State = TaskExecutionType.Running;
sheduler.LastRun = _heart.LastRun;
sheduler.Iteration = _heart.CountLaunches;
_cancelTokSource = new CancellationTokenSource();
_status = new StatusTask
{
StartRun = DateTime.Now,
EndRun = null,
Error = null,
Sheduler = session.Get <Sheduler>(Id),
TaskExecType = TaskExecType.Running
};
session.Save(_status);
_recId = _status.Id;
var keyPair = new KeyValuePair <int, CancellationToken>(_status.Id, _cancelTokSource.Token);
Task task = null;
try
{
task = Task.Factory.StartNew(x =>
{
var key =
(KeyValuePair <int, CancellationToken>)x;
if (!key.Value.IsCancellationRequested)
{
var t = new Thread(DoWork);
t.Start(key.Key);
while (t.IsAlive &&
!key.Value.IsCancellationRequested)
{
}
if (t.IsAlive)
{
t.Abort();
}
}
}, keyPair, _cancelTokSource.Token);
if (sheduler.IsKill && sheduler.Runtime.HasValue)
{
task.Wait(new TimeSpan(0, sheduler.Runtime.Value, 0));
if (task.IsCompleted && _cancelTokSource != null &&
!_cancelTokSource.IsCancellationRequested)
{
State = TaskExecutionType.Succeed;
}
else if (task.Status != TaskStatus.Canceled && task.Status != TaskStatus.RanToCompletion &&
task.Status != TaskStatus.Faulted)
{
_cancelTokSource.Cancel();
State = TaskExecutionType.Failure;
}
else
{
State = TaskExecutionType.Failure;
}
}
else
{
task.Wait();
if (task.IsCompleted && _cancelTokSource != null &&
!_cancelTokSource.IsCancellationRequested)
{
State = TaskExecutionType.Succeed;
}
else
{
State = TaskExecutionType.Failure;
}
}
Task.WaitAll(new[] { task });
if (task.Status != TaskStatus.Canceled && task.Status != TaskStatus.RanToCompletion &&
task.Status != TaskStatus.Faulted)
{
task.Dispose();
}
}
catch (InvalidOperationException)
{
State = TaskExecutionType.Failure;
if (task != null)
{
Task.WaitAll(new[] { task });
}
}
catch (AggregateException)
{
State = TaskExecutionType.Failure;
if (task != null)
{
Task.WaitAll(new[] { task });
}
}
catch (OperationCanceledException)
{
State = TaskExecutionType.Failure;
if (task != null)
{
Task.WaitAll(new[] { task });
}
}
catch (ThreadAbortException)
{
State = TaskExecutionType.Failure;
Thread.ResetAbort();
if (task != null)
{
Task.WaitAll(new[] { task });
}
}
finally
{
if (task != null && task.Status != TaskStatus.RanToCompletion)
{
Task.WaitAll(new[] { task });
if (task.Status != TaskStatus.Canceled &&
task.Status != TaskStatus.Faulted)
{
task.Dispose();
}
}
}
}
catch
{
State = TaskExecutionType.Failure;
}
finally
{
if (sheduler != null)
{
if (_status != null)
{
session.Refresh(_status);
_status = session.Get <StatusTask>(_recId);
if (_status.TaskExecType != TaskExecType.Failure)
{
_status.TaskExecType =
(TaskExecType)Enum.Parse(typeof(TaskExecType), ((int)State).ToString());
_status.EndRun = DateTime.Now;
session.Save(_status);
}
}
sheduler.Duration = _heart.LastDuration;
sheduler.UpdateShedule();
DateTime?next = sheduler.NextRun;
arg.Interval = !next.HasValue
? -1
: (long)next.Value.Subtract(DateTime.Now).TotalMilliseconds;
if (IsRemove)
{
arg.Interval = -1;
}
sheduler.IsEnabled = next.HasValue;
session.Save(sheduler);
session.Flush();
_cancelTokSource = null;
_status = null;
}
}
}
}
}
