Wrappers (does not yet compile)

Author: aram356

Cargo.lock

@@ -19,6 +19,7 @@ futures = "0.3"
 handlebars = "6.3.2"
 hex = "0.4.3"
 hmac = "0.12.1"
+http = "1.3.1"
 log = "0.4.20"
 log-fastly = "0.10.0"
 serde = { version = "1.0", features = ["derive"] }

crates/common/Cargo.toml

@@ -1,3 +1,6 @@
-pub const SYNTHETIC_HEADER_FRESH: &str = "X-Synthetic-Fresh";
-pub const SYNTHETIC_HEADER_TRUSTED_SERVER: &str = "X-Synthetic-Trusted-Server";
-pub const SYNTHETIC_HEADER_PUB_USER_ID: &str = "X-Pub-User-ID";
+use http::header::HeaderName;
+
+pub const HEADER_SYNTHETIC_FRESH: HeaderName = HeaderName::from_static("x-synthetic-fresh");
+pub const HEADER_SYNTHETIC_PUB_USER_ID: HeaderName = HeaderName::from_static("x-pub-user-id");
+pub const HEADER_SYNTHETIC_TRUSTED_SERVER: HeaderName = HeaderName::from_static("x-synthetic-trusted-server");
+pub const HEADER_X_FORWARDED_FOR: HeaderName = HeaderName::from_static("x-forwarded-for");

crates/common/src/constants.rs

@@ -1,6 +1,7 @@
 use cookie::{Cookie, CookieJar};
 use fastly::http::header;
-use fastly::Request;
+
+use crate::http_wrapper::RequestWrapper;
 
 const COOKIE_MAX_AGE: i32 = 365 * 24 * 60 * 60; // 1 year
 
@@ -17,7 +18,7 @@ pub fn parse_cookies_to_jar(s: &str) -> CookieJar {
     jar
 }
 
-pub fn handle_request_cookies(req: &Request) -> Option<CookieJar> {
+pub fn handle_request_cookies<T: RequestWrapper>(req: &T) -> Option<CookieJar> {
     match req.get_header(header::COOKIE) {
         Some(header_value) => {
             let header_value_str: &str = header_value.to_str().unwrap_or("");

crates/common/src/cookies.rs

@@ -0,0 +1,20 @@
+use http::Method;
+use http::header::{HeaderName, HeaderValue};
+use std::net::IpAddr;
+
+pub trait RequestWrapper {
+    fn get_client_ip_addr(&self) -> Option<IpAddr>;
+
+    fn get_header(
+        &self,
+        name: HeaderName,
+    ) -> Option<&HeaderValue>;
+
+    fn get_headers(&self) -> impl Iterator<Item = (&HeaderName, &HeaderValue)>;
+
+    fn get_method(&self) -> &Method;
+
+    fn get_path(&self) -> &str;
+
+    fn set_header(&mut self, name: HeaderName, value: HeaderValue);
+}

crates/common/src/http_wrapper.rs

@@ -1,5 +1,6 @@
 pub mod constants;
 pub mod cookies;
+pub mod http_wrapper;
 pub mod models;
 pub mod prebid;
 pub mod settings;

crates/common/src/lib.rs

@@ -2,7 +2,8 @@ use fastly::http::{header, Method};
 use fastly::{Error, Request, Response};
 use serde_json::json;
 
-use crate::constants::{SYNTHETIC_HEADER_FRESH, SYNTHETIC_HEADER_TRUSTED_SERVER};
+use crate::constants::{HEADER_X_FORWARDED_FOR, HEADER_SYNTHETIC_FRESH, HEADER_SYNTHETIC_TRUSTED_SERVER};
+use crate::http_wrapper::RequestWrapper;
 use crate::settings::Settings;
 use crate::synthetic::generate_synthetic_id;
 
@@ -28,10 +29,10 @@ impl PrebidRequest {
     ///
     /// # Returns
     /// * `Result<Self, Error>` - New PrebidRequest or error
-    pub fn new(settings: &Settings, req: &Request) -> Result<Self, Error> {
+    pub fn new<T: RequestWrapper>(settings: &Settings, req: &T) -> Result<Self, Error> {
         // Get the POTSI ID from header (which we just set in handle_prebid_test)
         let synthetic_id = req
-            .get_header(SYNTHETIC_HEADER_TRUSTED_SERVER)
+            .get_header(HEADER_SYNTHETIC_TRUSTED_SERVER)
             .and_then(|h| h.to_str().ok())
             .map(|s| s.to_string())
             .unwrap_or_else(|| generate_synthetic_id(settings, req));
@@ -41,7 +42,7 @@ impl PrebidRequest {
             .get_client_ip_addr()
             .map(|ip| ip.to_string())
             .unwrap_or_else(|| {
-                req.get_header("X-Forwarded-For")
+                req.get_header(HEADER_X_FORWARDED_FOR)
                     .and_then(|h| h.to_str().ok())
                     .unwrap_or("")
                     .split(',') // X-Forwarded-For can be a comma-separated list
@@ -89,16 +90,16 @@ impl PrebidRequest {
     ///
     /// # Returns
     /// * `Result<Response, Error>` - Prebid Server response or error
-    pub async fn send_bid_request(
+    pub async fn send_bid_request<T: RequestWrapper>(
         &self,
         settings: &Settings,
-        incoming_req: &Request,
+        incoming_req: &T,
     ) -> Result<Response, Error> {
         let mut req = Request::new(Method::POST, settings.prebid.server_url.to_owned());
 
         // Get and store the POTSI ID value from the incoming request
         let potsi_id = incoming_req
-            .get_header(SYNTHETIC_HEADER_TRUSTED_SERVER)
+            .get_header(HEADER_SYNTHETIC_TRUSTED_SERVER)
             .and_then(|h| h.to_str().ok())
             .map(|s| s.to_string())
             .unwrap_or_else(|| self.synthetic_id.clone());
@@ -169,8 +170,8 @@ impl PrebidRequest {
         req.set_header(header::CONTENT_TYPE, "application/json");
         req.set_header("X-Forwarded-For", &self.client_ip);
         req.set_header(header::ORIGIN, &self.origin);
-        req.set_header(SYNTHETIC_HEADER_FRESH, &self.synthetic_id);
-        req.set_header(SYNTHETIC_HEADER_TRUSTED_SERVER, &potsi_id);
+        req.set_header(HEADER_SYNTHETIC_FRESH, &self.synthetic_id);
+        req.set_header(HEADER_SYNTHETIC_TRUSTED_SERVER, &potsi_id);
 
         println!(
             "Sending prebid request with Fresh ID: {} and POTSI ID: {}",

crates/common/src/prebid.rs

@@ -1,18 +1,18 @@
 use fastly::http::header;
-use fastly::Request;
 use handlebars::Handlebars;
 use hmac::{Hmac, Mac};
 use serde_json::json;
 use sha2::Sha256;
 
-use crate::constants::{SYNTHETIC_HEADER_PUB_USER_ID, SYNTHETIC_HEADER_TRUSTED_SERVER};
+use crate::constants::{HEADER_SYNTHETIC_PUB_USER_ID, HEADER_SYNTHETIC_TRUSTED_SERVER};
 use crate::cookies::handle_request_cookies;
+use crate::http_wrapper::RequestWrapper;
 use crate::settings::Settings;
 
 type HmacSha256 = Hmac<Sha256>;
 
 /// Generates a fresh synthetic_id based on request parameters
-pub fn generate_synthetic_id(settings: &Settings, req: &Request) -> String {
+pub fn generate_synthetic_id<T: RequestWrapper>(settings: &Settings, req: &T) -> String {
     let user_agent = req
         .get_header(header::USER_AGENT)
         .map(|h| h.to_str().unwrap_or("unknown"));
@@ -21,7 +21,7 @@ pub fn generate_synthetic_id(settings: &Settings, req: &Request) -> String {
             .map(|cookie| cookie.value().to_string())
     });
     let auth_user_id = req
-        .get_header(SYNTHETIC_HEADER_PUB_USER_ID)
+        .get_header(HEADER_SYNTHETIC_PUB_USER_ID)
         .map(|h| h.to_str().unwrap_or("anonymous"));
     let publisher_domain = req
         .get_header(header::HOST)
@@ -58,10 +58,10 @@ pub fn generate_synthetic_id(settings: &Settings, req: &Request) -> String {
 }
 
 /// Gets or creates a synthetic_id from the request
-pub fn get_or_generate_synthetic_id(settings: &Settings, req: &Request) -> String {
+pub fn get_or_generate_synthetic_id<T: RequestWrapper>(settings: &Settings, req: &T) -> String {
     // First try to get existing POTSI ID from header
     if let Some(synthetic_id) = req
-        .get_header(SYNTHETIC_HEADER_TRUSTED_SERVER)
+        .get_header(HEADER_SYNTHETIC_TRUSTED_SERVER)
         .and_then(|h| h.to_str().ok())
         .map(|s| s.to_string())
     {
@@ -148,7 +148,7 @@ mod tests {
     fn test_get_or_generate_synthetic_id_with_header() {
         let settings = create_settings();
         let req = create_test_request(vec![(
-            SYNTHETIC_HEADER_TRUSTED_SERVER,
+            HEADER_SYNTHETIC_TRUSTED_SERVER,
             "existing_synthetic_id",
         )]);
 

crates/common/src/synthetic.rs

@@ -6,6 +6,7 @@ edition = "2021"
 [dependencies]
 fastly = "0.11.2"
 futures = "0.3"
+http = "1.3.1"
 log = "0.4.20"
 log-fastly = "0.10.0"
 serde = { version = "1.0", features = ["derive"] }

crates/fastly/Cargo.toml

@@ -0,0 +1,49 @@
+use fastly::Request as FastlyRequest;
+use http::header::{HeaderName, HeaderValue};
+use http::Method;
+use std::net::IpAddr;
+
+use trusted_server_common::http_wrapper::RequestWrapper;
+
+#[derive(Debug)]
+pub struct FastlyRequestWrapper {
+    request: FastlyRequest,
+}
+
+impl FastlyRequestWrapper {
+    pub fn new(request: FastlyRequest) -> Self {
+        FastlyRequestWrapper { request }
+    }
+}
+
+impl RequestWrapper for FastlyRequestWrapper {
+    #[inline(always)]
+    fn get_client_ip_addr(&self) -> Option<IpAddr> {
+        self.request.get_client_ip_addr()
+    }
+
+    #[inline(always)]
+    fn get_header(&self, name: HeaderName) -> Option<&HeaderValue> {
+        self.request.get_header(name)
+    }
+
+    #[inline(always)]
+    fn get_headers(&self) -> impl Iterator<Item = (&HeaderName, &HeaderValue)> {
+        self.request.get_headers()
+    }
+
+    #[inline(always)]
+    fn get_method(&self) -> &Method {
+        self.request.get_method()
+    }
+
+    #[inline(always)]
+    fn get_path(&self) -> &str {
+        self.request.get_path()
+    }
+
+    #[inline(always)]
+    fn set_header(&mut self, name: HeaderName, value: HeaderValue) {
+        self.request.set_header(name, value)
+    }
+}