public void Publish(Event @event)
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
var policy = Policy.Handle <Exception>()
.WaitAndRetry(_options.RetryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
(ex, time) =>
{
_logger.LogWarning(ex,
"Could not publish event: {EventId} after {Timeout}s ({ExceptionMessage})", @event.Id,
$"{time.TotalSeconds:n1}", ex.Message);
});
var client = _persistentConnection.GetClient();
var eventName = _subsManager.GetEventKey(@event);
var message = JsonSerializer.Serialize(@event, @event.GetType(), _options.JsonSerializerOptions);
policy.Execute(() =>
{
var mqttMessageBuilder = new MqttApplicationMessageBuilder()
.WithTopic(eventName)
.WithPayload(message)
.WithExactlyOnceQoS();
if (_options.PublishRetainedMessage)
{
mqttMessageBuilder = mqttMessageBuilder.WithRetainFlag();
}
client.PublishAsync(mqttMessageBuilder.Build(), CancellationToken.None).Wait();
});
}
/// <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);
}
var devices = results.DataRead.GroupBy(a => a.ValueItemChangeEvent.Id.Remove(a.ValueItemChangeEvent.Id.LastIndexOf('/')).Remove(0, 2));
foreach (var device in devices)
{
var observations = new List <Observation>();
var deviceMessage = new IotEdgeMessage
{
Format = "rec2.3",
Observations = observations,
DeviceId = device.Key
};
AddUpdatedValuesToMessage(observations, device.Key, device.ToList(), si.CachedSubscribedItems, sendAdditionalProperties);
var messageBuilder = new MqttApplicationMessageBuilder();
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(message);
}
return(true);
}
public async Task PublishAsync(string topic, string payload, int qos, bool retain)
{
var message = new MqttApplicationMessageBuilder()
.WithTopic(topic);
if (!string.IsNullOrEmpty(payload))
{
message = message.WithPayload(payload);
}
if (qos == 2)
{
message = message.WithExactlyOnceQoS();
}
else
{
message = message.WithAtLeastOnceQoS();
}
if (retain)
{
message = message.WithRetainFlag();
}
await client.PublishAsync(message.Build());
}
private MqttApplicationMessage BuildMessage()
{
byte[] data = input.SelectedBinaryValue;
MqttApplicationMessageBuilder messageBuilder = new MqttApplicationMessageBuilder()
.WithPayload(new MemoryStream(data), data.Length)
.WithTopic(topicPublish.Text);
if (qosPublish.SelectedIndex == -1)
{
qosPublish.SelectedIndex = 0;
}
messageBuilder.WithQualityOfServiceLevel((MqttQualityOfServiceLevel)qosPublish.SelectedIndex);
messageBuilder.WithRetainFlag(retain.Checked);
return(messageBuilder.Build());
}
public async Task PublishOnAsync(string topic, string message, bool retain)
{
MqttApplicationMessageBuilder builder;
MqttApplicationMessage msg;
if (!this.Client.IsConnected)
{
return;
}
builder = new MqttApplicationMessageBuilder();
builder.WithAtMostOnceQoS();
builder.WithPayload(message);
builder.WithTopic(topic);
builder.WithRetainFlag(retain);
msg = builder.Build();
await this.Client.PublishAsync(msg).ConfigureAwait(false);
}
private static MqttApplicationMessage BuildApplicationMessage(MqttMessageSettings mqttMessageSettings)
{
var mqttMessageBuilder = new MqttApplicationMessageBuilder()
.WithTopic(mqttMessageSettings.Topic)
.WithPayload(mqttMessageSettings.Payload);
if (mqttMessageSettings.QualityOfServiceLevel.HasValue)
{
mqttMessageBuilder = mqttMessageBuilder.WithQualityOfServiceLevel(mqttMessageSettings.QualityOfServiceLevel.Value);
}
if (mqttMessageSettings.Retain.HasValue)
{
mqttMessageBuilder = mqttMessageBuilder.WithRetainFlag(mqttMessageSettings.Retain.Value);
}
var mqttMessage = mqttMessageBuilder.Build();
return(mqttMessage);
}
/// <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);
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
var factory = new MqttFactory();
var l = factory.CreateMqttClient();
var opt = new MqttClientOptions();
opt.ClientId = "LocalTestClient";
opt.ChannelOptions = new MqttClientTcpOptions
{
Port = 8883,
// TlsOptions = new MqttClientTlsOptions
// {
// AllowUntrustedCertificates = true,
// UseTls = true,
// },
Server = "localhost",
// Server = "mqtt.qaybe.de",
};
opt.Credentials = new MqttClientCredentials
{
Username = "******",
Password = Encoding.UTF8.GetBytes("Test")
};
var result = await l.ConnectAsync(opt, CancellationToken.None);
var mssg = new MqttApplicationMessageBuilder();
mssg.WithRetainFlag(true);
var la = mssg.WithPayload("Hello from Client sowieso")
.WithTopic("test/nace/message")
.Build();
var response = await l.PublishAsync(la, CancellationToken.None);
Console.WriteLine(response.ReasonString);
}
public async Task <MQTTnet.Client.Connecting.MqttClientAuthenticateResult> ConnectAsync(CancellationToken cancellationToken)
{
var cancelToken = cancellationToken != null ? cancellationToken : CancellationToken.None;
MqttClientAuthenticateResult connectPrimary = null;
if (!PrimaryClient.IsConnected)
{
PrimaryClient.UseConnectedHandler(async e =>
{
var primaryFilters = Options.PrimaryFilters != null && Options.PrimaryFilters.Any()
? Options.PrimaryFilters
: new TopicFilter[] { new TopicFilterBuilder().WithTopic("#").Build() };
await PrimaryClient.SubscribeAsync(primaryFilters);
});
connectPrimary = await PrimaryClient.ConnectAsync(Options.PrimaryOptions, cancelToken);
if (connectPrimary.ResultCode != MqttClientConnectResultCode.Success)
{
throw new ArgumentException("PrimaryOptions, could not connect to primary server.");
}
}
if (!SecondaryClient.IsConnected)
{
var connectSecondary = await SecondaryClient.ConnectAsync(Options.SecondaryOptions, cancelToken);
if (connectSecondary.ResultCode != MqttClientConnectResultCode.Success)
{
throw new ArgumentException("SecondaryOptions, could not connect to secondary server.");
}
}
PrimaryClient.UseDisconnectedHandler(async e =>
{
var connectRetry = Policy
.Handle <Exception>()
.WaitAndRetryForeverAsync(
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
(exception, timespan) =>
{
Console.WriteLine("### DISCONNECTED FROM SERVER ###");
});
await connectRetry.ExecuteAsync(async() => {
var response = await PrimaryClient.ConnectAsync(Options.PrimaryOptions, cancelToken);
Console.Write($"{response.ResultCode} {response.ReasonString}");
});
});
SecondaryClient.UseDisconnectedHandler(async e =>
{
var connectRetry = Policy
.Handle <Exception>()
.WaitAndRetryForeverAsync(
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
(exception, timespan) =>
{
Console.WriteLine("### DISCONNECTED FROM SERVER ###");
});
await connectRetry.ExecuteAsync(async() => {
var response = await SecondaryClient.ConnectAsync(Options.SecondaryOptions, cancelToken);
Console.Write($"{response.ResultCode} {response.ReasonString}");
});
});
PrimaryClient.UseApplicationMessageReceivedHandler(e =>
{
var message = new MqttApplicationMessageBuilder()
.WithTopic(e.ApplicationMessage.Topic)
.WithPayload(e.ApplicationMessage.Payload);
if (e.ApplicationMessage.Retain)
{
message = message.WithRetainFlag();
}
switch (e.ApplicationMessage.QualityOfServiceLevel)
{
case MqttQualityOfServiceLevel.ExactlyOnce:
message = message.WithExactlyOnceQoS();
break;
case MqttQualityOfServiceLevel.AtLeastOnce:
message = message.WithAtLeastOnceQoS();
break;
case MqttQualityOfServiceLevel.AtMostOnce:
message = message.WithAtMostOnceQoS();
break;
default:
throw new ArgumentOutOfRangeException();
}
Task.Run(() => SecondaryClient.PublishAsync(message.Build(), cancelToken), cancelToken);
});
if (Options.SyncMode)
{
SecondaryClient.UseConnectedHandler(async e =>
{
var secondaryFilters = Options.SecondaryFilters != null && Options.SecondaryFilters.Any()
? Options.SecondaryFilters
: new TopicFilter[] { new TopicFilterBuilder().WithTopic("#").Build() };
await SecondaryClient.SubscribeAsync(secondaryFilters);
});
SecondaryClient.UseApplicationMessageReceivedHandler(e =>
{
var message = new MqttApplicationMessageBuilder()
.WithTopic(e.ApplicationMessage.Topic)
.WithPayload(e.ApplicationMessage.Payload);
if (e.ApplicationMessage.Retain)
{
message = message.WithRetainFlag();
}
switch (e.ApplicationMessage.QualityOfServiceLevel)
{
case MqttQualityOfServiceLevel.ExactlyOnce:
message = message.WithExactlyOnceQoS();
break;
case MqttQualityOfServiceLevel.AtLeastOnce:
message = message.WithAtLeastOnceQoS();
break;
case MqttQualityOfServiceLevel.AtMostOnce:
message = message.WithAtMostOnceQoS();
break;
default:
throw new ArgumentOutOfRangeException();
}
Task.Run(() => PrimaryClient.PublishAsync(message.Build(), cancelToken), cancelToken);
});
}
return(connectPrimary);
}
