update to proxmox-sys 0.2 crate

[proxmox-backup.git] / src / api2 / node / mod.rs

diff --git a/src/api2/node/mod.rs b/src/api2/node/mod.rs
index b9980ef771d705ed78cac5e622857aab5aa28daf..b60ea9e7e72719d41684e84bc2ed7a9934b7973a 100644 (file)
--- a/src/api2/node/mod.rs
+++ b/src/api2/node/mod.rs
@@ -12,21 +12,23 @@ use hyper::Request;
 use serde_json::{json, Value};
 use tokio::io::{AsyncBufReadExt, BufReader};
 
-use proxmox::api::router::{Router, SubdirMap};
-use proxmox::api::{
-    api, schema::*, ApiHandler, ApiMethod, ApiResponseFuture, Permission, RpcEnvironment,
+use proxmox_sys::{identity, sortable};
+use proxmox_sys::fd::fd_change_cloexec;
+
+use proxmox_router::{
+    ApiHandler, ApiMethod, ApiResponseFuture, Permission, RpcEnvironment, Router, SubdirMap,
 };
-use proxmox::list_subdirs_api_method;
+use proxmox_schema::*;
+use proxmox_router::list_subdirs_api_method;
 use proxmox_http::websocket::WebSocket;
-use proxmox::{identity, sortable};
 
-use pbs_tools::auth::private_auth_key;
+use proxmox_rest_server::WorkerTask;
+
+use pbs_api_types::{Authid, NODE_SCHEMA, PRIV_SYS_CONSOLE};
 use pbs_tools::ticket::{self, Empty, Ticket};
 
-use crate::api2::types::*;
-use crate::config::acl::PRIV_SYS_CONSOLE;
-use crate::server::WorkerTask;
 use crate::tools;
+use crate::auth_helpers::private_auth_key;
 
 pub mod apt;
 pub mod certificates;
@@ -34,17 +36,17 @@ pub mod config;
 pub mod disks;
 pub mod dns;
 pub mod network;
-pub mod tasks;
 pub mod subscription;
+pub mod tasks;
 
 pub(crate) mod rrd;
 
 mod journal;
+mod report;
 pub(crate) mod services;
 mod status;
 mod syslog;
 mod time;
-mod report;
 
 pub const SHELL_CMD_SCHEMA: Schema = StringSchema::new("The command to run.")
     .format(&ApiStringFormat::Enum(&[
@@ -94,10 +96,7 @@ pub const SHELL_CMD_SCHEMA: Schema = StringSchema::new("The command to run.")
     }
 )]
 /// Call termproxy and return shell ticket
-async fn termproxy(
-    cmd: Option<String>,
-    rpcenv: &mut dyn RpcEnvironment,
-) -> Result<Value, Error> {
+async fn termproxy(cmd: Option<String>, rpcenv: &mut dyn RpcEnvironment) -> Result<Value, Error> {
     // intentionally user only for now
     let auth_id: Authid = rpcenv
         .get_auth_id()
@@ -120,11 +119,10 @@ async fn termproxy(
     let listener = TcpListener::bind("localhost:0")?;
     let port = listener.local_addr()?.port();
 
-    let ticket = Ticket::new(ticket::TERM_PREFIX, &Empty)?
-        .sign(
-            private_auth_key(),
-            Some(&tools::ticket::term_aad(&userid, &path, port)),
-        )?;
+    let ticket = Ticket::new(ticket::TERM_PREFIX, &Empty)?.sign(
+        private_auth_key(),
+        Some(&tools::ticket::term_aad(&userid, &path, port)),
+    )?;
 
     let mut command = Vec::new();
     match cmd.as_deref() {
@@ -151,12 +149,12 @@ async fn termproxy(
     let upid = WorkerTask::spawn(
         "termproxy",
         None,
-        auth_id,
+        auth_id.to_string(),
         false,
         move |worker| async move {
             // move inside the worker so that it survives and does not close the port
             // remove CLOEXEC from listenere so that we can reuse it in termproxy
-            tools::fd_change_cloexec(listener.as_raw_fd(), false)?;
+            fd_change_cloexec(listener.as_raw_fd(), false)?;
 
             let mut arguments: Vec<&str> = Vec::new();
             let fd_string = listener.as_raw_fd().to_string();
@@ -188,7 +186,7 @@ async fn termproxy(
             let stdout_fut = async move {
                 let mut reader = BufReader::new(stdout).lines();
                 while let Some(line) = reader.next_line().await? {
-                    worker_stdout.log(line);
+                    worker_stdout.log_message(line);
                 }
                 Ok::<(), Error>(())
             };
@@ -197,13 +195,13 @@ async fn termproxy(
             let stderr_fut = async move {
                 let mut reader = BufReader::new(stderr).lines();
                 while let Some(line) = reader.next_line().await? {
-                    worker_stderr.warn(line);
+                    worker_stderr.log_warning(line);
                 }
                 Ok::<(), Error>(())
             };
 
             let mut needs_kill = false;
-            let res = tokio::select!{
+            let res = tokio::select! {
                 res = child.wait() => {
                     let exit_code = res?;
                     if !exit_code.success() {
@@ -229,9 +227,9 @@ async fn termproxy(
                 }
 
                 if let Err(err) = child.kill().await {
-                    worker.warn(format!("error killing termproxy: {}", err));
+                    worker.log_warning(format!("error killing termproxy: {}", err));
                 } else if let Err(err) = child.wait().await {
-                    worker.warn(format!("error awaiting termproxy: {}", err));
+                    worker.log_warning(format!("error awaiting termproxy: {}", err));
                 }
             }
 
@@ -288,22 +286,24 @@ fn upgrade_to_websocket(
         }
 
         let userid = auth_id.user();
-        let ticket = tools::required_string_param(&param, "vncticket")?;
-        let port: u16 = tools::required_integer_param(&param, "port")? as u16;
+        let ticket = pbs_tools::json::required_string_param(&param, "vncticket")?;
+        let port: u16 = pbs_tools::json::required_integer_param(&param, "port")? as u16;
 
         // will be checked again by termproxy
-        Ticket::<Empty>::parse(ticket)?
-            .verify(
-                crate::auth_helpers::public_auth_key(),
-                ticket::TERM_PREFIX,
-                Some(&tools::ticket::term_aad(&userid, "/system", port)),
-            )?;
+        Ticket::<Empty>::parse(ticket)?.verify(
+            crate::auth_helpers::public_auth_key(),
+            ticket::TERM_PREFIX,
+            Some(&tools::ticket::term_aad(&userid, "/system", port)),
+        )?;
 
         let (ws, response) = WebSocket::new(parts.headers.clone())?;
 
-        crate::server::spawn_internal_task(async move {
-            let conn: Upgraded = match hyper::upgrade::on(Request::from_parts(parts, req_body)).map_err(Error::from).await {
-                Ok(upgraded) => upgraded,
+        proxmox_rest_server::spawn_internal_task(async move {
+            let conn: Upgraded = match hyper::upgrade::on(Request::from_parts(parts, req_body))
+                .map_err(Error::from)
+                .await
+            {
+               Ok(upgraded) => upgraded,
                 _ => bail!("error"),
             };
 
@@ -316,6 +316,12 @@ fn upgrade_to_websocket(
     .boxed()
 }
 
+#[api]
+/// List Nodes (only for compatiblity)
+fn list_nodes() -> Result<Value, Error> {
+    Ok(json!([ { "node": proxmox_sys::nodename().to_string() } ]))
+}
+
 pub const SUBDIRS: SubdirMap = &[
     ("apt", &apt::ROUTER),
     ("certificates", &certificates::ROUTER),
@@ -339,6 +345,10 @@ pub const SUBDIRS: SubdirMap = &[
     ),
 ];
 
-pub const ROUTER: Router = Router::new()
+pub const ITEM_ROUTER: Router = Router::new()
     .get(&list_subdirs_api_method!(SUBDIRS))
     .subdirs(SUBDIRS);
+
+pub const ROUTER: Router = Router::new()
+    .get(&API_METHOD_LIST_NODES)
+    .match_all("node", &ITEM_ROUTER);