void Unlock(BrokerMessage message, Consumer exclude)
{
Consumer consumer = null;
lock (this.syncRoot)
{
message.Unlock();
consumer = this.GetConsumerWithLock(exclude);
if (consumer != null)
{
if (consumer.SettleOnSend)
{
this.messages.Remove(message.Node);
}
else
{
message.LockedBy = consumer;
}
}
}
if (consumer != null)
{
consumer.Signal(message);
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
GroupCreateDTO groupCreate = new GroupCreateDTO();
groupCreate.ObjectGuid = Guid.NewGuid().ToString().Replace("-", "");
groupCreate.SamAccountName = "Group SamAccountName 11111";
groupCreate.DisplayName = "Group DisplayName 1212121212";
groupCreate.Name = "Group Name 12121212";
groupCreate.Description = "Group Description 12121212";
groupCreate.DistinguishedName = "Group DistinguishedName asakdalk";
groupCreate.GroupScope = GroupScopeEnum.DOMAIN.ToString();
groupCreate.GroupType = GroupTypeEnum.DISTRIBUTION.ToString();
groupCreate.LastAdChangeMillis = DateTimeOffset.Now.ToUnixTimeMilliseconds();
SyncEventDTO body = new SyncEventDTO();
body.ActiveDirectoryId = "5c11b84a4e9b467d84356761448a997e";
body.Type = "GROUP_CREATE";
body.Message = groupCreate;
Console.WriteLine("ExecuteAsync ... ");
BrokerHeader header = new BrokerHeader();
header.Tenant = "12345";
header.User = "******";
BrokerMessage message = new BrokerMessage(header, body);
await _notifierService.Notify(message);
}
void Dequeue(BrokerMessage message)
{
lock (this.syncRoot)
{
this.messages.Remove(message.Node);
}
}
public static void AddRabbitMQConsumer(this IServiceCollection services)
{
services.AddHostedService <RabbitMQHostedConsumer>();
services.AddSingleton(sp =>
{
var rabbitMQOption = sp.GetService <IOptions <WarehouseRabbitMQOption> >()?.Value;
if (rabbitMQOption == null)
{
throw new ArgumentNullException("RabbitMQ Options is not being initialized");
}
return(new RabbitMQQueueConsumer(rabbitMQOption.QueueName
, new RabbitMqConnectionPool(rabbitMQOption.ConnectionString)
, async(body, serializer) =>
{
using var serviceScope = sp.GetRequiredService <IServiceScopeFactory>().CreateScope();
List <IMessageHandler> allHandlers = new();
allHandlers.Add(new DeliveryRequestMessageHandler(serviceScope, serializer, rabbitMQOption.WarehouseQueueName));
BrokerMessage message = serializer.DeserializeRequest <BrokerMessage>(body);
body.Position = 0;
var handler = allHandlers.FirstOrDefault(g => g.MessageType == message.MessageType);
if (handler == null)
{
throw new Exception($"Не найден обработчик сообщения {message.MessageType}");
}
await handler.HandleAsync(body);
}));
});
}
void OnDispose(Delivery delivery)
{
if (delivery.Transactional())
{
Transaction txn = this.queue.broker.txnManager.GetTransaction(((TransactionalState)delivery.State).TxnId);
txn.AddOperation(delivery, this.OnTxnDischarge);
this.link.DisposeDelivery(delivery, false, delivery.State, false);
}
else
{
if (!delivery.Settled)
{
this.link.DisposeDelivery(delivery, true, delivery.State);
}
BrokerMessage message = (BrokerMessage)delivery;
if (delivery.State.DescriptorCode == Accepted.Code ||
delivery.State.DescriptorCode == Rejected.Code ||
delivery.State.DescriptorCode == Modified.Code)
{
if (message.Node != null && message.Node.List != null)
{
this.queue.Dequeue(message);
}
delivery.Dispose();
}
else if (delivery.State.DescriptorCode == Released.Code)
{
this.queue.Unlock(message);
}
}
}
void Enqueue(BrokerMessage message)
{
// clone the message as the incoming one is associated with a delivery already
BrokerMessage clone = new BrokerMessage(message.Buffer);
Consumer consumer = null;
lock (this.syncRoot)
{
consumer = this.GetConsumerWithLock(null);
if (consumer == null)
{
clone.Node = this.messages.AddLast(clone);
}
else
{
if (!consumer.SettleOnSend)
{
clone.LockedBy = consumer;
clone.Node = this.messages.AddLast(clone);
}
}
}
if (consumer != null)
{
consumer.Signal(clone);
}
}
public bool Init()
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
var connection = factory.CreateConnection();
m_Channel = connection.CreateModel();
m_Channel.ExchangeDeclare(exchange: ExchangeId, type: "topic");
var queueName = m_Channel.QueueDeclare().QueueName;
m_Channel.QueueBind(queue: queueName,
exchange: ExchangeId,
routingKey: StockRoute);
var consumer = new EventingBasicConsumer(m_Channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var routingKey = ea.RoutingKey;
var keys = routingKey.Split('.');
if (keys.Length >= 3)
{
string root = keys[0];
string exchange = keys[1];
string dataType = keys[2];
if ("analysis".Equals(root, StringComparison.OrdinalIgnoreCase))
{
if ("transactions".Equals(dataType, StringComparison.OrdinalIgnoreCase))
{
BrokerMessage <IList <TransactionAnalysis> > message = null;
message = body.Deserialize <BrokerMessage <IList <TransactionAnalysis> > >();
if (message != null)
{
OnReceiveTransactionAnalysis?.Invoke(message.Data);
}
}
else
{
//unknow message
}
}
}
};
m_Channel.BasicConsume(queue: queueName,
noAck: true,
consumer: consumer);
return(true);
}
private static NetBrokerMessage getBrokerMessage(BrokerMessage brokerMessage)
{
NetBrokerMessage netBrokerMessage = new NetBrokerMessage(brokerMessage.Payload);
netBrokerMessage.Expiration = brokerMessage.Expiration;
netBrokerMessage.MessageId = brokerMessage.Message_id;
netBrokerMessage.Timestamp = brokerMessage.Timestamp;
return(netBrokerMessage);
}
public BrokerMessage process(BrokerMessage request)
{
String warning = String.Format("unimplemented; serviceName = '{0}'; methodName = '{1}'", request.getServiceName(), request.getMethodName());
log.warn(warning);
return BrokerMessage.buildResponse(request);
}
private static BrokerMessage getBrokerMessage(NetBrokerMessage brokerMessage)
{
BrokerMessage brokerMsg = new BrokerMessage();
brokerMsg.Expiration = brokerMessage.Expiration;
brokerMsg.Message_id = brokerMessage.MessageId;
brokerMsg.Payload = brokerMessage.Payload;
brokerMsg.Timestamp = brokerMessage.Timestamp;
return(brokerMsg);
}
void OnTxnDischarge(Delivery delivery, bool fail)
{
if (!fail)
{
BrokerMessage message = (BrokerMessage)delivery;
if (message.Node != null && message.Node.List != null)
{
this.queue.Dequeue(message);
}
this.link.DisposeDelivery(delivery, true, delivery.State);
delivery.Dispose();
}
}
internal async Task SendSmsAsync(Guid messageId, string phoneNumber, string message, Dictionary <string, string> messageParameters)
{
var brokerMessage = new BrokerMessage
{
MessageId = messageId,
Channel = Channel.Sms,
Properties = new Dictionary <string, string>
{
{ "PhoneNumber", phoneNumber },
{ "Message", message }
},
MessageParameters = messageParameters
};
await _brokerMessageEventPublisher.PublishAsync(brokerMessage);
}
public static void AddRabbitMQConsumer(this IServiceCollection services)
{
services.AddHostedService <RabbitMQHostedConsumer>();
services.AddSingleton(sp =>
{
var rabbitMQOption = sp.GetService <IOptions <WarehouseRabbitMQOption> >()?.Value;
var distributedCache = sp.GetService <IDistributedCache>();
if (rabbitMQOption == null)
{
throw new ArgumentNullException("RabbitMQ Options is not being initialized");
}
return(new RabbitMQQueueConsumer(rabbitMQOption.QueueName
, new RabbitMqConnectionPool(rabbitMQOption.ConnectionString)
, async(body, serializer) =>
{
using var serviceScope = sp.GetRequiredService <IServiceScopeFactory>().CreateScope();
List <IMessageHandler> allHandlers = new();
allHandlers.Add(new DeliveryResponseMessageHandler(serviceScope, serializer));
allHandlers.Add(new UpdateProductCounterByReserveMessageHandler(serviceScope, serializer));
allHandlers.Add(new UpdateProductCounterByShipmentMessageHandler(serviceScope, serializer));
allHandlers.Add(new UpdateProductCounterByResetReserveMessageHandler(serviceScope, serializer));
BrokerMessage message = serializer.DeserializeRequest <BrokerMessage>(body);
string cacheKey = message.MessageType + message.Id;
if (await distributedCache.GetAsync(cacheKey) != null)
{
return;
}
var handler = allHandlers.FirstOrDefault(g => g.MessageType == message.MessageType);
if (handler == null)
{
throw new Exception($"Не найден обработчик сообщения {message.MessageType}");
}
await handler.HandleAsync(body);
distributedCache.Set(cacheKey, Array.Empty <byte>(), new DistributedCacheEntryOptions
{
AbsoluteExpiration = DateTime.UtcNow.AddDays(2)
});
}));
});
}
internal async Task SendEmailMessageAsync(Guid messageId, string customerEmail, string subject, string message,
Dictionary <string, string> messageParameters)
{
var brokerMessage = new BrokerMessage
{
MessageId = messageId,
Channel = Channel.Email,
Properties = new Dictionary <string, string>
{
{ "Email", customerEmail },
{ "Subject", subject },
{ "Body", message }
},
MessageParameters = messageParameters
};
await _brokerMessageEventPublisher.PublishAsync(brokerMessage);
}
public async Task <ActionResult <BrokerContent> > BrokerPost([FromForm] BrokerContent content)
{
var files = Request.Form.Files.Any() ? Request.Form.Files : new FormFileCollection();
if (!files.Any())
{
files = null;
}
var email = content.Email;
var serviceProvider = content.Provider;
var number = content.PhoneNumber;
var name = content.Name;
var message = new BrokerMessage(new[] { "*****@*****.**" }, name, email, serviceProvider, number, files);
await _emailSender.SendMailAsync(message);
return(Ok());
}
private async Task ProcessMessageAsync(BrokerMessage message)
{
_log.Info("Message received", process: nameof(ProcessMessageAsync), context: new
{
message.MessageId
});
if (message.Channel == Channel.PushNotification)
{
await _service.ProcessNotificationMessageAsync(
message.MessageId,
message.Properties["PushRegistrationId"],
message.Properties["MessageGroupId"],
message.Properties["CustomerId"],
message.Properties["Message"],
message.Properties["CustomPayload"],
message.MessageParameters);
}
}
public async Task <BrokerResult> SendMessage(BrokerMessage brokerMessage)
{
try
{
var result = await Producer.ProduceAsync(
brokerMessage.TopicName,
new Message <Null, string> {
Value = brokerMessage.Message
}
);
return(new BrokerResult(true, $"Mensagem '{result.Value}' de '{result.TopicPartitionOffset}'"));
}
catch (ProduceException <Null, string> e)
{
Console.WriteLine($"Delivery failed: {e.Error.Reason}");
}
return(new BrokerResult(false, string.Empty));
}
internal async Task SendPushNotificationAsync(Guid messageId, Guid messageGroupId, string pushRegistrationId,
string customerId, string message, Dictionary <string, string> customPayload,
Dictionary <string, string> messageParameters)
{
var brokerMessage = new BrokerMessage
{
MessageId = messageId,
Channel = Channel.PushNotification,
Properties = new Dictionary <string, string>
{
{ "PushRegistrationId", pushRegistrationId },
{ "MessageGroupId", messageGroupId.ToString() },
{ "CustomerId", customerId },
{ "Message", message },
{ "CustomPayload", JsonConvert.SerializeObject(customPayload) },
},
MessageParameters = messageParameters
};
await _brokerMessageEventPublisher.PublishAsync(brokerMessage);
}
void Enqueue(BrokerMessage message)
{
Consumer consumer = null;
lock (this.syncRoot)
{
consumer = this.GetConsumerWithLock();
if (consumer == null)
{
message.Node = this.messages.AddLast(message);
}
else if (consumer.SettleMode != SettleMode.SettleOnSend)
{
message.LockedBy = consumer;
message.Node = this.messages.AddLast(message);
}
}
if (consumer != null)
{
consumer.Signal(message);
}
}
public void Signal(BrokerMessage message)
{
this.link.SendMessage(message, message.Buffer);
}
public void onFault(BrokerMessage request, Exception fault)
{
log.enteredMethod();
String javascript = JavascriptCallbackAdapterHelper.buildJavascriptFault(request, fault);
postJavascript(javascript);
}
public void onResponse(BrokerMessage request, BrokerMessage response)
{
log.enteredMethod();
String javascript = JavascriptCallbackAdapterHelper.buildJavascriptResponse(response);
postJavascript(javascript);
}
public bool Init(string queueName = null)
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
var connection = factory.CreateConnection();
m_Channel = connection.CreateModel();
m_Channel.ExchangeDeclare(exchange: ExchangeId, type: "topic");
var uniqueQueueName = string.Empty;
if (string.IsNullOrEmpty(queueName))
{
uniqueQueueName = m_Channel.QueueDeclare().QueueName;
}
else
{
uniqueQueueName = m_Channel.QueueDeclare(queue: queueName).QueueName;
}
m_Channel.QueueBind(queue: uniqueQueueName,
exchange: ExchangeId,
routingKey: StockRoute);
var consumer = new EventingBasicConsumer(m_Channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var routingKey = ea.RoutingKey;
var keys = routingKey.Split('.');
if (keys.Length >= 3)
{
string root = keys[0];
string exchange = keys[1];
string dataType = keys[2];
if ("stock".Equals(root, StringComparison.OrdinalIgnoreCase))
{
if ("instruments".Equals(dataType, StringComparison.OrdinalIgnoreCase))
{
BrokerMessage <IList <Instrument> > message = null;
if (ea.BasicProperties != null && ContentTypeJson.Equals(ea.BasicProperties.ContentType))
{
string json = Encoding.ASCII.GetString(body);
message = JsonConvert.DeserializeObject <BrokerMessage <IList <Instrument> > >(json);
}
else
{
message = body.Deserialize <BrokerMessage <IList <Instrument> > >();
}
if (message != null)
{
OnChangeInstruments?.Invoke(message.Data);
}
}
else if ("orders".Equals(dataType, StringComparison.OrdinalIgnoreCase))
{
BrokerMessage <IList <PairOrder> > message = null;
if (ea.BasicProperties != null && ContentTypeJson.Equals(ea.BasicProperties.ContentType))
{
string json = Encoding.ASCII.GetString(body);
message = JsonConvert.DeserializeObject <BrokerMessage <IList <PairOrder> > >(json);
}
else
{
message = body.Deserialize <BrokerMessage <IList <PairOrder> > >();
}
if (message != null)
{
OnChangePairOrder?.Invoke(message.Data);
}
}
else if ("deepOrders".Equals(dataType, StringComparison.OrdinalIgnoreCase))
{
BrokerMessage <IList <PairOrder> > message = null;
if (ea.BasicProperties != null && ContentTypeJson.Equals(ea.BasicProperties.ContentType))
{
string json = Encoding.ASCII.GetString(body);
message = JsonConvert.DeserializeObject <BrokerMessage <IList <PairOrder> > >(json);
}
else
{
message = body.Deserialize <BrokerMessage <IList <PairOrder> > >();
}
if (message != null)
{
OnChangeDeepPairOrder?.Invoke(message.Data);
}
}
else if ("transactions".Equals(dataType, StringComparison.OrdinalIgnoreCase))
{
BrokerMessage <TransactionsInfo> message = null;
if (ea.BasicProperties != null && ContentTypeJson.Equals(ea.BasicProperties.ContentType))
{
string json = Encoding.ASCII.GetString(body);
message = JsonConvert.DeserializeObject <BrokerMessage <TransactionsInfo> >(json);
}
else
{
message = body.Deserialize <BrokerMessage <TransactionsInfo> >();
}
if (message != null)
{
OnChangeTransaction?.Invoke(message.Data);
}
}
else
{
//unknow message
}
}
}
};
m_Channel.BasicConsume(queue: uniqueQueueName,
noAck: true,
consumer: consumer);
return(true);
}
void Enqueue(BrokerMessage message)
{
// clone the message as the incoming one is associated with a delivery already
BrokerMessage clone = new BrokerMessage(message.Buffer);
Consumer consumer = null;
lock (this.syncRoot)
{
consumer = this.GetConsumerWithLock();
if (consumer == null)
{
clone.Node = this.messages.AddLast(clone);
}
else
{
if (!consumer.SettleOnSend)
{
clone.LockedBy = consumer;
clone.Node = this.messages.AddLast(clone);
}
}
}
if (consumer != null)
{
consumer.Signal(clone);
}
}
public void Signal(BrokerMessage message)
{
this.link.SendMessage(message, message.Buffer);
}
public void Signal(BrokerMessage message)
{
this.link.SendMessageNoWait(message, this.GetNextTag(), AmqpConstants.NullBinary);
}
public void Signal(BrokerMessage message)
{
this.link.SendMessageNoWait(message, this.GetNextTag(), AmqpConstants.NullBinary);
}
public void Unlock(BrokerMessage message)
{
Consumer consumer = null;
lock (this.syncRoot)
{
message.Unlock();
consumer = this.GetConsumerWithLock();
if (consumer != null)
{
if (consumer.SettleMode == SettleMode.SettleOnSend)
{
this.messages.Remove(message.Node);
}
else
{
message.LockedBy = consumer;
}
}
}
if (consumer != null)
{
consumer.Signal(message);
}
}
public void Dequeue(BrokerMessage message)
{
lock (this.syncRoot)
{
this.messages.Remove(message.Node);
}
}
public async Task PublishAsync(BrokerMessage message)
{
await _publisher.ProduceAsync(message);
}
private void NotifyListeners(BrokerMessage message)
{
if (message != null)
{
// Notify clients
// queue clients notification for execution, so that this thread could
// release the lock (clients notification could be lengthy)
ThreadPool.QueueUserWorkItem(delegate(object state)
{
lock (this)
{
if (_brokerHandlerDelegate != null)
{
foreach (BrokerHandler handler in _brokerHandlerDelegate.GetInvocationList())
{
try
{
handler(message);
}
catch { }
}
}
}
//_brokerHandlerDelegate(sp.Body.Notification.BrokerMessage);
});
}
}
public static void AddRabbitMQConsumer(this IServiceCollection services)
{
services.AddHostedService <RabbitMQHostedConsumer>();
services.AddSingleton(sp =>
{
var rabbitMQOption = sp.GetService <IOptions <RabbitMQOption> >()?.Value;
if (rabbitMQOption == null)
{
throw new ArgumentNullException("RabbitMQ Options is not being initialized");
}
return(new RabbitMQQueueConsumer(rabbitMQOption.QueueName
, new RabbitMqConnectionPool(rabbitMQOption.ConnectionString)
, async(body, serializer) =>
{
using var serviceScope = sp.GetRequiredService <IServiceScopeFactory>().CreateScope();
var repository = serviceScope.ServiceProvider.GetService <NotificationRepository>();
var smtpService = serviceScope.ServiceProvider.GetService <SmtpService>();
BrokerMessage message = serializer.DeserializeRequest <BrokerMessage>(body);
body.Position = 0;
switch (message.MessageType)
{
case OrderCreated.TYPE:
{
var orderCreated = serializer.DeserializeRequest <OrderCreated>(body);
smtpService.SendEmail("Заказ оплачен", @$ "Заказ №{ orderCreated.OrderNumber}
на сумму { orderCreated.Price}
успешно оплачен", orderCreated.UserEmail);
break;
}
case OrderCreatedError.TYPE:
{
var orderCreatedError = serializer.DeserializeRequest <OrderCreatedError>(body);
smtpService.SendEmail("Заказ отменен", $"Заказ отменен по причине {orderCreatedError.Message}", orderCreatedError.UserEmail);
}
break;
case OrderWasPayment.TYPE:
{
var orderWasPayment = serializer.DeserializeRequest <OrderWasPayment>(body);
smtpService.SendEmail("Заказ оплачен", $"Заказ №{orderWasPayment.OrderNumber} на сумму {orderWasPayment.Price} успешно оплачен", orderWasPayment.UserEmail);
}
break;
case OrderRefundPayment.TYPE:
{
var orderRefundPayment = serializer.DeserializeRequest <OrderRefundPayment>(body);
smtpService.SendEmail("Возврат денежных средства", $"Возврат оплаты заказа №{ orderRefundPayment.OrderNumber} на сумму { orderRefundPayment.Price}"
, orderRefundPayment.UserEmail);
}
break;
case OrderReadyToDelivery.TYPE:
{
var orderToDelivery = serializer.DeserializeRequest <OrderReadyToDelivery>(body);
smtpService.SendEmail("Товар отгружен", $"Заказ №{orderToDelivery.OrderNumber} отгружен. Отслеживайте местоположение заказа на сайте http://гдемойтовар/{orderToDelivery.OrderNumber}"
, orderToDelivery.UserEmail);
}
break;
default:
throw new Exception($"Malformed message type {message.MessageType}");
}
}));
});
}
void Enqueue(BrokerMessage message)
{
Consumer consumer = null;
lock (this.syncRoot)
{
consumer = this.GetConsumerWithLock();
if (consumer == null)
{
message.Node = this.messages.AddLast(message);
}
else if (consumer.SettleMode != SettleMode.SettleOnSend)
{
message.LockedBy = consumer;
message.Node = this.messages.AddLast(message);
}
}
if (consumer != null)
{
consumer.Signal(message);
}
}
public void Signal(BrokerMessage message)
{
this.link.SendMessageNoWait(message, this.GetNextTag(), new ArraySegment <byte>());
}
