public string ProcessMessage(IInboundMessage message) { if (message == null) throw new ArgumentNullException(nameof(message)); var messageContextFactory = new MessageContextFactory(_synonymService, _areaService); var messageContext = messageContextFactory.Create(message); string answer; try { answer = ProcessMessage(messageContext); if (messageContext.GetContainsWord("debug")) { answer += Environment.NewLine + Environment.NewLine + GenerateDebugOutput(messageContext); } } catch (Exception exception) { answer = $"{Emoji.Scream} Mist! Da ist etwas total schief gelaufen! Bitte stelle mir nie wieder solche Fragen!"; Log.Error(exception, $"Error while processing message '{message.Text}'."); } return answer; }
public async Task <byte[]> JoinIfComplete(IInboundMessage message) { var(messageId, chunkId, chunksCount) = ExtractHeadersValues(message); var count = await _store.CountChunks(messageId); if (count >= chunksCount - 1) { var chunks = await _store.GetChunks(messageId); if (chunks.ContainsKey(chunkId)) { return(null); } chunks.Add(chunkId, message.RawContent); var completeMessage = Join(chunks); await _store.Cleanup(messageId); return(completeMessage); } else { await _store.Store(messageId, chunkId, chunksCount, message.RawContent); return(null); } }
public void ProcessMessage(IInboundMessage message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } var synonymService = _controller.GetService <SynonymService>(); var messageContextFactory = new MessageContextFactory(synonymService); _messageContext = messageContextFactory.Create(message); try { Answer = ProcessMessage(); if (_messageContext.GetContainsWord("debug")) { Answer += Environment.NewLine + Environment.NewLine + GenerateDebugOutput(); } } catch (Exception exception) { Answer = $"{Emoji.Scream} Mist! Da ist etwas total schief gelaufen! Bitte stelle mir nie wieder solche Fragen!"; Log.Error(exception, $"Error while processing message '{message.Text}'."); } }
public async Task AddMessage(IInboundMessage message) { // TODO: Check this! if (_processingException != null) { throw new SilverbackException("Cannot add to the batch because the processing of the previous batch failed. See inner exception for details.", _processingException); } await _semaphore.WaitAsync(); try { _messages.Add(message); _messageLogger.LogInformation(_logger, "Message added to batch.", message); if (_messages.Count == 1) { CurrentBatchId = Guid.NewGuid(); _waitTimer?.Start(); } else if (_messages.Count == _settings.Size) { await ProcessBatch(); } } finally { _semaphore.Release(); } }
private void WebSocketOnMessage(object sender, MessageEventArgs args) { string messageJson = args?.Data ?? ""; IInboundMessage baseMessage = _interpreter.InterpretMessage(messageJson); OnMessage?.Invoke(sender, baseMessage); }
public void AddMessage(IInboundMessage message) { // TODO: Check this! if (_processingException != null) { throw new SilverbackException("Cannot add to the batch because the processing of the previous batch failed. See inner exception for details.", _processingException); } lock (_messages) { _messages.Add(message); _messageLogger.LogInformation(_logger, "Message added to batch.", message, CurrentBatchId, CurrentSize); if (_messages.Count == 1) { CurrentBatchId = Guid.NewGuid(); _waitTimer?.Start(); } else if (_messages.Count == _settings.Size) { ProcessBatch(); } } }
protected override ErrorAction ApplyPolicy(IInboundMessage message, Exception exception) { ApplyDelay(message); _messageLogger.LogInformation(_logger, "The message will be processed again.", message); return(ErrorAction.Retry); }
private void PublishToNewEndpoint(IInboundMessage message, Exception exception) { message.Headers.AddOrReplace(MessageHeader.SourceEndpointKey, message.Endpoint?.Name); _producer.Produce( _transformationFunction?.Invoke(message.Content, exception) ?? message.Content ?? message.RawContent, _headersTransformationFunction?.Invoke(message.Headers, exception) ?? message.Headers); }
public void ApplyWhen_Exception_CanHandleReturnsExpectedResult(IInboundMessage message, Exception exception, bool mustApply) { var policy = (TestErrorPolicy) new TestErrorPolicy() .ApplyWhen((msg, ex) => msg.Headers.GetValue <int>(MessageHeader.FailedAttemptsKey) <= 5 && ex.Message != "no"); var canHandle = policy.CanHandle(message, exception); canHandle.Should().Be(mustApply); }
private async Task ListenTo(IInboundMessage baseMessage) { if (baseMessage == null || baseMessage.MessageType == MessageType.Unknown) { return; } _inboundDataVisitor = new InboundDataVisitor(this); await baseMessage.Accept(_inboundDataVisitor); }
private static void UpdateFailedAttemptsHeader(IInboundMessage message, int attempt) { if (message is IInboundBatch batch) { batch.Messages.ForEach(m => UpdateFailedAttemptsHeader(m, attempt)); } else { message.Headers.AddOrReplace(MessageHeader.FailedAttemptsHeaderName, attempt.ToString()); } }
private void ApplyDelay(IInboundMessage message) { var delay = _initialDelay.Milliseconds + message.FailedAttempts * _delayIncrement.Milliseconds; if (delay <= 0) { return; } _messageLogger.LogTrace(_logger, $"Waiting {delay} milliseconds before retrying the message.", message); Thread.Sleep(delay); }
public void LogProcessing(ILogger logger, IInboundMessage message) { var batch = message as IInboundBatch; LogInformation(logger, batch != null ? "Processing inbound batch." : "Processing inbound message.", message, batch?.Id, batch?.Size); }
protected override bool MustProcess(IInboundMessage message, IServiceProvider serviceProvider) { var inboundLog = serviceProvider.GetRequiredService <IInboundLog>(); if (inboundLog.Exists(message.Message, message.Endpoint)) { return(false); } inboundLog.Add(message.Message, message.Endpoint); return(true); }
private void RelayAndCommitSingleMessage(IInboundMessage message, IServiceProvider serviceProvider) { try { _messagesHandler(new[] { message }, serviceProvider); Commit(new[] { message.Offset }, serviceProvider); } catch (Exception) { Rollback(serviceProvider); throw; } }
private void ProcessSingleMessage(IInboundMessage message) { _inboundMessageProcessor.TryDeserializeAndProcess( message, _errorPolicy, deserializedMessage => { using (var scope = _serviceProvider.CreateScope()) { RelayAndCommitSingleMessage(deserializedMessage, scope.ServiceProvider); } }); }
public void LogProcessingError(ILogger logger, IInboundMessage message, Exception exception) { var batch = message as IInboundBatch; LogWarning(logger, exception, batch != null ? "Error occurred processing the inbound batch." : "Error occurred processing the inbound message.", message, batch?.Id, batch?.Size); }
public MessageContext(IInboundMessage originalMessage) { if (originalMessage == null) throw new ArgumentNullException(nameof(originalMessage)); OriginalMessage = originalMessage; Words = new HashSet<string>(); IdentifiedAreaIds = new HashSet<AreaId>(); IdentifiedComponentIds = new HashSet<ComponentId>(); FilteredComponentIds = new HashSet<ComponentId>(); IdentifiedComponentStates = new HashSet<ComponentState>(); }
protected override ErrorAction ApplyPolicy(IInboundMessage message, Exception exception) { foreach (var policy in _policies) { if (policy.CanHandle(message, exception)) { return(policy.HandleError(message, exception)); } } _messageLogger.LogTrace(_logger, "All policies have been applied but the message still couldn't be successfully processed. The consumer will be stopped.", message); return(ErrorAction.StopConsuming); }
protected override async Task <bool> MustProcess(IInboundMessage message, IServiceProvider serviceProvider) { var inboundLog = serviceProvider.GetRequiredService <IInboundLog>(); if (await inboundLog.Exists(message.Content, message.Endpoint)) { return(false); } await inboundLog.Add(message.Content, message.Endpoint); return(true); }
private async Task <IInboundMessage> HandleChunkedMessage(IInboundMessage message, IServiceProvider serviceProvider) { if (!message.Headers.Contains(MessageHeader.ChunkIdKey)) { return(message); } var completeMessage = await serviceProvider.GetRequiredService <ChunkConsumer>().JoinIfComplete(message); return(completeMessage == null ? null : new InboundMessage(completeMessage, message.Headers, message.Offset, message.Endpoint, message.MustUnwrap)); }
protected override bool MustProcess(IInboundMessage message, IServiceProvider serviceProvider) { var offsetStore = serviceProvider.GetRequiredService <IOffsetStore>(); var latest = offsetStore.GetLatestValue(message.Offset.Key); if (latest != null && message.Offset.CompareTo(latest) <= 0) { return(false); } offsetStore.Store(message.Offset); return(true); }
/// <summary> /// Processes the inbound message. /// </summary> /// <param name="message">Message to process.</param> public void Process(IInboundMessage message) { var stateMessage = message as InboundStateMessage; if (stateMessage != null) { State = stateMessage.State; if (message is InboundSubscribeMessage) { IsSubscribed = true; } } }
public MessageContext Create(IInboundMessage message) { if (message == null) throw new ArgumentNullException(nameof(message)); _currentContext = new MessageContext(message); IdentifyWords(); IdentifyAreas(); IdentifyComponents(); IdentifyComponentStates(); FilterComponentIds(); return _currentContext; }
public MessageContext(IInboundMessage originalMessage) { if (originalMessage == null) { throw new ArgumentNullException(nameof(originalMessage)); } OriginalMessage = originalMessage; Words = new HashSet <string>(); IdentifiedAreaIds = new HashSet <AreaId>(); IdentifiedComponentIds = new HashSet <ComponentId>(); IdentifiedComponentStates = new HashSet <IComponentState>(); }
private IInboundMessage DeserializeRawMessage(IInboundMessage message) { var deserialized = message.Content ?? (((InboundMessage)message).Content = message.Endpoint.Serializer.Deserialize(message.RawContent, message.Headers)); // Create typed message for easier specific subscription var typedInboundMessage = (InboundMessage)Activator.CreateInstance( typeof(InboundMessage <>).MakeGenericType(deserialized.GetType()), message); typedInboundMessage.Content = deserialized; return(typedInboundMessage); }
public ErrorAction HandleError(IInboundMessage message, Exception exception) { var result = ApplyPolicy(message, exception); if (MessageToPublishFactory != null) { using (var scope = _serviceProvider.CreateScope()) { scope.ServiceProvider.GetRequiredService <IPublisher>() .Publish(MessageToPublishFactory.Invoke(message)); } } return(result); }
public MessageContext Create(IInboundMessage message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } _currentContext = new MessageContext(message); IdentifyWords(); IdentifyAreas(); IdentifyComponents(); IdentifyComponentStates(); return(_currentContext); }
private IInboundMessage HandleChunkedMessage(IInboundMessage message, IServiceProvider serviceProvider) { if (!(message.Message is MessageChunk chunk)) { return(message); } var joinedMessage = serviceProvider.GetRequiredService <ChunkConsumer>().JoinIfComplete(chunk); if (joinedMessage == null) { return(null); } var deserializedJoinedMessage = message.Endpoint.Serializer.Deserialize(joinedMessage); return(InboundMessageHelper.CreateNewInboundMessage(deserializedJoinedMessage, message)); }
protected override ErrorAction ApplyPolicy(IInboundMessage message, Exception exception) { _messageLogger.LogInformation(_logger, $"The message will be be moved to '{_endpoint.Name}'.", message); if (message is IInboundBatch inboundBatch) { foreach (var singleFailedMessage in inboundBatch.Messages) { PublishToNewEndpoint(singleFailedMessage, exception); } } else { PublishToNewEndpoint(message, exception); } return(ErrorAction.Skip); }
public static IInboundMessage <TMessage> CreateNewInboundMessage <TMessage>(TMessage message, IInboundMessage sourceInboundMessage) { var newMessage = (InboundMessage)Activator.CreateInstance(typeof(InboundMessage <>).MakeGenericType(message.GetType())); if (sourceInboundMessage.Headers != null) { newMessage.Headers.AddRange(sourceInboundMessage.Headers); } newMessage.Message = message; newMessage.Endpoint = sourceInboundMessage.Endpoint; newMessage.Offset = sourceInboundMessage.Offset; newMessage.FailedAttempts = sourceInboundMessage.FailedAttempts; newMessage.MustUnwrap = sourceInboundMessage.MustUnwrap; return((IInboundMessage <TMessage>)newMessage); }
messages.All(msg => CanHandle(msg, exception)); // TODO: Check this public virtual bool CanHandle(IInboundMessage message, Exception exception) { if (message == null) { _logger.LogTrace($"The policy '{GetType().Name}' cannot be applied because the message is null."); return(false); } var failedAttempts = message.Headers.GetValueOrDefault <int>(MessageHeader.FailedAttemptsKey); if (MaxFailedAttemptsSetting >= 0 && failedAttempts > MaxFailedAttemptsSetting) { _messageLogger.LogTrace(_logger, $"The policy '{GetType().Name}' will be skipped because the current failed attempts " + $"({failedAttempts}) exceeds the configured maximum attempts " + $"({MaxFailedAttemptsSetting}).", message); return(false); } if (_includedExceptions.Any() && _includedExceptions.All(e => !e.IsInstanceOfType(exception))) { _messageLogger.LogTrace(_logger, $"The policy '{GetType().Name}' will be skipped because the {exception.GetType().Name} " + "is not in the list of handled exceptions.", message); return(false); } if (_excludedExceptions.Any(e => e.IsInstanceOfType(exception))) { _messageLogger.LogTrace(_logger, $"The policy '{GetType().Name}' will be skipped because the {exception.GetType().Name} " + "is in the list of excluded exceptions.", message); return(false); } if (_applyRule != null && !_applyRule.Invoke(message, exception)) { _messageLogger.LogTrace(_logger, $"The policy '{GetType().Name}' will be skipped because the apply rule has been " + "evaluated and returned false.", message); return(false); } return(true); }
private static IInboundMessage DeserializeIfNeeded(IInboundMessage message) { if (message is IInboundBatch batch) { return(new InboundBatch( batch.Id, batch.Messages.Select(DeserializeIfNeeded), batch.Endpoint)); } if (message.Message is byte[]) { return(InboundMessageHelper.CreateNewInboundMessage( Deserialize(message), message)); } return(message); }