Raven/osirose-new
SHA256
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects 6 Releases Wiki Activity

- chore: ran cargo fix on the codebase

Browse Source
This commit is contained in:
raven
2025-03-07 21:03:15 -05:00
parent 3b789d0fd4
commit b6f2d3f456
59 changed files with 1324 additions and 523 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
utils/src/consul_registration.rs
View File

@@ -2,8 +2,8 @@ use reqwest::Client;
use serde::Serialize;
use std::collections::HashMap;
use std::env;
use std::net::ToSocketAddrs;
use std::fs;
use std::net::ToSocketAddrs;
use std::path::Path;
use uuid::Uuid;
use warp::Filter;
@@ -52,8 +52,6 @@ pub fn get_or_generate_service_id(package_name: &str) -> String {
service_id
}
pub async fn register_service(
consul_url: &str,
service_id: &str,
@@ -64,7 +62,6 @@ pub async fn register_service(
mut meta: HashMap<String, String>,
health_check_url: &str,
) -> Result<(), Box<dyn std::error::Error>> {
meta.insert("version".to_string(), VERSION.to_string());
let registration = ConsulRegistration {
id: service_id.to_string(),
@@ -92,9 +89,13 @@ pub async fn register_service(
Ok(())
}
pub async fn deregister_service(consul_url: &str, service_id: &str) -> Result<(), Box<dyn std::error::Error>> {
pub async fn deregister_service(
consul_url: &str,
service_id: &str,
) -> Result<(), Box<dyn std::error::Error>> {
let client = Client::new();
let consul_deregister_url = format!("{}/v1/agent/service/deregister/{}", consul_url, service_id);
let consul_deregister_url =
format!("{}/v1/agent/service/deregister/{}", consul_url, service_id);
client
.put(&consul_deregister_url)
@@ -115,7 +116,14 @@ pub async fn start_health_check(service_address: &str) -> Result<(), Box<dyn std
.map(|| warp::reply::with_status("OK", warp::http::StatusCode::OK))
.with(log);
tokio::spawn(warp::serve(health_route).run(health_check_endpoint_addr.to_socket_addrs()?.next().unwrap()));
tokio::spawn(
warp::serve(health_route).run(
health_check_endpoint_addr
.to_socket_addrs()?
.next()
.unwrap(),
),
);
Ok(())
}
}

2
utils/src/lib.rs
View File

@@ -1,5 +1,5 @@
pub mod consul_registration;
pub mod service_discovery;
pub mod null_string;
pub mod redis_cache;
pub mod service_discovery;
pub mod signal_handler;

11
utils/src/null_string.rs
View File

@@ -1,7 +1,12 @@
use bincode::{Decode, Encode, de::Decoder, enc::Encoder, error::{DecodeError, EncodeError}};
use std::str;
use bincode::de::read::Reader;
use bincode::enc::write::Writer;
use bincode::{
de::Decoder,
enc::Encoder,
error::{DecodeError, EncodeError},
Decode, Encode,
};
use std::str;
#[derive(Debug, Clone, Default)]
pub struct NullTerminatedString(pub String);
@@ -21,7 +26,7 @@ impl Encode for NullTerminatedString {
}
}
impl Decode for NullTerminatedString {
impl<Context> Decode<Context> for NullTerminatedString {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let mut buffer = Vec::new();
let mut byte = [0u8; 1];

92
utils/src/redis_cache.rs
View File

@@ -23,7 +23,7 @@ pub trait Cache {
&self,
key: &String,
) -> Result<Option<T>, redis::RedisError>;
async fn delete(&mut self, key: &str) -> redis::RedisResult<()>;
}
@@ -34,7 +34,9 @@ pub struct RedisCache {
impl RedisCache {
pub fn new(redis_url: &str) -> Self {
let cfg = Config::from_url(redis_url);
let pool = cfg.create_pool(Some(Runtime::Tokio1)).expect("Failed to create Redis pool");
let pool = cfg
.create_pool(Some(Runtime::Tokio1))
.expect("Failed to create Redis pool");
RedisCache { pool }
}
}
@@ -47,20 +49,20 @@ impl Cache for RedisCache {
value: &T,
ttl: u64,
) -> Result<(), redis::RedisError> {
let mut conn = self.pool.get().await
.map_err(|err| {
redis::RedisError::from((
redis::ErrorKind::IoError,
"Failed to get Redis connection",
format!("{:?}", err),
))
})?;
let serialized_value = serde_json::to_string(value)
.map_err(|err| RedisError::from((
let mut conn = self.pool.get().await.map_err(|err| {
redis::RedisError::from((
redis::ErrorKind::IoError,
"Failed to get Redis connection",
format!("{:?}", err),
))
})?;
let serialized_value = serde_json::to_string(value).map_err(|err| {
RedisError::from((
redis::ErrorKind::IoError,
"Serialization error",
format!("Serialization error: {}", err),
)))?;
))
})?;
if ttl > 0 {
conn.set_ex(key, serialized_value, ttl).await
} else {
@@ -68,22 +70,25 @@ impl Cache for RedisCache {
}
}
async fn get<T: for<'de> Deserialize<'de> + Send + Sync>(&self, key: &String) -> Result<Option<T>, redis::RedisError> {
let mut conn = self.pool.get().await
.map_err(|err| {
redis::RedisError::from((
redis::ErrorKind::IoError,
"Failed to get Redis connection",
format!("{:?}", err),
))
})?;
async fn get<T: for<'de> Deserialize<'de> + Send + Sync>(
&self,
key: &String,
) -> Result<Option<T>, redis::RedisError> {
let mut conn = self.pool.get().await.map_err(|err| {
redis::RedisError::from((
redis::ErrorKind::IoError,
"Failed to get Redis connection",
format!("{:?}", err),
))
})?;
if let Some(serialized_value) = conn.get::<_, Option<String>>(key).await? {
let deserialized_value = serde_json::from_str(&serialized_value)
.map_err(|err| RedisError::from((
let deserialized_value = serde_json::from_str(&serialized_value).map_err(|err| {
RedisError::from((
redis::ErrorKind::IoError,
"Deserialization error",
format!("Deserialization error: {}", err),
)))?;
))
})?;
Ok(Some(deserialized_value))
} else {
Ok(None)
@@ -96,22 +101,22 @@ impl Cache for RedisCache {
value: Option<&T>,
ttl: Option<u64>,
) -> Result<(), redis::RedisError> {
let mut conn = self.pool.get().await
.map_err(|err| {
redis::RedisError::from((
redis::ErrorKind::IoError,
"Failed to get Redis connection",
format!("{:?}", err),
))
})?;
let mut conn = self.pool.get().await.map_err(|err| {
redis::RedisError::from((
redis::ErrorKind::IoError,
"Failed to get Redis connection",
format!("{:?}", err),
))
})?;
let serialized_value;
if value.is_some() {
serialized_value = serde_json::to_string(&value)
.map_err(|err| RedisError::from((
serialized_value = serde_json::to_string(&value).map_err(|err| {
RedisError::from((
redis::ErrorKind::IoError,
"Serialization error",
format!("Serialization error: {}", err),
)))?;
))
})?;
} else {
serialized_value = conn.get(key).await?;
}
@@ -123,14 +128,13 @@ impl Cache for RedisCache {
}
async fn delete(&mut self, key: &str) -> redis::RedisResult<()> {
let mut conn = self.pool.get().await
.map_err(|err| {
redis::RedisError::from((
redis::ErrorKind::IoError,
"Failed to get Redis connection",
format!("{:?}", err),
))
})?;
let mut conn = self.pool.get().await.map_err(|err| {
redis::RedisError::from((
redis::ErrorKind::IoError,
"Failed to get Redis connection",
format!("{:?}", err),
))
})?;
conn.del(key).await
}
}

24
utils/src/service_discovery.rs
View File

@@ -1,5 +1,5 @@
use std::collections::HashMap;
use serde::Deserialize;
use std::collections::HashMap;
#[derive(Debug, Deserialize)]
pub struct ServiceNode {
@@ -9,23 +9,24 @@ pub struct ServiceNode {
pub ServiceMeta: HashMap<String, String>,
}
pub async fn get_service_address(consul_url: &str, service_name: &str) -> Result<Vec<ServiceNode>, Box<dyn std::error::Error>> {
pub async fn get_service_address(
consul_url: &str,
service_name: &str,
) -> Result<Vec<ServiceNode>, Box<dyn std::error::Error>> {
let client = reqwest::Client::new();
let consul_service_url = format!("{}/v1/catalog/service/{}", consul_url, service_name);
let response = client
.get(&consul_service_url)
.send()
.await?;
let response = client.get(&consul_service_url).send().await?;
if !response.status().is_success() {
return Err(format!(
"Failed to fetch service nodes for '{}': {}",
service_name, response.status()
service_name,
response.status()
)
.into());
.into());
}
// Deserialize the response into a Vec<ServiceNode>
let nodes: Vec<ServiceNode> = response.json().await?;
@@ -48,9 +49,10 @@ async fn get_services_with_tag(
if !response.status().is_success() {
return Err(format!(
"Failed to fetch service nodes for '{}': {}",
service_name, response.status()
service_name,
response.status()
)
.into());
.into());
}
// Deserialize the response into a Vec<ServiceNode>

8
utils/src/signal_handler.rs
View File

@@ -16,13 +16,15 @@ async fn terminate_signal() {
#[cfg(unix)]
{
use tokio::signal::unix::{signal, SignalKind};
let mut sigterm = signal(SignalKind::terminate()).expect("Failed to set up SIGTERM handler");
let mut sigterm =
signal(SignalKind::terminate()).expect("Failed to set up SIGTERM handler");
sigterm.recv().await;
}
#[cfg(windows)]
{
let mut ctrlbreak = signal::windows::ctrl_break().expect("Failed to set up CTRL_BREAK handler");
let mut ctrlbreak =
signal::windows::ctrl_break().expect("Failed to set up CTRL_BREAK handler");
ctrlbreak.recv().await;
}
}
}