one commit contains all impl

vanity-worker/src/main.rs

@@ -0,0 +1,76 @@
+use std::collections::HashMap;
+
+use rand_core::OsRng;
+use tokio::sync::RwLock;
+use x25519_dalek::{PublicKey, StaticSecret};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client =
+        libvanity::worker::worker_client::WorkerClient::connect("grpc://127.0.0.1:8877").await?;
+
+    let (tx, rx) = tokio::sync::mpsc::channel(128);
+
+    let requests = std::sync::Arc::new(RwLock::new(HashMap::new()));
+
+    let mut another = client.clone();
+    let requests_writer = requests.clone();
+    let pull_thread = tokio::spawn(async move {
+        use libvanity::worker::request::NewOrDone::{Done, New};
+
+        let mut tasks = another
+            .poll(tokio_stream::wrappers::ReceiverStream::new(rx))
+            .await
+            .expect("msg")
+            .into_inner();
+        let requests = requests_writer;
+        while let Some(msg) = tasks.message().await.unwrap() {
+            if let Some(new_or_done) = msg.new_or_done {
+                match new_or_done {
+                    New(request) => {
+                        let mut writer = requests.write().await;
+                        writer.insert(request.id, request.pattern);
+                    }
+                    Done(response) => {
+                        let mut writer = requests.write().await;
+                        writer.remove(&response);
+                    }
+                }
+            }
+        }
+    });
+
+    let worker_threads = Vec::from_iter(1..10).into_iter().map(|id| {
+        let requests = requests.clone();
+        let tx = tx.clone();
+        let _id = id.clone();
+        tokio::spawn(async move {
+            loop {
+                let requests = requests.read().await.clone();
+                if requests.is_empty() {
+                    tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+                    continue;
+                }
+
+                let private = StaticSecret::new(&mut OsRng);
+                let public = PublicKey::from(&private);
+
+                for (id, pattern) in requests.iter() {
+                    let matcher = regex::Regex::new(pattern).unwrap();
+                    let matcher = matcher.clone();
+                    let public_b64 = base64::encode(public.as_bytes());
+                    if matcher.is_match(&public_b64) {
+                        let mut result = libvanity::worker::Result::default();
+                        result.id = id.clone();
+                        result.result = base64::encode(private.to_bytes());
+                        tx.send(result).await.expect("no error");
+                    }
+                }
+            }
+        })
+    });
+
+    let _ = tokio::join!(futures::future::join_all(worker_threads), pull_thread);
+
+    Ok(())
+}