private void ManagedMqttClientApplicationMessageProcessed(object sender, ApplicationMessageProcessedEventArgs e)
{
if (e.HasFailed)
{
_logger.LogError($"Message could not be processed for {this}, message: '{e.Exception?.Message}'", e.Exception);
}
}
/// <summary>
/// 消息发布回调
/// </summary>
/// <param name="e"></param>
private void ApplicationMessageProcessedHandlerMethod(ApplicationMessageProcessedEventArgs e)
{
try
{
if (rawMessageListener == null)
{
Log.Error($"rawMessageListener is null");
return;
}
RawMessage rawMessage = new RawMessage(e.ApplicationMessage.Id.ToString(), e.ApplicationMessage.ApplicationMessage.Topic, Encoding.UTF8.GetString(e.ApplicationMessage.ApplicationMessage.Payload));
if (e.HasFailed)
{
Log.Info($"messageId " + e.ApplicationMessage.Id + ", topic: " + e.ApplicationMessage.ApplicationMessage.Topic + ", payload: " + Encoding.UTF8.GetString(e.ApplicationMessage.ApplicationMessage.Payload) + " is published fail");
rawMessageListener.OnMessageUnPublished(rawMessage);
}
else if (e.HasSucceeded)
{
Log.Info($"messageId " + e.ApplicationMessage.Id + ", topic: " + e.ApplicationMessage.ApplicationMessage.Topic + ", payload: " + Encoding.UTF8.GetString(e.ApplicationMessage.ApplicationMessage.Payload) + " is published success");
rawMessageListener.OnMessagePublished(rawMessage);
}
}
catch (Exception ex)
{
Log.Error("SDK.Error: the message is " + Encoding.UTF8.GetString(e.ApplicationMessage.ApplicationMessage.Payload));
}
}
public Task HandleApplicationMessageProcessedAsync(ApplicationMessageProcessedEventArgs eventArgs)
{
if (eventArgs?.HasFailed ?? throw new ArgumentNullException(nameof(eventArgs)))
{
_logger.LogError(new EventId(0), eventArgs.Exception, $"Message could not be processed for {this}, message: '{eventArgs.Exception?.Message}'");
}
return(Task.CompletedTask);
}
public async Task HandleApplicationMessageProcessedAsync(ApplicationMessageProcessedEventArgs eventArgs)
{
// This just tells us that a message we sent was received successfully by the broker.
await Task.Run(() =>
{
Logger.LogTrace(LogCategory.Processor, this.Name, "Client Message Processed by Broker", eventArgs.ToJSON());
if (eventArgs.HasSucceeded == false)
{
// TODO: What to do here?
// Add to a file? And retry later?
}
});
}
private void client_MqttMsgPublishProcessed(object sender, ApplicationMessageProcessedEventArgs e)
{
if (e.HasFailed)
{
Debug.Log("A message with the topic \"" + e.ApplicationMessage.ApplicationMessage.Topic + "\" has been Failed to sent, retrying" + e.Exception);
return;
}
//TODO (done): an indicator if all messages have been processes and the application is save to exit
if (!currentlyProcessingMessages.Remove(e.ApplicationMessage.ApplicationMessage.GetHashCode()))
{
Debug.LogError("A message error has occured. A message was processed that should not have been sent");
}
//TODO(obsolete): a retransmitt sptop, so that there is no loop --> noticed the managed client retransmitts the message, if it failed
}
public void Publish_Internal_Method_Throws()
{
using var mock = AutoMock.GetLoose();
var exception = new Exception();
mock.Mock <IManagedMqttClient>()
.Setup(x => x.PublishAsync(It.IsAny <ManagedMqttApplicationMessage>())).Throws(exception);
mock.Mock <IManagedMqttClient>()
.SetupProperty(x => x.ApplicationMessageProcessedHandler);
mock.Mock <IManagedMqttClient>()
.SetupProperty(x => x.ApplicationMessageSkippedHandler);
mock.Mock <IManagedMqttClient>()
.SetupGet(x => x.IsConnected)
.Returns(true);
var rxMqttClinet = mock.Create <RxMqttClient>();
var message = new ManagedMqttApplicationMessageBuilder()
.WithApplicationMessage(new MqttApplicationMessageBuilder()
.WithTopic("T")
.WithPayload("P")
.WithExactlyOnceQoS()
.Build())
.Build();
var observable = Observable.Return(message);
var @event = new ApplicationMessageProcessedEventArgs(message, exception);
var testScheduler = new TestScheduler();
testScheduler.ScheduleAbsolute(@event, 5, (_, state) =>
{
var IManagedMqttClientMock = mock.Mock <IManagedMqttClient>().Object;
mock.Mock <IManagedMqttClient>().Object.ApplicationMessageProcessedHandler.HandleApplicationMessageProcessedAsync(state);
return(Disposable.Empty);
});
// act
var testObserver = testScheduler.Start(() => observable.PublishOn(rxMqttClinet), 0, 1, 10);
Assert.Single(testObserver.Messages.Where(m => m.Value.Kind == System.Reactive.NotificationKind.OnNext));
Assert.Single(testObserver.Messages.Where(m => m.Value.Kind == System.Reactive.NotificationKind.OnCompleted));
Assert.Empty(testObserver.Messages.Where(m => m.Value.Kind == System.Reactive.NotificationKind.OnError));
var onNext = testObserver.Messages.Where(m => m.Value.Kind == System.Reactive.NotificationKind.OnNext).Single();
Assert.Equal(message, onNext.Value.Value.MqttApplicationMessage);
Assert.Equal(RxMqttClientPublishReasonCode.HasFailed, onNext.Value.Value.ReasonCode);
Assert.Equal(exception, onNext.Value.Value.Exception);
}
public void ApplicationMessageProcessedHandler()
{
using var mock = AutoMock.GetLoose();
mock.Mock <IManagedMqttClient>()
.SetupProperty(x => x.ApplicationMessageProcessedHandler);
var rxMqttClinet = mock.Create <RxMqttClient>();
var testScheduler = new TestScheduler();
var message = new ManagedMqttApplicationMessage();
var @event = new ApplicationMessageProcessedEventArgs(message, new Exception());
testScheduler.ScheduleAsync(TimeSpan.FromTicks(2), (_, __) => mock.Mock <IManagedMqttClient>().Object.ApplicationMessageProcessedHandler.HandleApplicationMessageProcessedAsync(@event));
// act
var testObserver = testScheduler.Start(() => rxMqttClinet.ApplicationMessageProcessedEvent, 0, 0, 4);
Assert.Equal(1, testObserver.Messages.Count);
Assert.Equal(NotificationKind.OnNext, testObserver.Messages.Last().Value.Kind);
Assert.Equal(@event, testObserver.Messages.Last().Value.Value);
Assert.Null(rxMqttClinet.InternalClient.SynchronizingSubscriptionsFailedHandler);
}
public void Publish_Not_IsConnected()
{
using var mock = AutoMock.GetLoose();
mock.Mock <IManagedMqttClient>()
.Setup(x => x.PublishAsync(It.IsAny <ManagedMqttApplicationMessage>())).Returns(Task.CompletedTask);
mock.Mock <IManagedMqttClient>()
.SetupProperty(x => x.ApplicationMessageProcessedHandler);
mock.Mock <IManagedMqttClient>()
.SetupProperty(x => x.ApplicationMessageSkippedHandler);
var rxMqttClinet = mock.Create <RxMqttClient>();
var message = new ManagedMqttApplicationMessageBuilder()
.WithApplicationMessage(new MqttApplicationMessageBuilder()
.WithTopic("T")
.WithPayload("P")
.WithExactlyOnceQoS()
.Build())
.Build();
var observable = Observable.Return(message);
var @event = new ApplicationMessageProcessedEventArgs(message, null);
var testScheduler = new TestScheduler();
// act
var testObserver = testScheduler.Start(() => observable.PublishOn(rxMqttClinet), 0, 0, 2);
Assert.Single(testObserver.Messages.Where(m => m.Value.Kind == System.Reactive.NotificationKind.OnNext));
Assert.Single(testObserver.Messages.Where(m => m.Value.Kind == System.Reactive.NotificationKind.OnCompleted));
Assert.Empty(testObserver.Messages.Where(m => m.Value.Kind == System.Reactive.NotificationKind.OnError));
var onNext = testObserver.Messages.Where(m => m.Value.Kind == System.Reactive.NotificationKind.OnNext).Single();
Assert.Equal(message, onNext.Value.Value.MqttApplicationMessage);
Assert.Equal(RxMqttClientPublishReasonCode.ClientNotConnected, onNext.Value.Value.ReasonCode);
Assert.Null(onNext.Value.Value.Exception);
}
private static void ApplicationMessageProcessedHandlerMethod(ApplicationMessageProcessedEventArgs obj)
{
Console.WriteLine("ApplicationMessageProcessedHandlerMethod");
}
private void OnApplicationMessageProcessed(ApplicationMessageProcessedEventArgs eventArgs)
{
Logger.LogDebug("Request processed.");
}
private void ApplicationMessageProcessedHandler(ApplicationMessageProcessedEventArgs obj)
{
Console.WriteLine($"PROCESSED: {obj.ApplicationMessage.ApplicationMessage.Topic} | {Encoding.UTF8.GetString(obj.ApplicationMessage.ApplicationMessage.Payload)}");
}
public static void OnMensajeProcesado(ApplicationMessageProcessedEventArgs obj)
{
new Log().Escribir("hola");
}
