apr_memcache.h

Go to the documentation of this file.

/* Copyright 2004 Paul Querna
 *
 * Licensed 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_MEMCACHE_H
#define APR_MEMCACHE_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"

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

typedef enum
{
    APR_MC_SERVER_LIVE, 
    APR_MC_SERVER_DEAD  
} apr_memcache_server_status_t;

typedef struct apr_memcache_conn_t apr_memcache_conn_t;

typedef struct apr_memcache_server_t apr_memcache_server_t;
struct apr_memcache_server_t
{
    const char *host; 
    apr_port_t port; 
    apr_memcache_server_status_t status; 
#if APR_HAS_THREADS || defined(DOXYGEN)
    apr_reslist_t *conns; 
#else
    apr_memcache_conn_t *conn;   
#endif
    apr_pool_t *p; 
};

typedef struct
{
    apr_uint32_t flags; 
    apr_uint16_t nalloc; 
    apr_uint16_t ntotal; 
    apr_memcache_server_t **live_servers; 
    apr_pool_t *p; 
} apr_memcache_t;

APR_DECLARE(apr_uint32_t)
apr_memcache_hash(const char* data, apr_uint32_t data_len);

APR_DECLARE(apr_memcache_server_t *)
apr_memcache_find_server_hash(apr_memcache_t *mc, const apr_uint32_t hash);

APR_DECLARE(apr_status_t)
apr_memcache_add_server(apr_memcache_t * mc,
                        apr_memcache_server_t *server);


APR_DECLARE(apr_memcache_server_t *)
apr_memcache_find_server(apr_memcache_t *mc,
                         const char *host,
                         apr_port_t port);

APR_DECLARE(apr_status_t)
apr_memcache_enable_server(apr_memcache_t *mc,
                           apr_memcache_server_t *ms);


APR_DECLARE(apr_status_t)
apr_memcache_disable_server(apr_memcache_t *mc,
                            apr_memcache_server_t *ms);

APR_DECLARE(apr_status_t)
apr_memcache_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_memcache_server_t **ns);
APR_DECLARE(apr_status_t) 
apr_memcache_create(apr_pool_t *p,
                    apr_uint16_t max_servers,
                    apr_uint32_t flags,
                    apr_memcache_t **mc);

APR_DECLARE(apr_status_t) 
apr_memcache_getp(apr_memcache_t *mc, 
                  apr_pool_t *p,
                  const char* key,
                  char **baton,
                  apr_size_t *len,
                  apr_uint32_t *flags);

APR_DECLARE(apr_status_t) 
apr_memcache_set(apr_memcache_t *mc,
                 const char* key,
                 char *baton,
                 const apr_uint32_t data_size,
                 apr_uint32_t timeout,
                 apr_uint32_t flags);

APR_DECLARE(apr_status_t) 
apr_memcache_add(apr_memcache_t *mc,
                 const char* key,
                 char *baton,
                 const apr_uint32_t data_size,
                 apr_uint32_t timeout,
                 apr_uint32_t flags);

APR_DECLARE(apr_status_t) 
apr_memcache_replace(apr_memcache_t *mc,
                 const char* key,
                 char *data,
                 const apr_uint32_t data_size,
                 apr_uint32_t timeout,
                 apr_uint32_t flags);
APR_DECLARE(apr_status_t) 
apr_memcache_delete(apr_memcache_t *mc,
                 const char* key,
                 apr_uint32_t timeout);

APR_DECLARE(apr_status_t) 
apr_memcache_incr(apr_memcache_t *mc, 
                 const char* key,
                 apr_int32_t n,
                 apr_uint32_t *nv);

APR_DECLARE(apr_status_t) 
apr_memcache_decr(apr_memcache_t *mc, 
                 const char* key,
                 apr_int32_t n,
                 apr_uint32_t *new_value);

APR_DECLARE(apr_status_t)
apr_memcache_version(apr_memcache_server_t *ms,
                  apr_pool_t *p,
                  char **baton);

typedef struct
{
    const char* version;
    apr_uint32_t pid;
    apr_uint32_t uptime;
    apr_time_t time;
    apr_time_t rusage_user;
    apr_time_t rusage_system;
    apr_uint32_t curr_items;
    apr_uint32_t total_items;
    apr_uint64_t bytes;
    apr_uint32_t curr_connections;
    apr_uint32_t total_connections;
    apr_uint32_t connection_structures;
    apr_uint32_t cmd_get;
    apr_uint32_t cmd_set;
    apr_uint32_t get_hits;
    apr_uint32_t get_misses;
    apr_uint64_t bytes_read;
    apr_uint64_t bytes_written;
    apr_uint32_t limit_maxbytes;
} apr_memcache_stats_t;

APR_DECLARE(apr_status_t) 
apr_memcache_stats(apr_memcache_server_t *ms, 
                  apr_pool_t *p,
                  apr_memcache_stats_t **stats);


#ifdef __cplusplus
}
#endif

#endif /* APR_MEMCACHE_H */

---