mirror of
https://github.com/abraunegg/onedrive
synced 2024-05-23 08:02:16 +02:00
286 lines
8.9 KiB
D
286 lines
8.9 KiB
D
import core.stdc.stdlib: EXIT_SUCCESS, EXIT_FAILURE, exit;
|
|
import std.file, std.string, std.regex, std.stdio, std.process, std.algorithm.searching, std.getopt, std.conv;
|
|
import selective;
|
|
static import log;
|
|
|
|
final class Config
|
|
{
|
|
public string refreshTokenFilePath;
|
|
public string deltaLinkFilePath;
|
|
public string databaseFilePath;
|
|
public string uploadStateFilePath;
|
|
public string syncListFilePath;
|
|
public string homePath;
|
|
|
|
private string userConfigFilePath;
|
|
// hashmap for the values found in the user config file
|
|
// ARGGGG D is stupid and cannot make hashmap initializations!!!
|
|
// private string[string] foobar = [ "aa": "bb" ] does NOT work!!!
|
|
private string[string] stringValues;
|
|
private bool[string] boolValues;
|
|
private long[string] longValues;
|
|
|
|
|
|
this(string configDirName)
|
|
{
|
|
// default configuration
|
|
stringValues["single_directory"] = "";
|
|
stringValues["sync_dir"] = "~/OneDrive";
|
|
stringValues["skip_file"] = "~*";
|
|
stringValues["log_dir"] = "/var/log/onedrive/";
|
|
stringValues["drive_id"] = "";
|
|
boolValues["upload_only"] = false;
|
|
boolValues["check_for_nomount"] = false;
|
|
boolValues["download_only"] = false;
|
|
boolValues["disable_notifications"] = false;
|
|
boolValues["disable_upload_validation"] = false;
|
|
boolValues["enable_logging"] = false;
|
|
boolValues["force_http_11"] = false;
|
|
boolValues["local_first"] = false;
|
|
boolValues["no_remote_delete"] = false;
|
|
boolValues["skip_symlinks"] = false;
|
|
boolValues["debug_https"] = false;
|
|
longValues["verbose"] = 0;
|
|
longValues["monitor_interval"] = 45,
|
|
longValues["min_notif_changes"] = 5;
|
|
|
|
// Determine the users home directory.
|
|
// Need to avoid using ~ here as expandTilde() below does not interpret correctly when running under init.d or systemd scripts
|
|
// Check for HOME environment variable
|
|
if (environment.get("HOME") != ""){
|
|
// Use HOME environment variable
|
|
log.vdebug("homePath: HOME environment variable set");
|
|
homePath = environment.get("HOME");
|
|
} else {
|
|
if ((environment.get("SHELL") == "") && (environment.get("USER") == "")){
|
|
// No shell is set or username - observed case when running as systemd service under CentOS 7.x
|
|
log.vdebug("homePath: WARNING - no HOME environment variable set");
|
|
log.vdebug("homePath: WARNING - no SHELL environment variable set");
|
|
log.vdebug("homePath: WARNING - no USER environment variable set");
|
|
homePath = "/root";
|
|
} else {
|
|
// A shell & valid user is set, but no HOME is set, use ~ which can be expanded
|
|
log.vdebug("homePath: WARNING - no HOME environment variable set");
|
|
homePath = "~";
|
|
}
|
|
}
|
|
|
|
// Output homePath calculation
|
|
log.vdebug("homePath: ", homePath);
|
|
|
|
|
|
// Determine the correct configuration directory to use
|
|
string configDirBase;
|
|
if (configDirName != "") {
|
|
// A CLI 'confdir' was passed in
|
|
log.vdebug("configDirName: CLI override to set configDirName to: ", configDirName);
|
|
if (canFind(configDirName,"~")) {
|
|
// A ~ was found
|
|
log.vdebug("configDirName: A '~' was found in configDirName, using the calculated 'homePath' to replace '~'");
|
|
configDirName = homePath ~ strip(configDirName,"~","~");
|
|
}
|
|
} else {
|
|
// Determine the base directory relative to which user specific configuration files should be stored.
|
|
if (environment.get("XDG_CONFIG_HOME") != ""){
|
|
log.vdebug("configDirBase: XDG_CONFIG_HOME environment variable set");
|
|
configDirBase = environment.get("XDG_CONFIG_HOME");
|
|
} else {
|
|
// XDG_CONFIG_HOME does not exist on systems where X11 is not present - ie - headless systems / servers
|
|
log.vdebug("configDirBase: WARNING - no XDG_CONFIG_HOME environment variable set");
|
|
configDirBase = homePath ~ "/.config";
|
|
}
|
|
|
|
// Output configDirBase calculation
|
|
log.vdebug("configDirBase: ", configDirBase);
|
|
// Set the default application configuration directory
|
|
log.vdebug("configDirName: Configuring application to use default config path");
|
|
// configDirBase contains the correct path so we do not need to check for presence of '~'
|
|
configDirName = configDirBase ~ "/onedrive";
|
|
}
|
|
|
|
|
|
log.vlog("Using Config Dir: ", configDirName);
|
|
if (!exists(configDirName)) mkdirRecurse(configDirName);
|
|
|
|
refreshTokenFilePath = configDirName ~ "/refresh_token";
|
|
deltaLinkFilePath = configDirName ~ "/delta_link";
|
|
databaseFilePath = configDirName ~ "/items.sqlite3";
|
|
uploadStateFilePath = configDirName ~ "/resume_upload";
|
|
userConfigFilePath = configDirName ~ "/config";
|
|
syncListFilePath = configDirName ~ "/sync_list";
|
|
}
|
|
|
|
bool initialize()
|
|
{
|
|
if (!load(userConfigFilePath)) {
|
|
// What was the reason for failure?
|
|
if (!exists(userConfigFilePath)) {
|
|
log.vlog("No config file found, using application defaults");
|
|
return true;
|
|
} else {
|
|
log.log("Configuration file has errors - please check your configuration");
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
Option[] update_from_args(string[] args)
|
|
{
|
|
// Application Startup option validation
|
|
try {
|
|
auto opt = getopt(
|
|
args,
|
|
std.getopt.config.bundling,
|
|
std.getopt.config.caseSensitive,
|
|
std.getopt.config.passThrough,
|
|
"check-for-nomount",
|
|
"Check for the presence of .nosync in the syncdir root. If found, do not perform sync.",
|
|
&boolValues["check_for_nomount"],
|
|
"debug-https",
|
|
"Debug OneDrive HTTPS communication.",
|
|
&boolValues["debug_https"],
|
|
"disable-notifications",
|
|
"Do not use desktop notifications in monitor mode.",
|
|
&boolValues["disable_notifications"],
|
|
"download-only|d",
|
|
"Only download remote changes",
|
|
&boolValues["download_only"],
|
|
"disable-upload-validation",
|
|
"Disable upload validation when uploading to OneDrive",
|
|
&boolValues["disable_upload_validation"],
|
|
"enable-logging",
|
|
"Enable client activity to a separate log file",
|
|
&boolValues["enable_logging"],
|
|
"force-http-1.1",
|
|
"Force the use of HTTP 1.1 for all operations",
|
|
&boolValues["force_http_11"],
|
|
"local-first",
|
|
"Synchronize from the local directory source first, before downloading changes from OneDrive.",
|
|
&boolValues["local_first"],
|
|
"no-remote-delete",
|
|
"Do not delete local file 'deletes' from OneDrive when using --upload-only",
|
|
&boolValues["no_remote_delete"],
|
|
"skip-symlinks",
|
|
"Skip syncing of symlinks",
|
|
&boolValues["skip_symlinks"],
|
|
"syncdir",
|
|
"Specify the local directory used for synchronization to OneDrive",
|
|
&stringValues["sync_dir"],
|
|
"upload-only",
|
|
"Only upload to OneDrive, do not sync changes from OneDrive locally",
|
|
&boolValues["upload_only"],
|
|
"verbose|v+",
|
|
"Print more details, useful for debugging (repeat for extra debugging)",
|
|
&longValues["verbose"]
|
|
);
|
|
return opt.options;
|
|
} catch (GetOptException e) {
|
|
log.error(e.msg);
|
|
log.error("Try 'onedrive -h' for more information");
|
|
exit(EXIT_FAILURE);
|
|
} catch (Exception e) {
|
|
// error
|
|
log.error(e.msg);
|
|
log.error("Try 'onedrive -h' for more information");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
string getValueString(string key)
|
|
{
|
|
auto p = key in stringValues;
|
|
if (p) {
|
|
return *p;
|
|
} else {
|
|
throw new Exception("Missing config value: " ~ key);
|
|
}
|
|
}
|
|
|
|
long getValueLong(string key)
|
|
{
|
|
auto p = key in longValues;
|
|
if (p) {
|
|
return *p;
|
|
} else {
|
|
throw new Exception("Missing config value: " ~ key);
|
|
}
|
|
}
|
|
|
|
bool getValueBool(string key)
|
|
{
|
|
auto p = key in boolValues;
|
|
if (p) {
|
|
return *p;
|
|
} else {
|
|
throw new Exception("Missing config value: " ~ key);
|
|
}
|
|
}
|
|
|
|
void setValueBool(string key, bool value)
|
|
{
|
|
boolValues[key] = value;
|
|
}
|
|
|
|
void setValueString(string key, string value)
|
|
{
|
|
stringValues[key] = value;
|
|
}
|
|
|
|
void setValueLong(string key, long value)
|
|
{
|
|
longValues[key] = value;
|
|
}
|
|
|
|
private bool load(string filename)
|
|
{
|
|
scope(failure) return false;
|
|
auto file = File(filename, "r");
|
|
auto r = regex(`^(\w+)\s*=\s*"(.*)"\s*$`);
|
|
foreach (line; file.byLine()) {
|
|
line = stripLeft(line);
|
|
if (line.length == 0 || line[0] == ';' || line[0] == '#') continue;
|
|
auto c = line.matchFirst(r);
|
|
if (!c.empty) {
|
|
c.popFront(); // skip the whole match
|
|
string key = c.front.dup;
|
|
auto p = key in boolValues;
|
|
if (p) {
|
|
c.popFront();
|
|
// only accept "true" as true value. TODO Should we support other formats?
|
|
setValueBool(key, c.front.dup == "true" ? true : false);
|
|
} else {
|
|
auto pp = key in stringValues;
|
|
if (pp) {
|
|
c.popFront();
|
|
setValueString(key, c.front.dup);
|
|
} else {
|
|
auto ppp = key in longValues;
|
|
if (ppp) {
|
|
c.popFront();
|
|
setValueLong(key, to!long(c.front.dup));
|
|
} else {
|
|
log.log("Unknown key in config file: ", key);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
log.log("Malformed config line: ", line);
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
unittest
|
|
{
|
|
auto cfg = new Config("");
|
|
cfg.load("config");
|
|
assert(cfg.getValueString("sync_dir") == "~/OneDrive");
|
|
}
|