feature: Added resolve binary for handle resolution debugging

src/bin/resolve.rs

···
+use std::env;
+
+use anyhow::Result;
+use smokesignal::config::{default_env, optional_env, version, CertificateBundles, DnsNameservers};
+use tracing_subscriber::{layer::SubscriberExt as _, util::SubscriberInitExt as _};
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    tracing_subscriber::registry()
+        .with(tracing_subscriber::EnvFilter::new(
+            std::env::var("RUST_LOG").unwrap_or_else(|_| "trace".into()),
+        ))
+        .with(tracing_subscriber::fmt::layer().pretty())
+        .init();
+
+    let certificate_bundles: CertificateBundles = optional_env("CERTIFICATE_BUNDLES").try_into()?;
+    let default_user_agent = format!("smokesignal ({}; +https://smokesignal.events/)", version()?);
+    let user_agent = default_env("USER_AGENT", &default_user_agent);
+    let dns_nameservers: DnsNameservers = optional_env("DNS_NAMESERVERS").try_into()?;
+
+    let mut client_builder = reqwest::Client::builder();
+    for ca_certificate in certificate_bundles.as_ref() {
+        tracing::info!("Loading CA certificate: {:?}", ca_certificate);
+        let cert = std::fs::read(ca_certificate)?;
+        let cert = reqwest::Certificate::from_pem(&cert)?;
+        client_builder = client_builder.add_root_certificate(cert);
+    }
+
+    client_builder = client_builder.user_agent(user_agent);
+    let http_client = client_builder.build()?;
+
+    // Initialize the DNS resolver with configuration from the app config
+    let dns_resolver = smokesignal::resolve::create_resolver(dns_nameservers);
+
+    for subject in env::args() {
+        let resolved_did =
+            smokesignal::resolve::resolve_subject(&http_client, &dns_resolver, &subject).await;
+        tracing::info!(?resolved_did, ?subject, "resolved subject");
+    }
+
+    Ok(())
+}

src/bin/smokesignal.rs

···
     let jinja = reload_env::build_env(&config.external_base, &config.version);
 
     // Initialize the DNS resolver with configuration from the app config
-    let dns_resolver = create_resolver(&config);
+    let dns_resolver = create_resolver(config.dns_nameservers.clone());
 
     let web_context = WebContext::new(
         pool.clone(),

src/config.rs

···
         let http_cookie_key: HttpCookieKey =
             require_env("HTTP_COOKIE_KEY").and_then(|value| value.try_into())?;
 
-        let http_static_path = default_env("HTTP_STATIC_PATH", "static").try_into()?;
+        let http_static_path = default_env("HTTP_STATIC_PATH", "static");
 
         let external_base = require_env("EXTERNAL_BASE")?;
 
···
     }
 }
 
-fn require_env(name: &str) -> Result<String> {
+pub fn require_env(name: &str) -> Result<String> {
     std::env::var(name).map_err(|_| ConfigError::EnvVarRequired(name.to_string()).into())
 }
 
-fn optional_env(name: &str) -> String {
+pub fn optional_env(name: &str) -> String {
     std::env::var(name).unwrap_or("".to_string())
 }
 
-fn default_env(name: &str, default_value: &str) -> String {
+pub fn default_env(name: &str, default_value: &str) -> String {
     std::env::var(name).unwrap_or(default_value.to_string())
 }
 

src/did.rs

···
     use serde_json::Value;
     use std::collections::HashMap;
 
-    #[derive(Clone, Deserialize)]
+    #[derive(Clone, Deserialize, Debug)]
     #[serde(rename_all = "camelCase")]
     pub struct Service {
         pub id: String,
···
         pub service_endpoint: String,
     }
 
-    #[derive(Clone, Deserialize)]
+    #[derive(Clone, Deserialize, Debug)]
     #[serde(tag = "type", rename_all = "camelCase")]
     pub enum VerificationMethod {
         Multikey {
···
         },
     }
 
-    #[derive(Clone, Deserialize)]
+    #[derive(Clone, Deserialize, Debug)]
     #[serde(rename_all = "camelCase")]
     pub struct Document {
         pub id: String,
···
 
     pub async fn query_hostname(http_client: &reqwest::Client, hostname: &str) -> Result<Document> {
         let url = format!("https://{}/.well-known/did.json", hostname);
+
+        tracing::debug!(?url, "query_hostname");
 
         http_client
             .get(&url)

src/jose.rs

···
         Signature::try_from(signature_bytes.as_slice()).map_err(|_| JoseError::InvalidSignature)?;
 
     // Verify signature
-    let verifying_key = VerifyingKey::from(public_key.clone());
+    let verifying_key = VerifyingKey::from(public_key);
     let content = format!("{}.{}", encoded_header, encoded_claims);
 
     verifying_key

src/resolve.rs

···
 use std::collections::HashSet;
 use std::time::Duration;
 
-use crate::config::Config;
+use crate::config::DnsNameservers;
 use crate::did::web::query_hostname;
 
 pub enum InputType {
···
     )
     .await;
 
+    tracing::debug!(
+        ?handle,
+        ?dns_lookup,
+        ?http_lookup,
+        ?did_web_lookup,
+        "raw query results"
+    );
+
     let did_web_lookup_did = did_web_lookup
         .map(|document| document.id)
         .map_err(ResolveError::DIDWebResolutionFailed);
···
     if results.is_empty() {
         return Err(ResolveError::NoDIDsFound);
     }
+
+    tracing::debug!(?handle, ?results, "query results");
 
     let first = results[0].clone();
     if results.iter().all(|result| result == &first) {
···
 ///
 /// If custom nameservers are configured in app config, they will be used.
 /// Otherwise, the system default resolver configuration will be used.
-pub fn create_resolver(config: &Config) -> TokioAsyncResolver {
+pub fn create_resolver(nameservers: DnsNameservers) -> TokioAsyncResolver {
     // Initialize the DNS resolver with custom nameservers if configured
-    let nameservers = config.dns_nameservers.as_ref();
+    let nameservers = nameservers.as_ref();
     let resolver_config = if !nameservers.is_empty() {
         // Use custom nameservers
         tracing::info!("Using custom DNS nameservers: {:?}", nameservers);