Add data directory configuration option

Currently we have `--seed-file` for the seed file and a config option
for the database.  Both of these files default to the systems data
directory with `comit/` appended.  It makes more sense to configure
these two items in the same fashion.

Add configuration option

	[Data]
	dir = path/to/data/dir

Use this path with `cnd.sqlite` and `seed.pem` appended for the database
and seed file respectively.

Remove `--seed-file` command line option and the database configuration
option.

Author: Tobin C. Harding

cnd/src/cli.rs

@@ -7,10 +7,6 @@ pub struct Options {
     #[structopt(short = "c", long = "config", parse(from_os_str))]
     pub config_file: Option<PathBuf>,
 
-    /// Path to secret seed file.
-    #[structopt(short = "s", long = "seed-file", parse(from_os_str))]
-    pub seed_file: Option<PathBuf>,
-
     /// Dump the current configuration and exit.
     #[structopt(long = "dump-config")]
     pub dump_config: bool,

cnd/src/config/file.rs

@@ -1,4 +1,4 @@
-use crate::config::{Bitcoin, Database, Ethereum, Network, Socket};
+use crate::config::{Bitcoin, Data, Ethereum, Network, Socket};
 use config as config_rs;
 use log::LevelFilter;
 use std::{ffi::OsStr, path::Path};
@@ -12,7 +12,7 @@ use std::{ffi::OsStr, path::Path};
 pub struct File {
     pub network: Option<Network>,
     pub http_api: Option<HttpApi>,
-    pub database: Option<Database>,
+    pub data: Option<Data>,
     pub logging: Option<Logging>,
     pub bitcoin: Option<Bitcoin>,
     pub ethereum: Option<Ethereum>,
@@ -23,7 +23,7 @@ impl File {
         File {
             network: Option::None,
             http_api: Option::None,
-            database: Option::None,
+            data: Option::None,
             logging: Option::None,
             bitcoin: Option::None,
             ethereum: Option::None,
@@ -160,8 +160,8 @@ port = 8000
 [http_api.cors]
 allowed_origins = "all"
 
-[database]
-sqlite = "/tmp/foobar.sqlite"
+[data]
+dir = "/tmp/comit/"
 
 [logging]
 level = "DEBUG"
@@ -188,8 +188,8 @@ node_url = "http://example.com/"
                     allowed_origins: AllowedOrigins::All(All::All),
                 }),
             }),
-            database: Some(Database {
-                sqlite: PathBuf::from("/tmp/foobar.sqlite"),
+            data: Some(Data {
+                dir: PathBuf::from("/tmp/comit/"),
             }),
             logging: Some(Logging {
                 level: Some(LevelFilter::Debug),

cnd/src/config/mod.rs

@@ -9,8 +9,8 @@ use std::{net::IpAddr, path::PathBuf};
 pub use self::{file::File, settings::Settings};
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-pub struct Database {
-    pub sqlite: PathBuf,
+pub struct Data {
+    pub dir: PathBuf,
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]

cnd/src/config/settings.rs

@@ -1,11 +1,8 @@
-use crate::config::{file, Bitcoin, Database, Ethereum, File, Network, Socket};
+use crate::config::{file, Bitcoin, Data, Ethereum, File, Network, Socket};
 use anyhow::Context;
 use log::LevelFilter;
 use reqwest::Url;
-use std::{
-    net::{IpAddr, Ipv4Addr},
-    path::Path,
-};
+use std::net::{IpAddr, Ipv4Addr};
 
 /// This structs represents the settings as they are used through out the code.
 ///
@@ -17,7 +14,7 @@ use std::{
 pub struct Settings {
     pub network: Network,
     pub http_api: HttpApi,
-    pub database: Database,
+    pub data: Data,
     pub logging: Logging,
     pub bitcoin: Bitcoin,
     pub ethereum: Ethereum,
@@ -28,7 +25,7 @@ impl From<Settings> for File {
         let Settings {
             network,
             http_api: HttpApi { socket, cors },
-            database,
+            data,
             logging: Logging { level, structured },
             bitcoin,
             ethereum,
@@ -46,7 +43,7 @@ impl From<Settings> for File {
                     },
                 }),
             }),
-            database: Some(database),
+            data: Some(data),
             logging: Some(file::Logging {
                 level: Some(level),
                 structured: Some(structured),
@@ -108,7 +105,7 @@ impl Settings {
         let File {
             network,
             http_api,
-            database,
+            data,
             logging,
             bitcoin,
             ethereum,
@@ -143,14 +140,14 @@ impl Settings {
                     HttpApi { socket, cors }
                 })
                 .unwrap_or_default(),
-            database: {
-                let default_database_path = crate::data_dir()
-                    .map(|dir| Path::join(&dir, "cnd.sqlite"))
-                    .context("unable to determine default database path")?;
-                database.unwrap_or_else(|| Database {
-                    sqlite: default_database_path,
+            data: {
+                let default_data_dir =
+                    crate::data_dir().context("unable to determine default database path")?;
+                data.unwrap_or_else(|| Data {
+                    dir: default_data_dir,
                 })
             },
+
             logging: {
                 let Logging {
                     level: default_level,

cnd/src/db/mod.rs

@@ -25,7 +25,11 @@ use crate::{
     swap_protocols::{Role, SwapId},
 };
 use diesel::{self, prelude::*, sqlite::SqliteConnection};
-use std::{path::Path, sync::Arc};
+use std::{
+    ffi::OsStr,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 
 /// This module provides persistent storage by way of Sqlite.
 
@@ -39,16 +43,27 @@ pub struct Sqlite {
 impl Sqlite {
     /// Return a handle that can be used to access the database.
     ///
-    /// When this returns an Sqlite database exists at 'path', a
-    /// successful connection to the database has been made, and
-    /// the database migrations have been run.
-    pub fn new(path: &Path) -> anyhow::Result<Self> {
-        ensure_folder_tree_exists(path)?;
+    /// When this returns, an Sqlite database file 'cnd.sql' exists in 'dir', a
+    /// successful connection to the database has been made, and the database
+    /// migrations have been run.
+    pub fn new_in_dir<D: AsRef<OsStr>>(dir: D) -> anyhow::Result<Self> {
+        let dir = Path::new(&dir);
+        let path = db_path_from_dir(dir);
+        Sqlite::new(&path)
+    }
 
-        let connection = SqliteConnection::establish(&format!("file:{}", path.display()))?;
+    /// Return a handle that can be used to access the database.
+    ///
+    /// Reads or creates an SQLite database file at 'file'.  When this returns
+    /// an Sqlite database exists, a successful connection to the database has
+    /// been made, and the database migrations have been run.
+    pub fn new(file: &Path) -> anyhow::Result<Self> {
+        ensure_folder_tree_exists(file)?;
+
+        let connection = SqliteConnection::establish(&format!("file:{}", file.display()))?;
         embedded_migrations::run(&connection)?;
 
-        log::info!("SQLite database file: {}", path.display());
+        log::info!("SQLite database file: {}", file.display());
 
         Ok(Sqlite {
             connection: Arc::new(async_std::sync::Mutex::new(connection)),
@@ -88,6 +103,12 @@ impl Sqlite {
     }
 }
 
+// Construct an absolute path to the database file using 'dir' as the base.
+fn db_path_from_dir(dir: &Path) -> PathBuf {
+    let path = dir.to_path_buf();
+    path.join("cnd.sqlite")
+}
+
 fn ensure_folder_tree_exists(path: &Path) -> anyhow::Result<()> {
     if let Some(parent) = path.parent() {
         std::fs::create_dir_all(parent)?;

cnd/src/lib.rs

@@ -59,6 +59,6 @@ pub fn default_config_path() -> anyhow::Result<PathBuf> {
 // Linux: /home/<user>/.local/share/comit/
 // Windows: C:\Users\<user>\AppData\Roaming\comit\
 // OSX: /Users/<user>/Library/Application Support/comit/
-fn data_dir() -> Option<PathBuf> {
+pub fn data_dir() -> Option<PathBuf> {
     ProjectDirs::from("", "", "comit").map(|proj_dirs| proj_dirs.data_dir().to_path_buf())
 }

cnd/src/main.rs

@@ -48,10 +48,7 @@ fn main() -> anyhow::Result<()> {
     let base_log_level = settings.logging.level;
     logging::initialize(base_log_level, settings.logging.structured)?;
 
-    let seed = match options.seed_file {
-        Some(file) => Seed::from_file(file)?,
-        None => Seed::from_default_file_or_generate(OsRng)?,
-    };
+    let seed = Seed::from_dir_or_generate(&settings.data.dir, OsRng)?;
 
     let mut runtime = tokio::runtime::Runtime::new()?;
 
@@ -70,7 +67,7 @@ fn main() -> anyhow::Result<()> {
 
     let state_store = Arc::new(InMemoryStateStore::default());
 
-    let database = Sqlite::new(&settings.database.sqlite)?;
+    let database = Sqlite::new_in_dir(&settings.data.dir)?;
 
     let local_key_pair = derive_key_pair(&seed);
     let local_peer_id = PeerId::from(local_key_pair.clone().public());

cnd/src/seed.rs

@@ -49,8 +49,35 @@ impl Seed {
         Ok(Seed(arr))
     }
 
-    /// Construct a seed from base64 data read in from pem file.
-    pub fn from_file<D: AsRef<OsStr>>(seed_file: D) -> Result<Seed, Error> {
+    /// Read the seed from the default location if it exists, otherwise
+    /// generate a random seed and write it to the default location.
+    pub fn from_default_dir_or_generate<R: Rng>(rand: R) -> Result<Seed, Error> {
+        let path = default_seed_path()?;
+        Seed::from_dir_or_generate(&path, rand)
+    }
+
+    /// Read the seed from the directory if it exists, otherwise
+    /// generate a random seed and write it to that location.
+    pub fn from_dir_or_generate<D: AsRef<OsStr>, R: Rng>(
+        data_dir: D,
+        rand: R,
+    ) -> Result<Seed, Error> {
+        let dir = Path::new(&data_dir);
+        let path = seed_path_from_dir(dir);
+
+        if path.exists() {
+            return Self::from_file(&path);
+        }
+
+        let random_seed = Seed::new_random(rand)?;
+        random_seed.write_to(path.clone())?;
+
+        log::info!("No seed file found, creating at: {}", path.display());
+
+        Ok(random_seed)
+    }
+
+    fn from_file<D: AsRef<OsStr>>(seed_file: D) -> Result<Seed, Error> {
         let file = Path::new(&seed_file);
         let contents = fs::read_to_string(file)?;
         let pem = pem::parse(contents)?;
@@ -73,23 +100,6 @@ impl Seed {
         }
     }
 
-    /// Read the seed from the default location if it exists, otherwise
-    /// generate a random seed and write it to the default location.
-    pub fn from_default_file_or_generate<R: Rng>(rand: R) -> Result<Seed, Error> {
-        let path = default_seed_path()?;
-
-        if path.exists() {
-            return Self::from_file(&path);
-        }
-
-        let random_seed = Seed::new_random(rand)?;
-        random_seed.write_to(path.clone())?;
-
-        log::info!("No seed file found, creating default at {}", path.display());
-
-        Ok(random_seed)
-    }
-
     fn write_to(&self, seed_file: PathBuf) -> Result<(), Error> {
         ensure_directory_exists(seed_file.clone())?;
         self._write_to(seed_file)?;
@@ -135,9 +145,13 @@ fn ensure_directory_exists(file: PathBuf) -> Result<(), Error> {
 }
 
 fn default_seed_path() -> Result<PathBuf, Error> {
-    crate::data_dir()
-        .map(|dir| Path::join(&dir, "seed.pem"))
-        .ok_or(Error::NoDefaultPath)
+    let default_path = crate::data_dir().ok_or(Error::NoDefaultPath)?;
+    Ok(seed_path_from_dir(&default_path))
+}
+
+fn seed_path_from_dir(dir: &Path) -> PathBuf {
+    let path = dir.to_path_buf();
+    path.join("seed.pem")
 }
 
 #[derive(Debug, thiserror::Error)]