void test()
{
uint64_t test_u64 = 0xFFF0000000000001LL;
size_t size = 10000000;
msgpack_sbuffer buf;
msgpack_sbuffer_init(&buf);
msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
msgpack_pack_array(pk, size);
{
int idx = 0;
for (; idx < size; ++idx)
msgpack_pack_uint64(pk, test_u64);
}
msgpack_packer_free(pk);
size_t upk_pos = 0;
msgpack_unpacked msg;
msgpack_unpacked_init(&msg);
while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
}
msgpack_sbuffer_destroy(&buf);
}
virtual void encode()
{
mImgs = boost::shared_ptr<boost::circular_buffer<CameraImage> >(new boost::circular_buffer<CameraImage>(60));
while(1)
{
if(mImgs->size() == 0)
{
usleep(3000);
continue;
}
printf("encoding!\n");
CameraImage i = mImgs->back();
mImgs->pop_back();
encodeImage(i);
msgpack_sbuffer buffer;
msgpack_packer pk;
msgpack_sbuffer_init(&buffer);
msgpack_packer_init(&pk, &buffer, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_int(&pk, 1);
msgpack_pack_int(&pk, i.camera_timestamp);
msgpack_pack_raw(&pk, i.encoded.size);
msgpack_pack_raw_body(&pk, (void*)i.encoded.buffer.get(), i.encoded.size);
write(mFile, buffer.data, buffer.size);
msgpack_sbuffer_destroy(&buffer);
}
}
static apr_status_t log_fluentd_writer(request_rec *r, void *handle, const char **strs, int *strl, int nelts, apr_size_t len)
{
fluentd_log *log = (fluentd_log *)handle;
apr_status_t result;
if (log->write_local == 1) {
if (log->normal_handle) {
result = normal_log_writer(r, log->normal_handle, strs, strl, nelts, len);
}
} else {
int i =0;
char *str;
msgpack_sbuffer sbuf;
msgpack_packer pk;
msgpack_sbuffer_init(&sbuf);
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 3);
msgpack_pack_raw(&pk,log->tag_len);
msgpack_pack_raw_body(&pk, log->tag, log->tag_len);
msgpack_pack_int(&pk, 1329275765);
msgpack_pack_array(&pk,nelts);
for (i = 0; i < nelts; i++) {
msgpack_pack_raw(&pk,strl[i]);
msgpack_pack_raw_body(&pk, strs[i], strl[i]);
}
log_fluentd_post(log,&sbuf);
msgpack_sbuffer_destroy(&sbuf);
}
return OK;
}
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;
}
void *in_xbee_flush(void *in_context, int *size)
{
char *buf;
msgpack_sbuffer *sbuf;
struct flb_in_xbee_config *ctx = in_context;
pthread_mutex_lock(&ctx->mtx_mp);
if (ctx->buffer_id == 0)
goto fail;
sbuf = &ctx->mp_sbuf;
*size = sbuf->size;
buf = malloc(sbuf->size);
if (!buf)
goto fail;
/* set a new buffer and re-initialize our MessagePack context */
memcpy(buf, sbuf->data, sbuf->size);
msgpack_sbuffer_destroy(&ctx->mp_sbuf);
msgpack_sbuffer_init(&ctx->mp_sbuf);
msgpack_packer_init(&ctx->mp_pck, &ctx->mp_sbuf, msgpack_sbuffer_write);
ctx->buffer_id = 0;
pthread_mutex_unlock(&ctx->mtx_mp);
return buf;
fail:
pthread_mutex_unlock(&ctx->mtx_mp);
return NULL;
}
void *in_serial_flush(void *in_context, int *size)
{
char *buf;
msgpack_sbuffer *sbuf;
struct flb_in_serial_config *ctx = in_context;
if (ctx->buffer_id == 0)
return NULL;
sbuf = &ctx->mp_sbuf;
*size = sbuf->size;
buf = malloc(sbuf->size);
if (!buf) {
return NULL;
}
/* set a new buffer and re-initialize our MessagePack context */
memcpy(buf, sbuf->data, sbuf->size);
msgpack_sbuffer_destroy(&ctx->mp_sbuf);
msgpack_sbuffer_init(&ctx->mp_sbuf);
msgpack_packer_init(&ctx->mp_pck, &ctx->mp_sbuf, msgpack_sbuffer_write);
ctx->buffer_id = 0;
return buf;
}
void ANetworkController::ReceivedSeekAndPauseReplay(msgpack_object* Data) {
AReplayPlayer* Player = NULL;
for (TActorIterator<AReplayPlayer> ObjIt(GetWorld()); ObjIt; ++ObjIt) {
Player = *ObjIt;
break;
}
check(Player != NULL);
float Seconds = Unpack<double>(Data);
Player->SeekAndPause(Seconds);
msgpack_sbuffer sbuf;
msgpack_sbuffer_init(&sbuf);
msgpack_packer pk;
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 2);
msgpack_pack_uint16(&pk, EPacketType::PT_SeekAndPauseReplay);
msgpack_pack_float(&pk, Player->GetTime());
int32 BytesSent;
TcpSocket->Send((uint8*)sbuf.data, sbuf.size, BytesSent);
msgpack_sbuffer_destroy(&sbuf);
}
int main(void) {
msgpack_sbuffer sbuf;
msgpack_sbuffer_init(&sbuf);
prepare(&sbuf);
unpack(sbuf.data, sbuf.size);
msgpack_sbuffer_destroy(&sbuf);
return 0;
}
static VALUE get_queued_messages() {
msgpack_sbuffer * sbuf = msgpack_sbuffer_new();
get_event_collection_message(sbuf);
if(sbuf && sbuf->size > 0) {
VALUE str = rb_str_new(sbuf->data, sbuf->size);
message_list_clear();
msgpack_sbuffer_destroy(sbuf);
return str;
}
return Qnil;
}
void unit_message_serialize_request(UNUSED(void **state))
{
msgpack_sbuffer sbuf;
msgpack_packer pk;
struct message_request request;
array params;
params.size = 1;
params.obj = CALLOC(1, struct message_object);
params.obj[0].type = OBJECT_TYPE_UINT;
params.obj[0].data.uinteger = 1234;
msgpack_sbuffer_init(&sbuf);
/* positiv test */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
request.msgid = 1234;
request.method = (string) {.str = "test method",
.length = sizeof("test method") - 1};
request.params = params;
assert_int_equal(0, message_serialize_request(&request, &pk));
msgpack_sbuffer_clear(&sbuf);
/* no valid string */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
request.msgid = 1234;
request.method = (string) STRING_INIT;
request.params = params;
assert_int_not_equal(0, message_serialize_request(&request, &pk));
msgpack_sbuffer_clear(&sbuf);
free_params(request.params);
params.size = 1;
params.obj = CALLOC(1, struct message_object);
params.obj[0].type = 1000;
params.obj[0].data.uinteger = 1234;
/* no valid params */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
request.msgid = 1234;
request.method = (string) {.str = "test method",
.length = sizeof("test method") - 1};
request.params = params;
assert_int_not_equal(0, message_serialize_request(&request, &pk));
msgpack_sbuffer_clear(&sbuf);
free_params(request.params);
/* null check */
assert_int_not_equal(0, message_serialize_request(NULL, NULL));
msgpack_sbuffer_destroy(&sbuf);
}
void unit_message_is_response(UNUSED(void **state))
{
msgpack_sbuffer sbuf;
msgpack_packer pk;
msgpack_zone mempool;
msgpack_object deserialized;
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_uint8(&pk, 0);
msgpack_pack_uint8(&pk, 0);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_true(message_is_response(&deserialized));
msgpack_sbuffer_clear(&sbuf);
/* wrong type test */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 0);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint8(&pk, 1);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_false(message_is_response(&deserialized));
msgpack_sbuffer_clear(&sbuf);
/* no array test */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_uint8(&pk, 1);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_false(message_is_response(&deserialized));
msgpack_sbuffer_clear(&sbuf);
/* NULL test */
assert_false(message_is_response(NULL));
msgpack_sbuffer_clear(&sbuf);
msgpack_zone_destroy(&mempool);
msgpack_sbuffer_destroy(&sbuf);
}
int main(int argc,char **argv) {
msgpack_sbuffer sbuf;
msgpack_sbuffer_init(&sbuf);
prepare(&sbuf);
char bf[2048]={0};
prepare_from_file(argv[1],bf,atoi(argv[2]));
unpack(bf, atoi(argv[2]));
msgpack_sbuffer_destroy(&sbuf);
return 0;
}
void *in_mem_flush(void *in_context, int *size)
{
char *buf;
struct flb_in_mem_config *ctx = in_context;
buf = malloc(ctx->sbuf.size);
if (!buf) {
return NULL;
}
memcpy(buf, ctx->sbuf.data, ctx->sbuf.size);
*size = ctx->sbuf.size;
msgpack_sbuffer_destroy(&ctx->sbuf);
msgpack_sbuffer_init(&ctx->sbuf);
msgpack_packer_init(&ctx->pckr, &ctx->sbuf, msgpack_sbuffer_write);
ctx->idx = 0;
return buf;
}
void ANetworkController::ReceivedGetGitHash() {
msgpack_sbuffer sbuf;
msgpack_sbuffer_init(&sbuf);
msgpack_packer pk;
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 2);
msgpack_pack_uint16(&pk, EPacketType::PT_GetGitHash);
msgpack_pack_str(&pk, GIT_HASH_LEN);
msgpack_pack_str_body(&pk, GIT_HASH, GIT_HASH_LEN);
int32 BytesSent;
TcpSocket->Send((uint8*)sbuf.data, sbuf.size, BytesSent);
msgpack_sbuffer_destroy(&sbuf);
}
void init_unpack_array(msgpack_object_type type)
{
size_t off = 0;
msgpack_sbuffer sbuf;
msgpack_sbuffer_init(&sbuf);
msgpack_packer pk;
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 3);
if (type == MSGPACK_OBJECT_NIL) {
msgpack_pack_nil(&pk);
} else if (type == MSGPACK_OBJECT_POSITIVE_INTEGER) {
msgpack_pack_int(&pk, 1);
} else if (type == MSGPACK_OBJECT_BOOLEAN) {
msgpack_pack_true(&pk);
} else if (type == MSGPACK_OBJECT_MAP) {
msgpack_pack_map(&pk, 1);
} else if (type == MSGPACK_OBJECT_ARRAY) {
msgpack_pack_array(&pk, 3);
msgpack_pack_int(&pk, 1);
msgpack_pack_int(&pk, 1);
msgpack_pack_int(&pk, 1);
} else if (type == MSGPACK_OBJECT_FLOAT) {
msgpack_pack_double(&pk, 1.2);
}
msgpack_pack_true(&pk);
msgpack_pack_str(&pk, 7);
msgpack_pack_str_body(&pk, "example", 7);
msgpack_unpacked result;
msgpack_unpacked_init(&result);
msgpack_unpack_next(&result, sbuf.data, sbuf.size, &off);
msgpack_sbuffer_destroy(&sbuf);
deserialized = result.data;
}
/*
* Convert the internal Fluent Bit data representation to the required
* one by Treasure Data cloud service.
*
* This function returns a new msgpack buffer and store the bytes length
* in the out_size variable.
*/
static char *td_format(void *data, size_t bytes, int *out_size)
{
int i;
int ret;
int n_size;
size_t off = 0;
time_t atime;
char *buf;
struct msgpack_sbuffer mp_sbuf;
struct msgpack_packer mp_pck;
msgpack_unpacked result;
msgpack_object root;
msgpack_object map;
msgpack_sbuffer *sbuf;
/* Initialize contexts for new output */
msgpack_sbuffer_init(&mp_sbuf);
msgpack_packer_init(&mp_pck, &mp_sbuf, msgpack_sbuffer_write);
/* Iterate the original buffer and perform adjustments */
msgpack_unpacked_init(&result);
/* Perform some format validation */
ret = msgpack_unpack_next(&result, data, bytes, &off);
if (!ret) {
return NULL;
}
/* We 'should' get an array */
if (result.data.type != MSGPACK_OBJECT_ARRAY) {
/*
* If we got a different format, we assume the caller knows what he is
* doing, we just duplicate the content in a new buffer and cleanup.
*/
buf = malloc(bytes);
if (!buf) {
return NULL;
}
memcpy(buf, data, bytes);
*out_size = bytes;
return buf;
}
root = result.data;
if (root.via.array.size == 0) {
return NULL;
}
off = 0;
msgpack_unpacked_destroy(&result);
msgpack_unpacked_init(&result);
while (msgpack_unpack_next(&result, data, bytes, &off)) {
if (result.data.type != MSGPACK_OBJECT_ARRAY) {
continue;
}
/* Each array must have two entries: time and record */
root = result.data;
if (root.via.array.size != 2) {
continue;
}
atime = root.via.array.ptr[0].via.u64;
map = root.via.array.ptr[1];
n_size = map.via.map.size + 1;
msgpack_pack_map(&mp_pck, n_size);
msgpack_pack_bin(&mp_pck, 4);
msgpack_pack_bin_body(&mp_pck, "time", 4);
msgpack_pack_int32(&mp_pck, atime);
for (i = 0; i < n_size - 1; i++) {
msgpack_pack_object(&mp_pck, map.via.map.ptr[i].key);
msgpack_pack_object(&mp_pck, map.via.map.ptr[i].val);
}
}
msgpack_unpacked_destroy(&result);
/* Create new buffer */
sbuf = &mp_sbuf;
*out_size = sbuf->size;
buf = malloc(sbuf->size);
if (!buf) {
return NULL;
}
/* set a new buffer and re-initialize our MessagePack context */
memcpy(buf, sbuf->data, sbuf->size);
msgpack_sbuffer_destroy(&mp_sbuf);
return buf;
}
static void
log_send(struct evkeyvalq *output_headers, struct evbuffer *res_buf,
thd_data *thd, struct evkeyvalq *get_args)
{
uint64_t millisec;
int threshold, limit;
const char *callback, *types, *query, *client_id, *target_name,
*learn_target_name;
parse_keyval(get_args, &query, &types, &client_id, &target_name,
&learn_target_name, &callback, &millisec, &threshold, &limit);
/* send data to learn client */
if (thd->zmq_sock && millisec && client_id && query && learn_target_name) {
char c;
size_t l;
msgpack_packer pk;
msgpack_sbuffer sbuf;
int cnt, submit_flag = 0;
msgpack_sbuffer_init(&sbuf);
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
cnt = 4;
if (types && !strcmp(types, "submit")) {
cnt++;
types = NULL;
submit_flag = 1;
}
msgpack_pack_map(&pk, cnt);
c = 'i';
msgpack_pack_raw(&pk, 1);
msgpack_pack_raw_body(&pk, &c, 1);
l = strlen(client_id);
msgpack_pack_raw(&pk, l);
msgpack_pack_raw_body(&pk, client_id, l);
c = 'q';
msgpack_pack_raw(&pk, 1);
msgpack_pack_raw_body(&pk, &c, 1);
l = strlen(query);
msgpack_pack_raw(&pk, l);
msgpack_pack_raw_body(&pk, query, l);
c = 's';
msgpack_pack_raw(&pk, 1);
msgpack_pack_raw_body(&pk, &c, 1);
msgpack_pack_uint64(&pk, millisec);
c = 'l';
msgpack_pack_raw(&pk, 1);
msgpack_pack_raw_body(&pk, &c, 1);
l = strlen(learn_target_name);
msgpack_pack_raw(&pk, l);
msgpack_pack_raw_body(&pk, learn_target_name, l);
if (submit_flag) {
c = 't';
msgpack_pack_raw(&pk, 1);
msgpack_pack_raw_body(&pk, &c, 1);
msgpack_pack_true(&pk);
}
{
zmq_msg_t msg;
if (!zmq_msg_init_size(&msg, sbuf.size)) {
memcpy((void *)zmq_msg_data(&msg), sbuf.data, sbuf.size);
if (zmq_send(thd->zmq_sock, &msg, 0)) {
print_error("zmq_send() error");
}
zmq_msg_close(&msg);
}
}
msgpack_sbuffer_destroy(&sbuf);
}
/* make result */
{
int content_length;
if (callback) {
evhttp_add_header(output_headers,
"Content-Type", "text/javascript; charset=UTF-8");
content_length = strlen(callback);
evbuffer_add(res_buf, callback, content_length);
evbuffer_add(res_buf, "(", 1);
content_length += suggest_result(res_buf, types, query, target_name,
threshold, limit,
&(thd->cmd_buf), thd->ctx) + 3;
evbuffer_add(res_buf, ");", 2);
} else {
evhttp_add_header(output_headers,
"Content-Type", "application/json; charset=UTF-8");
content_length = suggest_result(res_buf, types, query, target_name,
threshold, limit,
&(thd->cmd_buf), thd->ctx);
}
if (content_length >= 0) {
char num_buf[16];
snprintf(num_buf, 16, "%d", content_length);
evhttp_add_header(output_headers, "Content-Length", num_buf);
}
}
}
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);
}
int cb_fluentd_flush(void *data, size_t bytes, void *out_context,
struct flb_config *config)
{
int fd;
int ret = -1;
int maps = 0;
size_t total;
char *buf = NULL;
msgpack_packer mp_pck;
msgpack_sbuffer mp_sbuf;
msgpack_unpacked mp_umsg;
size_t mp_upos = 0;
(void) out_context;
(void) config;
/*
* The incoming data comes in Fluent Bit format an array of objects, as we
* aim to send this information to Fluentd through it in_forward plugin, we
* need to transform the data. The Fluentd in_forward plugin allows one
* of the following formats:
*
* 1. [tag, time, record]
*
* or
*
* 2. [tag, [[time,record], [time,record], ...]]
*
* we use the format #2
*/
/* Initialize packager */
msgpack_sbuffer_init(&mp_sbuf);
msgpack_packer_init(&mp_pck, &mp_sbuf, msgpack_sbuffer_write);
/*
* Count the number of map entries
*
* FIXME: Fluent Bit should expose the number of maps into the
* data, so we avoid this silly counting.
*/
msgpack_unpacked_init(&mp_umsg);
while (msgpack_unpack_next(&mp_umsg, data, bytes, &mp_upos)) {
maps++;
}
msgpack_unpacked_destroy(&mp_umsg);
/* Output: root array */
msgpack_pack_array(&mp_pck, 2);
msgpack_pack_bin(&mp_pck, sizeof(FLB_CONFIG_DEFAULT_TAG) - 1);
msgpack_pack_bin_body(&mp_pck,
FLB_CONFIG_DEFAULT_TAG,
sizeof(FLB_CONFIG_DEFAULT_TAG) - 1);
msgpack_pack_array(&mp_pck, maps);
/* Allocate a new buffer to merge data */
total = bytes + mp_sbuf.size;
buf = malloc(total);
if (!buf) {
perror("malloc");
return -1;
}
memcpy(buf, mp_sbuf.data, mp_sbuf.size);
memcpy(buf + mp_sbuf.size, data, bytes);
msgpack_sbuffer_destroy(&mp_sbuf);
fd = flb_net_tcp_connect(out_fluentd_plugin.host,
out_fluentd_plugin.port);
if (fd <= 0) {
free(buf);
return -1;
}
/* FIXME: plain TCP write */
ret = write(fd, buf, total);
close(fd);
free(buf);
return ret;
}
static char * packStructure(char *serviceName, char *dest, char *trans_id, char *payload, char *contentType, unsigned int payload_len)
{
msgpack_sbuffer sbuf;
msgpack_packer pk;
char* b64buffer = NULL;
size_t encodeSize = 0;
char source[MAX_PARAMETERNAME_LEN/2] = {'\0'};
int msg_type = 4;
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, LMLite %s ENTER\n", __FUNCTION__ ));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, deviceMAC *********:%s\n",deviceMAC));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, serviceName :%s\n",serviceName));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, dest :%s\n",dest));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, transaction_id :%s\n",trans_id));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, contentType :%s\n",contentType));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, payload_len :%d\n",payload_len));
snprintf(source, sizeof(source), "mac:%s/%s", deviceMAC, serviceName);
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Received DeviceMac from Atom side: %s\n",deviceMAC));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Source derived is %s\n", source));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, <======== Start of packStructure ======>\n"));
// Start of msgpack encoding
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, -----------Start of msgpack encoding------------\n"));
msgpack_sbuffer_init(&sbuf);
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_map(&pk, WEBPA_MAP_SIZE);
msgpack_pack_str(&pk, strlen(WEBPA_MSG_TYPE));
msgpack_pack_str_body(&pk, WEBPA_MSG_TYPE,strlen(WEBPA_MSG_TYPE));
msgpack_pack_int(&pk, msg_type);
msgpack_pack_str(&pk, strlen(WEBPA_SOURCE));
msgpack_pack_str_body(&pk, WEBPA_SOURCE,strlen(WEBPA_SOURCE));
msgpack_pack_str(&pk, strlen(source));
msgpack_pack_str_body(&pk, source,strlen(source));
msgpack_pack_str(&pk, strlen(WEBPA_DESTINATION));
msgpack_pack_str_body(&pk, WEBPA_DESTINATION,strlen(WEBPA_DESTINATION));
msgpack_pack_str(&pk, strlen(dest));
msgpack_pack_str_body(&pk, dest,strlen(dest));
msgpack_pack_str(&pk, strlen(WEBPA_TRANSACTION_ID));
msgpack_pack_str_body(&pk, WEBPA_TRANSACTION_ID,strlen(WEBPA_TRANSACTION_ID));
msgpack_pack_str(&pk, strlen(trans_id));
msgpack_pack_str_body(&pk, trans_id,strlen(trans_id));
msgpack_pack_str(&pk, strlen(WEBPA_PAYLOAD));
msgpack_pack_str_body(&pk, WEBPA_PAYLOAD,strlen(WEBPA_PAYLOAD));
if(strcmp(contentType,"avro/binary") == 0)
{
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, msg->payload binary\n"));
msgpack_pack_bin(&pk, payload_len);
msgpack_pack_bin_body(&pk, payload, payload_len);
}
else // string: "contentType :application/json"
{
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, msg->payload string\n"));
msgpack_pack_str(&pk, strlen(payload));
msgpack_pack_str_body(&pk, payload,strlen(payload));
}
msgpack_pack_str(&pk, strlen(CONTENT_TYPE));
msgpack_pack_str_body(&pk, CONTENT_TYPE,strlen(CONTENT_TYPE));
msgpack_pack_str(&pk, strlen(contentType));
msgpack_pack_str_body(&pk, contentType,strlen(contentType));
/*if(consoleDebugEnable)
fprintf(stderr, "RDK_LOG_DEBUG,msgpack encoded data contains %d bytes and data is : %s\n",(int)sbuf.size,sbuf.data);*/
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,-----------End of msgpack encoding------------\n"));
// End of msgpack encoding
// Start of Base64 Encode
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,-----------Start of Base64 Encode ------------\n"));
encodeSize = b64_get_encoded_buffer_size( sbuf.size );
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,encodeSize is %d\n", (int)encodeSize));
b64buffer = malloc(encodeSize + 1); // one byte extra for terminating NULL byte
b64_encode((const uint8_t *)sbuf.data, sbuf.size, (uint8_t *)b64buffer);
b64buffer[encodeSize] = '\0' ;
/*if(consoleDebugEnable)
{
int i;
fprintf(stderr, "RDK_LOG_DEBUG,\n\n b64 encoded data is : ");
for(i = 0; i < encodeSize; i++)
fprintf(stderr,"%c", b64buffer[i]);
fprintf(stderr,"\n\n");
}*/
//CcspLMLiteTrace(("RDK_LOG_DEBUG,\nb64 encoded data length is %d\n",i));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,---------- End of Base64 Encode -------------\n"));
// End of Base64 Encode
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,Destroying sbuf.....\n"));
msgpack_sbuffer_destroy(&sbuf);
//CcspLMLiteTrace(("RDK_LOG_DEBUG,Final Encoded data: %s\n",b64buffer));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,Final Encoded data length: %d\n",(int)strlen(b64buffer)));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,<======== End of packStructure ======>\n"));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, LMLite %s EXIT\n", __FUNCTION__ ));
return b64buffer;
}
void* run_test(void *threadid)
{
long tid = (long)threadid;
for (int cycle = 0; cycle < CYCLES; ++cycle) {
GHashTable* sockets = g_hash_table_new(g_direct_hash, g_direct_equal);
int epfd = epoll_create(MAX_CONNECTIONS);
if (epfd < 1) {
printf("can't create epoll\n");
if (sockets) {
g_hash_table_destroy(sockets);
sockets = NULL;
}
return NULL;
}
struct epoll_event ev, ev_read, events[MAX_CONNECTIONS];
memset(&ev, 0x0, sizeof(struct epoll_event));
memset(&ev_read, 0x0, sizeof(struct epoll_event));
memset(events, 0x0, sizeof(struct epoll_event) * MAX_CONNECTIONS);
ev.events = EPOLLONESHOT | EPOLLOUT | EPOLLRDHUP;
ev_read.events = EPOLLIN | EPOLLRDHUP;
//unsigned int sends = 0;
int sdIN[MAX_CONNECTIONS] = { 0 };
int sdOUT[MAX_CONNECTIONS] = { 0 };
int requester[MAX_CONNECTIONS] = { 0 };
for (int i = 0; i < MAX_CONNECTIONS; i++) {
requester[i] = nn_socket(AF_SP, NN_REQ);
if(requester[i] < 0) {
flockfile(stdout);
printf("nn_socket() %s (%d)\n", nn_strerror(nn_errno()), nn_errno());
funlockfile(stdout);
exit(1);
}
int val = 1;
nn_setsockopt(requester[i], NN_TCP, NN_TCP_NODELAY, &val, sizeof(val));
int ret = nn_connect(requester[i], "tcp://10.2.142.102:12345");
//int ret = nn_connect(requester[i], "tcp://127.0.0.1:12345");
if (ret < 0) {
flockfile(stdout);
printf("nn_connect() %s (%d)\n", nn_strerror(nn_errno()), nn_errno());
funlockfile(stdout);
}
size_t sd_size = sizeof(int);
nn_getsockopt(requester[i], NN_SOL_SOCKET, NN_SNDFD, &sdOUT[i], &sd_size);
nn_getsockopt(requester[i], NN_SOL_SOCKET, NN_RCVFD, &sdIN[i], &sd_size);
//printf("fd = %d | %d\n", sdOUT[i], sdIN[i]);
if (requester[i] >= 0) {
g_hash_table_insert(sockets, GINT_TO_POINTER(i), GINT_TO_POINTER(0));
ev.data.fd = sdOUT[i];
if (epoll_ctl(epfd, EPOLL_CTL_ADD, sdOUT[i], &ev)) {
printf("can't epoll_ctl\n");
if (sockets) {
g_hash_table_destroy(sockets);
sockets = NULL;
}
nn_close(requester[i]);
return NULL;
}
ev_read.data.fd = sdIN[i];
if (epoll_ctl(epfd, EPOLL_CTL_ADD, sdIN[i], &ev_read)) {
printf("can't epoll_ctl\n");
if (sockets) {
g_hash_table_destroy(sockets);
sockets = NULL;
}
nn_close(requester[i]);
return NULL;
}
}
}
while (1) {
int rv = epoll_wait(epfd, events, MAX_CONNECTIONS, 5000);
if (rv == 0) {
break;
} else if (rv < 0) {
flockfile(stdout);
printf("#%ld | can't epoll_wait: %s (%d)\n", tid, strerror(errno), errno);
funlockfile(stdout);
break;
}
int rv_ch = 0;
for (int epoll_event = 0; epoll_event < MAX_CONNECTIONS ; epoll_event++) {
if (rv_ch++ == rv) {
break;
}
if (events[epoll_event].events & EPOLLIN) {
int num = -1;
for (int i = 0; i < MAX_CONNECTIONS; i++) {
if (events[epoll_event].data.fd == sdIN[i]) {
num = i;
break;
}
}
if (num == -1) {
//nn_term();
flockfile(stdout);
printf("IN | Can`t find socket\n");
funlockfile(stdout);
exit(1);
}
char buffer[BUFFER_READ];
if (nn_recv(requester[num], buffer, BUFFER_READ, NN_DONTWAIT) < 0) {
if (nn_errno() == EAGAIN || nn_errno() == EFSM) {
continue;
}
flockfile(stdout);
printf("#%ld | can't recv on socket #%d %s (%d)\n", tid, requester[num], nn_strerror(nn_errno()), nn_errno());
funlockfile(stdout);
exit(1);
} else {
int a = GPOINTER_TO_INT(g_hash_table_lookup(sockets, GINT_TO_POINTER(num)));
if (a < MESSAGES) {
ev.data.fd = sdOUT[num];
if (epoll_ctl(epfd, EPOLL_CTL_MOD, sdOUT[num], &ev)) {
printf("can't epoll_ctl\n");
if (sockets) {
g_hash_table_destroy(sockets);
sockets = NULL;
}
nn_close(requester[num]);
return NULL;
}
}
++reads_counter;
//printf("recv %d\n", events[epoll_event].data.fd);
}
}
if (events[epoll_event].events & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) {
++discon_counter;
flockfile(stdout);
printf("#%ld | Debug: Close conn: %d - 0x%04x\n", tid, events[epoll_event].data.fd, events[epoll_event].events);
funlockfile(stdout);
if (epoll_ctl(epfd, EPOLL_CTL_DEL, events[epoll_event].data.fd, NULL)) {
flockfile(stdout);
printf("#%ld | Couldn't epoll_ctl2, fd=%d, error: %s (%d)\n", tid, events[epoll_event].data.fd, strerror(errno), errno);
funlockfile(stdout);
}
//shutdown(events[epoll_event].data.fd, SHUT_RDWR);
continue;
}
if (events[epoll_event].events & EPOLLOUT) {
int num = -1;
for (int i = 0; i < MAX_CONNECTIONS; i++) {
if (events[epoll_event].data.fd == sdOUT[i]) {
num = i;
break;
}
}
if (num == -1) {
//nn_term();
flockfile(stdout);
printf("OUT | Can`t find socket\n");
funlockfile(stdout);
exit(1);
}
msgpack_sbuffer sbuf;
msgpack_sbuffer_init(&sbuf);
msgpack_packer pck;
msgpack_packer_init(&pck, &sbuf, msgpack_sbuffer_write);
msgpack_pack_raw(&pck, 5);
msgpack_pack_raw_body(&pck, "Hello", 10);
int size = sbuf.size;
char *buf = malloc(sbuf.size);
memcpy(buf, sbuf.data, sbuf.size);
msgpack_sbuffer_destroy(&sbuf);
if (nn_send(requester[num], buf, size, NN_DONTWAIT) < 0) {
if (nn_errno() == EAGAIN) {
continue;
}
++discon_counter;
flockfile(stdout);
printf("#%ld | can't send on socket #%d %s (%d)\n", tid, num, nn_strerror(nn_errno()), nn_errno());
funlockfile(stdout);
if (epoll_ctl(epfd, EPOLL_CTL_DEL, events[epoll_event].data.fd, NULL)) {
flockfile(stdout);
printf("#%ld | Couldn't epoll_ctl4, fd=%d, error: %s (%d)\n", tid, events[epoll_event].data.fd, strerror(errno), errno);
funlockfile(stdout);
exit(1);
}
nn_close(requester[num]);
free(buf);
break;
} else {
//printf("send %d\n", events[epoll_event].data.fd);
int a = GPOINTER_TO_INT(g_hash_table_lookup(sockets, GINT_TO_POINTER(num)));
g_hash_table_insert(sockets, GINT_TO_POINTER(num), GINT_TO_POINTER(++a));
update(1);
++sends_counter;
free(buf);
}
}
}
fflush(stdout);
}
for (int i = 0; i < MAX_CONNECTIONS; i++) {
if (GPOINTER_TO_INT(g_hash_table_lookup(sockets, GINT_TO_POINTER(i))) == 0) {
++sockets_wo_send_counter;
}
nn_close(requester[i]);
}
if (sockets) {
g_hash_table_foreach(sockets, find_min_max, NULL);
g_hash_table_destroy(sockets);
}
}
return NULL;
}
void ANetworkController::ReceivedGetBehaviors() {
msgpack_sbuffer sbuf;
msgpack_sbuffer_init(&sbuf);
/* serialize values into the buffer using msgpack_sbuffer_write callback function. */
msgpack_packer pk;
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 2);
msgpack_pack_uint16(&pk, EPacketType::PT_GetBehaviors);
TArray<ABehaviours*> BehaviorsList;
for (TActorIterator<ABehaviours> ObjIt(GetWorld()); ObjIt; ++ObjIt) {
ABehaviours* Behaviors = *ObjIt;
BehaviorsList.Add(Behaviors);
}
int32 BehaviorsListNum = BehaviorsList.Num();
msgpack_pack_array(&pk, BehaviorsListNum);
for (int i = 0; i < BehaviorsListNum; i++) {
ABehaviours* Behaviors = BehaviorsList[i];
msgpack_pack_map(&pk, 4);
msgpack_pack_str(&pk, 13);
msgpack_pack_str_body(&pk, "FlockingState", 13);
msgpack_pack_uint8(&pk, (uint8)Behaviors->FlockingState);
msgpack_pack_str(&pk, 13);
msgpack_pack_str_body(&pk, "ThrottleGains", 13);
Pack(&pk, Behaviors->ThrottleGains);
msgpack_pack_str(&pk, 13);
msgpack_pack_str_body(&pk, "SteeringGains", 13);
Pack(&pk, Behaviors->SteeringGains);
int32 BehaviorsNum = Behaviors->Behaviours.Num();
msgpack_pack_str(&pk, 9);
msgpack_pack_str_body(&pk, "Behaviors", 9);
msgpack_pack_array(&pk, BehaviorsNum);
for (int j = 0; j < BehaviorsNum; j++) {
UBehaviour* Behavior = Behaviors->Behaviours[j];
TArray<UProperty*> Properties;
for (TFieldIterator<UProperty> PropIt(Behavior->GetClass()); PropIt; ++PropIt) {
UProperty* Property = *PropIt;
if (Cast<UNumericProperty>(Property) || Cast<UBoolProperty>(Property)) {
Properties.Add(Property);
}
}
msgpack_pack_map(&pk, Properties.Num() + 1);
msgpack_pack_str(&pk, 4);
msgpack_pack_str_body(&pk, "Name", 4);
FString Name = Behavior->GetClass()->GetName();
msgpack_pack_str(&pk, Name.Len());
msgpack_pack_str_body(&pk, TCHAR_TO_UTF8(*Name), Name.Len());
for (auto PropIt(Properties.CreateIterator()); PropIt; ++PropIt) {
UProperty* Property = *PropIt;
const void* Value = Property->ContainerPtrToValuePtr<uint8>(Behavior);
FString Name = Property->GetName();
msgpack_pack_str(&pk, Name.Len());
msgpack_pack_str_body(&pk, TCHAR_TO_UTF8(*Name), Name.Len());
if (UNumericProperty *NumericProperty = Cast<UNumericProperty>(Property)) {
if (NumericProperty->IsFloatingPoint()) {
msgpack_pack_double(&pk, NumericProperty->GetFloatingPointPropertyValue(Value));
}
else if (NumericProperty->IsInteger()) {
msgpack_pack_int(&pk, NumericProperty->GetSignedIntPropertyValue(Value));
}
}
else if (UBoolProperty *BoolProperty = Cast<UBoolProperty>(Property)) {
if (BoolProperty->GetPropertyValue(Value)) {
msgpack_pack_true(&pk);
}
else {
msgpack_pack_false(&pk);
}
}
}
}
}
int32 BytesSent;
TcpSocket->Send((uint8*)sbuf.data, sbuf.size, BytesSent);
msgpack_sbuffer_destroy(&sbuf);
}
/* It parse a JSON string and convert it to MessagePack format */
char *flb_pack_json(char *js, size_t len, int *size)
{
int i;
int flen;
int arr_size;
char *p;
char *buf;
jsmntok_t *t;
jsmntok_t *tokens;
msgpack_packer pck;
msgpack_sbuffer sbuf;
if (!js) {
return NULL;
}
tokens = json_tokenise(js, len, &arr_size);
if (!tokens) {
return NULL;
}
flb_debug("JSON to pack: '%s'", js);
/* initialize buffers */
msgpack_sbuffer_init(&sbuf);
msgpack_packer_init(&pck, &sbuf, msgpack_sbuffer_write);
for (i = 0; i < arr_size ; i++) {
t = &tokens[i];
if (t->start == -1 || t->end == -1 || (t->start == 0 && t->end == 0)) {
break;
}
flen = (t->end - t->start);
switch (t->type) {
case JSMN_OBJECT:
flb_debug("json_pack: token=%i is OBJECT (size=%i)", i, t->size);
msgpack_pack_map(&pck, t->size);
break;
case JSMN_ARRAY:
flb_debug("json_pack: token=%i is ARRAY (size=%i)", i, t->size);
msgpack_pack_array(&pck, t->size);
break;
case JSMN_STRING:
flb_debug("json_pack: token=%i is STRING (len=%i)\n", i, flen);
msgpack_pack_bin(&pck, flen);
msgpack_pack_bin_body(&pck, js + t->start, flen);
break;
case JSMN_PRIMITIVE:
p = js + t->start;
if (strncmp(p, "false", 5) == 0) {
flb_debug("json_pack: token=%i is FALSE", i);
msgpack_pack_false(&pck);
}
else if (strncmp(p, "true", 4) == 0) {
flb_debug("json_pack: token=%i is TRUE", i);
msgpack_pack_true(&pck);
}
else if (strncmp(p, "null", 4) == 0) {
flb_debug("json_pack: token=%i is NULL", i);
msgpack_pack_nil(&pck);
}
else {
flb_debug("json_pack: token=%i is INT64", i);
msgpack_pack_int64(&pck, atol(p));
}
break;
}
}
/* dump data back to a new buffer */
*size = sbuf.size;
buf = malloc(sbuf.size);
memcpy(buf, sbuf.data, sbuf.size);
msgpack_sbuffer_destroy(&sbuf);
free(tokens);
return buf;
}
void msgpack_sbuffer_destroy_wrap(msgpack_sbuffer* sbuf)
{
msgpack_sbuffer_destroy(sbuf);
}
/* Receive a tokenized JSON message and convert it to MsgPack */
static char *tokens_to_msgpack(char *js,
jsmntok_t *tokens, int arr_size, int *out_size)
{
int i;
int flen;
char *p;
char *buf;
jsmntok_t *t;
msgpack_packer pck;
msgpack_sbuffer sbuf;
/* initialize buffers */
msgpack_sbuffer_init(&sbuf);
msgpack_packer_init(&pck, &sbuf, msgpack_sbuffer_write);
for (i = 0; i < arr_size ; i++) {
t = &tokens[i];
if (t->start == -1 || t->end == -1 || (t->start == 0 && t->end == 0)) {
break;
}
flen = (t->end - t->start);
switch (t->type) {
case JSMN_OBJECT:
msgpack_pack_map(&pck, t->size);
break;
case JSMN_ARRAY:
msgpack_pack_array(&pck, t->size);
break;
case JSMN_STRING:
msgpack_pack_bin(&pck, flen);
msgpack_pack_bin_body(&pck, js + t->start, flen);
break;
case JSMN_PRIMITIVE:
p = js + t->start;
if (*p == 'f') {
msgpack_pack_false(&pck);
}
else if (*p == 't') {
msgpack_pack_true(&pck);
}
else if (*p == 'n') {
msgpack_pack_nil(&pck);
}
else {
if (is_float(p, flen)) {
msgpack_pack_double(&pck, atof(p));
}
else {
msgpack_pack_int64(&pck, atol(p));
}
}
break;
case JSMN_UNDEFINED:
msgpack_sbuffer_destroy(&sbuf);
return NULL;
}
}
/* dump data back to a new buffer */
*out_size = sbuf.size;
buf = malloc(sbuf.size);
memcpy(buf, sbuf.data, sbuf.size);
msgpack_sbuffer_destroy(&sbuf);
return buf;
}
void cb_forward_flush(void *data, size_t bytes,
char *tag, int tag_len,
struct flb_input_instance *i_ins, void *out_context,
struct flb_config *config)
{
int ret = -1;
int entries = 0;
size_t off = 0;
size_t total;
size_t bytes_sent;
msgpack_packer mp_pck;
msgpack_sbuffer mp_sbuf;
msgpack_unpacked result;
struct flb_out_forward_config *ctx = out_context;
struct flb_upstream_conn *u_conn;
(void) i_ins;
(void) config;
flb_debug("[out_forward] request %lu bytes to flush", bytes);
/* Initialize packager */
msgpack_sbuffer_init(&mp_sbuf);
msgpack_packer_init(&mp_pck, &mp_sbuf, msgpack_sbuffer_write);
/* Count number of entries, is there a better way to do this ? */
msgpack_unpacked_init(&result);
while (msgpack_unpack_next(&result, data, bytes, &off)) {
entries++;
}
flb_debug("[out_fw] %i entries tag='%s' tag_len=%i",
entries, tag, tag_len);
msgpack_unpacked_destroy(&result);
/* Output: root array */
msgpack_pack_array(&mp_pck, 2);
msgpack_pack_str(&mp_pck, tag_len);
msgpack_pack_str_body(&mp_pck, tag, tag_len);
msgpack_pack_array(&mp_pck, entries);
/* Get a TCP connection instance */
u_conn = flb_upstream_conn_get(ctx->u);
if (!u_conn) {
flb_error("[out_forward] no upstream connections available");
msgpack_sbuffer_destroy(&mp_sbuf);
FLB_OUTPUT_RETURN(FLB_RETRY);
}
/* Write message header */
ret = flb_io_net_write(u_conn, mp_sbuf.data, mp_sbuf.size, &bytes_sent);
if (ret == -1) {
flb_error("[out_forward] could not write chunk header");
msgpack_sbuffer_destroy(&mp_sbuf);
flb_upstream_conn_release(u_conn);
FLB_OUTPUT_RETURN(FLB_RETRY);
}
msgpack_sbuffer_destroy(&mp_sbuf);
total = ret;
/* Write body */
ret = flb_io_net_write(u_conn, data, bytes, &bytes_sent);
if (ret == -1) {
flb_error("[out_forward] error writing content body");
flb_upstream_conn_release(u_conn);
FLB_OUTPUT_RETURN(FLB_RETRY);
}
total += bytes_sent;
flb_upstream_conn_release(u_conn);
flb_trace("[out_forward] ended write()=%d bytes", total);
FLB_OUTPUT_RETURN(FLB_OK);
}
void *in_kmsg_flush(void *in_context, int *size)
{
int i;
char *buf;
msgpack_packer pck;
msgpack_sbuffer sbuf;
struct kmsg_line *entry;
struct flb_in_kmsg_config *ctx = in_context;
/* initialize buffers */
msgpack_sbuffer_init(&sbuf);
msgpack_packer_init(&pck, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pck, 2);
/* Tag */
msgpack_pack_raw(&pck, ctx->tag_len);
msgpack_pack_raw_body(&pck, ctx->tag, ctx->tag_len);
/* Primary Array: ['TAG', [ */
msgpack_pack_array(&pck, ctx->buffer_id);
/* Pack each data_array entry */
for (i = 0; i < ctx->buffer_id; i++) {
entry = &ctx->buffer[i];
uint64_t t = ctx->boot_time.tv_sec + entry->tv.tv_sec;
msgpack_pack_array(&pck, 2);
msgpack_pack_uint64(&pck, t);
msgpack_pack_map(&pck, 3);
/* Priority */
msgpack_pack_raw(&pck, 8);
msgpack_pack_raw_body(&pck, "priority", 8);
msgpack_pack_char(&pck, entry->priority);
/* Sequence */
msgpack_pack_raw(&pck, 8);
msgpack_pack_raw_body(&pck, "sequence", 8);
msgpack_pack_uint64(&pck, entry->sequence);
/* Time: FIXME */
/* Data message (line) */
msgpack_pack_raw(&pck, 3);
msgpack_pack_raw_body(&pck, "msg", 3);
msgpack_pack_raw(&pck, entry->line_len);
msgpack_pack_raw_body(&pck, entry->line, entry->line_len);
}
*size = sbuf.size;
buf = malloc(sbuf.size);
memcpy(buf, sbuf.data, sbuf.size);
msgpack_sbuffer_destroy(&sbuf);
ctx->buffer_id = 0;
return buf;
}
void ANetworkController::SendData() {
if (!TcpSocket) {
return;
}
// Clear the data if there is anything on the stream
TryReceiveData();
AVehiclestats* Stats = NULL;
for (TActorIterator<AVehiclestats> ObjIt(GetWorld()); ObjIt; ++ObjIt) {
Stats = *ObjIt;
break;
}
if (Stats == NULL) {
return;
}
// Send crashlog
msgpack_sbuffer sbuf;
msgpack_sbuffer_init(&sbuf);
msgpack_packer pk;
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
for (auto Iter = Stats->IncidentLog.CreateConstIterator(); Iter; ++Iter) {
msgpack_pack_array(&pk, 2);
msgpack_pack_uint16(&pk, EPacketType::PT_IncidentLog);
Pack(&pk, *Iter);
}
Stats->IncidentLog.Empty();
// Send the statestics
msgpack_pack_array(&pk, 2);
msgpack_pack_uint16(&pk, EPacketType::PT_GetStats);
msgpack_pack_map(&pk, 6);
msgpack_pack_str(&pk, 7);
msgpack_pack_str_body(&pk, "spawned", 7);
msgpack_pack_uint32(&pk, Stats->GetNumVehiclesSpawned());
msgpack_pack_str(&pk, 6);
msgpack_pack_str_body(&pk, "onroad", 6);
msgpack_pack_uint32(&pk, Stats->GetNumVehiclesOnTheRoad());
msgpack_pack_str(&pk, 7);
msgpack_pack_str_body(&pk, "crashed", 7);
msgpack_pack_uint32(&pk, Stats->GetNumVehiclesCrashed());
msgpack_pack_str(&pk, 9);
msgpack_pack_str_body(&pk, "incidents", 9);
msgpack_pack_uint32(&pk, Stats->GetNumVehiclesIncidents());
TArray<float> Throughputs;
for (TActorIterator<AMeasurementGate> ObjIt(GetWorld()); ObjIt; ++ObjIt) {
AMeasurementGate* Gate = *ObjIt;
Throughputs.Add(Gate->GetThroughput(0));
Throughputs.Add(Gate->GetThroughput(1));
}
msgpack_pack_str(&pk, 11);
msgpack_pack_str_body(&pk, "throughputs", 11);
msgpack_pack_array(&pk, Throughputs.Num());
for (auto Iter = Throughputs.CreateConstIterator(); Iter; ++Iter) {
msgpack_pack_float(&pk, *Iter);
}
msgpack_pack_str(&pk, 4);
msgpack_pack_str_body(&pk, "time", 4);
msgpack_pack_float(&pk, Stats->GetTime());
int32 BytesLeft = sbuf.size;
while (BytesLeft > 0) {
int32 Index = sbuf.size - BytesLeft;
int32 BytesSent;
TcpSocket->Send((uint8*)sbuf.data + Index, BytesLeft, BytesSent);
BytesLeft = BytesLeft - BytesSent;
if (BytesSent == -1) {
break;
}
}
msgpack_sbuffer_destroy(&sbuf);
}
