private static async Task StartServer()
{
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(1883);
var mqttServer = new MqttFactory().CreateMqttServer();
await mqttServer.StartAsync(optionsBuilder.Build());
var ct = new CancellationTokenSource();
var heartbeatTask = Task.Run(async() => await ServerHeartbeat(ct.Token, mqttServer));
Console.WriteLine("Type 'quit' to exit");
while (true)
{
string input = Console.ReadLine();
if (input != null && input.Contains("quit"))
{
break;
}
}
ct.Cancel();
await heartbeatTask;
await mqttServer.StopAsync();
}
public async Task MqttServer_WillMessage()
{
var serverAdapter = new TestMqttServerAdapter();
var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
var receivedMessagesCount = 0;
try
{
await s.StartAsync(new MqttServerOptions());
var willMessage = new MqttApplicationMessageBuilder().WithTopic("My/last/will").WithAtMostOnceQoS().Build();
var c1 = await serverAdapter.ConnectTestClient("c1");
var c2 = await serverAdapter.ConnectTestClient("c2", willMessage);
c1.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
await c1.SubscribeAsync(new TopicFilterBuilder().WithTopic("#").Build());
await c2.DisconnectAsync();
await Task.Delay(1000);
await c1.DisconnectAsync();
}
finally
{
await s.StopAsync();
}
Assert.AreEqual(0, receivedMessagesCount);
}
public async Task MqttServer_NoRetainedMessage()
{
var serverAdapter = new TestMqttServerAdapter();
var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
var receivedMessagesCount = 0;
try
{
await s.StartAsync(new MqttServerOptions());
var c1 = await serverAdapter.ConnectTestClient(s, "c1");
await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).Build());
await c1.DisconnectAsync();
var c2 = await serverAdapter.ConnectTestClient(s, "c2");
c2.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
await c2.SubscribeAsync(new TopicFilterBuilder().WithTopic("retained").Build());
await Task.Delay(500);
}
finally
{
await s.StopAsync();
}
Assert.AreEqual(0, receivedMessagesCount);
}
public async Task MqttServer_HandleCleanDisconnect()
{
var serverAdapter = new MqttTcpServerAdapter(new MqttNetLogger().CreateChildLogger());
var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
var clientConnectedCalled = 0;
var clientDisconnectedCalled = 0;
s.ClientConnected += (_, __) => clientConnectedCalled++;
s.ClientDisconnected += (_, __) => clientDisconnectedCalled++;
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.Build();
await s.StartAsync(new MqttServerOptions());
var c1 = new MqttFactory().CreateMqttClient();
await c1.ConnectAsync(clientOptions);
await Task.Delay(100);
await c1.DisconnectAsync();
await Task.Delay(100);
await s.StopAsync();
await Task.Delay(100);
Assert.AreEqual(clientConnectedCalled, clientDisconnectedCalled);
}
public async Task MqttServer_ShutdownDisconnectsClientsGracefully()
{
var serverAdapter = new MqttTcpServerAdapter(new MqttNetLogger().CreateChildLogger());
var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.Build();
var disconnectCalled = 0;
await s.StartAsync(new MqttServerOptions());
var c1 = new MqttFactory().CreateMqttClient();
c1.Disconnected += (sender, args) => disconnectCalled++;
await c1.ConnectAsync(clientOptions);
await Task.Delay(100);
await s.StopAsync();
await Task.Delay(100);
Assert.AreEqual(1, disconnectCalled);
}
public async Task MqttServer_SessionTakeover()
{
var server = new MqttFactory().CreateMqttServer();
try
{
await server.StartAsync(new MqttServerOptions());
var client1 = new MqttFactory().CreateMqttClient();
var client2 = new MqttFactory().CreateMqttClient();
var options = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.WithCleanSession(false)
.WithClientId("a").Build();
await client1.ConnectAsync(options);
await Task.Delay(500);
await client2.ConnectAsync(options);
await Task.Delay(500);
Assert.IsFalse(client1.IsConnected);
Assert.IsTrue(client2.IsConnected);
}
finally
{
await server.StopAsync();
}
}
public async Task MqttServer_WillMessage()
{
var serverAdapter = new TestMqttServerAdapter();
var services = new ServiceCollection()
.AddLogging()
.AddMqttServer()
.AddSingleton <IMqttServerAdapter>(serverAdapter)
.BuildServiceProvider();
var s = new MqttFactory(services).CreateMqttServer();
var receivedMessagesCount = 0;
try
{
await s.StartAsync();
var willMessage = new MqttApplicationMessageBuilder().WithTopic("My/last/will").WithAtMostOnceQoS().Build();
var c1 = await serverAdapter.ConnectTestClient(s, "c1");
var c2 = await serverAdapter.ConnectTestClient(s, "c2", willMessage);
c1.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
await c1.SubscribeAsync(new TopicFilter("#", MqttQualityOfServiceLevel.AtMostOnce));
await c2.DisconnectAsync();
await Task.Delay(1000);
}
finally
{
await s.StopAsync();
}
Assert.AreEqual(1, receivedMessagesCount);
}
public async Task MqttServer_Publish()
{
var serverAdapter = new TestMqttServerAdapter();
var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
var receivedMessagesCount = 0;
try
{
await s.StartAsync(new MqttServerOptions());
var c1 = await serverAdapter.ConnectTestClient(s, "c1");
c1.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
var message = new MqttApplicationMessageBuilder().WithTopic("a").WithAtLeastOnceQoS().Build();
await c1.SubscribeAsync(new TopicFilter("a", MqttQualityOfServiceLevel.AtLeastOnce));
await s.PublishAsync(message);
await Task.Delay(500);
}
finally
{
await s.StopAsync();
}
Assert.AreEqual(1, receivedMessagesCount);
}
public async Task MqttServer_Publish_MultipleClients()
{
var serverAdapter = new MqttTcpServerAdapter(new MqttNetLogger().CreateChildLogger());
var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
var receivedMessagesCount = 0;
var locked = new object();
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.Build();
var clientOptions2 = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.Build();
try
{
await s.StartAsync(new MqttServerOptions());
var c1 = new MqttFactory().CreateMqttClient();
var c2 = new MqttFactory().CreateMqttClient();
await c1.ConnectAsync(clientOptions);
await c2.ConnectAsync(clientOptions2);
c1.ApplicationMessageReceived += (_, __) =>
{
lock (locked)
{
receivedMessagesCount++;
}
};
c2.ApplicationMessageReceived += (_, __) =>
{
lock (locked)
{
receivedMessagesCount++;
}
};
var message = new MqttApplicationMessageBuilder().WithTopic("a").WithAtLeastOnceQoS().Build();
await c1.SubscribeAsync(new TopicFilter("a", MqttQualityOfServiceLevel.AtLeastOnce));
await c2.SubscribeAsync(new TopicFilter("a", MqttQualityOfServiceLevel.AtLeastOnce));
//await Task.WhenAll(Publish(c1, message), Publish(c2, message));
await Publish(c1, message);
await Task.Delay(500);
}
finally
{
await s.StopAsync();
}
Assert.AreEqual(2000, receivedMessagesCount);
}
static void Main(string[] args)
{
var optionsServer = new MqttServerOptionsBuilder()
.WithDefaultEndpointBoundIPAddress(new System.Net.IPAddress(new byte[] { 192, 168, 10, 254 }))
.WithDefaultEndpointPort(1883);
IMqttServer _mqttBroker = new MqttFactory().CreateMqttServer();
//IMqttClient mqttClient = new MqttFactory().CreateMqttClient();
//var optionsClient = new MqttClientOptionsBuilder().WithClientId("9999").WithTcpServer("192.168.10.254", 1883);
var receivedEvents = new List <string>();
_mqttBroker.ClientConnected += delegate(object sender, MQTTnet.Server.MqttClientConnectedEventArgs e)
{
//receivedEvents.Add(args.ClientId);
Console.WriteLine($"Client {e.ClientId} has connected");
};
_mqttBroker.ApplicationMessageReceived += delegate(object sender, MqttApplicationMessageReceivedEventArgs e)
{
//receivedEvents.Add(args.ClientId);
Console.WriteLine($"Client {e.ClientId} Published ({e.ApplicationMessage.ConvertPayloadToString()})");
};
//** Start broker
Task _brokerStart = Task.Run(() => _mqttBroker.StartAsync(optionsServer.Build()));
_brokerStart.Wait();
Console.WriteLine("Broker Started");
//Task taskClientStart = Task.Run(() => mqttClient.ConnectAsync(optionsClient.Build()));
//taskClientStart.Wait();
Console.WriteLine("Waiting to exit, Press Any Key");
var pause = new ManualResetEvent(false);
Console.ReadKey();
//pause.WaitOne();
Console.WriteLine("Goodbye");
//var taskClientStop = Task.Run(() => mqttClient.DisconnectAsync());
//taskClientStop.Wait();
//** Stop Broker
Task _brokerTaskStop = Task.Run(() => _mqttBroker.StopAsync());
_brokerTaskStop.Wait();
Console.WriteLine("Broker Stopped");
}
public async Task StartAsync()
{
var mqttServer = new MqttFactory().CreateMqttServer();
await mqttServer.StartAsync(new MqttServerOptions());
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
await mqttServer.StopAsync();
}
public static async Task <bool> Run()
{
// Configure MQTT server.
// Configure MQTT server.
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(Conf.Port);
var options = new MqttServerOptions();
options.ConnectionValidator = c =>
{
// if (c.ClientId.Length 10)
// {
// c.ReturnCode = MqttConnectReturnCode.ConnectionRefusedIdentifierRejected;
// return;
// }
// TODO: Adds WebHook to auth
if (c.Username != Conf.DefaultUser)
{
c.ReturnCode = MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
return;
}
if (c.Password != Conf.DefaultPass)
{
c.ReturnCode = MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
return;
}
c.ReturnCode = MqttConnectReturnCode.ConnectionAccepted;
};
var mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.ApplicationMessageReceived += (s, e) => {
// TODO: Adds Webhook to sending message ..
Console.WriteLine("### RECEIVED APPLICATION MESSAGE ###");
Console.WriteLine($"+ Topic = {e.ApplicationMessage.Topic}");
Console.WriteLine($"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}");
Console.WriteLine($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
Console.WriteLine($"+ Retain = {e.ApplicationMessage.Retain}");
Console.WriteLine();
};
options.SubscriptionInterceptor = ctx => {
Console.WriteLine("ClientID={0}", ctx.ClientId);
};
await mqttServer.StartAsync(options);
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
await mqttServer.StopAsync();
return(true);
}
static async void exec()
{
// Start a MQTT server.
var mqttServer = new MqttFactory().CreateMqttServer();
await mqttServer.StartAsync(new MqttServerOptions());
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
await mqttServer.StopAsync();
}
public async Task MqttServer_PersistRetainedMessage()
{
var storage = new TestStorage();
var serverAdapter = new TestMqttServerAdapter();
var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
try
{
var options = new MqttServerOptions {
Storage = storage
};
await s.StartAsync(options);
var c1 = await serverAdapter.ConnectTestClient("c1");
await c1.PublishAndWaitForAsync(s, new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
await Task.Delay(250);
await c1.DisconnectAsync();
}
finally
{
await s.StopAsync();
}
Assert.AreEqual(1, storage.Messages.Count);
s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
var receivedMessagesCount = 0;
try
{
var options = new MqttServerOptions {
Storage = storage
};
await s.StartAsync(options);
var c2 = await serverAdapter.ConnectTestClient("c2");
c2.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
await c2.SubscribeAsync(new TopicFilterBuilder().WithTopic("retained").Build());
await Task.Delay(250);
}
finally
{
await s.StopAsync();
}
Assert.AreEqual(1, receivedMessagesCount);
}
public async Task MqttServer_LotsOfRetainedMessages()
{
const int ClientCount = 100;
var server = new MqttFactory().CreateMqttServer();
try
{
await server.StartAsync(new MqttServerOptionsBuilder().Build());
Parallel.For(
0,
ClientCount,
new ParallelOptions {
MaxDegreeOfParallelism = 10
},
i =>
{
using (var client = new MqttFactory().CreateMqttClient())
{
client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("localhost").Build())
.GetAwaiter().GetResult();
for (var j = 0; j < 10; j++)
{
// Clear retained message.
client.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("r" + i)
.WithPayload(new byte[0]).WithRetainFlag().Build()).GetAwaiter().GetResult();
// Set retained message.
client.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("r" + i)
.WithPayload("value" + j).WithRetainFlag().Build()).GetAwaiter().GetResult();
}
client.DisconnectAsync().GetAwaiter().GetResult();
}
});
await Task.Delay(100);
var retainedMessages = server.GetRetainedMessages();
Assert.AreEqual(ClientCount, retainedMessages.Count);
for (var i = 0; i < ClientCount; i++)
{
Assert.IsTrue(retainedMessages.Any(m => m.Topic == "r" + i));
}
}
finally
{
await server.StopAsync();
}
}
public async Task MqttServer_PersistRetainedMessage()
{
var storage = new TestStorage();
var serverAdapter = new TestMqttServerAdapter();
var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
try
{
var options = new MqttServerOptions {
Storage = storage
};
await s.StartAsync(options);
var c1 = await serverAdapter.ConnectTestClient(s, "c1");
await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
await c1.DisconnectAsync();
}
finally
{
await s.StopAsync();
}
await Task.Delay(TimeSpan.FromSeconds(2));
// TODO: Find another way to wait for the retained components.
s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
var receivedMessagesCount = 0;
try
{
var options = new MqttServerOptions {
Storage = storage
};
await s.StartAsync(options);
var c2 = await serverAdapter.ConnectTestClient(s, "c2");
c2.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
await c2.SubscribeAsync(new TopicFilterBuilder().WithTopic("retained").Build());
await Task.Delay(500);
}
finally
{
await s.StopAsync();
}
Assert.AreEqual(1, receivedMessagesCount);
}
public static async Task test()
{
Console.WriteLine("Hello World! for MQTTnet Server...");
// Start a MQTT server.
var mqttServer = new MqttFactory().CreateMqttServer();
await mqttServer.StartAsync(new MqttServerOptions());
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
await mqttServer.StopAsync();
}
public async Task MqttServer_SameClientIdConnectDisconnectEventOrder()
{
var s = new MqttFactory().CreateMqttServer();
var events = new List <string>();
s.ClientConnected += (_, __) =>
{
lock (events)
{
events.Add("c");
}
};
s.ClientDisconnected += (_, __) =>
{
lock (events)
{
events.Add("d");
}
};
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.WithClientId("same_id")
.Build();
await s.StartAsync(new MqttServerOptions());
var c1 = new MqttFactory().CreateMqttClient();
var c2 = new MqttFactory().CreateMqttClient();
await c1.ConnectAsync(clientOptions);
await Task.Delay(250);
await c2.ConnectAsync(clientOptions);
await Task.Delay(250);
await c1.DisconnectAsync();
await Task.Delay(250);
await c2.DisconnectAsync();
await Task.Delay(250);
await s.StopAsync();
var flow = string.Join(string.Empty, events);
Assert.AreEqual("cdcd", flow);
}
public async Task MqttServer_PersistRetainedMessage()
{
var storage = new TestStorage();
var serverAdapter = new TestMqttServerAdapter();
var services = new ServiceCollection()
.AddLogging()
.AddMqttServer()
.AddSingleton <IMqttServerAdapter>(serverAdapter)
.BuildServiceProvider();
var s = new MqttFactory(services).CreateMqttServer(options => options.Storage = storage);
try
{
await s.StartAsync();
var c1 = await serverAdapter.ConnectTestClient(s, "c1");
await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
await c1.DisconnectAsync();
}
finally
{
await s.StopAsync();
}
await services.WaitForRetainedMessage("retained").TimeoutAfter(TimeSpan.FromSeconds(5));
s = new MqttFactory(services).CreateMqttServer(options => options.Storage = storage);
var receivedMessagesCount = 0;
try
{
await s.StartAsync();
var c2 = await serverAdapter.ConnectTestClient(s, "c2");
c2.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
await c2.SubscribeAsync(new TopicFilter("retained", MqttQualityOfServiceLevel.AtMostOnce));
await Task.Delay(500);
}
finally
{
await s.StopAsync();
}
Assert.AreEqual(1, receivedMessagesCount);
}
public async Task MqttServer_RetainedMessage()
{
var serverAdapter = new TestMqttServerAdapter();
var services = new ServiceCollection()
.AddLogging()
.AddMqttServer()
.AddSingleton <IMqttServerAdapter>(serverAdapter)
.BuildServiceProvider();
var s = new MqttFactory(services).CreateMqttServer();
var retainMessagemanager = services.GetRequiredService <IMqttClientRetainedMessageManager>();
var receivedMessagesCount = 0;
try
{
await s.StartAsync();
var c1 = await serverAdapter.ConnectTestClient(s, "c1");
await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
await c1.DisconnectAsync();
var subscribe = new MqttSubscribePacket()
{
TopicFilters = new List <TopicFilter>()
{
new TopicFilter("retained", MqttQualityOfServiceLevel.AtMostOnce)
}
};
//make shure the retainedMessageManagerreceived the package
while (!(await retainMessagemanager.GetSubscribedMessagesAsync(subscribe)).Any())
{
await Task.Delay(TimeSpan.FromMilliseconds(10));
}
var c2 = await serverAdapter.ConnectTestClient(s, "c2");
c2.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
await c2.SubscribeAsync(new TopicFilter("retained", MqttQualityOfServiceLevel.AtMostOnce));
await Task.Delay(500);
}
finally
{
await s.StopAsync();
}
Assert.AreEqual(1, receivedMessagesCount);
}
static async Task Main(string[] args)
{
var server = new MqttFactory().CreateMqttServer();
var options = new MqttServerOptionsBuilder()
.WithDefaultEndpointPort(6969);
RegisterLoggers(server);
await server.StartAsync(options.Build());
Console.ReadLine();
await server.StopAsync();
}
static async Task Init()
{
//configure options
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionValidator(c =>
{
Console.WriteLine($"{c.ClientId} connection validator for c.Endpoint: {c.Endpoint}");
c.ReasonCode = MqttConnectReasonCode.Success;
})
.WithApplicationMessageInterceptor(context =>
{
Console.WriteLine("WithApplicationMessageInterceptor block merging data");
var newData = Encoding.UTF8.GetBytes(DateTime.Now.ToString("O"));
var oldData = context.ApplicationMessage.Payload;
var mergedData = newData.Concat(oldData).ToArray();
context.ApplicationMessage.Payload = mergedData;
})
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(1884);
//start server
var mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.StartAsync(optionsBuilder.Build()).Wait();
//mqttServer.Options.DefaultEndpointOptions.BoundInterNetworkAddress
Console.WriteLine($"Broker is Running: Host: {GetLocalIPAddress()} Port: {mqttServer.Options.DefaultEndpointOptions.Port}");
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
//To keep the app running in container
//https://stackoverflow.com/questions/38549006/docker-container-exits-immediately-even-with-console-readline-in-a-net-core-c
Task.Run(() => Thread.Sleep(Timeout.Infinite)).Wait();
mqttServer.StopAsync().Wait();
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
}
static async Task Main(string[] args)
{
var logger = new MqttNetLogger();
logger.LogMessagePublished += (s, e) => Console.WriteLine(e.TraceMessage.ToString());
var server = new MqttFactory().CreateMqttServer(logger);
var options = new MqttServerOptionsBuilder()
.WithDefaultEndpointPort(6969);
await server.StartAsync(options.Build());
logger.Publish(MqttNetLogLevel.Info, "Program", "Press any key to shutdown the server.", null, null);
Console.ReadLine();
await server.StopAsync();
}
public async Task Connect()
{
var server = new MqttFactory().CreateMqttServer();
var client = new MqttFactory().CreateMqttClient();
try
{
await server.StartAsync(new MqttServerOptions());
await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
}
finally
{
await server.StopAsync();
}
}
static async void InitMqtt()
{
// Start a MQTT server.
Console.WriteLine("Starting MQTT Server at: localhost:1883");
// Configure MQTT server.
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(1883);
var mqttServer = new MqttFactory().CreateMqttServer();
await mqttServer.StartAsync(optionsBuilder.Build());
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
await mqttServer.StopAsync();
}
public async Task MqttServer_SameClientIdConnectDisconnectEventOrder()
{
var serverAdapter = new MqttTcpServerAdapter(new MqttNetLogger().CreateChildLogger());
var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
var connectedClient = false;
var connecteCalledBeforeConnectedClients = false;
s.ClientConnected += (_, __) =>
{
connecteCalledBeforeConnectedClients |= connectedClient;
connectedClient = true;
};
s.ClientDisconnected += (_, __) =>
{
connectedClient = false;
};
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.WithClientId(Guid.NewGuid().ToString())
.Build();
await s.StartAsync(new MqttServerOptions());
var c1 = new MqttFactory().CreateMqttClient();
var c2 = new MqttFactory().CreateMqttClient();
await c1.ConnectAsync(clientOptions);
await Task.Delay(100);
await c2.ConnectAsync(clientOptions);
await Task.Delay(100);
await c1.DisconnectAsync();
await c2.DisconnectAsync();
await s.StopAsync();
await Task.Delay(100);
Assert.IsFalse(connecteCalledBeforeConnectedClients, "ClientConnected was called before ClientDisconnect was called");
}
public async Task MqttServer_InterceptMessage()
{
void Interceptor(MqttApplicationMessageInterceptorContext context)
{
context.ApplicationMessage.Payload = Encoding.ASCII.GetBytes("extended");
}
var serverAdapter = new TestMqttServerAdapter();
var services = new ServiceCollection()
.AddLogging()
.AddMqttServer()
.AddSingleton <IMqttServerAdapter>(serverAdapter)
.BuildServiceProvider();
var s = new MqttFactory(services).CreateMqttServer(options => options.ApplicationMessageInterceptor = Interceptor);
try
{
await s.StartAsync();
var c1 = await serverAdapter.ConnectTestClient(s, "c1");
var c2 = await serverAdapter.ConnectTestClient(s, "c2");
await c2.SubscribeAsync(new TopicFilterBuilder().WithTopic("test").Build());
var isIntercepted = false;
c2.ApplicationMessageReceived += (sender, args) =>
{
isIntercepted = string.Compare("extended", Encoding.UTF8.GetString(args.ApplicationMessage.Payload), StringComparison.Ordinal) == 0;
};
var m = new MqttApplicationMessageBuilder().WithTopic("test").Build();
await c1.PublishAsync(m);
await c1.DisconnectAsync();
await Task.Delay(500);
Assert.IsTrue(isIntercepted);
}
finally
{
await s.StopAsync();
}
}
public static async Task Main(string[] args)
{
var mqttServer = new MqttFactory().CreateMqttServer();
var handler = new DeviceConnectionHandler(mqttServer);
mqttServer.ClientConnected += handler.ClientConnected;
mqttServer.ClientDisconnected += handler.ClientDisconnected;
mqttServer.ClientSubscribedTopic += handler.ClientSubscribedTopic;
mqttServer.ClientUnsubscribedTopic += handler.ClientUnsubscribedTopic;
mqttServer.ApplicationMessageReceived += handler.ApplicationMessageReceived;
await mqttServer.StartAsync(new MqttServerOptions());
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
await mqttServer.StopAsync();
}
public async Task MqttServer_ConnectionDenied()
{
var server = new MqttFactory().CreateMqttServer();
var client = new MqttFactory().CreateMqttClient();
try
{
var options = new MqttServerOptionsBuilder().WithConnectionValidator(context =>
{
context.ReturnCode = MqttConnectReturnCode.ConnectionRefusedNotAuthorized;
}).Build();
await server.StartAsync(options);
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost").Build();
try
{
await client.ConnectAsync(clientOptions);
Assert.Fail("An exception should be raised.");
}
catch (Exception exception)
{
if (exception is MqttConnectingFailedException)
{
}
else
{
Assert.Fail("Wrong exception.");
}
}
}
finally
{
await client.DisconnectAsync();
await server.StopAsync();
client.Dispose();
}
}
public async Task Subscribe_And_Publish()
{
var server = new MqttFactory().CreateMqttServer();
var client1 = new MqttFactory().CreateMqttClient();
var client2 = new MqttFactory().CreateMqttClient();
try
{
await server.StartAsync(new MqttServerOptions());
var receivedMessages = new List <MqttApplicationMessageReceivedEventArgs>();
await client1.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithClientId("client1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
client1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
{
lock (receivedMessages)
{
receivedMessages.Add(e);
}
});
await client1.SubscribeAsync("a");
await client2.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithClientId("client2").WithProtocolVersion(MqttProtocolVersion.V500).Build());
await client2.PublishAsync("a", "b");
await Task.Delay(500);
await client2.DisconnectAsync();
await client1.DisconnectAsync();
Assert.AreEqual(1, receivedMessages.Count);
Assert.AreEqual("client1", receivedMessages[0].ClientId);
Assert.AreEqual("a", receivedMessages[0].ApplicationMessage.Topic);
Assert.AreEqual("b", receivedMessages[0].ApplicationMessage.ConvertPayloadToString());
}
finally
{
await server.StopAsync();
}
}
