public void ValidateUadpPubSubConnectionCreateNetworkMessageSequenceNumber()
{
Assert.IsNotNull(m_uadpPublisherConnection, "The UADP connection from standard configuration is invalid.");
//Arrange
WriterGroupDataType writerGroup0 = m_uadpPublisherConnection.PubSubConnectionConfiguration.WriterGroups[0];
//Act
m_uadpPublisherConnection.ResetSequenceNumber();
for (int i = 0; i < 10; i++)
{
//Create network message
UadpNetworkMessage networkMessage = m_uadpPublisherConnection.CreateNetworkMessage(writerGroup0) as UadpNetworkMessage;
//Assert
Assert.IsNotNull(networkMessage, "CreateNetworkMessage did not return an UadpNetworkMessage.");
Assert.AreEqual(networkMessage.SequenceNumber, i + 1, "UadpNetworkMessage.SequenceNumber for message {0} is not {0}.", i + 1);
//validate dataset message sequence number
Assert.IsNotNull(networkMessage.UadpDataSetMessages, "CreateNetworkMessage did not return an UadpNetworkMessage.UadpDataSetMessages.");
Assert.IsTrue(networkMessage.UadpDataSetMessages.Count == 3, "CreateNetworkMessage did not return 3 UadpNetworkMessage.UadpDataSetMessages.");
Assert.AreEqual(networkMessage.UadpDataSetMessages[0].SequenceNumber, i * 3 + 1, "UadpNetworkMessage.UadpDataSetMessages[0].SequenceNumber for message {0} is not {1}.", i + 1, i * 3 + 1);
Assert.AreEqual(networkMessage.UadpDataSetMessages[1].SequenceNumber, i * 3 + 2, "UadpNetworkMessage.UadpDataSetMessages[1].SequenceNumber for message {0} is not {1}.", i + 1, i * 3 + 2);
Assert.AreEqual(networkMessage.UadpDataSetMessages[2].SequenceNumber, i * 3 + 3, "UadpNetworkMessage.UadpDataSetMessages[2].SequenceNumber for message {0} is not {1}.", i + 1, i * 3 + 3);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UaPublisher"/> class.
/// </summary>
internal UaPublisher(IUaPubSubConnection pubSubConnection, WriterGroupDataType writerGroupConfiguration)
{
m_pubSubConnection = pubSubConnection;
m_writerGroupConfiguration = writerGroupConfiguration;
Initialize();
}
/// <summary>
/// Create and return the list of DataSetMetaData response messages
/// </summary>
/// <param name="dataSetWriterIds"></param>
/// <returns></returns>
public IList <UaNetworkMessage> CreateDataSetMetaDataNetworkMessages(UInt16[] dataSetWriterIds)
{
List <UaNetworkMessage> networkMessages = new List <UaNetworkMessage>();
var writers = GetAllDataSetWriters();
foreach (UInt16 dataSetWriterId in dataSetWriterIds)
{
DataSetWriterDataType writer = writers.Where(w => w.DataSetWriterId == dataSetWriterId).FirstOrDefault();
if (writer != null)
{
WriterGroupDataType writerGroup = PubSubConnectionConfiguration.WriterGroups.Where(wg => wg.DataSetWriters.Contains(writer)).FirstOrDefault();
if (writerGroup != null)
{
DataSetMetaDataType metaData = Application.DataCollector.GetPublishedDataSet(writer.DataSetName)?.DataSetMetaData;
if (metaData != null)
{
UadpNetworkMessage networkMessage = new UadpNetworkMessage(writerGroup, metaData);
networkMessage.PublisherId = PubSubConnectionConfiguration.PublisherId.Value;
networkMessage.DataSetWriterId = dataSetWriterId;
networkMessages.Add(networkMessage);
}
}
}
}
return(networkMessages);
}
/// <summary>
/// Create new instance of UadpNetworkMessage
/// </summary>
/// <param name="writerGroupConfiguration">The <see cref="WriterGroupDataType"/> confguration object that produced this message.</param>
/// <param name="uadpDataSetMessages"><see cref="UadpDataSetMessage"/> list as input</param>
public UadpNetworkMessage(WriterGroupDataType writerGroupConfiguration, List <UadpDataSetMessage> uadpDataSetMessages)
: base(writerGroupConfiguration, uadpDataSetMessages?.ConvertAll <UaDataSetMessage>(x => (UaDataSetMessage)x) ?? new List <UaDataSetMessage>())
{
UADPVersion = kUadpVersion;
DataSetClassId = Guid.Empty;
Timestamp = DateTime.UtcNow;
}
/// <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>());
}
}
/// <summary>
/// Determine if the connection has anything to publish -> at least one WriterDataSet is configured as enabled for current writer group
/// </summary>
/// <param name="writerGroupConfiguration"></param>
/// <returns></returns>
public bool CanPublish(WriterGroupDataType writerGroupConfiguration)
{
if (!m_isRunning)
{
return false;
}
// check if connection status is operational
if (Application.UaPubSubConfigurator.FindStateForObject(m_pubSubConnectionDataType) != PubSubState.Operational)
{
return false;
}
if (writerGroupConfiguration.Enabled)
{
foreach (DataSetWriterDataType writer in writerGroupConfiguration.DataSetWriters)
{
if (writer.Enabled)
{
return true;
}
}
}
return false;
}
public void ValidateUadpPubSubConnectionCreateNetworkMessage()
{
Assert.IsNotNull(m_uadpPublisherConnection, "The UADP connection from standard configuration is invalid.");
//Arrange
WriterGroupDataType writerGroup0 = m_uadpPublisherConnection.PubSubConnectionConfiguration.WriterGroups[0];
UadpWriterGroupMessageDataType messageSettings = ExtensionObject.ToEncodeable(writerGroup0.MessageSettings)
as UadpWriterGroupMessageDataType;
//Act
m_uadpPublisherConnection.ResetSequenceNumber();
UadpNetworkMessage networkMessage0 = m_uadpPublisherConnection.CreateNetworkMessage(writerGroup0) as UadpNetworkMessage;
//Assert
Assert.IsNotNull(networkMessage0, "CreateNetworkMessage did not return an UadpNetworkMessage.");
Assert.AreEqual(networkMessage0.DataSetClassId, Guid.Empty, "UadpNetworkMessage.DataSetClassId is invalid.");
Assert.AreEqual(networkMessage0.WriterGroupId, writerGroup0.WriterGroupId, "UadpNetworkMessage.WriterGroupId is invalid.");
Assert.AreEqual(networkMessage0.UADPVersion, 1, "UadpNetworkMessage.UADPVersion is invalid.");
Assert.AreEqual(networkMessage0.SequenceNumber, 1, "UadpNetworkMessage.SequenceNumber is not 1.");
Assert.AreEqual(networkMessage0.GroupVersion, messageSettings.GroupVersion, "UadpNetworkMessage.GroupVersion is not valid.");
Assert.AreEqual(networkMessage0.PublisherId, m_uadpPublisherConnection.PubSubConnectionConfiguration.PublisherId.Value,
"UadpNetworkMessage.PublisherId is not valid.");
Assert.IsNotNull(networkMessage0.UadpDataSetMessages, "UadpNetworkMessage.UadpDataSetMessages is null.");
Assert.AreEqual(networkMessage0.UadpDataSetMessages.Count, 3, "UadpNetworkMessage.UadpDataSetMessages.Count is not 3.");
//validate flags
Assert.AreEqual((uint)networkMessage0.NetworkMessageContentMask, messageSettings.NetworkMessageContentMask,
"UadpNetworkMessage.messageSettings.NetworkMessageContentMask is not valid.");
}
public void ValidateUdpPubSubConnectionCreateNetworkMessageSequenceNumber()
{
Assert.IsNotNull(m_udpPublisherConnection, "The UADP connection from standard configuration is invalid.");
//Arrange
WriterGroupDataType writerGroup0 = m_udpPublisherConnection.PubSubConnectionConfiguration.WriterGroups.First();
//Act
m_udpPublisherConnection.ResetSequenceNumber();
for (int i = 0; i < 10; i++)
{
// Create network message
var networkMessages = m_udpPublisherConnection.CreateNetworkMessages(writerGroup0, new WriterGroupPublishState());
Assert.IsNotNull(networkMessages, "connection.CreateNetworkMessages shall not return null");
var networkMessagesNetworkType = networkMessages.FirstOrDefault(net => net.IsMetaDataMessage == false);
Assert.IsNotNull(networkMessagesNetworkType, "connection.CreateNetworkMessages shall return only one network message");
UadpNetworkMessage networkMessage = networkMessagesNetworkType as UadpNetworkMessage;
Assert.IsNotNull(networkMessage, "networkMessageEncode should not be null");
//Assert
Assert.IsNotNull(networkMessage, "CreateNetworkMessage did not return an UadpNetworkMessage.");
Assert.AreEqual(networkMessage.SequenceNumber, i + 1, "UadpNetworkMessage.SequenceNumber for message {0} is not {0}.", i + 1);
//validate dataset message sequence number
Assert.IsNotNull(networkMessage.DataSetMessages, "CreateNetworkMessage did not return an UadpNetworkMessage.UadpDataSetMessages.");
Assert.IsTrue(networkMessage.DataSetMessages.Count == 3, "CreateNetworkMessage did not return 3 UadpNetworkMessage.UadpDataSetMessages.");
Assert.AreEqual(((UadpDataSetMessage)networkMessage.DataSetMessages[0]).SequenceNumber, i * 3 + 1, "UadpNetworkMessage.UadpDataSetMessages[0].SequenceNumber for message {0} is not {1}.", i + 1, i * 3 + 1);
Assert.AreEqual(((UadpDataSetMessage)networkMessage.DataSetMessages[1]).SequenceNumber, i * 3 + 2, "UadpNetworkMessage.UadpDataSetMessages[1].SequenceNumber for message {0} is not {1}.", i + 1, i * 3 + 2);
Assert.AreEqual(((UadpDataSetMessage)networkMessage.DataSetMessages[2]).SequenceNumber, i * 3 + 3, "UadpNetworkMessage.UadpDataSetMessages[2].SequenceNumber for message {0} is not {1}.", i + 1, i * 3 + 3);
}
}
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>
/// Create new instance of <see cref="MqttMetadataPublisher"/>.
/// </summary>
internal MqttMetadataPublisher(IMqttPubSubConnection parentConnection, WriterGroupDataType writerGroup, DataSetWriterDataType dataSetWriter,
double metaDataUpdateTime)
{
m_parentConnection = parentConnection;
m_writerGroup = writerGroup;
m_dataSetWriter = dataSetWriter;
m_intervalRunner = new IntervalRunner(dataSetWriter.DataSetWriterId, metaDataUpdateTime, CanPublish, PublishMessage);
}
public void ValidateOperational_2ToDisabled_0_Publisher()
{
UaPubSubApplication uaPubSubApplication = UaPubSubApplication.Create(publisherConfigurationFile);
UaPubSubConfigurator configurator = uaPubSubApplication.UaPubSubConfigurator;
// The hierarchy PubSub -> PubSubConnection -> PubSubWriterGroup -> DataSetWriter brought to [Disabled, Disabled, Disabled, Disabled]
PubSubConfigurationDataType pubSub = uaPubSubApplication.UaPubSubConfigurator.PubSubConfiguration;
PubSubConnectionDataType publisherConnection = uaPubSubApplication.UaPubSubConfigurator.PubSubConfiguration.Connections.First();
WriterGroupDataType writerGroup = publisherConnection.WriterGroups[0];
DataSetWriterDataType datasetWriter = writerGroup.DataSetWriters[0];
configurator.Disable(pubSub);
configurator.Disable(publisherConnection);
configurator.Disable(writerGroup);
configurator.Disable(datasetWriter);
PubSubState psState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(pubSub);
PubSubState conState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(publisherConnection);
PubSubState wgState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(writerGroup);
PubSubState dswState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(datasetWriter);
Assert.That(psState == PubSubState.Disabled, Is.True);
Assert.That(conState == PubSubState.Disabled, Is.True);
Assert.That(wgState == PubSubState.Disabled, Is.True);
Assert.That(dswState == PubSubState.Disabled, Is.True);
// The hierarchy PubSub -> PubSubConnection -> PubSubWriterGroup -> DataSetWriter brought to [Operational, Operational, Operational, Operational]
configurator.Enable(pubSub);
configurator.Enable(publisherConnection);
configurator.Enable(writerGroup);
configurator.Enable(datasetWriter);
psState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(pubSub);
conState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(publisherConnection);
wgState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(writerGroup);
dswState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(datasetWriter);
Assert.That(psState == PubSubState.Operational, Is.True);
Assert.That(conState == PubSubState.Operational, Is.True);
Assert.That(wgState == PubSubState.Operational, Is.True);
Assert.That(dswState == PubSubState.Operational, Is.True);
// The hierarchy PubSub -> PubSubConnection -> PubSubWriterGroup -> DataSetWriter brought to [Disabled, Disabled, Disabled, Disabled]
configurator.Disable(pubSub);
configurator.Disable(publisherConnection);
configurator.Disable(writerGroup);
configurator.Disable(datasetWriter);
psState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(pubSub);
conState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(publisherConnection);
wgState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(writerGroup);
dswState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(datasetWriter);
Assert.That(psState == PubSubState.Disabled, Is.True);
Assert.That(conState == PubSubState.Disabled, Is.True);
Assert.That(wgState == PubSubState.Disabled, Is.True);
Assert.That(dswState == PubSubState.Disabled, Is.True);
}
/// <summary>
/// Create new instance of <see cref="JsonNetworkMessage"/> as a DataSet message
/// </summary>
/// <param name="writerGroupConfiguration">The <see cref="WriterGroupDataType"/> configuration object that produced this message.</param>
/// <param name="jsonDataSetMessages"><see cref="JsonDataSetMessage"/> list as input</param>
public JsonNetworkMessage(WriterGroupDataType writerGroupConfiguration, List <JsonDataSetMessage> jsonDataSetMessages)
: base(writerGroupConfiguration, jsonDataSetMessages?.ConvertAll <UaDataSetMessage>(x => (UaDataSetMessage)x) ?? new List <UaDataSetMessage>())
{
MessageId = Guid.NewGuid().ToString();
MessageType = kDataSetMessageType;
DataSetClassId = string.Empty;
m_jsonNetworkMessageType = JSONNetworkMessageType.DataSetMessage;
}
/// <summary>
/// Create new instance of <see cref="JsonNetworkMessage"/> as a DataSetMetadata message
/// </summary>
public JsonNetworkMessage(WriterGroupDataType writerGroupConfiguration, DataSetMetaDataType metadata)
: base(writerGroupConfiguration, metadata)
{
MessageId = Guid.NewGuid().ToString();
MessageType = kMetaDataMessageType;
DataSetClassId = string.Empty;
m_jsonNetworkMessageType = JSONNetworkMessageType.DataSetMetaData;
}
/// <summary>
/// Initializes a new instance of the <see cref="UaPublisher"/> class.
/// </summary>
internal UaPublisher(IUaPubSubConnection pubSubConnection, WriterGroupDataType writerGroupConfiguration)
{
if (pubSubConnection == null)
{
throw new ArgumentNullException(nameof(pubSubConnection));
}
if (writerGroupConfiguration == null)
{
throw new ArgumentNullException(nameof(writerGroupConfiguration));
}
m_pubSubConnection = pubSubConnection;
m_writerGroupConfiguration = writerGroupConfiguration;
Initialize();
}
public void ValidateUaPublisherPublishIntevalDeviation(
[Values(100, 1000, 2000)] double publishingInterval,
[Values(20, 30)] double maxDeviation,
[Values(10)] int publishTimeInSecods)
{
//Arrange
s_publishTimes.Clear();
var mockConnection = new Mock <IUaPubSubConnection>();
mockConnection.Setup(x => x.CanPublish(It.IsAny <WriterGroupDataType>())).Returns(true);
mockConnection.Setup(x => x.CreateNetworkMessages(It.IsAny <WriterGroupDataType>(), It.IsAny <WriterGroupPublishState>()))
.Callback(() => s_publishTimes.Add(DateTime.Now));
WriterGroupDataType writerGroupDataType = new WriterGroupDataType();
writerGroupDataType.PublishingInterval = publishingInterval;
//Act
UaPublisher publisher = new UaPublisher(mockConnection.Object, writerGroupDataType);
publisher.Start();
//wait so many seconds
Thread.Sleep(publishTimeInSecods * 1000);
publisher.Stop();
int faultIndex = -1;
double faultDeviation = 0;
s_publishTimes = (from t in s_publishTimes
orderby t
select t).ToList();
//Assert
for (int i = 1; i < s_publishTimes.Count; i++)
{
double interval = s_publishTimes[i].Subtract(s_publishTimes[i - 1]).TotalMilliseconds;
double deviation = Math.Abs(publishingInterval - interval);
if (deviation >= maxDeviation && deviation > faultDeviation)
{
faultIndex = i;
faultDeviation = deviation;
}
}
Assert.IsTrue(faultIndex < 0, "publishingInterval={0}, maxDeviation={1}, publishTimeInSecods={2}, deviation[{3}] = {4} has maximum deviation", publishingInterval, maxDeviation, publishTimeInSecods, faultIndex, faultDeviation);
}
/// <summary>
/// Initializes a new instance of the <see cref="UaPublisher"/> class.
/// </summary>
internal UaPublisher(IUaPubSubConnection pubSubConnection, WriterGroupDataType writerGroupConfiguration)
{
if (pubSubConnection == null)
{
throw new ArgumentNullException(nameof(pubSubConnection));
}
if (writerGroupConfiguration == null)
{
throw new ArgumentNullException(nameof(writerGroupConfiguration));
}
m_pubSubConnection = pubSubConnection;
m_writerGroupConfiguration = writerGroupConfiguration;
m_writerGroupPublishState = new WriterGroupPublishState();
m_intervalRunner = new IntervalRunner(m_writerGroupConfiguration.Name, m_writerGroupConfiguration.PublishingInterval, CanPublish, PublishMessages);
}
public void MyTestInitialize()
{
// Create a publisher application
// todo refactor to use the MessagesHelper create configuration
string publisherConfigurationFile = Utils.GetAbsoluteFilePath(PublisherConfigurationFileName, true, true, false);
m_publisherApplication = UaPubSubApplication.Create(publisherConfigurationFile);
Assert.IsNotNull(m_publisherApplication, "m_publisherApplication should not be null");
// Get the publisher configuration
m_publisherConfiguration = m_publisherApplication.UaPubSubConfigurator.PubSubConfiguration;
Assert.IsNotNull(m_publisherConfiguration, "m_publisherConfiguration should not be null");
// Get first connection
Assert.IsNotNull(m_publisherConfiguration.Connections, "m_publisherConfiguration.Connections should not be null");
Assert.IsNotEmpty(m_publisherConfiguration.Connections, "m_publisherConfiguration.Connections should not be empty");
m_firstPublisherConnection = m_publisherApplication.PubSubConnections[0];
Assert.IsNotNull(m_firstPublisherConnection, "m_firstPublisherConnection should not be null");
// Read the first writer group
Assert.IsNotEmpty(m_publisherConfiguration.Connections[0].WriterGroups, "pubSubConfigConnection.WriterGroups should not be empty");
m_firstWriterGroup = m_publisherConfiguration.Connections[0].WriterGroups[0];
Assert.IsNotNull(m_firstWriterGroup, "m_firstWriterGroup should not be null");
Assert.IsNotNull(m_publisherConfiguration.PublishedDataSets, "m_publisherConfiguration.PublishedDataSets should not be null");
Assert.IsNotEmpty(m_publisherConfiguration.PublishedDataSets, "m_publisherConfiguration.PublishedDataSets should not be empty");
// Create a subscriber application
string subscriberConfigurationFile = Utils.GetAbsoluteFilePath(SubscriberConfigurationFileName, true, true, false);
m_subscriberApplication = UaPubSubApplication.Create(subscriberConfigurationFile);
Assert.IsNotNull(m_subscriberApplication, "m_subscriberApplication should not be null");
// Get the subscriber configuration
m_subscriberConfiguration = m_subscriberApplication.UaPubSubConfigurator.PubSubConfiguration;
Assert.IsNotNull(m_subscriberConfiguration, "m_subscriberConfiguration should not be null");
// Read the first reader group
m_firstReaderGroup = m_subscriberConfiguration.Connections[0].ReaderGroups[0];
Assert.IsNotNull(m_firstWriterGroup, "m_firstReaderGroup should not be null");
m_firstDataSetReaderType = GetFirstDataSetReader();
}
/// <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]);
}
public void ValidateUdpPubSubConnectionCreateNetworkMessage()
{
Assert.IsNotNull(m_udpPublisherConnection, "The UADP connection from standard configuration is invalid.");
//Arrange
WriterGroupDataType writerGroup0 = m_udpPublisherConnection.PubSubConnectionConfiguration.WriterGroups.First();
UadpWriterGroupMessageDataType messageSettings = ExtensionObject.ToEncodeable(writerGroup0.MessageSettings)
as UadpWriterGroupMessageDataType;
//Act
m_udpPublisherConnection.ResetSequenceNumber();
var networkMessages = m_udpPublisherConnection.CreateNetworkMessages(writerGroup0, new WriterGroupPublishState());
Assert.IsNotNull(networkMessages, "connection.CreateNetworkMessages shall not return null");
var networkMessagesNetworkType = networkMessages.FirstOrDefault(net => net.IsMetaDataMessage == false);
Assert.IsNotNull(networkMessagesNetworkType, "connection.CreateNetworkMessages shall return only one network message");
UadpNetworkMessage networkMessage0 = networkMessagesNetworkType as UadpNetworkMessage;
Assert.IsNotNull(networkMessage0, "networkMessageEncode should not be null");
//Assert
Assert.IsNotNull(networkMessage0, "CreateNetworkMessage did not return an UadpNetworkMessage.");
Assert.AreEqual(networkMessage0.DataSetClassId, Guid.Empty, "UadpNetworkMessage.DataSetClassId is invalid.");
Assert.AreEqual(networkMessage0.WriterGroupId, writerGroup0.WriterGroupId, "UadpNetworkMessage.WriterGroupId is invalid.");
Assert.AreEqual(networkMessage0.UADPVersion, 1, "UadpNetworkMessage.UADPVersion is invalid.");
Assert.AreEqual(networkMessage0.SequenceNumber, 1, "UadpNetworkMessage.SequenceNumber is not 1.");
Assert.AreEqual(networkMessage0.GroupVersion, messageSettings.GroupVersion, "UadpNetworkMessage.GroupVersion is not valid.");
Assert.AreEqual(networkMessage0.PublisherId, m_udpPublisherConnection.PubSubConnectionConfiguration.PublisherId.Value,
"UadpNetworkMessage.PublisherId is not valid.");
Assert.IsNotNull(networkMessage0.DataSetMessages, "UadpNetworkMessage.UadpDataSetMessages is null.");
Assert.AreEqual(networkMessage0.DataSetMessages.Count, 3, "UadpNetworkMessage.UadpDataSetMessages.Count is not 3.");
//validate flags
Assert.AreEqual((uint)networkMessage0.NetworkMessageContentMask, messageSettings.NetworkMessageContentMask,
"UadpNetworkMessage.messageSettings.NetworkMessageContentMask is not valid.");
}
public void MyTestInitialize()
{
// Create a publisher application
m_publisherApplication = UaPubSubApplication.Create(PublisherConfigurationFileName);
Assert.IsNotNull(m_publisherApplication, "m_publisherApplication should not be null");
// Get the publisher configuration
m_publisherConfiguration = m_publisherApplication.UaPubSubConfigurator.PubSubConfiguration;
Assert.IsNotNull(m_publisherConfiguration, "m_publisherConfiguration should not be null");
// Get first connection
Assert.IsNotNull(m_publisherConfiguration.Connections, "m_publisherConfiguration.Connections should not be null");
Assert.IsNotEmpty(m_publisherConfiguration.Connections, "m_publisherConfiguration.Connections should not be empty");
m_firstPublisherConnection = m_publisherApplication.PubSubConnections[0];
Assert.IsNotNull(m_firstPublisherConnection, "m_firstPublisherConnection should not be null");
// Read the first writer group
Assert.IsNotEmpty(m_publisherConfiguration.Connections[0].WriterGroups, "pubSubConfigConnection.WriterGroups should not be empty");
m_firstWriterGroup = m_publisherConfiguration.Connections[0].WriterGroups[0];
Assert.IsNotNull(m_firstWriterGroup, "m_firstWriterGroup should not be null");
Assert.IsNotNull(m_publisherConfiguration.PublishedDataSets, "m_publisherConfiguration.PublishedDataSets should not be null");
Assert.IsNotEmpty(m_publisherConfiguration.PublishedDataSets, "m_publisherConfiguration.PublishedDataSets should not be empty");
// Create a subscriber application
m_subscriberApplication = UaPubSubApplication.Create(SubscriberConfigurationFileName);
Assert.IsNotNull(m_subscriberApplication, "m_subscriberApplication should not be null");
// Get the subscriber configuration
m_subscriberConfiguration = m_subscriberApplication.UaPubSubConfigurator.PubSubConfiguration;
Assert.IsNotNull(m_subscriberConfiguration, "m_subscriberConfiguration should not be null");
// Read the first reader group
m_firstReaderGroup = m_subscriberConfiguration.Connections[0].ReaderGroups[0];
Assert.IsNotNull(m_firstWriterGroup, "m_firstReaderGroup should not be null");
m_firstDataSetReaderType = GetFirstDataSetReader();
}
/// <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>());
}
}
/// <summary>
/// Create the network message built from the provided writerGroupConfiguration
/// </summary>
/// <param name="writerGroupConfiguration"></param>
/// <returns></returns>
public override UaNetworkMessage CreateNetworkMessage(WriterGroupDataType writerGroupConfiguration)
{
UadpWriterGroupMessageDataType messageSettings = ExtensionObject.ToEncodeable(writerGroupConfiguration.MessageSettings)
as UadpWriterGroupMessageDataType;
if (messageSettings == null)
{
//Wrong configuration of writer group MessageSettings
return(null);
}
//Create list of dataSet messages to be sent
List <UadpDataSetMessage> dataSetMessages = new List <UadpDataSetMessage>();
foreach (DataSetWriterDataType dataSetWriter in writerGroupConfiguration.DataSetWriters)
{
//check if dataSetWriter enabled
if (dataSetWriter.Enabled)
{
DataSet dataSet = Application.DataCollector.CollectData(dataSetWriter.DataSetName);
if (dataSet != null)
{
UadpDataSetWriterMessageDataType dataSetMessageSettings =
ExtensionObject.ToEncodeable(dataSetWriter.MessageSettings) as
UadpDataSetWriterMessageDataType;
// check MessageSettings to see how to encode DataSet
if (dataSetMessageSettings != null)
{
UadpDataSetMessage uadpDataSetMessage = new UadpDataSetMessage(dataSet);
uadpDataSetMessage.DataSetWriterId = dataSetWriter.DataSetWriterId;
uadpDataSetMessage.SetMessageContentMask((UadpDataSetMessageContentMask)dataSetMessageSettings.DataSetMessageContentMask);
uadpDataSetMessage.SetFieldContentMask((DataSetFieldContentMask)dataSetWriter.DataSetFieldContentMask);
uadpDataSetMessage.SequenceNumber = (ushort)(Utils.IncrementIdentifier(ref m_dataSetSequenceNumber) % UInt16.MaxValue);
uadpDataSetMessage.ConfiguredSize = dataSetMessageSettings.ConfiguredSize;
uadpDataSetMessage.DataSetOffset = dataSetMessageSettings.DataSetOffset;
uadpDataSetMessage.TimeStamp = DateTime.UtcNow;
uadpDataSetMessage.Status = (ushort)StatusCodes.Good;
dataSetMessages.Add(uadpDataSetMessage);
}
}
}
}
//cancel send if no dataset message
if (dataSetMessages.Count == 0)
{
return(null);
}
UadpNetworkMessage uadpNetworkMessage = new UadpNetworkMessage(dataSetMessages);
uadpNetworkMessage.SetNetworkMessageContentMask((UadpNetworkMessageContentMask)messageSettings.NetworkMessageContentMask);
uadpNetworkMessage.WriterGroupId = writerGroupConfiguration.WriterGroupId;
// Network message header
uadpNetworkMessage.PublisherId = PubSubConnectionConfiguration.PublisherId.Value;
uadpNetworkMessage.SequenceNumber = (ushort)(Utils.IncrementIdentifier(ref m_sequenceNumber) % UInt16.MaxValue);
// Writer group header
uadpNetworkMessage.GroupVersion = messageSettings.GroupVersion;
uadpNetworkMessage.NetworkMessageNumber = 1; //only one network message per publish
return(uadpNetworkMessage);
}
public void ValidateUdpPubSubConnectionNetworkMessagePublishUnicast()
{
//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
string configurationFile = Utils.GetAbsoluteFilePath(PublisherConfigurationFileName, true, true, false);
PubSubConfigurationDataType publisherConfiguration = UaPubSubConfigurationHelper.LoadConfiguration(configurationFile);
Assert.IsNotNull(publisherConfiguration, "publisherConfiguration is null");
Assert.Greater(publisherConfiguration.Connections.Count, 1, "publisherConfiguration.Connection should be > 0");
IPAddress unicastIPAddress = localhost.Address;
Assert.IsNotNull(unicastIPAddress, "unicastIPAddress is null");
NetworkAddressUrlDataType publisherAddress = new NetworkAddressUrlDataType();
publisherAddress.Url = string.Format(UdpUrlFormat, Utils.UriSchemeOpcUdp, unicastIPAddress.ToString());
publisherConfiguration.Connections.First().Address = new ExtensionObject(publisherAddress);
//create publisher UaPubSubApplication with changed configuration settings
UaPubSubApplication publisherApplication = UaPubSubApplication.Create(publisherConfiguration);
Assert.IsNotNull(publisherApplication, "publisherApplication is null");
UdpPubSubConnection publisherConnection = publisherApplication.PubSubConnections.First() as UdpPubSubConnection;
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 unicast)
UdpClient udpUnicastClient = new UdpClientUnicast(localhost.Address, DiscoveryPortNo);
Assert.IsNotNull(udpUnicastClient, "udpUnicastClient is null");
udpUnicastClient.BeginReceive(new AsyncCallback(OnReceive), udpUnicastClient);
// prepare a network message
WriterGroupDataType writerGroup0 = publisherConnection.PubSubConnectionConfiguration.WriterGroups.First();
Assert.IsNotNull(writerGroup0, "writerGroup0 is null");
System.Collections.Generic.IList <UaNetworkMessage> networkMessages = publisherConnection.CreateNetworkMessages(writerGroup0, new WriterGroupPublishState());
Assert.IsNotNull(networkMessages, "connection.CreateNetworkMessages shall not return null");
//Act
publisherConnection.Start();
if (networkMessages != null)
{
foreach (UaNetworkMessage uaNetworkMessage in networkMessages)
{
if (uaNetworkMessage != null)
{
publisherConnection.PublishNetworkMessage(uaNetworkMessage);
}
}
}
//Assert
bool noMessageReceived = false;
if (!m_shutdownEvent.WaitOne(EstimatedPublishingTime))
{
noMessageReceived = true;
}
publisherConnection.Stop();
udpUnicastClient.Close();
udpUnicastClient.Dispose();
if (noMessageReceived == true)
{
Assert.Fail("The UDP message was not received");
}
}
/// <summary>
/// Create new instance of <see cref="JsonNetworkMessage"/>
/// </summary>
/// <param name="writerGroupConfiguration">The <see cref="WriterGroupDataType"/> confguration object that produced this message.</param>
/// <param name="jsonDataSetMessages"><see cref="JsonDataSetMessage"/> list as input</param>
public JsonNetworkMessage(WriterGroupDataType writerGroupConfiguration, List <JsonDataSetMessage> jsonDataSetMessages)
: base(writerGroupConfiguration, jsonDataSetMessages?.ConvertAll <UaDataSetMessage>(x => (UaDataSetMessage)x) ?? new List <UaDataSetMessage>())
{
MessageType = kDefaultMessageType;
DataSetClassId = string.Empty;
}
/// <summary> /// Create the network message built from the provided writerGroupConfiguration /// </summary> /// <param name="writerGroupConfiguration"></param> /// <returns></returns> public abstract UaNetworkMessage CreateNetworkMessage(WriterGroupDataType writerGroupConfiguration);
/// <summary>
/// Creates a PubSubConfiguration object programmatically.
/// </summary>
/// <returns></returns>
public static PubSubConfigurationDataType CreatePublisherConfiguration()
{
// Define a PubSub connection with PublisherId 100
PubSubConnectionDataType pubSubConnection1 = new PubSubConnectionDataType();
pubSubConnection1.Name = "UADPConnection1";
pubSubConnection1.Enabled = true;
pubSubConnection1.PublisherId = (UInt16)100;
pubSubConnection1.TransportProfileUri = Profiles.UadpTransport;
NetworkAddressUrlDataType address = new NetworkAddressUrlDataType();
// Specify the local Network interface name to be used
// e.g. address.NetworkInterface = "Ethernet";
// Leave empty to publish on all available local interfaces.
address.NetworkInterface = String.Empty;
address.Url = "opc.udp://239.0.0.1:4840";
pubSubConnection1.Address = new ExtensionObject(address);
#region Define WriterGroup1
WriterGroupDataType writerGroup1 = new WriterGroupDataType();
writerGroup1.Name = "WriterGroup 1";
writerGroup1.Enabled = true;
writerGroup1.WriterGroupId = 1;
writerGroup1.PublishingInterval = 5000;
writerGroup1.KeepAliveTime = 5000;
writerGroup1.MaxNetworkMessageSize = 1500;
writerGroup1.HeaderLayoutUri = "UADP-Cyclic-Fixed";
UadpWriterGroupMessageDataType messageSettings = new UadpWriterGroupMessageDataType()
{
DataSetOrdering = DataSetOrderingType.AscendingWriterId,
GroupVersion = 0,
NetworkMessageContentMask = (uint)(UadpNetworkMessageContentMask.PublisherId | UadpNetworkMessageContentMask.GroupHeader
| UadpNetworkMessageContentMask.WriterGroupId | UadpNetworkMessageContentMask.GroupVersion
| UadpNetworkMessageContentMask.NetworkMessageNumber | UadpNetworkMessageContentMask.SequenceNumber)
};
writerGroup1.MessageSettings = new ExtensionObject(messageSettings);
writerGroup1.TransportSettings = new ExtensionObject(new DatagramWriterGroupTransportDataType());
// Define DataSetWriter 'Simple'
DataSetWriterDataType dataSetWriter1 = new DataSetWriterDataType();
dataSetWriter1.Name = "Writer 1";
dataSetWriter1.DataSetWriterId = 1;
dataSetWriter1.Enabled = true;
dataSetWriter1.DataSetFieldContentMask = (uint)DataSetFieldContentMask.RawData;
dataSetWriter1.DataSetName = "Simple";
dataSetWriter1.KeyFrameCount = 1;
UadpDataSetWriterMessageDataType uadpDataSetWriterMessage = new UadpDataSetWriterMessageDataType()
{
ConfiguredSize = 32,
DataSetOffset = 15,
NetworkMessageNumber = 1,
DataSetMessageContentMask = (uint)(UadpDataSetMessageContentMask.Status | UadpDataSetMessageContentMask.SequenceNumber),
};
dataSetWriter1.MessageSettings = new ExtensionObject(uadpDataSetWriterMessage);
writerGroup1.DataSetWriters.Add(dataSetWriter1);
// Define DataSetWriter 'AllTypes'
DataSetWriterDataType dataSetWriter2 = new DataSetWriterDataType();
dataSetWriter2.Name = "Writer 2";
dataSetWriter2.DataSetWriterId = 2;
dataSetWriter2.Enabled = true;
dataSetWriter2.DataSetFieldContentMask = (uint)DataSetFieldContentMask.RawData;
dataSetWriter2.DataSetName = "AllTypes";
dataSetWriter2.KeyFrameCount = 1;
uadpDataSetWriterMessage = new UadpDataSetWriterMessageDataType()
{
ConfiguredSize = 32,
DataSetOffset = 47,
NetworkMessageNumber = 1,
DataSetMessageContentMask = (uint)(UadpDataSetMessageContentMask.Status | UadpDataSetMessageContentMask.SequenceNumber),
};
dataSetWriter2.MessageSettings = new ExtensionObject(uadpDataSetWriterMessage);
writerGroup1.DataSetWriters.Add(dataSetWriter2);
pubSubConnection1.WriterGroups.Add(writerGroup1);
#endregion
#region Define PublishedDataSet Simple
PublishedDataSetDataType publishedDataSetSimple = new PublishedDataSetDataType();
publishedDataSetSimple.Name = "Simple"; //name shall be unique in a configuration
// Define publishedDataSetSimple.DataSetMetaData
publishedDataSetSimple.DataSetMetaData = new DataSetMetaDataType();
publishedDataSetSimple.DataSetMetaData.DataSetClassId = Uuid.Empty;
publishedDataSetSimple.DataSetMetaData.Name = publishedDataSetSimple.Name;
publishedDataSetSimple.DataSetMetaData.Fields = new FieldMetaDataCollection()
{
new FieldMetaData()
{
Name = "BoolToggle",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Boolean,
DataType = DataTypeIds.Boolean,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Int32",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Int32,
DataType = DataTypeIds.Int32,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Int32Fast",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Int32,
DataType = DataTypeIds.Int32,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "DateTime",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.DateTime,
DataType = DataTypeIds.DateTime,
ValueRank = ValueRanks.Scalar
},
};
publishedDataSetSimple.DataSetMetaData.ConfigurationVersion = new ConfigurationVersionDataType()
{
MinorVersion = 1,
MajorVersion = 1
};
PublishedDataItemsDataType publishedDataSetSimpleSource = new PublishedDataItemsDataType();
publishedDataSetSimpleSource.PublishedData = new PublishedVariableDataTypeCollection();
//create PublishedData based on metadata names
foreach (var field in publishedDataSetSimple.DataSetMetaData.Fields)
{
publishedDataSetSimpleSource.PublishedData.Add(
new PublishedVariableDataType()
{
PublishedVariable = new NodeId(field.Name, PublishedValuesWrites.NamespaceIndexSimple),
AttributeId = Attributes.Value,
});
}
publishedDataSetSimple.DataSetSource = new ExtensionObject(publishedDataSetSimpleSource);
#endregion
#region Define PublishedDataSet AllTypes
PublishedDataSetDataType publishedDataSetAllTypes = new PublishedDataSetDataType();
publishedDataSetAllTypes.Name = "AllTypes"; //name shall be unique in a configuration
// Define publishedDataSetAllTypes.DataSetMetaData
publishedDataSetAllTypes.DataSetMetaData = new DataSetMetaDataType();
publishedDataSetAllTypes.DataSetMetaData.DataSetClassId = Uuid.Empty;
publishedDataSetAllTypes.DataSetMetaData.Name = publishedDataSetAllTypes.Name;
publishedDataSetAllTypes.DataSetMetaData.Fields = new FieldMetaDataCollection()
{
new FieldMetaData()
{
Name = "BoolToggle",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Boolean,
DataType = DataTypeIds.Boolean,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Byte",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Byte,
DataType = DataTypeIds.Byte,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Int16",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Int16,
DataType = DataTypeIds.Int16,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Int32",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Int32,
DataType = DataTypeIds.Int32,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "SByte",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.SByte,
DataType = DataTypeIds.SByte,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "UInt16",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.UInt16,
DataType = DataTypeIds.UInt16,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "UInt32",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.UInt32,
DataType = DataTypeIds.UInt32,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Float",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Float,
DataType = DataTypeIds.Float,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Double",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Double,
DataType = DataTypeIds.Double,
ValueRank = ValueRanks.Scalar
},
};
publishedDataSetAllTypes.DataSetMetaData.ConfigurationVersion = new ConfigurationVersionDataType()
{
MinorVersion = 1,
MajorVersion = 1
};
PublishedDataItemsDataType publishedDataSetAllTypesSource = new PublishedDataItemsDataType();
//create PublishedData based on metadata names
foreach (var field in publishedDataSetAllTypes.DataSetMetaData.Fields)
{
publishedDataSetAllTypesSource.PublishedData.Add(
new PublishedVariableDataType()
{
PublishedVariable = new NodeId(field.Name, PublishedValuesWrites.NamespaceIndexAllTypes),
AttributeId = Attributes.Value,
});
}
publishedDataSetAllTypes.DataSetSource = new ExtensionObject(publishedDataSetAllTypesSource);
#endregion
//create the PubSub configuration root object
PubSubConfigurationDataType pubSubConfiguration = new PubSubConfigurationDataType();
pubSubConfiguration.Connections = new PubSubConnectionDataTypeCollection()
{
pubSubConnection1
};
pubSubConfiguration.PublishedDataSets = new PublishedDataSetDataTypeCollection()
{
publishedDataSetSimple, publishedDataSetAllTypes
};
return(pubSubConfiguration);
}
/// <summary> /// Create the network messages built from the provided writerGroupConfiguration /// </summary> /// <param name="writerGroupConfiguration">The writer group configuration </param> /// <returns>A list of the <see cref="UaNetworkMessage"/> created from the provided writerGroupConfiguration.</returns> public abstract IList<UaNetworkMessage> CreateNetworkMessages(WriterGroupDataType writerGroupConfiguration);
/// <summary>
/// Create the list of network messages built from the provided writerGroupConfiguration
/// </summary>
public override IList <UaNetworkMessage> CreateNetworkMessages(WriterGroupDataType writerGroupConfiguration, WriterGroupPublishState state)
{
UadpWriterGroupMessageDataType messageSettings = ExtensionObject.ToEncodeable(writerGroupConfiguration.MessageSettings)
as UadpWriterGroupMessageDataType;
if (messageSettings == null)
{
//Wrong configuration of writer group MessageSettings
return(null);
}
DatagramWriterGroupTransportDataType transportSettings = ExtensionObject.ToEncodeable(writerGroupConfiguration.TransportSettings)
as DatagramWriterGroupTransportDataType;
if (transportSettings == null)
{
//Wrong configuration of writer group TransportSettings
return(null);
}
List <UaNetworkMessage> networkMessages = new List <UaNetworkMessage>();
//Create list of dataSet messages to be sent
List <UadpDataSetMessage> dataSetMessages = new List <UadpDataSetMessage>();
foreach (DataSetWriterDataType dataSetWriter in writerGroupConfiguration.DataSetWriters)
{
//check if dataSetWriter enabled
if (dataSetWriter.Enabled)
{
DataSet dataSet = CreateDataSet(dataSetWriter, state);
if (dataSet != null)
{
bool hasMetaDataChanged = state.HasMetaDataChanged(dataSetWriter, dataSet.DataSetMetaData);
if (hasMetaDataChanged)
{
// add metadata network message
networkMessages.Add(new UadpNetworkMessage(writerGroupConfiguration, dataSet.DataSetMetaData)
{
PublisherId = PubSubConnectionConfiguration.PublisherId.Value,
DataSetWriterId = dataSetWriter.DataSetWriterId
});
}
UadpDataSetWriterMessageDataType dataSetMessageSettings = ExtensionObject.ToEncodeable(dataSetWriter.MessageSettings) as
UadpDataSetWriterMessageDataType;
// check MessageSettings to see how to encode DataSet
if (dataSetMessageSettings != null)
{
UadpDataSetMessage uadpDataSetMessage = new UadpDataSetMessage(dataSet);
uadpDataSetMessage.DataSetWriterId = dataSetWriter.DataSetWriterId;
uadpDataSetMessage.SetMessageContentMask((UadpDataSetMessageContentMask)dataSetMessageSettings.DataSetMessageContentMask);
uadpDataSetMessage.SetFieldContentMask((DataSetFieldContentMask)dataSetWriter.DataSetFieldContentMask);
uadpDataSetMessage.SequenceNumber = (ushort)(Utils.IncrementIdentifier(ref m_dataSetSequenceNumber) % UInt16.MaxValue);
uadpDataSetMessage.ConfiguredSize = dataSetMessageSettings.ConfiguredSize;
uadpDataSetMessage.DataSetOffset = dataSetMessageSettings.DataSetOffset;
uadpDataSetMessage.Timestamp = DateTime.UtcNow;
uadpDataSetMessage.Status = StatusCodes.Good;
dataSetMessages.Add(uadpDataSetMessage);
state.OnMessagePublished(dataSetWriter, dataSet);
}
}
}
}
//cancel send if no dataset message
if (dataSetMessages.Count == 0)
{
return(networkMessages);
}
UadpNetworkMessage uadpNetworkMessage = new UadpNetworkMessage(writerGroupConfiguration, dataSetMessages);
uadpNetworkMessage.SetNetworkMessageContentMask((UadpNetworkMessageContentMask)messageSettings.NetworkMessageContentMask);
uadpNetworkMessage.WriterGroupId = writerGroupConfiguration.WriterGroupId;
// Network message header
uadpNetworkMessage.PublisherId = PubSubConnectionConfiguration.PublisherId.Value;
uadpNetworkMessage.SequenceNumber = (ushort)(Utils.IncrementIdentifier(ref m_sequenceNumber) % UInt16.MaxValue);
// Writer group header
uadpNetworkMessage.GroupVersion = messageSettings.GroupVersion;
uadpNetworkMessage.NetworkMessageNumber = 1; //only one network message per publish
networkMessages.Add(uadpNetworkMessage);
return(networkMessages);
}
/// <summary>
/// Create new instance of <see cref="JsonNetworkMessage"/>
/// </summary>
/// <param name="writerGroupConfiguration">The <see cref="WriterGroupDataType"/> confguration object that produced this message.</param>
/// <param name="jsonDataSetMessages"><see cref="JsonDataSetMessage"/> list as input</param>
public JsonNetworkMessage(WriterGroupDataType writerGroupConfiguration, List <UaDataSetMessage> jsonDataSetMessages) : base(writerGroupConfiguration, jsonDataSetMessages)
{
MessageType = kDefaultMessageType;
DataSetClassId = string.Empty;
}
/// <summary>
/// Create instance of <see cref="UaNetworkMessage"/>.
/// </summary>
/// <param name="writerGroupConfiguration">The <see cref="WriterGroupDataType"/> confguration object that produced this message.</param>
/// <param name="uaDataSetMessages">The containing data set messages.</param>
protected UaNetworkMessage(WriterGroupDataType writerGroupConfiguration, List <UaDataSetMessage> uaDataSetMessages)
{
WriterGroupConfiguration = writerGroupConfiguration;
m_uaDataSetMessages = uaDataSetMessages;
}