public void UpdateUiControls()
{
using (var applicationInstance = new ApplicationInstance(Settings.Default.TestApplicationLocation))
{
applicationInstance.Run(async () =>
{
// This is running on the UI thread
// Debugger.Launch();
var window = (Application.Current.MainWindow as MainWindow);
if (window == null)
Assert.Fail("No main window");
Assert.AreEqual("Initial heading", window.HeadingLabel.Text);
window.HeadingTextBox.Text = "Our text";
ClickButton(window.Go);
// Give it time to do its thing
await Task.Delay(500);
Assert.AreEqual("Our text", window.HeadingLabel.Text);
});
}
}
public void UpdateUiControls()
{
using (var applicationInstance = new ApplicationInstance())
{
applicationInstance.Launch(Settings.Default.TestApplicationLocation);
applicationInstance.RunMethod(() => UpdateUiControlsImpl());
}
}
public void AnonymousMethodsWithAsyncAreAbleToBeUsed()
{
using (var applicationInstance = new ApplicationInstance())
{
applicationInstance.Launch(Settings.Default.TestApplicationLocation);
applicationInstance.Run(async () =>
{
await Task.Delay(5000);
});
}
}
public void AnonymousMethodsAreAbleToBeUsed()
{
using (var applicationInstance = new ApplicationInstance())
{
applicationInstance.Launch(Settings.Default.TestApplicationLocation);
applicationInstance.Run(() =>
{
Thread.Sleep(5000);
});
}
}
public void ApplicationCanBeLaunchedAndAttachedTo()
{
Process process;
using (var applicationInstance = new ApplicationInstance())
{
applicationInstance.Launch(Settings.Default.TestApplicationLocation);
process = applicationInstance.Process;
Assert.IsNotNull(applicationInstance.Process);
}
Assert.IsTrue(process.HasExited);
}
public void ApplicationCanBeLaunchedAndAttachedTo()
{
Process process;
using (var applicationInstance = new ApplicationInstance())
{
applicationInstance.Launch(@"PATHTOAPPLICATION");
process = applicationInstance.Process;
Assert.IsNotNull(applicationInstance.Process);
applicationInstance.Run(() => { });
}
Assert.IsTrue(process.HasExited);
}
//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);
}
}
}
public connectorForm(ApplicationInstance application) : base(application.ApplicationConfiguration.CreateMessageContext(), application, null, application.ApplicationConfiguration)
{
InitializeComponent();
}
protected override void OnProcessRequest()
{
ApplicationInstance applicationInstance = CurrentContext.CurrentApplicationInstance;
Write(string.Format("{0} {1}", applicationInstance, applicationInstance.Version));
}
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);
}
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);
}
}
/// <summary>
/// On page loaded
/// </summary>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
App.unclosedSession = this;
sessionInfo = e.Parameter as SessionInfo;
if (sessionInfo == null)
{
sessionMgmtAction = SESSIONMGMT_ACTION.NEW;
sessionInfo = new SessionInfo();
sessionInfo.sessionName = "";
sessionInfo.profilePath = "";
sessionInfo.sourceType = "";
m_sessionConfig_full_path = "";
m_sessionConfig = null;
}
else
{
m_sessionConfig_full_path = Path.Combine(m_local, SiteProfileManager.GetFullPath(App.SiteProfileId, sessionInfo.profilePath));
// json configuration
m_sessionConfig = OpcuaSessionConfig.LoadFromJsonFile(m_sessionConfig_full_path);
}
ApplicationInstance application = OpcuaSessionConfig.OpcuaApplication;
ApplicationConfiguration configuration = application.ApplicationConfiguration;
ServiceMessageContext context = configuration.CreateMessageContext();
if (!configuration.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
configuration.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
}
m_context = context;
m_application = application;
m_configuration = configuration;
SessionsCTRL.Configuration = configuration;
SessionsCTRL.MessageContext = context;
SessionsCTRL.AddressSpaceCtrl = BrowseCTRL;
SessionsCTRL.NodeSelected += SessionCtrl_NodeSelected;
// disable cached endpoints from Opc.Ua.SampleClient.Config.xml
//// get list of cached endpoints.
//m_endpoints = m_configuration.LoadCachedEndpoints(true);
m_endpoints = new ConfiguredEndpointCollection();
m_endpoints.DiscoveryUrls = configuration.ClientConfiguration.WellKnownDiscoveryUrls;
// work around to fill Configuration and DiscoveryUrls
if (m_sessionConfig != null)
{
m_sessionConfig.endpoint.Configuration = EndpointConfiguration.Create(m_configuration);
m_sessionConfig.endpoint.Description.Server.DiscoveryUrls.Add(m_sessionConfig.endpoint.EndpointUrl.AbsoluteUri.ToString());
m_endpoints.Add(m_sessionConfig.endpoint);
}
// hook up endpoint selector
EndpointSelectorCTRL.Initialize(m_endpoints, m_configuration);
EndpointSelectorCTRL.ConnectEndpoint += EndpointSelectorCTRL_ConnectEndpoint;
EndpointSelectorCTRL.EndpointsChanged += EndpointSelectorCTRL_OnChange;
BrowseCTRL.SessionTreeCtrl = SessionsCTRL;
BrowseCTRL.NodeSelected += BrowseCTRL_NodeSelected;
btnDelSubscription.IsEnabled = false;
btnAddSubscription.IsEnabled = false;
btnDelSubscription.Click += ContextMenu_OnDelete;
btnAddSubscription.Click += ContextMenu_OnReport;
// exception dialog
GuiUtils.ExceptionMessageDlg += ExceptionMessageDlg;
EndpointSelectorCTRL.IsEnabled = false;
BrowseCTRL.IsEnabled = false;
SessionsCTRL.IsEnabled = false;
txtSessionName.Text = sessionInfo.sessionName;
if (sessionMgmtAction == SESSIONMGMT_ACTION.NEW)
{
txtSessionName.IsReadOnly = false;
btnReload.IsEnabled = false;
btnReload.Visibility = Visibility.Collapsed;
EndpointSelectorCTRL.IsEnabled = true;
}
else
{
if (m_sessionConfig == null)
{
txtSessionName.IsReadOnly = true;
EndpointSelectorCTRL.IsEnabled = true;
btnReload.IsEnabled = false;
}
else
{
txtSessionName.IsReadOnly = true;
btnReload.IsEnabled = false;
var ignored = Task.Run(OpenSessionView_OpcuaClient);
}
}
}
public async Task StartServer(bool clean, int basePort = -1)
{
ApplicationInstance.MessageDlg = new ApplicationMessageDlg();
Application = new ApplicationInstance
{
ApplicationName = "Global Discovery Server",
ApplicationType = ApplicationType.Server,
ConfigSectionName = "Opc.Ua.GlobalDiscoveryTestServer"
};
BasePort = basePort;
Config = await Load(Application, basePort).ConfigureAwait(false);
if (clean)
{
string thumbprint = Config.SecurityConfiguration.ApplicationCertificate.Thumbprint;
if (thumbprint != null)
{
using (var store = Config.SecurityConfiguration.ApplicationCertificate.OpenStore())
{
await store.Delete(thumbprint).ConfigureAwait(false);
}
}
// 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 Load(Application, basePort).ConfigureAwait(false);
}
// check the application certificate.
bool haveAppCertificate = await Application.CheckApplicationInstanceCertificate(true, 0).ConfigureAwait(false);
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).ConfigureAwait(false);
ServerState serverState = Server.GetStatus().State;
if (serverState != ServerState.Running)
{
throw new ServiceResultException("Server failed to start");
}
}
public OpcClient(string serverUrl)
{
m_serverUrl = serverUrl;
m_application = ApplicationInstance.Default;
}
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 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();
}
}
protected void btnAddContent_Click(object sender, EventArgs e)
{
Session["ContentID"] = 1;
Response.Redirect("Content.aspx", false);
ApplicationInstance.CompleteRequest();
}
/// <summary>
/// Constructors method
/// </summary>
public OpcUaClient()
{
var certificateValidator = new CertificateValidator();
certificateValidator.CertificateValidation += (sender, eventArgs) =>
{
if (ServiceResult.IsGood(eventArgs.Error))
{
eventArgs.Accept = true;
}
else if ((eventArgs.Error.StatusCode.Code == StatusCodes.BadCertificateUntrusted) && true)
{
eventArgs.Accept = true;
}
else
{
throw new Exception(string.Format("Failed to validate certificate with error code {0}: {1}", eventArgs.Error.Code, eventArgs.Error.AdditionalInfo));
}
};
// Build the application configuration
application = new ApplicationInstance
{
ApplicationType = ApplicationType.Client,
ConfigSectionName = OpcUaName,
ApplicationConfiguration = new ApplicationConfiguration
{
ApplicationUri = "",
ApplicationName = OpcUaName,
ApplicationType = ApplicationType.Client,
CertificateValidator = certificateValidator,
ServerConfiguration = new ServerConfiguration
{
MaxSubscriptionCount = 100,
MaxMessageQueueSize = 100,
MaxNotificationQueueSize = 100,
MaxPublishRequestCount = 100
},
SecurityConfiguration = new SecurityConfiguration
{
AutoAcceptUntrustedCertificates = true,
},
TransportQuotas = new TransportQuotas
{
OperationTimeout = 600000,
MaxStringLength = 1048576,
MaxByteStringLength = 1048576,
MaxArrayLength = 65535,
MaxMessageSize = 4194304,
MaxBufferSize = 65535,
ChannelLifetime = 600000,
SecurityTokenLifetime = 3600000
},
ClientConfiguration = new ClientConfiguration
{
DefaultSessionTimeout = 60000,
MinSubscriptionLifetime = 10000
},
DisableHiResClock = true
}
};
// Assign a application certificate (when specified)
// if (ApplicationCertificate != null)
// application.ApplicationConfiguration.SecurityConfiguration.ApplicationCertificate = new CertificateIdentifier(_options.ApplicationCertificate);
m_configuration = application.ApplicationConfiguration;
}
public NcStartApplicationInstancesResponse StartApplicationInstances(NcStartApplicationInstancesRequest request)
{
Log.Info(this, "StartApplicationInstances()");
try {
Application app = Database.Applications.Where(x => x.Id == request.ApplicationId).FirstOrDefault();
if (app != null)
{
Tenant tenant = null;
if (string.IsNullOrEmpty(request.TenantName))
{
throw new MonoscapeException("Tenant name should be specified");
}
else
{
tenant = app.Tenants.Where(x => x.Name.Equals(request.TenantName)).FirstOrDefault();
if (tenant == null)
{
throw new MonoscapeException("Tenant " + request.TenantName + " not found");
}
}
List <ApplicationInstance> instancesStarted = new List <ApplicationInstance> ();
NcStartApplicationInstancesResponse response = new NcStartApplicationInstancesResponse();
for (int i = 0; i < request.NumberOfInstances; i++)
{
// Extract application to a new folder
int port = ExtractApplicationPackage(app, tenant.Name);
// Start a web server instance
ApplicationInstance instance = StartWebServer(app, tenant, port);
if (instance != null)
{
// Add to database
if (app.ApplicationInstances == null)
{
app.ApplicationInstances = new List <ApplicationInstance> ();
}
app.ApplicationInstances.Add(instance);
// Track instances started
instancesStarted.Add(instance.Clone());
// Add server url to the response
if (response.Urls == null)
{
response.Urls = new List <string> ();
}
response.Urls.Add(instance.Url);
}
}
response.ApplicationInstances = instancesStarted;
return(response);
}
else
{
throw new MonoscapeException("Application not found");
}
}
catch (Exception e) {
Log.Error(this, e);
throw e;
}
}
public async Task LoadConfiguration(string pkiRoot = null)
{
Application = new ApplicationInstance {
ApplicationName = typeof(T).Name,
ApplicationType = ApplicationType.Server
};
// create the application configuration. Use temp path for cert stores.
pkiRoot = pkiRoot ?? Path.GetTempPath() + Path.GetRandomFileName();
var endpointUrl = $"{UriScheme}://localhost:0/" + typeof(T).Name;
var serverConfig = Application.Build(
"urn:localhost:UA:" + typeof(T).Name,
"uri:opcfoundation.org:" + typeof(T).Name)
.AsServer(
new string[] {
endpointUrl
});
if (SecurityNone)
{
serverConfig.AddUnsecurePolicyNone();
}
if (endpointUrl.StartsWith(Utils.UriSchemeHttps, StringComparison.InvariantCultureIgnoreCase))
{
serverConfig.AddPolicy(MessageSecurityMode.SignAndEncrypt, SecurityPolicies.Basic256Sha256);
}
else if (endpointUrl.StartsWith(Utils.UriSchemeOpcTcp, StringComparison.InvariantCultureIgnoreCase))
{
// add deprecated policies for opc.tcp tests
serverConfig.AddPolicy(MessageSecurityMode.Sign, SecurityPolicies.Basic128Rsa15)
.AddPolicy(MessageSecurityMode.Sign, SecurityPolicies.Basic256)
.AddPolicy(MessageSecurityMode.SignAndEncrypt, SecurityPolicies.Basic128Rsa15)
.AddPolicy(MessageSecurityMode.SignAndEncrypt, SecurityPolicies.Basic256)
.AddSignPolicies()
.AddSignAndEncryptPolicies();
}
if (OperationLimits)
{
serverConfig.SetOperationLimits(new OperationLimits()
{
MaxNodesPerBrowse = 2500,
MaxNodesPerRead = 250,
MaxNodesPerWrite = 250,
MaxNodesPerMethodCall = 500,
MaxMonitoredItemsPerCall = 1000,
MaxNodesPerTranslateBrowsePathsToNodeIds = 1000
});
}
if (ReverseConnectTimeout != 0)
{
serverConfig.SetReverseConnect(new ReverseConnectServerConfiguration()
{
ConnectInterval = ReverseConnectTimeout / 4,
ConnectTimeout = ReverseConnectTimeout,
RejectTimeout = ReverseConnectTimeout / 4
});
}
Config = await serverConfig.AddSecurityConfiguration(
"CN=" + typeof(T).Name + ", C=US, S=Arizona, O=OPC Foundation, DC=localhost",
pkiRoot)
.SetAutoAcceptUntrustedCertificates(AutoAccept)
.Create().ConfigureAwait(false);
}
private static void RunMethodImpl(ApplicationInstance applicationInstance, MethodInfo method, TestInjectorSettings testInjectorSettings)
{
if (!method.IsStatic)
throw new InvalidOperationException("Method must be static");
new TestInjectorClient().RunMethod(applicationInstance.Process,
method.DeclaringType,
method.Name,
testInjectorSettings ?? TestInjectorSettings.Default);
}
/// <summary>
/// Crappy method to initialize the session. I don't know what many of these things do, sincerely.
/// </summary>
private Session InitializeSession(Uri url)
{
var certificateValidator = new CertificateValidator();
certificateValidator.CertificateValidation += (sender, eventArgs) =>
{
if (ServiceResult.IsGood(eventArgs.Error))
{
eventArgs.Accept = true;
}
else if ((eventArgs.Error.StatusCode.Code == StatusCodes.BadCertificateUntrusted) && _options.AutoAcceptUntrustedCertificates)
{
eventArgs.Accept = true;
}
else
{
throw new OpcException(string.Format("Failed to validate certificate with error code {0}: {1}", eventArgs.Error.Code, eventArgs.Error.AdditionalInfo), eventArgs.Error.StatusCode);
}
};
// Build the application configuration
var appInstance = new ApplicationInstance
{
ApplicationType = ApplicationType.Client,
ConfigSectionName = _options.ConfigSectionName,
ApplicationConfiguration = new ApplicationConfiguration
{
ApplicationUri = url.ToString(),
ApplicationName = _options.ApplicationName,
ApplicationType = ApplicationType.Client,
CertificateValidator = certificateValidator,
SecurityConfiguration = new SecurityConfiguration
{
AutoAcceptUntrustedCertificates = _options.AutoAcceptUntrustedCertificates
},
TransportQuotas = new TransportQuotas
{
OperationTimeout = 600000,
MaxStringLength = 1048576,
MaxByteStringLength = 1048576,
MaxArrayLength = 65535,
MaxMessageSize = 4194304,
MaxBufferSize = 65535,
ChannelLifetime = 300000,
SecurityTokenLifetime = 3600000
},
ClientConfiguration = new ClientConfiguration
{
DefaultSessionTimeout = 60000,
MinSubscriptionLifetime = 10000
},
DisableHiResClock = true
}
};
// Assign a application certificate (when specified)
if (_options.ApplicationCertificate != null)
{
appInstance.ApplicationConfiguration.SecurityConfiguration.ApplicationCertificate = new CertificateIdentifier(_options.ApplicationCertificate);
}
// Find the endpoint to be used
var endpoints = ClientUtils.SelectEndpoint(url, _options.UseMessageSecurity);
// Create the OPC session:
var session = Session.Create(
configuration: appInstance.ApplicationConfiguration,
endpoint: new ConfiguredEndpoint(
collection: null,
description: endpoints,
configuration: EndpointConfiguration.Create(applicationConfiguration: appInstance.ApplicationConfiguration)),
updateBeforeConnect: false,
checkDomain: false,
sessionName: _options.SessionName,
sessionTimeout: _options.SessionTimeout,
identity: null,
preferredLocales: new string[] { });
return(session);
}
protected UaSource(ApplicationInstance applicationInstance) => this.applicationInstance = applicationInstance;
public OpcClient(string serverUrl, ApplicationInstance application)
{
m_serverUrl = serverUrl;
m_application = application;
}
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>
/// Initializes a new instance of the <see cref="ServerPushConfigurationClient"/> class.
/// </summary>
/// <param name="application">The application.</param>
public ServerPushConfigurationClient(ApplicationInstance application)
{
m_application = application;
}
/// <summary>
/// Sets the application instance for this view model.
/// </summary>
/// <param name="applicationInstance">The application instance.</param>
internal virtual void SetApplicationInstance(ApplicationInstance applicationInstance)
{
}
protected override void Execute()
{
var projects = _controllers.TranscreateController.GetSelectedProjects();
if (projects?.Count != 1)
{
Enabled = false;
return;
}
var project = projects[0];
if (project is BackTranslationProject)
{
return;
}
var studioProject = _controllers.ProjectsController.GetProjects()
.FirstOrDefault(a => a.GetProjectInfo().Id.ToString() == project.Id);
if (studioProject == null)
{
return;
}
var studioProjectInfo = studioProject.GetProjectInfo();
var backTranslationsFolder = Path.Combine(studioProjectInfo.LocalProjectFolder, "BackProjects");
if (Directory.Exists(backTranslationsFolder))
{
var message01 = "The Back-Translations folder is not empty."
+ Environment.NewLine + Environment.NewLine
+ "'" + backTranslationsFolder + "'"
+ Environment.NewLine + Environment.NewLine;
var message02 = "Do you want to proceed and delete this folder?";
var response = MessageBox.Show(message01 + message02, PluginResources.Plugin_Name,
MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (response != DialogResult.Yes)
{
return;
}
TryDeleteDirectory(backTranslationsFolder);
}
var taskContexts = new List <TaskContext>();
var progressSettings = new ProgressDialogSettings(ApplicationInstance.GetActiveForm(), true, true, true);
var result = ProgressDialog.Execute("Create Back-Translation Projects", () =>
{
ProgressDialog.Current.Report(0, "Reading language files...");
var dateTimeStamp = DateTime.UtcNow;
var dataTimeStampToString = DateTimeStampToString(dateTimeStamp);
var workFlowPath = GetPath(studioProjectInfo.LocalProjectFolder, "WorkFlow");
var workingActionPath = GetPath(workFlowPath, "Convert");
var workingFolder = GetPath(workingActionPath, dataTimeStampToString);
var exportOptions = new ExportOptions();
exportOptions.IncludeBackTranslations = true;
exportOptions.IncludeTranslations = true;
exportOptions.CopySourceToTarget = false;
var importOptions = new ImportOptions();
importOptions.OverwriteTranslations = true;
importOptions.OriginSystem = "Transcreate Automation";
importOptions.StatusTranslationUpdatedId = string.Empty;
var analysisBands = _projectAutomationService.GetAnalysisBands(studioProject);
var sdlxliffReader = new SdlxliffReader(_segmentBuilder, exportOptions, analysisBands);
var sdlxliffWriter = new SdlxliffWriter(_segmentBuilder, importOptions, analysisBands);
var xliffWriter = new XliffWriter(Enumerators.XLIFFSupport.xliff12sdl);
// Read the SDLXLIFF data
var fileDataList = GetFileDataList(project, studioProjectInfo, sdlxliffReader);
var filesWithEmptyTranslations = fileDataList.Count(a => a.HasEmptyTranslations);
if (filesWithEmptyTranslations > 0)
{
var message01 = string.Format(PluginResources.Found_empty_translations_in_0_files,
filesWithEmptyTranslations)
+ Environment.NewLine + Environment.NewLine;
var message02 = PluginResources.Proceed_and_copy_source_to_target_for_empty_translations;
var response = MessageBox.Show(message01 + message02, PluginResources.Plugin_Name,
MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (response != DialogResult.Yes)
{
return;
}
}
ProgressDialog.Current.ProgressBarIsIndeterminate = false;
decimal maximum = project.TargetLanguages.Count;
decimal current = 0;
foreach (var targetLanguage in project.TargetLanguages)
{
if (ProgressDialog.Current.CheckCancellationPending())
{
ProgressDialog.Current.ThrowIfCancellationPending();
}
current++;
var progress = current / maximum * 100;
ProgressDialog.Current.Report((int)progress, "Language: " + targetLanguage.CultureInfo.DisplayName);
var sourceFiles = new List <string>();
var languageFolder = GetPath(workingFolder, targetLanguage.CultureInfo.Name);
var targetFiles = project.ProjectFiles.Where(a =>
string.Compare(a.TargetLanguage, targetLanguage.CultureInfo.Name,
StringComparison.CurrentCultureIgnoreCase) == 0);
var languageFileData = new List <FileData>();
foreach (var projectFile in targetFiles)
{
var fileData =
fileDataList.FirstOrDefault(a => a.Data.DocInfo.DocumentId == projectFile.FileId);
if (fileData == null)
{
continue;
}
SwitchSourceWithTargetSegments(fileData);
var xliffFolder = GetPath(languageFolder, projectFile.Path);
var xliffFilePath = Path.Combine(xliffFolder,
projectFile.Name.Substring(0, projectFile.Name.Length - ".sdlxliff".Length));
// Write the XLIFF file
var success = xliffWriter.WriteFile(fileData.Data, xliffFilePath, true);
if (!success)
{
throw new Exception(string.Format(
PluginResources.Unexpected_error_while_converting_the_file, xliffFilePath));
}
sourceFiles.Add(xliffFilePath);
languageFileData.Add(fileData);
}
var iconPath = GetBackTranslationIconPath();
var newStudioProject = _projectAutomationService.CreateBackTranslationProject(
studioProject, targetLanguage.CultureInfo.Name, iconPath, sourceFiles, "BT");
_projectAutomationService.RunPretranslationWithoutTm(newStudioProject);
var taskContext = CreateBackTranslationTaskContext(newStudioProject, languageFileData,
studioProjectInfo.LocalProjectFolder, sdlxliffReader, sdlxliffWriter, xliffWriter);
taskContext.Completed = true;
taskContexts.Add(taskContext);
}
}, progressSettings);
if (result.Cancelled || result.OperationFailed)
{
TryDeleteDirectory(backTranslationsFolder);
var message = result.Cancelled ? "Process cancelled by user." : result.Error?.Message;
MessageBox.Show(message, PluginResources.Plugin_Name);
return;
}
foreach (var taskContext in taskContexts)
{
CleanupProjectSettings(taskContext.FileBasedProject);
ActivateProject(taskContext.FileBasedProject);
_projectAutomationService.RemoveLastReportOfType("Translate");
var reports = _controllers.TranscreateController.CreateHtmlReports(taskContext, taskContext.FileBasedProject, taskContext.Project);
_controllers.TranscreateController.ReportsController.AddReports(_controllers.TranscreateController.ClientId, reports);
_controllers.TranscreateController.UpdateBackTranslationProjectData(project, taskContext);
}
_controllers.TranscreateController.InvalidateProjectsContainer();
Enabled = 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);
}
}
protected void GenerateWidget(object sender, EventArgs e)
{
div_generated.Visible = false;
if (tb_digital_reader_href.Text.Trim() != "" &&
tb_pdf_href.Text.Trim() != "" &&
tb_thumbnail_href.Text.Trim() != "" &&
tb_website_href.Text.Trim() != "" &&
tb_thumbnail_src.Text.Trim() != "")
{
String g_widget_code = Util.ReadTextFile("widget", @"MailTemplates\Widgets\");
g_widget_code = g_widget_code.Replace("%brochure_href%", tb_thumbnail_href.Text.Trim());
g_widget_code = g_widget_code.Replace("%brochure_src%", tb_thumbnail_src.Text.Trim());
g_widget_code = g_widget_code.Replace("%digital_reader_href%", tb_digital_reader_href.Text.Trim());
g_widget_code = g_widget_code.Replace("%website_href%", tb_website_href.Text.Trim());
g_widget_code = g_widget_code.Replace("%pdf_href%", tb_pdf_href.Text.Trim());
g_widget_code = g_widget_code.Replace("%widget_title%", dd_feature.Text.Trim());
lit_generated_widget.Text = g_widget_code;
tb_source.Text = g_widget_code;
div_generated.Visible = true;
// Save widget .html file
String short_month_name = dd_issues.SelectedItem.Text.Substring(0, 3) + dd_issues.SelectedItem.Text.Substring(dd_issues.SelectedItem.Text.IndexOf(" ") + 3);
String feature_name = Util.SanitiseStringForFilename(dd_feature.SelectedItem.Text.Replace(@"/", "-")).Replace(" ", String.Empty);
String file_name = "w3-"
+ dd_feature_region.Text.Substring(0, 2).ToUpper() + "-"
+ short_month_name + "-"
+ feature_name;
//+"-"
//+ DateTime.Now.ToString().Replace(":", "-").Replace(@"/", "-") + "-"
//+ User.Identity.Name;
using (TextWriter tsw = new StreamWriter(Util.path + @"\MailTemplates\Widgets\" + file_name + ".html", false)) //StreamWriter sw = File.AppendText()
{
tsw.WriteLine(g_widget_code);
}
hf_file_name.Value = file_name;
// Download .html file
if (cb_download.Checked)
{
FileInfo file = new FileInfo(Util.path + @"\MailTemplates\Widgets\" + file_name + ".html");
if (file.Exists)
{
try
{
Response.Clear();
Response.AddHeader("Content-Disposition", "attachment; filename=\"" + file.Name + "\"");
Response.AddHeader("Content-Length", file.Length.ToString());
Response.ContentType = "application/octet-stream";
Response.WriteFile(file.FullName);
Response.Flush();
ApplicationInstance.CompleteRequest();
Util.WriteLogWithDetails("Widget File '" + file_name + ".html' generated and downloaded.", "widgetgenerator_log");
}
catch
{
Util.PageMessage(this, "There was an error downloading the widget file. Please try again.");
}
}
else
{
Util.PageMessage(this, "There was an error downloading the widget file. Please try again.");
}
}
else
{
Util.WriteLogWithDetails("Widget File '" + file_name + ".html' generated.", "widgetgenerator_log");
}
}
else
{
Util.PageMessage(this, "Specify all required fields!");
}
}
protected void Page_Load(object sender, EventArgs e)
{
#region Validating session
if (Session["UserID"] == null || Session["IsStudent"] == null)
{
Response.Redirect("index.html", false);
ApplicationInstance.CompleteRequest();
}
#endregion
if (!IsPostBack)
{
if (Session["ScenarioID"] != null)
{
chkContents.Visible = false;
fileImage.Enabled = false;
using (SqlConnection con = new SqlConnection())
{
con.ConnectionString = ConfigurationManager.ConnectionStrings["CPDBCS"].ConnectionString;
SqlCommand cmd = new SqlCommand();
cmd.CommandText = "ShowScenario";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Clear();
cmd.Parameters.Add("@ScenarioID", SqlDbType.Int).Value = Convert.ToInt32(Session["ScenarioID"]);
cmd.Connection = con;
con.Open();
SqlDataAdapter da = new SqlDataAdapter(cmd);
DataSet ds = new DataSet();
da.Fill(ds, "getScenario");
if (ds.Tables["getScenario"].Rows.Count > 0)
{
txtName.Text = ds.Tables["getScenario"].Rows[0]["Name"].ToString();
txtDetails.Text = ds.Tables["getScenario"].Rows[0]["Details"].ToString();
txtwelcome.Text = ds.Tables["getScenario"].Rows[0]["Welcome"].ToString();
txtlearnabt.Text = ds.Tables["getScenario"].Rows[0]["LearnAbout"].ToString();
txtDesc.Text = ds.Tables["getScenario"].Rows[0]["Desciption"].ToString();
lstRAnking.Text = ds.Tables["getScenario"].Rows[0]["Rank"].ToString();
}
}
}
#region Bind contents to checkbox list
using (SqlConnection con = new SqlConnection())
{
con.ConnectionString = ConfigurationManager.ConnectionStrings["CPDBCS"].ConnectionString;
SqlCommand cmd = new SqlCommand();
cmd.CommandText = "ShowContent";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Clear();
cmd.Parameters.Add("@UserID", SqlDbType.Int).Value = Session["UserID"].ToString();
cmd.Connection = con;
con.Open();
SqlDataAdapter da = new SqlDataAdapter(cmd);
DataSet ds = new DataSet();
da.Fill(ds, "CreateScenario");
if (ds.Tables["CreateScenario"].Rows.Count > 0)
{
chkContents.DataSource = ds.Tables["CreateScenario"];
chkContents.DataTextField = "HeadingText";
chkContents.DataValueField = "ContentID";
chkContents.DataBind();
}
//SqlDataReader dr = cmd.ExecuteReader();
//if (dr.Read())
//{
// chkContents.DataSource = dr;
// chkContents.DataTextField = "HeadingText";
// chkContents.DataValueField = "ContentID";
// chkContents.DataBind();
//}
};
#endregion
}
}
/// <summary>
/// Main entry point.
/// </summary>
public static async Task Main(string[] args)
{
TextWriter output = Console.Out;
output.WriteLine("OPC UA Console Reference Client");
output.WriteLine("OPC UA library: {0} @ {1} -- {2}",
Utils.GetAssemblyBuildNumber(),
Utils.GetAssemblyTimestamp().ToString("G", CultureInfo.InvariantCulture),
Utils.GetAssemblySoftwareVersion());
// 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;
string logFile = null;
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 },
{ "logfile=", "custom file name for log output", l => { if (l != null)
{
logFile = l;
}
} },
};
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);
// override logfile
if (logFile != null)
{
var logFilePath = config.TraceConfiguration.OutputFilePath;
var filename = Path.GetFileNameWithoutExtension(logFilePath);
config.TraceConfiguration.OutputFilePath = logFilePath.Replace(filename, logFile);
config.TraceConfiguration.DeleteOnLoad = true;
config.TraceConfiguration.ApplySettings();
}
// 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.
using (UAClient uaClient = new UAClient(
application.ApplicationConfiguration, output, ClientBase.ValidateResponse)
{
AutoAccept = autoAccept
})
{
bool connected = await uaClient.ConnectAsync(serverUrl.ToString());
if (connected)
{
output.WriteLine("Connected! Ctrl-C to quit.");
// enable subscription transfer
uaClient.Session.TransferSubscriptionsOnReconnect = true;
// Run tests for available methods on reference server.
var samples = new ClientSamples(output, ClientBase.ValidateResponse);
samples.ReadNodes(uaClient.Session);
samples.WriteNodes(uaClient.Session);
samples.Browse(uaClient.Session);
samples.CallMethod(uaClient.Session);
samples.SubscribeToDataChanges(uaClient.Session, 120_000);
// Wait for some DataChange notifications from MonitoredItems
quit = quitEvent.WaitOne(timeout > 0 ? waitTime : 30_000);
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("Client stopped.");
}
catch (Exception ex)
{
output.WriteLine(ex.Message);
}
}
protected void btnSave_Click(object sender, EventArgs e)
{
using (SqlConnection con = new SqlConnection())
{
try
{
#region Declaration
int isStudent = Convert.ToInt32(Session["IsStudent"]);
string userID = Session["UserID"].ToString();
string image = null;
if (fileImage.HasFile)
{
image = DateTime.Now.ToString("yyyyMMddHHmmssfff").ToString() + ".jpg";
string filePath = "ScenarioImages/" + image;
fileImage.SaveAs(Server.MapPath(filePath));
}
int scenarioID = -1;
if (Session["ScenarioID"] != null)
{
scenarioID = Convert.ToInt32(Session["ScenarioID"]);
}
#endregion
#region Saving parent content
con.ConnectionString = ConfigurationManager.ConnectionStrings["CPDBCS"].ConnectionString;
SqlCommand cmd = new SqlCommand();
cmd.CommandText = "SaveScenario";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Clear();
cmd.Parameters.Add("@ScenarioID", SqlDbType.Int).Value = scenarioID;
cmd.Parameters.Add("@Name", SqlDbType.VarChar).Value = txtName.Text;
cmd.Parameters.Add("@Welcome", SqlDbType.VarChar).Value = txtwelcome.Text;
cmd.Parameters.Add("@LearnAbt", SqlDbType.VarChar).Value = txtlearnabt.Text;
cmd.Parameters.Add("@Desc", SqlDbType.VarChar).Value = txtDesc.Text;
cmd.Parameters.Add("@Details", SqlDbType.VarChar).Value = txtDetails.Text;
if (lstRAnking.Text != null)
{
cmd.Parameters.Add("@Rank", SqlDbType.VarChar).Value = lstRAnking.Text;
}
else
{
cmd.Parameters.Add("@Rank", SqlDbType.VarChar).Value = "Low";
}
if (!string.IsNullOrEmpty(image))
{
cmd.Parameters.Add("@Image", SqlDbType.VarChar).Value = image;
}
cmd.Parameters.Add("@IsCreatedByStudent", SqlDbType.Int).Value = isStudent;
cmd.Parameters.Add("@CreatedBy", SqlDbType.Int).Value = userID;
cmd.Parameters.Add("@NewScenarioID", SqlDbType.VarChar, 50);
cmd.Parameters["@NewScenarioID"].Direction = ParameterDirection.Output;
cmd.Connection = con;
con.Open();
cmd.ExecuteNonQuery();
string newScenarioID = cmd.Parameters["@NewScenarioID"].Value.ToString();
#endregion
#region Saving child content
foreach (ListItem childContentID in chkContents.Items)
{
int contentID = Convert.ToInt32(childContentID.Value);
int isDel = 0;
if (!childContentID.Selected)
{
isDel = 1;
}
cmd.CommandText = "SaveScenarioContent";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Clear();
cmd.Parameters.Add("@ScenarioID", SqlDbType.Int).Value = newScenarioID;
cmd.Parameters.Add("@ContentID", SqlDbType.Int).Value = contentID;
cmd.Parameters.Add("@IsDeleted", SqlDbType.Int).Value = isDel;
cmd.Connection = con;
cmd.ExecuteNonQuery();
}
#endregion
ScriptManager.RegisterClientScriptBlock(this, GetType(), "alert", "alert('Scenario saved successfully')", true);
Response.Redirect("ShowScenarios.aspx", false);
ApplicationInstance.CompleteRequest();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
};
}
protected void gridStudent_RowCommand(object sender, GridViewCommandEventArgs e)
{
int rowIndex = Convert.ToInt32(e.CommandArgument);
if (e.CommandName == "cmdDelete")
{
try
{
if (con.State == ConnectionState.Closed)
{
con.Open();
}
cmd.Parameters.Clear();
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "DELETE_STUDENT";
cmd.Parameters.Add("@studentId", SqlDbType.Int).Value = Convert.ToInt32(e.CommandArgument);
cmd.Connection = con;
cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
if (con.State == ConnectionState.Open)
{
con.Close();
}
}
Response.Redirect("manageStudent.aspx", false);
ApplicationInstance.CompleteRequest();
}
if (e.CommandName == "cmdSave")
{
try
{
if (con.State == ConnectionState.Closed)
{
con.Open();
}
GridViewRow row = gridStudent.Rows[rowIndex];
string studentId = (row.FindControl("StuId") as HiddenField).Value;
Boolean IsAllowedit = (row.FindControl("chkSelect") as CheckBox).Checked;
cmd.Parameters.Clear();
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "UPDATE_STUDENT_Permission";
cmd.Parameters.Add("@StudenttId", SqlDbType.Int).Value = Convert.ToInt32(studentId);
cmd.Parameters.Add("@IsAllowEdit", SqlDbType.Bit).Value = IsAllowedit;
cmd.Connection = con;
cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
if (con.State == ConnectionState.Open)
{
con.Close();
}
}
Response.Redirect("manageStudent.aspx", false);
ApplicationInstance.CompleteRequest();
}
}
public List <Report> CreateFinalReport(Interfaces.IProject project, FileBasedProject studioProject, out string workingPathOut)
{
var reports = new List <Report>();
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = true,
Indent = false
};
var reportName = "SDL Transcreate Report";
var studioProjectInfo = studioProject.GetProjectInfo();
var dateTimeStamp = DateTime.UtcNow;
var dataTimeStampToString = DateTimeStampToString(dateTimeStamp);
var workflowPath = GetPath(studioProjectInfo.LocalProjectFolder, "Workflow");
var actionPath = GetPath(workflowPath, "Report");
var workingPath = GetPath(actionPath, dataTimeStampToString);
var exportOptions = new ExportOptions();
exportOptions.IncludeBackTranslations = true;
exportOptions.IncludeTranslations = true;
exportOptions.CopySourceToTarget = false;
var analysisBands = _projectAutomationService.GetAnalysisBands(studioProject);
var progressSettings = new ProgressDialogSettings(ApplicationInstance.GetActiveForm(), true, true, false);
var result = ProgressDialog.ProgressDialog.Execute("Create Transcreate Reports", () =>
{
var sdlxliffReader = new SdlxliffReader(_segmentBuilder, exportOptions, analysisBands);
decimal maximum = project.ProjectFiles.Count;
decimal current = 0;
foreach (var targetLanguage in project.TargetLanguages)
{
var projectFiles = project.ProjectFiles.Where(a => string.Compare(a.TargetLanguage, targetLanguage.CultureInfo.Name,
StringComparison.CurrentCultureIgnoreCase) == 0).ToList();
var workingLanguageFolder = GetPath(workingPath, targetLanguage.CultureInfo.Name);
foreach (var projectFile in projectFiles)
{
if (ProgressDialog.ProgressDialog.Current.CheckCancellationPending())
{
ProgressDialog.ProgressDialog.Current.ThrowIfCancellationPending();
}
current++;
var progress = current / maximum * 100;
ProgressDialog.ProgressDialog.Current.Report((int)progress, "File: " + projectFile.Name);
var projectFilePath = Path.Combine(project.Path, projectFile.Location);
var xliffData = sdlxliffReader.ReadFile(project.Id, projectFile.FileId, projectFilePath,
targetLanguage.CultureInfo.Name);
var backTranslationProject = GetBackTranslationProject(project, targetLanguage.CultureInfo.Name);
var backTranslationFile = GetBackTranslationProjectFile(backTranslationProject, projectFile);
var xliffDataBackTranslation = GetBackTranslationXliffData(backTranslationProject, backTranslationFile, sdlxliffReader);
var fileName = projectFile.Name.Substring(0, projectFile.Name.LastIndexOf(".", StringComparison.Ordinal));
var reportFile = Path.Combine(workingLanguageFolder, fileName + ".xml");
using (var writer = XmlWriter.Create(reportFile, settings))
{
writer.WriteStartElement("task");
writer.WriteAttributeString("name", reportName);
writer.WriteAttributeString("created", dataTimeStampToString);
writer.WriteStartElement("taskInfo");
writer.WriteAttributeString("action", "SDL Transcreate Report");
writer.WriteAttributeString("file", projectFile.Path + projectFile.Name);
writer.WriteAttributeString("taskId", Guid.NewGuid().ToString());
writer.WriteAttributeString("runAt", GetDisplayDateTime(dateTimeStamp));
WriteReportProject(writer, "project", project);
WriteReportProject(writer, "backProject", backTranslationProject);
WriteReportLanguage(writer, "source", project.SourceLanguage.CultureInfo.Name);
WriteReportLanguage(writer, "target", targetLanguage.CultureInfo.Name);
WriteReportCustomer(writer, project);
WriteReportTranslationProviders(writer, studioProject);
writer.WriteEndElement(); //taskInfo
writer.WriteStartElement("translations");
foreach (var dataFile in xliffData.Files)
{
writer.WriteStartElement("version");
writer.WriteAttributeString("type", dataFile.Original);
var backTranslationDataFile =
xliffDataBackTranslation?.Files.FirstOrDefault(a => a.Original == dataFile.Original);
writer.WriteStartElement("segments");
foreach (var transUnit in dataFile.Body.TransUnits)
{
var textFunction = transUnit.Contexts.FirstOrDefault(
a => string.Compare(a.DisplayName, "Text Function", StringComparison.CurrentCultureIgnoreCase) == 0);
foreach (var segmentPair in transUnit.SegmentPairs)
{
writer.WriteStartElement("segment");
var backTranslationSegmentPair = GetBackTranslationSegmentPair(backTranslationDataFile, segmentPair);
writer.WriteAttributeString("id", segmentPair.Id);
writer.WriteAttributeString("textFunction", textFunction?.Description ?? string.Empty);
writer.WriteStartElement("source");
writer.WriteString(segmentPair.Source.ToString());
writer.WriteEndElement(); //source
writer.WriteStartElement("target");
writer.WriteString(segmentPair.Target.ToString());
writer.WriteEndElement(); //source
writer.WriteStartElement("back");
writer.WriteString(backTranslationSegmentPair?.Target?.ToString() ?? string.Empty);
writer.WriteEndElement(); //backTranslation
writer.WriteStartElement("comments");
var comments = GetSegmentComments(segmentPair.Target, xliffData.DocInfo);
if (comments != null)
{
foreach (var comment in comments)
{
writer.WriteStartElement("comment");
writer.WriteAttributeString("version", comment.Version);
writer.WriteAttributeString("author", comment.Author);
writer.WriteAttributeString("severity", comment.Severity.ToString());
writer.WriteAttributeString("date", GetDisplayDateTime(comment.Date));
writer.WriteString(comment.Text ?? string.Empty);
writer.WriteEndElement(); //comment
}
}
writer.WriteEndElement(); //comments
writer.WriteEndElement(); //segment
}
}
writer.WriteEndElement(); //segments
writer.WriteEndElement(); //version
}
writer.WriteEndElement(); //translations
}
// transform the file against an xslt
var templatePath = GetReportTemplatePath("TranscreateFinalReport.xsl");
var reportFilePath = CreateHtmlReportFile(reportFile, templatePath);
var report = new Report
{
Name = fileName,
Date = dateTimeStamp,
Description = "Transcreate Report",
Group = "Transcreate Report",
Language = targetLanguage.CultureInfo.Name,
Path = reportFilePath
};
reports.Add(report);
}
}
}, progressSettings);
workingPathOut = workingPath;
if (result.Cancelled)
{
System.Windows.Forms.MessageBox.Show("Process cancelled by user.", PluginResources.Plugin_Name);
return(new List <Report>());
}
return(reports);
}
public async Task TestBadApplicationInstance()
{
// no app name
var applicationInstance = new ApplicationInstance();
Assert.NotNull(applicationInstance);
Assert.ThrowsAsync <ServiceResultException>(async() =>
await applicationInstance.Build(ApplicationUri, ProductUri)
.AsServer(new string[] { EndpointUrl })
.AddSecurityConfiguration(SubjectName, m_pkiRoot)
.Create()
.ConfigureAwait(false)
);
// discoveryserver can not be combined with client/server
applicationInstance = new ApplicationInstance()
{
ApplicationName = ApplicationName,
ApplicationType = ApplicationType.DiscoveryServer
};
Assert.ThrowsAsync <ArgumentException>(async() =>
await applicationInstance.Build(ApplicationUri, ProductUri)
.AsClient()
.AddSecurityConfiguration(SubjectName, m_pkiRoot)
.Create()
.ConfigureAwait(false)
);
Assert.ThrowsAsync <ArgumentException>(async() =>
await applicationInstance.Build(ApplicationUri, ProductUri)
.AsServer(new string[] { EndpointUrl })
.AddSecurityConfiguration(SubjectName, m_pkiRoot)
.Create()
.ConfigureAwait(false)
);
// server overrides client settings
applicationInstance = new ApplicationInstance()
{
ApplicationName = ApplicationName,
ApplicationType = ApplicationType.Client
};
var config = await applicationInstance.Build(ApplicationUri, ProductUri)
.AsServer(new string[] { EndpointUrl })
.AddSecurityConfiguration(SubjectName, m_pkiRoot)
.Create()
.ConfigureAwait(false);
Assert.AreEqual(ApplicationType.Server, applicationInstance.ApplicationType);
// client overrides server setting
applicationInstance = new ApplicationInstance()
{
ApplicationName = ApplicationName,
ApplicationType = ApplicationType.Server
};
await applicationInstance.Build(ApplicationUri, ProductUri)
.AsClient()
.AddSecurityConfiguration(SubjectName, m_pkiRoot)
.Create()
.ConfigureAwait(false);
Assert.AreEqual(ApplicationType.Client, applicationInstance.ApplicationType);
// invalid sec policy testing
applicationInstance = new ApplicationInstance()
{
ApplicationName = ApplicationName
};
// invalid use, use AddUnsecurePolicyNone instead
Assert.ThrowsAsync <ArgumentException>(async() =>
await applicationInstance.Build(ApplicationUri, ProductUri)
.AsServer(new string[] { EndpointUrl })
.AddPolicy(MessageSecurityMode.None, SecurityPolicies.None)
.AddSecurityConfiguration(SubjectName, m_pkiRoot)
.Create()
.ConfigureAwait(false)
);
// invalid mix sign / none
Assert.ThrowsAsync <ArgumentException>(async() =>
await applicationInstance.Build(ApplicationUri, ProductUri)
.AsServer(new string[] { EndpointUrl })
.AddPolicy(MessageSecurityMode.Sign, SecurityPolicies.None)
.AddSecurityConfiguration(SubjectName)
.Create()
.ConfigureAwait(false)
);
// invalid policy
Assert.ThrowsAsync <ArgumentException>(async() =>
await applicationInstance.Build(ApplicationUri, ProductUri)
.AsServer(new string[] { EndpointUrl })
.AddPolicy(MessageSecurityMode.Sign, "123")
.AddSecurityConfiguration(SubjectName, m_pkiRoot)
.Create()
.ConfigureAwait(false)
);
// invalid user token policy
Assert.ThrowsAsync <ArgumentNullException>(async() =>
await applicationInstance.Build(ApplicationUri, ProductUri)
.AsServer(new string[] { EndpointUrl })
.AddUserTokenPolicy(null)
.AddSecurityConfiguration(SubjectName, m_pkiRoot)
.Create()
.ConfigureAwait(false)
);
}
/// <summary>
/// 默认的构造函数，实例化一个新的OPC UA类
/// </summary>
public OpcUaClient()
{
dic_subscriptions = new Dictionary <string, Subscription>();
var certificateValidator = new CertificateValidator();
certificateValidator.CertificateValidation += (sender, eventArgs) => {
if (ServiceResult.IsGood(eventArgs.Error))
{
eventArgs.Accept = true;
}
else if (eventArgs.Error.StatusCode.Code == StatusCodes.BadCertificateUntrusted)
{
eventArgs.Accept = true;
}
else
{
throw new Exception(
$"Failed to validate certificate with error code {eventArgs.Error.Code}: {eventArgs.Error.AdditionalInfo}");
}
};
var securityConfigurationcv = new SecurityConfiguration {
AutoAcceptUntrustedCertificates = true,
RejectSHA1SignedCertificates = false,
MinimumCertificateKeySize = 1024,
};
certificateValidator.Update(securityConfigurationcv);
// Build the application configuration
application = new ApplicationInstance {
ApplicationType = ApplicationType.Client,
ConfigSectionName = OpcUaName,
ApplicationConfiguration = new ApplicationConfiguration {
ApplicationName = OpcUaName,
ApplicationType = ApplicationType.Client,
CertificateValidator = certificateValidator,
ServerConfiguration = new ServerConfiguration {
MaxSubscriptionCount = 100000,
MaxMessageQueueSize = 1000000,
MaxNotificationQueueSize = 1000000,
MaxPublishRequestCount = 10000000,
},
SecurityConfiguration = new SecurityConfiguration {
AutoAcceptUntrustedCertificates = true,
RejectSHA1SignedCertificates = false,
MinimumCertificateKeySize = 1024,
},
TransportQuotas = new TransportQuotas {
OperationTimeout = 6000000,
MaxStringLength = int.MaxValue,
MaxByteStringLength = int.MaxValue,
MaxArrayLength = 65535,
MaxMessageSize = 419430400,
MaxBufferSize = 65535,
ChannelLifetime = -1,
SecurityTokenLifetime = -1
},
ClientConfiguration = new ClientConfiguration {
DefaultSessionTimeout = -1,
MinSubscriptionLifetime = -1,
},
DisableHiResClock = true
}
};
// Assign a application certificate (when specified)
// if (ApplicationCertificate != null)
// application.ApplicationConfiguration.SecurityConfiguration.ApplicationCertificate = new CertificateIdentifier(_options.ApplicationCertificate);
AppConfig = application.ApplicationConfiguration;
}
