quoter/src/main.rs
2023-10-03 13:43:21 +03:00

115 lines
4.0 KiB
Rust

use actix_web::{web, App, HttpResponse, HttpServer, Responder, web::Bytes};
use redis::{Client, AsyncCommands};
use std::collections::HashMap;
use std::env;
use futures::StreamExt;
use tokio::sync::broadcast;
mod data;
async fn sse_handler(
token: web::Path<String>,
redis: web::Data<Client>,
) -> impl Responder {
let author_id = match data::get_auth_id(&token).await {
Ok(id) => id,
Err(e) => {
eprintln!("TOKEN check failed: {}", e);
return HttpResponse::Unauthorized().finish();
}
};
let mut con = match redis.get_async_connection().await {
Ok(con) => con,
Err(e) => {
eprintln!("Failed to get async connection: {}", e);
return HttpResponse::InternalServerError().finish();
}
};
let _ = match con.sadd::<&str, &i32, usize>("authors-online", &author_id).await {
Ok(_) => (),
Err(e) => {
eprintln!("Failed to add author to online list: {}", e);
return HttpResponse::InternalServerError().finish();
}
};
let chats: Vec<String> = match con.smembers::<String, Vec<String>>(format!("chats_by_author/{}", author_id)).await {
Ok(chats) => {
if chats.is_empty() {
match data::create_first_chat(author_id, &mut con).await {
Ok(chat) => chat,
Err(e) => {
eprintln!("Failed to create first chat: {}", e);
return HttpResponse::InternalServerError().finish();
}
}
} else {
chats
}
},
Err(e) => {
eprintln!("Failed to get chats by author: {}", e);
match data::create_first_chat(author_id, &mut con).await {
Ok(chat) => chat,
Err(e) => {
eprintln!("Failed to create first chat: {}", e);
return HttpResponse::InternalServerError().finish();
}
}
}
};
let (tx, mut rx) = broadcast::channel(100);
let _handle = tokio::spawn(async move {
let conn = redis.get_async_connection().await.expect("Failed to get async connection");
let mut pubsub = conn.into_pubsub();
pubsub.subscribe("new_follower").await.expect("Failed to subscribe to new_follower");
pubsub.subscribe("new_shout").await.expect("Failed to subscribe to new_shout");
pubsub.subscribe("new_reaction").await.expect("Failed to subscribe to new_reaction");
for chat_id in &chats {
let channel_name = format!("chat:{}", chat_id);
pubsub
.subscribe(channel_name.clone())
.await
.expect(&format!("Failed to subscribe to {}", channel_name));
}
while let Some(msg) = pubsub.on_message().next().await {
let payload: HashMap<String, String> = msg.get_payload().expect("Failed to get payload");
tx.clone().send(serde_json::to_string(&payload).expect("Failed to serialize payload")).expect("Failed to send payload");
}
});
let server_event = match rx.recv().await {
Ok(event) => event,
Err(e) => {
eprintln!("Failed to receive server event: {}", e);
return HttpResponse::InternalServerError().finish();
}
};
let server_event_stream = futures::stream::once(async move { Ok::<_, actix_web::Error>(Bytes::from(server_event)) });
HttpResponse::Ok()
.append_header(("content-type", "text/event-stream"))
.streaming(server_event_stream)
}
#[actix_web::main]
async fn main() -> std::io::Result<()> {
let redis_url = env::var("REDIS_URL").expect("REDIS_URL must be set");
let client = redis::Client::open(redis_url).expect("Failed to open Redis client");
HttpServer::new(move || {
App::new()
.app_data(web::Data::new(client.clone()))
.route("/presence/{token}", web::get().to(sse_handler))
})
.bind("127.0.0.1:8080")?
.run()
.await
}