aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--src/db/lib.rs42
-rw-r--r--src/garage/cli/convert_db.rs58
2 files changed, 88 insertions, 12 deletions
diff --git a/src/db/lib.rs b/src/db/lib.rs
index fe44b01e..eef3e177 100644
--- a/src/db/lib.rs
+++ b/src/db/lib.rs
@@ -171,6 +171,48 @@ impl Db {
}
}
+/// List of supported database engine types
+///
+/// The `enum` holds list of *all* database engines that are are be supported by crate, no matter
+/// if relevant feature is enabled or not. It allows us to distinguish between invalid engine
+/// and valid engine, whose support is not enabled via feature flag.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Engine {
+ Lmdb,
+ Sqlite,
+ Sled,
+}
+
+impl Engine {
+ /// Return variant name as static `&str`
+ pub fn as_str(&self) -> &'static str {
+ match self {
+ Self::Lmdb => "lmdb",
+ Self::Sqlite => "sqlite",
+ Self::Sled => "sled",
+ }
+ }
+}
+
+impl std::fmt::Display for Engine {
+ fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+ self.as_str().fmt(fmt)
+ }
+}
+
+impl std::str::FromStr for Engine {
+ type Err = Error;
+
+ fn from_str(text: &str) -> Result<Engine> {
+ match text {
+ "lmdb" | "heed" => Ok(Self::Lmdb),
+ "sqlite" | "sqlite3" | "rusqlite" => Ok(Self::Sqlite),
+ "sled" => Ok(Self::Sled),
+ kind => Err(Error(format!("Invalid DB engine: {}", kind).into())),
+ }
+ }
+}
+
#[allow(clippy::len_without_is_empty)]
impl Tree {
#[inline]
diff --git a/src/garage/cli/convert_db.rs b/src/garage/cli/convert_db.rs
index 3c6ce69c..044ccbb9 100644
--- a/src/garage/cli/convert_db.rs
+++ b/src/garage/cli/convert_db.rs
@@ -14,44 +14,73 @@ pub struct ConvertDbOpt {
/// Input database engine (sled, lmdb or sqlite; limited by db engines
/// enabled in this build)
#[structopt(short = "a")]
- input_engine: String,
+ input_engine: Engine,
/// Output database path
#[structopt(short = "o")]
output_path: PathBuf,
/// Output database engine
#[structopt(short = "b")]
- output_engine: String,
+ output_engine: Engine,
+
+ #[structopt(flatten)]
+ db_open: OpenDbOpt,
+}
+
+/// Overrides for database open operation
+#[derive(StructOpt, Debug, Default)]
+pub struct OpenDbOpt {
+ #[cfg(feature = "lmdb")]
+ #[structopt(flatten)]
+ lmdb: OpenLmdbOpt,
+}
+
+/// Overrides for LMDB database open operation
+#[cfg(feature = "lmdb")]
+#[derive(StructOpt, Debug, Default)]
+pub struct OpenLmdbOpt {
+ /// LMDB map size override
+ /// (supported suffixes: B, KiB, MiB, GiB, TiB, PiB)
+ #[cfg(feature = "lmdb")]
+ #[structopt(long = "lmdb-map-size", name = "bytes", display_order = 1_000)]
+ map_size: Option<bytesize::ByteSize>,
}
pub(crate) fn do_conversion(args: ConvertDbOpt) -> Result<()> {
- let input = open_db(args.input_path, args.input_engine)?;
- let output = open_db(args.output_path, args.output_engine)?;
+ if args.input_engine == args.output_engine {
+ return Err(Error("input and output database engine must differ".into()));
+ }
+
+ let input = open_db(args.input_path, args.input_engine, &args.db_open)?;
+ let output = open_db(args.output_path, args.output_engine, &args.db_open)?;
output.import(&input)?;
Ok(())
}
-fn open_db(path: PathBuf, engine: String) -> Result<Db> {
- match engine.as_str() {
+fn open_db(path: PathBuf, engine: Engine, open: &OpenDbOpt) -> Result<Db> {
+ match engine {
#[cfg(feature = "sled")]
- "sled" => {
+ Engine::Sled => {
let db = sled_adapter::sled::Config::default().path(&path).open()?;
Ok(sled_adapter::SledDb::init(db))
}
#[cfg(feature = "sqlite")]
- "sqlite" | "sqlite3" | "rusqlite" => {
+ Engine::Sqlite => {
let db = sqlite_adapter::rusqlite::Connection::open(&path)?;
db.pragma_update(None, "journal_mode", &"WAL")?;
db.pragma_update(None, "synchronous", &"NORMAL")?;
Ok(sqlite_adapter::SqliteDb::init(db))
}
#[cfg(feature = "lmdb")]
- "lmdb" | "heed" => {
+ Engine::Lmdb => {
std::fs::create_dir_all(&path).map_err(|e| {
Error(format!("Unable to create LMDB data directory: {}", e).into())
})?;
- let map_size = lmdb_adapter::recommended_map_size();
+ let map_size = match open.lmdb.map_size {
+ Some(c) => c.as_u64() as usize,
+ None => lmdb_adapter::recommended_map_size(),
+ };
let mut env_builder = lmdb_adapter::heed::EnvOpenOptions::new();
env_builder.max_dbs(100);
@@ -62,8 +91,13 @@ fn open_db(path: PathBuf, engine: String) -> Result<Db> {
let db = env_builder.open(&path)?;
Ok(lmdb_adapter::LmdbDb::init(db))
}
- e => Err(Error(
- format!("Invalid or unsupported DB engine: {}", e).into(),
+
+ // Pattern is unreachable when all supported DB engines are compiled into binary. The allow
+ // attribute is added so that we won't have to change this match in case stop building
+ // support for one or more engines by default.
+ #[allow(unreachable_patterns)]
+ engine => Err(Error(
+ format!("Engine support not available in this build: {}", engine).into(),
)),
}
}