/*
* The functions below are used to process write requests.
* - on_write_request_read1 and on_write_request_read2 read the request itself
* - on_write_request_process processes it (if the client requests to
* cache the negative result, the on_negative_write_request_process is used)
* - on_write_response_write1 sends the response
*/
static int
on_write_request_read1(struct query_state *qstate)
{
struct cache_write_request *write_request;
ssize_t result;
TRACE_IN(on_write_request_read1);
if (qstate->kevent_watermark == 0)
qstate->kevent_watermark = sizeof(size_t) * 3;
else {
init_comm_element(&qstate->request, CET_WRITE_REQUEST);
write_request = get_cache_write_request(&qstate->request);
result = qstate->read_func(qstate, &write_request->entry_length,
sizeof(size_t));
result += qstate->read_func(qstate,
&write_request->cache_key_size, sizeof(size_t));
result += qstate->read_func(qstate,
&write_request->data_size, sizeof(size_t));
if (result != sizeof(size_t) * 3) {
TRACE_OUT(on_write_request_read1);
return (-1);
}
if (BUFSIZE_INVALID(write_request->entry_length) ||
BUFSIZE_INVALID(write_request->cache_key_size) ||
(BUFSIZE_INVALID(write_request->data_size) &&
(write_request->data_size != 0))) {
TRACE_OUT(on_write_request_read1);
return (-1);
}
write_request->entry = (char *)calloc(1,
write_request->entry_length + 1);
assert(write_request->entry != NULL);
write_request->cache_key = (char *)calloc(1,
write_request->cache_key_size +
qstate->eid_str_length);
assert(write_request->cache_key != NULL);
memcpy(write_request->cache_key, qstate->eid_str,
qstate->eid_str_length);
if (write_request->data_size != 0) {
write_request->data = (char *)calloc(1,
write_request->data_size);
assert(write_request->data != NULL);
}
qstate->kevent_watermark = write_request->entry_length +
write_request->cache_key_size +
write_request->data_size;
qstate->process_func = on_write_request_read2;
}
TRACE_OUT(on_write_request_read1);
return (0);
}
/*
* The functions below are used to process read requests.
* - on_read_request_read1 and on_read_request_read2 read the request itself
* - on_read_request_process processes it
* - on_read_response_write1 and on_read_response_write2 send the response
*/
static int
on_read_request_read1(struct query_state *qstate)
{
struct cache_read_request *read_request;
ssize_t result;
TRACE_IN(on_read_request_read1);
if (qstate->kevent_watermark == 0)
qstate->kevent_watermark = sizeof(size_t) * 2;
else {
init_comm_element(&qstate->request, CET_READ_REQUEST);
read_request = get_cache_read_request(&qstate->request);
result = qstate->read_func(qstate,
&read_request->entry_length, sizeof(size_t));
result += qstate->read_func(qstate,
&read_request->cache_key_size, sizeof(size_t));
if (result != sizeof(size_t) * 2) {
TRACE_OUT(on_read_request_read1);
return (-1);
}
if (BUFSIZE_INVALID(read_request->entry_length) ||
BUFSIZE_INVALID(read_request->cache_key_size)) {
TRACE_OUT(on_read_request_read1);
return (-1);
}
read_request->entry = (char *)calloc(1,
read_request->entry_length + 1);
assert(read_request->entry != NULL);
read_request->cache_key = (char *)calloc(1,
read_request->cache_key_size +
qstate->eid_str_length);
assert(read_request->cache_key != NULL);
memcpy(read_request->cache_key, qstate->eid_str,
qstate->eid_str_length);
qstate->kevent_watermark = read_request->entry_length +
read_request->cache_key_size;
qstate->process_func = on_read_request_read2;
}
TRACE_OUT(on_read_request_read1);
return (0);
}
/*
* The functions below are used to process write requests.
* - on_transform_request_read1 and on_transform_request_read2 read the
* request itself
* - on_transform_request_process processes it
* - on_transform_response_write1 sends the response
*/
static int
on_transform_request_read1(struct query_state *qstate)
{
struct cache_transform_request *transform_request;
ssize_t result;
TRACE_IN(on_transform_request_read1);
if (qstate->kevent_watermark == 0)
qstate->kevent_watermark = sizeof(size_t) + sizeof(int);
else {
init_comm_element(&qstate->request, CET_TRANSFORM_REQUEST);
transform_request =
get_cache_transform_request(&qstate->request);
result = qstate->read_func(qstate,
&transform_request->entry_length, sizeof(size_t));
result += qstate->read_func(qstate,
&transform_request->transformation_type, sizeof(int));
if (result != sizeof(size_t) + sizeof(int)) {
TRACE_OUT(on_transform_request_read1);
return (-1);
}
if ((transform_request->transformation_type != TT_USER) &&
(transform_request->transformation_type != TT_ALL)) {
TRACE_OUT(on_transform_request_read1);
return (-1);
}
if (transform_request->entry_length != 0) {
if (BUFSIZE_INVALID(transform_request->entry_length)) {
TRACE_OUT(on_transform_request_read1);
return (-1);
}
transform_request->entry = (char *)calloc(1,
transform_request->entry_length + 1);
assert(transform_request->entry != NULL);
qstate->process_func = on_transform_request_read2;
} else
qstate->process_func = on_transform_request_process;
qstate->kevent_watermark = transform_request->entry_length;
}
TRACE_OUT(on_transform_request_read1);
return (0);
}
/*
* The functions below are used to process multipart write session initiation
* requests.
* - on_mp_write_session_request_read1 and on_mp_write_session_request_read2
* read the request itself
* - on_mp_write_session_request_process processes it
* - on_mp_write_session_response_write1 sends the response
*/
int
on_mp_write_session_request_read1(struct query_state *qstate)
{
struct cache_mp_write_session_request *c_mp_ws_request;
ssize_t result;
TRACE_IN(on_mp_write_session_request_read1);
if (qstate->kevent_watermark == 0)
qstate->kevent_watermark = sizeof(size_t);
else {
init_comm_element(&qstate->request,
CET_MP_WRITE_SESSION_REQUEST);
c_mp_ws_request = get_cache_mp_write_session_request(
&qstate->request);
result = qstate->read_func(qstate,
&c_mp_ws_request->entry_length, sizeof(size_t));
if (result != sizeof(size_t)) {
LOG_ERR_3("on_mp_write_session_request_read1",
"read failed");
TRACE_OUT(on_mp_write_session_request_read1);
return (-1);
}
if (BUFSIZE_INVALID(c_mp_ws_request->entry_length)) {
LOG_ERR_3("on_mp_write_session_request_read1",
"invalid entry_length value");
TRACE_OUT(on_mp_write_session_request_read1);
return (-1);
}
c_mp_ws_request->entry = calloc(1,
c_mp_ws_request->entry_length + 1);
assert(c_mp_ws_request->entry != NULL);
qstate->kevent_watermark = c_mp_ws_request->entry_length;
qstate->process_func = on_mp_write_session_request_read2;
}
TRACE_OUT(on_mp_write_session_request_read1);
return (0);
}
/*
* The functions below are used to process multipart write sessions write
* requests.
* - on_mp_write_session_write_request_read1 and
* on_mp_write_session_write_request_read2 read the request itself
* - on_mp_write_session_write_request_process processes it
* - on_mp_write_session_write_response_write1 sends the response
*/
static int
on_mp_write_session_write_request_read1(struct query_state *qstate)
{
struct cache_mp_write_session_write_request *write_request;
ssize_t result;
TRACE_IN(on_mp_write_session_write_request_read1);
init_comm_element(&qstate->request,
CET_MP_WRITE_SESSION_WRITE_REQUEST);
write_request = get_cache_mp_write_session_write_request(
&qstate->request);
result = qstate->read_func(qstate, &write_request->data_size,
sizeof(size_t));
if (result != sizeof(size_t)) {
LOG_ERR_3("on_mp_write_session_write_request_read1",
"read failed");
TRACE_OUT(on_mp_write_session_write_request_read1);
return (-1);
}
if (BUFSIZE_INVALID(write_request->data_size)) {
LOG_ERR_3("on_mp_write_session_write_request_read1",
"invalid data_size value");
TRACE_OUT(on_mp_write_session_write_request_read1);
return (-1);
}
write_request->data = calloc(1, write_request->data_size);
assert(write_request->data != NULL);
qstate->kevent_watermark = write_request->data_size;
qstate->process_func = on_mp_write_session_write_request_read2;
TRACE_OUT(on_mp_write_session_write_request_read1);
return (0);
}
