/// <summary>
/// Prepare data
/// </summary>
/// <param name="publisherConnection"></param>
/// <returns></returns>
private byte[] PrepareData(UdpPubSubConnection publisherConnection, UdpConnectionType udpConnectionType = UdpConnectionType.Networking, int networkMessageIndex = 0)
{
try
{
WriterGroupDataType writerGroup0 = publisherConnection.PubSubConnectionConfiguration.WriterGroups.First();
IList <UaNetworkMessage> networkMessages = null;
if (udpConnectionType == UdpConnectionType.Discovery)
{
List <UInt16> dataSetWriterIds = new List <UInt16>();
foreach (DataSetWriterDataType dataSetWriterDataType in writerGroup0.DataSetWriters)
{
dataSetWriterIds.Add(dataSetWriterDataType.DataSetWriterId);
}
networkMessages = publisherConnection.CreateDataSetMetaDataNetworkMessages(dataSetWriterIds.ToArray());
}
else
{
networkMessages = publisherConnection.CreateNetworkMessages(writerGroup0, new WriterGroupPublishState());
}
Assert.IsNotNull(networkMessages, "CreateNetworkMessages returned null");
Assert.IsTrue(networkMessages.Count > networkMessageIndex, "networkMessageIndex is outside of bounds");
UaNetworkMessage message = networkMessages[networkMessageIndex];
byte[] bytes = message.Encode(ServiceMessageContext.GlobalContext);
return(bytes);
}
catch
{
return(Array.Empty <byte>());
}
}
public void ValidateUadpPubSubConnectionNetworkMessagePublishMulticast()
{
//Arrange
var localhost = GetFirstNic();
Assert.IsNotNull(localhost, "localhost is null");
Assert.IsNotNull(localhost.Address, "localhost.Address is null");
//create publisher configuration object with modified port
PubSubConfigurationDataType publisherConfiguration = UaPubSubConfigurationHelper.LoadConfiguration(PublisherConfigurationFileName);
Assert.IsNotNull(publisherConfiguration, "publisherConfiguration is null");
IPAddress multicastIPAddress = new IPAddress(new byte[4] {
239, 0, 0, 1
});
Assert.IsNotNull(multicastIPAddress, "multicastIPAddress is null");
NetworkAddressUrlDataType publisherAddress = new NetworkAddressUrlDataType();
publisherAddress.Url = "opc.udp://" + multicastIPAddress.ToString() + ":4840";
publisherConfiguration.Connections[0].Address = new ExtensionObject(publisherAddress);
//create publisher UaPubSubApplication with changed configuration settings
UaPubSubApplication publisherApplication = UaPubSubApplication.Create(publisherConfiguration);
Assert.IsNotNull(publisherApplication, "publisherApplication is null");
UadpPubSubConnection publisherConnection = publisherApplication.PubSubConnections[0] as UadpPubSubConnection;
Assert.IsNotNull(publisherConnection, "publisherConnection is null");
// will signal that the uadp message was received from local ip
m_shutdownEvent = new ManualResetEvent(false);
//setup uadp client for receiving from multicast (simulate a subscriber multicast)
UdpClient udpMulticastClient = new UdpClientMulticast(localhost.Address, multicastIPAddress, 4840);
udpMulticastClient.BeginReceive(new AsyncCallback(OnReceive), udpMulticastClient);
// prepare a network message
WriterGroupDataType writerGroup0 = publisherConnection.PubSubConnectionConfiguration.WriterGroups[0];
UaNetworkMessage networkMessage = publisherConnection.CreateNetworkMessage(writerGroup0);
//Act
publisherConnection.Start();
publisherConnection.PublishNetworkMessage(networkMessage);
//Assert
if (!m_shutdownEvent.WaitOne(EstimatedPublishingTime))
{
Assert.Fail("The UADP message was not received");
}
publisherConnection.Stop();
udpMulticastClient.Close();
udpMulticastClient.Dispose();
}
/// <summary>
/// Publish the network message
/// </summary>
/// <param name="networkMessage"></param>
/// <returns></returns>
public override bool PublishNetworkMessage(UaNetworkMessage networkMessage)
{
if (networkMessage == null || m_publisherUdpClients == null || m_publisherUdpClients.Count == 0)
{
return(false);
}
try
{
lock (m_lock)
{
if (m_publisherUdpClients != null && m_publisherUdpClients.Count > 0)
{
ServiceMessageContext messageContext = new ServiceMessageContext();
BinaryEncoder encoder = new BinaryEncoder(messageContext);
networkMessage.Encode(encoder);
byte[] bytes = ReadBytes(encoder.BaseStream);
encoder.Dispose();
foreach (var udpClient in m_publisherUdpClients)
{
try
{
int sent = udpClient.Send(bytes, bytes.Length, NetworkAddressEndPoint);
}
catch (Exception ex)
{
Utils.Trace(ex, "UadpPubSubConnection.PublishNetworkMessage");
return(false);
}
}
return(true);
}
}
}
catch (Exception ex)
{
Utils.Trace(ex, "UadpPubSubConnection.PublishNetworkMessage");
return(false);
}
return(false);
}
/// <summary>
/// Generate and publish the dataset MetaData message
/// </summary>
private void PublishMessage()
{
try
{
UaNetworkMessage metaDataNetworkMessage = m_parentConnection.CreateDataSetMetaDataNetworkMessage(m_writerGroup, m_dataSetWriter);
if (metaDataNetworkMessage != null)
{
bool success = m_parentConnection.PublishNetworkMessage(metaDataNetworkMessage);
Utils.Trace(
"MqttMetadataPublisher Publish DataSetMetaData, DataSetWriterId:{0}; success = {1}",
m_dataSetWriter.DataSetWriterId, success);
}
}
catch (Exception e)
{
// Unexpected exception in PublishMessages
Utils.Trace(e, "MqttMetadataPublisher.PublishMessages");
}
}
/// <summary>
/// Publish the network message
/// </summary>
public override bool PublishNetworkMessage(UaNetworkMessage networkMessage)
{
if (networkMessage == null || m_publisherUdpClients == null || m_publisherUdpClients.Count == 0)
{
return(false);
}
try
{
lock (m_lock)
{
if (m_publisherUdpClients != null && m_publisherUdpClients.Count > 0)
{
// Get encoded bytes
byte[] bytes = networkMessage.Encode(MessageContext);
foreach (var udpClient in m_publisherUdpClients)
{
try
{
udpClient.Send(bytes, bytes.Length, NetworkAddressEndPoint);
Utils.Trace("UdpPubSubConnection.PublishNetworkMessage bytes:{0}, endpoint:{1}", bytes.Length, NetworkAddressEndPoint);
}
catch (Exception ex)
{
Utils.Trace(ex, "UdpPubSubConnection.PublishNetworkMessage");
return(false);
}
}
return(true);
}
}
}
catch (Exception ex)
{
Utils.Trace(ex, "UdpPubSubConnection.PublishNetworkMessage");
return(false);
}
return(false);
}
/// <summary>
/// Prepare data
/// </summary>
/// <param name="publisherConnection"></param>
/// <returns></returns>
private byte[] PrepareData(UadpPubSubConnection publisherConnection)
{
try
{
WriterGroupDataType writerGroup0 = publisherConnection.PubSubConnectionConfiguration.WriterGroups[0];
UaNetworkMessage message = publisherConnection.CreateNetworkMessage(writerGroup0);
ServiceMessageContext messageContext = new ServiceMessageContext();
BinaryEncoder encoder = new BinaryEncoder(messageContext);
message.Encode(encoder);
byte[] bytes = ReadBytes(encoder.BaseStream);
encoder.Dispose();
return(bytes);
}
catch (Exception)
{
}
return(new byte[0]);
}
/// <summary>
/// Prepare data
/// </summary>
/// <param name="publisherConnection"></param>
/// <returns></returns>
private byte[] PrepareData(UdpPubSubConnection publisherConnection, int networkMessageIndex = 0)
{
try
{
WriterGroupDataType writerGroup0 = publisherConnection.PubSubConnectionConfiguration.WriterGroups.First();
IList <UaNetworkMessage> networkMessages = publisherConnection.CreateNetworkMessages(writerGroup0);
Assert.IsNotNull(networkMessages, "CreateNetworkMessages returned null");
Assert.IsTrue(networkMessages.Count > networkMessageIndex, "networkMessageIndex is outside of bounds");
UaNetworkMessage message = networkMessages[networkMessageIndex];
byte[] bytes = message.Encode();
return(bytes);
}
catch
{
return(Array.Empty <byte>());
}
}
