public async Task CallsSendAsync()
{
var(sender, clientMock) = await ComposeServiceBusAndGetSender();
var message = new Message();
await sender.SendAsync(message);
clientMock.Mock.Verify(o => o.SendAsync(message), Times.Once);
}
public async Task LogIssueAsync(
Issue issue,
CancellationToken cancellationToken = default)
{
_issues.Add(issue);
await _eventSender.SendAsync(
new PublishDocumentEvent(_sessionId, issue),
cancellationToken)
.ConfigureAwait(false);
}
public async Task SendAsync <TMessage>(
TMessage messageEntity,
IDictionary <string, object> userProperties = null) where TMessage : class
{
var message = GenerateMessage(OutboundMessage <TMessage> .FromEntity(messageEntity, userProperties));
var sw = Stopwatch.StartNew();
await _sender.SendAsync(message).ConfigureAwait(false);
TrackDependency(sw, nameof(SendAsync), userProperties);
_logger.LogDebug(LogEventIds.OutboundGatewaySentSingle, $"Sent single message of type {typeof(TMessage).Name}");
}
private async Task sendAndWaitAsync(AbstractMessage msg)
{
sendId = msg.ID;
if (ON_MESSAGE != null)
{
MESSAGE_SENDER.NewValidMessage -= MESSAGE_SENDER_NewValidMessage;
MESSAGE_SENDER.NewValidMessage += MESSAGE_SENDER_NewValidMessage;
}
TIMER_SEMA.Wait();
bool success = await MESSAGE_SENDER.SendAsync(msg).ConfigureAwait(false);
if (ON_TIMEOUT != null)
{
if (!success)
{
ON_TIMEOUT(this);
}
startTimer();
}
if (disposed)
{
return;
}
TIMER_SEMA.Release();
}
public async Task <ActionResult <IEnumerable <string> > > Get()
{
var log = new List <string>();
var sessionId = Guid.NewGuid().ToString();
log.Add($"Creating session {sessionId}");
IMessageSession session = await _sessionClient.AcceptMessageSessionAsync(sessionId);
Message response = null;
var t = session.ReceiveAsync(new TimeSpan(0, 5, 0))
.ContinueWith(m => response = m.Result)
.ContinueWith(m => log.Add($"received response from service for {sessionId}"));
var message = new Message(Encoding.UTF8.GetBytes("test message"))
{
SessionId = sessionId
};
await _messageSender.SendAsync(message);
log.Add($"Sent work request for {sessionId}");
await t;
await session.CompleteAsync(response.SystemProperties.LockToken);
log.Add($"Completed session: {sessionId}");
return(log);
}
public async Task <int> PublishEvents()
{
var events = _eventLogRepository.GetAll()
.Where(x => !x.Published)
.OrderBy(x => x.CreatedDateTime)
.Take(50)
.ToList();
foreach (var eventLog in events)
{
if (eventLog.EventType == "AUDIT_LOG_ENTRY_CREATED")
{
var logEntry = JsonSerializer.Deserialize <AuditLogEntry>(eventLog.Message);
await _auditLogCreatedEventSender.SendAsync(new AuditLogCreatedEvent { AuditLog = logEntry });
}
else
{
// TODO: Take Note
}
eventLog.Published = true;
eventLog.UpdatedDateTime = _dateTimeProvider.OffsetNow;
await _eventLogRepository.UnitOfWork.SaveChangesAsync();
}
return(events.Count);
}
public async Task SendAsync(IEnumerable <IDomainEvent> events)
{
foreach (var domainEvent in events)
{
await _sender.SendAsync(BuildBrokeredMessage(domainEvent));
}
}
public async Task HandleAsync(EntityCreatedEvent <FileEntry> domainEvent)
{
using (var scope = _serviceProvider.CreateScope())
{
var auditSerivce = scope.ServiceProvider.GetService <IAuditLogService>();
var currentUser = scope.ServiceProvider.GetService <ICurrentUser>();
await auditSerivce.AddOrUpdateAsync(new AuditLogEntryDTO
{
UserId = currentUser.IsAuthenticated ? currentUser.UserId : Guid.Empty,
CreatedDateTime = domainEvent.EventDateTime,
Action = "CREATED_FILEENTRY",
ObjectId = domainEvent.Entity.Id.ToString(),
Log = domainEvent.Entity.AsJsonString(),
});
IMessageSender <FileUploadedEvent> fileUploadedEventSender = scope.ServiceProvider.GetService <IMessageSender <FileUploadedEvent> >();
// Forward to external systems
await fileUploadedEventSender.SendAsync(new FileUploadedEvent
{
FileEntry = domainEvent.Entity,
});
}
}
static async Task SendSessionMessagesAsync(int numberOfSessions, int messagesPerSession)
{
if (numberOfSessions == 0 || messagesPerSession == 0)
{
await Task.FromResult(false);
}
var random = new Random();
for (int i = numberOfSessions - 1; i >= 0; i--)
{
var messagesToSend = new List <Message>();
string sessionId = SessionPrefix + i;
for (int j = 0; j < messagesPerSession; j++)
{
var text = random.Next().ToString();
// Create a new message to send to the queue
var message = new Message(Encoding.UTF8.GetBytes(text));
// Assign a SessionId for the message
message.SessionId = sessionId;
messagesToSend.Add(message);
// Write the sessionId, body of the message to the console
Console.WriteLine($"Sending SessionId: {message.SessionId}, message: {text}");
}
// Send a batch of messages corresponding to this sessionId to the queue
await messageSender.SendAsync(messagesToSend);
}
Console.WriteLine("=====================================");
Console.WriteLine($"Sent {messagesPerSession} messages each for {numberOfSessions} sessions.");
Console.WriteLine("=====================================");
}
public async Task <int> ResendSmsMessageAsync()
{
var dateTime = _dateTimeProvider.OffsetNow.AddMinutes(-1);
var messages = _repository.GetAll()
.Where(x => x.SentDateTime == null && x.RetriedCount < 3)
.Where(x => (x.RetriedCount == 0 && x.CreatedDateTime < dateTime) || (x.RetriedCount != 0 && x.UpdatedDateTime < dateTime))
.ToList();
if (messages.Any())
{
foreach (var sms in messages)
{
await _smsMessageCreatedEventSender.SendAsync(new SmsMessageCreatedEvent { Id = sms.Id });
_repository.IncreaseRetry(sms.Id);
}
}
else
{
_logger.LogInformation("No SMS to resend.");
}
return(messages.Count);
}
public async Task <int> PublishEvents()
{
var events = _eventLogRepository.GetAll()
.Where(x => !x.Published)
.OrderBy(x => x.CreatedDateTime)
.Take(50)
.ToList();
foreach (var eventLog in events)
{
if (eventLog.EventType == "FILEENTRY_CREATED")
{
await _fileUploadedEventSender.SendAsync(new FileUploadedEvent { FileEntry = JsonSerializer.Deserialize <FileEntry>(eventLog.Message) });
}
else if (eventLog.EventType == "FILEENTRY_DELETED")
{
await _fileDeletedEventSender.SendAsync(new FileDeletedEvent { FileEntry = JsonSerializer.Deserialize <FileEntry>(eventLog.Message) });
}
else
{
// TODO: Take Note
}
eventLog.Published = true;
eventLog.UpdatedDateTime = _dateTimeProvider.OffsetNow;
await _eventLogRepository.UnitOfWork.SaveChangesAsync();
}
return(events.Count);
}
public async Task <int> ResendEmailMessagesAsync()
{
var dateTime = _dateTimeProvider.OffsetNow.AddMinutes(-1);
var messages = _repository.GetAll()
.Where(x => x.SentDateTime == null && x.RetriedCount < 3)
.Where(x => (x.RetriedCount == 0 && x.CreatedDateTime < dateTime) || (x.RetriedCount != 0 && x.UpdatedDateTime < dateTime))
.ToList();
if (messages.Any())
{
foreach (var email in messages)
{
await _emailMessageCreatedEventSender.SendAsync(new EmailMessageCreatedEvent { Id = email.Id });
email.RetriedCount++;
await _repository.AddOrUpdateAsync(email);
await _repository.UnitOfWork.SaveChangesAsync();
}
}
else
{
_logger.LogInformation("No email to resend.");
}
return(messages.Count);
}
static async Task SendMessagesWithSessionAsync(int numberOfMessagesToSend, int numberOfSessions)
{
try
{
for (var j = 0; j < numberOfSessions; j++)
{
for (var i = 0; i < numberOfMessagesToSend; i++)
{
// Create a new message to send to the queue
string messageBody = $"Message {i}";
var message = new Message(Encoding.UTF8.GetBytes(messageBody));
message.SessionId = $"{j}";
// Write the body of the message to the console
Console.WriteLine($"Sending message: {messageBody} with sessionId {j}");
// Send the message to the queue
await messageSender.SendAsync(message);
}
}
}
catch (Exception exception)
{
Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
}
}
public async Task <HttpResponseMessage> GenerateInvoiceAsync(int suscriberId)
{
try
{
var chosenSubscriber = await _subscriberService.GetSubscriberAsync(suscriberId);
var reportsBl = new List <PhoneReportBl>();
chosenSubscriber.Phones.ForEach(p => reportsBl.Add(_reportService.GenerateReport(p)));
var newInvoice = _invoiceDataCapture.Capture(chosenSubscriber, reportsBl);
var invoiceToReturn = await _invoiceService.AddAsync(newInvoice, suscriberId);
await _phoneService.UpdateBundlesAsync(suscriberId);
var serializerFormat = "json";
var chosenSubscriberEmail = await _subscriberService.GetSubscribersEmailAsync(suscriberId);
var _fileSerializer = _serializerProvider.SerializerChanger(serializerFormat);
var path = _serializerProvider.GetCurrentDirectory(serializerFormat, invoiceToReturn);
await _fileSerializer.SaveToFileAsync(path, invoiceToReturn);
await _messageSender.SendAsync(chosenSubscriberEmail, path, invoiceToReturn);
_invoiceService.RemoveInvoiceFile(path);
return(Request.CreateResponse(HttpStatusCode.OK, invoiceToReturn));
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, $"Generating new invoice failed. {e.Message}"));
}
}
public async Task SendMessageAsync(string id, string message)
{
await _messageSender.SendAsync(new Message(Encoding.UTF8.GetBytes(message))
{
MessageId = id,
SessionId = _serviceBusContext.SessionId
});
}
static async Task SendAMessage(IMessageSender client)
{
var brokeredMessage = new Message(Encoding.UTF8.GetBytes("Hello World"))
{
ContentType = "text/plain"
};
await client.SendAsync(brokeredMessage);
}
public async Task SendAsync_ShouldWrapServerMessageToMessageWithMetadata(
object message,
MessageMetadata metadata,
IMessageSender sut)
{
await sut.SendAsync(message, metadata, Cts.Token);
Mock.Get(sut).Verify(x => x.SendAsync(It.Is <MessageWithMetadata>(
y => y.Message == message && y.Metadata == metadata), Cts.Token));
}
public async Task HandleAsync(IMessage <IProcessingCommand> message, ExtendedMessageReceivedInfo info)
{
ProcessErrorCode errorCode = await RunProcessing(message.Body);
var response = new ProcessingResponse
{
Command = message.Body,
ErrorCode = errorCode
};
await _responseSender.SendAsync(response);
}
public async Task <IActionResult> Post([FromBody] Message <string> value)
{
if (ModelState.IsValid)
{
await sender.SendAsync(value);
return(Ok());
}
return(BadRequest(ModelState));
}
public async Task UpdateClientConfigurationAsync()
{
var message = new ClientConfigurationMessage
{
MaxClientMessageSizeBytes = _maxClientMessageSizeBytes,
};
_log.LogDebug($"Send client configuration with:");
_log.LogDebug($"(MaxClientMessageSizeBytes='{message.MaxClientMessageSizeBytes}'");
await _messageSender.SendAsync(message);
}
private void SendAndDeletePending(IEnumerator <IEventRecord> enumerator, Action <bool> successCallback, Action <Exception> errorCallback)
{
Action sendNextEvent = null;
Action deletePending = null;
sendNextEvent =
() => {
try {
if (enumerator.MoveNext())
{
var item = enumerator.Current;
sender.SendAsync(
() => BuildMessage(item),
deletePending,
errorCallback);
}
else
{
// no more elements
successCallback(true);
}
} catch (Exception e) {
errorCallback(e);
}
};
deletePending =
() => {
var item = enumerator.Current;
queue.DeletePendingAsync(
item.PartitionKey,
item.RowKey,
rowDeleted => {
if (rowDeleted)
{
instrumentation.EventPublished();
sendNextEvent.Invoke();
}
else
{
// another thread or process has already sent this event.
// stop competing for the same partition and try to send it at the end of the queue if there are any
// events still pending.
successCallback(false);
}
},
errorCallback);
};
sendNextEvent();
}
public async Task <IActionResult> Post(int id, [FromForm] decimal amount)
{
var result = await ChangeBalanceCmd.Create(id, amount)
.Tap(cmd => _messageSender.SendAsync(cmd));
if (result.IsFailure)
{
return(BadRequest(result.Error));
}
return(NoContent());
}
public async Task Publish(params EventBase[] events)
{
foreach (var @event in events)
{
_logger.LogInformation($"Publishing {@event.GetType().Name} event");
await _mediator.Publish(GetNotificationCorrespondingToDomainEvent(@event));
await _messageSender.SendAsync(new Core.Models.Message <Guid, EventBase> {
Key = Guid.NewGuid(), Value = @event
});
}
}
private async Task ProcessPublishedAsync(IDataStorage connection, ProcessingContext context)
{
context.ThrowIfStopping();
var messages = await GetSafelyAsync(connection.GetPublishedMessagesOfNeedRetry);
foreach (var message in messages)
{
await _messageSender.SendAsync(message);
await context.WaitAsync(_delay);
}
}
public async Task <ActionResult> ByPwd([FromBody] PwdAuthRequest request)
{
var result = await PwdAuthCmd
.Create(request.Password, request.Email)
.Bind(async cmd => await _messageSender.SendAsync <PwdAuthCmd, string>(cmd));
if (result.IsFailure)
{
throw new InvalidOperationException(result.Error);
}
return(Ok(result.Value));
}
public async Task SendMessagesAsync(T payload)
{
string data = JsonSerializer.Serialize <T>(payload);
var message = new Message(Encoding.UTF8.GetBytes(data));
try
{
await sender.SendAsync(message).ConfigureAwait(false);
}
catch (MessagingEntityNotFoundException)
{
try
{
await manager.CreateIfNotExisted().ConfigureAwait(false);
await sender.SendAsync(message).ConfigureAwait(false);
}
catch (Exception ex)
{
logger.LogError($"ServiceBus: failed to create client: {setting.ConnectionString}: {ex}");
}
}
}
public async Task <IActionResult> Post([FromBody] NewCustomerModel newCustomerModel)
{
_cache.Set(newCustomerModel.TransactionId.ToString(), newCustomerModel, TimeSpan.FromDays(1));
var message = new CloudEvent <NewCustomerModel>
{
TransactionId = newCustomerModel.TransactionId.ToString(),
Data = newCustomerModel
};
await _messageSender.SendAsync(message);
return(CreateResponseOnPost(newCustomerModel));
}
public static ValueTask SendAsync(
this IMessageSender messageSender,
object message,
MessageMetadata metadata,
CancellationToken cancellationToken)
{
var messageWithMetadata = new MessageWithMetadata
{
Message = message,
Metadata = metadata
};
return(messageSender.SendAsync(messageWithMetadata, cancellationToken));
}
private async Task HandlePingAsync(string message)
{
long serverTime = long.Parse(message.Split("::").LastOrDefault()?.Replace("\"", string.Empty));
long clientTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();
long latency = clientTime >= serverTime ? clientTime - serverTime : serverTime - clientTime;
string pong = $"\"primus::pong::{serverTime}\"";
if (_logger.IsDebug)
{
_logger.Debug($"Sending 'pong' message to ETH stats...");
}
_client.Send(pong);
await _messageSender.SendAsync(_client, new LatencyMessage(latency));
}
private void CheckAvailability()
{
try
{
if (_context.Database.CanConnect())
{
_messageSender.SendAsync(GetMessage(ClientServiceStatus.Running))
.GetAwaiter().GetResult();
}
else
{
_messageSender.SendAsync(
GetMessage(ClientServiceStatus.Degraded, "Cannot connect to database."))
.GetAwaiter().GetResult();
}
}
catch (Exception e)
{
_messageSender.SendAsync(
GetMessage(ClientServiceStatus.Unavailable, e.Message))
.GetAwaiter().GetResult();
}
}
/// <summary>
/// 执行。
/// </summary>
/// <param name="sender">消息发送者。</param>
/// <param name="message">调用消息。</param>
public async Task ExecuteAsync(IMessageSender sender, object message)
{
var buffer = (IByteBuffer)message;
if (_logger.IsEnabled(LogLevel.Information))
_logger.Information($"接收到消息：{buffer.ToString(Encoding.UTF8)}。");
var content = buffer.ToArray();
RemoteInvokeMessage remoteInvokeMessage;
try
{
remoteInvokeMessage = _serializer.Deserialize<byte[], RemoteInvokeMessage>(content);
}
catch (Exception exception)
{
_logger.Error($"将接收到的消息反序列化成 TransportMessage<RemoteInvokeMessage> 时发送了错误，消息内容：{buffer.ToString(Encoding.UTF8)}。", exception);
return;
}
var entry = _serviceEntryLocate.Locate(remoteInvokeMessage);
if (entry == null)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.Error($"根据服务Id：{remoteInvokeMessage.ServiceId}，找不到服务条目。");
return;
}
if (_logger.IsEnabled(LogLevel.Debug))
_logger.Debug("准备执行本地逻辑。");
var resultMessage = new RemoteInvokeResultMessage
{
Id = remoteInvokeMessage.Id
};
try
{
var result = entry.Func(remoteInvokeMessage.Parameters);
var task = result as Task;
if (task == null)
{
resultMessage.Result = result;
}
else
{
task.Wait();
var taskType = task.GetType();
if (taskType.IsGenericType)
resultMessage.Result = taskType.GetProperty("Result").GetValue(task);
}
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.Error("执行本地逻辑时候发生了错误。", exception);
resultMessage.ExceptionMessage = GetExceptionMessage(exception);
}
try
{
if (_logger.IsEnabled(LogLevel.Debug))
_logger.Debug("准备发送响应消息。");
var resultData = _serializer.Serialize(resultMessage);
buffer = Unpooled.Buffer(resultData.Length);
buffer.WriteBytes(resultData);
await sender.SendAsync(buffer);
if (_logger.IsEnabled(LogLevel.Debug))
_logger.Debug("响应消息发送成功。");
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.Error("发送响应消息时候发生了异常。", exception);
}
}
/// <summary>
/// 执行。
/// </summary>
/// <param name="sender">消息发送者。</param>
/// <param name="message">调用消息。</param>
public async Task ExecuteAsync(IMessageSender sender, TransportMessage message)
{
if (_logger.IsEnabled(LogLevel.Information))
_logger.LogInformation("接收到消息。");
if (!message.IsInvokeMessage())
return;
RemoteInvokeMessage remoteInvokeMessage;
try
{
remoteInvokeMessage = message.GetContent<RemoteInvokeMessage>();
}
catch (Exception exception)
{
_logger.LogError("将接收到的消息反序列化成 TransportMessage<RemoteInvokeMessage> 时发送了错误。", exception);
return;
}
var entry = _serviceEntryLocate.Locate(remoteInvokeMessage);
if (entry == null)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.LogError($"根据服务Id：{remoteInvokeMessage.ServiceId}，找不到服务条目。");
return;
}
if (_logger.IsEnabled(LogLevel.Debug))
_logger.LogDebug("准备执行本地逻辑。");
var resultMessage = new RemoteInvokeResultMessage();
try
{
var result = entry.Func(remoteInvokeMessage.Parameters);
var task = result as Task;
if (task == null)
{
resultMessage.Result = result;
}
else
{
task.Wait();
var taskType = task.GetType().GetTypeInfo();
if (taskType.IsGenericType)
resultMessage.Result = taskType.GetProperty("Result").GetValue(task);
}
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.LogError("执行本地逻辑时候发生了错误。", exception);
resultMessage.ExceptionMessage = GetExceptionMessage(exception);
}
try
{
if (_logger.IsEnabled(LogLevel.Debug))
_logger.LogDebug("准备发送响应消息。");
await sender.SendAsync(TransportMessage.CreateInvokeResultMessage(message.Id, resultMessage));
if (_logger.IsEnabled(LogLevel.Debug))
_logger.LogDebug("响应消息发送成功。");
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.LogError("发送响应消息时候发生了异常。", exception);
}
}