void
grn_output_int32(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type, int value)
{
put_delimiter(ctx, outbuf, output_type);
switch (output_type) {
case GRN_CONTENT_JSON:
grn_text_itoa(ctx, outbuf, value);
break;
case GRN_CONTENT_TSV:
grn_text_itoa(ctx, outbuf, value);
break;
case GRN_CONTENT_XML:
GRN_TEXT_PUTS(ctx, outbuf, "<INT>");
grn_text_itoa(ctx, outbuf, value);
GRN_TEXT_PUTS(ctx, outbuf, "</INT>");
break;
case GRN_CONTENT_MSGPACK :
#ifdef HAVE_MESSAGE_PACK
msgpack_pack_int32(&ctx->impl->msgpacker, value);
#endif
break;
case GRN_CONTENT_NONE:
break;
}
INCR_LENGTH;
}
void api_request_status(rpc_io *rpcio, msgpack_object *request_obj,
msgpack_packer *response_msg) {
int rc;
char *program_name = NULL;
size_t program_len = 0;
rc = obj_get(request_obj, "program", MSGPACK_OBJECT_RAW, &program_name, &program_len);
/* A missing 'program' field is OK. It means we want all programs */
msgpack_pack_map(response_msg, 1);
msgpack_pack_string(response_msg, "programs", -1);
/* programs is a map of:
* programname => {
* command: "string",
* args: "string",
* uid: uid,
* gid: gid,
* nice: nice,
* ionice: ionice,
* is_running: boolean
* instances: {
* pid: ...
* state: ...
* admin_state: ...
* start: ...
* duration: ...
* }
* }
*/
msgpack_pack_map(response_msg, rpcio->procnanny->programs_len);
pn_prog_each(rpcio->procnanny, i, program, {
if (program_name != NULL && strncmp(program->name, program_name, program_len)) {
continue;
}
msgpack_pack_string(response_msg, program->name, program->name_len);
msgpack_pack_map(response_msg, 8); /* 8 fields */
msgpack_pack_string(response_msg, "command", -1);
msgpack_pack_string(response_msg, program->command, program->command_len);
msgpack_pack_string(response_msg, "args", -1);
msgpack_pack_array(response_msg, program->args_len);
int argind = 0;
for (argind = 0; argind < program->args_len; argind++) {
msgpack_pack_string(response_msg, program->args[argind], -1);
}
msgpack_pack_string(response_msg, "uid", -1);
msgpack_pack_uint32(response_msg, program->uid);
msgpack_pack_string(response_msg, "gid", -1);
msgpack_pack_uint32(response_msg, program->gid);
msgpack_pack_string(response_msg, "nice", -1);
msgpack_pack_int32(response_msg, program->nice);
msgpack_pack_string(response_msg, "ionice", -1);
msgpack_pack_int32(response_msg, program->ionice);
msgpack_pack_string(response_msg, "active", -1);
msgpack_pack_true(response_msg);
msgpack_pack_string(response_msg, "instances", -1);
msgpack_pack_map(response_msg, program->nprocs);
pn_prog_proc_each(program, instance, process, {
msgpack_pack_uint32(response_msg, instance);
msgpack_pack_map(response_msg, 5);
msgpack_pack_string(response_msg, "pid", -1);
msgpack_pack_uint32(response_msg, process->pid);
msgpack_pack_string(response_msg, "state", -1);
switch (process->state) {
case PROCESS_STATE_STARTING:
msgpack_pack_string(response_msg, "starting", -1); break;
case PROCESS_STATE_RUNNING:
msgpack_pack_string(response_msg, "running", -1); break;
case PROCESS_STATE_STOPPING:
msgpack_pack_string(response_msg, "stopping", -1); break;
case PROCESS_STATE_EXITED:
msgpack_pack_string(response_msg, "exited", -1); break;
case PROCESS_STATE_BACKOFF:
msgpack_pack_string(response_msg, "backoff", -1); break;
case PROCESS_STATE_NEW:
msgpack_pack_string(response_msg, "new", -1); break;
default:
msgpack_pack_string(response_msg, "unknown", -1); break;
}
msgpack_pack_string(response_msg, "exitcode", -1);
msgpack_pack_uint8(response_msg, process->exit_status);
msgpack_pack_string(response_msg, "exitsignal", -1);
msgpack_pack_uint8(response_msg, process->exit_signal);
msgpack_pack_string(response_msg, "admin_state", -1);
switch (process->admin_state) {
case ADMIN_STATE_DOWN:
msgpack_pack_string(response_msg, "down", -1); break;
case ADMIN_STATE_UP:
msgpack_pack_string(response_msg, "up", -1); break;
default:
msgpack_pack_string(response_msg, "unknown", -1); break;
}
})
});
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);
}
int msgpack_pack_int32_wrap(msgpack_packer* pk, int32_t d)
{
return msgpack_pack_int32(pk, d);
}
/*
* 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;
}
