static void
recv_handler(grn_ctx *ctx, void *zmq_recv_sock, msgpack_zone *mempool, grn_obj *cmd_buf)
{
zmq_msg_t msg;
if (zmq_msg_init(&msg)) {
print_error("cannot init zmq message.");
} else {
if (zmq_recv(zmq_recv_sock, &msg, 0)) {
print_error("cannot recv zmq message.");
} else {
msgpack_object obj;
msgpack_unpack_return ret;
ret = msgpack_unpack(zmq_msg_data(&msg), zmq_msg_size(&msg), NULL, mempool, &obj);
if (MSGPACK_UNPACK_SUCCESS == ret) {
load_from_learner(&obj, ctx, cmd_buf);
} else {
print_error("invalid recv data.");
}
msgpack_zone_clear(mempool);
}
zmq_msg_close(&msg);
}
}
int main(void)
{
msgpack_sbuffer sbuf;
msgpack_packer pk;
msgpack_zone mempool;
msgpack_object deserialized;
/* msgpack::sbuffer is a simple buffer implementation. */
msgpack_sbuffer_init(&sbuf);
/* serialize values into the buffer using msgpack_sbuffer_write callback function. */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 3);
msgpack_pack_int(&pk, 1);
msgpack_pack_true(&pk);
msgpack_pack_str(&pk, 7);
msgpack_pack_str_body(&pk, "example", 7);
/* deserialize the buffer into msgpack_object instance. */
/* deserialized object is valid during the msgpack_zone instance alive. */
msgpack_zone_init(&mempool, 2048);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
/* print the deserialized object. */
msgpack_object_print(stdout, deserialized);
puts("");
msgpack_zone_destroy(&mempool);
msgpack_sbuffer_destroy(&sbuf);
return 0;
}
msgpack_object* AReplayPlayer::PacketAtOffset(size_t TmpOffset) {
msgpack_unpack_return ret = msgpack_unpack(data, size, &offset, &mempool, &tmp_object);
if (ret <= 0) {
return NULL;
}
return &tmp_object;
}
msgpack_object* AReplayPlayer::PeekNextPacket() {
size_t offset_copy = offset;
msgpack_zone_clear(&mempool);
msgpack_unpack_return ret = msgpack_unpack(data, size, &offset_copy, &mempool, &tmp_object);
if (ret <= 0) {
return NULL;
}
return &tmp_object;
}
void
load_data(char *filename, load_data_function unpack_function)
{
char *save_file_name;
char *save_data;
FILE *save_file;
int len;
struct stat file_stat;
msgpack_zone *mempool;
msgpack_object deserialized;
if ((save_file_name = get_save_file_path(filename)) == NULL) {
red_log(REDD_WARNING, "get_save_file_path returned NULL");
return;
}
if (stat(save_file_name, &file_stat) != 0) {
free(save_file_name);
return;
}
if (!S_ISREG(file_stat.st_mode)) {
free(save_file_name);
return;
}
len = file_stat.st_size;
if ((save_file = fopen(save_file_name, "r")) != NULL) {
size_t bytes_read;
save_data = (char *)malloc(len);
bytes_read = fread((void *)save_data, 1, len, save_file);
fclose(save_file);
if (bytes_read != len) {
red_log(REDD_WARNING, "Failed to read data from %s", save_file_name);
free(save_file_name);
free(save_data);
return;
}
} else {
red_log(REDD_WARNING, "Failed to open %s", save_file_name);
free(save_file_name);
return;
}
mempool = (msgpack_zone *)malloc(sizeof(msgpack_zone));
msgpack_zone_init(mempool, 4096);
msgpack_unpack(save_data, len, NULL, mempool, &deserialized);
unpack_function(deserialized);
free(save_file_name);
save_file_name = NULL;
free(save_data);
save_data = NULL;
msgpack_zone_destroy(mempool);
free(mempool);
mempool = NULL;
}
/// output MessagePack sbuffer to stream in text format
static void log_text_sbuffer(FILE *stream, msgpack_sbuffer *msg) {
// deserialize sbuffer to object
msgpack_zone mempool;
msgpack_zone_init(&mempool, 1024);
msgpack_object deserialized;
msgpack_unpack(msg->data, msg->size, NULL, &mempool, &deserialized);
// now output the message object
log_text(stream, &deserialized);
// and free up memory
msgpack_zone_destroy(&mempool);
}
msgpack_object* AReplayPlayer::NextPacket() {
EOffsetHistory* CurrentOffset = (EOffsetHistory*) malloc(sizeof(EOffsetHistory));
CurrentOffset->Offset = offset;
CurrentOffset->Previous = OffsetHistory;
OffsetHistory = CurrentOffset;
msgpack_zone_clear(&mempool);
msgpack_unpack_return ret = msgpack_unpack(data, size, &offset, &mempool, &tmp_object);
if (ret <= 0) {
return NULL;
}
return &tmp_object;
}
value_t unserialize(const zookeeper::value_t& val) {
msgpack::object obj;
std::unique_ptr<msgpack::zone> z(new msgpack::zone());
msgpack_unpack_return ret = msgpack_unpack(
val.c_str(), val.size(), nullptr, z.get(),
reinterpret_cast<msgpack_object*>(&obj)
);
//Only strict unparse.
if(static_cast<msgpack::unpack_return>(ret) != msgpack::UNPACK_SUCCESS) {
throw std::system_error(cocaine::error::unicorn_errors::invalid_value);
}
value_t target;
cocaine::io::type_traits<cocaine::dynamic_t>::unpack(obj, target);
return target;
}
static void
on_response(msgxchng_response_t *res, int status)
{
if (status == RED_ERR)
exit(1);
msgpack_zone mempool;
msgpack_zone_init(&mempool, 4096);
msgpack_object deserialized;
msgpack_unpack(res->data, res->data_len, NULL, &mempool, &deserialized);
int success = 0;
if (deserialized.type == MSGPACK_OBJECT_MAP) {
msgpack_object_kv* p = deserialized.via.map.ptr;
msgpack_object_kv* const pend = deserialized.via.map.ptr + deserialized.via.map.size;
for (; p < pend; ++p) {
if (p->key.type == MSGPACK_OBJECT_RAW && p->val.type == MSGPACK_OBJECT_RAW) {
if (!strncmp(p->key.via.raw.ptr, "return", p->key.via.raw.size)) {
if (!strncmp(p->val.via.raw.ptr, "success", p->val.via.raw.size))
success = 1;
else
success = 0;
} else if (!strncmp(p->key.via.raw.ptr, "error", p->key.via.raw.size)) {
if (!config.no_output) fprintf(stderr, "red: %s\n", p->val.via.raw.ptr);
}
}
}
}
clean_msgxchng_response(res);
free(res);
if (!success)
exit(1);
}
void unit_message_deserialize_response(UNUSED(void **state))
{
struct api_error error = ERROR_INIT;
msgpack_sbuffer sbuf;
msgpack_packer pk;
msgpack_zone mempool;
msgpack_object deserialized;
struct message_response response;
msgpack_sbuffer_init(&sbuf);
msgpack_zone_init(&mempool, 2048);
/* positiv test */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
free_params(response.params);
/* wrong type type */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_nil(&pk);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong type */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 0);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong msgid */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_int(&pk, -1234);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong msgid value*/
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint32(&pk, UINT32_MAX);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong nil */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong params */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_nil(&pk);
msgpack_pack_nil(&pk);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* null input params */
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
NULL));
assert_int_not_equal(0, message_deserialize_response(&response, NULL,
&error));
assert_int_not_equal(0, message_deserialize_response(NULL, &deserialized,
&error));
msgpack_zone_destroy(&mempool);
msgpack_sbuffer_destroy(&sbuf);
}
