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