diff --git a/Cargo.lock b/Cargo.lock index cf28212e13..4f7deb3082 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1019,12 +1019,16 @@ dependencies = [ [[package]] name = "combine" -version = "4.5.2" +version = "4.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cc4369b5e4c0cddf64ad8981c0111e7df4f7078f4d6ba98fb31f2e17c4c57b7e" +checksum = "50b727aacc797f9fc28e355d21f34709ac4fc9adecfe470ad07b8f4464f53062" dependencies = [ "bytes 1.0.1", + "futures-core", "memchr", + "pin-project-lite 0.2.6", + "tokio 1.13.0", + "tokio-util 0.6.9", ] [[package]] @@ -3005,7 +3009,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0a32cb439c4e89c1e6415e5b3b23d9d8cc6dc1bf5a8cade19adbd5418de803be" dependencies = [ "async-trait", - "combine 4.5.2", + "combine 4.6.3", "dtoa", "itoa", "percent-encoding 2.1.0", @@ -3013,6 +3017,26 @@ dependencies = [ "url 2.2.2", ] +[[package]] +name = "redis" +version = "0.21.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a80b5f38d7f5a020856a0e16e40a9cfabf88ae8f0e4c2dcd8a3114c1e470852" +dependencies = [ + "async-trait", + "bytes 1.0.1", + "combine 4.6.3", + "dtoa", + "futures-util", + "itoa", + "percent-encoding 2.1.0", + "pin-project-lite 0.2.6", + "sha1", + "tokio 1.13.0", + "tokio-util 0.6.9", + "url 2.2.2", +] + [[package]] name = "redis_common" version = "0.0.1" @@ -4762,6 +4786,7 @@ dependencies = [ "pulldown-cmark", "r2d2_redis", "rand 0.8.4", + "redis 0.21.5", "redis_common", "regex", "reqwest", diff --git a/crates/service/websocket_gateway/Cargo.toml b/crates/service/websocket_gateway/Cargo.toml index e7940c4dde..f3debcbe34 100644 --- a/crates/service/websocket_gateway/Cargo.toml +++ b/crates/service/websocket_gateway/Cargo.toml @@ -63,6 +63,7 @@ sqlx = { version = "0.5", features = [ "mysql", "runtime-actix-native-tls", "off # Redis Database limitation = "0.1.1" # Redis rate limiter r2d2_redis = "0.14.0" +redis_async = { package = "redis", version = "0.21.5", features = ["tokio-comp"] } # Twitch # NB "unsupported" pubsub features may disappear from the Twitch API at any time. It's an unofficial API. diff --git a/crates/service/websocket_gateway/src/endpoints_ws/obs_gateway_websocket_handler.rs b/crates/service/websocket_gateway/src/endpoints_ws/obs_gateway_websocket_handler.rs index 6d5b0713a2..52c89b2b42 100644 --- a/crates/service/websocket_gateway/src/endpoints_ws/obs_gateway_websocket_handler.rs +++ b/crates/service/websocket_gateway/src/endpoints_ws/obs_gateway_websocket_handler.rs @@ -33,6 +33,7 @@ use twitch_common::twitch_user_id::TwitchUserId; use crate::endpoints_ws::helpers::publish_active_browser_info::publish_active_browser_info; use crate::endpoints_ws::threads::redis_pubsub_event_listener_thread::RedisPubsubEventListenerThread; use crate::endpoints_ws::threads::tts_inference_job_token_queue::TtsInferenceJobTokenQueue; +use tokio::task::JoinHandle; // TODO: Redis calls are synchronous (but fast), but is there any way to make them async? @@ -129,7 +130,10 @@ pub async fn obs_gateway_websocket_handler( info!("Starting user Redis PubSub thread..."); - server_state.multithreading.redis_pubsub_runtime.spawn(thread.start_thread()); + let mut jh = server_state.multithreading.redis_pubsub_runtime.spawn(thread.start_thread()); + + + server_state.multithreading.redis_pubsub_runtime.spawn(kill(jh)); let websocket = ObsGatewayWebSocket::new( tts_job_token_queue, @@ -146,6 +150,15 @@ pub async fn obs_gateway_websocket_handler( }) } +// NB: Well, abort() doesn't stop the thread :( +async fn kill (handle: JoinHandle<()>) { + error!("Waiting to kill pubsub thread..."); + sleep(Duration::from_secs(120)); + error!("Killing pubsub thread..."); + handle.abort(); + error!("Killed pubsub thread."); +} + /// Websocket behavior struct ObsGatewayWebSocket { twitch_user_id: TwitchUserId, diff --git a/crates/service/websocket_gateway/src/endpoints_ws/threads/redis_pubsub_event_listener_thread.rs b/crates/service/websocket_gateway/src/endpoints_ws/threads/redis_pubsub_event_listener_thread.rs index 493b0cc10d..ab6bad96bf 100644 --- a/crates/service/websocket_gateway/src/endpoints_ws/threads/redis_pubsub_event_listener_thread.rs +++ b/crates/service/websocket_gateway/src/endpoints_ws/threads/redis_pubsub_event_listener_thread.rs @@ -1,17 +1,25 @@ -use std::sync::Arc; +use container_common::anyhow_result::AnyhowResult; +use futures_util::StreamExt; +use crate::endpoints_ws::threads::tts_inference_job_token_queue::TtsInferenceJobTokenQueue; +use futures::Future; +use futures::future::Ready; +use log::error; +use log::info; use r2d2_redis::RedisConnectionManager; use r2d2_redis::r2d2; -use r2d2_redis::redis::Commands; -use container_common::anyhow_result::AnyhowResult; -use log::info; -use crate::endpoints_ws::threads::tts_inference_job_token_queue::TtsInferenceJobTokenQueue; -use twitch_common::twitch_user_id::TwitchUserId; +use r2d2_redis::redis::{Commands, PubSub, Msg}; use redis_common::redis_keys::RedisKeys; +use redis_async::Client as AsyncClient; +use std::sync::Arc; +use std::thread::sleep; +use time::Duration; +use twitch_common::twitch_user_id::TwitchUserId; pub struct RedisPubsubEventListenerThread { twitch_user_id: TwitchUserId, /// Redis PubSub connection exclusive to *this* thread. redis: Arc>, + async_redis: AsyncClient, token_queue: TtsInferenceJobTokenQueue, } @@ -28,8 +36,12 @@ impl RedisPubsubEventListenerThread { let redis = Arc::new(r2d2::Pool::builder() .build(redis_manager)?); + + let async_redis = AsyncClient::open(redis_pubsub_connection_string)?; + Ok(Self { twitch_user_id: twitch_user_id.clone(), + async_redis, redis, token_queue, }) @@ -46,18 +58,62 @@ impl RedisPubsubEventListenerThread { let mut pubsub_pool = self.redis.get().unwrap(); let mut pubsub = pubsub_pool.as_pubsub(); + let mut async_redis_conn = self.async_redis.get_async_connection().await.unwrap(); + let mut async_pubsub = async_redis_conn.into_pubsub(); + let pubsub_key = RedisKeys::twitch_tts_job_topic(self.twitch_user_id.get_str()); pubsub.subscribe(&pubsub_key).unwrap(); + let mut pubsub_stream = async_pubsub.on_message(); + loop { info!("Twitch user Redis PubSub thread loop iter"); - // TODO: This is blocking. We need a way to exit the thread. - let message = pubsub.get_message().unwrap(); - let tts_job_token : String = message.get_payload().unwrap(); - info!("Job token received from Redis: {}", tts_job_token); - self.token_queue.enqueue_token(&tts_job_token).unwrap(); + // NB: We can't have calls to read the Twitch websocket client block forever, and they + // would do exactly that if not for this code. This is adapted from the very good example + // in the `tokio-tungstenite` repo, which also contains good recipes for splitting sockets + // into two unidirectional streams: + // https://github.com/snapview/tokio-tungstenite/blob/master/examples/interval-server.rs + + let mut interval = tokio::time::interval(std::time::Duration::from_secs(1)); + tokio::select! { + //maybe_message = pubsub.get_message().unwrap() => { + //maybe_message = Self::blocking_get_message(&mut pubsub) => { + maybe_message = pubsub_stream.next() => { + //let tts_job_token : String = maybe_message.unwrap().get_payload().unwrap(); + if let Some(message) = maybe_message { + let tts_job_token : String = message.get_payload().unwrap(); + + info!("Job token received from Redis: {}", tts_job_token); + self.token_queue.enqueue_token(&tts_job_token).unwrap(); + + } else { + info!("NO MESSAGE"); + sleep(std::time::Duration::from_secs(1)); + + } + } + _ = interval.tick() => { + sleep(std::time::Duration::from_secs(1)); + error!("."); + } + } + + +// // TODO: This is blocking. We need a way to exit the thread. +// let message = pubsub.get_message().unwrap(); +// let tts_job_token : String = message.get_payload().unwrap(); +// +// info!("Job token received from Redis: {}", tts_job_token); +// self.token_queue.enqueue_token(&tts_job_token).unwrap(); } } + + // NB: Futures. Ugh + fn blocking_get_message(pubsub: &mut PubSub) -> Ready> { + let message = pubsub.get_message().unwrap(); + let fut = futures::future::ok::(message); + fut + } } \ No newline at end of file