tools

mpd_update_library.c (5977B)

---

 #define _POSIX_C_SOURCE 200809L
 
 #include "mpd_common.h"
 
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 
 #define UPDATE_RETRIES 5U
 
 static void usage(FILE *file, const char *program) {
   fprintf(file, "Usage: %s [--no-wait] [--rescan] [FILE|-]\n", program);
 }
 
 static int compare_strings(const void *left, const void *right) {
   const char *const *a = left;
   const char *const *b = right;
   return strcmp(*a, *b);
 }
 
 static bool top_directories(const struct mt_strvec *paths,
                             struct mt_strvec *directories) {
   for (size_t i = 0; i < paths->len; i++) {
     const char *slash = strchr(paths->items[i], '/');
     size_t length = slash == NULL ? strlen(paths->items[i])
                                   : (size_t)(slash - paths->items[i]);
     if (!mt_strvec_push_n(directories, paths->items[i], length)) {
       perror("mpd: store update directory");
       return false;
     }
   }
 
   qsort(directories->items, directories->len, sizeof(*directories->items),
         compare_strings);
   size_t output = 0;
   for (size_t i = 0; i < directories->len; i++) {
     if (output > 0U &&
         strcmp(directories->items[output - 1U], directories->items[i]) == 0) {
       free(directories->items[i]);
     } else {
       directories->items[output++] = directories->items[i];
     }
   }
   directories->len = output;
   return true;
 }
 
 static void retry_delay(unsigned attempt) {
   unsigned milliseconds = 250U << attempt;
   if (milliseconds > 4000U)
     milliseconds = 4000U;
   struct timespec delay = {.tv_sec = (time_t)(milliseconds / 1000U),
                            .tv_nsec = (long)(milliseconds % 1000U) * 1000000L};
   while (nanosleep(&delay, &delay) < 0 && errno == EINTR) {
   }
 }
 
 static struct mpd_connection *reconnect(unsigned attempt) {
   if (attempt > 0U)
     retry_delay(attempt - 1U);
   return mt_connect();
 }
 
 static bool submit_directory(struct mpd_connection **connection,
                              const char *directory, bool rescan) {
   for (unsigned attempt = 0; attempt < UPDATE_RETRIES; attempt++) {
     if (*connection == NULL)
       *connection = reconnect(attempt);
     if (*connection == NULL)
       continue;
 
     unsigned id = rescan ? mpd_run_rescan(*connection, directory)
                          : mpd_run_update(*connection, directory);
     if (id != 0U) {
       printf("Submitted update for '%s' (job %u).\n", directory, id);
       return true;
     }
 
     enum mpd_error error = mpd_connection_get_error(*connection);
     mt_report_error(*connection, rescan ? "submit rescan" : "submit update");
     if (error == MPD_ERROR_SERVER || error == MPD_ERROR_ARGUMENT)
       return false;
     mpd_connection_free(*connection);
     *connection = NULL;
   }
   fprintf(stderr, "mpd: exhausted retries for '%s'\n", directory);
   return false;
 }
 
 static bool wait_for_updates(struct mpd_connection **connection) {
   for (unsigned failures = 0; failures < UPDATE_RETRIES;) {
     if (*connection == NULL)
       *connection = reconnect(failures);
     if (*connection == NULL) {
       failures++;
       continue;
     }
 
     struct mpd_status *status = mpd_run_status(*connection);
     if (status == NULL) {
       mt_report_error(*connection, "check update status");
       mpd_connection_free(*connection);
       *connection = NULL;
       failures++;
       continue;
     }
     unsigned update_id = mpd_status_get_update_id(status);
     mpd_status_free(status);
     if (update_id == 0U)
       return true;
 
     enum mpd_idle event = mpd_run_idle_mask(*connection, MPD_IDLE_UPDATE);
     if ((event & MPD_IDLE_UPDATE) != 0) {
       failures = 0;
       continue;
     }
     mt_report_error(*connection, "wait for database update");
     mpd_connection_free(*connection);
     *connection = NULL;
     failures++;
   }
   fprintf(stderr, "mpd: exhausted retries while waiting for updates\n");
   return false;
 }
 
 int main(int argc, char **argv) {
   bool wait = true;
   bool rescan = false;
   const char *path = NULL;
   for (int i = 1; i < argc; i++) {
     if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) {
       usage(stdout, argv[0]);
       return 0;
     }
     if (strcmp(argv[i], "--no-wait") == 0) {
       wait = false;
     } else if (strcmp(argv[i], "--rescan") == 0) {
       rescan = true;
     } else if (argv[i][0] == '-' && strcmp(argv[i], "-") != 0) {
       usage(stderr, argv[0]);
       return 2;
     } else if (path == NULL) {
       path = argv[i];
     } else {
       usage(stderr, argv[0]);
       return 2;
     }
   }
 
   struct mt_strvec paths;
   struct mt_strvec directories;
   mt_strvec_init(&paths);
   mt_strvec_init(&directories);
   bool ok = true;
 
   if (path == NULL && isatty(STDIN_FILENO)) {
     ok = mt_strvec_push(&directories, "");
   } else {
     bool close_input;
     FILE *input = mt_open_input(path, &close_input);
     if (input == NULL)
       ok = false;
     else {
       ok = mt_read_lines(input, &paths);
       if (close_input && fclose(input) != 0) {
         perror("mpd: close input");
         ok = false;
       }
       if (ok)
         ok = top_directories(&paths, &directories);
     }
   }
   if (!ok) {
     mt_strvec_clear(&paths);
     mt_strvec_clear(&directories);
     return 1;
   }
   if (directories.len == 0U) {
     printf("No directories found in input.\n");
     mt_strvec_clear(&paths);
     mt_strvec_clear(&directories);
     return 0;
   }
 
   struct mpd_connection *connection = NULL;
   for (size_t i = 0; i < directories.len; i++) {
     if (!submit_directory(&connection, directories.items[i], rescan)) {
       ok = false;
       break;
     }
   }
   if (ok && wait) {
     printf("Waiting for database updates to finish...\n");
     ok = wait_for_updates(&connection);
   }
   if (ok)
     printf("Processed %zu director%s successfully.\n", directories.len,
            directories.len == 1U ? "y" : "ies");
 
   if (connection != NULL)
     mpd_connection_free(connection);
   mt_strvec_clear(&paths);
   mt_strvec_clear(&directories);
   return ok ? 0 : 1;
 }