feat(s2n-events): Add config option to generate C API (#2818)

goatgoose · web-flow · commit 9b89de7f8fb9 · 2025-09-25T14:41:28.000-04:00
diff --git a/tools/event-generator/src/main.rs b/tools/event-generator/src/main.rs
@@ -61,9 +61,7 @@ impl EventInfo<'_> {
                 env!("CARGO_MANIFEST_DIR"),
                 "/../../quic/s2n-quic-core/src/event"
             ),
-            generate_config: GenerateConfig {
-                mode: OutputMode::Mut,
-            },
+            generate_config: GenerateConfig::default(),
             s2n_quic_core_path: quote!(crate),
             api: quote!(),
             builder: quote!(),
@@ -112,6 +110,7 @@ impl EventInfo<'_> {
             ),
             generate_config: GenerateConfig {
                 mode: OutputMode::Ref,
+                ..Default::default()
             },
             s2n_quic_core_path: quote!(s2n_quic_core),
             api: quote! {
diff --git a/tools/s2n-events/src/bin/generate_test_events.rs b/tools/s2n-events/src/bin/generate_test_events.rs
@@ -3,15 +3,15 @@
 
 use proc_macro2::TokenStream;
 use quote::quote;
-use s2n_events::{parser, validation, Output, Result};
+use s2n_events::{parser, validation, GenerateConfig, Output, OutputMode, Result};
 
 struct EventInfo<'a> {
     input_path: &'a str,
     output_path: &'a str,
     crate_name: &'a str,
     s2n_quic_core_path: TokenStream,
-    builder: TokenStream,
     tracing_subscriber_def: TokenStream,
+    config: GenerateConfig,
 }
 
 impl EventInfo<'_> {
@@ -48,10 +48,11 @@ impl EventInfo<'_> {
             ),
             output_path: concat!(env!("CARGO_MANIFEST_DIR"), "/tests/c_ffi_events/event"),
             s2n_quic_core_path: quote!(s2n_quic_core),
-            builder: quote! {
-                pub use s2n_quic_core::event::builder::SocketAddress;
-            },
             tracing_subscriber_def,
+            config: GenerateConfig {
+                mode: OutputMode::Mut,
+                c_api: true,
+            },
         }
     }
 }
@@ -83,10 +84,10 @@ fn main() -> Result<()> {
 
         let mut output = Output {
             s2n_quic_core_path: event_info.s2n_quic_core_path,
-            builders: event_info.builder,
             tracing_subscriber_def: event_info.tracing_subscriber_def,
             crate_name: event_info.crate_name,
             root,
+            config: event_info.config,
             ..Default::default()
         };
 
diff --git a/tools/s2n-events/src/generate_config.rs b/tools/s2n-events/src/generate_config.rs
@@ -32,6 +32,7 @@ impl OutputMode {
 #[derive(Debug, Default)]
 pub struct GenerateConfig {
     pub mode: OutputMode,
+    pub c_api: bool,
 }
 
 impl GenerateConfig {
@@ -143,10 +144,23 @@ impl GenerateConfig {
         }
     }
 
-    pub fn supervisor(&self) -> TokenStream {
+    fn supervisor_supported(&self) -> bool {
+        // The supervisor feature will require additional effort to expose a C API for. For now,
+        // this feature is disabled for simplicity.
+        if self.c_api {
+            return false;
+        }
+
         match self.mode {
-            OutputMode::Ref => quote!(),
-            OutputMode::Mut => quote!(
+            OutputMode::Ref => false,
+            OutputMode::Mut => true,
+        }
+    }
+
+    pub fn supervisor(&self) -> TokenStream {
+        match self.supervisor_supported() {
+            false => quote!(),
+            true => quote!(
                 pub mod supervisor {
                     //! This module contains the `supervisor::Outcome` and `supervisor::Context` for use
                     //! when implementing [`Subscriber::supervisor_timeout`](crate::event::Subscriber::supervisor_timeout) and
@@ -214,9 +228,9 @@ impl GenerateConfig {
     }
 
     pub fn supervisor_timeout(&self) -> TokenStream {
-        match self.mode {
-            OutputMode::Ref => quote!(),
-            OutputMode::Mut => quote!(
+        match self.supervisor_supported() {
+            false => quote!(),
+            true => quote!(
                 /// The period at which `on_supervisor_timeout` is called
                 ///
                 /// If multiple `event::Subscriber`s are composed together, the minimum `supervisor_timeout`
@@ -257,9 +271,9 @@ impl GenerateConfig {
     }
 
     pub fn supervisor_timeout_tuple(&self) -> TokenStream {
-        match self.mode {
-            OutputMode::Ref => quote!(),
-            OutputMode::Mut => quote!(
+        match self.supervisor_supported() {
+            false => quote!(),
+            true => quote!(
                 #[inline]
                 fn supervisor_timeout(
                     &mut self,
diff --git a/tools/s2n-events/tests/c_ffi_events/event/generated.rs b/tools/s2n-events/tests/c_ffi_events/event/generated.rs
@@ -217,7 +217,6 @@ pub mod tracing {
 }
 pub mod builder {
     use super::*;
-    pub use s2n_quic_core::event::builder::SocketAddress;
     #[derive(Clone, Debug)]
     pub struct ConnectionMeta {
         pub id: u64,
@@ -323,58 +322,6 @@ pub mod builder {
         }
     }
 }
-pub mod supervisor {
-    #![doc = r" This module contains the `supervisor::Outcome` and `supervisor::Context` for use"]
-    #![doc = r" when implementing [`Subscriber::supervisor_timeout`](crate::event::Subscriber::supervisor_timeout) and"]
-    #![doc = r" [`Subscriber::on_supervisor_timeout`](crate::event::Subscriber::on_supervisor_timeout)"]
-    #![doc = r" on a Subscriber."]
-    use crate::{
-        application,
-        event::{builder::SocketAddress, IntoEvent},
-    };
-    #[non_exhaustive]
-    #[derive(Clone, Debug, Eq, PartialEq)]
-    pub enum Outcome {
-        #[doc = r" Allow the connection to remain open"]
-        Continue,
-        #[doc = r" Close the connection and notify the peer"]
-        Close { error_code: application::Error },
-        #[doc = r" Close the connection without notifying the peer"]
-        ImmediateClose { reason: &'static str },
-    }
-    impl Default for Outcome {
-        fn default() -> Self {
-            Self::Continue
-        }
-    }
-    #[non_exhaustive]
-    #[derive(Debug)]
-    pub struct Context<'a> {
-        #[doc = r" Number of handshakes that have begun but not completed"]
-        pub inflight_handshakes: usize,
-        #[doc = r" Number of open connections"]
-        pub connection_count: usize,
-        #[doc = r" The address of the peer"]
-        pub remote_address: SocketAddress<'a>,
-        #[doc = r" True if the connection is in the handshake state, false otherwise"]
-        pub is_handshaking: bool,
-    }
-    impl<'a> Context<'a> {
-        pub fn new(
-            inflight_handshakes: usize,
-            connection_count: usize,
-            remote_address: &'a crate::inet::SocketAddress,
-            is_handshaking: bool,
-        ) -> Self {
-            Self {
-                inflight_handshakes,
-                connection_count,
-                remote_address: remote_address.into_event(),
-                is_handshaking,
-            }
-        }
-    }
-}
 pub use traits::*;
 mod traits {
     use super::*;
@@ -432,40 +379,6 @@ mod traits {
             meta: &api::ConnectionMeta,
             info: &api::ConnectionInfo,
         ) -> Self::ConnectionContext;
-        #[doc = r" The period at which `on_supervisor_timeout` is called"]
-        #[doc = r""]
-        #[doc = r" If multiple `event::Subscriber`s are composed together, the minimum `supervisor_timeout`"]
-        #[doc = r" across all `event::Subscriber`s will be used."]
-        #[doc = r""]
-        #[doc = r" If the `supervisor_timeout()` is `None` across all `event::Subscriber`s, connection supervision"]
-        #[doc = r" will cease for the remaining lifetime of the connection and `on_supervisor_timeout` will no longer"]
-        #[doc = r" be called."]
-        #[doc = r""]
-        #[doc = r" It is recommended to avoid setting this value less than ~100ms, as short durations"]
-        #[doc = r" may lead to higher CPU utilization."]
-        #[allow(unused_variables)]
-        fn supervisor_timeout(
-            &mut self,
-            conn_context: &mut Self::ConnectionContext,
-            meta: &api::ConnectionMeta,
-            context: &supervisor::Context,
-        ) -> Option<Duration> {
-            None
-        }
-        #[doc = r" Called for each `supervisor_timeout` to determine any action to take on the connection based on the `supervisor::Outcome`"]
-        #[doc = r""]
-        #[doc = r" If multiple `event::Subscriber`s are composed together, the minimum `supervisor_timeout`"]
-        #[doc = r" across all `event::Subscriber`s will be used, and thus `on_supervisor_timeout` may be called"]
-        #[doc = r" earlier than the `supervisor_timeout` for a given `event::Subscriber` implementation."]
-        #[allow(unused_variables)]
-        fn on_supervisor_timeout(
-            &mut self,
-            conn_context: &mut Self::ConnectionContext,
-            meta: &api::ConnectionMeta,
-            context: &supervisor::Context,
-        ) -> supervisor::Outcome {
-            supervisor::Outcome::default()
-        }
         #[doc = "Called when the `ByteArrayEvent` event is triggered"]
         #[inline]
         fn on_byte_array_event(
@@ -551,50 +464,6 @@ mod traits {
             )
         }
         #[inline]
-        fn supervisor_timeout(
-            &mut self,
-            conn_context: &mut Self::ConnectionContext,
-            meta: &api::ConnectionMeta,
-            context: &supervisor::Context,
-        ) -> Option<Duration> {
-            let timeout_a = self
-                .0
-                .supervisor_timeout(&mut conn_context.0, meta, context);
-            let timeout_b = self
-                .1
-                .supervisor_timeout(&mut conn_context.1, meta, context);
-            match (timeout_a, timeout_b) {
-                (None, None) => None,
-                (None, Some(timeout)) | (Some(timeout), None) => Some(timeout),
-                (Some(a), Some(b)) => Some(a.min(b)),
-            }
-        }
-        #[inline]
-        fn on_supervisor_timeout(
-            &mut self,
-            conn_context: &mut Self::ConnectionContext,
-            meta: &api::ConnectionMeta,
-            context: &supervisor::Context,
-        ) -> supervisor::Outcome {
-            let outcome_a = self
-                .0
-                .on_supervisor_timeout(&mut conn_context.0, meta, context);
-            let outcome_b = self
-                .1
-                .on_supervisor_timeout(&mut conn_context.1, meta, context);
-            match (outcome_a, outcome_b) {
-                (supervisor::Outcome::ImmediateClose { reason }, _)
-                | (_, supervisor::Outcome::ImmediateClose { reason }) => {
-                    supervisor::Outcome::ImmediateClose { reason }
-                }
-                (supervisor::Outcome::Close { error_code }, _)
-                | (_, supervisor::Outcome::Close { error_code }) => {
-                    supervisor::Outcome::Close { error_code }
-                }
-                _ => supervisor::Outcome::Continue,
-            }
-        }
-        #[inline]
         fn on_byte_array_event(
             &mut self,
             context: &mut Self::ConnectionContext,
diff --git a/tools/s2n-events/tests/test_c_ffi_events.rs b/tools/s2n-events/tests/test_c_ffi_events.rs
@@ -6,9 +6,7 @@ mod c_ffi_events;
 pub use c_ffi_events::event;
 use c_ffi_events::event::ConnectionPublisher;
 use s2n_quic_core::{
-    application,
     event::IntoEvent,
-    inet,
     time::{testing::Clock as MockClock, Clock},
 };
 
