add logging

Author: eserilev

Cargo.toml

@@ -23,6 +23,7 @@ ethereum_ssz_derive = "0.7"
 flate2 = "1.0"
 futures = "0.3.30"
 http = "1"
+mediatype = "0.19.13"
 reqwest = { version = "0.12.5", features = ["json"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1", features = ["raw_value"] }

builder-server/src/server.rs

@@ -1,3 +1,5 @@
+use std::str::FromStr;
+
 use axum::{
     body::Body,
     extract::{Path, State},
@@ -11,9 +13,13 @@ use builder_api_types::{
     SignedValidatorRegistrationData, Slot,
 };
 use ethereum_apis_common::{
-    build_response, build_response_with_headers, ContentType, JsonOrSszWithFork,
+    build_response, build_response_with_headers, Accept, ContentType, JsonOrSszWithFork,
+};
+use http::{
+    header::{ACCEPT, CONTENT_TYPE},
+    HeaderMap,
 };
-use http::{header::CONTENT_TYPE, HeaderMap};
+use tracing::info;
 
 use crate::builder::Builder;
 
@@ -89,12 +95,21 @@ where
     I: AsRef<A> + Send + Sync,
     A: Builder<E>,
 {
-    let content_type_header = headers.get(CONTENT_TYPE);
-    let content_type = content_type_header.and_then(|value| value.to_str().ok());
-    let content_type = match content_type {
-        Some("application/octet-stream") => ContentType::Ssz,
-        _ => ContentType::Json,
+    let content_type_header = headers.get(ACCEPT);
+    let content_type_str = content_type_header
+        .and_then(|value| value.to_str().ok())
+        .unwrap_or("application/json");
+    let content_type = match Accept::from_str(content_type_str) {
+        Ok(Accept::Ssz) => {
+            info!("REQUESTED SSZ");
+            ContentType::Ssz
+        },
+        _ => {
+            info!("REQUESTED JSON");
+            ContentType::Json
+        },
     };
+
     let res = api_impl
         .as_ref()
         .get_header(slot, parent_hash, pubkey)

common/Cargo.toml

@@ -11,6 +11,7 @@ ethereum_ssz.workspace = true
 flate2.workspace = true
 futures.workspace = true
 http.workspace = true
+mediatype.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 tokio.workspace = true

common/src/lib.rs

@@ -12,9 +12,10 @@ use bytes::Bytes;
 use flate2::read::GzDecoder;
 use http::header::CONTENT_ENCODING;
 use http::{header::CONTENT_TYPE, HeaderValue, StatusCode};
+use mediatype::{names, MediaType, MediaTypeList};
 use serde::{Deserialize, Serialize};
 use ssz::Encode;
-use std::{io::Read, str::FromStr};
+use std::{fmt, io::Read, str::FromStr};
 use tracing::error;
 
 pub const CONSENSUS_VERSION_HEADER: &str = "Eth-Consensus-Version";
@@ -464,3 +465,78 @@ where
         Ok(Self(result))
     }
 }
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Accept {
+    Json,
+    Ssz,
+    Any,
+}
+
+impl fmt::Display for Accept {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Accept::Ssz => write!(f, "application/octet-stream"),
+            Accept::Json => write!(f, "application/json"),
+            Accept::Any => write!(f, "*/*"),
+        }
+    }
+}
+
+impl FromStr for Accept {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let media_type_list = MediaTypeList::new(s);
+
+        // [q-factor weighting]: https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2
+        // find the highest q-factor supported accept type
+        let mut highest_q = 0_u16;
+        let mut accept_type = None;
+
+        const APPLICATION: &str = names::APPLICATION.as_str();
+        const OCTET_STREAM: &str = names::OCTET_STREAM.as_str();
+        const JSON: &str = names::JSON.as_str();
+        const STAR: &str = names::_STAR.as_str();
+        const Q: &str = names::Q.as_str();
+
+        media_type_list.into_iter().for_each(|item| {
+            if let Ok(MediaType {
+                ty,
+                subty,
+                suffix: _,
+                params,
+            }) = item
+            {
+                let q_accept = match (ty.as_str(), subty.as_str()) {
+                    (APPLICATION, OCTET_STREAM) => Some(Accept::Ssz),
+                    (APPLICATION, JSON) => Some(Accept::Json),
+                    (STAR, STAR) => Some(Accept::Any),
+                    _ => None,
+                }
+                .map(|item_accept_type| {
+                    let q_val = params
+                        .iter()
+                        .find_map(|(n, v)| match n.as_str() {
+                            Q => {
+                                Some((v.as_str().parse::<f32>().unwrap_or(0_f32) * 1000_f32) as u16)
+                            }
+                            _ => None,
+                        })
+                        .or(Some(1000_u16));
+
+                    (q_val.unwrap(), item_accept_type)
+                });
+
+                match q_accept {
+                    Some((q, accept)) if q > highest_q => {
+                        highest_q = q;
+                        accept_type = Some(accept);
+                    }
+                    _ => (),
+                }
+            }
+        });
+        accept_type.ok_or_else(|| "accept header is not supported".to_string())
+    }
+}