tyler
/
proxmox-backup
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

proxmox-rest-server: pass owned RestEnvironment to get_index 

This way we avoid pointers with lifetimes.
This commit is contained in:
Dietmar Maurer 2021-10-04 14:49:25 +02:00
parent 3483a3b3a1
commit 48176b0a77
6 changed files with 34 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
proxmox-rest-server/examples/minimal-rest-server.rs
View File

@ -8,7 +8,7 @@ use lazy_static::lazy_static;
use proxmox::api::{api, router::SubdirMap, Router, RpcEnvironmentType, UserInformation}; use proxmox::api::{api, router::SubdirMap, Router, RpcEnvironmentType, UserInformation};
use proxmox::list_subdirs_api_method; use proxmox::list_subdirs_api_method;
use proxmox_rest_server::{ApiAuth, ApiConfig, AuthError, RestServer}; use proxmox_rest_server::{ApiAuth, ApiConfig, AuthError, RestServer, RestEnvironment};
// Create a Dummy User info and auth system // Create a Dummy User info and auth system
// Normally this would check and authenticate the user // Normally this would check and authenticate the user
struct DummyUserInfo; struct DummyUserInfo;
@ -46,9 +46,7 @@ impl ApiAuth for DummyAuth {
// iow. what the user browses to // iow. what the user browses to
fn get_index<'a>( fn get_index<'a>(
_auth_id: Option<String>, _env: RestEnvironment,
_language: Option<String>,
_api: &'a ApiConfig,
_parts: http::request::Parts, _parts: http::request::Parts,
) -> Pin<Box<dyn Future<Output = http::Response<hyper::Body>> + Send + 'a>> { ) -> Pin<Box<dyn Future<Output = http::Response<hyper::Body>> + Send + 'a>> {
Box::pin(async move { Box::pin(async move {

9
proxmox-rest-server/src/api_config.rs
View File

@ -16,9 +16,9 @@ use serde::Serialize;
use proxmox::api::{ApiMethod, Router, RpcEnvironmentType, UserInformation}; use proxmox::api::{ApiMethod, Router, RpcEnvironmentType, UserInformation};
use proxmox::tools::fs::{create_path, CreateOptions}; use proxmox::tools::fs::{create_path, CreateOptions};
use crate::{ApiAuth, AuthError, FileLogger, FileLogOptions, CommandSocket}; use crate::{ApiAuth, AuthError, FileLogger, FileLogOptions, CommandSocket, RestEnvironment};
pub type GetIndexFn = &'static (dyn for<'a> Fn(Option<String>, Option<String>, &'a ApiConfig, Parts) -> Pin<Box<dyn Future<Output = Response<Body>> + Send + 'a>> + Send + Sync); pub type GetIndexFn = &'static (dyn Fn(RestEnvironment, Parts) -> Pin<Box<dyn Future<Output = Response<Body>> + Send>> + Send + Sync);
/// REST server configuration /// REST server configuration
pub struct ApiConfig { pub struct ApiConfig {
@ -72,11 +72,10 @@ impl ApiConfig {
pub(crate) async fn get_index( pub(crate) async fn get_index(
&self, &self,
auth_id: Option<String>, rest_env: RestEnvironment,
language: Option<String>,
parts: Parts, parts: Parts,
) -> Response<Body> { ) -> Response<Body> {
(self.get_index_fn)(auth_id, language, self, parts).await (self.get_index_fn)(rest_env, parts).await
} }
pub(crate) async fn check_auth( pub(crate) async fn check_auth(

15
proxmox-rest-server/src/rest.rs
View File

@ -36,7 +36,7 @@ use pbs_tools::stream::AsyncReaderStream;
use crate::{ use crate::{
ApiConfig, FileLogger, AuthError, RestEnvironment, CompressionMethod, ApiConfig, FileLogger, AuthError, RestEnvironment, CompressionMethod,
extract_cookie, normalize_uri_path, formatter::*, normalize_uri_path, formatter::*,
}; };
extern "C" { extern "C" {
@ -587,13 +587,6 @@ async fn handle_static_file_download(
} }
} }
fn extract_lang_header(headers: &http::HeaderMap) -> Option<String> {
if let Some(Ok(cookie)) = headers.get("COOKIE").map(|v| v.to_str()) {
return extract_cookie(cookie, "PBSLangCookie");
}
None
}
// FIXME: support handling multiple compression methods // FIXME: support handling multiple compression methods
fn extract_compression_method(headers: &http::HeaderMap) -> Option<CompressionMethod> { fn extract_compression_method(headers: &http::HeaderMap) -> Option<CompressionMethod> {
if let Some(Ok(encodings)) = headers.get(header::ACCEPT_ENCODING).map(|v| v.to_str()) { if let Some(Ok(encodings)) = headers.get(header::ACCEPT_ENCODING).map(|v| v.to_str()) {
@ -727,17 +720,17 @@ async fn handle_request(
} }
if comp_len == 0 { if comp_len == 0 {
let language = extract_lang_header(&parts.headers);
match api.check_auth(&parts.headers, &method).await { match api.check_auth(&parts.headers, &method).await {
Ok((auth_id, _user_info)) => { Ok((auth_id, _user_info)) => {
return Ok(api.get_index(Some(auth_id), language, parts).await); rpcenv.set_auth_id(Some(auth_id));
return Ok(api.get_index(rpcenv, parts).await);
} }
Err(AuthError::Generic(_)) => { Err(AuthError::Generic(_)) => {
tokio::time::sleep_until(Instant::from_std(delay_unauth_time)).await; tokio::time::sleep_until(Instant::from_std(delay_unauth_time)).await;
} }
Err(AuthError::NoData) => {} Err(AuthError::NoData) => {}
} }
return Ok(api.get_index(None, language, parts).await); return Ok(api.get_index(rpcenv, parts).await);
} else { } else {
let filename = api.find_alias(&components); let filename = api.find_alias(&components);
let compression = extract_compression_method(&parts.headers); let compression = extract_compression_method(&parts.headers);

6
proxmox-restore-daemon/src/main.rs
View File

@ -23,7 +23,7 @@ use hyper::header;
use proxmox::api::RpcEnvironmentType; use proxmox::api::RpcEnvironmentType;
use pbs_client::DEFAULT_VSOCK_PORT; use pbs_client::DEFAULT_VSOCK_PORT;
use proxmox_rest_server::{ApiConfig, RestServer}; use proxmox_rest_server::{ApiConfig, RestServer, RestEnvironment};
mod proxmox_restore_daemon; mod proxmox_restore_daemon;
use proxmox_restore_daemon::*; use proxmox_restore_daemon::*;
@ -94,9 +94,7 @@ fn setup_system_env() -> Result<(), Error> {
} }
fn get_index<'a>( fn get_index<'a>(
_auth_id: Option<String>, _env: RestEnvironment,
_language: Option<String>,
_api: &'a ApiConfig,
_parts: Parts, _parts: Parts,
) -> Pin<Box<dyn Future<Output = http::Response<Body>> + Send + 'a>> { ) -> Pin<Box<dyn Future<Output = http::Response<Body>> + Send + 'a>> {
Box::pin(async move { Box::pin(async move {

6
src/bin/proxmox-backup-api.rs
View File

@ -12,7 +12,7 @@ use proxmox::try_block;
use proxmox::api::RpcEnvironmentType; use proxmox::api::RpcEnvironmentType;
use proxmox::tools::fs::CreateOptions; use proxmox::tools::fs::CreateOptions;
use proxmox_rest_server::{daemon, ApiConfig, RestServer}; use proxmox_rest_server::{daemon, ApiConfig, RestServer, RestEnvironment};
use proxmox_backup::server::auth::default_api_auth; use proxmox_backup::server::auth::default_api_auth;
use proxmox_backup::auth_helpers::*; use proxmox_backup::auth_helpers::*;
@ -28,9 +28,7 @@ fn main() {
} }
fn get_index<'a>( fn get_index<'a>(
_auth_id: Option<String>, _env: RestEnvironment,
_language: Option<String>,
_api: &'a ApiConfig,
_parts: Parts, _parts: Parts,
) -> Pin<Box<dyn Future<Output = Response<Body>> + Send + 'a>> { ) -> Pin<Box<dyn Future<Output = Response<Body>> + Send + 'a>> {
Box::pin(async move { Box::pin(async move {

30
src/bin/proxmox-backup-proxy.rs
View File

@ -17,13 +17,15 @@ use tokio_stream::wrappers::ReceiverStream;
use serde_json::{json, Value}; use serde_json::{json, Value};
use proxmox::try_block; use proxmox::try_block;
use proxmox::api::RpcEnvironmentType; use proxmox::api::{RpcEnvironment, RpcEnvironmentType};
use proxmox::sys::linux::socket::set_tcp_keepalive; use proxmox::sys::linux::socket::set_tcp_keepalive;
use proxmox::tools::fs::CreateOptions; use proxmox::tools::fs::CreateOptions;
use pbs_tools::task_log; use pbs_tools::task_log;
use pbs_datastore::DataStore; use pbs_datastore::DataStore;
use proxmox_rest_server::{rotate_task_log_archive, ApiConfig, RestServer, WorkerTask}; use proxmox_rest_server::{
rotate_task_log_archive, extract_cookie , ApiConfig, RestServer, RestEnvironment, WorkerTask,
};
use proxmox_backup::{ use proxmox_backup::{
server::{ server::{
@ -78,23 +80,31 @@ fn main() -> Result<(), Error> {
pbs_runtime::main(run()) pbs_runtime::main(run())
} }
fn extract_lang_header(headers: &http::HeaderMap) -> Option<String> {
if let Some(Ok(cookie)) = headers.get("COOKIE").map(|v| v.to_str()) {
return extract_cookie(cookie, "PBSLangCookie");
}
None
}
fn get_index<'a>( fn get_index<'a>(
auth_id: Option<String>, env: RestEnvironment,
language: Option<String>,
api: &'a ApiConfig,
parts: Parts, parts: Parts,
) -> Pin<Box<dyn Future<Output = Response<Body>> + Send + 'a>> { ) -> Pin<Box<dyn Future<Output = Response<Body>> + Send + 'a>> {
Box::pin(get_index_future(auth_id, language, api, parts)) Box::pin(get_index_future(env, parts))
} }
async fn get_index_future( async fn get_index_future(
auth_id: Option<String>, env: RestEnvironment,
language: Option<String>,
api: &ApiConfig,
parts: Parts, parts: Parts,
) -> Response<Body> { ) -> Response<Body> {
// fixme: make all IO async let auth_id = env.get_auth_id();
let api = env.api_config();
let language = extract_lang_header(&parts.headers);
// fixme: make all IO async
let (userid, csrf_token) = match auth_id { let (userid, csrf_token) = match auth_id {
Some(auth_id) => { Some(auth_id) => {