public IMessageConsumer CreateTopicSubscription(string[] topics,
string subscriptionName,
OnMessagesReceived onMessagesReceived,
string consumerId,
ConsumerConfig consumerConfig,
bool start = true)
{
var channel = _connection.CreateModel();
var queueName = channel.QueueDeclare(subscriptionName, true, false, false, null).QueueName;
topics.ForEach(topic =>
{
topic = Configuration.Instance.FormatMessageQueueName(topic);
channel.ExchangeDeclare(topic, ExchangeType.Fanout, true, false, null);
channel.QueueBind(queueName,
topic,
string.Empty);
});
var subscriber = new RabbitMQConsumer(channel,
topics,
queueName,
consumerId,
BuildOnRabbitMQMessageReceived(onMessagesReceived),
consumerConfig);
if (start)
{
subscriber.Start();
}
return(subscriber);
}
public ICommitOffsetable StartQueueClient(string commandQueueName,
string consumerId,
OnMessagesReceived onMessagesReceived,
ConsumerConfig consumerConfig = null)
{
throw new NotImplementedException();
}
public IMessageConsumer CreateQueueConsumer(string commandQueueName,
OnMessagesReceived onMessagesReceived,
string consumerId,
ConsumerConfig consumerConfig,
bool start = true)
{
var channel = _connection.CreateModel();
commandQueueName = Configuration.Instance.FormatMessageQueueName(commandQueueName);
channel.QueueDeclare(commandQueueName, true, false, false, null);
channel.BasicQos(0, (ushort)consumerConfig.FullLoadThreshold, false);
var consumer = new RabbitMQConsumer(channel,
new [] { commandQueueName },
commandQueueName,
consumerId,
BuildOnRabbitMQMessageReceived(onMessagesReceived),
consumerConfig);
if (start)
{
consumer.Start();
}
return(consumer);
}
private void HandleBotResponse(object sender, BotResponseEventArgs e)
{
Debug.Log($"Response from Bot of type: {e.EventType}");
switch (e.EventType)
{
case EventTypes.None:
break;
case EventTypes.ConversationStarted:
OnConversationStarted?.Invoke(this, e.ConversationId);
break;
case EventTypes.MessageSent:
OnMessageSent?.Invoke(this, e.SentMessageId);
break;
case EventTypes.MessageReceived:
OnMessagesReceived?.Invoke(this, e.Messages);
break;
case EventTypes.Error:
break;
}
}
public SubscriptionConsumer(string id,
OnMessagesReceived onMessagesReceived,
SubscriptionClient subscriptionClient)
: base(id, onMessagesReceived)
{
_subscriptionClient = subscriptionClient;
}
public ICommitOffsetable StartSubscriptionClient(string topic,
string subscriptionName,
string consumerId,
OnMessagesReceived onMessagesReceived,
ConsumerConfig consumerConfig = null)
{
throw new NotImplementedException();
}
public IMessageConsumer CreateQueueConsumer(string commandQueueName,
OnMessagesReceived onMessagesReceived,
string consumerId,
ConsumerConfig consumerConfig,
bool start = true)
{
throw new NotImplementedException();
}
void ReceiveMessages(CancellationTokenSource cancellationTokenSource, OnMessagesReceived onMessagesReceived, EQueueConsumer equeueConsumer)
{
IEnumerable <EQueueMessages.QueueMessage> messages = null;
#region peek messages that not been consumed since last time
while (!cancellationTokenSource.IsCancellationRequested)
{
try
{
messages = equeueConsumer.PullMessages(100, 2000, cancellationTokenSource.Token);
foreach (var message in messages)
{
try
{
var equeueMessage = Encoding.UTF8.GetString(message.Body).ToJsonObject <EQueueMessage>();
var messageContext = new MessageContext(equeueMessage, message.QueueId, message.QueueOffset);
equeueConsumer.AddMessage(message);
onMessagesReceived(messageContext);
equeueConsumer.BlockIfFullLoad();
}
catch (OperationCanceledException)
{
return;
}
catch (ThreadAbortException)
{
return;
}
catch (Exception ex)
{
if (message.Body != null)
{
equeueConsumer.RemoveMessage(message.QueueId, message.QueueOffset);
}
_logger.Error(ex.GetBaseException().Message, ex);
}
}
}
catch (OperationCanceledException)
{
return;
}
catch (ThreadAbortException)
{
return;
}
catch (Exception ex)
{
if (!cancellationTokenSource.IsCancellationRequested)
{
Thread.Sleep(1000);
_logger.Error(ex.GetBaseException().Message, ex);
}
}
}
#endregion
}
public IMessageConsumer CreateTopicSubscription(string topic,
string subscriptionName,
OnMessagesReceived onMessagesReceived,
string consumerId,
ConsumerConfig consumerConfig,
bool start = true)
{
throw new NotImplementedException();
}
void ReceiveMessages(CancellationTokenSource cancellationTokenSource, OnMessagesReceived onMessagesReceived, KafkaConsumer kafkaConsumer)
{
IEnumerable <Kafka.Client.Messages.Message> messages = null;
#region peek messages that not been consumed since last time
while (!cancellationTokenSource.IsCancellationRequested)
{
try
{
messages = kafkaConsumer.GetMessages(cancellationTokenSource.Token);
foreach (var message in messages)
{
try
{
var kafkaMessage = Encoding.UTF8.GetString(message.Payload).ToJsonObject <KafkaMessage>();
var messageContext = new MessageContext(kafkaMessage, message.PartitionId.Value, message.Offset);
kafkaConsumer.AddMessage(message);
onMessagesReceived(messageContext);
kafkaConsumer.BlockIfFullLoad();
}
catch (OperationCanceledException)
{
return;
}
catch (ThreadAbortException)
{
return;
}
catch (Exception ex)
{
if (message.Payload != null)
{
kafkaConsumer.RemoveMessage(message.PartitionId.Value, message.Offset);
}
_logger.Error(ex.GetBaseException().Message, ex);
}
}
}
catch (OperationCanceledException)
{
return;
}
catch (ThreadAbortException)
{
return;
}
catch (Exception ex)
{
if (!cancellationTokenSource.IsCancellationRequested)
{
Thread.Sleep(1000);
_logger.Error(ex.GetBaseException().Message, ex);
}
}
}
#endregion
}
private OnRabbitMQMessageReceived BuildOnRabbitMQMessageReceived(OnMessagesReceived onMessagesReceived)
{
return((consumer, args) =>
{
var message = Encoding.UTF8.GetString(args.Body).ToJsonObject <RabbitMQMessage>();
var messageContext = new MessageContext(message, new MessageOffset(string.Empty, args.Exchange, 0, (long)args.DeliveryTag));
onMessagesReceived(messageContext);
});
}
private OnEQueueMessageReceived BuildOnEQueueMessageReceived(OnMessagesReceived onMessagesReceived)
{
return((consumer, message) =>
{
var equeueMessage = Encoding.UTF8.GetString(message.Body).ToJsonObject <EQueueMessage>();
var messageContext = new MessageContext(equeueMessage, message.QueueId, message.QueueOffset);
onMessagesReceived(messageContext);
});
}
public IMessageConsumer StartQueueClient(string commandQueueName,
string consumerId,
OnMessagesReceived onMessagesReceived,
ConsumerConfig consumerConfig = null)
{
commandQueueName = Configuration.Instance.FormatMessageQueueName(commandQueueName);
var queue = CommandQueues.GetOrAdd(commandQueueName, key => new BlockingCollection <IMessageContext>());
var queueClient = new QueueClient(commandQueueName, consumerId, onMessagesReceived, queue);
return(queueClient);
}
public ICommitOffsetable StartQueueClient(string commandQueueName,
string consumerId,
OnMessagesReceived onMessagesReceived,
ConsumerConfig consumerConfig = null)
{
commandQueueName = $"{commandQueueName}.{consumerId}";
commandQueueName = Configuration.Instance.FormatMessageQueueName(commandQueueName);
var commandQueueClient = CreateQueueClient(commandQueueName);
return(new QueueConsumer(commandQueueName, onMessagesReceived, commandQueueClient));
}
public SubscriptionClient(string topic, string subscriptionName, string consumerId, OnMessagesReceived onMessagesReceived, bool start = true)
{
_topic = topic;
_subscriptionName = subscriptionName;
Id = consumerId;
_onMessagesReceived = onMessagesReceived;
if (start)
{
Start();
}
}
public IMessageConsumer StartSubscriptionClient(string topic,
string subscriptionName,
string consumerId,
OnMessagesReceived onMessagesReceived,
ConsumerConfig consumerConfig = null)
{
return(StartSubscriptionClient(new[] { topic },
subscriptionName,
consumerId,
onMessagesReceived,
consumerConfig));
}
private EQueueConsumer CreateSubscriptionClient(string topic,
string subscriptionName,
OnMessagesReceived onMessagesReceived,
string consumerId = null,
ConsumerConfig consumerConfig = null)
{
var consumer = new EQueueConsumer(ClusterName, NameServerList, topic, subscriptionName, consumerId,
BuildOnEQueueMessageReceived(onMessagesReceived),
consumerConfig);
return(consumer);
}
public ICommitOffsetable StartSubscriptionClient(string topic,
string subscriptionName,
string consumerId,
OnMessagesReceived onMessagesReceived,
ConsumerConfig consumerConfig = null)
{
topic = Configuration.Instance.FormatMessageQueueName(topic);
subscriptionName = Configuration.Instance.FormatMessageQueueName(subscriptionName);
var subscriptionClient = CreateSubscriptionClient(topic, subscriptionName);
return(new SubscriptionConsumer($"{topic}.{subscriptionName}", onMessagesReceived, subscriptionClient));
}
private EQueueConsumer CreateQueueConsumer(string commandQueueName,
string consumerId,
OnMessagesReceived onMessagesReceived,
ConsumerConfig consumerConfig = null)
{
var consumer = new EQueueConsumer(ClusterName, NameServerList, commandQueueName,
commandQueueName, consumerId,
BuildOnEQueueMessageReceived(onMessagesReceived),
consumerConfig);
return(consumer);
}
public ICommitOffsetable StartQueueClient(string commandQueueName,
string consumerId,
OnMessagesReceived onMessagesReceived,
ConsumerConfig consumerConfig = null)
{
commandQueueName = Configuration.Instance.FormatMessageQueueName(commandQueueName);
consumerId = Configuration.Instance.FormatMessageQueueName(consumerId);
var queueConsumer = CreateQueueConsumer(commandQueueName, consumerId, onMessagesReceived, consumerConfig);
_queueConsumers.Add(queueConsumer);
return(queueConsumer);
}
private KafkaConsumer <string, KafkaMessage> CreateSubscriptionClient(string topic,
string subscriptionName,
OnMessagesReceived onMessagesReceived,
string consumerId = null,
ConsumerConfig consumerConfig = null)
{
CreateTopicIfNotExists(topic);
return(new KafkaConsumer <string, KafkaMessage>(_brokerList, topic, subscriptionName, consumerId,
BuildOnKafkaMessageReceived(onMessagesReceived),
new StringDeserializer(Encoding.UTF8),
new KafkaMessageDeserializer(),
consumerConfig));
}
private KafkaConsumer <string, KafkaMessage> CreateQueueConsumer(string queue,
OnMessagesReceived onMessagesReceived,
string consumerId = null,
ConsumerConfig consumerConfig = null)
{
CreateTopicIfNotExists(queue);
var queueConsumer = new KafkaConsumer <string, KafkaMessage>(_brokerList, queue, $"{queue}.consumer", consumerId,
BuildOnKafkaMessageReceived(onMessagesReceived),
new StringDeserializer(Encoding.UTF8),
new KafkaMessageDeserializer(),
consumerConfig);
return(queueConsumer);
}
public QueueClient(string queue,
string consumerId,
OnMessagesReceived onMessagesReceived,
BlockingCollection <IMessageContext> messageQueue,
bool start = true)
{
_queue = queue;
_messageQueue = messageQueue;
Id = consumerId;
_onMessagesReceived = onMessagesReceived;
if (start)
{
Start();
}
}
public IMessageConsumer StartQueueClient(string commandQueueName,
string consumerId,
OnMessagesReceived onMessagesReceived,
ConsumerConfig consumerConfig = null)
{
commandQueueName = Configuration.Instance.FormatMessageQueueName(commandQueueName);
consumerId = Configuration.Instance.FormatMessageQueueName(consumerId);
var queueConsumer = _clientProvider.CreateQueueConsumer(commandQueueName,
onMessagesReceived,
consumerId,
consumerConfig);
QueueConsumers.Add(queueConsumer);
return(queueConsumer);
}
public IMessageConsumer CreateQueueConsumer(string queue,
OnMessagesReceived onMessagesReceived,
string consumerId,
ConsumerConfig consumerConfig,
bool start = true)
{
var consumer = new KafkaConsumer <string, KafkaMessage>(_brokerList, new [] { queue }, $"{queue}.consumer", consumerId,
BuildOnKafkaMessageReceived(onMessagesReceived),
consumerConfig);
if (start)
{
consumer.Start();
}
return(consumer);
}
public IMessageConsumer CreateTopicSubscription(string[] topics,
string subscriptionName,
OnMessagesReceived onMessagesReceived,
string consumerId,
ConsumerConfig consumerConfig,
bool start = true)
{
var consumer = new KafkaConsumer <string, KafkaMessage>(_brokerList, topics, subscriptionName, consumerId,
BuildOnKafkaMessageReceived(onMessagesReceived),
consumerConfig);
if (start)
{
consumer.Start();
}
return(consumer);
}
public IMessageConsumer StartSubscriptionClient(string[] topics,
string subscriptionName,
string consumerId,
OnMessagesReceived onMessagesReceived,
ConsumerConfig consumerConfig = null)
{
topics = topics.Select(topic => Configuration.Instance.FormatMessageQueueName(topic))
.ToArray();
var client = new SubscriptionClient(topics, subscriptionName, consumerId, onMessagesReceived);
topics.ForEach(topic =>
{
var clients = SubscriptionClients.GetOrAdd(topic, key => new List <SubscriptionClient>());
clients.Add(client);
});
return(client);
}
public IMessageConsumer StartSubscriptionClient(string[] topics,
string subscriptionName,
string consumerId,
OnMessagesReceived onMessagesReceived,
ConsumerConfig consumerConfig = null)
{
topics = topics.Select(topic => Configuration.Instance.FormatMessageQueueName(topic))
.ToArray();
subscriptionName = Configuration.Instance.FormatMessageQueueName(subscriptionName);
var topicSubscription = _clientProvider.CreateTopicSubscription(topics,
subscriptionName,
onMessagesReceived,
consumerId,
consumerConfig);
Subscribers.Add(topicSubscription);
return(topicSubscription);
}
public IMessageConsumer CreateQueueConsumer(string commandQueueName,
OnMessagesReceived onMessagesReceived,
string consumerId,
ConsumerConfig consumerConfig,
bool start = true)
{
var consumer = new EQueueConsumer(_clusterName,
_nameServerList,
new[] { commandQueueName },
commandQueueName,
consumerId,
BuildOnEQueueMessageReceived(onMessagesReceived),
consumerConfig);
if (start)
{
consumer.Start();
}
return(consumer);
}
public IMessageConsumer CreateTopicSubscription(string[] topics,
string subscriptionName,
OnMessagesReceived onMessagesReceived,
string consumerId,
ConsumerConfig consumerConfig,
bool start = true)
{
var consumer = new EQueueConsumer(_clusterName,
_nameServerList,
topics,
subscriptionName,
consumerId,
BuildOnEQueueMessageReceived(onMessagesReceived),
consumerConfig);
if (start)
{
consumer.Start();
}
return(consumer);
}
