wip

apps/master/src/main.rs

@@ -2,10 +2,12 @@ mod commands;
 
 use std::env;
 
+use async_nats::jetstream::{self, context::traits::Requester};
 use serenity::{
     Client,
     all::{Context, EventHandler, GatewayIntents},
     async_trait,
+    futures::future::ErrInto,
     model::{
         application::{Command, Interaction},
         gateway::Ready,
@@ -65,26 +67,75 @@ impl EventHandler for Handler {
 
 #[tokio::main]
 async fn main() {
-    // Configure the client with your Discord bot token in the environment.
     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 handler = Handler { nats_client };
+    let jetstream_client = jetstream::new(nats_client.clone());
 
-    // Build our client.
-    let mut discord_client = Client::builder(discord_token, GatewayIntents::non_privileged())
-        .event_handler(handler)
+    let stream = jetstream_client
+        .create_stream(jetstream::stream::Config {
+            name: "LOCKS".to_string(),
+            subjects: vec!["locks.*".to_string()],
+            storage: jetstream::stream::StorageType::Memory,
+            max_messages_per_subject: 1,
+            discard_new_per_subject: true,
+            discard: jetstream::stream::DiscardPolicy::New,
+            ..Default::default()
+        })
         .await
-        .expect("Error creating discord client");
+        .expect("Error creating locks stream");
 
-    // Finally, start a single shard, and start listening to events.
-    //
-    // Shards will automatically attempt to reconnect, and will perform exponential backoff until
-    // it reconnects.
-    if let Err(why) = discord_client.start().await {
-        println!("Client start error: {why:?}");
+    println!("created the stream");
+
+    match jetstream_client.publish("locks.a", "test".into()).await.unwrap().await {
+        Ok(a) => {
+            println!("publish ok {:?}", a);
+        }
+        Err(why) => {
+            println!("{why:?}");
+        }
     }
+
+    // match jetstream_client.request("locks.a", "test").await {
+    //     Ok(a) => {
+    //         println!("publish ok {a:?}");
+    //         Ok("a")
+    //     }
+    //     Err(why) => {
+    //         println!("{why:?}");
+    //         Err("a")
+    //     }
+    // };
+    // match jetstream_client.publish("locks.b", "test".into()).await {
+    //     Ok(a) => {
+    //         println!("publish ok {a:?}");
+    //     }
+    //     Err(why) => {
+    //         println!("{why:?}");
+    //     }
+    // };
+    // match jetstream_client.publish("locks.a", "test".into()).await {
+    //     Ok(a) => {
+    //         println!("publish ok {a:?}");
+    //     }
+    //     Err(why) => {
+    //         println!("{why:?}");
+    //     }
+    // };
+
+    println!("done");
+
+    // let handler = Handler { nats_client };
+
+    // let mut discord_client = Client::builder(discord_token, GatewayIntents::non_privileged())
+    //     .event_handler(handler)
+    //     .await
+    //     .expect("Error creating discord client");
+
+    // if let Err(why) = discord_client.start().await {
+    //     println!("Client start error: {why:?}");
+    // }
 }