public void should_receive_errors_using_a_coruoutine()
{
IEnumerable <string> returnWords()
{
yield return("Mario");
yield return("Cioni");
throw new Exception("This should be caught in onError()");
yield return("Gaspare");
yield return("Fu");
yield return("Giulia");
}
var messages = new List <string>();
var observer = new AnonymousObserver <string>(
onNext: w => messages.Add(w),
onError: (e) => messages.Add("*** I got an error! ***"),
onCompleted: () => messages.Add("Done")
);
using (returnWords().Select(w => w.ToLower()).Subscribe(observer))
{
}
messages[0].Should().Be("mario");
messages[1].Should().Be("cioni");
messages[2].Should().Be("*** I got an error! ***");
// messages[3].Should().Be("gaspare");
// messages[4].Should().Be("fu");
// messages[5].Should().Be("giulia");
// messages[6].Should().Be("done");
}
/// <summary>
/// The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation.
/// Pay attention that the the result of the parameter function is Task<IDisposable>.
/// </summary>
public virtual IObservable <TResult> Create <TResult>(Func <IObserver <TResult>, CancellationToken, Task <Action> > subscribeAsync)
{
return(new AnonymousObservable <TResult>(observer =>
{
var subscription = new SingleAssignmentDisposable();
var cancellable = new CancellationDisposable();
var taskObservable = subscribeAsync(observer, cancellable.Token).ToObservable();
///The logic of the first parameter (a stands for an action)
/// if a is not null
/// subscription.Disposable= Disposable.Create(a);
/// else
/// subscription.Disposable=Disposable.Empty
var taskCompletionObserver = new AnonymousObserver <Action>(
a => subscription.Disposable = a != null ? Disposable.Create(a) : Disposable.Empty, observer.OnError, Stubs.Nop);
//
// We don't cancel the subscription below *ever* and want to make sure the returned resource eventually gets disposed.
// Notice because we're using the AnonymousObservable<T> type, we get auto-detach behavior for free.
//
taskObservable.Subscribe(taskCompletionObserver);
return new CompositeDisposable(cancellable, subscription);
}));
}
/// <summary>
/// The function of the code below is:
/// Creates an observable sequence from a specified cancellable asynchronous[异步的] Subscribe method.
/// </summary>
/// <typeparam name="TResult"> The type of the element in the return sequence.</typeparam>
/// <param name="subscribeAsync"> A functions delegate takes 2 parameters and 1 output result.
/// The first parameter is an object that implements interface IObserver.
/// The second parameter is a structure named CancellationToken which propagates notification that operations should be canceled.
/// The result is an instance of Task that represents an asynchronous operation.
/// </param>
public virtual IObservable <TResult> Create <TResult>(Func <IObserver <TResult>, CancellationToken, Task> subscribeAsync)
{
//call constructor AnonymousObservable(Func<IObserver<T>, IDisposable> subscribe)
// The parameter passed into the constructor is a lambda expression.
// observer is input and the codes in {} is a procedure that can produce an IDisposable output result.
return(new AnonymousObservable <TResult>(observer =>
{
// Initializes the System.Threading.CancellationTokenSource.
var cancellable = new CancellationDisposable();
// There we see a new function ToObservable() which returns an observable sequence that signals when the task completes.
// The second parameter means getting the <see cref="T:System.Threading.CancellationToken"/> used by this CancellationDisposable.
var taskObservable = subscribeAsync(observer, cancellable.Token).ToObservable();
// constructor AnonymousObserver : Creates an observer from the specified OnNext, OnError, and OnCompleted actions.
// new structure Unit
// Determines whether the specified Unit values is equal to the current Unit.
var taskCompletionObserver = new AnonymousObserver <Unit>(Stubs <Unit> .Ignore, observer.OnError, observer.OnCompleted);
// Subscribe: Notifies the provider taskObservable that an observer taskCompletionObserver is to receive notifications.
var subscription = taskObservable.Subscribe(taskCompletionObserver);
// Represents a group of disposable resources that are disposed together.
return new CompositeDisposable(cancellable, subscription);
}));
}
public void should_receive_errors()
{
var words = new List <string> {
"Mario", "Cioni", "Di", "Gaspare", "Fu", "Giulia"
}
.Select(w =>
{
if (w == "Di")
{
throw new Exception("This should be caught in onError()");
}
return(w);
});
var messages = new List <string>();
var observer = new AnonymousObserver <string>(
onNext: w => messages.Add(w),
onError: (e) => messages.Add("*** I got an error! ***"),
onCompleted: () => messages.Add("Done")
);
using (words.ToObservable().Select(w => w.ToLower()).Subscribe(observer))
{
}
messages[0].Should().Be("mario");
messages[1].Should().Be("cioni");
messages[2].Should().Be("*** I got an error! ***");
// messages[3].Should().Be("gaspare");
// messages[4].Should().Be("fu");
// messages[5].Should().Be("giulia");
// messages[6].Should().Be("done");
}
/// <summary>
/// Subscribes to changes in the observable.
/// </summary>
/// <param name="observer">The subscriber.</param>
/// <returns>A disposable object. When disposed, the observer will stop receiving events.</returns>
public IDisposable Subscribe(IObserver <T> observer)
{
var disposableObserver = new AnonymousObserver(observer);
this.observers.Add(disposableObserver);
return(disposableObserver);
}
public Oscillator(int sampleRate, Func<double, double> generator)
{
this.sampleRate = sampleRate;
Data = Samples(generator);
Frequency = new AnonymousObserver<double>(SetFrequency);
}
public void TestServiceBusWithEmbeddedBroker()
{
// use the embedded broker
var brokerUri = _broker.FailoverUri;
// set up ServiceBus using fluent interfaces and all current endpoints and pointing at test AMQ broker
IServiceBus serviceBus = ServiceBus.Configure()
.WithActiveMQEndpoints<ITestMessage1>()
.Named("Obvs.TestService")
.UsingQueueFor<TestCommand>().ClientAcknowledge()
.UsingQueueFor<TestCommand2>().ClientAcknowledge()
.UsingQueueFor<IRequest>().AutoAcknowledge()
.ConnectToBroker(brokerUri)
.SerializedAsJson()
.AsClientAndServer()
.PublishLocally()
.OnlyMessagesWithNoEndpoints()
.UsingConsoleLogging()
.Create();
// create threadsafe collection to hold received messages in
ConcurrentBag<IMessage> messages = new ConcurrentBag<IMessage>();
// create some actions that will act as a fake services acting on incoming commands and requests
Action<TestCommand> fakeService1 = command => serviceBus.PublishAsync(new TestEvent {Id = command.Id});
Action<TestRequest> fakeService2 = request => serviceBus.ReplyAsync(request, new TestResponse {Id = request.Id});
AnonymousObserver<IMessage> observer = new AnonymousObserver<IMessage>(messages.Add, Console.WriteLine, () => Console.WriteLine("OnCompleted"));
// subscribe to all messages on the ServiceBus
CompositeDisposable subscriptions = new CompositeDisposable
{
serviceBus.Events.Subscribe(observer),
serviceBus.Commands.Subscribe(observer),
serviceBus.Requests.Subscribe(observer),
serviceBus.Commands.OfType<TestCommand>().Subscribe(fakeService1),
serviceBus.Requests.OfType<TestRequest>().Subscribe(fakeService2)
};
// send some messages
serviceBus.SendAsync(new TestCommand { Id = 123 });
serviceBus.SendAsync(new TestCommand2 { Id = 123 });
serviceBus.SendAsync(new TestCommand3 { Id = 123 });
serviceBus.GetResponses(new TestRequest { Id = 456 }).Subscribe(observer);
// wait some time until we think all messages have been sent and received over AMQ
Thread.Sleep(TimeSpan.FromSeconds(1));
// test we got everything we expected
Assert.That(messages.OfType<TestCommand>().Count() == 1, "TestCommand not received");
Assert.That(messages.OfType<TestCommand2>().Count() == 1, "TestCommand2 not received");
Assert.That(messages.OfType<TestCommand3>().Count() == 1, "TestCommand3 not received");
Assert.That(messages.OfType<TestEvent>().Count() == 1, "TestEvent not received");
Assert.That(messages.OfType<TestRequest>().Count() == 1, "TestRequest not received");
Assert.That(messages.OfType<TestResponse>().Count() == 1, "TestResponse not received");
subscriptions.Dispose();
((IDisposable)serviceBus).Dispose();
// win!
}
public async Task ShouldSendAndReceiveMessagesOverServiceBus()
{
IServiceBus serviceBus = ServiceBus.Configure()
.WithRabbitMQEndpoints <ITestMessage>()
.Named("Obvs.TestService")
.ConnectToBroker("amqp://192.168.99.100:32769") // edit to correspond with 5672 port on local RabbitMQ from DockerHub
.SerializedAsJson()
.AsClientAndServer()
.PublishLocally().AnyMessagesWithNoEndpointClients()
.UsingConsoleLogging()
.Create();
// create threadsafe collection to hold received messages in
var messages = new ConcurrentBag <IMessage>();
// create some actions that will act as a fake services acting on incoming commands and requests
Action <TestCommand> fakeService1 = command => serviceBus.PublishAsync(new TestEvent {
Id = command.Id
});
Action <TestRequest> fakeService2 = request => serviceBus.ReplyAsync(request, new TestResponse {
Id = request.Id
});
var observer = new AnonymousObserver <IMessage>(msg => { messages.Add(msg); Console.WriteLine(msg); }, exception => Console.WriteLine(exception));
// subscribe to all messages on the ServiceBus
var sub1 = serviceBus.Events.Subscribe(observer);
var sub2 = serviceBus.Commands.Subscribe(observer);
var sub3 = serviceBus.Requests.Subscribe(observer);
var sub4 = serviceBus.Commands.OfType <TestCommand>().Subscribe(fakeService1);
var sub5 = serviceBus.Requests.OfType <TestRequest>().Subscribe(fakeService2);
// send some messages
await serviceBus.SendAsync(new TestCommand { Id = 123 });
var sub6 = serviceBus.GetResponses(new TestRequest {
Id = 456
}).Subscribe(observer);
// wait some time until we think all messages have been sent and received from RabbitMQ
await Task.Delay(TimeSpan.FromSeconds(1));
// test we got everything we expected
Assert.That(messages.OfType <TestCommand>().Count() == 1, "TestCommand not received");
Assert.That(messages.OfType <TestEvent>().Count() == 1, "TestEvent not received");
Assert.That(messages.OfType <TestRequest>().Count() == 1, "TestRequest not received");
Assert.That(messages.OfType <TestResponse>().Count() == 1, "TestResponse not received");
// dispose subscriptions
sub1.Dispose();
sub2.Dispose();
sub3.Dispose();
sub4.Dispose();
sub5.Dispose();
sub6.Dispose();
// always call Dispose on serviceBus when exiting process
((IDisposable)serviceBus).Dispose();
}
public MainWindowViewModel()
{
IObserver <string> observer = new AnonymousObserver <string>(s =>
{
Debug.WriteLine("xx" + s);
ReactiveTracer.Add(s);
});
LoggerAdapter.TracerSubject.Subscribe(observer);
}
public async void TestServiceEndpointsOverLocalHostSockets()
{
// set up ServiceBus using fluent interfaces and all current endpoints and pointing at localhost
var serviceBus = ServiceBus.Configure()
.WithNetMqEndpoints <ITestMessage>()
.Named("Obvs.TestNetMqService")
.BindToAddress("tcp://localhost")
.OnPort(5555)
.SerializedAsJson()
.AsClientAndServer()
.UsingConsoleLogging()
.Create();
// create threadsafe collection to hold received messages in
var messages = new ConcurrentBag <IMessage>();
// create some actions that will act as a fake services acting on incoming commands and requests
Action <TestCommand> fakeService1 = command => serviceBus.PublishAsync(new TestEvent {
Id = command.Id
});
Action <TestRequest> fakeService2 = request => serviceBus.ReplyAsync(request, new TestResponse {
Id = request.Id
});
var observer = new AnonymousObserver <IMessage>(msg =>
{
messages.Add(msg);
Console.WriteLine(msg);
}, exception => Console.WriteLine(exception));
// subscribe to all messages on the ServiceBus
serviceBus.Events.Subscribe(observer);
serviceBus.Commands.Subscribe(observer);
serviceBus.Requests.Subscribe(observer);
serviceBus.Commands.OfType <TestCommand>().SubscribeOn(TaskPoolScheduler.Default).Subscribe(fakeService1);
serviceBus.Requests.OfType <TestRequest>().Subscribe(fakeService2);
// send some messages
await serviceBus.SendAsync(new TestCommand { Id = 123 });
serviceBus.GetResponses(new TestRequest {
Id = 456
}).Subscribe(observer);
// wait some time until we think all messages have been sent and received over AMQ
await Task.Delay(TimeSpan.FromSeconds(2));
// test we got everything we expected
Assert.That(messages.OfType <TestCommand>().Count() == 1, "TestCommand not received");
Assert.That(messages.OfType <TestEvent>().Count() == 1, "TestEvent not received");
Assert.That(messages.OfType <TestRequest>().Count() == 1, "TestRequest not received");
Assert.That(messages.OfType <TestResponse>().Count() == 1, "TestResponse not received");
// win!
}
public async void TestServiceBusWithLocalEventStore()
{
var serviceBus = ServiceBus.Configure()
.WithEventStoreSharedConnectionScope("ConnectTo=tcp://admin:[email protected]:1113", config => config
.WithEventStoreEndpoints<ITestMessage1>()
.Named("Obvs.EventStore.Test")
.AppendMessageProperties(message => null)
.FilterReceivedMessages(properties => true)
.UseSharedConnection()
.SerializedAsJson()
.AsClientAndServer())
.UsingConsoleLogging()
.Create();
var fakeService = new AnonymousObserver<ITestMessage1>(msg =>
{
var command = msg as TestCommand;
if (command != null)
{
serviceBus.PublishAsync(new TestEvent {Id = command.Id});
return;
}
var request = msg as TestRequest;
if (request != null)
{
serviceBus.ReplyAsync(request, new TestResponse {Id = request.Id});
}
});
var sub = serviceBus.Commands.OfType<ITestMessage1>()
.Merge(serviceBus.Requests.OfType<ITestMessage1>())
.ObserveOn(Scheduler.Default)
.Subscribe(fakeService);
var receivedEvent = await Observable.Create<TestEvent>(observer =>
{
var disposable = serviceBus.Events
.OfType<TestEvent>()
.ObserveOn(Scheduler.Default)
.Subscribe(observer);
serviceBus.SendAsync(new TestCommand {Id = 123});
return disposable;
}).Take(1);
var receivedResponse = await serviceBus.GetResponse<TestResponse>(new TestRequest {Id = 456});
sub.Dispose();
Assert.That(receivedEvent.Id, Is.EqualTo(123));
Assert.That(receivedResponse.Id, Is.EqualTo(456));
}
private async Task ShouldSendAndReceiveMessagesOverServiceBus(IServiceBus serviceBus)
{
// create threadsafe collection to hold received messages in
var messages = new ConcurrentBag <IMessage>();
// create some actions that will act as a fake services acting on incoming commands and requests
Action <TestCommand> fakeService1 = command => serviceBus.PublishAsync(new TestEvent {
Id = command.Id
});
Action <TestRequest> fakeService2 = request => serviceBus.ReplyAsync(request, new TestResponse {
Id = request.Id
});
var observer = new AnonymousObserver <IMessage>(msg =>
{
messages.Add(msg);
_output.WriteLine(JsonConvert.SerializeObject(msg));
}, exception => _output.WriteLine(exception.ToString()));
// subscribe to all messages on the ServiceBus
var sub1 = serviceBus.Events.Subscribe(observer);
var sub2 = serviceBus.Commands.Subscribe(observer);
var sub3 = serviceBus.Requests.Subscribe(observer);
var sub4 = serviceBus.Commands.OfType <TestCommand>().Subscribe(fakeService1);
var sub5 = serviceBus.Requests.OfType <TestRequest>().Subscribe(fakeService2);
// send some messages
await serviceBus.SendAsync(new TestCommand { Id = 123 });
var sub6 = serviceBus.GetResponses(new TestRequest {
Id = 456
}).Subscribe(observer);
// wait some time until we think all messages have been sent and received from RabbitMQ
await Task.Delay(TimeSpan.FromSeconds(1));
// test we got everything we expected
Assert.True(messages.OfType <TestCommand>().Count() == 1, "TestCommand not received");
Assert.True(messages.OfType <TestEvent>().Count() == 1, "TestEvent not received");
Assert.True(messages.OfType <TestRequest>().Count() == 1, "TestRequest not received");
Assert.True(messages.OfType <TestResponse>().Count() == 1, "TestResponse not received");
// dispose subscriptions
sub1.Dispose();
sub2.Dispose();
sub3.Dispose();
sub4.Dispose();
sub5.Dispose();
sub6.Dispose();
// always call Dispose on serviceBus when exiting process
((IDisposable)serviceBus).Dispose();
}
public virtual IObservable <TResult> Create <TResult>(Func <IObserver <TResult>, CancellationToken, Task> subscribeAsync)
{
return(new AnonymousObservable <TResult>(observer =>
{
var cancellable = new CancellationDisposable();
var taskObservable = subscribeAsync(observer, cancellable.Token).ToObservable();
var taskCompletionObserver = new AnonymousObserver <Unit>(Stubs <Unit> .Ignore, observer.OnError, observer.OnCompleted);
var subscription = taskObservable.Subscribe(taskCompletionObserver);
return StableCompositeDisposable.Create(cancellable, subscription);
}));
}
public async Task TestSendingAndReceivingBytesOverLocalHost()
{
const string topic = "TestTopic";
var messages = new ConcurrentBag <IMessage>();
var observer = new AnonymousObserver <IMessage>(msg =>
{
Console.WriteLine("Received: " + msg);
messages.Add(msg);
}, err => Console.WriteLine("Error: " + err));
IMessageSource <IMessage> source = new MessageSource <IMessage>("tcp://localhost:5556",
new IMessageDeserializer <IMessage>[]
{
new ProtoBufMessageDeserializer <TestMessage1>(),
new ProtoBufMessageDeserializer <TestMessage2>()
},
topic);
var sub = source.Messages.Subscribe(observer);
IMessagePublisher <IMessage> publisher = new MessagePublisher <IMessage>("tcp://localhost:5556",
new ProtoBufMessageSerializer(), topic);
await publisher.PublishAsync(new TestMessage1 { Id = 1 });
await publisher.PublishAsync(new TestMessage1 { Id = 2 });
await publisher.PublishAsync(new TestMessage2 { Id = 1 });
await publisher.PublishAsync(new TestMessage2 { Id = 2 });
await publisher.PublishAsync(new TestMessage1 { Id = 3 });
await publisher.PublishAsync(new TestMessage2 { Id = 3 });
await Task.Delay(TimeSpan.FromSeconds(2));
Assert.True(messages.OfType <TestMessage1>().Any(msg => msg.Id == 1), "TestMessage1 1 not received");
Assert.True(messages.OfType <TestMessage1>().Any(msg => msg.Id == 2), "TestMessage1 2 not received");
Assert.True(messages.OfType <TestMessage1>().Any(msg => msg.Id == 3), "TestMessage1 3 not received");
Assert.True(messages.OfType <TestMessage2>().Any(msg => msg.Id == 1), "TestMessage2 1 not received");
Assert.True(messages.OfType <TestMessage2>().Any(msg => msg.Id == 2), "TestMessage2 2 not received");
Assert.True(messages.OfType <TestMessage2>().Any(msg => msg.Id == 3), "TestMessage2 3 not received");
sub.Dispose();
source.Dispose();
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
// string name = req.Query["name"];
// string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
// dynamic data = JsonConvert.DeserializeObject(requestBody);
var eventNames = new List <string>();
Action <KeyValuePair <string, object> > callback = (KeyValuePair <string, object> evnt) =>
{
eventNames.Add(evnt.Key);
Console.WriteLine($"{evnt.Key} {evnt.Value}");
Console.WriteLine($"Activity.Current.Id: {Activity.Current?.Id}");
Console.WriteLine($"Activity.Current.ParentId: {Activity.Current?.ParentId}");
Console.WriteLine($"Activity.Current.OperationName: {Activity.Current?.OperationName}");
Console.WriteLine("=========================================================================");
};
// Turn it into an observer (using System.Reactive.Core's AnonymousObserver)
IObserver <KeyValuePair <string, object> > observer = new AnonymousObserver <KeyValuePair <string, object> >(callback);
// Create a predicate (asks only for one kind of event)
Func <string, object, object, bool> predicate = (string eventName, object request, object arg3) =>
{
return(true);
};
DiagnosticListener.AllListeners.Subscribe(delegate(DiagnosticListener listener)
{
// We get a callback of every Diagnostics Listener that is active in the system (past present or future)
if (listener.Name == "HttpHandlerDiagnosticListener")
{
Console.WriteLine("Subscribed to HttpHandlerDiagnosticListener");
listener.Subscribe(observer, predicate);
}
});
var httpClient = new HttpClient();
var res = await httpClient.GetStringAsync("http://google.com");
return(new OkObjectResult(eventNames));
}
public void ShouldSendAndReceiveMessagesOverServiceBus()
{
IServiceBus serviceBus = ServiceBus.Configure()
.WithRabbitMQEndpoints <ITestMessage>()
.Named("Obvs.TestService")
.ConnectToBroker("amqp://localhost")
.SerializedAsJson()
.AsClientAndServer()
.UsingConsoleLogging()
.Create();
// create threadsafe collection to hold received messages in
ConcurrentBag <IMessage> messages = new ConcurrentBag <IMessage>();
// create some actions that will act as a fake services acting on incoming commands and requests
Action <TestCommand> fakeService1 = command => serviceBus.PublishAsync(new TestEvent {
Id = command.Id
});
Action <TestRequest> fakeService2 = request => serviceBus.ReplyAsync(request, new TestResponse {
Id = request.Id
});
AnonymousObserver <IMessage> observer = new AnonymousObserver <IMessage>(msg => { messages.Add(msg); Console.WriteLine(msg); }, exception => Console.WriteLine(exception));
// subscribe to all messages on the ServiceBus
serviceBus.Events.Subscribe(observer);
serviceBus.Commands.Subscribe(observer);
serviceBus.Requests.Subscribe(observer);
serviceBus.Commands.OfType <TestCommand>().Subscribe(fakeService1);
serviceBus.Requests.OfType <TestRequest>().Subscribe(fakeService2);
// send some messages
serviceBus.SendAsync(new TestCommand {
Id = 123
});
serviceBus.GetResponses(new TestRequest {
Id = 456
}).Subscribe(observer);
// wait some time until we think all messages have been sent and received from RabbitMQ
Thread.Sleep(TimeSpan.FromSeconds(1));
// test we got everything we expected
Assert.That(messages.OfType <TestCommand>().Count() == 1, "TestCommand not received");
Assert.That(messages.OfType <TestEvent>().Count() == 1, "TestEvent not received");
Assert.That(messages.OfType <TestRequest>().Count() == 1, "TestRequest not received");
Assert.That(messages.OfType <TestResponse>().Count() == 1, "TestResponse not received");
}
private Task SearchAsync()
{
Device.BeginInvokeOnMainThread(() => { ViewModel.Device = "Searching"; });
var tcs = new TaskCompletionSource <bool>();
Task.Run(async() =>
{
using (var discoveryService = new DiscoveryService())
using (var observer = new AnonymousObserver <DeviceAvailableEventArgs>(async e =>
{
State.PreviousDevice = await TargetDevice.FromDiscoveredDeviceAsync(e.DiscoveredDevice);
tcs.SetResult(true);
}))
{
var pipeline = Observable
.FromEventPattern <DeviceAvailableEventArgs>(
handler => discoveryService.OnDevice += handler,
handler => discoveryService.OnDevice -= handler
)
.Select(x => x.EventArgs);
if (State.PreviousDevice == null)
{
pipeline = pipeline
.Take(1);
}
if (State?.PreviousDevice?.Usn != null)
{
pipeline = pipeline
.Where(x => x.DiscoveredDevice.Usn == State.PreviousDevice.Usn)
.Take(1);
}
pipeline.Subscribe(observer);
await discoveryService.SearchAsync();
tcs.SetResult(true);
}
});
return(tcs.Task);
}
public virtual IObservable <TResult> Create <TResult>(Func <IObserver <TResult>, CancellationToken, Task <IDisposable> > subscribeAsync)
{
return(new AnonymousObservable <TResult>(observer =>
{
var subscription = new SingleAssignmentDisposable();
var cancellable = new CancellationDisposable();
var taskObservable = subscribeAsync(observer, cancellable.Token).ToObservable();
var taskCompletionObserver = new AnonymousObserver <IDisposable>(d => subscription.Disposable = d ?? Disposable.Empty, observer.OnError, Stubs.Nop);
//
// We don't cancel the subscription below *ever* and want to make sure the returned resource gets disposed eventually.
// Notice because we're using the AnonymousObservable<T> type, we get auto-detach behavior for free.
//
taskObservable.Subscribe(taskCompletionObserver);
return StableCompositeDisposable.Create(cancellable, subscription);
}));
}
private Task <CommandResult <TResponse> > Execute <TResponse>(IObservable <TResponse> observable, BaseCommand <TResponse> command, CommandResult <TResponse> commandResult)
{
TaskCompletionSource <CommandResult <TResponse> > tcs = new TaskCompletionSource <CommandResult <TResponse> >();
try
{
AnonymousObserver <TResponse> observer =
new AnonymousObserver <TResponse>(
_ => { },
_ => tcs.TrySetResult(commandResult),
() => tcs.TrySetResult(commandResult));
observable.Subscribe(observer);
}
catch (Exception ex)
{
this.OnExecutionException(command, commandResult, ex);
tcs.TrySetResult(commandResult);
}
return(tcs.Task);
}
public void TestServiceBusWithRemoteKafka()
{
IServiceBus serviceBus = ServiceBus.Configure()
.WithKafkaEndpoints <ITestMessage1>()
.Named("Obvs.TestService")
.AppendMessageProperties(message => new Dictionary <string, string> {
{ "TestProperty", "123" }
})
.FilterReceivedMessages(properties => true)
.ConnectToKafka(_seed2Addresses)
.SerializedAsJson()
.AsClientAndServer()
.PublishLocally()
.OnlyMessagesWithNoEndpoints()
.UsingConsoleLogging()
.Create();
ConcurrentBag <IMessage> messages = new ConcurrentBag <IMessage>();
// create some actions that will act as a fake services acting on incoming commands and requests
Action <TestCommand> fakeService1 = command => serviceBus.PublishAsync(new TestEvent {
Id = command.Id
});
Action <TestRequest> fakeService2 = request => serviceBus.ReplyAsync(request, new TestResponse {
Id = request.Id
});
AnonymousObserver <IMessage> observer = new AnonymousObserver <IMessage>(x =>
{
Console.WriteLine("********* " + x);
messages.Add(x);
}, Console.WriteLine, () => Console.WriteLine("OnCompleted"));
// subscribe to all messages on the ServiceBus
CompositeDisposable subscriptions = new CompositeDisposable
{
serviceBus.Events.Subscribe(observer),
serviceBus.Commands.Subscribe(observer),
serviceBus.Requests.Subscribe(observer),
serviceBus.Commands.OfType <TestCommand>().Subscribe(fakeService1),
serviceBus.Requests.OfType <TestRequest>().Subscribe(fakeService2)
};
// send some messages
serviceBus.SendAsync(new TestCommand {
Id = 123
});
serviceBus.SendAsync(new TestCommand2 {
Id = 123
});
serviceBus.SendAsync(new TestCommand3 {
Id = 123
});
serviceBus.GetResponses(new TestRequest {
Id = 456
}).Subscribe(observer);
// wait some time until we think all messages have been sent and received over AMQ
Thread.Sleep(TimeSpan.FromSeconds(10));
// test we got everything we expected
Assert.That(messages.OfType <TestCommand>().Count() == 1, "TestCommand not received");
Assert.That(messages.OfType <TestCommand2>().Count() == 1, "TestCommand2 not received");
Assert.That(messages.OfType <TestCommand3>().Count() == 1, "TestCommand3 not received");
Assert.That(messages.OfType <TestEvent>().Count() == 1, "TestEvent not received");
Assert.That(messages.OfType <TestRequest>().Count() == 1, "TestRequest not received");
Assert.That(messages.OfType <TestResponse>().Count() == 1, "TestResponse not received");
subscriptions.Dispose();
((IDisposable)serviceBus).Dispose();
// win!
}
private static Task ForEachAsync_ <TSource>(IObservable <TSource> source, Action <TSource> onNext, CancellationToken cancellationToken)
{
var tcs = new TaskCompletionSource <object>();
var subscription = new SingleAssignmentDisposable();
var ctr = default(CancellationTokenRegistration);
if (cancellationToken.CanBeCanceled)
{
ctr = cancellationToken.Register(() =>
{
tcs.TrySetCanceled(cancellationToken);
subscription.Dispose();
});
}
if (!cancellationToken.IsCancellationRequested)
{
// Making sure we always complete, even if disposing throws.
var dispose = new Action <Action>(action =>
{
try
{
ctr.Dispose(); // no null-check needed (struct)
subscription.Dispose();
}
catch (Exception ex)
{
tcs.TrySetException(ex);
return;
}
action();
});
var taskCompletionObserver = new AnonymousObserver <TSource>(
x =>
{
if (!subscription.IsDisposed)
{
try
{
onNext(x);
}
catch (Exception exception)
{
dispose(() => tcs.TrySetException(exception));
}
}
},
exception =>
{
dispose(() => tcs.TrySetException(exception));
},
() =>
{
dispose(() => tcs.TrySetResult(null));
}
);
//
// Subtle race condition: if the source completes before we reach the line below, the SingleAssigmentDisposable
// will already have been disposed. Upon assignment, the disposable resource being set will be disposed on the
// spot, which may throw an exception. (See TFS 487142)
//
try
{
//
// [OK] Use of unsafe Subscribe: we're catching the exception here to set the TaskCompletionSource.
//
// Notice we could use a safe subscription to route errors through OnError, but we still need the
// exception handling logic here for the reason explained above. We cannot afford to throw here
// and as a result never set the TaskCompletionSource, so we tunnel everything through here.
//
subscription.Disposable = source.Subscribe/*Unsafe*/ (taskCompletionObserver);
}
catch (Exception ex)
{
tcs.TrySetException(ex);
}
}
return(tcs.Task);
}
public IDisposable Subscribe(Action <T> callback)
{
var observer = new AnonymousObserver <T>(callback);
return(Subscribe(observer));
}
public async Task TestServiceBusWithLocalEventStore()
{
// run EventStore on Docker and then edit below for local address:port that maps to 1113
var serviceBus = ServiceBus.Configure()
.WithEventStoreSharedConnectionScope("ConnectTo=tcp://admin:[email protected]:32777", config => config
.WithEventStoreEndpoints <ITestMessage1>()
.Named("Obvs.EventStore.Test")
.AppendMessageProperties(message => null)
.FilterReceivedMessages(properties => true)
.UseSharedConnection()
.SerializedAsJson()
.AsClientAndServer())
.UsingConsoleLogging()
.Create();
var fakeService = new AnonymousObserver <ITestMessage1>(msg =>
{
var command = msg as TestCommand;
if (command != null)
{
serviceBus.PublishAsync(new TestEvent {
Id = command.Id
});
return;
}
var request = msg as TestRequest;
if (request != null)
{
serviceBus.ReplyAsync(request, new TestResponse {
Id = request.Id
});
}
});
var sub = serviceBus.Commands.OfType <ITestMessage1>()
.Merge(serviceBus.Requests.OfType <ITestMessage1>())
.ObserveOn(Scheduler.Default)
.Subscribe(fakeService);
var receivedEvent = await Observable.Create <TestEvent>(observer =>
{
var disposable = serviceBus.Events
.OfType <TestEvent>()
.ObserveOn(Scheduler.Default)
.Subscribe(observer);
serviceBus.SendAsync(new TestCommand {
Id = 123
});
return(disposable);
}).Take(1);
var receivedResponse = await serviceBus.GetResponse <TestResponse>(new TestRequest { Id = 456 });
sub.Dispose();
Assert.That(receivedEvent.Id, Is.EqualTo(123));
Assert.That(receivedResponse.Id, Is.EqualTo(456));
}
public IDisposable Subscribe(Action <T> callback, Action <Exception> error, Action finish)
{
var observer = new AnonymousObserver <T>(callback, error, finish);
return(Subscribe(observer));
}
public void AnonymousObserver_Error_Null()
{
var observer = new AnonymousObserver<int>(_ => { }, e => { }, () => { });
ReactiveAssert.Throws<ArgumentNullException>(() => observer.OnError(null));
}
public void AnonymousObserver_Error_Null()
{
var observer = new AnonymousObserver <int>(_ => { }, e => { }, () => { });
ReactiveAssert.Throws <ArgumentNullException>(() => observer.OnError(null));
}
public IDisposable Subscribe(IExcelObserver excelObserver)
{
var observer = new AnonymousObserver <T>(value => excelObserver.OnNext(value), excelObserver.OnError, excelObserver.OnCompleted);
return(_observable.Subscribe(observer));
}
/// <summary>
/// Returns a task that will receive the last value or the exception produced by the observable sequence.
/// </summary>
/// <typeparam name="TResult">The type of the elements in the source sequence.</typeparam>
/// <param name="observable">Observable sequence to convert to a task.</param>
/// <param name="cancellationToken">Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence.</param>
/// <param name="state">The state to use as the underlying task's AsyncState.</param>
/// <returns>A task that will receive the last element or the exception produced by the observable sequence.</returns>
/// <exception cref="ArgumentNullException"><paramref name="observable"/> is null.</exception>
public static Task <TResult> ToTask <TResult>(this IObservable <TResult> observable, CancellationToken cancellationToken, object state)
{
if (observable == null)
{
throw new ArgumentNullException("observable");
}
var hasValue = false;
var lastValue = default(TResult);
var tcs = new TaskCompletionSource <TResult>(state);
var disposable = new SingleAssignmentDisposable();
var ctr = default(CancellationTokenRegistration);
if (cancellationToken.CanBeCanceled)
{
ctr = cancellationToken.Register(() =>
{
disposable.Dispose();
tcs.TrySetCanceled();
});
}
var taskCompletionObserver = new AnonymousObserver <TResult>(
value =>
{
hasValue = true;
lastValue = value;
},
ex =>
{
tcs.TrySetException(ex);
ctr.Dispose(); // no null-check needed (struct)
disposable.Dispose();
},
() =>
{
if (hasValue)
{
tcs.TrySetResult(lastValue);
}
else
{
tcs.TrySetException(new InvalidOperationException(Strings_Linq.NO_ELEMENTS));
}
ctr.Dispose(); // no null-check needed (struct)
disposable.Dispose();
}
);
//
// Subtle race condition: if the source completes before we reach the line below, the SingleAssigmentDisposable
// will already have been disposed. Upon assignment, the disposable resource being set will be disposed on the
// spot, which may throw an exception. (Similar to TFS 487142)
//
try
{
//
// [OK] Use of unsafe Subscribe: we're catching the exception here to set the TaskCompletionSource.
//
// Notice we could use a safe subscription to route errors through OnError, but we still need the
// exception handling logic here for the reason explained above. We cannot afford to throw here
// and as a result never set the TaskCompletionSource, so we tunnel everything through here.
//
disposable.Disposable = observable.Subscribe/*Unsafe*/ (taskCompletionObserver);
}
catch (Exception ex)
{
tcs.TrySetException(ex);
}
return(tcs.Task);
}
