Kordophone/kpcli/src/daemon/mod.rs

use anyhow::Result;
use clap::Subcommand;
use dbus::blocking::{Connection, Proxy};

const DBUS_NAME: &str = "net.buzzert.kordophonecd";
const DBUS_PATH: &str = "/net/buzzert/kordophonecd/daemon";

mod dbus_interface {
    #![allow(unused)]
    include!(concat!(env!("OUT_DIR"), "/kordophone-client.rs"));
}

use dbus_interface::NetBuzzertKordophoneRepository as KordophoneRepository;

#[derive(Subcommand)]
pub enum Commands {
    /// Gets all known conversations.
    Conversations,

    /// Runs a sync operation.
    Sync,

    /// Prints the server Kordophone version.
    Version,
}

impl Commands {
    pub async fn run(cmd: Commands) -> Result<()> {
        let mut client = DaemonCli::new()?;
        match cmd {
            Commands::Version => client.print_version().await,
            Commands::Conversations => client.print_conversations().await,
            Commands::Sync => client.sync_conversations().await,
        }
    }
}

struct DaemonCli {
    conn: Connection,
}

impl DaemonCli {
    pub fn new() -> Result<Self> {
        Ok(Self {
            conn: Connection::new_session()?
        })
    }

    fn proxy(&self) -> Proxy<&Connection> {
        self.conn.with_proxy(DBUS_NAME, DBUS_PATH, std::time::Duration::from_millis(5000))
    }

    pub async fn print_version(&mut self) -> Result<()> {
        let version = KordophoneRepository::get_version(&self.proxy())?;
        println!("Server version: {}", version);
        Ok(())
    }

    pub async fn print_conversations(&mut self) -> Result<()> {
        let conversations = KordophoneRepository::get_conversations(&self.proxy())?;
        println!("Conversations: {:?}", conversations);
        Ok(())
    }

    pub async fn sync_conversations(&mut self) -> Result<()> {
        let success = KordophoneRepository::sync_all_conversations(&self.proxy())?;
        println!("Synced conversations: {}", success);
        Ok(())
    }
}