/// <summary>
/// Adds a node to be monitored. If there is no session to the endpoint, one is created.
/// If there is no spubscription with the requested publishing interval, one is created.
/// </summary>
/// <param name="publishingInterval"></param>
/// <param name="samplingInterval"></param>
/// <param name="nodeId"></param>
public void AddNodeForMonitoring(int publishingInterval, int samplingInterval, NodeId nodeId)
{
_opcSessionSemaphore.Wait();
try
{
if (PublisherShutdownInProgress)
{
return;
}
// check if there is already a subscription with the same publishing interval, which could be used to monitor the node
OpcSubscription opcSubscription = OpcSubscriptions.FirstOrDefault(s => s.RequestedPublishingInterval == publishingInterval);
// if there was none found, create one
if (opcSubscription == null)
{
opcSubscription = new OpcSubscription(publishingInterval);
OpcSubscriptions.Add(opcSubscription);
Trace($"AddNodeForMonitoring: No matching subscription with publishing interval of {publishingInterval} found'. Requested to create a new one.");
}
// if it is already there, we just ignore it, otherwise we add a new item to monitor.
OpcMonitoredItem opcMonitoredItem = opcSubscription.OpcMonitoredItems.FirstOrDefault(m => m.StartNodeId == nodeId);
// if there was none found, create one
if (opcMonitoredItem == null)
{
// add a new item to monitor
opcMonitoredItem = new OpcMonitoredItem(nodeId, EndpointUri)
{
RequestedSamplingInterval = samplingInterval
};
opcSubscription.OpcMonitoredItems.Add(opcMonitoredItem);
Trace($"AddNodeForMonitoring: Added item with nodeId '{nodeId.ToString()}' for monitoring.");
// Start publishing.
Task.Run(async() => await ConnectAndMonitor());
}
}
finally
{
_opcSessionSemaphore.Release();
}
}
/// <summary>
/// Create the publisher data structures to manage OPC sessions, subscriptions and monitored items.
/// </summary>
/// <returns></returns>
public static async Task <bool> CreateOpcPublishingDataAsync()
{
// create a list to manage sessions, subscriptions and monitored items.
try
{
await PublisherNodeConfigurationSemaphore.WaitAsync().ConfigureAwait(false);
await OpcSessionsListSemaphore.WaitAsync().ConfigureAwait(false);
var uniqueEndpointUrls = _nodePublishingConfiguration.Select(n => n.EndpointUrl).Distinct();
foreach (var endpointUrl in uniqueEndpointUrls)
{
// create new session info.
OpcSession opcSession = new OpcSession(endpointUrl, _nodePublishingConfiguration.Where(n => n.EndpointUrl == endpointUrl).First().UseSecurity, OpcSessionCreationTimeout);
// create a subscription for each distinct publishing inverval
var nodesDistinctPublishingInterval = _nodePublishingConfiguration.Where(n => n.EndpointUrl.Equals(endpointUrl, StringComparison.OrdinalIgnoreCase)).Select(c => c.OpcPublishingInterval).Distinct();
foreach (var nodeDistinctPublishingInterval in nodesDistinctPublishingInterval)
{
// create a subscription for the publishing interval and add it to the session.
OpcSubscription opcSubscription = new OpcSubscription(nodeDistinctPublishingInterval);
// add all nodes with this OPC publishing interval to this subscription.
var nodesWithSamePublishingInterval = _nodePublishingConfiguration.Where(n => n.EndpointUrl.Equals(endpointUrl, StringComparison.OrdinalIgnoreCase)).Where(n => n.OpcPublishingInterval == nodeDistinctPublishingInterval);
foreach (var nodeInfo in nodesWithSamePublishingInterval)
{
// differentiate if NodeId or ExpandedNodeId format is used
if (nodeInfo.ExpandedNodeId != null)
{
// create a monitored item for the node, we do not have the namespace index without a connected session.
// so request a namespace update.
OpcMonitoredItem opcMonitoredItem = new OpcMonitoredItem(nodeInfo.ExpandedNodeId, opcSession.EndpointUrl, nodeInfo.OpcSamplingInterval, nodeInfo.DisplayName);
opcSubscription.OpcMonitoredItems.Add(opcMonitoredItem);
Interlocked.Increment(ref NodeConfigVersion);
}
else if (nodeInfo.NodeId != null)
{
// create a monitored item for the node with the configured or default sampling interval
OpcMonitoredItem opcMonitoredItem = new OpcMonitoredItem(nodeInfo.NodeId, opcSession.EndpointUrl, nodeInfo.OpcSamplingInterval, nodeInfo.DisplayName);
opcSubscription.OpcMonitoredItems.Add(opcMonitoredItem);
Interlocked.Increment(ref NodeConfigVersion);
}
else
{
Logger.Error($"Node {nodeInfo.OriginalId} has an invalid format. Skipping...");
}
}
// add subscription to session.
opcSession.OpcSubscriptions.Add(opcSubscription);
}
// add session.
OpcSessions.Add(opcSession);
}
}
catch (Exception e)
{
Logger.Fatal(e, "Creation of the internal OPC data managment structures failed. Exiting...");
return(false);
}
finally
{
OpcSessionsListSemaphore.Release();
PublisherNodeConfigurationSemaphore.Release();
}
return(true);
}
/// <summary>
/// Adds a event node to be monitored. If there is no subscription with the requested publishing interval,
/// one is created.
/// </summary>
public async Task <HttpStatusCode> AddEventNodeForMonitoringAsync(NodeId nodeId, ExpandedNodeId expandedNodeId,
int?opcPublishingInterval, int?opcSamplingInterval, string displayName,
int?heartbeatInterval, bool?skipFirst, CancellationToken ct, IotCentralItemPublishMode?iotCentralItemPublishMode,
PublishNodesMethodRequestModel publishEventsMethodData)
{
string logPrefix = "AddEventNodeForMonitoringAsync:";
bool sessionLocked = false;
try
{
sessionLocked = await LockSessionAsync().ConfigureAwait(false);
if (!sessionLocked || ct.IsCancellationRequested)
{
return(HttpStatusCode.Gone);
}
// check if there is already a subscription with the same publishing interval, which can be used to monitor the node
int opcPublishingIntervalForNode = opcPublishingInterval ?? OpcPublishingIntervalDefault;
IOpcSubscription opcEventSubscription = OpcEventSubscriptions.FirstOrDefault(s => s.RequestedPublishingInterval == opcPublishingIntervalForNode);
// if there was none found, create one
if (opcEventSubscription == null)
{
if (opcPublishingInterval == null)
{
Logger.Information($"{logPrefix} No matching subscription with default publishing interval found.");
Logger.Information($"Create a new subscription with a default publishing interval.");
}
else
{
Logger.Information($"{logPrefix} No matching subscription with publishing interval of {opcPublishingInterval} found.");
Logger.Information($"Create a new subscription with a publishing interval of {opcPublishingInterval}.");
}
opcEventSubscription = new OpcSubscription(opcPublishingInterval);
OpcEventSubscriptions.Add(opcEventSubscription);
}
// create objects for publish check
ExpandedNodeId expandedNodeIdCheck = expandedNodeId;
NodeId nodeIdCheck = nodeId;
if (State == SessionState.Connected)
{
if (expandedNodeId == null)
{
string namespaceUri = _namespaceTable.ToArray().ElementAtOrDefault(nodeId.NamespaceIndex);
expandedNodeIdCheck = new ExpandedNodeId(nodeId.Identifier, nodeId.NamespaceIndex, namespaceUri, 0);
}
if (nodeId == null)
{
nodeIdCheck = new NodeId(expandedNodeId.Identifier, (ushort)(_namespaceTable.GetIndex(expandedNodeId.NamespaceUri)));
}
}
// if it is already published, we do nothing, else we create a new monitored event item
if (!IsEventNodePublishedInSessionInternal(nodeIdCheck, expandedNodeIdCheck))
{
OpcMonitoredItem opcMonitoredItem = null;
EncryptedNetworkCredential encryptedCredentials = null;
if (publishEventsMethodData.OpcAuthenticationMode == OpcAuthenticationMode.UsernamePassword)
{
if (string.IsNullOrWhiteSpace(publishEventsMethodData.UserName) && string.IsNullOrWhiteSpace(publishEventsMethodData.Password))
{
throw new ArgumentException($"If {nameof(publishEventsMethodData.OpcAuthenticationMode)} is set to '{OpcAuthenticationMode.UsernamePassword}', you have to specify '{nameof(publishEventsMethodData.UserName)}' and/or '{nameof(publishEventsMethodData.Password)}'.");
}
encryptedCredentials = await EncryptedNetworkCredential.FromPlainCredential(publishEventsMethodData.UserName, publishEventsMethodData.Password);
}
// add a new item to monitor
if (expandedNodeId == null)
{
opcMonitoredItem = new OpcMonitoredItem(new EventConfigurationModel(publishEventsMethodData.EndpointId, publishEventsMethodData.EndpointName, publishEventsMethodData.EndpointUrl, publishEventsMethodData.UseSecurity, publishEventsMethodData.OpcAuthenticationMode ?? OpcAuthenticationMode.Anonymous, encryptedCredentials,
publishEventsMethodData.OpcEvents[0].Id, publishEventsMethodData.OpcEvents[0].DisplayName, publishEventsMethodData.OpcEvents[0].SelectClauses,
publishEventsMethodData.OpcEvents[0].WhereClause, publishEventsMethodData.OpcEvents[0].IotCentralEventPublishMode), EndpointId, EndpointUrl);;
}
else
{
opcMonitoredItem = new OpcMonitoredItem(new EventConfigurationModel(publishEventsMethodData.EndpointId, publishEventsMethodData.EndpointName, publishEventsMethodData.EndpointUrl, publishEventsMethodData.UseSecurity, publishEventsMethodData.OpcAuthenticationMode ?? OpcAuthenticationMode.Anonymous, encryptedCredentials,
expandedNodeId.ToString(), publishEventsMethodData.OpcEvents[0].DisplayName, publishEventsMethodData.OpcEvents[0].SelectClauses,
publishEventsMethodData.OpcEvents[0].WhereClause, publishEventsMethodData.OpcEvents[0].IotCentralEventPublishMode), EndpointId, EndpointUrl);
}
opcEventSubscription.OpcMonitoredItems.Add(opcMonitoredItem);
Interlocked.Increment(ref NodeConfigVersion);
Logger.Debug($"{logPrefix} Added event item with nodeId '{(expandedNodeId == null ? nodeId.ToString() : expandedNodeId.ToString())}' for monitoring.");
// trigger the actual OPC communication with the server to be done
ConnectAndMonitorSession.Set();
return(HttpStatusCode.Accepted);
}
else
{
Logger.Debug($"{logPrefix} Node with Id '{(expandedNodeId == null ? nodeId.ToString() : expandedNodeId.ToString())}' is already monitored.");
}
}
catch (Exception e)
{
Logger.Error(e, $"{logPrefix} Exception while trying to add node '{(expandedNodeId == null ? nodeId.ToString() : expandedNodeId.ToString())}' for monitoring.");
return(HttpStatusCode.InternalServerError);
}
finally
{
if (sessionLocked)
{
ReleaseSession();
}
}
return(HttpStatusCode.OK);
}
public static void Main(string[] args)
{
var opcTraceInitialized = false;
try
{
var shouldShowHelp = false;
// command line options configuration
Mono.Options.OptionSet options = new Mono.Options.OptionSet {
// Publishing configuration options
{ "pf|publishfile=", $"the filename to configure the nodes to publish.\nDefault: '{NodesToPublishAbsFilenameDefault}'", (string p) => NodesToPublishAbsFilename = p },
{ "sd|shopfloordomain=", $"the domain of the shopfloor. if specified this domain is appended (delimited by a ':' to the 'ApplicationURI' property when telemetry is sent to IoTHub.\n" +
"The value must follow the syntactical rules of a DNS hostname.\nDefault: not set", (string s) => {
Regex domainNameRegex = new Regex("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$");
if (domainNameRegex.IsMatch(s))
{
ShopfloorDomain = s;
}
else
{
throw new OptionException("The shopfloor domain is not a valid DNS hostname.", "shopfloordomain");
}
} },
{ "sw|sessionconnectwait=", $"specify the wait time in seconds publisher is trying to connect to disconnected endpoints and starts monitoring unmonitored items\nMin: 10\nDefault: {PublisherSessionConnectWaitSec}", (int i) => {
if (i > 10)
{
PublisherSessionConnectWaitSec = i;
}
else
{
throw new OptionException("The sessionconnectwait must be greater than 10 sec", "sessionconnectwait");
}
} },
{ "vc|verboseconsole=", $"the output of publisher is shown on the console.\nDefault: {VerboseConsole}", (bool b) => VerboseConsole = b },
// IoTHub specific options
{ "ih|iothubprotocol=", $"the protocol to use for communication with Azure IoTHub (allowed values: {string.Join(", ", Enum.GetNames(IotHubProtocol.GetType()))}).\nDefault: {Enum.GetName(IotHubProtocol.GetType(), IotHubProtocol)}",
(Microsoft.Azure.Devices.Client.TransportType p) => IotHubProtocol = p },
{ "ms|iothubmessagesize=", $"the max size of a message which can be send to IoTHub. when telemetry of this size is available it will be sent.\n0 will enforce immediate send when telemetry is available\nMin: 0\nMax: 256 * 1024\nDefault: {_MaxSizeOfIoTHubMessageBytes}", (uint u) => {
if (u >= 0 && u <= 256 * 1024)
{
_MaxSizeOfIoTHubMessageBytes = u;
}
else
{
throw new OptionException("The iothubmessagesize must be in the range between 1 and 256*1024.", "iothubmessagesize");
}
} },
{ "si|iothubsendinterval=", $"the interval in seconds when telemetry should be send to IoTHub. If 0, then only the iothubmessagesize parameter controls when telemetry is sent.\nDefault: '{_DefaultSendIntervalSeconds}'", (int i) => {
if (i >= 0)
{
_DefaultSendIntervalSeconds = i;
}
else
{
throw new OptionException("The iothubsendinterval must be larger or equal 0.", "iothubsendinterval");
}
} },
// opc server configuration options
{ "lf|logfile=", $"the filename of the logfile to use.\nDefault: './Logs/<applicationname>.log.txt'", (string l) => LogFileName = l },
{ "pn|portnum=", $"the server port of the publisher OPC server endpoint.\nDefault: {PublisherServerPort}", (ushort p) => PublisherServerPort = p },
{ "pa|path=", $"the enpoint URL path part of the publisher OPC server endpoint.\nDefault: '{PublisherServerPath}'", (string a) => PublisherServerPath = a },
{ "lr|ldsreginterval=", $"the LDS(-ME) registration interval in ms. If 0, then the registration is disabled.\nDefault: {LdsRegistrationInterval}", (int i) => {
if (i >= 0)
{
LdsRegistrationInterval = i;
}
else
{
throw new OptionException("The ldsreginterval must be larger or equal 0.", "ldsreginterval");
}
} },
{ "ot|operationtimeout=", $"the operation timeout of the publisher OPC UA client in ms.\nDefault: {OpcOperationTimeout}", (int i) => {
if (i >= 0)
{
OpcOperationTimeout = i;
}
else
{
throw new OptionException("The operation timeout must be larger or equal 0.", "operationtimeout");
}
} },
{ "oi|opcsamplinginterval=", "the publisher is using this as default value in milliseconds to request the servers to sample the nodes with this interval\n" +
"this value might be revised by the OPC UA servers to a supported sampling interval.\n" +
"please check the OPC UA specification for details how this is handled by the OPC UA stack.\n" +
"a negative value will set the sampling interval to the publishing interval of the subscription this node is on.\n" +
$"0 will configure the OPC UA server to sample in the highest possible resolution and should be taken with care.\nDefault: {OpcSamplingInterval}", (int i) => OpcSamplingInterval = i },
{ "op|opcpublishinginterval=", "the publisher is using this as default value in milliseconds for the publishing interval setting of the subscriptions established to the OPC UA servers.\n" +
"please check the OPC UA specification for details how this is handled by the OPC UA stack.\n" +
$"a value less than or equal zero will let the server revise the publishing interval.\nDefault: {OpcPublishingInterval}", (int i) => {
if (i > 0 && i >= OpcSamplingInterval)
{
OpcPublishingInterval = i;
}
else
{
if (i <= 0)
{
OpcPublishingInterval = 0;
}
else
{
throw new OptionException($"The opcpublishinterval ({i}) must be larger than the opcsamplinginterval ({OpcSamplingInterval}).", "opcpublishinterval");
}
}
} },
{ "ct|createsessiontimeout=", $"specify the timeout in seconds used when creating a session to an endpoint. On unsuccessful connection attemps a backoff up to {OpcSessionCreationBackoffMax} times the specified timeout value is used.\nMin: 1\nDefault: {OpcSessionCreationTimeout}", (uint u) => {
if (u > 1)
{
OpcSessionCreationTimeout = u;
}
else
{
throw new OptionException("The createsessiontimeout must be greater than 1 sec", "createsessiontimeout");
}
} },
{ "ki|keepaliveinterval=", $"specify the interval in seconds the publisher is sending keep alive messages to the OPC servers on the endpoints it is connected to.\nMin: 2\nDefault: {OpcKeepAliveIntervalInSec}", (int i) => {
if (i >= 2)
{
OpcKeepAliveIntervalInSec = i;
}
else
{
throw new OptionException("The keepaliveinterval must be greater or equal 2", "keepalivethreshold");
}
} },
{ "kt|keepalivethreshold=", $"specify the number of keep alive packets a server can miss, before the session is disconneced\nMin: 1\nDefault: {OpcKeepAliveDisconnectThreshold}", (uint u) => {
if (u > 1)
{
OpcKeepAliveDisconnectThreshold = u;
}
else
{
throw new OptionException("The keepalivethreshold must be greater than 1", "keepalivethreshold");
}
} },
{ "st|opcstacktracemask=", $"the trace mask for the OPC stack. See github OPC .NET stack for definitions.\nTo enable IoTHub telemetry tracing set it to 711.\nDefault: {OpcStackTraceMask:X} ({Program.OpcStackTraceMask})", (int i) => {
if (i >= 0)
{
OpcStackTraceMask = i;
}
else
{
throw new OptionException("The OPC stack trace mask must be larger or equal 0.", "opcstacktracemask");
}
} },
{ "as|autotrustservercerts=", $"the publisher trusts all servers it is establishing a connection to.\nDefault: {OpcPublisherAutoTrustServerCerts}", (bool b) => OpcPublisherAutoTrustServerCerts = b },
// trust own public cert option
{ "tm|trustmyself=", $"the publisher certificate is put into the trusted certificate store automatically.\nDefault: {TrustMyself}", (bool b) => TrustMyself = b },
// own cert store options
{ "at|appcertstoretype=", $"the own application cert store type. \n(allowed values: Directory, X509Store)\nDefault: '{OpcOwnCertStoreType}'", (string s) => {
if (s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) || s.Equals(Directory, StringComparison.OrdinalIgnoreCase))
{
OpcOwnCertStoreType = s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) ? X509Store : Directory;
OpcOwnCertStorePath = s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) ? _opcOwnCertX509StorePathDefault : _opcOwnCertDirectoryStorePathDefault;
}
else
{
throw new OptionException();
}
} },
{ "ap|appcertstorepath=", $"the path where the own application cert should be stored\nDefault (depends on store type):\n" +
$"X509Store: '{_opcOwnCertX509StorePathDefault}'\n" +
$"Directory: '{_opcOwnCertDirectoryStorePathDefault}'", (string s) => OpcOwnCertStorePath = s },
// trusted cert store options
{
"tt|trustedcertstoretype=", $"the trusted cert store type. \n(allowed values: Directory, X509Store)\nDefault: {OpcTrustedCertStoreType}", (string s) => {
if (s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) || s.Equals(Directory, StringComparison.OrdinalIgnoreCase))
{
OpcTrustedCertStoreType = s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) ? X509Store : Directory;
OpcTrustedCertStorePath = s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) ? OpcTrustedCertX509StorePathDefault : OpcTrustedCertDirectoryStorePathDefault;
}
else
{
throw new OptionException();
}
}
},
{ "tp|trustedcertstorepath=", $"the path of the trusted cert store\nDefault (depends on store type):\n" +
$"X509Store: '{OpcTrustedCertX509StorePathDefault}'\n" +
$"Directory: '{OpcTrustedCertDirectoryStorePathDefault}'", (string s) => OpcTrustedCertStorePath = s },
// rejected cert store options
{ "rt|rejectedcertstoretype=", $"the rejected cert store type. \n(allowed values: Directory, X509Store)\nDefault: {OpcRejectedCertStoreType}", (string s) => {
if (s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) || s.Equals(Directory, StringComparison.OrdinalIgnoreCase))
{
OpcRejectedCertStoreType = s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) ? X509Store : Directory;
OpcRejectedCertStorePath = s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) ? _opcRejectedCertX509StorePathDefault : _opcRejectedCertDirectoryStorePathDefault;
}
else
{
throw new OptionException();
}
} },
{ "rp|rejectedcertstorepath=", $"the path of the rejected cert store\nDefault (depends on store type):\n" +
$"X509Store: '{_opcRejectedCertX509StorePathDefault}'\n" +
$"Directory: '{_opcRejectedCertDirectoryStorePathDefault}'", (string s) => OpcRejectedCertStorePath = s },
// issuer cert store options
{
"it|issuercertstoretype=", $"the trusted issuer cert store type. \n(allowed values: Directory, X509Store)\nDefault: {OpcIssuerCertStoreType}", (string s) => {
if (s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) || s.Equals(Directory, StringComparison.OrdinalIgnoreCase))
{
OpcIssuerCertStoreType = s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) ? X509Store : Directory;
OpcIssuerCertStorePath = s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) ? _opcIssuerCertX509StorePathDefault : _opcIssuerCertDirectoryStorePathDefault;
}
else
{
throw new OptionException();
}
}
},
{ "ip|issuercertstorepath=", $"the path of the trusted issuer cert store\nDefault (depends on store type):\n" +
$"X509Store: '{_opcIssuerCertX509StorePathDefault}'\n" +
$"Directory: '{_opcIssuerCertDirectoryStorePathDefault}'", (string s) => OpcIssuerCertStorePath = s },
// device connection string cert store options
{ "dt|devicecertstoretype=", $"the iothub device cert store type. \n(allowed values: Directory, X509Store)\nDefault: {IotDeviceCertStoreType}", (string s) => {
if (s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) || s.Equals(Directory, StringComparison.OrdinalIgnoreCase))
{
IotDeviceCertStoreType = s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) ? X509Store : Directory;
IotDeviceCertStorePath = s.Equals(X509Store, StringComparison.OrdinalIgnoreCase) ? _iotDeviceCertX509StorePathDefault : _iotDeviceCertDirectoryStorePathDefault;
}
else
{
throw new OptionException();
}
} },
{ "dp|devicecertstorepath=", $"the path of the iot device cert store\nDefault Default (depends on store type):\n" +
$"X509Store: '{_iotDeviceCertX509StorePathDefault}'\n" +
$"Directory: '{_iotDeviceCertDirectoryStorePathDefault}'", (string s) => IotDeviceCertStorePath = s },
// misc
{ "h|help", "show this message and exit", h => shouldShowHelp = h != null },
};
List <string> arguments;
try
{
// parse the command line
arguments = options.Parse(args);
}
catch (OptionException e)
{
// show message
WriteLine($"Error: {e.Message}");
// show usage
Usage(options);
return;
}
// Validate and parse arguments.
if (arguments.Count > 2 || shouldShowHelp)
{
Usage(options);
return;
}
else if (arguments.Count == 2)
{
ApplicationName = arguments[0];
_IotHubOwnerConnectionString = arguments[1];
}
else if (arguments.Count == 1)
{
ApplicationName = arguments[0];
}
else
{
ApplicationName = Utils.GetHostName();
}
WriteLine("Publisher is starting up...");
// init OPC configuration and tracing
Init(OpcStackTraceMask, VerboseConsole);
OpcStackConfiguration opcStackConfiguration = new OpcStackConfiguration(ApplicationName);
opcTraceInitialized = true;
OpcConfiguration = opcStackConfiguration.Configuration;
// log shopfloor domain setting
if (string.IsNullOrEmpty(ShopfloorDomain))
{
Trace("There is no shopfloor domain configured.");
}
else
{
Trace($"Publisher is in shopfloor domain '{ShopfloorDomain}'.");
}
// Set certificate validator.
if (OpcPublisherAutoTrustServerCerts)
{
Trace("Publisher configured to auto trust server certificates of the servers it is connecting to.");
OpcConfiguration.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_AutoTrustServerCerts);
}
else
{
Trace("Publisher configured to not auto trust server certificates. When connecting to servers, you need to manually copy the rejected server certs to the trusted store to trust them.");
OpcConfiguration.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_Default);
}
// start our server interface
try
{
Trace($"Starting server on endpoint {OpcConfiguration.ServerConfiguration.BaseAddresses[0].ToString()} ...");
_publisherServer = new PublisherServer();
_publisherServer.Start(OpcConfiguration);
Trace("Server started.");
}
catch (Exception e)
{
Trace(e, $"Failed to start Publisher OPC UA server.");
Trace("exiting...");
return;
}
// get information on the nodes to publish and validate the json by deserializing it.
try
{
PublishDataSemaphore.Wait();
if (string.IsNullOrEmpty(NodesToPublishAbsFilename))
{
// check if we have an env variable specifying the published nodes path, otherwise use the default
NodesToPublishAbsFilename = NodesToPublishAbsFilenameDefault;
if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("_GW_PNFP")))
{
Trace("Publishing node configuration file path read from environment.");
NodesToPublishAbsFilename = Environment.GetEnvironmentVariable("_GW_PNFP");
}
}
Trace($"Attempting to load nodes file from: {NodesToPublishAbsFilename}");
PublisherConfigFileEntries = JsonConvert.DeserializeObject <List <PublisherConfigFileEntry> >(File.ReadAllText(NodesToPublishAbsFilename));
Trace($"Loaded {PublisherConfigFileEntries.Count.ToString()} config file entry/entries.");
foreach (var publisherConfigFileEntry in PublisherConfigFileEntries)
{
if (publisherConfigFileEntry.NodeId == null)
{
// new node configuration syntax.
foreach (var opcNode in publisherConfigFileEntry.OpcNodes)
{
PublishConfig.Add(new NodeToPublishConfig(ExpandedNodeId.Parse(opcNode.ExpandedNodeId), publisherConfigFileEntry.EndpointUri, opcNode.OpcSamplingInterval ?? OpcSamplingInterval, opcNode.OpcPublishingInterval ?? OpcPublishingInterval));
}
}
else
{
// legacy (using ns=) node configuration syntax using default sampling and publishing interval.
PublishConfig.Add(new NodeToPublishConfig(publisherConfigFileEntry.NodeId, publisherConfigFileEntry.EndpointUri, OpcSamplingInterval, OpcPublishingInterval));
}
}
}
catch (Exception e)
{
Trace(e, "Loading of the node configuration file failed. Does the file exist and has correct syntax?");
Trace("exiting...");
return;
}
finally
{
PublishDataSemaphore.Release();
}
Trace($"There are {PublishConfig.Count.ToString()} nodes to publish.");
// initialize and start IoTHub messaging
IotHubCommunication = new IotHubMessaging();
if (!IotHubCommunication.Init(_IotHubOwnerConnectionString, _MaxSizeOfIoTHubMessageBytes, _DefaultSendIntervalSeconds))
{
return;
}
// create a list to manage sessions, subscriptions and monitored items.
try
{
PublishDataSemaphore.Wait();
OpcSessionsSemaphore.Wait();
var uniqueEndpointUrls = PublishConfig.Select(n => n.EndpointUri).Distinct();
foreach (var endpointUrl in uniqueEndpointUrls)
{
// create new session info.
OpcSession opcSession = new OpcSession(endpointUrl, OpcSessionCreationTimeout);
// create a subscription for each distinct publishing inverval
var nodesDistinctPublishingInterval = PublishConfig.Where(n => n.EndpointUri.Equals(endpointUrl)).Select(c => c.OpcPublishingInterval).Distinct();
foreach (var nodeDistinctPublishingInterval in nodesDistinctPublishingInterval)
{
// create a subscription for the publishing interval and add it to the session.
OpcSubscription opcSubscription = new OpcSubscription(nodeDistinctPublishingInterval);
// add all nodes with this OPC publishing interval to this subscription.
var nodesWithSamePublishingInterval = PublishConfig.Where(n => n.EndpointUri.Equals(endpointUrl)).Where(n => n.OpcPublishingInterval == nodeDistinctPublishingInterval);
foreach (var nodeInfo in nodesWithSamePublishingInterval)
{
// differentiate if legacy (using ns=) or new syntax (using nsu=) is used
if (nodeInfo.NodeId == null)
{
// create a monitored item for the node
OpcMonitoredItem opcMonitoredItem = new OpcMonitoredItem(nodeInfo.ExpandedNodeId, opcSession.EndpointUri)
{
RequestedSamplingInterval = nodeInfo.OpcSamplingInterval,
SamplingInterval = nodeInfo.OpcSamplingInterval
};
opcSubscription.OpcMonitoredItems.Add(opcMonitoredItem);
}
else
{
// give user a warning that the syntax is obsolete
Trace($"Please update the syntax of the configuration file and use ExpandedNodeId instead of NodeId property name for node with identifier '{nodeInfo.NodeId.ToString()}' on EndpointUrl '{nodeInfo.EndpointUri.AbsolutePath}'.");
// create a monitored item for the node with the configured or default sampling interval
OpcMonitoredItem opcMonitoredItem = new OpcMonitoredItem(nodeInfo.NodeId, opcSession.EndpointUri)
{
RequestedSamplingInterval = nodeInfo.OpcSamplingInterval,
SamplingInterval = nodeInfo.OpcSamplingInterval
};
opcSubscription.OpcMonitoredItems.Add(opcMonitoredItem);
}
}
// add subscription to session.
opcSession.OpcSubscriptions.Add(opcSubscription);
}
// add session.
OpcSessions.Add(opcSession);
}
}
finally
{
OpcSessionsSemaphore.Release();
PublishDataSemaphore.Release();
}
// kick off the task to maintain all sessions
var cts = new CancellationTokenSource();
Task.Run(async() => await SessionConnector(cts.Token));
// Show notification on session events
_publisherServer.CurrentInstance.SessionManager.SessionActivated += ServerEventStatus;
_publisherServer.CurrentInstance.SessionManager.SessionClosing += ServerEventStatus;
_publisherServer.CurrentInstance.SessionManager.SessionCreated += ServerEventStatus;
// stop on user request
WriteLine("");
WriteLine("");
WriteLine("Publisher is running. Press ENTER to quit.");
WriteLine("");
WriteLine("");
ReadLine();
cts.Cancel();
WriteLine("Publisher is shuting down...");
// close all connected session
PublisherShutdownInProgress = true;
// stop the server
_publisherServer.Stop();
// Clean up Publisher sessions
Task.Run(async() => await SessionShutdown()).Wait();
// shutdown the IoTHub messaging
IotHubCommunication.Shutdown();
}
catch (Exception e)
{
if (opcTraceInitialized)
{
Trace(e, e.StackTrace);
e = e.InnerException ?? null;
while (e != null)
{
Trace(e, e.StackTrace);
e = e.InnerException ?? null;
}
Trace("Publisher exiting... ");
}
else
{
WriteLine($"{DateTime.Now.ToString()}: {e.Message.ToString()}");
WriteLine($"{DateTime.Now.ToString()}: {e.StackTrace}");
e = e.InnerException ?? null;
while (e != null)
{
WriteLine($"{DateTime.Now.ToString()}: {e.Message.ToString()}");
WriteLine($"{DateTime.Now.ToString()}: {e.StackTrace}");
e = e.InnerException ?? null;
}
WriteLine($"{DateTime.Now.ToString()}: Publisher exiting...");
}
}
}