X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=notmuch-new.c;h=2faf2f8e01029d4b933aa9041d3d7be7a5a40f6d;hp=941f9d615a44ce07521395db331a9c6b7d11b6c4;hb=d3b5533123293fdc1e4177f42018f085c03585c9;hpb=c58523088ac7fcbfa841187b1447269b638bfa95 diff --git a/notmuch-new.c b/notmuch-new.c index 941f9d61..2faf2f8e 100644 --- a/notmuch-new.c +++ b/notmuch-new.c @@ -24,6 +24,7 @@ typedef struct _filename_node { char *filename; + time_t mtime; struct _filename_node *next; } _filename_node_t; @@ -38,17 +39,19 @@ typedef struct { int verbose; const char **new_tags; size_t new_tags_length; + const char **new_ignore; + size_t new_ignore_length; int total_files; int processed_files; - int added_messages; + int added_messages, removed_messages, renamed_messages; struct timeval tv_start; _filename_list_t *removed_files; _filename_list_t *removed_directories; + _filename_list_t *directory_mtimes; notmuch_bool_t synchronize_flags; - _filename_list_t *message_ids_to_sync; } add_files_state_t; static volatile sig_atomic_t do_print_progress = 0; @@ -64,10 +67,13 @@ static volatile sig_atomic_t interrupted; static void handle_sigint (unused (int sig)) { - ssize_t ignored; static char msg[] = "Stopping... \n"; - ignored = write(2, msg, sizeof(msg)-1); + /* This write is "opportunistic", so it's okay to ignore the + * result. It is not required for correctness, and if it does + * fail or produce a short write, we want to get out of the signal + * handler as quickly as possible, not retry it. */ + IGNORE_RESULT (write (2, msg, sizeof(msg)-1)); interrupted = 1; } @@ -87,7 +93,7 @@ _filename_list_create (const void *ctx) return list; } -static void +static _filename_node_t * _filename_list_add (_filename_list_t *list, const char *filename) { @@ -100,6 +106,8 @@ _filename_list_add (_filename_list_t *list, *(list->tail) = node; list->tail = &node->next; + + return node; } static void @@ -175,6 +183,20 @@ _entries_resemble_maildir (struct dirent **entries, int count) return 0; } +/* Test if the file/directory is to be ignored. + */ +static notmuch_bool_t +_entry_in_ignore_list (const char *entry, add_files_state_t *state) +{ + size_t i; + + for (i = 0; i < state->new_ignore_length; i++) + if (strcmp (entry, state->new_ignore[i]) == 0) + return TRUE; + + return FALSE; +} + /* Examine 'path' recursively as follows: * * o Ask the filesystem for the mtime of 'path' (fs_mtime) @@ -182,15 +204,20 @@ _entries_resemble_maildir (struct dirent **entries, int count) * * o Ask the filesystem for files and directories within 'path' * (via scandir and stored in fs_entries) - * o Ask the database for files and directories within 'path' - * (db_files and db_subdirs) * * o Pass 1: For each directory in fs_entries, recursively call into * this same function. * - * o Pass 2: If 'fs_mtime' > 'db_mtime', then walk fs_entries - * simultaneously with db_files and db_subdirs. Look for one of - * three interesting cases: + * o Compare fs_mtime to db_mtime. If they are equivalent, terminate + * the algorithm at this point, (this directory has not been + * updated in the filesystem since the last database scan of PASS + * 2). + * + * o Ask the database for files and directories within 'path' + * (db_files and db_subdirs) + * + * o Pass 2: Walk fs_entries simultaneously with db_files and + * db_subdirs. Look for one of three interesting cases: * * 1. Regular file in fs_entries and not in db_files * This is a new file to add_message into the database. @@ -209,6 +236,7 @@ _entries_resemble_maildir (struct dirent **entries, int count) * information is lost from the database). * * o Tell the database to update its time of 'path' to 'fs_mtime' + * if fs_mtime isn't the current wall-clock time. */ static notmuch_status_t add_files_recursive (notmuch_database_t *notmuch, @@ -226,6 +254,7 @@ add_files_recursive (notmuch_database_t *notmuch, notmuch_directory_t *directory; notmuch_filenames_t *db_files = NULL; notmuch_filenames_t *db_subdirs = NULL; + time_t stat_time; struct stat st; notmuch_bool_t is_maildir, new_directory; const char **tag; @@ -235,6 +264,7 @@ add_files_recursive (notmuch_database_t *notmuch, path, strerror (errno)); return NOTMUCH_STATUS_FILE_ERROR; } + stat_time = time (NULL); /* This is not an error since we may have recursed based on a * symlink to a regular file, not a directory, and we don't know @@ -247,15 +277,26 @@ add_files_recursive (notmuch_database_t *notmuch, directory = notmuch_database_get_directory (notmuch, path); db_mtime = notmuch_directory_get_mtime (directory); - if (db_mtime == 0) { - new_directory = TRUE; - db_files = NULL; - db_subdirs = NULL; - } else { - new_directory = FALSE; - db_files = notmuch_directory_get_child_files (directory); - db_subdirs = notmuch_directory_get_child_directories (directory); - } + new_directory = db_mtime ? FALSE : TRUE; + + /* XXX This is a temporary workaround. If we don't update the + * database mtime until after processing messages in this + * directory, then a 0 mtime is *not* sufficient to indicate that + * this directory has no messages or subdirs in the database (for + * example, if an earlier run skipped the mtime update because + * fs_mtime == stat_time, or was interrupted before updating the + * mtime at the end). To address this, we record a (bogus) + * non-zero value before processing any child messages so that a + * later run won't mistake this for a new directory (and, for + * example, fail to detect removed files and subdirs). + * + * A better solution would be for notmuch_database_get_directory + * to indicate if it really created a new directory or not, either + * by a new out-argument, or by recording this information and + * providing an accessor. + */ + if (new_directory) + notmuch_directory_set_mtime (directory, -1); /* If the database knows about this directory, then we sort based * on strcmp to match the database sorting. Otherwise, we can do @@ -267,6 +308,10 @@ add_files_recursive (notmuch_database_t *notmuch, if (num_fs_entries == -1) { fprintf (stderr, "Error opening directory %s: %s\n", path, strerror (errno)); + /* We consider this a fatal error because, if a user moved a + * message from another directory that we were able to scan + * into this directory, skipping this directory will cause + * that message to be lost. */ ret = NOTMUCH_STATUS_FILE_ERROR; goto DONE; } @@ -295,23 +340,25 @@ add_files_recursive (notmuch_database_t *notmuch, } /* Ignore special directories to avoid infinite recursion. - * Also ignore the .notmuch directory and any "tmp" directory - * that appears within a maildir. + * Also ignore the .notmuch directory, any "tmp" directory + * that appears within a maildir and files/directories + * the user has configured to be ignored. */ - /* XXX: Eventually we'll want more sophistication to let the - * user specify files to be ignored. */ if (strcmp (entry->d_name, ".") == 0 || strcmp (entry->d_name, "..") == 0 || (is_maildir && strcmp (entry->d_name, "tmp") == 0) || - strcmp (entry->d_name, ".notmuch") ==0) + strcmp (entry->d_name, ".notmuch") == 0 || + _entry_in_ignore_list (entry->d_name, state)) { continue; } next = talloc_asprintf (notmuch, "%s/%s", path, entry->d_name); status = add_files_recursive (notmuch, next, state); - if (status && ret == NOTMUCH_STATUS_SUCCESS) + if (status) { ret = status; + goto DONE; + } talloc_free (next); next = NULL; } @@ -328,6 +375,14 @@ add_files_recursive (notmuch_database_t *notmuch, if (fs_mtime == db_mtime) goto DONE; + /* new_directory means a directory that the database has never + * seen before. In that case, we can simply leave db_files and + * db_subdirs NULL. */ + if (!new_directory) { + db_files = notmuch_directory_get_child_files (directory); + db_subdirs = notmuch_directory_get_child_directories (directory); + } + /* Pass 2: Scan for new files, removed files, and removed directories. */ for (i = 0; i < num_fs_entries; i++) { @@ -336,6 +391,10 @@ add_files_recursive (notmuch_database_t *notmuch, entry = fs_entries[i]; + /* Ignore files & directories user has configured to be ignored */ + if (_entry_in_ignore_list (entry->d_name, state)) + continue; + /* Check if we've walked past any names in db_files or * db_subdirs. If so, these have been deleted. */ while (notmuch_filenames_valid (db_files) && @@ -369,7 +428,7 @@ add_files_recursive (notmuch_database_t *notmuch, /* If we're looking at a symlink, we only want to add it if it * links to a regular file, (and not to a directory, say). * - * Similarly, if the file is of unknown type (due to filesytem + * Similarly, if the file is of unknown type (due to filesystem * limitations), then we also need to look closer. * * In either case, a stat does the trick. @@ -421,6 +480,12 @@ add_files_recursive (notmuch_database_t *notmuch, fflush (stdout); } + status = notmuch_database_begin_atomic (notmuch); + if (status) { + ret = status; + goto DONE; + } + status = notmuch_database_add_message (notmuch, next, &message); switch (status) { /* success */ @@ -435,11 +500,8 @@ add_files_recursive (notmuch_database_t *notmuch, break; /* Non-fatal issues (go on to next file) */ case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID: - /* Defer sync of maildir flags until after old filenames - * are removed in the case of a rename. */ if (state->synchronize_flags == TRUE) - _filename_list_add (state->message_ids_to_sync, - notmuch_message_get_message_id (message)); + notmuch_message_maildir_flags_to_tags (message); break; case NOTMUCH_STATUS_FILE_NOT_EMAIL: fprintf (stderr, "Note: Ignoring non-mail file: %s\n", @@ -458,11 +520,18 @@ add_files_recursive (notmuch_database_t *notmuch, case NOTMUCH_STATUS_NULL_POINTER: case NOTMUCH_STATUS_TAG_TOO_LONG: case NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW: + case NOTMUCH_STATUS_UNBALANCED_ATOMIC: case NOTMUCH_STATUS_LAST_STATUS: INTERNAL_ERROR ("add_message returned unexpected value: %d", status); goto DONE; } + status = notmuch_database_end_atomic (notmuch); + if (status) { + ret = status; + goto DONE; + } + if (message) { notmuch_message_destroy (message); message = NULL; @@ -505,21 +574,25 @@ add_files_recursive (notmuch_database_t *notmuch, notmuch_filenames_move_to_next (db_subdirs); } - if (! interrupted) { - status = notmuch_directory_set_mtime (directory, fs_mtime); - if (status && ret == NOTMUCH_STATUS_SUCCESS) - ret = status; - } + /* If the directory's mtime is the same as the wall-clock time + * when we stat'ed the directory, we skip updating the mtime in + * the database because a message could be delivered later in this + * same second. This may lead to unnecessary re-scans, but it + * avoids overlooking messages. */ + if (fs_mtime != stat_time) + _filename_list_add (state->directory_mtimes, path)->mtime = fs_mtime; DONE: if (next) talloc_free (next); - if (entry) - free (entry); if (dir) closedir (dir); - if (fs_entries) + if (fs_entries) { + for (i = 0; i < num_fs_entries; i++) + free (fs_entries[i]); + free (fs_entries); + } if (db_subdirs) notmuch_filenames_destroy (db_subdirs); if (db_files) @@ -603,7 +676,7 @@ add_files (notmuch_database_t *notmuch, * initialized to zero by the top-level caller before calling * count_files). */ static void -count_files (const char *path, int *count) +count_files (const char *path, int *count, add_files_state_t *state) { struct dirent *entry = NULL; char *next; @@ -625,13 +698,13 @@ count_files (const char *path, int *count) entry = fs_entries[i++]; /* Ignore special directories to avoid infinite recursion. - * Also ignore the .notmuch directory. + * Also ignore the .notmuch directory and files/directories + * the user has configured to be ignored. */ - /* XXX: Eventually we'll want more sophistication to let the - * user specify files to be ignored. */ if (strcmp (entry->d_name, ".") == 0 || strcmp (entry->d_name, "..") == 0 || - strcmp (entry->d_name, ".notmuch") == 0) + strcmp (entry->d_name, ".notmuch") == 0 || + _entry_in_ignore_list (entry->d_name, state)) { continue; } @@ -652,17 +725,19 @@ count_files (const char *path, int *count) fflush (stdout); } } else if (S_ISDIR (st.st_mode)) { - count_files (next, count); + count_files (next, count, state); } free (next); } DONE: - if (entry) - free (entry); - if (fs_entries) + if (fs_entries) { + for (i = 0; i < num_fs_entries; i++) + free (fs_entries[i]); + free (fs_entries); + } } static void @@ -691,18 +766,45 @@ upgrade_print_progress (void *closure, fflush (stdout); } +/* Remove one message filename from the database. */ +static notmuch_status_t +remove_filename (notmuch_database_t *notmuch, + const char *path, + add_files_state_t *add_files_state) +{ + notmuch_status_t status; + notmuch_message_t *message; + status = notmuch_database_begin_atomic (notmuch); + if (status) + return status; + status = notmuch_database_find_message_by_filename (notmuch, path, &message); + if (status || message == NULL) + return status; + status = notmuch_database_remove_message (notmuch, path); + if (status == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) { + add_files_state->renamed_messages++; + if (add_files_state->synchronize_flags == TRUE) + notmuch_message_maildir_flags_to_tags (message); + status = NOTMUCH_STATUS_SUCCESS; + } else if (status == NOTMUCH_STATUS_SUCCESS) { + add_files_state->removed_messages++; + } + notmuch_message_destroy (message); + notmuch_database_end_atomic (notmuch); + return status; +} + /* Recursively remove all filenames from the database referring to * 'path' (or to any of its children). */ -static void +static notmuch_status_t _remove_directory (void *ctx, notmuch_database_t *notmuch, const char *path, - int *renamed_files, - int *removed_files) + add_files_state_t *add_files_state) { + notmuch_status_t status = NOTMUCH_STATUS_SUCCESS; notmuch_directory_t *directory; notmuch_filenames_t *files, *subdirs; - notmuch_status_t status; char *absolute; directory = notmuch_database_get_directory (notmuch, path); @@ -713,12 +815,10 @@ _remove_directory (void *ctx, { absolute = talloc_asprintf (ctx, "%s/%s", path, notmuch_filenames_get (files)); - status = notmuch_database_remove_message (notmuch, absolute); - if (status == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) - *renamed_files = *renamed_files + 1; - else - *removed_files = *removed_files + 1; + status = remove_filename (notmuch, absolute, add_files_state); talloc_free (absolute); + if (status) + goto DONE; } for (subdirs = notmuch_directory_get_child_directories (directory); @@ -727,11 +827,15 @@ _remove_directory (void *ctx, { absolute = talloc_asprintf (ctx, "%s/%s", path, notmuch_filenames_get (subdirs)); - _remove_directory (ctx, notmuch, absolute, renamed_files, removed_files); + status = _remove_directory (ctx, notmuch, absolute, add_files_state); talloc_free (absolute); + if (status) + goto DONE; } + DONE: notmuch_directory_destroy (directory); + return status; } int @@ -748,17 +852,20 @@ notmuch_new_command (void *ctx, int argc, char *argv[]) char *dot_notmuch_path; struct sigaction action; _filename_node_t *f; - int renamed_files, removed_files; - notmuch_status_t status; int i; notmuch_bool_t timer_is_active = FALSE; + notmuch_bool_t run_hooks = TRUE; add_files_state.verbose = 0; add_files_state.output_is_a_tty = isatty (fileno (stdout)); + argc--; argv++; /* skip subcommand argument */ + for (i = 0; i < argc && argv[i][0] == '-'; i++) { if (STRNCMP_LITERAL (argv[i], "--verbose") == 0) { add_files_state.verbose = 1; + } else if (strcmp (argv[i], "--no-hooks") == 0) { + run_hooks = FALSE; } else { fprintf (stderr, "Unrecognized option: %s\n", argv[i]); return 1; @@ -769,17 +876,23 @@ notmuch_new_command (void *ctx, int argc, char *argv[]) return 1; add_files_state.new_tags = notmuch_config_get_new_tags (config, &add_files_state.new_tags_length); + add_files_state.new_ignore = notmuch_config_get_new_ignore (config, &add_files_state.new_ignore_length); add_files_state.synchronize_flags = notmuch_config_get_maildir_synchronize_flags (config); - add_files_state.message_ids_to_sync = _filename_list_create (ctx); db_path = notmuch_config_get_database_path (config); + if (run_hooks) { + ret = notmuch_run_hook (db_path, "pre-new"); + if (ret) + return ret; + } + dot_notmuch_path = talloc_asprintf (ctx, "%s/%s", db_path, ".notmuch"); if (stat (dot_notmuch_path, &st)) { int count; count = 0; - count_files (db_path, &count); + count_files (db_path, &count, &add_files_state); if (interrupted) return 1; @@ -821,10 +934,12 @@ notmuch_new_command (void *ctx, int argc, char *argv[]) add_files_state.processed_files = 0; add_files_state.added_messages = 0; + add_files_state.removed_messages = add_files_state.renamed_messages = 0; gettimeofday (&add_files_state.tv_start, NULL); add_files_state.removed_files = _filename_list_create (ctx); add_files_state.removed_directories = _filename_list_create (ctx); + add_files_state.directory_mtimes = _filename_list_create (ctx); if (! debugger_is_active () && add_files_state.output_is_a_tty && ! add_files_state.verbose) { @@ -833,28 +948,27 @@ notmuch_new_command (void *ctx, int argc, char *argv[]) } ret = add_files (notmuch, db_path, &add_files_state); + if (ret) + goto DONE; - removed_files = 0; - renamed_files = 0; gettimeofday (&tv_start, NULL); - for (f = add_files_state.removed_files->head; f; f = f->next) { - status = notmuch_database_remove_message (notmuch, f->filename); - if (status == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) - renamed_files++; - else - removed_files++; + for (f = add_files_state.removed_files->head; f && !interrupted; f = f->next) { + ret = remove_filename (notmuch, f->filename, &add_files_state); + if (ret) + goto DONE; if (do_print_progress) { do_print_progress = 0; generic_print_progress ("Cleaned up", "messages", - tv_start, removed_files + renamed_files, + tv_start, add_files_state.removed_messages + add_files_state.renamed_messages, add_files_state.removed_files->count); } } gettimeofday (&tv_start, NULL); - for (f = add_files_state.removed_directories->head, i = 0; f; f = f->next, i++) { - _remove_directory (ctx, notmuch, f->filename, - &renamed_files, &removed_files); + for (f = add_files_state.removed_directories->head, i = 0; f && !interrupted; f = f->next, i++) { + ret = _remove_directory (ctx, notmuch, f->filename, &add_files_state); + if (ret) + goto DONE; if (do_print_progress) { do_print_progress = 0; generic_print_progress ("Cleaned up", "directories", @@ -863,34 +977,19 @@ notmuch_new_command (void *ctx, int argc, char *argv[]) } } - talloc_free (add_files_state.removed_files); - talloc_free (add_files_state.removed_directories); - - /* Now that removals are done (hence the database is aware of all - * renames), we can synchronize maildir_flags to tags for all - * messages that had new filenames appear on this run. */ - gettimeofday (&tv_start, NULL); - if (add_files_state.synchronize_flags) { - _filename_node_t *node; - notmuch_message_t *message; - for (node = add_files_state.message_ids_to_sync->head, i = 0; - node; - node = node->next, i++) - { - message = notmuch_database_find_message (notmuch, node->filename); - notmuch_message_maildir_flags_to_tags (message); - notmuch_message_destroy (message); - if (do_print_progress) { - do_print_progress = 0; - generic_print_progress ( - "Synchronized tags for", "messages", - tv_start, i, add_files_state.message_ids_to_sync->count); - } + for (f = add_files_state.directory_mtimes->head; f && !interrupted; f = f->next) { + notmuch_directory_t *directory; + directory = notmuch_database_get_directory (notmuch, f->filename); + if (directory) { + notmuch_directory_set_mtime (directory, f->mtime); + notmuch_directory_destroy (directory); } } - talloc_free (add_files_state.message_ids_to_sync); - add_files_state.message_ids_to_sync = NULL; + DONE: + talloc_free (add_files_state.removed_files); + talloc_free (add_files_state.removed_directories); + talloc_free (add_files_state.directory_mtimes); if (timer_is_active) stop_progress_printing_timer (); @@ -921,26 +1020,28 @@ notmuch_new_command (void *ctx, int argc, char *argv[]) printf ("No new mail."); } - if (removed_files) { + if (add_files_state.removed_messages) { printf (" Removed %d %s.", - removed_files, - removed_files == 1 ? "message" : "messages"); + add_files_state.removed_messages, + add_files_state.removed_messages == 1 ? "message" : "messages"); } - if (renamed_files) { + if (add_files_state.renamed_messages) { printf (" Detected %d file %s.", - renamed_files, - renamed_files == 1 ? "rename" : "renames"); + add_files_state.renamed_messages, + add_files_state.renamed_messages == 1 ? "rename" : "renames"); } printf ("\n"); - if (ret) { - printf ("\nNote: At least one error was encountered: %s\n", + if (ret) + printf ("\nNote: A fatal error was encountered: %s\n", notmuch_status_to_string (ret)); - } notmuch_database_close (notmuch); + if (run_hooks && !ret && !interrupted) + ret = notmuch_run_hook (db_path, "post-new"); + return ret || interrupted; }