debian/notmuch
1
0
Fork 0
mirror of https://git.notmuchmail.org/git/notmuch synced 2024-11-24 11:58:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
notmuch/lib/open.cc

889 lines
23 KiB
C++
Raw Normal View History

lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
#include <unistd.h>
lib/open: fix hook directory calculation in split configuration Choose sibling directory of xapian database, as .notmuch may not exist. libgen.h is already used in debugger.c, so it is not a new dependency / potential portability problem.
2021-02-17 12:16:54 +01:00
#include <libgen.h>
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
#include "database-private.h"
#include "parse-time-vrp.h"
compat: rename {,notmuch_}canonicalize_file_name When compat canonicalize_file_name was introduced, it was limited to C code only because it was used by C code only during that time. >From 5ec6fd4d, (lib/open: check for split configuration when creating database., 2021-02-16), lib/open.cc, which is C++, relies on the existent of canonicalize_file_name. However, we can't blindly enable canonicalize_file_name for C++ code, because different implementation has different additional signature for C++ and users can arbitrarily add -DHAVE_CANONICALIZE_FILE_NAME=0 to {C,CXX}FLAGS. Let's move our implementation into a util library. Helped-by: Tomi Ollila <tomi.ollila@iki.fi> Signed-off-by: Đoàn Trần Công Danh <congdanhqx@gmail.com>
2021-04-24 03:05:37 +02:00
#include "path-util.h"
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
#if HAVE_XAPIAN_DB_RETRY_LOCK
#define DB_ACTION (Xapian::DB_CREATE_OR_OPEN | Xapian::DB_RETRY_LOCK)
#else
#define DB_ACTION Xapian::DB_CREATE_OR_OPEN
#endif
notmuch_status_t
notmuch_database_open (const char *path,
notmuch_database_mode_t mode,
notmuch_database_t **database)
{
char *status_string = NULL;
notmuch_status_t status;
lib/open: replace call to deprecated notmuch_database_open_verbose Essentially inline the existing shim definition of notmuch_database_open_verbose.
2021-10-23 14:27:02 +02:00
status = notmuch_database_open_with_config (path, mode, "", NULL,
database, &status_string);
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
if (status_string) {
fputs (status_string, stderr);
free (status_string);
}
return status;
}
notmuch_status_t
notmuch_database_open_verbose (const char *path,
notmuch_database_mode_t mode,
notmuch_database_t **database,
char **status_string)
lib: add stub for notmuch_database_open_with_config Initially document the intended API and copy the code from notmuch_database_open_verbose. Most of the documented functionality is not there yet.
2020-08-08 16:16:36 +02:00
{
return notmuch_database_open_with_config (path, mode, "", NULL,
database, status_string);
}
lib/open: add support for config profiles and default locations Fill in the remainder of the documented functionality for n_d_open_with_config with respect to config file location. Similar searching default locations of the database file still needs to be added.
2020-08-08 16:16:46 +02:00
static const char *
_xdg_dir (void *ctx,
const char *xdg_root_variable,
const char *xdg_prefix,
const char *profile_name)
{
const char *xdg_root = getenv (xdg_root_variable);
if (! xdg_root) {
const char *home = getenv ("HOME");
if (! home) return NULL;
xdg_root = talloc_asprintf (ctx,
"%s/%s",
home,
xdg_prefix);
}
if (! profile_name)
profile_name = getenv ("NOTMUCH_PROFILE");
if (! profile_name)
profile_name = "default";
return talloc_asprintf (ctx,
"%s/notmuch/%s",
xdg_root,
profile_name);
}
lib/open: set HOOK_DIR on open This is a simple two step path search. Most error checking is deferred until running the hooks.
2021-01-09 20:05:58 +01:00
static notmuch_status_t
lib/config: add configuration variable for backup directory Like the hook directory, we primarily need a way to communicate this directory between various components, but we may as well let the user configure it. Most of the diff is generalizing choose_hook_dir to work for both backup and hook directories.
2021-02-17 16:04:54 +01:00
_choose_dir (notmuch_database_t *notmuch,
const char *profile,
notmuch_config_key_t key,
const char *xdg_var,
const char *xdg_subdir,
const char *subdir,
char **message = NULL)
lib/open: set HOOK_DIR on open This is a simple two step path search. Most error checking is deferred until running the hooks.
2021-01-09 20:05:58 +01:00
{
lib/config: add configuration variable for backup directory Like the hook directory, we primarily need a way to communicate this directory between various components, but we may as well let the user configure it. Most of the diff is generalizing choose_hook_dir to work for both backup and hook directories.
2021-02-17 16:04:54 +01:00
const char *parent;
const char *dir;
lib/open: set HOOK_DIR on open This is a simple two step path search. Most error checking is deferred until running the hooks.
2021-01-09 20:05:58 +01:00
struct stat st;
int err;
lib/config: add configuration variable for backup directory Like the hook directory, we primarily need a way to communicate this directory between various components, but we may as well let the user configure it. Most of the diff is generalizing choose_hook_dir to work for both backup and hook directories.
2021-02-17 16:04:54 +01:00
dir = notmuch_config_get (notmuch, key);
lib/open: set HOOK_DIR on open This is a simple two step path search. Most error checking is deferred until running the hooks.
2021-01-09 20:05:58 +01:00
lib/config: add configuration variable for backup directory Like the hook directory, we primarily need a way to communicate this directory between various components, but we may as well let the user configure it. Most of the diff is generalizing choose_hook_dir to work for both backup and hook directories.
2021-02-17 16:04:54 +01:00
if (dir)
lib/open: set HOOK_DIR on open This is a simple two step path search. Most error checking is deferred until running the hooks.
2021-01-09 20:05:58 +01:00
return NOTMUCH_STATUS_SUCCESS;
lib/config: add configuration variable for backup directory Like the hook directory, we primarily need a way to communicate this directory between various components, but we may as well let the user configure it. Most of the diff is generalizing choose_hook_dir to work for both backup and hook directories.
2021-02-17 16:04:54 +01:00
parent = _xdg_dir (notmuch, xdg_var, xdg_subdir, profile);
if (! parent)
lib: run uncrustify This is the result of running $ uncrustify --replace --config ../devel/uncrustify.cfg *.c *.h *.cc in the lib directory
2021-03-13 13:45:34 +01:00
return NOTMUCH_STATUS_PATH_ERROR;
lib/open: set HOOK_DIR on open This is a simple two step path search. Most error checking is deferred until running the hooks.
2021-01-09 20:05:58 +01:00
lib/config: add configuration variable for backup directory Like the hook directory, we primarily need a way to communicate this directory between various components, but we may as well let the user configure it. Most of the diff is generalizing choose_hook_dir to work for both backup and hook directories.
2021-02-17 16:04:54 +01:00
dir = talloc_asprintf (notmuch, "%s/%s", parent, subdir);
lib/open: set HOOK_DIR on open This is a simple two step path search. Most error checking is deferred until running the hooks.
2021-01-09 20:05:58 +01:00
lib/config: add configuration variable for backup directory Like the hook directory, we primarily need a way to communicate this directory between various components, but we may as well let the user configure it. Most of the diff is generalizing choose_hook_dir to work for both backup and hook directories.
2021-02-17 16:04:54 +01:00
err = stat (dir, &st);
lib/open: set HOOK_DIR on open This is a simple two step path search. Most error checking is deferred until running the hooks.
2021-01-09 20:05:58 +01:00
if (err) {
if (errno == ENOENT) {
lib/open: fix hook directory calculation in split configuration Choose sibling directory of xapian database, as .notmuch may not exist. libgen.h is already used in debugger.c, so it is not a new dependency / potential portability problem.
2021-02-17 12:16:54 +01:00
char *notmuch_path = dirname (talloc_strdup (notmuch, notmuch->xapian_path));
lib/config: add configuration variable for backup directory Like the hook directory, we primarily need a way to communicate this directory between various components, but we may as well let the user configure it. Most of the diff is generalizing choose_hook_dir to work for both backup and hook directories.
2021-02-17 16:04:54 +01:00
dir = talloc_asprintf (notmuch, "%s/%s", notmuch_path, subdir);
lib/open: set HOOK_DIR on open This is a simple two step path search. Most error checking is deferred until running the hooks.
2021-01-09 20:05:58 +01:00
} else {
IGNORE_RESULT (asprintf (message, "Error: Cannot stat %s: %s.\n",
lib/config: add configuration variable for backup directory Like the hook directory, we primarily need a way to communicate this directory between various components, but we may as well let the user configure it. Most of the diff is generalizing choose_hook_dir to work for both backup and hook directories.
2021-02-17 16:04:54 +01:00
dir, strerror (errno)));
lib/open: set HOOK_DIR on open This is a simple two step path search. Most error checking is deferred until running the hooks.
2021-01-09 20:05:58 +01:00
return NOTMUCH_STATUS_FILE_ERROR;
}
}
lib/config: add configuration variable for backup directory Like the hook directory, we primarily need a way to communicate this directory between various components, but we may as well let the user configure it. Most of the diff is generalizing choose_hook_dir to work for both backup and hook directories.
2021-02-17 16:04:54 +01:00
_notmuch_config_cache (notmuch, key, dir);
lib/open: set HOOK_DIR on open This is a simple two step path search. Most error checking is deferred until running the hooks.
2021-01-09 20:05:58 +01:00
return NOTMUCH_STATUS_SUCCESS;
}
lib/open: add support for config profiles and default locations Fill in the remainder of the documented functionality for n_d_open_with_config with respect to config file location. Similar searching default locations of the database file still needs to be added.
2020-08-08 16:16:46 +02:00
static notmuch_status_t
lib: provide notmuch_config_path Since the library searches in several locations for a config file, the caller does not know which of these is chosen in the usual case of passing NULL as a config file. This changes provides an API for the caller to retrieve the name of the config file chosen. It will be tested in a following commit.
2021-02-21 12:34:52 +01:00
_load_key_file (notmuch_database_t *notmuch,
const char *path,
lib/open: add support for config profiles and default locations Fill in the remainder of the documented functionality for n_d_open_with_config with respect to config file location. Similar searching default locations of the database file still needs to be added.
2020-08-08 16:16:46 +02:00
const char *profile,
GKeyFile **key_file)
{
notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
if (path && EMPTY_STRING (path))
goto DONE;
if (! path)
path = getenv ("NOTMUCH_CONFIG");
lib: provide notmuch_config_path Since the library searches in several locations for a config file, the caller does not know which of these is chosen in the usual case of passing NULL as a config file. This changes provides an API for the caller to retrieve the name of the config file chosen. It will be tested in a following commit.
2021-02-21 12:34:52 +01:00
if (path)
path = talloc_strdup (notmuch, path);
else {
const char *dir = _xdg_dir (notmuch, "XDG_CONFIG_HOME", ".config", profile);
lib/open: add support for config profiles and default locations Fill in the remainder of the documented functionality for n_d_open_with_config with respect to config file location. Similar searching default locations of the database file still needs to be added.
2020-08-08 16:16:46 +02:00
if (dir) {
lib: provide notmuch_config_path Since the library searches in several locations for a config file, the caller does not know which of these is chosen in the usual case of passing NULL as a config file. This changes provides an API for the caller to retrieve the name of the config file chosen. It will be tested in a following commit.
2021-02-21 12:34:52 +01:00
path = talloc_asprintf (notmuch, "%s/config", dir);
lib: run uncrustify This is the result of running $ uncrustify --replace --config ../devel/uncrustify.cfg *.c *.h *.cc in the lib directory
2021-03-13 13:45:34 +01:00
if (access (path, R_OK) != 0)
lib/open: add support for config profiles and default locations Fill in the remainder of the documented functionality for n_d_open_with_config with respect to config file location. Similar searching default locations of the database file still needs to be added.
2020-08-08 16:16:46 +02:00
path = NULL;
}
}
if (! path) {
const char *home = getenv ("HOME");
lib: provide notmuch_config_path Since the library searches in several locations for a config file, the caller does not know which of these is chosen in the usual case of passing NULL as a config file. This changes provides an API for the caller to retrieve the name of the config file chosen. It will be tested in a following commit.
2021-02-21 12:34:52 +01:00
path = talloc_asprintf (notmuch, "%s/.notmuch-config", home);
lib/open: add support for config profiles and default locations Fill in the remainder of the documented functionality for n_d_open_with_config with respect to config file location. Similar searching default locations of the database file still needs to be added.
2020-08-08 16:16:46 +02:00
if (! profile)
profile = getenv ("NOTMUCH_PROFILE");
if (profile)
lib: provide notmuch_config_path Since the library searches in several locations for a config file, the caller does not know which of these is chosen in the usual case of passing NULL as a config file. This changes provides an API for the caller to retrieve the name of the config file chosen. It will be tested in a following commit.
2021-02-21 12:34:52 +01:00
path = talloc_asprintf (notmuch, "%s.%s", path, profile);
lib/open: add support for config profiles and default locations Fill in the remainder of the documented functionality for n_d_open_with_config with respect to config file location. Similar searching default locations of the database file still needs to be added.
2020-08-08 16:16:46 +02:00
}
*key_file = g_key_file_new ();
if (! g_key_file_load_from_file (*key_file, path, G_KEY_FILE_NONE, NULL)) {
lib: add NOTMUCH_STATUS_NO_CONFIG This will allow client code to provide more meaningful diagnostics. In particular it will enable "notmuch new" to continue suggsting the user run "notmuch setup" to create a config after "notmuch new" is transitioned to the new configuration framework.
2021-01-03 13:30:46 +01:00
status = NOTMUCH_STATUS_NO_CONFIG;
lib/open: add support for config profiles and default locations Fill in the remainder of the documented functionality for n_d_open_with_config with respect to config file location. Similar searching default locations of the database file still needs to be added.
2020-08-08 16:16:46 +02:00
}
lib: run uncrustify This is the result of running $ uncrustify --replace --config ../devel/uncrustify.cfg *.c *.h *.cc in the lib directory
2021-03-13 13:45:34 +01:00
DONE:
lib: provide notmuch_config_path Since the library searches in several locations for a config file, the caller does not know which of these is chosen in the usual case of passing NULL as a config file. This changes provides an API for the caller to retrieve the name of the config file chosen. It will be tested in a following commit.
2021-02-21 12:34:52 +01:00
if (path)
notmuch->config_path = path;
lib/open: add support for config profiles and default locations Fill in the remainder of the documented functionality for n_d_open_with_config with respect to config file location. Similar searching default locations of the database file still needs to be added.
2020-08-08 16:16:46 +02:00
return status;
}
lib/open: reuse directory checks from n_d_c_with_config Make checks more uniform between creating new databases and opening existing ones.
2021-03-04 14:31:13 +01:00
static notmuch_status_t
_db_dir_exists (const char *database_path, char **message)
{
struct stat st;
int err;
err = stat (database_path, &st);
if (err) {
IGNORE_RESULT (asprintf (message, "Error: Cannot open database at %s: %s.\n",
database_path, strerror (errno)));
return NOTMUCH_STATUS_FILE_ERROR;
}
if (! S_ISDIR (st.st_mode)) {
IGNORE_RESULT (asprintf (message, "Error: Cannot open database at %s: "
"Not a directory.\n",
database_path));
return NOTMUCH_STATUS_FILE_ERROR;
}
return NOTMUCH_STATUS_SUCCESS;
}
lib/open: factor out choosing database path The plan is to share code with a new database creation function that has a similar API to n_d_open_with_config.
2021-01-01 17:16:25 +01:00
static notmuch_status_t
lib/open: use db struct as talloc ctx for choose_database_path The extra talloc struct "local" was left over from before the notmuch struct was allocated earlier. Having the notmuch struct available in this function will allow more flexibility to track the configuration variations (e.g. split vs. non-split).
2021-12-25 14:33:02 +01:00
_choose_database_path (notmuch_database_t *notmuch,
lib/open: factor out choosing database path The plan is to share code with a new database creation function that has a similar API to n_d_open_with_config.
2021-01-01 17:16:25 +01:00
const char *profile,
lib/open: pull _load_key_file out of _choose_database_path Although this increases code duplication, it also increases flexibility in handling various combinations of missing config file and missing database.
2021-02-11 01:02:37 +01:00
GKeyFile *key_file,
lib/open: factor out choosing database path The plan is to share code with a new database creation function that has a similar API to n_d_open_with_config.
2021-01-01 17:16:25 +01:00
const char **database_path,
char **message)
{
lib/open: return non-SUCCESS on missing database path This simplifies the logic of creating the directory path when it doesn't exist.
2022-07-29 13:23:11 +02:00
notmuch_status_t status;
lib/open: support NOTMUCH_DATABASE environment variable The additional code is trivial, but making sure we get the priority of various options correct takes a few tests.
2020-12-26 04:22:23 +01:00
if (! *database_path) {
*database_path = getenv ("NOTMUCH_DATABASE");
}
lib/open: pull _load_key_file out of _choose_database_path Although this increases code duplication, it also increases flexibility in handling various combinations of missing config file and missing database.
2021-02-11 01:02:37 +01:00
if (! *database_path && key_file) {
lib/config: use g_key_file_get_string to read config values Unlike the previous g_key_file_get_value, this version processes escape codes for whitespace and \. The remaining two broken tests from the last commit are because "notmuch config get" treats every value as a list, and thus the previously introduces stripping of leading whitespace applies.
2021-09-30 20:59:54 +02:00
char *path = g_key_file_get_string (key_file, "database", "path", NULL);
lib/open: free value from g_key_file_get_value This fixes a small memory leak.
2021-03-06 14:49:32 +01:00
if (path) {
lib/open: canonicalize relative path read from config file This matches functionality in the the CLI function notmuch_config_get_database_path, which was previously used in the CLI code for all calls to open a database.
2021-03-03 13:31:44 +01:00
if (path[0] == '/')
lib/open: use db struct as talloc ctx for choose_database_path The extra talloc struct "local" was left over from before the notmuch struct was allocated earlier. Having the notmuch struct available in this function will allow more flexibility to track the configuration variations (e.g. split vs. non-split).
2021-12-25 14:33:02 +01:00
*database_path = talloc_strdup (notmuch, path);
lib/open: canonicalize relative path read from config file This matches functionality in the the CLI function notmuch_config_get_database_path, which was previously used in the CLI code for all calls to open a database.
2021-03-03 13:31:44 +01:00
else
lib/open: use db struct as talloc ctx for choose_database_path The extra talloc struct "local" was left over from before the notmuch struct was allocated earlier. Having the notmuch struct available in this function will allow more flexibility to track the configuration variations (e.g. split vs. non-split).
2021-12-25 14:33:02 +01:00
*database_path = talloc_asprintf (notmuch, "%s/%s", getenv ("HOME"), path);
lib/open: free value from g_key_file_get_value This fixes a small memory leak.
2021-03-06 14:49:32 +01:00
g_free (path);
}
}
lib/open: support XDG_DATA_HOME as a fallback database location. This changes some error reporting, either intentionally by reporting the highest level missing directory, or by side effect from looking in XDG locations when given null database location.
2021-01-04 01:04:46 +01:00
if (! *database_path) {
lib/open: use db struct as talloc ctx for choose_database_path The extra talloc struct "local" was left over from before the notmuch struct was allocated earlier. Having the notmuch struct available in this function will allow more flexibility to track the configuration variations (e.g. split vs. non-split).
2021-12-25 14:33:02 +01:00
*database_path = _xdg_dir (notmuch, "XDG_DATA_HOME", ".local/share", profile);
lib/open: restore default database path of $HOME/mail Although this default worked for "notmuch config get", it didn't work most other places. Restore the previous functionality, with the wrinkle that XDG locations will shadow $HOME/mail if they exist. This fixes a bug reported by Jack Kamm in id:87eeefdc8b.fsf@gmail.com
2021-05-10 12:39:18 +02:00
status = _db_dir_exists (*database_path, message);
if (status) {
*database_path = NULL;
} else {
lib/open: use notmuch->params to track split status Persisting this status will allow us to use the information in other compilation units, in particular when setting configuration defaults.
2021-12-25 14:33:03 +01:00
notmuch->params |= NOTMUCH_PARAM_SPLIT;
lib/open: restore default database path of $HOME/mail Although this default worked for "notmuch config get", it didn't work most other places. Restore the previous functionality, with the wrinkle that XDG locations will shadow $HOME/mail if they exist. This fixes a bug reported by Jack Kamm in id:87eeefdc8b.fsf@gmail.com
2021-05-10 12:39:18 +02:00
}
}
lib/open: look in MAILDIR for database, as documented. This fixes the bug id:87bl9lx864.fsf@kisara.moe
2021-08-04 12:42:35 +02:00
if (! *database_path) {
*database_path = getenv ("MAILDIR");
lib/open: restore default database path of $HOME/mail Although this default worked for "notmuch config get", it didn't work most other places. Restore the previous functionality, with the wrinkle that XDG locations will shadow $HOME/mail if they exist. This fixes a bug reported by Jack Kamm in id:87eeefdc8b.fsf@gmail.com
2021-05-10 12:39:18 +02:00
}
if (! *database_path) {
lib/open: use db struct as talloc ctx for choose_database_path The extra talloc struct "local" was left over from before the notmuch struct was allocated earlier. Having the notmuch struct available in this function will allow more flexibility to track the configuration variations (e.g. split vs. non-split).
2021-12-25 14:33:02 +01:00
*database_path = talloc_asprintf (notmuch, "%s/mail", getenv ("HOME"));
lib/open: restore default database path of $HOME/mail Although this default worked for "notmuch config get", it didn't work most other places. Restore the previous functionality, with the wrinkle that XDG locations will shadow $HOME/mail if they exist. This fixes a bug reported by Jack Kamm in id:87eeefdc8b.fsf@gmail.com
2021-05-10 12:39:18 +02:00
status = _db_dir_exists (*database_path, message);
if (status) {
*database_path = NULL;
}
lib/open: support XDG_DATA_HOME as a fallback database location. This changes some error reporting, either intentionally by reporting the highest level missing directory, or by side effect from looking in XDG locations when given null database location.
2021-01-04 01:04:46 +01:00
}
lib/open: factor out choosing database path The plan is to share code with a new database creation function that has a similar API to n_d_open_with_config.
2021-01-01 17:16:25 +01:00
if (*database_path == NULL) {
CLI+lib: detect missing database in split configurations. Eventually we want to do all opening of databases in the top level (main function). This means that detection of missing databases needs to move out of subcommands. It also requires updating the library to use the new NO_DATABASE status code.
2021-02-23 21:19:13 +01:00
*message = strdup ("Error: could not locate database.\n");
return NOTMUCH_STATUS_NO_DATABASE;
lib/open: factor out choosing database path The plan is to share code with a new database creation function that has a similar API to n_d_open_with_config.
2021-01-01 17:16:25 +01:00
}
if (*database_path[0] != '/') {
*message = strdup ("Error: Database path must be absolute.\n");
return NOTMUCH_STATUS_PATH_ERROR;
}
lib/open: return non-SUCCESS on missing database path This simplifies the logic of creating the directory path when it doesn't exist.
2022-07-29 13:23:11 +02:00
status = _db_dir_exists (*database_path, message);
if (status) {
IGNORE_RESULT (asprintf (message,
"Error: database path '%s' does not exist or is not a directory.\n",
*database_path));
return NOTMUCH_STATUS_NO_DATABASE;
}
lib/open: factor out choosing database path The plan is to share code with a new database creation function that has a similar API to n_d_open_with_config.
2021-01-01 17:16:25 +01:00
return NOTMUCH_STATUS_SUCCESS;
}
lib/open: refactor call to mkdir into function This makes the error handling available for re-use. Using g_mkdir_with_parents also handles the case of a pre-existing directory. This introduces new functionality, namely creating the parent directories, which will be useful for creating directories like '.local/share/notmuch/default'.
2022-07-28 12:41:02 +02:00
static notmuch_status_t
_mkdir (const char *path, char **message)
{
if (g_mkdir_with_parents (path, 0755)) {
IGNORE_RESULT (asprintf (message, "Error: Cannot create directory %s: %s.\n",
path, strerror (errno)));
return NOTMUCH_STATUS_FILE_ERROR;
}
return NOTMUCH_STATUS_SUCCESS;
}
lib/{open,message}: make some internal functions static They are not used outside their file, so being extern seems like an oversight
2021-05-24 02:08:28 +02:00
static notmuch_database_t *
lib/open: track which parameters are passed This will be used to fine tune the loading of configuration for certain special configuration items (initially just "database.path").
2021-10-28 03:34:18 +02:00
_alloc_notmuch (const char *database_path, const char *config_path, const char *profile)
lib/open: allocate notmuch_t struct early This gives more flexibility in restructuring the database opening code.
2021-01-27 01:46:44 +01:00
{
notmuch_database_t *notmuch;
notmuch = talloc_zero (NULL, notmuch_database_t);
if (! notmuch)
return NULL;
notmuch->exception_reported = false;
notmuch->status_string = NULL;
notmuch->writable_xapian_db = NULL;
lib: provide notmuch_config_path Since the library searches in several locations for a config file, the caller does not know which of these is chosen in the usual case of passing NULL as a config file. This changes provides an API for the caller to retrieve the name of the config file chosen. It will be tested in a following commit.
2021-02-21 12:34:52 +01:00
notmuch->config_path = NULL;
lib/open: allocate notmuch_t struct early This gives more flexibility in restructuring the database opening code.
2021-01-27 01:46:44 +01:00
notmuch->atomic_nesting = 0;
lib: autocommit after some number of completed transactions This change addresses two known issues with large sets of changes to the database. The first is that as reported by Steven Allen [1], notmuch commits are not "flushed" when they complete, which means that if there is an open transaction when the database closes (or e.g. the program crashes) then all changes since the last commit will be discarded (nothing is irrecoverably lost for "notmuch new", as the indexing process just restarts next time it is run). This does not really "fix" the issue reported in [1]; that seems rather difficult given how transactions work in Xapian. On the other hand, with the default settings, this should mean one only loses less than a minutes worth of work. The second issue is the occasionally reported "storm" of disk writes when notmuch finishes. I don't yet have a test for this, but I think committing as we go should reduce the amount of work when finalizing the database. [1]: id:20151025210215.GA3754@stebalien.com
2021-05-18 04:06:01 +02:00
notmuch->transaction_count = 0;
notmuch->transaction_threshold = 0;
lib/open: allocate notmuch_t struct early This gives more flexibility in restructuring the database opening code.
2021-01-27 01:46:44 +01:00
notmuch->view = 1;
lib/open: track which parameters are passed This will be used to fine tune the loading of configuration for certain special configuration items (initially just "database.path").
2021-10-28 03:34:18 +02:00
notmuch->params = NOTMUCH_PARAM_NONE;
if (database_path)
notmuch->params |= NOTMUCH_PARAM_DATABASE;
if (config_path)
notmuch->params |= NOTMUCH_PARAM_CONFIG;
if (profile)
notmuch->params |= NOTMUCH_PARAM_PROFILE;
lib/open: allocate notmuch_t struct early This gives more flexibility in restructuring the database opening code.
2021-01-27 01:46:44 +01:00
return notmuch;
}
lib/open: Use check for existing database by trial opening This is a bit heavyweight for now, but it will make more sense when we check multiple locations for the Xapian database.
2021-02-07 17:54:45 +01:00
static notmuch_status_t
_trial_open (const char *xapian_path, char **message_ptr)
{
try {
Xapian::Database db (xapian_path);
} catch (const Xapian::DatabaseOpeningError &error) {
IGNORE_RESULT (asprintf (message_ptr,
"Cannot open Xapian database at %s: %s\n",
xapian_path,
error.get_msg ().c_str ()));
return NOTMUCH_STATUS_PATH_ERROR;
} catch (const Xapian::Error &error) {
IGNORE_RESULT (asprintf (message_ptr,
"A Xapian exception occurred opening database: %s\n",
error.get_msg ().c_str ()));
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
return NOTMUCH_STATUS_SUCCESS;
}
lib/compact: enable split config This promotes _choose_xapian_path from static to extern linkage in order to share between open.cc and database.cc.
2021-02-02 12:51:23 +01:00
notmuch_status_t
_notmuch_choose_xapian_path (void *ctx, const char *database_path,
const char **xapian_path, char **message_ptr)
lib/open: Use check for existing database by trial opening This is a bit heavyweight for now, but it will make more sense when we check multiple locations for the Xapian database.
2021-02-07 17:54:45 +01:00
{
notmuch_status_t status;
const char *trial_path, *notmuch_path;
status = _db_dir_exists (database_path, message_ptr);
if (status)
goto DONE;
lib: support splitting mail from database location. Introduce a new configuration value for the mail root, and use it to locate mail messages in preference to the database.path (which previously implied the mail messages were also in this location. Initially only a subset of the CLI is tested in a split configuration. Further changes will be needed for the remainder of the CLI to work in split configurations.
2020-12-31 23:20:31 +01:00
trial_path = talloc_asprintf (ctx, "%s/xapian", database_path);
status = _trial_open (trial_path, message_ptr);
if (status != NOTMUCH_STATUS_PATH_ERROR)
goto DONE;
lib/open: fix leaks calling _trial_open _trial_open can't know if the PATH_ERROR return value will cause the error message to be returned from the library, so it's up the caller to clean up if not.
2021-03-27 13:12:28 +01:00
if (*message_ptr)
free (*message_ptr);
lib/open: Use check for existing database by trial opening This is a bit heavyweight for now, but it will make more sense when we check multiple locations for the Xapian database.
2021-02-07 17:54:45 +01:00
notmuch_path = talloc_asprintf (ctx, "%s/.notmuch", database_path);
status = _db_dir_exists (notmuch_path, message_ptr);
if (status)
goto DONE;
trial_path = talloc_asprintf (ctx, "%s/xapian", notmuch_path);
status = _trial_open (trial_path, message_ptr);
DONE:
if (status == NOTMUCH_STATUS_SUCCESS)
*xapian_path = trial_path;
return status;
}
lib: remove "path" from notmuch struct This removes duplication between the struct element and the configuration string_map entry. Create a simple wrapper for setting the database path that makes sure the trailing / is stripped.
2021-02-02 21:43:58 +01:00
static void
_set_database_path (notmuch_database_t *notmuch,
const char *database_path)
{
char *path = talloc_strdup (notmuch, database_path);
strip_trailing (path, '/');
_notmuch_config_cache (notmuch, NOTMUCH_CONFIG_DATABASE_PATH, path);
}
lib/notmuch_database_reopen: reload some database metadata In some uses of reopen, new documents and threads maybe have been added, and e.g. compaction may have changed the uuid.
2021-05-09 14:28:48 +02:00
static void
_load_database_state (notmuch_database_t *notmuch)
{
std::string last_thread_id;
std::string last_mod;
notmuch->last_doc_id = notmuch->xapian_db->get_lastdocid ();
last_thread_id = notmuch->xapian_db->get_metadata ("last_thread_id");
if (last_thread_id.empty ()) {
notmuch->last_thread_id = 0;
} else {
const char *str;
char *end;
str = last_thread_id.c_str ();
notmuch->last_thread_id = strtoull (str, &end, 16);
if (*end != '\0')
INTERNAL_ERROR ("Malformed database last_thread_id: %s", str);
}
/* Get current highest revision number. */
last_mod = notmuch->xapian_db->get_value_upper_bound (
NOTMUCH_VALUE_LAST_MOD);
if (last_mod.empty ())
notmuch->revision = 0;
else
notmuch->revision = Xapian::sortable_unserialise (last_mod);
notmuch->uuid = talloc_strdup (
notmuch, notmuch->xapian_db->get_uuid ().c_str ());
}
lib/open: factor out the second half of n_d_open_with_config The idea is to allow reuse in n_d_create_with_config. This is primarily code movement, with some changes in error messages to reduce the number of input parameters.
2021-01-30 18:57:32 +01:00
static notmuch_status_t
_finish_open (notmuch_database_t *notmuch,
const char *profile,
notmuch_database_mode_t mode,
GKeyFile *key_file,
char **message_ptr)
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
{
notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
lib/open: factor out the second half of n_d_open_with_config The idea is to allow reuse in n_d_create_with_config. This is primarily code movement, with some changes in error messages to reduce the number of input parameters.
2021-01-30 18:57:32 +01:00
char *incompat_features;
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
char *message = NULL;
lib: autocommit after some number of completed transactions This change addresses two known issues with large sets of changes to the database. The first is that as reported by Steven Allen [1], notmuch commits are not "flushed" when they complete, which means that if there is an open transaction when the database closes (or e.g. the program crashes) then all changes since the last commit will be discarded (nothing is irrecoverably lost for "notmuch new", as the indexing process just restarts next time it is run). This does not really "fix" the issue reported in [1]; that seems rather difficult given how transactions work in Xapian. On the other hand, with the default settings, this should mean one only loses less than a minutes worth of work. The second issue is the occasionally reported "storm" of disk writes when notmuch finishes. I don't yet have a test for this, but I think committing as we go should reduce the amount of work when finalizing the database. [1]: id:20151025210215.GA3754@stebalien.com
2021-05-18 04:06:01 +02:00
const char *autocommit_str;
char *autocommit_end;
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
unsigned int version;
lib/open: factor out the second half of n_d_open_with_config The idea is to allow reuse in n_d_create_with_config. This is primarily code movement, with some changes in error messages to reduce the number of input parameters.
2021-01-30 18:57:32 +01:00
const char *database_path = notmuch_database_get_path (notmuch);
lib/open: allocate notmuch_t struct early This gives more flexibility in restructuring the database opening code.
2021-01-27 01:46:44 +01:00
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
try {
if (mode == NOTMUCH_DATABASE_MODE_READ_WRITE) {
lib: save path of xapian database in notmuch struct. This will allow re-opening in a different mode (read/write vs. read-only) with current Xapian API. It will also prove useful when updating the compact functions to support more flexible database location.
2021-03-14 15:01:58 +01:00
notmuch->writable_xapian_db = new Xapian::WritableDatabase (notmuch->xapian_path,
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
DB_ACTION);
notmuch->xapian_db = notmuch->writable_xapian_db;
} else {
lib: save path of xapian database in notmuch struct. This will allow re-opening in a different mode (read/write vs. read-only) with current Xapian API. It will also prove useful when updating the compact functions to support more flexible database location.
2021-03-14 15:01:58 +01:00
notmuch->xapian_db = new Xapian::Database (notmuch->xapian_path);
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
}
/* Check version. As of database version 3, we represent
* changes in terms of features, so assume a version bump
* means a dramatically incompatible change. */
version = notmuch_database_get_version (notmuch);
if (version > NOTMUCH_DATABASE_VERSION) {
IGNORE_RESULT (asprintf (&message,
"Error: Notmuch database at %s\n"
" has a newer database format version (%u) than supported by this\n"
" version of notmuch (%u).\n",
lib/open: factor out the second half of n_d_open_with_config The idea is to allow reuse in n_d_create_with_config. This is primarily code movement, with some changes in error messages to reduce the number of input parameters.
2021-01-30 18:57:32 +01:00
database_path, version, NOTMUCH_DATABASE_VERSION));
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
status = NOTMUCH_STATUS_FILE_ERROR;
goto DONE;
}
/* Check features. */
incompat_features = NULL;
notmuch->features = _notmuch_database_parse_features (
lib/open: factor out the second half of n_d_open_with_config The idea is to allow reuse in n_d_create_with_config. This is primarily code movement, with some changes in error messages to reduce the number of input parameters.
2021-01-30 18:57:32 +01:00
notmuch, notmuch->xapian_db->get_metadata ("features").c_str (),
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
version, mode == NOTMUCH_DATABASE_MODE_READ_WRITE ? 'w' : 'r',
&incompat_features);
if (incompat_features) {
IGNORE_RESULT (asprintf (&message,
"Error: Notmuch database at %s\n"
" requires features (%s)\n"
" not supported by this version of notmuch.\n",
lib/open: factor out the second half of n_d_open_with_config The idea is to allow reuse in n_d_create_with_config. This is primarily code movement, with some changes in error messages to reduce the number of input parameters.
2021-01-30 18:57:32 +01:00
database_path, incompat_features));
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
status = NOTMUCH_STATUS_FILE_ERROR;
goto DONE;
}
lib/notmuch_database_reopen: reload some database metadata In some uses of reopen, new documents and threads maybe have been added, and e.g. compaction may have changed the uuid.
2021-05-09 14:28:48 +02:00
_load_database_state (notmuch);
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
notmuch->query_parser = new Xapian::QueryParser;
notmuch->term_gen = new Xapian::TermGenerator;
notmuch->term_gen->set_stemmer (Xapian::Stem ("english"));
notmuch->value_range_processor = new Xapian::NumberRangeProcessor (NOTMUCH_VALUE_TIMESTAMP);
lib: run uncrustify This is the result of running $ uncrustify --replace --config ../devel/uncrustify.cfg *.c *.h *.cc in the lib directory
2021-03-13 13:45:34 +01:00
notmuch->date_range_processor = new ParseTimeRangeProcessor (NOTMUCH_VALUE_TIMESTAMP,
"date:");
notmuch->last_mod_range_processor = new Xapian::NumberRangeProcessor (NOTMUCH_VALUE_LAST_MOD,
"lastmod:");
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
notmuch->query_parser->set_default_op (Xapian::Query::OP_AND);
notmuch->query_parser->set_database (*notmuch->xapian_db);
lib: leave stemmer object accessible This enables using the same stemmer in both query parsers.
2021-08-24 17:17:17 +02:00
notmuch->stemmer = new Xapian::Stem ("english");
notmuch->query_parser->set_stemmer (*notmuch->stemmer);
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
notmuch->query_parser->set_stemming_strategy (Xapian::QueryParser::STEM_SOME);
notmuch->query_parser->add_rangeprocessor (notmuch->value_range_processor);
notmuch->query_parser->add_rangeprocessor (notmuch->date_range_processor);
notmuch->query_parser->add_rangeprocessor (notmuch->last_mod_range_processor);
lib: cache configuration information from database The main goal is to allow configuration information to be temporarily overridden by a separate config file. That will require further changes not in this commit. The performance impact is unclear, and will depend on the balance between number of queries and number of distinct metadata items read on the first call to n_d_get_config.
2020-08-08 16:16:37 +02:00
/* Configuration information is needed to set up query parser */
status = _notmuch_config_load_from_database (notmuch);
if (status)
goto DONE;
lib: add stub for notmuch_database_open_with_config Initially document the intended API and copy the code from notmuch_database_open_verbose. Most of the documented functionality is not there yet.
2020-08-08 16:16:36 +02:00
if (key_file)
status = _notmuch_config_load_from_file (notmuch, key_file);
if (status)
goto DONE;
lib/config: add configuration variable for backup directory Like the hook directory, we primarily need a way to communicate this directory between various components, but we may as well let the user configure it. Most of the diff is generalizing choose_hook_dir to work for both backup and hook directories.
2021-02-17 16:04:54 +01:00
status = _choose_dir (notmuch, profile,
NOTMUCH_CONFIG_HOOK_DIR,
"XDG_CONFIG_HOME",
".config",
"hooks",
&message);
lib/open: set HOOK_DIR on open This is a simple two step path search. Most error checking is deferred until running the hooks.
2021-01-09 20:05:58 +01:00
if (status)
goto DONE;
lib/config: add configuration variable for backup directory Like the hook directory, we primarily need a way to communicate this directory between various components, but we may as well let the user configure it. Most of the diff is generalizing choose_hook_dir to work for both backup and hook directories.
2021-02-17 16:04:54 +01:00
status = _choose_dir (notmuch, profile,
NOTMUCH_CONFIG_BACKUP_DIR,
"XDG_DATA_HOME",
".local/share",
"backups",
&message);
if (status)
goto DONE;
lib/open: load default values for known configuration keys. This emulates the behaviour of notmuch_config_open defined in the CLI, in that it fills in default values if they are not otherwise defined.
2020-12-24 21:10:05 +01:00
status = _notmuch_config_load_defaults (notmuch);
if (status)
goto DONE;
lib: autocommit after some number of completed transactions This change addresses two known issues with large sets of changes to the database. The first is that as reported by Steven Allen [1], notmuch commits are not "flushed" when they complete, which means that if there is an open transaction when the database closes (or e.g. the program crashes) then all changes since the last commit will be discarded (nothing is irrecoverably lost for "notmuch new", as the indexing process just restarts next time it is run). This does not really "fix" the issue reported in [1]; that seems rather difficult given how transactions work in Xapian. On the other hand, with the default settings, this should mean one only loses less than a minutes worth of work. The second issue is the occasionally reported "storm" of disk writes when notmuch finishes. I don't yet have a test for this, but I think committing as we go should reduce the amount of work when finalizing the database. [1]: id:20151025210215.GA3754@stebalien.com
2021-05-18 04:06:01 +02:00
autocommit_str = notmuch_config_get (notmuch, NOTMUCH_CONFIG_AUTOCOMMIT);
if (unlikely (! autocommit_str)) {
INTERNAL_ERROR ("missing configuration for autocommit");
}
notmuch->transaction_threshold = strtoul (autocommit_str, &autocommit_end, 10);
if (*autocommit_end != '\0')
INTERNAL_ERROR ("Malformed database database.autocommit value: %s", autocommit_str);
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
status = _notmuch_database_setup_standard_query_fields (notmuch);
if (status)
goto DONE;
status = _notmuch_database_setup_user_query_fields (notmuch);
if (status)
goto DONE;
} catch (const Xapian::Error &error) {
IGNORE_RESULT (asprintf (&message, "A Xapian exception occurred opening database: %s\n",
error.get_msg ().c_str ()));
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
lib/open: factor out the second half of n_d_open_with_config The idea is to allow reuse in n_d_create_with_config. This is primarily code movement, with some changes in error messages to reduce the number of input parameters.
2021-01-30 18:57:32 +01:00
DONE:
if (message_ptr)
*message_ptr = message;
return status;
}
notmuch_status_t
notmuch_database_open_with_config (const char *database_path,
notmuch_database_mode_t mode,
const char *config_path,
const char *profile,
notmuch_database_t **database,
char **status_string)
{
notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
notmuch_database_t *notmuch = NULL;
char *message = NULL;
GKeyFile *key_file = NULL;
lib: make glib initialization thread-safe In principle this could be done without depending on C++11 features, but these features should be available since gcc 4.8.1, and this localized usage is easy to replace if it turns out to be problematic for portability.
2021-05-09 22:33:48 +02:00
_notmuch_init ();
lib/open: factor out the second half of n_d_open_with_config The idea is to allow reuse in n_d_create_with_config. This is primarily code movement, with some changes in error messages to reduce the number of input parameters.
2021-01-30 18:57:32 +01:00
lib/open: track which parameters are passed This will be used to fine tune the loading of configuration for certain special configuration items (initially just "database.path").
2021-10-28 03:34:18 +02:00
notmuch = _alloc_notmuch (database_path, config_path, profile);
lib/open: factor out the second half of n_d_open_with_config The idea is to allow reuse in n_d_create_with_config. This is primarily code movement, with some changes in error messages to reduce the number of input parameters.
2021-01-30 18:57:32 +01:00
if (! notmuch) {
status = NOTMUCH_STATUS_OUT_OF_MEMORY;
goto DONE;
}
lib: provide notmuch_config_path Since the library searches in several locations for a config file, the caller does not know which of these is chosen in the usual case of passing NULL as a config file. This changes provides an API for the caller to retrieve the name of the config file chosen. It will be tested in a following commit.
2021-02-21 12:34:52 +01:00
status = _load_key_file (notmuch, config_path, profile, &key_file);
lib/open: pull _load_key_file out of _choose_database_path Although this increases code duplication, it also increases flexibility in handling various combinations of missing config file and missing database.
2021-02-11 01:02:37 +01:00
if (status) {
message = strdup ("Error: cannot load config file.\n");
goto DONE;
}
lib/open: use db struct as talloc ctx for choose_database_path The extra talloc struct "local" was left over from before the notmuch struct was allocated earlier. Having the notmuch struct available in this function will allow more flexibility to track the configuration variations (e.g. split vs. non-split).
2021-12-25 14:33:02 +01:00
if ((status = _choose_database_path (notmuch, profile, key_file,
lib/open: use notmuch->params to track split status Persisting this status will allow us to use the information in other compilation units, in particular when setting configuration defaults.
2021-12-25 14:33:03 +01:00
&database_path,
lib/open: factor out the second half of n_d_open_with_config The idea is to allow reuse in n_d_create_with_config. This is primarily code movement, with some changes in error messages to reduce the number of input parameters.
2021-01-30 18:57:32 +01:00
&message)))
goto DONE;
status = _db_dir_exists (database_path, &message);
if (status)
goto DONE;
lib/open: Use check for existing database by trial opening This is a bit heavyweight for now, but it will make more sense when we check multiple locations for the Xapian database.
2021-02-07 17:54:45 +01:00
_set_database_path (notmuch, database_path);
lib/open: factor out the second half of n_d_open_with_config The idea is to allow reuse in n_d_create_with_config. This is primarily code movement, with some changes in error messages to reduce the number of input parameters.
2021-01-30 18:57:32 +01:00
lib/compact: enable split config This promotes _choose_xapian_path from static to extern linkage in order to share between open.cc and database.cc.
2021-02-02 12:51:23 +01:00
status = _notmuch_choose_xapian_path (notmuch, database_path,
&notmuch->xapian_path, &message);
lib/open: factor out the second half of n_d_open_with_config The idea is to allow reuse in n_d_create_with_config. This is primarily code movement, with some changes in error messages to reduce the number of input parameters.
2021-01-30 18:57:32 +01:00
if (status)
goto DONE;
status = _finish_open (notmuch, profile, mode, key_file, &message);
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
DONE:
lib/open: free GKeyFile This fixes a small-to-medium (depending on size of config file) memory leak.
2021-03-06 14:49:34 +01:00
if (key_file)
g_key_file_free (key_file);
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
if (message) {
if (status_string)
*status_string = message;
else
free (message);
}
lib/open: fix potential double-free, ensure *database=NULL on error During refactoring for 0.32, the code that set notmuch=NULL on various errors was moved into _finish_open. This meant that the the code which relied on that to set *database to NULL on error was no longer correct. It also introduced a potential double free, since the notmuch struct was deallocated inside _finish_open (via n_d_destroy). In this commit we revert to "allocator frees", and leave any cleanup to the caller of _finish_open. This allows us to get back the behaviour of setting *database to NULL with a small change. Other callers of _finish_open will need free notmuch on errors.
2021-10-23 15:22:34 +02:00
if (status && notmuch) {
notmuch_database_destroy (notmuch);
notmuch = NULL;
}
lib: factor out notmuch_database_open* related code to own file Reduce the size of database.cc, and prepare for extending the database opening API
2020-08-08 16:16:45 +02:00
if (database)
*database = notmuch;
if (notmuch)
notmuch->open = true;
return status;
}
lib/database: move n_d_create* to open.cc This will help share code with n_d_open_with_config.
2021-01-02 01:22:00 +01:00
notmuch_status_t
notmuch_database_create (const char *path, notmuch_database_t **database)
{
char *status_string = NULL;
notmuch_status_t status;
status = notmuch_database_create_verbose (path, database,
&status_string);
if (status_string) {
fputs (status_string, stderr);
free (status_string);
}
return status;
}
notmuch_status_t
notmuch_database_create_verbose (const char *path,
notmuch_database_t **database,
char **status_string)
lib: introduce notmuch_database_create_with_config This takes a config path parameter, and can use that to decide the new database location.
2021-01-02 01:43:14 +01:00
{
return notmuch_database_create_with_config (path, "", NULL, database, status_string);
}
notmuch_status_t
notmuch_database_create_with_config (const char *database_path,
const char *config_path,
const char *profile,
notmuch_database_t **database,
char **status_string)
lib/database: move n_d_create* to open.cc This will help share code with n_d_open_with_config.
2021-01-02 01:22:00 +01:00
{
notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
notmuch_database_t *notmuch = NULL;
lib/open: check for split configuration when creating database. The main functionality will be tested when notmuch-new is converted to support split configuration. Here only the somewhat odd case of split mail root which is actually symlinked to the database path is tested.
2021-02-17 01:08:23 +01:00
const char *notmuch_path = NULL;
lib/database: move n_d_create* to open.cc This will help share code with n_d_open_with_config.
2021-01-02 01:22:00 +01:00
char *message = NULL;
lib: introduce notmuch_database_create_with_config This takes a config path parameter, and can use that to decide the new database location.
2021-01-02 01:43:14 +01:00
GKeyFile *key_file = NULL;
lib/open: reuse directory checks from n_d_c_with_config Make checks more uniform between creating new databases and opening existing ones.
2021-03-04 14:31:13 +01:00
lib: make glib initialization thread-safe In principle this could be done without depending on C++11 features, but these features should be available since gcc 4.8.1, and this localized usage is easy to replace if it turns out to be problematic for portability.
2021-05-09 22:33:48 +02:00
_notmuch_init ();
lib/open: reuse directory checks from n_d_c_with_config Make checks more uniform between creating new databases and opening existing ones.
2021-03-04 14:31:13 +01:00
lib/open: track which parameters are passed This will be used to fine tune the loading of configuration for certain special configuration items (initially just "database.path").
2021-10-28 03:34:18 +02:00
notmuch = _alloc_notmuch (database_path, config_path, profile);
lib/open: reuse directory checks from n_d_c_with_config Make checks more uniform between creating new databases and opening existing ones.
2021-03-04 14:31:13 +01:00
if (! notmuch) {
status = NOTMUCH_STATUS_OUT_OF_MEMORY;
goto DONE;
}
lib/database: move n_d_create* to open.cc This will help share code with n_d_open_with_config.
2021-01-02 01:22:00 +01:00
lib: provide notmuch_config_path Since the library searches in several locations for a config file, the caller does not know which of these is chosen in the usual case of passing NULL as a config file. This changes provides an API for the caller to retrieve the name of the config file chosen. It will be tested in a following commit.
2021-02-21 12:34:52 +01:00
status = _load_key_file (notmuch, config_path, profile, &key_file);
lib/open: pull _load_key_file out of _choose_database_path Although this increases code duplication, it also increases flexibility in handling various combinations of missing config file and missing database.
2021-02-11 01:02:37 +01:00
if (status) {
message = strdup ("Error: cannot load config file.\n");
goto DONE;
}
lib/open: factor out library initialization This is slightly more tidy, but more importantly it allows for re-use of this code in n_d_create_with_config. That re-use will be crucial when we no longer call n_d_open_with_config from n_d_create_with_config.
2021-01-29 12:44:18 +01:00
lib/open: use db struct as talloc ctx for choose_database_path The extra talloc struct "local" was left over from before the notmuch struct was allocated earlier. Having the notmuch struct available in this function will allow more flexibility to track the configuration variations (e.g. split vs. non-split).
2021-12-25 14:33:02 +01:00
if ((status = _choose_database_path (notmuch, profile, key_file,
lib/open: use notmuch->params to track split status Persisting this status will allow us to use the information in other compilation units, in particular when setting configuration defaults.
2021-12-25 14:33:03 +01:00
&database_path, &message)))
lib/database: move n_d_create* to open.cc This will help share code with n_d_open_with_config.
2021-01-02 01:22:00 +01:00
goto DONE;
lib/open: reuse directory checks from n_d_c_with_config Make checks more uniform between creating new databases and opening existing ones.
2021-03-04 14:31:13 +01:00
_set_database_path (notmuch, database_path);
lib/database: move n_d_create* to open.cc This will help share code with n_d_open_with_config.
2021-01-02 01:22:00 +01:00
lib/open: use notmuch->params to track split status Persisting this status will allow us to use the information in other compilation units, in particular when setting configuration defaults.
2021-12-25 14:33:03 +01:00
if (key_file && ! (notmuch->params & NOTMUCH_PARAM_SPLIT)) {
compat: rename {,notmuch_}canonicalize_file_name When compat canonicalize_file_name was introduced, it was limited to C code only because it was used by C code only during that time. >From 5ec6fd4d, (lib/open: check for split configuration when creating database., 2021-02-16), lib/open.cc, which is C++, relies on the existent of canonicalize_file_name. However, we can't blindly enable canonicalize_file_name for C++ code, because different implementation has different additional signature for C++ and users can arbitrarily add -DHAVE_CANONICALIZE_FILE_NAME=0 to {C,CXX}FLAGS. Let's move our implementation into a util library. Helped-by: Tomi Ollila <tomi.ollila@iki.fi> Signed-off-by: Đoàn Trần Công Danh <congdanhqx@gmail.com>
2021-04-24 03:05:37 +02:00
char *mail_root = notmuch_canonicalize_file_name (
lib/config: use g_key_file_get_string to read config values Unlike the previous g_key_file_get_value, this version processes escape codes for whitespace and \. The remaining two broken tests from the last commit are because "notmuch config get" treats every value as a list, and thus the previously introduces stripping of leading whitespace applies.
2021-09-30 20:59:54 +02:00
g_key_file_get_string (key_file, "database", "mail_root", NULL));
compat: rename {,notmuch_}canonicalize_file_name When compat canonicalize_file_name was introduced, it was limited to C code only because it was used by C code only during that time. >From 5ec6fd4d, (lib/open: check for split configuration when creating database., 2021-02-16), lib/open.cc, which is C++, relies on the existent of canonicalize_file_name. However, we can't blindly enable canonicalize_file_name for C++ code, because different implementation has different additional signature for C++ and users can arbitrarily add -DHAVE_CANONICALIZE_FILE_NAME=0 to {C,CXX}FLAGS. Let's move our implementation into a util library. Helped-by: Tomi Ollila <tomi.ollila@iki.fi> Signed-off-by: Đoàn Trần Công Danh <congdanhqx@gmail.com>
2021-04-24 03:05:37 +02:00
char *db_path = notmuch_canonicalize_file_name (database_path);
lib/database: move n_d_create* to open.cc This will help share code with n_d_open_with_config.
2021-01-02 01:22:00 +01:00
lib/open: use notmuch->params to track split status Persisting this status will allow us to use the information in other compilation units, in particular when setting configuration defaults.
2021-12-25 14:33:03 +01:00
if (mail_root && (0 != strcmp (mail_root, db_path)))
notmuch->params |= NOTMUCH_PARAM_SPLIT;
lib/open: check for split configuration when creating database. The main functionality will be tested when notmuch-new is converted to support split configuration. Here only the somewhat odd case of split mail root which is actually symlinked to the database path is tested.
2021-02-17 01:08:23 +01:00
free (mail_root);
free (db_path);
}
lib/open: use notmuch->params to track split status Persisting this status will allow us to use the information in other compilation units, in particular when setting configuration defaults.
2021-12-25 14:33:03 +01:00
if (notmuch->params & NOTMUCH_PARAM_SPLIT) {
lib/open: check for split configuration when creating database. The main functionality will be tested when notmuch-new is converted to support split configuration. Here only the somewhat odd case of split mail root which is actually symlinked to the database path is tested.
2021-02-17 01:08:23 +01:00
notmuch_path = database_path;
} else {
lib/open: use db struct as talloc ctx for choose_database_path The extra talloc struct "local" was left over from before the notmuch struct was allocated earlier. Having the notmuch struct available in this function will allow more flexibility to track the configuration variations (e.g. split vs. non-split).
2021-12-25 14:33:02 +01:00
if (! (notmuch_path = talloc_asprintf (notmuch, "%s/%s", database_path, ".notmuch"))) {
lib/open: check for split configuration when creating database. The main functionality will be tested when notmuch-new is converted to support split configuration. Here only the somewhat odd case of split mail root which is actually symlinked to the database path is tested.
2021-02-17 01:08:23 +01:00
status = NOTMUCH_STATUS_OUT_OF_MEMORY;
goto DONE;
}
lib/open: refactor call to mkdir into function This makes the error handling available for re-use. Using g_mkdir_with_parents also handles the case of a pre-existing directory. This introduces new functionality, namely creating the parent directories, which will be useful for creating directories like '.local/share/notmuch/default'.
2022-07-28 12:41:02 +02:00
status = _mkdir (notmuch_path, &message);
if (status)
goto DONE;
lib/database: move n_d_create* to open.cc This will help share code with n_d_open_with_config.
2021-01-02 01:22:00 +01:00
}
lib/open: use _finish_open in n_d_create_with_config This avoids reading the configuration file twice.
2021-01-30 18:30:18 +01:00
if (! (notmuch->xapian_path = talloc_asprintf (notmuch, "%s/%s", notmuch_path, "xapian"))) {
status = NOTMUCH_STATUS_OUT_OF_MEMORY;
goto DONE;
}
lib/open: check for split configuration when creating database. The main functionality will be tested when notmuch-new is converted to support split configuration. Here only the somewhat odd case of split mail root which is actually symlinked to the database path is tested.
2021-02-17 01:08:23 +01:00
status = _trial_open (notmuch->xapian_path, &message);
if (status == NOTMUCH_STATUS_SUCCESS) {
notmuch_database_destroy (notmuch);
notmuch = NULL;
status = NOTMUCH_STATUS_DATABASE_EXISTS;
goto DONE;
}
lib/open: fix leaks calling _trial_open _trial_open can't know if the PATH_ERROR return value will cause the error message to be returned from the library, so it's up the caller to clean up if not.
2021-03-27 13:12:28 +01:00
if (message)
free (message);
lib/open: use _finish_open in n_d_create_with_config This avoids reading the configuration file twice.
2021-01-30 18:30:18 +01:00
status = _finish_open (notmuch,
profile,
NOTMUCH_DATABASE_MODE_READ_WRITE,
key_file,
&message);
lib/database: move n_d_create* to open.cc This will help share code with n_d_open_with_config.
2021-01-02 01:22:00 +01:00
if (status)
goto DONE;
/* Upgrade doesn't add these feature to existing databases, but
* new databases have them. */
notmuch->features |= NOTMUCH_FEATURE_FROM_SUBJECT_ID_VALUES;
notmuch->features |= NOTMUCH_FEATURE_INDEXED_MIMETYPES;
notmuch->features |= NOTMUCH_FEATURE_UNPREFIX_BODY_ONLY;
status = notmuch_database_upgrade (notmuch, NULL, NULL);
if (status) {
notmuch_database_close (notmuch);
notmuch = NULL;
}
DONE:
lib/open: free GKeyFile This fixes a small-to-medium (depending on size of config file) memory leak.
2021-03-06 14:49:34 +01:00
if (key_file)
g_key_file_free (key_file);
lib/database: move n_d_create* to open.cc This will help share code with n_d_open_with_config.
2021-01-02 01:22:00 +01:00
if (message) {
if (status_string)
*status_string = message;
else
free (message);
}
lib/create: fix memory leak, ensure *database=NULL on error This code previously relied on _finish_open to free the notmuch struct on errors (except for the case of database == NULL, which was a potential double free). When we removed those frees from _finish_open, we introduced a (small) memory leak. In this commit, fix the memory leak, and harmonize the on-error behaviour with n_d_open_with_config.
2021-10-23 15:22:36 +02:00
if (status && notmuch) {
notmuch_database_destroy (notmuch);
notmuch = NULL;
}
lib/database: move n_d_create* to open.cc This will help share code with n_d_open_with_config.
2021-01-02 01:22:00 +01:00
if (database)
*database = notmuch;
lib/create: fix memory leak, ensure *database=NULL on error This code previously relied on _finish_open to free the notmuch struct on errors (except for the case of database == NULL, which was a potential double free). When we removed those frees from _finish_open, we introduced a (small) memory leak. In this commit, fix the memory leak, and harmonize the on-error behaviour with n_d_open_with_config.
2021-10-23 15:22:36 +02:00
if (notmuch)
notmuch->open = true;
lib/database: move n_d_create* to open.cc This will help share code with n_d_open_with_config.
2021-01-02 01:22:00 +01:00
return status;
}
lib: support reopening databases for write access. In the future Xapian will apparently support this more conveniently for the cases other than READ_ONLY => READ_ONLY Conceptually this function seems to fit better in lib/open.cc; database.cc is still large enough that moving the function makes sense.
2021-03-14 15:01:59 +01:00
notmuch_status_t
notmuch_database_reopen (notmuch_database_t *notmuch,
notmuch_database_mode_t new_mode)
{
notmuch_database_mode_t cur_mode = _notmuch_database_mode (notmuch);
if (notmuch->xapian_db == NULL) {
_notmuch_database_log (notmuch, "Cannot reopen closed or nonexistent database\n");
return NOTMUCH_STATUS_ILLEGAL_ARGUMENT;
}
try {
if (cur_mode == new_mode &&
new_mode == NOTMUCH_DATABASE_MODE_READ_ONLY) {
notmuch->xapian_db->reopen ();
} else {
notmuch->xapian_db->close ();
delete notmuch->xapian_db;
notmuch->xapian_db = NULL;
/* no need to free the same object twice */
notmuch->writable_xapian_db = NULL;
if (new_mode == NOTMUCH_DATABASE_MODE_READ_WRITE) {
notmuch->writable_xapian_db = new Xapian::WritableDatabase (notmuch->xapian_path,
DB_ACTION);
notmuch->xapian_db = notmuch->writable_xapian_db;
} else {
notmuch->xapian_db = new Xapian::Database (notmuch->xapian_path,
DB_ACTION);
}
}
lib/notmuch_database_reopen: reload some database metadata In some uses of reopen, new documents and threads maybe have been added, and e.g. compaction may have changed the uuid.
2021-05-09 14:28:48 +02:00
_load_database_state (notmuch);
lib: support reopening databases for write access. In the future Xapian will apparently support this more conveniently for the cases other than READ_ONLY => READ_ONLY Conceptually this function seems to fit better in lib/open.cc; database.cc is still large enough that moving the function makes sense.
2021-03-14 15:01:59 +01:00
} catch (const Xapian::Error &error) {
if (! notmuch->exception_reported) {
_notmuch_database_log (notmuch, "Error: A Xapian exception reopening database: %s\n",
error.get_msg ().c_str ());
notmuch->exception_reported = true;
}
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
notmuch->view++;
notmuch->open = true;
return NOTMUCH_STATUS_SUCCESS;
}
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
lib/{open,message}: make some internal functions static They are not used outside their file, so being extern seems like an oversight
2021-05-24 02:08:28 +02:00
static notmuch_status_t
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
_maybe_load_config_from_database (notmuch_database_t *notmuch,
GKeyFile *key_file,
const char *database_path,
const char *profile)
{
char *message; /* ignored */
if (_db_dir_exists (database_path, &message))
CLI+lib: detect missing database in split configurations. Eventually we want to do all opening of databases in the top level (main function). This means that detection of missing databases needs to move out of subcommands. It also requires updating the library to use the new NO_DATABASE status code.
2021-02-23 21:19:13 +01:00
return NOTMUCH_STATUS_NO_DATABASE;
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
_set_database_path (notmuch, database_path);
if (_notmuch_choose_xapian_path (notmuch, database_path, &notmuch->xapian_path, &message))
CLI+lib: detect missing database in split configurations. Eventually we want to do all opening of databases in the top level (main function). This means that detection of missing databases needs to move out of subcommands. It also requires updating the library to use the new NO_DATABASE status code.
2021-02-23 21:19:13 +01:00
return NOTMUCH_STATUS_NO_DATABASE;
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
(void) _finish_open (notmuch, profile, NOTMUCH_DATABASE_MODE_READ_ONLY, key_file, &message);
return NOTMUCH_STATUS_SUCCESS;
}
notmuch_status_t
notmuch_database_load_config (const char *database_path,
const char *config_path,
const char *profile,
notmuch_database_t **database,
char **status_string)
{
notmuch_status_t status = NOTMUCH_STATUS_SUCCESS, warning = NOTMUCH_STATUS_SUCCESS;
notmuch_database_t *notmuch = NULL;
char *message = NULL;
GKeyFile *key_file = NULL;
lib: make glib initialization thread-safe In principle this could be done without depending on C++11 features, but these features should be available since gcc 4.8.1, and this localized usage is easy to replace if it turns out to be problematic for portability.
2021-05-09 22:33:48 +02:00
_notmuch_init ();
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
lib/open: track which parameters are passed This will be used to fine tune the loading of configuration for certain special configuration items (initially just "database.path").
2021-10-28 03:34:18 +02:00
notmuch = _alloc_notmuch (database_path, config_path, profile);
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
if (! notmuch) {
status = NOTMUCH_STATUS_OUT_OF_MEMORY;
goto DONE;
}
lib: provide notmuch_config_path Since the library searches in several locations for a config file, the caller does not know which of these is chosen in the usual case of passing NULL as a config file. This changes provides an API for the caller to retrieve the name of the config file chosen. It will be tested in a following commit.
2021-02-21 12:34:52 +01:00
status = _load_key_file (notmuch, config_path, profile, &key_file);
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
switch (status) {
case NOTMUCH_STATUS_SUCCESS:
lib: provide notmuch_config_path Since the library searches in several locations for a config file, the caller does not know which of these is chosen in the usual case of passing NULL as a config file. This changes provides an API for the caller to retrieve the name of the config file chosen. It will be tested in a following commit.
2021-02-21 12:34:52 +01:00
break;
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
case NOTMUCH_STATUS_NO_CONFIG:
warning = status;
break;
default:
message = strdup ("Error: cannot load config file.\n");
goto DONE;
}
lib/open: use db struct as talloc ctx for choose_database_path The extra talloc struct "local" was left over from before the notmuch struct was allocated earlier. Having the notmuch struct available in this function will allow more flexibility to track the configuration variations (e.g. split vs. non-split).
2021-12-25 14:33:02 +01:00
status = _choose_database_path (notmuch, profile, key_file,
lib/open: use notmuch->params to track split status Persisting this status will allow us to use the information in other compilation units, in particular when setting configuration defaults.
2021-12-25 14:33:03 +01:00
&database_path, &message);
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
switch (status) {
CLI+lib: detect missing database in split configurations. Eventually we want to do all opening of databases in the top level (main function). This means that detection of missing databases needs to move out of subcommands. It also requires updating the library to use the new NO_DATABASE status code.
2021-02-23 21:19:13 +01:00
case NOTMUCH_STATUS_NO_DATABASE:
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
case NOTMUCH_STATUS_SUCCESS:
CLI+lib: detect missing database in split configurations. Eventually we want to do all opening of databases in the top level (main function). This means that detection of missing databases needs to move out of subcommands. It also requires updating the library to use the new NO_DATABASE status code.
2021-02-23 21:19:13 +01:00
if (! warning)
warning = status;
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
break;
default:
goto DONE;
}
CLI+lib: detect missing database in split configurations. Eventually we want to do all opening of databases in the top level (main function). This means that detection of missing databases needs to move out of subcommands. It also requires updating the library to use the new NO_DATABASE status code.
2021-02-23 21:19:13 +01:00
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
if (database_path) {
status = _maybe_load_config_from_database (notmuch, key_file, database_path, profile);
CLI+lib: detect missing database in split configurations. Eventually we want to do all opening of databases in the top level (main function). This means that detection of missing databases needs to move out of subcommands. It also requires updating the library to use the new NO_DATABASE status code.
2021-02-23 21:19:13 +01:00
switch (status) {
case NOTMUCH_STATUS_NO_DATABASE:
case NOTMUCH_STATUS_SUCCESS:
if (! warning)
warning = status;
break;
default:
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
goto DONE;
CLI+lib: detect missing database in split configurations. Eventually we want to do all opening of databases in the top level (main function). This means that detection of missing databases needs to move out of subcommands. It also requires updating the library to use the new NO_DATABASE status code.
2021-02-23 21:19:13 +01:00
}
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
}
if (key_file) {
status = _notmuch_config_load_from_file (notmuch, key_file);
if (status)
goto DONE;
}
status = _notmuch_config_load_defaults (notmuch);
if (status)
goto DONE;
DONE:
if (status_string)
*status_string = message;
lib/load_config: deallocate / NULL database on fatal error This fixes a potential memory leak, and makes the behaviour of notmuch_database_load_config (somewhat) consistent with n_d_{open,create} with config.
2021-10-23 15:22:38 +02:00
if (status &&
status != NOTMUCH_STATUS_NO_DATABASE
&& status != NOTMUCH_STATUS_NO_CONFIG) {
notmuch_database_destroy (notmuch);
notmuch = NULL;
}
lib: provide notmuch_database_load_config This is mainly targetted at notmuch-config.c, or similar applications that don't necessarily need both a configuration file and a database to exist.
2021-02-10 00:48:38 +01:00
if (database)
*database = notmuch;
if (status)
return status;
else
return warning;
}
Reference in a new issue Copy permalink