Platform specific directory handling

client/client.rs

@@ -3,12 +3,10 @@ use std::env::{current_dir, vars};
 use std::io::{self, Write as std_Write};
 
 use anyhow::{bail, Context, Result};
-use async_std::net::TcpStream;
-#[cfg(not(windows))]
-use async_std::os::unix::net::UnixStream;
 use log::error;
 
 use pueue::message::*;
+use pueue::platform::socket::*;
 use pueue::protocol::*;
 use pueue::settings::Settings;
 
@@ -58,21 +56,7 @@ impl Client {
             }
         };
 
-        let mut socket: Box<dyn GenericSocket> = if let Some(socket_path) = unix_socket_path {
-            let stream = UnixStream::connect(socket_path).await?;
-            Box::new(stream)
-        } else {
-            // Don't allow anything else than loopback until we have proper crypto
-            // let address = format!("{}:{}", address, port);
-            let address = format!("127.0.0.1:{}", port.unwrap());
-
-            // Connect to socket
-            let socket = TcpStream::connect(&address)
-                .await
-                .context("Failed to connect to the daemon. Did you start it?")?;
-
-            Box::new(socket)
-        };
+        let mut socket = get_client(unix_socket_path, port).await?;
 
         // Send the secret to the daemon
         let secret = settings.shared.secret.clone().into_bytes();

daemon/socket.rs

@@ -1,9 +1,6 @@
 use std::sync::mpsc::Sender;
 
 use anyhow::{bail, Result};
-use async_std::net::TcpListener;
-#[cfg(not(windows))]
-use async_std::os::unix::net::UnixListener;
 use async_std::task;
 use log::{debug, info, warn};
 
@@ -38,13 +35,7 @@ pub async fn accept_incoming(sender: Sender<Message>, state: SharedState, opt: O
         }
     };
 
-    let listener: Box<dyn GenericListener> = if let Some(socket_path) = unix_socket_path {
-        Box::new(UnixListener::bind(socket_path).await?)
-    } else {
-        let port = port.unwrap();
-        let address = format!("127.0.0.1:{}", port);
-        Box::new(TcpListener::bind(address).await?)
-    };
+    let listener = get_listener(unix_socket_path, port).await?;
 
     loop {
         // Poll if we have a new incoming connection.

shared/platform/linux/directories.rs

@@ -7,12 +7,16 @@ use users::{get_current_uid, get_user_by_uid};
 pub fn get_unix_socket_path() -> Result<String> {
     // Get the user and their username
     let user = get_user_by_uid(get_current_uid())
-        .ok_or(anyhow!("Couldn't find username for current user"))?;
+        .ok_or_else(|| anyhow!("Couldn't find username for current user"))?;
     let username = user.name().to_string_lossy();
 
-    // Create the socket in the default /tmp/ directory
-    let path = Path::new("/tmp/").join(format!("pueue_{}.socket", username));
-    Ok(path.to_string_lossy().into())
+    // Create the socket in the default pueue path
+    let pueue_path = PathBuf::from(default_pueue_path()?);
+    let path = pueue_path.join(format!("pueue_{}.socket", username));
+    Ok(path
+        .to_str()
+        .ok_or_else(|| anyhow!("Failed to parse log path (Weird characters?)"))?
+        .to_string())
 }
 
 fn get_home_dir() -> Result<PathBuf> {
@@ -35,25 +39,25 @@ pub fn default_pueue_path() -> Result<String> {
     let path = get_home_dir()?.join(".local/share/pueue");
     Ok(path
         .to_str()
-        .ok_or(anyhow!("Failed to parse log path (Weird characters?)"))?
+        .ok_or_else(|| anyhow!("Failed to parse log path (Weird characters?)"))?
         .to_string())
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    use std::fs::{remove_file, File};
+    use std::fs::{create_dir_all, remove_file, File};
     use std::io::prelude::*;
 
     use anyhow::Result;
 
     #[test]
     fn test_create_unix_socket() -> Result<()> {
         let path = get_unix_socket_path()?;
+        create_dir_all(default_pueue_path()?)?;
 
-        // If pueue is currently running on the system,
-        // simply accept that we found the correct path
+        // If pueue is currently running on the system, simply accept that we found the correct path
         if PathBuf::from(&path).exists() {
             return Ok(());
         }

shared/platform/macos/directories.rs

@@ -1,6 +1,23 @@
 use std::path::{Path, PathBuf};
 
 use anyhow::{anyhow, Result};
+use users::{get_current_uid, get_user_by_uid};
+
+/// Get the default unix socket path for the current user
+pub fn get_unix_socket_path() -> Result<String> {
+    // Get the user and their username
+    let user = get_user_by_uid(get_current_uid())
+        .ok_or(anyhow!("Couldn't find username for current user"))?;
+    let username = user.name().to_string_lossy();
+
+    // Create the socket in the default pueue path
+    let pueue_path = PathBuf::from(default_pueue_path()?);
+    let path = pueue_path.join(format!("pueue_{}.socket", username));
+    Ok(path
+        .to_str()
+        .ok_or(anyhow!("Failed to parse log path (Weird characters?)"))?
+        .to_string())
+}
 
 fn get_home_dir() -> Result<PathBuf> {
     dirs::home_dir().ok_or_else(|| anyhow!("Couldn't resolve home dir"))

shared/platform/mod.rs

@@ -1,10 +1,25 @@
+/// Linux specific stuff
 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
 pub mod linux;
+/// MacOs specific stuff
 #[cfg(target_os = "macos")]
 pub mod macos;
+/// Shared unix stuff
+#[cfg(not(target_os = "windows"))]
+pub mod unix;
+/// Windows specific stuff
 #[cfg(target_os = "windows")]
 pub mod windows;
 
+/// Shared unix stuff for sockets
+#[cfg(not(target_os = "windows"))]
+pub use self::unix::socket;
+
+/// Windows specific socket stuff
+#[cfg(target_os = "windows")]
+pub use self::windows::socket;
+
+// The next block is platform specific directory functions
 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
 pub use self::linux::directories;
 

shared/platform/unix/mod.rs

@@ -0,0 +1 @@
+pub mod socket;

shared/platform/unix/socket.rs

@@ -0,0 +1,66 @@
+use anyhow::{Context, Result};
+use async_std::io::{Read, Write};
+use async_std::net::{TcpListener, TcpStream};
+use async_std::os::unix::net::{UnixListener, UnixStream};
+use async_trait::async_trait;
+
+pub trait GenericSocket: Read + Write + Unpin + Send + Sync {}
+pub type SocketBox = Box<dyn GenericSocket>;
+
+#[async_trait]
+pub trait GenericListener: Sync + Send {
+    async fn accept<'a>(&'a self) -> Result<Box<dyn GenericSocket>>;
+}
+
+#[async_trait]
+impl GenericListener for TcpListener {
+    async fn accept<'a>(&'a self) -> Result<Box<dyn GenericSocket>> {
+        let (socket, _) = self.accept().await?;
+        Ok(Box::new(socket))
+    }
+}
+
+#[async_trait]
+impl GenericListener for UnixListener {
+    async fn accept<'a>(&'a self) -> Result<Box<dyn GenericSocket>> {
+        let (socket, _) = self.accept().await?;
+        Ok(Box::new(socket))
+    }
+}
+
+impl GenericSocket for TcpStream {}
+impl GenericSocket for UnixStream {}
+
+pub async fn get_client(
+    unix_socket_path: Option<String>,
+    port: Option<String>,
+) -> Result<Box<dyn GenericSocket>> {
+    if let Some(socket_path) = unix_socket_path {
+        let stream = UnixStream::connect(socket_path).await?;
+        return Ok(Box::new(stream));
+    }
+
+    // Don't allow anything else than loopback until we have proper crypto
+    // let address = format!("{}:{}", address, port);
+    let address = format!("127.0.0.1:{}", port.unwrap());
+
+    // Connect to socket
+    let socket = TcpStream::connect(&address)
+        .await
+        .context("Failed to connect to the daemon. Did you start it?")?;
+
+    Ok(Box::new(socket))
+}
+
+pub async fn get_listener(
+    unix_socket_path: Option<String>,
+    port: Option<String>,
+) -> Result<Box<dyn GenericListener>> {
+    if let Some(socket_path) = unix_socket_path {
+        return Ok(Box::new(UnixListener::bind(socket_path).await?));
+    }
+
+    let port = port.unwrap();
+    let address = format!("127.0.0.1:{}", port);
+    Ok(Box::new(TcpListener::bind(address).await?))
+}

shared/platform/windows/directories.rs

@@ -2,6 +2,17 @@ use std::path::{Path, PathBuf};
 
 use anyhow::{anyhow, Result};
 
+/// Get the default unix socket path for the current user
+pub fn get_unix_socket_path() -> Result<String> {
+    // Create the socket in the default pueue path
+    let pueue_path = PathBuf::from(default_pueue_path()?);
+    let path = pueue_path.join("pueue.socket");
+    Ok(path
+        .to_str()
+        .ok_or(anyhow!("Failed to parse log path (Weird characters?)"))?
+        .to_string())
+}
+
 fn get_home_dir() -> Result<PathBuf> {
     dirs::home_dir().ok_or_else(|| anyhow!("Couldn't resolve home dir"))
 }

shared/platform/windows/mod.rs

@@ -1 +1,2 @@
 pub mod directories;
+pub mod socket;

shared/platform/windows/socket.rs

@@ -0,0 +1,31 @@
+use anyhow::Result;
+use async_std::io::{Read, Write};
+use async_std::net::{TcpListener, TcpStream};
+use async_trait::async_trait;
+
+pub trait GenericSocket: Read + Write + Unpin + Send + Sync {}
+pub type SocketBox = Box<dyn GenericSocket>;
+
+#[async_trait]
+pub trait GenericListener: Sync + Send {
+    async fn accept<'a>(&'a self) -> Result<Box<dyn GenericSocket>>;
+}
+
+#[async_trait]
+impl GenericListener for TcpListener {
+    async fn accept<'a>(&'a self) -> Result<Box<dyn GenericSocket>> {
+        let (socket, _) = self.accept().await?;
+        Ok(Box::new(socket))
+    }
+}
+
+impl GenericSocket for TcpStream {}
+
+pub async fn get_listener(
+    unix_socket_path: Option<String>,
+    port: Option<String>,
+) -> Result<Box<dyn GenericListener>> {
+    let port = port.unwrap();
+    let address = format!("127.0.0.1:{}", port);
+    Ok(Box::new(TcpListener::bind(address).await?))
+}

shared/protocol.rs

@@ -1,43 +1,13 @@
 use std::io::Cursor;
 
 use anyhow::{Context, Result};
-use async_std::io::{Read, Write};
-use async_std::net::{TcpListener, TcpStream};
-#[cfg(not(windows))]
-use async_std::os::unix::net::{UnixListener, UnixStream};
 use async_std::prelude::*;
-use async_trait::async_trait;
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use log::debug;
 
 use crate::message::*;
 
-#[async_trait]
-pub trait GenericListener: Sync + Send {
-    async fn accept<'a>(&'a self) -> Result<Box<dyn GenericSocket>>;
-}
-
-#[async_trait]
-impl GenericListener for TcpListener {
-    async fn accept<'a>(&'a self) -> Result<Box<dyn GenericSocket>> {
-        let (socket, _) = self.accept().await?;
-        Ok((Box::new(socket)))
-    }
-}
-
-#[cfg(not(windows))]
-#[async_trait]
-impl GenericListener for UnixListener {
-    async fn accept<'a>(&'a self) -> Result<Box<dyn GenericSocket>> {
-        let (socket, _) = self.accept().await?;
-        Ok((Box::new(socket)))
-    }
-}
-
-pub trait GenericSocket: Read + Write + Unpin + Send + Sync {}
-pub type SocketBox = Box<dyn GenericSocket>;
-impl GenericSocket for TcpStream {}
-impl GenericSocket for UnixStream {}
+pub use crate::platform::socket::*;
 
 /// Convenience wrapper around send_bytes.
 /// Deserialize a message and feed the bytes into send_bytes.