[Project] More rework

diff --git a/src/libserver/fuzzy_backend_redis.c b/src/libserver/fuzzy_backend_redis.c
index df9103e30725daab40a11a7e0828e6863ec26c8b..79c712386a9ed8d4ad3991f4108302e7d58d176f 100644 (file)
--- a/src/libserver/fuzzy_backend_redis.c
+++ b/src/libserver/fuzzy_backend_redis.c
@@ -71,9 +71,9 @@ enum rspamd_fuzzy_redis_command {
 struct rspamd_fuzzy_redis_session {
        struct rspamd_fuzzy_backend_redis *backend;
        redisAsyncContext *ctx;
-       struct event timeout;
+       ev_timer timeout;
        const struct rspamd_fuzzy_cmd *cmd;
-       struct ev_loop *ev_base;
+       struct ev_loop *event_loop;
        float prob;
        gboolean shingles_checked;
 
@@ -143,10 +143,7 @@ rspamd_fuzzy_redis_session_dtor (struct rspamd_fuzzy_redis_session *session,
                                ac, is_fatal);
        }
 
-       if (rspamd_event_pending (&session->timeout, EV_TIMEOUT)) {
-               event_del (&session->timeout);
-       }
-
+       ev_timer_stop (session->event_loop, &session->timeout);
        rspamd_fuzzy_redis_session_free_args (session);
 
        REF_RELEASE (session->backend);
@@ -276,9 +273,10 @@ rspamd_fuzzy_backend_init_redis (struct rspamd_fuzzy_backend *bk,
 }
 
 static void
-rspamd_fuzzy_redis_timeout (gint fd, short what, gpointer priv)
+rspamd_fuzzy_redis_timeout (EV_P_ ev_timer *w, int revents)
 {
-       struct rspamd_fuzzy_redis_session *session = priv;
+       struct rspamd_fuzzy_redis_session *session =
+                       (struct rspamd_fuzzy_redis_session *)w->data;
        redisAsyncContext *ac;
        static char errstr[128];
 
@@ -320,12 +318,11 @@ rspamd_fuzzy_redis_shingles_callback (redisAsyncContext *c, gpointer r,
        struct rspamd_fuzzy_redis_session *session = priv;
        redisReply *reply = r, *cur;
        struct rspamd_fuzzy_reply rep;
-       struct timeval tv;
        GString *key;
        struct _rspamd_fuzzy_shingles_helper *shingles, *prev = NULL, *sel = NULL;
        guint i, found = 0, max_found = 0, cur_found = 0;
 
-       event_del (&session->timeout);
+       ev_timer_stop (session->event_loop, &session->timeout);
        memset (&rep, 0, sizeof (rep));
 
        if (c->err == 0) {
@@ -421,12 +418,11 @@ rspamd_fuzzy_redis_shingles_callback (redisAsyncContext *c, gpointer r,
                                        }
                                        else {
                                                /* Add timeout */
-                                               event_set (&session->timeout, -1, EV_TIMEOUT,
+                                               session->timeout.data = session;
+                                               ev_timer_init (&session->timeout,
                                                                rspamd_fuzzy_redis_timeout,
-                                                               session);
-                                               event_base_set (session->ev_base, &session->timeout);
-                                               double_to_tv (session->backend->timeout, &tv);
-                                               event_add (&session->timeout, &tv);
+                                                               session->backend->timeout, 0.0);
+                                               ev_timer_start (session->event_loop, &session->timeout);
                                        }
 
                                        return;
@@ -456,7 +452,6 @@ rspamd_fuzzy_redis_shingles_callback (redisAsyncContext *c, gpointer r,
 static void
 rspamd_fuzzy_backend_check_shingles (struct rspamd_fuzzy_redis_session *session)
 {
-       struct timeval tv;
        struct rspamd_fuzzy_reply rep;
        const struct rspamd_fuzzy_shingle_cmd *shcmd;
        GString *key;
@@ -501,11 +496,11 @@ rspamd_fuzzy_backend_check_shingles (struct rspamd_fuzzy_redis_session *session)
        }
        else {
                /* Add timeout */
-               event_set (&session->timeout, -1, EV_TIMEOUT, rspamd_fuzzy_redis_timeout,
-                               session);
-               event_base_set (session->ev_base, &session->timeout);
-               double_to_tv (session->backend->timeout, &tv);
-               event_add (&session->timeout, &tv);
+               session->timeout.data = session;
+               ev_timer_init (&session->timeout,
+                               rspamd_fuzzy_redis_timeout,
+                               session->backend->timeout, 0.0);
+               ev_timer_start (session->event_loop, &session->timeout);
        }
 }
 
@@ -519,7 +514,7 @@ rspamd_fuzzy_redis_check_callback (redisAsyncContext *c, gpointer r,
        gulong value;
        guint found_elts = 0;
 
-       event_del (&session->timeout);
+       ev_timer_stop (session->event_loop, &session->timeout);
        memset (&rep, 0, sizeof (rep));
 
        if (c->err == 0) {
@@ -602,7 +597,6 @@ rspamd_fuzzy_backend_check_redis (struct rspamd_fuzzy_backend *bk,
        struct rspamd_fuzzy_redis_session *session;
        struct upstream *up;
        struct upstream_list *ups;
-       struct timeval tv;
        rspamd_inet_addr_t *addr;
        struct rspamd_fuzzy_reply rep;
        GString *key;
@@ -620,7 +614,7 @@ rspamd_fuzzy_backend_check_redis (struct rspamd_fuzzy_backend *bk,
        session->prob = 1.0;
        memcpy (rep.digest, session->cmd->digest, sizeof (rep.digest));
        memcpy (session->found_digest, session->cmd->digest, sizeof (rep.digest));
-       session->ev_base = rspamd_fuzzy_backend_event_base (bk);
+       session->event_loop = rspamd_fuzzy_backend_event_base (bk);
 
        /* First of all check digest */
        session->nargs = 5;
@@ -677,11 +671,11 @@ rspamd_fuzzy_backend_check_redis (struct rspamd_fuzzy_backend *bk,
                }
                else {
                        /* Add timeout */
-                       event_set (&session->timeout, -1, EV_TIMEOUT, rspamd_fuzzy_redis_timeout,
-                                       session);
-                       event_base_set (session->ev_base, &session->timeout);
-                       double_to_tv (backend->timeout, &tv);
-                       event_add (&session->timeout, &tv);
+                       session->timeout.data = session;
+                       ev_timer_init (&session->timeout,
+                                       rspamd_fuzzy_redis_timeout,
+                                       session->backend->timeout, 0.0);
+                       ev_timer_start (session->event_loop, &session->timeout);
                }
        }
 }
@@ -694,7 +688,7 @@ rspamd_fuzzy_redis_count_callback (redisAsyncContext *c, gpointer r,
        redisReply *reply = r;
        gulong nelts;
 
-       event_del (&session->timeout);
+       ev_timer_stop (session->event_loop, &session->timeout);
 
        if (c->err == 0) {
                rspamd_upstream_ok (session->up);
@@ -741,7 +735,6 @@ rspamd_fuzzy_backend_count_redis (struct rspamd_fuzzy_backend *bk,
        struct rspamd_fuzzy_redis_session *session;
        struct upstream *up;
        struct upstream_list *ups;
-       struct timeval tv;
        rspamd_inet_addr_t *addr;
        GString *key;
 
@@ -754,7 +747,7 @@ rspamd_fuzzy_backend_count_redis (struct rspamd_fuzzy_backend *bk,
        session->callback.cb_count = cb;
        session->cbdata = ud;
        session->command = RSPAMD_FUZZY_REDIS_COMMAND_COUNT;
-       session->ev_base = rspamd_fuzzy_backend_event_base (bk);
+       session->event_loop = rspamd_fuzzy_backend_event_base (bk);
 
        session->nargs = 2;
        session->argv = g_malloc (sizeof (gchar *) * 2);
@@ -801,11 +794,11 @@ rspamd_fuzzy_backend_count_redis (struct rspamd_fuzzy_backend *bk,
                }
                else {
                        /* Add timeout */
-                       event_set (&session->timeout, -1, EV_TIMEOUT, rspamd_fuzzy_redis_timeout,
-                                       session);
-                       event_base_set (session->ev_base, &session->timeout);
-                       double_to_tv (backend->timeout, &tv);
-                       event_add (&session->timeout, &tv);
+                       session->timeout.data = session;
+                       ev_timer_init (&session->timeout,
+                                       rspamd_fuzzy_redis_timeout,
+                                       session->backend->timeout, 0.0);
+                       ev_timer_start (session->event_loop, &session->timeout);
                }
        }
 }
@@ -818,7 +811,7 @@ rspamd_fuzzy_redis_version_callback (redisAsyncContext *c, gpointer r,
        redisReply *reply = r;
        gulong nelts;
 
-       event_del (&session->timeout);
+       ev_timer_stop (session->event_loop, &session->timeout);
 
        if (c->err == 0) {
                rspamd_upstream_ok (session->up);
@@ -866,7 +859,6 @@ rspamd_fuzzy_backend_version_redis (struct rspamd_fuzzy_backend *bk,
        struct rspamd_fuzzy_redis_session *session;
        struct upstream *up;
        struct upstream_list *ups;
-       struct timeval tv;
        rspamd_inet_addr_t *addr;
        GString *key;
 
@@ -879,7 +871,7 @@ rspamd_fuzzy_backend_version_redis (struct rspamd_fuzzy_backend *bk,
        session->callback.cb_version = cb;
        session->cbdata = ud;
        session->command = RSPAMD_FUZZY_REDIS_COMMAND_VERSION;
-       session->ev_base = rspamd_fuzzy_backend_event_base (bk);
+       session->event_loop = rspamd_fuzzy_backend_event_base (bk);
 
        session->nargs = 2;
        session->argv = g_malloc (sizeof (gchar *) * 2);
@@ -926,11 +918,11 @@ rspamd_fuzzy_backend_version_redis (struct rspamd_fuzzy_backend *bk,
                }
                else {
                        /* Add timeout */
-                       event_set (&session->timeout, -1, EV_TIMEOUT, rspamd_fuzzy_redis_timeout,
-                                       session);
-                       event_base_set (session->ev_base, &session->timeout);
-                       double_to_tv (backend->timeout, &tv);
-                       event_add (&session->timeout, &tv);
+                       session->timeout.data = session;
+                       ev_timer_init (&session->timeout,
+                                       rspamd_fuzzy_redis_timeout,
+                                       session->backend->timeout, 0.0);
+                       ev_timer_start (session->event_loop, &session->timeout);
                }
        }
 }
@@ -1309,7 +1301,8 @@ rspamd_fuzzy_redis_update_callback (redisAsyncContext *c, gpointer r,
 {
        struct rspamd_fuzzy_redis_session *session = priv;
        redisReply *reply = r;
-       event_del (&session->timeout);
+
+       ev_timer_stop (session->event_loop, &session->timeout);
 
        if (c->err == 0) {
                rspamd_upstream_ok (session->up);
@@ -1356,12 +1349,11 @@ rspamd_fuzzy_backend_update_redis (struct rspamd_fuzzy_backend *bk,
        struct rspamd_fuzzy_redis_session *session;
        struct upstream *up;
        struct upstream_list *ups;
-       struct timeval tv;
        rspamd_inet_addr_t *addr;
        guint i;
        GString *key;
        struct fuzzy_peer_cmd *io_cmd;
-       struct rspamd_fuzzy_cmd *cmd;
+       struct rspamd_fuzzy_cmd *cmd = NULL;
        guint nargs, ncommands, cur_shift;
 
        g_assert (backend != NULL);
@@ -1445,7 +1437,7 @@ rspamd_fuzzy_backend_update_redis (struct rspamd_fuzzy_backend *bk,
        session->command = RSPAMD_FUZZY_REDIS_COMMAND_UPDATES;
        session->cmd = cmd;
        session->prob = 1.0;
-       session->ev_base = rspamd_fuzzy_backend_event_base (bk);
+       session->event_loop = rspamd_fuzzy_backend_event_base (bk);
 
        /* First of all check digest */
        session->nargs = nargs;
@@ -1550,11 +1542,11 @@ rspamd_fuzzy_backend_update_redis (struct rspamd_fuzzy_backend *bk,
                }
                else {
                        /* Add timeout */
-                       event_set (&session->timeout, -1, EV_TIMEOUT, rspamd_fuzzy_redis_timeout,
-                                       session);
-                       event_base_set (session->ev_base, &session->timeout);
-                       double_to_tv (backend->timeout, &tv);
-                       event_add (&session->timeout, &tv);
+                       session->timeout.data = session;
+                       ev_timer_init (&session->timeout,
+                                       rspamd_fuzzy_redis_timeout,
+                                       session->backend->timeout, 0.0);
+                       ev_timer_start (session->event_loop, &session->timeout);
                }
        }
 }

diff --git a/src/libserver/milter.c b/src/libserver/milter.c
index f9b4eee8c0bf8741d395aea27ede2277a5e87c42..bb27d2ff11a470fddcfb3894d048da0c4c034bac 100644 (file)
--- a/src/libserver/milter.c
+++ b/src/libserver/milter.c
@@ -1083,7 +1083,7 @@ rspamd_milter_handle_session (struct rspamd_milter_session *session,
 
 
 gboolean
-rspamd_milter_handle_socket (gint fd, const struct timeval *tv,
+rspamd_milter_handle_socket (gint fd, ev_tstamp timeout,
                rspamd_mempool_t *pool,
                struct ev_loop *ev_base, rspamd_milter_finish finish_cb,
                rspamd_milter_error error_cb, void *ud)
@@ -1108,6 +1108,7 @@ rspamd_milter_handle_socket (gint fd, const struct timeval *tv,
        priv->pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "milter");
        priv->discard_on_reject = milter_ctx->discard_on_reject;
        priv->quarantine_on_reject = milter_ctx->quarantine_on_reject;
+       priv->ev.timeout = timeout;
 
        if (pool) {
                /* Copy tag */
@@ -1117,14 +1118,6 @@ rspamd_milter_handle_socket (gint fd, const struct timeval *tv,
        priv->headers = kh_init (milter_headers_hash_t);
        kh_resize (milter_headers_hash_t, priv->headers, 32);
 
-       if (tv) {
-               memcpy (&priv->tv, tv, sizeof (*tv));
-               priv->ptv = &priv->tv;
-       }
-       else {
-               priv->ptv = NULL;
-       }
-
        session->priv = priv;
        REF_INIT_RETAIN (session, rspamd_milter_session_dtor);
 

diff --git a/src/libserver/milter.h b/src/libserver/milter.h
index c01538f759e03df979f71e71c56c664ce7224583..7906aeadf83884c2c9942e91968b33a84d4f855c 100644 (file)
--- a/src/libserver/milter.h
+++ b/src/libserver/milter.h
@@ -20,6 +20,7 @@
 #include "fstring.h"
 #include "addr.h"
 #include "contrib/libucl/ucl.h"
+#include "contrib/libev/ev.h"
 #include "ref.h"
 
 enum rspamd_milter_reply {
@@ -81,7 +82,7 @@ typedef void (*rspamd_milter_error) (gint fd,
  * @param ud
  * @return
  */
-gboolean rspamd_milter_handle_socket (gint fd, const struct timeval *tv,
+gboolean rspamd_milter_handle_socket (gint fd, ev_tstamp timeout,
                rspamd_mempool_t *pool,
                struct ev_loop *ev_base, rspamd_milter_finish finish_cb,
                rspamd_milter_error error_cb, void *ud);

diff --git a/src/libserver/milter_internal.h b/src/libserver/milter_internal.h
index 7c0e4f26f0fd6f636d26e78ef2b5df3d13f8640f..41862a1691c50edbab7682bdc7bcf5762a78ba24 100644 (file)
--- a/src/libserver/milter_internal.h
+++ b/src/libserver/milter_internal.h
@@ -62,7 +62,6 @@ struct rspamd_milter_private {
        struct rspamd_milter_parser parser;
        struct rspamd_io_ev ev;
        struct rspamd_milter_outbuf *out_chain;
-       struct timeval *ptv;
        struct ev_loop *event_loop;
        rspamd_mempool_t *pool;
        khash_t(milter_headers_hash_t) *headers;

diff --git a/src/libserver/protocol.c b/src/libserver/protocol.c
index f2827828b18c5cb1da3c0506025d814dfeaed0fd..c75a402a475f449f5e7d2699e870bce0ddccf95a 100644 (file)
--- a/src/libserver/protocol.c
+++ b/src/libserver/protocol.c
@@ -1301,7 +1301,7 @@ rspamd_protocol_write_ucl (struct rspamd_task *task,
                ucl_object_insert_key (top, ucl_object_fromstring (task->message_id),
                                "message-id", 0, false);
                ucl_object_insert_key (top,
-                               ucl_object_fromdouble (task->time_real_finish - task->time_real),
+                               ucl_object_fromdouble (task->time_real_finish - task->task_timestamp),
                                "time_real", 0, false);
                ucl_object_insert_key (top,
                                ucl_object_fromdouble (task->time_virtual_finish - task->time_virtual),

diff --git a/src/libserver/redis_pool.c b/src/libserver/redis_pool.c
index d7e8015e52307b31b77f3839b8f4aa90bde540fc..6c74ee6f506aa21c1bb5d174eaf00c4b4d3ff4f1 100644 (file)
--- a/src/libserver/redis_pool.c
+++ b/src/libserver/redis_pool.c
@@ -30,7 +30,7 @@ struct rspamd_redis_pool_connection {
        struct redisAsyncContext *ctx;
        struct rspamd_redis_pool_elt *elt;
        GList *entry;
-       struct event timeout;
+       ev_timer timeout;
        gboolean active;
        gchar tag[MEMPOOL_UID_LEN];
        ref_entry_t ref;
@@ -120,9 +120,7 @@ rspamd_redis_pool_conn_dtor (struct rspamd_redis_pool_connection *conn)
        else {
                msg_debug_rpool ("inactive connection removed");
 
-               if (rspamd_event_pending (&conn->timeout, EV_TIMEOUT)) {
-                       event_del (&conn->timeout);
-               }
+               ev_timer_stop (conn->elt->pool->event_loop, &conn->timeout);
 
                if (conn->ctx && !(conn->ctx->c.flags & REDIS_FREEING)) {
                        redisAsyncContext *ac = conn->ctx;
@@ -173,9 +171,10 @@ rspamd_redis_pool_elt_dtor (gpointer p)
 }
 
 static void
-rspamd_redis_conn_timeout (gint fd, short what, gpointer p)
+rspamd_redis_conn_timeout (EV_P_ ev_timer *w, int revents)
 {
-       struct rspamd_redis_pool_connection *conn = p;
+       struct rspamd_redis_pool_connection *conn =
+                       (struct rspamd_redis_pool_connection *)w->data;
 
        g_assert (!conn->active);
        msg_debug_rpool ("scheduled removal of connection %p, refcount: %d",
@@ -186,7 +185,6 @@ rspamd_redis_conn_timeout (gint fd, short what, gpointer p)
 static void
 rspamd_redis_pool_schedule_timeout (struct rspamd_redis_pool_connection *conn)
 {
-       struct timeval tv;
        gdouble real_timeout;
        guint active_elts;
 
@@ -203,10 +201,12 @@ rspamd_redis_pool_schedule_timeout (struct rspamd_redis_pool_connection *conn)
 
        msg_debug_rpool ("scheduled connection %p cleanup in %.1f seconds",
                        conn->ctx, real_timeout);
-       double_to_tv (real_timeout, &tv);
-       event_set (&conn->timeout, -1, EV_TIMEOUT, rspamd_redis_conn_timeout, conn);
-       event_base_set (conn->elt->pool->event_loop, &conn->timeout);
-       event_add (&conn->timeout, &tv);
+
+       conn->timeout.data = conn;
+       ev_timer_init (&conn->timeout,
+                       rspamd_redis_conn_timeout,
+                       real_timeout, 0.0);
+       ev_timer_start (conn->elt->pool->event_loop, &conn->timeout);
 }
 
 static void
@@ -352,7 +352,7 @@ rspamd_redis_pool_connect (struct rspamd_redis_pool *pool,
                        g_assert (!conn->active);
 
                        if (conn->ctx->err == REDIS_OK) {
-                               event_del (&conn->timeout);
+                               ev_timer_stop (elt->pool->event_loop, &conn->timeout);
                                conn->active = TRUE;
                                g_queue_push_tail_link (elt->active, conn_entry);
                                msg_debug_rpool ("reused existing connection to %s:%d: %p",

diff --git a/src/libserver/rspamd_symcache.c b/src/libserver/rspamd_symcache.c
index 43a916f3a8505acfc71de238575457a39c87b8ed..aa83024b2b3fd43be0f530e0399cbff62fb21703 100644 (file)
--- a/src/libserver/rspamd_symcache.c
+++ b/src/libserver/rspamd_symcache.c
@@ -229,10 +229,10 @@ struct cache_savepoint {
 
 struct rspamd_cache_refresh_cbdata {
        gdouble last_resort;
-       struct event resort_ev;
+       ev_timer resort_ev;
        struct rspamd_symcache *cache;
        struct rspamd_worker *w;
-       struct ev_loop *ev_base;
+       struct ev_loop *event_loop;
 };
 
 /* weight, frequency, time */
@@ -1577,16 +1577,8 @@ rspamd_symcache_check_symbol (struct rspamd_task *task,
 
        if (check) {
                msg_debug_cache_task ("execute %s, %d", item->symbol, item->id);
-#ifdef HAVE_EVENT_NO_CACHE_TIME_FUNC
-               struct timeval tv;
-
-               event_base_update_cache_time (task->ev_base);
-               event_base_gettimeofday_cached (task->ev_base, &tv);
-               t1 = tv_to_double (&tv);
-#else
-               t1 = rspamd_get_ticks (FALSE);
-#endif
-               dyn_item->start_msec = (t1 - task->time_real) * 1e3;
+               t1 = ev_now (task->event_loop);
+               dyn_item->start_msec = (t1 - task->time_virtual) * 1e3;
                dyn_item->async_events = 0;
                checkpoint->cur_item = item;
                checkpoint->items_inflight ++;
@@ -2200,11 +2192,11 @@ rspamd_symcache_call_peak_cb (struct ev_loop *ev_base,
 }
 
 static void
-rspamd_symcache_resort_cb (gint fd, short what, gpointer ud)
+rspamd_symcache_resort_cb (EV_P_ ev_timer *w, int revents)
 {
-       struct timeval tv;
        gdouble tm;
-       struct rspamd_cache_refresh_cbdata *cbdata = ud;
+       struct rspamd_cache_refresh_cbdata *cbdata =
+                       (struct rspamd_cache_refresh_cbdata *)w->data;
        struct rspamd_symcache *cache;
        struct rspamd_symcache_item *item;
        guint i;
@@ -2217,10 +2209,8 @@ rspamd_symcache_resort_cb (gint fd, short what, gpointer ud)
        cur_ticks = rspamd_get_ticks (FALSE);
        msg_debug_cache ("resort symbols cache, next reload in %.2f seconds", tm);
        g_assert (cache != NULL);
-       evtimer_set (&cbdata->resort_ev, rspamd_symcache_resort_cb, cbdata);
-       event_base_set (cbdata->ev_base, &cbdata->resort_ev);
-       double_to_tv (tm, &tv);
-       event_add (&cbdata->resort_ev, &tv);
+       cbdata->resort_ev.repeat = tm;
+       ev_timer_again (EV_A_ w);
 
        if (rspamd_worker_is_primary_controller (cbdata->w)) {
                /* Gather stats from shared execution times */
@@ -2263,7 +2253,7 @@ rspamd_symcache_resort_cb (gint fd, short what, gpointer ud)
                                                        item->frequency_peaks);
 
                                        if (cache->peak_cb != -1) {
-                                               rspamd_symcache_call_peak_cb (cbdata->ev_base,
+                                               rspamd_symcache_call_peak_cb (cbdata->event_loop,
                                                                cache, item,
                                                                cur_value, cur_err);
                                        }
@@ -2283,36 +2273,41 @@ rspamd_symcache_resort_cb (gint fd, short what, gpointer ud)
                        }
                }
 
-
                cbdata->last_resort = cur_ticks;
                /* We don't do actual sorting due to topological guarantees */
        }
 }
 
+static void
+rspamd_symcache_refresh_dtor (void *d)
+{
+       struct rspamd_cache_refresh_cbdata *cbdata =
+                       (struct rspamd_cache_refresh_cbdata *)d;
+
+       ev_timer_stop (cbdata->event_loop, &cbdata->resort_ev);
+}
+
 void
 rspamd_symcache_start_refresh (struct rspamd_symcache *cache,
                                                           struct ev_loop *ev_base, struct rspamd_worker *w)
 {
-       struct timeval tv;
        gdouble tm;
        struct rspamd_cache_refresh_cbdata *cbdata;
 
        cbdata = rspamd_mempool_alloc0 (cache->static_pool, sizeof (*cbdata));
        cbdata->last_resort = rspamd_get_ticks (TRUE);
-       cbdata->ev_base = ev_base;
+       cbdata->event_loop = ev_base;
        cbdata->w = w;
        cbdata->cache = cache;
        tm = rspamd_time_jitter (cache->reload_time, 0);
        msg_debug_cache ("next reload in %.2f seconds", tm);
        g_assert (cache != NULL);
-       evtimer_set (&cbdata->resort_ev, rspamd_symcache_resort_cb,
-                       cbdata);
-       event_base_set (ev_base, &cbdata->resort_ev);
-       double_to_tv (tm, &tv);
-       event_add (&cbdata->resort_ev, &tv);
+       cbdata->resort_ev.data = cbdata;
+       ev_timer_init (&cbdata->resort_ev, rspamd_symcache_resort_cb,
+                       tm, tm);
+       ev_timer_start (cbdata->event_loop, &cbdata->resort_ev);
        rspamd_mempool_add_destructor (cache->static_pool,
-                       (rspamd_mempool_destruct_t) event_del,
-                       &cbdata->resort_ev);
+                       rspamd_symcache_refresh_dtor, cbdata);
 }
 
 void
@@ -2838,16 +2833,8 @@ rspamd_symcache_finalize_item (struct rspamd_task *task,
        checkpoint->items_inflight --;
        checkpoint->cur_item = NULL;
 
-#ifdef HAVE_EVENT_NO_CACHE_TIME_FUNC
-       struct timeval tv;
-       event_base_update_cache_time (task->ev_base);
-       event_base_gettimeofday_cached (task->ev_base, &tv);
-       t2 = tv_to_double (&tv);
-#else
-       t2 = rspamd_get_ticks (FALSE);
-#endif
-
-       diff = ((t2 - task->time_real) * 1e3 - dyn_item->start_msec);
+       t2 = ev_now (task->event_loop);
+       diff = ((t2 - task->time_virtual) * 1e3 - dyn_item->start_msec);
 
        if (G_UNLIKELY (RSPAMD_TASK_IS_PROFILING (task))) {
                rspamd_task_profile_set (task, item->symbol, diff);

diff --git a/src/libstat/backends/redis_backend.c b/src/libstat/backends/redis_backend.c
index b5f02c27041e3d118f7d4796daa867e1f3ec659a..4e0d806f99716b4bf5c088f04cd27d1d865a6738 100644 (file)
--- a/src/libstat/backends/redis_backend.c
+++ b/src/libstat/backends/redis_backend.c
@@ -1444,7 +1444,7 @@ rspamd_redis_init (struct rspamd_stat_ctx *ctx,
        backend->stcf = stf;
 
        st_elt = g_malloc0 (sizeof (*st_elt));
-       st_elt->event_loop = ctx->ev_base;
+       st_elt->event_loop = ctx->event_loop;
        st_elt->ctx = backend;
        backend->stat_elt = rspamd_stat_ctx_register_async (
                        rspamd_redis_async_stat_cb,

diff --git a/src/libstat/stat_config.c b/src/libstat/stat_config.c
index 1ad064c5354d783376e5f6ac55f13048590aa0e4..52c78ba6b0c62243a72861fe942204e57699a39f 100644 (file)
--- a/src/libstat/stat_config.c
+++ b/src/libstat/stat_config.c
@@ -163,7 +163,7 @@ rspamd_stat_init (struct rspamd_config *cfg, struct ev_loop *ev_base)
        stat_ctx->statfiles = g_ptr_array_new ();
        stat_ctx->classifiers = g_ptr_array_new ();
        stat_ctx->async_elts = g_queue_new ();
-       stat_ctx->ev_base = ev_base;
+       stat_ctx->event_loop = ev_base;
        stat_ctx->lua_stat_tokens_ref = -1;
 
        /* Interact with lua_stat */
@@ -510,25 +510,24 @@ rspamd_async_elt_dtor (struct rspamd_stat_async_elt *elt)
                elt->cleanup (elt, elt->ud);
        }
 
-       event_del (&elt->timer_ev);
+       ev_timer_stop (elt->event_loop, &elt->timer_ev);
        g_free (elt);
 }
 
 static void
-rspamd_async_elt_on_timer (gint fd, short what, gpointer d)
+rspamd_async_elt_on_timer (EV_P_ ev_timer *w, int revents)
 {
-       struct rspamd_stat_async_elt *elt = d;
+       struct rspamd_stat_async_elt *elt = (struct rspamd_stat_async_elt *)w->data;
        gdouble jittered_time;
 
-       event_del (&elt->timer_ev);
 
        if (elt->enabled) {
                elt->handler (elt, elt->ud);
        }
 
        jittered_time = rspamd_time_jitter (elt->timeout, 0);
-       double_to_tv (jittered_time, &elt->tv);
-       event_add (&elt->timer_ev, &elt->tv);
+       elt->timer_ev.repeat = jittered_time;
+       ev_timer_again (EV_A_ w);
 }
 
 struct rspamd_stat_async_elt*
@@ -548,21 +547,19 @@ rspamd_stat_ctx_register_async (rspamd_stat_async_handler handler,
        elt->cleanup = cleanup;
        elt->ud = d;
        elt->timeout = timeout;
+       elt->event_loop = st_ctx->event_loop;
        REF_INIT_RETAIN (elt, rspamd_async_elt_dtor);
        /* Enabled by default */
 
 
-       if (st_ctx->ev_base) {
+       if (st_ctx->event_loop) {
                elt->enabled = TRUE;
-               event_set (&elt->timer_ev, -1, EV_TIMEOUT, rspamd_async_elt_on_timer, elt);
-               event_base_set (st_ctx->ev_base, &elt->timer_ev);
                /*
                 * First we set timeval to zero as we want cb to be executed as
                 * fast as possible
                 */
-               elt->tv.tv_sec = 0;
-               elt->tv.tv_usec = 0;
-               event_add (&elt->timer_ev, &elt->tv);
+               ev_timer_init (&elt->timer_ev, rspamd_async_elt_on_timer, 0.0, 0.0);
+               ev_timer_start (st_ctx->event_loop, &elt->timer_ev);
        }
        else {
                elt->enabled = FALSE;

diff --git a/src/libstat/stat_internal.h b/src/libstat/stat_internal.h
index 84c1de2be21907272fd42a8a669b427b08f1cdf2..50dbae9c10ac8ef548cb4779d81e239a35386492 100644 (file)
--- a/src/libstat/stat_internal.h
+++ b/src/libstat/stat_internal.h
@@ -62,8 +62,8 @@ typedef void (*rspamd_stat_async_cleanup)(struct rspamd_stat_async_elt *elt,
 struct rspamd_stat_async_elt {
        rspamd_stat_async_handler handler;
        rspamd_stat_async_cleanup cleanup;
-       struct event timer_ev;
-       struct timeval tv;
+       struct ev_loop *event_loop;
+       ev_timer timer_ev;
        gdouble timeout;
        gboolean enabled;
        gpointer ud;
@@ -93,7 +93,7 @@ struct rspamd_stat_ctx {
        struct rspamd_stat_tokenizer *tokenizer;
        gpointer tkcf;
 
-       struct ev_loop *ev_base;
+       struct ev_loop *event_loop;
 };
 
 typedef enum rspamd_learn_cache_result {