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 StartupCore()
{
AsyncTaskSequenceSerial startupActions = new AsyncTaskSequenceSerial(this);
startupActions.Name = "StartupHub";
startupActions.SuccessCompletionReportHandlerDelegate = this.CompleteStartup;
startupActions.FailureCompletionReportHandlerDelegate = this.CompleteStartup;
startupActions.AddTask(new AsyncTask(this.EstablishServiceChannel));
startupActions.Start();
}
protected override void StartupCore()
{
AsyncTaskSequenceSerial sequence = new AsyncTaskSequenceSerial(this);
sequence.FailureCompletionReportHandlerDelegate = this.CompleteStartup;
sequence.SuccessCompletionReportHandlerDelegate = this.CompleteStartup;
sequence.AddTask(new AsyncTask(this.StartupScheduleConference));
sequence.AddTask(new AsyncTask(this.StartupJoinConference));
sequence.AddTask(new AsyncTask(this.StartupPrimaryChannel));
sequence.Start();
}
protected override void ShutdownCore()
{
AsyncTaskSequenceSerial sequence = new AsyncTaskSequenceSerial(this);
sequence.Name = "CustomerContactMangerShutdown";
sequence.SuccessCompletionReportHandlerDelegate = this.CompleteShutdown;
sequence.FailureCompletionReportHandlerDelegate = this.CompleteShutdown;
sequence.AddTask(new AsyncTask(this.ShutdownPresenceView));
sequence.AddTask(new AsyncTask(this.ShutdownContactSubscription));
sequence.AddTask(new AsyncTask(this.ShutdownUserEndpoint));
sequence.Start();
}
protected override void StartupCore()
{
AsyncTaskSequenceSerial sequence = new AsyncTaskSequenceSerial(this);
sequence.Name = "StartupAppFrontEnd";
sequence.SuccessCompletionReportHandlerDelegate = this.CompleteStartup;
sequence.FailureCompletionReportHandlerDelegate = this.CompleteStartup;
sequence.AddTask(new AsyncTask(this.StartupCallbackManager));
sequence.AddTask(new AsyncTask(this.StartupMusicProvider));
sequence.AddTask(new AsyncTask(this.StartupEndpoint));
sequence.Start();
}
private void StartupCustomerSession(CustomerSession customerSession)
{
AsyncTaskSequenceSerial sequence = new AsyncTaskSequenceSerial(this);
sequence.AddTask(new AsyncTask(this.StartupCustomerSession, customerSession));
// There is nothing to do when the start completes successfully for the customer session.
sequence.FailureCompletionReportHandlerDelegate =
delegate(Exception excception)
{
this.RemoveSession(customerSession);
};
sequence.Start();
}
protected override void StartupCore()
{
AsyncTaskSequenceSerial sequence = new AsyncTaskSequenceSerial(this);
sequence.Name = "CustomerContactMangerStartup";
sequence.SuccessCompletionReportHandlerDelegate = this.CompleteStartup;
sequence.FailureCompletionReportHandlerDelegate = this.CompleteStartup;
sequence.AddTask(new AsyncTask(this.StartupUserEndpoint));
sequence.AddTask(new AsyncTask(this.StartupContactSubscription));
// Create presence view for the contacts. This sample does not handle dynamically added/removed contact's presence.
sequence.AddTask(new AsyncTask(this.StartPresenceView));
sequence.AddTask(new AsyncTask(this.StartWaitForPresence));
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();
}
protected override void ShutdownCore()
{
if (m_serviceChannelCall != null)
{
AsyncTaskSequence shutdownSequence = new AsyncTaskSequenceSerial(this);
shutdownSequence.Name = "ShutdownHub";
shutdownSequence.FailureCompletionReportHandlerDelegate = this.CompleteShutdown;
shutdownSequence.SuccessCompletionReportHandlerDelegate = this.CompleteShutdown;
shutdownSequence.AddTask(new AsyncTask(this.TerminateServiceChannelCall));
shutdownSequence.Start();
}
else
{
this.CompleteShutdown(null);
}
}
protected override void StartupCore()
{
if (!ApplicationConfiguration.LoadConfiguration())
{
this.CompleteStartup(new InvalidOperationException("Cannot load configuration"));
}
AsyncTaskSequenceSerial sequence = new AsyncTaskSequenceSerial(this);
sequence.Name = "StartupAppPlatform";
sequence.AddTask(new AsyncTask(this.StartupPlatform));
//sequence.AddTask(new AsyncTask(this.StartWorkflowRuntime));
sequence.AddTask(new AsyncTask(this.StartupReverseLookup));
sequence.SuccessCompletionReportHandlerDelegate = this.CompleteStartup;
sequence.FailureCompletionReportHandlerDelegate = this.CompleteStartup;
sequence.Start();
}
/// <summary>
/// Clean up a request given as argument in the task.
/// </summary>
/// <param name="task">The task for this operation.</param>
private void CleanupRequest(AsyncTask task, object state)
{
task.DoOneStep(
delegate()
{
CallbackRequest callbackRequest = (CallbackRequest)state;
// We need to terminate view and then endppoint. Endpoint termiantion alone is enough. We will do both here for sample usage.
AsyncTaskSequenceSerial sequence = new AsyncTaskSequenceSerial(this);
sequence.Name = "CleanupCallbackRequest";
sequence.FailureCompletionReportHandlerDelegate = delegate(Exception exception) { task.Complete(null); };
sequence.SuccessCompletionReportHandlerDelegate = delegate(Exception exception) { task.Complete(exception); };
AsyncTask viewShutdownAction = new AsyncTask(this.ShutdownPresenceView, callbackRequest);
sequence.AddTask(viewShutdownAction);
AsyncTask endpointShutdownAction = new AsyncTask(this.ShutdownUserEndpoint, callbackRequest);
sequence.AddTask(endpointShutdownAction);
sequence.Start();
});
}
public void AddCallback(
Customer requestingCustomer,
string callbackTargetUri,
string callbackTargetDisplayName)
{
var request = new CallbackRequest(
requestingCustomer,
callbackTargetUri,
callbackTargetDisplayName);
System.Threading.ManualResetEvent callbackSetupWaitHandle = new System.Threading.ManualResetEvent(false);
AsyncTaskSequenceSerial sequence = new AsyncTaskSequenceSerial(this);
sequence.Name = "AddCallback";
sequence.SuccessCompletionReportHandlerDelegate =
delegate(Exception exception) { callbackSetupWaitHandle.Set(); };
sequence.FailureCompletionReportHandlerDelegate =
delegate(Exception exception) { request.Exception = exception; callbackSetupWaitHandle.Set(); };
lock (this.SyncRoot)
{
if (this.IsTerminatingTerminated)
{
throw new InvalidOperationException("AddCallback called when CallbackManager is terminating/terminated.");
}
this.AddRequest(request);
AsyncTask startEndpointTask = new AsyncTask(this.StartupUserEndpoint, request);
sequence.AddTask(startEndpointTask);
AsyncTask startPresenceView = new AsyncTask(this.StartupPresenceView, request);
sequence.AddTask(startPresenceView);
}
sequence.Start();
callbackSetupWaitHandle.WaitOne();
if (request.Exception != null)
{
this.RemoveRequest(request);
throw request.Exception;
}
}
