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); }