move mgmtchannel read/write to methods on Framed

This will allow us to borrow the read and write halves of a channel
separately, for doing bulk upload/download.

Signed-off-by: Ian Jackson <ijackson@chiark.greenend.org.uk>

diff --git a/daemon/cmdlistener.rs b/daemon/cmdlistener.rs
index 45f56c9c187c3e8495c42815791c7f2b2999892e..e8636f4d21d88e87116752d38ab52f3f7f137460 100644 (file)
--- a/daemon/cmdlistener.rs
+++ b/daemon/cmdlistener.rs
@@ -1153,7 +1153,7 @@ impl CommandStream<'_> {
   pub fn mainloop(mut self) {
     loop {
       use MgmtChannelReadError::*;
-      let resp = match self.chan.read::<MgmtCommand>() {
+      let resp = match self.chan.read.read::<MgmtCommand>() {
         Ok(cmd) => {
           let mut cmd_s = log_enabled!(log::Level::Info)
             .as_some_from(|| format!("{:?}", &cmd))
@@ -1180,7 +1180,7 @@ impl CommandStream<'_> {
         Err(IO(e)) => Err(e).context("read command stream")?,
         Err(Parse(s)) => MgmtResponse::Error { error: ME::ParseFailed(s) },
       };
-      self.chan.write(&resp).context("swrite command stream")?;
+      self.chan.write.write(&resp).context("swrite command stream")?;
     }
   }
 }

diff --git a/src/mgmtchannel.rs b/src/mgmtchannel.rs
index 2b763ca766fc628afeb8651911b2a688f7473232..cf54988b75c701cdba18a2996e30ece8ab055f96 100644 (file)
--- a/src/mgmtchannel.rs
+++ b/src/mgmtchannel.rs
@@ -35,8 +35,8 @@ impl From<rmp_serde::encode::Error> for MgmtChannelWriteError {
 }
 
 pub struct MgmtChannel {
-  read:  FrameReader<BufReader<Box<dyn Read >>>,
-  write: FrameWriter<BufWriter<Box<dyn Write>>>,
+  pub read:  FrameReader<BufReader<Box<dyn Read >>>,
+  pub write: FrameWriter<BufWriter<Box<dyn Write>>>,
 }
 
 impl Debug for MgmtChannel{ 
@@ -68,49 +68,11 @@ impl MgmtChannel {
     MgmtChannel { read, write }
   }
 
-  #[throws(MgmtChannelReadError)]
-  pub fn read_withbulk<'c,T>(&'c mut self) -> (T, ReadFrame<impl Read + 'c>)
-  where T: DeserializeOwned + Debug
-  {
-    use MgmtChannelReadError::*;
-    let mut f = self.read.new_frame()?.ok_or(MgmtChannelReadError::EOF)?;
-    let r = rmp_serde::decode::from_read(&mut f);
-    let v = r.map_err(|e| Parse(format!("{}", &e)))?;
-    trace!("read OK {:?}", &v);
-    (v, f)
-  }
-
-  #[throws(MgmtChannelReadError)]
-  pub fn read<T>(&mut self) -> T
-  where T: DeserializeOwned + Debug
-  {
-    self.read_withbulk()?.0
-  }
-
-  #[throws(MgmtChannelWriteError)]
-  pub fn write_withbulk<'c,T>(&mut self, val: &T)
-                              -> WriteFrame<impl Write + 'c>
-  where T: Serialize + Debug
-  {
-    let mut f = self.write.new_frame()?;
-    rmp_serde::encode::write_named(&mut f, val)?;
-    trace!("writing {:?}", val);
-    f
-  }
-
-  #[throws(MgmtChannelWriteError)]
-  pub fn write<T>(&mut self, val: &T)
-  where T: Serialize + Debug
-  {
-    let f = self.write_withbulk(val)?;
-    f.finish()?;
-  }
-
   #[throws(AE)]
   pub fn cmd(&mut self, cmd: &MgmtCommand) -> MgmtResponse {
     use MgmtResponse::*;
-    self.write(&cmd).context("send command")?;
-    let resp = self.read().context("read response")?;
+    self.write.write(&cmd).context("send command")?;
+    let resp = self.read.read().context("read response")?;
     match &resp {
       Fine | AccountsList{..} | GamesList{..} | LibraryItems(_) => { },
       AlterGame { error: None, .. } => { },

diff --git a/src/packetframe.rs b/src/packetframe.rs
index c7c6d633660a26982c23d57a75f39831ebb7cc62..2fa958ee667917b26da5ad8b8088a107972dc09d 100644 (file)
--- a/src/packetframe.rs
+++ b/src/packetframe.rs
@@ -263,7 +263,26 @@ impl<R:Read> FrameReader<R> {
         Err(RHE::IO(e)) => throw!(e),
       }
     }
-  }   
+  }
+
+  #[throws(MgmtChannelReadError)]
+  pub fn read_withbulk<'c,T>(&'c mut self) -> (T, ReadFrame<impl Read + 'c>)
+  where T: DeserializeOwned + Debug
+  {
+    use MgmtChannelReadError::*;
+    let mut f = self.new_frame()?.ok_or(MgmtChannelReadError::EOF)?;
+    let r = rmp_serde::decode::from_read(&mut f);
+    let v = r.map_err(|e| Parse(format!("{}", &e)))?;
+    trace!("read OK {:?}", &v);
+    (v, f)
+  }
+
+  #[throws(MgmtChannelReadError)]
+  pub fn read<T>(&mut self) -> T
+  where T: DeserializeOwned + Debug
+  {
+    self.read_withbulk()?.0
+  }
 }
 
 trait ReadOutput {
@@ -324,6 +343,25 @@ impl<W:Write> FrameWriter<W> {
       self.inner.flush()?;
     }
   }
+
+  #[throws(MgmtChannelWriteError)]
+  pub fn write_withbulk<'c,T>(&'c mut self, val: &T)
+                              -> WriteFrame<impl Write + 'c>
+  where T: Serialize + Debug
+  {
+    let mut f = self.new_frame()?;
+    rmp_serde::encode::write_named(&mut f, val)?;
+    trace!("writing {:?}", val);
+    f
+  }
+
+  #[throws(MgmtChannelWriteError)]
+  pub fn write<T>(&mut self, val: &T)
+  where T: Serialize + Debug
+  {
+    let f = self.write_withbulk(val)?;
+    f.finish()?;
+  }
 }
 
 impl<'w,W:Write> WriteFrame<'w,W> {