Initial commit

master
Tait Hoyem 2 years ago
commit 3c968ac7c3

@ -0,0 +1,15 @@
[package]
name = "odilia-recv"
version = "0.1.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
env_logger = "^0.8.4"
log = "^0.4.0"
sysinfo = "^0.23.0"
once_cell = "^1.9.0"
jsonrpc-core-client = "^18.0.0"
jsonrpc-core = "^18.0.0"
jsonrpc-derive = "^18.0.0"

@ -0,0 +1,126 @@
#![feature(fn_traits)]
use jsonrpc_core::Result;
use jsonrpc_derive::rpc;
use std::io::prelude::*;
use std::{
os::unix::net::{
UnixStream,
UnixListener,
},
env, fs,
path::Path,
process::{exit, id},
collections::HashMap,
};
use sysinfo::{ProcessExt, System, SystemExt};
#[rpc]
pub trait Rpc {
#[rpc(name = "test")]
fn test(&self) -> Result<()>;
#[rpc(name = "next")]
fn next(&self, attrs: HashMap<String, String>) -> Result<String>;
#[rpc(name = "changeMode")]
fn change_mode(&self, mode: String) -> Result<bool>;
}
fn set_mode(mode: &String) -> std::io::Result<()> {
println!("Treying to write to socket!");
let mut stream = UnixStream::connect("/tmp/odilia-mode.sock")?;
stream.write_all(mode.as_bytes())?;
println!("Wrote to socket!");
Ok(())
}
pub struct RpcImpl;
impl Rpc for RpcImpl {
fn change_mode(&self, mode: String) -> Result<bool> {
// change mode internally
let ret = set_mode(&mode);
match ret {
Ok(_) => println!("Success writing to socket!"),
Err(e) => println!("Error writing to socket: {:?}", e),
}
println!("MODE: {}", mode);
Ok(true)
}
fn test(&self) -> Result<()> {
println!("TEST IS RUN!");
Ok(())
}
fn next(&self, attrs: HashMap<String, String>) -> Result<String> {
for (key, val) in attrs.iter() {
println!("{}={}", key, val);
}
Ok("next where ^^".to_owned())
}
}
fn main() -> std::io::Result<()> {
let mut io = jsonrpc_core::IoHandler::new();
io.extend_with(RpcImpl.to_delegate());
env::set_var("RUST_LOG", "swhks=trace");
env_logger::init();
let pidfile: String = String::from("/tmp/odilia-recv.pid");
let sockfile: String = String::from("/tmp/odilia-ctrl.sock");
if Path::new(&pidfile).exists() {
log::trace!("Reading {} file and checking for running instances.", pidfile);
let swhkd_pid = match fs::read_to_string(&pidfile) {
Ok(swhkd_pid) => swhkd_pid,
Err(e) => {
log::error!("Unable to read {} to check all running instances", e);
exit(1);
}
};
log::debug!("Previous PID: {}", swhkd_pid);
let mut sys = System::new_all();
sys.refresh_all();
for (pid, process) in sys.processes() {
if pid.to_string() == swhkd_pid && process.exe() == env::current_exe().unwrap() {
log::error!("Server is already running!");
exit(1);
}
}
}
if Path::new(&sockfile).exists() {
log::trace!("Sockfile exists, attempting to remove it.");
match fs::remove_file(&sockfile) {
Ok(_) => {
log::debug!("Removed old socket file");
}
Err(e) => {
log::error!("Error removing the socket file!: {}", e);
log::error!("You can manually remove the socket file: {}", sockfile);
exit(1);
}
};
}
match fs::write(&pidfile, id().to_string()) {
Ok(_) => {}
Err(e) => {
log::error!("Unable to write to {}: {}", pidfile, e);
exit(1);
}
}
let listener = UnixListener::bind(sockfile)?;
loop {
match listener.accept() {
Ok((mut socket, addr)) => {
let mut response = String::new();
socket.read_to_string(&mut response)?;
println!("RESP: {}", io.handle_request_sync(&response).expect("Could not unwrap"));
println!("{}", &response);
//run_system_command(&response);
log::debug!("Socket: {:?} Address: {:?} Response: {}", socket, addr, response);
}
Err(e) => log::error!("accept function failed: {:?}", e),
}
}
}
Loading…
Cancel
Save