private void AddRequest(CallbackRequest request) { lock (this.SyncRoot) { m_pendingRequests.AddLast(request); } }
private void RemoveRequest(CallbackRequest request) { lock (this.SyncRoot) { m_pendingRequests.Remove(request); } // We need to clean up the request. Since this is simple task, we can do it without sequence. AsyncTask cleanupAction = new AsyncTask(this.CleanupRequest, request); cleanupAction.StartTask(); }
private void ShutdownUserEndpoint(AsyncTask task, object state) { CallbackRequest callbackRequest = (CallbackRequest)state; AsyncTask proxyTask = new AsyncTask(m_appFrontEnd.RelaseUserEndpoint, callbackRequest.MyUserEndpoint); proxyTask.TaskCompleted += delegate(object sender, AsyncTaskCompletedEventArgs e) { task.Complete(e.ActionResult.Exception); }; proxyTask.StartTask(); }
private void InitiateCallback(CallbackRequest request) { lock (this.SyncRoot) { if (this.IsTerminatingTerminated) { return; } this.RemoveRequest(request); } //Exit the lock to avoid deadlocks. m_appFrontEnd.InitiateCallback(request.Customer, request.TargetUri, request.TargetDispalyName); }
private void StartupUserEndpoint(AsyncTask task, object state) { CallbackRequest callbackRequest = (CallbackRequest)state; AsyncTask proxyTask = new AsyncTask(m_appFrontEnd.CreateOrGetUserEndpoint, callbackRequest.Customer.UserUri); proxyTask.TaskCompleted += delegate(object sender, AsyncTaskCompletedEventArgs e) { UserEndpointCreationActionResult result = proxyTask.TaskResult as UserEndpointCreationActionResult; if (result != null) { callbackRequest.MyUserEndpoint = result.MyUserEndpoint; } task.Complete(e.ActionResult.Exception); }; proxyTask.StartTask(); }
/// <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(); }); }
private void ShutdownPresenceView(AsyncTask task, object state) { task.DoOneStep( delegate() { CallbackRequest callbackRequest = (CallbackRequest)state; var presenceView = callbackRequest.PresenceView; presenceView.PresenceNotificationReceived -= this.PresenceView_NotificationReceived; presenceView.SubscriptionStateChanged -= this.PresenceView_SubscriptionStateChanged; presenceView.BeginTerminate( delegate(IAsyncResult ar) { task.DoFinalStep( delegate() { presenceView.EndTerminate(ar); }); }, null); }); }
private void StartupPresenceView(AsyncTask task, object state) { task.DoFinalStep( delegate() { CallbackRequest callbackRequest = (CallbackRequest)state; var viewSettings = new RemotePresenceViewSettings(); viewSettings.SubscriptionMode = RemotePresenceViewSubscriptionMode.Persistent; var presenceView = new RemotePresenceView(callbackRequest.CutomerEndpoint, viewSettings); presenceView.ApplicationContext = callbackRequest; var target = new RemotePresentitySubscriptionTarget(callbackRequest.TargetUri); presenceView.PresenceNotificationReceived += this.PresenceView_NotificationReceived; presenceView.SubscriptionStateChanged += this.PresenceView_SubscriptionStateChanged; callbackRequest.PresenceView = presenceView; presenceView.StartSubscribingToPresentities( new RemotePresentitySubscriptionTarget[] { target }); }); }
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; } }
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(); }