265 lines
7.6 KiB
Rust
265 lines
7.6 KiB
Rust
/*
|
|
* This file is part of espanso.
|
|
*
|
|
* Copyright (C) 2019-2021 Federico Terzi
|
|
*
|
|
* espanso is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* espanso is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with espanso. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
use anyhow::Result;
|
|
use serde::{de::DeserializeOwned, Serialize};
|
|
use std::{path::Path};
|
|
use thiserror::Error;
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub mod windows;
|
|
|
|
#[cfg(not(target_os = "windows"))]
|
|
pub mod unix;
|
|
|
|
mod util;
|
|
|
|
pub type EventHandler<Event> = Box<dyn Fn(Event) -> EventHandlerResponse<Event>>;
|
|
|
|
pub enum EventHandlerResponse<Event> {
|
|
NoResponse,
|
|
Response(Event),
|
|
Error(anyhow::Error),
|
|
Exit,
|
|
}
|
|
|
|
pub trait IPCServer<Event> {
|
|
fn run(self, handler: EventHandler<Event>) -> Result<()>;
|
|
}
|
|
|
|
pub trait IPCClient<Event> {
|
|
fn send_sync(&mut self, event: Event) -> Result<Event>;
|
|
fn send_async(&mut self, event: Event) -> Result<()>;
|
|
}
|
|
|
|
#[cfg(not(target_os = "windows"))]
|
|
pub fn server<Event: Send + Sync + DeserializeOwned + Serialize>(
|
|
id: &str,
|
|
parent_dir: &Path,
|
|
) -> Result<impl IPCServer<Event>> {
|
|
let server = unix::UnixIPCServer::new(id, parent_dir)?;
|
|
Ok(server)
|
|
}
|
|
|
|
#[cfg(not(target_os = "windows"))]
|
|
pub fn client<Event: Serialize + DeserializeOwned>(id: &str, parent_dir: &Path) -> Result<impl IPCClient<Event>> {
|
|
let client = unix::UnixIPCClient::new(id, parent_dir)?;
|
|
Ok(client)
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub fn server<Event: Send + Sync + DeserializeOwned + Serialize>(
|
|
id: &str,
|
|
_: &Path,
|
|
) -> Result<impl IPCServer<Event>> {
|
|
let server = windows::WinIPCServer::new(id)?;
|
|
Ok(server)
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub fn client<Event: Serialize + DeserializeOwned>(id: &str, _: &Path) -> Result<impl IPCClient<Event>> {
|
|
let client = windows::WinIPCClient::new(id)?;
|
|
Ok(client)
|
|
}
|
|
|
|
#[derive(Error, Debug)]
|
|
pub enum IPCServerError {
|
|
#[error("stream ended")]
|
|
StreamEnded,
|
|
|
|
#[error("handler reported error `{0}`")]
|
|
HandlerError(#[from] anyhow::Error),
|
|
}
|
|
|
|
#[derive(Error, Debug)]
|
|
pub enum IPCClientError {
|
|
#[error("empty response")]
|
|
EmptyResponse,
|
|
|
|
#[error("malformed response received `{0}`")]
|
|
MalformedResponse(#[from] anyhow::Error),
|
|
|
|
#[error("message response timed out")]
|
|
Timeout,
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::{
|
|
sync::{mpsc::channel},
|
|
};
|
|
|
|
use super::*;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
enum Event {
|
|
Async,
|
|
Sync(String),
|
|
SyncResult(String),
|
|
ExitRequest,
|
|
}
|
|
|
|
#[test]
|
|
fn ipc_async_message() {
|
|
let server = server::<Event>("testespansoipcasync", &std::env::temp_dir()).unwrap();
|
|
|
|
let client_handle = std::thread::spawn(move || {
|
|
let mut client = client::<Event>("testespansoipcasync", &std::env::temp_dir()).unwrap();
|
|
|
|
client.send_async(Event::Async).unwrap();
|
|
client.send_async(Event::ExitRequest).unwrap();
|
|
});
|
|
|
|
server
|
|
.run(Box::new(move |event| match event {
|
|
Event::ExitRequest => EventHandlerResponse::Exit,
|
|
evt => {
|
|
assert!(matches!(evt, Event::Async));
|
|
EventHandlerResponse::NoResponse
|
|
}
|
|
}))
|
|
.unwrap();
|
|
|
|
client_handle.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn ipc_sync_message() {
|
|
let server = server::<Event>("testespansoipcsync", &std::env::temp_dir()).unwrap();
|
|
|
|
let client_handle = std::thread::spawn(move || {
|
|
let mut client = client::<Event>("testespansoipcsync", &std::env::temp_dir()).unwrap();
|
|
|
|
let response = client.send_sync(Event::Sync("test".to_owned())).unwrap();
|
|
client.send_async(Event::ExitRequest).unwrap();
|
|
|
|
assert!(matches!(response, Event::SyncResult(s) if s == "test"));
|
|
});
|
|
|
|
server
|
|
.run(Box::new(move |event| match event {
|
|
Event::ExitRequest => EventHandlerResponse::Exit,
|
|
Event::Sync(s) => EventHandlerResponse::Response(Event::SyncResult(s)),
|
|
_ => EventHandlerResponse::NoResponse,
|
|
}))
|
|
.unwrap();
|
|
|
|
client_handle.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn ipc_multiple_sync_with_delay_message() {
|
|
let server = server::<Event>("testespansoipcmultiplesync", &std::env::temp_dir()).unwrap();
|
|
|
|
let client_handle = std::thread::spawn(move || {
|
|
let mut client = client::<Event>("testespansoipcmultiplesync", &std::env::temp_dir()).unwrap();
|
|
|
|
let response = client.send_sync(Event::Sync("test".to_owned())).unwrap();
|
|
|
|
std::thread::sleep(std::time::Duration::from_millis(500));
|
|
|
|
let response2 = client.send_sync(Event::Sync("test2".to_owned())).unwrap();
|
|
client.send_async(Event::ExitRequest).unwrap();
|
|
|
|
assert!(matches!(response, Event::SyncResult(s) if s == "test"));
|
|
assert!(matches!(response2, Event::SyncResult(s) if s == "test2"));
|
|
});
|
|
|
|
server
|
|
.run(Box::new(move |event| match event {
|
|
Event::ExitRequest => EventHandlerResponse::Exit,
|
|
Event::Sync(s) => EventHandlerResponse::Response(Event::SyncResult(s)),
|
|
_ => EventHandlerResponse::NoResponse,
|
|
}))
|
|
.unwrap();
|
|
|
|
client_handle.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn ipc_multiple_clients() {
|
|
let server = server::<Event>("testespansoipcmultiple", &std::env::temp_dir()).unwrap();
|
|
|
|
let (tx, rx) = channel();
|
|
|
|
let client_handle = std::thread::spawn(move || {
|
|
let mut client = client::<Event>("testespansoipcmultiple", &std::env::temp_dir()).unwrap();
|
|
|
|
let response = client.send_sync(Event::Sync("client1".to_owned())).unwrap();
|
|
|
|
tx.send(()).unwrap();
|
|
|
|
assert!(matches!(response, Event::SyncResult(s) if s == "client1"));
|
|
});
|
|
|
|
let client_handle2 = std::thread::spawn(move || {
|
|
let mut client = client::<Event>("testespansoipcmultiple", &std::env::temp_dir()).unwrap();
|
|
|
|
let response = client.send_sync(Event::Sync("client2".to_owned())).unwrap();
|
|
|
|
// Wait for the other client before terminating
|
|
rx.recv().unwrap();
|
|
|
|
client.send_async(Event::ExitRequest).unwrap();
|
|
|
|
assert!(matches!(response, Event::SyncResult(s) if s == "client2"));
|
|
});
|
|
|
|
server
|
|
.run(Box::new(move |event| match event {
|
|
Event::ExitRequest => EventHandlerResponse::Exit,
|
|
Event::Sync(s) => EventHandlerResponse::Response(Event::SyncResult(s)),
|
|
_ => EventHandlerResponse::NoResponse,
|
|
}))
|
|
.unwrap();
|
|
|
|
client_handle.join().unwrap();
|
|
client_handle2.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn ipc_sync_big_payload_message() {
|
|
let server = server::<Event>("testespansoipcsyncbig", &std::env::temp_dir()).unwrap();
|
|
|
|
let client_handle = std::thread::spawn(move || {
|
|
let mut client = client::<Event>("testespansoipcsyncbig", &std::env::temp_dir()).unwrap();
|
|
|
|
let mut payload = String::new();
|
|
for _ in 0..10000 {
|
|
payload.push_str("log string repeated");
|
|
}
|
|
let response = client.send_sync(Event::Sync(payload.clone())).unwrap();
|
|
client.send_async(Event::ExitRequest).unwrap();
|
|
|
|
assert!(matches!(response, Event::SyncResult(s) if s == payload));
|
|
});
|
|
|
|
server
|
|
.run(Box::new(move |event| match event {
|
|
Event::ExitRequest => EventHandlerResponse::Exit,
|
|
Event::Sync(s) => EventHandlerResponse::Response(Event::SyncResult(s)),
|
|
_ => EventHandlerResponse::NoResponse,
|
|
}))
|
|
.unwrap();
|
|
|
|
client_handle.join().unwrap();
|
|
}
|
|
}
|