public void Execute(ApplicationInstructions instructions, ApplicationConfiguration configuration)
{
Validate.ExecuteAlias(instructions.ExecuteAlias);
var isTimedMode = instructions.TimedMode || configuration.IsTimedMode;
var group = TaskCollection.SelectTaskGroup(instructions.ExecuteAlias.Alias);
Validate.TaskGroup(group);
try
{
PrintStartTime(isTimedMode);
if (instructions.ParallelMode)
{
ExecuteASync(group, instructions, configuration);
}
else
{
ExecuteSync(group, instructions, configuration);
}
}
finally
{
PrintEndTime(isTimedMode);
}
}
/// <summary>
/// This constructor loads the configuration.
/// </summary>
/// <remarks> It loads Client configuration, test configuration and
/// initializes contexts for vendor namespaces. </remarks>
public TestClient(ApplicationConfiguration configuration)
{
m_configuration = configuration;
LoadTestConfiguration(null);
m_messageContext = Compare.MessageContext = m_configuration.CreateMessageContext();
TestUtils.InitializeContexts(m_messageContext);
}
/// <summary>
/// Displays the dialog.
/// </summary>
public ConfiguredEndpoint ShowDialog(ApplicationConfiguration configuration, bool createNew)
{
m_configuration = configuration;
m_endpoint = null;
// create a default collection if none provided.
if (createNew)
{
ApplicationDescription server = new DiscoveredServerListDlg().ShowDialog(null, m_configuration);
if (server != null)
{
return new ConfiguredEndpoint(server, EndpointConfiguration.Create(configuration));
}
return null;
}
ServersCTRL.Initialize(null, configuration);
OkBTN.IsEnabled = false;
Popup myPopup = new Popup();
myPopup.Child = this;
myPopup.IsOpen = true;
return m_endpoint;
}
/// <summary>
/// Uses the command line to override the UA TCP implementation specified in the configuration.
/// </summary>
/// <param name="configuration">The configuration instance that stores the configurable information for a UA application.
/// </param>
public static void OverrideUaTcpImplementation(ApplicationConfiguration configuration)
{
// check if UA TCP configuration included.
TransportConfiguration transport = null;
for (int ii = 0; ii < configuration.TransportConfigurations.Count; ii++)
{
if (configuration.TransportConfigurations[ii].UriScheme == Utils.UriSchemeOpcTcp)
{
transport = configuration.TransportConfigurations[ii];
break;
}
}
// check if UA TCP implementation explicitly specified.
if (transport != null)
{
string[] args = Environment.GetCommandLineArgs();
if (args != null && args.Length > 1)
{
if (String.Compare(args[1], "-uaTcpAnsiC", StringComparison.InvariantCultureIgnoreCase) == 0)
{
transport.TypeName = Utils.UaTcpBindingNativeStack;
}
else if (String.Compare(args[1], "-uaTcpDotNet", StringComparison.InvariantCultureIgnoreCase) == 0)
{
transport.TypeName = Utils.UaTcpBindingDefault;
}
}
}
}
/// <summary>
/// Creates a form which uses the specified client configuration.
/// </summary>
/// <param name="configuration">The configuration to use.</param>
public MainForm(ApplicationConfiguration configuration)
{
InitializeComponent();
ConnectServerCTRL.Configuration = m_configuration = configuration;
ConnectServerCTRL.ServerUrl = "opc.tcp://localhost:62541/Quickstarts/ReferenceServer";
this.Text = m_configuration.ApplicationName;
}
public void ShouldMapAllConfigFields()
{
var console = new string[0];
var config = new ApplicationConfiguration
{
IsInGroupMode = true,
IsTimedMode = true,
IsVerbodeMode = true
};
config.DefaultArguments.ExecuteAlias = "alias";
config.DefaultArguments.MethodArguments = new[] { "config" };
config.DefaultArguments.ConstructorArguments = new[] { "config" };
builder = new InstructionBuilder(console, config);
var instructions = builder.Build();
Assert.That(instructions.ExecuteAlias.Alias, Is.EqualTo("alias"));
Assert.That(instructions.Instructions.ContainsKey(InstructionType.DisplayHelp), Is.False);
Assert.That(instructions.Instructions.ContainsKey(InstructionType.DisplayList), Is.False);
Assert.That(instructions.Instructions[InstructionType.Constructor].Arguments, Is.EqualTo(new[] { "config" }));
Assert.That(instructions.Instructions[InstructionType.Method].Arguments, Is.EqualTo(new[] { "config" }));
Assert.That(instructions.Instructions[InstructionType.Group], Is.Not.Null);
Assert.That(instructions.Instructions[InstructionType.Timed], Is.Not.Null);
Assert.That(instructions.Instructions[InstructionType.Verbose], Is.Not.Null);
}
/// <summary>
/// This method loads the configuration for the test server.
/// </summary>
protected override void OnServerStarting(ApplicationConfiguration configuration)
{
base.OnServerStarting(configuration);
LoadTestConfiguration(null);
TestUtils.InitializeContexts(base.MessageContext);
}
protected void btnSave_Click(object sender, EventArgs e)
{
lblError.Text = string.Empty;
lblSave.Text = string.Empty;
lblMessage.Text = string.Empty;
lblMessage.Visible = false;
lblError.Visible = false;
lblSave.Visible = false;
try {
using (TransactionScope scope = new TransactionScope()) {
ApplicationConfigurationManager.UpdateAppConfigStatus();
ApplicationConfiguration objAppConfig = new ApplicationConfiguration();
objAppConfig.PrimaryProducerCommissionPercent = Convert.ToDecimal(txtPrimeryProducer.Text);
objAppConfig.SecondaryProducerCommissionPercent = Convert.ToDecimal(txtSecondaryProducer.Text);
objAppConfig.EmailNotificationSite1 = txtEmailSite1.Text.Trim();
objAppConfig.EmailNotificationSite2 = txtEmailSite2.Text.Trim();
objAppConfig.EmailNotificationSite3 = txtEmailSite3.Text.Trim();
objAppConfig.Status = 1;
ApplicationConfigurationManager.Save(objAppConfig);
fillRecord();
lblSave.Text = "Record Saved.";
lblSave.Visible = true;
scope.Complete();
}
}
catch (Exception ex) {
lblError.Text = "Record Not Saved.";
lblError.Visible = true;
}
}
/// <summary>
/// Initializes the node manager.
/// </summary>
public TestDataNodeManager(Opc.Ua.Server.IServerInternal server, ApplicationConfiguration configuration)
:
base(server, configuration)
{
// update the namespaces.
List<string> namespaceUris = new List<string>();
namespaceUris.Add(Namespaces.TestData);
namespaceUris.Add(Namespaces.TestData + "/Instance");
NamespaceUris = namespaceUris;
// get the configuration for the node manager.
m_configuration = configuration.ParseExtension<TestDataNodeManagerConfiguration>();
// use suitable defaults if no configuration exists.
if (m_configuration == null)
{
m_configuration = new TestDataNodeManagerConfiguration();
}
m_lastUsedId = m_configuration.NextUnusedId-1;
// create the object used to access the test system.
m_system = new TestDataSystem(this, server.NamespaceUris, server.ServerUris);
// update the default context.
SystemContext.SystemHandle = m_system;
}
/// <summary>
/// Creates a form which displays the status for a UA server.
/// </summary>
/// <param name="server">The server displayed in the form.</param>
/// <param name="configuration">The configuration used to initialize the server.</param>
public void Initialize(StandardServer server, ApplicationConfiguration configuration)
{
m_server = server;
m_configuration = configuration;
m_dispatcherTimer = new DispatcherTimer();
m_dispatcherTimer.Tick += UpdateTimerCTRL_Tick;
m_dispatcherTimer.Interval = new TimeSpan(0, 0, 5); // tick every 5 seconds
m_dispatcherTimer.Start();
// add the urls to the drop down.
UrlCB.Items.Clear();
foreach (EndpointDescription endpoint in m_server.GetEndpoints())
{
if (!UrlCB.Items.Contains(endpoint.EndpointUrl))
{
UrlCB.Items.Add(endpoint.EndpointUrl);
}
}
if (UrlCB.Items.Count > 0)
{
UrlCB.SelectedIndex = 0;
}
}
public PublisherForm(
ServiceMessageContext context,
ApplicationInstance application,
PublisherForm masterForm,
ApplicationConfiguration configuration)
{
InitializeComponent();
this.Icon = ClientUtils.GetAppIcon();
m_masterForm = masterForm;
m_context = context;
m_application = application;
m_server = application.Server as Opc.Ua.Server.StandardServer;
if (m_masterForm == null)
{
m_forms = new List<PublisherForm>();
}
SessionsCTRL.Configuration = m_configuration = configuration;
SessionsCTRL.MessageContext = context;
// get list of cached endpoints.
m_endpoints = m_configuration.LoadCachedEndpoints(true);
m_endpoints.DiscoveryUrls = configuration.ClientConfiguration.WellKnownDiscoveryUrls;
EndpointSelectorCTRL.Initialize(m_endpoints, m_configuration);
// initialize control state.
Disconnect();
//lth: initial MassTransit Publisher
m_massTransitPublisher = new MassTransitPublisher();
this.NotificationsCTRL.ItemsAdded += NotificationsCTRL_ItemsAdded;
}
/// <summary>
/// Creates a new transport channel that supports the IRegistrationChannel service contract.
/// </summary>
/// <param name="configuration">The application configuration.</param>
/// <param name="description">The description for the endpoint.</param>
/// <param name="endpointConfiguration">The configuration to use with the endpoint.</param>
/// <param name="clientCertificate">The client certificate.</param>
/// <param name="messageContext">The message context to use when serializing the messages.</param>
/// <returns></returns>
public static ITransportChannel Create(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
X509Certificate2 clientCertificate,
ServiceMessageContext messageContext)
{
// create a UA binary channel.
ITransportChannel channel = CreateUaBinaryChannel(
configuration,
description,
endpointConfiguration,
clientCertificate,
messageContext);
// create a WCF XML channel.
if (channel == null)
{
Uri endpointUrl = new Uri(description.EndpointUrl);
channel = new RegistrationChannel();
TransportChannelSettings settings = new TransportChannelSettings();
settings.Configuration = endpointConfiguration;
settings.Description = description;
settings.ClientCertificate = clientCertificate;
channel.Initialize(endpointUrl, settings);
}
return channel;
}
/// <summary>
/// Displays the dialog.
/// </summary>
public ConfiguredEndpoint ShowDialog(ApplicationConfiguration configuration, bool createNew)
{
m_configuration = configuration;
m_endpoint = null;
// create a default collection if none provided.
if (createNew)
{
ApplicationDescription server = new DiscoveredServerListDlg().ShowDialog(null, m_configuration);
if (server != null)
{
return new ConfiguredEndpoint(server, EndpointConfiguration.Create(configuration));
}
return null;
}
ServersCTRL.Initialize(null, configuration);
OkBTN.Enabled = false;
if (ShowDialog() != DialogResult.OK)
{
return null;
}
return m_endpoint;
}
public OnlineSettingsForm(ApplicationConfiguration applicationConfiguration)
{
InitializeComponent();
this.applicationConfiguration = applicationConfiguration;
workingApplicationConfiguration = ObjectCopier.CloneObject<ApplicationConfiguration, ApplicationConfiguration>(applicationConfiguration);
}
/// <summary>
/// Initializes the manager with its configuration.
/// </summary>
public SubscriptionManager(
IServerInternal server,
ApplicationConfiguration configuration)
{
if (server == null) throw new ArgumentNullException("server");
if (configuration == null) throw new ArgumentNullException("configuration");
m_server = server;
m_minPublishingInterval = configuration.ServerConfiguration.MinPublishingInterval;
m_maxPublishingInterval = configuration.ServerConfiguration.MaxPublishingInterval;
m_publishingResolution = configuration.ServerConfiguration.PublishingResolution;
m_maxSubscriptionLifetime = (uint)configuration.ServerConfiguration.MaxSubscriptionLifetime;
m_minSubscriptionLifetime = (uint)configuration.ServerConfiguration.MinSubscriptionLifetime;
m_maxMessageCount = (uint)configuration.ServerConfiguration.MaxMessageQueueSize;
m_maxNotificationsPerPublish = (uint)configuration.ServerConfiguration.MaxNotificationsPerPublish;
m_maxPublishRequestCount = configuration.ServerConfiguration.MaxPublishRequestCount;
m_maxSubscriptionCount = configuration.ServerConfiguration.MaxSubscriptionCount;
m_subscriptions = new Dictionary<uint,Subscription>();
m_publishQueues = new Dictionary<NodeId,SessionPublishQueue>();
m_statusMessages = new Dictionary<NodeId, Queue<StatusMessage>>();
// create a event to signal shutdown.
m_shutdownEvent = new ManualResetEvent(true);
}
public static string Replace(ApplicationConfiguration.ReplaceInfo[] replaceInfos, string text)
{
foreach (ApplicationConfiguration.ReplaceInfo replaceInfo in replaceInfos)
text = text.Replace(replaceInfo.from, replaceInfo.to);
return text;
}
/// <summary>
/// Creates the node managers for the server.
/// </summary>
/// <remarks>
/// This method allows the sub-class create any additional node managers which it uses. The SDK
/// always creates a CoreNodeManager which handles the built-in nodes defined by the specification.
/// Any additional NodeManagers are expected to handle application specific nodes.
/// </remarks>
protected override MasterNodeManager CreateMasterNodeManager(IServerInternal server, ApplicationConfiguration configuration)
{
Utils.Trace("Creating the Node Managers.");
List<INodeManager> nodeManagers = new List<INodeManager>();
// create the custom node managers.
nodeManagers.Add(new TutorialNodeManager(server, configuration));
#region Task #C4 - Add Support for COM Wrapper
// manually configure the COM server to prevent unapproved wrappers.
ComDaClientConfiguration wrapperConfig = new ComDaClientConfiguration();
wrapperConfig.ServerName = "COM";
wrapperConfig.ServerUrl = "opc.com://localhost/OPCSample.OpcDaServer";
wrapperConfig.MaxReconnectWait = 10000;
wrapperConfig.SeperatorChars = null;
wrapperConfig.BrowseToNotSupported = false;
wrapperConfig.ItemIdParser = new ItemIdParser();
// create an instance of the wrapper node manager.
TutorialDaComNodeManager manager = new TutorialDaComNodeManager(
server,
wrapperConfig.ServerUrl,
wrapperConfig,
true);
nodeManagers.Add(manager);
#endregion
// create master node manager.
return new MasterNodeManager(server, configuration, null, nodeManagers.ToArray());
}
/// <summary>
/// Creates a form which uses the specified client configuration.
/// </summary>
/// <param name="configuration">The configuration to use.</param>
public MainForm(ApplicationConfiguration configuration)
{
InitializeComponent();
ConnectServerCTRL.Configuration = m_configuration = configuration;
ConnectServerCTRL.ServerUrl = "opc.tcp://diamond:62522/Quickstarts/PerfTestServer";
this.Text = m_configuration.ApplicationName;
}
/// <summary>
/// Displays the dialog.
/// </summary>
public EndpointDescription ShowDialog(
ApplicationConfiguration configuration,
ConfiguredEndpointCollection endpoints,
X509Certificate2 clientCertificate)
{
m_configuration = configuration;
m_endpoints = endpoints;
m_messageContext = configuration.CreateMessageContext();
m_clientCertificate = clientCertificate;
m_running = false;
m_filePath = @".\perftest.csv";
EndpointSelectorCTRL.Initialize(m_endpoints, configuration);
lock (m_lock)
{
OkBTN.Enabled = m_running = false;
}
// show dialog.
if (ShowDialog() != DialogResult.OK)
{
return null;
}
return null;
}
/// <summary>
/// Initializes the object with default values.
/// </summary>
public CoreNodeManager(
IServerInternal server,
ApplicationConfiguration configuration,
ushort dynamicNamespaceIndex)
{
if (server == null) throw new ArgumentNullException("server");
if (configuration == null) throw new ArgumentNullException("configuration");
m_server = server;
m_nodes = new NodeTable(server.NamespaceUris, server.ServerUris, server.TypeTree);
m_monitoredItems = new Dictionary<uint,MonitoredItem>();
m_defaultMinimumSamplingInterval = 1000;
m_namespaceUris = new List<string>();
m_dynamicNamespaceIndex = dynamicNamespaceIndex;
#if LEGACY_CORENODEMANAGER
m_eventSources = new Dictionary<object,IEventSource>();
#endif
// use namespace 1 if out of range.
if (m_dynamicNamespaceIndex == 0 || m_dynamicNamespaceIndex >= server.NamespaceUris.Count)
{
m_dynamicNamespaceIndex = 1;
}
m_samplingGroupManager = new SamplingGroupManager(
server,
this,
(uint)configuration.ServerConfiguration.MaxNotificationQueueSize,
configuration.ServerConfiguration.AvailableSamplingRates);
}
/// <summary>
/// Creates the objects used to validate the user identity tokens supported by the server.
/// </summary>
private void CreateUserIdentityValidators(ApplicationConfiguration configuration)
{
for (int ii = 0; ii < configuration.ServerConfiguration.UserTokenPolicies.Count; ii++)
{
UserTokenPolicy policy = configuration.ServerConfiguration.UserTokenPolicies[ii];
// ignore policies without an explicit id.
if (String.IsNullOrEmpty(policy.PolicyId))
{
continue;
}
// create a validator for an issued token policy.
if (policy.TokenType == UserTokenType.IssuedToken)
{
// the name of the element in the configuration file.
XmlQualifiedName qname = new XmlQualifiedName(policy.PolicyId, Namespaces.OpcUa);
// find the id for the issuer certificate.
CertificateIdentifier id = configuration.ParseExtension<CertificateIdentifier>(qname);
if (id == null)
{
Utils.Trace(
(int)Utils.TraceMasks.Error,
"Could not load CertificateIdentifier for UserTokenPolicy {0}",
policy.PolicyId);
continue;
}
m_tokenResolver = CreateSecurityTokenResolver(id);
m_tokenSerializer = WSSecurityTokenSerializer.DefaultInstance;
}
// create a validator for a certificate token policy.
if (policy.TokenType == UserTokenType.Certificate)
{
// the name of the element in the configuration file.
XmlQualifiedName qname = new XmlQualifiedName(policy.PolicyId, Namespaces.OpcUa);
// find the location of the trusted issuers.
CertificateTrustList trustedIssuers = configuration.ParseExtension<CertificateTrustList>(qname);
if (trustedIssuers == null)
{
Utils.Trace(
(int)Utils.TraceMasks.Error,
"Could not load CertificateTrustList for UserTokenPolicy {0}",
policy.PolicyId);
continue;
}
// trusts any certificate in the trusted people store.
m_certificateValidator = X509CertificateValidator.PeerTrust;
}
}
}
public void ShouldStillRemoveConfigurationFileIfGitRemoteIsNotRemoved([Frozen]Mock<IGitRepositoryConfigurer> repositoryConfigurer, [Frozen]Mock<IFileSystem> fileSystem, ApplicationConfiguration applicationConfiguration)
{
repositoryConfigurer.Setup(x => x.Unconfigure()).Throws<RepositoryConfigurationException>();
applicationConfiguration.RemoveConfiguration();
fileSystem.Verify(x => x.Delete(It.IsAny<string>()));
}
/// <summary>
/// Creates a form which uses the specified client configuration.
/// </summary>
/// <param name="configuration">The configuration to use.</param>
public MainForm(ApplicationConfiguration configuration)
{
InitializeComponent();
this.Icon = ClientUtils.GetAppIcon();
ConnectServerCTRL.Configuration = m_configuration = configuration;
ConnectServerCTRL.ServerUrl = "opc.tcp://localhost:61000/DsatsDemoServer";
this.Text = m_configuration.ApplicationName;
}
public void CreateConfigurations(out EngineConfiguration engineConfiguration,
out ApplicationConfiguration applicationConfiguraion,
out PerksConfiguration perksConfiguration)
{
engineConfiguration = CreateEngineConfiguration();
applicationConfiguraion = CreateApplicationConfiguration();
perksConfiguration = CreatePerksConfiguration();
}
/// <summary>
/// Constructs a new instance of the session.
/// </summary>
/// <param name="channel">The channel used to communicate with the server.</param>
/// <param name="configuration">The configuration for the client application.</param>
/// <param name="endpoint">The endpoint use to initialize the channel.</param>
public Session(
ISessionChannel channel,
ApplicationConfiguration configuration,
ConfiguredEndpoint endpoint)
:
this(channel as ITransportChannel, configuration, endpoint, null)
{
}
public StrategiesForm(StrategyConfiguration strategyConfiguration, List<CryptoCoin> knownCoins,
ApplicationConfiguration applicationConfiguration)
{
InitializeComponent();
this.strategyConfiguration = strategyConfiguration;
this.applicationConfiguration = applicationConfiguration;
this.knownCoins = knownCoins;
}
/// <summary>
/// Initializes the resource manager with the server instance that owns it.
/// </summary>
public ResourceManager(IServerInternal server, ApplicationConfiguration configuration)
{
if (server == null) throw new ArgumentNullException("server");
if (configuration == null) throw new ArgumentNullException("configuration");
m_server = server;
m_translationTables = new List<TranslationTable>();
}
/// <summary>
/// Creates a form which uses the specified client configuration.
/// </summary>
/// <param name="configuration">The configuration to use.</param>
public MainForm(ApplicationConfiguration configuration)
{
InitializeComponent();
this.Icon = ClientUtils.GetAppIcon();
ConnectServerCTRL.Configuration = m_configuration = configuration;
ConnectServerCTRL.ServerUrl = "opc.tcp://localhost:62541/Quickstarts/MethodsServer";
this.Text = m_configuration.ApplicationName;
}
public SettingsForm(ApplicationConfiguration applicationConfiguration, XgminerConfiguration minerConfiguration,
PathConfiguration pathConfiguration)
{
InitializeComponent();
this.minerConfiguration = minerConfiguration;
this.applicationConfiguration = applicationConfiguration;
this.pathConfiguration = pathConfiguration;
}
public MinerSettingsForm(XgminerConfiguration minerConfiguration, ApplicationConfiguration applicationConfiguration)
{
InitializeComponent();
this.minerConfiguration = minerConfiguration;
this.workingMinerConfiguration = ObjectCopier.CloneObject<XgminerConfiguration, XgminerConfiguration>(minerConfiguration);
this.applicationConfiguration = applicationConfiguration;
this.workingApplicationConfiguration = ObjectCopier.CloneObject<ApplicationConfiguration, ApplicationConfiguration>(applicationConfiguration);
}
private async Task ConsoleClient()
{
Log(conn_name + " - " + "Create an Application Configuration...");
exitCode = ExitCode.ErrorCreateApplication;
ApplicationInstance application = new ApplicationInstance
{
ApplicationName = "JSON-SCADA OPC-UA Client",
ApplicationType = ApplicationType.Client,
ConfigSectionName = "",
};
bool haveAppCertificate = false;
ApplicationConfiguration config = null;
try
{
// load the application configuration.
Log(conn_name + " - " + "Load config from " + OPCUA_conn.configFileName);
config = await application.LoadApplicationConfiguration(OPCUA_conn.configFileName, false);
// config.SecurityConfiguration.AutoAcceptUntrustedCertificates = true;
// check the application certificate.
haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, 0);
if (!haveAppCertificate)
{
Log(conn_name + " - " + "FATAL: Application instance certificate invalid!", LogLevelNoLog);
Environment.Exit(1);
}
if (haveAppCertificate)
{
config.ApplicationUri = X509Utils.GetApplicationUriFromCertificate(config.SecurityConfiguration.ApplicationCertificate.Certificate);
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
autoAccept = true;
}
config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
}
else
{
Log(conn_name + " - " + "WARN: missing application certificate, using unsecure connection.");
}
}
catch (Exception e)
{
Log(conn_name + " - WARN: " + e.Message);
}
if (config == null)
{
Log(conn_name + " - " + "FATAL: error in XML config file!", LogLevelNoLog);
Environment.Exit(1);
}
try
{
Log(conn_name + " - " + "Discover endpoints of " + OPCUA_conn.endpointURLs[0]);
exitCode = ExitCode.ErrorDiscoverEndpoints;
var selectedEndpoint = CoreClientUtils.SelectEndpoint(OPCUA_conn.endpointURLs[0], haveAppCertificate && OPCUA_conn.useSecurity, 15000);
Log(conn_name + " - " + "Selected endpoint uses: " +
selectedEndpoint.SecurityPolicyUri.Substring(selectedEndpoint.SecurityPolicyUri.LastIndexOf('#') + 1));
Log(conn_name + " - " + "Create a session with OPC UA server.");
exitCode = ExitCode.ErrorCreateSession;
var endpointConfiguration = EndpointConfiguration.Create(config);
var endpoint = new ConfiguredEndpoint(null, selectedEndpoint, endpointConfiguration);
await Task.Delay(50);
session = await Session.Create(config, endpoint, false, "OPC UA Console Client", 60000, new UserIdentity(new AnonymousIdentityToken()), null);
// Log("" + session.KeepAliveInterval); // default is 5000
session.KeepAliveInterval = System.Convert.ToInt32(OPCUA_conn.timeoutMs);
// register keep alive handler
session.KeepAlive += Client_KeepAlive;
}
catch (Exception e)
{
Log(conn_name + " - WARN: " + e.Message);
}
if (session == null)
{
Log(conn_name + " - " + "FATAL: error creating session!", LogLevelNoLog);
Environment.Exit(1);
}
Log(conn_name + " - " + "Browsing the OPC UA server namespace.");
exitCode = ExitCode.ErrorBrowseNamespace;
await FindObjects(session, ObjectIds.ObjectsFolder);
await Task.Delay(50);
Log(conn_name + " - " + "Add a list of items (server current time and status) to the subscription.");
exitCode = ExitCode.ErrorMonitoredItem;
ListMon.ForEach(i => i.Notification += OnNotification);
//ListMon.ForEach(i => i.SamplingInterval = System.Convert.ToInt32(System.Convert.ToDouble(OPCUA_conn.autoCreateTagSamplingInterval) * 1000);
// ListMon.ForEach(i => Log(conn_name + " - " + i.DisplayName));
Log(conn_name + " - " + ListMon.Count + " Objects found");
Log(conn_name + " - " + "Create a subscription with publishing interval of " + System.Convert.ToDouble(OPCUA_conn.autoCreateTagPublishingInterval) + "seconds");
exitCode = ExitCode.ErrorCreateSubscription;
var subscription =
new Subscription(session.DefaultSubscription)
{
PublishingInterval = System.Convert.ToInt32(System.Convert.ToDouble(OPCUA_conn.autoCreateTagPublishingInterval) * 1000),
PublishingEnabled = true
};
await Task.Delay(50);
subscription.AddItems(ListMon);
await Task.Delay(50);
Log(conn_name + " - " + "Add the subscription to the session.");
Log(conn_name + " - " + subscription.MonitoredItemCount + " Monitored items");
exitCode = ExitCode.ErrorAddSubscription;
session.AddSubscription(subscription);
subscription.Create();
subscription.ApplyChanges();
Log(conn_name + " - " + "Running...");
exitCode = ExitCode.ErrorRunning;
}
/// <summary>
/// Creates a form which displays the status for a UA server.
/// </summary>
public ServerForm(StandardServer server, ApplicationConfiguration configuration) : base(server, configuration)
{
}
/// <inheritdoc/>
public INodeManager CreateNodeManager(IServerInternal server,
ApplicationConfiguration configuration)
{
return(new SimpleEventsNodeManager(server, configuration));
}
/// <summary>
/// Initializes a new instance of the UAClient class.
/// </summary>
public UAClient(ApplicationConfiguration configuration)
{
m_configuration = configuration;
m_configuration.CertificateValidator.CertificateValidation += CertificateValidation;
}
/// <summary>
/// Creates the resource manager for the server.
/// </summary>
protected override ResourceManager CreateResourceManager(IServerInternal server, ApplicationConfiguration configuration)
{
ResourceManager resourceManager = new ResourceManager(server, configuration);
// add some localized strings to the resource manager to demonstrate that localization occurs.
resourceManager.Add("InvalidPassword", "de-DE", "Das Passwort ist nicht gültig für Konto '{0}'.");
resourceManager.Add("InvalidPassword", "es-ES", "La contraseña no es válida para la cuenta de '{0}'.");
resourceManager.Add("UnexpectedUserTokenError", "fr-FR", "Une erreur inattendue s'est produite lors de la validation utilisateur.");
resourceManager.Add("UnexpectedUserTokenError", "de-DE", "Ein unerwarteter Fehler ist aufgetreten während des Anwenders.");
return(resourceManager);
}
public static ServiceBundle Create(ApplicationConfiguration config)
{
return(new ServiceBundle(config));
}
/// <summary>
/// Constructor
/// </summary>
public DownloadMonthlyQueueData(ApplicationConfiguration config)
{
m_configuration = config;
}
/// <inheritdoc />
public IWebUIFactory GetWebUiFactory(ApplicationConfiguration appConfig)
{
return(appConfig.WebUiFactoryCreator != null?
appConfig.WebUiFactoryCreator() :
CreateWebUiFactory());
}
public GitWebhookController()
{
var configuration = ApplicationConfiguration.Read <UlearnConfiguration>();
gitSecret = configuration.Git.Webhook.Secret;
}
protected override MasterNodeManager CreateMasterNodeManager(IServerInternal server, ApplicationConfiguration configuration)
{
List <INodeManager> nodeManagers = new List <INodeManager>();
nodeManagers.Add(new SimpleNodeManager(server, configuration));
return(new MasterNodeManager(server, configuration, null, nodeManagers.ToArray()));
}
/// <summary>
/// Creates the node managers for the server.
/// </summary>
/// <remarks>
/// This method allows the sub-class create any additional node managers which it uses. The SDK
/// always creates a CoreNodeManager which handles the built-in nodes defined by the specification.
/// Any additional NodeManagers are expected to handle application specific nodes.
/// </remarks>
protected override MasterNodeManager CreateMasterNodeManager(IServerInternal server, ApplicationConfiguration configuration)
{
Utils.Trace("Creating the Node Managers.");
List <INodeManager> nodeManagers = new List <INodeManager>();
// create the custom node managers.
nodeManagers.Add(new ApplicationsNodeManager(server, configuration));
// create master node manager.
return(new MasterNodeManager(server, configuration, null, nodeManagers.ToArray()));
}
/// <inheritdoc/>
public INodeManager CreateNodeManager(IServerInternal server,
ApplicationConfiguration configuration)
{
return(new MemoryBufferNodeManager(server, configuration));
}
/// <summary>
/// Creates the node managers for the server.
/// </summary>
/// <remarks>
/// This method allows the sub-class create any additional node managers which it uses. The SDK
/// always creates a CoreNodesManager which handles the built-in nodes defined by the specification.
/// Any additional NodeManagers are expected to handle application specific nodes.
/// </remarks>
protected override MasterNodeManager CreateMasterNodeManager(IServerInternal server, ApplicationConfiguration configuration)
{
var nodeManagers = new List <INodeManager>();
if (!string.IsNullOrEmpty(NodesFileName) && !File.Exists(NodesFileName))
{
string errorMessage = $"The user node configuration file {NodesFileName} does not exist.";
Logger.Error(errorMessage);
throw new Exception(errorMessage);
}
// Add encodable complex types.
server.Factory.AddEncodeableTypes(Assembly.GetExecutingAssembly());
PlcNodeManager = new PlcNodeManager(server, configuration, NodesFileName);
nodeManagers.Add(PlcNodeManager);
if (PlcSimulation.AddSimpleEventsSimulation)
{
SimpleEventsNodeManager = new SimpleEventsNodeManager(server, configuration);
nodeManagers.Add(SimpleEventsNodeManager);
}
if (PlcSimulation.AddAlarmSimulation)
{
AlarmNodeManager = new AlarmConditionServerNodeManager(server, configuration);
nodeManagers.Add(AlarmNodeManager);
}
if (PlcSimulation.AddReferenceTestSimulation)
{
SimulationNodeManager = new ReferenceNodeManager(server, configuration);
nodeManagers.Add(SimulationNodeManager);
}
var masterNodeManager = new MasterNodeManager(server, configuration, null, nodeManagers.ToArray());
return(masterNodeManager);
}
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>
/// Initializes the node manager.
/// </summary>
public AlarmNodeManager(IServerInternal server, ApplicationConfiguration configuration, string[] namespaceUris) :
base(server, configuration, namespaceUris)
{
}
private void button1_Click(object sender, EventArgs e)
{
if (MessageBox.Show("文书是否要集中打印", "集中打印", MessageBoxButtons.YesNo, MessageBoxIcon.Question) != DialogResult.Yes)
{
return;
}
foreach (CheckedListBoxItem item in chkDocCheckList.Items)
{
if (item.CheckState == CheckState.Checked)
{
ApplicationConfiguration.MedicalDocucementElement document = ApplicationConfiguration.GetMedicalDocument(item.Value.ToString());
//没有找到退出
if (string.IsNullOrEmpty(document.Caption))
{
DialogResult dialogResult = MessageBoxFormPC.Show(string.Format("无法加载文书'{0}'的设计模版,请确保模版文件已经存在", item.Value.ToString()),
"提示信息", MessageBoxButtons.OK, MessageBoxIcon.Information);
continue;
}
try
{
Type t = Type.GetType(document.Type);
CustomBaseDoc baseDoc = Activator.CreateInstance(t) as CustomBaseDoc;
baseDoc.BackColor = Color.White;
baseDoc.Name = item.Value.ToString();
baseDoc.HideScrollBar();
baseDoc.Initial();
baseDoc.LoadReport(ExtendApplicationContext.Current.AppPath + document.Path);
bool IsPrintSuccess = baseDoc.PrintBaseDoc();
List <string> fileList = new List <string>();
foreach (CheckedListBoxItem boxItem in chkDocCheckList.Items)
{
if (boxItem.CheckState == CheckState.Checked)
{
fileList.Add(boxItem.Value.ToString());
}
}
//ApplicationConfiguration.multiPrintNames = string.Join(",", fileList.ToArray());
//(new ConfigurationDA()).UpdateConfigTableDataTable(ExtendApplicationContext.Current.CommDict.ConfigDict);
//if (ExtendApplicationContext.Current.PatientInformation != null && IsPrintSuccess)
//{
// Common.MED_ANES_BUTTON_MARKDataTable buttonMarkDT = new CommonDA().GetAnesDocButtonMarkData(ExtendApplicationContext.Current.PatientInformation.PatientID,
// ExtendApplicationContext.Current.PatientInformation.VisitID, ExtendApplicationContext.Current.PatientInformation.OperID, MedicalDocSettings.ReturnDocNameByKey(baseDoc.Name));
// if (buttonMarkDT.Count == 0)
// {
// Common.MED_ANES_BUTTON_MARKRow dr = buttonMarkDT.NewMED_ANES_BUTTON_MARKRow();
// dr.PATIENT_ID = ExtendApplicationContext.Current.PatientInformation.PatientID;
// dr.VISIT_ID = ExtendApplicationContext.Current.PatientInformation.VisitID;
// dr.OPER_ID = ExtendApplicationContext.Current.PatientInformation.OperID;
// dr.BUTTON_NAME = MedicalDocSettings.ReturnDocNameByKey(baseDoc.Name);
// dr.RGB = new CommonDA().returnRGB(Color.Blue);
// buttonMarkDT.AddMED_ANES_BUTTON_MARKRow(dr);
// }
// else if (buttonMarkDT.Count > 0)
// {
// Common.MED_ANES_BUTTON_MARKRow dr = buttonMarkDT[0] as Common.MED_ANES_BUTTON_MARKRow;
// dr.RGB = new CommonDA().returnRGB(Color.Blue);
// }
// try
// {
// int r = new CommonDA().UpdateAnesDocButtonMarkData(buttonMarkDT);
// }
// catch (Exception ex)
// {
// ExceptionHandler.Handle(ex);
// } //todo
//}
}
catch
{
}
}
}
}
/// <inheritdoc/>
public INodeManager Create(IServerInternal server, ApplicationConfiguration configuration)
{
return(new AlarmNodeManager(server, configuration, NamespacesUris.ToArray()));
}
static void Main()
{
ApplicationConfiguration.Initialize();
Application.Run(new Main());
}
/// <summary>
/// Creates the node managers for the server.
/// </summary>
/// <remarks>
/// This method allows the sub-class create any additional node managers which it uses. The SDK
/// always creates a CoreNodeManager which handles the built-in nodes defined by the specification.
/// Any additional NodeManagers are expected to handle application specific nodes.
///
/// Applications with small address spaces do not need to create their own NodeManagers and can add any
/// application specific nodes to the CoreNodeManager. Applications should use custom NodeManagers when
/// the structure of the address space is stored in another system or when the address space is too large
/// to keep in memory.
/// </remarks>
protected override MasterNodeManager CreateMasterNodeManager(IServerInternal server, ApplicationConfiguration configuration)
{
Debug.WriteLine("Creating the Node Managers.");
List <INodeManager> nodeManagers = new List <INodeManager>();
// create the custom node managers.
nodeManagers.Add(new global::TestData.TestDataNodeManager(server, configuration));
nodeManagers.Add(new global::MemoryBuffer.MemoryBufferNodeManager(server, configuration));
nodeManagers.Add(new global::Boiler.BoilerNodeManager(server, configuration));
// create master node manager.
return(new MasterNodeManager(server, configuration, null, nodeManagers.ToArray()));
}
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 root = Path.Combine("%LocalApplicationData%", "OPC");
string pkiRoot = Path.Combine(root, "pki");
var clientConfig = new ServerConfigurationPushTestClientConfiguration()
{
ServerUrl = "opc.tcp://localhost:58810/GlobalDiscoveryTestServer",
AppUserName = "",
AppPassword = "",
SysAdminUserName = "******",
SysAdminPassword = "******",
TempStorePath = Path.Combine(pkiRoot, "temp")
};
var transportQuotas = new TransportQuotas()
{
OperationTimeout = 120000,
MaxStringLength = 1048576,
MaxByteStringLength = 1048576,
MaxArrayLength = 65535,
MaxMessageSize = 4194304,
MaxBufferSize = 65535,
ChannelLifetime = 300000,
SecurityTokenLifetime = 3600000,
};
// build the application configuration.
Config = await application
.Build(
"urn:localhost:opcfoundation.org:ServerConfigurationPushTestClient",
"http://opcfoundation.org/UA/ServerConfigurationPushTestClient")
.SetTransportQuotas(transportQuotas)
.AsClient()
.AddSecurityConfiguration(
"CN=Server Configuration Push Test Client, O=OPC Foundation",
pkiRoot, pkiRoot, pkiRoot)
.SetAutoAcceptUntrustedCertificates(true)
.SetRejectSHA1SignedCertificates(false)
.SetRejectUnknownRevocationStatus(true)
.SetMinimumCertificateKeySize(1024)
.AddExtension <ServerConfigurationPushTestClientConfiguration>(null, clientConfig)
.SetOutputFilePath(Path.Combine(root, "Logs", "Opc.Ua.Gds.Tests.log.txt"))
.SetTraceMasks(Utils.TraceMasks.Error)
.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>();
m_client = new ServerPushConfigurationClient(application.ApplicationConfiguration)
{
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;
}
public static MaximoOperationExecutionContext GetInstance(IOperationData operationData, DynamicObject proxy = null)
{
return(ApplicationConfiguration.IsMif() ? (MaximoOperationExecutionContext) new MifExecutionContext(operationData, proxy) :
new MeaExecutionContext(operationData, proxy));
}
public XNodeManager(IServerInternal server, ApplicationConfiguration configuration) : base(server, configuration,
"http://opcfoundation.org/Quickstarts/ReferenceApplications")
{
}
public override IBroker CreateBroker(ApplicationConfiguration appConfig, CoreUIParent uiParent)
{
return(new WamBroker(uiParent, appConfig, Logger));
}
/// <summary>
/// Creates the resource manager for the server.
/// </summary>
protected override ResourceManager CreateResourceManager(IServerInternal server, ApplicationConfiguration configuration)
{
var resourceManager = new ResourceManager(server, configuration);
FieldInfo[] fields = typeof(StatusCodes).GetFields(BindingFlags.Public | BindingFlags.Static);
foreach (FieldInfo field in fields)
{
uint?id = field.GetValue(typeof(StatusCodes)) as uint?;
if (id != null)
{
resourceManager.Add(id.Value, "en-US", field.Name);
}
}
return(resourceManager);
}
/// <summary>
/// Finds the endpoint that best matches the current settings.
/// </summary>
/// <param name="discoveryUrl">The discovery URL.</param>
/// <param name="useSecurity">if set to <c>true</c> select an endpoint that uses security.</param>
/// <returns>The best available endpoint.</returns>
public static EndpointDescription SelectEndpoint(ApplicationConfiguration application, string discoveryUrl, bool useSecurity)
{
// needs to add the '/discovery' back onto non-UA TCP URLs.
if (discoveryUrl.StartsWith(Utils.UriSchemeHttps))
{
if (!discoveryUrl.EndsWith("/discovery"))
{
discoveryUrl += "/discovery";
}
}
// parse the selected URL.
Uri uri = new Uri(discoveryUrl);
// set a short timeout because this is happening in the drop down event.
EndpointConfiguration configuration = EndpointConfiguration.Create();
configuration.OperationTimeout = 5000;
EndpointDescription selectedEndpoint = null;
// Connect to the server's discovery endpoint and find the available configuration.
using (DiscoveryClient client = DiscoveryClient.Create(uri, configuration))
{
EndpointDescriptionCollection endpoints = client.GetEndpoints(null);
// select the best endpoint to use based on the selected URL and the UseSecurity checkbox.
for (int ii = 0; ii < endpoints.Count; ii++)
{
EndpointDescription endpoint = endpoints[ii];
// check for a match on the URL scheme.
if (endpoint.EndpointUrl.StartsWith(uri.Scheme))
{
// check if security was requested.
if (useSecurity)
{
if (endpoint.SecurityMode == MessageSecurityMode.None)
{
continue;
}
}
else
{
if (endpoint.SecurityMode != MessageSecurityMode.None)
{
continue;
}
}
// pick the first available endpoint by default.
if (selectedEndpoint == null)
{
selectedEndpoint = endpoint;
}
// The security level is a relative measure assigned by the server to the
// endpoints that it returns. Clients should always pick the highest level
// unless they have a reason not too.
if (endpoint.SecurityLevel > selectedEndpoint.SecurityLevel)
{
selectedEndpoint = endpoint;
}
}
}
// pick the first available endpoint by default.
if (selectedEndpoint == null && endpoints.Count > 0)
{
selectedEndpoint = endpoints[0];
}
}
// if a server is behind a firewall it may return URLs that are not accessible to the client.
// This problem can be avoided by assuming that the domain in the URL used to call
// GetEndpoints can be used to access any of the endpoints. This code makes that conversion.
// Note that the conversion only makes sense if discovery uses the same protocol as the endpoint.
Uri endpointUrl = Utils.ParseUri(selectedEndpoint.EndpointUrl);
if (endpointUrl != null && endpointUrl.Scheme == uri.Scheme)
{
UriBuilder builder = new UriBuilder(endpointUrl);
builder.Host = uri.DnsSafeHost;
builder.Port = uri.Port;
selectedEndpoint.EndpointUrl = builder.ToString();
}
// return the selected endpoint.
return(selectedEndpoint);
}
public ULearnDb()
: this(ApplicationConfiguration.Read <DatabaseConfiguration>().Database)
{
}
protected override MasterNodeManager CreateMasterNodeManager(IServerInternal server, ApplicationConfiguration configuration)
{
Utils.Trace("Creating the Node Managers.");
List <INodeManager> nodeManagers = new List <INodeManager>();
//tao node theo danh sach
nodeManagers.Add(new EmptyNodeManager(server, configuration));
//tao cac node chay rieng boi server
return(new MasterNodeManager(server, configuration, null, nodeManagers.ToArray()));
}
private static void EnsureApplicationCertificate(ApplicationConfiguration configuration)
{
const ushort keySize = 1024;
const ushort lifetimeInMonths = 300;
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
bool errorFlag = false;
string hostName = Dns.GetHostName();
var serverDomainNames = configuration.GetServerDomainNames();
var applicationCertificate = configuration.SecurityConfiguration.ApplicationCertificate;
var certificate = applicationCertificate.Find(true);
if (certificate != null)
{
// if cert found then check domains
var domainsFromCertficate = Utils.GetDomainsFromCertficate(certificate);
foreach (string serverDomainName in serverDomainNames)
{
if (Utils.FindStringIgnoreCase(domainsFromCertficate, serverDomainName))
{
continue;
}
if (string.Equals(serverDomainName, "localhost", StringComparison.OrdinalIgnoreCase))
{
if (Utils.FindStringIgnoreCase(domainsFromCertficate, hostName))
{
continue;
}
var hostEntry = Dns.GetHostEntry(hostName);
if (hostEntry.Aliases.Any(alias => Utils.FindStringIgnoreCase(domainsFromCertficate, alias)))
{
continue;
}
if (hostEntry.AddressList.Any(ipAddress => Utils.FindStringIgnoreCase(domainsFromCertficate, ipAddress.ToString())))
{
continue;
}
}
Trace.TraceInformation("The application is configured to use domain '{0}' which does not appear in the certificate.", serverDomainName);
errorFlag = true;
} // end for
// if no errors and keySizes match
if (!errorFlag && (keySize == certificate.PublicKey.Key.KeySize))
{
return; // cert okay
}
}
// if we get here then we'll create a new cert
if (certificate == null)
{
certificate = applicationCertificate.Find(false);
if (certificate != null)
{
Trace.TraceInformation("Matching certificate with SubjectName '{0}' found but without a private key.", applicationCertificate.SubjectName);
}
}
// lets check if there is any to delete
if (certificate != null)
{
using (var store2 = applicationCertificate.OpenStore())
{
store2.Delete(certificate.Thumbprint);
}
}
if (serverDomainNames.Count == 0)
{
serverDomainNames.Add(hostName);
}
CertificateFactory.CreateCertificate(applicationCertificate.StoreType, applicationCertificate.StorePath, configuration.ApplicationUri, configuration.ApplicationName, null, serverDomainNames, keySize, lifetimeInMonths);
Trace.TraceInformation("Created new certificate with SubjectName '{0}', in certificate store '{1}'.", applicationCertificate.SubjectName, applicationCertificate.StorePath);
configuration.CertificateValidator.Update(configuration.SecurityConfiguration);
}
public AccountsService()
{
this.configuration = new ApplicationConfiguration();
this.configuration.Load();
}
public virtual IBroker CreateBroker(ApplicationConfiguration appConfig, CoreUIParent uiParent)
{
return(appConfig.BrokerCreatorFunc != null?
appConfig.BrokerCreatorFunc(uiParent, appConfig, Logger) :
new NullBroker());
}
