add proper command line options and logging

vanityd/src/main.rs

@@ -2,21 +2,37 @@ pub(crate) mod consts;
 pub(crate) mod server;
 pub(crate) mod worker;
 
-use std::net::ToSocketAddrs;
+use std::{net::ToSocketAddrs, str::FromStr};
 
+use clap::Parser;
 use libvanity::{
     vanity::vanity_service_server::VanityServiceServer, worker::worker_server::WorkerServer,
 };
 
 pub use libvanity;
 
+#[derive(Parser)]
+struct Args {
+    #[clap(short, long, default_value = "127.0.0.1:8877")]
+    bind_address: String,
+
+    #[clap(short, long, default_value = "redis://127.0.0.1:6379")]
+    redis_address: String,
+
+    #[clap(short, long, default_value = "INFO")]
+    log_level: String,
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args = Args::parse();
+
+    let level = tracing::Level::from_str(&args.log_level)?;
     tracing_subscriber::FmtSubscriber::builder()
-        .with_max_level(tracing::Level::DEBUG)
+        .with_max_level(level)
         .init();
 
-    let redis = redis::Client::open("redis://127.0.0.1:6379")?;
+    let redis = redis::Client::open(args.redis_address)?;
 
     let vanity_server = server::VanityService::new(redis.clone());
     let worker_server = worker::WorkerService::new(redis.clone());
@@ -24,7 +40,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tonic::transport::Server::builder()
         .add_service(VanityServiceServer::new(vanity_server))
         .add_service(WorkerServer::new(worker_server))
-        .serve("127.0.0.1:8877".to_socket_addrs()?.next().unwrap())
+        .serve(args.bind_address.to_socket_addrs()?.next().unwrap())
         .await?;
 
     Ok(())

vanityd/src/server.rs

@@ -31,17 +31,33 @@ impl service_server::VanityService for VanityService {
             .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
         let pattern = req.into_inner().pattern;
 
-        let mut redis = self.redis.get_async_connection().await.expect("msg");
-        redis
+        tracing::trace!("entered request method: pattern={}", pattern);
+
+        let mut redis = match self.redis.get_async_connection().await {
+            Ok(redis) => redis,
+            Err(err) => {
+                tracing::warn!("failed to get redis connection: {}", err);
+                return Err(tonic::Status::unavailable(err.to_string()));
+            }
+        };
+        if let Err(err) = redis
             .publish::<&str, String, ()>("vanity:new", format!("{}|{}", id, pattern))
             .await
-            .expect("should not fail");
+        {
+            tracing::warn!("failed to publish new requests: {}", err);
+            return Err(tonic::Status::unavailable(err.to_string()));
+        }
+        tracing::debug!("new requests published on new clients: {}", pattern);
 
         let mut pubsub = redis.into_pubsub();
-        pubsub
+        if let Err(err) = pubsub
             .subscribe(format!("{}:{}", REDIS_PUBSUB_PATTERN_RESULT, id))
             .await
-            .expect("msg");
+        {
+            tracing::warn!("failed to subscribe on result channel: {}", err);
+            return Err(tonic::Status::unavailable(err.to_string()));
+        };
+        tracing::debug!("listening on result channel: {}", pattern);
 
         let mut msgs = pubsub.on_message();
 
@@ -49,6 +65,7 @@ impl service_server::VanityService for VanityService {
             if let Some(msg) = msgs.next().await {
                 let mut response = VanityResponse::default();
                 response.result = String::from_utf8_lossy(msg.get_payload_bytes()).to_string();
+                tracing::trace!("returned from request method: pattern={}", pattern);
                 return Ok(tonic::Response::new(response));
             }
         }