apr_redis.h

Go to the documentation of this file.

/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef APR_REDIS_H
#define APR_REDIS_H

#include "apr.h"
#include "apr_pools.h"
#include "apr_time.h"
#include "apr_strings.h"
#include "apr_network_io.h"
#include "apr_ring.h"
#include "apr_buckets.h"
#include "apr_reslist.h"
#include "apr_hash.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

#ifndef RC_DEFAULT_SERVER_PORT
#define RC_DEFAULT_SERVER_PORT 6379
#endif

#ifndef RC_DEFAULT_SERVER_MIN
#define RC_DEFAULT_SERVER_MIN 0
#endif

#ifndef RC_DEFAULT_SERVER_SMAX
#define RC_DEFAULT_SERVER_SMAX 1
#endif

#ifndef RC_DEFAULT_SERVER_TTL
#define RC_DEFAULT_SERVER_TTL 600
#endif

typedef enum
{
    APR_RC_SERVER_LIVE, 
    APR_RC_SERVER_DEAD  
} apr_redis_server_status_t;

typedef struct apr_redis_conn_t apr_redis_conn_t;

typedef struct apr_redis_server_t apr_redis_server_t;
struct apr_redis_server_t
{
    const char *host; 
    apr_port_t port; 
    apr_redis_server_status_t status; 
#if APR_HAS_THREADS || defined(DOXYGEN)
    apr_reslist_t *conns; 
#else
    apr_redis_conn_t *conn;
#endif
    apr_pool_t *p; 
#if APR_HAS_THREADS
    apr_thread_mutex_t *lock;
#endif
    apr_time_t btime;
    apr_uint32_t rwto;
    struct
    {
        int major;
        int minor;
        int patch;
        char *number;
    } version;
};

typedef struct apr_redis_t apr_redis_t;

/* Custom hash callback function prototype, user for server selection.
* @param baton user selected baton
* @param data data to hash
* @param data_len length of data
*/
typedef apr_uint32_t (*apr_redis_hash_func)(void *baton,
                                            const char *data,
                                            const apr_size_t data_len);
/* Custom Server Select callback function prototype.
* @param baton user selected baton
* @param rc redis instance, use rc->live_servers to select a node
* @param hash hash of the selected key.
*/
typedef apr_redis_server_t* (*apr_redis_server_func)(void *baton,
                                                 apr_redis_t *rc,
                                                 const apr_uint32_t hash);

struct apr_redis_t
{
    apr_uint32_t flags; 
    apr_uint16_t nalloc; 
    apr_uint16_t ntotal; 
    apr_redis_server_t **live_servers; 
    apr_pool_t *p; 
    void *hash_baton;
    apr_redis_hash_func hash_func;
    void *server_baton;
    apr_redis_server_func server_func;
};

APU_DECLARE(apr_uint32_t) apr_redis_hash(apr_redis_t *rc,
                                         const char *data,
                                         const apr_size_t data_len);

APU_DECLARE(apr_uint32_t) apr_redis_hash_crc32(void *baton,
                                               const char *data,
                                               const apr_size_t data_len);

APU_DECLARE(apr_uint32_t) apr_redis_hash_default(void *baton,
                                                 const char *data,
                                                 const apr_size_t data_len);

APU_DECLARE(apr_redis_server_t *) apr_redis_find_server_hash(apr_redis_t *rc,
                                                             const apr_uint32_t hash);

APU_DECLARE(apr_redis_server_t *) apr_redis_find_server_hash_default(void *baton,
                                                                      apr_redis_t *rc,
                                                                      const apr_uint32_t hash);

APU_DECLARE(apr_status_t) apr_redis_add_server(apr_redis_t *rc,
                                               apr_redis_server_t *server);


APU_DECLARE(apr_redis_server_t *) apr_redis_find_server(apr_redis_t *rc,
                                                        const char *host,
                                                        apr_port_t port);

APU_DECLARE(apr_status_t) apr_redis_enable_server(apr_redis_t *rc,
                                                  apr_redis_server_t *rs);


APU_DECLARE(apr_status_t) apr_redis_disable_server(apr_redis_t *rc,
                                                   apr_redis_server_t *rs);

APU_DECLARE(apr_status_t) apr_redis_server_create(apr_pool_t *p,
                                                  const char *host,
                                                  apr_port_t port,
                                                  apr_uint32_t min,
                                                  apr_uint32_t smax,
                                                  apr_uint32_t max,
                                                  apr_uint32_t ttl,
                                                  apr_uint32_t rwto,
                                                  apr_redis_server_t **ns);
APU_DECLARE(apr_status_t) apr_redis_create(apr_pool_t *p,
                                           apr_uint16_t max_servers,
                                           apr_uint32_t flags,
                                           apr_redis_t **rc);

APU_DECLARE(apr_status_t) apr_redis_getp(apr_redis_t *rc,
                                         apr_pool_t *p,
                                         const char* key,
                                         char **baton,
                                         apr_size_t *len,
                                         apr_uint16_t *flags);

APU_DECLARE(apr_status_t) apr_redis_set(apr_redis_t *rc,
                                        const char *key,
                                        char *baton,
                                        const apr_size_t data_size,
                                        apr_uint16_t flags);

APU_DECLARE(apr_status_t) apr_redis_setex(apr_redis_t *rc,
                                          const char *key,
                                          char *baton,
                                          const apr_size_t data_size,
                                          apr_uint32_t timeout,
                                          apr_uint16_t flags);

APU_DECLARE(apr_status_t) apr_redis_delete(apr_redis_t *rc,
                                           const char *key,
                                           apr_uint32_t timeout);

APU_DECLARE(apr_status_t) apr_redis_version(apr_redis_server_t *rs,
                                            apr_pool_t *p,
                                            char **baton);

APU_DECLARE(apr_status_t) apr_redis_info(apr_redis_server_t *rs,
                                         apr_pool_t *p,
                                         char **baton);

APU_DECLARE(apr_status_t) apr_redis_incr(apr_redis_t *rc,
                                         const char *key,
                                         apr_int32_t inc,
                                         apr_uint32_t *new_value);
APU_DECLARE(apr_status_t) apr_redis_decr(apr_redis_t *rc,
                                         const char *key,
                                         apr_int32_t inc,
                                         apr_uint32_t *new_value);


APU_DECLARE(apr_status_t) apr_redis_ping(apr_redis_server_t *rs);

APU_DECLARE(apr_status_t) apr_redis_multgetp(apr_redis_t *rc,
                                             apr_pool_t *temp_pool,
                                             apr_pool_t *data_pool,
                                             apr_hash_t *values);

typedef enum
{
    APR_RS_SERVER_MASTER, 
    APR_RS_SERVER_SLAVE,  
    APR_RS_SERVER_UNKNOWN  
} apr_redis_server_role_t;

typedef struct
{
/* # Server */
    apr_uint32_t major;
    apr_uint32_t minor;
    apr_uint32_t patch;
    apr_uint32_t process_id;
    apr_uint32_t uptime_in_seconds;
    apr_uint32_t arch_bits;

/* # Clients */
    apr_uint32_t connected_clients;
    apr_uint32_t blocked_clients;

/* # Memory */
    apr_uint64_t maxmemory;
    apr_uint64_t used_memory;
    apr_uint64_t total_system_memory;

/* # Stats */
    apr_uint64_t total_connections_received;
    apr_uint64_t total_commands_processed;
    apr_uint64_t rejected_connections;
    apr_uint64_t total_net_input_bytes;
    apr_uint64_t total_net_output_bytes;
    apr_uint64_t keyspace_hits;
    apr_uint64_t keyspace_misses;

/* # Replication */
    apr_redis_server_role_t role;
    apr_uint32_t connected_slaves;

/* # CPU */
    apr_uint32_t used_cpu_sys;
    apr_uint32_t used_cpu_user;

/* # Cluster */
    apr_uint32_t cluster_enabled;
} apr_redis_stats_t;

APU_DECLARE(apr_status_t) apr_redis_stats(apr_redis_server_t *rs,
                                          apr_pool_t *p,
                                          apr_redis_stats_t **stats);

#ifdef __cplusplus
}
#endif

#endif /* APR_REDIS_H */