public FetchTypeTree ( ExpandedNodeId typeId ) : void | ||
typeId | ExpandedNodeId | |
return | void |
/// <summary> /// Called when a session is created with a server. /// </summary> private void OnSessionCreated(Session session) { string commonAppDataPath = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData); string configFileName = Utils.Format(@"{0}\OPC Foundation\ComPseudoServers\{1}.internal.xml", commonAppDataPath, m_clsid); lock (m_lock) { try { m_session = null; m_Subscription = null; m_AreaNodes.Clear(); m_session = session; // load the config file. if (File.Exists(configFileName)) { XmlSerializer ser = new XmlSerializer(typeof(Configuration)); TextReader reader = new StreamReader(configFileName); m_configFile = (Configuration)ser.Deserialize(reader); reader.Close(); // set the ActualDataType property for (int ii = 0; ii < m_configFile.Attributes.Length - 1; ii++) { NodeId nodeid = new NodeId(m_configFile.Attributes[ii].strDataTypeNodeId); m_configFile.Attributes[ii].ActualDataType = DataTypes.GetSystemType(nodeid, EncodeableFactory.GlobalFactory); } } else { InitConfigInfo(configFileName); } // Obtain the current server table, generate index mapping tables (client->server, server->client) // and update the client side namespace table if necessary due to server changes GenerateNamespaceIndexMappings(m_clsid); // The client side namespace table may have been updated if the server namespace table // has changed therefore save the updated client table. SaveConfigInfo(configFileName); // fetch type tree. m_session.FetchTypeTree(Opc.Ua.ObjectTypeIds.BaseEventType); m_session.FetchTypeTree(Opc.Ua.ReferenceTypeIds.References); //Create UA Event Subscription if none configured in the registry m_Subscription = new Opc.Ua.Client.Subscription(m_session.DefaultSubscription); m_Subscription.PublishingEnabled = true; m_Subscription.PublishingInterval = m_configFile.ProxySubscriptionSettings.PublishingInterval; m_Subscription.KeepAliveCount = m_configFile.ProxySubscriptionSettings.KeepAliveCount; m_Subscription.LifetimeCount = m_configFile.ProxySubscriptionSettings.LifetimeCount; m_Subscription.Priority = m_configFile.ProxySubscriptionSettings.Priority; m_Subscription.MaxNotificationsPerPublish = m_configFile.ProxySubscriptionSettings.MaxNotificationsPerPublish; m_session.AddSubscription(m_Subscription); m_Subscription.Create(); m_KeepAliveInterval = (int)(m_Subscription.CurrentPublishingInterval * m_Subscription.CurrentKeepAliveCount); // Add Server object as the only monitored item to this subscription NodeId nodeId_Server = new NodeId(Opc.Ua.Objects.Server); MonitoredItem monitoredItem = CreateMonitoredItemForEvents(nodeId_Server); m_Subscription.AddItem(monitoredItem); m_Subscription.ApplyChanges(); AreaNode areaNode = new AreaNode(); areaNode.AreaName = "/"; ++areaNode.RefCount; areaNode.MonitoredItem = monitoredItem; m_notifiers.Add(monitoredItem.ClientHandle, areaNode); m_AreaNodes.Add("/", areaNode); m_Subscription.Session.Call( Opc.Ua.ObjectTypes.ConditionType, Methods.ConditionType_ConditionRefresh, m_Subscription.Id); } catch (Exception e) { Utils.Trace(e, "Initializing server after create."); throw ComUtils.CreateComException(e); } } }
/// <summary> /// Creates a new session. /// </summary> private Session CreateSession(Guid clsid) { // lookup the cached configuration information. ConfiguredEndpoint endpoint = null; bool previouslyConnected = true; if (!m_verifiedEndpoints.TryGetValue(clsid, out endpoint)) { endpoint = LoadConfiguredEndpoint(clsid); if (endpoint != null) { Utils.Trace("Loaded endpoint with URL: {0}", endpoint.EndpointUrl); previouslyConnected = false; } } if (endpoint == null) { endpoint = m_endpointCache.Create(DefaultServerUrl); } // Initialize the client configuration. // Fetch the current configuration information by connecting to the server's discovery endpoint. // This method assumes that the discovery endpoint can be constructed by appending "/discovery" to the URL. if (endpoint.UpdateBeforeConnect && !previouslyConnected) { endpoint.UpdateFromServer(BindingFactory.Default); Utils.Trace("Updated endpoint from server: {0}", endpoint.EndpointUrl); } // Need to specify that the server is trusted by the client application. if (!previouslyConnected) { m_configuration.SecurityConfiguration.AddTrustedPeer(endpoint.Description.ServerCertificate); } // Set the session keep alive to 600 seconds. m_configuration.ClientConfiguration.DefaultSessionTimeout = 600000; ServiceMessageContext messageContext = m_configuration.CreateMessageContext(); // Initialize the channel which will be created with the server. ITransportChannel channel = SessionChannel.Create( m_configuration, endpoint.Description, endpoint.Configuration, m_configuration.SecurityConfiguration.ApplicationCertificate.Find(true), messageContext); // Wrap the channel with the session object. Session session = new Session(channel, m_configuration, endpoint, null); session.ReturnDiagnostics = DiagnosticsMasks.SymbolicId; // The user login credentials must be provided when opening a session. IUserIdentity identity = null; if (endpoint.UserIdentity != null) { identity = new Opc.Ua.UserIdentity(endpoint.UserIdentity); } // Create the session. This actually connects to the server. session.Open("COM Client Session", identity); // need to fetch the references in order use the node cache. session.FetchTypeTree(ReferenceTypeIds.References); // save the updated information. if (!previouslyConnected) { try { SaveConfiguredEndpoint(clsid, endpoint); } catch (Exception e) { Utils.Trace(e, "Could not save SaveConfiguredEndpoint in registry."); } m_verifiedEndpoints.Add(clsid, endpoint); } return session; }