+ notmuch->value_range_processor = NULL;
+ delete notmuch->date_range_processor;
+ notmuch->date_range_processor = NULL;
+}
+
+#if HAVE_XAPIAN_COMPACT
+static int
+unlink_cb (const char *path,
+ unused (const struct stat *sb),
+ unused (int type),
+ unused (struct FTW *ftw))
+{
+ return remove (path);
+}
+
+static int
+rmtree (const char *path)
+{
+ return nftw (path, unlink_cb, 64, FTW_DEPTH | FTW_PHYS);
+}
+
+class NotmuchCompactor : public Xapian::Compactor
+{
+ notmuch_compact_status_cb_t status_cb;
+ void *status_closure;
+
+public:
+ NotmuchCompactor(notmuch_compact_status_cb_t cb, void *closure) :
+ status_cb (cb), status_closure (closure) { }
+
+ virtual void
+ set_status (const std::string &table, const std::string &status)
+ {
+ char *msg;
+
+ if (status_cb == NULL)
+ return;
+
+ if (status.length () == 0)
+ msg = talloc_asprintf (NULL, "compacting table %s", table.c_str());
+ else
+ msg = talloc_asprintf (NULL, " %s", status.c_str());
+
+ if (msg == NULL) {
+ return;
+ }
+
+ status_cb (msg, status_closure);
+ talloc_free (msg);
+ }
+};
+
+/* Compacts the given database, optionally saving the original database
+ * in backup_path. Additionally, a callback function can be provided to
+ * give the user feedback on the progress of the (likely long-lived)
+ * compaction process.
+ *
+ * The backup path must point to a directory on the same volume as the
+ * original database. Passing a NULL backup_path will result in the
+ * uncompacted database being deleted after compaction has finished.
+ * Note that the database write lock will be held during the
+ * compaction process to protect data integrity.
+ */
+notmuch_status_t
+notmuch_database_compact (const char *path,
+ const char *backup_path,
+ notmuch_compact_status_cb_t status_cb,
+ void *closure)
+{
+ void *local;
+ char *notmuch_path, *xapian_path, *compact_xapian_path;
+ notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
+ notmuch_database_t *notmuch = NULL;
+ struct stat statbuf;
+ notmuch_bool_t keep_backup;
+
+ local = talloc_new (NULL);
+ if (! local)
+ return NOTMUCH_STATUS_OUT_OF_MEMORY;
+
+ ret = notmuch_database_open (path, NOTMUCH_DATABASE_MODE_READ_WRITE, ¬much);
+ if (ret) {
+ goto DONE;
+ }
+
+ if (! (notmuch_path = talloc_asprintf (local, "%s/%s", path, ".notmuch"))) {
+ ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
+ goto DONE;
+ }
+
+ if (! (xapian_path = talloc_asprintf (local, "%s/%s", notmuch_path, "xapian"))) {
+ ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
+ goto DONE;
+ }
+
+ if (! (compact_xapian_path = talloc_asprintf (local, "%s.compact", xapian_path))) {
+ ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
+ goto DONE;
+ }
+
+ if (backup_path == NULL) {
+ if (! (backup_path = talloc_asprintf (local, "%s.old", xapian_path))) {
+ ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
+ goto DONE;
+ }
+ keep_backup = FALSE;
+ }
+ else {
+ keep_backup = TRUE;
+ }
+
+ if (stat (backup_path, &statbuf) != -1) {
+ fprintf (stderr, "Path already exists: %s\n", backup_path);
+ ret = NOTMUCH_STATUS_FILE_ERROR;
+ goto DONE;
+ }
+ if (errno != ENOENT) {
+ fprintf (stderr, "Unknown error while stat()ing path: %s\n",
+ strerror (errno));
+ ret = NOTMUCH_STATUS_FILE_ERROR;
+ goto DONE;
+ }
+
+ /* Unconditionally attempt to remove old work-in-progress database (if
+ * any). This is "protected" by database lock. If this fails due to write
+ * errors (etc), the following code will fail and provide error message.
+ */
+ (void) rmtree (compact_xapian_path);
+
+ try {
+ NotmuchCompactor compactor (status_cb, closure);
+
+ compactor.set_renumber (false);
+ compactor.add_source (xapian_path);
+ compactor.set_destdir (compact_xapian_path);
+ compactor.compact ();
+ } catch (const Xapian::Error &error) {
+ fprintf (stderr, "Error while compacting: %s\n", error.get_msg().c_str());
+ ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
+ goto DONE;
+ }
+
+ if (rename (xapian_path, backup_path)) {
+ fprintf (stderr, "Error moving %s to %s: %s\n",
+ xapian_path, backup_path, strerror (errno));
+ ret = NOTMUCH_STATUS_FILE_ERROR;
+ goto DONE;
+ }
+
+ if (rename (compact_xapian_path, xapian_path)) {
+ fprintf (stderr, "Error moving %s to %s: %s\n",
+ compact_xapian_path, xapian_path, strerror (errno));
+ ret = NOTMUCH_STATUS_FILE_ERROR;
+ goto DONE;
+ }
+
+ if (! keep_backup) {
+ if (rmtree (backup_path)) {
+ fprintf (stderr, "Error removing old database %s: %s\n",
+ backup_path, strerror (errno));
+ ret = NOTMUCH_STATUS_FILE_ERROR;
+ goto DONE;
+ }
+ }
+
+ DONE:
+ if (notmuch)
+ notmuch_database_destroy (notmuch);
+
+ talloc_free (local);
+
+ return ret;
+}
+#else
+notmuch_status_t
+notmuch_database_compact (unused (const char *path),
+ unused (const char *backup_path),
+ unused (notmuch_compact_status_cb_t status_cb),
+ unused (void *closure))
+{
+ fprintf (stderr, "notmuch was compiled against a xapian version lacking compaction support.\n");
+ return NOTMUCH_STATUS_UNSUPPORTED_OPERATION;
+}
+#endif
+
+void
+notmuch_database_destroy (notmuch_database_t *notmuch)
+{
+ notmuch_database_close (notmuch);