Fix and improve dry run handling.

[dss.git] / dss.c

diff --git a/dss.c b/dss.c
index 665185f6f02e2e85b96c315cb9f274fab0aa0709..f65a29f37720d6dcb6c9ce44965c376d2afaafcf 100644 (file)
--- a/dss.c
+++ b/dss.c
@@ -22,10 +22,12 @@
 #include "error.h"
 #include "fd.h"
 #include "exec.h"
+#include "daemon.h"
 
 
 struct gengetopt_args_info conf;
 char *dss_error_txt = NULL;
+static FILE *logfile;
 
 DEFINE_DSS_ERRLIST;
 
@@ -36,11 +38,11 @@ DEFINE_DSS_ERRLIST;
        COMMAND(create) \
        COMMAND(prune) \
        COMMAND(run)
-#define COMMAND(x) int com_ ##x(int, char * const * const);
+#define COMMAND(x) int com_ ##x(void);
 COMMANDS
 #undef COMMAND
-#define COMMAND(x) if (conf.x ##_given) return com_ ##x(argc, argv);
-int call_command_handler(int argc, char * const * const argv)
+#define COMMAND(x) if (conf.x ##_given) return com_ ##x();
+int call_command_handler(void)
 {
        COMMANDS
        DSS_EMERG_LOG("BUG: did not find command handler\n");
@@ -68,6 +70,40 @@ struct snapshot {
        unsigned interval;
 };
 
+__printf_2_3 void dss_log(int ll, const char* fmt,...)
+{
+       va_list argp;
+       FILE *outfd;
+       struct tm *tm;
+       time_t t1;
+       char str[255] = "";
+
+       if (ll < conf.loglevel_arg)
+               return;
+       outfd = logfile? logfile : stderr;
+       time(&t1);
+       tm = localtime(&t1);
+       strftime(str, sizeof(str), "%b %d %H:%M:%S", tm);
+       fprintf(outfd, "%s ", str);
+       if (conf.loglevel_arg <= INFO)
+               fprintf(outfd, "%i: ", ll);
+       va_start(argp, fmt);
+       vfprintf(outfd, fmt, argp);
+       va_end(argp);
+}
+
+/**
+ * Print a message either to stdout or to the log file.
+ */
+__printf_1_2 void dss_msg(const char* fmt,...)
+{
+       FILE *outfd = conf.daemon_given? logfile : stdout;
+       va_list argp;
+       va_start(argp, fmt);
+       vfprintf(outfd, fmt, argp);
+       va_end(argp);
+}
+
 int is_snapshot(const char *dirname, int64_t now, struct snapshot *s)
 {
        int i, ret;
@@ -308,8 +344,7 @@ out:
        return ret;
 }
 
-int remove_redundant_snapshot(struct snapshot_list *sl,
-               int dry_run, pid_t *pid)
+int remove_redundant_snapshot(struct snapshot_list *sl, pid_t *pid)
 {
        int ret, i, interval;
        struct snapshot *s;
@@ -356,8 +391,8 @@ int remove_redundant_snapshot(struct snapshot_list *sl,
                        prev = s;
                }
                assert(victim);
-               if (dry_run) {
-                       printf("%s would be removed (interval = %i)\n",
+               if (conf.dry_run_given) {
+                       dss_msg("%s would be removed (interval = %i)\n",
                                victim->name, victim->interval);
                        continue;
                }
@@ -367,7 +402,7 @@ int remove_redundant_snapshot(struct snapshot_list *sl,
        return 0;
 }
 
-int remove_old_snapshot(struct snapshot_list *sl, int dry_run, pid_t *pid)
+int remove_old_snapshot(struct snapshot_list *sl, pid_t *pid)
 {
        int i, ret;
        struct snapshot *s;
@@ -377,8 +412,8 @@ int remove_old_snapshot(struct snapshot_list *sl, int dry_run, pid_t *pid)
        FOR_EACH_SNAPSHOT(s, i, sl) {
                if (s->interval <= conf.num_intervals_arg)
                        continue;
-               if (dry_run) {
-                       printf("%s would be removed (interval = %i)\n",
+               if (conf.dry_run_given) {
+                       dss_msg("%s would be removed (interval = %i)\n",
                                s->name, s->interval);
                        continue;
                }
@@ -409,31 +444,24 @@ int wait_for_rm_process(pid_t pid)
        return 1;
 }
 
-int com_run(int argc, char * const * argv)
+int com_run(void)
 {
+       if (conf.dry_run_given) {
+               make_err_msg("dry_run not supported by this command");
+               return -E_SYNTAX;
+       }
        return 42;
 }
 
-int com_prune(int argc, char * const * argv)
+int com_prune(void)
 {
-       int ret, dry_run = 0;
+       int ret;
        struct snapshot_list sl;
        pid_t pid;
 
-       if (argc > 2) {
-               make_err_msg("too many arguments");
-               return -E_SYNTAX;
-       }
-       if (argc == 2) {
-               if (strcmp(argv[1], "-d")) {
-                       make_err_msg("%s", argv[1]);
-                       return -E_SYNTAX;
-               }
-               dry_run = 1;
-       }
        for (;;) {
                get_snapshot_list(&sl);
-               ret = remove_old_snapshot(&sl, dry_run, &pid);
+               ret = remove_old_snapshot(&sl, &pid);
                free_snapshot_list(&sl);
                if (ret < 0)
                        return ret;
@@ -445,7 +473,7 @@ int com_prune(int argc, char * const * argv)
        }
        for (;;) {
                get_snapshot_list(&sl);
-               ret = remove_redundant_snapshot(&sl, dry_run, &pid);
+               ret = remove_redundant_snapshot(&sl, &pid);
                free_snapshot_list(&sl);
                if (ret < 0)
                        return ret;
@@ -561,19 +589,27 @@ int rename_incomplete_snapshot(int64_t start)
        return ret;
 }
 
-int com_create(int argc, __a_unused char * const * argv)
+int com_create(void)
 {
        int ret, status, es;
        char **rsync_argv;
        int64_t snapshot_num;
        pid_t pid;
 
-       if (argc != 1) {
-               ret = -E_SYNTAX;
-               make_err_msg("create: no args expected, %d given", argc - 1);
-               return ret;
-       }
        create_rsync_argv(&rsync_argv, &snapshot_num);
+       if (conf.dry_run_given) {
+               int i;
+               char *msg = NULL;
+               for (i = 0; rsync_argv[i]; i++) {
+                       char *tmp = msg;
+                       msg = make_message("%s%s%s", tmp? tmp : "",
+                               tmp? " " : "", rsync_argv[i]);
+                       free(tmp);
+               }
+               dss_msg("%s\n", msg);
+               free(msg);
+               return 1;
+       }
        DSS_NOTICE_LOG("creating snapshot %lli\n", (long long)snapshot_num);
        ret = create_snapshot(rsync_argv, &pid);
        if (ret < 0)
@@ -598,19 +634,14 @@ out:
        return ret;
 }
 
-int com_ls(int argc, __a_unused char * const * argv)
+int com_ls(void)
 {
-       int i, ret;
+       int i;
        struct snapshot_list sl;
        struct snapshot *s;
-       if (argc != 1) {
-               ret = -E_SYNTAX;
-               make_err_msg("ls: no args expected, %d given", argc - 1);
-               return ret;
-       }
        get_snapshot_list(&sl);
        FOR_EACH_SNAPSHOT(s, i, &sl)
-               printf("%u\t%s\n", s->interval, s->name);
+               dss_msg("%u\t%s\n", s->interval, s->name);
        free_snapshot_list(&sl);
        return 1;
 }
@@ -623,16 +654,6 @@ __noreturn void clean_exit(int status)
        exit(status);
 }
 
-__printf_2_3 void dss_log(int ll, const char* fmt,...)
-{
-       va_list argp;
-       if (ll < conf.loglevel_arg)
-               return;
-       va_start(argp, fmt);
-       vfprintf(stderr, fmt, argp);
-       va_end(argp);
-}
-
 int read_config_file(void)
 {
        int ret;
@@ -703,10 +724,16 @@ int main(int argc, char **argv)
        ret = check_config();
        if (ret < 0)
                goto out;
+       if (conf.logfile_given) {
+               logfile = open_log(conf.logfile_arg);
+               log_welcome(conf.loglevel_arg);
+       }
+       if (conf.daemon_given)
+               daemon_init();
        ret = dss_chdir(conf.dest_dir_arg);
        if (ret < 0)
                goto out;
-       ret = call_command_handler(conf.inputs_num, conf.inputs);
+       ret = call_command_handler();
 out:
        if (ret < 0)
                log_err_msg(EMERG, -ret);