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/telegram/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/telegram/src/main.rs

@@ -8,16 +8,14 @@
 // don't kill the Telegram connection.
 
 use std::cell::RefCell;
-use std::collections::VecDeque;
 use std::path::PathBuf;
 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::net::UnixListener;
 use tokio_util::compat::TokioAsyncReadCompatExt;
-use log::{info, warn, error};
+use log::{info, error};
 
 use poc_memory::channel_capnp::{channel_client, channel_server};
 
@@ -228,12 +226,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();
@@ -248,20 +255,20 @@ 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();
-
+    ) -> 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();
+
             let (url, client, chat_id) = {
                 let s = state.borrow();
                 (s.api_url("sendMessage"), s.client.clone(), s.config.chat_id)
@@ -280,25 +287,25 @@ impl channel_server::Server for ChannelServerImpl {
                     .push_own(format!("[agent] {}", message));
             }
             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;
 
@@ -313,7 +320,7 @@ impl channel_server::Server for ChannelServerImpl {
             );
         }
 
-        Promise::ok(())
+        std::future::ready(Ok(()))
     }
 }