public void ValidateDisableOnNUll()
{
UaPubSubApplication uaPubSubApplication = UaPubSubApplication.Create(publisherConfigurationFile);
UaPubSubConfigurator configurator = uaPubSubApplication.UaPubSubConfigurator;
Assert.Throws <ArgumentException>(() => configurator.Disable(null), "The Disable method does not throw exception when called with null parameter.");
}
/// <summary>
/// Create new instance of <see cref="UdpPubSubConnection"/> from <see cref="PubSubConnectionDataType"/> configuration data
/// </summary>
public UdpPubSubConnection(UaPubSubApplication uaPubSubApplication, PubSubConnectionDataType pubSubConnectionDataType)
: base(uaPubSubApplication, pubSubConnectionDataType)
{
m_transportProtocol = TransportProtocol.UADP;
Utils.Trace("UdpPubSubConnection with name '{0}' was created.", pubSubConnectionDataType.Name);
}
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();
}
public void ValidateDisableOnNonExisting()
{
UaPubSubApplication uaPubSubApplication = UaPubSubApplication.Create(publisherConfigurationFile);
UaPubSubConfigurator configurator = uaPubSubApplication.UaPubSubConfigurator;
PubSubConfigurationDataType nonExisting = new PubSubConfigurationDataType();
Assert.Throws <ArgumentException>(() => configurator.Disable(nonExisting), "The Disable method does not throw exception when called with non existing parameter.");
}
public void ValidateOperational_2ToDisabled_0_Reader()
{
UaPubSubApplication uaPubSubApplication = UaPubSubApplication.Create(SubscriberConfigurationFileName);
UaPubSubConfigurator configurator = uaPubSubApplication.UaPubSubConfigurator;
// The hierarchy PubSub -> PubSubConnection -> PubSubReaderGroup -> DataSetReader brought to [Disabled, Disabled, Disabled, Disabled]
PubSubConfigurationDataType pubSub = uaPubSubApplication.UaPubSubConfigurator.PubSubConfiguration;
PubSubConnectionDataType subscriberConnection = uaPubSubApplication.UaPubSubConfigurator.PubSubConfiguration.Connections[0];
ReaderGroupDataType readerGroup = subscriberConnection.ReaderGroups[0];
DataSetReaderDataType datasetReader = readerGroup.DataSetReaders[0];
configurator.Disable(pubSub);
configurator.Disable(subscriberConnection);
configurator.Disable(readerGroup);
configurator.Disable(datasetReader);
PubSubState psState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(pubSub);
PubSubState conState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(subscriberConnection);
PubSubState rgState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(readerGroup);
PubSubState dsrState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(datasetReader);
Assert.That(psState == PubSubState.Disabled, Is.True);
Assert.That(conState == PubSubState.Disabled, Is.True);
Assert.That(rgState == PubSubState.Disabled, Is.True);
Assert.That(dsrState == PubSubState.Disabled, Is.True);
// The hierarchy PubSub -> PubSubConnection -> PubSubReaderGroup -> DataSetReader brought to [Operational, Operational, Operational, Operational]
configurator.Enable(pubSub);
configurator.Enable(subscriberConnection);
configurator.Enable(readerGroup);
configurator.Enable(datasetReader);
psState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(pubSub);
conState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(subscriberConnection);
rgState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(readerGroup);
dsrState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(datasetReader);
Assert.That(psState == PubSubState.Operational, Is.True);
Assert.That(conState == PubSubState.Operational, Is.True);
Assert.That(rgState == PubSubState.Operational, Is.True);
Assert.That(dsrState == PubSubState.Operational, Is.True);
// The hierarchy PubSub -> PubSubConnection -> PubSubReaderGroup -> DataSetReader brought to [Disabled, Disabled, Disabled, Disabled]
configurator.Disable(pubSub);
configurator.Disable(subscriberConnection);
configurator.Disable(readerGroup);
configurator.Disable(datasetReader);
psState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(pubSub);
conState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(subscriberConnection);
rgState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(readerGroup);
dsrState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(datasetReader);
Assert.That(psState == PubSubState.Disabled, Is.True);
Assert.That(conState == PubSubState.Disabled, Is.True);
Assert.That(rgState == PubSubState.Disabled, Is.True);
Assert.That(dsrState == PubSubState.Disabled, Is.True);
}
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);
}
public void ValidateDisableOnDisabled()
{
UaPubSubApplication uaPubSubApplication = UaPubSubApplication.Create(publisherConfigurationFile);
UaPubSubConfigurator configurator = uaPubSubApplication.UaPubSubConfigurator;
PubSubConfigurationDataType pubSub = uaPubSubApplication.UaPubSubConfigurator.PubSubConfiguration;
configurator.Disable(pubSub);
Assert.AreEqual((StatusCode)StatusCodes.BadInvalidState, configurator.Disable(pubSub));
}
public void MyTestInitialize()
{
// Create a publisher application
m_uaPublisherApplication = UaPubSubApplication.Create(PublisherConfigurationFileName);
Assert.IsNotNull(m_uaPublisherApplication, "m_publisherApplication should not be null");
// Get the publisher configuration
m_publisherConfiguration = m_uaPublisherApplication.UaPubSubConfigurator.PubSubConfiguration;
Assert.IsNotNull(m_publisherConfiguration, "m_publisherConfiguration should not be null");
// Get publisher 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_uadpPublisherConnection = m_uaPublisherApplication.PubSubConnections[0] as UadpPubSubConnection;
Assert.IsNotNull(m_uadpPublisherConnection, "m_uadpPublisherConnection should not be null");
}
public static void Main(string[] args)
{
Console.WriteLine("OPC UA Console Reference Publisher");
try
{
// Define the configuration of UA Publisher application
PubSubConfigurationDataType pubSubConfiguration = CreatePublisherConfiguration();
// Create the UA Publisher application
using (UaPubSubApplication uaPubSubApplication = UaPubSubApplication.Create(pubSubConfiguration))
{
// Start values simulator
PublishedValuesWrites valuesSimulator = new PublishedValuesWrites(uaPubSubApplication);
valuesSimulator.Start();
// Start the publisher
uaPubSubApplication.Start();
Console.WriteLine("Publisher Started. Press Ctrl-C to exit...");
ManualResetEvent quitEvent = new ManualResetEvent(false);
try
{
Console.CancelKeyPress += (sender, eArgs) =>
{
quitEvent.Set();
eArgs.Cancel = true;
};
}
catch
{
}
// wait for timeout or Ctrl-C
quitEvent.WaitOne();
}
Console.WriteLine("Program ended.");
Console.WriteLine("Press any key to finish...");
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void MyTestInitialize()
{
// Create a publisher application
string configurationFile = Utils.GetAbsoluteFilePath(PublisherConfigurationFileName, true, true, false);
m_uaPublisherApplication = UaPubSubApplication.Create(configurationFile);
Assert.IsNotNull(m_uaPublisherApplication, "m_publisherApplication should not be null");
// Get the publisher configuration
m_publisherConfiguration = m_uaPublisherApplication.UaPubSubConfigurator.PubSubConfiguration;
Assert.IsNotNull(m_publisherConfiguration, "m_publisherConfiguration should not be null");
// Get publisher 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_udpPublisherConnection = m_uaPublisherApplication.PubSubConnections.First() as UdpPubSubConnection;
Assert.IsNotNull(m_udpPublisherConnection, "m_uadpPublisherConnection should not be null");
}
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();
}
public void ValidateUaPubSubApplicationCreate()
{
// Arrange
UaPubSubApplication uaPubSubApplication = UaPubSubApplication.Create(m_pubSubConfiguration);
// Assert
Assert.IsTrue(uaPubSubApplication.PubSubConnections != null, "uaPubSubApplication.PubSubConnections collection is null");
Assert.AreEqual(2, uaPubSubApplication.PubSubConnections.Count, "uaPubSubApplication.PubSubConnections count");
UaPubSubConnection connection = uaPubSubApplication.PubSubConnections[0] as UaPubSubConnection;
Assert.IsTrue(connection.Publishers != null, "connection.Publishers is null");
Assert.IsTrue(connection.Publishers.Count == 1, "connection.Publishers count is not 2");
int index = 0;
foreach (IUaPublisher publisher in connection.Publishers)
{
Assert.IsTrue(publisher != null, "connection.Publishers[{0}] is null", index);
Assert.IsTrue(publisher.PubSubConnection == connection, "connection.Publishers[{0}].PubSubConnection is not set correctly", index);
Assert.IsTrue(publisher.WriterGroupConfiguration.WriterGroupId == m_pubSubConfiguration.Connections[0].WriterGroups[index].WriterGroupId, "connection.Publishers[{0}].WriterGroupConfiguration is not set correctly", index);
index++;
}
}
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();
}
public void ValidateUdpPubSubConnectionNetworkMessageReceiveFromBroadcast()
{
// Arrange
var localhost = GetFirstNic();
Assert.IsNotNull(localhost, "localhost is null");
Assert.IsNotNull(localhost.Address, "localhost.Address is null");
string configurationFile = Utils.GetAbsoluteFilePath(m_subscriberConfigurationFileName, true, true, false);
PubSubConfigurationDataType subscriberConfiguration = UaPubSubConfigurationHelper.LoadConfiguration(configurationFile);
Assert.IsNotNull(subscriberConfiguration, "subscriberConfiguration is null");
NetworkAddressUrlDataType subscriberAddress = new NetworkAddressUrlDataType();
subscriberAddress.Url = string.Format(kUdpUrlFormat, Utils.UriSchemeOpcUdp, localhost.Address.ToString());
subscriberConfiguration.Connections.First().Address = new ExtensionObject(subscriberAddress);
UaPubSubApplication subscriberApplication = UaPubSubApplication.Create(subscriberConfiguration);
Assert.IsNotNull(subscriberApplication, "subscriberApplication is null");
UdpPubSubConnection subscriberConnection = subscriberApplication.PubSubConnections.First() as UdpPubSubConnection;
Assert.IsNotNull(subscriberConnection, "subscriberConnection is null");
subscriberApplication.RawDataReceived += RawDataReceived;
configurationFile = Utils.GetAbsoluteFilePath(m_publisherConfigurationFileName, true, true, false);
PubSubConfigurationDataType publisherConfiguration = UaPubSubConfigurationHelper.LoadConfiguration(configurationFile);
Assert.IsNotNull(publisherConfiguration, "publisherConfiguration is null");
IPAddress broadcastIPAddress = GetFirstNicLastIPByteChanged(255);
Assert.IsNotNull(broadcastIPAddress, "broadcastIPAddress is null");
NetworkAddressUrlDataType publisherAddress = new NetworkAddressUrlDataType();
publisherAddress.Url = string.Format(kUdpUrlFormat, Utils.UriSchemeOpcUdp, broadcastIPAddress.ToString());
publisherConfiguration.Connections.First().Address = new ExtensionObject(publisherAddress);
UaPubSubApplication publisherApplication = UaPubSubApplication.Create(publisherConfiguration);
Assert.IsNotNull(publisherApplication, "publisherApplication is null");
UdpPubSubConnection publisherConnection = publisherApplication.PubSubConnections.First() as UdpPubSubConnection;
Assert.IsNotNull(publisherConnection, "publisherConnection is null");
//Act
subscriberConnection.Start();
m_shutdownEvent = new ManualResetEvent(false);
m_sentBytes = PrepareData(publisherConnection);
// first physical network ip is mandatory on UdpClientBroadcast as parameter
UdpClient udpBroadcastClient = new UdpClientBroadcast(localhost.Address, kDiscoveryPortNo, UsedInContext.Publisher);
Assert.IsNotNull(udpBroadcastClient, "udpBroadcastClient is null");
IPEndPoint remoteEndPoint = new IPEndPoint(broadcastIPAddress, kDiscoveryPortNo);
int sentBytesLen = udpBroadcastClient.Send(m_sentBytes, m_sentBytes.Length, remoteEndPoint);
Assert.AreEqual(sentBytesLen, m_sentBytes.Length, "Sent bytes size not equal to published bytes size!");
Thread.Sleep(kEstimatedPublishingTime);
// Assert
if (!m_shutdownEvent.WaitOne(kEstimatedPublishingTime))
{
Assert.Fail("Subscriber broadcast error ... published data not received");
}
subscriberConnection.Stop();
}
public void ValidateMqttLocalPubSubConnectionWithJson(
[Values((byte)1, (UInt16)1, (UInt32)1, (UInt64)1, "abc")] object publisherId,
[Values(0, 10000)] double metaDataUpdateTime)
{
RestartMosquitto("mosquitto");
//Arrange
UInt16 writerGroupId = 1;
string mqttLocalBrokerUrl = "mqtt://localhost:1883";
ITransportProtocolConfiguration mqttConfiguration = new MqttClientProtocolConfiguration(version: EnumMqttProtocolVersion.V500);
JsonNetworkMessageContentMask jsonNetworkMessageContentMask = JsonNetworkMessageContentMask.NetworkMessageHeader
| JsonNetworkMessageContentMask.PublisherId
| JsonNetworkMessageContentMask.DataSetMessageHeader;
JsonDataSetMessageContentMask jsonDataSetMessageContentMask = JsonDataSetMessageContentMask.None;
DataSetFieldContentMask dataSetFieldContentMask = DataSetFieldContentMask.None;
DataSetMetaDataType[] dataSetMetaDataArray = new DataSetMetaDataType[]
{
MessagesHelper.CreateDataSetMetaData1("DataSet1"),
MessagesHelper.CreateDataSetMetaData2("DataSet2"),
MessagesHelper.CreateDataSetMetaData3("DataSet3"),
MessagesHelper.CreateDataSetMetaDataAllTypes("DataSet4")
};
PubSubConfigurationDataType publisherConfiguration = MessagesHelper.CreatePublisherConfiguration(
Profiles.PubSubMqttJsonTransport,
mqttLocalBrokerUrl, publisherId: publisherId, writerGroupId: writerGroupId,
jsonNetworkMessageContentMask: jsonNetworkMessageContentMask,
jsonDataSetMessageContentMask: jsonDataSetMessageContentMask,
dataSetFieldContentMask: dataSetFieldContentMask,
dataSetMetaDataArray: dataSetMetaDataArray, nameSpaceIndexForData: NamespaceIndexAllTypes,
metaDataUpdateTime);
Assert.IsNotNull(publisherConfiguration, "publisherConfiguration should not be null");
// Configure the mqtt publisher configuration with the MQTTbroker
PubSubConnectionDataType mqttPublisherConnection = MessagesHelper.GetConnection(publisherConfiguration, publisherId);
Assert.IsNotNull(mqttPublisherConnection, "The MQTT publisher connection is invalid.");
mqttPublisherConnection.ConnectionProperties = mqttConfiguration.ConnectionProperties;
Assert.IsNotNull(mqttPublisherConnection.ConnectionProperties, "The MQTT publisher connection properties are not valid.");
// Create publisher application for multiple datasets
UaPubSubApplication publisherApplication = UaPubSubApplication.Create(publisherConfiguration);
MessagesHelper.LoadData(publisherApplication, NamespaceIndexAllTypes);
IUaPubSubConnection publisherConnection = publisherApplication.PubSubConnections.First();
Assert.IsNotNull(publisherConnection, "Publisher first connection should not be null");
Assert.IsNotNull(publisherConfiguration.Connections.First(), "publisherConfiguration first connection should not be null");
Assert.IsNotNull(publisherConfiguration.Connections.First().WriterGroups.First(), "publisherConfiguration first writer group of first connection should not be null");
var networkMessages = publisherConnection.CreateNetworkMessages(publisherConfiguration.Connections.First().WriterGroups.First(), new WriterGroupPublishState());
Assert.IsNotNull(networkMessages, "connection.CreateNetworkMessages shall not return null");
Assert.GreaterOrEqual(networkMessages.Count, 1, "connection.CreateNetworkMessages shall have at least one network message");
List <JsonNetworkMessage> uaNetworkMessages = MessagesHelper.GetJsonUaDataNetworkMessages(networkMessages.Cast <JsonNetworkMessage>().ToList());
Assert.IsNotNull(uaNetworkMessages, "Json ua-data entries are missing from configuration!");
List <JsonNetworkMessage> uaMetaDataNetworkMessages = MessagesHelper.GetJsonUaMetaDataNetworkMessages(networkMessages.Cast <JsonNetworkMessage>().ToList());
Assert.IsNotNull(uaMetaDataNetworkMessages, "Json ua-metadata entries are missing from configuration!");
bool hasDataSetWriterId = (jsonNetworkMessageContentMask & JsonNetworkMessageContentMask.DataSetMessageHeader) != 0 &&
(jsonDataSetMessageContentMask & JsonDataSetMessageContentMask.DataSetWriterId) != 0;
PubSubConfigurationDataType subscriberConfiguration = MessagesHelper.CreateSubscriberConfiguration(
Profiles.PubSubMqttJsonTransport,
mqttLocalBrokerUrl, publisherId: publisherId, writerGroupId: writerGroupId, setDataSetWriterId: hasDataSetWriterId,
jsonNetworkMessageContentMask: jsonNetworkMessageContentMask,
jsonDataSetMessageContentMask: jsonDataSetMessageContentMask,
dataSetFieldContentMask: dataSetFieldContentMask,
dataSetMetaDataArray: dataSetMetaDataArray, nameSpaceIndexForData: NamespaceIndexAllTypes);
Assert.IsNotNull(subscriberConfiguration, "subscriberConfiguration should not be null");
// Create subscriber application for multiple datasets
UaPubSubApplication subscriberApplication = UaPubSubApplication.Create(subscriberConfiguration);
Assert.IsNotNull(subscriberApplication, "subscriberApplication should not be null");
Assert.IsNotNull(subscriberApplication.PubSubConnections.First(), "subscriberConfiguration first connection should not be null");
// Configure the mqtt subscriber configuration with the MQTTbroker
PubSubConnectionDataType mqttSubcriberConnection = MessagesHelper.GetConnection(subscriberConfiguration, publisherId);
Assert.IsNotNull(mqttSubcriberConnection, "The MQTT subscriber connection is invalid.");
mqttSubcriberConnection.ConnectionProperties = mqttConfiguration.ConnectionProperties;
Assert.IsNotNull(mqttSubcriberConnection.ConnectionProperties, "The MQTT subscriber connection properties are not valid.");
var dataSetReaders = subscriberApplication.PubSubConnections.First().GetOperationalDataSetReaders();
Assert.IsNotNull(dataSetReaders, "dataSetReaders should not be null");
IUaPubSubConnection subscriberConnection = subscriberApplication.PubSubConnections.First();
Assert.IsNotNull(subscriberConnection, "Subscriber first connection should not be null");
//Act
// it will signal if the mqtt message was received from local ip
m_uaDataShutdownEvent = new ManualResetEvent(false);
// it will signal if the mqtt metadata message was received from local ip
m_uaMetaDataShutdownEvent = new ManualResetEvent(false);
// it will signal if the changed configuration message was received on local ip
m_uaConfigurationUpdateEvent = new ManualResetEvent(false);
subscriberApplication.DataReceived += UaPubSubApplication_DataReceived;
subscriberApplication.MetaDataReceived += UaPubSubApplication_MetaDataReceived;
subscriberApplication.ConfigurationUpdating += UaPubSubApplication_ConfigurationUpdating;
subscriberConnection.Start();
publisherConnection.Start();
//Assert
if (!m_uaDataShutdownEvent.WaitOne(EstimatedPublishingTime))
{
Assert.Fail("The JSON message was not received");
}
if (!m_uaMetaDataShutdownEvent.WaitOne(EstimatedPublishingTime))
{
Assert.Fail("The JSON metadata message was not received");
}
subscriberConnection.Stop();
publisherConnection.Stop();
}
public void ValidateDisabled_0ToPause_1_Publisher()
{
UaPubSubApplication uaPubSubApplication = UaPubSubApplication.Create(PublisherConfigurationFileName);
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[0];
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);
// Bring connection to Enabled
configurator.Enable(publisherConnection);
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.Paused, Is.True);
Assert.That(wgState == PubSubState.Disabled, Is.True);
Assert.That(dswState == PubSubState.Disabled, Is.True);
// Bring writerGroup to Enabled
configurator.Enable(writerGroup);
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.Paused, Is.True);
Assert.That(wgState == PubSubState.Paused, Is.True);
Assert.That(dswState == PubSubState.Disabled, Is.True);
// Bring datasetWriter to Enabled
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.Disabled, Is.True);
Assert.That(conState == PubSubState.Paused, Is.True);
Assert.That(wgState == PubSubState.Paused, Is.True);
Assert.That(dswState == PubSubState.Paused, Is.True);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="pubSubApplication"></param>
public PublishedValuesWrites(UaPubSubApplication uaPubSubApplication)
{
m_publishedDataSets = uaPubSubApplication.UaPubSubConfigurator.PubSubConfiguration.PublishedDataSets;
m_dataStore = uaPubSubApplication.DataStore;
}
public void ValidateMqttLocalPubSubConnectionWithUadp(
[Values((byte)1, (UInt16)1, (UInt32)1, (UInt64)1, "abc")] object publisherId)
{
RestartMosquitto("mosquitto");
//Arrange
UInt16 writerGroupId = 1;
string mqttLocalBrokerUrl = "mqtt://localhost:1883";
ITransportProtocolConfiguration mqttConfiguration = new MqttClientProtocolConfiguration(version: EnumMqttProtocolVersion.V500);
UadpNetworkMessageContentMask uadpNetworkMessageContentMask = UadpNetworkMessageContentMask.PublisherId
| UadpNetworkMessageContentMask.WriterGroupId
| UadpNetworkMessageContentMask.PayloadHeader;
UadpDataSetMessageContentMask uadpDataSetMessageContentMask = UadpDataSetMessageContentMask.None;
DataSetFieldContentMask dataSetFieldContentMask = DataSetFieldContentMask.None;
DataSetMetaDataType[] dataSetMetaDataArray = new DataSetMetaDataType[]
{
MessagesHelper.CreateDataSetMetaData1("DataSet1"),
MessagesHelper.CreateDataSetMetaData2("DataSet2"),
MessagesHelper.CreateDataSetMetaData3("DataSet3")
};
PubSubConfigurationDataType publisherConfiguration = MessagesHelper.CreatePublisherConfiguration(
Profiles.PubSubMqttUadpTransport,
mqttLocalBrokerUrl, publisherId: publisherId, writerGroupId: writerGroupId,
uadpNetworkMessageContentMask: uadpNetworkMessageContentMask,
uadpDataSetMessageContentMask: uadpDataSetMessageContentMask,
dataSetFieldContentMask: dataSetFieldContentMask,
dataSetMetaDataArray: dataSetMetaDataArray, nameSpaceIndexForData: kNamespaceIndexAllTypes);
Assert.IsNotNull(publisherConfiguration, "publisherConfiguration should not be null");
// Configure the mqtt publisher configuration with the MQTTbroker
PubSubConnectionDataType mqttPublisherConnection = MessagesHelper.GetConnection(publisherConfiguration, publisherId);
Assert.IsNotNull(mqttPublisherConnection, "The MQTT publisher connection is invalid.");
mqttPublisherConnection.ConnectionProperties = mqttConfiguration.ConnectionProperties;
Assert.IsNotNull(mqttPublisherConnection.ConnectionProperties, "The MQTT publisher connection properties are not valid.");
// Create publisher application for multiple datasets
UaPubSubApplication publisherApplication = UaPubSubApplication.Create(publisherConfiguration);
MessagesHelper.LoadData(publisherApplication, kNamespaceIndexAllTypes);
IUaPubSubConnection publisherConnection = publisherApplication.PubSubConnections.First();
Assert.IsNotNull(publisherConnection, "Publisher first connection should not be null");
Assert.IsNotNull(publisherConfiguration.Connections.First(), "publisherConfiguration first connection should not be null");
Assert.IsNotNull(publisherConfiguration.Connections.First().WriterGroups.First(), "publisherConfiguration first writer group of first connection should not be null");
var networkMessages = publisherConnection.CreateNetworkMessages(publisherConfiguration.Connections.First().WriterGroups.First(), new WriterGroupPublishState());
Assert.IsNotNull(networkMessages, "connection.CreateNetworkMessages shall not return null");
Assert.GreaterOrEqual(networkMessages.Count, 1, "connection.CreateNetworkMessages shall have at least one network message");
UadpNetworkMessage uaNetworkMessage = networkMessages[0] as UadpNetworkMessage;
Assert.IsNotNull(uaNetworkMessage, "networkMessageEncode should not be null");
bool hasDataSetWriterId = (uadpNetworkMessageContentMask & UadpNetworkMessageContentMask.PayloadHeader) != 0;
PubSubConfigurationDataType subscriberConfiguration = MessagesHelper.CreateSubscriberConfiguration(
Profiles.PubSubMqttUadpTransport,
mqttLocalBrokerUrl, publisherId: publisherId, writerGroupId: writerGroupId, setDataSetWriterId: hasDataSetWriterId,
uadpNetworkMessageContentMask: uadpNetworkMessageContentMask,
uadpDataSetMessageContentMask: uadpDataSetMessageContentMask,
dataSetFieldContentMask: dataSetFieldContentMask,
dataSetMetaDataArray: dataSetMetaDataArray, nameSpaceIndexForData: kNamespaceIndexAllTypes);
Assert.IsNotNull(subscriberConfiguration, "subscriberConfiguration should not be null");
// Create subscriber application for multiple datasets
UaPubSubApplication subscriberApplication = UaPubSubApplication.Create(subscriberConfiguration);
Assert.IsNotNull(subscriberApplication, "subscriberApplication should not be null");
Assert.IsNotNull(subscriberApplication.PubSubConnections.First(), "subscriberConfiguration first connection should not be null");
// Configure the mqtt subscriber configuration with the MQTTbroker
PubSubConnectionDataType mqttSubcriberConnection = MessagesHelper.GetConnection(subscriberConfiguration, publisherId);
Assert.IsNotNull(mqttSubcriberConnection, "The MQTT subscriber connection is invalid.");
mqttSubcriberConnection.ConnectionProperties = mqttConfiguration.ConnectionProperties;
Assert.IsNotNull(mqttSubcriberConnection.ConnectionProperties, "The MQTT subscriber connection properties are not valid.");
var dataSetReaders = subscriberApplication.PubSubConnections.First().GetOperationalDataSetReaders();
Assert.IsNotNull(dataSetReaders, "dataSetReaders should not be null");
IUaPubSubConnection subscriberConnection = subscriberApplication.PubSubConnections.First();
Assert.IsNotNull(subscriberConnection, "Subscriber first connection should not be null");
//Act
// it will signal if the uadp message was received from local ip
m_uaDataShutdownEvent = new ManualResetEvent(false);
subscriberApplication.DataReceived += UaPubSubApplication_DataReceived;
subscriberConnection.Start();
publisherConnection.Start();
//Assert
if (!m_uaDataShutdownEvent.WaitOne(kEstimatedPublishingTime))
{
Assert.Fail("The UADP message was not received");
}
subscriberConnection.Stop();
publisherConnection.Stop();
}
/// <summary>
/// Create new instance of <see cref="UadpPubSubConnection"/> from <see cref="PubSubConnectionDataType"/> configuration data
/// </summary>
/// <param name="uaPubSubApplication"></param>
/// <param name="pubSubConnectionDataType"></param>
public UadpPubSubConnection(UaPubSubApplication uaPubSubApplication, PubSubConnectionDataType pubSubConnectionDataType)
: base(uaPubSubApplication, pubSubConnectionDataType)
{
m_transportProtocol = TransportProtocol.UADP;
}
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");
}
}
public void ValidateUdpPubSubConnectionNetworkMessagePublishBroadcast()
{
//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");
IPAddress broadcastIPAddress = GetFirstNicLastIPByteChanged(255);
Assert.IsNotNull(broadcastIPAddress, "broadcastIPAddress is null");
NetworkAddressUrlDataType publisherAddress = new NetworkAddressUrlDataType();
publisherAddress.Url = "opc.udp://" + broadcastIPAddress.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");
UdpPubSubConnection publisherConnection = publisherApplication.PubSubConnections[0] 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 broadcast (simulate a subscriber broadcast)
UdpClient udpBroadcastClient = new UdpClientBroadcast(localhost.Address, 4840, UsedInContext.Subscriber);
udpBroadcastClient.BeginReceive(new AsyncCallback(OnReceive), udpBroadcastClient);
// prepare a network message
WriterGroupDataType writerGroup0 = publisherConnection.PubSubConnectionConfiguration.WriterGroups.First();
IList <UaNetworkMessage> networkMessages = publisherConnection.CreateNetworkMessages(writerGroup0);
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
if (!m_shutdownEvent.WaitOne(EstimatedPublishingTime))
{
Assert.Fail("The UADP message was not received");
}
publisherConnection.Stop();
udpBroadcastClient.Close();
udpBroadcastClient.Dispose();
}
public void ValidateUaPubSubApplicationCreateNullFilePath()
{
Assert.Throws <ArgumentException>(() => UaPubSubApplication.Create((string)null), "Calling Create with null parameter shall throw error");
}
public void ValidateUaPubSubApplicationCreateNullPubSubConfigurationDataType()
{
Assert.DoesNotThrow(() => UaPubSubApplication.Create((PubSubConfigurationDataType)null), "Calling Create with null parameter shall not throw error");
}
public void ValidateUadpPubSubConnectionNetworkMessageReceiveFromUnicast()
{
// Arrange
var localhost = GetFirstNic();
Assert.IsNotNull(localhost, "localhost is null");
Assert.IsNotNull(localhost.Address, "localhost.Address is null");
PubSubConfigurationDataType subscriberConfiguration = UaPubSubConfigurationHelper.LoadConfiguration(SubscriberConfigurationFileName);
Assert.IsNotNull(subscriberConfiguration, "subscriberConfiguration is null");
NetworkAddressUrlDataType subscriberAddress = new NetworkAddressUrlDataType();
subscriberAddress.Url = "opc.udp://" + localhost.Address.ToString() + ":4840";
subscriberConfiguration.Connections[0].Address = new ExtensionObject(subscriberAddress);
UaPubSubApplication subscriberApplication = UaPubSubApplication.Create(subscriberConfiguration);
Assert.IsNotNull(subscriberApplication, "subscriberApplication is null");
UadpPubSubConnection subscriberConnection = subscriberApplication.PubSubConnections[0] as UadpPubSubConnection;
Assert.IsNotNull(subscriberConnection, "subscriberConnection is null");
subscriberConnection.UadpMessageReceived += DataReceived;
PubSubConfigurationDataType publisherConfiguration = UaPubSubConfigurationHelper.LoadConfiguration(PublisherConfigurationFileName);
Assert.IsNotNull(publisherConfiguration, "publisherConfiguration is null");
NetworkAddressUrlDataType publisherAddress = new NetworkAddressUrlDataType();
publisherAddress.Url = "opc.udp://" + localhost.Address.ToString() + ":4840";
publisherConfiguration.Connections[0].Address = new ExtensionObject(publisherAddress);
UaPubSubApplication publisherApplication = UaPubSubApplication.Create(publisherConfiguration);
Assert.IsNotNull(publisherApplication, "publisherApplication is null");
UadpPubSubConnection publisherConnection = publisherApplication.PubSubConnections[0] as UadpPubSubConnection;
Assert.IsNotNull(publisherConnection, "publisherConnection is null");
//Act
subscriberConnection.Start();
m_shutdownEvent = new ManualResetEvent(false);
// physical network ip is mandatory on UdpClientUnicast as parameter
UdpClient udpUnicastClient = new UdpClientUnicast(localhost.Address, 4840);
Assert.IsNotNull(udpUnicastClient, "udpUnicastClient is null");
// first physical network ip = unicast address ip
IPEndPoint remoteEndPoint = new IPEndPoint(localhost.Address, 4840);
Assert.IsNotNull(remoteEndPoint, "remoteEndPoint is null");
m_sentBytes = PrepareData(publisherConnection);
int sentBytesLen = udpUnicastClient.Send(m_sentBytes, m_sentBytes.Length, remoteEndPoint);
Assert.AreEqual(sentBytesLen, m_sentBytes.Length, "Sent bytes size not equal to published bytes size!");
Thread.Sleep(EstimatedPublishingTime);
// Assert
if (!m_shutdownEvent.WaitOne(EstimatedPublishingTime))
{
Assert.Fail("Subscriber unicast error ... published data not received");
}
subscriberConnection.Stop();
}
public static void Main(string[] args)
{
Console.WriteLine("OPC UA Console Reference Subscriber");
// command line options
bool showHelp = false;
bool useMqttJson = true;
bool useMqttUadp = false;
bool useUdpUadp = false;
string subscriberUrl = null;
Mono.Options.OptionSet options = new Mono.Options.OptionSet {
{ "h|help", "Show usage information", v => showHelp = v != null },
{ "m|mqtt_json", "Use MQTT with Json encoding Profile. This is the default option.", v => useMqttJson = v != null },
{ "p|mqtt_uadp", "Use MQTT with UADP encoding Profile.", v => useMqttUadp = v != null },
{ "u|udp_uadp", "Use UDP with UADP encoding Profile", v => useUdpUadp = v != null },
{ "url|subscriber_url=", "Subscriber Url Address", v => subscriberUrl = v },
};
IList <string> extraArgs = null;
try
{
extraArgs = options.Parse(args);
if (extraArgs.Count > 0)
{
foreach (string extraArg in extraArgs)
{
Console.WriteLine("Error: Unknown option: {0}", extraArg);
showHelp = true;
}
}
}
catch (OptionException e)
{
Console.WriteLine(e.Message);
showHelp = true;
}
if (showHelp)
{
Console.WriteLine("Usage: dotnet ConsoleReferenceSubscriber.dll [OPTIONS]");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
try
{
InitializeLog();
PubSubConfigurationDataType pubSubConfiguration = null;
if (useUdpUadp)
{
// set default UDP Subscriber Url to local multicast if not sent in args.
if (string.IsNullOrEmpty(subscriberUrl))
{
subscriberUrl = "opc.udp://239.0.0.1:4840";
}
// Create configuration using UDP protocol and UADP Encoding
pubSubConfiguration = CreateSubscriberConfiguration_UdpUadp(subscriberUrl);
Console.WriteLine("The Pubsub Connection was initialized using UDP & UADP Profile.");
}
else
{
// set default MQTT Broker Url to localhost if not sent in args.
if (string.IsNullOrEmpty(subscriberUrl))
{
subscriberUrl = "mqtt://localhost:1883";
}
if (useMqttUadp)
{
// Create configuration using MQTT protocol and UADP Encoding
pubSubConfiguration = CreateSubscriberConfiguration_MqttUadp(subscriberUrl);
Console.WriteLine("The PubSub Connection was initialized using MQTT & UADP Profile.");
}
else
{
// Create configuration using MQTT protocol and JSON Encoding
pubSubConfiguration = CreateSubscriberConfiguration_MqttJson(subscriberUrl);
Console.WriteLine("The PubSub Connection was initialized using MQTT & JSON Profile.");
}
}
// Create the UA Publisher application
using (UaPubSubApplication uaPubSubApplication = UaPubSubApplication.Create(pubSubConfiguration))
{
// Subscribte to RawDataReceived event
uaPubSubApplication.RawDataReceived += UaPubSubApplication_RawDataReceived;
// Subscribte to DataReceived event
uaPubSubApplication.DataReceived += UaPubSubApplication_DataReceived;
// Subscribte to MetaDataReceived event
uaPubSubApplication.MetaDataReceived += UaPubSubApplication_MetaDataDataReceived;
uaPubSubApplication.ConfigurationUpdating += UaPubSubApplication_ConfigurationUpdating;
// Start the publisher
uaPubSubApplication.Start();
Console.WriteLine("Subscriber Started. Press Ctrl-C to exit...");
ManualResetEvent quitEvent = new ManualResetEvent(false);
try
{
Console.CancelKeyPress += (sender, eArgs) => {
quitEvent.Set();
eArgs.Cancel = true;
};
}
catch
{
}
// wait for timeout or Ctrl-C
quitEvent.WaitOne();
}
Console.WriteLine("Program ended.");
Console.WriteLine("Press any key to finish...");
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void ValidateUdpPubSubConnectionNetworkMessageReceiveFromDiscoveryResponse()
{
// Arrange
var localhost = GetFirstNic();
Assert.IsNotNull(localhost, "localhost is null");
Assert.IsNotNull(localhost.Address, "localhost.Address is null");
//discovery IP address 224.0.2.14
IPAddress multicastIPAddress = new IPAddress(new byte[4] {
224, 0, 2, 14
});
Assert.IsNotNull(multicastIPAddress, "multicastIPAddress is null");
string configurationFile = Utils.GetAbsoluteFilePath(SubscriberConfigurationFileName, true, true, false);
PubSubConfigurationDataType subscriberConfiguration = UaPubSubConfigurationHelper.LoadConfiguration(configurationFile);
Assert.IsNotNull(subscriberConfiguration, "subscriberConfiguration is null");
NetworkAddressUrlDataType subscriberAddress = new NetworkAddressUrlDataType();
subscriberAddress.Url = string.Format(UdpUrlFormat, Utils.UriSchemeOpcUdp, multicastIPAddress.ToString());
subscriberConfiguration.Connections[0].Address = new ExtensionObject(subscriberAddress);
UaPubSubApplication subscriberApplication = UaPubSubApplication.Create(subscriberConfiguration);
Assert.IsNotNull(subscriberApplication, "subscriberApplication is null");
UdpPubSubConnection subscriberConnection = subscriberApplication.PubSubConnections.First() as UdpPubSubConnection;
Assert.IsNotNull(subscriberConnection, "subscriberConnection is null");
subscriberApplication.RawDataReceived += RawDataReceived;
configurationFile = Utils.GetAbsoluteFilePath(PublisherConfigurationFileName, true, true, false);
PubSubConfigurationDataType publisherConfiguration = UaPubSubConfigurationHelper.LoadConfiguration(configurationFile);
Assert.IsNotNull(publisherConfiguration, "publisherConfiguration is null");
NetworkAddressUrlDataType publisherAddress = new NetworkAddressUrlDataType();
publisherAddress.Url = string.Format(UdpUrlFormat, Utils.UriSchemeOpcUdp, multicastIPAddress.ToString());
publisherConfiguration.Connections.First().Address = new ExtensionObject(publisherAddress);
UaPubSubApplication publisherApplication = UaPubSubApplication.Create(publisherConfiguration);
Assert.IsNotNull(publisherApplication, "publisherApplication is null");
UdpPubSubConnection publisherConnection = publisherApplication.PubSubConnections.First() as UdpPubSubConnection;
Assert.IsNotNull(publisherConnection, "publisherConnection is null");
//Act
subscriberConnection.Start();
m_shutdownEvent = new ManualResetEvent(false);
m_sentBytes = PrepareData(publisherConnection, UdpConnectionType.Discovery);
// first physical network ip is mandatory on UdpClientMulticast as parameter, for multicast publisher the port must not be 4840
UdpClient udpMulticastClient = new UdpClientMulticast(localhost.Address, multicastIPAddress, 0);
Assert.IsNotNull(udpMulticastClient, "udpMulticastClient is null");
IPEndPoint remoteEndPoint = new IPEndPoint(multicastIPAddress, DiscoveryPortNo);
int sentBytesLen = udpMulticastClient.Send(m_sentBytes, m_sentBytes.Length, remoteEndPoint);
Assert.AreEqual(sentBytesLen, m_sentBytes.Length, "Sent bytes size not equal to published bytes size!");
Thread.Sleep(EstimatedPublishingTime);
// Assert
if (!m_shutdownEvent.WaitOne(EstimatedPublishingTime))
{
Assert.Fail("Subscriber multicast error ... published data not received");
}
subscriberConnection.Stop();
}
public void ValidateUdpPubSubConnectionNetworkMessageDiscoveryPublish()
{
//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(m_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");
//discovery IP adress 224.0.2.14
IPAddress[] multicastIPAddresses = Dns.GetHostAddresses(kUdpDiscoveryIp);
IPAddress multicastIPAddress = multicastIPAddresses.First();
Assert.IsNotNull(multicastIPAddress, "multicastIPAddress is null");
NetworkAddressUrlDataType publisherAddress = new NetworkAddressUrlDataType();
publisherAddress.Url = string.Format(kUdpUrlFormat, Utils.UriSchemeOpcUdp, multicastIPAddress.ToString());
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");
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 multicast)
UdpClient udpMulticastClient = new UdpClientMulticast(localhost.Address, multicastIPAddress, kDiscoveryPortNo);
udpMulticastClient.BeginReceive(new AsyncCallback(OnReceive), udpMulticastClient);
// prepare a network message
WriterGroupDataType writerGroup0 = publisherConnection.PubSubConnectionConfiguration.WriterGroups.First();
List <UInt16> dataSetWriterIds = new List <UInt16>();
foreach (DataSetWriterDataType dataSetWriterDataType in writerGroup0.DataSetWriters)
{
dataSetWriterIds.Add(dataSetWriterDataType.DataSetWriterId);
}
IList <UaNetworkMessage> networkMessages = publisherConnection.CreateDataSetMetaDataNetworkMessages(dataSetWriterIds.ToArray());
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(kEstimatedPublishingTime))
{
noMessageReceived = true;
}
publisherConnection.Stop();
udpMulticastClient.Close();
udpMulticastClient.Dispose();
if (noMessageReceived)
{
Assert.Fail("The UDP message was not received");
}
}
public void ValidateUdpClientCreatorGetUdpClients()
{
// Create a publisher application
UaPubSubApplication publisherApplication = UaPubSubApplication.Create(PublisherConfigurationFileName);
Assert.IsNotNull(publisherApplication, "m_publisherApplication should not be null");
// Get the publisher configuration
PubSubConfigurationDataType publisherConfiguration = publisherApplication.UaPubSubConfigurator.PubSubConfiguration;
Assert.IsNotNull(publisherConfiguration, "m_publisherConfiguration should not be null");
// Check publisher connections
Assert.IsNotNull(publisherConfiguration.Connections, "m_publisherConfiguration.Connections should not be null");
Assert.IsNotEmpty(publisherConfiguration.Connections, "m_publisherConfiguration.Connections should not be empty");
PubSubConnectionDataType publisherConnection1 = publisherConfiguration.Connections[0];
Assert.IsNotNull(publisherConnection1, "publisherConnection1 should not be null");
NetworkAddressUrlDataType networkAddressUrlState1 = ExtensionObject.ToEncodeable(publisherConnection1.Address)
as NetworkAddressUrlDataType;
Assert.IsNotNull(networkAddressUrlState1, "networkAddressUrlState1 is null");
IPEndPoint configuredEndPoint1 = UdpClientCreator.GetEndPoint(networkAddressUrlState1.Url);
Assert.IsNotNull(configuredEndPoint1, "configuredEndPoint1 is null");
List <UdpClient> udpClients1 = UdpClientCreator.GetUdpClients(UsedInContext.Publisher, networkAddressUrlState1, configuredEndPoint1);
Assert.IsNotNull(udpClients1, "udpClients1 is null");
Assert.IsNotEmpty(udpClients1, "udpClients1 is empty");
UdpClient udpClient1 = udpClients1[0];
Assert.IsTrue(udpClient1 is UdpClientMulticast, "udpClient1 was configured as UdpClientMulticast");
Assert.IsNotNull(udpClient1.Client.LocalEndPoint, "udpClient1 IP address is empty");
PubSubConnectionDataType publisherConnection2 = publisherConfiguration.Connections[1];
Assert.IsNotNull(publisherConnection2, "publisherConnection2 should not be null");
NetworkAddressUrlDataType networkAddressUrlState2 = ExtensionObject.ToEncodeable(publisherConnection2.Address)
as NetworkAddressUrlDataType;
Assert.IsNotNull(networkAddressUrlState2, "networkAddressUrlState2 is null");
IPEndPoint configuredEndPoint2 = UdpClientCreator.GetEndPoint(networkAddressUrlState2.Url);
Assert.IsNotNull(configuredEndPoint2, "configuredEndPoint2 is null");
List <UdpClient> udpClients2 = UdpClientCreator.GetUdpClients(UsedInContext.Publisher, networkAddressUrlState2, configuredEndPoint2);
Assert.IsNotNull(udpClients2, "udpClients2 is null");
Assert.IsNotEmpty(udpClients2, "udpClients2 is empty");
UdpClient udpClient2 = udpClients2[0];
Assert.IsTrue(udpClient2 is UdpClientBroadcast, "udpClient2 was configured as UdpClientBroadcast");
Assert.IsNotNull(udpClient2.Client.LocalEndPoint, "udpClient2 IP address is empty");
IPEndPoint udpClientEndPoint1 = udpClient1.Client.LocalEndPoint as IPEndPoint;
Assert.IsNotNull(udpClientEndPoint1, "udpClientEndPoint1 could not be cast to IPEndPoint");
IPEndPoint udpClientEndPoint2 = udpClient2.Client.LocalEndPoint as IPEndPoint;
Assert.IsNotNull(udpClientEndPoint2, "udpClientEndPoint2 could not be cast to IPEndPoint");
Assert.AreEqual(udpClientEndPoint1.Address.ToString(), udpClientEndPoint2.Address.ToString(), "udpClientEndPoint1 IP address: {0} should match udpClientEndPoint2 IP Address {1}", udpClientEndPoint1.Address.ToString(), udpClientEndPoint2.Address.ToString());
Assert.AreNotEqual(udpClientEndPoint1.Port, udpClientEndPoint2.Port, "udpClientEndPoint1 port number: {0} should not match udpClientEndPoint1 port number: {1}", udpClientEndPoint1.Port, udpClientEndPoint2.Port);
}
