maximevanhees/hetzner_rhai
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

idioamtic improvements

Browse Source
This commit is contained in:
Maxime Van Hees 2025-07-15 15:04:11 +02:00
parent 9dfb10cca6
commit 5e8e9754b2
3 changed files with 131 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
example.rhai
View File

@ -13,13 +13,6 @@ try {
print(`Getting details for server: ${first_server.name}`); print(`Getting details for server: ${first_server.name}`);
let detailed_server = client.get_server(first_server.id); let detailed_server = client.get_server(first_server.id);
print(detailed_server.show_details()); print(detailed_server.show_details());
print(`Pinging server ${detailed_server.name}...`);
let is_online = detailed_server.ping();
if is_online {
print("Server is online.");
} else {
print("Server is offline.");
}
// --- REBOOT --- // --- REBOOT ---
// To reboot the server, uncomment the following lines: // To reboot the server, uncomment the following lines:

2
src/hetzner_api.rs
View File

@ -41,8 +41,6 @@ impl HetznerClient {
all_servers.append(&mut servers); all_servers.append(&mut servers);
println!("next page? {:#?}", response.meta);
if is_empty || response.meta.pagination.next_page.is_none() { if is_empty || response.meta.pagination.next_page.is_none() {
break; break;
} }

372
src/rhai_api.rs
View File

@ -2,14 +2,38 @@ use crate::async_handler::Response;
use crate::async_handler::Request; use crate::async_handler::Request;
use crate::hetzner_api::{HetznerClient, WrappedServer}; use crate::hetzner_api::{HetznerClient, WrappedServer};
use rhai::{Engine, EvalAltResult}; use rhai::{Engine, EvalAltResult};
use std::sync::{Arc, Mutex, mpsc::{Sender, Receiver}}; use std::sync::{mpsc::{Receiver, Sender}, Arc, Mutex};
use prettytable::{Table, Row, Cell}; use prettytable::{Table, Row, Cell};
#[derive(Clone)]
struct ApiBridge {
command_tx: Sender<Request>,
reply_rx: Arc<Mutex<Receiver<Response>>>,
}
impl ApiBridge {
fn new(command_tx: Sender<Request>, reply_rx: Arc<Mutex<Receiver<Response>>>) -> Self {
Self { command_tx, reply_rx }
}
fn call<T>(
&self,
request: Request,
response_handler: impl FnOnce(Response) -> Result<T, Box<EvalAltResult>>,
) -> Result<T, Box<EvalAltResult>> {
self.command_tx.send(request).map_err(|e| e.to_string())?;
let response = self.reply_rx.lock().unwrap().recv().map_err(|e| e.to_string())?;
response_handler(response)
}
}
pub fn register_hetzner_api( pub fn register_hetzner_api(
engine: &mut Engine, engine: &mut Engine,
command_tx: Sender<Request>, command_tx: Sender<Request>,
reply_rx: Arc<Mutex<Receiver<Response>>>, reply_rx: Arc<Mutex<Receiver<Response>>>,
) { ) {
let api_bridge = ApiBridge::new(command_tx, reply_rx);
engine engine
.register_type_with_name::<HetznerClient>("HetznerClient") .register_type_with_name::<HetznerClient>("HetznerClient")
.register_fn("new_hetzner_client", |api_token: &str| -> Result<HetznerClient, Box<EvalAltResult>> { .register_fn("new_hetzner_client", |api_token: &str| -> Result<HetznerClient, Box<EvalAltResult>> {
@ -19,261 +43,127 @@ pub fn register_hetzner_api(
Ok(HetznerClient::new(api_token)) Ok(HetznerClient::new(api_token))
}); });
let list_servers_tx = command_tx.clone(); let bridge = api_bridge.clone();
let list_servers_rx = reply_rx.clone(); engine.register_fn("list_servers", move |client: &mut HetznerClient| {
let get_server_status_tx = command_tx.clone(); bridge.call(Request::ListServers(client.clone()), |response| {
let get_server_status_rx = reply_rx.clone(); match response {
let get_server_tx = command_tx.clone(); Response::ListServers(result) => result.map_err(|e| e.into()),
let get_server_rx = reply_rx.clone(); _ => Err("Unexpected response".into()),
let reboot_server_tx = command_tx.clone(); }
let reboot_server_rx = reply_rx.clone(); })
let reset_server_tx = command_tx.clone(); });
let reset_server_rx = reply_rx.clone();
let enable_rescue_mode_tx = command_tx.clone(); let bridge = api_bridge.clone();
let enable_rescue_mode_rx = reply_rx.clone(); engine.register_fn("get_server_status", move |client: &mut HetznerClient, server_id: i64| {
let disable_rescue_mode_tx = command_tx.clone(); bridge.call(Request::GetServerStatus(client.clone(), server_id), |response| {
let disable_rescue_mode_rx = reply_rx.clone(); match response {
Response::GetServerStatus(result) => result.map_err(|e| e.into()),
_ => Err("Unexpected response".into()),
}
})
});
let bridge = api_bridge.clone();
engine.register_fn("get_server", move |client: &mut HetznerClient, server_id: i64| {
bridge.call(Request::GetServer(client.clone(), server_id), |response| {
match response {
Response::GetServer(result) => result.map_err(|e| e.into()),
_ => Err("Unexpected response".into()),
}
})
});
engine engine
.register_fn(
"list_servers",
move |client: &mut HetznerClient| -> Result<Vec<WrappedServer>, Box<EvalAltResult>> {
list_servers_tx.send(Request::ListServers(client.clone()))
.map_err(|e| e.to_string())?;
let response = list_servers_rx.lock().unwrap().recv()
.map_err(|e| e.to_string())?;
match response {
Response::ListServers(result) => result.map_err(|e| e.into()),
_ => Err("Unexpected response".into()),
}
},
)
.register_fn(
"get_server_status",
move |client: &mut HetznerClient,
server_id: i64|
-> Result<String, Box<EvalAltResult>> {
get_server_status_tx.send(Request::GetServerStatus(client.clone(), server_id))
.map_err(|e| e.to_string())?;
let response = get_server_status_rx.lock().unwrap().recv()
.map_err(|e| e.to_string())?;
match response {
Response::GetServerStatus(result) => result.map_err(|e| e.into()),
_ => Err("Unexpected response".into()),
}
},
)
.register_fn(
"get_server",
move |client: &mut HetznerClient,
server_id: i64|
-> Result<WrappedServer, Box<EvalAltResult>> {
get_server_tx.send(Request::GetServer(client.clone(), server_id))
.map_err(|e| e.to_string())?;
let response = get_server_rx.lock().unwrap().recv()
.map_err(|e| e.to_string())?;
match response {
Response::GetServer(result) => result.map_err(|e| e.into()),
_ => Err("Unexpected response".into()),
}
},
)
.register_type_with_name::<WrappedServer>("Server") .register_type_with_name::<WrappedServer>("Server")
.register_get("id", |server: &mut WrappedServer| server.0.id) .register_get("id", |server: &mut WrappedServer| server.0.id)
.register_get("name", |server: &mut WrappedServer| { .register_get("name", |server: &mut WrappedServer| server.0.name.clone())
server.0.name.clone() .register_get("status", |server: &mut WrappedServer| format!("{:?}", server.0.status))
.register_get("created", |server: &mut WrappedServer| server.0.created.clone())
.register_get("public_ipv4", |server: &mut WrappedServer| server.0.public_net.ipv4.clone().unwrap().ip)
.register_get("server_type", |server: &mut WrappedServer| server.0.server_type.clone().name)
.register_get("included_traffic", |server: &mut WrappedServer| server.0.included_traffic.unwrap_or(0))
.register_get("ingoing_traffic", |server: &mut WrappedServer| server.0.ingoing_traffic.unwrap_or(0))
.register_get("outgoing_traffic", |server: &mut WrappedServer| server.0.outgoing_traffic.unwrap_or(0))
.register_get("primary_disk_size", |server: &mut WrappedServer| server.0.primary_disk_size)
.register_get("rescue_enabled", |server: &mut WrappedServer| server.0.rescue_enabled);
let bridge = api_bridge.clone();
engine.register_fn("reboot", move |server: &mut WrappedServer, client: HetznerClient| {
bridge.call(Request::RebootServer(client, server.0.id), |response| {
match response {
Response::RebootServer(result) => result.map_err(|e| e.into()),
_ => Err("Unexpected response".into()),
}
}) })
.register_get("status", |server: &mut WrappedServer| { });
format!("{:?}", server.0.status)
})
.register_get("created", |server: &mut WrappedServer| {
server.0.created.clone()
})
.register_get("public_ipv4", |server: &mut WrappedServer| {
server.0.public_net.ipv4.clone().unwrap().ip
})
.register_get("server_type", |server: &mut WrappedServer| {
server.0.server_type.clone().name
})
.register_get("included_traffic", |server: &mut WrappedServer| {
server.0.included_traffic.unwrap_or(0)
})
.register_get("ingoing_traffic", |server: &mut WrappedServer| {
server.0.ingoing_traffic.unwrap_or(0)
})
.register_get("outgoing_traffic", |server: &mut WrappedServer| {
server.0.outgoing_traffic.unwrap_or(0)
})
.register_get("primary_disk_size", |server: &mut WrappedServer| {
server.0.primary_disk_size
})
.register_get("rescue_enabled", |server: &mut WrappedServer| {
server.0.rescue_enabled
})
.register_fn(
"reboot",
move |server: &mut WrappedServer,
client: HetznerClient|
-> Result<(), Box<EvalAltResult>> {
reboot_server_tx
.send(Request::RebootServer(client, server.0.id))
.map_err(|e| e.to_string())?;
let response = reboot_server_rx let bridge = api_bridge.clone();
.lock() engine.register_fn("reset", move |server: &mut WrappedServer, client: HetznerClient| {
.unwrap() bridge.call(Request::ResetServer(client, server.0.id), |response| {
.recv() match response {
.map_err(|e| e.to_string())?; Response::ResetServer(result) => result.map_err(|e| e.into()),
_ => Err("Unexpected response".into()),
}
})
});
match response { let bridge = api_bridge.clone();
Response::RebootServer(result) => result.map_err(|e| e.into()), engine.register_fn("enable_rescue_mode", move |server: &mut WrappedServer, client: HetznerClient| {
_ => Err("Unexpected response".into()), bridge.call(Request::EnableRescueMode(client, server.0.id), |response| {
} match response {
}, Response::EnableRescueMode(result) => result.map_err(|e| e.into()),
) _ => Err("Unexpected response".into()),
.register_fn( }
"reset", })
move |server: &mut WrappedServer, });
client: HetznerClient|
-> Result<(), Box<EvalAltResult>> {
reset_server_tx
.send(Request::ResetServer(client, server.0.id))
.map_err(|e| e.to_string())?;
let response = reset_server_rx let bridge = api_bridge.clone();
.lock() engine.register_fn("disable_rescue_mode", move |server: &mut WrappedServer, client: HetznerClient| {
.unwrap() bridge.call(Request::DisableRescueMode(client, server.0.id), |response| {
.recv() match response {
.map_err(|e| e.to_string())?; Response::DisableRescueMode(result) => result.map_err(|e| e.into()),
_ => Err("Unexpected response".into()),
}
})
});
match response { engine
Response::ResetServer(result) => result.map_err(|e| e.into()), .register_iterator::<Vec<WrappedServer>>()
_ => Err("Unexpected response".into()),
}
},
)
.register_iterator::<Vec<WrappedServer>>()
.register_fn("len", |list: &mut Vec<WrappedServer>| list.len() as i64) .register_fn("len", |list: &mut Vec<WrappedServer>| list.len() as i64)
.register_indexer_get(|list: &mut Vec<WrappedServer>, index: i64| list[index as usize].clone()) .register_indexer_get(|list: &mut Vec<WrappedServer>, index: i64| list[index as usize].clone())
.register_fn( .register_fn("show_table", |servers: &mut Vec<WrappedServer>| -> Result<String, Box<EvalAltResult>> {
"show_table", let mut table = Table::new();
|servers: &mut Vec<WrappedServer>| -> Result<String, Box<EvalAltResult>> { table.set_titles(Row::new(vec![Cell::new("Server List").style_spec("c")]));
let mut table = Table::new(); table.add_row(Row::new(vec![
table.set_titles(Row::new(vec![Cell::new("Server List").style_spec("c")])); Cell::new("ID"),
Cell::new("Name"),
Cell::new("Status"),
Cell::new("Public IPv4"),
]));
for server in servers {
table.add_row(Row::new(vec![ table.add_row(Row::new(vec![
Cell::new("ID"),
Cell::new("Name"),
Cell::new("Status"),
Cell::new("Public IPv4"),
]));
for server in servers {
table.add_row(Row::new(vec![
Cell::new(&server.0.id.to_string()),
Cell::new(&server.0.name),
Cell::new(&format!("{:?}", server.0.status)),
Cell::new(&server.0.public_net.ipv4.clone().unwrap().ip.to_string()),
]));
}
Ok(table.to_string())
},
)
.register_fn(
"show_details",
|server: &mut WrappedServer| -> Result<String, Box<EvalAltResult>> {
let mut table = Table::new();
table.set_titles(Row::new(vec![
Cell::new(&server.0.name).style_spec("c")
]));
table.add_row(Row::new(vec![
Cell::new("ID"),
Cell::new(&server.0.id.to_string()), Cell::new(&server.0.id.to_string()),
])); Cell::new(&server.0.name),
table.add_row(Row::new(vec![
Cell::new("Status"),
Cell::new(&format!("{:?}", server.0.status)), Cell::new(&format!("{:?}", server.0.status)),
]));
table.add_row(Row::new(vec![
Cell::new("Created"),
Cell::new(&server.0.created),
]));
table.add_row(Row::new(vec![
Cell::new("IPv4"),
Cell::new(&server.0.public_net.ipv4.clone().unwrap().ip.to_string()), Cell::new(&server.0.public_net.ipv4.clone().unwrap().ip.to_string()),
])); ]));
table.add_row(Row::new(vec![ }
Cell::new("Type"), Ok(table.to_string())
Cell::new(&server.0.server_type.name), })
])); .register_fn("show_details", |server: &mut WrappedServer| -> Result<String, Box<EvalAltResult>> {
table.add_row(Row::new(vec![ let mut table = Table::new();
Cell::new("Included Traffic"), table.set_titles(Row::new(vec![Cell::new(&server.0.name).style_spec("c")]));
Cell::new(&format!("{} GB", server.0.included_traffic.unwrap_or(0) / 1024 / 1024 / 1024)), table.add_row(Row::new(vec![Cell::new("ID"), Cell::new(&server.0.id.to_string())]));
])); table.add_row(Row::new(vec![Cell::new("Status"), Cell::new(&format!("{:?}", server.0.status))]));
table.add_row(Row::new(vec![ table.add_row(Row::new(vec![Cell::new("Created"), Cell::new(&server.0.created)]));
Cell::new("Ingoing Traffic"), table.add_row(Row::new(vec![Cell::new("IPv4"), Cell::new(&server.0.public_net.ipv4.clone().unwrap().ip.to_string())]));
Cell::new(&format!("{} MB", server.0.ingoing_traffic.unwrap_or(0) / 1024 / 1024)), table.add_row(Row::new(vec![Cell::new("Type"), Cell::new(&server.0.server_type.name)]));
])); table.add_row(Row::new(vec![Cell::new("Included Traffic"), Cell::new(&format!("{} GB", server.0.included_traffic.unwrap_or(0) / 1024 / 1024 / 1024))]));
table.add_row(Row::new(vec![ table.add_row(Row::new(vec![Cell::new("Ingoing Traffic"), Cell::new(&format!("{} MB", server.0.ingoing_traffic.unwrap_or(0) / 1024 / 1024))]));
Cell::new("Outgoing Traffic"), table.add_row(Row::new(vec![Cell::new("Outgoing Traffic"), Cell::new(&format!("{} MB", server.0.outgoing_traffic.unwrap_or(0) / 1024 / 1024))]));
Cell::new(&format!("{} MB", server.0.outgoing_traffic.unwrap_or(0) / 1024 / 1024)), table.add_row(Row::new(vec![Cell::new("Primary Disk Size"), Cell::new(&server.0.primary_disk_size.to_string())]));
])); table.add_row(Row::new(vec![Cell::new("Rescue Enabled"), Cell::new(&server.0.rescue_enabled.to_string())]));
table.add_row(Row::new(vec![
Cell::new("Primary Disk Size"),
Cell::new(&server.0.primary_disk_size.to_string()),
]));
table.add_row(Row::new(vec![
Cell::new("Rescue Enabled"),
Cell::new(&server.0.rescue_enabled.to_string()),
]));
Ok(table.to_string()) Ok(table.to_string())
}, });
);
engine.register_fn(
"enable_rescue_mode",
move |server: &mut WrappedServer,
client: HetznerClient|
-> Result<String, Box<EvalAltResult>> {
enable_rescue_mode_tx
.send(Request::EnableRescueMode(client, server.0.id))
.map_err(|e| e.to_string())?;
let response = enable_rescue_mode_rx
.lock()
.unwrap()
.recv()
.map_err(|e| e.to_string())?;
match response {
Response::EnableRescueMode(result) => result.map_err(|e| e.into()),
_ => Err("Unexpected response".into()),
}
},
)
.register_fn(
"disable_rescue_mode",
move |server: &mut WrappedServer,
client: HetznerClient|
-> Result<(), Box<EvalAltResult>> {
disable_rescue_mode_tx
.send(Request::DisableRescueMode(client, server.0.id))
.map_err(|e| e.to_string())?;
let response = disable_rescue_mode_rx
.lock()
.unwrap()
.recv()
.map_err(|e| e.to_string())?;
match response {
Response::DisableRescueMode(result) => result.map_err(|e| e.into()),
_ => Err("Unexpected response".into()),
}
},
);
} }