Rework common demo code

DemoServer trait is simplified, now a DemoServer reference is passed to
demo_common::listen(), the Init has been removed.

picow GlobalState is renamed to PicoDemo, and DemoServer implemented
using that.

Author: mkj

embassy/demos/common/src/lib.rs

@@ -11,7 +11,7 @@ pub mod takepipe;
 
 pub use config::SSHConfig;
 pub use menu_buf::AsyncMenuBuf;
-pub use server::{listener, DemoServer, ServerApp};
+pub use server::{listen, DemoCommon, DemoServer};
 
 // needed for derive
 use sunset::sshwire;

embassy/demos/common/src/server.rs

@@ -14,11 +14,16 @@ use sunset_embassy::{SSHServer, SunsetMutex};
 
 use crate::SSHConfig;
 
+pub trait DemoServer {
+    /// A handler to run for each incoming connection.
+    async fn run(&self, serv: &SSHServer<'_>, common: DemoCommon) -> Result<()>;
+}
+
 // common entry point
-pub async fn listener<S: DemoServer>(
+pub async fn listen(
     stack: Stack<'_>,
     config: &SunsetMutex<SSHConfig>,
-    init: S::Init,
+    demo: &impl DemoServer,
 ) -> ! {
     // TODO: buffer size?
     // Does it help to be larger than ethernet MTU?
@@ -37,7 +42,7 @@ pub async fn listener<S: DemoServer>(
             continue;
         }
 
-        let r = session::<S>(&mut socket, &config, &init).await;
+        let r = session(&mut socket, &config, demo).await;
         if let Err(e) = r {
             warn!("Ended with error {e:#?}");
         }
@@ -51,10 +56,10 @@ pub async fn listener<S: DemoServer>(
 }
 
 /// Run a SSH session when a socket accepts a connection
-async fn session<S: DemoServer>(
+async fn session(
     socket: &mut TcpSocket<'_>,
     config: &SunsetMutex<SSHConfig>,
-    init: &S::Init,
+    demo: &impl DemoServer,
 ) -> sunset::Result<()> {
     // OK unwrap: has been accepted
     let src = socket.remote_endpoint().unwrap();
@@ -66,11 +71,10 @@ async fn session<S: DemoServer>(
     let mut ssh_txbuf = [0; 1000];
     let serv = SSHServer::new(&mut ssh_rxbuf, &mut ssh_txbuf)?;
 
-    // Create the handler. ServerApp is common handling (this file),
+    // Create the handler. DemoCommon is common handling (this file),
     // demo is the specific demo (std or picow).
-    let demo = S::new(init);
     let conf = config.lock().await.clone();
-    let app = ServerApp::new(conf)?;
+    let app = DemoCommon::new(conf)?;
     // .run returns a future that runs for the life of the session
     let session = demo.run(&serv, app);
 
@@ -89,15 +93,15 @@ async fn session<S: DemoServer>(
 /// Provides `ServBehaviour` for the server
 ///
 /// Further customisations are provided by `DemoServer` generic
-pub struct ServerApp {
+pub struct DemoCommon {
     config: SSHConfig,
 
     opened: bool,
     // Can be taken by the demoserver to run an interactive session.
     pub sess: Option<ChanHandle>,
 }
 
-impl ServerApp {
+impl DemoCommon {
     const ADMIN_USER: &'static str = "config";
 
     fn new(config: SSHConfig) -> Result<Self> {
@@ -180,13 +184,3 @@ impl ServerApp {
         username == Self::ADMIN_USER
     }
 }
-
-pub trait DemoServer {
-    /// State to be passed to each new connection by the server
-    type Init;
-
-    fn new(init: &Self::Init) -> Self;
-
-    /// A task to run for each incoming connection.
-    async fn run(&self, serv: &SSHServer<'_>, common: ServerApp) -> Result<()>;
-}

embassy/demos/picow/src/keyboard.rs

@@ -9,7 +9,7 @@ use embassy_usb_driver::Driver;
 use crate::*;
 
 pub(crate) async fn run<'a, D: Driver<'a>>(
-    _global: &'static GlobalState,
+    _global: &'static PicoDemo,
     hid: HidReaderWriter<'a, D, 1, 8>,
 ) -> ! {
     let (reader, _writer) = hid.split();

embassy/demos/picow/src/main.rs

@@ -21,7 +21,7 @@ use embassy_sync::blocking_mutex::raw::NoopRawMutex;
 use embassy_sync::channel::Channel;
 use embassy_sync::mutex::Mutex;
 
-use demo_common::{takepipe, DemoServer, SSHConfig, ServerApp};
+use demo_common::{takepipe, DemoCommon, DemoServer, SSHConfig};
 use sunset::*;
 use sunset_demo_embassy_common as demo_common;
 use sunset_embassy::{ProgressHolder, SSHServer, SunsetMutex};
@@ -107,8 +107,8 @@ async fn main(spawner: Spawner) {
 
     // state depends on the mac for cyw43 vs w5500
     let net_mac = SunsetMutex::new([0; 6]);
-    static STATE: StaticCell<GlobalState> = StaticCell::new();
-    let state = STATE.init_with(|| GlobalState {
+    static STATE: StaticCell<PicoDemo> = StaticCell::new();
+    let state = STATE.init_with(|| PicoDemo {
         usb_pipe,
         serial1_pipe,
         config,
@@ -158,12 +158,16 @@ async fn main(spawner: Spawner) {
 async fn net_listener(
     stack: Stack<'static>,
     config: &'static SunsetMutex<SSHConfig>,
-    global: &'static GlobalState,
+    demo: &'static PicoDemo,
 ) -> ! {
-    demo_common::listener::<PicoServer>(stack, config, global).await
+    demo_common::listen(stack, config, &demo).await
 }
 
-pub(crate) struct GlobalState {
+/// Shared state for the device.
+///
+/// This is shared between all connections.
+/// `PicoDemo` implements `DemoServer` to handle incoming connections.
+pub(crate) struct PicoDemo {
     // If locking multiple mutexes, always lock in the order below to avoid inversion.
     pub usb_pipe: &'static TakePipe<'static>,
     pub serial1_pipe: &'static TakePipe<'static>,
@@ -175,18 +179,14 @@ pub(crate) struct GlobalState {
     pub net_mac: SunsetMutex<[u8; 6]>,
 }
 
-struct PicoServer {
-    global: &'static GlobalState,
-}
-
 // Presents a menu, either on serial or incoming SSH
 //
 // `local` is set for usb serial menus which require different auth
 async fn menu<R, W>(
     chanr: &mut R,
     chanw: &mut W,
     local: bool,
-    state: &'static GlobalState,
+    state: &'static PicoDemo,
 ) -> Result<()>
 where
     R: Read<Error = sunset::Error>,
@@ -288,14 +288,9 @@ where
     info!("serial task completed");
     Ok(())
 }
-impl DemoServer for PicoServer {
-    type Init = &'static GlobalState;
-
-    fn new(global: &Self::Init) -> Self {
-        Self { global }
-    }
 
-    async fn run(&self, serv: &SSHServer<'_>, mut common: ServerApp) -> Result<()> {
+impl DemoServer for &'static PicoDemo {
+    async fn run(&self, serv: &SSHServer<'_>, mut common: DemoCommon) -> Result<()> {
         let username = Mutex::<NoopRawMutex, _>::new(String::<20>::new());
         let chan_pipe = Channel::<NoopRawMutex, ChanHandle, 1>::new();
 
@@ -337,14 +332,14 @@ impl DemoServer for PicoServer {
             #[cfg(feature = "serial1")]
             let default_pipe = self.global.serial1_pipe;
             #[cfg(not(feature = "serial1"))]
-            let default_pipe = self.global.usb_pipe;
+            let default_pipe = self.usb_pipe;
 
             let mut stdio2 = stdio.clone();
             match username.lock().await.as_str() {
                 // Open the config menu
-                "config" => menu(&mut stdio, &mut stdio2, false, self.global).await,
+                "config" => menu(&mut stdio, &mut stdio2, false, self).await,
                 // Open the usb serial directly
-                "usb" => serial(&mut stdio, &mut stdio2, self.global.usb_pipe).await,
+                "usb" => serial(&mut stdio, &mut stdio2, self.usb_pipe).await,
                 // Open the normal (?) serial directly (either usb or uart)
                 _ => serial(&mut stdio, &mut stdio2, default_pipe).await,
             }

embassy/demos/picow/src/picowmenu.rs

@@ -22,7 +22,7 @@ use pretty_hex::PrettyHex;
 
 use crate::demo_common;
 use crate::flashconfig;
-use crate::GlobalState;
+use crate::PicoDemo;
 use demo_common::{AsyncMenuBuf, SSHConfig};
 
 use demo_common::menu::*;
@@ -35,7 +35,7 @@ const MAX_PW_LEN: usize = 50;
 
 pub(crate) struct MenuCtx {
     pub out: AsyncMenuBuf,
-    state: &'static GlobalState,
+    state: &'static PicoDemo,
 
     // true for local serial console menu, false for SSH menu
     local: bool,
@@ -50,7 +50,7 @@ pub(crate) struct MenuCtx {
 }
 
 impl MenuCtx {
-    pub fn new(state: &'static GlobalState, local: bool) -> Self {
+    pub fn new(state: &'static PicoDemo, local: bool) -> Self {
         Self {
             state,
             local,

embassy/demos/picow/src/usb.rs

@@ -25,7 +25,7 @@ bind_interrupts!(struct Irqs {
 #[embassy_executor::task]
 pub(crate) async fn task(
     usb: embassy_rp::peripherals::USB,
-    global: &'static GlobalState,
+    global: &'static PicoDemo,
 ) -> ! {
     let driver = embassy_rp::usb::Driver::new(usb, Irqs);
 
@@ -100,7 +100,7 @@ pub(crate) async fn task(
 }
 
 async fn console_if00_run<'a, D: Driver<'a>>(
-    global: &'static GlobalState,
+    global: &'static PicoDemo,
     cdc: CdcAcmClass<'a, D>,
 ) -> ! {
     let (mut cdc_tx, mut cdc_rx) = cdc.split();
@@ -123,7 +123,7 @@ async fn console_if00_run<'a, D: Driver<'a>>(
 }
 
 async fn menu_if02_run<'a, D: Driver<'a>>(
-    global: &'static GlobalState,
+    global: &'static PicoDemo,
     cdc: CdcAcmClass<'a, D>,
 ) -> ! {
     let (mut cdc_tx, mut cdc_rx) = cdc.split();

embassy/demos/std/src/main.rs

@@ -19,7 +19,7 @@ use sunset_embassy::{ProgressHolder, SSHServer, SunsetMutex, SunsetRawMutex};
 mod setupmenu;
 pub(crate) use sunset_demo_embassy_common as demo_common;
 
-use demo_common::{DemoServer, SSHConfig, ServerApp};
+use demo_common::{DemoCommon, DemoServer, SSHConfig};
 
 const NUM_LISTENERS: usize = 4;
 // +1 for dhcp
@@ -73,21 +73,15 @@ async fn main_task(spawner: Spawner) {
     spawner.spawn(net_task(runner)).unwrap();
 
     for _ in 0..NUM_LISTENERS {
-        spawner.spawn(listener(stack, config)).unwrap();
+        spawner.spawn(listen(stack, config)).unwrap();
     }
 }
 
 #[derive(Default)]
 struct StdDemo;
 
 impl DemoServer for StdDemo {
-    type Init = ();
-
-    fn new(_init: &Self::Init) -> Self {
-        Default::default()
-    }
-
-    async fn run(&self, serv: &SSHServer<'_>, mut common: ServerApp) -> Result<()> {
+    async fn run(&self, serv: &SSHServer<'_>, mut common: DemoCommon) -> Result<()> {
         let chan_pipe = Channel::<SunsetRawMutex, ChanHandle, 1>::new();
 
         let prog_loop = async {
@@ -158,11 +152,12 @@ impl DemoServer for StdDemo {
 
 // TODO: pool_size should be NUM_LISTENERS but needs a literal
 #[embassy_executor::task(pool_size = 4)]
-async fn listener(
+async fn listen(
     stack: Stack<'static>,
     config: &'static SunsetMutex<SSHConfig>,
 ) -> ! {
-    demo_common::listener::<StdDemo>(stack, config, ()).await
+    let demo = StdDemo::default();
+    demo_common::listen(stack, config, &demo).await
 }
 
 #[embassy_executor::main]