Skip to main content

hyperlane_core/server/
impl.rs

1use super::*;
2
3/// Provides a default implementation for Server.
4impl Default for Server {
5    /// Creates a new Server instance with default values.
6    ///
7    /// # Returns
8    ///
9    /// - `Self` - A new instance with default configuration.
10    #[inline(always)]
11    fn default() -> Self {
12        Self {
13            server_config: ServerConfig::default(),
14            request_config: RequestConfig::default(),
15            task_panic: Vec::new(),
16            request_error: Vec::new(),
17            route_matcher: RouteMatcher::new(),
18            request_middleware: Vec::new(),
19            response_middleware: Vec::new(),
20        }
21    }
22}
23
24/// Implements the `PartialEq` trait for `Server`.
25///
26/// This allows for comparing two `Server` instances for equality.
27impl PartialEq for Server {
28    /// Checks if two `Server` instances are equal.
29    ///
30    /// # Arguments
31    ///
32    /// - `&Self` - The other `Server` instance to compare against.
33    ///
34    /// # Returns
35    ///
36    /// - `bool` - `true` if the instances are equal, `false` otherwise.
37    #[inline]
38    fn eq(&self, other: &Self) -> bool {
39        self.get_server_config() == other.get_server_config()
40            && self.get_request_config() == other.get_request_config()
41            && self.get_route_matcher() == other.get_route_matcher()
42            && self.get_task_panic().len() == other.get_task_panic().len()
43            && self.get_request_error().len() == other.get_request_error().len()
44            && self.get_request_middleware().len() == other.get_request_middleware().len()
45            && self.get_response_middleware().len() == other.get_response_middleware().len()
46            && self
47                .get_task_panic()
48                .iter()
49                .zip(other.get_task_panic().iter())
50                .all(|pair: (&ServerHookHandler, &ServerHookHandler)| Arc::ptr_eq(pair.0, pair.1))
51            && self
52                .get_request_error()
53                .iter()
54                .zip(other.get_request_error().iter())
55                .all(|pair: (&ServerHookHandler, &ServerHookHandler)| Arc::ptr_eq(pair.0, pair.1))
56            && self
57                .get_request_middleware()
58                .iter()
59                .zip(other.get_request_middleware().iter())
60                .all(|pair: (&ServerHookHandler, &ServerHookHandler)| Arc::ptr_eq(pair.0, pair.1))
61            && self
62                .get_response_middleware()
63                .iter()
64                .zip(other.get_response_middleware().iter())
65                .all(|pair: (&ServerHookHandler, &ServerHookHandler)| Arc::ptr_eq(pair.0, pair.1))
66    }
67}
68
69/// Implements the `Eq` trait for `Server`.
70///
71/// This indicates that `Server` has a total equality relation.
72impl Eq for Server {}
73
74/// Implementation of `From` trait for converting `usize` address into `Server`.
75impl From<usize> for Server {
76    /// Converts a memory address into an owned `Server` by cloning from the reference.
77    ///
78    /// # Arguments
79    ///
80    /// - `usize` - The memory address of the `Server` instance.
81    ///
82    /// # Returns
83    ///
84    /// - `Server` - A cloned `Server` instance from the given address.
85    #[inline(always)]
86    fn from(address: usize) -> Self {
87        let server: &Server = address.into();
88        server.clone()
89    }
90}
91
92/// Implementation of `From` trait for converting `usize` address into `&Server`.
93impl From<usize> for &'static Server {
94    /// Converts a memory address into a reference to `Server`.
95    ///
96    /// # Arguments
97    ///
98    /// - `usize` - The memory address of the `Server` instance.
99    ///
100    /// # Returns
101    ///
102    /// - `&'static Server` - A reference to the `Server` at the given address.
103    ///
104    /// # Safety
105    ///
106    /// - The address is guaranteed to be a valid `Server` instance
107    ///   that was previously converted from a reference and is managed by the runtime.
108    #[inline(always)]
109    fn from(address: usize) -> &'static Server {
110        unsafe { &*(address as *const Server) }
111    }
112}
113
114/// Implementation of `From` trait for converting `usize` address into `&mut Server`.
115impl From<usize> for &'static mut Server {
116    /// Converts a memory address into a mutable reference to `Server`.
117    ///
118    /// # Arguments
119    ///
120    /// - `usize` - The memory address of the `Server` instance.
121    ///
122    /// # Returns
123    ///
124    /// - `&'static mut Server` - A mutable reference to the `Server` at the given address.
125    ///
126    /// # Safety
127    ///
128    /// - The address is guaranteed to be a valid `Server` instance
129    ///   that was previously converted from a reference and is managed by the runtime.
130    #[inline(always)]
131    fn from(address: usize) -> &'static mut Server {
132        unsafe { &mut *(address as *mut Server) }
133    }
134}
135
136/// Implementation of `From` trait for converting `&Server` into `usize` address.
137impl From<&Server> for usize {
138    /// Converts a reference to `Server` into its memory address.
139    ///
140    /// # Arguments
141    ///
142    /// - `&Server` - The reference to the `Server` instance.
143    ///
144    /// # Returns
145    ///
146    /// - `usize` - The memory address of the `Server` instance.
147    #[inline(always)]
148    fn from(server: &Server) -> Self {
149        server as *const Server as usize
150    }
151}
152
153/// Implementation of `From` trait for converting `&mut Server` into `usize` address.
154impl From<&mut Server> for usize {
155    /// Converts a mutable reference to `Server` into its memory address.
156    ///
157    /// # Arguments
158    ///
159    /// - `&mut Server` - The mutable reference to the `Server` instance.
160    ///
161    /// # Returns
162    ///
163    /// - `usize` - The memory address of the `Server` instance.
164    #[inline(always)]
165    fn from(server: &mut Server) -> Self {
166        server as *mut Server as usize
167    }
168}
169
170/// Implementation of `AsRef` trait for `Server`.
171impl AsRef<Server> for Server {
172    /// Converts `&Server` to `&Server` via memory address conversion.
173    ///
174    /// # Returns
175    ///
176    /// - `&Self` - A reference to the `Server` instance.
177    #[inline(always)]
178    fn as_ref(&self) -> &Self {
179        let address: usize = self.into();
180        address.into()
181    }
182}
183
184/// Implementation of `AsMut` trait for `Server`.
185impl AsMut<Server> for Server {
186    /// Converts `&mut Server` to `&mut Server` via memory address conversion.
187    ///
188    /// # Returns
189    ///
190    /// - `&mut Self` - A mutable reference to the `Server` instance.
191    #[inline(always)]
192    fn as_mut(&mut self) -> &mut Self {
193        let address: usize = self.into();
194        address.into()
195    }
196}
197
198/// Converts a `ServerConfig` into a `Server` instance.
199///
200/// This allows creating a `Server` directly from its configuration,
201/// using default values for other fields.
202impl From<ServerConfig> for Server {
203    /// Creates a new `Server` instance from the given `ServerConfig`.
204    ///
205    /// # Arguments
206    ///
207    /// - `ServerConfig` - The server configuration to use.
208    ///
209    /// # Returns
210    ///
211    /// - `Self` - A new `Server` instance with the provided configuration.
212    #[inline(always)]
213    fn from(server_config: ServerConfig) -> Self {
214        Self {
215            server_config,
216            ..Default::default()
217        }
218    }
219}
220
221/// Converts a `RequestConfig` into a `Server` instance.
222///
223/// This allows creating a `Server` directly from its request configuration,
224/// using default values for other fields.
225impl From<RequestConfig> for Server {
226    /// Creates a new `Server` instance from the given `RequestConfig`.
227    ///
228    /// # Arguments
229    ///
230    /// - `RequestConfig` - The request configuration to use.
231    ///
232    /// # Returns
233    ///
234    /// - `Self` - A new `Server` instance with the provided request configuration.
235    #[inline(always)]
236    fn from(request_config: RequestConfig) -> Self {
237        Self {
238            request_config,
239            ..Default::default()
240        }
241    }
242}
243
244/// Implementation of `Lifetime` trait for `Server`.
245impl Lifetime for Server {
246    /// Converts a reference to the server into a `'static` reference.
247    ///
248    /// # Returns
249    ///
250    /// - `&'static Self` - A reference to the server with a `'static` lifetime.
251    ///
252    /// # Safety
253    ///
254    /// - The address is guaranteed to be a valid `Server` instance
255    ///   that was previously converted from a reference and is managed by the runtime.
256    #[inline(always)]
257    unsafe fn leak(&self) -> &'static Self {
258        let address: usize = self.into();
259        address.into()
260    }
261
262    /// Converts a reference to the server into a `'static` mutable reference.
263    ///
264    /// # Returns
265    ///
266    /// - `&'static mut Self` - A mutable reference to the server with a `'static` lifetime.
267    ///
268    /// # Safety
269    ///
270    /// - The address is guaranteed to be a valid `Server` instance
271    ///   that was previously converted from a reference and is managed by the runtime.
272    #[inline(always)]
273    unsafe fn leak_mut(&self) -> &'static mut Self {
274        let address: usize = self.into();
275        address.into()
276    }
277}
278
279/// Represents the server, providing methods to configure and run it.
280///
281/// This struct wraps the `Server` configuration and routing logic,
282/// offering a high-level API for setting up the HTTP and WebSocket server.
283impl Server {
284    /// Registers a hook into the server's processing pipeline.
285    ///
286    /// This function dispatches the provided `HookType` to the appropriate
287    /// internal hook collection based on its variant. The hook will be executed
288    /// at the corresponding stage of request processing according to its type:
289    /// - `Panic` - Added to panic handlers for error recovery
290    /// - `RequestError` - Added to request error handlers
291    /// - `RequestMiddleware` - Added to pre-route middleware chain
292    /// - `Route` - Registered as a route handler for the specified path
293    /// - `ResponseMiddleware` - Added to post-route middleware chain
294    ///
295    /// # Arguments
296    ///
297    /// - `HookType` - The `HookType` instance containing the hook configuration and factory.
298    #[inline]
299    pub fn handle_hook(&mut self, hook: HookType) {
300        match hook {
301            HookType::TaskPanic(_, hook) => {
302                self.get_mut_task_panic().push(hook());
303            }
304            HookType::RequestError(_, hook) => {
305                self.get_mut_request_error().push(hook());
306            }
307            HookType::RequestMiddleware(_, hook) => {
308                self.get_mut_request_middleware().push(hook());
309            }
310            HookType::Route(path, hook) => {
311                self.get_mut_route_matcher().add(path, hook()).unwrap();
312            }
313            HookType::ResponseMiddleware(_, hook) => {
314                self.get_mut_response_middleware().push(hook());
315            }
316        };
317    }
318
319    /// Sets the server configuration from a JSON string.
320    ///
321    /// # Arguments
322    ///
323    /// - `C` - The configuration.
324    ///
325    /// # Returns
326    ///
327    /// - `&mut Self` - Reference to self for method chaining.
328    #[inline]
329    pub fn config_from_json<C>(&mut self, json: C) -> &mut Self
330    where
331        C: AsRef<str>,
332    {
333        let config: ServerConfig = serde_json::from_str(json.as_ref()).unwrap();
334        self.set_server_config(config);
335        self
336    }
337
338    /// Sets the server configuration.
339    ///
340    /// # Arguments
341    ///
342    /// - `ServerConfig` - The server configuration.
343    ///
344    /// # Returns
345    ///
346    /// - `&mut Self` - Reference to self for method chaining.
347    #[inline(always)]
348    pub fn server_config(&mut self, config: ServerConfig) -> &mut Self {
349        self.set_server_config(config);
350        self
351    }
352
353    /// Sets the HTTP request config.
354    ///
355    /// # Arguments
356    ///
357    /// - `RequestConfig` - The HTTP request config to set.
358    ///
359    /// # Returns
360    ///
361    /// - `&mut Self` - Reference to self for method chaining.
362    #[inline(always)]
363    pub fn request_config(&mut self, config: RequestConfig) -> &mut Self {
364        self.set_request_config(config);
365        self
366    }
367
368    /// Registers a task panic handler to the processing pipeline.
369    ///
370    /// This method allows registering task panic handlers that implement the `ServerHook` trait,
371    /// which will be executed when a panic occurs during request processing.
372    ///
373    /// # Returns
374    ///
375    /// - `&mut Self` - Reference to self for method chaining.
376    #[inline(always)]
377    pub fn task_panic<S>(&mut self) -> &mut Self
378    where
379        S: ServerHook,
380    {
381        self.get_mut_task_panic().push(Hook::factory::<S>());
382        self
383    }
384
385    /// Registers a request error handler to the processing pipeline.
386    ///
387    /// This method allows registering request error handlers that implement the `ServerHook` trait,
388    /// which will be executed when a request error occurs during HTTP request processing.
389    ///
390    /// # Returns
391    ///
392    /// - `&mut Self` - Reference to self for method chaining.
393    #[inline(always)]
394    pub fn request_error<S>(&mut self) -> &mut Self
395    where
396        S: ServerHook,
397    {
398        self.get_mut_request_error().push(Hook::factory::<S>());
399        self
400    }
401
402    /// Registers a route hook for a specific path.
403    ///
404    /// This method allows registering route handlers that implement the `ServerHook` trait,
405    /// providing type safety and better code organization.
406    ///
407    /// # Arguments
408    ///
409    /// - `impl AsRef<str>` - The route path pattern.
410    ///
411    /// # Returns
412    ///
413    /// - `&mut Self` - Reference to self for method chaining.
414    #[inline(always)]
415    pub fn route<S>(&mut self, path: impl AsRef<str>) -> &mut Self
416    where
417        S: ServerHook,
418    {
419        self.get_mut_route_matcher()
420            .add(path.as_ref(), Hook::factory::<S>())
421            .unwrap();
422        self
423    }
424
425    /// Registers request middleware to the processing pipeline.
426    ///
427    /// This method allows registering middleware that implements the `ServerHook` trait,
428    /// which will be executed before route handlers for every incoming request.
429    ///
430    /// # Returns
431    ///
432    /// - `&mut Self` - Reference to self for method chaining.
433    #[inline(always)]
434    pub fn request_middleware<S>(&mut self) -> &mut Self
435    where
436        S: ServerHook,
437    {
438        self.get_mut_request_middleware().push(Hook::factory::<S>());
439        self
440    }
441
442    /// Registers response middleware to the processing pipeline.
443    ///
444    /// This method allows registering middleware that implements the `ServerHook` trait,
445    /// which will be executed after route handlers for every outgoing response.
446    ///
447    /// # Returns
448    ///
449    /// - `&mut Self` - Reference to self for method chaining.
450    #[inline(always)]
451    pub fn response_middleware<S>(&mut self) -> &mut Self
452    where
453        S: ServerHook,
454    {
455        self.get_mut_response_middleware()
456            .push(Hook::factory::<S>());
457        self
458    }
459
460    /// Format the host and port into a bindable address string.
461    ///
462    /// # Arguments
463    ///
464    /// - `H` - The host address.
465    /// - `u16` - The port number.
466    ///
467    /// # Returns
468    ///
469    /// - `String` - The formatted address string in the form "host:port".
470    #[inline(always)]
471    pub fn format_bind_address<H>(host: H, port: u16) -> String
472    where
473        H: AsRef<str>,
474    {
475        format!("{}{COLON}{port}", host.as_ref())
476    }
477
478    /// Flushes the standard output stream.
479    ///
480    /// # Returns
481    ///
482    /// - `io::Result<()>` - The result of the flush operation.
483    #[inline(always)]
484    pub fn try_flush_stdout() -> io::Result<()> {
485        stdout().flush()
486    }
487
488    /// Flushes the standard output stream.
489    ///
490    /// # Panics
491    ///
492    /// This function will panic if the flush operation fails.
493    #[inline(always)]
494    pub fn flush_stdout() {
495        stdout().flush().unwrap();
496    }
497
498    /// Flushes the standard error stream.
499    ///
500    /// # Returns
501    ///
502    /// - `io::Result<()>` - The result of the flush operation.
503    #[inline(always)]
504    pub fn try_flush_stderr() -> io::Result<()> {
505        stderr().flush()
506    }
507
508    /// Flushes the standard error stream.
509    ///
510    /// # Panics
511    ///
512    /// This function will panic if the flush operation fails.
513    #[inline(always)]
514    pub fn flush_stderr() {
515        stderr().flush().unwrap();
516    }
517
518    /// Flushes both the standard output and error streams.
519    ///
520    /// # Returns
521    ///
522    /// - `io::Result<()>` - The result of the flush operation.
523    #[inline(always)]
524    pub fn try_flush_stdout_and_stderr() -> io::Result<()> {
525        Self::try_flush_stdout()?;
526        Self::try_flush_stderr()
527    }
528
529    /// Flushes both the standard output and error streams.
530    ///
531    /// # Panics
532    ///
533    /// This function will panic if either flush operation fails.
534    #[inline(always)]
535    pub fn flush_stdout_and_stderr() {
536        Self::flush_stdout();
537        Self::flush_stderr();
538    }
539
540    /// Handles errors that occur while processing HTTP requests.
541    ///
542    /// # Arguments
543    ///
544    /// - `&mut Stream` - The `Stream` for the current request.
545    /// - `&mut Context` - The `Context` for the current request.
546    /// - `&RequestError` - The error that occurred.
547    pub async fn handle_request_error(
548        &self,
549        stream: &mut Stream,
550        ctx: &mut Context,
551        error: &RequestError,
552    ) {
553        ctx.set_request_error_data(error.clone());
554        stream.set_closed(false);
555        for hook in self.get_request_error().iter() {
556            if hook(stream, ctx).await.is_reject() {
557                return;
558            }
559        }
560    }
561
562    /// Handles a single client connection, looping across keep-alive requests
563    /// while reusing `ctx.request` in place without moving or reallocating it.
564    ///
565    /// # Arguments
566    ///
567    /// - `&CompiledPipeline` - The pre-compiled inline hook dispatch table.
568    /// - `&mut Stream` - The `Stream` for the current connection.
569    /// - `&mut Context` - The recycled `Context` for the connection.
570    async fn handle_connection(
571        &self,
572        pipeline: &CompiledPipeline,
573        stream: &mut Stream,
574        ctx: &mut Context,
575    ) {
576        loop {
577            match stream.try_fill_http_request(ctx.get_mut_request()).await {
578                Ok(()) => {
579                    if !pipeline.run_request(stream, ctx, None).await {
580                        return;
581                    }
582                }
583                Err(RequestError::ClientClosedConnection(_))
584                    if self.get_request_error().is_empty() =>
585                {
586                    return;
587                }
588                Err(error) => {
589                    ctx.set_original_head(None);
590                    let version: Option<HttpVersion> = h1_error_response_version(stream, &error);
591                    Box::pin(reply_to_request_error(self, stream, ctx, &error, version)).await;
592                    return;
593                }
594            }
595        }
596    }
597
598    /// Serves one HTTP/1.1 connection through the existing keep alive pipeline.
599    ///
600    /// This is the same pipeline a plaintext connection has always used: the
601    /// request parser runs in a loop, so keep alive, upgrades and raw writes
602    /// behave exactly as they did before TLS and the multiplexed protocols
603    /// existed. A handler that panics is caught here and reported through the
604    /// existing task panic hooks, so the accept loop survives it and the hooks
605    /// see the panic while the stream and context are still alive.
606    ///
607    /// # Arguments
608    ///
609    /// - `&CompiledPipeline` - The pre-compiled inline hook dispatch table.
610    /// - `&mut Stream` - The stream carrying the connection.
611    ///
612    /// # Returns
613    ///
614    /// - `()` - Resolves once the connection is finished.
615    pub(crate) async fn serve_h1_connection_stream(
616        &self,
617        pipeline: &CompiledPipeline,
618        stream: &mut Stream,
619    ) {
620        let mut ctx: Context = take_pooled_context();
621        let panicked: Option<PanicData> =
622            catch_connection_panic(self.handle_connection(pipeline, stream, &mut ctx)).await;
623        if let Some(panic) = panicked {
624            ctx.set_task_panic(panic)
625                .get_mut_response()
626                .set_status_code(HttpStatus::InternalServerError.code());
627            stream.set_closed(false);
628            for hook in self.get_task_panic().iter() {
629                if hook(stream, &mut ctx).await.is_reject() {
630                    break;
631                }
632            }
633        }
634        return_pooled_context(ctx);
635    }
636
637    /// Serves one request already populated in `ctx` over a multiplexed protocol stream.
638    ///
639    /// # Arguments
640    ///
641    /// - `&CompiledPipeline` - The pre-compiled inline hook dispatch table.
642    /// - `&mut Stream` - The stream the pipeline writes its response onto.
643    /// - `&mut Context` - The context whose request has already been filled.
644    /// - `String` - The complete original target before query-map conversion.
645    pub(crate) async fn run_protocol_lifecycle_in_place(
646        &self,
647        pipeline: &CompiledPipeline,
648        stream: &mut Stream,
649        ctx: &mut Context,
650        target: String,
651    ) {
652        let panicked: Option<PanicData> = catch_connection_panic(async {
653            let _keep_alive: bool = pipeline.run_request(stream, ctx, Some(target)).await;
654        })
655        .await;
656        let Some(panic) = panicked else {
657            return;
658        };
659        ctx.set_task_panic(panic)
660            .get_mut_response()
661            .set_status_code(HttpStatus::InternalServerError.code());
662        stream.set_closed(false);
663        for hook in self.get_task_panic().iter() {
664            if hook(stream, ctx).await.is_reject() {
665                break;
666            }
667        }
668    }
669
670    /// Starts the server, binds to the configured address, and begins listening.
671    ///
672    /// The configured protocol selects the listener. HTTP/1.1 and HTTP/2 share
673    /// the TCP listener, the latter speaking its own preface and optionally
674    /// wrapping the connection in TLS, while HTTP/3 binds a QUIC UDP endpoint.
675    /// Invalid TLS material and an HTTP/3 configuration without TLS are both
676    /// rejected before the socket is bound, so a misconfigured server fails to
677    /// start rather than accepting connections it cannot serve.
678    ///
679    /// The accept loop owns a clone of the server instead of borrowing it, so
680    /// running a short lived `Server` stays safe and dropping it leaves no
681    /// leaked allocation behind.
682    ///
683    /// # Returns
684    ///
685    /// - `Result<ServerControlHook, Box<ServerError>>` - The shutdown hook on
686    ///   success, or the failure that prevented the server from binding.
687    pub async fn run(&self) -> Result<ServerControlHook, Box<ServerError>> {
688        let server_config: &ServerConfig = self.get_server_config();
689        let protocol: ServerProtocol = server_config.get_protocol();
690        let tls_config: Option<TlsConfig> = server_config.get_tls().clone();
691        if protocol == ServerProtocol::Http3 && tls_config.is_none() {
692            return Err(Box::new(ServerError::MissingTlsForHttp3));
693        }
694        let stream_tls: Option<Arc<rustls::ServerConfig>> = match tls_config.clone() {
695            Some(_) if protocol == ServerProtocol::Http3 => None,
696            Some(config) => Some(build_stream_tls_config(&config, &protocol)?),
697            None => None,
698        };
699        let bind_address: &String = server_config.get_address();
700        let server: Server = Self::clone(self);
701        let pipeline: CompiledPipeline = CompiledPipeline::from_server(&server);
702        let request_config: RequestConfig = *self.get_request_config();
703        let (shutdown_sender, shutdown_receiver) = channel(());
704        let (running_sender, running_receiver) = channel(SERVER_RUNNING);
705        let _: JoinHandle<()> = match protocol {
706            ServerProtocol::Http3 => {
707                let Some(config) = tls_config.clone() else {
708                    return Err(Box::new(ServerError::MissingTlsForHttp3));
709                };
710                let quic_config: Arc<QuicServerConfig> = Arc::new(
711                    QuicServerConfig::try_from(build_quic_tls_config(&config)?).map_err(
712                        |error: NoInitialCipherSuite| {
713                            Box::new(ServerError::Tls(format!(
714                                "no compatible cipher suite for quic: {}",
715                                error
716                            )))
717                        },
718                    )?,
719                );
720                let bind_addr: SocketAddr =
721                    bind_address
722                        .parse::<SocketAddr>()
723                        .map_err(|error: AddrParseError| {
724                            Box::new(ServerError::Tls(format!(
725                                "invalid bind address {}: {}",
726                                bind_address, error
727                            )))
728                        })?;
729                let endpoints: QuicEndpointSet = bind_quic_endpoints(quic_config, bind_addr)?;
730                let env: ConnectionEnv = ConnectionEnv {
731                    shared: Arc::new(ConnectionShared {
732                        server,
733                        pipeline,
734                        request_config,
735                        protocol,
736                        tls_config: None,
737                    }),
738                };
739                spawn(async move {
740                    quic_accept_all(env, endpoints, shutdown_receiver, running_sender).await;
741                })
742            }
743            _ => {
744                let nodelay: bool = server_config.get_nodelay().unwrap_or(true);
745                let tcp_listeners: Vec<TcpListener> =
746                    bind_tcp_listeners(bind_address, nodelay).await?;
747                let env: ConnectionEnv = ConnectionEnv {
748                    shared: Arc::new(ConnectionShared {
749                        server,
750                        pipeline,
751                        request_config,
752                        protocol,
753                        tls_config: stream_tls,
754                    }),
755                };
756                spawn(async move {
757                    tcp_accept_all(env, tcp_listeners, shutdown_receiver, running_sender).await;
758                })
759            }
760        };
761        let wait_hook: ServerControlHookHandler<()> = Arc::new(move || {
762            let mut running_receiver_clone: Receiver<bool> = running_receiver.clone();
763            Box::pin(async move {
764                while !*running_receiver_clone.borrow_and_update() {
765                    let _: Result<(), RecvError> = running_receiver_clone.changed().await;
766                }
767            })
768        });
769        let shutdown_hook: ServerControlHookHandler<()> = Arc::new(move || {
770            let shutdown_sender_clone: Sender<()> = shutdown_sender.clone();
771            Box::pin(async move {
772                let _: Result<(), SendError<()>> = shutdown_sender_clone.send(());
773            })
774        });
775        let mut server_control_hook: ServerControlHook = ServerControlHook::default();
776        server_control_hook.set_shutdown_hook(shutdown_hook);
777        server_control_hook.set_wait_hook(wait_hook);
778        Ok(server_control_hook)
779    }
780}