open()

Open a connection to a Store. More...

Collaboration diagram for open():

Functions
static StoreHandle *	store_bdb_open (const char *path, bool create)
	Open a connection to a Store - Implements StoreOps::open() -.
static StoreHandle *	store_gdbm_open (const char *path, bool create)
	Open a connection to a Store - Implements StoreOps::open() -.
static StoreHandle *	store_kyotocabinet_open (const char *path, bool create)
	Open a connection to a Store - Implements StoreOps::open() -.
static StoreHandle *	store_lmdb_open (const char *path, bool create)
	Open a connection to a Store - Implements StoreOps::open() -.
static StoreHandle *	store_qdbm_open (const char *path, bool create)
	Open a connection to a Store - Implements StoreOps::open() -.
static StoreHandle *	store_rocksdb_open (const char *path, bool create)
	Open a connection to a Store - Implements StoreOps::open() -.
static StoreHandle *	store_tokyocabinet_open (const char *path, bool create)
	Open a connection to a Store - Implements StoreOps::open() -.
static StoreHandle *	store_tdb_open (const char *path, bool create)
	Open a connection to a Store - Implements StoreOps::open() -.

Detailed Description

Open a connection to a Store.

Parameters

[in]	path	Path to the database file
[in]	create	Create the file if it's not there?

Return values

ptr	Success, Store pointer
NULL	Failure

The open function has the purpose of opening a backend-specific connection to the database file specified by the path parameter. Backends MUST return non-NULL specific handle information on success.

Function Documentation

store_bdb_open()

static StoreHandle * store_bdb_open ( const char *  path, bool  create  )

static

Open a connection to a Store - Implements StoreOps::open() -.

Definition at line 115 of file bdb.c.

{
  if (!path)
    return NULL;
 
  struct BdbStoreData *sdata = bdb_sdata_new();
 
  const int pagesize = 512;
 
  buf_printf(&sdata->lockfile, "%s-lock-hack", path);
 
  sdata->fd = open(buf_string(&sdata->lockfile),
                   O_WRONLY | (create ? O_CREAT : 0), S_IRUSR | S_IWUSR);
  if (sdata->fd < 0)
  {
    bdb_sdata_free(&sdata);
    return NULL;
  }
 
  if (mutt_file_lock(sdata->fd, true, true))
    goto fail_close;
 
  int rc = db_env_create(&sdata->env, 0);
  if (rc)
    goto fail_unlock;
 
  rc = (*sdata->env->open)(sdata->env, NULL, DB_INIT_MPOOL | DB_CREATE | DB_PRIVATE, 0600);
  if (rc)
    goto fail_env;
 
  sdata->db = NULL;
  rc = db_create(&sdata->db, sdata->env, 0);
  if (rc)
    goto fail_env;
 
  uint32_t createflags = DB_CREATE;
  struct stat st = { 0 };
 
  if ((stat(path, &st) != 0) && (errno == ENOENT))
  {
    createflags |= DB_EXCL;
    sdata->db->set_pagesize(sdata->db, pagesize);
  }
 
  rc = (*sdata->db->open)(sdata->db, NULL, path, NULL, DB_BTREE, createflags, 0600);
  if (rc)
    goto fail_db;
 
  // Return an opaque pointer
  return (StoreHandle *) sdata;
 
fail_db:
  sdata->db->close(sdata->db, 0);
fail_env:
  sdata->env->close(sdata->env, 0);
fail_unlock:
  mutt_file_unlock(sdata->fd);
fail_close:
  close(sdata->fd);
  unlink(buf_string(&sdata->lockfile));
  bdb_sdata_free(&sdata);
 
  return NULL;
}

Here is the call graph for this function:

store_gdbm_open()

static StoreHandle * store_gdbm_open ( const char *  path, bool  create  )

static

Open a connection to a Store - Implements StoreOps::open() -.

Definition at line 42 of file gdbm.c.

{
  if (!path)
    return NULL;
 
  const int pagesize = 4096;
 
  GDBM_FILE db = gdbm_open((char *) path, pagesize,
                           create ? GDBM_WRCREAT : GDBM_WRITER, 00600, NULL);
  if (!db)
  {
    /* if rw failed try ro */
    db = gdbm_open((char *) path, pagesize, GDBM_READER, 00600, NULL);
  }
 
  // Return an opaque pointer
  return (StoreHandle *) db;
}

store_kyotocabinet_open()

static StoreHandle * store_kyotocabinet_open ( const char *  path, bool  create  )

static

Open a connection to a Store - Implements StoreOps::open() -.

Definition at line 41 of file kc.c.

{
  if (!path)
    return NULL;
 
  KCDB *db = kcdbnew();
  if (!db)
    return NULL;
 
  struct Buffer *kcdbpath = buf_pool_get();
 
  buf_printf(kcdbpath, "%s#type=kct#opts=l#rcomp=lex", path);
 
  if (!kcdbopen(db, buf_string(kcdbpath), KCOWRITER | (create ? KCOCREATE : 0)))
  {
    int ecode = kcdbecode(db);
    mutt_debug(LL_DEBUG2, "kcdbopen failed for %s: %s (ecode %d)\n",
               buf_string(kcdbpath), kcdbemsg(db), ecode);
    kcdbdel(db);
    db = NULL;
  }
 
  buf_pool_release(&kcdbpath);
  // Return an opaque pointer
  return (StoreHandle *) db;
}

Here is the call graph for this function:

store_lmdb_open()

static StoreHandle * store_lmdb_open ( const char *  path, bool  create  )

static

Open a connection to a Store - Implements StoreOps::open() -.

Definition at line 150 of file lmdb.c.

{
  if (!path)
    return NULL;
 
  if (!create && access(path, F_OK) != 0)
  {
    return NULL;
  }
 
  struct LmdbStoreData *sdata = lmdb_sdata_new();
 
  int rc = mdb_env_create(&sdata->env);
  if (rc != MDB_SUCCESS)
  {
    mutt_debug(LL_DEBUG2, "mdb_env_create: %s\n", mdb_strerror(rc));
    lmdb_sdata_free(&sdata);
    return NULL;
  }
 
  mdb_env_set_mapsize(sdata->env, LMDB_DB_SIZE);
 
  rc = mdb_env_open(sdata->env, path, MDB_NOSUBDIR, 0644);
  if (rc != MDB_SUCCESS)
  {
    mutt_debug(LL_DEBUG2, "mdb_env_open: %s\n", mdb_strerror(rc));
    goto fail_env;
  }
 
  rc = lmdb_get_read_txn(sdata);
  if (rc != MDB_SUCCESS)
  {
    mutt_debug(LL_DEBUG2, "mdb_txn_begin: %s\n", mdb_strerror(rc));
    goto fail_env;
  }
 
  rc = mdb_dbi_open(sdata->txn, NULL, MDB_CREATE, &sdata->db);
  if (rc != MDB_SUCCESS)
  {
    mutt_debug(LL_DEBUG2, "mdb_dbi_open: %s\n", mdb_strerror(rc));
    goto fail_dbi;
  }
 
  mdb_txn_reset(sdata->txn);
  sdata->txn_mode = TXN_UNINITIALIZED;
  // Return an opaque pointer
  return (StoreHandle *) sdata;
 
fail_dbi:
  mdb_txn_abort(sdata->txn);
  sdata->txn_mode = TXN_UNINITIALIZED;
  sdata->txn = NULL;
 
fail_env:
  mdb_env_close(sdata->env);
  lmdb_sdata_free(&sdata);
  return NULL;
}

Here is the call graph for this function:

store_qdbm_open()

static StoreHandle * store_qdbm_open ( const char *  path, bool  create  )

static

Open a connection to a Store - Implements StoreOps::open() -.

Definition at line 42 of file qdbm.c.

{
  if (!path)
    return NULL;
 
  VILLA *db = vlopen(path, VL_OWRITER | (create ? VL_OCREAT : 0), VL_CMPLEX);
 
  // Return an opaque pointer
  return (StoreHandle *) db;
}

store_rocksdb_open()

static StoreHandle * store_rocksdb_open ( const char *  path, bool  create  )

static

Open a connection to a Store - Implements StoreOps::open() -.

Definition at line 77 of file rocksdb.c.

{
  if (!path)
    return NULL;
 
  struct RocksDbStoreData *sdata = rocksdb_sdata_new();
 
  /* RocksDB stores errors in form of strings */
  sdata->err = NULL;
 
  /* setup generic options, create new db and limit log to one file */
  sdata->options = rocksdb_options_create();
  if (create)
  {
    rocksdb_options_set_create_if_missing(sdata->options, 1);
  }
  rocksdb_options_set_keep_log_file_num(sdata->options, 1);
 
  /* setup read options, we verify with checksums */
  sdata->read_options = rocksdb_readoptions_create();
  rocksdb_readoptions_set_verify_checksums(sdata->read_options, 1);
 
  /* setup write options, no sync needed, disable WAL */
  sdata->write_options = rocksdb_writeoptions_create();
  rocksdb_writeoptions_set_sync(sdata->write_options, 0);
  rocksdb_writeoptions_disable_WAL(sdata->write_options, 1);
 
  rocksdb_options_set_compression(sdata->options, rocksdb_no_compression);
 
  /* open database and check for error in sdata->error */
  sdata->db = rocksdb_open(sdata->options, path, &sdata->err);
  if (sdata->err)
  {
    rocksdb_options_destroy(sdata->options);
    rocksdb_readoptions_destroy(sdata->read_options);
    rocksdb_writeoptions_destroy(sdata->write_options);
    rocksdb_sdata_free(&sdata);
    return NULL;
  }
 
  // Return an opaque pointer
  return (StoreHandle *) sdata;
}

Here is the call graph for this function:

store_tokyocabinet_open()

static StoreHandle * store_tokyocabinet_open ( const char *  path, bool  create  )

static

Open a connection to a Store - Implements StoreOps::open() -.

Definition at line 42 of file tc.c.

{
  if (!path)
    return NULL;
 
  TCBDB *db = tcbdbnew();
  if (!db)
    return NULL;
  if (!tcbdbopen(db, path, BDBOWRITER | (create ? BDBOCREAT : 0)))
  {
    int ecode = tcbdbecode(db);
    mutt_debug(LL_DEBUG2, "tcbdbopen failed for %s: %s (ecode %d)\n", path,
               tcbdberrmsg(ecode), ecode);
    tcbdbdel(db);
    return NULL;
  }
 
  // Return an opaque pointer
  return (StoreHandle *) db;
}

store_tdb_open()

static StoreHandle * store_tdb_open ( const char *  path, bool  create  )

static

Open a connection to a Store - Implements StoreOps::open() -.

Definition at line 42 of file tdb.c.

{
  if (!path)
    return NULL;
 
  /* TDB_NOLOCK - Don't do any locking
   * TDB_NOSYNC - Don't use synchronous transactions
   * TDB_INCOMPATIBLE_HASH - Better hashing
   */
  const int flags = TDB_NOLOCK | TDB_INCOMPATIBLE_HASH | TDB_NOSYNC;
  const int hash_size = 33533; // Based on test timings for 100K emails
 
  struct tdb_context *db = tdb_open(path, hash_size, flags,
                                    (create ? O_CREAT : 0) | O_RDWR, 00600);
 
  // Return an opaque pointer
  return (StoreHandle *) db;
}