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/tmux/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"
 libc = "0.2"
 scopeguard = "1"

channels/tmux/src/main.rs

@@ -12,8 +12,7 @@ use std::cell::RefCell;
 use std::collections::BTreeMap;
 use std::rc::Rc;
 
-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;
 use tokio::net::UnixListener;
@@ -145,12 +144,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();
@@ -165,14 +173,14 @@ 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> {
+    ) -> 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 message = pry!(pry!(params.get_message()).to_str()).to_string();
@@ -193,14 +201,14 @@ impl channel_server::Server for ChannelServerImpl {
             log.push_own(format!("> {}", message));
         }
 
-        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 channels: Vec<_> = s.panes.keys().map(|label| {
             let key = format!("tmux.{}", label);
@@ -215,22 +223,22 @@ impl channel_server::Server for ChannelServerImpl {
             entry.set_connected(*connected);
             entry.set_unread(*unread as u32);
         }
-        Promise::ok(())
+        std::future::ready(Ok(()))
     }
 
     fn subscribe(
-        &mut self,
+        self: Rc<Self>,
         _params: channel_server::SubscribeParams,
         _results: channel_server::SubscribeResults,
-    ) -> Promise<(), capnp::Error> {
-        Promise::ok(())
+    ) -> impl std::future::Future<Output = Result<(), capnp::Error>> {
+        std::future::ready(Ok(()))
     }
 
     fn open(
-        &mut self,
+        self: Rc<Self>,
         params: channel_server::OpenParams,
         _results: channel_server::OpenResults,
-    ) -> Promise<(), capnp::Error> {
+    ) -> impl std::future::Future<Output = Result<(), capnp::Error>> {
         let params = pry!(params.get());
         let label = pry!(pry!(params.get_label()).to_str()).to_string();
 
@@ -238,15 +246,15 @@ impl channel_server::Server for ChannelServerImpl {
         {
             let s = self.state.borrow();
             if s.panes.contains_key(&label) {
-                return Promise::ok(());
+                return std::future::ready(Ok(()));
             }
         }
 
         // Find the tmux pane by name (window or pane title)
         let pane_id = match find_pane_by_name(&label) {
             Some(id) => id,
-            None => return Promise::err(capnp::Error::failed(
-                format!("no tmux pane named '{}'", label))),
+            None => return std::future::ready(Err(capnp::Error::failed(
+                format!("no tmux pane named '{}'", label)))),
         };
 
         info!("opening channel tmux.{} (pane {})", label, pane_id);
@@ -264,14 +272,14 @@ impl channel_server::Server for ChannelServerImpl {
             pipe_pane_reader(reader_state, pane).await;
         });
 
-        Promise::ok(())
+        std::future::ready(Ok(()))
     }
 
     fn close(
-        &mut self,
+        self: Rc<Self>,
         params: channel_server::CloseParams,
         _results: channel_server::CloseResults,
-    ) -> 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 label = channel.strip_prefix("tmux.").unwrap_or(&channel).to_string();
@@ -287,7 +295,7 @@ impl channel_server::Server for ChannelServerImpl {
                 .output();
         }
 
-        Promise::ok(())
+        std::future::ready(Ok(()))
     }
 }