starred/komodo
1
0
Fork 0
mirror of https://github.com/moghtech/komodo.git synced 2026-09-21 00:01:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

properly forward periphery trace into core error trace

Browse Source
This commit is contained in:
mbecker20
2023-08-27 13:59:59 -04:00
parent 8f57af0667
commit d2a706fd9d
13 changed files with 70 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bin/core/src/auth/mod.rs
+4 -4
View File
@@ -7,7 +7,6 @@ use axum::{
use rand::{distributions::Alphanumeric, thread_rng, Rng};
use reqwest::StatusCode;
use resolver_api::Resolver;
use serror::serialize_error;
use uuid::Uuid;
mod github;
@@ -17,8 +16,10 @@ mod local;
mod secret;
use crate::{
helpers::into_response_error,
requests::auth::AuthRequest,
state::{State, StateExtension},
ResponseResult,
};
pub use self::jwt::{InnerRequestUser, JwtClient, RequestUser, RequestUserExtension};
@@ -53,12 +54,11 @@ pub fn router(state: &State) -> Router {
if let Err(e) = &res {
info!("/auth request {req_id} | ERROR: {e:?}");
}
let res =
res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
let res = res.map_err(into_response_error)?;
let elapsed = timer.elapsed();
info!("/auth request {req_id} | resolve time: {elapsed:?}");
debug!("/auth request {req_id} | RESPONSE: {res}");
Result::<_, (StatusCode, String)>::Ok((TypedHeader(ContentType::json()), res))
ResponseResult::Ok((TypedHeader(ContentType::json()), res))
},
),
);
bin/core/src/helpers/mod.rs
+12 -2
View File
@@ -1,6 +1,7 @@
use std::time::Duration;
use anyhow::{anyhow, Context};
use axum::{headers::ContentType, http::StatusCode, TypedHeader};
use monitor_types::{
entities::{
deployment::{Deployment, DockerContainerState},
@@ -15,6 +16,7 @@ use monitor_types::{
use mungos::mongodb::bson::{doc, to_bson};
use periphery_client::{requests, PeripheryClient};
use rand::{thread_rng, Rng};
use serror::serialize_error_pretty;
use crate::{auth::RequestUser, state::State};
@@ -57,6 +59,14 @@ pub fn make_update(
}
}
pub fn into_response_error(e: anyhow::Error) -> (StatusCode, TypedHeader<ContentType>, String) {
(
StatusCode::INTERNAL_SERVER_ERROR,
TypedHeader(ContentType::json()),
serialize_error_pretty(e),
)
}
impl State {
pub async fn get_user(&self, user_id: &str) -> anyhow::Result<User> {
self.db
@@ -218,11 +228,11 @@ impl State {
pub fn periphery_client(&self, server: &Server) -> anyhow::Result<PeripheryClient> {
if !server.config.enabled {
return Err(anyhow!("server not enabled"))
return Err(anyhow!("server not enabled"));
}
let client = PeripheryClient::new(&server.config.address, &self.config.passkey);
Ok(client)
}
}
bin/core/src/main.rs
+3 -1
View File
@@ -1,7 +1,7 @@
#[macro_use]
extern crate log;
use axum::{Extension, Router};
use axum::{Extension, Router, http::StatusCode, TypedHeader, headers::ContentType};
use termination_signal::tokio::immediate_term_handle;
use tower_http::cors::{Any, CorsLayer};
@@ -15,6 +15,8 @@ mod requests;
mod state;
mod ws;
type ResponseResult<T> = Result<T, (StatusCode, TypedHeader<ContentType>, String)>;
async fn app() -> anyhow::Result<()> {
let state = state::State::load().await?;
bin/core/src/requests/execute/mod.rs
+6 -10
View File
@@ -1,20 +1,18 @@
use std::time::Instant;
use anyhow::Context;
use axum::{
headers::ContentType, http::StatusCode, middleware, routing::post, Extension, Json, Router,
TypedHeader,
};
use axum::{headers::ContentType, middleware, routing::post, Extension, Json, Router, TypedHeader};
use monitor_types::requests::execute::*;
use resolver_api::{derive::Resolver, Resolve, Resolver};
use serde::{Deserialize, Serialize};
use serror::serialize_error;
use typeshare::typeshare;
use uuid::Uuid;
use crate::{
auth::{auth_request, RequestUser, RequestUserExtension},
helpers::into_response_error,
state::{State, StateExtension},
ResponseResult,
};
mod build;
@@ -68,16 +66,14 @@ pub fn router() -> Router {
if let Err(e) = &res {
info!("/execute request {req_id} SPAWN ERROR: {e:#?}");
}
let res =
res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
let res = res.map_err(into_response_error)?;
if let Err(e) = &res {
info!("/execute request {req_id} ERROR: {e:#?}");
}
let res =
res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
let res = res.map_err(into_response_error)?;
let elapsed = timer.elapsed();
info!("/execute request {req_id} | resolve time: {elapsed:?}");
Result::<_, (StatusCode, String)>::Ok((TypedHeader(ContentType::json()), res))
ResponseResult::Ok((TypedHeader(ContentType::json()), res))
},
),
)
bin/core/src/requests/read/mod.rs
+6 -7
View File
@@ -2,19 +2,20 @@ use std::time::Instant;
use async_trait::async_trait;
use axum::{
headers::ContentType, http::StatusCode, middleware, routing::post, Extension, Json, Router,
headers::ContentType, middleware, routing::post, Extension, Json, Router,
TypedHeader,
};
use monitor_types::requests::read::*;
use resolver_api::{derive::Resolver, Resolve, ResolveToString, Resolver};
use serde::{Deserialize, Serialize};
use serror::serialize_error;
use typeshare::typeshare;
use uuid::Uuid;
use crate::{
auth::{auth_request, RequestUser, RequestUserExtension},
helpers::into_response_error,
state::{State, StateExtension},
ResponseResult,
};
mod alert;
@@ -135,16 +136,14 @@ pub fn router() -> Router {
"/read request {req_id} | user: {} ({}) | {request:?}",
user.username, user.id
);
let res = state
.resolve_request(request, user)
.await;
let res = state.resolve_request(request, user).await;
if let Err(e) = &res {
warn!("/read request {req_id} ERROR: {e:#?}");
}
let res = res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
let res = res.map_err(into_response_error)?;
let elapsed = timer.elapsed();
debug!("/read request {req_id} | resolve time: {elapsed:?}");
Result::<_, (StatusCode, String)>::Ok((TypedHeader(ContentType::json()), res))
ResponseResult::Ok((TypedHeader(ContentType::json()), res))
},
),
)
bin/core/src/requests/write/mod.rs
+6 -10
View File
@@ -1,20 +1,18 @@
use std::time::Instant;
use anyhow::Context;
use axum::{
headers::ContentType, http::StatusCode, middleware, routing::post, Extension, Json, Router,
TypedHeader,
};
use axum::{headers::ContentType, middleware, routing::post, Extension, Json, Router, TypedHeader};
use monitor_types::requests::write::*;
use resolver_api::{derive::Resolver, Resolve, Resolver};
use serde::{Deserialize, Serialize};
use serror::serialize_error;
use typeshare::typeshare;
use uuid::Uuid;
use crate::{
auth::{auth_request, RequestUser, RequestUserExtension},
helpers::into_response_error,
state::{State, StateExtension},
ResponseResult,
};
mod alerter;
@@ -118,16 +116,14 @@ pub fn router() -> Router {
if let Err(e) = &res {
info!("/write request {req_id} SPAWN ERROR: {e:#?}");
}
let res =
res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
let res = res.map_err(into_response_error)?;
if let Err(e) = &res {
info!("/write request {req_id} ERROR: {e:#?}");
}
let res =
res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
let res = res.map_err(into_response_error)?;
let elapsed = timer.elapsed();
info!("/write request {req_id} | resolve time: {elapsed:?}");
Result::<_, (StatusCode, String)>::Ok((TypedHeader(ContentType::json()), res))
ResponseResult::Ok((TypedHeader(ContentType::json()), res))
},
),
)