public static void Main(string[] args)
{
try
{
ApplicationInstance.MessageDlg = new ApplicationMessageDlg();
ApplicationInstance application = new ApplicationInstance();
application.ApplicationName = "Manufacturing Execution System";
application.ApplicationType = ApplicationType.Client;
application.ConfigSectionName = "Opc.Ua.MES";
// load the application configuration.
ApplicationConfiguration appConfiguration = application.LoadApplicationConfiguration(false).Result;
// check the application certificate.
application.CheckApplicationInstanceCertificate(false, 0).Wait();
// get list of cached endpoints.
ConfiguredEndpointCollection endpoints = appConfiguration.LoadCachedEndpoints(true);
endpoints.DiscoveryUrls = appConfiguration.ClientConfiguration.WellKnownDiscoveryUrls;
StationsCollection collection = StationsCollection.Load(appConfiguration);
if (collection.Count > 0)
{
m_station = collection[0];
}
else
{
throw new ArgumentException("Can not load station definition from configuration file!");
}
// connect to all servers.
m_sessionAssembly = EndpointConnect(endpoints[c_Assembly], appConfiguration);
m_sessionTest = EndpointConnect(endpoints[c_Test], appConfiguration);
m_sessionPackaging = EndpointConnect(endpoints[c_Packaging], appConfiguration);
if (!CreateMonitoredItem(m_station.StatusNode, m_sessionAssembly, new MonitoredItemNotificationEventHandler(MonitoredItem_AssemblyStation)))
{
Trace("Failed to create monitored Item for the assembly station!");
}
if (!CreateMonitoredItem(m_station.StatusNode, m_sessionTest, new MonitoredItemNotificationEventHandler(MonitoredItem_TestStation)))
{
Trace("Failed to create monitored Item for the test station!");
}
if (!CreateMonitoredItem(m_station.StatusNode, m_sessionPackaging, new MonitoredItemNotificationEventHandler(MonitoredItem_PackagingStation)))
{
Trace("Failed to create monitored Item for the packaging station!");
}
StartAssemblyLine();
// MESLogic method is executed periodically, with period c_updateRate
RestartTimer(c_updateRate);
Trace("MES started. Press any key to exit.");
try
{
Console.ReadKey(true);
}
catch
{
// wait forever if there is no console, e.g. in docker
Thread.Sleep(Timeout.Infinite);
}
}
catch (Exception ex)
{
Trace("Critical Exception: {0}, MES exiting!", ex.Message);
}
}
public static void Main(string[] args)
{
try
{
ApplicationInstance.MessageDlg = new ApplicationMessageDlg();
ApplicationInstance application = new ApplicationInstance();
application.ApplicationName = "Manufacturing Execution System";
application.ApplicationType = ApplicationType.Client;
application.ConfigSectionName = "Opc.Ua.MES";
// load the application configuration.
ApplicationConfiguration appConfiguration = application.LoadApplicationConfiguration(false).Result;
// check the application certificate.
application.CheckApplicationInstanceCertificate(false, 0).Wait();
// get list of cached endpoints.
ConfiguredEndpointCollection endpoints = appConfiguration.LoadCachedEndpoints(true);
endpoints.DiscoveryUrls = appConfiguration.ClientConfiguration.WellKnownDiscoveryUrls;
StationsCollection collection = StationsCollection.Load(appConfiguration);
if (collection.Count > 0)
{
m_station = collection[0];
}
else
{
throw new ArgumentException("Can not load station definition from configuration file!");
}
// connect to all servers.
m_sessionAssembly = new SessionHandler();
m_sessionTest = new SessionHandler();
m_sessionPackaging = new SessionHandler();
DateTime retryTimeout = DateTime.UtcNow + TimeSpan.FromMilliseconds(c_connectTimeout);
do
{
try
{
m_sessionAssembly.EndpointConnect(endpoints[c_Assembly], appConfiguration);
m_sessionTest.EndpointConnect(endpoints[c_Test], appConfiguration);
m_sessionPackaging.EndpointConnect(endpoints[c_Packaging], appConfiguration);
}
catch (Exception ex)
{
Trace("Exception connecting to assembly line: {0}, retry!", ex.Message);
}
if (DateTime.UtcNow > retryTimeout)
{
throw new Exception(String.Format("Failed to connect to assembly line for {0} seconds!", c_connectTimeout / 1000));
}
System.Threading.Thread.Sleep(c_waitTime);
}while (!(m_sessionAssembly.SessionConnected && m_sessionTest.SessionConnected && m_sessionPackaging.SessionConnected));
if (!CreateMonitoredItem(m_station.StatusNode, m_sessionAssembly.Session, new MonitoredItemNotificationEventHandler(MonitoredItem_AssemblyStation)))
{
throw new Exception("Failed to create monitored Item for the assembly station!");
}
if (!CreateMonitoredItem(m_station.StatusNode, m_sessionTest.Session, new MonitoredItemNotificationEventHandler(MonitoredItem_TestStation)))
{
throw new Exception("Failed to create monitored Item for the test station!");
}
if (!CreateMonitoredItem(m_station.StatusNode, m_sessionPackaging.Session, new MonitoredItemNotificationEventHandler(MonitoredItem_PackagingStation)))
{
throw new Exception("Failed to create monitored Item for the packaging station!");
}
StartAssemblyLine();
// MESLogic method is executed periodically, with period c_updateRate
RestartTimer(c_updateRate);
Trace("MES started. Press Ctrl-C to exit.");
m_quitEvent = new ManualResetEvent(false);
try
{
Console.CancelKeyPress += (sender, eArgs) => {
m_quitEvent.Set();
eArgs.Cancel = true;
};
}
catch
{
}
// wait for MES timeout or Ctrl-C
m_quitEvent.WaitOne();
}
catch (Exception ex)
{
Trace("Critical Exception: {0}, MES exiting!", ex.Message);
}
}
private async Task ConsoleAggregationServer()
{
ApplicationInstance.MessageDlg = new ApplicationMessageDlg();
ApplicationInstance application = new ApplicationInstance();
application.ApplicationName = "Quickstart Aggregation Server";
application.ApplicationType = ApplicationType.Server;
application.ConfigSectionName = "Quickstarts.AggregationServer";
// load the application configuration.
ApplicationConfiguration config = await application.LoadApplicationConfiguration(false);
// check the application certificate.
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, CertificateFactory.DefaultKeySize);
if (!haveAppCertificate)
{
throw new Exception("Application instance certificate invalid!");
}
if (!config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
}
// start the server.
server = new AggregationServer();
await application.Start(server);
// print reverse connect info
Console.WriteLine("Reverse Connect Clients:");
var reverseConnections = server.GetReverseConnections();
foreach (var connection in reverseConnections)
{
Console.WriteLine(connection.Key);
}
// print endpoint info
Console.WriteLine("Server Endpoints:");
var endpoints = server.GetEndpoints().Select(e => e.EndpointUrl).Distinct();
foreach (var endpoint in endpoints)
{
Console.WriteLine(endpoint);
}
// print the reverse connect host
if (config.ClientConfiguration?.ReverseConnect != null)
{
var reverseConnect = config.ClientConfiguration.ReverseConnect;
Console.WriteLine("Reverse Connect Server Endpoints:");
foreach (var endpoint in reverseConnect.ClientEndpoints)
{
Console.WriteLine(endpoint.EndpointUrl);
}
Console.WriteLine("HoldTime: {0}", reverseConnect.HoldTime);
Console.WriteLine("WaitTimeout: {0}", reverseConnect.WaitTimeout);
}
// start the status thread
status = Task.Run(async() => await StatusThread());
// print notification on session events
server.CurrentInstance.SessionManager.SessionActivated += EventStatus;
server.CurrentInstance.SessionManager.SessionClosing += EventStatus;
server.CurrentInstance.SessionManager.SessionCreated += EventStatus;
}
public async Task LoadClientConfiguration(int port = -1)
{
ApplicationInstance.MessageDlg = new ApplicationMessageDlg();
ApplicationInstance application = new ApplicationInstance {
ApplicationName = "Global Discovery Client",
ApplicationType = ApplicationType.Client,
ConfigSectionName = "Opc.Ua.GlobalDiscoveryTestClient"
};
#if USE_FILE_CONFIG
// load the application configuration.
Configuration = await application.LoadApplicationConfiguration(false).ConfigureAwait(false);
#else
string root = Path.Combine("%LocalApplicationData%", "OPC");
string pkiRoot = Path.Combine(root, "pki");
var clientConfig = new GlobalDiscoveryTestClientConfiguration()
{
GlobalDiscoveryServerUrl = "opc.tcp://localhost:58810/GlobalDiscoveryTestServer",
AppUserName = "******",
AppPassword = "******",
AdminUserName = "******",
AdminPassword = "******"
};
// build the application configuration.
Configuration = await application
.Build(
"urn:localhost:opcfoundation.org:GlobalDiscoveryTestClient",
"http://opcfoundation.org/UA/GlobalDiscoveryTestClient")
.AsClient()
.SetDefaultSessionTimeout(600000)
.SetMinSubscriptionLifetime(10000)
.AddSecurityConfiguration(
"CN=Global Discovery Test Client, O=OPC Foundation, DC=localhost",
pkiRoot)
.SetAutoAcceptUntrustedCertificates(true)
.SetRejectSHA1SignedCertificates(false)
.SetRejectUnknownRevocationStatus(true)
.SetMinimumCertificateKeySize(1024)
.AddExtension <GlobalDiscoveryTestClientConfiguration>(null, clientConfig)
.SetOutputFilePath(Path.Combine(root, "Logs", "Opc.Ua.Gds.Tests.log.txt"))
.SetTraceMasks(519)
.Create().ConfigureAwait(false);
#endif
// check the application certificate.
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(true, 0).ConfigureAwait(false);
if (!haveAppCertificate)
{
throw new Exception("Application instance certificate invalid!");
}
Configuration.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
GlobalDiscoveryTestClientConfiguration gdsClientConfiguration = Configuration.ParseExtension <GlobalDiscoveryTestClientConfiguration>();
m_client = new GlobalDiscoveryServerClient(Configuration, gdsClientConfiguration.GlobalDiscoveryServerUrl)
{
EndpointUrl = TestUtils.PatchOnlyGDSEndpointUrlPort(gdsClientConfiguration.GlobalDiscoveryServerUrl, port)
};
if (String.IsNullOrEmpty(gdsClientConfiguration.AppUserName))
{
AppUser = new UserIdentity(new AnonymousIdentityToken());
}
else
{
AppUser = new UserIdentity(gdsClientConfiguration.AppUserName, gdsClientConfiguration.AppPassword);
}
AdminUser = new UserIdentity(gdsClientConfiguration.AdminUserName, gdsClientConfiguration.AdminPassword);
}
/// <summary>
/// Main
/// </summary>
/// <param name="args"></param>
public static void Main(string[] args)
{
Console.WriteLine("Starting LightLDS - The lightweight OPC UA Local Discovery Server");
ApplicationInstance application = new ApplicationInstance();
try
{
var applicationConfiguration = new ApplicationConfiguration();
applicationConfiguration.ApplicationName = "Light OPC UA Local Discovery Server";
applicationConfiguration.ApplicationUri = "urn:localhost:K47S:LocalDiscoveryServer";
applicationConfiguration.ProductUri = "http://K47S/LocalDiscoveryServer";
applicationConfiguration.ApplicationType = ApplicationType.DiscoveryServer;
var securityConfiguration = new SecurityConfiguration();
securityConfiguration.ApplicationCertificate = new CertificateIdentifier()
{
StoreType = @"Directory",
StorePath = @"%CommonApplicationData%/LightLDS/PKI/own",
SubjectName = "CN=Local Discovery Server, O=K47S, DC=localhost",
};
securityConfiguration.TrustedIssuerCertificates = new CertificateTrustList()
{
StoreType = @"Directory",
StorePath = @"%CommonApplicationData%/LightLDS/PKI/issuers",
};
securityConfiguration.TrustedPeerCertificates = new CertificateTrustList()
{
StoreType = @"Directory",
StorePath = @"%CommonApplicationData%/LightLDS/PKI/trusted",
};
securityConfiguration.RejectedCertificateStore = new CertificateTrustList()
{
StoreType = @"Directory",
StorePath = @"%CommonApplicationData%/LightLDS/PKI/rejected",
};
securityConfiguration.AutoAcceptUntrustedCertificates = true;
securityConfiguration.RejectSHA1SignedCertificates = false;
securityConfiguration.MinimumCertificateKeySize = 1024;
applicationConfiguration.SecurityConfiguration = securityConfiguration;
var serverConfiguration = new ServerConfiguration();
serverConfiguration.BaseAddresses = new StringCollection(new List <string>()
{
"opc.tcp://localhost:4840"
});
serverConfiguration.SecurityPolicies = new ServerSecurityPolicyCollection(new List <ServerSecurityPolicy>()
{
new ServerSecurityPolicy()
{
SecurityMode = MessageSecurityMode.None,
SecurityPolicyUri = "http://opcfoundation.org/UA/SecurityPolicy#None",
}
});
serverConfiguration.UserTokenPolicies = new UserTokenPolicyCollection(new List <UserTokenPolicy>()
{
new UserTokenPolicy()
{
TokenType = UserTokenType.Anonymous,
SecurityPolicyUri = "http://opcfoundation.org/UA/SecurityPolicy#None"
}
});
serverConfiguration.DiagnosticsEnabled = true;
serverConfiguration.MaxSessionCount = 100;
serverConfiguration.MinSessionTimeout = 10000;
serverConfiguration.MaxSessionTimeout = 3600000;
serverConfiguration.MaxBrowseContinuationPoints = 10;
serverConfiguration.MaxQueryContinuationPoints = 10;
serverConfiguration.MaxHistoryContinuationPoints = 100;
serverConfiguration.MaxRequestAge = 600000;
serverConfiguration.MinPublishingInterval = 100;
serverConfiguration.MaxPublishingInterval = 3600000;
serverConfiguration.PublishingResolution = 100;
serverConfiguration.MaxSubscriptionLifetime = 3600000;
serverConfiguration.MaxMessageQueueSize = 100;
serverConfiguration.MaxNotificationQueueSize = 100;
serverConfiguration.MaxNotificationsPerPublish = 1000;
serverConfiguration.MinMetadataSamplingInterval = 1000;
applicationConfiguration.ServerConfiguration = serverConfiguration;
var transportQuotaConfig = new TransportQuotas();
applicationConfiguration.TransportQuotas = transportQuotaConfig;
var traceConfiguration = new TraceConfiguration();
traceConfiguration.OutputFilePath = "%CommonApplicationData%/LightLDS/Logs/LocalDiscoveryServer.log.txt";
traceConfiguration.DeleteOnLoad = true;
traceConfiguration.TraceMasks = 0x7FFFFFFF;
applicationConfiguration.TraceConfiguration = traceConfiguration;
application.ApplicationConfiguration = applicationConfiguration;
application.ApplicationConfiguration.Validate(ApplicationType.Server);
// check the application certificate.
application.CheckApplicationInstanceCertificate(false, 0).Wait();
// start the server.
var server = new DiscoveryServerInstance();
application.Start(server).Wait();
Console.WriteLine("LightLDS running. Press ENTER to exit.");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.ReadLine();
}
/// <summary>
/// Start server
/// </summary>
/// <param name="ports"></param>
/// <returns></returns>
private async Task StartServerInternal(IEnumerable <int> ports)
{
_logger.Information("Starting server...");
ApplicationInstance.MessageDlg = new DummyDialog();
var config = _factory.CreateServer(ports, out _server);
config = ApplicationInstance.FixupAppConfig(config);
await config.Validate(ApplicationType.Server);
config.CertificateValidator.CertificateValidation += (v, e) => {
if (e.Error.StatusCode ==
StatusCodes.BadCertificateUntrusted)
{
e.Accept = AutoAccept;
_logger.Information((e.Accept ? "Accepted" : "Rejected") +
" Certificate {subject}", e.Certificate.Subject);
}
};
await config.CertificateValidator.Update(config.SecurityConfiguration);
// Use existing certificate, if it is there.
var cert = await config.SecurityConfiguration.ApplicationCertificate
.Find(true);
if (cert == null)
{
// Create cert
cert = CertificateFactory.CreateCertificate(
config.SecurityConfiguration.ApplicationCertificate.StoreType,
config.SecurityConfiguration.ApplicationCertificate.StorePath,
null, config.ApplicationUri, config.ApplicationName,
config.SecurityConfiguration.ApplicationCertificate.SubjectName,
null, CertificateFactory.defaultKeySize,
DateTime.UtcNow - TimeSpan.FromDays(1),
CertificateFactory.defaultLifeTime,
CertificateFactory.defaultHashSize,
false, null, null);
}
if (cert != null)
{
config.SecurityConfiguration.ApplicationCertificate.Certificate = cert;
config.ApplicationUri = Utils.GetApplicationUriFromCertificate(cert);
}
var application = new ApplicationInstance(config);
// check the application certificate.
var haveAppCertificate =
await application.CheckApplicationInstanceCertificate(false, 0);
if (!haveAppCertificate)
{
throw new Exception(
"Application instance certificate invalid!");
}
// start the server.
await application.Start(_server);
foreach (var ep in config.ServerConfiguration.BaseAddresses)
{
_logger.Information("Listening on {ep}", ep);
}
_logger.Information("Server started.");
}
public async Task StartServer(bool clean, int basePort = -1)
{
ApplicationInstance.MessageDlg = new ApplicationMessageDlg();
ApplicationInstance application = new ApplicationInstance
{
ApplicationName = "Global Discovery Server",
ApplicationType = ApplicationType.Server,
ConfigSectionName = "Opc.Ua.GlobalDiscoveryTestServer"
};
// load the application configuration.
ApplicationConfiguration config = await application.LoadApplicationConfiguration(false);
TestUtils.PatchBaseAddressesPorts(config, basePort);
if (clean)
{
string thumbprint = config.SecurityConfiguration.ApplicationCertificate.Thumbprint;
if (thumbprint != null)
{
using (var store = config.SecurityConfiguration.ApplicationCertificate.OpenStore())
{
await store.Delete(thumbprint);
}
}
// always start with clean cert store
TestUtils.CleanupTrustList(config.SecurityConfiguration.TrustedIssuerCertificates.OpenStore());
TestUtils.CleanupTrustList(config.SecurityConfiguration.TrustedPeerCertificates.OpenStore());
TestUtils.CleanupTrustList(config.SecurityConfiguration.RejectedCertificateStore.OpenStore());
}
if (clean)
{
string thumbprint = config.SecurityConfiguration.ApplicationCertificate.Thumbprint;
if (thumbprint != null)
{
using (var store = config.SecurityConfiguration.ApplicationCertificate.OpenStore())
{
await store.Delete(thumbprint);
}
}
// always start with clean cert store
TestUtils.CleanupTrustList(config.SecurityConfiguration.ApplicationCertificate.OpenStore());
TestUtils.CleanupTrustList(config.SecurityConfiguration.TrustedIssuerCertificates.OpenStore());
TestUtils.CleanupTrustList(config.SecurityConfiguration.TrustedPeerCertificates.OpenStore());
TestUtils.CleanupTrustList(config.SecurityConfiguration.RejectedCertificateStore.OpenStore());
config = await application.LoadApplicationConfiguration(false);
}
TestUtils.PatchBaseAddressesPorts(config, basePort);
// check the application certificate.
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, 0);
if (!haveAppCertificate)
{
throw new Exception("Application instance certificate invalid!");
}
if (!config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
}
// get the DatabaseStorePath configuration parameter.
GlobalDiscoveryServerConfiguration gdsConfiguration = config.ParseExtension <GlobalDiscoveryServerConfiguration>();
string databaseStorePath = Utils.ReplaceSpecialFolderNames(gdsConfiguration.DatabaseStorePath);
if (clean)
{
// clean up database
if (File.Exists(databaseStorePath))
{
File.Delete(databaseStorePath);
}
// clean up GDS stores
TestUtils.DeleteDirectory(gdsConfiguration.AuthoritiesStorePath);
TestUtils.DeleteDirectory(gdsConfiguration.ApplicationCertificatesStorePath);
foreach (var group in gdsConfiguration.CertificateGroups)
{
TestUtils.DeleteDirectory(group.BaseStorePath);
}
}
var database = JsonApplicationsDatabase.Load(databaseStorePath);
// start the server.
m_server = new GlobalDiscoverySampleServer(
database,
database,
new CertificateGroup());
await application.Start(m_server);
ServerState serverState = Server.GetStatus().State;
if ((serverState = Server.GetStatus().State) != ServerState.Running)
{
throw new ServiceResultException("Server failed to start");
}
}
/// <summary>
/// Connects to the OPC server asynchronously.
/// </summary>
public async Task <bool> ConnectAsync(OpcConnectionOptions connectionOptions, int operationTimeout = -1)
{
ApplicationInstance application = new ApplicationInstance
{
ApplicationName = string.Format("DrvOpcUa_{0} Driver", deviceNumStr),
ApplicationType = ApplicationType.Client,
ConfigSectionName = "Scada.Comm.Drivers.DrvOpcUa"
};
// load the application configuration
// TODO: use stream instead of file after updating OPCFoundation.NetStandard.Opc.Ua
WriteConfigFile(out string configFileName);
ApplicationConfiguration config = await application.LoadApplicationConfiguration(configFileName, false);
// check the application certificate
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, 0);
if (!haveAppCertificate)
{
throw new ScadaException(Locale.IsRussian ?
"Сертификат экземпляра приложения недействителен!" :
"Application instance certificate invalid!");
}
if (haveAppCertificate)
{
config.ApplicationUri = X509Utils.GetApplicationUriFromCertificate(
config.SecurityConfiguration.ApplicationCertificate.Certificate);
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
AutoAccept = true;
}
config.CertificateValidator.CertificateValidation += CertificateValidator_CertificateValidation;
}
else
{
log.WriteLine(Locale.IsRussian ?
"Предупреждение: отсутствует сертификат приложения, используется незащищенное соединение." :
"Warning: missing application certificate, using unsecure connection.");
}
// create session
EndpointDescription selectedEndpoint = operationTimeout > 0
? CoreClientUtils.SelectEndpoint(connectionOptions.ServerUrl, haveAppCertificate, operationTimeout)
: CoreClientUtils.SelectEndpoint(connectionOptions.ServerUrl, haveAppCertificate);
selectedEndpoint.SecurityMode = connectionOptions.SecurityMode;
selectedEndpoint.SecurityPolicyUri = connectionOptions.GetSecurityPolicy();
EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(config);
ConfiguredEndpoint endpoint = new ConfiguredEndpoint(null, selectedEndpoint, endpointConfiguration);
UserIdentity userIdentity = connectionOptions.AuthenticationMode == AuthenticationMode.Username ?
new UserIdentity(connectionOptions.Username, connectionOptions.Password) :
new UserIdentity(new AnonymousIdentityToken());
OpcSession = await Session.Create(config, endpoint, false,
"Rapid SCADA DrvOpcUa_" + deviceNumStr,
(uint)config.ClientConfiguration.DefaultSessionTimeout, userIdentity, null);
log.WriteLine(Locale.IsRussian ?
"OPC сессия успешно создана: {0}" :
"OPC session created successfully: {0}", connectionOptions.ServerUrl);
return(true);
}
public async Task run()
{
ApplicationInstance application = new ApplicationInstance
{
ApplicationName = "UA Core Sample Client",
ApplicationType = ApplicationType.Client,
ConfigSectionName = "Opc.Ua.SampleClient"
};
ApplicationConfiguration config = await application.LoadApplicationConfiguration(false);
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, 0);
if (!haveAppCertificate)
{
throw new Exception("Application instance certificate invalid!");
}
if (haveAppCertificate)
{
config.ApplicationUri = Utils.GetApplicationUriFromCertificate(config.SecurityConfiguration.ApplicationCertificate.Certificate);
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
autoAccept = true;
}
config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
}
else
{
Console.WriteLine(" WARN: missing application certificate, using unsecure connection.");
}
var selectedEndpoint = CoreClientUtils.SelectEndpoint(endpointURL, haveAppCertificate, 15000);
Console.WriteLine(" Selected endpoint uses: {0}", selectedEndpoint.SecurityPolicyUri.Substring(selectedEndpoint.SecurityPolicyUri.LastIndexOf('#') + 1));
var endpointConfiguration = EndpointConfiguration.Create(config);
var endpoint = new ConfiguredEndpoint(null, selectedEndpoint, endpointConfiguration);
session = await Session.Create(config, endpoint, false, "OPC UA Console Client", 60000, new UserIdentity(new AnonymousIdentityToken()), null);
session.KeepAlive += Client_KeepAlive;
var subscription = new Subscription(session.DefaultSubscription)
{
PublishingInterval = 1000
};
var list = new List <MonitoredItem> {
new MonitoredItem(subscription.DefaultItem)
{
MonitoringMode = MonitoringMode.Reporting, NodeClass = NodeClass.Variable, SamplingInterval = 1, QueueSize = 1 // DisplayName = "ServerStatusCurrentTime", StartNodeId = "i="+Variables.Server_ServerStatus_CurrentTime.ToString()
, DisplayName = "Temparature", StartNodeId = "ns=5;s=Temparature"
},
new MonitoredItem(subscription.DefaultItem)
{
MonitoringMode = MonitoringMode.Reporting, NodeClass = NodeClass.Variable, SamplingInterval = 1, QueueSize = 1 // DisplayName = "ServerStatusCurrentTime", StartNodeId = "i="+Variables.Server_ServerStatus_CurrentTime.ToString()
, DisplayName = "Humidity", StartNodeId = "ns=5;s=Humidity"
}
};
list.ForEach(i => i.Notification += OnNotification);
subscription.AddItems(list);
session.AddSubscription(subscription);
subscription.Create();
}
public void StartDiscovery()
{
try
{
var config = new ApplicationConfiguration()
{
ApplicationName = "Axiu UA Discovery",
ApplicationUri = Utils.Format(@"urn:{0}:AxiuUADiscovery", System.Net.Dns.GetHostName()),
ApplicationType = ApplicationType.DiscoveryServer,
ServerConfiguration = new ServerConfiguration()
{
BaseAddresses = { "opc.tcp://*****:*****@"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\MachineDefault", SubjectName = Utils.Format(@"CN={0}, DC={1}", "AxiuOpcua", System.Net.Dns.GetHostName())
},
TrustedIssuerCertificates = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\UA Certificate Authorities"
},
TrustedPeerCertificates = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\UA Applications"
},
RejectedCertificateStore = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\RejectedCertificates"
},
AutoAcceptUntrustedCertificates = true,
AddAppCertToTrustedStore = true
},
TransportConfigurations = new TransportConfigurationCollection(),
TransportQuotas = new TransportQuotas {
OperationTimeout = 15000
},
ClientConfiguration = new ClientConfiguration {
DefaultSessionTimeout = 60000
},
TraceConfiguration = new TraceConfiguration()
};
config.Validate(ApplicationType.DiscoveryServer).GetAwaiter().GetResult();
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
config.CertificateValidator.CertificateValidation += (s, e) => { e.Accept = (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted); };
}
var application = new ApplicationInstance
{
ApplicationName = "Axiu UA Discovery",
ApplicationType = ApplicationType.DiscoveryServer,
ApplicationConfiguration = config
};
//application.CheckApplicationInstanceCertificate(false, 2048).GetAwaiter().GetResult();
bool certOk = application.CheckApplicationInstanceCertificate(false, 0).Result;
if (!certOk)
{
Console.WriteLine("证书验证失败!");
}
var server = new DiscoveryServer();
// start the server.
application.Start(server).Wait();
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("启动OPC-UA Discovery服务端触发异常:" + ex.Message);
Console.ResetColor();
}
}
static async void OPCStart()
{
#region Startup
Console.WriteLine("Step 1 - Create application configuration and certificate.");
try
{
config = new ApplicationConfiguration()
{
ApplicationName = ApplicationName,
ApplicationUri = Utils.Format(@"urn:{0}:{1}", System.Net.Dns.GetHostName(), ApplicationName),
ApplicationType = ApplicationType.Client,
SecurityConfiguration = new SecurityConfiguration
{
#region Comment
/// Summary
#region
// These directories are locally on your computer.
// Generate self-signed (untrusted) client certificate(s).
// AutoAcceptUntrustedCertificates = true: Use this for testing only or if application does not require server certificate check.
// Explanation of how this works (this is for another library, but it's the same idea): http://opclabs.doc-that.com/files/onlinedocs/QuickOpc/Latest/User's%20Guide%20and%20Reference-QuickOPC/Trusting%20Server%20Instance%20Certificate.html
#endregion
/// Full information of security model and certificates of OPC UA. It's quite a big document, but worth reading if you care about security (you should).
// More information (Security and certificates): https://opcfoundation.org/wp-content/uploads/2014/05/OPC-UA_Security_Model_for_Administrators_V1.00.pdf
// If you want to use cloud for certificates, check this out: https://docs.microsoft.com/bs-latn-ba/azure/iot-accelerators/overview-opc-vault-architecture
#endregion
ApplicationCertificate = new CertificateIdentifier {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\MachineDefault", SubjectName = Utils.Format(@"CN={0}, DC={1}", ApplicationName, System.Net.Dns.GetHostName())
},
TrustedIssuerCertificates = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\UA Certificate Authorities"
},
TrustedPeerCertificates = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\UA Applications"
},
RejectedCertificateStore = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\RejectedCertificates"
},
AutoAcceptUntrustedCertificates = true,
AddAppCertToTrustedStore = true,
},
TransportConfigurations = new TransportConfigurationCollection(),
TransportQuotas = new TransportQuotas {
OperationTimeout = 15000
},
ClientConfiguration = new ClientConfiguration {
DefaultSessionTimeout = 60000
},
TraceConfiguration = new TraceConfiguration()
};
config.Validate(ApplicationType.Client).GetAwaiter().GetResult();
var application = new ApplicationInstance
{
ApplicationName = ApplicationName,
ApplicationType = ApplicationType.Client,
ApplicationConfiguration = config
};
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, 0);
if (!haveAppCertificate)
{
throw new Exception("Application instance certificate invalid!");
}
if (haveAppCertificate)
{
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
autoAccept = true;
}
config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
}
else
{
Console.WriteLine(" WARN: missing application certificate, using unsecure connection.");
}
}
catch (Exception ex)
{
Console.WriteLine("Exception: " + ex.Message);
}
var selectedEndpoint = CoreClientUtils.SelectEndpoint(OpcUAServer, useSecurity: false, operationTimeout: 150000);
Console.WriteLine($"Step 2 - Create a session with your server: {selectedEndpoint.EndpointUrl} ");
session = Session.Create(config, new ConfiguredEndpoint(null, selectedEndpoint, EndpointConfiguration.Create(config)), false, "", 60000, new UserIdentity(new AnonymousIdentityToken()), null).GetAwaiter().GetResult();
greenMessage("Successfully connected to PLC");
Console.WriteLine("Step 3 - Browse the server namespace.");
ReferenceDescriptionCollection refs;
Byte[] cp;
session.Browse(null, null, ObjectIds.ObjectsFolder, 0u, BrowseDirection.Forward, ReferenceTypeIds.HierarchicalReferences, true, (uint)NodeClass.Variable | (uint)NodeClass.Object | (uint)NodeClass.Method, out cp, out refs);
Console.WriteLine("DisplayName: BrowseName, NodeClass");
// Show only the nodes
#region
var rd = refs[4];
Console.WriteLine("{0}: {1}, {2}", rd.DisplayName, rd.BrowseName, rd.NodeClass);
ReferenceDescriptionCollection nextRefs;
byte[] nextCp;
session.Browse(null, null, ExpandedNodeId.ToNodeId(rd.NodeId, session.NamespaceUris), 0u, BrowseDirection.Forward, ReferenceTypeIds.HierarchicalReferences, true, (uint)NodeClass.Variable | (uint)NodeClass.Object | (uint)NodeClass.Method, out nextCp, out nextRefs);
foreach (var nextRd in nextRefs)
{
Console.WriteLine("+ {0}: {1}, {2}", nextRd.DisplayName, nextRd.BrowseName, nextRd.NodeClass);
}
#endregion
// Show all information of the OPC UA Server, including nodes
#region
//foreach (var rd in refs)
//{
// Console.WriteLine("{0}: {1}, {2}", rd.DisplayName, rd.BrowseName, rd.NodeClass);
// ReferenceDescriptionCollection nextRefs;
// byte[] nextCp;
// session.Browse(null, null, ExpandedNodeId.ToNodeId(rd.NodeId, session.NamespaceUris), 0u, BrowseDirection.Forward, ReferenceTypeIds.HierarchicalReferences, true, (uint)NodeClass.Variable | (uint)NodeClass.Object | (uint)NodeClass.Method, out nextCp, out nextRefs);
// foreach (var nextRd in nextRefs)
// {
// Console.WriteLine("+ {0}: {1}, {2}", nextRd.DisplayName, nextRd.BrowseName, nextRd.NodeClass);
// }
//}
#endregion
Console.WriteLine("Step 4 - Create a subscription. Set a faster publishing interval if you wish.");
var subscription = new Subscription(session.DefaultSubscription)
{
PublishingInterval = 3500
};
Console.WriteLine("Step 5 - Add a list of items you wish to monitor to the subscription.");
var list = new List <MonitoredItem> {
new MonitoredItem(subscription.DefaultItem)
{
DisplayName = "ServerStatusCurrentTime",
StartNodeId = "i=2258"
},
new MonitoredItem(subscription.DefaultItem)
{
DisplayName = TemperatureDisplayName,
StartNodeId = TemperatureNode,
AttributeId = 13, // Monitor the AttributeId 13 (= value) of the TemperatureNode
DiscardOldest = true,
QueueSize = 1
}
};
list.ForEach(i => i.Notification += OnNotification);
subscription.AddItems(list);
Console.WriteLine("Step 6 - Add the subscription to the session.");
session.AddSubscription(subscription);
subscription.Create();
#endregion
//Read nodes
ReadNode(TemperatureNode);
}
/// <summary>
/// Build the opc ua stack application configuration
/// </summary>
public static async Task <ApplicationConfiguration> BuildApplicationConfigurationAsync(
this IClientServicesConfig opcConfig,
IIdentity identity,
CertificateValidationEventHandler handler,
ILogger logger)
{
if (string.IsNullOrWhiteSpace(opcConfig.ApplicationName))
{
throw new ArgumentNullException(nameof(opcConfig.ApplicationName));
}
// wait with the configuration until network is up
for (var retry = 0; retry < 3; retry++)
{
if (NetworkInterface.GetIsNetworkAvailable())
{
break;
}
else
{
await Task.Delay(3000);
}
}
var appInstance = new ApplicationInstance {
ApplicationName = opcConfig.ApplicationName,
ApplicationType = ApplicationType.Client,
};
try {
await Retry.WithLinearBackoff(null, new CancellationToken(),
async() => {
// try to resolve the hostname
var hostname = !string.IsNullOrWhiteSpace(identity?.Gateway)
? identity.Gateway
: !string.IsNullOrWhiteSpace(identity?.DeviceId)
? identity.DeviceId
: Utils.GetHostName();
var appBuilder = appInstance
.Build(
opcConfig.ApplicationUri.Replace("urn:localhost", $"urn:{hostname}"),
opcConfig.ProductUri)
.SetTransportQuotas(opcConfig.ToTransportQuotas())
.AsClient();
var appConfig = await opcConfig
.BuildSecurityConfiguration(
appBuilder,
appInstance.ApplicationConfiguration,
hostname)
.ConfigureAwait(false);
appConfig.CertificateValidator.CertificateValidation += handler;
var ownCertificate = appConfig.SecurityConfiguration.ApplicationCertificate.Certificate;
if (ownCertificate == null)
{
logger.Information("No application own certificate found. Creating a self-signed " +
"own certificate valid since yesterday for {defaultLifeTime} months, with a " +
"{defaultKeySize} bit key and {defaultHashSize} bit hash.",
CertificateFactory.DefaultLifeTime,
CertificateFactory.DefaultKeySize,
CertificateFactory.DefaultHashSize);
}
else
{
logger.Information("Own certificate Subject '{subject}' (thumbprint: {thumbprint}) loaded.",
ownCertificate.Subject, ownCertificate.Thumbprint);
}
var hasAppCertificate = await appInstance
.CheckApplicationInstanceCertificate(
true,
CertificateFactory.DefaultKeySize,
CertificateFactory.DefaultLifeTime)
.ConfigureAwait(false);
if (!hasAppCertificate ||
appConfig.SecurityConfiguration.ApplicationCertificate.Certificate == null)
{
logger.Error("Failed to load or create application own certificate.");
throw new InvalidConfigurationException("OPC UA application own certificate invalid");
}
if (ownCertificate == null)
{
ownCertificate = appConfig.SecurityConfiguration.ApplicationCertificate.Certificate;
logger.Information("Own certificate Subject '{subject}' (thumbprint: {thumbprint}) created.",
ownCertificate.Subject, ownCertificate.Thumbprint);
}
await ShowCertificateStoreInformationAsync(appConfig, logger)
.ConfigureAwait(false);
},
e => true, 5);
}
catch (Exception e) {
throw new InvalidConfigurationException("OPC UA configuration not valid", e);
}
return(appInstance.ApplicationConfiguration);
}
public async Task LoadClientConfiguration(int port = -1)
{
ApplicationInstance.MessageDlg = new ApplicationMessageDlg();
ApplicationInstance application = new ApplicationInstance {
ApplicationName = "Server Configuration Push Test Client",
ApplicationType = ApplicationType.Client,
ConfigSectionName = "Opc.Ua.ServerConfigurationPushTestClient"
};
#if USE_FILE_CONFIG
// load the application configuration.
Config = await application.LoadApplicationConfiguration(false).ConfigureAwait(false);
#else
string pkiRoot = "%LocalApplicationData%/OPC/pki";
var clientConfig = new ServerConfigurationPushTestClientConfiguration()
{
ServerUrl = "opc.tcp://localhost:58810/GlobalDiscoveryTestServer",
AppUserName = "",
AppPassword = "",
SysAdminUserName = "******",
SysAdminPassword = "******",
TempStorePath = pkiRoot + "/temp"
};
// build the application configuration.
Config = await application
.Build(
"urn:localhost:opcfoundation.org:ServerConfigurationPushTestClient",
"http://opcfoundation.org/UA/ServerConfigurationPushTestClient")
.AsClient()
.AddSecurityConfiguration(
"CN=Server Configuration Push Test Client, O=OPC Foundation",
pkiRoot)
.SetAutoAcceptUntrustedCertificates(true)
.SetRejectSHA1SignedCertificates(false)
.SetMinimumCertificateKeySize(1024)
.AddExtension <ServerConfigurationPushTestClientConfiguration>(null, clientConfig)
.SetOutputFilePath(pkiRoot + "/Logs/Opc.Ua.Gds.Tests.log.txt")
.SetTraceMasks(519)
.Create().ConfigureAwait(false);
#endif
// check the application certificate.
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(true, 0).ConfigureAwait(false);
if (!haveAppCertificate)
{
throw new Exception("Application instance certificate invalid!");
}
Config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
ServerConfigurationPushTestClientConfiguration clientConfiguration = application.ApplicationConfiguration.ParseExtension <ServerConfigurationPushTestClientConfiguration>();
_client = new ServerPushConfigurationClient(application)
{
EndpointUrl = TestUtils.PatchOnlyGDSEndpointUrlPort(clientConfiguration.ServerUrl, port)
};
if (String.IsNullOrEmpty(clientConfiguration.AppUserName))
{
AppUser = new UserIdentity(new AnonymousIdentityToken());
}
else
{
AppUser = new UserIdentity(clientConfiguration.AppUserName, clientConfiguration.AppPassword);
}
SysAdminUser = new UserIdentity(clientConfiguration.SysAdminUserName, clientConfiguration.SysAdminPassword);
TempStorePath = clientConfiguration.TempStorePath;
}
static int Main(string[] args)
{
_application.ApplicationName = "Nodeset2Json";
_application.ApplicationType = ApplicationType.Server;
try
{
//check if argument has been passed
if (args.Length < 2)
{
Console.WriteLine("usage: nodeset2json.exe [dir]nodeset_file_xml [dir]output_file");
return(-1);
}
if (args[0].EndsWith(".xml"))
{
_server.NodesetFilePath = args[0]; //Input file
//Load configuration from xml file "NodesetServer.Config.xml"
string configFilePath = Path.Combine(System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "NodesetServer.Config.xml");
_application.LoadApplicationConfiguration(configFilePath, false).Wait();
// check the application certificate.
// here the opc foundation certificates are used
bool certOk = _application.CheckApplicationInstanceCertificate(false, 0).Result;
if (!certOk)
{
throw new Exception("Application instance certificate invalid!");
}
// Start the server
_application.Start(_server).GetAwaiter().OnCompleted(OnServerStarted);
var nsm = _server.NodeManager;
var ns = nsm.NodeSet; //BINGO: I got myself a nodeset!
RecursiveNode tree = new RecursiveNode(ns); //get the nodeset as a non binary tree
//the money shot
using (StreamWriter file = File.CreateText(args[1])) //Output file
{
var settings = new JsonSerializerSettings
{
ContractResolver = NodesetContractResolver.Instance,
NullValueHandling = NullValueHandling.Ignore
};
var json = JsonConvert.SerializeObject(tree, Formatting.Indented, settings);
file.Write(json);
}
return(0);
}
else
{
throw new Exception("Invalid nodeset xml file!");
}
}
catch (Exception e)
{
//TODO Implement logging sink instead of console.writeline
Console.WriteLine($"{e.Message} \n {e.InnerException?.Message} \n {e.StackTrace}");
return(-1);
}
}
public void opcUaServerInit()
{
string storePath = AppContext.BaseDirectory;
var config = new ApplicationConfiguration()
{
ApplicationName = "Axiu-Opcua",
ApplicationUri = Utils.Format(@"urn:{0}:Axiu-Opcua", System.Net.Dns.GetHostName()),
ApplicationType = ApplicationType.Client,
SecurityConfiguration = new SecurityConfiguration
{
ApplicationCertificate = new CertificateIdentifier {
StoreType = @"Directory", StorePath = Path.Combine(storePath, @"OPC Foundation/CertificateStores/MachineDefault"), SubjectName = Utils.Format(@"CN={0}, DC={1}", "Axiu-Opcua", System.Net.Dns.GetHostName())
},
TrustedIssuerCertificates = new CertificateTrustList {
StoreType = @"Directory", StorePath = Path.Combine(storePath, @"OPC Foundation/CertificateStores/UA Certificate Authorities")
},
TrustedPeerCertificates = new CertificateTrustList {
StoreType = @"Directory", StorePath = Path.Combine(storePath, @"OPC Foundation/CertificateStores/UA Applications")
},
RejectedCertificateStore = new CertificateTrustList {
StoreType = @"Directory", StorePath = Path.Combine(storePath, @"OPC Foundation/CertificateStores/RejectedCertificates")
},
AutoAcceptUntrustedCertificates = true,
AddAppCertToTrustedStore = true
},
TransportConfigurations = new TransportConfigurationCollection(),
TransportQuotas = new TransportQuotas {
OperationTimeout = 15000
},
ClientConfiguration = new ClientConfiguration {
DefaultSessionTimeout = 60000
},
TraceConfiguration = new TraceConfiguration()
};
config.Validate(ApplicationType.Client).GetAwaiter().GetResult();
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
config.CertificateValidator.CertificateValidation += (s, e) => { e.Accept = (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted); };
}
var application = new ApplicationInstance
{
ApplicationName = "Axiu-Opcua",
ApplicationType = ApplicationType.Client,
ApplicationConfiguration = config
};
application.CheckApplicationInstanceCertificate(false, 2048).GetAwaiter().GetResult();
var selectedEndpoint = CoreClientUtils.SelectEndpoint(url, useSecurity: true, int.MaxValue);
Console.WriteLine("配置已准备完毕,即将打开链接会话...");
_session = Session.Create(config, new ConfiguredEndpoint(null, selectedEndpoint, EndpointConfiguration.Create(config)),
false, "", int.MaxValue, null, null).GetAwaiter().GetResult();
// ReadNodeList("ns=3;s=\"上位通讯\"");
// AddSubscrip(null);
Console.WriteLine("完成链接会话...");
SubscribeToDataChanges();
}
/// <summary>
/// Create application configuration
/// </summary>
/// <param name="opcConfig"></param>
/// <param name="identity"></param>
/// <param name="createSelfSignedCertIfNone"></param>
/// <param name="handler"></param>
/// <returns></returns>
public static async Task <ApplicationConfiguration> ToApplicationConfigurationAsync(
this IClientServicesConfig opcConfig, IIdentity identity, bool createSelfSignedCertIfNone,
CertificateValidationEventHandler handler)
{
if (string.IsNullOrWhiteSpace(opcConfig.ApplicationName))
{
throw new ArgumentNullException(nameof(opcConfig.ApplicationName));
}
// wait with the configuration until network is up
for (var retry = 0; retry < 10; retry++)
{
if (NetworkInterface.GetIsNetworkAvailable())
{
break;
}
else
{
await Task.Delay(10000);
}
}
var applicationConfiguration = new ApplicationConfiguration {
ApplicationName = opcConfig.ApplicationName,
ProductUri = opcConfig.ProductUri,
ApplicationType = ApplicationType.Client,
TransportQuotas = opcConfig.ToTransportQuotas(),
CertificateValidator = new CertificateValidator(),
ClientConfiguration = new ClientConfiguration(),
ServerConfiguration = new ServerConfiguration()
};
try {
await Retry.WithLinearBackoff(null, new CancellationToken(),
async() => {
// try to resolve the hostname
var hostname = !string.IsNullOrWhiteSpace(identity?.Gateway) ?
identity.Gateway : !string.IsNullOrWhiteSpace(identity?.DeviceId) ?
identity.DeviceId : Dns.GetHostName();
var alternateBaseAddresses = new List <string>();
try {
alternateBaseAddresses.Add($"urn://{hostname}");
var hostEntry = Dns.GetHostEntry(hostname);
if (hostEntry != null)
{
alternateBaseAddresses.Add($"urn://{hostEntry.HostName}");
foreach (var alias in hostEntry.Aliases)
{
alternateBaseAddresses.Add($"urn://{alias}");
}
foreach (var ip in hostEntry.AddressList)
{
// only ad IPV4 addresses
switch (ip.AddressFamily)
{
case AddressFamily.InterNetwork:
alternateBaseAddresses.Add($"urn://{ip}");
break;
default:
break;
}
}
}
}
catch { }
applicationConfiguration.ApplicationUri =
opcConfig.ApplicationUri.Replace("urn:localhost", $"urn:{hostname}");
applicationConfiguration.SecurityConfiguration =
opcConfig.ToSecurityConfiguration(hostname);
applicationConfiguration.ServerConfiguration.AlternateBaseAddresses =
alternateBaseAddresses.ToArray();
await applicationConfiguration.Validate(applicationConfiguration.ApplicationType);
var application = new ApplicationInstance(applicationConfiguration);
var hasAppCertificate = await application.CheckApplicationInstanceCertificate(true,
CertificateFactory.defaultKeySize);
if (!hasAppCertificate)
{
throw new InvalidConfigurationException("OPC UA application certificate invalid");
}
applicationConfiguration.CertificateValidator.CertificateValidation += handler;
await applicationConfiguration.CertificateValidator
.Update(applicationConfiguration.SecurityConfiguration);
},
e => true, 20);
}
catch (Exception e) {
throw new InvalidConfigurationException("OPC UA configuration not valid", e);
}
return(applicationConfiguration);
}
public OpcMethodTest(string testserverUrl, int maxShortWaitSec, int maxLongWaitSec, CancellationToken ct) : base("OpcMethodTest", testserverUrl, maxShortWaitSec, maxLongWaitSec, ct)
{
string logPrefix = $"{_logClassPrefix}:OpcMethodTest:";
Logger.Information($"{logPrefix} Publisher URL: {PublisherUrl}");
//TestserverUrl = testserverUrl;
_application = new ApplicationInstance
{
ApplicationName = "UA Core Sample Client",
ApplicationType = ApplicationType.Client,
ConfigSectionName = "Opc.Ua.SampleClient"
};
// load the application configuration.
_config = _application.LoadApplicationConfiguration(false).Result;
// check the application certificate.
bool haveAppCertificate = _application.CheckApplicationInstanceCertificate(false, 0).Result;
if (!haveAppCertificate)
{
Logger.Fatal($"{logPrefix} Application instance certificate invalid!");
throw new Exception("Application instance certificate invalid!");
}
if (haveAppCertificate)
{
_config.ApplicationUri = Utils.GetApplicationUriFromCertificate(_config.SecurityConfiguration.ApplicationCertificate.Certificate);
if (_config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
AutoAccept = true;
}
_config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
}
else
{
Logger.Warning($"{logPrefix} Missing application certificate, using unsecure connection.");
}
Logger.Information($"{logPrefix} Discover endpoints of {PublisherUrl}.");
_selectedEndpoint = CoreClientUtils.SelectEndpoint(PublisherUrl, haveAppCertificate, 15000);
Logger.Information($"{logPrefix} Selected endpoint uses: {0}",
_selectedEndpoint.SecurityPolicyUri.Substring(_selectedEndpoint.SecurityPolicyUri.LastIndexOf('#') + 1));
Logger.Information($"{logPrefix} Create a session with OPC UA server.");
_endpointConfiguration = EndpointConfiguration.Create(_config);
_configuredEndpoint = new ConfiguredEndpoint(null, _selectedEndpoint, _endpointConfiguration);
// create session
_session = Session.Create(_config, _configuredEndpoint, false, "OPC UA Console Client", 60000, new UserIdentity(new AnonymousIdentityToken()), null).Result;
_session.KeepAlive += Client_KeepAlive;
Logger.Information($"{logPrefix} Browse the OPC UA server namespace.");
ReferenceDescriptionCollection references;
Byte[] continuationPoint;
references = _session.FetchReferences(ObjectIds.ObjectsFolder);
_session.Browse(
null,
null,
ObjectIds.ObjectsFolder,
0u,
BrowseDirection.Forward,
ReferenceTypeIds.HierarchicalReferences,
true,
(uint)NodeClass.Variable | (uint)NodeClass.Object | (uint)NodeClass.Method,
out continuationPoint,
out references);
Logger.Information($"{logPrefix} DisplayName, BrowseName, NodeClass");
foreach (var rd in references)
{
Logger.Information($"{logPrefix} {rd.DisplayName}, {rd.BrowseName}, {rd.NodeClass}");
ReferenceDescriptionCollection nextRefs;
byte[] nextCp;
_session.Browse(
null,
null,
ExpandedNodeId.ToNodeId(rd.NodeId, _session.NamespaceUris),
0u,
BrowseDirection.Forward,
ReferenceTypeIds.HierarchicalReferences,
true,
(uint)NodeClass.Variable | (uint)NodeClass.Object | (uint)NodeClass.Method,
out nextCp,
out nextRefs);
foreach (var nextRd in nextRefs)
{
Logger.Information($"{logPrefix} + {nextRd.DisplayName}, {nextRd.BrowseName}, {nextRd.NodeClass}");
}
_publishingIntervalSec = maxLongWaitSec;
Logger.Information($"{logPrefix} Create a subscription with publishing interval of {_publishingIntervalSec} second.");
var subscription = new Subscription(_session.DefaultSubscription)
{
PublishingInterval = _publishingIntervalSec * 1000
};
Logger.Information($"{logPrefix} Add a list of items (server current time and status) to the subscription.");
var list = new List <MonitoredItem> {
new MonitoredItem(subscription.DefaultItem)
{
DisplayName = "ServerStatusCurrentTime", StartNodeId = "i=" + Variables.Server_ServerStatus_CurrentTime.ToString(CultureInfo.InvariantCulture)
}
};
_lastTimestamp = new DateTime(0);
list.ForEach(i => i.Notification += OnNotification);
subscription.AddItems(list);
Logger.Information($"{logPrefix} Add the subscription to the session.");
_session.AddSubscription(subscription);
subscription.Create();
//await Task.Delay(-1, ct);
//subscription.Delete(true);
}
}
static void Main(string[] args)
{
Console.WriteLine("Create application configuration and certificate, start connection and extraction...");
var config = new ApplicationConfiguration()
{
ApplicationName = "UABenchMarks",
ApplicationUri = Utils.Format(@"urn:{0}:UABenchMarks", System.Net.Dns.GetHostName()),
ApplicationType = ApplicationType.Client,
SecurityConfiguration = new SecurityConfiguration
{
ApplicationCertificate = new CertificateIdentifier {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\MachineDefault", SubjectName = Utils.Format(@"CN={0}, DC={1}", "MyHomework", System.Net.Dns.GetHostName())
},
TrustedIssuerCertificates = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\UA Certificate Authorities"
},
TrustedPeerCertificates = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\UA Applications"
},
RejectedCertificateStore = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\RejectedCertificates"
},
AutoAcceptUntrustedCertificates = true,
AddAppCertToTrustedStore = true
},
TransportConfigurations = new TransportConfigurationCollection(),
TransportQuotas = new TransportQuotas {
OperationTimeout = 15000
},
ClientConfiguration = new ClientConfiguration {
DefaultSessionTimeout = 60000
},
TraceConfiguration = new TraceConfiguration()
};
config.Validate(ApplicationType.Client).GetAwaiter().GetResult();
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
config.CertificateValidator.CertificateValidation += (s, e) => { e.Accept = (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted); };
}
var application = new ApplicationInstance
{
ApplicationName = "UABenchMarks",
ApplicationType = ApplicationType.Client,
ApplicationConfiguration = config
};
application.CheckApplicationInstanceCertificate(false, 2048).GetAwaiter().GetResult();
var selectedEndpoint = CoreClientUtils.SelectEndpoint(DiscoveryUrl, useSecurity: false, operationTimeout: 15000);
using (var session = Session.Create(config, new ConfiguredEndpoint(null, selectedEndpoint, EndpointConfiguration.Create(config)), false, "", 60000, null, null).GetAwaiter().GetResult())
{
Console.WriteLine("Trying QueryFirst Call...");
//QueryFirstCall(session);
Console.WriteLine("Start Fetch...");
startTime = DateTime.Now;
BrowseRootTree(session);
DateTime end = DateTime.Now;
TimeSpan ts = end - startTime;
Console.WriteLine("Total Net Calls: {0}", netCalls);
Console.WriteLine("Total Nodes Found: {0}", totalNodes);
Console.WriteLine("Total Get Time: Seconds: {1}", ts.TotalMinutes, ts.TotalSeconds);
//Console.WriteLine("Step 4 - Create a subscription. Set a faster publishing interval if you wish.");
//var subscription = new Subscription(session.DefaultSubscription) { PublishingInterval = 30000 };
//Console.WriteLine("Step 5 - Add a list of items you wish to monitor to the subscription.");
//var list = new List<MonitoredItem> { new MonitoredItem(subscription.DefaultItem) { DisplayName = "ServerStatusCurrentTime", StartNodeId = "i=2258" } };
//list.ForEach(i => i.Notification += OnNotification);
//subscription.AddItems(list);
//Console.WriteLine("Step 6 - Add the subscription to the session.");
//session.AddSubscription(subscription);
//subscription.Create();
//Console.WriteLine("Press any key to remove subscription...");
//Console.ReadKey(true);
}
Console.WriteLine("Press any key to exit...");
Console.ReadKey(true);
}
async void OnConnect(object sender, EventArgs e)
{
DisconnectClient();
if (UsernameEntry.Text == "" || PasswordEntry.Text == "")
{
await DisplayAlert("Error", "Please enter administrator username/password", "Dismiss");
}
else
{
ConnectIndicator.IsRunning = true;
ApplicationInstance application = new ApplicationInstance();
application.ApplicationType = Opc.Ua.ApplicationType.Client;
application.ConfigSectionName = "Opc.Ua.GdsClient";
// load the application configuration.
ApplicationConfiguration config = application.LoadApplicationConfiguration(false).Result;
// check the application certificate.
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, 0);
bool connectToServer = true;
if (!haveAppCertificate)
{
connectToServer = await DisplayAlert("Warning", "missing application certificate, \nusing unsecure connection. \nDo you want to continue?", "Yes", "No");
}
config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
if (connectToServer == true)
{
try
{
// connect to OPC UA server
PushClient = new ServerPushConfigurationClient(application);
PushClient.AdminCredentials = new UserIdentity(UsernameEntry.Text, PasswordEntry.Text);
await PushClient.Connect(DiscoveryUrlsPicker.Items[DiscoveryUrlsPicker.SelectedIndex]);
if (PushClient.IsConnected)
{
if (CreatePushButton.Text == "CreateCSR")
{
var app = (ApplicationRecordApiModel)BindingContext;
var Page = new ServerCertGrpPage(PushClient, this._opcVaultServiceClient);
Page.BindingContext = app;
await Navigation.PushAsync(Page);
}
else
{
await Navigation.PushAsync(new ServerCertGrpPage(PushClient, this._opcVaultServiceClient, this._cert, this._issuer, this._crl, ((CertificateRequestIndexApiModel)this.BindingContext).RequestId));
}
}
}
catch (Exception ee)
{
ConnectIndicator.IsRunning = false;
await Xamarin.Forms.Application.Current.MainPage.DisplayAlert("An error has occurred", "Exception message: " + ee.Message, "Dismiss");
}
}
else
{
ConnectIndicator.IsRunning = false;
}
}
}
public static void Main(string[] args)
{
ApplicationInstance.MessageDlg = new ApplicationMessageDlg();
ApplicationInstance application = new ApplicationInstance();
application.ApplicationName = "UA AMQP Publisher";
application.ApplicationType = ApplicationType.ClientAndServer;
application.ConfigSectionName = "Opc.Ua.Publisher";
try
{
// load the application configuration.
Task <ApplicationConfiguration> task = application.LoadApplicationConfiguration(false);
task.Wait();
m_configuration = task.Result;
// check the application certificate.
Task <bool> task2 = application.CheckApplicationInstanceCertificate(false, 0);
task2.Wait();
bool certOK = task2.Result;
if (!certOK)
{
throw new Exception("Application instance certificate invalid!");
}
// start the server.
Task task3 = application.Start(new SampleServer());
task3.Wait();
// get list of cached endpoints.
m_endpoints = m_configuration.LoadCachedEndpoints(true);
m_endpoints.DiscoveryUrls = m_configuration.ClientConfiguration.WellKnownDiscoveryUrls;
// start publishers.
m_publishers = AmqpConnectionCollection.Load(m_configuration);
foreach (AmqpConnection publisher in m_publishers)
{
Task t = publisher.OpenAsync();
}
m_MonitoredItem_Notification = new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
// connect to a server.
EndpointConnect();
// publish preconfigured nodes
PublishedNodesCollection nodes = PublishedNodesCollection.Load(m_configuration);
foreach (NodeId node in nodes)
{
CreateMonitoredItem(node);
}
Console.WriteLine("Publisher started. Press any key to exit...");
Console.ReadKey(true);
if (m_publishers != null)
{
foreach (var publisher in m_publishers)
{
publisher.Close();
}
}
if (m_session != null)
{
m_session.Close();
}
}
catch (ServiceResultException ex)
{
Utils.Trace("ServiceResultException:" + ex.Message);
Console.WriteLine("Exception: {0}", ex.Message);
Console.WriteLine("Press any key to exit...");
Console.ReadKey(true);
}
}
private async Task <Session> ConsoleSampleClient()
{
Console.WriteLine("1 - Create an Application Configuration.");
ExitCode = ExitCode.ErrorCreateApplication;
ApplicationInstance application = new ApplicationInstance {
ApplicationName = "UA Core Complex Client",
ApplicationType = ApplicationType.Client,
ConfigSectionName = "Opc.Ua.ComplexClient"
};
// load the application configuration.
ApplicationConfiguration config = await application.LoadApplicationConfiguration(false).ConfigureAwait(false);
// check the application certificate.
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, 0).ConfigureAwait(false);
if (!haveAppCertificate)
{
throw new Exception("Application instance certificate invalid!");
}
if (ReverseConnectUri != null)
{
// start the reverse connection manager
m_reverseConnectManager = new ReverseConnectManager();
m_reverseConnectManager.AddEndpoint(ReverseConnectUri);
m_reverseConnectManager.StartService(config);
}
if (haveAppCertificate)
{
config.ApplicationUri = X509Utils.GetApplicationUriFromCertificate(config.SecurityConfiguration.ApplicationCertificate.Certificate);
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
m_autoAccept = true;
}
config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
}
else
{
Console.WriteLine(" WARN: missing application certificate, using unsecure connection.");
}
Console.WriteLine("2 - Discover endpoints of {0}.", m_endpointURL);
ExitCode = ExitCode.ErrorDiscoverEndpoints;
EndpointDescription selectedEndpoint;
if (m_reverseConnectManager == null)
{
selectedEndpoint = CoreClientUtils.SelectEndpoint(m_endpointURL, haveAppCertificate && !SecurityNone, 15000);
}
else
{
Console.WriteLine(" Waiting for reverse connection.");
ITransportWaitingConnection connection = await m_reverseConnectManager.WaitForConnection(
new Uri(m_endpointURL), null, new CancellationTokenSource(60000).Token);
if (connection == null)
{
throw new ServiceResultException(StatusCodes.BadTimeout, "Waiting for a reverse connection timed out.");
}
selectedEndpoint = CoreClientUtils.SelectEndpoint(config, connection, haveAppCertificate && !SecurityNone, 15000);
}
Console.WriteLine(" Selected endpoint uses: {0}",
selectedEndpoint.SecurityPolicyUri.Substring(selectedEndpoint.SecurityPolicyUri.LastIndexOf('#') + 1));
Console.WriteLine("3 - Create a session with OPC UA server.");
ExitCode = ExitCode.ErrorCreateSession;
// create the user identity
UserIdentity userIdentity;
if (String.IsNullOrEmpty(Username) && String.IsNullOrEmpty(Password))
{
userIdentity = new UserIdentity(new AnonymousIdentityToken());
}
else
{
userIdentity = new UserIdentity(Username, Password);
}
// create worker session
if (m_reverseConnectManager == null)
{
m_session = await CreateSession(config, selectedEndpoint, userIdentity).ConfigureAwait(false);
}
else
{
Console.WriteLine(" Waiting for reverse connection.");
ITransportWaitingConnection connection = await m_reverseConnectManager.WaitForConnection(
new Uri(m_endpointURL), null, new CancellationTokenSource(60000).Token).ConfigureAwait(false);
if (connection == null)
{
throw new ServiceResultException(StatusCodes.BadTimeout, "Waiting for a reverse connection timed out.");
}
m_session = await CreateSession(config, connection, selectedEndpoint, userIdentity).ConfigureAwait(false);
}
// register keep alive handler
m_session.KeepAlive += Client_KeepAlive;
Console.WriteLine("4 - Browse for all custom type variables.");
ExitCode = ExitCode.ErrorReadComplexTypes;
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
var allVariableNodes = BrowseAdddressSpace ? BrowseAllVariables() : new List <INode>();
var allCustomTypeVariables = allVariableNodes.Where(n => ((VariableNode)n).DataType.NamespaceIndex != 0).ToList();
stopWatch.Stop();
Console.WriteLine($" -- Browse all nodes took {stopWatch.ElapsedMilliseconds}ms.");
Console.WriteLine($" -- Browsed {allVariableNodes.Count} nodes, from which {allCustomTypeVariables.Count} are custom type variables.");
stopWatch.Reset();
// for testing clear the nodecache
m_session.NodeCache.Clear();
stopWatch.Start();
if (LoadTypeSystem)
{
Console.WriteLine("5 - Load the server type dictionary.");
ExitCode = ExitCode.ErrorLoadTypeDictionary;
stopWatch.Reset();
stopWatch.Start();
var complexTypeSystem = new ComplexTypeSystem(m_session);
await complexTypeSystem.Load().ConfigureAwait(false);
stopWatch.Stop();
Console.WriteLine($"Load type system took {stopWatch.ElapsedMilliseconds}ms.");
Console.WriteLine($"Custom types defined for this session:");
foreach (var type in complexTypeSystem.GetDefinedTypes())
{
Console.WriteLine($"{type.Namespace}.{type.Name}");
}
Console.WriteLine($"Loaded {m_session.DataTypeSystem.Count} dictionaries:");
foreach (var dictionary in m_session.DataTypeSystem)
{
Console.WriteLine($" + {dictionary.Value.Name}");
foreach (var type in dictionary.Value.DataTypes)
{
Console.WriteLine($" -- {type.Key}:{type.Value}");
}
}
}
else
{
Console.WriteLine("4 - Not loading the server type dictionary.");
}
foreach (VariableNode variableNode in allCustomTypeVariables)
{
try
{
var value = m_session.ReadValue(variableNode.NodeId);
CastInt32ToEnum(variableNode, value);
Console.WriteLine($" -- {variableNode}:{value}");
if (value.Value is ExtensionObject extensionObject)
{
if (extensionObject.Body is BaseComplexType complexType)
{
foreach (var item in complexType.GetPropertyEnumerator())
{
if (Verbose)
{
Console.WriteLine($" -- -- {item.Name}:{complexType[item.Name]}");
}
if (WriteComplexInt && item.PropertyType == typeof(Int32))
{
var data = complexType[item.Name];
if (data != null)
{
complexType[item.Name] = (Int32)data + 1;
}
Console.WriteLine($" -- -- Increment: {item.Name}, {complexType[item.Name]}");
WriteValue(m_session, variableNode.NodeId, value);
}
}
}
}
if (PrintAsJson)
{
PrintValueAsJson(variableNode.BrowseName.Name, value);
}
}
catch (ServiceResultException sre)
{
if (sre.StatusCode == StatusCodes.BadUserAccessDenied)
{
Console.WriteLine($" -- {variableNode}: Access denied!");
}
}
}
Console.WriteLine("6 - Create test sessions which load only single types as needed.");
if (LoadTypeSystem)
{
foreach (VariableNode variableNode in allCustomTypeVariables)
{
Session testSession = null;
try
{
Console.WriteLine($"Open session for {variableNode}:");
testSession = await CreateSession(config, selectedEndpoint, userIdentity).ConfigureAwait(false);
var complexTypeSystem = new ComplexTypeSystem(testSession);
NodeId dataType = variableNode.DataType;
Type nullType = testSession.Factory.GetSystemType(dataType);
var valueBefore = testSession.ReadValue(variableNode.NodeId);
Console.WriteLine($" -- {valueBefore}");
Type systemType = await complexTypeSystem.LoadType(dataType).ConfigureAwait(false);
var valueAfter = testSession.ReadValue(variableNode.NodeId);
Console.WriteLine($" -- {variableNode}: {systemType} {dataType}");
Console.WriteLine($" -- {valueAfter}");
Console.WriteLine($"Custom types defined for {variableNode}:");
foreach (var type in complexTypeSystem.GetDefinedTypes())
{
Console.WriteLine($" -- {type.Namespace}.{type.Name}");
}
}
catch (ServiceResultException sre)
{
if (sre.StatusCode == StatusCodes.BadUserAccessDenied)
{
Console.WriteLine($" -- {variableNode}: Access denied!");
}
}
finally
{
testSession?.Close();
}
}
}
else
{
Console.WriteLine("6 - Not testing to load individual types.");
}
Console.WriteLine("7 - Create a subscription with publishing interval of 1 second.");
ExitCode = ExitCode.ErrorCreateSubscription;
var subscription = new Subscription(m_session.DefaultSubscription)
{
PublishingInterval = 1000
};
Console.WriteLine("8 - Add all custom values and the server time to the subscription.");
ExitCode = ExitCode.ErrorMonitoredItem;
var list = new List <MonitoredItem> {
new MonitoredItem(subscription.DefaultItem)
{
DisplayName = "ServerStatusCurrentTime", StartNodeId = "i=" + Variables.Server_ServerStatus_CurrentTime.ToString()
}
};
list.ForEach(i => i.Notification += OnNotification);
foreach (var customVariable in allCustomTypeVariables)
{
var newItem = new MonitoredItem(subscription.DefaultItem)
{
DisplayName = customVariable.DisplayName.Text,
StartNodeId = ExpandedNodeId.ToNodeId(customVariable.NodeId, m_session.NamespaceUris)
};
newItem.Notification += OnComplexTypeNotification;
list.Add(newItem);
}
subscription.AddItems(list);
Console.WriteLine("9 - Add the subscription to the session.");
ExitCode = ExitCode.ErrorAddSubscription;
m_session.AddSubscription(subscription);
subscription.Create();
Console.WriteLine("10 - Running...Press Ctrl-C to exit...");
ExitCode = ExitCode.ErrorRunning;
return(m_session);
}
public void SubscripeToOpcUaServer(string OpcUaEndpoint, List <string> NoteIdList)
{
var config = new ApplicationConfiguration()
{
ApplicationName = "OpcUaClientconifg",
ApplicationUri = Utils.Format(@"urn:{0}:OpcUaClient", System.Net.Dns.GetHostName()),
ApplicationType = ApplicationType.Client,
SecurityConfiguration = new SecurityConfiguration
{
ApplicationCertificate = new CertificateIdentifier {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\MachineDefault", SubjectName = Utils.Format(@"CN={0}, DC={1}", "MyHomework", System.Net.Dns.GetHostName())
},
TrustedIssuerCertificates = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\UA Certificate Authorities"
},
TrustedPeerCertificates = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\UA Applications"
},
RejectedCertificateStore = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\RejectedCertificates"
},
AutoAcceptUntrustedCertificates = true,
AddAppCertToTrustedStore = true,
RejectSHA1SignedCertificates = false,
MinimumCertificateKeySize = 1024
},
TransportConfigurations = new TransportConfigurationCollection(),
TransportQuotas = new TransportQuotas {
OperationTimeout = 15000
},
ClientConfiguration = new ClientConfiguration {
DefaultSessionTimeout = 60000
},
TraceConfiguration = new TraceConfiguration()
};
config.Validate(ApplicationType.Client).GetAwaiter().GetResult();
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
config.CertificateValidator.CertificateValidation += (s, e) => { e.Accept = (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted); };
}
var application = new ApplicationInstance
{
ApplicationName = "OpcUaClient",
ApplicationType = ApplicationType.Client,
ApplicationConfiguration = config
};
application.CheckApplicationInstanceCertificate(false, 2048).GetAwaiter().GetResult();
var selectedEndpoint = CoreClientUtils.SelectEndpoint(OpcUaEndpoint, useSecurity: false, operationTimeout: 15000); //"opc.tcp://141.60.104.13:4840"
session = Session.Create(config, new ConfiguredEndpoint(null, selectedEndpoint, EndpointConfiguration.Create(config)), false, "", 60000, null, null).GetAwaiter().GetResult();
{
ReferenceDescriptionCollection refs;
Byte[] cp;
session.Browse(null, null, ObjectIds.ObjectsFolder, 0u, BrowseDirection.Forward, ReferenceTypeIds.HierarchicalReferences, true, (uint)NodeClass.Variable | (uint)NodeClass.Object | (uint)NodeClass.Method, out cp, out refs);
foreach (var rd in refs)
{
ReferenceDescriptionCollection nextRefs;
byte[] nextCp;
session.Browse(null, null, ExpandedNodeId.ToNodeId(rd.NodeId, session.NamespaceUris), 0u, BrowseDirection.Forward, ReferenceTypeIds.HierarchicalReferences, true, (uint)NodeClass.Variable | (uint)NodeClass.Object | (uint)NodeClass.Method, out nextCp, out nextRefs);
}
var subscription = new Subscription(session.DefaultSubscription)
{
PublishingInterval = 1000
};
list = new List <MonitoredItem>();
foreach (var item in NoteIdList)
{
var monitoredItem = new MonitoredItem(subscription.DefaultItem)
{
StartNodeId = item
};
list.Add(monitoredItem);
}
subscription.AddItems(list);
session.AddSubscription(subscription);
subscription.Create();
}
}
public async void CreateCertificate(AssetManager assets)
{
ApplicationInstance application = new ApplicationInstance
{
ApplicationType = ApplicationType.Client,
ConfigSectionName = "Opc.Ua.AIS_Demonstrator" /// [...] sets the name of the config section containing the path to the application configuration file.
};
/*
* // Old code to find location of config.xml file + load its content into "context" variable.
* // Instead, the CreateCertificate Variable is now called with the content string as a parameter since the AssetManager needs to be instantiated in an Activity
* string currentFolder = DependencyService.Get<IPathService>().PublicExternalFolder.ToString();
* string filename = application.ConfigSectionName + ".Config.xml";
* string content = DependencyService.Get<IAssetService>().LoadFile(filename);
* File.WriteAllText(currentFolder + filename, content);
*/
// new code to find location of config.xml file + load its content into "context" variable
// the CreateCertificate Variable is now called with the content string as a parameter since the AssetManager needs to be instantiated in an Activity
string configFilename = application.ConfigSectionName + ".Config.xml";
string serverCertFilename = "server_selfsigned_cert_2048.pem";
string clientCertFilename = "client_selfsigned_cert_2048.pem";
string currentFolder = Environment.GetFolderPath(Environment.SpecialFolder.Personal); // gets the path of the Internal Storage as a string
string PKIPath = "/storage/emulated/0/OPC Foundation/PKI/";
Directory.CreateDirectory(PKIPath + "trusted/");
Directory.CreateDirectory(PKIPath + "own/");
ServerCertPath = PKIPath + "trusted/" + serverCertFilename;
ClientCertPath = PKIPath + "own/" + clientCertFilename;
configPath = currentFolder + configFilename;
// in case the config file doesn't exist: create new config file in internal storage as a copy of the Asset config
if (!File.Exists(currentFolder + configFilename))
{
string content;
using (StreamReader sr = new StreamReader(assets.Open(configFilename)))
{
content = sr.ReadToEnd();
}
File.WriteAllText(currentFolder + configFilename, content);
}
else
{ // The config file already exists
// Load configuration from file
config = await application.LoadApplicationConfiguration(currentFolder + configFilename, false);
}
// in case the server certificate file doesn't exist: create new certificate file in internal storage as a copy of the Asset server certificate
if (!File.Exists(ServerCertPath))
{
assets.Open(serverCertFilename).CopyTo(File.Create(ServerCertPath));
/* string content;
* using (StreamReader sr = new StreamReader(assets.Open(serverCertFilename)))
* {
* content = sr.ReadToEnd();
* }
* File.WriteAllText(ServerCertPath, content);*/
}
// check the application certificate.
haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, 0);
// haveAppCertificate = config.SecurityConfiguration.ApplicationCertificate.Certificate != null; // ToDo Delete this line or the one above
// Create a new app certificate if no certificate is present
if (!haveAppCertificate)
{
X509Certificate2 appCertificate = CertificateFactory.CreateCertificate(
config.SecurityConfiguration.ApplicationCertificate.StoreType, // string storeType
config.SecurityConfiguration.ApplicationCertificate.StorePath, // string storePath
null, // string password
config.ApplicationUri, // string applicationUri
config.ApplicationName, // string applicationName
config.SecurityConfiguration.ApplicationCertificate.SubjectName, // string subjectName
null, // IList<string> domainNames
2048, // ushort KeySize
DateTime.UtcNow - TimeSpan.FromDays(1), // DateTime startDate
24, // ushort lifetimeInMonths
256, // ushort hashSizeInBits
false, // bool isCA; default = false
null, // X509certificate2 issuerCACertKey
null // byte[] publicKey; default = null
);
config.SecurityConfiguration.ApplicationCertificate.Certificate = appCertificate;
}
if (haveAppCertificate)
{
config.ApplicationUri = Utils.GetApplicationUriFromCertificate(config.SecurityConfiguration.ApplicationCertificate.Certificate);
config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
}
}
public void InitializeOPCUAClient()
{
//Console.WriteLine("Step 1 - Create application configuration and certificate.");
var config = new ApplicationConfiguration()
{
ApplicationName = MyApplicationName,
ApplicationUri = Utils.Format(@"urn:{0}:" + MyApplicationName + "", ServerAddress),
ApplicationType = ApplicationType.Client,
SecurityConfiguration = new SecurityConfiguration
{
ApplicationCertificate = new CertificateIdentifier {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\MachineDefault", SubjectName = Utils.Format(@"CN={0}, DC={1}", MyApplicationName, ServerAddress)
},
TrustedIssuerCertificates = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\UA Certificate Authorities"
},
TrustedPeerCertificates = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\UA Applications"
},
RejectedCertificateStore = new CertificateTrustList {
StoreType = @"Directory", StorePath = @"%CommonApplicationData%\OPC Foundation\CertificateStores\RejectedCertificates"
},
AutoAcceptUntrustedCertificates = true,
AddAppCertToTrustedStore = true
},
TransportConfigurations = new TransportConfigurationCollection(),
TransportQuotas = new TransportQuotas {
OperationTimeout = 15000
},
ClientConfiguration = new ClientConfiguration {
DefaultSessionTimeout = 60000
},
TraceConfiguration = new TraceConfiguration()
};
config.Validate(ApplicationType.Client).GetAwaiter().GetResult();
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
config.CertificateValidator.CertificateValidation += (s, e) => { e.Accept = (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted); };
}
var application = new ApplicationInstance
{
ApplicationName = MyApplicationName,
ApplicationType = ApplicationType.Client,
ApplicationConfiguration = config
};
application.CheckApplicationInstanceCertificate(false, 2048).GetAwaiter().GetResult();
//string serverAddress = Dns.GetHostName();
string serverAddress = ServerAddress;;
var selectedEndpoint = CoreClientUtils.SelectEndpoint("opc.tcp://" + serverAddress + ":" + ServerPortNumber + "", useSecurity: SecurityEnabled, operationTimeout: 15000);
// Console.WriteLine($"Step 2 - Create a session with your server: {selectedEndpoint.EndpointUrl} ");
OPCSession = Session.Create(config, new ConfiguredEndpoint(null, selectedEndpoint, EndpointConfiguration.Create(config)), false, "", 60000, null, null).GetAwaiter().GetResult();
{
//Console.WriteLine("Step 4 - Create a subscription. Set a faster publishing interval if you wish.");
var subscription = new Subscription(OPCSession.DefaultSubscription)
{
PublishingInterval = 1000
};
//Console.WriteLine("Step 5 - Add a list of items you wish to monitor to the subscription.");
var list = new List <MonitoredItem> {
};
//list.Add(new MonitoredItem(subscription.DefaultItem) { DisplayName = "M0404.CPU945.iBatchOutput", StartNodeId = "ns=2;s=M0404.CPU945.iBatchOutput" });
list.Add(new MonitoredItem(subscription.DefaultItem)
{
DisplayName = "ServerStatusCurrentTime", StartNodeId = "i=2258"
});
foreach (KeyValuePair <string, TagClass> td in TagList)
{
list.Add(new MonitoredItem(subscription.DefaultItem)
{
DisplayName = td.Value.DisplayName, StartNodeId = "ns=" + OPCNameSpace + ";s=" + td.Value.NodeID + ""
});
}
list.ForEach(i => i.Notification += OnTagValueChange);
subscription.AddItems(list);
//Console.WriteLine("Step 6 - Add the subscription to the session.");
OPCSession.AddSubscription(subscription);
subscription.Create();
}
}
/// <summary>
/// Main entry point.
/// </summary>
public static async Task Main(string[] args)
{
TextWriter output = Console.Out;
output.WriteLine("OPC UA Console Reference Client");
// The application name and config file names
var applicationName = "ConsoleReferenceClient";
var configSectionName = "Quickstarts.ReferenceClient";
var usage = $"Usage: dotnet {applicationName}.dll [OPTIONS]";
// command line options
bool showHelp = false;
bool autoAccept = false;
bool logConsole = false;
bool appLog = false;
bool renewCertificate = false;
string password = null;
int timeout = Timeout.Infinite;
Mono.Options.OptionSet options = new Mono.Options.OptionSet {
usage,
{ "h|help", "show this message and exit", h => showHelp = h != null },
{ "a|autoaccept", "auto accept certificates (for testing only)", a => autoAccept = a != null },
{ "c|console", "log to console", c => logConsole = c != null },
{ "l|log", "log app output", c => appLog = c != null },
{ "p|password="******"optional password for private key", (string p) => password = p },
{ "r|renew", "renew application certificate", r => renewCertificate = r != null },
{ "t|timeout=", "timeout in seconds to exit application", (int t) => timeout = t * 1000 },
};
try
{
// parse command line and set options
var extraArg = ConsoleUtils.ProcessCommandLine(output, args, options, ref showHelp, false);
// connect Url?
Uri serverUrl = new Uri("opc.tcp://localhost:62541/Quickstarts/ReferenceServer");
if (!string.IsNullOrEmpty(extraArg))
{
serverUrl = new Uri(extraArg);
}
// log console output to logger
if (logConsole && appLog)
{
output = new LogWriter();
}
// Define the UA Client application
ApplicationInstance.MessageDlg = new ApplicationMessageDlg(output);
CertificatePasswordProvider PasswordProvider = new CertificatePasswordProvider(password);
ApplicationInstance application = new ApplicationInstance {
ApplicationName = applicationName,
ApplicationType = ApplicationType.Client,
ConfigSectionName = configSectionName,
CertificatePasswordProvider = PasswordProvider
};
// load the application configuration.
var config = await application.LoadApplicationConfiguration(silent : false);
// setup the logging
ConsoleUtils.ConfigureLogging(config, applicationName, logConsole, LogLevel.Information);
// delete old certificate
if (renewCertificate)
{
await application.DeleteApplicationInstanceCertificate().ConfigureAwait(false);
}
// check the application certificate.
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, minimumKeySize : 0).ConfigureAwait(false);
if (!haveAppCertificate)
{
throw new ErrorExitException("Application instance certificate invalid!", ExitCode.ErrorCertificate);
}
// wait for timeout or Ctrl-C
var quitEvent = ConsoleUtils.CtrlCHandler();
// connect to a server until application stopped
bool quit = false;
DateTime start = DateTime.UtcNow;
int waitTime = int.MaxValue;
do
{
if (timeout > 0)
{
waitTime = timeout - (int)DateTime.UtcNow.Subtract(start).TotalMilliseconds;
if (waitTime <= 0)
{
break;
}
}
// create the UA Client object and connect to configured server.
UAClient uaClient = new UAClient(application.ApplicationConfiguration, output, ClientBase.ValidateResponse)
{
AutoAccept = autoAccept
};
bool connected = await uaClient.ConnectAsync(serverUrl.ToString());
if (connected)
{
// Run tests for available methods.
uaClient.ReadNodes();
uaClient.WriteNodes();
uaClient.Browse();
uaClient.CallMethod();
uaClient.SubscribeToDataChanges();
// Wait for some DataChange notifications from MonitoredItems
quit = quitEvent.WaitOne(Math.Min(30_000, waitTime));
uaClient.Disconnect();
}
else
{
output.WriteLine("Could not connect to server! Retry in 10 seconds or Ctrl-C to quit.");
quit = quitEvent.WaitOne(Math.Min(10_000, waitTime));
}
} while (!quit);
output.WriteLine("\nClient stopped.");
}
catch (Exception ex)
{
output.WriteLine(ex.Message);
}
}
//TODO [TestCase(InvalidCertType.KeySize1024, true, false)]
public async Task TestInvalidAppCertChainDoNotRecreate(InvalidCertType certType, bool server, bool suppress)
{
// pki directory root for test runs.
var pkiRoot = Path.GetTempPath() + Path.GetRandomFileName() + Path.DirectorySeparatorChar;
var applicationInstance = new ApplicationInstance()
{
ApplicationName = ApplicationName
};
Assert.NotNull(applicationInstance);
ApplicationConfiguration config;
if (server)
{
config = await applicationInstance.Build(ApplicationUri, ProductUri)
.AsServer(new string[] { "opc.tcp://localhost:12345/Configuration" })
.AddSecurityConfiguration(SubjectName, pkiRoot)
.Create().ConfigureAwait(false);
}
else
{
config = await applicationInstance.Build(ApplicationUri, ProductUri)
.AsClient()
.AddSecurityConfiguration(SubjectName, pkiRoot)
.Create().ConfigureAwait(false);
}
Assert.NotNull(config);
CertificateIdentifier applicationCertificate = applicationInstance.ApplicationConfiguration.SecurityConfiguration.ApplicationCertificate;
Assert.IsNull(applicationCertificate.Certificate);
var testCerts = CreateInvalidCertChain(certType);
if (certType != InvalidCertType.NoIssuer)
{
using (var issuerCert = testCerts[1])
{
Assert.NotNull(issuerCert);
Assert.False(issuerCert.HasPrivateKey);
issuerCert.AddToStore(
applicationInstance.ApplicationConfiguration.SecurityConfiguration.TrustedIssuerCertificates.StoreType,
applicationInstance.ApplicationConfiguration.SecurityConfiguration.TrustedIssuerCertificates.StorePath
);
}
}
X509Certificate2 publicKey = null;
using (var testCert = testCerts[0])
{
Assert.NotNull(testCert);
Assert.True(testCert.HasPrivateKey);
testCert.AddToStore(
applicationCertificate.StoreType,
applicationCertificate.StorePath
);
publicKey = new X509Certificate2(testCert.RawData);
}
using (publicKey)
{
if (suppress)
{
bool certOK = await applicationInstance.CheckApplicationInstanceCertificate(true, 0)
.ConfigureAwait(false);
Assert.True(certOK);
Assert.AreEqual(publicKey, applicationCertificate.Certificate);
}
else
{
var sre = Assert.ThrowsAsync <ServiceResultException>(async() =>
await applicationInstance.CheckApplicationInstanceCertificate(true, 0).ConfigureAwait(false));
Assert.AreEqual(StatusCodes.BadConfigurationError, sre.StatusCode);
}
}
}
/// <summary>
/// Start server
/// </summary>
/// <param name="ports"></param>
/// <param name="pkiRootPath"></param>
/// <returns></returns>
private async Task StartServerInternalAsync(IEnumerable <int> ports, string pkiRootPath)
{
ApplicationInstance.MessageDlg = new DummyDialog();
var config = _factory.CreateServer(ports, pkiRootPath, out _server);
_logger.Information("Server created...");
config = ApplicationInstance.FixupAppConfig(config);
_logger.Information("Validate configuration...");
await config.Validate(ApplicationType.Server);
config.SecurityConfiguration.AutoAcceptUntrustedCertificates = AutoAccept;
config.CertificateValidator = new CertificateValidator();
config.CertificateValidator.CertificateValidation += (v, e) => {
if (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted)
{
e.Accept = AutoAccept;
_logger.Information((e.Accept ? "Accepted" : "Rejected") +
" Certificate {subject}", e.Certificate.Subject);
}
};
_logger.Information("Initialize certificate validation...");
await config.CertificateValidator.Update(config.SecurityConfiguration);
var cert = config.SecurityConfiguration.ApplicationCertificate.Certificate;
if (cert == null)
{
_logger.Information("Creating new certificate in {path}...",
config.SecurityConfiguration.ApplicationCertificate.StorePath);
// Create cert
#pragma warning disable IDE0067 // Dispose objects before losing scope
cert = CertificateFactory.CreateCertificate(
config.SecurityConfiguration.ApplicationCertificate.StoreType,
config.SecurityConfiguration.ApplicationCertificate.StorePath,
null, config.ApplicationUri, config.ApplicationName,
config.SecurityConfiguration.ApplicationCertificate.SubjectName,
null, CertificateFactory.defaultKeySize,
DateTime.UtcNow - TimeSpan.FromDays(1),
CertificateFactory.defaultLifeTime,
CertificateFactory.defaultHashSize);
#pragma warning restore IDE0067 // Dispose objects before losing scope
config.SecurityConfiguration.ApplicationCertificate.Certificate = cert;
await config.CertificateValidator.UpdateCertificate(config.SecurityConfiguration);
}
config.ApplicationUri = Utils.GetApplicationUriFromCertificate(cert);
var application = new ApplicationInstance(config);
// check the application certificate.
var haveAppCertificate =
await application.CheckApplicationInstanceCertificate(false, 0);
if (!haveAppCertificate)
{
_logger.Error("Failed validating own certificate!");
throw new Exception("Application instance certificate invalid!");
}
// Set Certificate
try {
// just take the public key
Certificate = new X509Certificate2(config.SecurityConfiguration.ApplicationCertificate.Certificate.RawData);
}
catch {
Certificate = config.SecurityConfiguration.ApplicationCertificate.Certificate;
}
_logger.Information("Starting server ...");
// start the server.
await application.Start(_server);
foreach (var ep in config.ServerConfiguration.BaseAddresses)
{
_logger.Information("Listening on {ep}", ep);
}
_logger.Information("Server started.");
}
private async Task StartConsoleReferenceServerAsync()
{
ApplicationInstance.MessageDlg = new ApplicationMessageDlg();
CertificatePasswordProvider PasswordProvider = new CertificatePasswordProvider(Password);
ApplicationInstance application = new ApplicationInstance {
ApplicationName = "Quickstart Reference Server",
ApplicationType = ApplicationType.Server,
ConfigSectionName = Utils.IsRunningOnMono() ? "Quickstarts.MonoReferenceServer" : "Quickstarts.ReferenceServer",
CertificatePasswordProvider = PasswordProvider
};
// load the application configuration.
ApplicationConfiguration config = await application.LoadApplicationConfiguration(false).ConfigureAwait(false);
var loggerConfiguration = new Serilog.LoggerConfiguration();
if (LogConsole)
{
loggerConfiguration.WriteTo.Console(restrictedToMinimumLevel: Serilog.Events.LogEventLevel.Warning);
}
#if DEBUG
else
{
loggerConfiguration.WriteTo.Debug(restrictedToMinimumLevel: Serilog.Events.LogEventLevel.Warning);
}
#endif
SerilogTraceLogger.Create(loggerConfiguration, config);
// check the application certificate.
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(
false, CertificateFactory.DefaultKeySize, CertificateFactory.DefaultLifeTime).ConfigureAwait(false);
if (!haveAppCertificate)
{
throw new Exception("Application instance certificate invalid!");
}
if (!config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
}
// start the server.
m_server = new ReferenceServer();
await application.Start(m_server).ConfigureAwait(false);
// print endpoint info
var endpoints = application.Server.GetEndpoints().Select(e => e.EndpointUrl).Distinct();
foreach (var endpoint in endpoints)
{
Console.WriteLine(endpoint);
}
// start the status thread
m_status = Task.Run(new Action(StatusThreadAsync));
// print notification on session events
m_server.CurrentInstance.SessionManager.SessionActivated += EventStatus;
m_server.CurrentInstance.SessionManager.SessionClosing += EventStatus;
m_server.CurrentInstance.SessionManager.SessionCreated += EventStatus;
}
