C0ffeeCode/rvault
1
0
Fork 0
Code Issues 1 Pull requests Projects 1 Releases Packages Wiki Activity

engine routing experiment

Browse source
This commit is contained in:
Laurenz 2024-05-01 20:05:18 +02:00
parent be4e698d61
commit 2c355ef75d
1 changed files with 31 additions and 62 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

89
src/engines.rs
View file

@ -1,77 +1,46 @@
pub mod kv;
use crate::engines::kv::logic::body_to_json;
use crate::engines::kv::structs::KvSecret;
use axum::{
extract::{Path, Request},
http::StatusCode,
middleware::{self, Next},
body::Body,
extract::{Request, State},
response::Response,
routing::*,
Router,
};
use log::*;
use sqlx::{Any, Pool};
pub fn secrets_router(pool: Pool<Any>) -> Router<Pool<Any>> {
// Router::new().layer(map_request(handler))
Router::new()
.route("/:mount_path/data/:kv_path", post(baz))
.with_state(pool)
Router::new().fallback(map_mount_points).with_state(pool)
}
/// Routing handler for path "/v1/kv-v2/data/foo"
/// expects payload as JSON, prints payload into struct
async fn map_mount_points(State(_pool): State<Pool<Any>>, req: Request) -> Response<Body> {
// let mount_path = mount_path.trim_start_matches('/');
// debug!("Mount path: {}", mount_path);
debug!("Mount path: {:?}", req);
async fn baz(Path(mount_path): Path<String>, Path(kv_path): Path<String>, body: String) -> String {
let mut body_json = body_to_json(body);
let mut mount_path: Vec<&str> = req.uri().path().split("/").collect();
// TODO: If version field provided during a read, the value at the version number will be returned
let secret: KvSecret = KvSecret {
data: body_json.to_string(),
// content: body_json["data"]["password1"].take().to_string(),
version: body_json["data"]["version"].take().as_i64(),
};
log::debug!(
"Secret: {}, Content: {}, Version: {:?}, path: {}",
kv_path,
secret.data,
secret.version,
mount_path,
// let a = sqlx::query!("SELECT * FROM secret_engines WHERE path = $1", mount_path.join("/"))
// .fetch_one(&pool)
// .await
// .expect("Failed to fetch secret engine");
let tada = vec!["a/b/c/d".to_string(), "/a/b/c".to_string(), "/kv-v2".into()];
// Find longest matching existing mount path for the request
for _ in 1..mount_path.len() {
if tada.contains(&mount_path.join("/")) {
trace!(
"Mount path {} found for route request: {}",
mount_path.join("/"),
req.uri().path()
);
String::from("RoutingTest baz successful")
break;
} else {
mount_path.pop();
}
}
// async fn handler(Host(hostname): Host, request: Request<Body>) -> &'static str {
// TODO: Find a solution for this mess
// async fn handler(request: Request<Body>) -> Result<Request<Body>, StatusCode> {
// // let path: Vec<&str> = request.uri().path().split('/').clone().collect();
// // log::info!("path, {:?}", path[1]);
// let root = service_fn(|req: Request<String>| async move {
// let res = Response::new("Hello, World!".to_string());
// Ok::<_, Infallible>(res)
// });
// let root = BoxService::new(root);
// let mut routes = vec!["/abc", "/def"];
// routes.sort_unstable_by(|a, b| a.len().cmp(&b.len()));
// let mut app = Router::new();
// app.as_service().call(request).await.unwrap();
// // match path[1] {
// // "test" => {
// // log::info!("test route");
// // // TODO: Nest another Router here
// // return Ok(Request::new(Body::empty()));
// // }
// // _ => {
// // log::info!("default");
// // return Err(StatusCode::NOT_FOUND);
// // }
// // }
// Err(StatusCode::IM_A_TEAPOT)
// }
return Response::new(Body::from(format!("Mount path:")));
}