private MqttApplicationMessage BuildMessage(string methodName, byte[] payload, bool utf8Payload, string contentType, MqttQualityOfServiceLevel qos, TimeSpan timeout, string target, Action <MqttApplicationMessageBuilder> action = null) { if (methodName == null) { throw new ArgumentNullException(nameof(methodName)); } var builder = new MqttApplicationMessageBuilder() .WithTopic(GetRequestTopic(target, qos)) .WithContentType(contentType) .WithUserProperty("Method", methodName) .WithQualityOfServiceLevel(qos); if (payload != null) { builder .WithPayload(payload) .WithPayloadFormatIndicator(utf8Payload ? MqttPayloadFormatIndicator.CharacterData : MqttPayloadFormatIndicator.Unspecified); } if (timeout != default && timeout != Timeout.InfiniteTimeSpan) { builder .WithMessageExpiryInterval(Convert.ToUInt32(timeout.TotalSeconds)) .WithUserProperty("Timeout", Convert.ToInt32(timeout.TotalSeconds).ToString()); } action?.Invoke(builder); return(builder.Build()); }
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 static void configure(IMqttServer server) { server.Started += async(sender, args) => { var msg = new MqttApplicationMessageBuilder() .WithPayload("Mqtt is awesome") .WithTopic("message"); while (true) { try { await server.PublishAsync(msg.Build()); msg.WithPayload("Mqtt is still awesome at " + DateTime.Now); } catch (Exception e) { Console.WriteLine(e); } finally { await Task.Delay(TimeSpan.FromSeconds(2)); } } }; }
/// <summary> /// 发布消息 /// </summary> /// <param name="topic">通道</param> /// <param name="message">消息</param> /// <param name="qosLevel">0:最多一次,1:至少一次,2:有且仅有一次</param> /// <param name="retain"></param> /// <returns></returns> public bool Publish(string topic, byte[] message, byte qosLevel = 0, bool retain = false) { try { if (!Connect()) { return(false); } var mamb = new MqttApplicationMessageBuilder() .WithTopic(topic) .WithPayload(message).WithRetainFlag(retain); if (qosLevel == 0) { mamb = mamb.WithAtMostOnceQoS(); } else if (qosLevel == 1) { mamb = mamb.WithAtLeastOnceQoS(); } else if (qosLevel == 2) { mamb = mamb.WithExactlyOnceQoS(); } var result = mqttClient.PublishAsync(mamb.Build()).Result; return(result.ReasonCode == MqttClientPublishReasonCode.Success); } catch (Exception ex) { OnException?.Invoke(ex); return(false); } }
public async Task No_Payload() { using (var testEnvironment = new TestEnvironment()) { await testEnvironment.StartServerAsync(); var sender = await testEnvironment.ConnectClientAsync(); var receiver = await testEnvironment.ConnectClientAsync(); var message = new MqttApplicationMessageBuilder() .WithTopic("A"); await receiver.SubscribeAsync(new MqttClientSubscribeOptions { TopicFilters = new List <TopicFilter> { new TopicFilter { Topic = "#" } } }, CancellationToken.None); MqttApplicationMessage receivedMessage = null; receiver.UseApplicationMessageReceivedHandler(e => receivedMessage = e.ApplicationMessage); await sender.PublishAsync(message.Build(), CancellationToken.None); await Task.Delay(1000); Assert.IsNotNull(receivedMessage); Assert.AreEqual("A", receivedMessage.Topic); Assert.AreEqual(null, receivedMessage.Payload); } }
public async Task PublishAsync(string topic, byte[] payload, Dictionary <string, string> properties, Qos qos, CancellationToken cancellationToken) { var mqttMessageBuilder = new MqttApplicationMessageBuilder() .WithTopic(topic) .WithPayload(payload) .WithQualityOfServiceLevel(MapQos(qos)); if (properties != null) { foreach (var entry in properties) { mqttMessageBuilder.WithUserProperty(entry.Key, entry.Value); } } MqttClientPublishResult publishResult; try { publishResult = await client.PublishAsync(mqttMessageBuilder.Build(), cancellationToken); } catch (Exception e) { throw new MqttException(cause: e); } ValidatePublishResult(publishResult); }
public async Task <MqttClientPublishResult> SendDiscoveryAsync <TEntityDefinition>( string topic, TEntityDefinition payload, CancellationToken cancellationToken = default) where TEntityDefinition : IEntityDefinition { var payloadString = GetPayloadString(payload); var messageBuilder = new MqttApplicationMessageBuilder() .WithTopic(topic) .WithPayload(payloadString) .WithRetainFlag(Settings.Value.Retain); if (Settings.Value.QualityOfService.HasValue) { messageBuilder = messageBuilder.WithQualityOfServiceLevel(Settings.Value.QualityOfService.Value); } Logger.LogInformation("[{topic}] {payload}", topic, payloadString); var message = messageBuilder.Build(); var result = await MqttClient.PublishAsync(message, cancellationToken); return(result); }
private IDisposable BindObserver( IMqttMessageBus target, TEntity entity, TEntityDefinition entityDefinition, MqttQualityOfServiceLevel?qualityOfServiceLevel, bool retainMessages) => GetStateChangeDetector(entity) .Subscribe( state => { var payload = GetStateMessagePayload(entityDefinition, entity); var messageBuilder = new MqttApplicationMessageBuilder() .WithTopic(entityDefinition.StateTopic) .WithPayload(payload) .WithRetainFlag(retainMessages); if (qualityOfServiceLevel.HasValue) { messageBuilder = messageBuilder.WithQualityOfServiceLevel(qualityOfServiceLevel.Value); } var message = messageBuilder.Build(); if (message.Payload != null) { target.PublishMessage(message); } } );
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(); }); }
public static async Task sendMessage(string user, string message) { //Console.WriteLine("Sending message"); var appMessage = new MqttApplicationMessageBuilder() .WithTopic("/request"); switch (message) { case "on": appMessage.WithPayload(new byte[] { 1 }); break; case "off": appMessage.WithPayload(new byte[] { 0 }); break; case "state": appMessage.WithPayload(new byte[] { 2 }); break; case "rAir": appMessage.WithPayload(new byte[] { 3 }); break; case "rWater": appMessage.WithPayload(new byte[] { 4 }); break; default: appMessage.WithPayload(message); break; } await client.PublishAsync(appMessage.Build()); }
private async Task ReceiveHubMessagesAsync() { using (Message receivedMessage = await DeviceClient.ReceiveAsync(TimeSpan.FromSeconds(30)).ConfigureAwait(false)) { if (receivedMessage == null) { Console.WriteLine("\t{0}> Timed out", DateTime.Now.ToLocalTime()); return; } var message = new MqttApplicationMessageBuilder() .WithPayload(receivedMessage.GetBytes()); string payload = Encoding.ASCII.GetString(receivedMessage.GetBytes()); Console.WriteLine("\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), payload); if (receivedMessage.Properties.ContainsKey("topic")) { message.WithTopic(receivedMessage.Properties["topic"]); } var keyExclude = new string[] { "topic", "clientId" }; foreach (var prop in receivedMessage.Properties.Where(k => !keyExclude.Contains(k.Key))) { message.WithUserProperty(prop.Key, prop.Value); } await LocalClient.PublishAsync(message.Build(), CancellationToken.None); await DeviceClient.CompleteAsync(receivedMessage).ConfigureAwait(false); } }
private void onSend(object state) { var topic = ServiceOptions.MqttClientSettings.Topic.ProcessTemplate(ServiceOptions.TemplateVariables.Variables, _clientId); var payload = ServiceOptions.MqttClientSettings.Payload.ProcessTemplate(ServiceOptions.TemplateVariables.Variables, _clientId); var messagebuilder = new MqttApplicationMessageBuilder() .WithTopic(topic) .WithPayload(payload); if (ServiceOptions.MqttClientSettings.Qos == 1) { messagebuilder.WithAtLeastOnceQoS(); } else if (ServiceOptions.MqttClientSettings.Qos == 2) { messagebuilder.WithExactlyOnceQoS(); } else { messagebuilder.WithAtMostOnceQoS(); } var message = messagebuilder.Build(); _logger.Debug($"Zombie publishing {payload} to {topic}"); _totalClientPublishes.Inc(); _clientPublishes.WithLabels(_clientId).Inc(); Task.Run(() => _mqttClient.PublishAsync(message, CancellationToken.None)); }
public async Task Subscribe_Lots_In_Single_Request() { using (var testEnvironment = new TestEnvironment(TestContext)) { var receivedMessagesCount = 0; await testEnvironment.StartServer(); var c1 = await testEnvironment.ConnectClient(); c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount)); var optionsBuilder = new MqttClientSubscribeOptionsBuilder(); for (var i = 0; i < 500; i++) { optionsBuilder.WithTopicFilter(i.ToString(), MqttQualityOfServiceLevel.AtMostOnce); } await c1.SubscribeAsync(optionsBuilder.Build()).ConfigureAwait(false); var c2 = await testEnvironment.ConnectClient(); var messageBuilder = new MqttApplicationMessageBuilder(); for (var i = 0; i < 500; i++) { messageBuilder.WithTopic(i.ToString()); await c2.PublishAsync(messageBuilder.Build()).ConfigureAwait(false); } SpinWait.SpinUntil(() => receivedMessagesCount == 500, TimeSpan.FromSeconds(20)); Assert.AreEqual(500, receivedMessagesCount); } }
public async void PublishMessage(string topic, string message) { MqttApplicationMessageBuilder messageBuilder = new MqttApplicationMessageBuilder() .WithTopic(topic) .WithPayload(message); await client.PublishAsync(messageBuilder.Build(), CancellationToken.None); }
/// <summary> /// 发布主题 /// </summary> /// <param name="Message"></param> public void Publish(IotTopic topic, string Message, bool isWait = false) { if (!Enabled) { return; } try { if (mqttClient == null) { return; } if (mqttClient.IsConnected == false) { mqttClient.ConnectAsync(options); } if (mqttClient.IsConnected == false) { Console.WriteLine("Publish >>Connected Failed! "); return; } string tp = topicDeviceId + "/" + Enum.GetName(typeof(IotTopic), topic); Console.WriteLine("Publish >>Message: " + Message); MqttApplicationMessageBuilder mamb = new MqttApplicationMessageBuilder() .WithTopic(tp) .WithPayload(Message) .WithExactlyOnceQoS() .WithRetainFlag(false); if (isWait == true) { mqttClient.PublishAsync(mamb.Build()).Wait(); } else { mqttClient.PublishAsync(mamb.Build()); } } catch (Exception exp) { Console.WriteLine("Publish exception >>" + exp.Message); } }
public async Task Handle(MqttMessageReceivedEvent notification) { Topic topic = Topic.Parse(notification.Topic); string payload = Encoding.UTF8.GetString(notification.Payload); //请求返回 if (topic.MessageType == MessageTypes.Response) { if (RequestWaiter.WaitingDic.TryGetValue(topic.MessageId, out Waiter waiter)) { waiter.ResponseJson = payload; waiter.Sp.Release(); } return; } var theHandler = Cache.GetHandler(topic.MessageBodyType); if (theHandler.handleMessageType != null) { using var scop = _serviceProvider.CreateScope(); var messageContext = Activator.CreateInstance(typeof(MessageContext <>).MakeGenericType(theHandler.handleMessageType)) as MessageContext; object message = JsonConvert.DeserializeObject(payload, theHandler.realMessageType); messageContext.ServiceProvider = scop.ServiceProvider; messageContext.MessageId = topic.MessageId; messageContext.MessageBody = payload; messageContext.SetPropertyValue("Message", message); var handlerInstance = ActivatorUtilities.CreateInstance(scop.ServiceProvider, theHandler.handlerType); var task = theHandler.handleMethod.Invoke(handlerInstance, new object[] { messageContext }) as Task; await task; //请求返回 if (messageContext.Response != null) { Topic responseTopic = new Topic { MessageId = topic.MessageId, MessageBodyType = messageContext.Response.GetType().FullName, MessageType = MessageTypes.Response, SourceClientId = _mqttClient.Options.ClientId, SourceEndpoint = _messageBusOptions.Endpoint, TargetClientId = topic.SourceClientId, TargetEndpoint = topic.SourceEndpoint }; var responsePayload = new MqttApplicationMessageBuilder() .WithPayload(JsonConvert.SerializeObject(messageContext.Response)) .WithAtLeastOnceQoS() .WithTopic(responseTopic.ToString()); await _mqttClient.PublishAsync(responsePayload.Build()); } } }
public TSelfInterface WithDeleteMessage(Action <MqttApplicationMessageBuilder> configurator) { var messageBuilder = new MqttApplicationMessageBuilder(); configurator.Invoke(messageBuilder); DeleteMessage = messageBuilder.Build(); return((TSelf)this); }
public static MqttApplicationMessage BuildMessage() { var message = new MqttApplicationMessageBuilder() .WithAtMostOnceQoS() .WithPayload("123") .WithTopic("test.netcore"); return(message.Build()); }
public void BroadCast(IMqttServer mqttServer, MqttApplicationMessageBuilder builder) { try { mqttServer.PublishAsync(builder.Build()); } catch (MqttCommunicationException ee) { throw ee; } }
public void Configure(IApplicationBuilder app, IHostingEnvironment env) { app.UseConnections(c => c.MapMqtt("/mqtt")); #endif app.UseMqttServer(server => { server.StartedHandler = new MqttServerStartedHandlerDelegate(async args => { var frameworkName = GetType().Assembly.GetCustomAttribute <TargetFrameworkAttribute>()? .FrameworkName; var msg = new MqttApplicationMessageBuilder() .WithPayload($"Mqtt hosted on {frameworkName} is awesome") .WithTopic("message"); while (true) { try { await server.PublishAsync(msg.Build()); msg.WithPayload($"Mqtt hosted on {frameworkName} is still awesome at {DateTime.Now}"); } catch (Exception e) { Console.WriteLine(e); } finally { await Task.Delay(TimeSpan.FromSeconds(2)); } } }); }); app.Use((context, next) => { if (context.Request.Path == "/") { context.Request.Path = "/Index.html"; } return(next()); }); app.UseStaticFiles(); app.UseStaticFiles(new StaticFileOptions { RequestPath = "/node_modules", FileProvider = new PhysicalFileProvider(Path.Combine(env.ContentRootPath, "node_modules")) }); }
public async void PublishMessage(IMqttClient mqttClient, MqttApplicationMessageBuilder mqttApplicationMessageBuilder) { //var applicationMessage = new MqttApplicationMessageBuilder() // .WithTopic(topic) // .WithPayload(Encoding.UTF8.GetBytes(message)) // .WithQualityOfServiceLevel(mqttQualityOfServiceLevel) // .WithRetainFlag(true)//保持标志(Retain-Flag)该标志确定代理是否持久保存某个特定主题的消息。订阅该主题的新客户端将在订阅后立即收到该主题的最后保留消息。 // .Build(); await mqttClient.PublishAsync(mqttApplicationMessageBuilder.Build()); }
public MqttApplicationMessage CreateMqttApplicationMessage(object @event, string topic) { var data = Serialize(@event); var builder = new MqttApplicationMessageBuilder(); builder.WithTopic(topic); builder.WithPayload(data); MessageCreater.Invoke(builder); return(builder.Build()); }
// In class _Startup_ of the ASP.NET Core 2.0 project. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { app.UseConnections(c => c.MapConnectionHandler <MqttConnectionHandler>("/mqtt", options => { options.WebSockets.SubProtocolSelector = MQTTnet.AspNetCore.ApplicationBuilderExtensions.SelectSubProtocol; })); //app.UseMqttEndpoint(); app.UseMqttServer(server => { server.Started += async(sender, args) => { var msg = new MqttApplicationMessageBuilder() .WithPayload("Mqtt is awesome") .WithTopic("message"); while (true) { try { await server.PublishAsync(msg.Build()); msg.WithPayload("Mqtt is still awesome at " + DateTime.Now); } catch (Exception e) { Console.WriteLine(e); } finally { await Task.Delay(TimeSpan.FromSeconds(2)); } } }; }); app.Use((context, next) => { if (context.Request.Path == "/") { context.Request.Path = "/Index.html"; } return(next()); }); app.UseStaticFiles(); app.UseStaticFiles(new StaticFileOptions { RequestPath = "/node_modules", FileProvider = new PhysicalFileProvider(Path.Combine(env.ContentRootPath, "node_modules")) }); }
void timerCallback(object state) { var appMsgBuilder = new MqttApplicationMessageBuilder(); var msg = Encoding.UTF8.GetBytes("我是服务端"); appMsgBuilder.WithPayload(msg) .WithTopic("家/客厅/空调/开关"); var appMsg = appMsgBuilder.Build(); mqttServer.PublishAsync(appMsg).Wait(); }
protected MqttApplicationMessage CreateDefaultDiscoveryMessage(TEntityDefinition entityDefinition) { var messageBuilder = new MqttApplicationMessageBuilder() .WithTopic(DiscoveryTopic) .WithPayload(GetDiscoveryPayloadString(entityDefinition)) .WithRetainFlag(RetainDiscoveryMessages); if (DiscoveryMessageQualityOfServiceLevel.HasValue) { messageBuilder = messageBuilder.WithQualityOfServiceLevel(DiscoveryMessageQualityOfServiceLevel.Value); } return(messageBuilder.Build()); }
private static MqttApplicationMessage CreateApplicationMessage(string topic, string message, bool retain = false, int qos = 0) { var mb = new MqttApplicationMessageBuilder() .WithQualityOfServiceLevel((MqttQualityOfServiceLevel)qos) .WithTopic(topic) .WithRetainFlag(retain); if (!string.IsNullOrWhiteSpace(message)) { mb.WithPayload(Encoding.UTF8.GetBytes(message)); } return(mb.Build()); }
public ManagedMqttApplicationMessageBuilder WithApplicationMessage(Action <MqttApplicationMessageBuilder> builder) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } var internalBuilder = new MqttApplicationMessageBuilder(); builder(internalBuilder); _applicationMessage = internalBuilder.Build(); return(this); }
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()); }
protected MqttApplicationMessage CreateDefaultDeleteMessage() { var messageBuilder = new MqttApplicationMessageBuilder() .WithTopic(DiscoveryTopic) .WithPayload(Array.Empty <byte>()); if (DiscoveryMessageQualityOfServiceLevel.HasValue) { messageBuilder = messageBuilder.WithQualityOfServiceLevel(DiscoveryMessageQualityOfServiceLevel.Value); } var message = messageBuilder.Build(); return(message); }
public async Task PublishAsync(string topic, string payload, string contentType) { if (mqttClient.IsConnected) { MqttApplicationMessageBuilder messageBuilder = new MqttApplicationMessageBuilder() .WithContentType(contentType) .WithPayload(payload) .WithTopic(topic) .WithQualityOfServiceLevel(MQTTnet.Protocol.MqttQualityOfServiceLevel.ExactlyOnce); var result = await mqttClient.PublishAsync(messageBuilder.Build()); Console.WriteLine(result.ReasonString); } }