tutorial2: rust implementation

DanielePalaia · DanielePalaia · commit 423f0f0d13b4 · 2024-08-02T13:44:57.000+02:00
diff --git a/rust-stream/Cargo.lock b/rust-stream/Cargo.lock
diff --git a/rust-stream/Cargo.toml b/rust-stream/Cargo.toml
@@ -7,5 +7,5 @@ edition = "2021"
 
 [dependencies]
 rabbitmq-stream-client = "0.4.2"
-tokio = { version = "1.0.0", features = ["rt", "rt-multi-thread", "macros"] }
+tokio = { version = "1.39.0", features = ["rt", "rt-multi-thread", "macros"] }
 futures = "0.3.30"
diff --git a/rust-stream/README.md b/rust-stream/README.md
@@ -19,4 +19,9 @@ Each cargo command should be launched in a separate shell.
 #### [Tutorial one: "Hello World!"](https://www.rabbitmq.com/tutorials/tutorial-one-rust-stream.html)
 
     cargo run --bin receive
-    cargo run --bin send
+    cargo run --bin send
+
+#### [Tutorial one: "Offset tracking!"](https://www.rabbitmq.com/tutorials/tutorial-one-rust-stream.html)
+
+    cargo run --bin send_offset_tracking
+    cargo run --bin receive_offset_tracking
diff --git a/rust-stream/src/bin/receive_offset_tracking.rs b/rust-stream/src/bin/receive_offset_tracking.rs
@@ -0,0 +1,104 @@
+use futures::StreamExt;
+use rabbitmq_stream_client::error::StreamCreateError;
+use rabbitmq_stream_client::types::{ByteCapacity, OffsetSpecification, ResponseCode};
+use std::io::stdin;
+use std::sync::atomic::{AtomicI64, Ordering};
+use std::sync::Arc;
+use tokio::task;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    use rabbitmq_stream_client::Environment;
+    let environment = Environment::builder().build().await?;
+    let stream = "stream-offset-tracking-rust";
+    let received_messages = Arc::new(AtomicI64::new(-1));
+    let first_offset = Arc::new(AtomicI64::new(-1));
+    let last_offset = Arc::new(AtomicI64::new(-1));
+    let create_response = environment
+        .stream_creator()
+        .max_length(ByteCapacity::GB(2))
+        .create(stream)
+        .await;
+
+    if let Err(e) = create_response {
+        if let StreamCreateError::Create { stream, status } = e {
+            match status {
+                // we can ignore this error because the stream already exists
+                ResponseCode::StreamAlreadyExists => {}
+                err => {
+                    println!("Error creating stream: {:?} {:?}", stream, err);
+                    std::process::exit(1);
+                }
+            }
+        }
+    }
+
+    let mut consumer = environment
+        .consumer()
+        .name("consumer-1")
+        .offset(OffsetSpecification::First)
+        .build(stream)
+        .await
+        .unwrap();
+
+    println!("Starting consuming");
+    println!("Press any key to close the consumer");
+
+    let mut stored_offset: u64 = consumer.query_offset().await.unwrap_or_else(|_| 0);
+
+    if stored_offset >  0 {
+        stored_offset += 1;
+    }
+    consumer = environment
+        .consumer()
+        .name("consumer-1")
+        .offset(OffsetSpecification::Offset(stored_offset))
+        .build(stream)
+        .await
+        .unwrap();
+
+    let first_cloned_offset = first_offset.clone();
+    let last_cloned_offset = last_offset.clone();
+
+    task::spawn(async move {
+        while let Some(delivery) = consumer.next().await {
+            let d = delivery.unwrap();
+
+            if first_offset.load(Ordering::Relaxed) == -1 {
+                println!("consuming first message");
+                _ = first_offset.compare_exchange(
+                    first_offset.load(Ordering::Relaxed),
+                    d.offset() as i64,
+                    Ordering::Relaxed,
+                    Ordering::Relaxed,
+                );
+            }
+
+            if received_messages.fetch_add(1, Ordering::Relaxed) % 10 == 0
+                || String::from_utf8_lossy(d.message().data().unwrap()).contains("marker")
+            {
+                let _ = consumer
+                    .store_offset(d.offset())
+                    .await
+                    .unwrap_or_else(|e| println!("Err: {}", e));
+                if String::from_utf8_lossy(d.message().data().unwrap()).contains("marker") {
+                    last_offset.store(d.offset() as i64, Ordering::Relaxed);
+                    let handle = consumer.handle();
+                    _ = handle.close().await;
+
+                }
+            }
+        }
+    });
+
+    _ = stdin().read_line(&mut "".to_string());
+
+    if first_cloned_offset.load(Ordering::Relaxed) != -1 {
+        println!(
+            "Done consuming first_offset: {:?} last_offset: {:?}  ",
+            first_cloned_offset, last_cloned_offset
+        );
+    }
+
+    Ok(())
+}
diff --git a/rust-stream/src/bin/send_offset_tracking.rs b/rust-stream/src/bin/send_offset_tracking.rs
@@ -0,0 +1,66 @@
+use rabbitmq_stream_client::error::StreamCreateError;
+use rabbitmq_stream_client::types::{ByteCapacity, Message, ResponseCode};
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::Arc;
+use tokio::sync::Notify;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    use rabbitmq_stream_client::Environment;
+    let environment = Environment::builder().build().await?;
+    let stream = "stream-offset-tracking-rust";
+    let message_count = 100;
+    let confirmed_messages = Arc::new(AtomicU32::new(0));
+    let notify_on_send = Arc::new(Notify::new());
+
+    let create_response = environment
+        .stream_creator()
+        .max_length(ByteCapacity::GB(2))
+        .create(stream)
+        .await;
+
+    if let Err(e) = create_response {
+        if let StreamCreateError::Create { stream, status } = e {
+            match status {
+                // we can ignore this error because the stream already exists
+                ResponseCode::StreamAlreadyExists => {}
+                err => {
+                    println!("Error creating stream: {:?} {:?}", stream, err);
+                    std::process::exit(1);
+                }
+            }
+        }
+    }
+
+    println!("Publishing {:?} messages", message_count);
+
+    let producer = environment.producer().build(stream).await?;
+
+    for i in 0..message_count {
+        let msg;
+        if i < message_count - 1 {
+            msg = Message::builder().body(format!("hello{}", i)).build();
+        } else {
+            msg = Message::builder().body(format!("marker{}", i)).build();
+        };
+
+        let counter = confirmed_messages.clone();
+        let notifier = notify_on_send.clone();
+        producer
+            .send(msg, move |_| {
+                let inner_counter = counter.clone();
+                let inner_notifier = notifier.clone();
+                async move {
+                    if inner_counter.fetch_add(1, Ordering::Relaxed) == message_count - 1 {
+                        inner_notifier.notify_one();
+                    }
+                }
+            })
+            .await?;
+    }
+
+    notify_on_send.notified().await;
+    println!("Messages confirmed.");
+    producer.close().await?;
+    Ok(())
+}
