X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=lib%2Fdatabase.cc;h=f8b95bc46f5fcacf61839c30b4b1cf17a124c9f4;hp=4524016b37aecb1d0ffbacfbe72d4b5c8b03b94d;hb=7a8046ced8c0e61ddd0ff463cfc17ed63e6edad3;hpb=146549321044615d9aef2b30cedccda9c49f3f38 diff --git a/lib/database.cc b/lib/database.cc index 4524016b..f8b95bc4 100644 --- a/lib/database.cc +++ b/lib/database.cc @@ -22,7 +22,8 @@ #include -#include +#include +#include #include /* g_free, GPtrArray, GHashTable */ @@ -35,33 +36,49 @@ typedef struct { const char *prefix; } prefix_t; -/* Here's the current schema for our database: +#define NOTMUCH_DATABASE_VERSION 1 + +#define STRINGIFY(s) _SUB_STRINGIFY(s) +#define _SUB_STRINGIFY(s) #s + +/* Here's the current schema for our database (for NOTMUCH_DATABASE_VERSION): * - * We currently have two different types of documents: mail and timestamps. + * We currently have two different types of documents (mail and + * directory) and also some metadata. * * Mail document * ------------- * A mail document is associated with a particular email message file - * on disk. It is indexed with the following prefixed terms: + * on disk. It is indexed with the following prefixed terms which the + * database uses to construct threads, etc.: * * Single terms of given prefix: * * type: mail * - * id: Unique ID of mail, (from Message-ID header or generated - * as "notmuch-sha1-. + * id: Unique ID of mail. This is from the Message-ID header + * if present and not too long (see NOTMUCH_MESSAGE_ID_MAX). + * If it's present and too long, then we use + * "notmuch-sha1-". + * If this header is not present, we use + * "notmuch-sha1-". * * thread: The ID of the thread to which the mail belongs * + * replyto: The ID from the In-Reply-To header of the mail (if any). + * * Multiple terms of given prefix: * - * ref: All unresolved message IDs from In-Reply-To and - * References headers in the message. (Once a referenced - * message is added to the database and the thread IDs - * are linked the corresponding "ref" term is dropped - * from the message document.) + * reference: All message IDs from In-Reply-To and References + * headers in the message. + * + * tag: Any tags associated with this message by the user. * - * tag: Any tags associated with this message by the user. + * file-direntry: A colon-separated pair of values + * (INTEGER:STRING), where INTEGER is the + * document ID of a directory document, and + * STRING is the name of a file within that + * directory for this mail message. * * A mail document also has two values: * @@ -70,21 +87,87 @@ typedef struct { * * MESSAGE_ID: The unique ID of the mail mess (see "id" above) * - * Timestamp document + * In addition, terms from the content of the message are added with + * "from", "to", "attachment", and "subject" prefixes for use by the + * user in searching. Similarly, terms from the path of the mail + * message are added with a "folder" prefix. But the database doesn't + * really care itself about any of these. + * + * The data portion of a mail document is empty. + * + * Directory document * ------------------ - * A timestamp document is used by a client of the notmuch library to + * A directory document is used by a client of the notmuch library to * maintain data necessary to allow for efficient polling of mail - * directories. The notmuch library does no interpretation of - * timestamps, but merely allows the user to store and retrieve - * timestamps as name/value pairs. + * directories. + * + * All directory documents contain one term: + * + * directory: The directory path (relative to the database path) + * Or the SHA1 sum of the directory path (if the + * path itself is too long to fit in a Xapian + * term). + * + * And all directory documents for directories other than top-level + * directories also contain the following term: + * + * directory-direntry: A colon-separated pair of values + * (INTEGER:STRING), where INTEGER is the + * document ID of the parent directory + * document, and STRING is the name of this + * directory within that parent. + * + * All directory documents have a single value: + * + * TIMESTAMP: The mtime of the directory (at last scan) + * + * The data portion of a directory document contains the path of the + * directory (relative to the database path). * - * The timestamp document is indexed with a single prefixed term: + * Database metadata + * ----------------- + * Xapian allows us to store arbitrary name-value pairs as + * "metadata". We currently use the following metadata names with the + * given meanings: * - * timestamp: The user's key value (likely a directory name) + * version The database schema version, (which is distinct + * from both the notmuch package version (see + * notmuch --version) and the libnotmuch library + * version. The version is stored as an base-10 + * ASCII integer. The initial database version + * was 1, (though a schema existed before that + * were no "version" database value existed at + * all). Successive versions are allocated as + * changes are made to the database (such as by + * indexing new fields). * - * and has a single value: + * last_thread_id The last thread ID generated. This is stored + * as a 16-byte hexadecimal ASCII representation + * of a 64-bit unsigned integer. The first ID + * generated is 1 and the value will be + * incremented for each thread ID. * - * TIMESTAMP: The time_t value from the user. + * thread_id_* A pre-allocated thread ID for a particular + * message. This is actually an arbitrarily large + * family of metadata name. Any particular name is + * formed by concatenating "thread_id_" with a message + * ID (or the SHA1 sum of a message ID if it is very + * long---see description of 'id' in the mail + * document). The value stored is a thread ID. + * + * These thread ID metadata values are stored + * whenever a message references a parent message + * that does not yet exist in the database. A + * thread ID will be allocated and stored, and if + * the message is later added, the stored thread + * ID will be used (and the metadata value will + * be cleared). + * + * Even before a message is added, it's + * pre-allocated thread ID is useful so that all + * descendant messages that reference this common + * parent can be recognized as belonging to the + * same thread. */ /* With these prefix values we follow the conventions published here: @@ -102,25 +185,28 @@ typedef struct { * nearly universal to all mail messages). */ -prefix_t BOOLEAN_PREFIX_INTERNAL[] = { - { "type", "T" }, - { "ref", "XREFERENCE" }, - { "replyto", "XREPLYTO" }, - { "timestamp", "XTIMESTAMP" }, - { "contact", "XCONTACT" } +static prefix_t BOOLEAN_PREFIX_INTERNAL[] = { + { "type", "T" }, + { "reference", "XREFERENCE" }, + { "replyto", "XREPLYTO" }, + { "directory", "XDIRECTORY" }, + { "file-direntry", "XFDIRENTRY" }, + { "directory-direntry", "XDDIRENTRY" }, }; -prefix_t BOOLEAN_PREFIX_EXTERNAL[] = { - { "thread", "G" }, - { "tag", "K" }, - { "id", "Q" } +static prefix_t BOOLEAN_PREFIX_EXTERNAL[] = { + { "thread", "G" }, + { "tag", "K" }, + { "is", "K" }, + { "id", "Q" } }; -prefix_t PROBABILISTIC_PREFIX[]= { - { "from", "XFROM" }, - { "to", "XTO" }, - { "attachment", "XATTACHMENT" }, - { "subject", "XSUBJECT"} +static prefix_t PROBABILISTIC_PREFIX[]= { + { "from", "XFROM" }, + { "to", "XTO" }, + { "attachment", "XATTACHMENT" }, + { "subject", "XSUBJECT"}, + { "folder", "XFOLDER"} }; int @@ -143,17 +229,20 @@ _find_prefix (const char *name) { unsigned int i; - for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_INTERNAL); i++) + for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_INTERNAL); i++) { if (strcmp (name, BOOLEAN_PREFIX_INTERNAL[i].name) == 0) return BOOLEAN_PREFIX_INTERNAL[i].prefix; + } - for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) + for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) { if (strcmp (name, BOOLEAN_PREFIX_EXTERNAL[i].name) == 0) return BOOLEAN_PREFIX_EXTERNAL[i].prefix; + } - for (i = 0; i < ARRAY_SIZE (PROBABILISTIC_PREFIX); i++) + for (i = 0; i < ARRAY_SIZE (PROBABILISTIC_PREFIX); i++) { if (strcmp (name, PROBABILISTIC_PREFIX[i].name) == 0) return PROBABILISTIC_PREFIX[i].prefix; + } INTERNAL_ERROR ("No prefix exists for '%s'\n", name); @@ -168,6 +257,8 @@ notmuch_status_to_string (notmuch_status_t status) return "No error occurred"; case NOTMUCH_STATUS_OUT_OF_MEMORY: return "Out of memory"; + case NOTMUCH_STATUS_READ_ONLY_DATABASE: + return "Attempt to write to a read-only database"; case NOTMUCH_STATUS_XAPIAN_EXCEPTION: return "A Xapian exception occurred"; case NOTMUCH_STATUS_FILE_ERROR: @@ -181,13 +272,26 @@ notmuch_status_to_string (notmuch_status_t status) case NOTMUCH_STATUS_TAG_TOO_LONG: return "Tag value is too long (exceeds NOTMUCH_TAG_MAX)"; case NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW: - return "Unblanced number of calls to notmuch_message_freeze/thaw"; + return "Unbalanced number of calls to notmuch_message_freeze/thaw"; + case NOTMUCH_STATUS_UNBALANCED_ATOMIC: + return "Unbalanced number of calls to notmuch_database_begin_atomic/end_atomic"; default: case NOTMUCH_STATUS_LAST_STATUS: return "Unknown error status value"; } } +static void +find_doc_ids_for_term (notmuch_database_t *notmuch, + const char *term, + Xapian::PostingIterator *begin, + Xapian::PostingIterator *end) +{ + *begin = notmuch->xapian_db->postlist_begin (term); + + *end = notmuch->xapian_db->postlist_end (term); +} + static void find_doc_ids (notmuch_database_t *notmuch, const char *prefix_name, @@ -195,24 +299,21 @@ find_doc_ids (notmuch_database_t *notmuch, Xapian::PostingIterator *begin, Xapian::PostingIterator *end) { - Xapian::PostingIterator i; char *term; term = talloc_asprintf (notmuch, "%s%s", _find_prefix (prefix_name), value); - *begin = notmuch->xapian_db->postlist_begin (term); - - *end = notmuch->xapian_db->postlist_end (term); + find_doc_ids_for_term (notmuch, term, begin, end); talloc_free (term); } -static notmuch_private_status_t -find_unique_doc_id (notmuch_database_t *notmuch, - const char *prefix_name, - const char *value, - unsigned int *doc_id) +notmuch_private_status_t +_notmuch_database_find_unique_doc_id (notmuch_database_t *notmuch, + const char *prefix_name, + const char *value, + unsigned int *doc_id) { Xapian::PostingIterator i, end; @@ -221,10 +322,19 @@ find_unique_doc_id (notmuch_database_t *notmuch, if (i == end) { *doc_id = 0; return NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND; - } else { - *doc_id = *i; - return NOTMUCH_PRIVATE_STATUS_SUCCESS; } + + *doc_id = *i; + +#if DEBUG_DATABASE_SANITY + i++; + + if (i != end) + INTERNAL_ERROR ("Term %s:%s is not unique as expected.\n", + prefix_name, value); +#endif + + return NOTMUCH_PRIVATE_STATUS_SUCCESS; } static Xapian::Document @@ -233,24 +343,21 @@ find_document_for_doc_id (notmuch_database_t *notmuch, unsigned doc_id) return notmuch->xapian_db->get_document (doc_id); } -static notmuch_private_status_t -find_unique_document (notmuch_database_t *notmuch, - const char *prefix_name, - const char *value, - Xapian::Document *document, - unsigned int *doc_id) +/* Generate a compressed version of 'message_id' of the form: + * + * notmuch-sha1- + */ +static char * +_message_id_compressed (void *ctx, const char *message_id) { - notmuch_private_status_t status; + char *sha1, *compressed; - status = find_unique_doc_id (notmuch, prefix_name, value, doc_id); + sha1 = notmuch_sha1_of_string (message_id); - if (status) { - *document = Xapian::Document (); - return status; - } + compressed = talloc_asprintf (ctx, "notmuch-sha1-%s", sha1); + free (sha1); - *document = find_document_for_doc_id (notmuch, *doc_id); - return NOTMUCH_PRIVATE_STATUS_SUCCESS; + return compressed; } notmuch_message_t * @@ -260,12 +367,23 @@ notmuch_database_find_message (notmuch_database_t *notmuch, notmuch_private_status_t status; unsigned int doc_id; - status = find_unique_doc_id (notmuch, "id", message_id, &doc_id); + if (strlen (message_id) > NOTMUCH_MESSAGE_ID_MAX) + message_id = _message_id_compressed (notmuch, message_id); - if (status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) - return NULL; + try { + status = _notmuch_database_find_unique_doc_id (notmuch, "id", + message_id, &doc_id); - return _notmuch_message_create (notmuch, notmuch, doc_id, NULL); + if (status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) + return NULL; + + return _notmuch_message_create (notmuch, notmuch, doc_id, NULL); + } catch (const Xapian::Error &error) { + fprintf (stderr, "A Xapian exception occurred finding message: %s.\n", + error.get_msg().c_str()); + notmuch->exception_reported = TRUE; + return NULL; + } } /* Advance 'str' past any whitespace or RFC 822 comments. A comment is @@ -289,13 +407,14 @@ skip_space_and_comments (const char **str) int nesting = 1; s++; while (*s && nesting) { - if (*s == '(') + if (*s == '(') { nesting++; - else if (*s == ')') + } else if (*s == ')') { nesting--; - else if (*s == '\\') + } else if (*s == '\\') { if (*(s+1)) s++; + } s++; } } @@ -305,7 +424,7 @@ skip_space_and_comments (const char **str) } /* Parse an RFC 822 message-id, discarding whitespace, any RFC 822 - * comments, and the '<' and '>' delimeters. + * comments, and the '<' and '>' delimiters. * * If not NULL, then *next will be made to point to the first character * not parsed, (possibly pointing to the final '\0' terminator. @@ -314,12 +433,12 @@ skip_space_and_comments (const char **str) * * Returns NULL if there is any error parsing the message-id. */ static char * -parse_message_id (void *ctx, const char *message_id, const char **next) +_parse_message_id (void *ctx, const char *message_id, const char **next) { const char *s, *end; char *result; - if (message_id == NULL) + if (message_id == NULL || *message_id == '\0') return NULL; s = message_id; @@ -372,41 +491,32 @@ parse_message_id (void *ctx, const char *message_id, const char **next) } /* Parse a References header value, putting a (talloc'ed under 'ctx') - * copy of each referenced message-id into 'hash'. */ + * copy of each referenced message-id into 'hash'. + * + * We explicitly avoid including any reference identical to + * 'message_id' in the result (to avoid mass confusion when a single + * message references itself cyclically---and yes, mail messages are + * not infrequent in the wild that do this---don't ask me why). +*/ static void parse_references (void *ctx, + const char *message_id, GHashTable *hash, const char *refs) { char *ref; - if (refs == NULL) + if (refs == NULL || *refs == '\0') return; while (*refs) { - ref = parse_message_id (ctx, refs, &refs); + ref = _parse_message_id (ctx, refs, &refs); - if (ref) + if (ref && strcmp (ref, message_id)) g_hash_table_insert (hash, ref, NULL); } } -char * -notmuch_database_default_path (void) -{ - char *path; - - if (getenv ("NOTMUCH_BASE")) - return strdup (getenv ("NOTMUCH_BASE")); - - if (asprintf (&path, "%s/mail", getenv ("HOME")) == -1) { - fprintf (stderr, "Out of memory.\n"); - return xstrdup(""); - } - - return path; -} - notmuch_database_t * notmuch_database_create (const char *path) { @@ -414,10 +524,11 @@ notmuch_database_create (const char *path) char *notmuch_path = NULL; struct stat st; int err; - char *local_path = NULL; - if (path == NULL) - path = local_path = notmuch_database_default_path (); + if (path == NULL) { + fprintf (stderr, "Error: Cannot create a database for a NULL path.\n"); + goto DONE; + } err = stat (path, &st); if (err) { @@ -442,29 +553,37 @@ notmuch_database_create (const char *path) goto DONE; } - notmuch = notmuch_database_open (path); + notmuch = notmuch_database_open (path, + NOTMUCH_DATABASE_MODE_READ_WRITE); + notmuch_database_upgrade (notmuch, NULL, NULL); DONE: if (notmuch_path) talloc_free (notmuch_path); - if (local_path) - free (local_path); return notmuch; } +notmuch_status_t +_notmuch_database_ensure_writable (notmuch_database_t *notmuch) +{ + if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY) { + fprintf (stderr, "Cannot write to a read-only database.\n"); + return NOTMUCH_STATUS_READ_ONLY_DATABASE; + } + + return NOTMUCH_STATUS_SUCCESS; +} + notmuch_database_t * -notmuch_database_open (const char *path) +notmuch_database_open (const char *path, + notmuch_database_mode_t mode) { notmuch_database_t *notmuch = NULL; char *notmuch_path = NULL, *xapian_path = NULL; struct stat st; int err; - char *local_path = NULL; - unsigned int i; - - if (path == NULL) - path = local_path = notmuch_database_default_path (); + unsigned int i, version; if (asprintf (¬much_path, "%s/%s", path, ".notmuch") == -1) { notmuch_path = NULL; @@ -486,22 +605,77 @@ notmuch_database_open (const char *path) } notmuch = talloc (NULL, notmuch_database_t); + notmuch->exception_reported = FALSE; notmuch->path = talloc_strdup (notmuch, path); if (notmuch->path[strlen (notmuch->path) - 1] == '/') notmuch->path[strlen (notmuch->path) - 1] = '\0'; + notmuch->needs_upgrade = FALSE; + notmuch->mode = mode; + notmuch->atomic_nesting = 0; try { - notmuch->xapian_db = new Xapian::WritableDatabase (xapian_path, - Xapian::DB_CREATE_OR_OPEN); + string last_thread_id; + + if (mode == NOTMUCH_DATABASE_MODE_READ_WRITE) { + notmuch->xapian_db = new Xapian::WritableDatabase (xapian_path, + Xapian::DB_CREATE_OR_OPEN); + version = notmuch_database_get_version (notmuch); + + if (version > NOTMUCH_DATABASE_VERSION) { + fprintf (stderr, + "Error: Notmuch database at %s\n" + " has a newer database format version (%u) than supported by this\n" + " version of notmuch (%u). Refusing to open this database in\n" + " read-write mode.\n", + notmuch_path, version, NOTMUCH_DATABASE_VERSION); + notmuch->mode = NOTMUCH_DATABASE_MODE_READ_ONLY; + notmuch_database_close (notmuch); + notmuch = NULL; + goto DONE; + } + + if (version < NOTMUCH_DATABASE_VERSION) + notmuch->needs_upgrade = TRUE; + } else { + notmuch->xapian_db = new Xapian::Database (xapian_path); + version = notmuch_database_get_version (notmuch); + if (version > NOTMUCH_DATABASE_VERSION) + { + fprintf (stderr, + "Warning: Notmuch database at %s\n" + " has a newer database format version (%u) than supported by this\n" + " version of notmuch (%u). Some operations may behave incorrectly,\n" + " (but the database will not be harmed since it is being opened\n" + " in read-only mode).\n", + notmuch_path, version, NOTMUCH_DATABASE_VERSION); + } + } + + 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); + } + 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::NumberValueRangeProcessor (NOTMUCH_VALUE_TIMESTAMP); notmuch->query_parser->set_default_op (Xapian::Query::OP_AND); notmuch->query_parser->set_database (*notmuch->xapian_db); notmuch->query_parser->set_stemmer (Xapian::Stem ("english")); notmuch->query_parser->set_stemming_strategy (Xapian::QueryParser::STEM_SOME); + notmuch->query_parser->add_valuerangeprocessor (notmuch->value_range_processor); for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) { prefix_t *prefix = &BOOLEAN_PREFIX_EXTERNAL[i]; @@ -514,14 +688,12 @@ notmuch_database_open (const char *path) notmuch->query_parser->add_prefix (prefix->name, prefix->prefix); } } catch (const Xapian::Error &error) { - fprintf (stderr, "A Xapian exception occurred: %s\n", + fprintf (stderr, "A Xapian exception occurred opening database: %s\n", error.get_msg().c_str()); notmuch = NULL; } - + DONE: - if (local_path) - free (local_path); if (notmuch_path) free (notmuch_path); if (xapian_path) @@ -533,11 +705,20 @@ notmuch_database_open (const char *path) void notmuch_database_close (notmuch_database_t *notmuch) { - notmuch->xapian_db->flush (); + try { + if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_WRITE) + (static_cast (notmuch->xapian_db))->flush (); + } catch (const Xapian::Error &error) { + if (! notmuch->exception_reported) { + fprintf (stderr, "Error: A Xapian exception occurred flushing database: %s\n", + error.get_msg().c_str()); + } + } delete notmuch->term_gen; delete notmuch->query_parser; delete notmuch->xapian_db; + delete notmuch->value_range_processor; talloc_free (notmuch); } @@ -547,109 +728,596 @@ notmuch_database_get_path (notmuch_database_t *notmuch) return notmuch->path; } -static notmuch_private_status_t -find_timestamp_document (notmuch_database_t *notmuch, const char *db_key, - Xapian::Document *doc, unsigned int *doc_id) +unsigned int +notmuch_database_get_version (notmuch_database_t *notmuch) +{ + unsigned int version; + string version_string; + const char *str; + char *end; + + version_string = notmuch->xapian_db->get_metadata ("version"); + if (version_string.empty ()) + return 0; + + str = version_string.c_str (); + if (str == NULL || *str == '\0') + return 0; + + version = strtoul (str, &end, 10); + if (*end != '\0') + INTERNAL_ERROR ("Malformed database version: %s", str); + + return version; +} + +notmuch_bool_t +notmuch_database_needs_upgrade (notmuch_database_t *notmuch) +{ + return notmuch->needs_upgrade; +} + +static volatile sig_atomic_t do_progress_notify = 0; + +static void +handle_sigalrm (unused (int signal)) { - return find_unique_document (notmuch, "timestamp", db_key, doc, doc_id); + do_progress_notify = 1; } -/* We allow the user to use arbitrarily long keys for timestamps, - * (they're for filesystem paths after all, which have no limit we - * know about). But we have a term-length limit. So if we exceed that, - * we'll use the SHA-1 of the user's key as the actual key for - * constructing a database term. +/* Upgrade the current database. + * + * After opening a database in read-write mode, the client should + * check if an upgrade is needed (notmuch_database_needs_upgrade) and + * if so, upgrade with this function before making any modifications. * - * Caution: This function returns a newly allocated string which the - * caller should free() when finished. + * The optional progress_notify callback can be used by the caller to + * provide progress indication to the user. If non-NULL it will be + * called periodically with 'count' as the number of messages upgraded + * so far and 'total' the overall number of messages that will be + * converted. */ -static char * -timestamp_db_key (const char *key) +notmuch_status_t +notmuch_database_upgrade (notmuch_database_t *notmuch, + void (*progress_notify) (void *closure, + double progress), + void *closure) { - int term_len = strlen (_find_prefix ("timestamp")) + strlen (key); + Xapian::WritableDatabase *db; + struct sigaction action; + struct itimerval timerval; + notmuch_bool_t timer_is_active = FALSE; + unsigned int version; + notmuch_status_t status; + unsigned int count = 0, total = 0; + + status = _notmuch_database_ensure_writable (notmuch); + if (status) + return status; + + db = static_cast (notmuch->xapian_db); + + version = notmuch_database_get_version (notmuch); + + if (version >= NOTMUCH_DATABASE_VERSION) + return NOTMUCH_STATUS_SUCCESS; + + if (progress_notify) { + /* Setup our handler for SIGALRM */ + memset (&action, 0, sizeof (struct sigaction)); + action.sa_handler = handle_sigalrm; + sigemptyset (&action.sa_mask); + action.sa_flags = SA_RESTART; + sigaction (SIGALRM, &action, NULL); + + /* Then start a timer to send SIGALRM once per second. */ + timerval.it_interval.tv_sec = 1; + timerval.it_interval.tv_usec = 0; + timerval.it_value.tv_sec = 1; + timerval.it_value.tv_usec = 0; + setitimer (ITIMER_REAL, &timerval, NULL); + + timer_is_active = TRUE; + } + + /* Before version 1, each message document had its filename in the + * data field. Copy that into the new format by calling + * notmuch_message_add_filename. + */ + if (version < 1) { + notmuch_query_t *query = notmuch_query_create (notmuch, ""); + notmuch_messages_t *messages; + notmuch_message_t *message; + char *filename; + Xapian::TermIterator t, t_end; + + total = notmuch_query_count_messages (query); + + for (messages = notmuch_query_search_messages (query); + notmuch_messages_valid (messages); + notmuch_messages_move_to_next (messages)) + { + if (do_progress_notify) { + progress_notify (closure, (double) count / total); + do_progress_notify = 0; + } + + message = notmuch_messages_get (messages); + + filename = _notmuch_message_talloc_copy_data (message); + if (filename && *filename != '\0') { + _notmuch_message_add_filename (message, filename); + _notmuch_message_sync (message); + } + talloc_free (filename); + + notmuch_message_destroy (message); + + count++; + } + + notmuch_query_destroy (query); + + /* Also, before version 1 we stored directory timestamps in + * XTIMESTAMP documents instead of the current XDIRECTORY + * documents. So copy those as well. */ + + t_end = notmuch->xapian_db->allterms_end ("XTIMESTAMP"); + + for (t = notmuch->xapian_db->allterms_begin ("XTIMESTAMP"); + t != t_end; + t++) + { + Xapian::PostingIterator p, p_end; + std::string term = *t; + + p_end = notmuch->xapian_db->postlist_end (term); + + for (p = notmuch->xapian_db->postlist_begin (term); + p != p_end; + p++) + { + Xapian::Document document; + time_t mtime; + notmuch_directory_t *directory; + + if (do_progress_notify) { + progress_notify (closure, (double) count / total); + do_progress_notify = 0; + } + + document = find_document_for_doc_id (notmuch, *p); + mtime = Xapian::sortable_unserialise ( + document.get_value (NOTMUCH_VALUE_TIMESTAMP)); + + directory = notmuch_database_get_directory (notmuch, + term.c_str() + 10); + notmuch_directory_set_mtime (directory, mtime); + notmuch_directory_destroy (directory); + } + } + } + + db->set_metadata ("version", STRINGIFY (NOTMUCH_DATABASE_VERSION)); + db->flush (); + + /* Now that the upgrade is complete we can remove the old data + * and documents that are no longer needed. */ + if (version < 1) { + notmuch_query_t *query = notmuch_query_create (notmuch, ""); + notmuch_messages_t *messages; + notmuch_message_t *message; + char *filename; + + for (messages = notmuch_query_search_messages (query); + notmuch_messages_valid (messages); + notmuch_messages_move_to_next (messages)) + { + if (do_progress_notify) { + progress_notify (closure, (double) count / total); + do_progress_notify = 0; + } + + message = notmuch_messages_get (messages); + + filename = _notmuch_message_talloc_copy_data (message); + if (filename && *filename != '\0') { + _notmuch_message_clear_data (message); + _notmuch_message_sync (message); + } + talloc_free (filename); + + notmuch_message_destroy (message); + } + + notmuch_query_destroy (query); + } + + if (version < 1) { + Xapian::TermIterator t, t_end; + + t_end = notmuch->xapian_db->allterms_end ("XTIMESTAMP"); + + for (t = notmuch->xapian_db->allterms_begin ("XTIMESTAMP"); + t != t_end; + t++) + { + Xapian::PostingIterator p, p_end; + std::string term = *t; + + p_end = notmuch->xapian_db->postlist_end (term); + + for (p = notmuch->xapian_db->postlist_begin (term); + p != p_end; + p++) + { + if (do_progress_notify) { + progress_notify (closure, (double) count / total); + do_progress_notify = 0; + } + + db->delete_document (*p); + } + } + } + + if (timer_is_active) { + /* Now stop the timer. */ + timerval.it_interval.tv_sec = 0; + timerval.it_interval.tv_usec = 0; + timerval.it_value.tv_sec = 0; + timerval.it_value.tv_usec = 0; + setitimer (ITIMER_REAL, &timerval, NULL); + + /* And disable the signal handler. */ + action.sa_handler = SIG_IGN; + sigaction (SIGALRM, &action, NULL); + } + + return NOTMUCH_STATUS_SUCCESS; +} + +notmuch_status_t +notmuch_database_begin_atomic (notmuch_database_t *notmuch) +{ + if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY || + notmuch->atomic_nesting > 0) + goto DONE; + + try { + (static_cast (notmuch->xapian_db))->begin_transaction (false); + } catch (const Xapian::Error &error) { + fprintf (stderr, "A Xapian exception occurred beginning transaction: %s.\n", + error.get_msg().c_str()); + notmuch->exception_reported = TRUE; + return NOTMUCH_STATUS_XAPIAN_EXCEPTION; + } + +DONE: + notmuch->atomic_nesting++; + return NOTMUCH_STATUS_SUCCESS; +} + +notmuch_status_t +notmuch_database_end_atomic (notmuch_database_t *notmuch) +{ + Xapian::WritableDatabase *db; + + if (notmuch->atomic_nesting == 0) + return NOTMUCH_STATUS_UNBALANCED_ATOMIC; + + if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY || + notmuch->atomic_nesting > 1) + goto DONE; + + db = static_cast (notmuch->xapian_db); + try { + db->commit_transaction (); + + /* This is a hack for testing. Xapian never flushes on a + * non-flushed commit, even if the flush threshold is 1. + * However, we rely on flushing to test atomicity. */ + const char *thresh = getenv ("XAPIAN_FLUSH_THRESHOLD"); + if (thresh && atoi (thresh) == 1) + db->commit (); + } catch (const Xapian::Error &error) { + fprintf (stderr, "A Xapian exception occurred committing transaction: %s.\n", + error.get_msg().c_str()); + notmuch->exception_reported = TRUE; + return NOTMUCH_STATUS_XAPIAN_EXCEPTION; + } + +DONE: + notmuch->atomic_nesting--; + return NOTMUCH_STATUS_SUCCESS; +} + +/* We allow the user to use arbitrarily long paths for directories. But + * we have a term-length limit. So if we exceed that, we'll use the + * SHA-1 of the path for the database term. + * + * Note: This function may return the original value of 'path'. If it + * does not, then the caller is responsible to free() the returned + * value. + */ +const char * +_notmuch_database_get_directory_db_path (const char *path) +{ + int term_len = strlen (_find_prefix ("directory")) + strlen (path); if (term_len > NOTMUCH_TERM_MAX) - return notmuch_sha1_of_string (key); + return notmuch_sha1_of_string (path); else - return strdup (key); + return path; } +/* Given a path, split it into two parts: the directory part is all + * components except for the last, and the basename is that last + * component. Getting the return-value for either part is optional + * (the caller can pass NULL). + * + * The original 'path' can represent either a regular file or a + * directory---the splitting will be carried out in the same way in + * either case. Trailing slashes on 'path' will be ignored, and any + * cases of multiple '/' characters appearing in series will be + * treated as a single '/'. + * + * Allocation (if any) will have 'ctx' as the talloc owner. But + * pointers will be returned within the original path string whenever + * possible. + * + * Note: If 'path' is non-empty and contains no non-trailing slash, + * (that is, consists of a filename with no parent directory), then + * the directory returned will be an empty string. However, if 'path' + * is an empty string, then both directory and basename will be + * returned as NULL. + */ notmuch_status_t -notmuch_database_set_timestamp (notmuch_database_t *notmuch, - const char *key, time_t timestamp) +_notmuch_database_split_path (void *ctx, + const char *path, + const char **directory, + const char **basename) { - Xapian::Document doc; - unsigned int doc_id; - notmuch_private_status_t status; - notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS; - char *db_key = NULL; + const char *slash; + + if (path == NULL || *path == '\0') { + if (directory) + *directory = NULL; + if (basename) + *basename = NULL; + return NOTMUCH_STATUS_SUCCESS; + } - db_key = timestamp_db_key (key); + /* Find the last slash (not counting a trailing slash), if any. */ - try { - status = find_timestamp_document (notmuch, db_key, &doc, &doc_id); + slash = path + strlen (path) - 1; - doc.add_value (NOTMUCH_VALUE_TIMESTAMP, - Xapian::sortable_serialise (timestamp)); + /* First, skip trailing slashes. */ + while (slash != path) { + if (*slash != '/') + break; - if (status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) { - char *term = talloc_asprintf (NULL, "%s%s", - _find_prefix ("timestamp"), db_key); - doc.add_term (term); - talloc_free (term); + --slash; + } - notmuch->xapian_db->add_document (doc); - } else { - notmuch->xapian_db->replace_document (doc_id, doc); + /* Then, find a slash. */ + while (slash != path) { + if (*slash == '/') + break; + + if (basename) + *basename = slash; + + --slash; + } + + /* Finally, skip multiple slashes. */ + while (slash != path) { + if (*slash != '/') + break; + + --slash; + } + + if (slash == path) { + if (directory) + *directory = talloc_strdup (ctx, ""); + if (basename) + *basename = path; + } else { + if (directory) + *directory = talloc_strndup (ctx, path, slash - path + 1); + } + + return NOTMUCH_STATUS_SUCCESS; +} + +notmuch_status_t +_notmuch_database_find_directory_id (notmuch_database_t *notmuch, + const char *path, + unsigned int *directory_id) +{ + notmuch_directory_t *directory; + notmuch_status_t status; + + if (path == NULL) { + *directory_id = 0; + return NOTMUCH_STATUS_SUCCESS; + } + + directory = _notmuch_directory_create (notmuch, path, &status); + if (status) { + *directory_id = -1; + return status; + } + + *directory_id = _notmuch_directory_get_document_id (directory); + + notmuch_directory_destroy (directory); + + return NOTMUCH_STATUS_SUCCESS; +} + +const char * +_notmuch_database_get_directory_path (void *ctx, + notmuch_database_t *notmuch, + unsigned int doc_id) +{ + Xapian::Document document; + + document = find_document_for_doc_id (notmuch, doc_id); + + return talloc_strdup (ctx, document.get_data ().c_str ()); +} + +/* Given a legal 'filename' for the database, (either relative to + * database path or absolute with initial components identical to + * database path), return a new string (with 'ctx' as the talloc + * owner) suitable for use as a direntry term value. + * + * The necessary directory documents will be created in the database + * as needed. + */ +notmuch_status_t +_notmuch_database_filename_to_direntry (void *ctx, + notmuch_database_t *notmuch, + const char *filename, + char **direntry) +{ + const char *relative, *directory, *basename; + Xapian::docid directory_id; + notmuch_status_t status; + + relative = _notmuch_database_relative_path (notmuch, filename); + + status = _notmuch_database_split_path (ctx, relative, + &directory, &basename); + if (status) + return status; + + status = _notmuch_database_find_directory_id (notmuch, directory, + &directory_id); + if (status) + return status; + + *direntry = talloc_asprintf (ctx, "%u:%s", directory_id, basename); + + return NOTMUCH_STATUS_SUCCESS; +} + +/* Given a legal 'path' for the database, return the relative path. + * + * The return value will be a pointer to the original path contents, + * and will be either the original string (if 'path' was relative) or + * a portion of the string (if path was absolute and begins with the + * database path). + */ +const char * +_notmuch_database_relative_path (notmuch_database_t *notmuch, + const char *path) +{ + const char *db_path, *relative; + unsigned int db_path_len; + + db_path = notmuch_database_get_path (notmuch); + db_path_len = strlen (db_path); + + relative = path; + + if (*relative == '/') { + while (*relative == '/' && *(relative+1) == '/') + relative++; + + if (strncmp (relative, db_path, db_path_len) == 0) + { + relative += db_path_len; + while (*relative == '/') + relative++; } + } - } catch (Xapian::Error &error) { - fprintf (stderr, "A Xapian exception occurred: %s.\n", + return relative; +} + +notmuch_directory_t * +notmuch_database_get_directory (notmuch_database_t *notmuch, + const char *path) +{ + notmuch_status_t status; + + try { + return _notmuch_directory_create (notmuch, path, &status); + } catch (const Xapian::Error &error) { + fprintf (stderr, "A Xapian exception occurred getting directory: %s.\n", error.get_msg().c_str()); - ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION; + notmuch->exception_reported = TRUE; + return NULL; } +} - if (db_key) - free (db_key); +/* Allocate a document ID that satisfies the following criteria: + * + * 1. The ID does not exist for any document in the Xapian database + * + * 2. The ID was not previously returned from this function + * + * 3. The ID is the smallest integer satisfying (1) and (2) + * + * This function will trigger an internal error if these constraints + * cannot all be satisfied, (that is, the pool of available document + * IDs has been exhausted). + */ +unsigned int +_notmuch_database_generate_doc_id (notmuch_database_t *notmuch) +{ + assert (notmuch->last_doc_id >= notmuch->xapian_db->get_lastdocid ()); - return ret; + notmuch->last_doc_id++; + + if (notmuch->last_doc_id == 0) + INTERNAL_ERROR ("Xapian document IDs are exhausted.\n"); + + return notmuch->last_doc_id; } -time_t -notmuch_database_get_timestamp (notmuch_database_t *notmuch, const char *key) +static const char * +_notmuch_database_generate_thread_id (notmuch_database_t *notmuch) { - Xapian::Document doc; - unsigned int doc_id; - notmuch_private_status_t status; - char *db_key = NULL; - time_t ret = 0; + /* 16 bytes (+ terminator) for hexadecimal representation of + * a 64-bit integer. */ + static char thread_id[17]; + Xapian::WritableDatabase *db; - db_key = timestamp_db_key (key); + db = static_cast (notmuch->xapian_db); - try { - status = find_timestamp_document (notmuch, db_key, &doc, &doc_id); + notmuch->last_thread_id++; - if (status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) - goto DONE; + sprintf (thread_id, "%016" PRIx64, notmuch->last_thread_id); - ret = Xapian::sortable_unserialise (doc.get_value (NOTMUCH_VALUE_TIMESTAMP)); - } catch (Xapian::Error &error) { - goto DONE; - } + db->set_metadata ("last_thread_id", thread_id); - DONE: - if (db_key) - free (db_key); + return thread_id; +} - return ret; +static char * +_get_metadata_thread_id_key (void *ctx, const char *message_id) +{ + if (strlen (message_id) > NOTMUCH_MESSAGE_ID_MAX) + message_id = _message_id_compressed (ctx, message_id); + + return talloc_asprintf (ctx, NOTMUCH_METADATA_THREAD_ID_PREFIX "%s", + message_id); } /* Find the thread ID to which the message with 'message_id' belongs. * - * Returns NULL if no message with message ID 'message_id' is in the - * database. + * Always returns a newly talloced string belonging to 'ctx'. * - * Otherwise, returns a newly talloced string belonging to 'ctx'. + * Note: If there is no message in the database with the given + * 'message_id' then a new thread_id will be allocated for this + * message and stored in the database metadata, (where this same + * thread ID can be looked up if the message is added to the database + * later). */ static const char * _resolve_message_id_to_thread_id (notmuch_database_t *notmuch, @@ -657,19 +1325,41 @@ _resolve_message_id_to_thread_id (notmuch_database_t *notmuch, const char *message_id) { notmuch_message_t *message; - const char *ret = NULL; + string thread_id_string; + const char *thread_id; + char *metadata_key; + Xapian::WritableDatabase *db; message = notmuch_database_find_message (notmuch, message_id); - if (message == NULL) - goto DONE; - ret = talloc_steal (ctx, notmuch_message_get_thread_id (message)); + if (message) { + thread_id = talloc_steal (ctx, notmuch_message_get_thread_id (message)); - DONE: - if (message) notmuch_message_destroy (message); - return ret; + return thread_id; + } + + /* Message has not been seen yet. + * + * We may have seen a reference to it already, in which case, we + * can return the thread ID stored in the metadata. Otherwise, we + * generate a new thread ID and store it there. + */ + db = static_cast (notmuch->xapian_db); + metadata_key = _get_metadata_thread_id_key (ctx, message_id); + thread_id_string = notmuch->xapian_db->get_metadata (metadata_key); + + if (thread_id_string.empty()) { + thread_id = _notmuch_database_generate_thread_id (notmuch); + db->set_metadata (metadata_key, thread_id); + } else { + thread_id = thread_id_string.c_str(); + } + + talloc_free (metadata_key); + + return talloc_strdup (ctx, thread_id); } static notmuch_status_t @@ -721,7 +1411,7 @@ _notmuch_database_link_message_to_parents (notmuch_database_t *notmuch, const char **thread_id) { GHashTable *parents = NULL; - const char *refs, *in_reply_to; + const char *refs, *in_reply_to, *in_reply_to_message_id; GList *l, *keys = NULL; notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS; @@ -729,12 +1419,22 @@ _notmuch_database_link_message_to_parents (notmuch_database_t *notmuch, _my_talloc_free_for_g_hash, NULL); refs = notmuch_message_file_get_header (message_file, "references"); - parse_references (message, parents, refs); + parse_references (message, notmuch_message_get_message_id (message), + parents, refs); in_reply_to = notmuch_message_file_get_header (message_file, "in-reply-to"); - parse_references (message, parents, in_reply_to); - _notmuch_message_add_term (message, "replyto", - parse_message_id (message, in_reply_to, NULL)); + parse_references (message, notmuch_message_get_message_id (message), + parents, in_reply_to); + + /* Carefully avoid adding any self-referential in-reply-to term. */ + in_reply_to_message_id = _parse_message_id (message, in_reply_to, NULL); + if (in_reply_to_message_id && + strcmp (in_reply_to_message_id, + notmuch_message_get_message_id (message))) + { + _notmuch_message_add_term (message, "replyto", + _parse_message_id (message, in_reply_to, NULL)); + } keys = g_hash_table_get_keys (parents); for (l = keys; l; l = l->next) { @@ -742,21 +1442,21 @@ _notmuch_database_link_message_to_parents (notmuch_database_t *notmuch, const char *parent_thread_id; parent_message_id = (char *) l->data; + + _notmuch_message_add_term (message, "reference", + parent_message_id); + parent_thread_id = _resolve_message_id_to_thread_id (notmuch, message, parent_message_id); - if (parent_thread_id == NULL) { - _notmuch_message_add_term (message, "ref", parent_message_id); - } else { - if (*thread_id == NULL) { - *thread_id = talloc_strdup (message, parent_thread_id); - _notmuch_message_add_term (message, "thread", *thread_id); - } else if (strcmp (*thread_id, parent_thread_id)) { - ret = _merge_threads (notmuch, *thread_id, parent_thread_id); - if (ret) - goto DONE; - } + if (*thread_id == NULL) { + *thread_id = talloc_strdup (message, parent_thread_id); + _notmuch_message_add_term (message, "thread", *thread_id); + } else if (strcmp (*thread_id, parent_thread_id)) { + ret = _merge_threads (notmuch, *thread_id, parent_thread_id); + if (ret) + goto DONE; } } @@ -781,7 +1481,7 @@ _notmuch_database_link_message_to_children (notmuch_database_t *notmuch, notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS; notmuch_private_status_t private_status; - find_doc_ids (notmuch, "ref", message_id, &child, &children_end); + find_doc_ids (notmuch, "reference", message_id, &child, &children_end); for ( ; child != children_end; child++) { @@ -798,7 +1498,7 @@ _notmuch_database_link_message_to_children (notmuch_database_t *notmuch, *thread_id = talloc_strdup (message, child_thread_id); _notmuch_message_add_term (message, "thread", *thread_id); } else if (strcmp (*thread_id, child_thread_id)) { - _notmuch_message_remove_term (child_message, "ref", + _notmuch_message_remove_term (child_message, "reference", message_id); _notmuch_message_sync (child_message); ret = _merge_threads (notmuch, *thread_id, child_thread_id); @@ -820,14 +1520,27 @@ _notmuch_database_link_message_to_children (notmuch_database_t *notmuch, /* Given a (mostly empty) 'message' and its corresponding * 'message_file' link it to existing threads in the database. * - * We first looke at 'message_file' and its link-relevant headers - * (References and In-Reply-To) for message IDs. We also look in the - * database for existing message that reference 'message'.p + * The first check is in the metadata of the database to see if we + * have pre-allocated a thread_id in advance for this message, (which + * would have happened if a message was previously added that + * referenced this one). + * + * Second, we look at 'message_file' and its link-relevant headers + * (References and In-Reply-To) for message IDs. + * + * Finally, we look in the database for existing message that + * reference 'message'. * - * The end result is to call _notmuch_message_add_thread_id with one - * or more thread IDs to which this message belongs, (including - * generating a new thread ID if necessary if the message doesn't - * connect to any existing threads). + * In all cases, we assign to the current message the first thread_id + * found (through either parent or child). We will also merge any + * existing, distinct threads where this message belongs to both, + * (which is not uncommon when messages are processed out of order). + * + * Finally, if no thread ID has been found through parent or child, we + * call _notmuch_message_generate_thread_id to generate a new thread + * ID. This should only happen for new, top-level messages, (no + * References or In-Reply-To header in this message, and no previously + * added message refers to this message). */ static notmuch_status_t _notmuch_database_link_message (notmuch_database_t *notmuch, @@ -835,7 +1548,30 @@ _notmuch_database_link_message (notmuch_database_t *notmuch, notmuch_message_file_t *message_file) { notmuch_status_t status; - const char *thread_id = NULL; + const char *message_id, *thread_id = NULL; + char *metadata_key; + string stored_id; + + message_id = notmuch_message_get_message_id (message); + metadata_key = _get_metadata_thread_id_key (message, message_id); + + /* Check if we have already seen related messages to this one. + * If we have then use the thread_id that we stored at that time. + */ + stored_id = notmuch->xapian_db->get_metadata (metadata_key); + if (! stored_id.empty()) { + Xapian::WritableDatabase *db; + + db = static_cast (notmuch->xapian_db); + + /* Clear the metadata for this message ID. We don't need it + * anymore. */ + db->set_metadata (metadata_key, ""); + thread_id = stored_id.c_str(); + + _notmuch_message_add_term (message, "thread", thread_id); + } + talloc_free (metadata_key); status = _notmuch_database_link_message_to_parents (notmuch, message, message_file, @@ -848,8 +1584,12 @@ _notmuch_database_link_message (notmuch_database_t *notmuch, if (status) return status; - if (thread_id == NULL) - _notmuch_message_ensure_thread_id (message); + /* If not part of any existing thread, generate a new thread ID. */ + if (thread_id == NULL) { + thread_id = _notmuch_database_generate_thread_id (notmuch); + + _notmuch_message_add_term (message, "thread", thread_id); + } return NOTMUCH_STATUS_SUCCESS; } @@ -866,16 +1606,18 @@ notmuch_database_add_message (notmuch_database_t *notmuch, const char *date, *header; const char *from, *to, *subject; - char *message_id; + char *message_id = NULL; if (message_ret) *message_ret = NULL; + ret = _notmuch_database_ensure_writable (notmuch); + if (ret) + return ret; + message_file = notmuch_message_file_open (filename); - if (message_file == NULL) { - ret = NOTMUCH_STATUS_FILE_ERROR; - goto DONE; - } + if (message_file == NULL) + return NOTMUCH_STATUS_FILE_ERROR; notmuch_message_file_restrict_headers (message_file, "date", @@ -897,9 +1639,9 @@ notmuch_database_add_message (notmuch_database_t *notmuch, subject = notmuch_message_file_get_header (message_file, "subject"); to = notmuch_message_file_get_header (message_file, "to"); - if (from == NULL && - subject == NULL && - to == NULL) + if ((from == NULL || *from == '\0') && + (subject == NULL || *subject == '\0') && + (to == NULL || *to == '\0')) { ret = NOTMUCH_STATUS_FILE_NOT_EMAIL; goto DONE; @@ -909,13 +1651,24 @@ notmuch_database_add_message (notmuch_database_t *notmuch, * is to find a message ID (or else create one ourselves). */ header = notmuch_message_file_get_header (message_file, "message-id"); - if (header) { - message_id = parse_message_id (message_file, header, NULL); + if (header && *header != '\0') { + message_id = _parse_message_id (message_file, header, NULL); + /* So the header value isn't RFC-compliant, but it's * better than no message-id at all. */ if (message_id == NULL) message_id = talloc_strdup (message_file, header); - } else { + + /* If a message ID is too long, substitute its sha1 instead. */ + if (message_id && strlen (message_id) > NOTMUCH_MESSAGE_ID_MAX) { + char *compressed = _message_id_compressed (message_file, + message_id); + talloc_free (message_id); + message_id = compressed; + } + } + + if (message_id == NULL ) { /* No message-id at all, let's generate one by taking a * hash over the file's contents. */ char *sha1 = notmuch_sha1_of_file (filename); @@ -935,46 +1688,50 @@ notmuch_database_add_message (notmuch_database_t *notmuch, * (which may or may not reference an existing document in the * database). */ - /* Use NULL for owner since we want to free this locally. */ - message = _notmuch_message_create_for_message_id (NULL, - notmuch, + message = _notmuch_message_create_for_message_id (notmuch, message_id, &private_status); talloc_free (message_id); - if (message == NULL) + if (message == NULL) { + ret = COERCE_STATUS (private_status, + "Unexpected status value from _notmuch_message_create_for_message_id"); goto DONE; + } + + _notmuch_message_add_filename (message, filename); /* Is this a newly created message object? */ if (private_status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) { - _notmuch_message_set_filename (message, filename); _notmuch_message_add_term (message, "type", "mail"); - } else { - ret = NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID; - goto DONE; - } - ret = _notmuch_database_link_message (notmuch, message, message_file); - if (ret) - goto DONE; + ret = _notmuch_database_link_message (notmuch, message, + message_file); + if (ret) + goto DONE; - date = notmuch_message_file_get_header (message_file, "date"); - _notmuch_message_set_date (message, date); + date = notmuch_message_file_get_header (message_file, "date"); + _notmuch_message_set_date (message, date); - _notmuch_message_index_file (message, filename); + _notmuch_message_index_file (message, filename); + } else { + ret = NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID; + } _notmuch_message_sync (message); } catch (const Xapian::Error &error) { - fprintf (stderr, "A Xapian exception occurred: %s.\n", + fprintf (stderr, "A Xapian exception occurred adding message: %s.\n", error.get_msg().c_str()); + notmuch->exception_reported = TRUE; ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION; goto DONE; } DONE: if (message) { - if (ret == NOTMUCH_STATUS_SUCCESS && message_ret) + if ((ret == NOTMUCH_STATUS_SUCCESS || + ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) && message_ret) *message_ret = message; else notmuch_message_destroy (message); @@ -985,3 +1742,107 @@ notmuch_database_add_message (notmuch_database_t *notmuch, return ret; } + +notmuch_status_t +notmuch_database_remove_message (notmuch_database_t *notmuch, + const char *filename) +{ + notmuch_message_t *message = + notmuch_database_find_message_by_filename (notmuch, filename); + notmuch_status_t status = NOTMUCH_STATUS_SUCCESS; + + if (message) { + status = _notmuch_message_remove_filename (message, filename); + if (status == NOTMUCH_STATUS_SUCCESS) + _notmuch_message_delete (message); + else if (status == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) + _notmuch_message_sync (message); + } + + return status; +} + +notmuch_message_t * +notmuch_database_find_message_by_filename (notmuch_database_t *notmuch, + const char *filename) +{ + void *local; + const char *prefix = _find_prefix ("file-direntry"); + char *direntry, *term; + Xapian::PostingIterator i, end; + notmuch_message_t *message = NULL; + notmuch_status_t status; + + local = talloc_new (notmuch); + + try { + status = _notmuch_database_filename_to_direntry (local, notmuch, + filename, &direntry); + if (status) + return NULL; + + term = talloc_asprintf (local, "%s%s", prefix, direntry); + + find_doc_ids_for_term (notmuch, term, &i, &end); + + if (i != end) { + notmuch_private_status_t private_status; + + message = _notmuch_message_create (notmuch, notmuch, + *i, &private_status); + } + } catch (const Xapian::Error &error) { + fprintf (stderr, "Error: A Xapian exception occurred finding message by filename: %s\n", + error.get_msg().c_str()); + notmuch->exception_reported = TRUE; + message = NULL; + } + + talloc_free (local); + + return message; +} + +notmuch_string_list_t * +_notmuch_database_get_terms_with_prefix (void *ctx, Xapian::TermIterator &i, + Xapian::TermIterator &end, + const char *prefix) +{ + int prefix_len = strlen (prefix); + notmuch_string_list_t *list; + + list = _notmuch_string_list_create (ctx); + if (unlikely (list == NULL)) + return NULL; + + for (i.skip_to (prefix); i != end; i++) { + /* Terminate loop at first term without desired prefix. */ + if (strncmp ((*i).c_str (), prefix, prefix_len)) + break; + + _notmuch_string_list_append (list, (*i).c_str () + prefix_len); + } + + return list; +} + +notmuch_tags_t * +notmuch_database_get_all_tags (notmuch_database_t *db) +{ + Xapian::TermIterator i, end; + notmuch_string_list_t *tags; + + try { + i = db->xapian_db->allterms_begin(); + end = db->xapian_db->allterms_end(); + tags = _notmuch_database_get_terms_with_prefix (db, i, end, + _find_prefix ("tag")); + _notmuch_string_list_sort (tags); + return _notmuch_tags_create (db, tags); + } catch (const Xapian::Error &error) { + fprintf (stderr, "A Xapian exception occurred getting tags: %s.\n", + error.get_msg().c_str()); + db->exception_reported = TRUE; + return NULL; + } +}