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;
}
