public static PythonDictionary publish_external(PythonDictionary parameters)
{
if (parameters is null)
{
throw new ArgumentNullException(nameof(parameters));
}
var server = Convert.ToString(parameters.get("server"));
var port = Convert.ToInt32(parameters.get("port", 1883));
var username = Convert.ToString(parameters.get("username"));
var password = Convert.ToString(parameters.get("password"));
var clientId = Convert.ToString(parameters.get("client_id", Guid.NewGuid().ToString("N")));
var topic = Convert.ToString(parameters.get("topic"));
var qos = Convert.ToInt32(parameters.get("qos", 0));
var retain = Convert.ToBoolean(parameters.get("retain", false));
var tls = Convert.ToBoolean(parameters.get("tls", false));
var timeout = Convert.ToInt32(parameters.get("timeout", 5000));
var payload = parameters.get("payload", null);
var mqttClient = new MqttFactory().CreateMqttClient();
try
{
var options = new MqttClientOptionsBuilder().WithTcpServer(server, port).WithCredentials(username, password).WithClientId(clientId)
.WithTimeout(TimeSpan.FromMilliseconds(timeout)).WithTls(new MqttClientOptionsBuilderTlsParameters
{
UseTls = tls
}).Build();
mqttClient.ConnectAsync(options).GetAwaiter().GetResult();
var message = new MqttApplicationMessageBuilder().WithTopic(topic).WithPayload(PythonConvert.ToPayload(payload))
.WithQualityOfServiceLevel((MqttQualityOfServiceLevel)qos).WithRetainFlag(retain).Build();
mqttClient.PublishAsync(message).GetAwaiter().GetResult();
return(new PythonDictionary
{
["type"] = "success"
});
}
catch (MqttConnectingFailedException)
{
return(new PythonDictionary
{
["type"] = "exception.connecting_failed"
});
}
catch (Exception exception)
{
return(PythonConvert.ToPythonDictionary(new ExceptionPythonModel(exception).ToDictionary()));
}
finally
{
mqttClient?.DisconnectAsync().GetAwaiter().GetResult();
mqttClient?.Dispose();
}
}
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 override async Task SendAsync(PayloadRoot payload, HostChannel channel)
{
if (channel == HostChannel.Undefined || payload.Row.Count == 0)
{
return;
}
string clientId = null, topic = null;
switch (channel)
{
case HostChannel.Status:
clientId = payload.MachineNo + "#" + nameof(HostChannel.Status);
topic = $"/{nameof(HostTransaction.Smmp).ToLower()}/{payload.MachineNo}/{nameof(WorkTasks.Collection).ToLower()}/{nameof(HostChannel.Status).ToLower()}";
break;
case HostChannel.Parameter:
clientId = payload.MachineNo + "#" + nameof(HostChannel.Parameter);
topic = $"/{nameof(HostTransaction.Smmp).ToLower()}/{payload.MachineNo}/{nameof(WorkTasks.Collection).ToLower()}/{nameof(HostChannel.Parameter).ToLower()}";
break;
case HostChannel.Production:
clientId = payload.MachineNo + "#" + nameof(HostChannel.Production);
topic = $"/{nameof(HostTransaction.Smmp).ToLower()}/{payload.MachineNo}/{nameof(WorkTasks.Collection).ToLower()}/{nameof(HostChannel.Production).ToLower()}";
break;
}
payload.Row.ForEach(c =>
{
if (YamlBase.Propertie.Debug)
{
Console.WriteLine($"[{DateTime.Now:MM/dd HH:mm ss}] ModbusTCP => NO.{payload.MachineNo} - {c.AttribNo}:{c.AttribValue}");
}
});
try
{
FoundationProvider box = new();
IConfigurationBuilder builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile("appsettings.json");
IConfigurationRoot config = builder.Build();
IMqttClient client = new MqttFactory().CreateMqttClient();
await client.ConnectAsync(new MqttClientOptionsBuilder()
.WithTcpServer(box.FoundationBasic.Server.Address.Split('/')[2].Split(':')[0], box.FoundationBasic.Server.MqttPort)
.WithCredentials(config.GetValue <string>("Server:Account"), config.GetValue <string>("Server:Password"))
.WithClientId(clientId)
.Build());
await client.PublishAsync(new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(JsonConvert.SerializeObject(payload))
.WithExactlyOnceQoS()
.WithRetainFlag()
.Build());
await client.DisconnectAsync();
client.Dispose();
}
catch (Exception e)
{
LogBuilder.WriteLog(LogEventLevel.Error, "MQTT Server => " + e.Message);
}
}
static async Task Main(string[] args)
{
var optionbuilder = new MqttClientOptionsBuilder()
.WithClientId("client_1")
.WithTcpServer("127.0.0.1", 3883);
var optionbuilder2 = new MqttClientOptionsBuilder()
.WithClientId("client_2")
.WithTcpServer("127.0.0.1", 3883);
var mqttClient = new MqttFactory().CreateMqttClient();
var mqttClient2 = new MqttFactory().CreateMqttClient();
var ret = await mqttClient.ConnectAsync(optionbuilder.Build());
Console.WriteLine($"client_1 result : {ret.ResultCode}");
var ret2 = await mqttClient2.ConnectAsync(optionbuilder2.Build());
Console.WriteLine($"client_2 result : {ret2.ResultCode}");
var subcriberet = await mqttClient2.SubscribeAsync(new MqttClientSubscribeOptions()
{
TopicFilters = new List <TopicFilter>
{
new TopicFilter()
{
Topic = "abc"
}
}
});
foreach (var item in subcriberet.Items)
{
Console.WriteLine($"Topic:{item.TopicFilter.Topic}, result:{item.ResultCode}");
}
mqttClient2.UseApplicationMessageReceivedHandler((e) =>
{
var msg = e.ApplicationMessage;
var topic = msg.Topic;
var payload = msg.ConvertPayloadToString();
Console.WriteLine($"clientId:{e.ClientId}, topic:{topic}, payload:{payload}");
});
while (true)
{
var input = Console.ReadLine().ToLower().Trim();
switch (input)
{
case "exit":
mqttClient.Dispose();
mqttClient2.Dispose();
return;
default:
await mqttClient.PublishAsync(new MqttApplicationMessage()
{
Topic = "abc",
Payload = Encoding.UTF8.GetBytes(DateTime.Now.ToString())
}, CancellationToken.None);
break;
}
}
}
public static MqttStatus Connect(string url, MqttConfig config)
{
Guid key = Guid.NewGuid();
try
{
#if DEBUG
IMqttClient client = new MqttFactory().CreateMqttClient(new ConsoleLogger());
#else
IMqttClient client = new MqttFactory().CreateMqttClient();
#endif
var b = new MqttClientOptionsBuilder()
.WithTcpServer(url, config.Port)
.WithKeepAlivePeriod(TimeSpan.FromSeconds(config.KeepAlive))
.WithMaximumPacketSize(Convert.ToUInt32(config.BufferSize))
.WithCommunicationTimeout(TimeSpan.FromSeconds(config.ConnectionTimeout))
.WithCleanSession(config.CleanSession);
if (config.SessionExpiryInterval > 0)
{
b = b.WithSessionExpiryInterval((uint)config.SessionExpiryInterval);
}
if (!string.IsNullOrEmpty(config.ClientId))
{
b = b.WithClientId(config.ClientId);
}
if (!config.SSLConnection)
{
b = b.WithCredentials(config.UserName, config.Password);
}
switch (config.ProtocolVersion)
{
case 310:
b = b.WithProtocolVersion(MqttProtocolVersion.V310);
break;
case 311:
b = b.WithProtocolVersion(MqttProtocolVersion.V311);
break;
case 500:
b = b.WithProtocolVersion(MqttProtocolVersion.V500);
break;
default:
throw new InvalidDataException("Invalid protocol versions. Valid versions are 310, 311 or 500");
}
if (config.SSLConnection)
{
string base64CACert = RSAKeys.GetPlainBase64(config.CAcertificate);
X509Certificate2 caCert = new X509Certificate2(Convert.FromBase64String(base64CACert));
byte[] caBytes = caCert.Export(X509ContentType.Cert);
string base64Client = RSAKeys.GetPlainBase64(config.ClientCertificate);
X509Certificate2 cliCert = new X509Certificate2(Convert.FromBase64String(base64Client), config.ClientCerificatePassphrase);
cliCert = cliCert.CopyWithPrivateKey(RSAKeys.ImportPrivateKey(config.PrivateKey, new PasswordFinder(config.ClientCerificatePassphrase)));
byte[] cliBytes = cliCert.Export(X509ContentType.Pfx);
try
{
var tls = new MqttClientOptionsBuilderTlsParameters
{
SslProtocol = System.Security.Authentication.SslProtocols.Tls12 | System.Security.Authentication.SslProtocols.Tls11 | System.Security.Authentication.SslProtocols.Tls,
UseTls = true,
AllowUntrustedCertificates = true,
IgnoreCertificateChainErrors = true,
IgnoreCertificateRevocationErrors = true,
Certificates = new List <X509Certificate>()
{
caCert, cliCert
},
//CertificateValidationHandler = context => true
CertificateValidationCallback = (certificate, chain, sslError, opts) => true
};
b = b.WithTls(tls);
}
finally
{
caCert.Dispose();
cliCert.Dispose();
}
}
client.UseDisconnectedHandler(async e =>
{
try
{
if (Connections.ContainsKey(key))
{
await Task.Delay(TimeSpan.FromSeconds(config.AutoReconnectDelay));
MqttClientAuthenticateResult reconnectResult = await client.ConnectAsync(b.Build());
SubscribePreviousConnection(key, reconnectResult);
}
}
catch
{
Connections.Remove(key);
client.Dispose();
}
});
MqttClientAuthenticateResult result = client.ConnectAsync(b.Build()).GetAwaiter().GetResult();
MqttClient mqtt = new MqttClient(client, config);
Connections[key] = mqtt;
SubscribePreviousConnection(key, result);
}
catch (Exception ex)
{
return(MqttStatus.Fail(Guid.Empty, ex));
}
return(MqttStatus.Success(key));
}
