111 lines
2.9 KiB
Rust
111 lines
2.9 KiB
Rust
mod commands;
|
|
mod config;
|
|
mod context;
|
|
mod helper;
|
|
mod logging;
|
|
|
|
use crate::commands::add_token::AddToken;
|
|
use crate::commands::{command_filter, Command};
|
|
use crate::config::GeoffreyAPIConfig;
|
|
use crate::context::Context;
|
|
use crate::logging::{init_logging, LogLevel};
|
|
use geoffrey_models::models::parameters::add_token_params::AddTokenParams;
|
|
use geoffrey_models::models::response::api_error::GeoffreyAPIError;
|
|
use geoffrey_models::models::token::Permissions;
|
|
use std::convert::TryFrom;
|
|
use std::net::SocketAddr;
|
|
use std::path::PathBuf;
|
|
use std::str::FromStr;
|
|
use std::sync::Arc;
|
|
use structopt::StructOpt;
|
|
|
|
pub type Result<T> = std::result::Result<T, GeoffreyAPIError>;
|
|
|
|
#[derive(Debug, StructOpt, Clone)]
|
|
#[structopt(name = "GeoffreyAPI", about = "Geoffrey Central API")]
|
|
struct Args {
|
|
#[structopt(env = "GEOFFREY_CONFIG", parse(from_os_str))]
|
|
config: PathBuf,
|
|
#[structopt(
|
|
short,
|
|
long,
|
|
env = "GEOFFREY_LOG_LEVEL",
|
|
parse(from_str),
|
|
default_value = "Info"
|
|
)]
|
|
log_level: LogLevel,
|
|
|
|
#[structopt(subcommand)]
|
|
command: GeoffreyApiCommand,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, StructOpt, Clone)]
|
|
enum GeoffreyApiCommand {
|
|
Run,
|
|
CreateAdminToken(CreateTokenCommand),
|
|
}
|
|
|
|
#[derive(Debug, StructOpt, PartialEq, Clone)]
|
|
struct CreateTokenCommand {
|
|
#[structopt(parse(try_from_str = Permissions::try_from))]
|
|
pub permissions: Vec<Permissions>,
|
|
}
|
|
|
|
async fn run_server(ctx: Arc<Context>) {
|
|
let socket_addr = match SocketAddr::from_str(ctx.cfg.host.as_str()) {
|
|
Ok(socket_addr) => socket_addr,
|
|
Err(e) => {
|
|
log::warn!("Error parsing {} as address: {}", ctx.cfg.host, e);
|
|
return;
|
|
}
|
|
};
|
|
|
|
let api = command_filter(ctx.clone());
|
|
|
|
warp::serve(api).run(socket_addr).await;
|
|
}
|
|
|
|
fn create_token(ctx: Arc<Context>, perms: Vec<Permissions>) {
|
|
match AddToken::run_command(
|
|
ctx,
|
|
AddTokenParams {
|
|
token: "".to_string(),
|
|
permissions: perms,
|
|
},
|
|
None,
|
|
) {
|
|
Ok(token) => {
|
|
// Don't log this to keep tokens out of the log
|
|
println!("Added admin token with secret: {}", token.secret)
|
|
}
|
|
Err(e) => {
|
|
log::warn!("Unable to create admin token: {}", e)
|
|
}
|
|
}
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
let args: Args = Args::from_args();
|
|
|
|
if let Err(e) = init_logging(args.log_level) {
|
|
println!("Unable to initialize logger: {}", e);
|
|
return;
|
|
}
|
|
|
|
let cfg = match GeoffreyAPIConfig::new(args.config.as_path()) {
|
|
Ok(cfg) => cfg,
|
|
Err(e) => {
|
|
log::warn!("Error opening config: {}", e);
|
|
return;
|
|
}
|
|
};
|
|
|
|
let ctx = Context::new(cfg).unwrap();
|
|
|
|
match args.command {
|
|
GeoffreyApiCommand::Run => run_server(ctx).await,
|
|
GeoffreyApiCommand::CreateAdminToken(perms) => create_token(ctx, perms.permissions),
|
|
};
|
|
}
|