static int
client_input_status(struct doveadm_connection *client, const char *const *args)
{
struct replicator_queue_iter *iter;
struct replicator_user *user;
const char *mask = args[0];
string_t *str = t_str_new(128);
if (mask == NULL)
return client_input_status_overview(client);
iter = replicator_queue_iter_init(client->queue);
while ((user = replicator_queue_iter_next(iter)) != NULL) {
if (!wildcard_match(user->username, mask))
continue;
str_truncate(str, 0);
str_append_tabescaped(str, user->username);
str_append_c(str, '\t');
str_append(str, replicator_priority_to_str(user->priority));
str_printfa(str, "\t%lld\t%lld\t%d\n",
(long long)user->last_fast_sync,
(long long)user->last_full_sync,
user->last_sync_failed);
o_stream_send(client->conn.output, str_data(str), str_len(str));
}
replicator_queue_iter_deinit(&iter);
o_stream_send(client->conn.output, "\n", 1);
return 0;
}
static int client_input_status_overview(struct doveadm_connection *client)
{
struct replicator_queue *queue =
replicator_brain_get_queue(client->brain);
struct replicator_queue_iter *iter;
struct replicator_user *user;
enum replication_priority priority;
unsigned int pending_counts[REPLICATION_PRIORITY_SYNC+1];
unsigned int user_count, next_secs, pending_failed_count;
unsigned int pending_full_resync_count, waiting_failed_count;
string_t *str = t_str_new(256);
memset(pending_counts, 0, sizeof(pending_counts));
pending_failed_count = 0; waiting_failed_count = 0;
pending_full_resync_count = 0;
user_count = 0;
iter = replicator_queue_iter_init(queue);
while ((user = replicator_queue_iter_next(iter)) != NULL) {
if (user->priority != REPLICATION_PRIORITY_NONE)
pending_counts[user->priority]++;
else if (replicator_queue_want_sync_now(queue, user, &next_secs)) {
if (user->last_sync_failed)
pending_failed_count++;
else
pending_full_resync_count++;
} else {
if (user->last_sync_failed)
waiting_failed_count++;
}
user_count++;
}
replicator_queue_iter_deinit(&iter);
for (priority = REPLICATION_PRIORITY_SYNC; priority > 0; priority--) {
str_printfa(str, "Queued '%s' requests\t%u\n",
replicator_priority_to_str(priority),
pending_counts[priority]);
}
str_printfa(str, "Queued 'failed' requests\t%u\n",
pending_failed_count);
str_printfa(str, "Queued 'full resync' requests\t%u\n",
pending_full_resync_count);
str_printfa(str, "Waiting 'failed' requests\t%u\n",
waiting_failed_count);
str_printfa(str, "Total number of known users\t%u\n", user_count);
str_append_c(str, '\n');
o_stream_send(client->conn.output, str_data(str), str_len(str));
return 0;
}
static int
client_input_replicate(struct doveadm_connection *client, const char *const *args)
{
struct replicator_queue_iter *iter;
struct replicator_user *user;
const char *usermask;
enum replication_priority priority;
unsigned int match_count;
/* <priority> <username>|<mask> */
if (str_array_length(args) != 2) {
i_error("%s: REPLICATE: Invalid parameters", client->conn.name);
return -1;
}
if (replication_priority_parse(args[0], &priority) < 0) {
o_stream_send_str(client->conn.output, "-Invalid priority\n");
return 0;
}
usermask = args[1];
if (strchr(usermask, '*') == NULL && strchr(usermask, '?') == NULL) {
replicator_queue_add(client->queue, usermask, priority);
o_stream_send_str(client->conn.output, "+1\n");
return 0;
}
match_count = 0;
iter = replicator_queue_iter_init(client->queue);
while ((user = replicator_queue_iter_next(iter)) != NULL) {
if (!wildcard_match(user->username, usermask))
continue;
replicator_queue_add(client->queue, user->username, priority);
match_count++;
}
replicator_queue_iter_deinit(&iter);
o_stream_send_str(client->conn.output,
t_strdup_printf("+%u\n", match_count));
return 0;
}