123 lines
3.8 KiB
Rust
123 lines
3.8 KiB
Rust
mod workers;
|
|
|
|
use std::env;
|
|
|
|
use futures::StreamExt;
|
|
use postcard::{from_bytes, to_stdvec};
|
|
use serenity::{
|
|
Client,
|
|
all::{Context, EventHandler, GatewayIntents, Ready},
|
|
async_trait,
|
|
};
|
|
use songbird::SerenityInit;
|
|
use types::jobs::{JobResponse, JobsMap, JobsResponseMap};
|
|
use which::which;
|
|
use yt_dlp::{Downloader, client::Libraries};
|
|
|
|
struct Handler {
|
|
nats_client: async_nats::Client,
|
|
downloader: Downloader,
|
|
}
|
|
|
|
#[async_trait]
|
|
impl EventHandler for Handler {
|
|
async fn ready(&self, ctx: Context, ready: Ready) {
|
|
println!("{} is connected!", ready.user.name);
|
|
|
|
let voice_manager = songbird::get(&ctx)
|
|
.await
|
|
.expect("Cannot init voice manager");
|
|
|
|
let mut subscriber = self
|
|
.nats_client
|
|
.queue_subscribe("corro-dj.*", "group1".to_string())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Receive and process messages
|
|
while let Some(message) = subscriber.next().await {
|
|
println!("Received message {:?}", message);
|
|
|
|
// let subject = message.subject.split(".").collect::<Vec<&str>>()[1];
|
|
let payload: JobsMap = from_bytes(&message.payload).unwrap();
|
|
|
|
let result =
|
|
match payload {
|
|
JobsMap::Download(payload) => {
|
|
workers::download::download(&self.downloader, payload)
|
|
.await
|
|
.map(|res| JobResponse {
|
|
content: res.content.map(JobsResponseMap::Download),
|
|
error: res.error,
|
|
})
|
|
}
|
|
JobsMap::Play(payload) => workers::play::play(&voice_manager, payload)
|
|
.await
|
|
.map(|res| JobResponse {
|
|
content: res.content.map(JobsResponseMap::Play),
|
|
error: res.error,
|
|
}),
|
|
JobsMap::Search(payload) => workers::search::search(&self.downloader, payload)
|
|
.await
|
|
.map(|res| JobResponse {
|
|
content: res.content.map(JobsResponseMap::Search),
|
|
error: res.error,
|
|
}),
|
|
};
|
|
|
|
let response = match result {
|
|
Ok(response) => response,
|
|
Err(why) => JobResponse {
|
|
content: None,
|
|
error: Some(why),
|
|
},
|
|
};
|
|
|
|
println!("response {:?}", response);
|
|
|
|
if let Some(reply) = message.reply {
|
|
self.nats_client
|
|
.publish(reply, to_stdvec(&response).unwrap().into())
|
|
.await
|
|
.unwrap();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
rustls::crypto::aws_lc_rs::default_provider()
|
|
.install_default()
|
|
.expect("Failed to install rustls crypto provider");
|
|
|
|
let discord_token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");
|
|
|
|
let nats_client = async_nats::connect("nats://localhost:4222")
|
|
.await
|
|
.expect("Error creating nats client");
|
|
|
|
let downloader = Downloader::builder(
|
|
Libraries::new(which("yt-dlp").unwrap(), which("ffmpeg").unwrap()),
|
|
"output",
|
|
)
|
|
.build()
|
|
.await
|
|
.unwrap();
|
|
|
|
let handler = Handler {
|
|
nats_client,
|
|
downloader,
|
|
};
|
|
|
|
let mut discord_client = Client::builder(&discord_token, GatewayIntents::non_privileged())
|
|
.event_handler(handler)
|
|
.register_songbird()
|
|
.await
|
|
.expect("Error creating discord client");
|
|
|
|
if let Err(why) = discord_client.start().await {
|
|
println!("Client start error: {why:?}");
|
|
}
|
|
}
|