view release on metacpan or  search on metacpan

src/Redis__Fast.xs  view on Meta::CPAN

    if(status != REDIS_OK) {
        // Connection Error!!
        // Redis context will close automatically
        self->ac = NULL;
    } else {
        self->is_connected = 1;
    }
}

static void Redis__Fast_disconnect_cb(redisAsyncContext* c, int status) {
    Redis__Fast self = (Redis__Fast)c->data;
    PERL_UNUSED_VAR(status);
    DEBUG_MSG("disconnected status = %d", status);
    self->ac = NULL;
}

static redisAsyncContext* __build_sock(pTHX_ Redis__Fast self)
{
    redisAsyncContext *ac;
    double timeout;
    int res;

    DEBUG_MSG("%s", "start");

    if(self->on_build_sock) {
        dSP;

        ENTER;
        SAVETMPS;

        PUSHMARK(SP);
        call_sv(self->on_build_sock, G_DISCARD | G_NOARGS);

        FREETMPS;
        LEAVE;
    }

    if(self->path) {
        ac = redisAsyncConnectUnix(self->path);
    } else {
        ac = redisAsyncConnect(self->hostname, self->port);
    }

    if(ac == NULL) {
        DEBUG_MSG("%s", "allocation error");
        return NULL;
    }
    if(ac->err) {
        DEBUG_MSG("connection error: %s", ac->errstr);
        redisAsyncFree(ac);
        return NULL;
    }

    if(self->ssl){
        redisSSLContext* ssl_context;
        redisSSLContextError ssl_error = REDIS_SSL_CTX_NONE;
        redisSSLOptions options = {
            .cacert_filename      = NULL,
            .capath               = NULL,
            .cert_filename        = NULL,
            .private_key_filename = NULL,
            .server_name          = self->hostname,
            .verify_mode          = self->ssl_verify_mode,
        };
        ssl_context = redisCreateSSLContextWithOptions(&options, &ssl_error);

        if(ssl_context == NULL || ssl_error != REDIS_SSL_CTX_NONE) {
            DEBUG_MSG("ssl context error: %s", redisSSLContextGetError(ssl_error));
            redisAsyncFree(ac);
            redisFreeSSLContext(ssl_context);
            return NULL;
        }

        if (redisInitiateSSLWithContext(&ac->c, ssl_context) != REDIS_OK) {
            DEBUG_MSG("ssl connection error: %s", ac->c.errstr);
            redisAsyncFree(ac);
            redisFreeSSLContext(ssl_context);
            return NULL;
        }
        DEBUG_MSG("%s", "ssl connection setup");
    }

    ac->data = (void*)self;
    self->ac = ac;
    self->is_connected = 0;

    Attach(ac);
    redisAsyncSetConnectCallback(ac, (redisConnectCallback*)Redis__Fast_connect_cb);
    redisAsyncSetDisconnectCallback(ac, (redisDisconnectCallback*)Redis__Fast_disconnect_cb);

    // wait to connect...
    timeout = -1;
    if(self->cnx_timeout) {
        timeout = self->cnx_timeout;
    }
    while(!self->is_connected) {
        res = wait_for_event(aTHX_ self, timeout, timeout);
        if(self->ac == NULL) {
            // set is_connected flag to reconnect.
            // see https://github.com/shogo82148/Redis-Fast/issues/73
            self->is_connected = 1;

            return NULL;
        }
        if(res != WAIT_FOR_EVENT_OK) {
            DEBUG_MSG("error: %d", res);

            // free the redis context
            redisAsyncFree(self->ac);
            _wait_all_responses(aTHX_ self);
            self->ac = NULL;

            // set is_connected flag to reconnect.
            // see https://github.com/shogo82148/Redis-Fast/issues/73
            self->is_connected = 1;

            return NULL;
        }
    }
    if(self->on_connect){
        dSP;