2022-04-25 00:02:14 +00:00
|
|
|
use crate::{
|
2022-04-25 23:51:13 +00:00
|
|
|
auth,
|
|
|
|
|
db::{User, UserId},
|
|
|
|
|
AppState, Error, Result,
|
2022-04-25 00:02:14 +00:00
|
|
|
};
|
|
|
|
|
use anyhow::anyhow;
|
2022-04-24 17:08:25 +00:00
|
|
|
use axum::{
|
|
|
|
|
body::Body,
|
2022-04-25 23:51:13 +00:00
|
|
|
extract::{Path, Query},
|
2022-04-26 02:05:09 +00:00
|
|
|
http::{self, Request, StatusCode},
|
|
|
|
|
middleware::{self, Next},
|
|
|
|
|
response::IntoResponse,
|
|
|
|
|
routing::{get, post, put},
|
|
|
|
|
Extension, Json, Router,
|
2022-04-24 17:08:25 +00:00
|
|
|
};
|
2022-04-25 23:51:13 +00:00
|
|
|
use serde::{Deserialize, Serialize};
|
2021-12-19 16:43:13 +00:00
|
|
|
use std::sync::Arc;
|
2022-04-26 02:05:09 +00:00
|
|
|
use tower::ServiceBuilder;
|
2022-05-02 13:17:43 +00:00
|
|
|
use tracing::instrument;
|
2022-04-24 16:45:20 +00:00
|
|
|
|
2022-04-26 02:05:09 +00:00
|
|
|
pub fn routes(state: Arc<AppState>) -> Router<Body> {
|
|
|
|
|
Router::new()
|
|
|
|
|
.route("/users", get(get_users).post(create_user))
|
2022-04-26 17:15:41 +00:00
|
|
|
.route(
|
|
|
|
|
"/users/:id",
|
|
|
|
|
put(update_user).delete(destroy_user).get(get_user),
|
|
|
|
|
)
|
|
|
|
|
.route("/users/:id/access_tokens", post(create_access_token))
|
2022-05-02 13:17:43 +00:00
|
|
|
.route("/crash", post(trace_crash))
|
2022-04-26 02:05:09 +00:00
|
|
|
.layer(
|
|
|
|
|
ServiceBuilder::new()
|
|
|
|
|
.layer(Extension(state))
|
|
|
|
|
.layer(middleware::from_fn(validate_api_token)),
|
|
|
|
|
)
|
2022-04-26 02:21:43 +00:00
|
|
|
// TODO: Compression on API routes?
|
2022-04-24 16:45:20 +00:00
|
|
|
}
|
|
|
|
|
|
2022-04-26 02:05:09 +00:00
|
|
|
pub async fn validate_api_token<B>(req: Request<B>, next: Next<B>) -> impl IntoResponse {
|
2022-04-26 02:10:14 +00:00
|
|
|
let token = req
|
2022-04-26 02:05:09 +00:00
|
|
|
.headers()
|
|
|
|
|
.get(http::header::AUTHORIZATION)
|
|
|
|
|
.and_then(|header| header.to_str().ok())
|
|
|
|
|
.ok_or_else(|| {
|
|
|
|
|
Error::Http(
|
|
|
|
|
StatusCode::BAD_REQUEST,
|
|
|
|
|
"missing authorization header".to_string(),
|
|
|
|
|
)
|
2022-04-26 02:10:14 +00:00
|
|
|
})?
|
|
|
|
|
.strip_prefix("token ")
|
|
|
|
|
.ok_or_else(|| {
|
|
|
|
|
Error::Http(
|
|
|
|
|
StatusCode::BAD_REQUEST,
|
|
|
|
|
"invalid authorization header".to_string(),
|
|
|
|
|
)
|
2022-04-26 02:05:09 +00:00
|
|
|
})?;
|
|
|
|
|
|
2022-04-26 02:10:14 +00:00
|
|
|
let state = req.extensions().get::<Arc<AppState>>().unwrap();
|
|
|
|
|
|
|
|
|
|
if token != state.api_token {
|
|
|
|
|
Err(Error::Http(
|
|
|
|
|
StatusCode::UNAUTHORIZED,
|
|
|
|
|
"invalid authorization token".to_string(),
|
|
|
|
|
))?
|
|
|
|
|
}
|
|
|
|
|
|
2022-04-26 02:05:09 +00:00
|
|
|
Ok::<_, Error>(next.run(req).await)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async fn get_users(Extension(app): Extension<Arc<AppState>>) -> Result<Json<Vec<User>>> {
|
2022-04-25 00:02:14 +00:00
|
|
|
let users = app.db.get_all_users().await?;
|
|
|
|
|
Ok(Json(users))
|
2022-04-24 17:08:25 +00:00
|
|
|
}
|
|
|
|
|
|
2022-04-25 00:02:14 +00:00
|
|
|
#[derive(Deserialize)]
|
2022-04-25 23:51:13 +00:00
|
|
|
struct CreateUserParams {
|
2022-04-25 00:02:14 +00:00
|
|
|
github_login: String,
|
|
|
|
|
admin: bool,
|
|
|
|
|
}
|
2022-04-22 19:33:19 +00:00
|
|
|
|
2022-04-25 23:51:13 +00:00
|
|
|
async fn create_user(
|
|
|
|
|
Json(params): Json<CreateUserParams>,
|
2022-04-26 02:05:09 +00:00
|
|
|
Extension(app): Extension<Arc<AppState>>,
|
2022-04-25 23:51:13 +00:00
|
|
|
) -> Result<Json<User>> {
|
2022-04-25 00:02:14 +00:00
|
|
|
let user_id = app
|
|
|
|
|
.db
|
|
|
|
|
.create_user(¶ms.github_login, params.admin)
|
|
|
|
|
.await?;
|
2022-04-22 19:33:19 +00:00
|
|
|
|
2022-04-25 00:02:14 +00:00
|
|
|
let user = app
|
|
|
|
|
.db
|
|
|
|
|
.get_user_by_id(user_id)
|
|
|
|
|
.await?
|
|
|
|
|
.ok_or_else(|| anyhow!("couldn't find the user we just created"))?;
|
2022-04-22 19:33:19 +00:00
|
|
|
|
2022-04-25 00:02:14 +00:00
|
|
|
Ok(Json(user))
|
|
|
|
|
}
|
2022-04-22 19:33:19 +00:00
|
|
|
|
2022-04-25 00:02:14 +00:00
|
|
|
#[derive(Deserialize)]
|
2022-04-25 23:51:13 +00:00
|
|
|
struct UpdateUserParams {
|
2022-04-25 00:02:14 +00:00
|
|
|
admin: bool,
|
|
|
|
|
}
|
2022-04-22 19:33:19 +00:00
|
|
|
|
2022-04-25 00:02:14 +00:00
|
|
|
async fn update_user(
|
|
|
|
|
Path(user_id): Path<i32>,
|
2022-04-25 23:51:13 +00:00
|
|
|
Json(params): Json<UpdateUserParams>,
|
2022-04-26 02:05:09 +00:00
|
|
|
Extension(app): Extension<Arc<AppState>>,
|
2022-04-25 23:51:13 +00:00
|
|
|
) -> Result<()> {
|
|
|
|
|
app.db
|
|
|
|
|
.set_user_is_admin(UserId(user_id), params.admin)
|
|
|
|
|
.await?;
|
2022-04-25 00:02:14 +00:00
|
|
|
Ok(())
|
|
|
|
|
}
|
2022-04-22 19:33:19 +00:00
|
|
|
|
2022-04-26 02:05:09 +00:00
|
|
|
async fn destroy_user(
|
|
|
|
|
Path(user_id): Path<i32>,
|
|
|
|
|
Extension(app): Extension<Arc<AppState>>,
|
|
|
|
|
) -> Result<()> {
|
2022-04-25 23:51:13 +00:00
|
|
|
app.db.destroy_user(UserId(user_id)).await?;
|
|
|
|
|
Ok(())
|
|
|
|
|
}
|
2022-04-22 19:33:19 +00:00
|
|
|
|
2022-04-26 02:05:09 +00:00
|
|
|
async fn get_user(
|
|
|
|
|
Path(login): Path<String>,
|
|
|
|
|
Extension(app): Extension<Arc<AppState>>,
|
|
|
|
|
) -> Result<Json<User>> {
|
2022-04-25 23:51:13 +00:00
|
|
|
let user = app
|
|
|
|
|
.db
|
|
|
|
|
.get_user_by_github_login(&login)
|
|
|
|
|
.await?
|
|
|
|
|
.ok_or_else(|| anyhow!("user not found"))?;
|
|
|
|
|
Ok(Json(user))
|
|
|
|
|
}
|
2022-04-22 19:33:19 +00:00
|
|
|
|
2022-05-02 13:17:43 +00:00
|
|
|
#[derive(Debug, Deserialize)]
|
|
|
|
|
struct Crash {
|
|
|
|
|
version: String,
|
|
|
|
|
text: String,
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-02 13:34:05 +00:00
|
|
|
#[instrument(skip(crash))]
|
2022-05-02 13:17:43 +00:00
|
|
|
async fn trace_crash(crash: Json<Crash>) -> Result<()> {
|
|
|
|
|
tracing::error!(version = %crash.version, text = %crash.text, "crash report");
|
|
|
|
|
Ok(())
|
|
|
|
|
}
|
|
|
|
|
|
2022-04-25 23:51:13 +00:00
|
|
|
#[derive(Deserialize)]
|
|
|
|
|
struct CreateAccessTokenQueryParams {
|
|
|
|
|
public_key: String,
|
|
|
|
|
impersonate: Option<String>,
|
|
|
|
|
}
|
2022-04-22 19:33:19 +00:00
|
|
|
|
2022-04-25 23:51:13 +00:00
|
|
|
#[derive(Serialize)]
|
|
|
|
|
struct CreateAccessTokenResponse {
|
|
|
|
|
user_id: UserId,
|
|
|
|
|
encrypted_access_token: String,
|
|
|
|
|
}
|
2022-04-22 19:33:19 +00:00
|
|
|
|
2022-04-25 23:51:13 +00:00
|
|
|
async fn create_access_token(
|
|
|
|
|
Path(login): Path<String>,
|
|
|
|
|
Query(params): Query<CreateAccessTokenQueryParams>,
|
2022-04-26 02:05:09 +00:00
|
|
|
Extension(app): Extension<Arc<AppState>>,
|
2022-04-25 23:51:13 +00:00
|
|
|
) -> Result<Json<CreateAccessTokenResponse>> {
|
|
|
|
|
// request.require_token().await?;
|
2022-04-22 19:33:19 +00:00
|
|
|
|
2022-04-25 23:51:13 +00:00
|
|
|
let user = app
|
|
|
|
|
.db
|
|
|
|
|
.get_user_by_github_login(&login)
|
|
|
|
|
.await?
|
|
|
|
|
.ok_or_else(|| anyhow!("user not found"))?;
|
|
|
|
|
|
|
|
|
|
let mut user_id = user.id;
|
|
|
|
|
if let Some(impersonate) = params.impersonate {
|
|
|
|
|
if user.admin {
|
|
|
|
|
if let Some(impersonated_user) = app.db.get_user_by_github_login(&impersonate).await? {
|
|
|
|
|
user_id = impersonated_user.id;
|
|
|
|
|
} else {
|
|
|
|
|
return Err(Error::Http(
|
|
|
|
|
StatusCode::UNPROCESSABLE_ENTITY,
|
|
|
|
|
format!("user {impersonate} does not exist"),
|
|
|
|
|
));
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
return Err(Error::Http(
|
|
|
|
|
StatusCode::UNAUTHORIZED,
|
|
|
|
|
format!("you do not have permission to impersonate other users"),
|
|
|
|
|
));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let access_token = auth::create_access_token(app.db.as_ref(), user_id).await?;
|
|
|
|
|
let encrypted_access_token =
|
|
|
|
|
auth::encrypt_access_token(&access_token, params.public_key.clone())?;
|
|
|
|
|
|
|
|
|
|
Ok(Json(CreateAccessTokenResponse {
|
|
|
|
|
user_id,
|
|
|
|
|
encrypted_access_token,
|
|
|
|
|
}))
|
|
|
|
|
}
|
