protected override void ShutdownCore()
{
AsyncTaskSequenceSerial sequence = new AsyncTaskSequenceSerial(this);
sequence.Name = "ShutdownAppPlatform";
sequence.AddTask(new AsyncTask(this.ShutdownReverseLookup, null));
//sequence.AddTask(new AsyncTask(this.ShutdownWorkflowRuntime, null));
// Shutdown all front ends in parallel.
AsyncTaskSequenceParallel shutdownAppFrontEndsSequence = new AsyncTaskSequenceParallel(this);
AsyncTask shutdownAppFrontEndsAction = new AsyncTask(AsyncTask.SequenceStartingMethod, shutdownAppFrontEndsSequence);
sequence.AddTask(shutdownAppFrontEndsAction);
shutdownAppFrontEndsSequence.Name = "ShutdownAppFrontEnds";
shutdownAppFrontEndsSequence.FailureCompletionReportHandlerDelegate = shutdownAppFrontEndsAction.Complete;
shutdownAppFrontEndsSequence.SuccessCompletionReportHandlerDelegate = shutdownAppFrontEndsAction.Complete;
// Populate the parallel sequence with individual customer sessions to terminate.
lock (this.SyncRoot)
{
foreach (AppFrontEnd fe in m_frontEnds)
{
AsyncTask task = new AsyncTask(this.ShutdownFrontEnd, fe);
shutdownAppFrontEndsSequence.AddTask(task);
}
}
sequence.AddTask(new AsyncTask(this.ShutdownCollaborationPlatform));
sequence.SuccessCompletionReportHandlerDelegate = this.CompleteShutdown;
sequence.FailureCompletionReportHandlerDelegate = this.CompleteShutdown;
sequence.Start();
}
protected override void ShutdownCore()
{
m_endpoint.UnregisterForIncomingCall <AudioVideoCall>(this.ReceiveIncomingAvCall);
m_endpoint.UnregisterForIncomingCall <InstantMessagingCall>(this.ReceiveIncomingIMCall);
AsyncTaskSequenceSerial sequence = new AsyncTaskSequenceSerial(this);
sequence.Name = "ShutdownAppFrontEnd";
sequence.SuccessCompletionReportHandlerDelegate = this.CompleteShutdown;
sequence.FailureCompletionReportHandlerDelegate = this.CompleteShutdown;
sequence.AddTask(new AsyncTask(this.ShutdownCallbackManager));
sequence.AddTask(new AsyncTask(this.ShutdownMusicProvider));
// Shutdown customer sessions in parallel.
AsyncTaskSequenceParallel customerSessionsSequence = new AsyncTaskSequenceParallel(this);
AsyncTask shutdownCustomerSessions = new AsyncTask(AsyncTask.SequenceStartingMethod, customerSessionsSequence);
customerSessionsSequence.Name = "ShutdownCustomerSessions";
customerSessionsSequence.FailureCompletionReportHandlerDelegate = shutdownCustomerSessions.Complete;
customerSessionsSequence.SuccessCompletionReportHandlerDelegate = shutdownCustomerSessions.Complete;
// Populate the parallel sequence with individual customer sessions to terminate.
lock (this.SyncRoot)
{
foreach (CustomerSession session in m_customerSessions)
{
AsyncTask task = new AsyncTask(this.ShutdownCustomerSession, session);
customerSessionsSequence.AddTask(task);
}
}
sequence.AddTask(shutdownCustomerSessions);
// Shutdown user endpoint just in case they are still there.
AsyncTaskSequenceParallel userEndpointsShutdownSequence = new AsyncTaskSequenceParallel(this);
AsyncTask shutdownUserEndpoints = new AsyncTask(AsyncTask.SequenceStartingMethod, userEndpointsShutdownSequence);
userEndpointsShutdownSequence.Name = "ShutdownUserEndpoints";
userEndpointsShutdownSequence.FailureCompletionReportHandlerDelegate = shutdownUserEndpoints.Complete;
userEndpointsShutdownSequence.SuccessCompletionReportHandlerDelegate = shutdownUserEndpoints.Complete;
lock (this.SyncRoot)
{
foreach (MyUserEndpoint myUserEndpoint in m_userEndpoints.Values)
{
AsyncTask task = new AsyncTask(this.ShutdownUserEndpoint, myUserEndpoint.UserEndpoint);
userEndpointsShutdownSequence.AddTask(task);
}
}
sequence.AddTask(shutdownUserEndpoints);
sequence.AddTask(new AsyncTask(this.ShutdownEndpoint));
sequence.Start();
}
/// <summary>
/// Shuts down the callback manager. Clean up all pending requests.
/// </summary>
protected override void ShutdownCore()
{
AsyncTaskSequenceParallel requestsToCleanup = new AsyncTaskSequenceParallel(this);
requestsToCleanup.Name = "ShutdownCallbackManager";
requestsToCleanup.SuccessCompletionReportHandlerDelegate = this.CompleteShutdown;
requestsToCleanup.FailureCompletionReportHandlerDelegate = this.CompleteShutdown;
m_cleanupTimer.Stop();
List <CallbackRequest> requestsSnapshot = null;
lock (this.SyncRoot)
{
requestsSnapshot = m_pendingRequests.ToList();
m_pendingRequests.Clear();
}
foreach (CallbackRequest request in requestsSnapshot)
{
AsyncTask cleanupAction = new AsyncTask(this.CleanupRequest, request);
cleanupAction.IsOptional = true; // We don't want one clean up to abort others.
requestsToCleanup.AddTask(cleanupAction);
}
requestsToCleanup.Start();
}
private void CleanupElapsed(object sender, ElapsedEventArgs e)
{
if (this.IsTerminatingTerminated)
{
return;
}
AsyncTaskSequenceParallel requestsToCleanup = new AsyncTaskSequenceParallel(this);
requestsToCleanup.Name = "CleanupStaleRequests";
lock (this.SyncRoot)
{
var cutoff = DateTime.Now.Subtract(m_maxLifeSpanOfRequest);
while (m_pendingRequests.First != null && m_pendingRequests.First.Value.CreationTime < cutoff)
{
CallbackRequest request = m_pendingRequests.First.Value;
m_pendingRequests.RemoveFirst();
AsyncTask cleanupAction = new AsyncTask(this.CleanupRequest, request);
cleanupAction.IsOptional = true;
requestsToCleanup.AddTask(cleanupAction);
}
}
requestsToCleanup.Start();
}
