fix: add filter chain name and host rewrite support

Enable Envoy go-control-plane integration by adding missing filter chain name field and host_rewrite_specifier support.

Signed-off-by: Eeshu-Yadav <eeshuyadav123@gmail.com>

Author: Eeshu-Yadav

.github/workflows/ci.yml

@@ -43,8 +43,17 @@ jobs:
       - name: Check formatting
         run: cargo fmt --all -- --check
 
-      - name: Run clippy (fail on warnings)
-        run: cargo clippy --all-targets --all-features -- -D warnings
+      - name: Run clippy (default features, recommended)
+        run: cargo clippy --all-targets -- -D warnings
+
+      # Optionally, test allocators individually (never together):
+      - name: Run clippy (jemalloc)
+        run: cargo clippy --all-targets --no-default-features --features jemalloc -- -D warnings
+
+      - name: Run clippy (dhat-heap)
+        run: cargo clippy --all-targets --no-default-features --features dhat-heap -- -D warnings
+
+      # Do NOT use --all-features: jemalloc and dhat-heap are mutually exclusive and will cause a build failure.
 
   # Build and test that share artifacts
   build-and-test:

CI_LINTING_GUIDE.md

@@ -37,6 +37,11 @@ git submodule update --force
 cargo build
 ```
 
+> **Note:**
+> Do **not** use `--all-features` with `cargo build` or `cargo clippy`.
+> The `jemalloc` and `dhat-heap` features are mutually exclusive and will cause a build failure if both are enabled.
+ > For CI/CD and development, use the default features. See the note in `.github/workflows/ci.yml` for more details.
+
 ### Running
 ```console
 cargo run --bin orion -- --config orion/conf/orion-runtime.yaml

README.md

@@ -1,8 +1,8 @@
 # for `disallowed_method`:
 # https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method
 disallowed-methods = [
-  { path = "orion_data_plane_api::decode::SourceFmt::Protobuf", reason = "Should not be used anymore. Use TryFrom instead." },
-  { path = "orion_data_plane_api::decode::SourceFmt::Yaml", reason = "Should not be used anymore. Use TryFrom instead." },
+  { path = "orion_data_plane_api::decode::SourceFmt::Protobuf", reason = "Should not be used anymore. Use TryFrom instead.", allow-invalid = true },
+  { path = "orion_data_plane_api::decode::SourceFmt::Yaml", reason = "Should not be used anymore. Use TryFrom instead.", allow-invalid = true },
   { path = "tokio::time::timeout", reason = "Use pingora_timeout::fast_timeout::fast_timeout instead" },
 ]
 

clippy.toml

@@ -122,7 +122,7 @@ mod envoy_conversions {
                 serde_yaml::Deserializer::from_reader(&envoy_file),
                 &mut track,
             ))
-            .with_context(|| format!("failed to deserialize {}", track.path().to_string()))?;
+            .with_context(|| format!("failed to deserialize {}", track.path()))?;
             Bootstrap::try_from(envoy).context("failed to convert into orion bootstrap")
         })()
         .with_context(|| format!("failed to read config from \"{}\"", envoy_path.as_ref().display()))
@@ -137,7 +137,7 @@ mod envoy_conversions {
                     Self { runtime: Runtime::default(), logging: Log::default(), bootstrap }
                 },
                 (Some(config), maybe_override) => {
-                    let ShimConfig { runtime, logging, bootstrap, envoy_bootstrap } = deserialize_yaml(&config)
+                    let ShimConfig { runtime, logging, bootstrap, envoy_bootstrap } = deserialize_yaml(config)
                         .with_context(|| format!("failed to deserialize \"{}\"", config.display()))?;
                     let mut bootstrap = match (bootstrap, envoy_bootstrap) {
                         (None, None) => Bootstrap::default(),
@@ -149,7 +149,7 @@ mod envoy_conversions {
                         },
                     };
                     if let Some(bootstrap_override) = maybe_override {
-                        bootstrap = bootstrap_from_path_to_envoy_bootstrap(&bootstrap_override)?;
+                        bootstrap = bootstrap_from_path_to_envoy_bootstrap(bootstrap_override)?;
                     }
                     Self { runtime, logging, bootstrap }
                 },
@@ -201,7 +201,7 @@ mod envoy_conversions {
                     let deserialized: Config = serde_yaml::from_str(&serialized)?;
                     if new_conf != deserialized {
                         tracing::info!("\n{}\n", serde_yaml::to_string(&deserialized)?);
-                        panic!("failed to roundtrip config transcoding")
+                        return Err("failed to roundtrip config transcoding".into());
                     }
                 } else {
                     tracing::info!("skipping {}", path.display())

orion-configuration/src/config.rs

@@ -127,6 +127,7 @@ mod envoy_conversions {
                 grpc_async_client_manager_config,
                 stats_flush,
                 memory_allocator_manager: _,
+                ..
             } = envoy;
             unsupported_field!(
                 // node,

orion-configuration/src/config/bootstrap.rs

@@ -251,6 +251,7 @@ mod envoy_conversions {
     };
     use std::{collections::BTreeSet, net::SocketAddr, num::NonZeroU32};
 
+    #[allow(clippy::too_many_lines)]
     impl TryFrom<EnvoyCluster> for Cluster {
         type Error = GenericError;
         fn try_from(envoy: EnvoyCluster) -> Result<Self, Self::Error> {
@@ -496,10 +497,10 @@ mod envoy_conversions {
                 }
                 Ok(Self { endpoints })
             })();
-            if !cluster_name.is_empty() {
-                ret.with_name(cluster_name)
-            } else {
+            if cluster_name.is_empty() {
                 ret
+            } else {
+                ret.with_name(cluster_name)
             }
         }
     }
@@ -677,7 +678,7 @@ mod envoy_conversions {
                 SupportedEnvoyTransportSocket::DownstreamTlsContext(_) => {
                     Err(GenericError::unsupported_variant("DownstreamTlsContext"))
                 },
-                SupportedEnvoyTransportSocket::UpstreamTlsContext(x) => x.try_into(),
+                SupportedEnvoyTransportSocket::UpstreamTlsContext(x) => (*x).try_into(),
             }
         }
     }

orion-configuration/src/config/cluster.rs

@@ -55,7 +55,7 @@ pub struct ClusterHealthCheck {
     /// An optional jitter amount from 0.0 to 1.0.
     /// If specified, during every interval we will add `interval` * `interval_jitter_percent` to the wait time.
     /// If `interval_jitter` and `interval_jitter_percent` are both set, both of them will be used to increase the wait time.
-    #[serde(skip_serializing_if = "f32_is_zero", default = "Default::default")]
+    #[serde(skip_serializing_if = "crate::config::cluster::health_check::f32_is_zero", default = "Default::default")]
     pub interval_jitter_percent: f32,
     /// The “unhealthy interval” is a health check interval that is used for hosts that are marked as unhealthy.
     /// As soon as the host is marked as healthy, Envoy will shift back to using the standard health check
@@ -79,7 +79,8 @@ pub struct ClusterHealthCheck {
     pub healthy_edge_interval: Option<Duration>,
 }
 
-fn f32_is_zero(x: &f32) -> bool {
+#[allow(clippy::trivially_copy_pass_by_ref)]
+pub fn f32_is_zero(x: &f32) -> bool {
     *x == 0.0
 }
 
@@ -197,8 +198,9 @@ pub struct HttpHealthCheck {
     pub path: Option<PathAndQuery>,
 }
 
+#[allow(clippy::range_plus_one)]
 fn default_expected_statuses() -> Vec<Range<u16>> {
-    vec![200..201]
+    (200..201).map(|n| n..n + 1).collect()
 }
 
 fn is_default_expected_statuses(value: &Vec<Range<u16>>) -> bool {
@@ -282,6 +284,7 @@ mod envoy_conversions {
     };
     use std::{ops::Range, str::FromStr};
 
+    #[allow(clippy::too_many_lines)]
     impl TryFrom<EnvoyHealthCheck> for HealthCheck {
         type Error = GenericError;
         fn try_from(value: EnvoyHealthCheck) -> Result<Self, Self::Error> {
@@ -348,7 +351,9 @@ mod envoy_conversions {
                 GenericError::from_msg_with_cause("failed to convert {interval_jitter} to std::time::Duration", e)
                     .with_node("interval_jitter")
             })?;
+            #[allow(clippy::cast_precision_loss)]
             let interval_jitter_percent = {
+                #[allow(clippy::cast_precision_loss)]
                 let as_float = interval_jitter_percent as f32;
                 if !as_float.is_finite() || as_float > 1.0 || as_float.is_sign_negative() {
                     Err(GenericError::from_msg(format!(
@@ -357,8 +362,7 @@ mod envoy_conversions {
                 } else {
                     Ok(as_float)
                 }
-            }
-            .with_node("interval_jitter_percent")?;
+            }?;
             let unhealthy_threshold = required!(unhealthy_threshold)?.value;
             let unhealthy_threshold = unhealthy_threshold
                 .try_into()
@@ -431,6 +435,7 @@ mod envoy_conversions {
                 } else if start < 100 || end >= 600 {
                     Err(GenericError::from_msg("invalid range [{start},{end}). Range has to be within [100,600)."))
                 } else {
+                    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
                     Ok((start as u16)..(end as u16))
                 }
             })

orion-configuration/src/config/cluster/health_check.rs

@@ -78,7 +78,7 @@ enum ExplicitProtocolOptions {
 
 impl Default for ExplicitProtocolOptions {
     fn default() -> Self {
-        Self::Http1(Http1ProtocolOptions::default())
+        Self::Http1(Http1ProtocolOptions)
     }
 }
 
@@ -101,7 +101,7 @@ pub struct Http2ProtocolOptions {
 
 impl Http2ProtocolOptions {
     pub fn max_concurrent_streams(&self) -> Option<usize> {
-        self.max_concurrent_streams.map(usize::from)
+        self.max_concurrent_streams
     }
     pub fn initial_stream_window_size(&self) -> Option<u32> {
         self.initial_stream_window_size.map(u32::from)
@@ -239,10 +239,10 @@ mod envoy_conversions {
             let common = common_http_protocol_options.map(CommonHttpOptions::try_from).transpose()?.unwrap_or_default();
             let (codec, http1_options, http2_options) = match upstream_protocol_options {
                 UpstreamHttpProtocolOptions::Explicit(ExplicitProtocolOptions::Http1(http1)) => {
-                    (Codec::Http1, http1, Default::default())
+                    (Codec::Http1, http1, Http2ProtocolOptions::default())
                 },
                 UpstreamHttpProtocolOptions::Explicit(ExplicitProtocolOptions::Http2(http2)) => {
-                    (Codec::Http2, Default::default(), http2)
+                    (Codec::Http2, Http1ProtocolOptions, http2)
                 },
             };
 

orion-configuration/src/config/cluster/http_protocol_options.rs

@@ -88,7 +88,7 @@ impl<'a> DataSourceReader<'a> {
     }
 }
 
-impl<'a> Read for DataSourceReader<'a> {
+impl Read for DataSourceReader<'_> {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         match self {
             Self::OwnedBytes { bytes, read } => {
@@ -105,7 +105,7 @@ impl<'a> Read for DataSourceReader<'a> {
     }
 }
 
-impl<'a> BufRead for DataSourceReader<'a> {
+impl BufRead for DataSourceReader<'_> {
     fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
         match self {
             Self::OwnedBytes { bytes, read } => Ok(&bytes[*read..]),
@@ -134,7 +134,7 @@ pub struct StringMatcher {
 }
 
 pub(crate) struct CaseSensitive<'a>(pub bool, pub &'a str);
-impl<'a> CaseSensitive<'a> {
+impl CaseSensitive<'_> {
     #[inline]
     pub fn equals(&self, b: &str) -> bool {
         if self.0 {