← Back to branch summary

~ubuntu-branches/ubuntu/wily/dovecot/wily

« back to all changes in this revision

Viewing changes to src/replication/replicator/replicator.c

  • Committer: Package Import Robot
  • Author(s): Jaldhar H. Vyas
  • Date: 2013-09-09 00:57:32 UTC
  • mfrom: (1.13.11)
  • mto: (4.8.5 experimental) (1.16.1)
  • mto: This revision was merged to the branch mainline in revision 97.
  • Revision ID: package-import@ubuntu.com-20130909005732-dn1eell8srqbhh0e
Tags: upstream-2.2.5
Import upstream version 2.2.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/replication/replicator/replicator.c
1
 
/* Copyright (c) 2012 Dovecot authors, see the included COPYING file */
 
1
/* Copyright (c) 2013 Dovecot authors, see the included COPYING file */
2
2
 
3
3
#include "lib.h"
4
4
#include "ioloop.h"
7
7
#include "master-service.h"
8
8
#include "master-service-settings.h"
9
9
#include "notify-connection.h"
 
10
#include "doveadm-connection.h"
10
11
#include "replicator-brain.h"
11
12
#include "replicator-queue.h"
12
13
#include "replicator-settings.h"
13
14
 
14
15
#define REPLICATOR_AUTH_SERVICE_NAME "replicator"
15
16
#define REPLICATOR_DB_DUMP_INTERVAL_MSECS (1000*60*15)
16
 
#define REPLICATOR_DB_PATH PKG_STATEDIR"/replicator.db"
 
17
/* if syncing fails, try again in 5 minutes */
 
18
#define REPLICATOR_FAILURE_RESYNC_INTERVAL_SECS (60*5)
 
19
#define REPLICATOR_DB_FNAME "replicator.db"
17
20
 
18
21
static struct replicator_queue *queue;
19
22
static struct replicator_brain *brain;
 
23
static const struct master_service_settings *service_set;
20
24
static const struct replicator_settings *set;
21
25
static struct timeout *to_dump;
22
26
 
23
27
static void client_connected(struct master_service_connection *conn)
24
28
{
25
29
        master_service_client_connection_accept(conn);
26
 
        (void)notify_connection_create(conn->fd, queue);
 
30
        if (strcmp(conn->name, "replicator-doveadm") == 0)
 
31
                doveadm_connection_create(queue, conn->fd);
 
32
        else
 
33
                (void)notify_connection_create(conn->fd, queue);
27
34
}
28
35
 
29
36
static void replication_add_users(struct replicator_queue *queue)
32
39
        struct auth_master_user_list_ctx *ctx;
33
40
        struct auth_user_info user_info;
34
41
        struct replicator_user *user;
35
 
        const char *username;
 
42
        const char *path, *username;
36
43
 
37
44
        auth_conn = auth_master_init(set->auth_socket_path,
38
45
                                     AUTH_MASTER_FLAG_NO_IDLE_TIMEOUT);
42
49
 
43
50
        /* add all users into replication queue, so that we can start doing
44
51
           full syncs for everyone whose state can't be found */
45
 
        ctx = auth_master_user_list_init(auth_conn, NULL, &user_info);
 
52
        ctx = auth_master_user_list_init(auth_conn, "", &user_info);
46
53
        while ((username = auth_master_user_list_next(ctx)) != NULL) {
47
54
                user = replicator_queue_add(queue, username,
48
55
                                            REPLICATION_PRIORITY_NONE);
53
60
        auth_master_deinit(&auth_conn);
54
61
 
55
62
        /* add updates from replicator db, if it exists */
56
 
        (void)replicator_queue_import(queue, REPLICATOR_DB_PATH);
 
63
        path = t_strconcat(service_set->state_dir, "/"REPLICATOR_DB_FNAME, NULL);
 
64
        (void)replicator_queue_import(queue, path);
57
65
}
58
66
 
59
 
static void replicator_dump_timeout(void *context ATTR_UNUSED)
 
67
static void ATTR_NULL(1)
 
68
replicator_dump_timeout(void *context ATTR_UNUSED)
60
69
{
61
 
        (void)replicator_queue_export(queue, REPLICATOR_DB_PATH);
 
70
        const char *path;
 
71
 
 
72
        path = t_strconcat(service_set->state_dir, "/"REPLICATOR_DB_FNAME, NULL);
 
73
        (void)replicator_queue_import(queue, path);
62
74
}
63
75
 
64
76
static void main_init(void)
65
77
{
66
78
        void **sets;
67
79
 
 
80
        service_set = master_service_settings_get(master_service);
68
81
        sets = master_service_settings_get_others(master_service);
69
82
        set = sets[0];
70
83
 
71
 
        queue = replicator_queue_init(set->replication_full_sync_interval);
 
84
        queue = replicator_queue_init(set->replication_full_sync_interval,
 
85
                                      REPLICATOR_FAILURE_RESYNC_INTERVAL_SECS);
72
86
        replication_add_users(queue);
73
87
        to_dump = timeout_add(REPLICATOR_DB_DUMP_INTERVAL_MSECS,
74
 
                              replicator_dump_timeout, NULL);
 
88
                              replicator_dump_timeout, (void *)NULL);
75
89
        brain = replicator_brain_init(queue, set);
 
90
        doveadm_connections_init();
76
91
}
77
92
 
78
93
static void main_deinit(void)
79
94
{
 
95
        const char *path;
 
96
 
 
97
        doveadm_connections_deinit();
80
98
        notify_connections_destroy_all();
81
99
        replicator_brain_deinit(&brain);
82
100
        timeout_remove(&to_dump);
83
 
        (void)replicator_queue_export(queue, REPLICATOR_DB_PATH);
 
101
        path = t_strconcat(service_set->state_dir, "/"REPLICATOR_DB_FNAME, NULL);
 
102
        (void)replicator_queue_export(queue, path);
84
103
        replicator_queue_deinit(&queue);
85
104
}
86
105
 
95
114
        const char *error;
96
115
 
97
116
        master_service = master_service_init("replicator", service_flags,
98
 
                                             &argc, &argv, NULL);
 
117
                                             &argc, &argv, "");
99
118
        if (master_getopt(master_service) > 0)
100
119
                return FATAL_DEFAULT;
101
120
 
106
125
 
107
126
        restrict_access_by_env(NULL, FALSE);
108
127
        restrict_access_allow_coredumps(TRUE);
 
128
 
 
129
        main_init();
109
130
        master_service_init_finish(master_service);
110
 
 
111
 
        main_init();
112
131
        master_service_run(master_service, client_connected);
113
132
        main_deinit();
114
133