refactor: remove state's dependency on util

Author: vicanso

Cargo.lock

@@ -56,11 +56,6 @@ graph TD
     plugin --> state
     plugin --> util
 
-    state --> config
-    state --> location
-    state --> upstream
-    state --> util
-
     upstream --> config
     upstream --> discovery
     upstream --> health

docs/modules.md

@@ -16,14 +16,15 @@ path = "src/lib.rs"
 ahash = { workspace = true }
 bytes = { workspace = true }
 http = { workspace = true }
+once_cell = { workspace = true }
+hostname = "0.4.0"
 pingora = { workspace = true }
 pingora-limits = { workspace = true }
 itoa = { workspace = true }
 opentelemetry = { version = "0.27.1", default-features = false, features = [
     "trace",
 ], optional = true }
 tokio = { workspace = true }
-pingap-util = { path = "../pingap-util" }
 
 
 [features]

pingap-state/Cargo.toml

@@ -16,17 +16,42 @@ use ahash::AHashMap;
 use bytes::{Bytes, BytesMut};
 use http::StatusCode;
 use http::Uri;
-use pingap_util::format_duration;
-use pingora::cache::CacheKey;
-
 #[cfg(feature = "full")]
 use opentelemetry::{
     global::{BoxedSpan, BoxedTracer, ObjectSafeSpan},
     trace::{SpanKind, TraceContextExt, Tracer},
     Context,
 };
+use pingora::cache::CacheKey;
 use pingora_limits::inflight::Guard;
-use std::time::Duration;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+const SEC: u64 = 1_000;
+
+#[inline]
+fn format_duration(mut buf: BytesMut, ms: u64) -> BytesMut {
+    if ms < 1000 {
+        buf.extend(itoa::Buffer::new().format(ms).as_bytes());
+        buf.extend(b"ms");
+    } else {
+        buf.extend(itoa::Buffer::new().format(ms / SEC).as_bytes());
+        let value = (ms % SEC) / 100;
+        if value != 0 {
+            buf.extend(b".");
+            buf.extend(itoa::Buffer::new().format(value).as_bytes());
+        }
+        buf.extend(b"s");
+    }
+    buf
+}
+
+#[inline]
+fn now_ms() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis() as u64
+}
 
 pub trait ModifyResponseBody: Sync + Send {
     fn handle(&self, data: Bytes) -> Bytes;
@@ -180,7 +205,7 @@ impl Ctx {
     /// set to their default values.
     pub fn new() -> Self {
         Self {
-            created_at: pingap_util::now_ms(),
+            created_at: now_ms(),
             ..Default::default()
         }
     }
@@ -358,10 +383,7 @@ impl Ctx {
                 }
             },
             "service_time" => {
-                buf = format_duration(
-                    buf,
-                    pingap_util::now_ms() - self.created_at,
-                )
+                buf = format_duration(buf, now_ms() - self.created_at)
             },
             _ => {},
         }
@@ -541,7 +563,7 @@ mod tests {
                 .as_ref()
         );
 
-        ctx.created_at = pingap_util::now_ms() - 1;
+        ctx.created_at = now_ms() - 1;
         assert_eq!(
             true,
             ctx.append_value(BytesMut::new(), "service_time")

pingap-state/src/ctx.rs

@@ -12,10 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use super::Ctx;
+use super::{get_hostname, Ctx};
 use bytes::BytesMut;
-use http::HeaderValue;
-use pingap_util::get_hostname;
+use http::{HeaderName, HeaderValue};
+use pingora::http::RequestHeader;
 use pingora::proxy::Session;
 
 pub const HOST_NAME_TAG: &[u8] = b"$hostname";
@@ -31,6 +31,21 @@ const UPSTREAM_ADDR_TAG: &[u8] = b"$upstream_addr";
 static SCHEME_HTTPS: HeaderValue = HeaderValue::from_static("https");
 static SCHEME_HTTP: HeaderValue = HeaderValue::from_static("http");
 
+/// Get request host in this order of precedence:
+/// host name from the request line,
+/// or host name from the "Host" request header field
+fn get_host(header: &RequestHeader) -> Option<&str> {
+    if let Some(host) = header.uri.host() {
+        return Some(host);
+    }
+    if let Some(host) = header.headers.get("Host") {
+        if let Ok(value) = host.to_str().map(|host| host.split(':').next()) {
+            return value;
+        }
+    }
+    None
+}
+
 /// Processes special header values that contain dynamic variables.
 /// Supports variables like $host, $scheme, $remote_addr etc.
 ///
@@ -58,8 +73,7 @@ pub fn convert_header_value(
     let to_header_value = |s: &str| HeaderValue::from_str(s).ok();
 
     match buf {
-        HOST_TAG => pingap_util::get_host(session.req_header())
-            .and_then(to_header_value),
+        HOST_TAG => get_host(session.req_header()).and_then(to_header_value),
         SCHEME_TAG => Some(if ctx.tls_version.is_some() {
             SCHEME_HTTPS.clone()
         } else {
@@ -85,9 +99,9 @@ pub fn convert_header_value(
         },
         PROXY_ADD_FORWARDED_TAG => {
             ctx.remote_addr.as_deref().and_then(|remote_addr| {
-                let value = match session.get_header(
-                    pingap_util::HTTP_HEADER_X_FORWARDED_FOR.clone(),
-                ) {
+                let value = match session
+                    .get_header(HeaderName::from_static("X-Forwarded-For"))
+                {
                     Some(existing) => format!(
                         "{}, {}",
                         existing.to_str().unwrap_or_default(),

pingap-state/src/http_header.rs

@@ -12,8 +12,26 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use once_cell::sync::Lazy;
+
 mod ctx;
 mod http_header;
 
+static HOST_NAME: Lazy<String> = Lazy::new(|| {
+    hostname::get()
+        .unwrap_or_default()
+        .to_str()
+        .unwrap_or_default()
+        .to_string()
+});
+
+/// Returns the system hostname.
+///
+/// Returns:
+/// * `&'static str` - The system's hostname as a string slice
+pub fn get_hostname() -> &'static str {
+    HOST_NAME.as_str()
+}
+
 pub use ctx::*;
 pub use http_header::*;