public async Task RunAsync_should_throw_if_saga_cannot_handle_message() { var message = UnhandledMessage.New(); var messageContext = NSubstitute.Substitute.For <IMessageContext <UnhandledMessage> >(); messageContext.Message.Returns(message); var sagaStateService = NSubstitute.Substitute.For <ISagaStateService <DummySaga, DummySagaState> >(); var state = new DummySagaState(message.CorrelationId); sagaStateService.GetAsync(messageContext, Arg.Any <CancellationToken>()) .Returns((state, Guid.NewGuid())); var saga = NSubstitute.Substitute.ForPartsOf <DummySaga>(state); var sagaFactory = NSubstitute.Substitute.For <ISagaFactory <DummySaga, DummySagaState> >(); sagaFactory.Create(state) .Returns(saga); var logger = NSubstitute.Substitute.For <ILogger <SagaRunner <DummySaga, DummySagaState> > >(); var transactionManager = NSubstitute.Substitute.For <ITransactionManager>(); var policyFactory = NSubstitute.Substitute.For <ISagaPolicyFactory <DummySaga> >(); var sut = new SagaRunner <DummySaga, DummySagaState>(sagaFactory, sagaStateService, transactionManager, policyFactory, logger); await Assert.ThrowsAsync <ConsumerNotFoundException>(() => sut.RunAsync(messageContext, CancellationToken.None)); }
private void ServerOnMessage(object sender, MessageEventArgs evt) { var socket = (WsSocket)sender; try { var msgOrig = JsonConvert.DeserializeObject <Message>(evt.Data); var actionName = msgOrig.ActionName?.ToLowerInvariant(); var msg = msgOrig; if (_actionNameToDataType.ContainsKey(actionName)) { var type = _actionNameToDataType[actionName]; var data = DeserializeData(msgOrig.Data, type); msg = new Message(socket) { ActionName = msgOrig.ActionName, Type = msgOrig.Type, Data = data, Hash = msgOrig.Hash }; } else { msg.Sender = socket; } if (_actionFilters.Count != 0) { lock (_actionFiltersLock) { if (_actionFilters.Any(x => !x(msg))) { return; } } } if (!InvokeHandlers(actionName, msg)) { UnhandledMessage?.Invoke(this, msg); } } catch (Exception e) { var message = new Message { Type = MessageType.Response, Data = "Received unknown data." }; var text = JsonConvert.SerializeObject(message); socket.Send(text); Logger.Error(e, $"Failed to handle WebSocket message: {evt.Data}"); } }
private void NewUnhandledMessage(UnhandledMessage obj) { var builder = new StringBuilder($"Name: {obj.GetType().Name}"); foreach (var propertyInfo in obj.Message.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)) { builder.Append($" - {propertyInfo.GetValue(obj.Message)}"); } UnhandledMessages.Add(builder.ToString()); }
public void Create_should_return_null_when_message_has_wrong_type() { var state = new DummySagaState(Guid.NewGuid()); var message = UnhandledMessage.New(); Func <StartDummySaga, DummySagaState> factory = (msg) => state; var sut = new LambdaSagaStateFactory <StartDummySaga, DummySagaState>(factory); var result = sut.Create(message); result.Should().BeNull(); }
public void Be_able_to_log_unhandled_messages() { using (var system = ActorSystem.Create("EventStreamSpecUnhandled", GetDebugUnhandledMessagesConfig())) { system.EventStream.Subscribe(TestActor, typeof(Debug)); var msg = new UnhandledMessage(42, system.DeadLetters, system.DeadLetters); system.EventStream.Publish(msg); var debugMsg = ExpectMsg <Debug>(); debugMsg.Message.ToString().StartsWith("Unhandled message from").ShouldBeTrue(); debugMsg.Message.ToString().EndsWith(": 42").ShouldBeTrue(); } }
protected async Task Listen() { while (true) { var buffer = await _input.ReadLineAsync(); var splitBuffer = buffer.Split(); if (splitBuffer[0].Equals("PING")) { await SendPong(buffer); } else if (splitBuffer[1].Equals("PRIVMSG")) { var parsedMessage = IrcMessage.ParseMessage(buffer); var parsedUser = IrcMessage.ParseUser(buffer); MessageReceived?.Invoke(parsedMessage, parsedUser); } else { UnhandledMessage?.Invoke(buffer); } } }
public void Handle(UnhandledMessage message) { ActorMonitoringExtension.Monitors(Context.System).IncrementUnhandledMessage(); }
internal void RaiseUnhandledMessage(JsonResponse message) { UnhandledMessage?.Invoke(this, message); }
protected virtual void OnUnhandledMessage(MessageContext context) { UnhandledMessage?.Invoke(context); }
async void Run() { var messageParser = new TwitchMessageParser(); int retries = 0; while (Connection != null) { try { string data = Connection.Read(); if (string.IsNullOrEmpty(data)) { // Failed to read, try again. if (retries >= 3) { break; } retries += 1; await Task.Delay(1000); } else { retries = 0; } var message = messageParser.Parse(data); if (message == null) { continue; } // Completely ignore certain messages. if (ignoredCommands.Contains(message.Command)) { continue; } // Process specified commands. ITwitchCommandProcessor commandProcessor; if (commandProcessors.TryGetValue(message.Command, out commandProcessor)) { commandProcessor.Process(Connection, message); } // Raise unhandled messages to UI thread. else { Dispatcher.Invoke(() => UnhandledMessage?.Invoke(message)); } } catch (IOException) { continue; } } try { // Raise disconnected event. Dispatcher.Invoke(() => Disconnected?.Invoke()); } catch (TaskCanceledException) {} }
void Receive(UnhandledMessage message) => received++;