canary
/
canary-rs
2
1
Fork 0
Code Issues 11 Pull Requests 2 Projects Releases Wiki Activity

Clean up old magpie crates + use Magpie library in music player

This commit is contained in:
mars 2022-11-01 01:48:31 -06:00
parent 7e1ec1ed39
commit 6aa3ca6f33
7 changed files with 3 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -3,8 +3,6 @@ members = [
"apps/magpie",
"apps/music-player",
"apps/sandbox",
"crates/magpie-client",
"crates/magpie-types",
"crates/music-player-protocol",
"crates/script",
"crates/types",

2
apps/music-player/Cargo.toml
View File

@ -5,5 +5,5 @@ edition = "2021"
[dependencies]
canary-music-player-protocol = { path = "../../crates/music-player-protocol" }
magpie-client = { path = "../../crates/magpie-client" }
canary-magpie = { path = "../magpie" }
mpris = "2.0.0-rc3"

4
apps/music-player/src/main.rs
View File

@ -1,6 +1,6 @@
use canary_music_player_protocol::*;
use magpie_client::{magpie_types, MagpieClient};
use magpie_types::{CreatePanel, MagpieServerMsg};
use canary_magpie::client::MagpieClient;
use canary_magpie::protocol::{CreatePanel, MagpieServerMsg};
use mpris::PlayerFinder;
pub struct MetadataTracker {

7
crates/magpie-client/Cargo.toml
View File

@ -1,7 +0,0 @@
[package]
name = "magpie-client"
version = "0.1.0"
edition = "2021"
[dependencies]
magpie-types = { path = "../magpie-types" }

45
crates/magpie-client/src/lib.rs
View File

@ -1,45 +0,0 @@
pub use magpie_types;
use std::os::unix::net::UnixStream;
use std::path::Path;
use magpie_types::{serde::Serialize, serde_json};
use magpie_types::{ClientMessenger, MagpieServerMsg, PanelId, SendMessage};
/// The name of the Magpie server socket.
pub const MAGPIE_SOCK: &str = "magpie.sock";
/// A client to a Magpie server.
pub struct MagpieClient {
pub messenger: ClientMessenger<UnixStream>,
}
impl MagpieClient {
pub fn new() -> 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(MAGPIE_SOCK);
let socket = UnixStream::connect(sock_path)?;
Ok(Self {
messenger: ClientMessenger::new(socket),
})
}
pub fn send(&mut self, msg: &MagpieServerMsg) {
if let Err(err) = self.messenger.send(msg) {
eprintln!("Message send error: {:?}", err);
}
}
pub fn send_json_message<T: Serialize>(&mut self, id: PanelId, msg: &T) {
let msg = serde_json::to_string(msg).unwrap();
eprintln!("Sending message: {}", msg);
let msg = SendMessage {
id,
msg: msg.into_bytes(),
};
self.send(&MagpieServerMsg::SendMessage(msg));
}
}

9
crates/magpie-types/Cargo.toml
View File

@ -1,9 +0,0 @@
[package]
name = "magpie-types"
version = "0.1.0"
edition = "2021"
[dependencies]
byteorder = "1.4"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1"

142
crates/magpie-types/src/lib.rs
View File

@ -1,142 +0,0 @@
use std::collections::VecDeque;
use std::io::{Read, Write};
use std::marker::PhantomData;
use std::path::PathBuf;
use serde::{de::DeserializeOwned, Deserialize, Serialize};
pub use serde;
pub use serde_json;
/// An identifier for a Magpie panel.
///
/// Only valid on a connection between a single client and its server. Clients
/// are allowed to use arbitrary values for [PanelId].
pub type PanelId = u32;
/// Creates a new Magpie panel with a given ID.
///
/// If the given [PanelId] is already being used on this connection, the server
/// will delete the old panel using that [PanelId].
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreatePanel {
pub id: PanelId,
pub script: PathBuf,
}
/// Sends a panel a message.
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SendMessage {
pub id: PanelId,
pub msg: Vec<u8>,
}
/// A message sent from a Magpie client to the server.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(tag = "kind")]
pub enum MagpieServerMsg {
CreatePanel(CreatePanel),
SendMessage(SendMessage),
}
/// A message sent from the Magpie server to a client.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(tag = "kind")]
pub enum MagpieClientMsg {}
/// A [Messenger] specialized for Magpie clients.
pub type ClientMessenger<T> = Messenger<T, MagpieClientMsg, MagpieServerMsg>;
/// A [Messenger] specialized for Magpie servers.
pub type ServerMessenger<T> = Messenger<T, MagpieServerMsg, MagpieClientMsg>;
/// Bidirectional, transport-agnostic Magpie IO wrapper struct.
pub struct Messenger<T, I, O> {
pub transport: T,
expected_len: Option<usize>,
received_buf: VecDeque<u8>,
received_queue: VecDeque<I>,
closed: bool,
_output: PhantomData<O>,
}
impl<T: Read + Write, I: DeserializeOwned, O: Serialize> Messenger<T, I, O> {
pub fn new(transport: T) -> Self {
Self {
transport,
expected_len: None,
received_buf: Default::default(),
received_queue: Default::default(),
closed: false,
_output: PhantomData,
}
}
pub fn is_closed(&self) -> bool {
self.closed
}
pub fn send(&mut self, msg: &O) -> std::io::Result<()> {
use byteorder::{LittleEndian, WriteBytesExt};
let payload = serde_json::to_vec(msg).unwrap();
let len = payload.len() as u32;
self.transport.write_u32::<LittleEndian>(len)?;
self.transport.write_all(&payload)?;
self.transport.flush()?;
Ok(())
}
/// Receives all pending messages and queues them for [recv].
pub fn flush_recv(&mut self) -> std::io::Result<()> {
let mut buf = [0u8; 1024];
loop {
match self.transport.read(&mut buf) {
Ok(0) => {
self.closed = true;
break;
}
Ok(n) => {
self.received_buf.write(&buf[..n])?;
}
Err(ref err) if err.kind() == std::io::ErrorKind::WouldBlock => break,
Err(ref err) if err.kind() == std::io::ErrorKind::Interrupted => continue,
Err(err) => return Err(err),
}
}
loop {
if let Some(expected_len) = self.expected_len {
if self.received_buf.len() < expected_len {
break;
}
self.expected_len = None;
let mut buf = vec![0u8; expected_len];
self.received_buf.read_exact(&mut buf)?;
match serde_json::from_slice::<I>(&buf) {
Ok(received) => self.received_queue.push_front(received),
Err(e) => {
let kind = std::io::ErrorKind::InvalidData;
let payload = Box::new(e);
let error = std::io::Error::new(kind, payload);
return Err(error);
}
}
} else if self.received_buf.len() >= 4 {
use byteorder::{LittleEndian, ReadBytesExt};
let expected_len = self.received_buf.read_u32::<LittleEndian>()?;
self.expected_len = Some(expected_len as usize);
} else {
break;
}
}
Ok(())
}
/// Tries to receive a single input packet.
pub fn recv(&mut self) -> Option<I> {
self.received_queue.pop_back()
}
}