feat: v0.2.0-rc

Cargo.lock

@@ -1954,11 +1954,12 @@ checksum = "106dd99e98437432fed6519dedecfade6a06a73bb7b2a1e019fdd2bee5778d94"
 
 [[package]]
 name = "proxy-inspector"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "async-trait",
  "base64 0.22.0",
  "bytes 1.6.0",
+ "hex",
  "http 1.1.0",
  "log",
  "once_cell",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "proxy-inspector"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -25,3 +25,4 @@ serde = { version = "1.0.197", features = ["derive"] }
 serde_json = "1.0.115"
 tokio-dns-unofficial = "0.4.0"
 trust-dns-resolver = { version = "0.23.2", features = ["tokio"] }
+hex = "0.4.3"

src/app.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use base64::Engine;
 use base64::engine::general_purpose::STANDARD;
 use bytes::Bytes;
-use http::HeaderName;
+use http::{HeaderMap, HeaderName, HeaderValue};
 use pingora::{Error, ErrorType};
 use pingora::http::ResponseHeader;
 use pingora::prelude::{HttpPeer, ProxyHttp, Result, Session};
@@ -55,6 +55,19 @@ impl ProxyApp {
         }
         None
     }
+
+    fn print_headers(buffer: &mut String, headers: &HeaderMap<HeaderValue>) {
+        let header_len = headers.len();
+        headers.iter().enumerate().for_each(|(i, (n, v))| {
+            buffer.push_str(
+                &format!("{}: {}{}",
+                         n.as_str(),
+                         v.to_str().unwrap_or("ERROR!BAD-VALUE!"),
+                         if i < header_len - 1 { "\n" } else { "" }
+                )
+            );
+        });
+    }
 }
 
 #[async_trait]
@@ -96,12 +109,13 @@ impl ProxyHttp for ProxyApp {
 
         if self.lookup_dns {
             if let Some(address) = self.lookup_ipv4(&hostname).await {
+                let peer_addr = format!("{}:{}", address, if self.tls { 443 } else { 80 });
                 let peer = HttpPeer::new(
-                    format!("{}:{}", address, if self.tls { 443 } else { 80 }),
+                    &peer_addr,
                     self.tls,
                     hostname.to_string(),
                 );
-                log::info!("Find peer: {} --> {:?}", hostname, address);
+                log::info!("Find peer: {} --> {:?}", hostname, peer_addr);
                 return Ok(Box::new(peer));
             }
         }
@@ -119,16 +133,7 @@ impl ProxyHttp for ProxyApp {
         req.push_str(&request_header.uri.to_string());
         req.push(' ');
         req.push_str(&format!("{:?}\n", request_header.version));
-        let header_len = request_header.headers.len();
+        Self::print_headers(&mut req, &request_header.headers);
-        request_header.headers.iter().enumerate().for_each(|(i, (n, v))| {
-            req.push_str(
-                &format!("{}: {}{}",
-                         n.as_str(),
-                         v.to_str().unwrap_or("ERROR!BAD-VALUE!"),
-                         if i < header_len - 1 { "\n" } else { "" }
-                )
-            );
-        });
 
         let body = match session.read_request_body().await {
             Ok(Some(body_bytes)) => Some(STANDARD.encode(body_bytes)),
@@ -148,10 +153,14 @@ impl ProxyHttp for ProxyApp {
         where Self::CTX: Send + Sync,
     {
         let mut resp = String::new();
-        resp.push_str(&format!("version: {}\n", upstream_response.status));
+        resp.push_str(&format!(
-        resp.push_str(&format!("headers: {:#?}", upstream_response.headers));
+            "{:?} {}\n",
+            upstream_response.version,
+            upstream_response.status
+        ));
+        Self::print_headers(&mut resp, &upstream_response.headers);
 
-        log::info!("Response: {}", resp);
+        log::info!("Response: \n{}", resp);
         Ok(())
     }
 

src/cert.rs

@@ -24,6 +24,7 @@ pub fn load_certificate(cert_fn: &str, key_fn: &str) -> Result<(Certificate, Str
 
 pub fn issue_certificate(intermediate_certificate: &Certificate, domain: &str) -> Result<Cert, String> {
     let cert = new_end_entity(domain)?;
+    log::info!("New certificate for: {} -> {}", domain, hex::encode(&cert.get_key_identifier()));
     let cert_pem = cert.serialize_pem_with_signer(intermediate_certificate).map_err(|e| format!("Sign cert failed: {}", e))?;
     let key_pem = cert.serialize_private_key_pem();
     Ok(Cert {

src/main.rs

@@ -1,4 +1,4 @@
-use log::{info, LevelFilter};
+use log::LevelFilter;
 use pingora::{
     server::{configuration::Opt, Server},
     services::{listening::Service as ListeningService, Service},
@@ -39,6 +39,7 @@ pub fn main() {
             }
         }
         let lookup_tls = group.lookup_dns.unwrap_or(false);
+        log::info!("Listen at: {}, tls: {}, lookup_tls: {}", listen_address, group.tls.is_some(), lookup_tls);
         match &group.tls {
             None => {
                 let proxy_service_tcp = service::proxy_service_tcp(
@@ -68,7 +69,7 @@ pub fn main() {
         services.push(Box::new(prometheus_service_http));
     }
 
-    info!("start listen...");
+    log::info!("start listen...");
     my_server.add_services(services);
     my_server.run_forever();
 }