dsync: Small code cleanup.

diff --git a/src/doveadm/dsync/doveadm-dsync.c b/src/doveadm/dsync/doveadm-dsync.c
index 73cfe6026e1bad6429b301c91dc59d04ef02488e..895ff46d0894c19ceaf41a41585d24972f8235af 100644 (file)
--- a/src/doveadm/dsync/doveadm-dsync.c
+++ b/src/doveadm/dsync/doveadm-dsync.c
@@ -486,16 +486,22 @@ cmd_dsync_run(struct doveadm_mail_cmd_context *_ctx, struct mail_user *user)
        struct dsync_cmd_context *ctx = (struct dsync_cmd_context *)_ctx;
        struct dsync_ibc *ibc, *ibc2 = NULL;
        struct dsync_brain *brain;
-       struct mail_namespace *sync_ns = NULL;
+       struct dsync_brain_settings set;
        enum dsync_brain_flags brain_flags;
        bool remote_errors_logged = FALSE;
        int status = 0, ret = 0;
 
+       memset(&set, 0, sizeof(set));
+       set.sync_box = ctx->mailbox;
+       memcpy(set.sync_box_guid, ctx->mailbox_guid, sizeof(set.sync_box_guid));
+       set.lock_timeout_secs = ctx->lock_timeout;
+       set.state = ctx->state_input;
+
        user->dsyncing = TRUE;
 
        if (ctx->namespace_prefix != NULL) {
-               sync_ns = mail_namespace_find(user->namespaces,
-                                             ctx->namespace_prefix);
+               set.sync_ns = mail_namespace_find(user->namespaces,
+                                                 ctx->namespace_prefix);
        }
 
        if (ctx->run_type == DSYNC_RUN_TYPE_LOCAL)
@@ -524,12 +530,9 @@ cmd_dsync_run(struct doveadm_mail_cmd_context *_ctx, struct mail_user *user)
                brain_flags |= DSYNC_BRAIN_FLAG_NO_MAIL_SYNC;
        if (doveadm_debug)
                brain_flags |= DSYNC_BRAIN_FLAG_DEBUG;
-       brain = dsync_brain_master_init(user, ibc, sync_ns, ctx->mailbox,
-                                       ctx->mailbox_guid,
-                                       ctx->sync_type, brain_flags,
-                                       ctx->lock_timeout,
-                                       ctx->state_input == NULL ? "" :
-                                       ctx->state_input);
+
+       brain = dsync_brain_master_init(user, ibc, ctx->sync_type,
+                                       brain_flags, &set);
 
        if (ctx->run_type == DSYNC_RUN_TYPE_LOCAL) {
                if (cmd_dsync_run_local(ctx, user, brain, ibc2) < 0)

diff --git a/src/doveadm/dsync/dsync-brain.c b/src/doveadm/dsync/dsync-brain.c
index f305520e2d4c9f46421380cb80dddac299bb32d7..ca48d22832bceb9f121cff180e4be6605b85545e 100644 (file)
--- a/src/doveadm/dsync/dsync-brain.c
+++ b/src/doveadm/dsync/dsync-brain.c
@@ -86,32 +86,32 @@ dsync_brain_set_flags(struct dsync_brain *brain, enum dsync_brain_flags flags)
 
 struct dsync_brain *
 dsync_brain_master_init(struct mail_user *user, struct dsync_ibc *ibc,
-                       struct mail_namespace *sync_ns, const char *sync_box,
-                       const guid_128_t sync_box_guid,
                        enum dsync_brain_sync_type sync_type,
-                       enum dsync_brain_flags flags, unsigned int lock_timeout,
-                       const char *state)
+                       enum dsync_brain_flags flags,
+                       const struct dsync_brain_settings *set)
 {
        struct dsync_ibc_settings ibc_set;
        struct dsync_brain *brain;
        const char *error;
 
        i_assert(sync_type != DSYNC_BRAIN_SYNC_TYPE_UNKNOWN);
-       i_assert(sync_type != DSYNC_BRAIN_SYNC_TYPE_STATE || *state != '\0');
+       i_assert(sync_type != DSYNC_BRAIN_SYNC_TYPE_STATE ||
+                (set->state != NULL && *set->state != '\0'));
 
        brain = dsync_brain_common_init(user, ibc);
        brain->sync_type = sync_type;
-       if (sync_ns != NULL)
-               brain->sync_ns = sync_ns;
-       brain->sync_box = p_strdup(brain->pool, sync_box);
-       memcpy(brain->sync_box_guid, sync_box_guid, sizeof(brain->sync_box_guid));
-       brain->lock_timeout = lock_timeout;
+       if (set->sync_ns != NULL)
+               brain->sync_ns = set->sync_ns;
+       brain->sync_box = p_strdup(brain->pool, set->sync_box);
+       memcpy(brain->sync_box_guid, set->sync_box_guid,
+              sizeof(brain->sync_box_guid));
+       brain->lock_timeout = set->lock_timeout_secs;
        brain->master_brain = TRUE;
        dsync_brain_set_flags(brain, flags);
 
        if (sync_type == DSYNC_BRAIN_SYNC_TYPE_STATE &&
            dsync_mailbox_states_import(brain->mailbox_states,
-                                       brain->pool, state, &error) < 0) {
+                                       brain->pool, set->state, &error) < 0) {
                hash_table_clear(brain->mailbox_states, FALSE);
                i_error("Saved sync state is invalid, "
                        "falling back to full sync: %s", error);
@@ -121,12 +121,13 @@ dsync_brain_master_init(struct mail_user *user, struct dsync_ibc *ibc,
 
        memset(&ibc_set, 0, sizeof(ibc_set));
        ibc_set.hostname = my_hostdomain();
-       ibc_set.sync_ns_prefix = sync_ns == NULL ? NULL : sync_ns->prefix;
-       ibc_set.sync_box = sync_box;
-       memcpy(ibc_set.sync_box_guid, sync_box_guid,
+       ibc_set.sync_ns_prefix = set->sync_ns == NULL ? NULL :
+               set->sync_ns->prefix;
+       ibc_set.sync_box = set->sync_box;
+       memcpy(ibc_set.sync_box_guid, set->sync_box_guid,
               sizeof(ibc_set.sync_box_guid));
        ibc_set.sync_type = sync_type;
-       ibc_set.lock_timeout = lock_timeout;
+       ibc_set.lock_timeout = set->lock_timeout_secs;
        /* reverse the backup direction for the slave */
        ibc_set.brain_flags = flags & ~(DSYNC_BRAIN_FLAG_BACKUP_SEND |
                                        DSYNC_BRAIN_FLAG_BACKUP_RECV);

diff --git a/src/doveadm/dsync/dsync-brain.h b/src/doveadm/dsync/dsync-brain.h
index 29bf4d2dcda3360cf8cb2feca4551337001aa8ff..ff0af27bada4235e51cdb1df9cf4b81a0f72c932 100644 (file)
--- a/src/doveadm/dsync/dsync-brain.h
+++ b/src/doveadm/dsync/dsync-brain.h
@@ -30,13 +30,25 @@ enum dsync_brain_sync_type {
        DSYNC_BRAIN_SYNC_TYPE_STATE
 };
 
+struct dsync_brain_settings {
+       /* Sync only this namespace */
+       struct mail_namespace *sync_ns;
+       /* Sync only this mailbox name */
+       const char *sync_box;
+       /* Sync only this mailbox GUID */
+       guid_128_t sync_box_guid;
+
+       /* If non-zero, use dsync lock file for this user */
+       unsigned int lock_timeout_secs;
+       /* Input state for DSYNC_BRAIN_SYNC_TYPE_STATE */
+       const char *state;
+};
+
 struct dsync_brain *
 dsync_brain_master_init(struct mail_user *user, struct dsync_ibc *ibc,
-                       struct mail_namespace *sync_ns, const char *sync_box,
-                       const guid_128_t sync_box_guid,
                        enum dsync_brain_sync_type sync_type,
-                       enum dsync_brain_flags flags, unsigned int lock_timeout,
-                       const char *state);
+                       enum dsync_brain_flags flags,
+                       const struct dsync_brain_settings *set);
 struct dsync_brain *
 dsync_brain_slave_init(struct mail_user *user, struct dsync_ibc *ibc);
 /* Returns 0 if everything was successful, -1 if syncing failed in some way */