feature: extension server framework: reliability improvements

airupfx/airupfx-extensions/Cargo.toml

@@ -10,5 +10,6 @@ publish = false
 anyhow = "1"
 airup-sdk = { path = "../../airup-sdk" }
 airupfx-fs = { path = "../airupfx-fs" }
+airupfx-signal = { path = "../airupfx-signal" }
 ciborium = "0.2"
 tokio = { workspace = true }

airupfx/airupfx-extensions/src/lib.rs

@@ -2,8 +2,9 @@ use airup_sdk::{
     info::ConnectionExt,
     ipc::MessageProto,
     nonblocking::ipc::{MessageProtoRecvExt, MessageProtoSendExt},
-    system::ConnectionExt as _,
+    system::{ConnectionExt as _, Event},
 };
+use airupfx_signal::SIGTERM;
 use ciborium::cbor;
 use std::{
     collections::{HashMap, HashSet},
@@ -22,6 +23,7 @@ pub struct Server {
     listener: UnixListener,
     path: String,
     extension_name: String,
+    service_name: String,
     rpc_methods: HashMap<String, Method>,
 }
 impl Server {
@@ -39,11 +41,12 @@ impl Server {
             .to_string();
         std::fs::remove_file(&extension_socket_path).ok();
 
-        Ok(Self::with_config(extension_name, extension_socket_path).await?)
+        Ok(Self::with_config(extension_name, service_name, extension_socket_path).await?)
     }
 
     pub async fn with_config<P: AsRef<Path>>(
         extension_name: impl Into<String>,
+        service_name: impl Into<String>,
         path: P,
     ) -> std::io::Result<Self> {
         let listener = UnixListener::bind(path.as_ref())?;
@@ -53,6 +56,7 @@ impl Server {
             listener,
             path: path.as_ref().display().to_string(),
             extension_name: extension_name.into(),
+            service_name: service_name.into(),
             rpc_methods: HashMap::with_capacity(16),
         })
     }
@@ -64,15 +68,15 @@ impl Server {
 
     pub async fn run(self) -> ! {
         let rpc_methods = Arc::new(self.rpc_methods);
-        let extension_name = self.extension_name;
-        let path = self.path;
         let method_set: HashSet<_> = rpc_methods.keys().cloned().collect();
+
+        let extension_name = self.extension_name.clone();
         tokio::spawn(async move {
             let mut airup_rpc_conn =
                 airup_sdk::nonblocking::Connection::connect(airup_sdk::socket_path()).await?;
 
             match airup_rpc_conn
-                .load_extension(&extension_name, &path, method_set)
+                .load_extension(&extension_name, &self.path, method_set)
                 .await
             {
                 Ok(Ok(())) => (),
@@ -86,9 +90,26 @@ impl Server {
                 }
             }
 
+            airup_rpc_conn
+                .trigger_event(&Event::new("notify_active".into(), self.service_name))
+                .await
+                .ok();
+
             Ok::<(), anyhow::Error>(())
         });
 
+        let extension_name = self.extension_name.clone();
+        airupfx_signal::signal(SIGTERM, |_| async move {
+            let Ok(mut airup_rpc_conn) =
+                airup_sdk::nonblocking::Connection::connect(airup_sdk::socket_path()).await
+            else {
+                return;
+            };
+
+            airup_rpc_conn.unload_extension(&extension_name).await.ok();
+        })
+        .ok();
+
         loop {
             let Ok((stream, _)) = self.listener.accept().await else {
                 continue;

airupfx/airupfx-signal/src/unix.rs

@@ -57,17 +57,17 @@ pub const SIGFPE: i32 = libc::SIGFPE;
 /// # Errors
 /// An `Err(_)` is returned if the underlying OS function failed.
 pub fn signal<
-    F: FnMut(i32) -> T + Send + Sync + 'static,
+    F: FnOnce(i32) -> T + Clone + Send + Sync + 'static,
     T: Future<Output = ()> + Send + 'static,
 >(
     signum: i32,
-    mut op: F,
+    op: F,
 ) -> std::io::Result<()> {
     let mut signal = tokio::signal::unix::signal(SignalKind::from_raw(signum))?;
     tokio::spawn(async move {
         loop {
             signal.recv().await;
-            op(signum).await;
+            op.clone()(signum).await;
         }
     });
 

docs/resources/airup-fallback-logger.airs

@@ -1,6 +1,7 @@
 [service]
 display-name = "Airup Fallback Logger"
 description = "An Airup extension that provides a simple logger interface for fallback use."
+kind = "notify"
 
 [exec]
 start = "/usr/libexec/airup/fallback-logger"