view release on metacpan or  search on metacpan

src/Fast.xs  view on Meta::CPAN

    timeout.tv_usec = micro_second;
    self->command_timeout = timeout;
    DEBUG_MSG("command timeout %d, %d", second, micro_second);

void
__set_max_retry(Redis::Cluster::Fast self, int max_retry)
CODE:
    self->max_retry = max_retry;
    DEBUG_MSG("max_retry %d", max_retry);

void
__set_route_use_slots(Redis::Cluster::Fast self, int use_slot)
CODE:
    self->use_cluster_slots = use_slot;

void
__set_cluster_discovery_retry_timeout(Redis::Cluster::Fast self, double double_sec)
CODE:
    self->discovery_timeout_usec = (int64_t) (double_sec * ONE_SECOND_TO_MICRO);
    DEBUG_MSG("discovery timeout %ld", self->discovery_timeout_usec);

SV*
__connect(Redis::Cluster::Fast self)
CODE:
    RETVAL = Redis__Cluster__Fast_connect(aTHX_ self);
    if (RETVAL == NULL) {
        RETVAL = &PL_sv_undef;
    }
OUTPUT:
    RETVAL

SV*
__disconnect(Redis::Cluster::Fast self)
CODE:
    RETVAL = Redis__Cluster__Fast_disconnect(aTHX_ self);
    if (RETVAL == NULL) {
        RETVAL = &PL_sv_undef;
    }
OUTPUT:
    RETVAL

SV*
__wait_until_event_ready(Redis::Cluster::Fast self)
CODE:
    RETVAL = Redis__Cluster__Fast_wait_until_event_ready(aTHX_ self);
    if (RETVAL == NULL) {
        RETVAL = &PL_sv_undef;
    }
OUTPUT:
    RETVAL

void
__std_cmd(Redis::Cluster::Fast self, ...)
PREINIT:
    cmd_reply_context_t* result_context;
    char** argv;
    size_t* argvlen;
    STRLEN len;
    int argc, i;
    SV* cb;
PPCODE:
    if (!self->acc) {
       croak("Not connected to any server");
    }

    cb = ST(items - 1);
    if (SvROK(cb) && SvTYPE(SvRV(cb)) == SVt_PVCV) {
        argc = items - 2;
    } else {
        cb = NULL;
        argc = items - 1;
    }

    Newx(argv, sizeof(char*) * argc, char*);
    Newx(argvlen, sizeof(size_t) * argc, size_t);
    Newx(result_context, sizeof(cmd_reply_context_t), cmd_reply_context_t);

    for (i = 0; i < argc; i++) {
        argv[i] = SvPV(ST(i + 1), len);
        argvlen[i] = len;
    }

    Redis__Cluster__Fast_run_cmd(aTHX_ self, argc, (const char **) argv, argvlen, result_context, cb);

    ST(0) = result_context->result ?
            sv_2mortal(result_context->result) : &PL_sv_undef;
    ST(1) = result_context->error ?
            sv_2mortal(result_context->error) : &PL_sv_undef;

    Safefree(argv);
    Safefree(argvlen);
    Safefree(result_context);

    XSRETURN(2);

int
__run_event_loop(Redis::Cluster::Fast self)
CODE:
    RETVAL = Redis__Cluster__Fast_run_event_loop(aTHX_ self);
OUTPUT:
    RETVAL

int
__wait_one_response(Redis::Cluster::Fast self)
CODE:
    RETVAL = Redis__Cluster__Fast_wait_one_response(aTHX_ self);
OUTPUT:
    RETVAL

int
__wait_all_responses(Redis::Cluster::Fast self)
CODE:
    RETVAL = Redis__Cluster__Fast_wait_all_responses(aTHX_ self);
OUTPUT:
    RETVAL

void
DESTROY(Redis::Cluster::Fast self)
CODE:
    if (self->cluster_event_base) {
        DEBUG_MSG("%s", "trying to free event_base");