static void WebsocketTest()
{
logger = new MqttNetLogger();
logger.LogMessagePublished += LoggerOnLogMessagePublished;
var endpoint = Endpoint;
var queryParams = new StringBuilder();
var expiresOn = DateTime.UtcNow.AddDays(2);
var period = Convert.ToInt64((expiresOn.ToUniversalTime() - DateTime.UtcNow).TotalSeconds);
queryParams.AppendFormat("{0}={1}", AWS4SignerBase.X_Amz_Expires, HttpHelpers.UrlEncode(period.ToString()));
var headers = new Dictionary <string, string> {
};
var signer = new AWS4SignerForQueryParameterAuth()
{
EndpointUri = new Uri(endpoint),
HttpMethod = "GET",
Region = "us-east-1",
Service = "iotdevicegateway"
};
var authorization = signer.ComputeSignature(headers,
queryParams.ToString(),
AWS4SignerBase.EMPTY_BODY_SHA256,
ACCESS_KEY,
SECRET_KEY);
var urlBuilder = new StringBuilder(endpoint.ToString());
urlBuilder.AppendFormat("?{0}", queryParams.ToString());
urlBuilder.AppendFormat("&{0}", authorization);
var presignedUrl = urlBuilder.ToString();
Task.Run(() => ConnectWs(presignedUrl));
}
public void Setup()
{
_logger = new MqttNetLogger();
_childLogger = _logger.CreateScopedLogger("child");
_logger.LogMessagePublished += OnLogMessagePublished;
}
public IMqttServer CreateMqttServer()
{
var logger = new MqttNetLogger();
return(CreateMqttServer(new List <IMqttServerAdapter> {
new MqttServerAdapter(logger)
}, logger));
}
public static void ForwardToConsole(MqttNetLogger logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
logger.LogMessagePublished -= PrintToConsole;
logger.LogMessagePublished += PrintToConsole;
}
public async Task <bool> ConnectAsync(Uri uri, string username, string password)
{
if (BrokerUri == null && uri != null)
{
BrokerUri = uri;
}
if (BrokerUri != null && uri == null)
{
uri = BrokerUri;
}
bool initok = false;
try
{
var factory = new MqttFactory();
MqttNetLogger mqttNetLogger = new MqttNetLogger();
mqttNetLogger.LogMessagePublished += MqttNetLogger_LogMessagePublished;;
Client = factory.CreateMqttClient(mqttNetLogger);
var clientOptions = new MqttClientOptionsBuilder()
.WithClientId(uri.ToString() + Guid.NewGuid().ToString())
.WithTcpServer(uri.Host, uri.Port)
.WithCredentials(username, password)
.Build();
Client.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(args => Client_ApplicationMessageReceived(Client, args));
Client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(args => Client_ConnectedAsync(Client, args));
Client.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(async e =>
{
try
{
await Client.ConnectAsync(clientOptions);
}
catch (Exception exception)
{
_logger.LogError("CONNECTING FAILED", exception);
}
});
try
{
var result = await Client.ConnectAsync(clientOptions);
initok = result.ResultCode == MqttClientConnectResultCode.Success;
}
catch (Exception exception)
{
_logger.LogError("CONNECTING FAILED", exception);
}
_logger.LogInformation("WAITING FOR APPLICATION MESSAGES");
}
catch (Exception exception)
{
_logger.LogError("CONNECTING FAILED", exception);
}
return(initok);
}
private static IServiceCollection AddHostedMqttServer(this IServiceCollection services)
{
var logger = new MqttNetLogger();
services.AddSingleton<IMqttNetLogger>(logger);
services.AddSingleton<MqttHostedServer>();
services.AddSingleton<IHostedService>(s => s.GetService<MqttHostedServer>());
services.AddSingleton<IMqttServer>(s => s.GetService<MqttHostedServer>());
return services;
}
public static IMqttServer CreateOrleansMqttSever(this MqttFactory factory, IClusterClient clusterClient, IMqttServerOptions options, ILoggerFactory appLoggerFactory)
{
if (clusterClient == null)
{
throw new ArgumentNullException(nameof(clusterClient));
}
var logger = new MqttNetLogger();
return(CreateOrleansMqttSever(factory, clusterClient, options, logger, appLoggerFactory.CreateLogger <OrleansManagedMqttServer>()));
}
/// <summary>
/// For use with building a silo, this will wire-up the "orleans" flavor of the MQTTserver object and its supporting infrastructure.
/// </summary>
private static IServiceCollection AddHostedOrleansMqttServer(this IServiceCollection services)
{
var logger = new MqttNetLogger();
var childLogger = logger.CreateChildLogger();
services.AddSingleton <IMqttNetLogger>(logger);
services.AddSingleton(childLogger);
services.AddSingleton <OrleansManagedMqttServer>();
services.AddSingleton <IHostedService>(s => s.GetService <OrleansManagedMqttServer>());
services.AddSingleton <IMqttServer>(s => s.GetService <OrleansManagedMqttServer>());
return(services);
}
public MainWindow()
{
InitializeComponent();
DataContext = this;
Closing += MainWindow_Closing;
Logger = new NullLogger("testLogger");
Logger.LogMessagePublished += Logger_LogMessagePublished;
CommunicationThread = new Thread(new ThreadStart(StartMqttClient));
CommunicationThread.Start();
QualityOfService = MqttQualityOfServiceLevel.AtMostOnce;
StatusPane.QosChanged += StatusPane_QosChanged;
StatusPane.CodeStyleChanged += StatusPane_CodeStyleChanged;
}
protected override void OnStart()
{
_storageService.SafeReadSerializedValue(out _options, DefaultDirectoryNames.Configuration, MqttServiceOptions.Filename);
IsLowLevelMqttLoggingEnabled = _options.EnableLogging;
var mqttFactory = new MqttFactory();
IMqttNetLogger mqttNetLogger;
if (IsLowLevelMqttLoggingEnabled)
{
mqttNetLogger = new LoggerAdapter(_logger);
}
else
{
mqttNetLogger = new MqttNetLogger();
}
_webSocketServerAdapter = new MqttWebSocketServerAdapter(mqttNetLogger);
var serverAdapters = new List <IMqttServerAdapter>
{
new MqttTcpServerAdapter(mqttNetLogger),
_webSocketServerAdapter
};
_mqttServer = mqttFactory.CreateMqttServer(serverAdapters, mqttNetLogger);
_mqttServer.UseApplicationMessageReceivedHandler(new MqttApplicationMessageReceivedHandlerDelegate(e => OnApplicationMessageReceived(e)));
var serverOptions = new MqttServerOptionsBuilder()
.WithDefaultEndpointPort(_options.ServerPort)
.WithConnectionValidator(ValidateClientConnection)
.WithPersistentSessions();
if (_options.PersistRetainedMessages)
{
var storage = new MqttServerStorage(_storageService, _systemCancellationToken, _logger);
storage.Start();
serverOptions.WithStorage(storage);
}
_mqttServer.StartAsync(serverOptions.Build()).GetAwaiter().GetResult();
_systemCancellationToken.Token.Register(() =>
{
_mqttServer.StopAsync().GetAwaiter().GetResult();
});
ParallelTask.StartLongRunning(ProcessIncomingMqttMessages, _systemCancellationToken.Token, _logger);
}
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 void Set_Custom_Log_ID()
{
var logger = new MqttNetLogger("logId");
var childLogger = logger.CreateScopedLogger("Source1");
logger.LogMessagePublished += (s, e) =>
{
Assert.AreEqual("logId", e.LogMessage.LogId);
};
childLogger.Verbose("Verbose");
childLogger.Info("Info");
childLogger.Warning(null, "Warning");
childLogger.Error(null, "Error");
}
private void InitServer()
{
IMqttNetLogger logger = new MqttNetLogger();
serverOptionsBuilder = new MqttServerOptionsBuilder()
.WithDefaultEndpointBoundIPAddress(IPAddress.Parse(ip))
.WithDefaultEndpointPort(port)
.WithDefaultCommunicationTimeout(TimeSpan.FromSeconds(communicationTimeout))
.WithEncryptionSslProtocol(sslProtocols);
// connect verfication
serverOptionsBuilder.WithConnectionValidator(valid =>
{
if (valid.ClientId.Length < 10)
{
valid.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid;
return;
}
if (!valid.Username.Equals(this.username))
{
valid.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
return;
}
if (!valid.Password.Equals(password))
{
valid.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
return;
}
valid.ReasonCode = MqttConnectReasonCode.Success;
});
serverOptions = serverOptionsBuilder.Build();
mqttServer = (new MqttFactory()).CreateMqttServer(logger) as MqttServer;
mqttServer.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(e =>
{
ClientIds.Add(e.ClientId);
Logger.Info($"clientID:{e.ClientId} connect success!");
});
mqttServer.ClientDisconnectedHandler = new MqttServerClientDisconnectedHandlerDelegate(e =>
{
ClientIds.RemoveWhere(s => s.Equals(e.ClientId));
Logger.Info($"clientID:{e.ClientId} disconnect!");
});
mqttServer.UseApplicationMessageReceivedHandler(e =>
{
AppMsgReceivedHandler?.Invoke(e.ClientId, e.ApplicationMessage);
});
}
public void Root_Log_Messages()
{
var logger = new MqttNetLogger();
var logMessagesCount = 0;
logger.LogMessagePublished += (s, e) =>
{
logMessagesCount++;
};
logger.Verbose("Verbose");
logger.Info("Info");
logger.Warning(null, "Warning");
logger.Error(null, "Error");
Assert.AreEqual(4, logMessagesCount);
}
public static async Task RunAsync()
{
var logger = new MqttNetLogger();
MqttNetConsoleLogger.ForwardToConsole(logger);
var factory = new MqttFactory(logger);
var server = factory.CreateMqttServer();
var client = factory.CreateMqttClient();
var serverOptions = new MqttServerOptionsBuilder().Build();
await server.StartAsync(serverOptions);
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 MqttNetLogger();
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.PublishAsync("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 IMqttNetLogger CreateChildLogger(string source = null)
{
if (source == null)
{
// Required to avoid argument null exception in dictionary.
source = string.Empty;
}
lock (_childLoggers)
{
if (!_childLoggers.TryGetValue(source, out var childLogger))
{
childLogger = new MqttNetLogger(source);
_childLoggers[source] = childLogger;
}
return(childLogger);
}
}
public void Bubbling_Log_Messages()
{
var logger = new MqttNetLogger();
var childLogger = logger.CreateScopedLogger("Source1");
var logMessagesCount = 0;
logger.LogMessagePublished += (s, e) =>
{
logMessagesCount++;
};
childLogger.Verbose("Verbose");
childLogger.Info("Info");
childLogger.Warning(null, "Warning");
childLogger.Error(null, "Error");
Assert.AreEqual(4, logMessagesCount);
}
public IMqttNetLogger Create(string loggerName)
{
var logger = _loggerFactory.CreateLogger(loggerName);
var mqttNetLogger = new MqttNetLogger();
mqttNetLogger.LogMessagePublished += (sender, e) =>
{
if (e.TraceMessage.Exception != null)
{
logger.LogError(e.TraceMessage.Exception, e.TraceMessage.Message);
}
else
{
logger.LogDebug(e.TraceMessage.Message);
}
};
return(mqttNetLogger);
}
private static IServiceCollection AddHostedMqttServerEx(this IServiceCollection services)
{
var logger = new MqttNetLogger();
var childLogger = logger.CreateChildLogger();
services.AddSingleton<IMqttNetLogger>(logger);
services.AddSingleton(childLogger);
services.AddSingleton<MqttHostedServerEx>();
services.AddSingleton<IHostedService>(s => s.GetService<MqttHostedServerEx>());
services.AddSingleton<IMqttServerEx>(s =>
{
var mhse = s.GetService<MqttHostedServerEx>();
var store = s.GetService<IMqttServerStorage>();
MqttServerOptions options = (MqttServerOptions)mhse.Options;
options.ConnectionValidator = mhse.ConnectionValidator;
if (options.Storage == null) options.Storage = store;
return mhse;
}
);
return services;
}
public ModemManager(Modem modem, DeviceManager deviceManager)
{
Modem = modem;
logger = LogManager.GetCurrentClassLogger();
mqttLogger = new MqttNetLogger();
mqttLogger.LogMessagePublished += MqttLogger_LogMessagePublished;
factory = new MqttFactory(mqttLogger);
// Create TCP based options using the builder.
var options = new MqttClientOptionsBuilder()
.WithClientId(modem.MqttClientId)
.WithCredentials(modem.MqttUserName, modem.MqttPassword)
.WithTcpServer(modem.MqttBrokerAddress.ToString())
.WithCleanSession(true)
.WithNoKeepAlive()
.WithSessionExpiryInterval(60 * 60 * 24)
.Build();
mqttClient = factory.CreateMqttClient(mqttLogger);
MqttClientAuthenticateResult conResult;
conResult = mqttClient.ConnectAsync(options).Result;
mqttClient.UseConnectedHandler(async(e) => {
while (mqttClient.IsConnected)
{
var devicePacket = deviceManager.GetDevicePacket();
if (devicePacket != null)
{
await mqttClient.PublishAsync("/MachineData", devicePacket.Encode());
logger.Info($"Device Packet: {devicePacket}");
continue;
}
await Task.Delay(10000);
}
});
DeviceManager = deviceManager;
}
public IMqttServer CreateMqttServer()
{
var logger = new MqttNetLogger();
return(CreateMqttServer(logger));
}
public async Task Create_Managed_Client_With_Logger()
{
var factory = new MqttFactory();
//This test compares
//1. correct logID
string logId = "logId";
bool invalidLogIdOccured = false;
//2. if the total log calls are the same for global and local
int globalLogCount = 0;
int localLogCount = 0;
MqttNetLogger logger = new MqttNetLogger(logId);
//we have a theoretical bug here if a concurrent test is also logging
var globalLog = new EventHandler <MqttNetLogMessagePublishedEventArgs>((s, e) =>
{
if (logId != e.TraceMessage.LogId)
{
invalidLogIdOccured = true;
}
Interlocked.Increment(ref globalLogCount);
});
MqttNetGlobalLogger.LogMessagePublished += globalLog;
logger.LogMessagePublished += (s, e) =>
{
if (logId != e.TraceMessage.LogId)
{
invalidLogIdOccured = 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").WithCommunicationTimeout(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.ConnectingFailedHandler = new ConnectingFailedHandlerDelegate(e => tcs.TrySetResult(null));
await Task.WhenAny(Task.Delay(managedClient.Options.ClientOptions.CommunicationTimeout), tcs.Task);
}
finally
{
await managedClient.StopAsync();
MqttNetGlobalLogger.LogMessagePublished -= globalLog;
}
Assert.IsFalse(invalidLogIdOccured);
Assert.AreNotEqual(0, globalLogCount);
Assert.AreEqual(globalLogCount, localLogCount);
}
public static async Task RunAsync()
{
try
{
var logger = new MqttNetLogger();
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);
}
}
static async Task Main(string[] args)
{
var optionbuilder = new MqttServerOptionsBuilder()
.WithDefaultEndpointPort(3883)
.WithConnectionValidator((valid) =>
{
});
var server_logger = new MqttNetLogger("server logger");
server_logger.LogMessagePublished += (sender, e) =>
{
//Console.WriteLine(e.TraceMessage.ToString());
};
var mqttServer = new MqttFactory().CreateMqttServer(server_logger);
mqttServer.StartedHandler = new MqttServerStartedHandlerDelegate((e) =>
{
Console.WriteLine("mqtt server started!");
});
mqttServer.StoppedHandler = new MqttServerStoppedHandlerDelegate((e) =>
{
Console.WriteLine("mqtt server stopped!");
});
mqttServer.UseClientConnectedHandler((eventArgs) =>
{
Console.WriteLine($"client Connected ClientId:{eventArgs.ClientId}");
});
mqttServer.UseClientDisconnectedHandler((eventArgs) =>
{
Console.WriteLine($"client Disconnected ClientId:{eventArgs.ClientId} Type:{eventArgs.DisconnectType}");
});
mqttServer.UseApplicationMessageReceivedHandler((eventArgs) =>
{
var msg = eventArgs.ApplicationMessage;
var topic = msg.Topic;
var payload = msg.ConvertPayloadToString();
Console.WriteLine($"Topic:{topic}\r\nPayload:{payload}");
});
mqttServer.ClientSubscribedTopicHandler = new MqttServerClientSubscribedHandlerDelegate((e) =>
{
Console.WriteLine($"topic subscribed ClientId:{e.ClientId} Topic:{e.TopicFilter.ToString()}");
});
mqttServer.ClientUnsubscribedTopicHandler = new MqttServerClientUnsubscribedTopicHandlerDelegate((e) =>
{
Console.WriteLine($"topic ubsubscribed ClientId:{e.ClientId} Topic:{e.TopicFilter.ToString()}");
});
await mqttServer.StartAsync(optionbuilder.Build());
Console.WriteLine("输入exit退出");
var input = string.Empty;
while (true)
{
input = Console.ReadLine().ToLower().Trim();
if (input == "exit")
{
break;
}
switch (input)
{
case "exit":
await mqttServer.StopAsync();
return;
case "client":
var clients = await mqttServer.GetClientStatusAsync();
if (clients.Count == 0)
{
Console.WriteLine("no client");
continue;
}
foreach (var client in clients)
{
Console.WriteLine($"clientid:{client.ClientId}");
}
break;
case "msg":
var msgs = await mqttServer.GetRetainedApplicationMessagesAsync();
if (msgs.Count == 0)
{
Console.WriteLine("no message");
}
foreach (var item in msgs)
{
Console.WriteLine($"Topic:{item.Topic}, payload:{item.ConvertPayloadToString()}");
}
break;
case "session":
var mqttSessions = await mqttServer.GetSessionStatusAsync();
if (mqttSessions.Count == 0)
{
Console.WriteLine("no session");
continue;
}
foreach (var item in mqttSessions)
{
Console.WriteLine($"ClientId:{item.ClientId},PendingMsgCnt:{item.PendingApplicationMessagesCount}");
}
break;
default:
await Task.Delay(100);
break;
}
}
}
