Struct DiagnosticsNodeManager 

pub struct DiagnosticsNodeManager { /* private fields */ }

Node manager handling nodes in the server hierarchy that are not part of the core namespace, and that are somehow dynamic. This includes the node for each namespace, session diagnostics, etc.

Trait Implementations

impl NodeManager for DiagnosticsNodeManager

fn owns_node(&self, id: &NodeId) -> bool

Return whether this node manager owns the given node, this is used for propagating service-level errors.

fn name(&self) -> &str

Name of this node manager, for debug purposes.

fn namespaces_for_user( &self, context: &RequestContext, ) -> Vec<NamespaceMetadata>

Namespaces for a given user, used to populate the namespace array. This being a method allows different users to see different namespaces.

fn init<'life0, 'life1, 'async_trait>( &'life0 self, _type_tree: &'life1 mut DefaultTypeTree, context: ServerContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, DiagnosticsNodeManager: 'async_trait,

Perform any necessary loading of nodes, should populate the type tree if needed.

fn resolve_external_references<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, items: &'life2 mut [&'life3 mut ExternalReferenceRequest], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, DiagnosticsNodeManager: 'async_trait,

Resolve a list of references given by a different node manager.

fn browse<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes_to_browse: &'life2 mut [BrowseNode], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiagnosticsNodeManager: 'async_trait,

Perform the Browse or BrowseNext service.

fn read<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, _max_age: f64, _timestamps_to_return: TimestampsToReturn, nodes_to_read: &'life2 mut [&'life3 mut ReadNode], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, DiagnosticsNodeManager: 'async_trait,

Execute the Read service. This should set results on the given nodes_to_read as needed.

fn translate_browse_paths_to_node_ids<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes: &'life2 mut [&'life3 mut BrowsePathItem<'_>], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, DiagnosticsNodeManager: 'async_trait,

Perform the translate browse paths to node IDs service.

fn owns_server_events(&self) -> bool

Return whether this node manager owns events on the server. The first node manager that returns true here will be called when reading or updating historical server events.

fn handle_new_node(&self, parent_id: &ExpandedNodeId) -> bool

Return whether this node should handle requests to create a node for the given parent ID. This is only called if no new node ID is requested, otherwise owns_node is called on the requested node ID.

fn history_read_raw_modified<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context: &'life1 RequestContext, details: &'life2 ReadRawModifiedDetails, nodes: &'life3 mut [&'life4 mut HistoryNode], timestamps_to_return: TimestampsToReturn, ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Self: Sync + 'async_trait,

Perform the history read raw modified service. This should write results to the nodes list of type either HistoryData or HistoryModifiedData

fn history_read_processed<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context: &'life1 RequestContext, details: &'life2 ReadProcessedDetails, nodes: &'life3 mut [&'life4 mut HistoryNode], timestamps_to_return: TimestampsToReturn, ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Self: Sync + 'async_trait,

Perform the history read processed service. This should write results to the nodes list of type HistoryData.

fn history_read_at_time<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context: &'life1 RequestContext, details: &'life2 ReadAtTimeDetails, nodes: &'life3 mut [&'life4 mut HistoryNode], timestamps_to_return: TimestampsToReturn, ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Self: Sync + 'async_trait,

Perform the history read processed service. This should write results to the nodes list of type HistoryData.

fn history_read_events<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context: &'life1 RequestContext, details: &'life2 ReadEventDetails, nodes: &'life3 mut [&'life4 mut HistoryNode], timestamps_to_return: TimestampsToReturn, ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Self: Sync + 'async_trait,

Perform the history read events service. This should write results to the nodes list of type HistoryEvent.

fn history_read_annotations<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context: &'life1 RequestContext, details: &'life2 ReadAnnotationDataDetails, nodes: &'life3 mut [&'life4 mut HistoryNode], timestamps_to_return: TimestampsToReturn, ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Self: Sync + 'async_trait,

Perform the history read annotations data service. This should write results to the nodes list of type Annotation.

fn write<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes_to_write: &'life2 mut [&'life3 mut WriteNode], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Perform the write service. This should write results to the nodes_to_write list. The default result is BadNodeIdUnknown

fn history_update<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes: &'life2 mut [&'life3 mut HistoryUpdateNode], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Perform the HistoryUpdate service. This should write result status codes to the nodes list as appropriate.

fn register_nodes<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes: &'life2 mut [&'life3 mut RegisterNodeItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Perform the register nodes service. The default behavior for this service is to do nothing and pretend the nodes were registered.

fn unregister_nodes<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, _nodes: &'life2 [&'life3 NodeId], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Perform the unregister nodes service. The default behavior for this service is to do nothing.

fn create_monitored_items<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, items: &'life2 mut [&'life3 mut CreateMonitoredItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Prepare for monitored item creation, the node manager must take action to sample data for each produced monitored item, according to the parameters. Monitored item parameters have already been revised according to server limits, but the node manager is allowed to further revise sampling interval.

fn modify_monitored_items<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, items: &'life2 [&'life3 MonitoredItemUpdateRef], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Modify monitored items. This method is purely informative for the node manager, to let it modify sampling intervals, apply a new filter, or similar.

fn set_monitoring_mode<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, mode: MonitoringMode, items: &'life2 [&'life3 MonitoredItemRef], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Modify monitored items. This method is purely informative for the node manager, to let it pause or resume sampling. Note that this should not delete context stored from create_monitored_items, since it may be called again to resume sampling.

fn delete_monitored_items<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, items: &'life2 [&'life3 MonitoredItemRef], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Delete monitored items. This method is purely informative for the node manager, to let it stop sampling, or similar.

fn query<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, context: &'life1 RequestContext, request: &'life2 mut QueryRequest, ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Perform a query on the address space.

fn call<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, methods_to_call: &'life2 mut [&'life3 mut MethodCall], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Call a list of methods.

fn add_nodes<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes_to_add: &'life2 mut [&'life3 mut AddNodeItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Add a list of nodes.

fn add_references<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, references_to_add: &'life2 mut [&'life3 mut AddReferenceItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Add a list of references.

fn delete_nodes<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes_to_delete: &'life2 mut [&'life3 mut DeleteNodeItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Delete a list of nodes.

fn delete_node_references<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, to_delete: &'life2 [&'life3 DeleteNodeItem], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Delete references for the given list of nodes. The node manager should respect delete_target_references.

fn delete_references<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, references_to_delete: &'life2 mut [&'life3 mut DeleteReferenceItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Delete a list of references.