db.c

Go to the documentation of this file.

 
#include "config.h"
#include <limits.h>
#include <notmuch.h>
#include <stdbool.h>
#include <stdio.h>
#include <sys/stat.h>
#include "private.h"
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "lib.h"
#include "adata.h"
#include "mdata.h"
#include "mutt_logging.h"
 
const char *nm_db_get_filename(struct Mailbox *m)
{
  struct NmMboxData *mdata = nm_mdata_get(m);
  const char *db_filename = NULL;
 
  const char *const c_nm_default_url = cs_subset_string(NeoMutt->sub, "nm_default_url");
  if (mdata && mdata->db_url && mdata->db_url->path)
    db_filename = mdata->db_url->path;
  else
    db_filename = c_nm_default_url;
 
  const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
  if (!db_filename && !c_folder)
    return NULL;
 
  if (!db_filename)
    db_filename = c_folder;
 
  if (nm_path_probe(db_filename, NULL) == MUTT_NOTMUCH)
    db_filename += NmUrlProtocolLen;
 
  mutt_debug(LL_DEBUG2, "nm: db filename '%s'\n", db_filename);
  return db_filename;
}
 
#if LIBNOTMUCH_CHECK_VERSION(5, 4, 0)
static const char *get_nm_config_file(void)
{
  const char *config_to_use = NULL;
  const char *c_nm_config_file = cs_subset_path(NeoMutt->sub, "nm_config_file");
 
  // Workaround the configuration system mapping "" to NULL.
  if (!c_nm_config_file)
  {
    config_to_use = "";
  }
  else if (!mutt_strn_equal(c_nm_config_file, "auto", 4))
  {
    config_to_use = c_nm_config_file;
  }
 
  return config_to_use;
}
#endif
 
notmuch_database_t *nm_db_do_open(const char *filename, bool writable, bool verbose)
{
  notmuch_database_t *db = NULL;
  int ct = 0;
  notmuch_status_t st = NOTMUCH_STATUS_SUCCESS;
  char *msg = NULL;
 
  const short c_nm_open_timeout = cs_subset_number(NeoMutt->sub, "nm_open_timeout");
  mutt_debug(LL_DEBUG1, "nm: db open '%s' %s (timeout %d)\n", filename,
             writable ? "[WRITE]" : "[READ]", c_nm_open_timeout);
 
  const notmuch_database_mode_t mode = writable ? NOTMUCH_DATABASE_MODE_READ_WRITE :
                                                  NOTMUCH_DATABASE_MODE_READ_ONLY;
 
  do
  {
#if LIBNOTMUCH_CHECK_VERSION(5, 4, 0)
    // notmuch 0.32-0.32.2 didn't bump libnotmuch version to 5.4.
    const char *config_file = get_nm_config_file();
    const char *const c_nm_config_profile = cs_subset_string(NeoMutt->sub, "nm_config_profile");
 
    st = notmuch_database_open_with_config(filename, mode, config_file,
                                           c_nm_config_profile, &db, &msg);
 
    // Attempt opening database without configuration file. Don't if the user specified no config.
    if (st == NOTMUCH_STATUS_NO_CONFIG && !mutt_str_equal(config_file, ""))
    {
      mutt_debug(LL_DEBUG1, "nm: Could not find notmuch configuration file: %s\n", config_file);
      mutt_debug(LL_DEBUG1, "nm: Attempting to open notmuch db without configuration file.\n");
 
      FREE(&msg);
 
      st = notmuch_database_open_with_config(filename, mode, "", NULL, &db, &msg);
    }
#elif LIBNOTMUCH_CHECK_VERSION(4, 2, 0)
    st = notmuch_database_open_verbose(filename, mode, &db, &msg);
#elif defined(NOTMUCH_API_3)
    st = notmuch_database_open(filename, mode, &db);
#else
    db = notmuch_database_open(filename, mode);
#endif
    if ((st == NOTMUCH_STATUS_FILE_ERROR) || db || !c_nm_open_timeout ||
        ((ct / 2) > c_nm_open_timeout))
    {
      break;
    }
 
    if (verbose && ct && ((ct % 2) == 0))
      mutt_error(_("Waiting for notmuch DB... (%d sec)"), ct / 2);
    mutt_date_sleep_ms(500); /* Half a second */
    ct++;
  } while (true);
 
  if (st != NOTMUCH_STATUS_SUCCESS)
  {
    db = NULL;
  }
 
  if (verbose)
  {
    if (!db)
    {
      if (msg)
      {
        mutt_error("%s", msg);
      }
      else
      {
        mutt_error(_("Can't open notmuch database: %s: %s"), filename,
                   st ? notmuch_status_to_string(st) : _("unknown reason"));
      }
    }
    else if (ct > 1)
    {
      mutt_clear_error();
    }
  }
 
  FREE(&msg);
 
  return db;
}
 
notmuch_database_t *nm_db_get(struct Mailbox *m, bool writable)
{
  struct NmAccountData *adata = nm_adata_get(m);
 
  if (!adata)
    return NULL;
 
  // Use an existing open db if we have one.
  if (adata->db)
    return adata->db;
 
  const char *db_filename = nm_db_get_filename(m);
  if (db_filename)
    adata->db = nm_db_do_open(db_filename, writable, true);
 
  return adata->db;
}
 
int nm_db_release(struct Mailbox *m)
{
  struct NmAccountData *adata = nm_adata_get(m);
  if (!adata || !adata->db || nm_db_is_longrun(m))
    return -1;
 
  mutt_debug(LL_DEBUG1, "nm: db close\n");
  nm_db_free(adata->db);
  adata->db = NULL;
  adata->longrun = false;
  return 0;
}
 
void nm_db_free(notmuch_database_t *db)
{
#ifdef NOTMUCH_API_3
  notmuch_database_destroy(db);
#else
  notmuch_database_close(db);
#endif
}
 
int nm_db_trans_begin(struct Mailbox *m)
{
  struct NmAccountData *adata = nm_adata_get(m);
  if (!adata || !adata->db)
    return -1;
 
  if (adata->trans)
    return 0;
 
  mutt_debug(LL_DEBUG2, "nm: db trans start\n");
  if (notmuch_database_begin_atomic(adata->db))
    return -1;
  adata->trans = true;
  return 1;
}
 
int nm_db_trans_end(struct Mailbox *m)
{
  struct NmAccountData *adata = nm_adata_get(m);
  if (!adata || !adata->db)
    return -1;
 
  if (!adata->trans)
    return 0;
 
  mutt_debug(LL_DEBUG2, "nm: db trans end\n");
  adata->trans = false;
  if (notmuch_database_end_atomic(adata->db))
    return -1;
 
  return 0;
}
 
int nm_db_get_mtime(struct Mailbox *m, time_t *mtime)
{
  if (!m || !mtime)
    return -1;
 
  struct stat st = { 0 };
  char path[PATH_MAX] = { 0 };
  const char *db_filename = nm_db_get_filename(m);
 
  mutt_debug(LL_DEBUG2, "nm: checking database mtime '%s'\n", db_filename);
 
  // See if the path we were given has a Xapian directory.
  // After notmuch 0.32, a .notmuch folder isn't guaranteed.
  snprintf(path, sizeof(path), "%s/xapian", db_filename);
  if (stat(path, &st) == 0)
  {
    *mtime = st.st_mtime;
    return 0;
  }
 
  // Otherwise, check for a .notmuch directory.
  snprintf(path, sizeof(path), "%s/.notmuch/xapian", db_filename);
 
  if (stat(path, &st) != 0)
    return -1;
 
  *mtime = st.st_mtime;
  return 0;
}
 
bool nm_db_is_longrun(struct Mailbox *m)
{
  struct NmAccountData *adata = nm_adata_get(m);
  if (!adata)
    return false;
 
  return adata->longrun;
}
 
void nm_db_longrun_init(struct Mailbox *m, bool writable)
{
  struct NmAccountData *adata = nm_adata_get(m);
 
  if (!(adata && nm_db_get(m, writable)))
    return;
 
  adata->longrun = true;
  mutt_debug(LL_DEBUG2, "nm: long run initialized\n");
}
 
void nm_db_longrun_done(struct Mailbox *m)
{
  struct NmAccountData *adata = nm_adata_get(m);
 
  if (adata)
  {
    adata->longrun = false; /* to force nm_db_release() released DB */
    if (nm_db_release(m) == 0)
      mutt_debug(LL_DEBUG2, "nm: long run deinitialized\n");
    else
      adata->longrun = true;
  }
}
 
void nm_db_debug_check(struct Mailbox *m)
{
  struct NmAccountData *adata = nm_adata_get(m);
  if (!adata || !adata->db)
    return;
 
  mutt_debug(LL_DEBUG1, "nm: ERROR: db is open, closing\n");
  nm_db_release(m);
}