protected override void UnsubscribeFromEventBus()
{
eventBus?.TryUnsubscribe(newBlockDiscoveredSubscription);
newBlockDiscoveredSubscription = null;
eventBus?.TryUnsubscribe(newBlockAvailableInDBSubscription);
newBlockAvailableInDBSubscription = null;
}
protected override void UnsubscribeFromEventBus()
{
eventBus?.TryUnsubscribe(nodeAddedSubscription);
nodeAddedSubscription = null;
eventBus?.TryUnsubscribe(nodeDeletedSubscription);
nodeDeletedSubscription = null;
}
public async Task WaitForEventBusEventAsync <T>(EventBusSubscription <T> subscription, string description, Func <T, bool> predicate) where T : IntegrationEvent
{
try
{
do
{
var evt = await subscription.ReadAsync(new CancellationTokenSource(5_000).Token);
if (predicate(evt))
{
break;
}
loggerTest.LogInformation($"Got notification event {evt}, but is not the one that we are looking for");
} while (true);
}
catch (OperationCanceledException)
{
string msg = $"Timeout out while waiting for integration event {typeof(T).Name}. {description}";
loggerTest.LogInformation(msg);
throw new Exception(msg);
}
loggerTest.LogInformation($"The following wait for event completed successfully: {description}");
}
public async Task DoesntSendDataWhenNoSubscriptionMatchesTheFilter()
{
await this.eventBus.Subscribe(EventBusSubscription.Create <Message>(
"testChannel",
"someClientId",
0,
null,
new { },
e => e.Author == "Sam",
operation));
OnMessageReceivedEventArgs eventArgs = null;
this.eventBus.OnMessageReceived += async(OnMessageReceivedEventArgs args) =>
{
await Task.Yield();
eventArgs = args;
};
await this.eventBus.Publish(new Message()
{
Author = "Bob", Content = "stuff"
}, "testChannel");
Assert.IsNull(eventArgs);
}
public async Task ShouldReceiveDataDefinedBySubscription()
{
await this.eventBus.Subscribe(EventBusSubscription.Create <Message>(
"testChannel",
"someClientId",
0,
null,
new { },
e => e.Author == "Bob",
operation));
OnMessageReceivedEventArgs eventArgs = null;
this.eventBus.OnMessageReceived += async(OnMessageReceivedEventArgs args) =>
{
await Task.Yield();
eventArgs = args;
};
await this.eventBus.Publish(new Message()
{
Author = "Bob", Content = "stuff"
}, "testChannel");
Assert.AreEqual("testChannel", eventArgs.Channel);
}
private async Task RegisterSubscription(
GraphQLFieldSelection fieldSelection,
GraphQLSubscriptionType type,
GraphQLDocument document,
FieldScope scope)
{
var fieldInfo = type.GetFieldInfo(fieldSelection.Name.Value) as GraphQLSubscriptionTypeFieldInfo;
Expression <Func <object, bool> > filter = null;
if (fieldInfo.Filter != null)
{
filter = entity => (bool)scope.InvokeWithArgumentsSync(
fieldSelection.Arguments.ToList(), fieldInfo.Filter, entity);
}
await type.EventBus.Subscribe(EventBusSubscription.Create(
fieldInfo.Channel,
this.clientId,
this.subscriptionId.Value,
this.Operation?.Name?.Value ?? "Anonymous",
this.variables,
filter,
this.ast));
}
public virtual void TestInitialize()
{
Initialize(mockedServices: false);
var bitcoindConfigKey = "BitcoindFullPath";
bitcoindFullPath = Configuration[bitcoindConfigKey];
if (string.IsNullOrEmpty(bitcoindFullPath))
{
throw new Exception($"Required parameter {bitcoindConfigKey} is missing from configuration");
}
var alternativeIp = Configuration["HostIp"];
if (!string.IsNullOrEmpty(alternativeIp))
{
hostIp = alternativeIp;
}
bool skipNodeStart = GetType().GetMethod(TestContext.TestName).GetCustomAttributes(true).Any(a => a.GetType() == typeof(SkipNodeStartAttribute));
if (!skipNodeStart)
{
zmqSubscribedEventSubscription = eventBus.Subscribe <ZMQSubscribedEvent>();
node0 = CreateAndStartNode(0);
_ = zmqSubscribedEventSubscription.ReadAsync(CancellationToken.None).Result;
rpcClient0 = node0.RpcClient;
SetupChain(rpcClient0);
}
}
protected override void SubscribeToEventBus(CancellationToken stoppingToken)
{
newBlockDiscoveredSubscription = eventBus.Subscribe <NewBlockDiscoveredEvent>();
newBlockAvailableInDBSubscription = eventBus.Subscribe <NewBlockAvailableInDB>();
_ = newBlockDiscoveredSubscription.ProcessEventsAsync(stoppingToken, logger, NewBlockDiscoveredAsync);
_ = newBlockAvailableInDBSubscription.ProcessEventsAsync(stoppingToken, logger, ParseBlockForTransactionsAsync);
}
protected override void SubscribeToEventBus(CancellationToken stoppingToken)
{
// subscribe to node events
nodeAddedSubscription = eventBus.Subscribe <NodeAddedEvent>();
nodeDeletedSubscription = eventBus.Subscribe <NodeDeletedEvent>();
_ = nodeAddedSubscription.ProcessEventsAsync(stoppingToken, logger, NodeRepositoryNodeAddedAsync);
_ = nodeDeletedSubscription.ProcessEventsAsync(stoppingToken, logger, NodeRepositoryDeletedEventAsync);
}
protected override void UnsubscribeFromEventBus()
{
eventBus?.TryUnsubscribe(invalidTxDetectedSubscription);
invalidTxDetectedSubscription = null;
eventBus?.TryUnsubscribe(removedFromMempoolSubscription);
removedFromMempoolSubscription = null;
}
protected override void SubscribeToEventBus(CancellationToken stoppingToken)
{
invalidTxDetectedSubscription = eventBus.Subscribe <InvalidTxDetectedEvent>();
removedFromMempoolSubscription = eventBus.Subscribe <RemovedFromMempoolEvent>();
_ = invalidTxDetectedSubscription.ProcessEventsAsync(stoppingToken, logger, InvalidTxDetectedAsync);
_ = removedFromMempoolSubscription.ProcessEventsAsync(stoppingToken, logger, RemovedFromMempoolEventAsync);
}
public void Subscribe(EventBusSubscription eventBusSubscription)
{
if (eventBusSubscription != null)
{
_logger.LogInformation($"Subscribing event {eventBusSubscription.SubscriptionEventName}");
StartBasicConsume();
DoInternalSubscription(eventBusSubscription);
}
}
private void DoInternalSubscription(EventBusSubscription subscription)
{
_eventBusConnection.EnsureConnection();
using (var channel = _eventBusConnection.CreateModel())
{
var args = new Dictionary <string, object>();
channel.QueueBind(
queue: _queueName,
exchange: _exchangeName,
routingKey: subscription.SubscriptionEventName,
args);
}
}
private void HandleMessage(
EventBusSubscription eventBusSubscription,
ReplyEventBusRequest <int, int> busRequest,
int messageCount)
{
Assertions.AssertTrue(!busRequest.IsError(), "not error message");
if (messageCount > 5)
{
busRequest.ErrorReply("test error", 2);
eventBusSubscription.Stop();
}
else
{
busRequest.Reply(busRequest.Content + 1);
}
}
internal async Task DisableSubscriptionAsync(EventBusSubscription subscription)
{
_logger.LogDebug("Disabling subscription: {0}", subscription.Name);
if (_subscriptions.Remove(subscription.Name) && IsConnectionOpen)
{
try {
await SendMessageAsync(new UnsubscribeAction {
Rule = subscription.Name
});
} catch (InvalidOperationException) {
// websocket is not connected; ignore error
} catch (Exception e) {
// nothing to do
_logger.LogDebug("Deactivating subscription FAILED: {0}\n{1}", subscription.Name, e);
}
}
}
public async Task Test()
{
var messageCount1 = 0;
_subscription1 = this.MessageEndpoint <int, int>(EventBusMessageTest.ConsumerAddress1, message =>
{
messageCount1++;
HandleMessage(_subscription1, message, messageCount1);
});
var messageCount2 = 0;
_subscription2 = this.MessageEndpoint <int, int>(EventBusMessageTest.ConsumerAddress2, message =>
{
messageCount2++;
HandleMessage(_subscription2, message, messageCount2);
});
}
internal async Task EnableSubscriptionAsync(EventBusSubscription subscription)
{
_logger.LogDebug("Enabling subscription: {0}", subscription.Name);
if (IsConnectionOpen)
{
try {
await SendMessageAndWaitForAcknowledgeAsync(new SubscribeAction {
Rule = subscription.Name,
Pattern = subscription.Pattern
});
} catch (InvalidOperationException) {
// websocket is not connected; ignore error
} catch (Exception e) {
_logger.LogDebug("Activating subscription FAILED: {0}\n{1}", subscription.Name, e);
subscription.Status = EventBusSubscriptionStatus.Error;
// subscription failed
SubscriptionError?.Invoke(this, new EventBusSubscriptErrorEventArgs(subscription, e));
}
}
}
public async Task IgnoresMultipleSameSubscriptions()
{
await this.eventBus.Subscribe(EventBusSubscription.Create <Message>(
"testChannel",
"someClientId",
0,
null,
new { },
e => e.Author == "Sam",
operation));
await this.eventBus.Subscribe(EventBusSubscription.Create <Message>(
"testChannel",
"someClientId",
0,
null,
new { },
e => e.Author == "Sam",
operation));
List <string> clientIds = new List <string>();
this.eventBus.OnMessageReceived += async(OnMessageReceivedEventArgs args) =>
{
await Task.Yield();
clientIds.Add(args.ClientId);
};
await this.eventBus.Publish(new Message()
{
Author = "Sam", Content = "stuff"
}, "testChannel");
Assert.AreEqual(1, clientIds.Count);
}
/// <summary>
/// The <see cref="SubscribeTo{T}(string,LambdaSharp.App.EventBus.EventBusPattern,Action{IEventBusSubscription,CloudWatchEvent{T}})"/> method creates a subscription for the specified source and type.
/// </summary>
/// <param name="name">The name of the LambdaSharp App EventBus subscription.</param>
/// <param name="eventPattern"></param>
/// <param name="callback">The callback to invoke when a matching event is received.</param>
/// <typeparam name="T">The event payload type.</typeparam>
/// <returns>The subscription instance.</returns>
public IEventBusSubscription SubscribeTo <T>(string name, EventBusPattern eventPattern, Action <IEventBusSubscription, CloudWatchEvent <T> > callback)
{
if (name is null)
{
throw new ArgumentNullException(nameof(name));
}
if (eventPattern is null)
{
throw new ArgumentNullException(nameof(eventPattern));
}
if (callback is null)
{
throw new ArgumentNullException(nameof(callback));
}
// register subscription
var subscription = new EventBusSubscription(
name,
JsonSerializer.Serialize(eventPattern),
(callbackSubscription, cloudWatchEventJson) => {
try {
// deserialize received event
callback?.Invoke(callbackSubscription, JsonSerializer.Deserialize <CloudWatchEvent <T> >(cloudWatchEventJson));
} catch (Exception e) {
_logger.LogError(e, "Callback for rule '{0}' failed", name);
}
},
this
);
_subscriptions[name] = subscription;
// kick off subscription, but don't wait for response
_ = subscription.EnableSubscriptionAsync();
return(subscription);
}
protected override void SubscribeToEventBus(CancellationToken stoppingToken)
{
newNotificationEventSubscription = eventBus.Subscribe <NewNotificationEvent>();
_ = newNotificationEventSubscription.ProcessEventsAsync(stoppingToken, logger, ProcessNotificationAsync);
}
protected override void UnsubscribeFromEventBus()
{
eventBus?.TryUnsubscribe(newNotificationEventSubscription);
newNotificationEventSubscription = null;
}
protected override void SubscribeToEventBus(CancellationToken stoppingToken)
{
newBlockDiscoveredSubscription = eventBus.Subscribe <NewBlockDiscoveredEvent>();
_ = newBlockDiscoveredSubscription.ProcessEventsAsync(stoppingToken, logger, NewBlockDiscoveredAsync);
}
