public void BasicTerminalTest()
{
m_client1.RegisterTerminal(TerminalStandpoint.Publisher, "Pub", "Desc", "[Test>Basic]");
m_client1.RegisterTerminal(TerminalStandpoint.Subscriber, "Sub", "Desc", "[Test>");
Thread.Sleep(1000);
PublishReceived evnt = new PublishReceived(m_client1_OnPublishReceived);
m_client1.OnPublishReceived += evnt;
m_wait.Reset();
m_numExpected = 1;
Delivery d = new Delivery("Test");
SetDeliveryAttributes(d, new string[] { "Sub" }, "Pub");
m_client1.Publish("Pub", d);
Assert.IsTrue(m_wait.WaitOne(5000));
m_client1.OnPublishReceived -= evnt;
m_client1.DeregisterTerminal(TerminalStandpoint.Publisher, "Pub");
m_client1.DeregisterTerminal(TerminalStandpoint.Subscriber, "Sub");
}
public void BasicTerminalFileTest100()
{
m_client1.RegisterTerminal(TerminalStandpoint.Publisher, "Pub", "Desc", "[Test>Basic]");
m_client1.RegisterTerminal(TerminalStandpoint.Subscriber, "Sub", "Desc", "[Test>");
Thread.Sleep(1000);
PublishReceived evnt = new PublishReceived(m_client1_OnPublishReceived);
m_client1.OnPublishReceived += evnt;
m_wait.Reset();
m_numExpected = 100;
Delivery d = new Delivery(TestHelper.ReadTestFile(), DeliveryEncoding.None);
SetDeliveryAttributes(d, new string[] { "Sub" }, "Pub");
for (int i = 0; i < 100; i++)
{
m_client1.Publish("Pub", d);
}
Assert.IsTrue(m_wait.WaitOne(20000));
m_client1.OnPublishReceived -= evnt;
m_client1.DeregisterTerminal(TerminalStandpoint.Publisher, "Pub");
m_client1.DeregisterTerminal(TerminalStandpoint.Subscriber, "Sub");
}
public void when_sending_publish_received_and_no_complete_is_sent_after_receiving_publish_release_then_publish_release_is_re_transmitted()
{
string clientId = Guid.NewGuid().ToString();
MqttConfiguration configuration = Mock.Of <MqttConfiguration>(c => c.WaitTimeoutSecs == 1);
Mock <IConnectionProvider> connectionProvider = new Mock <IConnectionProvider>();
Mock <IRepository <ClientSession> > sessionRepository = new Mock <IRepository <ClientSession> >();
sessionRepository
.Setup(r => r.Read(It.IsAny <string>()))
.Returns(new ClientSession(clientId)
{
PendingMessages = new List <PendingMessage> {
new PendingMessage()
}
});
PublishSenderFlow flow = new PublishSenderFlow(sessionRepository.Object, configuration);
ushort packetId = (ushort)new Random().Next(0, ushort.MaxValue);
PublishReceived publishReceived = new PublishReceived(packetId);
Subject <IPacket> receiver = new Subject <IPacket>();
Subject <IPacket> sender = new Subject <IPacket>();
Mock <IMqttChannel <IPacket> > channel = new Mock <IMqttChannel <IPacket> >();
channel.Setup(c => c.IsConnected).Returns(true);
channel.Setup(c => c.ReceiverStream).Returns(receiver);
channel.Setup(c => c.SenderStream).Returns(sender);
channel.Setup(c => c.SendAsync(It.IsAny <IPacket>()))
.Callback <IPacket>(packet => sender.OnNext(packet))
.Returns(Task.Delay(0));
connectionProvider.Setup(m => m.GetConnection(It.Is <string>(s => s == clientId))).Returns(channel.Object);
ManualResetEventSlim ackSentSignal = new ManualResetEventSlim(initialState: false);
sender.Subscribe(p =>
{
if (p is PublishRelease)
{
ackSentSignal.Set();
}
});
Task flowTask = flow.ExecuteAsync(clientId, publishReceived, channel.Object);
bool ackSent = ackSentSignal.Wait(2000);
Assert.True(ackSent);
channel.Verify(c => c.SendAsync(It.Is <IPacket>(p => p is PublishRelease &&
(p as PublishRelease).PacketId == packetId)), Times.AtLeast(1));
}
public async Task when_writing_publish_received_packet_then_succeeds(string jsonPath, string packetPath)
{
jsonPath = Path.Combine(Environment.CurrentDirectory, jsonPath);
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
byte[] expectedPacket = Packet.ReadAllBytes(packetPath);
FlowPacketFormatter <PublishReceived> formatter = new FlowPacketFormatter <PublishReceived>(MqttPacketType.PublishReceived, id => new PublishReceived(id));
PublishReceived publishReceived = Packet.ReadPacket <PublishReceived>(jsonPath);
byte[] result = await formatter.FormatAsync(publishReceived);
expectedPacket.Should().BeEquivalentTo(result);
}
async Task SendPendingAcknowledgementsAsync(ClientSession session, IMqttChannel <IPacket> channel)
{
foreach (PendingAcknowledgement pendingAcknowledgement in session.GetPendingAcknowledgements())
{
IFlowPacket ack = default;
if (pendingAcknowledgement.Type == MqttPacketType.PublishReceived)
{
ack = new PublishReceived(pendingAcknowledgement.PacketId);
}
else if (pendingAcknowledgement.Type == MqttPacketType.PublishRelease)
{
ack = new PublishRelease(pendingAcknowledgement.PacketId);
}
await _senderFlow.SendAckAsync(session.Id, ack, channel);
}
}
async Task SendPendingAcknowledgementsAsync(ClientSession session, IMqttChannel <IPacket> channel)
{
foreach (var pendingAcknowledgement in session.GetPendingAcknowledgements())
{
var ack = default(IFlowPacket);
if (pendingAcknowledgement.Type == MqttPacketType.PublishReceived)
{
ack = new PublishReceived(pendingAcknowledgement.PacketId);
}
else if (pendingAcknowledgement.Type == MqttPacketType.PublishRelease)
{
ack = new PublishRelease(pendingAcknowledgement.PacketId);
}
await senderFlow.SendAckAsync(session.ClientId, ack, channel, PendingMessageStatus.PendingToAcknowledge)
.ConfigureAwait(continueOnCapturedContext: false);
}
}
public Task Handle(PublishReceived notification, CancellationToken cancellationToken)
{
if (!HistorianConfiguration.Npgsql.Enable)
{
return(Task.CompletedTask);
}
var settings = new JsonSerializerSettings()
{
Formatting = Formatting.Indented,
Converters =
{
new Newtonsoft.Json.Converters.StringEnumConverter()
},
};
if ($"{Prefix}/cpu-temperature".Equals(notification.Topic))
{
// parse ping payload
OnMeasurementReceived("cpu-temperature", JsonConvert.DeserializeObject <CpuTemperatureMeasurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
if ($"{Prefix}/hdd-temperature".Equals(notification.Topic))
{
// parse ping payload
OnMeasurementReceived("hdd-temperature", JsonConvert.DeserializeObject <HddTemperatureMeasurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
if ($"{Prefix}/hdd-usage".Equals(notification.Topic))
{
// parse ping payload
OnMeasurementReceived("hdd-usage", JsonConvert.DeserializeObject <HddUsageMeasurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
if ($"{Prefix}/heartbeat".Equals(notification.Topic))
{
// parse ping payload
OnMeasurementReceived("heartbeat", JsonConvert.DeserializeObject <HeartbeatMeasurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
if ($"{Prefix}/load".Equals(notification.Topic))
{
// parse ping payload
OnMeasurementReceived("load", JsonConvert.DeserializeObject <LoadMeasurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
if ($"{Prefix}/ping".Equals(notification.Topic))
{
// parse ping payload
OnMeasurementReceived("ping", JsonConvert.DeserializeObject <PingMeasurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
if ($"{Prefix}/tcp-port-state".Equals(notification.Topic))
{
// parse ping payload
OnMeasurementReceived("tcp-port-state", JsonConvert.DeserializeObject <TcpPortStateMeasurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
if ($"{Prefix}/uptime".Equals(notification.Topic))
{
// parse ping payload
OnMeasurementReceived("uptime", JsonConvert.DeserializeObject <UptimeMeasurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
if ($"{Prefix}/ns-resolve".Equals(notification.Topic))
{
// parse ping payload
OnMeasurementReceived("ns-resolve", JsonConvert.DeserializeObject <NsResolveMeasurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
if ($"{Prefix}/dht22".Equals(notification.Topic))
{
// parse ping payload
OnMeasurementReceived("dht22", JsonConvert.DeserializeObject <Dht22Measurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
if ($"{Prefix}/state".Equals(notification.Topic))
{
// parse payload
OnMeasurementReceived("state", JsonConvert.DeserializeObject <StateMeasurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
if ($"{Prefix}/rational-number".Equals(notification.Topic))
{
// parse payload
OnMeasurementReceived("rational-number", JsonConvert.DeserializeObject <RationalNumberMeasurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
if ($"{Prefix}/ups-battery".Equals(notification.Topic))
{
// parse payload
OnMeasurementReceived("ups-battery", JsonConvert.DeserializeObject <UpsBatteryMeasurement>(Encoding.UTF8.GetString(notification.Payload), settings), cancellationToken);
}
foreach (var genericJsonEventConfigurationItem in HistorianConfiguration.Npgsql.GenericJson.Items)
{
bool isTopicMatch = genericJsonEventConfigurationItem.Topics.Any(topicPattern => topicPattern.IsTopicMatch(notification.Topic));
if (isTopicMatch)
{
var measurement = new GenericJsonMeasurement()
{
QueryString = genericJsonEventConfigurationItem.QueryString,
Topic = notification.Topic,
Payload = Encoding.UTF8.GetString(notification.Payload),
};
OnMeasurementReceived("generic-json", measurement, cancellationToken);
}
}
return(Task.CompletedTask);
}
