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; }