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); } }