int main(int argc, char **argv) { if(argc != 2) { fprintf(stderr, "Usage: %s /dev/<ssp-port>\n", argv[0]); return 1; } signal(SIGPIPE, SIG_IGN); signal(SIGINT, interrupt); fprintf(stderr, "eSSP starting up (port %s)...\n", argv[1]); if(!sspConnectToValidator(argv[1])) { return 3; } eventBase = event_base_new(); atexit(cleanup); setupDatabase(); redisLibeventAttach(db, eventBase); redisAsyncSetConnectCallback(db, connectCallback); redisAsyncSetDisconnectCallback(db, disconnectCallback); event_base_dispatch(eventBase); return 0; }
bool AsyncRedisMgr::redis_init() { m_redis_base = event_base_new(); if (m_redis_base == NULL) { LOG4CPLUS_ERROR(logger,"create event base fail."); return false; } m_redis_context = redisAsyncConnect(m_redis_host.c_str(),m_redis_port); if (m_redis_context != NULL && m_redis_context->err) { LOG4CPLUS_ERROR(logger,"connect redis fail: "<<m_redis_context->errstr); return false; } if(redisLibeventAttach(m_redis_context,m_redis_base) != REDIS_OK) { LOG4CPLUS_ERROR(logger,"when we bind the redisconext with eventbase fail."); return false; } return true; }
void connect() { if(redisContext_) { throw IllegalStateException("Error redisContext already created"); } state_ = REDISREQUEST_CONNECTING; ScopedMutexLock(lockRedis_); redisContext_ = redisAsyncConnect(host_.c_str(), port_); if (redisContext_->err) { _LOG_DEBUG("REDIS CONNECT FAILED (CREATE ERROR): %s:%d, err = %x, this = %p" , host_.c_str(), port_, redisContext_->err, this); state_ = REDISREQUEST_CONNECTFAILED; //fire_onRedisRequest_Error(redisContext_->err, "connect error", NULL); // disconnectCallback() is called later soon.. // error process will be executed by that function. } redisContext_->data = this; redisLibeventAttach(redisContext_, (struct event_base *)ioService_->coreHandle()); redisAsyncSetConnectCallback(redisContext_, connectCallback); redisAsyncSetDisconnectCallback(redisContext_, disconnectCallback); timerObj_->setTimer(TIMER_ID_CONNECTION_TIMEOUT, DEFAULT_CONNECT_TIMEOUT, false); _LOG_DEBUG("redis connect start : %s:%d, flag = 0x%x, fd = %d, context = %p, this = %p" , host_.c_str(), port_, redisContext_->c.flags, redisContext_->c.fd, redisContext_, this); }
gpointer rspamd_redis_runtime (struct rspamd_task *task, struct rspamd_statfile_config *stcf, gboolean learn, gpointer c) { struct redis_stat_ctx *ctx = REDIS_CTX (c); struct redis_stat_runtime *rt; struct upstream *up; rspamd_inet_addr_t *addr; g_assert (ctx != NULL); g_assert (stcf != NULL); if (learn && ctx->write_servers == NULL) { msg_err_task ("no write servers defined for %s, cannot learn", stcf->symbol); return NULL; } if (learn) { up = rspamd_upstream_get (ctx->write_servers, RSPAMD_UPSTREAM_MASTER_SLAVE, NULL, 0); } else { up = rspamd_upstream_get (ctx->read_servers, RSPAMD_UPSTREAM_ROUND_ROBIN, NULL, 0); } if (up == NULL) { msg_err_task ("no upstreams reachable"); return NULL; } rt = rspamd_mempool_alloc0 (task->task_pool, sizeof (*rt)); rspamd_redis_expand_object (ctx->redis_object, ctx, task, &rt->redis_object_expanded); rt->selected = up; rt->task = task; rt->ctx = ctx; rt->stcf = stcf; addr = rspamd_upstream_addr (up); g_assert (addr != NULL); rt->redis = redisAsyncConnect (rspamd_inet_address_to_string (addr), rspamd_inet_address_get_port (addr)); if (rt->redis == NULL) { msg_err_task ("cannot connect redis"); return NULL; } redisLibeventAttach (rt->redis, task->ev_base); rspamd_redis_maybe_auth (ctx, rt->redis); return rt; }
static void *redis_subscribe(void *args) { struct cachefs *fs = (struct cachefs *)args; redisLibeventAttach(handle->async, handle->event_base); redisAsyncCommand(handle->async, on_subscribe_msg, fs, \ "SUBSCRIBE %s", fs->redis_res_channel); event_base_dispatch(handle->event_base); }
void redis_disconnect_callback(const redisAsyncContext* c, int status) { struct nbd_handle* handle; if (c->data) { handle = (struct nbd_handle*) c->data; } else { fprintf_light_red(stderr, "FATAL: Handle not passed to disconnect " "callback.\n"); assert(c->data != NULL); return; } if (status != REDIS_OK) { if (c->err == REDIS_ERR_EOF) /* probably standard timeout, reconnect */ { fprintf_red(stderr, "Redis server disconnected us.\n"); if ((handle->redis_c = redisAsyncConnect(handle->redis_server, handle->redis_port)) != NULL) { fprintf_blue(stderr, "New Redis context, attaching to " "libevent.\n"); handle->redis_c->data = c->data; redisLibeventAttach(handle->redis_c, handle->eb); fprintf_blue(stderr, "Setting disconnect callback.\n"); if (redisAsyncSetDisconnectCallback(handle->redis_c, &redis_disconnect_callback) != REDIS_ERR) { assert(redisAsyncCommand(handle->redis_c, &redis_async_callback, NULL, "select %d", handle->redis_db) == REDIS_OK); fprintf_light_blue(stderr, "Successfully reconnected to " "the Redis server.\n"); } else { fprintf_light_red(stderr, "Error setting disconnect " "callback handler for Redis.\n"); } } else { fprintf_light_red(stderr, "Error trying to reconnect to " "Redis.\n"); } return; } fprintf_light_red(stderr, "FATAL ERROR DISCONNECTION FROM REDIS\n"); fprintf_light_blue(stderr, "Error: %s\n", c->errstr); assert(false); } }
int main (int argc, char **argv) { signal(SIGPIPE, SIG_IGN); struct event_base *base = event_base_new(); const char *hostname = (argc > 1) ? argv[1] : "127.0.0.1"; int port = (argc > 2) ? atoi(argv[2]) : 6379; const char *subname = (argc > 3) ? argv[3] : "test"; redisAsyncContext *c = redisAsyncConnect(hostname, port); if (c->err) { /* Let *c leak for now... */ printf("Error: %s\n", c->errstr); return 1; } g_yuv_size = 1920*1080*3/2; g_yuv = malloc(g_yuv_size); start_time = time((time_t*)NULL); now_time = time((time_t*)NULL); // init pipe if(pipe(pipe_fd)){ printf("pipe error\n"); return -1; } // create thread pthread_attr_t attr; struct sched_param param; pthread_t tsk_id; pthread_attr_init(&attr); pthread_attr_setschedpolicy(&attr, SCHED_FIFO); pthread_attr_getschedparam(&attr, ¶m); pthread_create(&tsk_id, &attr, (void *)thread_function, NULL); // event redisLibeventAttach(c,base); redisAsyncSetConnectCallback(c,connectCallback); redisAsyncSetDisconnectCallback(c,disconnectCallback); redisAsyncCommand(c, subCallback, (char*) "sub", "SMEMSUBSCRIBE %s", subname); event_base_dispatch(base); return 0; }
static void rspamd_redis_async_stat_cb (struct rspamd_stat_async_elt *elt, gpointer d) { struct redis_stat_ctx *ctx; struct rspamd_redis_stat_elt *redis_elt = elt->ud; struct rspamd_redis_stat_cbdata *cbdata; rspamd_inet_addr_t *addr; g_assert (redis_elt != NULL); ctx = redis_elt->ctx; if (redis_elt->cbdata) { /* We have some other process pending */ rspamd_redis_async_cbdata_cleanup (redis_elt->cbdata); } /* Disable further events unless needed */ elt->enabled = FALSE; cbdata = g_slice_alloc0 (sizeof (*cbdata)); cbdata->selected = rspamd_upstream_get (ctx->read_servers, RSPAMD_UPSTREAM_ROUND_ROBIN, NULL, 0); g_assert (cbdata->selected != NULL); addr = rspamd_upstream_addr (cbdata->selected); g_assert (addr != NULL); cbdata->redis = redisAsyncConnect (rspamd_inet_address_to_string (addr), rspamd_inet_address_get_port (addr)); g_assert (cbdata->redis != NULL); redisLibeventAttach (cbdata->redis, redis_elt->ev_base); cbdata->inflight = 1; cbdata->cur = ucl_object_typed_new (UCL_OBJECT); cbdata->elt = redis_elt; cbdata->cur_keys = g_ptr_array_new (); redis_elt->cbdata = cbdata; /* XXX: deal with timeouts maybe */ /* Get keys in redis that match our symbol */ rspamd_redis_maybe_auth (ctx, cbdata->redis); redisAsyncCommand (cbdata->redis, rspamd_redis_stat_keys, cbdata, "SMEMBERS %s_keys", ctx->stcf->symbol); }
void *command_thread(void *arg) { signal(SIGPIPE, SIG_IGN); struct event_base *base = event_base_new(); printf("starting sub conn\n"); redisAsyncContext *c = redisAsyncConnect(REDIS_HOST, REDIS_HOST_PORT); if (c->err) { printf("REDIS not connected: %s\n", c->errstr); } redisLibeventAttach(c, base); redisAsyncCommand(c, message_handler, NULL, "SUBSCRIBE housekeeping"); event_base_dispatch(base); return 0; }
/** \brief SCConfLogReopenAsyncRedis() Open or re-opens connection to redis for logging. * \param log_ctx Log file context allocated by caller */ static int SCConfLogReopenAsyncRedis(LogFileCtx *log_ctx) { SCLogRedisContext * ctx = log_ctx->redis; const char *redis_server = log_ctx->redis_setup.server; int redis_port = log_ctx->redis_setup.port; /* only try to reconnect once per second */ if (ctx->tried >= time(NULL)) { return -1; } ctx->async = redisAsyncConnect(redis_server, redis_port); if (ctx->ev_base != NULL) { event_base_free(ctx->ev_base); } if (ctx->async == NULL) { SCLogError(SC_ERR_MEM_ALLOC, "Error allocate redis async."); ctx->tried = time(NULL); return -1; } if (ctx->async != NULL && ctx->async->err) { SCLogError(SC_ERR_SOCKET, "Error setting to redis async: [%s].", ctx->async->errstr); ctx->tried = time(NULL); return -1; } ctx->ev_base = event_base_new(); if (ctx->ev_base == NULL) { ctx->tried = time(NULL); redisAsyncFree(ctx->async); ctx->async = NULL; return -1; } redisLibeventAttach(ctx->async, ctx->ev_base); log_ctx->redis = ctx; log_ctx->Close = SCLogFileCloseRedis; return 0; }
int main (int argc, char **argv) { signal(SIGPIPE, SIG_IGN); struct event_base *base = event_base_new(); redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379); if (c->err) { /* Let *c leak for now... */ printf("Error: %s\n", c->errstr); return 1; } redisLibeventAttach(c,base); redisAsyncSetConnectCallback(c,connectCallback); redisAsyncSetDisconnectCallback(c,disconnectCallback); redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1])); redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key"); event_base_dispatch(base); return 0; }
/*Inicia conexao com o Redis e configura as funcoes de callback no libEvent*/ void initRedis( const char * channel, char * id) { signal(SIGPIPE, SIG_IGN); struct event_base *base = event_base_new(); strcpy(globalChannel, channel); setMyID(id); redisAsyncContext * redis = redisAsyncConnect("127.0.0.1", 6379); if ( redis->err ) { printf("Erro conectando no redis %s\n", redis->errstr); exit(EXIT_FAILURE); } initStdin( channel); redisLibeventAttach( redis,base); redisAsyncSetConnectCallback(redis, connectCallback); redisAsyncSetDisconnectCallback( redis,disconnectCallback); event_base_dispatch(base); }
int main (int argc, char **argv) { if (argc < 2) { printf("error need channel to be specified\n"); return 1; } signal(SIGPIPE, SIG_IGN); struct event_base *base = event_base_new(); redisAsyncContext *c = redisAsyncConnect("pub-redis-13387.us-east-1-4.6.ec2.redislabs.com", 13387); redisContext *cs = redisConnect("pub-redis-13387.us-east-1-4.6.ec2.redislabs.com", 13387); if (c->err) { printf("error: %s\n", c->errstr); return 1; } redisLibeventAttach(c, base); redisAsyncCommand(c, onMessage, cs, "SUBSCRIBE %s",argv[1]); event_base_dispatch(base); return 0; }
void func(const std::string& commandStr) { g_SubscribeMutex.lock(); struct event_base *m_base = event_base_new(); redisAsyncContext *m_redis = redisAsyncConnect("127.0.0.1", 6379); if (m_redis->err) { /* Let *c leak for now... */ printf("Error: %s\n", m_redis->errstr); } redisAsyncCommand(m_redis,authCallback, (char*) "auth", "auth %s", "014006"); redisLibeventAttach(m_redis, m_base); redisAsyncSetConnectCallback(m_redis, connectCallback); redisAsyncSetDisconnectCallback(m_redis, disconnectCallback); redisAsyncCommand(m_redis, subscribeCallback, (char*) "sub", commandStr.c_str()); g_SubscribeMutex.unlock(); event_base_dispatch(m_base); }
static struct redis *__redis_connect_async(struct redis *redis) { redis->eb = event_base_new(); LM_INFO("Connecting (ASYNC) to Redis at %s:%d\n", redis->ip, redis->port); redis->async_ctxt = redisAsyncConnect(redis->ip, redis->port); if(redis->async_ctxt->err) { LM_ERR("%s\n", redis->async_ctxt->errstr); return NULL; } redisLibeventAttach(redis->async_ctxt, redis->eb); redisAsyncSetConnectCallback(redis->async_ctxt, __async_connect_cb); redisAsyncSetDisconnectCallback(redis->async_ctxt, __async_disconnect_cb); redisAsyncCommand(redis->async_ctxt, NULL, NULL, "SELECT %d", redis->db); __redis_subscribe_to_kill_list(redis); event_base_dispatch(redis->eb); return redis; }
int RedisConnectionAsync::asyncConnect() { _ac = redisAsyncConnect(_host.c_str(), _port); if (_ac == nullptr) return -1; _ac->data = (void*)this; if (_ac->err) { redisAsyncFree(_ac); _ac = nullptr; return -1; // throw RedisException((std::string)"RedisAsyncConnect: "+_ac->errstr); } if (redisAsyncSetConnectCallback(_ac, &connected)!=REDIS_OK || redisAsyncSetDisconnectCallback(_ac, &disconnected)!=REDIS_OK) { redisAsyncFree(_ac); _ac = nullptr; return -1; // throw RedisException("RedisAsyncConnect: Can't register callbacks"); } #if HIREDISPP_USE_LIBEVENT if (redisLibeventAttach(_ac, (struct event_base *)_loopbase)!=REDIS_OK) { redisAsyncFree(_ac); _ac = nullptr; return -1; // throw RedisException("redisLibeventAttach: nothing should be attached when something is already attached"); } // Send PING command, so libevent start working redisAsyncCommand(_ac, nullptr, nullptr, "PING"); #else // actually start io proccess ev_io_start(EV_DEFAULT, &((((redisLibevEvents*)(_ac->ev.data)))->rev)); ev_io_start(EV_DEFAULT, &((((redisLibevEvents*)(_ac->ev.data)))->wev)); #endif return 0; }
/* * Responsible for subscribing to the Redis "fonz-out" channel, receiving * PUB messages, assembling packets and forwarding them to the serial port. */ void redis_receiver(char *hostname, int port) { redisAsyncContext *ctxt; struct event_base *base; /* * Initialize the Fonz packet transmitter, and the Redis connection. */ fp_init(0, 4); ctxt = redisAsyncConnect(hostname, port); if (ctxt->err) { fprintf(stderr, "?redis (rx) error: %s\n", ctxt->errstr); exit(1); } base = event_base_new(); redisLibeventAttach(ctxt, base); /* * Subscribe to the fonz-out channel, and use the libevent * dispatcher to do the work. */ redisAsyncCommand(ctxt, pkt_recv, NULL, "SUBSCRIBE fonz-out"); event_base_dispatch(base); }
gboolean rspamd_redis_learn_tokens (struct rspamd_task *task, GPtrArray *tokens, gint id, gpointer p) { struct redis_stat_runtime *rt = REDIS_RUNTIME (p); struct upstream *up; rspamd_inet_addr_t *addr; struct timeval tv; rspamd_fstring_t *query; const gchar *redis_cmd; rspamd_token_t *tok; gint ret; up = rspamd_upstream_get (rt->ctx->write_servers, RSPAMD_UPSTREAM_MASTER_SLAVE, NULL, 0); if (up == NULL) { msg_err_task ("no upstreams reachable"); return FALSE; } rt->selected = up; addr = rspamd_upstream_addr (up); g_assert (addr != NULL); rt->redis = redisAsyncConnect (rspamd_inet_address_to_string (addr), rspamd_inet_address_get_port (addr)); g_assert (rt->redis != NULL); redisLibeventAttach (rt->redis, task->ev_base); rspamd_redis_maybe_auth (rt->ctx, rt->redis); /* * Add the current key to the set of learned keys */ redisAsyncCommand (rt->redis, NULL, NULL, "SADD %s_keys %s", rt->stcf->symbol, rt->redis_object_expanded); if (rt->stcf->clcf->flags & RSPAMD_FLAG_CLASSIFIER_INTEGER) { redis_cmd = "HINCRBY"; } else { redis_cmd = "HINCRBYFLOAT"; } rt->id = id; query = rspamd_redis_tokens_to_query (task, tokens, redis_cmd, rt->redis_object_expanded, TRUE, id, rt->stcf->clcf->flags & RSPAMD_FLAG_CLASSIFIER_INTEGER); g_assert (query != NULL); /* * XXX: * Dirty hack: we get a token and check if it's value is -1 or 1, so * we could understand that we are learning or unlearning */ tok = g_ptr_array_index (task->tokens, 0); if (tok->values[id] > 0) { rspamd_printf_fstring (&query, "" "*4\r\n" "$7\r\n" "HINCRBY\r\n" "$%d\r\n" "%s\r\n" "$6\r\n" "learns\r\n" "$1\r\n" "1\r\n", (gint)strlen (rt->redis_object_expanded), rt->redis_object_expanded); } else { rspamd_printf_fstring (&query, "" "*4\r\n" "$7\r\n" "HINCRBY\r\n" "$%d\r\n" "%s\r\n" "$6\r\n" "learns\r\n" "$2\r\n" "-1\r\n", (gint)strlen (rt->redis_object_expanded), rt->redis_object_expanded); } rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)rspamd_fstring_free, query); ret = redisAsyncFormattedCommand (rt->redis, rspamd_redis_learned, rt, query->str, query->len); if (ret == REDIS_OK) { rspamd_session_add_event (task->s, rspamd_redis_fin_learn, rt, rspamd_redis_stat_quark ()); rt->has_event = TRUE; /* Set timeout */ if (event_get_base (&rt->timeout_event)) { event_del (&rt->timeout_event); } event_set (&rt->timeout_event, -1, EV_TIMEOUT, rspamd_redis_timeout, rt); event_base_set (task->ev_base, &rt->timeout_event); double_to_tv (rt->ctx->timeout, &tv); event_add (&rt->timeout_event, &tv); return TRUE; } else { msg_err_task ("call to redis failed: %s", rt->redis->errstr); } return FALSE; }
struct nbd_handle* nbd_init_redis(char* export_name, char* redis_server, int redis_port, int redis_db, uint64_t fsize, char* nodename, char* port, bool old) { struct addrinfo hints; struct addrinfo* server = NULL; struct event_base* eb = NULL; struct nbd_handle* ret = NULL; struct event* evsignal = NULL; struct evconnlistener* conn = NULL; struct redisAsyncContext* redis_c = NULL; /* sanity check */ if (redis_server == NULL || nodename == NULL || port == NULL || export_name == NULL) return NULL; /* setup network socket */ memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; if (getaddrinfo(nodename, port, &hints, &server)) { if (server) freeaddrinfo(server); return NULL; } /* initialize libevent */ if ((eb = event_base_new()) == NULL) { freeaddrinfo(server); return NULL; } /* initialize libhiredis */ if ((redis_c = redisAsyncConnect(redis_server, redis_port)) == NULL) { freeaddrinfo(server); event_base_free(eb); return NULL; } redisLibeventAttach(redis_c, eb); /* set disconnect handler */ if (redisAsyncSetDisconnectCallback(redis_c, &redis_disconnect_callback) == REDIS_ERR) { redisAsyncDisconnect(redis_c); freeaddrinfo(server); event_base_free(eb); return NULL; } /* initialize this nbd module */ if ((ret = (struct nbd_handle*) malloc(sizeof(struct nbd_handle))) == NULL) { freeaddrinfo(server); event_base_free(eb); return NULL; } redis_c->data = ret; /* set unused field for disconnect callback */ evsignal = evsignal_new(eb, SIGINT, nbd_signal_handler, (void *)ret); if (!evsignal || event_add(evsignal, NULL) < 0) { freeaddrinfo(server); event_base_free(eb); return NULL; } /* setup network connection */ if ((conn = evconnlistener_new_bind(eb, old ? &nbd_old_conn : &nbd_new_conn, ret, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1, server->ai_addr, server->ai_addrlen)) == NULL) { freeaddrinfo(server); event_base_free(eb); free(ret); return NULL; } evconnlistener_set_error_cb(conn, nbd_event_error); ret->fd = -1; ret->size = fsize; ret->export_name = export_name; ret->redis_server = redis_server; ret->name_len = strlen(export_name); ret->redis_port = redis_port; ret->redis_db = redis_db; ret->eb = eb; ret->conn = conn; ret->redis_c = redis_c; assert(redisAsyncCommand(redis_c, &redis_async_callback, NULL, "select %d", redis_db) == REDIS_OK); freeaddrinfo(server); return ret; }
/*** * @function rspamd_redis.make_request({params}) * Make request to redis server, params is a table of key=value arguments in any order * @param {task} task worker task object * @param {ip} host server address * @param {function} callback callback to be called in form `function (task, err, data)` * @param {string} cmd command to be sent to redis * @param {table} args numeric array of strings used as redis arguments * @param {number} timeout timeout in seconds for request (1.0 by default) * @return {boolean} `true` if a request has been scheduled */ static int lua_redis_make_request (lua_State *L) { struct lua_redis_userdata *ud; struct rspamd_lua_ip *addr = NULL; struct rspamd_task *task = NULL; const gchar *cmd = NULL; gint top, cbref = -1; struct timeval tv; gboolean ret = FALSE; gdouble timeout = REDIS_DEFAULT_TIMEOUT; if (lua_istable (L, 1)) { /* Table version */ lua_pushstring (L, "task"); lua_gettable (L, -2); if (lua_type (L, -1) == LUA_TUSERDATA) { task = lua_check_task (L, -1); } lua_pop (L, 1); lua_pushstring (L, "callback"); lua_gettable (L, -2); if (lua_type (L, -1) == LUA_TFUNCTION) { /* This also pops function from the stack */ cbref = luaL_ref (L, LUA_REGISTRYINDEX); } else { msg_err ("bad callback argument for lua redis"); lua_pop (L, 1); } lua_pushstring (L, "cmd"); lua_gettable (L, -2); cmd = lua_tostring (L, -1); lua_pop (L, 1); lua_pushstring (L, "host"); lua_gettable (L, -2); if (lua_type (L, -1) == LUA_TUSERDATA) { addr = lua_check_ip (L, -1); } lua_pop (L, 1); lua_pushstring (L, "timeout"); lua_gettable (L, -2); timeout = lua_tonumber (L, -1); lua_pop (L, 1); if (task != NULL && addr != NULL && cbref != -1 && cmd != NULL) { ud = rspamd_mempool_alloc (task->task_pool, sizeof (struct lua_redis_userdata)); ud->task = task; ud->L = L; ud->cbref = cbref; lua_pushstring (L, "args"); lua_redis_parse_args (L, -1, cmd, ud); ret = TRUE; } else { if (cbref != -1) { luaL_unref (L, LUA_REGISTRYINDEX, cbref); } msg_err ("incorrect function invocation"); } } else if ((task = lua_check_task (L, 1)) != NULL) { addr = lua_check_ip (L, 2); top = lua_gettop (L); /* Now get callback */ if (lua_isfunction (L, 3) && addr != NULL && addr->addr && top >= 4) { /* Create userdata */ ud = rspamd_mempool_alloc (task->task_pool, sizeof (struct lua_redis_userdata)); ud->task = task; ud->L = L; /* Pop other arguments */ lua_pushvalue (L, 3); /* Get a reference */ ud->cbref = luaL_ref (L, LUA_REGISTRYINDEX); cmd = luaL_checkstring (L, 4); if (top > 4) { lua_redis_parse_args (L, 5, cmd, ud); } else { lua_redis_parse_args (L, 0, cmd, ud); } ret = TRUE; } else { msg_err ("incorrect function invocation"); } } if (ret) { ud->terminated = 0; ud->ctx = redisAsyncConnect (rspamd_inet_address_to_string (addr->addr), rspamd_inet_address_get_port (addr->addr)); redisAsyncSetConnectCallback (ud->ctx, lua_redis_connect_cb); if (ud->ctx == NULL || ud->ctx->err) { ud->terminated = 1; redisAsyncFree (ud->ctx); lua_redis_free_args (ud); luaL_unref (ud->L, LUA_REGISTRYINDEX, ud->cbref); lua_pushboolean (L, FALSE); return 1; } redisLibeventAttach (ud->ctx, ud->task->ev_base); ret = redisAsyncCommandArgv (ud->ctx, lua_redis_callback, ud, ud->nargs, (const gchar **)ud->args, NULL); if (ret == REDIS_OK) { rspamd_session_add_event (ud->task->s, lua_redis_fin, ud, g_quark_from_static_string ("lua redis")); double_to_tv (timeout, &tv); event_set (&ud->timeout, -1, EV_TIMEOUT, lua_redis_timeout, ud); event_base_set (ud->task->ev_base, &ud->timeout); event_add (&ud->timeout, &tv); } else { msg_info ("call to redis failed: %s", ud->ctx->errstr); ud->terminated = 1; lua_redis_free_args (ud); redisAsyncFree (ud->ctx); luaL_unref (ud->L, LUA_REGISTRYINDEX, ud->cbref); } } lua_pushboolean (L, ret); return 1; }
void AsyncService::attach(redisAsyncContext* ac) { redisLibeventAttach(ac, base_); }
gpointer rspamd_stat_cache_redis_runtime (struct rspamd_task *task, gpointer c, gboolean learn) { struct rspamd_redis_cache_ctx *ctx = c; struct rspamd_redis_cache_runtime *rt; struct upstream *up; rspamd_inet_addr_t *addr; g_assert (ctx != NULL); if (learn && ctx->write_servers == NULL) { msg_err_task ("no write servers defined for %s, cannot learn", ctx->stcf->symbol); return NULL; } if (task->tokens == NULL || task->tokens->len == 0) { return NULL; } if (learn) { up = rspamd_upstream_get (ctx->write_servers, RSPAMD_UPSTREAM_MASTER_SLAVE, NULL, 0); } else { up = rspamd_upstream_get (ctx->read_servers, RSPAMD_UPSTREAM_ROUND_ROBIN, NULL, 0); } if (up == NULL) { msg_err_task ("no upstreams reachable"); return NULL; } rt = rspamd_mempool_alloc0 (task->task_pool, sizeof (*rt)); rt->selected = up; rt->task = task; rt->ctx = ctx; addr = rspamd_upstream_addr (up); g_assert (addr != NULL); rt->redis = redisAsyncConnect (rspamd_inet_address_to_string (addr), rspamd_inet_address_get_port (addr)); g_assert (rt->redis != NULL); redisLibeventAttach (rt->redis, task->ev_base); /* Now check stats */ event_set (&rt->timeout_event, -1, EV_TIMEOUT, rspamd_redis_cache_timeout, rt); event_base_set (task->ev_base, &rt->timeout_event); rspamd_redis_cache_maybe_auth (ctx, rt->redis); if (!learn) { rspamd_stat_cache_redis_generate_id (task); } return rt; }