Client WIP.

src/bin/cli.rs

 use serde::{Deserialize, Serialize};
 use structopt::StructOpt;
 
-const SOCKET_PATH: &str = "$HOME/.twfss/sock";
-
 pub fn socket_path() -> String {
-    SOCKET_PATH
-        .to_owned()
-        .replace("$HOME", dirs::home_dir().unwrap().to_str().unwrap())
+    format!(
+        "{}/.twfss/sock",
+        dirs::home_dir().unwrap().to_str().unwrap().to_owned()
+    )
 }
 
 #[derive(StructOpt, Serialize, Deserialize)]
         status: bool,
     },
     AddDirectory {
+        // TODO: Login information.
         local_directory: PathBuf,
         remote_url: String,
     },
     RemoveDirectory {
         local_directory: PathBuf,
     },
+    // TODO: Command to update login information in case of login problems.
 }
 
 // The file is included in the sync client, where main() is unused.

src/bin/client.rs

+use std::fs::create_dir_all;
 use std::io::{self, Read, Write};
 use std::os::unix::net::{UnixListener, UnixStream};
+use std::sync::{Arc, Mutex};
 use std::thread;
 
+use twfss::{Database, SynchronizedDirectory};
+
 mod cli;
 
+fn config_dir() -> String {
+    format!(
+        "{}/.config/twfss",
+        dirs::home_dir().unwrap().to_str().unwrap().to_owned()
+    )
+}
+
+fn data_dir() -> String {
+    format!(
+        "{}/.local/share/twfss-client",
+        dirs::home_dir().unwrap().to_str().unwrap().to_owned()
+    )
+}
+
+fn db_path() -> String {
+    format!("{}/client.db", data_dir())
+}
+
 fn main() {
-    // Initialize the existing synchronized directories.
+    // Create the data directories if necessary.
+    create_dir_all(config_dir()).unwrap();
+    create_dir_all(data_dir()).unwrap();
+
+    // Check whether the client is already running, and exit if it is.
     // TODO
 
     // TODO: Register signal handler for graceful shutdown.
 
+    // Initialize the existing synchronized directories.
+    let mut directories = Vec::new();
+    let db = Arc::new(Mutex::new(Database::create_or_open(&db_path()).unwrap()));
+    for directory in db.lock().unwrap().synchronized_directories() {
+        // TODO: Error handling. If the directory was removed, remove it from the
+        // list of synchronized directories.
+        directories.push(SynchronizedDirectory::open(db.clone(), &directory, false).unwrap());
+    }
+
     // Listen for CLI commands.
     // TODO: Graceful shutdown on errors.
     let listener = UnixListener::bind(cli::socket_path()).unwrap();

src/lib.rs

+use std::io;
+use std::sync::{Arc, Mutex};
+
+pub struct SynchronizedDirectory {
+    db: Arc<Mutex<Database>>,
+    master: bool,
+    // TODO
+}
+
+impl SynchronizedDirectory {
+    pub fn open(
+        db: Arc<Mutex<Database>>,
+        _path: &str,
+        master: bool,
+    ) -> Result<SynchronizedDirectory, Error> {
+        // TODO
+        Ok(SynchronizedDirectory { db, master })
+    }
+
+    // TODO: Login information.
+    pub fn new(
+        db: Arc<Mutex<Database>>,
+        local_path: &str,
+        remote_path: &str,
+        master: bool,
+    ) -> Result<SynchronizedDirectory, Error> {
+        // TODO
+        Ok(SynchronizedDirectory { db, master })
+    }
+}
+
+pub struct SyncEvent {
+    // TODO
+}
+
+impl SyncEvent {
+    // TODO
+}
+
+pub struct Database {
+    // TODO
+}
+
+impl Database {
+    pub fn create_or_open(_path: &str) -> Result<Database, Error> {
+        // TODO
+        Ok(Database {})
+    }
+
+    pub fn synchronized_directories(&self) -> Vec<String> {
+        // TODO
+        Vec::new()
+    }
+}
+
+#[derive(Debug)]
+pub enum Error {
+    Io(std::io::Error),
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Error {
+        Error::Io(e)
+    }
+}