redis clients phpredis phpredis_program

PhpRedis Program and Struct

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

PHP & Zend

PHP version 7.2.34 -> /usr/include/php
Zend version 3.2.0 -> /usr/include/php/Zend
PhpRedis 5.3.3

목차

• redis_string_response() -> library.c
• redis_sock_read() -> library.c
• INTERNAL_FUNCTION_PARAMETERS -> zend.h
• ZVAL -> zend_types.h
• RETVAL_BOOL -> zend_API.h
• PHP_METHOD
• struct RedisSock -> PhpRedis common.h
• struct RedisArray -> PhpRedis redis_array.h
• struct redisClusterNode -> PhpRedis cluster_library.h

redis_string_response()

redis_string_response()는 phpredis -> library.c에 있고, get, lpop, rpop, spop, hget에서 사용합니다.

PHP_REDIS_API void redis_string_response( INTERNAL_FUNCTION_PARAMETERS,
          RedisSock *redis_sock, zval *z_tab, void *ctx) {
  char *response;
  int response_len;
  if ((response = redis_sock_read(redis_sock, &response_len)) == NULL) {
    if ( IS_ATOMIC(redis_sock)) {
      RETURN_FALSE;
    }
    add_next_index_bool(z_tab, 0);
    return;
  }
  if (IS_ATOMIC(redis_sock)) {
    if (!redis_unpack(redis_sock, response, response_len, return_value)) {
      RETVAL_STRINGL(response, response_len);
    }
  } else {
    zval z_unpacked;
    if (redis_unpack(redis_sock, response, response_len, &z_unpacked)) {
      add_next_index_zval(z_tab, &z_unpacked);
    } else {
      add_next_index_stringl(z_tab, response, response_len);
    }
  }
  efree(response);
}

redis_string_response( INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, NULL);

redis_sock_read()

레디스 응답(reply) 코드에 따른 처리를 볼 수 있다.

PHP_REDIS_API char * redis_sock_read(RedisSock *redis_sock, int *buf_len) { char inbuf[4096]; size_t len; *buf_len = 0; if (redis_sock_gets(redis_sock, inbuf, sizeof(inbuf) - 1, &len) < 0) { return NULL; } switch(inbuf[0]) { case '-': /* Redis Error */ redis_sock_set_err(redis_sock, inbuf+1, len); /* Filter our ERROR through the few that should actually throw */ redis_error_throw(redis_sock); return NULL; case '$': /* Redis Bulk */ *buf_len = atoi(inbuf + 1); return redis_sock_read_bulk_reply(redis_sock, *buf_len); case '*': /* Redis Array(multibulk) */ /* For null multi-bulk replies (like timeouts from brpoplpush): */ if(memcmp(inbuf + 1, "-1", 2) == 0) { return NULL; } /* fall through */ case '+': /* Redis Status */ case ':': /* Redis Integer */ /* Single Line Reply */ /* +OK or :123 */ if (len > 1) { *buf_len = len; return estrndup(inbuf, *buf_len); } default: zend_throw_exception_ex(redis_exception_ce, 0, "protocol error, got '%c' as reply type byte\n", inbuf[0]); } return NULL; }

INTERNAL_FUNCTION_PARAMETERS

zend.h

#define INTERNAL_FUNCTION_PARAMETERS zend_execute_data *execute_data, zval *return_value #define INTERNAL_FUNCTION_PARAM_PASSTHRU execute_data, return_value

ZVAL

zend_types.h

typedef struct _zval_struct zval; struct _zval_struct { zend_value value; /* value */ union { struct { ZEND_ENDIAN_LOHI_4( zend_uchar type, /* active type */ zend_uchar type_flags, zend_uchar const_flags, zend_uchar reserved) /* call info for EX(This) */ } v; uint32_t type_info; } u1; union { uint32_t next; /* hash collision chain */ uint32_t cache_slot; /* literal cache slot */ uint32_t lineno; /* line number (for ast nodes) */ uint32_t num_args; /* arguments number for EX(This) */ uint32_t fe_pos; /* foreach position */ uint32_t fe_iter_idx; /* foreach iterator index */ uint32_t access_flags; /* class constant access flags */ uint32_t property_guard; /* single property guard */ uint32_t extra; /* not further specified */ } u2; }; typedef union _zend_value { zend_long lval; /* long value */ double dval; /* double value */ zend_refcounted *counted; zend_string *str; zend_array *arr; zend_object *obj; zend_resource *res; zend_reference *ref; zend_ast_ref *ast; zval *zv; void *ptr; zend_class_entry *ce; zend_function *func; struct { uint32_t w1; uint32_t w2; } ww; } zend_value;
• WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN # define ZEND_ENDIAN_LOHI(lo, hi) hi; lo; # define ZEND_ENDIAN_LOHI_3(lo, mi, hi) hi; mi; lo; # define ZEND_ENDIAN_LOHI_4(a, b, c, d) d; c; b; a; # define ZEND_ENDIAN_LOHI_C(lo, hi) hi, lo # define ZEND_ENDIAN_LOHI_C_3(lo, mi, hi) hi, mi, lo, # define ZEND_ENDIAN_LOHI_C_4(a, b, c, d) d, c, b, a #else # define ZEND_ENDIAN_LOHI(lo, hi) lo; hi; # define ZEND_ENDIAN_LOHI_3(lo, mi, hi) lo; mi; hi; # define ZEND_ENDIAN_LOHI_4(a, b, c, d) a; b; c; d; # define ZEND_ENDIAN_LOHI_C(lo, hi) lo, hi # define ZEND_ENDIAN_LOHI_C_3(lo, mi, hi) lo, mi, hi, # define ZEND_ENDIAN_LOHI_C_4(a, b, c, d) a, b, c, d #endif
• regular data types /* regular data types */ #define IS_UNDEF 0 #define IS_NULL 1 #define IS_FALSE 2 #define IS_TRUE 3 #define IS_LONG 4 #define IS_DOUBLE 5 #define IS_STRING 6 #define IS_ARRAY 7 #define IS_OBJECT 8 #define IS_RESOURCE 9 #define IS_REFERENCE 10 /* constant expressions */ #define IS_CONSTANT 11 #define IS_CONSTANT_AST 12 /* fake types */ #define _IS_BOOL 13 #define IS_CALLABLE 14 #define IS_VOID 18 #define IS_ITERABLE 19 /* internal types */ #define IS_INDIRECT 15 #define IS_PTR 17 #define _IS_ERROR 20
• Z_TYPE_INFO #define Z_TYPE_INFO(zval) (zval).u1.type_info #define Z_TYPE_INFO_P(zval_p) Z_TYPE_INFO(*(zval_p)) #define ZVAL_UNDEF(z) do { Z_TYPE_INFO_P(z) = IS_UNDEF; } while (0) #define ZVAL_NULL(z) do { Z_TYPE_INFO_P(z) = IS_NULL; } while (0) #define ZVAL_FALSE(z) do { Z_TYPE_INFO_P(z) = IS_FALSE; } while (0) #define ZVAL_TRUE(z) do { Z_TYPE_INFO_P(z) = IS_TRUE; } while (0) #define ZVAL_BOOL(z, b) do { Z_TYPE_INFO_P(z) = (b) ? IS_TRUE : IS_FALSE; } while (0) #define ZVAL_LONG(z, l) { zval *__z = (z); Z_LVAL_P(__z) = l; Z_TYPE_INFO_P(__z) = IS_LONG; } #define ZVAL_DOUBLE(z, d) { zval *__z = (z); Z_DVAL_P(__z) = d; Z_TYPE_INFO_P(__z) = IS_DOUBLE; }

zend_API.h

#define RETVAL_BOOL(b) ZVAL_BOOL(return_value, b) #define RETVAL_NULL() ZVAL_NULL(return_value) #define RETVAL_LONG(l) ZVAL_LONG(return_value, l) #define RETVAL_DOUBLE(d) ZVAL_DOUBLE(return_value, d) #define RETVAL_STR(s) ZVAL_STR(return_value, s) #define RETVAL_INTERNED_STR(s) ZVAL_INTERNED_STR(return_value, s) #define RETVAL_NEW_STR(s) ZVAL_NEW_STR(return_value, s) #define RETVAL_STR_COPY(s) ZVAL_STR_COPY(return_value, s) #define RETVAL_STRING(s) ZVAL_STRING(return_value, s) #define RETVAL_STRINGL(s, l) ZVAL_STRINGL(return_value, s, l) #define RETVAL_EMPTY_STRING() ZVAL_EMPTY_STRING(return_value) #define RETVAL_RES(r) ZVAL_RES(return_value, r) #define RETVAL_ARR(r) ZVAL_ARR(return_value, r) #define RETVAL_OBJ(r) ZVAL_OBJ(return_value, r) #define RETVAL_ZVAL(zv, copy, dtor) ZVAL_ZVAL(return_value, zv, copy, dtor) #define RETVAL_FALSE ZVAL_FALSE(return_value) #define RETVAL_TRUE ZVAL_TRUE(return_value) #define RETURN_BOOL(b) { RETVAL_BOOL(b); return; } #define RETURN_NULL() { RETVAL_NULL(); return;} #define RETURN_LONG(l) { RETVAL_LONG(l); return; } #define RETURN_DOUBLE(d) { RETVAL_DOUBLE(d); return; } #define RETURN_STR(s) { RETVAL_STR(s); return; } #define RETURN_INTERNED_STR(s) { RETVAL_INTERNED_STR(s); return; } #define RETURN_NEW_STR(s) { RETVAL_NEW_STR(s); return; } #define RETURN_STR_COPY(s) { RETVAL_STR_COPY(s); return; } #define RETURN_STRING(s) { RETVAL_STRING(s); return; } #define RETURN_STRINGL(s, l) { RETVAL_STRINGL(s, l); return; } #define RETURN_EMPTY_STRING() { RETVAL_EMPTY_STRING(); return; } #define RETURN_RES(r) { RETVAL_RES(r); return; } #define RETURN_ARR(r) { RETVAL_ARR(r); return; } #define RETURN_OBJ(r) { RETVAL_OBJ(r); return; } #define RETURN_ZVAL(zv, copy, dtor) { RETVAL_ZVAL(zv, copy, dtor); return; } #define RETURN_FALSE { RETVAL_FALSE; return; } #define RETURN_TRUE { RETVAL_TRUE; return; }
• 1) 배열 인덱스를 지정 specific ZEND_API int add_index_long(zval *arg, zend_ulong idx, zend_long n); ZEND_API int add_index_null(zval *arg, zend_ulong idx); ZEND_API int add_index_bool(zval *arg, zend_ulong idx, int b); ZEND_API int add_index_resource(zval *arg, zend_ulong idx, zend_resource *r); ZEND_API int add_index_double(zval *arg, zend_ulong idx, double d); ZEND_API int add_index_str(zval *arg, zend_ulong idx, zend_string *str); ZEND_API int add_index_string(zval *arg, zend_ulong idx, const char *str); ZEND_API int add_index_stringl(zval *arg, zend_ulong idx, const char *str, size_t length); -> 문자열 길이를 알고 있을 때, 바이너리일 때 ZEND_API int add_index_zval(zval *arg, zend_ulong index, zval *value);
• 2) 배열 다음 next 인덱스 자동 지정 ZEND_API int add_next_index_long(zval *arg, zend_long n); ZEND_API int add_next_index_null(zval *arg); ZEND_API int add_next_index_bool(zval *arg, int b); ZEND_API int add_next_index_resource(zval *arg, zend_resource *r); ZEND_API int add_next_index_double(zval *arg, double d); ZEND_API int add_next_index_str(zval *arg, zend_string *str); ZEND_API int add_next_index_string(zval *arg, const char *str); ZEND_API int add_next_index_stringl(zval *arg, const char *str, size_t length); ZEND_API int add_next_index_zval(zval *arg, zval *value);
• 3) 배열 연관 associative 인덱스 지정 ZEND_API int add_assoc_long_ex(zval *arg, const char *key, size_t key_len, zend_long n); ZEND_API int add_assoc_null_ex(zval *arg, const char *key, size_t key_len); ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, size_t key_len, int b); ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, size_t key_len, zend_resource *r); ZEND_API int add_assoc_double_ex(zval *arg, const char *key, size_t key_len, double d); ZEND_API int add_assoc_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str); ZEND_API int add_assoc_string_ex(zval *arg, const char *key, size_t key_len, const char *str); ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, size_t key_len, const char *str, size_t length); ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, size_t key_len, zval *value);

PHP_METHOD -> zend_API.h

• php.h #define PHP_FUNCTION ZEND_FUNCTION #define PHP_METHOD ZEND_METHOD
• zend_API.h #define ZEND_FN(name) zif_##name #define ZEND_MN(name) zim_##name #define ZEND_NAMED_FUNCTION(name) void name(INTERNAL_FUNCTION_PARAMETERS) #define ZEND_FUNCTION(name) ZEND_NAMED_FUNCTION(ZEND_FN(name)) #define ZEND_METHOD(classname, name) ZEND_NAMED_FUNCTION(ZEND_MN(classname##_##name)) #define ZEND_NUM_ARGS() EX_NUM_ARGS()
• zend_complie.h #define ZEND_CALL_NUM_ARGS(call) (call)->This.u2.num_args #define EX_NUM_ARGS() ZEND_CALL_NUM_ARGS(execute_data)

PhpRedis

PhpRedis 5.3.3

common.h

• struct RedisSock /* {{{ struct RedisSock */ typedef struct { php_stream *stream; php_stream_context *stream_ctx; zend_string *host; int port; zend_string *user; zend_string *pass; double timeout; double read_timeout; long retry_interval; redis_sock_status status; int persistent; int watching; zend_string *persistent_id; redis_serializer serializer; int compression; int compression_level; long dbNumber; zend_string *prefix; short mode; fold_item *head; fold_item *current; zend_string *pipeline_cmd; zend_string *err; int scan; int readonly; int reply_literal; int null_mbulk_as_null; int tcp_keepalive; } RedisSock; /* }}} */
• Transaction modes #define ATOMIC 0 #define MULTI 1 #define PIPELINE 2 #define IS_ATOMIC(redis_sock) (redis_sock->mode == ATOMIC) #define IS_MULTI(redis_sock) (redis_sock->mode & MULTI) #define IS_PIPELINE(redis_sock) (redis_sock->mode & PIPELINE)
• REDIS_PROCESS_CMD /* Process a command assuming our command where our command building * function is redis_<cmdname>_cmd */ #define REDIS_PROCESS_CMD(cmdname, resp_func) \ RedisSock *redis_sock; char *cmd; int cmd_len; void *ctx=NULL; \ if ((redis_sock = redis_sock_get(getThis(), 0)) == NULL || \ redis_##cmdname##_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU,redis_sock, \ &cmd, &cmd_len, NULL, &ctx)==FAILURE) { \ RETURN_FALSE; \ } \ REDIS_PROCESS_REQUEST(redis_sock, cmd, cmd_len); \ if (IS_ATOMIC(redis_sock)) { \ resp_func(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, ctx); \ } else { \ REDIS_PROCESS_RESPONSE_CLOSURE(resp_func, ctx) \ }
• REDIS_PROCESS_KW_CMD /* Process a command but with a specific command building function * and keyword which is passed to us*/ #define REDIS_PROCESS_KW_CMD(kw, cmdfunc, resp_func) \ RedisSock *redis_sock; char *cmd; int cmd_len; void *ctx=NULL; \ if ((redis_sock = redis_sock_get(getThis(), 0)) == NULL || \ cmdfunc(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, kw, &cmd, \ &cmd_len, NULL, &ctx)==FAILURE) { \ RETURN_FALSE; \ } \ REDIS_PROCESS_REQUEST(redis_sock, cmd, cmd_len); \ if (IS_ATOMIC(redis_sock)) { \ resp_func(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, ctx); \ } else { \ REDIS_PROCESS_RESPONSE_CLOSURE(resp_func, ctx) \ }
• REDIS_PROCESS_REQUEST #define REDIS_PROCESS_REQUEST(redis_sock, cmd, cmd_len) \ if (IS_PIPELINE(redis_sock)) { \ PIPELINE_ENQUEUE_COMMAND(cmd, cmd_len); \ } else { \ SOCKET_WRITE_COMMAND(redis_sock, cmd, cmd_len); \ } \ efree(cmd);
• REDIS_PROCESS_RESPONSE #define REDIS_PROCESS_RESPONSE_CLOSURE(function, closure_context) \ if (!IS_PIPELINE(redis_sock)) { \ if (redis_response_enqueued(redis_sock) != SUCCESS) { \ RETURN_FALSE; \ } \ } \ REDIS_SAVE_CALLBACK(function, closure_context); \ RETURN_ZVAL(getThis(), 1, 0); \ #define REDIS_PROCESS_RESPONSE(function) else { \ REDIS_PROCESS_RESPONSE_CLOSURE(function, NULL) \ }

redis_array.h

• struct RedisArray typedef struct RedisArray_ { int count; zend_string **hosts; /* array of host:port strings */ zval *redis; /* array of Redis instances */ zval *z_multi_exec; /* Redis instance to be used in multi-exec */ zend_bool index; /* use per-node index */ zend_bool auto_rehash; /* migrate keys on read operations */ zend_bool pconnect; /* should we use pconnect */ zval z_fun; /* key extractor, callable */ zval z_dist; /* key distributor, callable */ zend_string *algorithm; /* key hashing algorithm name */ HashTable *pure_cmds; /* hash table */ double connect_timeout; /* socket connect timeout */ double read_timeout; /* socket read timeout */ Continuum *continuum; struct RedisArray_ *prev; } RedisArray;

cluster_library.h

• struct redisClusterNode /* A Redis Cluster master node */ typedef struct redisClusterNode { RedisSock *sock; /* Our Redis socket in question */ short slot; /* One slot we believe this node serves */ zend_llist slots; /* List of all slots we believe this node serves */ unsigned short slave; /* Are we a slave */ HashTable *slaves; /* Hash table of slaves */ } redisClusterNode;
• struct redisCluster /* RedisCluster implementation structure */ typedef struct redisCluster { zend_string *auth; double timeout; /* Timeout and read timeout (for normal operations) */ double read_timeout; int persistent; /* Are we using persistent connections */ long waitms; /* How long in milliseconds should we wait when being bounced around */ /* Are we flagged as being in readonly mode, meaning we could fall back to * a given master's slave */ short readonly; short failover; /* RedisCluster failover options (never, on error, to load balance) */ HashTable *seeds; /* Hash table of seed host/ports */ redisClusterNode *master[REDIS_CLUSTER_SLOTS]; /* RedisCluster masters, by direct slot */ HashTable *nodes; /* All RedisCluster objects we've created/are connected to */ clusterFoldItem *multi_head; /* Transaction handling linked list, and where we are as we EXEC */ clusterFoldItem *multi_curr; /* When we issue EXEC to nodes, we need to keep track of how many replies * we have, as this can fail for various reasons (EXECABORT, watch, etc.) */ char multi_len[REDIS_CLUSTER_SLOTS]; zval multi_resp; /* Variable to store MULTI response */ short clusterdown; /* Flag for when we get a CLUSTERDOWN error */ /* Key to our persistent list cache and number of redirections we've * received since construction */ zend_string *cache_key; uint64_t redirections; zend_string *err; /* The last ERROR we encountered */ unsigned short cmd_slot; /* The slot our command is operating on, as well as it's socket */ RedisSock *cmd_sock; short subscribed_slot; /* The slot where we're subscribed */ RedisSock *flags; /* One RedisSock struct for serialization and prefix information */ /* The first line of our last reply, not including our reply type byte * or the trailing \r\n */ char line_reply[1024]; REDIS_REPLY_TYPE reply_type; /* The last reply type and length or integer response we got */ long long reply_len; /* Last MOVED or ASK redirection response information */ CLUSTER_REDIR_TYPE redir_type; char redir_host[255]; int redir_host_len; unsigned short redir_slot; unsigned short redir_port; zend_object std; /* Zend object handler */ } redisCluster;