kjuulh/hyperlog
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects Releases 3 Wiki Activity

refactor: into crates

Browse Source 
Signed-off-by: kjuulh <contact@kjuulh.io>
This commit is contained in:
Kasper Juul Hermansen 2024-04-30 20:36:45 +02:00
parent 14ef235dd9
commit 1be3a4fa6c
Signed by: kjuulh
GPG Key ID: 57B6E1465221F912
5 changed files with 200 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
crates/hyperlog-core/src/lib.rs
View File

@ -1,4 +1,5 @@
#![feature(map_try_insert)]
pub mod commander;
pub mod querier;

116
crates/hyperlog/src/cli.rs Normal file
View File

@ -0,0 +1,116 @@
use std::{net::SocketAddr, ops::Deref, sync::Arc};
use axum::extract::MatchedPath;
use axum::http::Request;
use axum::routing::get;
use axum::Router;
use clap::{Parser, Subcommand};
use hyperlog_core::{commander, state};
use tower_http::trace::TraceLayer;
use crate::{
server::serve,
state::{SharedState, State},
};
#[derive(Parser)]
#[command(author, version, about, long_about = None, subcommand_required = true)]
struct Command {
#[command(subcommand)]
command: Option<Commands>,
}
#[derive(Subcommand)]
enum Commands {
Serve {
#[arg(env = "SERVICE_HOST", long, default_value = "127.0.0.1:3000")]
host: SocketAddr,
},
Exec {
#[command(subcommand)]
commands: ExecCommands,
},
Query {
#[command(subcommand)]
commands: QueryCommands,
},
Info {},
}
#[derive(Subcommand)]
enum ExecCommands {
CreateRoot {
#[arg(long = "root")]
root: String,
},
CreateSection {
#[arg(long = "root")]
root: String,
#[arg(long = "path")]
path: Option<String>,
},
}
#[derive(Subcommand)]
enum QueryCommands {
Get {
#[arg(long = "root")]
root: String,
#[arg(long = "path")]
path: Option<String>,
},
}
pub async fn execute() -> anyhow::Result<()> {
let cli = Command::parse();
let state = state::State::new()?;
match cli.command {
Some(Commands::Serve { host }) => {
tracing::info!("Starting service");
serve(host).await?;
}
Some(Commands::Exec { commands }) => match commands {
ExecCommands::CreateRoot { root } => state
.commander
.execute(commander::Command::CreateRoot { root })?,
ExecCommands::CreateSection { root, path } => {
state.commander.execute(commander::Command::CreateSection {
root,
path: path
.unwrap_or_default()
.split('.')
.map(|s| s.to_string())
.filter(|s| !s.is_empty())
.collect::<Vec<String>>(),
})?
}
},
Some(Commands::Query { commands }) => match commands {
QueryCommands::Get { root, path } => {
let res = state.querier.get(
&root,
path.unwrap_or_default()
.split('.')
.filter(|s| !s.is_empty()),
);
let output = serde_json::to_string_pretty(&res)?;
println!("{}", output);
}
},
Some(Commands::Info {}) => {
println!("graph stored at: {}", state.storage.info()?)
}
None => {}
}
Ok(())
}

176
crates/hyperlog/src/main.rs
View File

@ -1,181 +1,13 @@
use std::{net::SocketAddr, ops::Deref, sync::Arc};
use anyhow::Context;
use axum::extract::MatchedPath;
use axum::http::Request;
use axum::routing::get;
use axum::Router;
use clap::{Parser, Subcommand};
use hyperlog_core::{commander, state};
use sqlx::{Pool, Postgres};
use tower_http::trace::TraceLayer;
#[derive(Parser)]
#[command(author, version, about, long_about = None, subcommand_required = true)]
struct Command {
#[command(subcommand)]
command: Option<Commands>,
}
#[derive(Subcommand)]
enum Commands {
Serve {
#[arg(env = "SERVICE_HOST", long, default_value = "127.0.0.1:3000")]
host: SocketAddr,
},
Exec {
#[command(subcommand)]
commands: ExecCommands,
},
Query {
#[command(subcommand)]
commands: QueryCommands,
},
Info {},
}
#[derive(Subcommand)]
enum ExecCommands {
CreateRoot {
#[arg(long = "root")]
root: String,
},
CreateSection {
#[arg(long = "root")]
root: String,
#[arg(long = "path")]
path: Option<String>,
},
}
#[derive(Subcommand)]
enum QueryCommands {
Get {
#[arg(long = "root")]
root: String,
#[arg(long = "path")]
path: Option<String>,
},
}
mod cli;
pub(crate) mod server;
pub(crate) mod state;
#[tokio::main]
async fn main() -> anyhow::Result<()> {
dotenv::dotenv().ok();
tracing_subscriber::fmt::init();
let cli = Command::parse();
let state = state::State::new()?;
match cli.command {
Some(Commands::Serve { host }) => {
tracing::info!("Starting service");
let state = SharedState(Arc::new(State::new().await?));
let app = Router::new()
.route("/", get(root))
.with_state(state.clone())
.layer(
TraceLayer::new_for_http().make_span_with(|request: &Request<_>| {
// Log the matched route's path (with placeholders not filled in).
// Use request.uri() or OriginalUri if you want the real path.
let matched_path = request
.extensions()
.get::<MatchedPath>()
.map(MatchedPath::as_str);
tracing::info_span!(
"http_request",
method = ?request.method(),
matched_path,
some_other_field = tracing::field::Empty,
)
}), // ...
);
tracing::info!("listening on {}", host);
let listener = tokio::net::TcpListener::bind(host).await.unwrap();
axum::serve(listener, app.into_make_service())
.await
.unwrap();
}
Some(Commands::Exec { commands }) => match commands {
ExecCommands::CreateRoot { root } => state
.commander
.execute(commander::Command::CreateRoot { root })?,
ExecCommands::CreateSection { root, path } => {
state.commander.execute(commander::Command::CreateSection {
root,
path: path
.unwrap_or_default()
.split('.')
.map(|s| s.to_string())
.filter(|s| !s.is_empty())
.collect::<Vec<String>>(),
})?
}
},
Some(Commands::Query { commands }) => match commands {
QueryCommands::Get { root, path } => {
let res = state.querier.get(
&root,
path.unwrap_or_default()
.split('.')
.filter(|s| !s.is_empty()),
);
let output = serde_json::to_string_pretty(&res)?;
println!("{}", output);
}
},
Some(Commands::Info {}) => {
println!("graph stored at: {}", state.storage.info()?)
}
None => {}
}
cli::execute().await?;
Ok(())
}
async fn root() -> &'static str {
"Hello, hyperlog!"
}
#[derive(Clone)]
pub struct SharedState(Arc<State>);
impl Deref for SharedState {
type Target = Arc<State>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
pub struct State {
pub db: Pool<Postgres>,
}
impl State {
pub async fn new() -> anyhow::Result<Self> {
let db = sqlx::PgPool::connect(
&std::env::var("DATABASE_URL").context("DATABASE_URL is not set")?,
)
.await?;
sqlx::migrate!("migrations/crdb")
.set_locking(false)
.run(&db)
.await?;
let _ = sqlx::query("SELECT 1;").fetch_one(&db).await?;
Ok(Self { db })
}
}

42
crates/hyperlog/src/server.rs Normal file
View File

@ -0,0 +1,42 @@
use std::{net::SocketAddr, sync::Arc};
use axum::{extract::MatchedPath, http::Request, routing::get, Router};
use tower_http::trace::TraceLayer;
use crate::state::{self, SharedState, State};
async fn root() -> &'static str {
"Hello, hyperlog!"
}
pub async fn serve(host: SocketAddr) -> anyhow::Result<()> {
let state = SharedState(Arc::new(State::new().await?));
let app = Router::new()
.route("/", get(root))
.with_state(state.clone())
.layer(
TraceLayer::new_for_http().make_span_with(|request: &Request<_>| {
// Log the matched route's path (with placeholders not filled in).
// Use request.uri() or OriginalUri if you want the real path.
let matched_path = request
.extensions()
.get::<MatchedPath>()
.map(MatchedPath::as_str);
tracing::info_span!(
"http_request",
method = ?request.method(),
matched_path,
some_other_field = tracing::field::Empty,
)
}), // ...
);
tracing::info!("listening on {}", host);
let listener = tokio::net::TcpListener::bind(host).await.unwrap();
axum::serve(listener, app.into_make_service())
.await
.unwrap();
Ok(())
}

37
crates/hyperlog/src/state.rs Normal file
View File

@ -0,0 +1,37 @@
use std::{ops::Deref, sync::Arc};
use anyhow::Context;
use sqlx::{Pool, Postgres};
#[derive(Clone)]
pub struct SharedState(pub Arc<State>);
impl Deref for SharedState {
type Target = Arc<State>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
pub struct State {
pub db: Pool<Postgres>,
}
impl State {
pub async fn new() -> anyhow::Result<Self> {
let db = sqlx::PgPool::connect(
&std::env::var("DATABASE_URL").context("DATABASE_URL is not set")?,
)
.await?;
sqlx::migrate!("migrations/crdb")
.set_locking(false)
.run(&db)
.await?;
let _ = sqlx::query("SELECT 1;").fetch_one(&db).await?;
Ok(Self { db })
}
}