public async Task ObserverTest_Unsubscribe() { TestInitialize(); ISimpleObserverableGrain grain = GetGrain(); this.observer1 = new SimpleGrainObserver(null, null, this.Logger); ISimpleGrainObserver reference = await this.GrainFactory.CreateObjectReference <ISimpleGrainObserver>(observer1); try { await grain.Unsubscribe(reference); await this.GrainFactory.DeleteObjectReference <ISimpleGrainObserver>(reference); } catch (TimeoutException) { throw; } catch (Exception exc) { Exception baseException = exc.GetBaseException(); if (!(baseException is OrleansException)) { Assert.True(false); } } }
public async Task ObserverTest_DoubleSubscriptionDifferentReferences() { TestInitialize(); var result = new AsyncResultHandle(); ISimpleObserverableGrain grain = GetGrain(); this.observer1 = new SimpleGrainObserver(this.ObserverTest_DoubleSubscriptionDifferentReferences_Callback, result, this.Logger); ISimpleGrainObserver reference1 = await this.GrainFactory.CreateObjectReference <ISimpleGrainObserver>(observer1); this.observer2 = new SimpleGrainObserver(this.ObserverTest_DoubleSubscriptionDifferentReferences_Callback, result, this.Logger); ISimpleGrainObserver reference2 = await this.GrainFactory.CreateObjectReference <ISimpleGrainObserver>(observer2); await grain.Subscribe(reference1); await grain.Subscribe(reference2); grain.SetA(6).Ignore(); Assert.True(await result.WaitForFinished(timeout), string.Format("Should not timeout waiting {0} for SetA", timeout)); await this.GrainFactory.DeleteObjectReference <ISimpleGrainObserver>(reference1); await this.GrainFactory.DeleteObjectReference <ISimpleGrainObserver>(reference2); }
public async Task ObserverTest_Unsubscribe() { ISimpleObserverableGrain grain = GetGrain(); this.observer1 = new SimpleGrainObserver(null, null); ISimpleGrainObserver reference = await SimpleGrainObserverFactory.CreateObjectReference(this.observer1); try { bool ok = grain.Unsubscribe(reference).Wait(timeout); if (!ok) { throw new TimeoutException(); } await SimpleGrainObserverFactory.DeleteObjectReference(reference); } catch (TimeoutException) { throw; } catch (Exception exc) { Exception baseException = exc.GetBaseException(); if (!(baseException is OrleansException)) { Assert.Fail("Unexpected exception type {0}", baseException); } } }
public async Task <bool> NotifyOtherGrain(IOneWayGrain otherGrain, ISimpleGrainObserver observer) { var task = otherGrain.Notify(observer); var completedSynchronously = task.Status == TaskStatus.RanToCompletion; await task; return(completedSynchronously); }
public async Task ClientInvokeCallback_GrainObserver() { TestClientInvokeCallback callback = new TestClientInvokeCallback(Guid.Empty); GrainClient.ClientInvokeCallback = callback.OnInvoke; RequestContextGrainObserver observer = new RequestContextGrainObserver(null, null); // CreateObjectReference will result in system target call to IClientObserverRegistrar. // We want to make sure this does not invoke ClientInvokeCallback. ISimpleGrainObserver reference = await GrainClient.GrainFactory.CreateObjectReference<ISimpleGrainObserver>(observer); GC.KeepAlive(observer); Assert.AreEqual(0, callback.TotalCalls, "Number of callbacks"); }
public async Task ObserverTest_SubscriberMustBeGrainReference() { var result = new AsyncResultHandle(); ISimpleObserverableGrain grain = GetGrain(); observer1 = new SimpleGrainObserver(ObserverTest_SimpleNotification_Callback, result); ISimpleGrainObserver reference = observer1; // Should be: GrainFactory.CreateObjectReference<ISimpleGrainObserver>(obj); await grain.Subscribe(reference); // Not reached }
public void ObserverTest_SubscriberMustBeGrainReference() { ResultHandle result = new ResultHandle(); ISimpleObserverableGrain grain = GetGrain(); this.observer1 = new SimpleGrainObserver(ObserverTest_SimpleNotification_Callback, result); ISimpleGrainObserver reference = this.observer1; // Should be: SimpleGrainObserverFactory.CreateObjectReference(obj); grain.Subscribe(reference).Wait(); // Not reached }
public async Task ObserverTest_SubscriberMustBeGrainReference() { TestInitialize(); await Xunit.Assert.ThrowsAsync(typeof(NotSupportedException), async() => { var result = new AsyncResultHandle(); ISimpleObserverableGrain grain = GetGrain(); observer1 = new SimpleGrainObserver(ObserverTest_SimpleNotification_Callback, result); ISimpleGrainObserver reference = observer1; // Should be: GrainFactory.CreateObjectReference<ISimpleGrainObserver>(obj); await grain.Subscribe(reference); // Not reached }); }
public async Task ObserverTest_SubscriberMustBeGrainReference() { TestInitialize(); await Assert.ThrowsAsync <NotSupportedException>(async() => { var result = new AsyncResultHandle(); ISimpleObserverableGrain grain = this.GetGrain(); this.observer1 = new SimpleGrainObserver(this.ObserverTest_SimpleNotification_Callback, result, this.Logger); ISimpleGrainObserver reference = this.observer1; // Should be: this.GrainFactory.CreateObjectReference<ISimpleGrainObserver>(obj); await grain.Subscribe(reference); // Not reached }); }
public async Task ObserverTest_SimpleNotification() { ResultHandle result = new ResultHandle(); ISimpleObserverableGrain grain = GetGrain(); this.observer1 = new SimpleGrainObserver(ObserverTest_SimpleNotification_Callback, result); ISimpleGrainObserver reference = await SimpleGrainObserverFactory.CreateObjectReference(this.observer1); grain.Subscribe(reference).Wait(); grain.SetA(3).Wait(); grain.SetB(2).Wait(); Assert.IsTrue(result.WaitForFinished(timeout), "Should not timeout waiting {0} for {1}", timeout, "SetB"); await SimpleGrainObserverFactory.DeleteObjectReference(reference); }
public async Task ObserverTest_DeleteObject() { TestInitialize(); var result = new AsyncResultHandle(); ISimpleObserverableGrain grain = GetGrain(); this.observer1 = new SimpleGrainObserver(this.ObserverTest_DeleteObject_Callback, result, this.Logger); ISimpleGrainObserver reference = this.GrainFactory.CreateObjectReference <ISimpleGrainObserver>(observer1); await grain.Subscribe(reference); await grain.SetA(5); Assert.True(await result.WaitForContinue(timeout), $"Should not timeout waiting {timeout} for SetA"); this.GrainFactory.DeleteObjectReference <ISimpleGrainObserver>(reference); await grain.SetB(3); Assert.False(await result.WaitForFinished(timeout), $"Should timeout waiting {timeout} for SetB"); }
public async Task ObserverTest_SimpleNotification_GeneratedFactory() { var result = new AsyncResultHandle(); ISimpleObserverableGrain grain = GetGrain(); observer1 = new SimpleGrainObserver(ObserverTest_SimpleNotification_Callback, result); ISimpleGrainObserver reference = await GrainFactory.CreateObjectReference <ISimpleGrainObserver>(observer1); await grain.Subscribe(reference); await grain.SetA(3); await grain.SetB(2); Assert.IsTrue(await result.WaitForFinished(timeout), "Should not timeout waiting {0} for {1}", timeout, "SetB"); await GrainFactory.DeleteObjectReference <ISimpleGrainObserver>(reference); }
public async Task ObserverTest_SimpleNotification_GeneratedFactory() { TestInitialize(); var result = new AsyncResultHandle(); ISimpleObserverableGrain grain = GetGrain(); this.observer1 = new SimpleGrainObserver(this.ObserverTest_SimpleNotification_Callback, result, this.Logger); ISimpleGrainObserver reference = this.GrainFactory.CreateObjectReference <ISimpleGrainObserver>(observer1); await grain.Subscribe(reference); await grain.SetA(3); await grain.SetB(2); Assert.True(await result.WaitForFinished(timeout)); this.GrainFactory.DeleteObjectReference <ISimpleGrainObserver>(reference); }
public async Task ObserverTest_DeleteObject() { var result = new AsyncResultHandle(); ISimpleObserverableGrain grain = GetGrain(); this.observer1 = new SimpleGrainObserver(ObserverTest_DeleteObject_Callback, result); ISimpleGrainObserver reference = await GrainFactory.CreateObjectReference <ISimpleGrainObserver>(this.observer1); await grain.Subscribe(reference); await grain.SetA(5); Assert.IsTrue(await result.WaitForContinue(timeout), "Should not timeout waiting {0} for {1}", timeout, "SetA"); await GrainFactory.DeleteObjectReference <ISimpleGrainObserver>(reference); await grain.SetB(3); Assert.IsFalse(await result.WaitForFinished(timeout), "Should timeout waiting {0} for {1}", timeout, "SetB"); }
public async Task ObserverTest_DoubleSubscriptionSameReference() { ResultHandle result = new ResultHandle(); ISimpleObserverableGrain grain = GetGrain(); this.observer1 = new SimpleGrainObserver(ObserverTest_DoubleSubscriptionSameReference_Callback, result); ISimpleGrainObserver reference = await SimpleGrainObserverFactory.CreateObjectReference(this.observer1); grain.Subscribe(reference).Wait(); grain.SetA(1).Wait(); // Use grain try { bool ok = grain.Subscribe(reference).Wait(timeout); if (!ok) { throw new TimeoutException(); } } catch (TimeoutException) { throw; } catch (Exception exc) { Exception baseException = exc.GetBaseException(); Console.WriteLine("Received exception: {0}", baseException); Assert.IsInstanceOfType(baseException, typeof(OrleansException)); if (!baseException.Message.StartsWith("Cannot subscribe already subscribed observer")) { Assert.Fail("Unexpected exception message: " + baseException); } } grain.SetA(2).Wait(); // Use grain Assert.IsFalse(result.WaitForFinished(timeout), "Should timeout waiting {0} for {1}", timeout, "SetA(2)"); await SimpleGrainObserverFactory.DeleteObjectReference(reference); }
public async Task ObserverTest_DoubleSubscriptionSameReference() { TestInitialize(); var result = new AsyncResultHandle(); ISimpleObserverableGrain grain = GetGrain(); this.observer1 = new SimpleGrainObserver(this.ObserverTest_DoubleSubscriptionSameReference_Callback, result, this.Logger); ISimpleGrainObserver reference = await this.GrainFactory.CreateObjectReference <ISimpleGrainObserver>(observer1); await grain.Subscribe(reference); await grain.SetA(1); // Use grain try { await grain.Subscribe(reference); } catch (TimeoutException) { throw; } catch (Exception exc) { Exception baseException = exc.GetBaseException(); this.Logger.Info("Received exception: {0}", baseException); Assert.IsAssignableFrom <OrleansException>(baseException); if (!baseException.Message.StartsWith("Cannot subscribe already subscribed observer")) { Assert.True(false, "Unexpected exception message: " + baseException); } } await grain.SetA(2); // Use grain Assert.False(await result.WaitForFinished(timeout), string.Format("Should timeout waiting {0} for SetA(2)", timeout)); await this.GrainFactory.DeleteObjectReference <ISimpleGrainObserver>(reference); }
public async Task ObserverTest_DoubleSubscriptionDifferentReferences() { ResultHandle result = new ResultHandle(); ISimpleObserverableGrain grain = GetGrain(); this.observer1 = new SimpleGrainObserver(ObserverTest_DoubleSubscriptionDifferentReferences_Callback, result); ISimpleGrainObserver reference1 = await SimpleGrainObserverFactory.CreateObjectReference(this.observer1); this.observer2 = new SimpleGrainObserver(ObserverTest_DoubleSubscriptionDifferentReferences_Callback, result); ISimpleGrainObserver reference2 = await SimpleGrainObserverFactory.CreateObjectReference(this.observer2); grain.Subscribe(reference1).Wait(); grain.Subscribe(reference2).Wait(); grain.SetA(6).Ignore(); Assert.IsTrue(result.WaitForFinished(timeout), "Should not timeout waiting {0} for {1}", timeout, "SetA"); await SimpleGrainObserverFactory.DeleteObjectReference(reference1); await SimpleGrainObserverFactory.DeleteObjectReference(reference2); }
public async Task ObserverTest_DoubleSubscriptionSameReference() { TestInitialize(); var result = new AsyncResultHandle(); ISimpleObserverableGrain grain = GetGrain(); observer1 = new SimpleGrainObserver(ObserverTest_DoubleSubscriptionSameReference_Callback, result); ISimpleGrainObserver reference = await GrainFactory.CreateObjectReference <ISimpleGrainObserver>(observer1); await grain.Subscribe(reference); await grain.SetA(1); // Use grain try { await grain.Subscribe(reference); } catch (TimeoutException) { throw; } catch (Exception exc) { Exception baseException = exc.GetBaseException(); logger.Info("Received exception: {0}", baseException); Assert.IsInstanceOfType(baseException, typeof(OrleansException)); if (!baseException.Message.StartsWith("Cannot subscribe already subscribed observer")) { Assert.Fail("Unexpected exception message: " + baseException); } } await grain.SetA(2); // Use grain Assert.IsFalse(await result.WaitForFinished(timeout), "Should timeout waiting {0} for {1}", timeout, "SetA(2)"); await GrainFactory.DeleteObjectReference <ISimpleGrainObserver>(reference); }
public async Task ObserverTest_SubscribeUnsubscribe() { TestInitialize(); var result = new AsyncResultHandle(); ISimpleObserverableGrain grain = GetGrain(); observer1 = new SimpleGrainObserver(ObserverTest_SubscribeUnsubscribe_Callback, result); ISimpleGrainObserver reference = await GrainFactory.CreateObjectReference <ISimpleGrainObserver>(observer1); await grain.Subscribe(reference); await grain.SetA(5); Assert.True(await result.WaitForContinue(timeout), string.Format("Should not timeout waiting {0} for SetA", timeout)); await grain.Unsubscribe(reference); await grain.SetB(3); Assert.False(await result.WaitForFinished(timeout), string.Format("Should timeout waiting {0} for SetB", timeout)); await GrainFactory.DeleteObjectReference <ISimpleGrainObserver>(reference); }
public Task Unsubscribe(ISimpleGrainObserver observer) { Observers.Unsubscribe(observer); return(TaskDone.Done); }
public Task Unsubscribe(ISimpleGrainObserver observer) { Observers.Unsubscribe(observer); return(Task.CompletedTask); }
public Task Subscribe(ISimpleGrainObserver observer) { State.Observers.Subscribe(observer); return(TaskDone.Done); }
public Task Subscribe(ISimpleGrainObserver observer) { this.Observer = observer; return(TaskDone.Done); }
public Task Subscribe(ISimpleGrainObserver observer) { State.Observers.Subscribe(observer); return(Task.CompletedTask); }
public Task Subscribe(ISimpleGrainObserver observer) { this.Observer = observer; return TaskDone.Done; }
public Task Subscribe(ISimpleGrainObserver observer) { this.Observer = observer; return(Task.CompletedTask); }
public ValueTask NotifyValueTask(ISimpleGrainObserver observer) { this.count++; observer.StateChanged(this.count - 1, this.count); return(default);
public Task Notify(ISimpleGrainObserver observer) { this.count++; observer.StateChanged(this.count - 1, this.count); return(Task.CompletedTask); }
public Task Unsubscribe(ISimpleGrainObserver observer) { Observers.Unsubscribe(observer); return TaskDone.Done; }