1

     2

#include <stdlib.h>

     3

#include <assert.h>

     4

     5

#include "server.h"

     7

#include "connection.h"

     8

#include "request.h"

     9

#include "../memcache.h"

    10

#include "../common.h"

    11

    13

    struct memcache_server *server = NULL;

    14

    19

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

    20

        ERROR("calloc");

    21

    22

    // store the vars

    24

    server->endpoint = endpoint;

    25

    server->max_connections = max_connections;

    26

    27

    // init lists

    28

    LIST_INIT(&server->conn_list);

    29

    TAILQ_INIT(&server->req_queue);

    30

    31

    // grow connpool so as to have a connection ready

    32

    memcache_server_grow_connpool(server);

    33

    34

    // success

    35

    return server;

    36

    37

error:

    38

    free(server);

    39

    40

    return NULL;

    41

}

    42

    43

void memcache_server_grow_connpool (struct memcache_server *server) {

    44

    struct memcache_conn *conn;

    45

    int count = 0;

    46

    47

    // count connections

    48

    LIST_FOREACH(conn, &server->conn_list, connlist_node) {

    49

        count++;

    50

    }

    51

    52

    // room for more?

    53

    if (count < server->max_connections) {

    54

        // create a new one

    55

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

    56

            ERROR("failed to grow the connpool");

    57

    58

        // enlist it

    59

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

    60

    61

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

    62

    }

    63

    64

    // ok

    65

    return;

    66

    67

error:

    68

    // XXX: we might be deadlocked now... requests queued, but no connections!

    69

    if (LIST_EMPTY(&server->conn_list) && !TAILQ_EMPTY(&server->req_queue))

    70

        FATAL("deadlock; requests queued, but no connections");

    71

    72

    // XXX: harmless... but need some retry logic

    73

}

    74

    75

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

    76

    struct memcache_conn *conn;

    77

    78

    // look for an idle connection

    79

    LIST_FOREACH(conn, &server->conn_list, connlist_node) {

    80

        if (memcache_conn_is_available(conn)) {

    81

            // we found an idle connection

    82

            break;

    83

        }

    84

    }

    85

    86

    if (conn != NULL) {

    87

        // we found an available connection

    88

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

    89

        memcache_conn_do_req(conn, req);

    90

    91

        return 0;

    92

    93

    } else {

    94

        // enqueue the request until a connection is available

    95

        // XXX: queue size limits

    96

    97

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

    98

    99

        // notify the req

   100

        memcache_req_queued(req);

   101

   102

        // grow the connpool, as we apparently don't have enough connections

   103

        memcache_server_grow_connpool(server);

   104

   105

        return 0;

   106

    }

   107

}

   108

   109

/*

   110

 * We might have available connections, process any queued requests, or try and grow the connpool if non available

   111

 */

   112

void memache_server_dequeue (struct memcache_server *server) {

   113

    struct memcache_conn *conn;

   114

    struct memcache_req *req;

   115

   116

    // if no requests are queued, nothing needs doing

   117

    if ((req = TAILQ_FIRST(&server->req_queue)) == NULL)

   118

        return;

   119

   120

    // look for idle connections to service the request

   121

    LIST_FOREACH(conn, &server->conn_list, connlist_node) {

   124

            // remove the req from the queue and execute it

   125

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

   126

   127

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

   128

            memcache_conn_do_req(conn, req);

   129

   130

            // if that was the last req, return, otherwise continue

   131

            if ((req = TAILQ_FIRST(&server->req_queue)) == NULL)

   132

                return;

   133

        }

   134

    }

   135

   136

    // no idle connections remaining, try and grow if applicable

   137

    memcache_server_grow_connpool(server);

   138

}

   139

   140

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

   141

    assert(server == conn->server);

   142

   143

    // grab the next queued request

   144

    memache_server_dequeue(server);

   145

}

   146

   147

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

   148

    assert(server == conn->server);

   149

   150

    // remove it from the list

   151

    LIST_REMOVE(conn, connlist_node);

   152

   153

    // free it

   154

    memcache_conn_free(conn);

   155

   156

    // this should grow the connpool back again

   157

    memache_server_dequeue(server);

   158

}

   159