notmuch_filenames_t *db_files = NULL;
notmuch_filenames_t *db_subdirs = NULL;
struct stat st;
- notmuch_bool_t is_maildir;
+ notmuch_bool_t is_maildir, new_directory;
if (stat (path, &st)) {
fprintf (stderr, "Error reading directory %s: %s\n",
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;
- }
+ /* 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
+ * that until this stat. */
+ if (! S_ISDIR (st.st_mode))
+ return NOTMUCH_STATUS_SUCCESS;
fs_mtime = st.st_mtime;
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);
+ }
+
/* If the database knows about this directory, then we sort based
* on strcmp to match the database sorting. Otherwise, we can do
* inode-based sorting for faster filesystem operation. */
num_fs_entries = scandir (path, &fs_entries, 0,
- db_mtime ?
- dirent_sort_strcmp_name : dirent_sort_inode);
+ new_directory ?
+ dirent_sort_inode : dirent_sort_strcmp_name);
if (num_fs_entries == -1) {
fprintf (stderr, "Error opening directory %s: %s\n",
entry = fs_entries[i];
- if (entry->d_type != DT_DIR)
+ if (entry->d_type != DT_DIR && entry->d_type != DT_LNK)
continue;
/* Ignore special directories to avoid infinite recursion.
goto DONE;
/* Pass 2: Scan for new files, removed files, and removed directories. */
- db_files = notmuch_directory_get_child_files (directory);
- db_subdirs = notmuch_directory_get_child_directories (directory);
-
for (i = 0; i < num_fs_entries; i++)
{
if (interrupted)
notmuch_filenames_advance (db_subdirs);
}
- if (entry->d_type != DT_REG)
+ /* 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). */
+ if (entry->d_type == DT_LNK) {
+ int err;
+
+ next = talloc_asprintf (notmuch, "%s/%s", path, entry->d_name);
+ err = stat (next, &st);
+ talloc_free (next);
+ next = NULL;
+
+ /* Don't emit an error for a link pointing nowhere, since
+ * the directory-traversal pass will have already done
+ * that. */
+ if (err)
+ continue;
+
+ if (! S_ISREG (st.st_mode))
+ continue;
+ } else if (entry->d_type != DT_REG) {
continue;
+ }
/* Don't add a file that we've added before. */
if (notmuch_filenames_has_more (db_files) &&
continue;
}
- /* We're not looking at a regular file that doesn't yet exist
+ /* We're now looking at a regular file that doesn't yet exist
* in the database, so add it. */
next = talloc_asprintf (notmuch, "%s/%s", path, entry->d_name);
next);
break;
/* Fatal issues. Don't process anymore. */
- case NOTMUCH_STATUS_READONLY_DATABASE:
+ case NOTMUCH_STATUS_READ_ONLY_DATABASE:
case NOTMUCH_STATUS_XAPIAN_EXCEPTION:
case NOTMUCH_STATUS_OUT_OF_MEMORY:
fprintf (stderr, "Error: %s. Halting processing.\n",
next = NULL;
}
+ /* Now that we've walked the whole filesystem list, anything left
+ * over in the database lists has been deleted. */
+ while (notmuch_filenames_has_more (db_files))
+ {
+ char *absolute = talloc_asprintf (state->removed_files,
+ "%s/%s", path,
+ notmuch_filenames_get (db_files));
+
+ _filename_list_add (state->removed_files, absolute);
+
+ notmuch_filenames_advance (db_files);
+ }
+
+ while (notmuch_filenames_has_more (db_subdirs))
+ {
+ char *absolute = talloc_asprintf (state->removed_directories,
+ "%s/%s", path,
+ notmuch_filenames_get (db_subdirs));
+
+ _filename_list_add (state->removed_directories, absolute);
+
+ notmuch_filenames_advance (db_subdirs);
+ }
+
if (! interrupted) {
status = notmuch_directory_set_mtime (directory, fs_mtime);
if (status && ret == NOTMUCH_STATUS_SUCCESS)
struct sigaction action;
struct itimerval timerval;
notmuch_bool_t timer_is_active = FALSE;
+ struct stat st;
if (state->output_is_a_tty && ! debugger_is_active () && ! state->verbose) {
/* Setup our handler for SIGALRM */
timer_is_active = TRUE;
}
+ 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;
+ }
+
status = add_files_recursive (notmuch, path, state);
if (timer_is_active) {
free (fs_entries);
}
+static void
+upgrade_print_progress (void *closure,
+ unsigned int count,
+ unsigned int total)
+{
+ add_files_state_t *state = closure;
+ struct timeval tv_now;
+ double elapsed_overall, rate_overall, time_remaining;
+
+ gettimeofday (&tv_now, NULL);
+
+ elapsed_overall = notmuch_time_elapsed (state->tv_start, tv_now);
+ rate_overall = count / elapsed_overall;
+ time_remaining = ((total - count) / rate_overall);
+
+ printf ("Upgraded %d of %d messages (", count, total);
+ notmuch_time_print_formatted_seconds (time_remaining);
+ printf (" remaining). \r");
+
+ fflush (stdout);
+}
+
+/* Recursively remove all filenames from the database referring to
+ * 'path' (or to any of its children). */
+static void
+_remove_directory (void *ctx,
+ notmuch_database_t *notmuch,
+ const char *path,
+ int *renamed_files,
+ int *removed_files)
+{
+ notmuch_directory_t *directory;
+ notmuch_filenames_t *files, *subdirs;
+ notmuch_status_t status;
+ char *absolute;
+
+ directory = notmuch_database_get_directory (notmuch, path);
+
+ for (files = notmuch_directory_get_child_files (directory);
+ notmuch_filenames_has_more (files);
+ notmuch_filenames_advance (files))
+ {
+ 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;
+ talloc_free (absolute);
+ }
+
+ for (subdirs = notmuch_directory_get_child_directories (directory);
+ notmuch_filenames_has_more (subdirs);
+ notmuch_filenames_advance (subdirs))
+ {
+ absolute = talloc_asprintf (ctx, "%s/%s", path,
+ notmuch_filenames_get (subdirs));
+ _remove_directory (ctx, notmuch, absolute, renamed_files, removed_files);
+ talloc_free (absolute);
+ }
+
+ notmuch_directory_destroy (directory);
+}
+
int
notmuch_new_command (void *ctx, int argc, char *argv[])
{
} else {
notmuch = notmuch_database_open (db_path,
NOTMUCH_DATABASE_MODE_READ_WRITE);
+ if (notmuch == NULL)
+ return 1;
+
+ if (notmuch_database_needs_upgrade (notmuch)) {
+ printf ("Welcome to a new version of notmuch! Your database will now be upgraded.\n");
+ gettimeofday (&add_files_state.tv_start, NULL);
+ notmuch_database_upgrade (notmuch, upgrade_print_progress,
+ &add_files_state);
+ printf ("Your notmuch database has now been upgraded to database format version %u.\n",
+ notmuch_database_get_version (notmuch));
+ }
+
add_files_state.total_files = 0;
}
}
for (f = add_files_state.removed_directories->head; f; f = f->next) {
- notmuch_directory_t *directory;
- notmuch_filenames_t *files;
-
- directory = notmuch_database_get_directory (notmuch, f->filename);
-
- for (files = notmuch_directory_get_child_files (directory);
- notmuch_filenames_has_more (files);
- notmuch_filenames_advance (files))
- {
- char *absolute;
-
- absolute = talloc_asprintf (ctx, "%s/%s", f->filename,
- notmuch_filenames_get (files));
- status = notmuch_database_remove_message (notmuch, absolute);
- if (status == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID)
- renamed_files++;
- else
- removed_files++;
- talloc_free (absolute);
- }
-
- notmuch_directory_destroy (directory);
+ _remove_directory (ctx, notmuch, f->filename,
+ &renamed_files, &removed_files);
}
talloc_free (add_files_state.removed_files);
projects / notmuch / blobdiff