public void SubscribeTo <T>(ISubscriptionConfiguration <T> configuration)
where T : class
{
configuration.Require("configuration");
SubscribeTo(new DefaultSubscription <T>(configuration));
}
public DefaultSubscription(ISubscriptionConfiguration <T> configuration)
{
configuration.Require("configuration");
configuration.Validate();
Configuration = configuration;
}
public void Subscribe <T>(Action <T> onMessage, Action <ISubscriptionConfiguration> configure) where T : class
{
ISubscriptionConfiguration configuration = this.Configuration.SubscriptionConfiguration();
configure(configuration);
string queueName = this.CreateQueueIfNotExists <T>(configuration);
QueueClient queueClient = QueueClient.CreateFromConnectionString(this.Configuration.ConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
OnMessageOptions options = new OnMessageOptions();
options.AutoComplete = true;
options.MaxConcurrentCalls = configuration.MaxConcurrentCalls;
queueClient.OnMessage(message =>
{
try
{
this.Configuration.Logger.InfoFormat(
"Message was received on Queue {0} with MessageId {1}",
queueName,
message.MessageId);
onMessage.Invoke(message.GetBody <T>());
}
catch (Exception ex)
{
this.Configuration.Logger.Fatal(ex);
}
},
options);
this.subscriptions.GetOrAdd(queueName, queueClient);
}
/// <summary>
/// Subscribes to a stream of messages that match a .NET type.
/// </summary>
/// <typeparam name="T">The type to subscribe to</typeparam>
/// <param name="onMessage">The action to run when a message arrives.</param>
/// <param name="configure">The configure action.</param>
public void Subscribe <T>(Action <T> onMessage, Action <ISubscriptionConfiguration> configure) where T : class
{
Type messageType = typeof(T);
ISubscriptionConfiguration configuration = this.Configuration.SubscriptionConfiguration();
configure(configuration);
string topic = this.CreateTopicIfNotExists <T>(configuration);
string realSubscriptionId = configuration.Subscription.ToLowerInvariant();
if (!this.namespaceManager.SubscriptionExists(topic, realSubscriptionId))
{
SqlFilter filter = new SqlFilter(string.Format("[Message.Type.FullName] = '{0}'", messageType.FullName));
SubscriptionDescription dataCollectionTopic = this.namespaceManager.CreateSubscription(topic, realSubscriptionId, filter);
}
string descriptor = topic + ":" + realSubscriptionId;
SubscriptionClient client = this.subscriptionClients.GetOrAdd(
descriptor,
(d) =>
{
return(SubscriptionClient.CreateFromConnectionString(
this.Configuration.ConnectionString,
topic,
realSubscriptionId,
configuration.ReceiveMode));
});
OnMessageOptions options = new OnMessageOptions()
{
AutoComplete = false,
MaxConcurrentCalls = configuration.MaxConcurrentCalls
};
client.OnMessage(envelope =>
{
try
{
this.Configuration.Logger.InfoFormat(
"Message was received on Subscription {0} Topic {1} with MessageId {2}",
realSubscriptionId,
topic,
envelope.MessageId);
object message = JsonConvert.DeserializeObject(envelope.GetBody <string>(), messageType);
onMessage(message as T);
envelope.Complete();
}
catch (Exception ex)
{
this.Configuration.Logger.Fatal(ex);
envelope.Abandon();
}
},
options);
}
public EventStoreReader(IEventStoreConnection eventStoreConnection, ProjectorInvoker projectorInvoker,
ISubscriptionConfiguration subscriptionConfiguration,
IPositionReaderService positionReaderService,
ILifetimeScope container)
{
_eventStoreConnection = eventStoreConnection;
_projectorInvoker = projectorInvoker;
_subscriptionConfiguration = subscriptionConfiguration;
_positionReaderService = positionReaderService;
_container = container;
}
public SubscriptionWorker(IDependencyResolver dependencyResolver)
{
this.dependencyResolver = dependencyResolver;
cancellationTokenSource = new CancellationTokenSource();
defaultDeadLetterStrategy = dependencyResolver.Get <IDeadLetterStrategy <MessageEnvelope> >();
defaultSubscriptionConfiguration = dependencyResolver.Get <ISubscriptionConfiguration>();
messageHandlers = new Dictionary <Type, List <Func <IMessageContext <MessageEnvelope>, bool> > >();
subscriberChannels = new List <ISubscriberChannel <MessageEnvelope> >();
typeTokenProviders = dependencyResolver.GetAll <ITypeTokenProvider>().ToList();
typeTokens = new Dictionary <string, Type>();
}
public ISubscription Create <TMessage>(
IBus bus,
ISubscriptionConfiguration configuration,
Action <TMessage, IDeliveryContext> callback)
{
logger.DebugFormat("Creating new handler subscription with configuration: {0}", configuration);
var deliveryProcessor = new ActionDeliveryProcessor <TMessage>(
bus,
messageSerializers,
callback);
var messageType = typeof(TMessage).Name;
var faultStrategy = configuration.BuildFaultStrategy(bus);
var endpointNames = configuration.EndpointNames.Any()
? configuration.EndpointNames
: new[] { messageType };
// each subscription get its own model, where each endpoint
// will be a consumer
var modelReferenceTag = string.Join("|", endpointNames);
var modelReference = modelFactory.CreateModel(modelReferenceTag);
// apply basic quality of service, this will set the prefetch count
// which is shared across all consumers
modelReference.Execute(
m => m.BasicQos(
configuration.PrefetchSize,
configuration.PrefetchCount,
false));
var deliveryStrategy = configuration.BuildDeliveryStrategy(
deliveryProcessor);
var deliveryQueues = BuildDeliveryQueues(
endpointNames,
modelReference,
messageType,
configuration,
faultStrategy);
var subscription = new Subscription(
configuration.Name,
modelReference,
deliveryStrategy,
deliveryQueues.ToArray());
return(Create(subscription));
}
public void ConfigureSubscription(ISubscriptionConfiguration configuration)
{
// TODO: configuration.WithDurable
// TODO: configuration.WithPriority
// TODO: configuration.WithPrefetchCount
configuration
.WithTopic(RemoteTopic ?? string.Empty)
.WithQueueName(QueueName);
if (QueueExpirationMs.HasValue && QueueExpirationMs > 0)
{
configuration.WithExpires(QueueExpirationMs.Value);
}
// TODO: configuration.AsExclusive
}
public PersistentSubscriptionClient(
// IEventStoreConnection eventStoreConnection,
// ProjectorInvoker projectorInvoker,
// IEventStoreConnectionManager eventStoreConnectionManager,
// ISubscriptionConfiguration subscriptionConfiguration,
ILifetimeScope container)
{
_container = container;
_eventStoreConnection = _container.Resolve <IEventStoreConnection>();
_projectorInvoker = _container.Resolve <ProjectorInvoker>();
_eventStoreConnectionManager = _container.Resolve <IEventStoreConnectionManager>();
_subscriptionConfiguration = _container.Resolve <ISubscriptionConfiguration>();
//
// _eventStoreConnection = eventStoreConnection;
// _projectorInvoker = projectorInvoker;
// _eventStoreConnectionManager = eventStoreConnectionManager;
// _subscriptionConfiguration = subscriptionConfiguration;
}
public SubscriptionManager(IServiceBusEvents events, IServiceBusConfiguration serviceBusConfiguration,
ISubscriptionConfiguration configuration, IScriptProvider scriptProvider,
IDatabaseContextFactory databaseContextFactory, IDatabaseGateway databaseGateway)
{
Guard.AgainstNull(events, "events");
Guard.AgainstNull(serviceBusConfiguration, "serviceBusConfiguration");
Guard.AgainstNull(configuration, "configuration");
Guard.AgainstNull(scriptProvider, "scriptProvider");
Guard.AgainstNull(databaseContextFactory, "databaseContextFactory");
Guard.AgainstNull(databaseGateway, "databaseGateway");
_log = Log.For(this);
_serviceBusConfiguration = serviceBusConfiguration;
_configuration = configuration;
_scriptProvider = scriptProvider;
_databaseContextFactory = databaseContextFactory;
_databaseGateway = databaseGateway;
events.Started += ServiceBus_Started;
_subscriptionProviderName = configuration.ProviderName;
if (string.IsNullOrEmpty(_subscriptionProviderName))
{
throw new ConfigurationErrorsException(string.Format(SubscriptionResources.ProviderNameEmpty,
"SubscriptionManager"));
}
_subscriptionConnectionString = configuration.ConnectionString;
if (string.IsNullOrEmpty(_subscriptionConnectionString))
{
throw new ConfigurationErrorsException(string.Format(SubscriptionResources.ConnectionStringEmpty,
"SubscriptionManager"));
}
using (_databaseContextFactory.Create(_subscriptionProviderName, _subscriptionConnectionString))
{
if (_databaseGateway.GetScalarUsing <int>(
RawQuery.Create(
_scriptProvider.Get(
Script.SubscriptionManagerExists))) != 1)
{
try
{
_databaseGateway.ExecuteUsing(RawQuery.Create(
_scriptProvider.Get(
Script.SubscriptionManagerCreate)));
}
catch (Exception ex)
{
if (
!ex.Message.Equals(
"There is already an object named 'SubscriberMessageType' in the database.",
StringComparison.OrdinalIgnoreCase))
{
throw new DataException(SubscriptionResources.SubscriptionManagerCreateException, ex);
}
}
}
}
}
public DefaultSubscriptionConfigurer(ISubscriptionConfiguration <T> configuration)
{
configuration.Require("configuration");
this.configuration = configuration;
}
private ISubscription Subscribe <TMessage>(Action <TMessage, IDeliveryContext> onMessage, ISubscriptionConfiguration subscriptionConfiguration)
{
logger.DebugFormat("Subscribing to action callback of type {0}", typeof(TMessage).Name);
var subscription = subscriptionFactory.Create(
this,
subscriptionConfiguration,
onMessage);
if (subscription.IsStartable)
{
subscription.Start();
}
else
{
logger.InfoFormat("Could not start subscription, invalid configuration: {0}", subscription);
}
return(subscription);
}
/// <summary>
/// Subscribes to a stream of messages that match a .NET type.
/// </summary>
/// <typeparam name="T">The type to subscribe to</typeparam>
/// <param name="onMessage">The action to run when a message arrives.</param>
/// <param name="configure">The configure action.</param>
public void Subscribe <T>(Action <T> onMessage, Action <ISubscriptionConfiguration> configure) where T : class
{
Type messageType = typeof(T);
ISubscriptionConfiguration configuration = this.Configuration.SubscribtionConfiguration();
configure(configuration);
string realSubscriptionId = configuration.Subscription.ToLowerInvariant();
var topic = configuration.GetTopicName(typeof(T));
string descriptor = topic + ":" + realSubscriptionId;
var client = this.subscriptionClients.GetOrAdd(
descriptor,
(d) =>
{
return(new ReceiverLink(
this.session,
realSubscriptionId,
string.Format("{0}/Subscriptions/{1}", topic, realSubscriptionId)));
});
//// Start listening
client.Start(
new Random().Next(),
(receiver, envelope) =>
{
try
{
this.Configuration.Logger.InfoFormat(
"Message was received on Subscription {0} Topic {1} with MessageId {2}",
realSubscriptionId,
topic,
envelope.Properties.MessageId);
string body = string.Empty;
var rawBody = envelope.GetBody <object>();
if (rawBody is byte[])
{
using (var reader = XmlDictionaryReader.CreateBinaryReader(
new MemoryStream(rawBody as byte[]),
null,
XmlDictionaryReaderQuotas.Max))
{
var doc = new XmlDocument();
doc.Load(reader);
body = doc.InnerText;
}
}
else
{
body = rawBody.ToString();
}
object message = JsonConvert.DeserializeObject(body, messageType);
onMessage(message as T);
client.Accept(envelope);
}
catch (Exception ex)
{
this.Configuration.Logger.Fatal(ex);
client.Reject(envelope);
}
});
}
private void SubConfigure(ISubscriptionConfiguration obj) => obj.WithTopic("test");
