Initial disk mode support

Makefile.am

@@ -21,6 +21,7 @@ libdqlite_la_SOURCES = \
   src/leader.c \
   src/lib/addr.c \
   src/lib/buffer.c \
+  src/lib/fs.c \
   src/lib/transport.c \
   src/logger.c \
   src/message.c \

include/dqlite.h

@@ -197,6 +197,16 @@ int dqlite_node_set_failure_domain(dqlite_node *n, unsigned long long code);
 int dqlite_node_set_snapshot_params(dqlite_node *n, unsigned snapshot_threshold,
                                     unsigned snapshot_trailing);
 
+/**
+ * WARNING: This is an experimental API.
+ *
+ * By default dqlite holds the SQLite database file and WAL in memory. By enabling
+ * disk-mode, dqlite will hold the SQLite database file on-disk while keeping the WAL
+ * in memory. Has to be called after `dqlite_node_create` and before
+ * `dqlite_node_start`.
+ */
+int dqlite_node_enable_disk_mode(dqlite_node *n);
+
 /**
  * Start a dqlite node.
  *
@@ -305,6 +315,8 @@ dqlite_node_id dqlite_generate_node_id(const char *address);
  */
 int dqlite_vfs_init(sqlite3_vfs *vfs, const char *name);
 
+int dqlite_vfs_enable_disk(sqlite3_vfs *vfs);
+
 /**
  * Release all memory used internally by a SQLite VFS object that was
  * initialized using @qlite_vfs_init.
@@ -386,6 +398,11 @@ int dqlite_vfs_shallow_snapshot(sqlite3_vfs *vfs,
 				struct dqlite_buffer bufs[],
 				unsigned n);
 
+int dqlite_vfs_snapshot_disk(sqlite3_vfs *vfs,
+				const char *filename,
+				struct dqlite_buffer bufs[],
+				unsigned n);
+
 /**
  * Return the number of database pages (excluding WAL).
  */
@@ -401,4 +418,12 @@ int dqlite_vfs_restore(sqlite3_vfs *vfs,
 		       const void *data,
 		       size_t n);
 
+/**
+ * Restore a snapshot of the main database file and of the WAL file.
+ */
+int dqlite_vfs_restore_disk(sqlite3_vfs *vfs,
+		       const char *filename,
+		       const void *data,
+		       size_t main_size,
+		       size_t wal_size);
 #endif /* DQLITE_H */

src/config.c

@@ -28,7 +28,8 @@
  * TODO: make this thread safe. */
 static unsigned serial = 1;
 
-int config__init(struct config *c, dqlite_node_id id, const char *address)
+int config__init(struct config *c, dqlite_node_id id,
+		 const char *address, const char *dir)
 {
 	int rv;
 	c->id = id;
@@ -46,6 +47,9 @@ int config__init(struct config *c, dqlite_node_id id, const char *address)
 	c->logger.emit = loggerDefaultEmit;
 	c->failure_domain = 0;
 	c->weight = 0;
+	strncpy(c->dir, dir, sizeof(c->dir)-1);
+	c->dir[sizeof(c->dir)-1] = '\0';
+	c->disk = false;
 	serial++;
 	return 0;
 }

src/config.h

@@ -17,13 +17,16 @@ struct config
 	char name[256];                /* VFS/replication registriatio name */
 	unsigned long long failure_domain; /* User-provided failure domain */
 	unsigned long long int weight;     /* User-provided node weight */
+	char dir[1024];                /* Data dir for on-disk database */
+	bool disk;                     /* Disk-mode or not */
 };
 
 /**
  * Initialize the config object with required values and set the rest to sane
  * defaults. A copy will be made of the given @address.
  */
-int config__init(struct config *c, dqlite_node_id id, const char *address);
+int config__init(struct config *c, dqlite_node_id id,
+		 const char *address, const char *dir);
 
 /**
  * Release any memory held by the config object.

src/db.c

@@ -7,23 +7,53 @@
 #include "db.h"
 #include "tracing.h"
 
+/* Limit taken from sqlite unix vfs. */
+#define MAX_PATHNAME 512
+
 /* Open a SQLite connection and set it to follower mode. */
 static int open_follower_conn(const char *filename,
 			      const char *vfs,
 			      unsigned page_size,
 			      sqlite3 **conn);
 
-void db__init(struct db *db, struct config *config, const char *filename)
+int db__init(struct db *db, struct config *config, const char *filename)
 {
-        tracef("db init %s", filename);
+	tracef("db init %s", filename);
+	int rv;
+
 	db->config = config;
 	db->filename = sqlite3_malloc((int)(strlen(filename) + 1));
-	assert(db->filename != NULL); /* TODO: return an error instead */
+	if (db->filename == NULL) {
+		rv = DQLITE_NOMEM;
+		goto err;
+	}
 	strcpy(db->filename, filename);
+	db->path = sqlite3_malloc(MAX_PATHNAME + 1);
+	if (db->path == NULL) {
+		rv = DQLITE_NOMEM;
+		goto err_after_filename_alloc;
+	}
+	if (db->config->disk) {
+		rv = snprintf(db->path, MAX_PATHNAME + 1, "%s/%s", db->config->dir, db->filename);
+	} else {
+		rv = snprintf(db->path, MAX_PATHNAME + 1, "%s", db->filename);
+	}
+	if (rv < 0 || rv >= MAX_PATHNAME + 1) {
+		goto err_after_path_alloc;
+	}
+
 	db->follower = NULL;
 	db->tx_id = 0;
 	db->read_lock = 0;
 	QUEUE__INIT(&db->leaders);
+	return 0;
+
+err_after_path_alloc:
+	sqlite3_free(db->path);
+err_after_filename_alloc:
+	sqlite3_free(db->filename);
+err:
+	return rv;
 }
 
 void db__close(struct db *db)
@@ -34,19 +64,17 @@ void db__close(struct db *db)
 		rc = sqlite3_close(db->follower);
 		assert(rc == SQLITE_OK);
 	}
+	sqlite3_free(db->path);
 	sqlite3_free(db->filename);
 }
 
 int db__open_follower(struct db *db)
 {
 	int rc;
 	assert(db->follower == NULL);
-	rc = open_follower_conn(db->filename, db->config->name,
+	rc = open_follower_conn(db->path, db->config->name,
 				db->config->page_size, &db->follower);
-	if (rc != 0) {
-		return rc;
-	}
-	return 0;
+	return rc;
 }
 
 static int open_follower_conn(const char *filename,
@@ -59,8 +87,10 @@ static int open_follower_conn(const char *filename,
 	char *msg = NULL;
 	int rc;
 
+	tracef("open follower conn: %s page_size:%u", filename, page_size);
 	rc = sqlite3_open_v2(filename, conn, flags, vfs);
 	if (rc != SQLITE_OK) {
+		tracef("open_v2 failed %d", rc);
 		goto err;
 	}
 

src/db.h

@@ -13,6 +13,7 @@ struct db
 {
 	struct config *config; /* Dqlite configuration */
 	char *filename;        /* Database filename */
+	char *path;            /* Used for on-disk db */
 	sqlite3 *follower;     /* Follower connection */
 	queue leaders;         /* Open leader connections */
 	unsigned tx_id;        /* Current ongoing transaction ID, if any */
@@ -24,8 +25,9 @@ struct db
  * Initialize a database object.
  *
  * The given @filename will be copied.
+ * Return 0 on success.
  */
-void db__init(struct db *db, struct config *config, const char *filename);
+int db__init(struct db *db, struct config *config, const char *filename);
 
 /**
  * Release all memory associated with a database object.

src/dqlite.c

@@ -12,6 +12,11 @@ int dqlite_vfs_init(sqlite3_vfs *vfs, const char *name)
 	return VfsInit(vfs, name);
 }
 
+int dqlite_vfs_enable_disk(sqlite3_vfs *vfs)
+{
+	return VfsEnableDisk(vfs);
+}
+
 void dqlite_vfs_close(sqlite3_vfs *vfs)
 {
 	VfsClose(vfs);
@@ -47,6 +52,25 @@ int dqlite_vfs_snapshot(sqlite3_vfs *vfs,
 	return VfsSnapshot(vfs, filename, data, n);
 }
 
+int dqlite_vfs_snapshot_disk(sqlite3_vfs *vfs,
+			const char *filename,
+			struct dqlite_buffer bufs[],
+			unsigned n)
+{
+	int rv;
+	if (n != 2) {
+		return -1;
+	}
+
+	rv = VfsDiskSnapshotDb(vfs, filename, &bufs[0]);
+	if (rv != 0) {
+		return rv;
+	}
+
+	rv = VfsDiskSnapshotWal(vfs, filename, &bufs[1]);
+	return rv;
+}
+
 int dqlite_vfs_num_pages(sqlite3_vfs *vfs,
 			 const char *filename,
 			 unsigned *n)
@@ -69,3 +93,12 @@ int dqlite_vfs_restore(sqlite3_vfs *vfs,
 {
 	return VfsRestore(vfs, filename, data, n);
 }
+
+int dqlite_vfs_restore_disk(sqlite3_vfs *vfs,
+		       const char *filename,
+		       const void *data,
+		       size_t main_size,
+		       size_t wal_size)
+{
+	return VfsDiskRestore(vfs, filename, data, main_size, wal_size);
+}