static void pack_obj_destroyed_event(rbkit_obj_destroyed_event *event, msgpack_packer *packer) {
msgpack_pack_map(packer, 3);
pack_event_header(packer, event->event_header.event_type);
msgpack_pack_int(packer, rbkit_message_field_payload);
msgpack_pack_map(packer, 1);
msgpack_pack_int(packer, rbkit_message_field_object_id);
msgpack_pack_unsigned_long_long(packer, event->object_id);
}
static void pack_hash_event(rbkit_hash_event *event, msgpack_packer *packer) {
VALUE hash;
int size;
msgpack_pack_map(packer, 3);
pack_event_header(packer, event->event_header.event_type);
hash = event->hash;
size = (int)RHASH_SIZE(hash);
msgpack_pack_int(packer, rbkit_message_field_payload);
msgpack_pack_map(packer, size);
rb_hash_foreach(hash, hash_pack_iterator, (VALUE)packer);
}
static void pack_obj_created_event(rbkit_obj_created_event *event, msgpack_packer *packer) {
msgpack_pack_map(packer, 3);
pack_event_header(packer, event->event_header.event_type);
msgpack_pack_int(packer, rbkit_message_field_payload);
msgpack_pack_map(packer, 2);
msgpack_pack_int(packer, rbkit_message_field_object_id);
msgpack_pack_unsigned_long_long(packer, event->object_id);
msgpack_pack_int(packer, rbkit_message_field_class_name);
pack_string(packer, event->klass);
//TODO: pack allocation info as well
}
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;
}
std::string encodeRequest(const Request &r) {
std::shared_ptr<msgpack_sbuffer> buffer{msgpack_sbuffer_new(), &msgpack_sbuffer_free};
std::shared_ptr<msgpack_packer> pk{msgpack_packer_new(buffer.get(), msgpack_sbuffer_write), &msgpack_packer_free};
msgpack_pack_map(pk.get(), 5);
msgpack_pack_raw(pk.get(), 4);
msgpack_pack_raw_body(pk.get(), "func", 4);
msgpack_pack_raw(pk.get(), r.func.size());
msgpack_pack_raw_body(pk.get(), r.func.data(), r.func.size());
msgpack_pack_raw(pk.get(), 6);
msgpack_pack_raw_body(pk.get(), "metric", 6);
msgpack_pack_raw(pk.get(), r.metric.size());
msgpack_pack_raw_body(pk.get(), r.metric.data(), r.metric.size());
msgpack_pack_raw(pk.get(), 9);
msgpack_pack_raw_body(pk.get(), "timestamp", 9);
msgpack_pack_uint64(pk.get(), r.timestamp);
msgpack_pack_raw(pk.get(), 5);
msgpack_pack_raw_body(pk.get(), "value", 5);
switch(r.value.type()) {
case Value::Type::Nil:
msgpack_pack_nil(pk.get());
break;
case Value::Type::Boolean:
if(r.value.as<bool>())
msgpack_pack_true(pk.get());
else
msgpack_pack_false(pk.get());
break;
case Value::Type::Numeric:
msgpack_pack_double(pk.get(), r.value.as<double>());
break;
case Value::Type::String:
{
std::string b = r.value.as<std::string>();
msgpack_pack_raw(pk.get(), b.size());
msgpack_pack_raw_body(pk.get(), b.data(), b.size());
}
break;
case Value::Type::Table:
{
// Hack
std::string b = r.value.as<std::string>();
if(b.empty())
msgpack_pack_nil(pk.get());
else
msgpack_sbuffer_write(reinterpret_cast<void *>(buffer.get()), b.data(), b.size());
}
break;
}
msgpack_pack_raw(pk.get(), 5);
msgpack_pack_raw_body(pk.get(), "state", 5);
if(r.state.empty())
msgpack_pack_nil(pk.get());
else
msgpack_sbuffer_write(reinterpret_cast<void *>(buffer.get()), r.state.data(), r.state.size());
return std::string(buffer->data, buffer->size);
}
static inline int process_pack(struct tcp_conn *conn,
char *pack, size_t size)
{
size_t off = 0;
msgpack_unpacked result;
msgpack_object entry;
struct flb_in_tcp_config *ctx;
ctx = conn->ctx;
/* First pack the results, iterate concatenated messages */
msgpack_unpacked_init(&result);
while (msgpack_unpack_next(&result, pack, size, &off)) {
entry = result.data;
msgpack_pack_array(&ctx->mp_pck, 2);
msgpack_pack_uint64(&ctx->mp_pck, time(NULL));
msgpack_pack_map(&ctx->mp_pck, 1);
msgpack_pack_bin(&ctx->mp_pck, 3);
msgpack_pack_bin_body(&ctx->mp_pck, "msg", 3);
msgpack_pack_object(&ctx->mp_pck, entry);
ctx->buffer_id++;
}
msgpack_unpacked_destroy(&result);
return 0;
}
void
grn_output_map_open(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
const char *name, int nelements)
{
put_delimiter(ctx, outbuf, output_type);
switch (output_type) {
case GRN_CONTENT_JSON:
GRN_TEXT_PUTS(ctx, outbuf, "{");
break;
case GRN_CONTENT_XML:
GRN_TEXT_PUTC(ctx, outbuf, '<');
GRN_TEXT_PUTS(ctx, outbuf, name);
GRN_TEXT_PUTC(ctx, outbuf, '>');
grn_vector_add_element(ctx, &ctx->impl->names, name, strlen(name), 0, GRN_DB_SHORT_TEXT);
break;
case GRN_CONTENT_TSV:
if (DEPTH > 2) { GRN_TEXT_PUTS(ctx, outbuf, "{\t"); }
break;
case GRN_CONTENT_MSGPACK :
#ifdef HAVE_MESSAGE_PACK
if (nelements < 0) {
GRN_LOG(ctx, GRN_LOG_DEBUG,
"grn_output_map_open nelements (%d) for <%s>",
nelements,
name);
}
msgpack_pack_map(&ctx->impl->msgpacker, nelements / 2);
#endif
break;
case GRN_CONTENT_NONE:
break;
}
INCR_DEPTH(1);
}
static void
msg_hgetall_reply(msgpack_packer* pk, const redisReply *r) {
/* zip keys and values together in a msgpack object */
unsigned int i;
if(r->elements % 2 != 0) {
return;
}
msgpack_pack_map(pk, r->elements / 2);
for(i = 0; i < r->elements; i += 2) {
redisReply *k = r->element[i], *v = r->element[i+1];
/* keys and values need to be strings */
if(k->type != REDIS_REPLY_STRING || v->type != REDIS_REPLY_STRING) {
return;
}
/* key */
msgpack_pack_raw(pk, k->len);
msgpack_pack_raw_body(pk, k->str, k->len);
/* value */
msgpack_pack_raw(pk, v->len);
msgpack_pack_raw_body(pk, v->str, v->len);
}
}
int in_mem_collect(struct flb_config *config, void *in_context)
{
struct sysinfo info;
(void) config;
struct flb_in_mem_config *ctx = in_context;
uint32_t totalram, freeram;
sysinfo(&info);
totalram = info.totalram / 1024;
freeram = info.freeram / 1024;
msgpack_pack_map(&ctx->pckr, 3);
msgpack_pack_raw(&ctx->pckr, 4);
msgpack_pack_raw_body(&ctx->pckr, "time", 4);
msgpack_pack_uint64(&ctx->pckr, time(NULL));
msgpack_pack_raw(&ctx->pckr, 5);
msgpack_pack_raw_body(&ctx->pckr, "total", 5);
msgpack_pack_uint32(&ctx->pckr, totalram);
msgpack_pack_raw(&ctx->pckr, 4);
msgpack_pack_raw_body(&ctx->pckr, "free", 4);
msgpack_pack_uint32(&ctx->pckr, freeram);
flb_debug("[in_mem] memory total %d kb, free %d kb (buffer=%i)",
info.totalram,
info.freeram,
ctx->idx);
++ctx->idx;
return 0;
}
/*
* Document-method: Hash#to_msgpack
*
* call-seq:
* hash.to_msgpack(out = '') -> String
*
* Serializes the Hash into raw bytes.
* This calls to_msgpack method reflectively for internal keys and values.
*/
static VALUE MessagePack_Hash_to_msgpack(int argc, VALUE *argv, VALUE self)
{
ARG_BUFFER(out, argc, argv);
msgpack_pack_map(out, RHASH_SIZE(self));
rb_hash_foreach(self, MessagePack_Hash_to_msgpack_foreach, out);
return out;
}
static inline int process_line(char *line, struct flb_in_serial_config *ctx)
{
int line_len;
char *p = line;
char *end = NULL;
char msg[1024];
/* Increase buffer position */
ctx->buffer_id++;
line_len = strlen(p);
strncpy(msg, p, line_len);
msg[line_len] = '\0';
/*
* Store the new data into the MessagePack buffer,
* we handle this as a list of maps.
*/
msgpack_pack_array(&ctx->mp_pck, 2);
msgpack_pack_uint64(&ctx->mp_pck, time(NULL));
msgpack_pack_map(&ctx->mp_pck, 1);
msgpack_pack_bin(&ctx->mp_pck, 3);
msgpack_pack_bin_body(&ctx->mp_pck, "msg", 3);
msgpack_pack_bin(&ctx->mp_pck, line_len);
msgpack_pack_bin_body(&ctx->mp_pck, p, line_len);
flb_debug("[in_serial] '%s'",
(const char *) msg);
return 0;
}
/*
* Document-method: Hash#to_msgpack
*
* call-seq:
* hash.to_msgpack(out = '') -> String
*
* Serializes the Hash into raw bytes.
* This calls to_msgpack method reflectively for internal keys and values.
*/
static VALUE MessagePack_Hash_to_msgpack(int argc, VALUE *argv, VALUE self)
{
ARG_BUFFER(out, argc, argv);
// FIXME check sizeof(st_index_t) > sizeof(unsigned int) && RARRAY_LEN(self) > UINT_MAX
msgpack_pack_map(out, (unsigned int)RHASH_SIZE(self));
rb_hash_foreach(self, MessagePack_Hash_to_msgpack_foreach, out);
return out;
}
void api_respond_error(msgpack_object *request_obj,
msgpack_packer *response_msg, const char *error) {
msgpack_pack_map(response_msg, 2);
msgpack_pack_string(response_msg, "error", -1);
msgpack_pack_string(response_msg, error, -1);
msgpack_pack_string(response_msg, "request", -1);
msgpack_pack_object(response_msg, *request_obj);
}
void api_request_dance(rpc_io *rpcio, msgpack_object *request,
msgpack_packer *response_msg) {
printf("Dance dance dance. La la la.\n");
msgpack_pack_map(response_msg, 1);
msgpack_pack_string(response_msg, "danced", 6);
msgpack_pack_true(response_msg);
}
int LogInLog_to_msgpack(msgpack_packer *pk, LogInLog *arg) {
msgpack_pack_array(pk, 13);
UserInfo_to_msgpack(pk, &arg->user);
msgpack_pack_int(pk, arg->site);
msgpack_pack_int(pk, arg->num);
msgpack_pack_array(pk, arg->sites_size);
for (int _i = 0; _i < arg->sites_size; ++_i) {
msgpack_pack_int(pk, arg->sites[_i]);
}
msgpack_pack_map(pk, arg->sites2_size);
for (int _i = 0; _i < arg->sites2_size; ++_i) {
if (arg->sites2_keys[_i]) {
size_t _l = strlen(arg->sites2_keys[_i]);
msgpack_pack_raw(pk, _l);
msgpack_pack_raw_body(pk, arg->sites2_keys[_i], _l);
} else {
msgpack_pack_nil(pk);
}
msgpack_pack_int(pk, arg->sites2_vals[_i]);
}
if (arg->s1) {
size_t _l = strlen(arg->s1);
msgpack_pack_raw(pk, _l);
msgpack_pack_raw_body(pk, arg->s1, _l);
} else {
msgpack_pack_nil(pk);
}
arg->b1 ? msgpack_pack_true(pk) : msgpack_pack_false(pk);
msgpack_pack_raw(pk, arg->r1_size);
msgpack_pack_raw_body(pk, arg->r1, arg->r1_size);
msgpack_pack_double(pk, arg->d1);
msgpack_pack_int(pk, arg->i2);
my_type_x_to_msgpack(pk, &arg->my1);
msgpack_pack_array(pk, arg->user_list_size);
for (int _i = 0; _i < arg->user_list_size; ++_i) {
UserInfo_to_msgpack(pk, &arg->user_list[_i]);
}
msgpack_pack_map(pk, arg->user_map_size);
for (int _i = 0; _i < arg->user_map_size; ++_i) {
UserInfo_to_msgpack(pk, &arg->user_map_keys[_i]);
UserInfo_to_msgpack(pk, &arg->user_map_vals[_i]);
}
return 0;
}
void msgpack_rpc_from_dictionary(Dictionary result, msgpack_packer *res)
{
msgpack_pack_map(res, result.size);
for (size_t i = 0; i < result.size; i++) {
msgpack_rpc_from_string(result.items[i].key, res);
msgpack_rpc_from_object(result.items[i].value, res);
}
}
/**
* Parse info message and return object.
*/
void
msg_info_reply(msgpack_packer* pk, const char *s, size_t sz) {
const char *p = s;
unsigned int count = 0;
/* TODO: handle new format */
/* count number of lines */
while(p < s + sz) {
p = strchr(p, '\r');
if(!p) break;
p++;
count++;
}
/* create msgpack object */
msgpack_pack_map(pk, count);
p = s;
while(p < s + sz) {
char *key, *val, *nl, *colon;
size_t key_sz, val_sz;
/* find key */
colon = strchr(p, ':');
if(!colon) {
break;
}
key_sz = colon - p;
key = calloc(key_sz + 1, 1);
memcpy(key, p, key_sz);
p = colon + 1;
/* find value */
nl = strchr(p, '\r');
if(!nl) {
free(key);
break;
}
val_sz = nl - p;
val = calloc(val_sz + 1, 1);
memcpy(val, p, val_sz);
p = nl + 1;
if(*p == '\n') p++;
/* add to object */
msgpack_pack_raw(pk, key_sz);
msgpack_pack_raw_body(pk, key, key_sz);
msgpack_pack_raw(pk, val_sz);
msgpack_pack_raw_body(pk, val, val_sz);
free(key);
free(val);
}
}
static void pack_cpu_sample_event(rbkit_cpu_sample_event *event, msgpack_packer *packer) {
rbkit_cpu_sample *sample;
size_t count;
msgpack_pack_map(packer, 3);
sample = event->sample;
// Keys 1 & 2 - event type and timestamp
pack_event_header(packer, event->event_header.event_type);
// Key 3 : Payload
msgpack_pack_int(packer, rbkit_message_field_payload);
// Value 3: Array of samples
msgpack_pack_array(packer, sample->frame_count);
for(count = 0; count != sample->frame_count; count++){
msgpack_pack_map(packer, 6);
// method_name
msgpack_pack_int(packer, rbkit_message_field_method_name);
pack_string(packer, sample->frames[count].method_name);
// label
msgpack_pack_int(packer, rbkit_message_field_label);
pack_string(packer, sample->frames[count].label);
// file
msgpack_pack_int(packer, rbkit_message_field_file);
pack_string(packer, sample->frames[count].file);
// line
msgpack_pack_int(packer, rbkit_message_field_line);
msgpack_pack_unsigned_long(packer, sample->frames[count].line);
// singleton_method
msgpack_pack_int(packer, rbkit_message_field_singleton_method);
msgpack_pack_int(packer, sample->frames[count].is_singleton_method);
// thread_od
msgpack_pack_int(packer, rbkit_message_field_thread_id);
msgpack_pack_unsigned_long(packer, sample->frames[count].thread_id);
}
}
static void pack_event_collection_event(rbkit_event_collection_event *event, msgpack_packer *packer) {
msgpack_sbuffer *sbuf = packer->data;
msgpack_pack_map(packer, 4);
pack_event_header(packer, event->event_header.event_type);
msgpack_pack_int(packer, rbkit_message_field_message_counter);
msgpack_pack_unsigned_long(packer, get_message_counter());
msgpack_pack_int(packer, rbkit_message_field_payload);
msgpack_pack_array(packer, event->message_count);
sbuf->data = realloc(sbuf->data, event->buffer_size + sbuf->size);
memcpy(sbuf->data + sbuf->size, event->buffer, event->buffer_size);
sbuf->size += event->buffer_size;
}
/* Callback to gather CPU usage between now and previous snapshot */
int in_cpu_collect(struct flb_config *config, void *in_context)
{
int i;
int maps;
int len;
double usage;
double total;
(void) config;
struct flb_in_cpu_config *ctx = in_context;
struct cpu_stats *cstats = &ctx->cstats;
struct cpu_snapshot *s;
/* Get the current CPU usage */
total = proc_cpu_load(ctx->n_processors, cstats);
cstats->load_now = total;
/* Calculate the difference between the two samples */
usage = fabs(cstats->load_now - cstats->load_pre) / ctx->cpu_ticks;
total = (usage * 100) / ctx->n_processors;
/* Put current load back */
cstats->load_pre = cstats->load_now;
/*
* Store the new data into the MessagePack buffer,
*/
msgpack_pack_array(&ctx->mp_pck, 2);
msgpack_pack_uint64(&ctx->mp_pck, time(NULL));
msgpack_pack_map(&ctx->mp_pck, (ctx->n_processors * 7 ) + 1);
msgpack_pack_bin(&ctx->mp_pck, 3);
msgpack_pack_bin_body(&ctx->mp_pck, "cpu", 3);
msgpack_pack_double(&ctx->mp_pck, total);
for (i = 1; i < ctx->n_processors + 1; i++) {
s = &cstats->info[i];
CPU_PACK_SNAP(s, user);
CPU_PACK_SNAP(s, nice);
CPU_PACK_SNAP(s, system);
CPU_PACK_SNAP(s, idle);
CPU_PACK_SNAP(s, iowait);
CPU_PACK_SNAP(s, irq);
CPU_PACK_SNAP(s, softirq);
}
flb_debug("[in_cpu] CPU %0.2f%%", total);
flb_stats_update(in_cpu_plugin.stats_fd, 0, 1);
return 0;
}
static void kdon_object_to_msgpack(kdon_t *kdon, msgpack_packer *packer)
{
size_t size = kdon_object_size(kdon);
void *iter;
const char *key;
kdon_t *value;
msgpack_pack_map(packer, size);
kdon_object_foreach(kdon, iter, key, value)
{
msgpack_pack_raw(packer, strlen(key));
msgpack_pack_raw_body(packer, key, strlen(key));
kdon_to_msgpack(value, packer);
}
static inline int process_line(char *line, struct flb_in_serial_config *ctx)
{
int line_len;
uint64_t val;
char *p = line;
char *end = NULL;
char msg[1024];
/* Increase buffer position */
ctx->buffer_id++;
errno = 0;
val = strtol(p, &end, 10);
if ((errno == ERANGE && (val == INT_MAX || val == INT_MIN))
|| (errno != 0 && val == 0)) {
goto fail;
}
/* Now process the human readable message */
line_len = strlen(p);
strncpy(msg, p, line_len);
msg[line_len] = '\0';
/*
* Store the new data into the MessagePack buffer,
* we handle this as a list of maps.
*/
msgpack_pack_array(&ctx->mp_pck, 2);
msgpack_pack_uint64(&ctx->mp_pck, time(NULL));
msgpack_pack_map(&ctx->mp_pck, 1);
msgpack_pack_bin(&ctx->mp_pck, 3);
msgpack_pack_bin_body(&ctx->mp_pck, "msg", 3);
msgpack_pack_bin(&ctx->mp_pck, line_len);
msgpack_pack_bin_body(&ctx->mp_pck, p, line_len);
flb_debug("[in_serial] '%s'",
(const char *) msg);
return 0;
fail:
ctx->buffer_id--;
return -1;
}
void publish_output(process_t *process, struct proc_data *procdata,
const char *ioname, const char *data, ssize_t length) {
/* TODO(sissel): move this to a separate file for 'event' streaming */
zmq_msg_t event;
int rc;
size_t msgsize;
program_t *program = pn_proc_program(process);
procnanny_t *pn = program->data;
fprintf(stdout, "%s[%d]: (%d bytes) %.*s\n", pn_proc_program(process)->name,
pn_proc_instance(process), length, length, data);
/* Fields:
* - data (the string read)
* - program name
* - process instance
* - stdout or stderr
*/
msgpack_sbuffer *buffer = msgpack_sbuffer_new();
msgpack_packer *output_msg = msgpack_packer_new(buffer, msgpack_sbuffer_write);
msgpack_pack_map(output_msg, 5);
/* "event" => "data" */
msgpack_pack_string(output_msg, "event", -1);
msgpack_pack_string(output_msg, "data", -1);
msgpack_pack_string(output_msg, "program", -1);
msgpack_pack_string(output_msg, program->name, program->name_len);
msgpack_pack_string(output_msg, "instance", -1);
msgpack_pack_int(output_msg, process->instance);
msgpack_pack_string(output_msg, "source", -1);
msgpack_pack_string(output_msg, ioname, -1);
msgpack_pack_string(output_msg, "data", -1);
msgpack_pack_string(output_msg, data, length);
zmq_msg_init_data(&event, buffer->data, buffer->size, free_msgpack_buffer, buffer);
zmq_send(pn->eventsocket, &event, 0);
zmq_msg_close(&event);
msgpack_packer_free(output_msg);
} /* publish_output */
static void
sem_object_end(void *state)
{
PackState _state = (PackState) state;
msgpack_sbuffer *buf;
JsonContainer current_container, parent_container;
msgpack_packer *pk;
JsonObjectField field;
size_t packed_size;
char *packed_data;
JsonValue value;
current_container = _state->current_container;
pk = _state->pk;
/* start to pack map */
msgpack_pack_map(pk, current_container->via.object.length);
/* pack each field */
field = current_container->via.object.start;
while (field != NULL) {
/* pack key */
pack_string(pk, field->key);
/* pack value */
pack_value(pk, field->value);
/* next field*/
field = field->next;
}
/* retrieve packed binary and reset buffer of packer */
buf = _state->buf;
packed_size = buf->size;
packed_data = msgpack_sbuffer_release(buf);
/* set packed binary to the last value of parent conationer */
parent_container = current_container->parent;
value = value_to_be_set(parent_container);
value->type = MSGPACK_BINARY;
value->via.msg.size = packed_size;
value->via.msg.data = packed_data;
/* step back to parent level */
_state->current_container = parent_container;
destroy_container(current_container);
}
void send_trigger(mdcli_t * client, char * target_worker, char * rule_id, int ival, char * user_id) {
zclock_log("activating trigger\ntarget=%s\nvalue=%d\nuser=%s",
target_worker, ival, user_id);
struct timeval tval;
gettimeofday(&tval, NULL);
// make a messagepack hash
msgpack_sbuffer * buffer = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
// value chunk
msgpack_pack_map(pk, 3);
// key
msgpack_pack_raw(pk, 5);
msgpack_pack_raw_body(pk, "value", 5);
// value
msgpack_pack_int(pk, ival);
//time chunk
// key
msgpack_pack_raw(pk, 5);
msgpack_pack_raw_body(pk, "epoch", 5);
// time
msgpack_pack_int(pk, tval.tv_sec);
msgpack_pack_raw(pk, 6);
msgpack_pack_raw_body(pk, "micros", 6);
// time
msgpack_pack_int(pk, tval.tv_usec);
zmsg_t * msg = zmsg_new();
// really, the user_id should be being added by a
// gatekeeper, not the block itself, or it's a security
// hole. will do for now FIX
zmsg_pushstr(msg, user_id);
// zmsg_pushmem(msg, &trigger.line_id, sizeof(int));
zmsg_pushmem(msg, buffer->data, buffer->size);
zmsg_pushstr(msg, rule_id);
zmsg_pushstr(msg, "DoAction");
mdcli_send(client, target_worker, &msg);
}
yar_packager * yar_pack_start(yar_data_type type, uint size) /* {{{ */ {
yar_packager *packager = malloc(sizeof(yar_packager));
packager->bf = msgpack_sbuffer_new();
packager->pk = msgpack_packer_new(packager->bf, msgpack_sbuffer_write);
switch (type) {
case YAR_DATA_ARRAY:
msgpack_pack_array(packager->pk, size);
break;
case YAR_DATA_MAP:
msgpack_pack_map(packager->pk, size);
break;
default:
break;
}
return packager;
}
void
dump_oid_info(msgpack_packer *pk, struct oid_info *oi)
{
#define DUMPi(field) msgpack_pack_named_int(pk, #field, oi->field)
msgpack_pack_map(pk, 6);
DUMPi(sid);
DUMPi(cid);
DUMPi(fd);
DUMPi(max_repetitions);
msgpack_pack_string(pk, "oid");
msgpack_pack_oid(pk, oi->oid);
msgpack_pack_string(pk, "value");
if (!oi->value.buf)
msgpack_pack_nil(pk);
else
msgpack_pack_ber(pk, oi->value);
#undef DUMPi
}
void in_xbee_rx_queue_raw(struct flb_in_xbee_config *ctx, const char *buf ,int len)
{
/* Increase buffer position */
pthread_mutex_lock(&ctx->mtx_mp);
in_xbee_flush_if_needed(ctx);
ctx->buffer_id++;
msgpack_pack_array(&ctx->mp_pck, 2);
msgpack_pack_uint64(&ctx->mp_pck, time(NULL));
msgpack_pack_map(&ctx->mp_pck, 1);
msgpack_pack_bin(&ctx->mp_pck, 4);
msgpack_pack_bin_body(&ctx->mp_pck, "data", 4);
msgpack_pack_bin(&ctx->mp_pck, len);
msgpack_pack_bin_body(&ctx->mp_pck, buf, len);
pthread_mutex_unlock(&ctx->mtx_mp);
}
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;
}
rpc_call_t *rpc_call_new(void *zmq, struct ev_loop *ev, const char *address,
const char *method) {
rpc_call_t *rpc = calloc(1, sizeof(rpc_call_t));
rpc->zmq = zmq;
rpc->ev = ev;
rpc->address = address;
rpc->pack_buffer = msgpack_sbuffer_new();
rpc->request = msgpack_packer_new(rpc->pack_buffer, msgpack_sbuffer_write);
msgpack_pack_map(rpc->request, 2); /* method and args */
msgpack_pack_string(rpc->request, "method", 6);
msgpack_pack_string(rpc->request, method, strlen(method));
msgpack_pack_string(rpc->request, "args", 4);
/* The rest of the packing is up to the invoker of the rpc call.
* Add whatever arguments are necessary later to rpc->request */
printf("Created new rpc call object targeting %s method %s\n",
address, method);
return rpc;
} /* rpc_call_new */
