void monitor_close(void)
{
shutdown(sock, SHUT_RDWR);
shutdown(sock_listen, SHUT_RDWR);
close(sock);
close(sock_listen);
msgpack_sbuffer_free(sbuf);
msgpack_sbuffer_free(draw_sbuf);
msgpack_unpacker_free(up);
}
int main(void) {
/* creates buffer and serializer instance. */
msgpack_sbuffer* buffer = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
/* serializes ["Hello", "MessagePack"]. */
msgpack_pack_array(pk, 2);
msgpack_pack_raw(pk, 5);
msgpack_pack_raw_body(pk, "Hello", 5);
msgpack_pack_raw(pk, 11);
msgpack_pack_raw_body(pk, "MessagePack", 11);
/* deserializes it. */
msgpack_unpacked msg;
msgpack_unpacked_init(&msg);
bool success = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
/* prints the deserialized object. */
msgpack_object obj = msg.data;
msgpack_object_print(stdout, obj); /*=> ["Hello", "MessagePack"] */
puts("");
// msgpack_pack_object/pk
/* cleaning */
msgpack_sbuffer_free(buffer);
msgpack_packer_free(pk);
}
TEST(fixint, size)
{
msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write);
size_t sum = 0;
EXPECT_EQ(0, msgpack_pack_fix_int8(pk, 0));
EXPECT_EQ(sum+=2, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_int16(pk, 0));
EXPECT_EQ(sum+=3, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_int32(pk, 0));
EXPECT_EQ(sum+=5, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_int64(pk, 0));
EXPECT_EQ(sum+=9, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_uint8(pk, 0));
EXPECT_EQ(sum+=2, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_uint16(pk, 0));
EXPECT_EQ(sum+=3, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_uint32(pk, 0));
EXPECT_EQ(sum+=5, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_uint64(pk, 0));
EXPECT_EQ(sum+=9, sbuf->size);
msgpack_sbuffer_free(sbuf);
msgpack_packer_free(pk);
}
void
yakyak_destroy(struct yakyak *yy)
{
msgpack_packer_free(yy->pk);
msgpack_sbuffer_free(yy->buf);
yy->pk = NULL;
yy->buf = NULL;
}
static void msgpack_flushfree(CTX ctx, kpackAPI_t *pk)
{
msgpack_sbuffer *sbuffer = pk->sbuffer;
kbytes_t t = {{sbuffer->data}, sbuffer->size};
knh_OutputStream_write(ctx, pk->w, t);
knh_OutputStream_flush(ctx, pk->w); /* TODO need flush? */
msgpack_sbuffer_free(pk->sbuffer);
msgpack_packer_free(pk->pk);
}
TEST(pack, num)
{
msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write);
EXPECT_EQ(0, msgpack_pack_int(pk, 1));
msgpack_sbuffer_free(sbuf);
msgpack_packer_free(pk);
}
static void trigger_publish_callback() {
msgpack_sbuffer *sbuf;
//Get all aggregated messages as payload of a single event.
sbuf = msgpack_sbuffer_new();
get_event_collection_message(sbuf);
//Send the msgpack array over PUB socket
if(sbuf && sbuf->size > 0)
publish_message(sbuf->data, sbuf->size);
// Clear the aggregated messages
message_list_clear();
msgpack_sbuffer_free(sbuf);
}
static void queue_cpu_sample_for_sending(rbkit_cpu_sample *sample) {
msgpack_sbuffer* buffer = msgpack_sbuffer_new();
msgpack_packer* packer = msgpack_packer_new(buffer, msgpack_sbuffer_write);
rbkit_cpu_sample_event *event = new_rbkit_cpu_sample_event(sample);
pack_event((rbkit_event_header *)event, packer);
free(event);
send_message(buffer);
msgpack_sbuffer_free(buffer);
msgpack_packer_free(packer);
}
static zmsg_t *create_call(const char *actionid, const char *module, const char *function, const char *data)
{
zmsg_t *msg = zmsg_new();
msgpack_sbuffer* pIntBuffer = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new( pIntBuffer, msgpack_sbuffer_write );
if (data && actionid && module)
{
msgpack_pack_map( pk, 3 );
{
m_pack_raw(pk, "command");
m_pack_raw(pk, "call");
m_pack_raw(pk, "body");
msgpack_pack_map( pk, 5 );
{
m_pack_raw(pk, "module");
m_pack_raw(pk, module);
m_pack_raw(pk, "function");
m_pack_raw(pk, function);
m_pack_raw(pk, "version");
msgpack_pack_uint64(pk, 1);
m_pack_raw(pk, "parameters");
msgpack_pack_map( pk, 1 );
{
m_pack_raw(pk, function);
m_pack_raw(pk, data);
}
m_pack_raw(pk, "seqno");
msgpack_pack_uint64(pk, 0);
}
m_pack_raw(pk, "actionid");
m_pack_raw(pk, actionid);
}
} else {
return NULL;
}
zmsg_pushmem(msg, pIntBuffer->data, pIntBuffer->size);
msgpack_sbuffer_free( pIntBuffer );
msgpack_packer_free( pk );
return msg;
}
static VALUE send_handshake_response(VALUE self) {
msgpack_sbuffer *buffer = msgpack_sbuffer_new();
msgpack_packer *packer = msgpack_packer_new(buffer, msgpack_sbuffer_write);
rbkit_hash_event *event = new_rbkit_hash_event(handshake, rbkit_status_as_hash(self));
pack_event((rbkit_event_header *)event, packer);
free(event);
if(buffer && buffer->size > 0)
respond_with_message(buffer->data, buffer->size);
msgpack_sbuffer_free(buffer);
msgpack_packer_free(packer);
return Qnil;
}
static VALUE stop_stat_server() {
if (logger->enabled == Qtrue)
stop_stat_tracing();
// Destroy the list which aggregates messages
message_list_destroy();
// Clear object_table which holds object allocation info
st_foreach(logger->object_table, free_values_i, 0);
st_clear(logger->object_table);
st_foreach(logger->str_table, free_keys_i, 0);
st_clear(logger->str_table);
msgpack_sbuffer_free(logger->sbuf);
msgpack_packer_free(logger->msgpacker);
zmq_close(zmq_publisher);
zmq_close(zmq_response_socket);
zmq_ctx_destroy(zmq_context);
free(logger);
logger = 0;
return Qnil;
}
static VALUE send_hash_as_event(int argc, VALUE *argv, VALUE self) {
VALUE hash_object;
VALUE event_type;
msgpack_sbuffer *buffer;
msgpack_packer *packer;
rbkit_hash_event *event;
rb_scan_args(argc, argv, "20", &hash_object, &event_type);
buffer = msgpack_sbuffer_new();
packer = msgpack_packer_new(buffer, msgpack_sbuffer_write);
event = new_rbkit_hash_event(FIX2INT(event_type), hash_object);
pack_event((rbkit_event_header *)event, packer);
free(event);
send_message(buffer);
msgpack_sbuffer_free(buffer);
msgpack_packer_free(packer);
return Qnil;
}
TEST(pack, insufficient)
{
msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write);
EXPECT_EQ(0, msgpack_pack_int(pk, 255)); // uint8 (2bytes)
msgpack_unpack_return success;
size_t offset = 0;
msgpack_unpacked msg;
msgpack_unpacked_init(&msg);
success = msgpack_unpack_next(&msg, sbuf->data, 1, &offset);
EXPECT_EQ(MSGPACK_UNPACK_CONTINUE, success);
EXPECT_EQ(0u, offset);
msgpack_unpacked_destroy(&msg);
msgpack_sbuffer_free(sbuf);
msgpack_packer_free(pk);
}
static void
test_code_decode(void **state) {
(void) state;
msg_t orig_msg, decoded_msg;
msgpack_sbuffer *sbuf;
int ret;
orig_msg.header.magic = 0xFF;
orig_msg.header.version = 0xA5;
orig_msg.header.type = PBLC_MSG_GET;
orig_msg.block = 0xAABBCCDD;
orig_msg.nblocks = 0xFFDDEE;
orig_msg.path = "this/is/a/test";
sbuf = msg_put_marshal(&orig_msg);
assert_non_null(sbuf);
assert_non_null(sbuf->data);
assert_true(sbuf->size > 0);
ret = msg_put_unmarshal(&decoded_msg,
sbuf->data, sbuf->size);
msgpack_sbuffer_free(sbuf);
assert_int_equal(ret, 0);
assert_int_equal(orig_msg.header.magic,
decoded_msg.header.magic);
assert_int_equal(orig_msg.header.version,
decoded_msg.header.version);
assert_int_equal(orig_msg.header.type,
decoded_msg.header.type);
assert_int_equal(orig_msg.block, decoded_msg.block);
assert_int_equal(orig_msg.nblocks, decoded_msg.nblocks);
assert_string_equal(orig_msg.path, decoded_msg.path);
assert_ptr_not_equal(orig_msg.path, decoded_msg.path);
msg_destroy(&decoded_msg);
}
static char *
pack_data(int *size)
{
msgpack_sbuffer *buffer = NULL;
msgpack_packer *packer = NULL;
char *data;
buffer = msgpack_sbuffer_new();
msgpack_sbuffer_init(buffer);
packer = msgpack_packer_new((void *)buffer, msgpack_sbuffer_write);
pack_node(packer, &node);
data = (char *)malloc(buffer->size + 1);
memcpy(data, &buffer->data[0], buffer->size);
data[buffer->size] = '\0';
*size = buffer->size;
msgpack_packer_free(packer);
msgpack_sbuffer_free(buffer);
return data;
}
void
save_data(char *filename, save_data_function pack_function)
{
msgpack_sbuffer *buffer = NULL;
msgpack_packer *packer = NULL;
char *save_file_name;
FILE *save_file;
if ((save_file_name = get_save_file_path(filename)) == NULL) {
red_log(REDD_WARNING, "get_save_file_path returned NULL");
return;
}
buffer = msgpack_sbuffer_new();
msgpack_sbuffer_init(buffer);
packer = msgpack_packer_new((void *)buffer, msgpack_sbuffer_write);
msgpack_pack_map(packer, 1);
pack_function(packer);
if ((save_file = fopen(save_file_name, "w")) != NULL) {
size_t written;
written = fwrite((void *)&buffer->data[0], 1, buffer->size, save_file);
fclose(save_file);
if (written != buffer->size) {
red_log(REDD_WARNING, "Failed to write to %s", save_file_name);
}
} else {
red_log(REDD_WARNING, "Failed to open %s", save_file_name);
}
free(save_file_name);
save_file_name = NULL;
msgpack_packer_free(packer);
packer = NULL;
msgpack_sbuffer_free(buffer);
buffer = NULL;
}
static VALUE send_objectspace_dump(VALUE self) {
msgpack_sbuffer* buffer = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
rbkit_object_dump * dump = get_object_dump(logger->object_table);
rbkit_object_space_dump_event *event = new_rbkit_object_space_dump_event(dump);
// Object space dump can span across messages.
// So we keep creating and queueing the messages
// until we've packed all objects.
while(event->packed_objects < event->object_count) {
pack_event((rbkit_event_header *)event, pk);
send_message(buffer);
}
free(event->current_page);
free(event);
free(dump);
msgpack_sbuffer_free(buffer);
msgpack_packer_free(pk);
return Qnil;
}
TEST(unpack, sequence)
{
msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write);
EXPECT_EQ(0, msgpack_pack_int(pk, 1));
EXPECT_EQ(0, msgpack_pack_int(pk, 2));
EXPECT_EQ(0, msgpack_pack_int(pk, 3));
msgpack_packer_free(pk);
msgpack_unpack_return success;
size_t offset = 0;
msgpack_unpacked msg;
msgpack_unpacked_init(&msg);
success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, success);
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type);
EXPECT_EQ(1u, msg.data.via.u64);
success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, success);
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type);
EXPECT_EQ(2u, msg.data.via.u64);
success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, success);
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type);
EXPECT_EQ(3u, msg.data.via.u64);
success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset);
EXPECT_EQ(MSGPACK_UNPACK_CONTINUE, success);
msgpack_sbuffer_free(sbuf);
msgpack_unpacked_destroy(&msg);
}
int main(void)
{
msgpack_sbuffer* buffer = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
msgpack_pack_array(pk, 2);
msgpack_pack_raw(pk, 5);
msgpack_pack_raw_body(pk, "hello", 5);
msgpack_pack_raw(pk, 11);
msgpack_pack_raw_body(pk, "messagepack", 11);
msgpack_unpacked msg;
msgpack_unpacked_init(&msg);
bool success = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
msgpack_object obj = msg.data;
msgpack_object_print(stdout, obj);
printf("\n");
msgpack_sbuffer_free(buffer);
msgpack_packer_free(pk);
}
void free_msgpack_buffer(void *data, void *hint) {
msgpack_sbuffer *buffer = hint;
msgpack_sbuffer_free(buffer);
}
TEST(streaming, basic)
{
msgpack_sbuffer* buffer = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
// 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4}
EXPECT_EQ(0, msgpack_pack_int(pk, 1));
EXPECT_EQ(0, msgpack_pack_int(pk, 2));
EXPECT_EQ(0, msgpack_pack_int(pk, 3));
EXPECT_EQ(0, msgpack_pack_str(pk, 3));
EXPECT_EQ(0, msgpack_pack_str_body(pk, "str", 3));
EXPECT_EQ(0, msgpack_pack_array(pk, 1));
EXPECT_EQ(0, msgpack_pack_str(pk, 8));
EXPECT_EQ(0, msgpack_pack_str_body(pk, "str_data", 8));
EXPECT_EQ(0, msgpack_pack_bin(pk, 3));
EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin", 3));
EXPECT_EQ(0, msgpack_pack_array(pk, 1));
EXPECT_EQ(0, msgpack_pack_bin(pk, 8));
EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin_data", 8));
EXPECT_EQ(0, msgpack_pack_map(pk, 1));
EXPECT_EQ(0, msgpack_pack_float(pk, 0.4f));
EXPECT_EQ(0, msgpack_pack_double(pk, 0.8));
int max_count = 6;
msgpack_packer_free(pk);
const char* input = buffer->data;
const char* const eof = input + buffer->size;
msgpack_unpacker pac;
msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE);
msgpack_unpacked result;
msgpack_unpacked_init(&result);
int count = 0;
while(count < max_count) {
bool unpacked = false;
msgpack_unpacker_reserve_buffer(&pac, 32*1024);
while(!unpacked) {
/* read buffer into msgpack_unapcker_buffer(&pac) upto
* msgpack_unpacker_buffer_capacity(&pac) bytes. */
memcpy(msgpack_unpacker_buffer(&pac), input, 1);
input += 1;
EXPECT_TRUE(input <= eof);
msgpack_unpacker_buffer_consumed(&pac, 1);
while(msgpack_unpacker_next(&pac, &result) == MSGPACK_UNPACK_SUCCESS) {
unpacked = 1;
msgpack_object obj = result.data;
msgpack_object e;
switch(count++) {
case 0:
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type);
EXPECT_EQ(1, obj.via.u64);
break;
case 1:
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type);
EXPECT_EQ(2, obj.via.u64);
break;
case 2:
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type);
EXPECT_EQ(3, obj.via.u64);
break;
case 3:
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
EXPECT_EQ(std::string("str",3), std::string(obj.via.str.ptr, obj.via.str.size));
break;
case 4:
EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type);
EXPECT_EQ(1, obj.via.array.size);
e = obj.via.array.ptr[0];
EXPECT_EQ(MSGPACK_OBJECT_STR, e.type);
EXPECT_EQ(std::string("str_data",8), std::string(e.via.str.ptr, e.via.str.size));
break;
case 5:
EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type);
EXPECT_EQ(std::string("bin",3), std::string(obj.via.bin.ptr, obj.via.bin.size));
break;
case 6:
EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type);
EXPECT_EQ(1, obj.via.array.size);
e = obj.via.array.ptr[0];
EXPECT_EQ(MSGPACK_OBJECT_BIN, e.type);
EXPECT_EQ(std::string("bin_data",8), std::string(e.via.bin.ptr, e.via.bin.size));
break;
case 7:
EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type);
EXPECT_EQ(1, obj.via.map.size);
e = obj.via.map.ptr[0].key;
EXPECT_EQ(MSGPACK_OBJECT_FLOAT, e.type);
ASSERT_FLOAT_EQ(0.4f, static_cast<float>(e.via.f64));
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type);
ASSERT_FLOAT_EQ(0.4f, static_cast<float>(e.via.dec));
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
e = obj.via.map.ptr[0].val;
EXPECT_EQ(MSGPACK_OBJECT_FLOAT, e.type);
ASSERT_DOUBLE_EQ(0.8, e.via.f64);
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type);
ASSERT_DOUBLE_EQ(0.8, e.via.dec);
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
break;
}
}
}
}
msgpack_unpacker_destroy(&pac);
msgpack_unpacked_destroy(&result);
msgpack_sbuffer_free(buffer);
}
void yar_pack_free(yar_packager *packager) /* {{{ */ {
msgpack_sbuffer_free(packager->bf);
msgpack_packer_free(packager->pk);
free(packager);
}
void session_report(struct session * s, char type){
if(s->need_report==0){
return;
}
s->need_report = 0;
struct msg_report rp;
rp.buffer = msgpack_sbuffer_new();
rp.pk = msgpack_packer_new(rp.buffer, msgpack_sbuffer_write);
rp.count = 0;
// 15 < keys < 65535
// https://github.com/msgpack/msgpack/blob/master/spec.md#formats-map
// +--------+--------+--------+~~~~~~~~~~~~~~~~~+
// | 0xde |YYYYYYYY|YYYYYYYY| N*2 objects |
// +--------+--------+--------+~~~~~~~~~~~~~~~~~+
msgpack_pack_map(rp.pk, 20);
report_add_pair(&rp, "@class", "http-scope");
report_add_pair_int(&rp, "@time", s->start_time);
report_add_pair(&rp, "method", http_method_str(s->method));
report_add_pair(&rp, "host", s->host);
report_add_pair(&rp, "host", s->host);
report_add_pair(&rp, "path", s->path);
report_add_pair(&rp, "node", config.node);
report_add_pair_int(&rp, "code", s->status_code);
//print_data(rp.buffer->data, rp.buffer->size);
report_add_pair(&rp, "server", int_ntoa(s->tcp->addr.daddr));
report_add_pair_int(&rp, "server-port", s->tcp->addr.dest);
report_add_pair(&rp, "client", int_ntoa(s->tcp->addr.saddr));
// report_add_pair_int(&rp, "loat_packet", s->lost_packets);
// report_add_pair_int(&rp, "total_packets", s->packets);
// /* report_add_packet_int(&rp, "packets", "%d/%d",s->lost_packets, s->packets);*/
report_add_pair(&rp, "status", close_status(type));
report_add_pair_int(&rp, "req-bytes", s->tcp->server.count);
report_add_pair_int(&rp, "rep-bytes", s->tcp->client.count);
report_add_pair_float(&rp, "net-req-time", s->req_time/1000000.0);
report_add_pair_float(&rp, "server-time", s->server_time/1000000.0);
report_add_pair_float(&rp, "net-rep-time", s->rep_time/1000000.0);
if(s->referer){
report_add_pair(&rp, "referer", s->referer);
char * referer_host = strstr(s->referer, "//");
if(referer_host){
referer_host+=2;
char *p = strstr(referer_host, "/");
if(p) *p = 0;
report_add_pair(&rp, "referer-host", referer_host);
}
}
struct kv *p = s->proplist;
while(p){
urldecode(p->value);
report_add_pair(&rp, kv_type_string(p->type, p->key), p->value);
p = p->next;
}
if(s->is_catch_response_body && s->response_body_size<65535){
report_add_pair_int(&rp, "body-captured-size", s->response_body_size);
report_add_key(&rp, "body-captured");
msgpack_pack_raw(rp.pk, s->response_body_size);
struct body_buf *b = s->response_body_first;
int size_pushed = 0;
while(b){
msgpack_pack_raw_body(rp.pk, b->data, b->size);
size_pushed += b->size;
b = b->next;
}
}
//print_data(rp.buffer->data, rp.buffer->size);
char *cp = rp.buffer->data;
cp = cp + 1;
*cp = rp.count >> 8;
cp = cp + 1;
*cp = rp.count % 256;
//printf("rp.buffer->size=%d\n", rp.count);
rp.routing_key = malloc(ROUTING_KEY_BUF_SIZE);
bzero(rp.routing_key, ROUTING_KEY_BUF_SIZE);
snprintf(rp.routing_key, ROUTING_KEY_BUF_SIZE,
"http-scope.%s.%dxx.%d", s->host, s->status_code / 100 ,s->status_code);
send_report(&rp);
//print_data(rp.buffer->data, rp.buffer->size);
free(rp.routing_key);
msgpack_sbuffer_free(rp.buffer);
msgpack_packer_free(rp.pk);
session_log(s);
session_clean(s);
session_start(s);
}
void rpc_service_handle(rpc_service_t *service, zmq_msg_t *request) {
/* Parse the msgpack */
zmq_msg_t response;
int rc;
msgpack_unpacked request_msg;
msgpack_unpacked_init(&request_msg);
rc = msgpack_unpack_next(&request_msg, zmq_msg_data(request),
zmq_msg_size(request), NULL);
insist_return(rc, (void)(0), "Failed to unpack message '%.*s'",
(int)zmq_msg_size(request), (char *)zmq_msg_data(request));
msgpack_object request_obj = request_msg.data;
/* Find the method name */
char *method = NULL;
size_t method_len = -1;
rc = obj_get(&request_obj, "method", MSGPACK_OBJECT_RAW, &method, &method_len);
msgpack_sbuffer *response_buffer = msgpack_sbuffer_new();
msgpack_sbuffer *result_buffer = msgpack_sbuffer_new();
msgpack_sbuffer *error_buffer = msgpack_sbuffer_new();
msgpack_packer *response_msg = msgpack_packer_new(response_buffer, msgpack_sbuffer_write);
msgpack_packer *result = msgpack_packer_new(result_buffer, msgpack_sbuffer_write);
msgpack_packer *error = msgpack_packer_new(error_buffer, msgpack_sbuffer_write);
//printf("Method: %.*s\n", method_len, method);
void *clock = zmq_stopwatch_start();
double duration;
if (rc != 0) { /* method not found */
msgpack_pack_nil(result); /* result is nil on error */
msgpack_pack_map(error, 2);
msgpack_pack_string(error, "error", -1);
msgpack_pack_string(error, "Message had no 'method' field", -1);
msgpack_pack_string(error, "request", -1);
msgpack_pack_object(error, request_obj);
} else { /* valid method, keep going */
//printf("The method is: '%.*s'\n", (int)method_len, method);
rpc_name name;
name.name = method;
name.len = method_len;
rpc_method *rpcmethod = g_tree_lookup(service->methods, &name);
/* if we found a valid rpc method and the args check passed ... */
if (rpcmethod != NULL) {
/* the callback is responsible for filling in the 'result' and 'error'
* objects. */
rpcmethod->callback(NULL, &request_obj, result, error, rpcmethod->data);
} else {
msgpack_pack_nil(result); /* result is nil on error */
/* TODO(sissel): allow methods to register themselves */
//fprintf(stderr, "Invalid request '%.*s' (unknown method): ",
//method_len, method);
//msgpack_object_print(stderr, request_obj);
//fprintf(stderr, "\n");
msgpack_pack_map(error, 2);
msgpack_pack_string(error, "error", -1);
msgpack_pack_string(error, "No such method requested", -1);
msgpack_pack_string(error, "request", -1);
msgpack_pack_object(error, request_obj);
}
} /* valid/invalid method handling */
duration = zmq_stopwatch_stop(clock) / 1000000.;
//printf("method '%.*s' took %lf seconds\n", (int)method_len, method);
msgpack_unpacked result_unpacked;
msgpack_unpacked error_unpacked;
msgpack_unpacked response_unpacked;
msgpack_unpacked_init(&result_unpacked);
msgpack_unpacked_init(&error_unpacked);
msgpack_unpacked_init(&response_unpacked);
/* TODO(sissel): If this unpack test fails, we should return an error to the calling
* client indicating that some internal error has occurred */
//fprintf(stderr, "Result payload: '%.*s'\n", result_buffer->size,
//result_buffer->data);
rc = msgpack_unpack_next(&result_unpacked, result_buffer->data,
result_buffer->size, NULL);
insist(rc == true, "msgpack_unpack_next failed on 'result' buffer"
" of request '%.*s'", (int)method_len, method);
rc = msgpack_unpack_next(&error_unpacked, error_buffer->data,
error_buffer->size, NULL);
insist(rc == true, "msgpack_unpack_next failed on 'error' buffer"
" of request '%.*s'", (int)method_len, method);
msgpack_pack_map(response_msg, 3); /* result, error, duration */
msgpack_pack_string(response_msg, "result", 6);
msgpack_pack_object(response_msg, result_unpacked.data);
msgpack_pack_string(response_msg, "error", 5);
msgpack_pack_object(response_msg, error_unpacked.data);
msgpack_pack_string(response_msg, "duration", 8);
msgpack_pack_double(response_msg, duration);
rc = msgpack_unpack_next(&response_unpacked, response_buffer->data,
response_buffer->size, NULL);
insist(rc == true, "msgpack_unpack_next failed on full response buffer"
" of request '%.*s'", (int)method_len, method);
//printf("request: ");
//msgpack_object_print(stdout, request_obj);
//printf("\n");
//printf("response: ");
//msgpack_object_print(stdout, response_unpacked.data);
//printf("\n");
zmq_msg_init_data(&response, response_buffer->data, response_buffer->size,
free_msgpack_buffer, response_buffer);
zmq_send(service->socket, &response, 0);
zmq_msg_close(&response);
msgpack_packer_free(error);
msgpack_packer_free(result);
msgpack_sbuffer_free(error_buffer);
msgpack_sbuffer_free(result_buffer);
msgpack_packer_free(response_msg);
msgpack_unpacked_destroy(&request_msg);
} /* rpc_service_handle */
void write_raw_msgpack(FILE *out, conjugrad_float_t *x, int ncol, void *meta) {
int nsingle = ncol * (N_ALPHA - 1);
int nsingle_padded = nsingle + N_ALPHA_PAD - (nsingle % N_ALPHA_PAD);
conjugrad_float_t *x1 = x;
conjugrad_float_t *x2 = &x[nsingle_padded];
(void)x2;
msgpack_sbuffer* buffer = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
#ifdef JANSSON
if(meta != NULL) {
msgpack_pack_map(pk, 5);
meta_write_msgpack(pk, (json_t *)meta);
} else {
msgpack_pack_map(pk, 4);
}
#else
msgpack_pack_map(pk, 4);
#endif
msgpack_pack_str(pk, 6);
msgpack_pack_str_body(pk, "format", 6);
msgpack_pack_str(pk, 5);
msgpack_pack_str_body(pk, "ccm-1", 5);
msgpack_pack_str(pk, 4);
msgpack_pack_str_body(pk, "ncol", 4);
msgpack_pack_int32(pk, ncol);
msgpack_pack_str(pk, 8);
msgpack_pack_str_body(pk, "x_single", 8);
msgpack_pack_array(pk, ncol * (N_ALPHA - 1));
for(int i = 0; i < ncol; i++) {
for(int a = 0; a < N_ALPHA - 1; a++) {
#if CONJUGRAD_FLOAT == 32
msgpack_pack_float(pk, V(i, a));
#elif CONJUGRAD_FLOAT == 64
msgpack_pack_double(pk, V(i, a));
#endif
}
}
msgpack_pack_str(pk, 6);
msgpack_pack_str_body(pk, "x_pair", 6);
int nedge = ncol * (ncol - 1) / 2;
msgpack_pack_map(pk, nedge);
char sbuf[8192];
for(int i = 0; i < ncol; i++) {
for(int j = i + 1; j < ncol; j++) {
int nchar = snprintf(sbuf, 8192, "%d/%d", i, j);
msgpack_pack_str(pk, nchar);
msgpack_pack_str_body(pk, sbuf, nchar);
msgpack_pack_map(pk, 3);
msgpack_pack_str(pk, 1);
msgpack_pack_str_body(pk, "i", 1);
msgpack_pack_int32(pk, i);
msgpack_pack_str(pk, 1);
msgpack_pack_str_body(pk, "j", 1);
msgpack_pack_int32(pk, j);
msgpack_pack_str(pk, 1);
msgpack_pack_str_body(pk, "x", 1);
msgpack_pack_array(pk, N_ALPHA * N_ALPHA);
for(int a = 0; a < N_ALPHA; a++) {
for(int b = 0; b < N_ALPHA; b++) {
#if CONJUGRAD_FLOAT == 32
msgpack_pack_float(pk, W(b, j, a, i));
#elif CONJUGRAD_FLOAT == 64
msgpack_pack_double(pk, W(b, j, a, i));
#endif
}
}
}
}
fwrite(buffer->data, buffer->size, 1, out);
msgpack_sbuffer_free(buffer);
msgpack_packer_free(pk);
}
static void *client_thread(void *arg) {
ssize_t nwritten;
pthread_detach(pthread_self());
int client_fd = (int) (long) arg;
int yes = 1, tcp_keepalive_probes = 3, tcp_keepalive_time = 5, tcp_keepalive_intvl = 2;
int nodelay = 1;
if (setsockopt(client_fd, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes)) == -1) {
log_error("setsockopt failed: %s", strerror(errno));
close(client_fd);
return NULL;
}
if (setsockopt(client_fd, SOL_TCP, TCP_KEEPCNT, &tcp_keepalive_probes, sizeof(tcp_keepalive_probes)) == -1) {
log_error("setsockopt failed: %s", strerror(errno));
close(client_fd);
return NULL;
}
if (setsockopt(client_fd, SOL_TCP, TCP_KEEPIDLE, &tcp_keepalive_time, sizeof(tcp_keepalive_time)) == -1) {
log_error("setsockopt failed: %s", strerror(errno));
close(client_fd);
return NULL;
}
if (setsockopt(client_fd, SOL_TCP, TCP_KEEPINTVL, &tcp_keepalive_intvl, sizeof(tcp_keepalive_intvl)) == -1) {
log_error("setsockopt failed: %s", strerror(errno));
close(client_fd);
return NULL;
}
if (setsockopt(client_fd, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay)) == -1) {
log_error("setsockopt failed: %s", strerror(errno));
close(client_fd);
return NULL;
}
size_t request_size = 8192;
struct request *request_back = NULL;
struct request *request = (struct request *) malloc(request_size);
if (!request) {
log_error("malloc failed: %s", strerror(errno));
close(client_fd);
return NULL;
}
msgpack_unpacked msg;
msgpack_unpacked_init(&msg);
bool enable_gzip = false;
while (1) {
struct response_header response_header;
ssize_t recvsize = readn(client_fd, request, sizeof(struct request));
if (!recvsize) {
log_warn("peer closed connection");
break;
}
if (recvsize < (ssize_t) sizeof(struct request)) {
log_warn("error while receiving header, received %zd", recvsize);
break;
}
if (request->payload_size > 256 * 1024 * 1024) {
log_warn("payload size %"PRIu32" too large", request->payload_size);
break;
}
if (sizeof(struct request) + request->payload_size > request_size) {
request_size = sizeof(struct request) + request->payload_size;
request_back = request;
request = realloc(request, request_size);
if (!request) {
log_error("realloc failed: %s", strerror(errno));
free(request_back);
break;
}
}
recvsize = readn(client_fd, request->payload, request->payload_size);
if (!recvsize) {
log_warn("peer closed connection");
break;
}
if (recvsize < request->payload_size) {
log_warn("error while receiving payload, received %zd (should be %"PRIu32")", recvsize, request->payload_size);
break;
}
if (request->flags & REQUEST_FLAG_GZIP) {
enable_gzip = true;
uLongf destLen = 16;
Bytef *dest = malloc(destLen);
if (!dest) {
log_error("malloc failed: %s", strerror(errno));
break;
}
int ret;
keep_malloc:
ret = uncompress(dest, &destLen, (Bytef *) request->payload, request->payload_size);
if (ret == Z_BUF_ERROR) {
destLen = destLen * 2;
free(dest);
dest = malloc(destLen);
if (!dest) {
log_error("malloc failed: %s", strerror(errno));
break;
}
goto keep_malloc;
}
if (ret != Z_OK) {
free(dest);
break;
}
request->flags &= ~REQUEST_FLAG_GZIP;
if (sizeof(struct request) + destLen > request_size) {
request_size = sizeof(struct request) + destLen;
request_back = request;
request = realloc(request, request_size);
if (!request) {
log_error("realloc failed: %s", strerror(errno));
free(request_back);
free(dest);
break;
}
}
memcpy(request->payload, dest, destLen);
request->payload_size = destLen;
free(dest);
}
bool success = msgpack_unpack_next(&msg, request->payload, request->payload_size, NULL);
if (!success) {
log_warn("error while parsing payload");
break;
}
msgpack_sbuffer* buffer = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
response_header.seq = request->seq;
__sync_add_and_fetch(&pending_commands, 1);
if (server->terminated) {
__sync_add_and_fetch(&pending_commands, -1);
break;
}
if (server->redirection) {
response_header.status = RESPONSE_STATUS_REDIRECTION;
msgpack_pack_map(pk, 2);
mp_pack_string(pk, "host");
mp_pack_string(pk, server->redirection->host);
mp_pack_string(pk, "port");
msgpack_pack_uint16(pk, server->redirection->port);
}
else {
response_header.status = execute_command(request, request->command, msg.data, pk);
}
__sync_add_and_fetch(&pending_commands, -1);
msgpack_packer_free(pk);
if (!(request->flags & REQUEST_FLAG_NO_REPLY)) {
if (!(buffer->size > 0)) {
response_header.payload_size = 0;
nwritten = writen(client_fd, &response_header, sizeof(response_header));
if (!nwritten) {
log_error("writen failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
break;
}
}
else {
if (!enable_gzip) {
response_header.payload_size = buffer->size;
nwritten = writen(client_fd, &response_header, sizeof(response_header));
if (!nwritten) {
log_error("writen failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
break;
}
nwritten = writen(client_fd, buffer->data, buffer->size);
if (!nwritten) {
log_error("writen failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
break;
}
}
else {
uLongf destLen = buffer->size * 1.00101 + 13;
Bytef *dest = malloc(destLen);
if (!dest) {
log_error("malloc failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
break;
}
int ret = compress(dest, &destLen, (Bytef *) buffer->data, buffer->size);
while (ret == Z_BUF_ERROR) {
destLen = destLen * 2 + 16;
free(dest);
dest = malloc(destLen);
if (!dest) {
log_error("malloc failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
break;
}
ret = compress(dest, &destLen, (Bytef *) buffer->data, buffer->size);
}
if (ret != Z_OK) {
log_error("error while compressing response: %d", ret);
if (dest)
free(dest);
break;
}
response_header.payload_size = destLen;
nwritten = writen(client_fd, &response_header, sizeof(response_header));
if (!nwritten) {
log_warn("peer closed connection");
msgpack_sbuffer_free(buffer);
free(dest);
break;
}
if (nwritten < 0) {
log_error("send response header failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
free(dest);
break;
}
if (nwritten < (ssize_t)sizeof(response_header)) {
log_warn("error while sending response header, sent %zd (should be %"PRIu64")", nwritten, sizeof(response_header));
msgpack_sbuffer_free(buffer);
free(dest);
break;
}
nwritten = writen(client_fd, dest, destLen);
if (!nwritten) {
log_warn("peer closed connection");
msgpack_sbuffer_free(buffer);
free(dest);
break;
}
if (nwritten < 0) {
log_error("send response failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
free(dest);
break;
}
if (nwritten < (ssize_t)destLen) {
log_warn("error while sending response, sent %zd (should be %"PRIu64")", nwritten, destLen);
msgpack_sbuffer_free(buffer);
free(dest);
break;
}
free(dest);
}
}
}
msgpack_sbuffer_free(buffer);
if (request_size > 65536) {
request_size = 8192;
request_back = request;
request = realloc(request, request_size);
if (!request) {
log_error("realloc failed: %s", strerror(errno));
free(request_back);
break;
}
}
}
close(client_fd);
free(request);
msgpack_unpacked_destroy(&msg);
return NULL;
}
