1

     2

#include <stdlib.h>

     3

#include <assert.h>

     4

     5

#include "server.h"

     6

#include "connection.h"

     7

#include "request.h"

     8

#include "../memcache.h"

     9

#include "../common.h"

    10

    11

struct memcache_server *memcache_server_alloc (struct config_endpoint *endpoint, int max_connections) {

    12

    struct memcache_server *server = NULL;

    13

    14

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

    15

        ERROR("calloc");

    16

    17

    // store the vars

    18

    server->endpoint = endpoint;

    19

    server->max_connections = max_connections;

    20

    21

    // grow connpool so as to have a connection ready

    22

    if (memcache_server_grow_connpool(server))

    23

        ERROR("error opening initial connection");

    24

    25

    // success

    26

    return server;

    27

    28

error:

    29

    free(server);

    30

    31

    return NULL;

    32

}

    33

    34

int memcache_server_grow_connpool (struct memcache_server *server) {

    35

   struct memcache_conn *conn;

    36

   int count;

    37

    38

   // count connections

    39

   for (count = 0, conn = server->conn_list.lh_first; conn != NULL; conn = conn->connlist_node.le_next, count++) ;

    40

    41

   // room for more?

    42

   if (count < server->max_connections) {

    43

        // create a new one

    44

        if ((conn = memcache_conn_open(server)) == NULL)

    45

            return -1;

    46

    47

        // enlist it

    48

        LIST_INSERT_HEAD(&server->conn_list, conn, connlist_node);

    49

    50

        // the connection will call memcache_server_coon_ready once it's ready for use...

    51

   }

    52

    53

   // success

    54

   return 0;

    55

}

    56

    57

int memcache_server_add_req (struct memcache_server *server, struct memcache_req *req) {

    58

    struct memcache_conn *conn;

    59

    60

    // look for an idle connection

    61

    for (conn = server->conn_list.lh_first; conn != NULL; conn = conn->connlist_node.le_next) {

    62

        if (memcache_conn_is_available(conn)) {

    63

            // we found an idle connection

    64

            break;

    65

        }

    66

    }

    67

    68

    if (conn != NULL) {

    69

        // we found an available connection

    70

        return memcache_conn_do_req(conn, req);

    71

    72

    } else {

    73

        // enqueue the request until a connection is available

    74

        // XXX: queue size limits

    75

    76

        TAILQ_INSERT_TAIL(&server->req_queue, req, reqqueue_node);

    80

    81

        return 0;

    82

    }

    83

}

    84

    85

void memcache_server_conn_ready (struct memcache_server *server, struct memcache_conn *conn) {

    86

    assert(server == conn->server);

    87

    88

    // do we have any queued requests waiting?

    89

    struct memcache_req *req = server->req_queue.tqh_first;

    90

    91

    if (req) {

    92

        // remove it from the queue and execute it

    93

        TAILQ_REMOVE(&server->req_queue, req, reqqueue_node);

    94

    95

        if (memcache_conn_do_req(conn, req)) {

    96

            WARNING("processing enqueued request failed");

    97

    98

            // notify the request/user, the req is now out of our hands

    99

            memcache_req_error(req);

   100

        }

   101

    }

   102

}

   103

   104

void memcache_server_conn_dead (struct memcache_server *server, struct memcache_conn *conn) {

   105

    assert(server == conn->server);

   106

   107

    // XXX: reconnect/error out requests?

   108

   109

    // remove it from the list

   110

    LIST_REMOVE(conn, connlist_node);

   111

   112

    // free it

   113

    memcache_conn_free(conn);

   114

}

   115