public async void SendMessage(DiscoveryMessage discoveryMessage)
{
byte[] message;
try
{
if (_logger.IsTrace)
{
_logger.Trace($"Sending message: {discoveryMessage}");
}
message = Serialize(discoveryMessage);
}
catch (Exception e)
{
_logger.Error($"Error during serialization of the message: {discoveryMessage}", e);
return;
}
IAddressedEnvelope <IByteBuffer> packet = new DatagramPacket(Unpooled.CopiedBuffer(message), discoveryMessage.FarAddress);
// _logger.Info($"The message {discoveryMessage} will be sent to {_channel.RemoteAddress}");
await _channel.WriteAndFlushAsync(packet).ContinueWith(t =>
{
if (t.IsFaulted)
{
if (_logger.IsTrace)
{
_logger.Trace($"Error when sending a discovery message Msg: {discoveryMessage.ToString()} ,Exp: {t.Exception}");
}
}
});
}
public void KeyNull2Test()
{
DiscoveryMessage target = new DiscoveryMessage();
target.Key = "";
Assert.Fail("No exception raised.");
}
public void DiscoveryMessageReceivedEventArgsConstructorTest()
{
DiscoveryMessage message = new DiscoveryMessage();
DiscoveryMessageReceivedEventArgs target = new DiscoveryMessageReceivedEventArgs(message);
Assert.AreSame(message, target.Message);
}
private void ProcessPairs(List <Frame> frameList, List <XElement> xmlList, IEnumerable <Tuple <XElement, XElement> > pairs)
{
foreach (var pair in pairs)
{
var requestFrame = frameList[xmlList.IndexOf(pair.Item1)];
var responseFrame = frameList[xmlList.IndexOf(pair.Item2)];
var client = UnitSet.GetUnit(responseFrame.DestinationMac);
var device = UnitSet.GetUnit(responseFrame.SourceMac);
var conversation = ConversationList.Find(client, device);
if (null == conversation)
{
continue;
}
var request = new DiscoveryMessage(requestFrame, conversation, MessageType.Request);
PackXml(pair.Item1, conversation, requestFrame, MessageType.Request);
var response = new DiscoveryMessage(responseFrame, conversation, MessageType.Response);
PackXml(pair.Item2, conversation, responseFrame, MessageType.Response);
conversation.Add(new RequestResponsePair(request, response, mParser.NetworkTrace, conversation,
ContentType.WSDiscovery));
}
}
public void ProcessDiscoveryMessageTest()
{
SecurityModule_Accessor target = null;
try
{
bool eventRaised = false;
target = new SecurityModule_Accessor();
DiscoveryMessage message = new DiscoveryMessage();
message.Checksum = 4321;
message.IPAddress = new IPAddress(new byte[] { 127, 0, 0, 1 });
message.Key = "sbrnd";
message.Value = "Honeywell";
message.MacAddress = new PhysicalAddress(new byte[] { 192, 168, 0, 1 });
target.add_DiscoveryCompleted(delegate { eventRaised = true; });
target.ProcessDiscoveryMessage(message);
Assert.AreEqual(new IPAddress(new byte[] { 127, 0, 0, 1 }), target.IPAddress);
Assert.AreEqual(new PhysicalAddress(new byte[] { 192, 168, 0, 1 }), target.MacAddress);
Assert.IsTrue(eventRaised);
}
finally
{
if (target != null)
{
target.Dispose();
}
}
}
public void ToStringTest()
{
DiscoveryMessage target = new DiscoveryMessage();
string actual = target.ToString();
Assert.IsFalse(actual.Length == 0);
Assert.IsTrue(actual.StartsWith("{"), "Didn't start with '{'");
Assert.IsTrue(actual.EndsWith("}"), "Didn't end with '}'");
}
public void KeyTest()
{
DiscoveryMessage target = new DiscoveryMessage();
string expected = "key";
string actual;
target.Key = expected;
actual = target.Key;
Assert.AreEqual(expected, actual);
}
public void MacAddressTest()
{
DiscoveryMessage target = new DiscoveryMessage();
PhysicalAddress expected = new PhysicalAddress(new byte[] { 00, 01, 02, 03, 04 });
PhysicalAddress actual;
target.MacAddress = expected;
actual = target.MacAddress;
Assert.AreEqual(expected, actual);
}
public void ValueTest()
{
DiscoveryMessage target = new DiscoveryMessage();
string expected = "Changed value";
string actual;
target.Value = expected;
actual = target.Value;
Assert.AreEqual(expected, actual);
}
public void DiscoveryMessageConstructorTest()
{
DiscoveryMessage target = new DiscoveryMessage();
Assert.AreEqual(0, target.Checksum);
Assert.AreEqual(null, target.IPAddress);
Assert.AreEqual(string.Empty, target.Key);
Assert.AreEqual(null, target.MacAddress);
Assert.AreEqual(string.Empty, target.Value);
}
public void ChecksumTest()
{
DiscoveryMessage target = new DiscoveryMessage();
int expected = 0xbeef;
int actual;
target.Checksum = expected;
actual = target.Checksum;
Assert.AreEqual(expected, actual);
}
public void IPAddressTest()
{
DiscoveryMessage target = new DiscoveryMessage();
IPAddress expected = new IPAddress(new byte[] { 001, 002, 003, 004 });
IPAddress actual;
target.IPAddress = expected;
actual = target.IPAddress;
Assert.AreEqual(expected, actual);
}
public async void SendMessage(DiscoveryMessage discoveryMessage)
{
byte[] message;
try
{
_logger.Info($"Sending message: {discoveryMessage}");
message = Seserialize(discoveryMessage);
}
catch (Exception e)
{
_logger.Error($"Error during serialization of the message: {discoveryMessage}", e);
return;
}
IAddressedEnvelope <IByteBuffer> packet = new DatagramPacket(Unpooled.CopiedBuffer(message), discoveryMessage.FarAddress);
await _channel.WriteAndFlushAsync(packet);
}
private byte[] Seserialize(DiscoveryMessage message)
{
switch (message.MessageType)
{
case MessageType.Ping:
return(_messageSerializationService.Serialize((PingMessage)message));
case MessageType.Pong:
return(_messageSerializationService.Serialize((PongMessage)message));
case MessageType.FindNode:
return(_messageSerializationService.Serialize((FindNodeMessage)message));
case MessageType.Neighbors:
return(_messageSerializationService.Serialize((NeighborsMessage)message));
default:
throw new Exception($"Unsupported messageType: {message.MessageType}");
}
}
public void OnDiscoveryMessageReceivedTest()
{
SecurityModule_Accessor target = null;
try
{
bool eventRaised = false;
target = new SecurityModule_Accessor();
target.add_DiscoveryMessageReceived(delegate { eventRaised = true; });
DiscoveryMessage message = new DiscoveryMessage();
target.OnDiscoveryMessageReceived(message);
Assert.IsTrue(eventRaised);
}
finally
{
if (target != null)
{
target.Dispose();
}
}
}
public void OnDiscoveryMessage(TestRunMessageEventArgs e) => DiscoveryMessage?.Invoke(this, e);
