478 lines
11 KiB
Rust
478 lines
11 KiB
Rust
mod backup;
|
|
mod config;
|
|
mod export;
|
|
mod import;
|
|
mod log;
|
|
mod sql;
|
|
mod start;
|
|
mod version;
|
|
|
|
pub use config::CF;
|
|
|
|
use crate::cnf::LOGO;
|
|
use clap::{Arg, Command};
|
|
|
|
pub const LOG: &str = "surrealdb::cli";
|
|
|
|
const INFO: &str = "
|
|
To get started using SurrealDB, and for guides on connecting to and building applications
|
|
on top of SurrealDB, check out the SurrealDB documentation (https://surrealdb.com/docs).
|
|
|
|
If you have questions or ideas, join the SurrealDB community (https://surrealdb.com/community).
|
|
|
|
If you find a bug, submit an issue on Github (https://github.com/surrealdb/surrealdb/issues).
|
|
|
|
We would love it if you could star the repository (https://github.com/surrealdb/surrealdb).
|
|
|
|
----------
|
|
";
|
|
|
|
fn split_endpoint(v: &str) -> (&str, &str) {
|
|
v.split_once("://").unwrap_or_default()
|
|
}
|
|
|
|
fn file_valid(v: &str) -> Result<(), String> {
|
|
match v {
|
|
v if !v.is_empty() => Ok(()),
|
|
_ => Err(String::from(
|
|
"\
|
|
Provide a valid path to a SQL file\
|
|
",
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn path_valid(v: &str) -> Result<(), String> {
|
|
match v {
|
|
"memory" => Ok(()),
|
|
v if v.starts_with("file:") => Ok(()),
|
|
v if v.starts_with("rocksdb:") => Ok(()),
|
|
v if v.starts_with("tikv:") => Ok(()),
|
|
v if v.starts_with("fdb:") => Ok(()),
|
|
_ => Err(String::from(
|
|
"\
|
|
Provide a valid database path parameter\
|
|
",
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn conn_valid(v: &str) -> Result<(), String> {
|
|
let scheme = split_endpoint(v).0;
|
|
match scheme {
|
|
"http" | "https" | "ws" | "wss" | "fdb" | "mem" | "rocksdb" | "file" | "tikv" => Ok(()),
|
|
_ => Err(String::from(
|
|
"\
|
|
Provide a valid database connection string\
|
|
",
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn from_valid(v: &str) -> Result<(), String> {
|
|
match v {
|
|
v if v.ends_with(".db") => Ok(()),
|
|
v if v.starts_with("http://") => Ok(()),
|
|
v if v.starts_with("https://") => Ok(()),
|
|
_ => Err(String::from(
|
|
"\
|
|
Provide a valid database connection string, \
|
|
or specify the path to a database file\
|
|
",
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn into_valid(v: &str) -> Result<(), String> {
|
|
match v {
|
|
v if v.ends_with(".db") => Ok(()),
|
|
v if v.starts_with("http://") => Ok(()),
|
|
v if v.starts_with("https://") => Ok(()),
|
|
_ => Err(String::from(
|
|
"\
|
|
Provide a valid database connection string, \
|
|
or specify the path to a database file\
|
|
",
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn key_valid(v: &str) -> Result<(), String> {
|
|
match v.len() {
|
|
16 => Ok(()),
|
|
24 => Ok(()),
|
|
32 => Ok(()),
|
|
_ => Err(String::from(
|
|
"\
|
|
For AES-128 encryption use a 16 bit key, \
|
|
for AES-192 encryption use a 24 bit key, \
|
|
and for AES-256 encryption use a 32 bit key\
|
|
",
|
|
)),
|
|
}
|
|
}
|
|
|
|
pub fn init() {
|
|
let setup = Command::new("SurrealDB command-line interface and server")
|
|
.about(INFO)
|
|
.before_help(LOGO)
|
|
.disable_version_flag(true)
|
|
.arg_required_else_help(true);
|
|
|
|
let setup = setup.subcommand(
|
|
Command::new("start")
|
|
.display_order(1)
|
|
.about("Start the database server")
|
|
.arg(
|
|
Arg::new("path")
|
|
.index(1)
|
|
.env("DB_PATH")
|
|
.required(false)
|
|
.validator(path_valid)
|
|
.default_value("memory")
|
|
.help("Database path used for storing data"),
|
|
)
|
|
.arg(
|
|
Arg::new("user")
|
|
.short('u')
|
|
.env("USER")
|
|
.long("user")
|
|
.forbid_empty_values(true)
|
|
.default_value("root")
|
|
.help("The master username for the database"),
|
|
)
|
|
.arg(
|
|
Arg::new("pass")
|
|
.short('p')
|
|
.env("PASS")
|
|
.long("pass")
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.help("The master password for the database"),
|
|
)
|
|
.arg(
|
|
Arg::new("addr")
|
|
.env("ADDR")
|
|
.long("addr")
|
|
.number_of_values(1)
|
|
.forbid_empty_values(true)
|
|
.multiple_occurrences(true)
|
|
.default_value("127.0.0.1/32")
|
|
.help("The allowed networks for master authentication"),
|
|
)
|
|
.arg(
|
|
Arg::new("bind")
|
|
.short('b')
|
|
.env("BIND")
|
|
.long("bind")
|
|
.forbid_empty_values(true)
|
|
.default_value("0.0.0.0:8000")
|
|
.help("The hostname or ip address to listen for connections on"),
|
|
)
|
|
.arg(
|
|
Arg::new("key")
|
|
.short('k')
|
|
.env("KEY")
|
|
.long("key")
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.validator(key_valid)
|
|
.help("Encryption key to use for on-disk encryption"),
|
|
)
|
|
.arg(
|
|
Arg::new("kvs-ca")
|
|
.env("KVS_CA")
|
|
.long("kvs-ca")
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.help("Path to the CA file used when connecting to the remote KV store"),
|
|
)
|
|
.arg(
|
|
Arg::new("kvs-crt")
|
|
.env("KVS_CRT")
|
|
.long("kvs-crt")
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.help(
|
|
"Path to the certificate file used when connecting to the remote KV store",
|
|
),
|
|
)
|
|
.arg(
|
|
Arg::new("kvs-key")
|
|
.env("KVS_KEY")
|
|
.long("kvs-key")
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.help(
|
|
"Path to the private key file used when connecting to the remote KV store",
|
|
),
|
|
)
|
|
.arg(
|
|
Arg::new("web-crt")
|
|
.env("WEB_CRT")
|
|
.long("web-crt")
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.help("Path to the certificate file for encrypted client connections"),
|
|
)
|
|
.arg(
|
|
Arg::new("web-key")
|
|
.env("WEB_KEY")
|
|
.long("web-key")
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.help("Path to the private key file for encrypted client connections"),
|
|
)
|
|
.arg(
|
|
Arg::new("strict")
|
|
.short('s')
|
|
.env("STRICT")
|
|
.long("strict")
|
|
.required(false)
|
|
.takes_value(false)
|
|
.help("Whether strict mode is enabled on this database instance"),
|
|
)
|
|
.arg(
|
|
Arg::new("log")
|
|
.short('l')
|
|
.env("LOG")
|
|
.long("log")
|
|
.takes_value(true)
|
|
.default_value("info")
|
|
.forbid_empty_values(true)
|
|
.help("The logging level for the database server")
|
|
.value_parser(["warn", "info", "debug", "trace", "full"]),
|
|
)
|
|
.arg(
|
|
Arg::new("no-banner")
|
|
.env("NO_BANNER")
|
|
.long("no-banner")
|
|
.required(false)
|
|
.takes_value(false)
|
|
.help("Whether to hide the startup banner"),
|
|
),
|
|
);
|
|
|
|
let setup = setup.subcommand(
|
|
Command::new("backup")
|
|
.display_order(2)
|
|
.about("Backup data to or from an existing database")
|
|
.arg(
|
|
Arg::new("from")
|
|
.index(1)
|
|
.required(true)
|
|
.validator(from_valid)
|
|
.help("Path to the remote database or file from which to export"),
|
|
)
|
|
.arg(
|
|
Arg::new("into")
|
|
.index(2)
|
|
.required(true)
|
|
.validator(into_valid)
|
|
.help("Path to the remote database or file into which to import"),
|
|
)
|
|
.arg(
|
|
Arg::new("user")
|
|
.short('u')
|
|
.long("user")
|
|
.forbid_empty_values(true)
|
|
.default_value("root")
|
|
.help("Database authentication username to use when connecting"),
|
|
)
|
|
.arg(
|
|
Arg::new("pass")
|
|
.short('p')
|
|
.long("pass")
|
|
.forbid_empty_values(true)
|
|
.default_value("root")
|
|
.help("Database authentication password to use when connecting"),
|
|
),
|
|
);
|
|
|
|
let setup = setup.subcommand(
|
|
Command::new("import")
|
|
.display_order(3)
|
|
.about("Import a SurrealQL script into an existing database")
|
|
.arg(
|
|
Arg::new("file")
|
|
.index(1)
|
|
.required(true)
|
|
.validator(file_valid)
|
|
.help("Path to the sql file to import"),
|
|
)
|
|
.arg(
|
|
Arg::new("ns")
|
|
.long("ns")
|
|
.required(true)
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.help("The namespace to import the data into"),
|
|
)
|
|
.arg(
|
|
Arg::new("db")
|
|
.long("db")
|
|
.required(true)
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.help("The database to import the data into"),
|
|
)
|
|
.arg(
|
|
Arg::new("conn")
|
|
.short('c')
|
|
.long("conn")
|
|
.alias("host")
|
|
.forbid_empty_values(true)
|
|
.validator(conn_valid)
|
|
.default_value("https://cloud.surrealdb.com")
|
|
.help("Remote database server url to connect to"),
|
|
)
|
|
.arg(
|
|
Arg::new("user")
|
|
.short('u')
|
|
.long("user")
|
|
.forbid_empty_values(true)
|
|
.default_value("root")
|
|
.help("Database authentication username to use when connecting"),
|
|
)
|
|
.arg(
|
|
Arg::new("pass")
|
|
.short('p')
|
|
.long("pass")
|
|
.forbid_empty_values(true)
|
|
.default_value("root")
|
|
.help("Database authentication password to use when connecting"),
|
|
),
|
|
);
|
|
|
|
let setup = setup.subcommand(
|
|
Command::new("export")
|
|
.display_order(4)
|
|
.about("Export an existing database as a SurrealQL script")
|
|
.arg(
|
|
Arg::new("file")
|
|
.index(1)
|
|
.required(true)
|
|
.validator(file_valid)
|
|
.help("Path to the sql file to export"),
|
|
)
|
|
.arg(
|
|
Arg::new("ns")
|
|
.long("ns")
|
|
.required(true)
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.help("The namespace to export the data from"),
|
|
)
|
|
.arg(
|
|
Arg::new("db")
|
|
.long("db")
|
|
.required(true)
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.help("The database to export the data from"),
|
|
)
|
|
.arg(
|
|
Arg::new("conn")
|
|
.short('c')
|
|
.long("conn")
|
|
.alias("host")
|
|
.forbid_empty_values(true)
|
|
.validator(conn_valid)
|
|
.default_value("https://cloud.surrealdb.com")
|
|
.help("Remote database server url to connect to"),
|
|
)
|
|
.arg(
|
|
Arg::new("user")
|
|
.short('u')
|
|
.long("user")
|
|
.forbid_empty_values(true)
|
|
.default_value("root")
|
|
.help("Database authentication username to use when connecting"),
|
|
)
|
|
.arg(
|
|
Arg::new("pass")
|
|
.short('p')
|
|
.long("pass")
|
|
.forbid_empty_values(true)
|
|
.default_value("root")
|
|
.help("Database authentication password to use when connecting"),
|
|
),
|
|
);
|
|
|
|
let setup = setup.subcommand(
|
|
Command::new("version")
|
|
.display_order(5)
|
|
.about("Output the command-line tool version information"),
|
|
);
|
|
|
|
let setup = setup.subcommand(
|
|
Command::new("sql")
|
|
.display_order(6)
|
|
.about("Start an SQL REPL in your terminal with pipe support")
|
|
.arg(
|
|
Arg::new("ns")
|
|
.long("ns")
|
|
.required(false)
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.help("The namespace to export the data from"),
|
|
)
|
|
.arg(
|
|
Arg::new("db")
|
|
.long("db")
|
|
.required(false)
|
|
.takes_value(true)
|
|
.forbid_empty_values(true)
|
|
.help("The database to export the data from"),
|
|
)
|
|
.arg(
|
|
Arg::new("conn")
|
|
.short('c')
|
|
.long("conn")
|
|
.alias("host")
|
|
.forbid_empty_values(true)
|
|
.validator(conn_valid)
|
|
.default_value("https://cloud.surrealdb.com")
|
|
.help("Remote database server url to connect to"),
|
|
)
|
|
.arg(
|
|
Arg::new("user")
|
|
.short('u')
|
|
.long("user")
|
|
.forbid_empty_values(true)
|
|
.default_value("root")
|
|
.help("Database authentication username to use when connecting"),
|
|
)
|
|
.arg(
|
|
Arg::new("pass")
|
|
.short('p')
|
|
.long("pass")
|
|
.forbid_empty_values(true)
|
|
.default_value("root")
|
|
.help("Database authentication password to use when connecting"),
|
|
)
|
|
.arg(
|
|
Arg::new("pretty")
|
|
.long("pretty")
|
|
.required(false)
|
|
.takes_value(false)
|
|
.help("Whether database responses should be pretty printed"),
|
|
),
|
|
);
|
|
|
|
let matches = setup.get_matches();
|
|
|
|
let output = match matches.subcommand() {
|
|
Some(("sql", m)) => futures::executor::block_on(sql::init(m)),
|
|
Some(("start", m)) => start::init(m),
|
|
Some(("backup", m)) => backup::init(m),
|
|
Some(("import", m)) => import::init(m),
|
|
Some(("export", m)) => export::init(m),
|
|
Some(("version", m)) => version::init(m),
|
|
_ => Ok(()),
|
|
};
|
|
|
|
if let Err(e) = output {
|
|
error!(target: LOG, "{}", e);
|
|
}
|
|
}
|