1

#ifndef MEMCACHE_REQ_H

     2

#define MEMCACHE_REQ_H

     3

     4

#include <sys/queue.h>

     5

     6

#include "../memcache.h"

     9

    10

struct memcache_req {

    11

    // the memcache context that we belong to

    12

    struct memcache *mc;

    13

    14

    // the command to execute

    15

    enum memcache_command cmd_type;

    16

    17

    // the reply we have received, or MEMCACHE_REPLY_INVALID

    18

    enum memcache_reply reply_type;

    19

    20

    // our key/obj

    21

    struct memcache_key key;

    22

    struct memcache_obj obj;

    23

    struct memcache_buf buf;

    24

    25

    // flags to indicate if we have valid obj/buf data, and if buf.data was allocated by us or supplied by the user

    26

    char have_obj, have_buf, is_buf_ours;

    27

    28

    // our state

    29

    enum memcache_state state;

    30

    31

    // our user callback argument

    32

    void *cb_arg;

    33

    34

    // the conn 

    35

    struct memcache_connection *conn;

    36

    37

    // we are a member of struct memcache_server.req_queue

    38

    TAILQ_ENTRY(memcache_req) reqqueue_node;

    39

};

    40

    41

/*

    42

 * Allocate and return a new req, or NULL if unsuccesfull.

    43

 */

    44

struct memcache_req *memcache_req_alloc (struct memcache *mc, enum memcache_command cmd_type, const struct memcache_key *key, const struct memcache_obj *obj, const struct memcache_buf *buf, void *cb_arg);

    45

    46

/*

    47

 * The request has been queued.

    48

 */

    49

void memcache_req_queued (struct memcache_req *req);

    50

    51

/*

    52

 * The request is being sent.

    53

 */

    54

void memcache_req_send (struct memcache_req *req);

    55

    56

/*

    57

 * The reply has been received, although if the respones also contains data, that will be notified separately.

    58

 *

    59

 * If the response doesn't contain any data, req_done will be called after this is. Otherwise, this will be called

    60

 * first, followed by zero or more calls to req_data, followed by req_reply/RPL_END + req_done.

    61

 *

    62

 * Note that no req data will not be available when this is first called, only once req_data/req_done is called.

    63

 */

    64

void memcache_req_recv (struct memcache_req *req, enum memcache_reply reply_type);

    65

    66

/*

    67

 * Some amount of reply data has been received. This may be called between the req_reply/MEMCACHE_RPL_VALUE and

    68

 * req_reply/MEMCACHE_RPL_END + req_done notifications.

    69

 *

    70

 * Note that this is not always called, it is possible that one might have:

    71

 *      memcache_req_reply(req, MEMCACHE_RPL_VALUE)

    72

 *      memcache_req_reply(req, MEMCACHE_RPL_END)

    73

 *      memcache_req_done(req)

    74

 *

    75

 * This will happen if both the value and the end replies are received in the same chunk.

    76

 *

    77

 * Note also that replies may have zero-length entries, in which case req_data will never be called either.

    78

 */

    79

void memcache_req_data (struct memcache_req *req);

    80

    81

/*

    82

 * The request was sent and is now done, and is not associated with the connection anymore.

    83

 *

    84

 * This will be called before req_reply/req_data, but not before/after req_error.

    85

 *

    86

 * The request will not be accessed anymore after calling this.

    87

 */

    88

void memcache_req_done (struct memcache_req *req);

    89

    90

/*

    91

 * An error occurred, and the request must be abandoned. The request is not active or enqueued anymore.

    92

 *

    93

 * The request will not be accessed anymore after calling this.

    94

 */

    95

void memcache_req_error (struct memcache_req *req);

    96

    97

/*

    98

 * Free an unused req. Should always be called by the user, not via internal means.

    99

 */

   100

void memcache_req_free (struct memcache_req *req);

   101

   102

#endif /* MEMCACHE_REQ_H */