astatin3/unshell
1
0
Fork 0
mirror of https://github.com/Astatin3/unshell.git synced 2026-06-08 22:38:01 -06:00
Code Issues Packages Projects Releases Wiki Activity

Move modules to individual projects. Change API syntax.

Browse Source
This commit is contained in:
Michael Mikovsky
2025-12-17 13:17:58 -07:00
parent 41c47048be
commit 6e73cb8a8e
22 changed files with 546 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files
unshell-server/src/api/app.rs
+31 -74
View File
@@ -7,12 +7,36 @@ use axum::{
use tokio::net::TcpListener;
use unshell_lib::{debug, info};
// axum_extra::
use crate::{
api::{auth, structs::CurrentUser},
logger::Logger,
server::Server,
};
macro_rules! route_get {
($router:expr, $path:expr, $func:expr) => {{
{
$router.route(
$path,
get($func).layer(middleware::from_fn(auth::authorize)),
)
}
}};
}
// macro_rules! route_post {
// ($router:expr, $path:expr, $func:expr) => {{
// {
// $router.route(
// $path,
// post($func).layer(middleware::from_fn(auth::authorize)),
// )
// }
// }};
// }
pub async fn start_api(address: &str, server: Server) {
let listener = TcpListener::bind(address)
.await
@@ -21,88 +45,21 @@ pub async fn start_api(address: &str, server: Server) {
info!("Listening on {}", listener.local_addr().unwrap());
let mut router = Router::new().route("/api/auth", post(auth::sign_in));
router = route_get_trees(router);
router = route_get_all_tree_values(router);
router = route_get_tree_keys(router);
router = route_trees(router);
router = route_get_log(router);
router = route_get!(router, "/api/log/{*offset}", Logger::poll_logs_api);
router = route_get!(router, "/api/trees", Server::get_trees_api);
router = route_get!(router, "/api/keys/{*path}", Server::all_tree_keys_api);
router = route_get!(router, "/api/values/{*path}", Server::all_tree_values_api);
// router = route_get_log(router);
axum::serve(listener, router.with_state(server))
.await
.expect("Error serving application");
}
// Route the "keys" api for each tree
fn route_get_log(router: Router<Server>) -> Router<Server> {
router.route(
"/api/log/{offset}",
get(
async |State(_): State<Server>,
Extension(_): Extension<CurrentUser>,
Path(offset): Path<usize>| {
debug!("GET /api/log/{}", offset);
let result = Logger::poll_logs(offset);
Json(serde_json::to_value(result).unwrap())
},
)
.layer(middleware::from_fn(auth::authorize)),
)
}
// Route the "keys" api for each tree
fn route_get_trees(router: Router<Server>) -> Router<Server> {
router.route(
"/api/trees",
get(
async |State(server): State<Server>, Extension(_): Extension<CurrentUser>| {
debug!("GET /api/trees");
let result = server.get_trees();
Json(serde_json::to_value(result).unwrap())
},
)
.layer(middleware::from_fn(auth::authorize)),
)
}
// Route the "keys" api for each tree
fn route_get_tree_keys(router: Router<Server>) -> Router<Server> {
router.route(
"/api/keys/{*path}",
get(
async |State(server): State<Server>,
Path(path): Path<String>,
Extension(_): Extension<CurrentUser>| {
debug!("GET /api/keys/{}", path);
let result = server.get_keys(&path);
Json(serde_json::to_value(result).unwrap())
},
)
.layer(middleware::from_fn(auth::authorize)),
)
}
// Route the "values" api to get all the values for each tree
fn route_get_all_tree_values(router: Router<Server>) -> Router<Server> {
router.route(
"/api/values/{*path}",
get(
async |State(server): State<Server>,
Path(path): Path<String>,
Extension(_): Extension<CurrentUser>| {
debug!("GET /api/values/{}", path);
let result = server.all_tree_values(&path);
Json(serde_json::to_value(result).unwrap())
},
)
.layer(middleware::from_fn(auth::authorize)),
)
}
// Loop through all trees and add /api/<tree>/<path> POST aand GET listeners for them
fn route_trees(mut router: Router<Server>) -> Router<Server> {
for tree in crate::DATABASE_TREES.iter() {
unshell-server/src/api/mod.rs
+2
View File
@@ -7,6 +7,8 @@ pub mod app;
mod auth;
mod structs;
pub use structs::CurrentUser;
static EXPIRE_DURATION: Duration = Duration::hours(12);
#[dynamic]
unshell-server/src/config/blob.rs
+12
View File
@@ -0,0 +1,12 @@
use std::collections::HashMap;
use crate::config::ConfigStructField;
#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
pub struct Blob {
name: String,
parent_component: String,
// parent_runtime: String,
config: HashMap<String, ConfigStructField>,
}
unshell-server/src/config/mod.rs
+5 -1
View File
@@ -1,3 +1,7 @@
mod blob;
pub use blob::Blob;
use std::{
collections::HashMap,
error::Error,
@@ -67,7 +71,7 @@ pub struct ComponentState {
pub fn load_config(path: &PathBuf) -> Result<Vec<ComponentState>, Box<dyn Error>> {
let path_absolute = fs::canonicalize(path.clone())?;
debug!("Loading data from path: `{}`", path_absolute);
debug!("Loading data from path: `{:?}`", path_absolute);
// Read string as path
let config_str = fs::read_to_string(path.clone())?;
unshell-server/src/lib.rs
+6 -6
View File
@@ -17,9 +17,9 @@ pub static DEFAULT_HOST: String = "localhost".to_string();
#[static_init::dynamic]
pub static DATABASE_NAME: String = "database".to_string();
#[static_init::dynamic]
pub static SERVER_CONFIG: unshell_lib::config::PayloadConfig = unshell_lib::config::PayloadConfig {
id: "Server",
components: unshell_lib::get_components(),
runtime_config: Vec::new(),
};
// #[static_init::dynamic]
// pub static SERVER_CONFIG: unshell_lib::config::PayloadConfig = unshell_lib::config::PayloadConfig {
// id: "Server",
// components: unshell_lib::get_components(),
// runtime_config: Vec::new(),
// };
unshell-server/src/logger.rs
+18
View File
@@ -1,9 +1,15 @@
use axum::extract::{Path, State};
use axum::{Extension, Json};
use chrono::Local;
use unshell_lib::debug;
// use lazy_static::lazy_static;
use std::fs::{self, File, OpenOptions};
use std::io::{BufRead, BufReader, Write};
use std::path::PathBuf;
use crate::Server;
use crate::api::CurrentUser;
// --- Constants ---
/// The directory where log files will be stored.
const LOG_DIR: &str = "logs";
@@ -125,6 +131,18 @@ impl Logger {
}
}
}
// Route the "keys" api for each tree
pub async fn poll_logs_api(
State(_): State<Server>,
Extension(_): Extension<CurrentUser>,
Path(offset): Path<usize>,
) -> axum::Json<serde_json::Value> {
debug!("GET /api/log/{}", offset);
let result = Self::poll_logs(offset);
Json(serde_json::to_value(result).unwrap())
}
}
// --- Example Usage ---
unshell-server/src/server/blobs.rs
+9
View File
@@ -0,0 +1,9 @@
use serde_json::Value;
use crate::Server;
impl Server {
pub fn get_blobs(&self) -> Result<Vec<Value>, String> {
Ok(Vec::new())
}
}
unshell-server/src/server/database.rs
+46 -21
View File
@@ -1,14 +1,14 @@
use std::collections::HashMap;
use axum::{
Extension, Json,
extract::{Path, State},
};
use serde_json::Value;
use sled::Tree;
use unshell_lib::error;
use unshell_lib::{debug, error};
use crate::server::Server;
// #[derive(Clone)]
// pub struct Database {
// db: sled::Db,
// }
use crate::{api::CurrentUser, server::Server};
impl Server {
fn get_tree(&self, tree_name: &str) -> Result<Tree, String> {
@@ -18,12 +18,17 @@ impl Server {
})
}
pub fn get_trees(&self) -> Vec<String> {
self.db
pub async fn get_trees_api(State(server): State<Server>) -> Json<Value> {
debug!("GET tree list");
let result = server
.db
.tree_names()
.iter()
.map(|n| String::from_utf8_lossy(&n.to_vec()).to_string())
.collect::<Vec<String>>()
.collect::<Vec<String>>();
Json(serde_json::to_value(result).unwrap())
}
pub fn put_value(&self, tree_name: &str, key: &str, value: &str) -> Result<(), String> {
@@ -50,7 +55,7 @@ impl Server {
}
}
pub fn get_keys(&self, tree_name: &str) -> Result<Vec<String>, String> {
fn get_keys(&self, tree_name: &str) -> Result<Vec<String>, String> {
Ok(self
.get_tree(tree_name)?
.iter()
@@ -61,15 +66,35 @@ impl Server {
.collect::<Vec<String>>())
}
pub fn all_tree_values(&self, tree_name: &str) -> Result<HashMap<String, String>, String> {
Ok(self
.get_keys(tree_name)?
.iter()
.map(|key| -> Result<(String, String), String> {
Ok((key.clone(), self.get_value(tree_name, &key)?))
})
.collect::<Result<Vec<(String, String)>, String>>()?
.into_iter()
.collect::<HashMap<String, String>>())
// Route the "keys" api for each tree
pub async fn all_tree_keys_api(
State(server): State<Server>,
Path(tree_name): Path<String>,
Extension(_): Extension<CurrentUser>,
) -> Json<Value> {
let result = server.get_keys(&tree_name);
Json(serde_json::to_value(result).unwrap())
}
// Route the "values" api to get all the values for each tree
pub async fn all_tree_values_api(
State(server): State<Server>,
Path(tree_name): Path<String>,
Extension(_): Extension<CurrentUser>,
) -> Json<Value> {
let result = || -> Result<HashMap<String, String>, String> {
Ok(server
.get_keys(&tree_name)?
.iter()
.map(|key| -> Result<(String, String), String> {
Ok((key.clone(), server.get_value(&tree_name, &key)?))
})
.collect::<Result<Vec<(String, String)>, String>>()?
.into_iter()
.collect::<HashMap<String, String>>())
}();
Json(serde_json::to_value(result).unwrap())
}
}
unshell-server/src/server/mod.rs
+1
View File
@@ -1,5 +1,6 @@
use std::{error::Error, path::PathBuf};
mod blobs;
mod database;
mod manager;