public void Factory_NullException_With_Logger()
{
var looger = new MqttNetEventLogger("MyCustomId");
// act
Assert.Throws <ArgumentNullException>(() => ((MqttFactory)null).CreateRxMqttClient(looger));
}
public async Task Create_Managed_Client_With_Logger()
{
var factory = new MqttFactory();
// This test compares
// 1. correct logID
var logId = "logId";
var hasInvalidLogId = false;
// 2. if the total log calls are the same for global and local
//var globalLogCount = 0;
var localLogCount = 0;
var logger = new MqttNetEventLogger(logId);
logger.LogMessagePublished += (s, e) =>
{
if (e.LogMessage.LogId != logId)
{
hasInvalidLogId = true;
}
Interlocked.Increment(ref localLogCount);
};
var managedClient = factory.CreateManagedMqttClient(logger);
try
{
var clientOptions = new ManagedMqttClientOptionsBuilder();
clientOptions.WithClientOptions(o => o.WithTcpServer("this_is_an_invalid_host").WithTimeout(TimeSpan.FromSeconds(1)));
// try connect to get some log entries
await managedClient.StartAsync(clientOptions.Build());
// wait at least connect timeout or we have some log messages
var tcs = new TaskCompletionSource <object>();
managedClient.ConnectingFailedAsync += e =>
{
tcs.TrySetResult(null);
return(PlatformAbstractionLayer.CompletedTask);
};
await Task.WhenAny(Task.Delay(managedClient.Options.ClientOptions.Timeout), tcs.Task);
}
finally
{
await managedClient.StopAsync();
}
await Task.Delay(500);
Assert.IsFalse(hasInvalidLogId);
Assert.AreNotEqual(0, localLogCount);
}
public void Factory_With_Logger()
{
var looger = new MqttNetEventLogger("MyCustomId");
// act
var client = new MqttFactory().CreateRxMqttClient(looger);
// test
Assert.NotNull(client);
Assert.IsType <RxMqttClient>(client);
}
public static void ForwardToConsole(MqttNetEventLogger logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
logger.LogMessagePublished -= PrintToConsole;
logger.LogMessagePublished += PrintToConsole;
}
static IServiceCollection AddHostedMqttServer(this IServiceCollection services)
{
var logger = new MqttNetEventLogger();
services.AddSingleton <IMqttNetLogger>(logger);
services.AddSingleton <MqttHostedServer>();
services.AddSingleton <IHostedService>(s => s.GetService <MqttHostedServer>());
services.AddSingleton <MqttServer>(s => s.GetService <MqttHostedServer>());
return(services);
}
public void Setup()
{
_nullLogger = new MqttNetNullLogger();
_sourceNullLogger = _nullLogger.WithSource("Source");
_eventLogger = new MqttNetEventLogger();
_eventLogger.LogMessagePublished += OnLogMessagePublished;
_sourceEventLogger = _eventLogger.WithSource("Source");
_eventLoggerNoListener = new MqttNetEventLogger();
_sourceEventLoggerNoListener = _eventLoggerNoListener.WithSource("Source");
}
public static void RunEmptyServerWithLogging()
{
var logger = new MqttNetEventLogger();
MqttNetConsoleLogger.ForwardToConsole(logger);
var mqttFactory = new MqttFactory(logger);
var mqttServer = mqttFactory.CreateMqttServer(new MqttServerOptions());
mqttServer.StartAsync().GetAwaiter().GetResult();
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
}
public void Log_Without_Source()
{
var logger = new MqttNetEventLogger();
MqttNetLogMessage logMessage = null;
logger.LogMessagePublished += (s, e) => { logMessage = e.LogMessage; };
logger.Publish(MqttNetLogLevel.Info, "SOURCE", "MESSAGE", new object[] { "ABC" }, new InvalidOperationException());
Assert.AreEqual(MqttNetLogLevel.Info, logMessage.Level);
Assert.AreEqual("SOURCE", logMessage.Source);
Assert.AreEqual("MESSAGE", logMessage.Message);
Assert.AreEqual("InvalidOperationException", logMessage.Exception.GetType().Name);
}
public void Use_Custom_Log_Id()
{
var logger = new MqttNetEventLogger("logId");
var childLogger = logger.WithSource("Source1");
logger.LogMessagePublished += (s, e) =>
{
Assert.AreEqual("logId", e.LogMessage.LogId);
Assert.AreEqual("Source1", e.LogMessage.Source);
};
childLogger.Verbose("Verbose");
childLogger.Info("Info");
childLogger.Warning((Exception)null, "Warning");
childLogger.Error(null, "Error");
}
public void Root_Log_Messages()
{
var logger = new MqttNetEventLogger();
var childLogger = logger.WithSource("Source1");
var logMessagesCount = 0;
logger.LogMessagePublished += (s, e) => { logMessagesCount++; };
childLogger.Verbose("Verbose");
childLogger.Info("Info");
childLogger.Warning((Exception)null, "Warning");
childLogger.Error(null, "Error");
Assert.AreEqual(4, logMessagesCount);
}
public void Log_With_Source()
{
MqttNetLogMessage logMessage = null;
var logger = new MqttNetEventLogger();
logger.LogMessagePublished += (s, e) =>
{
logMessage = e.LogMessage;
};
var sourceLogger = logger.WithSource("The_Source");
sourceLogger.Info("MESSAGE", null, null);
Assert.AreEqual("The_Source", logMessage.Source);
}
public static async Task RunAsync()
{
var logger = new MqttNetEventLogger();
MqttNetConsoleLogger.ForwardToConsole(logger);
var factory = new MqttFactory(logger);
var server = factory.CreateMqttServer(new MqttServerOptionsBuilder().Build());
var client = factory.CreateMqttClient();
await server.StartAsync();
var clientOptions = new MqttClientOptionsBuilder().WithTcpServer("localhost").Build();
await client.ConnectAsync(clientOptions);
await Task.Delay(Timeout.Infinite);
}
public static async Task RunAsync()
{
try
{
var logger = new MqttNetEventLogger();
MqttNetConsoleLogger.ForwardToConsole(logger);
var factory = new MqttFactory(logger);
var client = factory.CreateMqttClient();
var options = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.Build();
Console.WriteLine("BEFORE CONNECT");
await client.ConnectAsync(options);
Console.WriteLine("AFTER CONNECT");
Console.WriteLine("BEFORE SUBSCRIBE");
await client.SubscribeAsync("test/topic");
Console.WriteLine("AFTER SUBSCRIBE");
Console.WriteLine("BEFORE PUBLISH");
await client.PublishStringAsync("test/topic", "payload");
Console.WriteLine("AFTER PUBLISH");
await Task.Delay(1000);
Console.WriteLine("BEFORE DISCONNECT");
await client.DisconnectAsync();
Console.WriteLine("AFTER DISCONNECT");
Console.WriteLine("FINISHED");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public static async Task Use_Event_Logger()
{
/*
* This sample shows how to get logs from the library.
*
* ATTENTION: Only use the logger for debugging etc. The performance is heavily decreased when a logger is used.
*/
// The logger ID is optional but can be set do distinguish different logger instances.
var mqttEventLogger = new MqttNetEventLogger("MyCustomLogger");
mqttEventLogger.LogMessagePublished += (sender, args) =>
{
var output = new StringBuilder();
output.AppendLine($">> [{args.LogMessage.Timestamp:O}] [{args.LogMessage.ThreadId}] [{args.LogMessage.Source}] [{args.LogMessage.Level}]: {args.LogMessage.Message}");
if (args.LogMessage.Exception != null)
{
output.AppendLine(args.LogMessage.Exception.ToString());
}
Console.Write(output);
};
var mqttFactory = new MqttFactory(mqttEventLogger);
var mqttClientOptions = mqttFactory.CreateClientOptionsBuilder()
.WithTcpServer("broker.hivemq.com")
.Build();
using (var mqttClient = mqttFactory.CreateMqttClient())
{
await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
Console.WriteLine("MQTT client is connected.");
var mqttClientDisconnectOptions = mqttFactory.CreateClientDisconnectOptionsBuilder()
.Build();
await mqttClient.DisconnectAsync(mqttClientDisconnectOptions, CancellationToken.None);
}
}
public static async Task RunAsync()
{
try
{
var logger = new MqttNetEventLogger();
MqttNetConsoleLogger.ForwardToConsole(logger);
var factory = new MqttFactory(logger);
var client = factory.CreateMqttClient();
var clientOptions = new MqttClientOptions
{
ChannelOptions = new MqttClientTcpOptions
{
Server = "127.0.0.1"
}
};
client.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
{
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();
});
client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(async e =>
{
Console.WriteLine("### CONNECTED WITH SERVER ###");
await client.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
Console.WriteLine("### SUBSCRIBED ###");
});
client.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(async e =>
{
Console.WriteLine("### DISCONNECTED FROM SERVER ###");
await Task.Delay(TimeSpan.FromSeconds(5));
try
{
await client.ConnectAsync(clientOptions);
}
catch
{
Console.WriteLine("### RECONNECTING FAILED ###");
}
});
try
{
await client.ConnectAsync(clientOptions);
}
catch (Exception exception)
{
Console.WriteLine("### CONNECTING FAILED ###" + Environment.NewLine + exception);
}
Console.WriteLine("### WAITING FOR APPLICATION MESSAGES ###");
while (true)
{
Console.ReadLine();
await client.SubscribeAsync(new MqttTopicFilter { Topic = "test", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
var applicationMessage = new MqttApplicationMessageBuilder()
.WithTopic("A/B/C")
.WithPayload("Hello World")
.WithAtLeastOnceQoS()
.Build();
await client.PublishAsync(applicationMessage);
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
