/// <summary>
/// Выполнить привязку.
/// </summary>
/// <param name="settings">Настройки очереди.</param>
/// <returns>Канал, на котором была выполнена привязка.</returns>
public async Task <IModel> BindAsync <TEvent>(SubscriberSettings settings)
where TEvent : class, IMessage
{
var channel = await _permanentConnectionManager
.GetConnection(settings.ConnectionSettings, ConnectionPurposeType.Subscriber)
.CreateModelAsync();
_topologyProvider.DeclareQueue(channel, settings, typeof(TEvent));
if (settings.UseDeadLetter)
{
_topologyProvider.UseDeadLetteredQueue(channel, settings, typeof(TEvent));
}
if (settings.ConnectionSettings.UseCommonUnroutedMessagesQueue)
{
_topologyProvider.UseCommonUnroutedMessagesQueue(channel, settings);
}
if (settings.ConnectionSettings.UseCommonErrorMessagesQueue)
{
_topologyProvider.UseCommonErrorMessagesQueue(channel, settings);
}
return(channel);
}
/// <summary>
/// Использовать очередь с ошибочными сообщениями.
/// </summary>
/// <param name="channel">Канал.</param>
/// <param name="settings">Настройки подписчика.</param>
/// <param name="messageType">Тип сообщения.</param>
public void UseDeadLetteredQueue(IModel channel, SubscriberSettings settings, Type messageType)
{
var queueName = _namingConvention.QueueNamingConvention(messageType, settings);
var deadLetterQueueName = _namingConvention.DeadLetterQueueNamingConvention(messageType, settings);
var deadLetterExchangeName = _namingConvention.DeadLetterExchangeNamingConvention(messageType, settings);
channel.ExchangeDeclare(
exchange: deadLetterExchangeName,
durable: settings.Durable,
autoDelete: settings.AutoDelete,
type: ExchangeType.Direct
);
channel.QueueDeclare(
queue: deadLetterQueueName,
durable: settings.Durable,
exclusive: settings.Exclusive,
autoDelete: settings.AutoDelete,
arguments: new Dictionary <string, object>
{
[QueueArgument.QUEUE_MODE] = QueueMode.Lazy
}
);
channel.QueueBind(
queue: deadLetterQueueName,
exchange: deadLetterExchangeName,
routingKey: queueName
);
}
/// <summary>
/// Использовать общую очередь с ошибочными сообщениями.
/// </summary>
/// <param name="channel">Канал.</param>
/// <param name="settings">Настройки подписчика.</param>
public void UseCommonErrorMessagesQueue(IModel channel, SubscriberSettings settings)
{
channel.QueueDeclare(
CommonQueuesConstants.ERROR_MESSAGES,
durable: true,
exclusive: false,
autoDelete: false,
arguments: new Dictionary <string, object>
{
[QueueArgument.QUEUE_MODE] = QueueMode.Lazy
}
);
channel.ExchangeDeclare(
exchange: CommonQueuesConstants.ERROR_MESSAGES,
type: ExchangeType.Fanout,
durable: true
);
channel.QueueBind(
CommonQueuesConstants.ERROR_MESSAGES,
exchange: CommonQueuesConstants.ERROR_MESSAGES,
routingKey: string.Empty
);
}
/// <summary>
/// Подтвердить, что сообщение обработано.
/// </summary>
/// <param name="channel">Канал.</param>
/// <param name="messageContext">Контекст сообщения.</param>
/// <param name="settings">Настройки подписчика.</param>
internal static void Ack(this IModel channel, MessageContext messageContext, SubscriberSettings settings)
{
if (!settings.AutoAck) // те у которых включен AutoAck автоматически удаляются из очереди, вручную подтверждать не нужно.
{
channel.BasicAck(messageContext.MessageData.DeliverEventArgs.DeliveryTag, false);
}
}
/// <summary>
/// Выполнить привязку.
/// </summary>
/// <typeparam name="TMessage">Тип сообщения для обработки.</typeparam>
/// <param name="subscriberSettings">Настройки подписчика.</param>
public async Task BindAsync <TMessage>(SubscriberSettings subscriberSettings)
where TMessage : class, IMessage
{
using var channel =
await _subscriberFactory
.GetSubscriber <TMessage>()
.BindAsync <TMessage>(subscriberSettings);
}
public B2C2OrderBooksSubscriber(
SubscriberSettings settings,
IB2C2OrderBookService b2C2OrderBookService,
ILogFactory logFactory)
{
_settings = settings;
_b2C2OrderBookService = b2C2OrderBookService;
_logFactory = logFactory;
}
public OrderBooksSubscriber(
SubscriberSettings settings,
IOrderBooksHandler orderBooksHandler,
ILogger <OrderBooksSubscriber> logger)
{
_settings = settings;
_orderBooksHandler = orderBooksHandler;
_logger = logger;
}
public B2C2QuoteSubscriber(
SubscriberSettings settings,
IQuoteService quoteService,
ILogFactory logFactory)
{
_settings = settings;
_quoteService = quoteService;
_logFactory = logFactory;
}
public EventsSubscriber(
SubscriberSettings settings,
ITradesService tradesService,
ILogger <EventsSubscriber> logger)
{
_settings = settings;
_tradesService = tradesService;
_logger = logger;
}
/// <summary>
/// Получить поведение.
/// </summary>
/// <typeparam name="TMessage">Тип сообщения.</typeparam>
/// <param name="subscriberSettings">Настройки подписчика.</param>
/// <returns>Поведение оповещения брокера сообщений.</returns>
public IAcknowledgementBehaviour GetBehaviour <TMessage>(SubscriberSettings subscriberSettings)
{
if (_resolver.TryGet(out var acknowledgementBehaviour, typeof(TMessage).Name))
{
return(acknowledgementBehaviour);
}
return(_resolver.GetRequired());
}
public OrderBooksUpdatesReportSubscriber(
SubscriberSettings settings,
IOrderBookUpdateReportRepository orderBookUpdateReportRepository,
ILogFactory logFactory)
{
_settings = settings;
_orderBookUpdateReportRepository = orderBookUpdateReportRepository;
_logFactory = logFactory;
_log = logFactory.CreateLog(this);
}
public LykkeOrderBookSubscriber(
SubscriberSettings settings,
IOrderBookService orderBookService,
ILogFactory logFactory)
{
_settings = settings;
_orderBookService = orderBookService;
_logFactory = logFactory;
_log = logFactory.CreateLog(this);
}
public ExternalOrderBookSubscriber(
SubscriberSettings settings,
IFakeExchange fakeExchange,
ILogFactory logFactory)
{
_settings = settings;
_fakeExchange = fakeExchange;
_logFactory = logFactory;
_log = logFactory.CreateLog(this);
}
public OrderBooksSubscriber(
SubscriberSettings settings,
IPricesHandler pricesHandler,
PriceType priceType,
ILogger <OrderBooksSubscriber> logger)
{
_settings = settings;
_pricesHandler = pricesHandler;
_priceType = priceType;
_logger = logger;
}
/// <summary>
/// Instantiate with the specified settings.
/// </summary>
/// <param name="clientCount">Optional.
/// The number of <see cref="SubscriberClient"/>s to create and use within a <see cref="SimpleSubscriber"/> instance.</param>
/// <param name="subscriberSettings">Optional. The settings to use when creating <see cref="SubscriberClient"/> instances.</param>
/// <param name="credentials">Optional. Credentials to use when creating <see cref="SubscriberClient"/> instances.</param>
/// <param name="serviceEndpoint">Optional.
/// The <see cref="ServiceEndpoint"/> to use when creating <see cref="SubscriberClient"/> instances.</param>
public ClientCreationSettings(
int?clientCount = null,
SubscriberSettings subscriberSettings = null,
ChannelCredentials credentials = null,
ServiceEndpoint serviceEndpoint = null)
{
ClientCount = clientCount;
SubscriberSettings = subscriberSettings;
Credentials = credentials;
ServiceEndpoint = serviceEndpoint;
}
public QuoteSubscriber(
SubscriberSettings settings,
IQuoteService quoteService,
IReadOnlyDictionary <string, string> assetPairMapping,
ILogFactory logFactory)
{
_settings = settings;
_quoteService = quoteService;
_assetPairMapping = assetPairMapping;
_logFactory = logFactory;
}
public QuoteSubscriber(
SubscriberSettings settings,
IQuoteService quoteService,
IMarketInstrumentService marketInstrumentService,
ILogFactory logFactory)
{
_settings = settings;
_quoteService = quoteService;
_marketInstrumentService = marketInstrumentService;
_logFactory = logFactory;
}
public IndexTickPriceSubscriber(
SubscriberSettings settings,
IIndexHandler indexHandler,
ILogFactory logFactory)
{
_settings = settings;
_indexHandler = indexHandler;
_logFactory = logFactory;
_log = logFactory.CreateLog(this);
}
public OrderBookSubscriber(
SubscriberSettings settings,
IOrderBookService orderBookService,
IMarketInstrumentService marketInstrumentService,
ILogFactory logFactory)
{
_settings = settings;
_orderBookService = orderBookService;
_marketInstrumentService = marketInstrumentService;
_logFactory = logFactory;
_log = logFactory.CreateLog(this);
}
public B2C2OrderBooksSubscriber(
SubscriberSettings settings,
IB2C2OrderBookService b2C2OrderBookService,
IMarketMakerService marketMakerService,
ILogFactory logFactory)
{
_settings = settings;
_b2C2OrderBookService = b2C2OrderBookService;
_marketMakerService = marketMakerService;
_logFactory = logFactory;
_log = logFactory.CreateLog(this);
}
public LykkeTradeSubscriber(
SubscriberSettings settings,
ISettingsService settingsService,
IPositionService positionService,
IDeduplicator deduplicator,
ILogFactory logFactory)
{
_settings = settings;
_settingsService = settingsService;
_positionService = positionService;
_deduplicator = deduplicator;
_logFactory = logFactory;
_log = logFactory.CreateLog(this);
}
/// <summary>
/// Создает новый экземпляр структуры <see cref="HandlerInfo"/>.
/// </summary>
/// <param name="messageType">Тип сообщения.</param>
/// <param name="attribute">Атрибут на обработчике.</param>
/// <param name="subscriberSettings">Настройки подписчика.</param>
/// <param name="handlerType">Тип обработчика сообщения.</param>
/// <param name="handlerMiddlewares">Список мидлварей на обработчике.</param>
public HandlerInfo(
Type messageType,
SubscriberConfigurationAttribute attribute,
SubscriberSettings subscriberSettings,
Type handlerType,
IEnumerable <MiddlewareAttribute> handlerMiddlewares
)
{
MessageType = messageType;
Attribute = attribute;
SubscriberSettings = subscriberSettings;
HandlerType = handlerType;
HandlerMiddlewares = handlerMiddlewares;
}
public LykkeTradeSubscriber(
SubscriberSettings settings,
ISettingsService settingsService,
IInternalTradeHandler[] internalTradeHandlers,
IDeduplicator deduplicator,
ILogFactory logFactory)
{
_settings = settings;
_settingsService = settingsService;
_internalTradeHandlers = internalTradeHandlers;
_deduplicator = deduplicator;
_logFactory = logFactory;
_log = logFactory.CreateLog(this);
}
public LykkeTradeSubscriber(
SubscriberSettings settings,
ISettingsService settingsService,
ITradeService tradeService,
ISummaryReportService summaryReportService,
IDeduplicator deduplicator,
ILogFactory logFactory)
{
_settings = settings;
_settingsService = settingsService;
_tradeService = tradeService;
_summaryReportService = summaryReportService;
_deduplicator = deduplicator;
_logFactory = logFactory;
_log = logFactory.CreateLog(this);
}
/// <summary>
/// Выполнить регистрацию подписчика на сообщения.
/// </summary>
/// <typeparam name="TMessage">Тип сообщения для обработки.</typeparam>
/// <param name="messageHandler">Обработчик сообщений.</param>
/// <param name="subscriberSettings">Настройки подписчика.</param>
/// <param name="onUnregister">Функция обратного вызова, для отслеживания ситуации, когда произошел дисконнект.</param>
public async Task RegisterAsync <TMessage>(
AcknowledgableMessageHandler <TMessage> messageHandler,
SubscriberSettings subscriberSettings,
Action <bool, string>?onUnregister = null
)
where TMessage : class, IMessage
{
var subscriber = _subscriberFactory.GetSubscriber <TMessage>();
for (var i = 0; i < subscriberSettings.ScalingSettings.ChannelsCount; i++)
{
await subscriber.SubscribeAsync(
messageHandler,
subscriberSettings,
onUnregister);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var settings = SubscriberSettings.ReadSettings();
var items = Reader.Read <Subscription>(settings.InputPath);
var resourceStore = new ResourceStore <Subscription>(items);
var subscriberThread = new SubscriberThread(resourceStore, settings);
new Thread(new ThreadStart(subscriberThread.Procedure)).Start();
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
IConfigurationRoot configuration = builder.Build();
services.Configure <SubscriberSettings>(configuration.GetSection("Settings"));
services.AddControllers();
}
/// <summary>
/// Оповестить брокер о результате обработки.
/// </summary>
/// <param name="acknowledgement">Данные о результате обработки.</param>
/// <param name="channel">Канал.</param>
/// <param name="messageContext">Контекст сообщения.</param>
/// <param name="settings">Настройки очереди.</param>
public Task HandleAsync <TMessage>(
Acknowledgement acknowledgement,
IModel channel,
MessageContext messageContext,
SubscriberSettings settings
) where TMessage : class, IMessage
{
return(acknowledgement switch
{
Ack _ => HandleAck(channel, messageContext, settings),
Reject reject => HandleRejectAsync <TMessage>(reject, channel, messageContext, settings),
Nack nack => HandleNackAsync <TMessage>(nack, channel, messageContext, settings),
Retry retry => HandleRetryAsync <TMessage>(retry, channel, messageContext, settings),
_ => throw new ArgumentOutOfRangeException(
nameof(acknowledgement),
typeof(Acknowledgement),
"Передан неизвестный подтип Acknowledgement."
)
});
/// <summary>
/// Выполнить регистрацию подписчика на сообщения.
/// </summary>
/// <typeparam name="TMessage">Тип сообщения для обработки.</typeparam>
/// <param name="eventHandler">Обработчик событий.</param>
/// <param name="subscriberSettings">Настройки подписчика.</param>
/// <param name="onUnregister">Функция обратного вызова, для отслеживания ситуации, когда произошел дисконнект.</param>
public Task RegisterAsync <TMessage>(
MessageHandler <TMessage> eventHandler,
SubscriberSettings subscriberSettings,
Action <bool, string>?onUnregister = null
)
where TMessage : class, IMessage
{
var handler = new AcknowledgableMessageHandler <TMessage>(message =>
{
return(eventHandler(message)
.ContinueWith <Acknowledgement>(_ => Ack.Ok));
});
return(RegisterAsync(
handler,
subscriberSettings,
onUnregister
));
}
public TopicSubscriberSelfDestroyingTopicWrapper(BusManager busManager,
SubscriberSettings <TMessage> subscriberSettings,
ITopicNameGetter topicNameGetter,
IMessageSerializer <TMessage> messageSerializer,
ILogger logger,
TrackingModule trackingModule)
{
_topicName = topicNameGetter.Get <TMessage>(subscriberSettings);
_busSubscriber = new TopicSubscriberV2 <TMessage>(
busManager,
subscriberSettings,
topicNameGetter,
messageSerializer,
logger,
trackingModule);
UsedTopics.Add(_topicName);
}
public GoogleCloudPubSubSinkTests(GoogleCloudPubsubFixture fixture)
{
this._fixture = fixture;
//---
this._projectId = this._fixture.ProjectId;
this._topicId = this._fixture.CreateTopicId();
this._subscriptionId = this._fixture.CreateSubscriptionId(this._topicId);
this._subscriptionIdFull = this._fixture.GetProjectSubsFull(this._subscriptionId);
//---
// It is necessary to specify a correct Deadline time (in UTC). If not then it is thrown
// the following error: Status(StatusCode=DeadlineExceeded, Detail="Deadline Exceeded")
ServiceEndpoint sep = null;
SubscriberSettings settings = new SubscriberSettings();
settings.PullSettings = new CallSettings();
settings.PullSettings.Timing = CallTiming.FromDeadline(DateTime.UtcNow.AddMinutes(5)); // 5 minutes deadline time.
// Client to access PubSub for subscriptions.
this._subscriberClient = SubscriberClient.Create(sep, settings);
}
/// <summary>
/// Объявить очередь с отложенной обработкой.
/// </summary>
/// <param name="channel">Канал.</param>
/// <param name="settings">Настройки подписчика.</param>
/// <param name="messageType">Тип сообщения.</param>
/// <param name="retryDelay">Период на которую откладывается обработка.</param>
/// <returns>Название очереди с отложенной обработкой.</returns>
public string DeclareDelayedQueue(IModel channel, SubscriberSettings settings, Type messageType, TimeSpan retryDelay)
{
var queueName = _namingConvention.QueueNamingConvention(messageType, settings);
var delayedQueueName = _namingConvention.DelayedQueueNamingConvention(messageType, settings, retryDelay);
channel.QueueDeclare(
queue: delayedQueueName,
// персистентность сообщений должна быть как у основной очереди.
durable: settings.Durable,
exclusive: false,
autoDelete: false,
arguments: new Dictionary <string, object>
{
// для отправки в основную очередь используется обменник по-умолчанию.
[QueueArgument.DEAD_LETTER_EXCHANGE] = string.Empty,
// сообщения будут возвращаться обратно в основную очередь по названию.
[QueueArgument.DEAD_LETTER_ROUTING_KEY] = queueName,
[QueueArgument.EXPIRES] = Convert.ToInt32(retryDelay.Add(TimeSpan.FromSeconds(10)).TotalMilliseconds),
[QueueArgument.MESSAGE_TTL] = Convert.ToInt32(retryDelay.TotalMilliseconds)
}
);
return(delayedQueueName);
}
