/// <summary> /// Adds a result. This is called by the receive thread. It will iterate over all registered /// Wait and Callbacks to find a matching one. When a match is found, it will either trigger the Wait, /// or call the callback. /// </summary> /// <param name="newReturnedObject"> /// The object returned from the server /// </param> public void AddResult(ReturnedObject newReturnedObject) { var callbacksToRemove = new List<RegisteredResultCallback>(); var waitsToIterate = this.waits.ToArray(); var callbacksToIterate = this.callbacks.ToArray(); foreach (var wait in waitsToIterate) { wait.Value.Filter.HandleReturnObject(newReturnedObject); if (wait.Value.Filter.IsCompleted()) { wait.Value.WaitEvent.Set(); wait.Key.SetTriggered(); } } foreach (var callback in callbacksToIterate) { callback.Key.Filter.HandleReturnObject(newReturnedObject); if (callback.Key.Filter.IsCompleted()) { callback.Key.Callback(newReturnedObject); callbacksToRemove.Add(callback.Key); } } foreach (var removedCallback in callbacksToRemove) { int outInt; this.callbacks.TryRemove(removedCallback, out outInt); } }
/// <summary> /// The handle return object. /// </summary> /// <param name="returnedMessage"> /// The returned object. /// </param> internal override void HandleReturnObject(ReturnedObject returnedMessage) { if (returnedMessage.MessageType == "nosub") { var noSubObject = returnedMessage.ParsedObject.ToObject<NoSubscribe>(); if (noSubObject.ID == this.subscriptionId) { this.nosubCalled = true; this.returnedObject = returnedMessage; } } }
/// <summary> /// Processes the reply message /// </summary> /// <param name="client"> /// The connection to send replies to the server /// </param> /// <param name="collectionManager"> /// The CollectionManager /// </param> /// <param name="resultHandler"> /// The ResultHandler /// </param> /// <param name="message"> /// The message to process /// </param> /// <returns> /// Task to process the message /// </returns> public Task HandleMessage( IDdpConnectionSender client, ICollectionManager collectionManager, IResultHandler resultHandler, string message) { JObject parsedObject = JObject.Parse(message); var result = new ReturnedObject((string)parsedObject["msg"], parsedObject, message); resultHandler.AddResult(result); return Task.FromResult(true); }
public void ConnectedResultFilter_HandleReturnObject_UnknownMessage() { var connectedResultFilter = new ConnectedResultFilter(); var ping = new Ping(); var returnedObject = new ReturnedObject("ping", JObject.FromObject(ping), JsonConvert.SerializeObject(ping)); connectedResultFilter.HandleReturnObject(returnedObject); Assert.IsFalse(connectedResultFilter.IsCompleted()); Assert.IsNull(connectedResultFilter.GetReturnedObject()); }
public void ConnectedResultFilter_HandleReturnObject_FailedMessage() { var connectedResultFilter = new ConnectedResultFilter(); var failed = new Failed() {Version = "1"}; var returnedObject = new ReturnedObject("failed", JObject.FromObject(failed), JsonConvert.SerializeObject(failed)); connectedResultFilter.HandleReturnObject(returnedObject); Assert.IsTrue(connectedResultFilter.IsCompleted()); Assert.AreEqual(returnedObject, connectedResultFilter.GetReturnedObject()); }
public void ResultHandler_WaitForResult_WaitHandler() { var resultHandler = new ResultHandler(); var waitHandle = resultHandler.RegisterWaitHandler(ResultFilterFactory.CreateConnectResultFilter()); var waitTask = resultHandler.WaitForResult(waitHandle); var connected = new Connected() {Session = "TestSession"}; var returnedObject = new ReturnedObject(connected.MessageType, JObject.FromObject(connected), JsonConvert.SerializeObject(connected)); resultHandler.AddResult(returnedObject); waitTask.Wait(); Assert.AreEqual(returnedObject, waitTask.Result); }
/// <summary> /// Handles a message received from the server /// </summary> /// <param name="messageReturned"> /// The returned object. /// </param> internal override void HandleReturnObject(ReturnedObject messageReturned) { if (messageReturned.MessageType == "result" && ((string)messageReturned.ParsedObject["id"]) == this.methodId) { this.resultCalled = true; this.returnedObject = messageReturned; } else if (messageReturned.MessageType == "updated") { var updatedObject = messageReturned.ParsedObject.ToObject<Updated>(); if (updatedObject.Methods.Contains(this.methodId)) { this.updatedCalled = true; } } }
public void ResultHandler_RegisterResultCallback_CallbackCalled() { var resultHandler = new ResultHandler(); bool callbackCalled = false; var connected = new Connected() { Session = "TestSession" }; var returnedObject = new ReturnedObject(connected.MessageType, JObject.FromObject(connected), JsonConvert.SerializeObject(connected)); resultHandler.RegisterResultCallback(ResultFilterFactory.CreateConnectResultFilter(), o => { callbackCalled = true; Assert.AreEqual(returnedObject, o); }); resultHandler.AddResult(returnedObject); Assert.IsTrue(callbackCalled); }
public void ResultHandler_WaitForResult_ReactivateWaitHandle() { var resultHandler = new ResultHandler(); var waitHandle = resultHandler.RegisterWaitHandler(ResultFilterFactory.CreateConnectResultFilter()); var waitTask = resultHandler.WaitForResult(waitHandle); var connected = new Connected() { Session = "TestSession" }; var returnedObject = new ReturnedObject(connected.MessageType, JObject.FromObject(connected), JsonConvert.SerializeObject(connected)); resultHandler.AddResult(returnedObject); waitTask.Wait(); Assert.AreEqual(returnedObject, waitTask.Result); PCLTesting.ExceptionAssert.Throws<InvalidOperationException>(() => resultHandler.WaitForResult(waitHandle)); }
public void MethodCallResultFilter_HandleReturnObject_NotHandledID() { var resultFilter = new MethodCallResultFilter("11"); var message = new Result() { Id = "10" }; var updated = new Updated() { Methods = new[] { "10" } }; var resultReturnedObject = new ReturnedObject("result", JObject.FromObject(message), JsonConvert.SerializeObject(message)); var updatedReturnedObject = new ReturnedObject("updated", JObject.FromObject(updated), JsonConvert.SerializeObject(updated)); resultFilter.HandleReturnObject(updatedReturnedObject); Assert.IsFalse(resultFilter.IsCompleted()); resultFilter.HandleReturnObject(resultReturnedObject); Assert.IsFalse(resultFilter.IsCompleted()); Assert.IsNull(resultFilter.GetReturnedObject()); }
/// <summary> /// Handles an object returned by the server /// </summary> /// <param name="messageReturned"> /// The returned object. /// </param> internal override void HandleReturnObject(ReturnedObject messageReturned) { if (messageReturned.MessageType == "ready") { var readyObject = messageReturned.ParsedObject.ToObject<Ready>(); if (readyObject.SubscriptionsReady.Contains(this.subscriptionId)) { this.readyCalled = true; this.returnedObject = messageReturned; } } if (messageReturned.MessageType == "nosub") { var noSubObject = messageReturned.ParsedObject.ToObject<NoSubscribe>(); if (noSubObject.ID == this.subscriptionId) { this.nosubCalled = true; this.returnedObject = messageReturned; } } }