ComputerSurge/komodo
3
0
Fork 0
forked from github-starred/komodo
Code Pull Requests 1 Actions Packages Releases 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

5
Cargo.lock generated
View File

@@ -2290,6 +2290,7 @@ dependencies = [
"reqwest",
"resolver_api",
"serde_json",
"serror",
]
[[package]]
@@ -2853,9 +2854,9 @@ dependencies = [
[[package]]
name = "serror"
version = "0.1.1"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "64ace3cd0543abaa9a05a1c4b5219c832aebf2a011ae31da4cf2b0d9808d6aea"
checksum = "6bc462876e265831d80297a3898a173e3d5c72a1501dec9234423de2d25ac89c"
dependencies = [
"anyhow",
"serde",

2
Cargo.toml
View File

@@ -28,7 +28,7 @@ make_option = "0.1.7"
resolver_api = "0.1.6"
parse_csl = "0.1.0"
mungos = "0.4.19"
serror = "0.1.1"
serror = "0.1.3"
svi = "0.1.4"
# external
tokio = { version = "1.32.0", features = ["full"] }

8
bin/core/src/auth/mod.rs
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))
},
),
);

14
bin/core/src/helpers/mod.rs
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)
}
}

4
bin/core/src/main.rs
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?;

16
bin/core/src/requests/execute/mod.rs
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))
},
),
)

13
bin/core/src/requests/read/mod.rs
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))
},
),
)

16
bin/core/src/requests/write/mod.rs
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))
},
),
)

2
bin/migrator/src/main.rs
View File

@@ -1,3 +1,5 @@
#![allow(unused)]
use crate::config::State;
#[macro_use]

10
bin/periphery/src/helpers/mod.rs
View File

@@ -1,7 +1,9 @@
use anyhow::anyhow;
use async_timing_util::unix_timestamp_ms;
use axum::{http::StatusCode, TypedHeader, headers::ContentType};
use monitor_types::entities::update::Log;
use run_command::{async_run_command, CommandOutput};
use serror::serialize_error_pretty;
use crate::state::State;
@@ -59,3 +61,11 @@ pub fn output_into_log(stage: &str, command: String, start_ts: i64, output: Comm
end_ts: unix_timestamp_ms() as i64,
}
}
pub fn into_response_error(e: anyhow::Error) -> (StatusCode, TypedHeader<ContentType>, String) {
(
StatusCode::INTERNAL_SERVER_ERROR,
TypedHeader(ContentType::json()),
serialize_error_pretty(e),
)
}

13
bin/periphery/src/main.rs
View File

@@ -10,7 +10,6 @@ use axum::{
};
use resolver_api::Resolver;
use serror::serialize_error;
use termination_signal::tokio::immediate_term_handle;
use uuid::Uuid;
@@ -23,6 +22,10 @@ mod state;
use requests::PeripheryRequest;
use state::State;
use crate::helpers::into_response_error;
type ResponseResult<T> = Result<T, (StatusCode, TypedHeader<ContentType>, String)>;
async fn app() -> anyhow::Result<()> {
let state = State::load().await?;
@@ -44,17 +47,15 @@ async fn app() -> anyhow::Result<()> {
if let Err(e) = &res {
debug!("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 {
debug!("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!("request {req_id} | resolve time: {elapsed:?}");
debug!("request {req_id} RESPONSE: {res}");
Result::<_, (StatusCode, String)>::Ok((TypedHeader(ContentType::json()), res))
ResponseResult::Ok((TypedHeader(ContentType::json()), res))
},
),
)

3
lib/periphery_client/Cargo.toml
View File

@@ -14,4 +14,5 @@ reqwest.workspace = true
anyhow.workspace = true
serde_json.workspace = true
log.workspace = true
resolver_api.workspace = true
resolver_api.workspace = true
serror.workspace = true

11
lib/periphery_client/src/lib.rs
View File

@@ -3,12 +3,13 @@ extern crate log;
use std::time::Duration;
use anyhow::{anyhow, Context};
use anyhow::Context;
use reqwest::StatusCode;
use resolver_api::HasResponse;
use serde_json::json;
pub use monitor_periphery::requests;
use serror::deserialize_error;
pub struct PeripheryClient {
reqwest: reqwest::Client,
@@ -54,7 +55,7 @@ impl PeripheryClient {
if let Some(timeout) = timeout {
req = req.timeout(timeout);
}
let res = req.send().await?;
let res = req.send().await.context("failed at request to periphery")?;
let status = res.status();
debug!("got response | type: {req_type} | {status} | body: {res:?}",);
if status == StatusCode::OK {
@@ -66,7 +67,11 @@ impl PeripheryClient {
.text()
.await
.context("failed to convert response to text")?;
Err(anyhow!("request failed | {status} | {text}"))
let error =
deserialize_error(text).context(format!("request to periphery failed | {status}"));
Err(error)
}
}
}