1

     2

#include <stdlib.h>

     3

     4

#include "memcache.h"

     5

#include "server.h"

     6

#include "request.h"

     7

#include "../common.h"

     8

    10

    struct memcache *mc = NULL;

    11

    12

    if ((mc = calloc(1, sizeof(*mc))) == NULL)

    13

        ERROR("calloc");

    14

    16

    mc->cb_fn = cb_fn;

    18

    19

    // init server list

    20

    LIST_INIT(&mc->server_list);

    21

    22

    // success

    23

    return mc;

    24

    25

error:

    26

    if (mc)

    27

        free(mc);

    28

    29

    return NULL;

    30

}

    31

    32

int memcache_add_server (struct memcache *mc, struct config_endpoint *endpoint, int max_connections) {

    33

    struct memcache_server *server = NULL;

    34

    35

    // alloc the server

    37

        goto error;

    38

    39

    // enlist it

    40

    LIST_INSERT_HEAD(&mc->server_list, server, serverlist_node);

    41

    42

    // done

    43

    return 0;

    44

    45

error:

    46

    return -1;

    47

}

    48

    49

struct memcache_server *memcache_choose_server (struct memcache *mc, const struct memcache_key *key) {

    50

    // XXX: support multiple servers

    51

    return mc->server_list.lh_first;

    52

}

    53

    54

static struct memcache_req *_memcache_req (struct memcache *mc, enum memcache_command cmd, const struct memcache_key *key, const struct memcache_obj *obj, const struct memcache_buf *buf, void *cb_arg) {

    55

    struct memcache_req *req = NULL;

    56

    struct memcache_server *server = NULL;

    57

    58

    // alloc the request

    59

    if ((req = memcache_req_alloc(mc, cmd, key, obj, buf, cb_arg)) == NULL)

    60

        ERROR("failed to allocate request");

    61

    62

    // pick a server

    63

    if ((server = memcache_choose_server(mc, key)) == NULL)

    64

        ERROR("failed to find a server to use");

    65

    66

    // enqueue it!

    67

    if (memcache_server_add_req(server, req))

    68

        ERROR("failed to hand over the request for processing");

    69

    70

    // success!

    71

    return req;

    72

    73

error:

    74

    if (req)

    75

        memcache_req_free(req);

    76

    77

    return NULL;

    78

}  

    79

    80

struct memcache_req *memcache_fetch (struct memcache *mc, const struct memcache_key *key, void *cb_arg) {

    81

    return _memcache_req(mc, MEMCACHE_CMD_FETCH_GET, key, NULL, NULL, cb_arg);

    82

}

    83

    84

struct memcache_req *memcache_store (struct memcache *mc, enum memcache_command cmd, const struct memcache_key *key, const struct memcache_obj *obj, const struct memcache_buf *buf, void *cb_arg) {

    85

    if (

    86

            (cmd != MEMCACHE_CMD_STORE_SET)

    87

        &&  (cmd != MEMCACHE_CMD_STORE_ADD)

    88

        &&  (cmd != MEMCACHE_CMD_STORE_REPLACE)

    89

        &&  (cmd != MEMCACHE_CMD_STORE_APPEND)

    90

        &&  (cmd != MEMCACHE_CMD_STORE_PREPEND)

    91

        &&  (cmd != MEMCACHE_CMD_STORE_CAS)

    92

    )

    93

        ERROR("invalid command for store");

    94

    95

    return _memcache_req(mc, cmd, key, obj, buf, cb_arg);

    96

    97

error:

    98

    return NULL;

    99

}

   100