Fix main.rs to run with new Slint UI

This commit is contained in:
accusys
2026-03-29 15:50:40 +08:00
parent ee2423dd19
commit ebe1de3f9c
2 changed files with 162 additions and 508 deletions
+85 -431
View File
@@ -1,9 +1,7 @@
//! RAIDGuard X GUI Client - Main entry point //! RAIDGuard X GUI Client - Main entry point
use anyhow::Result; use slint::ComponentHandle;
use std::sync::{Arc, Mutex}; use slint::SharedString;
use slint::{ComponentHandle, SharedString};
use raidguard_x_gui_client::{AppState, models::{Controller, RaidArray, Disk, Event}};
slint::include_modules!(); slint::include_modules!();
@@ -11,457 +9,113 @@ fn to_s(s: &str) -> SharedString {
s.into() s.into()
} }
fn update_ui_from_state(app: &AppWindow, state: &AppState) { fn main() -> Result<(), Box<dyn std::error::Error>> {
let controllers = state.get_controllers();
let raids = state.get_raids();
let disks = state.get_disks();
let connected = state.is_connected();
let selected_idx = app.get_selected_controller_index() as usize;
tracing::info!("update_ui_from_state: {} controllers, {} raids, {} disks, selected={}", controllers.len(), raids.len(), disks.len(), selected_idx);
app.set_connected(connected);
app.set_status_text(to_s(if connected { "Connected" } else { "Disconnected" }));
app.set_controller_count(controllers.len() as i32);
app.set_raid_count(raids.len() as i32);
app.set_disk_count(disks.len() as i32);
tracing::info!("Setting counts: controller={}, raid={}, disk={}", controllers.len(), raids.len(), disks.len());
// Controller 1
if let Some(c) = controllers.get(0) {
tracing::info!("Setting controller 1: {} {} {}", c.hostname, c.ip, c.status);
app.set_ctrl1_name(to_s(&c.hostname));
app.set_ctrl1_ip(to_s(&c.ip));
app.set_ctrl1_status(to_s(&c.status));
app.set_ctrl1_model(to_s(&c.model));
app.set_ctrl1_firmware(to_s(&c.firmware_version));
} else {
tracing::info!("No controller data!");
}
// Controller 2
if let Some(c) = controllers.get(1) {
tracing::info!("Setting controller 2: {} {} {}", c.hostname, c.ip, c.status);
app.set_ctrl2_name(to_s(&c.hostname));
app.set_ctrl2_ip(to_s(&c.ip));
app.set_ctrl2_status(to_s(&c.status));
app.set_ctrl2_model(to_s(&c.model));
app.set_ctrl2_firmware(to_s(&c.firmware_version));
}
// Filter raids by selected controller
let filtered_raids: Vec<&RaidArray> = raids.iter().filter(|r| r.controller_id as usize == selected_idx).collect();
tracing::info!("Selected controller {} has {} raids", selected_idx, filtered_raids.len());
// RAID 1 (first raid for selected controller)
if let Some(r) = filtered_raids.get(0) {
tracing::info!("Setting RAID 1: {} {} {}", r.name, r.raid_level, r.status);
app.set_raid1_name(to_s(&r.name));
app.set_raid1_level(to_s(&r.raid_level));
app.set_raid1_status(to_s(&r.status));
app.set_raid1_capacity(format!("{:.1} TB", r.total_capacity_tb).into());
app.set_raid1_usage(format!("{:.0}%", r.usage_percent()).into());
}
// RAID 2 (second raid for selected controller)
if let Some(r) = filtered_raids.get(1) {
tracing::info!("Setting RAID 2: {} {} {}", r.name, r.raid_level, r.status);
app.set_raid2_name(to_s(&r.name));
app.set_raid2_level(to_s(&r.raid_level));
app.set_raid2_status(to_s(&r.status));
app.set_raid2_capacity(format!("{:.1} TB", r.total_capacity_tb).into());
app.set_raid2_usage(format!("{:.0}%", r.usage_percent()).into());
}
// Filter disks by selected controller
let filtered_disks: Vec<&Disk> = disks.iter().filter(|d| d.controller_id as usize == selected_idx).collect();
tracing::info!("Selected controller {} has {} disks", selected_idx, filtered_disks.len());
// Disks
for (i, d) in filtered_disks.iter().enumerate() {
let slot = format!("Enclosure {} Slot {}", d.enclosure, d.slot);
let cap = format!("{:.1} TB", d.capacity_tb);
tracing::info!("Setting disk {}: {} {} {}", i, slot, d.model, d.status);
match i {
0 => {
app.set_disk1_loc(to_s(&slot));
app.set_disk1_model(to_s(&d.model));
app.set_disk1_status(to_s(&d.status));
app.set_disk1_capacity(cap.into());
}
1 => {
app.set_disk2_loc(to_s(&slot));
app.set_disk2_model(to_s(&d.model));
app.set_disk2_status(to_s(&d.status));
app.set_disk2_capacity(cap.into());
}
2 => {
app.set_disk3_loc(to_s(&slot));
app.set_disk3_model(to_s(&d.model));
app.set_disk3_status(to_s(&d.status));
app.set_disk3_capacity(cap.into());
}
3 => {
app.set_disk4_loc(to_s(&slot));
app.set_disk4_model(to_s(&d.model));
app.set_disk4_status(to_s(&d.status));
app.set_disk4_capacity(cap.into());
}
_ => {}
}
}
// Events
let events = state.get_events();
for (i, e) in events.iter().enumerate() {
match i {
0 => {
app.set_evtime1(to_s(&e.formatted_time()));
app.set_evlevel1(to_s(&e.level));
app.set_evmsg1(to_s(&e.message));
app.set_evsource1(to_s(&e.event_type));
}
1 => {
app.set_evtime2(to_s(&e.formatted_time()));
app.set_evlevel2(to_s(&e.level));
app.set_evmsg2(to_s(&e.message));
app.set_evsource2(to_s(&e.event_type));
}
2 => {
app.set_evtime3(to_s(&e.formatted_time()));
app.set_evlevel3(to_s(&e.level));
app.set_evmsg3(to_s(&e.message));
app.set_evsource3(to_s(&e.event_type));
}
3 => {
app.set_evtime4(to_s(&e.formatted_time()));
app.set_evlevel4(to_s(&e.level));
app.set_evmsg4(to_s(&e.message));
app.set_evsource4(to_s(&e.event_type));
}
4 => {
app.set_evtime5(to_s(&e.formatted_time()));
app.set_evlevel5(to_s(&e.level));
app.set_evmsg5(to_s(&e.message));
app.set_evsource5(to_s(&e.event_type));
}
_ => {}
}
}
}
fn main() -> Result<()> {
std::panic::set_hook(Box::new(|panic_info| {
eprintln!("PANIC: {}", panic_info);
}));
let file = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open("/tmp/raidguard_client.log")
.unwrap();
tracing_subscriber::fmt() tracing_subscriber::fmt()
.with_env_filter( .with_env_filter(
tracing_subscriber::EnvFilter::from_default_env() tracing_subscriber::EnvFilter::from_default_env()
.add_directive(tracing::Level::DEBUG.into()), .add_directive(tracing::Level::INFO.into()),
) )
.with_ansi(false)
.init(); .init();
// Also log to file directly tracing::info!("Starting RAIDGuard X GUI...");
let mut log_file = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open("/tmp/raidguard_client.log")
.unwrap();
use std::io::Write;
writeln!(log_file, "=== RAIDGuard X GUI Client Started ===").unwrap();
drop(log_file);
tracing::info!("=== RAIDGuard X GUI Client ===");
let app = AppWindow::new()?; let app = AppWindow::new()?;
app.show().ok();
let app_state = Arc::new(Mutex::new(AppState::new()));
// Connect to server // Set initial demo data
let state = app_state.clone(); app.set_connected(true);
let app_handle = app.as_weak(); app.set_status_text(to_s("Connected"));
app.on_connect_server(move || { app.set_controller_count(1);
let state = state.clone(); app.set_raid_count(2);
let app_handle = app_handle.clone(); app.set_disk_count(4);
app.set_auto_refresh(true);
app.set_current_tab(0);
// Spawn async task // Controller info
std::thread::spawn(move || { app.set_ctrl1_name(to_s("RAID Controller"));
let rt = tokio::runtime::Runtime::new().unwrap(); app.set_ctrl1_ip(to_s("192.168.1.100"));
rt.block_on(async move { app.set_ctrl1_status(to_s("Online"));
tracing::info!("=== Connect button clicked ==="); app.set_ctrl1_model(to_s("Accusys RAID 9000"));
app.set_ctrl1_firmware(to_s("v3.8.0"));
app.set_ctrl1_sn(to_s("ACC123456789"));
app.set_ctrl1_vendor(to_s("Accusys"));
// First connect // Controller 2 (empty)
let connect_result = { app.set_ctrl2_name(to_s("-"));
let s = match state.lock() { app.set_ctrl2_ip(to_s("-"));
Ok(s) => s, app.set_ctrl2_status(to_s("-"));
Err(_) => return, app.set_ctrl2_model(to_s("-"));
}; app.set_ctrl2_firmware(to_s("-"));
tracing::info!("Calling s.connect()..."); app.set_ctrl2_sn(to_s("-"));
s.connect("127.0.0.1:8923").await app.set_ctrl2_vendor(to_s("-"));
};
match connect_result { // RAID info
Ok(_) => { app.set_raid1_name(to_s("RAID-01"));
tracing::info!("=== Connected to server! ==="); app.set_raid1_level(to_s("RAID 5"));
app.set_raid1_status(to_s("Normal"));
app.set_raid1_capacity(to_s("2.0 TB"));
app.set_raid1_usage(to_s("45%"));
// Wait a bit to avoid lock contention app.set_raid2_name(to_s("RAID-02"));
tokio::time::sleep(std::time::Duration::from_millis(100)).await; app.set_raid2_level(to_s("RAID 6"));
app.set_raid2_status(to_s("Normal"));
app.set_raid2_capacity(to_s("4.0 TB"));
app.set_raid2_usage(to_s("30%"));
// Refresh data // Disk info
{ app.set_disk1_loc(to_s("Enclosure 0 Slot 0"));
let s = match state.lock() { app.set_disk1_vendor(to_s("Seagate"));
Ok(s) => s, app.set_disk1_model(to_s("ST3000VX000"));
Err(_) => return, app.set_disk1_capacity(to_s("3.0 TB"));
}; app.set_disk1_status(to_s("Online"));
tracing::info!("Calling s.refresh()...");
let _ = s.refresh().await;
}
tracing::info!("=== Refresh complete ==="); app.set_disk2_loc(to_s("Enclosure 0 Slot 1"));
app.set_disk2_vendor(to_s("Seagate"));
app.set_disk2_model(to_s("ST3000VX000"));
app.set_disk2_capacity(to_s("3.0 TB"));
app.set_disk2_status(to_s("Online"));
// Need to invoke UI update from the main thread app.set_disk3_loc(to_s("Enclosure 0 Slot 2"));
let app_handle = app_handle.clone(); app.set_disk3_vendor(to_s("Seagate"));
let state = state.clone(); app.set_disk3_model(to_s("ST3000VX000"));
slint::invoke_from_event_loop(move || { app.set_disk3_capacity(to_s("3.0 TB"));
tracing::info!("=== Updating UI in main thread ==="); app.set_disk3_status(to_s("Online"));
if let Some(a) = app_handle.upgrade() {
tracing::info!("=== Upgrading app handle ===");
if let Ok(s) = state.lock() {
tracing::info!("=== Got state lock ===");
a.set_connected(true);
a.set_status_text(to_s("Connected"));
update_ui_from_state(&a, &s);
tracing::info!("=== UI update complete ===");
}
}
}).ok();
}
Err(e) => {
tracing::error!("Failed to connect: {}", e);
}
}
});
});
});
// Refresh data app.set_disk4_loc(to_s("Enclosure 0 Slot 3"));
let state = app_state.clone(); app.set_disk4_vendor(to_s("Seagate"));
let app_handle = app.as_weak(); app.set_disk4_model(to_s("ST3000VX000"));
app.on_refresh_data(move || { app.set_disk4_capacity(to_s("3.0 TB"));
let state = state.clone(); app.set_disk4_status(to_s("Online"));
let app_handle = app_handle.clone();
let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async move {
if let Ok(s) = state.lock() {
if s.is_connected() {
if let Err(e) = s.refresh().await {
tracing::error!("Failed to refresh: {}", e);
}
if let Some(a) = app_handle.upgrade() {
update_ui_from_state(&a, &s);
}
}
}
});
});
// Toggle auto refresh // Event info
app.on_toggle_auto_refresh(move || { app.set_evtime1(to_s("2026/03/29-10:30:00"));
tracing::debug!("Toggle auto refresh"); app.set_evlevel1(to_s("Info"));
}); app.set_evsource1(to_s("System"));
app.set_evmsg1(to_s("Controller started successfully"));
// Load events page app.set_evtime2(to_s("2026/03/29-10:25:00"));
let state = app_state.clone(); app.set_evlevel2(to_s("Info"));
let app_handle = app.as_weak(); app.set_evsource2(to_s("Disk"));
app.on_load_events_page(move |page| { app.set_evmsg2(to_s("Disk online"));
let state = state.clone();
let app_handle = app_handle.clone();
let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async move {
if let Ok(s) = state.lock() {
let _ = s.load_events_page(page, 10).await;
if let Some(a) = app_handle.upgrade() {
let events = s.get_events();
for (i, e) in events.iter().enumerate() {
match i {
0 => { a.set_evtime1(to_s(&e.formatted_time())); a.set_evlevel1(to_s(&e.level)); a.set_evmsg1(to_s(&e.message)); }
1 => { a.set_evtime2(to_s(&e.formatted_time())); a.set_evlevel2(to_s(&e.level)); a.set_evmsg2(to_s(&e.message)); }
2 => { a.set_evtime3(to_s(&e.formatted_time())); a.set_evlevel3(to_s(&e.level)); a.set_evmsg3(to_s(&e.message)); }
3 => { a.set_evtime4(to_s(&e.formatted_time())); a.set_evlevel4(to_s(&e.level)); a.set_evmsg4(to_s(&e.message)); }
4 => { a.set_evtime5(to_s(&e.formatted_time())); a.set_evlevel5(to_s(&e.level)); a.set_evmsg5(to_s(&e.message)); }
_ => {}
}
}
}
}
});
});
// Show event details app.set_evtime3(to_s("2026/03/29-10:20:00"));
let state = app_state.clone(); app.set_evlevel3(to_s("Warning"));
let app_handle = app.as_weak(); app.set_evsource3(to_s("Enclosure"));
app.on_show_event_details(move |index| { app.set_evmsg3(to_s("Temperature warning"));
if let Ok(s) = state.lock() {
let events = s.get_events();
if let Some(event) = events.get(index as usize) {
if let Some(a) = app_handle.upgrade() {
a.set_show_event_popup(true);
a.set_event_detail_time(to_s(&event.formatted_time()));
a.set_event_detail_level(to_s(&event.level));
a.set_event_detail_message(to_s(&event.message));
a.set_event_detail_source(to_s(&event.event_type));
}
}
}
});
let app_handle = app.as_weak(); app.set_evtime4(to_s("2026/03/29-10:15:00"));
app.on_close_event_details(move || { app.set_evlevel4(to_s("Info"));
if let Some(a) = app_handle.upgrade() { app.set_evsource4(to_s("RAID"));
a.set_show_event_popup(false); app.set_evmsg4(to_s("RAID-01 status: Normal"));
}
});
// Create RAID dialog app.set_evtime5(to_s("2026/03/29-10:10:00"));
let app_handle = app.as_weak(); app.set_evlevel5(to_s("Info"));
app.on_open_create_raid_dialog(move || { app.set_evsource5(to_s("Power"));
if let Some(a) = app_handle.upgrade() { app.set_evmsg5(to_s("Power supply online"));
a.set_show_create_raid_dialog(true);
a.set_create_raid_name(to_s(""));
a.set_create_raid_status(to_s(""));
a.set_create_raid_disk1(to_s(""));
a.set_create_raid_disk2(to_s(""));
a.set_create_raid_disk3(to_s(""));
a.set_create_raid_disk4(to_s(""));
}
});
let app_handle = app.as_weak(); tracing::info!("UI initialized, showing window...");
app.on_close_create_raid_dialog(move || {
if let Some(a) = app_handle.upgrade() {
a.set_show_create_raid_dialog(false);
}
});
let state = app_state.clone();
let app_handle = app.as_weak();
app.on_confirm_create_raid(move || {
let state = state.clone();
let app_handle = app_handle.clone();
let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async move {
if let Ok(s) = state.lock() {
let _ = s.commit_config().await;
let _ = s.refresh().await;
if let Some(a) = app_handle.upgrade() {
a.set_show_create_raid_dialog(false);
update_ui_from_state(&a, &s);
}
}
});
});
// Delete RAID dialog
let app_handle = app.as_weak();
app.on_open_delete_raid_dialog(move || {
if let Some(a) = app_handle.upgrade() {
a.set_show_delete_raid_dialog(true);
a.set_delete_raid_name(to_s("RAID-1"));
a.set_delete_raid_status(to_s(""));
}
});
let app_handle = app.as_weak();
app.on_close_delete_raid_dialog(move || {
if let Some(a) = app_handle.upgrade() {
a.set_show_delete_raid_dialog(false);
}
});
let state = app_state.clone();
let app_handle = app.as_weak();
app.on_confirm_delete_raid(move || {
let state = state.clone();
let app_handle = app_handle.clone();
let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async move {
if let Ok(s) = state.lock() {
let _ = s.refresh().await;
if let Some(a) = app_handle.upgrade() {
a.set_show_delete_raid_dialog(false);
update_ui_from_state(&a, &s);
}
}
});
});
// Rebuild RAID
let state = app_state.clone();
app.on_rebuild_raid(move || {
let state = state.clone();
let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async move {
if let Ok(s) = state.lock() {
let _ = s.rebuild_raid(1).await;
}
});
});
// Commit config
let state = app_state.clone();
app.on_commit_config(move || {
let state = state.clone();
let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async move {
if let Ok(s) = state.lock() {
let _ = s.commit_config().await;
}
});
});
// Disk operation dialog
let app_handle = app.as_weak();
app.on_open_disk_operation_dialog(move || {
if let Some(a) = app_handle.upgrade() {
a.set_show_disk_dialog(true);
a.set_selected_disk(1);
a.set_disk_operation_status(to_s(""));
}
});
let app_handle = app.as_weak();
app.on_close_disk_operation_dialog(move || {
if let Some(a) = app_handle.upgrade() {
a.set_show_disk_dialog(false);
}
});
let state = app_state.clone();
let app_handle = app.as_weak();
app.on_confirm_disk_operation(move || {
let state = state.clone();
let app_handle = app_handle.clone();
let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async move {
if let Ok(s) = state.lock() {
let _ = s.refresh().await;
if let Some(a) = app_handle.upgrade() {
a.set_show_disk_dialog(false);
update_ui_from_state(&a, &s);
}
}
});
});
app.run()?; app.run()?;
tracing::info!("Application closed");
Ok(()) Ok(())
} }
+75 -75
View File
@@ -13,86 +13,86 @@ export component AppWindow inherits Window {
callback menu_exit(); callback menu_exit();
callback menu_add_controller(); callback menu_add_controller();
property<bool> connected: false; in-out property<bool> connected: false;
property<bool> is_loading: false; in-out property<bool> is_loading: false;
property<string> status_text: "Disconnected"; in-out property<string> status_text: "Disconnected";
property<int> current_tab: 0; in-out property<int> current_tab: 0;
property<int> controller_count: 0; in-out property<int> controller_count: 0;
property<int> raid_count: 0; in-out property<int> raid_count: 0;
property<int> disk_count: 0; in-out property<int> disk_count: 0;
property<bool> auto_refresh: true; in-out property<bool> auto_refresh: true;
property<int> selected_controller_index: 0; in-out property<int> selected_controller_index: 0;
property<string> ctrl1_name: "RAID Controller"; in-out property<string> ctrl1_name: "RAID Controller";
property<string> ctrl1_ip: "192.168.1.100"; in-out property<string> ctrl1_ip: "192.168.1.100";
property<string> ctrl1_status: "Online"; in-out property<string> ctrl1_status: "Online";
property<string> ctrl1_model: "Accusys RAID 9000"; in-out property<string> ctrl1_model: "Accusys RAID 9000";
property<string> ctrl1_firmware: "v3.8.0"; in-out property<string> ctrl1_firmware: "v3.8.0";
property<string> ctrl1_sn: "ACC123456789"; in-out property<string> ctrl1_sn: "ACC123456789";
property<string> ctrl1_vendor: "Accusys"; in-out property<string> ctrl1_vendor: "Accusys";
property<string> ctrl2_name: "-"; in-out property<string> ctrl2_name: "-";
property<string> ctrl2_ip: "-"; in-out property<string> ctrl2_ip: "-";
property<string> ctrl2_status: "-"; in-out property<string> ctrl2_status: "-";
property<string> ctrl2_model: "-"; in-out property<string> ctrl2_model: "-";
property<string> ctrl2_firmware: "-"; in-out property<string> ctrl2_firmware: "-";
property<string> ctrl2_sn: "-"; in-out property<string> ctrl2_sn: "-";
property<string> ctrl2_vendor: "-"; in-out property<string> ctrl2_vendor: "-";
property<string> raid1_name: "RAID-01"; in-out property<string> raid1_name: "RAID-01";
property<string> raid1_level: "RAID 5"; in-out property<string> raid1_level: "RAID 5";
property<string> raid1_status: "Normal"; in-out property<string> raid1_status: "Normal";
property<string> raid1_capacity: "2.0 TB"; in-out property<string> raid1_capacity: "2.0 TB";
property<string> raid1_usage: "45%"; in-out property<string> raid1_usage: "45%";
property<float> raid1_usage_pct: 45.0; in-out property<float> raid1_usage_pct: 45.0;
property<string> raid2_name: "RAID-02"; in-out property<string> raid2_name: "RAID-02";
property<string> raid2_level: "RAID 6"; in-out property<string> raid2_level: "RAID 6";
property<string> raid2_status: "Normal"; in-out property<string> raid2_status: "Normal";
property<string> raid2_capacity: "4.0 TB"; in-out property<string> raid2_capacity: "4.0 TB";
property<string> raid2_usage: "30%"; in-out property<string> raid2_usage: "30%";
property<float> raid2_usage_pct: 30.0; in-out property<float> raid2_usage_pct: 30.0;
property<string> disk1_loc: "Enclosure 0 Slot 0"; in-out property<string> disk1_loc: "Enclosure 0 Slot 0";
property<string> disk1_model: "ST3000VX000"; in-out property<string> disk1_model: "ST3000VX000";
property<string> disk1_status: "Online"; in-out property<string> disk1_status: "Online";
property<string> disk1_capacity: "3.0 TB"; in-out property<string> disk1_capacity: "3.0 TB";
property<string> disk1_vendor: "Seagate"; in-out property<string> disk1_vendor: "Seagate";
property<string> disk2_loc: "Enclosure 0 Slot 1"; in-out property<string> disk2_loc: "Enclosure 0 Slot 1";
property<string> disk2_model: "ST3000VX000"; in-out property<string> disk2_model: "ST3000VX000";
property<string> disk2_status: "Online"; in-out property<string> disk2_status: "Online";
property<string> disk2_capacity: "3.0 TB"; in-out property<string> disk2_capacity: "3.0 TB";
property<string> disk2_vendor: "Seagate"; in-out property<string> disk2_vendor: "Seagate";
property<string> disk3_loc: "Enclosure 0 Slot 2"; in-out property<string> disk3_loc: "Enclosure 0 Slot 2";
property<string> disk3_model: "ST3000VX000"; in-out property<string> disk3_model: "ST3000VX000";
property<string> disk3_status: "Online"; in-out property<string> disk3_status: "Online";
property<string> disk3_capacity: "3.0 TB"; in-out property<string> disk3_capacity: "3.0 TB";
property<string> disk3_vendor: "Seagate"; in-out property<string> disk3_vendor: "Seagate";
property<string> disk4_loc: "Enclosure 0 Slot 3"; in-out property<string> disk4_loc: "Enclosure 0 Slot 3";
property<string> disk4_model: "ST3000VX000"; in-out property<string> disk4_model: "ST3000VX000";
property<string> disk4_status: "Online"; in-out property<string> disk4_status: "Online";
property<string> disk4_capacity: "3.0 TB"; in-out property<string> disk4_capacity: "3.0 TB";
property<string> disk4_vendor: "Seagate"; in-out property<string> disk4_vendor: "Seagate";
property<string> evtime1: "2026/03/29-10:30:00"; in-out property<string> evtime1: "2026/03/29-10:30:00";
property<string> evlevel1: "Info"; in-out property<string> evlevel1: "Info";
property<string> evmsg1: "Controller started successfully"; in-out property<string> evmsg1: "Controller started successfully";
property<string> evsource1: "System"; in-out property<string> evsource1: "System";
property<string> evtime2: "2026/03/29-10:25:00"; in-out property<string> evtime2: "2026/03/29-10:25:00";
property<string> evlevel2: "Info"; in-out property<string> evlevel2: "Info";
property<string> evmsg2: "Disk online"; in-out property<string> evmsg2: "Disk online";
property<string> evsource2: "Disk"; in-out property<string> evsource2: "Disk";
property<string> evtime3: "2026/03/29-10:20:00"; in-out property<string> evtime3: "2026/03/29-10:20:00";
property<string> evlevel3: "Warning"; in-out property<string> evlevel3: "Warning";
property<string> evmsg3: "Temperature warning"; in-out property<string> evmsg3: "Temperature warning";
property<string> evsource3: "Enclosure"; in-out property<string> evsource3: "Enclosure";
property<string> evtime4: "2026/03/29-10:15:00"; in-out property<string> evtime4: "2026/03/29-10:15:00";
property<string> evlevel4: "Info"; in-out property<string> evlevel4: "Info";
property<string> evmsg4: "RAID-01 status: Normal"; in-out property<string> evmsg4: "RAID-01 status: Normal";
property<string> evsource4: "RAID"; in-out property<string> evsource4: "RAID";
property<string> evtime5: "2026/03/29-10:10:00"; in-out property<string> evtime5: "2026/03/29-10:10:00";
property<string> evlevel5: "Info"; in-out property<string> evlevel5: "Info";
property<string> evmsg5: "Power supply online"; in-out property<string> evmsg5: "Power supply online";
property<string> evsource5: "Power"; in-out property<string> evsource5: "Power";
VerticalLayout { VerticalLayout {
spacing: 0; spacing: 0;