Upgrade capnp 0.20 → 0.25, capnp-rpc 0.20 → 0.25

RPC trait methods changed from &mut self to self: Rc<Self> and
return types from Promise<(), Error> to impl Future<Output = Result<...>>.

Updated all Server impls across 6 files: DaemonImpl (rpc.rs),
NotifyForwarder (channels.rs), and ChannelServerImpl in all channel
crates (irc, telegram, tmux, socat). Local pry! macro replaces
capnp_rpc::pry to match the new impl Future return type.

Warning-clean workspace build.

Co-Authored-By: Proof of Concept <poc@bcachefs.org>

channels/irc/Cargo.toml

@@ -4,8 +4,8 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-capnp = "0.20"
-capnp-rpc = "0.20"
+capnp = "0.25"
+capnp-rpc = "0.25"
 dirs = "6"
 futures = "0.3"
 json5 = "1.3"

channels/irc/src/main.rs

@@ -12,14 +12,12 @@
 // Socket: ~/.consciousness/channels/irc.sock
 
 use std::cell::RefCell;
-use std::collections::VecDeque;
 use std::io;
 use std::path::PathBuf;
 use std::rc::Rc;
 use std::sync::Arc;
 
-use capnp::capability::Promise;
-use capnp_rpc::{pry, rpc_twoparty_capnp, twoparty, RpcSystem};
+use capnp_rpc::{rpc_twoparty_capnp, twoparty, RpcSystem};
 use futures::AsyncReadExt;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::net::UnixListener;
@@ -481,12 +479,21 @@ struct ChannelServerImpl {
     state: SharedState,
 }
 
+macro_rules! pry {
+    ($e:expr) => {
+        match $e {
+            Ok(v) => v,
+            Err(e) => return std::future::ready(Err(e.into())),
+        }
+    };
+}
+
 impl channel_server::Server for ChannelServerImpl {
     fn recv(
-        &mut self,
+        self: Rc<Self>,
         params: channel_server::RecvParams,
         mut results: channel_server::RecvResults,
-    ) -> Promise<(), capnp::Error> {
+    ) -> impl std::future::Future<Output = Result<(), capnp::Error>> {
         let params = pry!(params.get());
         let channel = pry!(pry!(params.get_channel()).to_str()).to_string();
         let all_new = params.get_all_new();
@@ -501,25 +508,25 @@ impl channel_server::Server for ChannelServerImpl {
         };
 
         results.get().set_text(&text);
-        Promise::ok(())
+        std::future::ready(Ok(()))
     }
 
     fn send(
-        &mut self,
+        self: Rc<Self>,
         params: channel_server::SendParams,
         _results: channel_server::SendResults,
-    ) -> Promise<(), capnp::Error> {
-        let params = pry!(params.get());
-        let channel = pry!(pry!(params.get_channel()).to_str()).to_string();
-        let message = pry!(pry!(params.get_message()).to_str()).to_string();
-
-        // Parse channel path to IRC target:
-        //   irc.#bcachefs  -> #bcachefs
-        //   irc.pm.nick    -> nick (PRIVMSG)
-        let target = channel_to_target(&channel);
-
+    ) -> impl std::future::Future<Output = Result<(), capnp::Error>> {
         let state = self.state.clone();
-        Promise::from_future(async move {
+        async move {
+            let params = params.get()?;
+            let channel = params.get_channel()?.to_str()?.to_string();
+            let message = params.get_message()?.to_str()?.to_string();
+
+            // Parse channel path to IRC target:
+            //   irc.#bcachefs  -> #bcachefs
+            //   irc.pm.nick    -> nick (PRIVMSG)
+            let target = channel_to_target(&channel);
+
             {
                 let mut s = state.borrow_mut();
                 s.send_privmsg(&target, &message).await
@@ -540,25 +547,25 @@ impl channel_server::Server for ChannelServerImpl {
                 .push_own(log_line);
 
             Ok(())
-        })
+        }
     }
 
     fn subscribe(
-        &mut self,
+        self: Rc<Self>,
         params: channel_server::SubscribeParams,
         _results: channel_server::SubscribeResults,
-    ) -> Promise<(), capnp::Error> {
+    ) -> impl std::future::Future<Output = Result<(), capnp::Error>> {
         let callback = pry!(pry!(params.get()).get_callback());
         self.state.borrow_mut().subscribers.push(callback);
         info!("client subscribed for notifications");
-        Promise::ok(())
+        std::future::ready(Ok(()))
     }
 
     fn list(
-        &mut self,
+        self: Rc<Self>,
         _params: channel_server::ListParams,
         mut results: channel_server::ListResults,
-    ) -> Promise<(), capnp::Error> {
+    ) -> impl std::future::Future<Output = Result<(), capnp::Error>> {
         let s = self.state.borrow();
         let connected = s.connected;
 
@@ -574,7 +581,7 @@ impl channel_server::Server for ChannelServerImpl {
             );
         }
 
-        Promise::ok(())
+        std::future::ready(Ok(()))
     }
 }