public Session(int watcher, RabbitBroker broker, BrokerSubscriptionParameter parameters, Func <IBrokerContext, Task> callback, Func <IBrokerContext> factoryContext)
{
_nextWarnTime = RabbitClock.GetNow().AddSeconds((watcher * 2) + 1);
_broker = broker;
_parameters = parameters;
_callback = callback;
_watcher = watcher;
_factoryContext = factoryContext;
_callback = callback;
_session = broker.GetChannel();
_session.BasicQos(0, (ushort)parameters.MaxParallelism, false);
var _consumer = new EventingBasicConsumer(_session);
_consumer.Received += _consumer_Received;
_act = () =>
{
_consumer.Received -= _consumer_Received;
};
if (broker.Configuration.ConfigAllowed)
{
SetUpBindings(parameters, _session);
}
_session.BasicConsume(parameters.StorageQueueName, false, _consumer);
}
/// <summary>
/// Loads the subscriber from connection string.
/// </summary>
/// <param name="payload">The payload.</param>
/// <returns></returns>
/// <exception cref="InvalidConfigurationException">Failed to load configuration {payload}</exception>
public static BrokerSubscriptionParameter LoadSubscriberFromConnectionString(this string payload)
{
var config = new BrokerSubscriptionParameter();
if (!LoadFromConnectionString <BrokerSubscriptionParameter>(payload, config))
{
throw new InvalidConfigurationException($"Failed to load configuration {payload}");
}
return(config);
}
/// <summary>
/// subscribe with custom business delegate
/// </summary>
/// <param name="broker"></param>
/// <param name="parameters"></param>
/// <param name="callback"></param>
internal void Subscribe(RabbitBroker broker, BrokerSubscriptionParameter parameters, Func <IBrokerContext, Task> callback, Func <IBrokerContext> factory)
{
_broker = broker;
_parameters = parameters;
_callback = callback;
_watcher = parameters.WatchDog;
_factory = factory;
CreateSession();
}
/// <summary>
/// Register a new subscription to an existing queue (i.e. on the default exchange)
/// </summary>
/// <param name="subscriptionParameters">The subscription parameters.</param>
/// <param name="callback">The callback that contains business code.</param>
/// <param name="factory">The factory is optional if you want override context. by default the value is () => new <see cref="!:Bb.Brokers.RabbitBrokerContext" />()</param>
/// <returns></returns>
/// <exception cref="InvalidConfigurationException">subscriptionParameters must be of type BrokerSubscriptionParameters</exception>
public IBrokerSubscription Subscribe(object subscriptionParameters, Func <IBrokerContext, Task> callback, Func <IBrokerContext> factory = null)
{
if (factory == null)
{
factory = () => new RabbitBrokerContext();
}
BrokerSubscriptionParameter _subscriptionParameters = (subscriptionParameters as BrokerSubscriptionParameter) ?? throw new InvalidConfigurationException("subscriptionParameters must be of type BrokerSubscriptionParameters");
var res = new RabbitBrokerSubscription();
res.Subscribe(this, _subscriptionParameters, callback, factory);
return(res);
}
public static IFactoryBroker AddDirect(this IFactoryBroker brokers, string serverName
, string publisherName
, string subscriberName
, string exchangeName
, string queueName
)
{
var e = brokers.CheckServerBroker(serverName);
if (e != null)
{
throw e;
}
BrokerPublishParameter publisher = brokers.GetConfigurationPublisher(publisherName) as BrokerPublishParameter;
if (publisher == null)
{
brokers.Add(publisher = new BrokerPublishParameter()
{
Name = publisherName,
ServerName = serverName,
ExchangeType = ExchangeType.DIRECT,
ExchangeName = exchangeName,
DefaultRountingKey = queueName
});
}
else
{
}
BrokerSubscriptionParameter subscriber = brokers.GetConfigurationSubscriber(publisherName) as BrokerSubscriptionParameter;
if (subscriber == null)
{
brokers.Add(subscriber = new BrokerSubscriptionParameter()
{
Name = subscriberName,
ServerName = serverName,
ExchangeType = ExchangeType.DIRECT,
ExchangeName = exchangeName,
StorageQueueName = queueName,
}.AddRoutingKeys(queueName)
);
}
return(brokers);
}
private void SetUpBindings(BrokerSubscriptionParameter parameters, IModel channel)
{
// Create the receiving queue.
channel.QueueDeclare(parameters.StorageQueueName, parameters.Durable, false, !parameters.Durable);
// No binding to create. Just create the queue, as bindings are implicit on the default exchange.
if (string.IsNullOrWhiteSpace(parameters.ExchangeName))
{
return;
}
// Normal case - exchange -> binding -> queue.
channel.ExchangeDeclare(parameters.ExchangeName, parameters.ExchangeType.ToString().ToLowerInvariant(), true, false);
foreach (var routingKey in parameters.AcceptedRoutingKeys)
{
channel.QueueBind(parameters.StorageQueueName, parameters.ExchangeName, routingKey);
}
}
