public async Task Subscribe_Lots_In_Single_Request()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
var receivedMessagesCount = 0;
await testEnvironment.StartServer();
var c1 = await testEnvironment.ConnectClient();
c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
var optionsBuilder = new MqttClientSubscribeOptionsBuilder();
for (var i = 0; i < 500; i++)
{
optionsBuilder.WithTopicFilter(i.ToString(), MqttQualityOfServiceLevel.AtMostOnce);
}
await c1.SubscribeAsync(optionsBuilder.Build()).ConfigureAwait(false);
var c2 = await testEnvironment.ConnectClient();
var messageBuilder = new MqttApplicationMessageBuilder();
for (var i = 0; i < 500; i++)
{
messageBuilder.WithTopic(i.ToString());
await c2.PublishAsync(messageBuilder.Build()).ConfigureAwait(false);
}
SpinWait.SpinUntil(() => receivedMessagesCount == 500, TimeSpan.FromSeconds(20));
Assert.AreEqual(500, receivedMessagesCount);
}
}
private async Task ReceiveHubMessagesAsync()
{
using (Message receivedMessage = await DeviceClient.ReceiveAsync(TimeSpan.FromSeconds(30)).ConfigureAwait(false))
{
if (receivedMessage == null)
{
Console.WriteLine("\t{0}> Timed out", DateTime.Now.ToLocalTime());
return;
}
var message = new MqttApplicationMessageBuilder()
.WithPayload(receivedMessage.GetBytes());
string payload = Encoding.ASCII.GetString(receivedMessage.GetBytes());
Console.WriteLine("\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), payload);
if (receivedMessage.Properties.ContainsKey("topic"))
{
message.WithTopic(receivedMessage.Properties["topic"]);
}
var keyExclude = new string[] { "topic", "clientId" };
foreach (var prop in receivedMessage.Properties.Where(k => !keyExclude.Contains(k.Key)))
{
message.WithUserProperty(prop.Key, prop.Value);
}
await LocalClient.PublishAsync(message.Build(), CancellationToken.None);
await DeviceClient.CompleteAsync(receivedMessage).ConfigureAwait(false);
}
}
public MqttApplicationMessage CreateMqttApplicationMessage(object @event, string topic)
{
var data = Serialize(@event);
var builder = new MqttApplicationMessageBuilder();
builder.WithTopic(topic);
builder.WithPayload(data);
MessageCreater.Invoke(builder);
return(builder.Build());
}
public async Task Handle_100_000_Messages_In_Receiving_Client()
{
using (var testEnvironment = CreateTestEnvironment())
{
await testEnvironment.StartServer();
var receivedMessages = 0;
using (var receiverClient = await testEnvironment.ConnectClient())
{
receiverClient.ApplicationMessageReceivedAsync += e =>
{
Interlocked.Increment(ref receivedMessages);
return(PlatformAbstractionLayer.CompletedTask);
};
await receiverClient.SubscribeAsync("t/+");
for (var i = 0; i < 100; i++)
{
_ = Task.Run(
async() =>
{
using (var client = await testEnvironment.ConnectClient())
{
var applicationMessageBuilder = new MqttApplicationMessageBuilder();
for (var j = 0; j < 1000; j++)
{
var message = applicationMessageBuilder.WithTopic("t/" + j)
.Build();
await client.PublishAsync(message)
.ConfigureAwait(false);
}
await client.DisconnectAsync();
}
});
}
SpinWait.SpinUntil(() => receivedMessages == 100000, TimeSpan.FromSeconds(60));
Assert.AreEqual(100000, receivedMessages);
}
}
}
public bool sendMessage(string theTopic, byte[] Data, MessagePriority priority = FedNetConstante.DEFAULT_PRIORITY)
{
if (!_theGameClient.IsConnected)
{
return(false);
}
if (theTopic == "")
{
return(false);
}
MqttApplicationMessageBuilder theMsgBuilder = new MqttApplicationMessageBuilder();
theMsgBuilder.WithTopic(FedNetConstante.CLIENT_TO_SERVER + FedNetConstante.DEFAULT_TOPIC_SEPARATOR + ClientId + FedNetConstante.DEFAULT_TOPIC_SEPARATOR + theTopic);
theMsgBuilder.WithQualityOfServiceLevel((MqttQualityOfServiceLevel)priority);
theMsgBuilder.WithPayload(Data);
_theGameClient.PublishAsync(theMsgBuilder.Build());
return(true);
}
private static MqttApplicationMessage WrapWillMessage(IWillMessage message)
{
if (message != null)
{
var applicationMessage = new MqttApplicationMessageBuilder();
applicationMessage
.WithTopic(message.Topic)
.WithPayload(message.Payload)
.WithRetainFlag(message.Retain);
ConvertToQualityOfServiceLevel(applicationMessage, message.QualityOfServiceLevel);
return(applicationMessage.Build());
}
return(null);
}
public async Task PublishOnAsync(string topic, string message, bool retain)
{
MqttApplicationMessageBuilder builder;
MqttApplicationMessage msg;
if (!this.Client.IsConnected)
{
return;
}
builder = new MqttApplicationMessageBuilder();
builder.WithAtMostOnceQoS();
builder.WithPayload(message);
builder.WithTopic(topic);
builder.WithRetainFlag(retain);
msg = builder.Build();
await this.Client.PublishAsync(msg).ConfigureAwait(false);
}
public async Task Subscribe_Lots_In_Multiple_Requests()
{
using (var testEnvironment = CreateTestEnvironment())
{
var receivedMessagesCount = 0;
await testEnvironment.StartServer();
var c1 = await testEnvironment.ConnectClient();
c1.ApplicationMessageReceivedAsync += e =>
{
Interlocked.Increment(ref receivedMessagesCount);
return(PlatformAbstractionLayer.CompletedTask);
};
for (var i = 0; i < 500; i++)
{
var so = new MqttClientSubscribeOptionsBuilder()
.WithTopicFilter(i.ToString()).Build();
await c1.SubscribeAsync(so).ConfigureAwait(false);
await Task.Delay(10);
}
var c2 = await testEnvironment.ConnectClient();
var messageBuilder = new MqttApplicationMessageBuilder();
for (var i = 0; i < 500; i++)
{
messageBuilder.WithTopic(i.ToString());
await c2.PublishAsync(messageBuilder.Build()).ConfigureAwait(false);
await Task.Delay(10);
}
SpinWait.SpinUntil(() => receivedMessagesCount == 500, 5000);
Assert.AreEqual(500, receivedMessagesCount);
}
}
public MainWindow()
{
InitializeComponent();
// Configure MQTT server.
//mqttServer = new MqttFactory().CreateMqttServer(options =>
//{
// options.DefaultEndpointOptions.Port = 1884;
// //options.Storage = new RetainedMessageHandler();
// options.ConnectionValidator = c =>
// {
// if (c.ClientId.Length < 10)
// {
// return MqttConnectReturnCode.ConnectionRefusedIdentifierRejected;
// }
// //if (c.Username != "mySecretUser")
// //{
// // return MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
// //}
// //if (c.Password != "mySecretPassword")
// //{
// // return MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
// //}
// return MqttConnectReturnCode.ConnectionAccepted;
// };
//});
optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
//.WithConnectionValidator(connValidator)
.WithDefaultEndpointPort(60000);
mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.StartAsync(optionsBuilder.Build());
mqttServer.UseApplicationMessageReceivedHandler(async e =>
{
string receivedMqtt = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
if (e.ApplicationMessage.Topic.StartsWith("Senzo/Mobile/Client/"))
{
Console.WriteLine("### RECEIVED APPLICATION MESSAGE FROM MOBILE ###");
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();
await Application.Current.Dispatcher.BeginInvoke(
DispatcherPriority.Background,
new Action(() =>
{
txtMessage.Text = "";
txtMessage.Text += "### RECEIVED APPLICATION MESSAGE ###";
txtMessage.Text += "$ Topic = " + e.ApplicationMessage.Topic;
txtMessage.Text += "$ Payload = " + Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
txtMessage.Text += "$ QoS = " + e.ApplicationMessage.QualityOfServiceLevel;
txtMessage.Text += "$ Retain = " + e.ApplicationMessage.Retain;
})
);
var message2 = new MqttApplicationMessageBuilder();
//.WithTopic("Senzo/Server/+")
//.WithPayload("Receive And Forward Message")
//.WithExactlyOnceQoS()
//.WithRetainFlag()
//.Build();
//foreach (string clientId in clientSession) {
// await mqttServer.PublishAsync(message2.WithTopic("Senzo/Gateway/Server/" +clientId)
// .WithPayload(receivedMqtt)
// .WithExactlyOnceQoS()
// .WithRetainFlag()
// .Build());
//}
//Console.WriteLine();
}
else if (e.ApplicationMessage.Topic.StartsWith("Senzo/Gateway/Client/"))
{
Console.WriteLine("### RECEIVED APPLICATION MESSAGE FROM GATEWAY ###");
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();
await Application.Current.Dispatcher.BeginInvoke(
DispatcherPriority.Background,
new Action(() =>
{
txtMessage.Text = "";
txtMessage.Text += "### RECEIVED APPLICATION MESSAGE ###";
txtMessage.Text += "$ Topic = " + e.ApplicationMessage.Topic;
txtMessage.Text += "$ Payload = " + Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
txtMessage.Text += "$ QoS = " + e.ApplicationMessage.QualityOfServiceLevel;
txtMessage.Text += "$ Retain = " + e.ApplicationMessage.Retain;
})
);
var message = new MqttApplicationMessageBuilder();
//.WithTopic("Senzo/Server/+")
//.WithPayload("Receive And Forward Message")
//.WithExactlyOnceQoS()
//.WithRetainFlag()
//.Build();
//foreach (string clientId in clientSession)
//{
// await mqttServer.PublishAsync(message.WithTopic("Senzo/Gateway/Server/" + clientId)
// .WithPayload(receivedMqtt)
// .WithExactlyOnceQoS()
// .WithRetainFlag()
// .Build());
//}
//Console.WriteLine();
}
else if ((string.Equals(e.ApplicationMessage.Topic, "test/topic")))
{
Console.WriteLine("### IGNORED APPLICATION MESSAGE FROM GATEWAY ###");
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();
}
else if (e.ApplicationMessage.Topic.StartsWith("MQTTnet.RPC") && e.ApplicationMessage.Topic.EndsWith("/Reply") && e.ClientId != null)
{
var message1 = new MqttApplicationMessageBuilder();
Console.WriteLine("### RPC APPLICATION MESSAGE FROM GATEWAY ###");
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($"+ ContentType = {e.ApplicationMessage.ContentType}");
Console.WriteLine();
await mqttServer.PublishAsync(message1.WithTopic(e.ApplicationMessage.Topic + "/response")
.WithPayload("TestResponse")
.WithExactlyOnceQoS()
.Build());
}
else
{
Console.WriteLine("### IGNORED APPLICATION MESSAGE FROM GATEWAY ###");
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();
}
});
mqttServer.ClientDisconnectedHandler = new MqttServerClientDisconnectedHandlerDelegate(e => OnDisconnected(e));
mqttServer.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(e => OnConnected(e));
//mqttServer.ApplicationMessageReceivedHandler = new Mqtt(e => OnAppMessage(e));
//mqttServer.UseClientConnectedHandler(e =>
// {
// Console.WriteLine("Client Connected:"+e.ClientId);
// clientSession.Add(e.ClientId);
// });
//mqttServer.UseClientDisconnectedHandler(e =>
//{
// Console.WriteLine("Client Disconnected:"+e.ClientId);
// clientSession.Remove(e.ClientId);
//});
}
public static async void SendToMQTT(DONN.LS.Entities.TempLocations item, string topic = "location"
, MQTTnet.Protocol.MqttQualityOfServiceLevel qos = MQTTnet.Protocol.MqttQualityOfServiceLevel.AtMostOnce)
{
var message = messageBuilder.WithTopic(topic).WithPayload(Newtonsoft.Json.JsonConvert.SerializeObject(item)).Build();
await mqttClient.PublishAsync(topic, Newtonsoft.Json.JsonConvert.SerializeObject(item), qos);
}
public static async Task ReqRepTest(int LoopNum)
{
string requestTopic = "mytopic/A/request";
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
using (var cts = new CancellationTokenSource())
using (var startedev = new ManualResetEventSlim())
using (var connectedev = new ManualResetEventSlim())
using (var recvev = new ManualResetEventSlim())
{
var fac = new MqttFactory();
await Task.WhenAll(
Task.Run(async() =>
{
var svr = fac.CreateMqttServer();
var msgbuilder = new MqttApplicationMessageBuilder().WithPayload("req");
svr.ApplicationMessageReceived += async(sender, ev) =>
{
if (ev.ApplicationMessage.Topic.Equals(requestTopic, StringComparison.Ordinal))
{
var reqmsg = MessagePackSerializer.Deserialize <ReqMsg>(ev.ApplicationMessage.Payload);
var msg = msgbuilder.WithTopic(reqmsg.ReplyTopic).Build();
await svr.PublishAsync(msg);
}
};
svr.Started += (sender, ev) =>
{
startedev.Set();
};
var opt = new MqttServerOptionsBuilder()
.WithDefaultEndpoint()
.WithDefaultEndpointBoundIPAddress(IPAddress.Loopback)
.WithDefaultEndpointPort(10012)
.Build();
await svr.StartAsync(opt).ConfigureAwait(false);
cts.Token.WaitHandle.WaitOne();
await svr.StopAsync().ConfigureAwait(false);
})
,
Task.Run(async() =>
{
var client = fac.CreateMqttClient();
string replyTopic = "mytopic/A/reply";
var queue = new ConcurrentQueue <TaskCompletionSource <byte[]> >();
client.ApplicationMessageReceived += (sender, ev) =>
{
if (queue.TryDequeue(out var tcs))
{
tcs.TrySetResult(ev.ApplicationMessage.Payload);
}
};
client.Connected += (sender, ev) =>
{
connectedev.Set();
};
var clientopt = new MqttClientOptionsBuilder()
.WithClientId("clid")
.WithTcpServer("localhost", 10012)
.Build()
;
await client.ConnectAsync(clientopt).ConfigureAwait(false);
connectedev.Wait();
var topicFilter = new TopicFilterBuilder()
.WithTopic(replyTopic)
.WithAtLeastOnceQoS()
.Build()
;
await client.SubscribeAsync(topicFilter).ConfigureAwait(false);
Console.WriteLine($"client task loop started:{sw.Elapsed}");
var beginTime = sw.Elapsed;
var msgbuilder = new MqttApplicationMessageBuilder().WithTopic(requestTopic);
for (int i = 0; i < LoopNum; i++)
{
var reqpayload = MessagePackSerializer.Serialize(new ReqMsg(replyTopic, "hoge"));
var msg = msgbuilder
.WithPayload(reqpayload)
.Build();
;
var reqtcs = new TaskCompletionSource <byte[]>();
queue.Enqueue(reqtcs);
await client.PublishAsync(msg).ConfigureAwait(false);
await reqtcs.Task;
}
var endTime = sw.Elapsed;
Console.WriteLine($"elapsed(mqtt):{sw.Elapsed},rps={LoopNum/(endTime.Subtract(beginTime).TotalSeconds)}");
}).ContinueWith(t =>
{
Console.WriteLine($"all client task done:{sw.Elapsed}");
cts.Cancel();
if (t.IsCanceled)
{
throw new TaskCanceledException("server task cancelled", t.Exception);
}
else if (t.IsFaulted)
{
throw new AggregateException(t.Exception);
}
})
).ConfigureAwait(false);
}
}
public static async Task TestMany(int loopNum, int taskNum)
{
var fac = new MqttFactory();
using (var cts = new CancellationTokenSource())
{
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
await Task.WhenAll(
Task.Run(async() =>
{
var svr = fac.CreateMqttServer();
svr.Started += (sender, ev) =>
{
Console.WriteLine($"{sw.Elapsed} svr started");
};
svr.ClientConnected += (sender, ev) =>
{
Console.WriteLine($"{sw.Elapsed} client connected(S): {ev.Client.ClientId}");
};
svr.ClientDisconnected += (sender, ev) =>
{
Console.WriteLine($"{sw.Elapsed} client disconnected(S): {ev.Client.ClientId}");
};
var opt = new MqttServerOptionsBuilder()
.WithDefaultEndpoint()
.WithDefaultEndpointBoundIPAddress(IPAddress.Loopback)
.WithDefaultEndpointPort(10012)
.Build();
await svr.StartAsync(opt).ConfigureAwait(false);
cts.Token.WaitHandle.WaitOne();
await svr.StopAsync().ConfigureAwait(false);
})
,
Task.Run(async() =>
{
await Task.Delay(100).ConfigureAwait(false);
var client = fac.CreateMqttClient();
var clientopt = new MqttClientOptionsBuilder()
.WithClientId("clid")
.WithTcpServer("localhost", 10012)
.Build()
;
// var opt = new ManagedMqttClientOptionsBuilder()
// .WithClientOptions(clientopt)
// .WithAutoReconnectDelay(TimeSpan.FromMilliseconds(100))
// .Build();
using (var connectedEvent = new ManualResetEventSlim(false))
{
client.ApplicationMessageReceived += (sender, ev) =>
{
Console.WriteLine($"{sw.Elapsed} recv {ev.ApplicationMessage.Topic},{ev.ApplicationMessage.Payload[0]}");
};
client.Connected += (sender, ev) =>
{
Console.WriteLine($"{sw.Elapsed} client connected");
connectedEvent.Set();
};
client.Disconnected += (sender, ev) =>
{
Console.WriteLine($"{sw.Elapsed} client disconnected");
};
var topicFilter = new TopicFilterBuilder()
.WithTopic("mytopic/A").WithAtLeastOnceQoS().Build();
Console.WriteLine($"{sw.Elapsed} begin connection");
await client.ConnectAsync(clientopt).ConfigureAwait(false);
// await client.StartAsync(opt).ConfigureAwait(false);
connectedEvent.Wait();
if (!client.IsConnected)
{
Console.WriteLine($"not connected");
}
else
{
Console.WriteLine($"{sw.Elapsed} connection established");
}
await client.SubscribeAsync(new[] { topicFilter }).ConfigureAwait(false);
Console.WriteLine($"{sw.Elapsed} subscribing done");
var msgbuilder = new MqttApplicationMessageBuilder();
msgbuilder = msgbuilder.WithTopic("mytopic/A").WithAtLeastOnceQoS();
var dat = new byte[1];
for (int i = 0; i < 100; i++)
{
await Task.Yield();
dat[0] = (byte)(i % 255);
var msg = msgbuilder.WithPayload(dat).Build();
await client.PublishAsync(msg).ConfigureAwait(false);
Console.WriteLine($"{sw.Elapsed}: publish{i}");
}
await client.UnsubscribeAsync(new[] { topicFilter.Topic }).ConfigureAwait(false);
await client.DisconnectAsync().ConfigureAwait(false);
// await client.StopAsync().ConfigureAwait(false);
// cts.Cancel();
}
// var opt = new MqttClientOptionsBuilder()
// .Build();
// await client.ConnectAsync(opt).ConfigureAwait(false);
// var topicFilter = new TopicFilterBuilder()
// .WithTopic("topic")
// .Build();
// var subresults = await client.SubscribeAsync(new TopicFilter[] {topicFilter}).ConfigureAwait(false);
// foreach(var subresult in subresults)
// {
// }
}).ContinueWith(t =>
{
cts.Cancel();
})
);
sw.Stop();
}
}
public MqttApplicationMessage Handle(DeconzItemStateChangedMqttMessage message)
=> _builder.WithTopic($"deconz/stat/{CreateEntityTypeTopic(message.Entity)}/{message.Entity.Name}/{message.PropertyName}")
.WithPayload(message.Content)
.Build();
