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;

    24

    25

    // grow connpool so as to have a connection ready

    26

    if (memcache_server_grow_connpool(server))

    27

        ERROR("error opening initial connection");

    28

    29

    // success

    30

    return server;

    31

    32

error:

    33

    free(server);

    34

    35

    return NULL;

    36

}

    37

    38

int memcache_server_grow_connpool (struct memcache_server *server) {

    39

   struct memcache_conn *conn;

    40

   int count;

    41

    42

   // count connections

    43

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

    44

    45

   // room for more?

    46

   if (count < server->max_connections) {

    47

        // create a new one

    48

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

    49

            return -1;

    50

    51

        // enlist it

    52

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

    53

    54

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

    55

   }

    56

    57

   // success

    58

   return 0;

    59

}

    60

    61

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

    62

    struct memcache_conn *conn;

    63

    64

    // look for an idle connection

    65

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

    66

        if (memcache_conn_is_available(conn)) {

    67

            // we found an idle connection

    68

            break;

    69

        }

    70

    }

    71

    72

    if (conn != NULL) {

    73

        // we found an available connection

    74

        // if the request fails, then we will know via conn_dead

    75

        memcache_conn_do_req(conn, req);

    76

    77

        return 0;

    78

    79

    } else {

    80

        // enqueue the request until a connection is available

    81

        // XXX: queue size limits

    82

    83

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

    84

    85

        // notify the req

    86

        memcache_req_queued(req);

    87

    88

        return 0;

    89

    }

    90

}

    91

    92

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

    93

    assert(server == conn->server);

    94

    95

    // do we have any queued requests waiting?

    96

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

    97

    98

    if (req) {

    99

        // remove it from the queue and execute it

   100

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

   101

   102

        // this will take care of any error handling by itself

   103

        memcache_conn_do_req(conn, req);

   104

    }

   105

}

   106

   107

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

   108

    assert(server == conn->server);

   109

   110

    // XXX: reconnect/error out requests?

   111

   112

    // remove it from the list

   113

    LIST_REMOVE(conn, connlist_node);

   114

   115

    // free it

   116

    memcache_conn_free(conn);

   117

}

   118