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/socat/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"
 poc-memory = { path = "../.." }

channels/socat/src/main.rs

@@ -11,8 +11,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, AsyncWriteExt};
 use tokio::net::{TcpStream, UnixListener, UnixStream};
@@ -163,10 +162,19 @@ async fn connect_outbound(state: SharedState, label: String, addr: String) -> Re
 
 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, params: channel_server::RecvParams, mut results: channel_server::RecvResults,
-    ) -> Promise<(), capnp::Error> {
+        self: Rc<Self>, params: channel_server::RecvParams, mut results: channel_server::RecvResults,
+    ) -> 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();
@@ -178,12 +186,12 @@ impl channel_server::Server for ChannelServerImpl {
             .unwrap_or_default();
 
         results.get().set_text(&text);
-        Promise::ok(())
+        std::future::ready(Ok(()))
     }
 
     fn send(
-        &mut self, params: channel_server::SendParams, _results: channel_server::SendResults,
-    ) -> Promise<(), capnp::Error> {
+        self: Rc<Self>, params: channel_server::SendParams, _results: channel_server::SendResults,
+    ) -> 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();
@@ -195,12 +203,12 @@ impl channel_server::Server for ChannelServerImpl {
             }
             ch.log.push_own(format!("> {}", message));
         }
-        Promise::ok(())
+        std::future::ready(Ok(()))
     }
 
     fn list(
-        &mut self, _params: channel_server::ListParams, mut results: channel_server::ListResults,
-    ) -> Promise<(), capnp::Error> {
+        self: Rc<Self>, _params: channel_server::ListParams, mut results: channel_server::ListResults,
+    ) -> impl std::future::Future<Output = Result<(), capnp::Error>> {
         let s = self.state.borrow();
         let channels: Vec<_> = s.channels.iter()
             .map(|(name, ch)| (name.clone(), ch.writer.is_some(), ch.log.unread()))
@@ -213,33 +221,33 @@ 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, params: channel_server::SubscribeParams, _results: channel_server::SubscribeResults,
-    ) -> Promise<(), capnp::Error> {
+        self: Rc<Self>, params: channel_server::SubscribeParams, _results: channel_server::SubscribeResults,
+    ) -> impl std::future::Future<Output = Result<(), capnp::Error>> {
         let callback = pry!(pry!(params.get()).get_callback());
         self.state.borrow_mut().subscribers.push(callback);
-        Promise::ok(())
+        std::future::ready(Ok(()))
     }
 
     fn open(
-        &mut self, params: channel_server::OpenParams, _results: channel_server::OpenResults,
-    ) -> Promise<(), capnp::Error> {
-        let params = pry!(params.get());
-        let label = pry!(pry!(params.get_label()).to_str()).to_string();
-
+        self: Rc<Self>, params: channel_server::OpenParams, _results: channel_server::OpenResults,
+    ) -> 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 label = params.get_label()?.to_str()?.to_string();
+
             connect_outbound(state, label.clone(), label).await
                 .map_err(|e| capnp::Error::failed(e))
-        })
+        }
     }
 
     fn close(
-        &mut self, params: channel_server::CloseParams, _results: channel_server::CloseResults,
-    ) -> Promise<(), capnp::Error> {
+        self: Rc<Self>, params: channel_server::CloseParams, _results: channel_server::CloseResults,
+    ) -> impl std::future::Future<Output = Result<(), capnp::Error>> {
         let params = pry!(params.get());
         let channel = pry!(pry!(params.get_channel()).to_str()).to_string();
 
@@ -248,7 +256,7 @@ impl channel_server::Server for ChannelServerImpl {
             info!("closing {}", channel);
             ch.writer = None;
         }
-        Promise::ok(())
+        std::future::ready(Ok(()))
     }
 }