lib-dict: Use ioloop pointers in parent struct

diff --git a/src/lib-dict/dict-client.c b/src/lib-dict/dict-client.c
index 2439d93ea336f36780f6668ac18638e63beb8532..aeed69e5b1ab44ea7a29068e331022ccc6460b3b 100644 (file)
--- a/src/lib-dict/dict-client.c
+++ b/src/lib-dict/dict-client.c
@@ -79,7 +79,6 @@ struct client_dict {
        time_t last_failed_connect;
        char *last_connect_error;
 
-       struct ioloop *ioloop, *prev_ioloop;
        struct io_wait_timer *wait_timer;
        uint64_t last_timer_switch_usecs;
        struct timeout *to_requests;
@@ -170,30 +169,6 @@ static bool client_dict_cmd_unref(struct client_dict_cmd *cmd)
        return FALSE;
 }
 
-static void dict_client_stop_wait(struct client_dict *dict)
-{
-       if (dict->prev_ioloop != NULL) {
-               current_ioloop = dict->ioloop;
-               /* stop client_dict_wait() */
-               io_loop_stop(dict->ioloop);
-       }
-}
-
-static void dict_pre_api_callback(struct client_dict *dict)
-{
-       if (dict->prev_ioloop != NULL) {
-               /* Don't let callback see that we've created our
-                  internal ioloop in case it wants to add some ios
-                  or timeouts. */
-               current_ioloop = dict->prev_ioloop;
-       }
-}
-
-static void dict_post_api_callback(struct client_dict *dict)
-{
-       dict_client_stop_wait(dict);
-}
-
 static bool
 dict_cmd_callback_line(struct client_dict_cmd *cmd, const char *const *args)
 {
@@ -789,7 +764,7 @@ client_dict_init(struct dict *driver, const char *uri,
        connection_init_client_unix(dict_connections, &dict->conn.conn, path);
        dict->uri = i_strdup(dest_uri + 1);
 
-       dict->ioloop = io_loop_create();
+       dict->dict.ioloop = io_loop_create();
        dict->wait_timer = io_wait_timer_add();
        io_loop_set_current(old_ioloop);
        *dict_r = &dict->dict;
@@ -808,8 +783,8 @@ static void client_dict_deinit(struct dict *_dict)
        i_assert(dict->transactions == NULL);
        i_assert(array_count(&dict->cmds) == 0);
 
-       io_loop_set_current(dict->ioloop);
-       io_loop_destroy(&dict->ioloop);
+       io_loop_set_current(dict->dict.ioloop);
+       io_loop_destroy(&dict->dict.ioloop);
        io_loop_set_current(old_ioloop);
 
        array_free(&dict->cmds);
@@ -829,14 +804,14 @@ static void client_dict_wait(struct dict *_dict)
        if (array_count(&dict->cmds) == 0)
                return;
 
-       dict->prev_ioloop = current_ioloop;
-       io_loop_set_current(dict->ioloop);
+       dict->dict.prev_ioloop = current_ioloop;
+       io_loop_set_current(dict->dict.ioloop);
        dict_switch_ioloop(_dict);
        while (array_count(&dict->cmds) > 0)
-               io_loop_run(dict->ioloop);
+               io_loop_run(dict->dict.ioloop);
 
-       io_loop_set_current(dict->prev_ioloop);
-       dict->prev_ioloop = NULL;
+       io_loop_set_current(dict->dict.prev_ioloop);
+       dict->dict.prev_ioloop = NULL;
 
        dict_switch_ioloop(_dict);
 }
@@ -975,9 +950,9 @@ client_dict_lookup_async_callback(struct client_dict_cmd *cmd,
                          cmd->query);
        }
 
-       dict_pre_api_callback(dict);
+       dict_pre_api_callback(&dict->dict);
        cmd->api_callback.lookup(&result, cmd->api_callback.context);
-       dict_post_api_callback(dict);
+       dict_post_api_callback(&dict->dict);
 }
 
 static void
@@ -1064,7 +1039,7 @@ client_dict_iter_api_callback(struct client_dict_iterate_context *ctx,
        if (ctx->deinit) {
                /* Iterator was already deinitialized. Stop if we're in
                   client_dict_wait(). */
-               dict_client_stop_wait(dict);
+               dict_post_api_callback(&dict->dict);
                return;
        }
        if (ctx->finished) {
@@ -1083,12 +1058,12 @@ client_dict_iter_api_callback(struct client_dict_iterate_context *ctx,
                }
        }
        if (ctx->ctx.async_callback != NULL) {
-               dict_pre_api_callback(dict);
+               dict_pre_api_callback(&dict->dict);
                ctx->ctx.async_callback(ctx->ctx.async_context);
-               dict_post_api_callback(dict);
+               dict_post_api_callback(&dict->dict);
        } else {
                /* synchronous lookup */
-               io_loop_stop(dict->ioloop);
+               io_loop_stop(dict->dict.ioloop);
        }
 }
 
@@ -1347,9 +1322,9 @@ client_dict_transaction_commit_callback(struct client_dict_cmd *cmd,
        }
        client_dict_transaction_free(&cmd->trans);
 
-       dict_pre_api_callback(dict);
+       dict_pre_api_callback(&dict->dict);
        cmd->api_callback.commit(&result, cmd->api_callback.context);
-       dict_post_api_callback(dict);
+       dict_post_api_callback(&dict->dict);
 }
 
 

diff --git a/src/lib-dict/dict-memcached-ascii.c b/src/lib-dict/dict-memcached-ascii.c
index 970f74dc4b10932f161d75a7b32a2ef6c2976f76..33f8ebee29ed9ca106b3691648000baca06c8744 100644 (file)
--- a/src/lib-dict/dict-memcached-ascii.c
+++ b/src/lib-dict/dict-memcached-ascii.c
@@ -56,7 +56,6 @@ struct memcached_ascii_dict {
        in_port_t port;
        unsigned int timeout_msecs;
 
-       struct ioloop *ioloop, *prev_ioloop;
        struct timeout *to;
        struct memcached_ascii_connection conn;
 
@@ -72,15 +71,15 @@ memcached_ascii_callback(struct memcached_ascii_dict *dict,
                         const struct dict_commit_result *result)
 {
        if (reply->callback != NULL) {
-               if (dict->prev_ioloop != NULL) {
+               if (dict->dict.prev_ioloop != NULL) {
                        /* Don't let callback see that we've created our
                           internal ioloop in case it wants to add some ios
                           or timeouts. */
-                       current_ioloop = dict->prev_ioloop;
+                       current_ioloop = dict->dict.prev_ioloop;
                }
                reply->callback(result, reply->context);
-               if (dict->prev_ioloop != NULL)
-                       current_ioloop = dict->ioloop;
+               if (dict->dict.prev_ioloop != NULL)
+                       current_ioloop = dict->dict.ioloop;
        }
 }
 
@@ -94,8 +93,8 @@ memcached_ascii_disconnected(struct memcached_ascii_connection *conn,
        const struct memcached_ascii_dict_reply *reply;
 
        connection_disconnect(&conn->conn);
-       if (conn->dict->ioloop != NULL)
-               io_loop_stop(conn->dict->ioloop);
+       if (conn->dict->dict.ioloop != NULL)
+               io_loop_stop(conn->dict->dict.ioloop);
 
        array_foreach(&conn->dict->replies, reply)
                memcached_ascii_callback(conn->dict, reply, &result);
@@ -246,21 +245,21 @@ static void memcached_ascii_conn_input(struct connection *_conn)
        while ((ret = memcached_ascii_input_reply(conn->dict, &error)) > 0) ;
        if (ret < 0)
                memcached_ascii_disconnected(conn, error);
-       io_loop_stop(conn->dict->ioloop);
+       io_loop_stop(conn->dict->dict.ioloop);
 }
 
 static int memcached_ascii_input_wait(struct memcached_ascii_dict *dict,
                                      const char **error_r)
 {
-       dict->prev_ioloop = current_ioloop;
-       io_loop_set_current(dict->ioloop);
+       dict->dict.prev_ioloop = current_ioloop;
+       io_loop_set_current(dict->dict.ioloop);
        if (dict->to != NULL)
                dict->to = io_loop_move_timeout(&dict->to);
        connection_switch_ioloop(&dict->conn.conn);
-       io_loop_run(dict->ioloop);
+       io_loop_run(dict->dict.ioloop);
 
-       io_loop_set_current(dict->prev_ioloop);
-       dict->prev_ioloop = NULL;
+       io_loop_set_current(dict->dict.prev_ioloop);
+       dict->dict.prev_ioloop = NULL;
 
        if (dict->to != NULL)
                dict->to = io_loop_move_timeout(&dict->to);
@@ -337,8 +336,8 @@ memcached_ascii_conn_connected(struct connection *_conn, bool success)
                i_error("memcached_ascii: connect(%s, %u) failed: %m",
                        net_ip2addr(&conn->dict->ip), conn->dict->port);
        }
-       if (conn->dict->ioloop != NULL)
-               io_loop_stop(conn->dict->ioloop);
+       if (conn->dict->dict.ioloop != NULL)
+               io_loop_stop(conn->dict->dict.ioloop);
 }
 
 static const struct connection_settings memcached_ascii_conn_set = {
@@ -446,7 +445,7 @@ memcached_ascii_dict_init(struct dict *driver, const char *uri,
        i_array_init(&dict->input_states, 4);
        i_array_init(&dict->replies, 4);
 
-       dict->ioloop = io_loop_create();
+       dict->dict.ioloop = io_loop_create();
        io_loop_set_current(old_ioloop);
        *dict_r = &dict->dict;
        return 0;
@@ -465,8 +464,8 @@ static void memcached_ascii_dict_deinit(struct dict *_dict)
        }
        connection_deinit(&dict->conn.conn);
 
-       io_loop_set_current(dict->ioloop);
-       io_loop_destroy(&dict->ioloop);
+       io_loop_set_current(dict->dict.ioloop);
+       io_loop_destroy(&dict->dict.ioloop);
        io_loop_set_current(old_ioloop);
 
        str_free(&dict->conn.reply_str);

diff --git a/src/lib-dict/dict-memcached.c b/src/lib-dict/dict-memcached.c
index 2b82dc6be0f7f41525b5c6226efbf721b26d7fd5..10945f14cec8c52a367999b1bf8c6517d7a15b0e 100644 (file)
--- a/src/lib-dict/dict-memcached.c
+++ b/src/lib-dict/dict-memcached.c
@@ -51,7 +51,6 @@ struct memcached_dict {
        in_port_t port;
        unsigned int timeout_msecs;
 
-       struct ioloop *ioloop;
        struct memcached_connection conn;
 
        bool connected;
@@ -66,8 +65,8 @@ static void memcached_conn_destroy(struct connection *_conn)
        conn->dict->connected = FALSE;
        connection_disconnect(_conn);
 
-       if (conn->dict->ioloop != NULL)
-               io_loop_stop(conn->dict->ioloop);
+       if (conn->dict->dict.ioloop != NULL)
+               io_loop_stop(conn->dict->dict.ioloop);
 }
 
 static int memcached_input_get(struct memcached_connection *conn)
@@ -117,8 +116,8 @@ static int memcached_input_get(struct memcached_connection *conn)
        i_stream_skip(conn->conn.input, body_len);
        conn->reply.reply_received = TRUE;
 
-       if (conn->dict->ioloop != NULL)
-               io_loop_stop(conn->dict->ioloop);
+       if (conn->dict->dict.ioloop != NULL)
+               io_loop_stop(conn->dict->dict.ioloop);
        return 1;
 }
 
@@ -151,8 +150,8 @@ static void memcached_conn_connected(struct connection *_conn, bool success)
        } else {
                conn->dict->connected = TRUE;
        }
-       if (conn->dict->ioloop != NULL)
-               io_loop_stop(conn->dict->ioloop);
+       if (conn->dict->dict.ioloop != NULL)
+               io_loop_stop(conn->dict->dict.ioloop);
 }
 
 static const struct connection_settings memcached_conn_set = {
@@ -250,7 +249,7 @@ static void memcached_dict_lookup_timeout(struct memcached_dict *dict)
 {
        i_error("memcached: Lookup timed out in %u.%03u secs",
                dict->timeout_msecs/1000, dict->timeout_msecs%1000);
-       io_loop_stop(dict->ioloop);
+       io_loop_stop(dict->dict.ioloop);
 }
 
 static void memcached_add_header(buffer_t *buf, unsigned int key_len)
@@ -295,9 +294,9 @@ memcached_dict_lookup(struct dict *_dict, pool_t pool, const char *key,
                return -1;
        }
 
-       i_assert(dict->ioloop == NULL);
+       i_assert(dict->dict.ioloop == NULL);
 
-       dict->ioloop = io_loop_create();
+       dict->dict.ioloop = io_loop_create();
        connection_switch_ioloop(&dict->conn.conn);
 
        if (dict->conn.conn.fd_in == -1 &&
@@ -309,7 +308,7 @@ memcached_dict_lookup(struct dict *_dict, pool_t pool, const char *key,
                                 memcached_dict_lookup_timeout, dict);
                if (!dict->connected) {
                        /* wait for connection */
-                       io_loop_run(dict->ioloop);
+                       io_loop_run(dict->dict.ioloop);
                }
 
                if (dict->connected) {
@@ -322,15 +321,15 @@ memcached_dict_lookup(struct dict *_dict, pool_t pool, const char *key,
                                       dict->conn.cmd->used);
 
                        i_zero(&dict->conn.reply);
-                       io_loop_run(dict->ioloop);
+                       io_loop_run(dict->dict.ioloop);
                }
                timeout_remove(&to);
        }
 
        io_loop_set_current(prev_ioloop);
        connection_switch_ioloop(&dict->conn.conn);
-       io_loop_set_current(dict->ioloop);
-       io_loop_destroy(&dict->ioloop);
+       io_loop_set_current(dict->dict.ioloop);
+       io_loop_destroy(&dict->dict.ioloop);
 
        if (!dict->conn.reply.reply_received) {
                /* we failed in some way. make sure we disconnect since the

diff --git a/src/lib-dict/dict-private.h b/src/lib-dict/dict-private.h
index d147c2d593a6162b70f601c91c38f499b77a297a..0738ea1210a5c47e0604f824a47f5cbb3599f013 100644 (file)
--- a/src/lib-dict/dict-private.h
+++ b/src/lib-dict/dict-private.h
@@ -4,6 +4,8 @@
 #include <time.h>
 #include "dict.h"
 
+struct ioloop;
+
 struct dict_vfuncs {
        int (*init)(struct dict *dict_driver, const char *uri,
                    const struct dict_settings *set,
@@ -52,6 +54,7 @@ struct dict {
        unsigned int iter_count;
        unsigned int transaction_count;
        struct dict_transaction_context *transactions;
+       struct ioloop *ioloop, *prev_ioloop;
 };
 
 struct dict_iterate_context {
@@ -90,4 +93,7 @@ extern struct dict dict_driver_fail;
 extern struct dict_iterate_context dict_iter_unsupported;
 extern struct dict_transaction_context dict_transaction_unsupported;
 
+void dict_pre_api_callback(struct dict *dict);
+void dict_post_api_callback(struct dict *dict);
+
 #endif

diff --git a/src/lib-dict/dict-redis.c b/src/lib-dict/dict-redis.c
index 93eb9e729835648b863ae92bbe3e4cb53a03d791..4ce4dc2b85bc9e3b0fdcc7543d6d599a02833b61 100644 (file)
--- a/src/lib-dict/dict-redis.c
+++ b/src/lib-dict/dict-redis.c
@@ -50,7 +50,6 @@ struct redis_dict {
        char *username, *password, *key_prefix, *expire_value;
        unsigned int timeout_msecs, db_id;
 
-       struct ioloop *ioloop, *prev_ioloop;
        struct redis_connection conn;
 
        ARRAY(enum redis_input_state) input_states;
@@ -85,15 +84,9 @@ static void redis_callback(struct redis_dict *dict,
                           const struct dict_commit_result *result)
 {
        if (reply->callback != NULL) {
-               if (dict->prev_ioloop != NULL) {
-                       /* Don't let callback see that we've created our
-                          internal ioloop in case it wants to add some ios
-                          or timeouts. */
-                       current_ioloop = dict->prev_ioloop;
-               }
+               dict_pre_api_callback(&dict->dict);
                reply->callback(result, reply->context);
-               if (dict->prev_ioloop != NULL)
-                       current_ioloop = dict->ioloop;
+               dict_post_api_callback(&dict->dict);
        }
 }
 
@@ -114,8 +107,8 @@ redis_disconnected(struct redis_connection *conn, const char *reason)
        array_clear(&conn->dict->replies);
        array_clear(&conn->dict->input_states);
 
-       if (conn->dict->ioloop != NULL)
-               io_loop_stop(conn->dict->ioloop);
+       if (conn->dict->dict.ioloop != NULL)
+               io_loop_stop(conn->dict->dict.ioloop);
 }
 
 static void redis_conn_destroy(struct connection *_conn)
@@ -137,23 +130,23 @@ static void redis_wait(struct redis_dict *dict)
 {
        struct timeout *to;
 
-       i_assert(dict->ioloop == NULL);
+       i_assert(dict->dict.ioloop == NULL);
 
-       dict->prev_ioloop = current_ioloop;
-       dict->ioloop = io_loop_create();
+       dict->dict.prev_ioloop = current_ioloop;
+       dict->dict.ioloop = io_loop_create();
        to = timeout_add(dict->timeout_msecs, redis_dict_wait_timeout, dict);
        connection_switch_ioloop(&dict->conn.conn);
 
        do {
-               io_loop_run(dict->ioloop);
+               io_loop_run(dict->dict.ioloop);
        } while (array_count(&dict->input_states) > 0);
 
        timeout_remove(&to);
-       io_loop_set_current(dict->prev_ioloop);
+       io_loop_set_current(dict->dict.prev_ioloop);
        connection_switch_ioloop(&dict->conn.conn);
-       io_loop_set_current(dict->ioloop);
-       io_loop_destroy(&dict->ioloop);
-       dict->prev_ioloop = NULL;
+       io_loop_set_current(dict->dict.ioloop);
+       io_loop_destroy(&dict->dict.ioloop);
+       dict->dict.prev_ioloop = NULL;
 }
 
 static int redis_input_get(struct redis_connection *conn, const char **error_r)
@@ -170,8 +163,8 @@ static int redis_input_get(struct redis_connection *conn, const char **error_r)
                if (strcmp(line, "$-1") == 0) {
                        conn->value_received = TRUE;
                        conn->value_not_found = TRUE;
-                       if (conn->dict->ioloop != NULL)
-                               io_loop_stop(conn->dict->ioloop);
+                       if (conn->dict->dict.ioloop != NULL)
+                               io_loop_stop(conn->dict->dict.ioloop);
                        redis_input_state_remove(conn->dict);
                        return 1;
                }
@@ -198,8 +191,8 @@ static int redis_input_get(struct redis_connection *conn, const char **error_r)
        conn->value_received = TRUE;
        str_truncate(conn->last_reply, str_len(conn->last_reply)-2);
 
-       if (conn->dict->ioloop != NULL)
-               io_loop_stop(conn->dict->ioloop);
+       if (conn->dict->dict.ioloop != NULL)
+               io_loop_stop(conn->dict->dict.ioloop);
        redis_input_state_remove(conn->dict);
        return 1;
 }
@@ -270,8 +263,8 @@ redis_conn_input_more(struct redis_connection *conn, const char **error_r)
                        /* if we're running in a dict-ioloop, we're handling a
                           synchronous commit and need to stop now */
                        if (array_count(&dict->replies) == 0 &&
-                           conn->dict->ioloop != NULL)
-                               io_loop_stop(conn->dict->ioloop);
+                           conn->dict->dict.ioloop != NULL)
+                               io_loop_stop(conn->dict->dict.ioloop);
                }
                return 1;
        }
@@ -313,8 +306,8 @@ static void redis_conn_connected(struct connection *_conn, bool success)
        } else {
                conn->dict->connected = TRUE;
        }
-       if (conn->dict->ioloop != NULL)
-               io_loop_stop(conn->dict->ioloop);
+       if (conn->dict->dict.ioloop != NULL)
+               io_loop_stop(conn->dict->dict.ioloop);
 }
 
 static const struct connection_settings redis_conn_set = {
@@ -552,10 +545,10 @@ static int redis_dict_lookup(struct dict *_dict, pool_t pool, const char *key,
        dict->conn.value_received = FALSE;
        dict->conn.value_not_found = FALSE;
 
-       i_assert(dict->ioloop == NULL);
+       i_assert(dict->dict.ioloop == NULL);
 
-       dict->prev_ioloop = current_ioloop;
-       dict->ioloop = io_loop_create();
+       dict->dict.prev_ioloop = current_ioloop;
+       dict->dict.ioloop = io_loop_create();
        connection_switch_ioloop(&dict->conn.conn);
 
        if (dict->conn.conn.fd_in == -1 &&
@@ -566,7 +559,7 @@ static int redis_dict_lookup(struct dict *_dict, pool_t pool, const char *key,
                                 redis_dict_lookup_timeout, dict);
                if (!dict->connected) {
                        /* wait for connection */
-                       io_loop_run(dict->ioloop);
+                       io_loop_run(dict->dict.ioloop);
                        if (dict->connected)
                                redis_dict_auth(dict);
                }
@@ -580,17 +573,17 @@ static int redis_dict_lookup(struct dict *_dict, pool_t pool, const char *key,
                        str_truncate(dict->conn.last_reply, 0);
                        redis_input_state_add(dict, REDIS_INPUT_STATE_GET);
                        do {
-                               io_loop_run(dict->ioloop);
+                               io_loop_run(dict->dict.ioloop);
                        } while (array_count(&dict->input_states) > 0);
                }
                timeout_remove(&to);
        }
 
-       io_loop_set_current(dict->prev_ioloop);
+       io_loop_set_current(dict->dict.prev_ioloop);
        connection_switch_ioloop(&dict->conn.conn);
-       io_loop_set_current(dict->ioloop);
-       io_loop_destroy(&dict->ioloop);
-       dict->prev_ioloop = NULL;
+       io_loop_set_current(dict->dict.ioloop);
+       io_loop_destroy(&dict->dict.ioloop);
+       dict->dict.prev_ioloop = NULL;
 
        if (!dict->conn.value_received) {
                /* we failed in some way. make sure we disconnect since the

diff --git a/src/lib-dict/dict.c b/src/lib-dict/dict.c
index 1b49a75d600808e46922cd475b2625cb7501de9d..815d6817a4aae82e0150ad40a93e65babe7283fd 100644 (file)
--- a/src/lib-dict/dict.c
+++ b/src/lib-dict/dict.c
@@ -3,6 +3,7 @@
 #include "lib.h"
 #include "array.h"
 #include "llist.h"
+#include "ioloop.h"
 #include "str.h"
 #include "dict-private.h"
 
@@ -121,6 +122,25 @@ static bool dict_key_prefix_is_valid(const char *key)
                str_begins(key, DICT_PATH_PRIVATE);
 }
 
+void dict_pre_api_callback(struct dict *dict)
+{
+       if (dict->prev_ioloop != NULL) {
+               /* Don't let callback see that we've created our
+                  internal ioloop in case it wants to add some ios
+                  or timeouts. */
+               io_loop_set_current(dict->prev_ioloop);
+       }
+}
+
+void dict_post_api_callback(struct dict *dict)
+{
+       if (dict->prev_ioloop != NULL) {
+               io_loop_set_current(dict->ioloop);
+               io_loop_stop(dict->ioloop);
+       }
+}
+
+
 int dict_lookup(struct dict *dict, pool_t pool, const char *key,
                const char **value_r, const char **error_r)
 {