private async void TimerCallback(object stateInfo)
{
_timersMutex.WaitOne();
try
{
var timerDetails = (TimerDetails)stateInfo;
var topic = $"mqtttimer/{timerDetails.Name}";
_logger.LogInformation($"Timer callback for {timerDetails.Name} called.");
_logger.LogInformation($"Publishing payload '{timerDetails.ResponsePayload}' to topic {topic}");
var managedMqttApplicationMessage = new ManagedMqttApplicationMessageBuilder()
.WithApplicationMessage(new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(timerDetails.ResponsePayload)
.WithAtLeastOnceQoS()
.WithRetainFlag()
.Build())
.Build();
await _mqttClient.PublishAsync(managedMqttApplicationMessage);
}
finally
{
_timersMutex.ReleaseMutex();
}
}
public async Task PublishAsync(string topic, string payload)
{
var applicationMessage = new MqttApplicationMessageBuilder().WithTopic(topic)
.WithPayload(payload)
.Build();
var manegedApplicationMessage = new ManagedMqttApplicationMessageBuilder().WithApplicationMessage(applicationMessage)
.Build();
await _mqttClient.PublishAsync(manegedApplicationMessage);
}
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);
}
/// <summary>
/// Sends the Observations to the MQTT broker
/// </summary>
/// <param name="sendAdditionalProperties">If true, the 'Writeable' and 'Forceable' properties will be sent in the Observation</param>
/// <returns></returns>
private async Task <bool> UpdateValues(SubscriptionReader si, ReadResult <SubscriptionResultItem> results, bool sendAdditionalProperties = false)
{
if (!results.Success)
{
Prompts.AddRange(results.Prompts);
return(false);
}
if (results.DataRead.Any(a => a.ValueItemChangeEvent.State == EwsValueStateEnum.Error))
{
CheckAndRetryValuesWithError(si, results);
}
var signalChanges = results.DataRead.GroupBy(a => a.ValueItemChangeEvent.Id.Remove(a.ValueItemChangeEvent.Id.LastIndexOf('/')).Remove(0, 2)).ToList();
var devices = _tempSignals.GroupBy(a => a.DatabasePath.Remove(a.DatabasePath.LastIndexOf('/')));
foreach (var device in devices)
{
var observations = new List <Observation>();
var deviceMessage = new IotEdgeMessage
{
Format = "rec2.3",
Observations = observations,
DeviceId = device.Key
};
var signalChangesForDevice = signalChanges.FirstOrDefault(a => a.Key == device.Key);
AddUpdatedValuesToMessage(observations, device.Key, signalChangesForDevice == null || !signalChangesForDevice.ToList().Any() ? new List <SubscriptionResultItem>() : signalChangesForDevice.ToList(), si.CachedSubscribedItems, sendAdditionalProperties);
if (deviceMessage.Observations != null && deviceMessage.Observations.Count > 0)
{
var messageBuilder = new MqttApplicationMessageBuilder();
var managedMessageBuilder = new ManagedMqttApplicationMessageBuilder();
var message = messageBuilder.WithRetainFlag().WithAtLeastOnceQoS().WithTopic(ValuePushTopic).WithPayload(deviceMessage.ToJson()).Build();
Logger.LogTrace(LogCategory.Processor, this.Name, $"Sending Message to MQTT Broker: {deviceMessage.ToJson()}");
await ManagedMqttClient.PublishAsync(managedMessageBuilder.WithApplicationMessage(message).Build());
}
}
return(true);
}
public async void PublishAsync()
{
using var mock = AutoMock.GetLoose();
mock.Mock <IManagedMqttClient>();
var rxMqttClinet = mock.Create <RxMqttClient>();
var message = new MqttApplicationMessageBuilder()
.WithTopic("T")
.WithPayload("P")
.WithExactlyOnceQoS()
.Build();
var mangedMessage = new ManagedMqttApplicationMessageBuilder()
.WithApplicationMessage(message)
.Build();
// act
await rxMqttClinet.PublishAsync(mangedMessage);
// test
mock.Mock <IManagedMqttClient>().Verify(x => x.PublishAsync(mangedMessage));
}
private async Task ClearMqttTopicRetainedMessage(TimerDetails timerDetails)
{
_timersMutex.WaitOne();
try
{
var topic = $"mqtttimer/{timerDetails.Name}";
var managedMqttApplicationMessage = new ManagedMqttApplicationMessageBuilder()
.WithApplicationMessage(new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithAtLeastOnceQoS()
.WithRetainFlag()
.Build())
.Build();
await _mqttClient.PublishAsync(managedMqttApplicationMessage);
}
finally
{
_timersMutex.ReleaseMutex();
}
}
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);
}
public void Publish_ManagedMqttApplicationMessage()
{
using var mock = AutoMock.GetLoose();
mock.Mock <IRxMqttClient>().Setup(x => x.PublishAsync(It.IsAny <ManagedMqttApplicationMessage>())).Returns(Task.CompletedTask);
mock.Mock <IRxMqttClient>().Setup(x => x.ApplicationMessageProcessedEvent).Returns(Observable.Never <ApplicationMessageProcessedEventArgs>());
mock.Mock <IRxMqttClient>().Setup(x => x.ApplicationMessageSkippedEvent).Returns(Observable.Never <ApplicationMessageSkippedEventArgs>());
mock.Mock <IRxMqttClient>().Setup(x => x.IsConnected).Returns(true);
var rxMqttClinet = mock.Mock <IRxMqttClient>();
var message = new ManagedMqttApplicationMessageBuilder()
.WithApplicationMessage(new MqttApplicationMessageBuilder()
.WithTopic("T")
.WithPayload("P")
.WithExactlyOnceQoS()
.Build())
.Build();
var observable = Observable.Return(message);
// act
rxMqttClinet.Object.Publish(observable).Subscribe();
// test
rxMqttClinet.Verify(x => x.PublishAsync(message));
}
