zhenyi
821537186e
- Reorganized import statements in adapter tests for better readability - Replaced or_insert_with(Vec::new) with or_default() in test closures - Updated Cargo.lock with new dependency versions and checksums - Added TLS features to tonic dependency configuration - Included sqlx, chrono, and uuid dependencies with specific features - Added jsonwebtoken and arc-swap as project dependencies - Reformatted assertion statements to comply with line length limits - Adjusted base64 import order in engine codec module - Updated protobuf include statement formatting
99 lines
3.0 KiB
Rust
99 lines
3.0 KiB
Rust
use async_trait::async_trait;
|
|
use fred::clients::{Client, SubscriberClient};
|
|
use fred::interfaces::{ClientLike, EventInterface, PubsubInterface};
|
|
use fred::prelude::*;
|
|
use tokio::sync::mpsc;
|
|
|
|
use crate::socket::message_bus::{MessageBus, MessageBusError};
|
|
|
|
pub struct RedisMessageBus {
|
|
client: Client,
|
|
subscriber: SubscriberClient,
|
|
}
|
|
|
|
impl RedisMessageBus {
|
|
pub async fn new(redis_url: &str) -> Result<Self, MessageBusError> {
|
|
let config =
|
|
Config::from_url(redis_url).map_err(|e| MessageBusError::Redis(e.to_string()))?;
|
|
|
|
let client = Client::new(config.clone(), None, None, None);
|
|
let subscriber = SubscriberClient::new(config, None, None, None);
|
|
|
|
// connect() starts the connection task; result is checked by wait_for_connect()
|
|
let _ = client.connect().await;
|
|
let _ = subscriber.connect().await;
|
|
|
|
client
|
|
.wait_for_connect()
|
|
.await
|
|
.map_err(|e| MessageBusError::Redis(e.to_string()))?;
|
|
subscriber
|
|
.wait_for_connect()
|
|
.await
|
|
.map_err(|e| MessageBusError::Redis(e.to_string()))?;
|
|
|
|
Ok(Self { client, subscriber })
|
|
}
|
|
|
|
pub fn client(&self) -> &Client {
|
|
&self.client
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl MessageBus for RedisMessageBus {
|
|
async fn publish(&self, channel: &str, message: &[u8]) -> Result<(), MessageBusError> {
|
|
self.client
|
|
.publish::<(), _, Vec<u8>>(channel, message.to_vec())
|
|
.await
|
|
.map_err(|e| MessageBusError::Redis(e.to_string()))?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn subscribe(&self, channel: &str) -> Result<mpsc::Receiver<Vec<u8>>, MessageBusError> {
|
|
let (tx, rx) = mpsc::channel::<Vec<u8>>(256);
|
|
|
|
self.subscriber
|
|
.subscribe(channel.to_string())
|
|
.await
|
|
.map_err(|e| MessageBusError::Redis(e.to_string()))?;
|
|
|
|
let subscriber = self.subscriber.clone();
|
|
let channel_owned = channel.to_string();
|
|
let mut message_rx = subscriber.message_rx();
|
|
|
|
tokio::spawn(async move {
|
|
while let Ok(message) = message_rx.recv().await {
|
|
if message.channel == channel_owned {
|
|
let data: Vec<u8> = FromValue::from_value(message.value).unwrap_or_default();
|
|
if tx.send(data).await.is_err() {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
Ok(rx)
|
|
}
|
|
|
|
async fn unsubscribe(&self, channel: &str) -> Result<(), MessageBusError> {
|
|
self.subscriber
|
|
.unsubscribe(channel.to_string())
|
|
.await
|
|
.map_err(|e| MessageBusError::Redis(e.to_string()))?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn close(&self) -> Result<(), MessageBusError> {
|
|
self.client
|
|
.quit()
|
|
.await
|
|
.map_err(|e| MessageBusError::Redis(e.to_string()))?;
|
|
self.subscriber
|
|
.quit()
|
|
.await
|
|
.map_err(|e| MessageBusError::Redis(e.to_string()))?;
|
|
Ok(())
|
|
}
|
|
}
|