discours.io/quoter
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ready-to-test

Browse Source
This commit is contained in:
Tony Rewin
2023-10-03 16:29:31 +03:00
parent 238a8406da
commit caa659b2c7
5 changed files with 115 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
src/data.rs
View File

@@ -1,35 +1,8 @@
use reqwest::Client as HTTPClient;
use serde::{Serialize, Deserialize};
use serde_json::Value;
use std::collections::HashMap;
use std::error::Error;
use std::env;
use uuid::Uuid;
use chrono::Utc;
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
enum PayloadKind {
NewMessage,
NewFollower,
NewShout,
NewApproval,
NewComment,
NewRate,
}
#[derive(Debug, Serialize, Deserialize)]
struct Payload {
chat_id: Option<String>,
shout_id: Option<i32>,
author_id: Option<i32>,
topic_id: Option<i32>,
reaction_id: Option<i32>,
community_id: Option<i32>,
kind: PayloadKind,
body: String,
}
pub async fn get_auth_id(token: &str) -> Result<i32, Box<dyn Error>> {
let api_base = env::var("API_BASE")?;
@@ -51,33 +24,69 @@ pub async fn get_auth_id(token: &str) -> Result<i32, Box<dyn Error>> {
Ok(id)
}
pub async fn create_first_chat(author_id: i32, con: &mut redis::aio::Connection) -> Result<Vec<String>, Box<dyn Error>> {
let chat_id = Uuid::new_v4().to_string();
let members = vec![author_id.to_string(), "1".to_string()];
let timestamp = Utc::now().timestamp();
let chat = serde_json::json!({
"id": chat_id.clone(),
"admins": members.clone(),
"members": members.clone(),
"title": "",
"createdBy": author_id,
"createdAt": timestamp,
"updatedAt": timestamp,
});
let _: () = redis::pipe()
.atomic()
.cmd("SADD")
.arg(format!("chats_by_author/{}", author_id))
.arg(&chat_id)
.ignore()
.set(format!("chats/{}", chat_id), chat.to_string())
.ignore()
.set(format!("chats/{}/next_message_id", chat_id), "0")
.ignore()
.query_async(con)
async fn get_shout_followers(shout_id: &str) -> Result<Vec<i32>, Box<dyn Error>> {
let api_base = env::var("API_BASE")?;
let gql = format!(r#"
query {{
shoutFollowers(shout: "{}") {{
follower {{
id
}}
}}
}}
"#, shout_id);
let client = reqwest::Client::new();
let response = client
.post(&api_base)
.body(gql)
.send()
.await?;
Ok(vec![chat_id])
let response_body: serde_json::Value = response.json().await?;
let ids: Vec<i32> = response_body["data"]["shoutFollowers"]
.as_array()
.ok_or("Failed to parse follower array")?
.iter()
.filter_map(|f| f["follower"]["id"].as_i64().map(|id| id as i32))
.collect();
Ok(ids)
}
pub async fn is_fitting(listener_id: i32, payload: HashMap<String, String>) -> Result<bool, &'static str> {
match payload.get("kind") {
Some(kind) => {
match kind.as_str() {
"new_follower" => {
// payload is AuthorFollower
Ok(payload.get("author").unwrap().to_string() == listener_id.to_string())
},
"new_reaction" => {
// payload is Reaction
let shout_id = payload.get("shout").unwrap();
let recipients = get_shout_followers(shout_id).await.unwrap();
Ok(recipients.contains(&listener_id))
},
"new_shout" => {
// payload is Shout
// TODO: check all community subscribers if no then
// check all topics subscribers if no then
// check all authors subscribers
Ok(true)
},
"new_message" => {
// payload is Chat
let members_str = payload.get("members").unwrap();
let members = serde_json::from_str::<Vec<String>>(members_str).unwrap();
Ok(members.contains(&listener_id.to_string()))
},
_ => Err("Invalid kind"),
}
},
None => Err("No kind provided"),
}
}

112
src/main.rs
View File

@@ -1,113 +1,81 @@
use actix_web::{web, App, HttpResponse, HttpServer, Responder, web::Bytes};
use actix_web::{web, App, HttpResponse, HttpServer, web::Bytes};
use redis::{Client, AsyncCommands};
use std::collections::HashMap;
use std::env;
use futures::StreamExt;
use tokio::sync::broadcast;
use actix_web::error::{ErrorUnauthorized, ErrorInternalServerError as ServerError};
mod data;
async fn sse_handler(
token: web::Path<String>,
redis: web::Data<Client>,
) -> impl Responder {
) -> Result<HttpResponse, actix_web::Error> {
let listener_id = data::get_auth_id(&token).await.map_err(|e| {
eprintln!("TOKEN check failed: {}", e);
ErrorUnauthorized("Unauthorized")
})?;
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 = redis.get_async_connection().await.map_err(|e| {
eprintln!("Failed to get async connection: {}", e);
ServerError("Internal Server Error")
})?;
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();
}
};
con.sadd::<&str, &i32, usize>("authors-online", &listener_id).await.map_err(|e| {
eprintln!("Failed to add author to online list: {}", e);
ServerError("Internal Server Error")
})?;
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 chats: Vec<String> = con.smembers::<String, Vec<String>>(format!("chats_by_author/{}", listener_id)).await.map_err(|e| {
eprintln!("Failed to get chats by author: {}", e);
ServerError("Internal Server Error")
})?;
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 conn = redis.get_async_connection().await.unwrap();
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");
pubsub.subscribe("new_follower").await.unwrap();
pubsub.subscribe("new_shout").await.unwrap();
pubsub.subscribe("new_reaction").await.unwrap();
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));
pubsub.subscribe(&channel_name).await.unwrap();
}
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 payload: HashMap<String, String> = msg.get_payload().unwrap();
if data::is_fitting(listener_id, payload.clone()).await.is_ok() {
let _ = tx.send(serde_json::to_string(&payload).unwrap());
};
}
});
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 = rx.recv().await.map_err(|e| {
eprintln!("Failed to receive server event: {}", e);
ServerError("Internal Server Error")
})?;
let server_event_stream = futures::stream::once(async move { Ok::<_, actix_web::Error>(Bytes::from(server_event)) });
HttpResponse::Ok()
Ok(HttpResponse::Ok()
.append_header(("content-type", "text/event-stream"))
.streaming(server_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");
let redis_url = env::var("REDIS_URL").unwrap_or_else(|_| String::from("redis://127.0.0.1/"));
let client = redis::Client::open(redis_url).unwrap();
HttpServer::new(move || {
App::new()
.app_data(web::Data::new(client.clone()))
.route("/presence/{token}", web::get().to(sse_handler))
.route("/connect", web::get().to(sse_handler))
.route("/disconnect", web::get().to(sse_handler))
})
.bind("127.0.0.1:8080")?
.run()