X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=notmuch-new.c;h=f34d4676cbc95c724fbbe93901b80012ff172f2c;hp=21c9b6ac95abdb81d9983758ec3b5d7612783644;hb=28ce73848d98d8ee2b661733402e2c10b13418d5;hpb=3a9c3ec9e719f0e5adefe0ceafffeb34c7a3917e diff --git a/notmuch-new.c b/notmuch-new.c index 21c9b6ac..f34d4676 100644 --- a/notmuch-new.c +++ b/notmuch-new.c @@ -22,6 +22,16 @@ #include +typedef struct { + int output_is_a_tty; + int verbose; + + int total_files; + int processed_files; + int added_messages; + struct timeval tv_start; +} add_files_state_t; + static volatile sig_atomic_t do_add_files_print_progress = 0; static void @@ -111,20 +121,19 @@ is_maildir (struct dirent **entries, int count) /* Examine 'path' recursively as follows: * - * o Ask the filesystem for the mtime of 'path' (path_mtime) + * o Ask the filesystem for the mtime of 'path' (fs_mtime) * - * o Ask the database for its timestamp of 'path' (path_dbtime) + * o Ask the database for its timestamp of 'path' (db_mtime) * - * o If 'path_mtime' > 'path_dbtime' + * o For each sub-directory of path, recursively call into this + * same function. * - * o For each regular file in 'path' with mtime newer than the - * 'path_dbtime' call add_message to add the file to the - * database. + * o If 'fs_mtime' > 'db_mtime' * - * o For each sub-directory of path, recursively call into this - * same function. + * o For each regular file directly within 'path', call + * add_message to add the file to the database. * - * o Tell the database to update its time of 'path' to 'path_mtime' + * o Tell the database to update its time of 'path' to 'fs_mtime' * * The 'struct stat *st' must point to a structure that has already * been initialized for 'path' by calling stat(). @@ -132,42 +141,52 @@ is_maildir (struct dirent **entries, int count) static notmuch_status_t add_files_recursive (notmuch_database_t *notmuch, const char *path, - struct stat *st, add_files_state_t *state) { DIR *dir = NULL; struct dirent *entry = NULL; char *next = NULL; - time_t path_mtime, path_dbtime; + time_t fs_mtime, db_mtime; notmuch_status_t status, ret = NOTMUCH_STATUS_SUCCESS; notmuch_message_t *message = NULL; - struct dirent **namelist = NULL; - int num_entries; + struct dirent **fs_entries = NULL; + int i, num_fs_entries; + notmuch_directory_t *directory; + struct stat st; + + if (stat (path, &st)) { + fprintf (stderr, "Error reading directory %s: %s\n", + path, strerror (errno)); + return NOTMUCH_STATUS_FILE_ERROR; + } + + if (! S_ISDIR (st.st_mode)) { + fprintf (stderr, "Error: %s is not a directory.\n", path); + return NOTMUCH_STATUS_FILE_ERROR; + } - path_mtime = st->st_mtime; + fs_mtime = st.st_mtime; - path_dbtime = notmuch_database_get_timestamp (notmuch, path); - num_entries = scandir (path, &namelist, 0, ino_cmp); + directory = notmuch_database_get_directory (notmuch, path); + db_mtime = notmuch_directory_get_mtime (directory); - if (num_entries == -1) { + num_fs_entries = scandir (path, &fs_entries, 0, ino_cmp); + + if (num_fs_entries == -1) { fprintf (stderr, "Error opening directory %s: %s\n", path, strerror (errno)); ret = NOTMUCH_STATUS_FILE_ERROR; goto DONE; } - int i=0; - - while (!interrupted) { - if (i == num_entries) + /* First, recurse into all sub-directories. */ + for (i = 0; i < num_fs_entries; i++) { + if (interrupted) break; - entry= namelist[i++]; + entry = fs_entries[i]; - /* If this directory hasn't been modified since the last - * add_files, then we only need to look further for - * sub-directories. */ - if (path_mtime <= path_dbtime && entry->d_type == DT_REG) + if (entry->d_type != DT_DIR) continue; /* Ignore special directories to avoid infinite recursion. @@ -179,107 +198,105 @@ add_files_recursive (notmuch_database_t *notmuch, strcmp (entry->d_name, "..") == 0 || (entry->d_type == DT_DIR && (strcmp (entry->d_name, "tmp") == 0) && - is_maildir (namelist, num_entries)) || + is_maildir (fs_entries, num_fs_entries)) || strcmp (entry->d_name, ".notmuch") ==0) { continue; } next = talloc_asprintf (notmuch, "%s/%s", path, entry->d_name); + status = add_files_recursive (notmuch, next, state); + if (status && ret == NOTMUCH_STATUS_SUCCESS) + ret = status; + talloc_free (next); + next = NULL; + } - if (stat (next, st)) { - int err = errno; + /* If this directory hasn't been modified since the last + * add_files, then we can skip the second pass where we look for + * new files in this directory. */ + if (fs_mtime <= db_mtime) + goto DONE; - switch (err) { - case ENOENT: - /* The file was removed between scandir and now... */ - case EPERM: - case EACCES: - /* We can't read this file so don't add it to the cache. */ - continue; - } + /* Second, scan the regular files in this directory. */ + for (i = 0; i < num_fs_entries; i++) { + if (interrupted) + break; + + entry = fs_entries[i]; + + if (entry->d_type != DT_REG) + continue; - fprintf (stderr, "Error reading %s: %s\n", - next, strerror (errno)); - ret = NOTMUCH_STATUS_FILE_ERROR; + next = talloc_asprintf (notmuch, "%s/%s", path, entry->d_name); + + state->processed_files++; + + if (state->verbose) { + if (state->output_is_a_tty) + printf("\r\033[K"); + + printf ("%i/%i: %s", + state->processed_files, + state->total_files, + next); + + putchar((state->output_is_a_tty) ? '\r' : '\n'); + fflush (stdout); + } + + status = notmuch_database_add_message (notmuch, next, &message); + switch (status) { + /* success */ + case NOTMUCH_STATUS_SUCCESS: + state->added_messages++; + tag_inbox_and_unread (message); + break; + /* Non-fatal issues (go on to next file) */ + case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID: + /* Stay silent on this one. */ + break; + case NOTMUCH_STATUS_FILE_NOT_EMAIL: + fprintf (stderr, "Note: Ignoring non-mail file: %s\n", + next); + break; + /* Fatal issues. Don't process anymore. */ + case NOTMUCH_STATUS_READONLY_DATABASE: + case NOTMUCH_STATUS_XAPIAN_EXCEPTION: + case NOTMUCH_STATUS_OUT_OF_MEMORY: + fprintf (stderr, "Error: %s. Halting processing.\n", + notmuch_status_to_string (status)); + ret = status; + goto DONE; + default: + case NOTMUCH_STATUS_FILE_ERROR: + case NOTMUCH_STATUS_NULL_POINTER: + case NOTMUCH_STATUS_TAG_TOO_LONG: + case NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW: + case NOTMUCH_STATUS_LAST_STATUS: + INTERNAL_ERROR ("add_message returned unexpected value: %d", status); goto DONE; } - if (S_ISREG (st->st_mode)) { - /* If the file hasn't been modified since the last - * add_files, then we need not look at it. */ - if (path_dbtime == 0 || st->st_mtime > path_dbtime) { - state->processed_files++; - - if (state->verbose) { - if (state->output_is_a_tty) - printf("\r\033[K"); - - printf ("%i/%i: %s", - state->processed_files, - state->total_files, - next); - - putchar((state->output_is_a_tty) ? '\r' : '\n'); - fflush (stdout); - } - - status = notmuch_database_add_message (notmuch, next, &message); - switch (status) { - /* success */ - case NOTMUCH_STATUS_SUCCESS: - state->added_messages++; - tag_inbox_and_unread (message); - break; - /* Non-fatal issues (go on to next file) */ - case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID: - /* Stay silent on this one. */ - break; - case NOTMUCH_STATUS_FILE_NOT_EMAIL: - fprintf (stderr, "Note: Ignoring non-mail file: %s\n", - next); - break; - /* Fatal issues. Don't process anymore. */ - case NOTMUCH_STATUS_READONLY_DATABASE: - case NOTMUCH_STATUS_XAPIAN_EXCEPTION: - case NOTMUCH_STATUS_OUT_OF_MEMORY: - fprintf (stderr, "Error: %s. Halting processing.\n", - notmuch_status_to_string (status)); - ret = status; - goto DONE; - default: - case NOTMUCH_STATUS_FILE_ERROR: - case NOTMUCH_STATUS_NULL_POINTER: - case NOTMUCH_STATUS_TAG_TOO_LONG: - case NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW: - case NOTMUCH_STATUS_LAST_STATUS: - INTERNAL_ERROR ("add_message returned unexpected value: %d", status); - goto DONE; - } - - if (message) { - notmuch_message_destroy (message); - message = NULL; - } - - if (do_add_files_print_progress) { - do_add_files_print_progress = 0; - add_files_print_progress (state); - } - } - } else if (S_ISDIR (st->st_mode)) { - status = add_files_recursive (notmuch, next, st, state); - if (status && ret == NOTMUCH_STATUS_SUCCESS) - ret = status; + if (message) { + notmuch_message_destroy (message); + message = NULL; + } + + if (do_add_files_print_progress) { + do_add_files_print_progress = 0; + add_files_print_progress (state); } talloc_free (next); next = NULL; } - status = notmuch_database_set_timestamp (notmuch, path, path_mtime); - if (status && ret == NOTMUCH_STATUS_SUCCESS) - ret = status; + if (! interrupted) { + status = notmuch_directory_set_mtime (directory, fs_mtime); + if (status && ret == NOTMUCH_STATUS_SUCCESS) + ret = status; + } DONE: if (next) @@ -288,8 +305,8 @@ add_files_recursive (notmuch_database_t *notmuch, free (entry); if (dir) closedir (dir); - if (namelist) - free (namelist); + if (fs_entries) + free (fs_entries); return ret; } @@ -297,28 +314,16 @@ add_files_recursive (notmuch_database_t *notmuch, /* This is the top-level entry point for add_files. It does a couple * of error checks, sets up the progress-printing timer and then calls * into the recursive function. */ -notmuch_status_t +static notmuch_status_t add_files (notmuch_database_t *notmuch, const char *path, add_files_state_t *state) { - struct stat st; notmuch_status_t status; struct sigaction action; struct itimerval timerval; notmuch_bool_t timer_is_active = FALSE; - if (stat (path, &st)) { - fprintf (stderr, "Error reading directory %s: %s\n", - path, strerror (errno)); - return NOTMUCH_STATUS_FILE_ERROR; - } - - if (! S_ISDIR (st.st_mode)) { - fprintf (stderr, "Error: %s is not a directory.\n", path); - return NOTMUCH_STATUS_FILE_ERROR; - } - if (state->output_is_a_tty && ! debugger_is_active () && ! state->verbose) { /* Setup our handler for SIGALRM */ memset (&action, 0, sizeof (struct sigaction)); @@ -337,7 +342,7 @@ add_files (notmuch_database_t *notmuch, timer_is_active = TRUE; } - status = add_files_recursive (notmuch, path, &st, state); + status = add_files_recursive (notmuch, path, state); if (timer_is_active) { /* Now stop the timer. */ @@ -367,21 +372,21 @@ count_files (const char *path, int *count) struct dirent *entry = NULL; char *next; struct stat st; - struct dirent **namelist = NULL; - int n_entries = scandir (path, &namelist, 0, ino_cmp); + struct dirent **fs_entries = NULL; + int num_fs_entries = scandir (path, &fs_entries, 0, ino_cmp); int i = 0; - if (n_entries == -1) { + if (num_fs_entries == -1) { fprintf (stderr, "Warning: failed to open directory %s: %s\n", path, strerror (errno)); goto DONE; } while (!interrupted) { - if (i == n_entries) + if (i == num_fs_entries) break; - entry= namelist[i++]; + entry = fs_entries[i++]; /* Ignore special directories to avoid infinite recursion. * Also ignore the .notmuch directory. @@ -420,8 +425,8 @@ count_files (const char *path, int *count) DONE: if (entry) free (entry); - if (namelist) - free (namelist); + if (fs_entries) + free (fs_entries); } int