ua-client 0.5.0

Native OPC UA browser/inspector GUI built on async-opcua and egui
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use std::collections::{HashMap, HashSet, VecDeque};

use opcua::types::{NodeId, ObjectId};

use crate::types::{
    AuthMode, EndpointInfo, LogLine, NodeSummary, ReferenceRow, SecurityMode, TreeChild,
};

const MAX_LOG_LINES: usize = 1000;
const MAX_HISTORY: usize = 20;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConnectionState {
    Disconnected,
    Connecting,
    Connected,
    Disconnecting,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DetailTab {
    Attributes,
    Events,
    DataChanges,
    References,
}

#[derive(Debug, Default)]
pub struct TreeModel {
    pub children: HashMap<NodeId, Vec<TreeChild>>,
    pub expanded: HashSet<NodeId>,
    pub loading: HashSet<NodeId>,
}

impl TreeModel {
    pub fn clear(&mut self) {
        self.children.clear();
        self.expanded.clear();
        self.loading.clear();
    }
}

pub struct AppModel {
    pub endpoint_url: String,
    pub endpoint_history: Vec<String>,
    pub connection: ConnectionState,
    pub root_node: NodeId,
    pub tree: TreeModel,
    pub selected: Option<NodeId>,
    pub node_summary: Option<NodeSummary>,
    pub active_tab: DetailTab,
    pub references: Option<Vec<ReferenceRow>>,
    pub references_loading: bool,
    pub log: VecDeque<LogLine>,
    pub selected_endpoint: Option<EndpointInfo>,
    pub endpoints_loading: bool,
    pub discovered_endpoints: Option<Vec<EndpointInfo>>,
    pub endpoints_dialog_open: bool,
    pub auth_mode: AuthMode,
    pub auth_username: String,
    pub auth_password: String,
    pub auth_cert_path: String,
    pub auth_key_path: String,
    pub last_selection_paths: HashMap<String, Vec<NodeId>>,
    pub endpoint_mode_filter: SecurityMode,
    pub file_picker_open: bool,
}

impl Default for AppModel {
    fn default() -> Self {
        Self {
            endpoint_url: "opc.tcp://localhost:4855".to_string(),
            endpoint_history: Vec::new(),
            connection: ConnectionState::Disconnected,
            root_node: NodeId::new(0, ObjectId::RootFolder as u32),
            tree: TreeModel::default(),
            selected: None,
            node_summary: None,
            active_tab: DetailTab::References,
            references: None,
            references_loading: false,
            log: VecDeque::with_capacity(MAX_LOG_LINES),
            selected_endpoint: None,
            endpoints_loading: false,
            discovered_endpoints: None,
            endpoints_dialog_open: false,
            auth_mode: AuthMode::Anonymous,
            auth_username: String::new(),
            auth_password: String::new(),
            auth_cert_path: String::new(),
            auth_key_path: String::new(),
            last_selection_paths: HashMap::new(),
            endpoint_mode_filter: SecurityMode::None,
            file_picker_open: false,
        }
    }
}

impl AppModel {
    pub fn push_log(&mut self, line: LogLine) {
        if self.log.len() == MAX_LOG_LINES {
            self.log.pop_front();
        }
        self.log.push_back(line);
    }

    pub fn reset_session_state(&mut self) {
        self.tree.clear();
        self.selected = None;
        self.node_summary = None;
        self.references = None;
        self.references_loading = false;
    }

    pub fn record_successful_connection(&mut self) {
        let url = self.endpoint_url.trim().to_string();
        if url.is_empty() {
            return;
        }
        self.endpoint_history.retain(|u| u != &url);
        self.endpoint_history.insert(0, url);
        self.endpoint_history.truncate(MAX_HISTORY);
    }
}