examples: Add examples about graceful shutdown and server restart

Test graceful shutdown and serrver restart.

Signed-off-by: Tim Zhang <[email protected]>

Author: Tim-Zhang

example/Cargo.lock

@@ -92,19 +92,32 @@ async fn main() {
     let a = Arc::new(a);
     let aservice = agent_ttrpc::create_agent_service(a);
 
-    let server = Server::new()
+    let mut server = Server::new()
         .bind("unix:///tmp/1")
         .unwrap()
         .register_service(hservice)
         .register_service(aservice);
 
-    let mut stream = signal(SignalKind::hangup()).unwrap();
+    let mut hangup = signal(SignalKind::hangup()).unwrap();
+    let mut interrupt = signal(SignalKind::interrupt()).unwrap();
+    server.start().await.unwrap();
+
     tokio::select! {
-        _ = stream.recv() => {
-            println!("signal received")
+        _ = hangup.recv() => {
+            // test stop_listen -> start
+            println!("stop listen");
+            server.stop_listen().await;
+            println!("start listen");
+            server.start().await.unwrap();
+
+            // hold some time for the new test connection.
+            let timeout = tokio::time::delay_for(std::time::Duration::from_secs(100));
+            timeout.await;
         }
-        _ = server.start() => {
-            println!("server exit")
+        _ = interrupt.recv() => {
+            // test graceful shutdown
+            println!("graceful shutdown");
+            server.shutdown().await.unwrap();
         }
     };
 }

example/async-server.rs

@@ -127,12 +127,13 @@ impl Server {
         S: AsyncRead + AsyncWrite + AsRawFd + Send + 'static,
     {
         let methods = self.methods.clone();
+
         let (disconnect_tx, close_conn_rx) = watch::channel(0);
         self.disconnect_tx = Some(disconnect_tx);
 
         let (conn_done_tx, all_conn_done_rx) = channel::<i32>(1);
-
         self.all_conn_done_rx = Some(all_conn_done_rx);
+
         let (stop_listen_tx, mut stop_listen_rx) = channel(1);
         self.stop_listen_tx = Some(stop_listen_tx);
 
@@ -216,6 +217,8 @@ impl Server {
                     }
                     fd_tx = stop_listen_rx.recv() => {
                         if let Some(mut fd_tx) = fd_tx {
+                            // dup fd to keep the listener open
+                            // or the listener will be closed when the incoming was dropped.
                             let dup_fd = unistd::dup(incoming.as_raw_fd()).unwrap();
                             common::set_fd_close_exec(dup_fd).unwrap();
                             drop(incoming);