canary-rs/apps/magpie/src/ipc.rs

use super::*;

use mio::net::UnixListener;
use mio::{Events, Interest, Poll, Token};
use mio_signals::{Signal, Signals};
use slab::Slab;
use std::ops::{Deref, DerefMut};
use std::path::{Path, PathBuf};
use std::sync::mpsc::Sender;
use std::time::Duration;

use crate::window::{WindowMessage, WindowMessageSender};

const SOCK_NAME: &str = "magpie.sock";

pub enum IpcMessage {}

/// Wraps [mio::net::UnixListener] with automatic file deletion on drop.
pub struct Listener {
    pub uds: UnixListener,
    pub path: PathBuf,
}

impl Drop for Listener {
    fn drop(&mut self) {
        match std::fs::remove_file(&self.path) {
            Ok(_) => {}
            Err(e) => eprintln!("Could not delete UnixListener {:?}", e),
        }
    }
}

impl Deref for Listener {
    type Target = UnixListener;

    fn deref(&self) -> &UnixListener {
        &self.uds
    }
}

impl DerefMut for Listener {
    fn deref_mut(&mut self) -> &mut UnixListener {
        &mut self.uds
    }
}

pub struct Client {}

pub struct Ipc {
    pub message_recv: MioReceiver<IpcMessage>,
    pub window_sender: WindowMessageSender,
    pub poll: Poll,
    pub events: Events,
    pub quit: bool,
    pub listener: Listener,
    pub signals: Signals,
    pub listener_token: Token,
    pub signals_token: Token,
    pub message_recv_token: Token,
    pub clients: Slab<Client>,
}

impl Ipc {
    pub fn new(
        message_recv: MioReceiver<IpcMessage>,
        window_sender: WindowMessageSender,
    ) -> std::io::Result<Self> {
        let sock_dir = std::env::var("XDG_RUNTIME_DIR").expect("XDG_RUNTIME_DIR not set");
        let sock_dir = Path::new(&sock_dir);
        let sock_path = sock_dir.join(SOCK_NAME);
        eprintln!("Making socket at: {:?}", sock_path);

        let mut listener = Listener {
            uds: UnixListener::bind(&sock_path)?,
            path: sock_path.to_path_buf(),
        };

        let mut signals = Signals::new(Signal::Interrupt | Signal::Quit)?;

        let events = Events::with_capacity(128);
        let poll = Poll::new()?;
        let listener_token = Token(usize::MAX);
        let signals_token = Token(listener_token.0 - 1);
        let message_recv_token = Token(signals_token.0 - 1);

        let registry = poll.registry();
        let interest = Interest::READABLE;
        registry.register(&mut listener.uds, listener_token, interest)?;
        registry.register(&mut signals, signals_token, interest)?;

        Ok(Self {
            message_recv,
            window_sender,
            poll,
            events,
            quit: false,
            listener,
            signals,
            listener_token,
            signals_token,
            message_recv_token,
            clients: Default::default(),
        })
    }

    pub fn poll(&mut self, timeout: Option<Duration>) -> std::io::Result<()> {
        self.poll.poll(&mut self.events, timeout)?;

        for event in self.events.iter() {
            if event.token() == self.listener_token {
                loop {
                    match self.listener.accept() {
                        Ok((connection, address)) => {
                            println!("Got a connection from: {:?}", address);
                        }
                        Err(ref err) if err.kind() == std::io::ErrorKind::WouldBlock => break,
                        Err(err) => return Err(err),
                    }
                }
            } else if event.token() == self.signals_token {
                while let Some(received) = self.signals.receive()? {
                    eprintln!("Received {:?} signal; exiting...", received);
                    let _ = self.window_sender.send_event(WindowMessage::Quit);
                    self.quit = true;
                }
            } else {
                panic!("Unrecognized event token: {:?}", event);
            }
        }

        Ok(())
    }

    pub fn run(mut self) {
        while !self.quit {
            let wait = Duration::from_millis(100);
            match self.poll(Some(wait)) {
                Ok(_) => {}
                Err(e) => {
                    eprintln!("IPC poll error: {:?}", e);
                }
            }
        }
    }
}