// Token: 0x0600043A RID: 1082 RVA: 0x0001CD5C File Offset: 0x0001AF5C
private object ThreadPoolRoutine(object state)
{
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask scheduledTask = state as UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask;
if (scheduledTask == null)
{
throw new ArgumentException("Unexpected state object or null", "state");
}
try
{
bool taskExecuted = false;
Exception ex = null;
using (LocaleThreadState.EnsurePrimaryLocale())
{
if (!SmartThreadPool.IsWorkItemCanceled)
{
try
{
taskExecuted = true;
this.taskRoutine(scheduledTask.TaskKey);
}
catch (Exception ex2)
{
ex = ex2;
this.log.Error(string.Format("Task {0} cought unhandled exception from task routine", scheduledTask), ex2);
}
}
if (scheduledTask.Callbacks != null)
{
foreach (UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTaskCallback scheduledTaskCallback in scheduledTask.Callbacks)
{
try
{
scheduledTaskCallback.Callback(new UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTaskCallbackEventArgs(scheduledTask.TaskKey, scheduledTaskCallback.State, ex, taskExecuted));
}
catch (Exception ex3)
{
this.log.Error(string.Format("Task {0} callback failed", scheduledTask), ex3);
}
}
}
}
}
catch (Exception ex4)
{
this.log.Error(string.Format("Task {0} cought unhandled exception during task processing", scheduledTask), ex4);
}
finally
{
object obj = this.syncLock;
lock (obj)
{
this.ongoingTasks.Remove(scheduledTask);
}
}
return(null);
}
internal void CallbackRoutine(
UpdateTaskScheduler <int, Guid> .ScheduledTaskCallbackEventArgs state)
{
Action action = (Action)null;
lock (this.syncLock)
{
DiscoveryNetObjectStatusManager.CallbackInfo callbackInfo;
if (this.awaitingCallbacks.TryGetValue(state.State, out callbackInfo))
{
if (callbackInfo.AwaitingCallsCount > 1)
{
--callbackInfo.AwaitingCallsCount;
if (DiscoveryNetObjectStatusManager.log.get_IsDebugEnabled())
{
DiscoveryNetObjectStatusManager.log.DebugFormat("Supressing callback for profile {0}, update request {1}, waiting for {2} more", (object)state.TaskKey, (object)state.State, (object)callbackInfo.AwaitingCallsCount);
}
}
else
{
action = callbackInfo.CallbackRoutine;
this.awaitingCallbacks.Remove(state.State);
if (DiscoveryNetObjectStatusManager.log.get_IsDebugEnabled())
{
DiscoveryNetObjectStatusManager.log.DebugFormat("Firing callback for profile {0}, update request {1}", (object)state.TaskKey, (object)state.State);
}
}
}
else
{
DiscoveryNetObjectStatusManager.log.ErrorFormat("Callback for profile {0} with unknown update request {1} received", (object)state.TaskKey, (object)state.State);
}
}
if (action == null)
{
return;
}
try
{
action();
}
catch (Exception ex)
{
DiscoveryNetObjectStatusManager.log.Error((object)string.Format("Callback handling routine for profile {0}, update request {1} failed", (object)state.TaskKey, (object)state.State), ex);
}
}
private void RequestUpdateInternal(
List <int> profileIDs,
Action updateFinishedCallback,
TimeSpan waitForChangesDelay)
{
UpdateTaskScheduler <int, Guid> .ScheduledTaskCallback callback = (UpdateTaskScheduler <int, Guid> .ScheduledTaskCallback)null;
if (updateFinishedCallback != null)
{
Guid guid = Guid.NewGuid();
lock (this.syncLock)
this.awaitingCallbacks.Add(guid, new DiscoveryNetObjectStatusManager.CallbackInfo(updateFinishedCallback, profileIDs.Count));
callback = new UpdateTaskScheduler <int, Guid> .ScheduledTaskCallback(new Action <UpdateTaskScheduler <int, Guid> .ScheduledTaskCallbackEventArgs>(this.CallbackRoutine), guid);
if (DiscoveryNetObjectStatusManager.log.get_IsDebugEnabled())
{
DiscoveryNetObjectStatusManager.log.DebugFormat("Registering awaiting callback for profiles {0}, request: {1}", (object)string.Join(", ", profileIDs.Select <int, string>((Func <int, string>)(p => p.ToString())).ToArray <string>()), (object)guid);
}
}
foreach (int profileId in profileIDs)
{
this.scheduler.RequestUpdateAsync(profileId, callback, waitForChangesDelay);
}
}
public void RequestUpdateAsync(
TTaskKey taskKey,
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTaskCallback callback,
TimeSpan waitForChangesDelay)
{
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask scheduledTask1 = new UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask();
scheduledTask1.TaskKey = taskKey;
scheduledTask1.PlannedExecution = DateTime.UtcNow.Add(waitForChangesDelay);
List <UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTaskCallback> scheduledTaskCallbackList;
if (callback == null)
{
scheduledTaskCallbackList = (List <UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTaskCallback>)null;
}
else
{
scheduledTaskCallbackList = new List <UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTaskCallback>();
scheduledTaskCallbackList.Add(callback);
}
scheduledTask1.Callbacks = scheduledTaskCallbackList;
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask scheduledTask2 = scheduledTask1;
if (this.log.get_IsDebugEnabled())
{
this.log.DebugFormat("RequestUpdate for Task {0} - Enter", (object)taskKey);
}
lock (this.syncLock)
{
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask scheduledTask3;
if (this.scheduledTasks.TryFind(scheduledTask2, (IComparer <UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask>)UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask.IdentityComparer.Instance, ref scheduledTask3))
{
if (scheduledTask2.PlannedExecution < scheduledTask3.PlannedExecution)
{
if (scheduledTask3.Callbacks != null)
{
if (scheduledTask2.Callbacks != null)
{
scheduledTask2.Callbacks.AddRange((IEnumerable <UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTaskCallback>)scheduledTask3.Callbacks);
}
else
{
scheduledTask2.Callbacks = scheduledTask3.Callbacks;
}
}
this.scheduledTasks.Remove(scheduledTask3, (IComparer <UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask>)UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask.IdentityComparer.Instance);
this.scheduledTasks.Enqueue(scheduledTask2);
if (this.log.get_IsInfoEnabled())
{
this.log.InfoFormat("Task {0} was rescheduled from {1} to {2}", (object)scheduledTask2, (object)scheduledTask3.PlannedExecution, (object)scheduledTask2.PlannedExecution);
}
Monitor.PulseAll(this.syncLock);
}
else
{
if (scheduledTask2.Callbacks != null)
{
if (scheduledTask3.Callbacks != null)
{
scheduledTask3.Callbacks.AddRange((IEnumerable <UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTaskCallback>)scheduledTask2.Callbacks);
}
else
{
scheduledTask3.Callbacks = scheduledTask2.Callbacks;
}
}
if (this.log.get_IsInfoEnabled())
{
this.log.InfoFormat("Task {0} has been scheduled already at {1}, requested time {2}", (object)scheduledTask2, (object)scheduledTask3.PlannedExecution, (object)scheduledTask2.PlannedExecution);
}
}
}
else
{
this.scheduledTasks.Enqueue(scheduledTask2);
if (this.log.get_IsInfoEnabled())
{
this.log.InfoFormat("Task {0} has been scheduled for {1}", (object)scheduledTask2, (object)scheduledTask2.PlannedExecution);
}
Monitor.PulseAll(this.syncLock);
}
}
if (!this.log.get_IsDebugEnabled())
{
return;
}
this.log.DebugFormat("RequestUpdate for Task {0} - Leave", (object)taskKey);
}
public override int Compare(
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask x,
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask y)
{
return(DateTime.Compare(y.PlannedExecution, x.PlannedExecution));
}
public int GetHashCode(
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask obj)
{
return(obj.TaskKey.GetHashCode());
}
public bool Equals(
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask x,
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask y)
{
return(x.TaskKey.CompareTo((object)y.TaskKey) == 0);
}
public override int Compare(
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask x,
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask y)
{
return(x.TaskKey.CompareTo((object)y.TaskKey));
}
private void SchedulerRoutine()
{
this.log.Debug((object)"Scheduler: scheduling thread started");
while (true)
{
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask scheduledTask = (UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask)null;
lock (this.syncLock)
{
if (this.ChangesActive)
{
this.log.Debug((object)"Suspending Scheduler: ongoing changes detected");
Monitor.Wait(this.syncLock);
}
else if (this.scheduledTasks.get_Count() == 0)
{
this.log.Debug((object)"Suspending Scheduler: no pending tasks to process");
Monitor.Wait(this.syncLock);
}
else
{
DateTime utcNow = DateTime.UtcNow;
scheduledTask = this.scheduledTasks.Peek();
if (scheduledTask.PlannedExecution > utcNow)
{
TimeSpan timeout = scheduledTask.PlannedExecution.Subtract(utcNow);
if (this.log.get_IsDebugEnabled())
{
this.log.DebugFormat("Suspending Scheduler: woke up too early, next task {0} is scheduled for {1}, will be suspended for {2}", (object)scheduledTask, (object)scheduledTask.PlannedExecution, (object)timeout);
}
scheduledTask = (UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask)null;
Monitor.Wait(this.syncLock, timeout);
}
else if (this.ongoingTasks.Contains(scheduledTask))
{
this.scheduledTasks.Remove(scheduledTask, (IComparer <UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask>)UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask.IdentityComparer.Instance);
scheduledTask.PlannedExecution = utcNow.Add(this.postponeTaskDelay);
this.scheduledTasks.Enqueue(scheduledTask);
if (this.log.get_IsDebugEnabled())
{
this.log.DebugFormat("Scheduler: task {0} is being executed, rescheduling its next execution to {1}", (object)scheduledTask, (object)scheduledTask.PlannedExecution);
}
scheduledTask = (UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask)null;
}
else
{
scheduledTask = this.scheduledTasks.Dequeue();
this.ongoingTasks.Add(scheduledTask);
if (this.log.get_IsDebugEnabled())
{
this.log.DebugFormat("Scheduler: Task {0} is planed to get executed now", (object)scheduledTask);
}
}
}
}
if (scheduledTask != null)
{
// ISSUE: method pointer
this.processingGroup.QueueWorkItem(new WorkItemCallback((object)this, __methodptr(ThreadPoolRoutine)), (object)scheduledTask);
if (this.log.get_IsDebugEnabled())
{
this.log.DebugFormat("Scheduler: Task {0} was executed", (object)scheduledTask);
}
}
Thread.Sleep(this.mandatorySchedulerDelay);
}
}
// Token: 0x06000438 RID: 1080 RVA: 0x0001C914 File Offset: 0x0001AB14
public void RequestUpdateAsync(TTaskKey taskKey, UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTaskCallback callback, TimeSpan waitForChangesDelay)
{
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask scheduledTask = new UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask();
scheduledTask.TaskKey = taskKey;
scheduledTask.PlannedExecution = DateTime.UtcNow.Add(waitForChangesDelay);
object callbacks;
if (callback == null)
{
callbacks = null;
}
else
{
(callbacks = new List <UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTaskCallback>()).Add(callback);
}
scheduledTask.Callbacks = callbacks;
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask scheduledTask2 = scheduledTask;
if (this.log.IsDebugEnabled)
{
this.log.DebugFormat("RequestUpdate for Task {0} - Enter", taskKey);
}
object obj = this.syncLock;
lock (obj)
{
UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask scheduledTask3 = null;
if (this.scheduledTasks.TryFind(scheduledTask2, UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask.IdentityComparer.Instance, out scheduledTask3))
{
if (scheduledTask2.PlannedExecution < scheduledTask3.PlannedExecution)
{
if (scheduledTask3.Callbacks != null)
{
if (scheduledTask2.Callbacks != null)
{
scheduledTask2.Callbacks.AddRange(scheduledTask3.Callbacks);
}
else
{
scheduledTask2.Callbacks = scheduledTask3.Callbacks;
}
}
this.scheduledTasks.Remove(scheduledTask3, UpdateTaskScheduler <TTaskKey, TCallbackArg> .ScheduledTask.IdentityComparer.Instance);
this.scheduledTasks.Enqueue(scheduledTask2);
if (this.log.IsInfoEnabled)
{
this.log.InfoFormat("Task {0} was rescheduled from {1} to {2}", scheduledTask2, scheduledTask3.PlannedExecution, scheduledTask2.PlannedExecution);
}
Monitor.PulseAll(this.syncLock);
}
else
{
if (scheduledTask2.Callbacks != null)
{
if (scheduledTask3.Callbacks != null)
{
scheduledTask3.Callbacks.AddRange(scheduledTask2.Callbacks);
}
else
{
scheduledTask3.Callbacks = scheduledTask2.Callbacks;
}
}
if (this.log.IsInfoEnabled)
{
this.log.InfoFormat("Task {0} has been scheduled already at {1}, requested time {2}", scheduledTask2, scheduledTask3.PlannedExecution, scheduledTask2.PlannedExecution);
}
}
}
else
{
this.scheduledTasks.Enqueue(scheduledTask2);
if (this.log.IsInfoEnabled)
{
this.log.InfoFormat("Task {0} has been scheduled for {1}", scheduledTask2, scheduledTask2.PlannedExecution);
}
Monitor.PulseAll(this.syncLock);
}
}
if (this.log.IsDebugEnabled)
{
this.log.DebugFormat("RequestUpdate for Task {0} - Leave", taskKey);
}
}