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