// FIX message for tests
static
void validate_message(const struct fix_message* pm)
{
const fix_parser* const parser = (const fix_parser*) ((const char*)pm - offsetof(fix_parser, message));
ensure_buffer(parser->buffer);
validate_simple_message(pm);
}
static GeglRectangle
get_bounding_box (GeglOperation *operation)
{
GeglRectangle result = {0,0,0,0};
GeglBuffer *buffer = ensure_buffer (operation);
result = *gegl_buffer_get_extent (GEGL_BUFFER (buffer));
return result;
}
static void
fill_buffer(void* vctx, const char* str, unsigned int len)
{
encode_ctx* ctx = (encode_ctx*)vctx;
if (ctx->error || (ctx->error = ensure_buffer(vctx, len))) {
return;
}
memcpy(ctx->bin.data + ctx->fill_offset, str, len);
ctx->fill_offset += len;
}
static void
mysqlchild_readable(int fd, void *data)
{
struct sql_request req;
mysql_task **tptr = data;
mysql_task *t = *tptr;
/* mysql_pipe *p = t->pipe; */
static char *buffer = 0;
static int buflen = 0;
static char *serial;
Var r;
if (from_mysql_fd != fd)
panic("MYSQLCHILD_READABLE: fd doesn't match from_mysql_fd!");
if (robust_read(fd, &req, sizeof(req)) != sizeof(req)) {
errlog("MYSQLCHILD_READABLE: req read failed\n");
req.kind = SQLREQ_ERROR;
} else {
if (req.length != 0) {
ensure_buffer(&buffer, &buflen, req.length + 1);
if (robust_read(fd, buffer, req.length) != sizeof(req.length)) {
errlog("MYSQLCHILD_READABLE: str read failed\n");
req.kind = SQLREQ_ERROR;
req.length = 0;
}
buffer[req.length] = '\0';
} else {
req.kind = SQLREQ_ERROR;
}
}
switch (req.kind) {
case SQLREQ_ERROR:
r.type = TYPE_ERR;
r.v.err = E_INVARG;
break;
case SQLREQ_CLOSE_HANDLE:
case SQLREQ_NEW_HANDLE:
case SQLREQ_DO_QUERY:
case SQLREQ_GET_ROW:
r = deserialize(buffer);
}
enqueue_from_enumerator(t->the_vm, r);
myfree(t, M_TASK);
}
static gboolean
process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_pad,
const GeglRectangle *result,
gint level)
{
GeglBuffer *buffer = ensure_buffer (operation);
if (buffer)
{
g_object_ref (buffer); /* Add an extra reference, since
* gegl_operation_set_data is
* stealing one.
*/
/* override core behaviour, by resetting the buffer in the operation_context */
gegl_operation_context_take_object (context, "output", G_OBJECT (buffer));
return TRUE;
}
return FALSE;
}
void connection_dispatch(pn_handler_t *h, pn_event_t *event, pn_event_type_t type)
{
connection_context_t *cc = connection_context(h);
bool replying = cc->global->opts->reply;
switch (type) {
case PN_LINK_REMOTE_OPEN:
{
pn_link_t *link = pn_event_link(event);
if (pn_link_is_receiver(link)) {
check(cc->recv_link == NULL, "Multiple incomming links on one connection");
cc->recv_link = link;
pn_connection_t *conn = pn_event_connection(event);
pn_list_add(cc->global->active_connections, conn);
if (cc->global->shutting_down) {
pn_connection_close(conn);
break;
}
if (replying) {
// Set up a reply link and defer granting credit to the incoming link
pn_connection_t *conn = pn_session_connection(pn_link_session(link));
pn_session_t *ssn = pn_session(conn);
pn_session_open(ssn);
char name[100]; // prefer a multiplatform uuid generator
sprintf(name, "reply_sender_%d", cc->connection_id);
cc->reply_link = pn_sender(ssn, name);
pn_link_open(cc->reply_link);
}
else {
pn_flowcontroller_t *fc = pn_flowcontroller(1024);
pn_handler_add(h, fc);
pn_decref(fc);
}
}
}
break;
case PN_LINK_FLOW:
{
if (replying) {
pn_link_t *reply_link = pn_event_link(event);
// pn_flowcontroller handles the non-reply case
check(reply_link == cc->reply_link, "internal error");
// Grant the sender as much credit as just given to us for replies
int delta = pn_link_credit(reply_link) - pn_link_credit(cc->recv_link);
if (delta > 0)
pn_link_flow(cc->recv_link, delta);
}
}
break;
case PN_DELIVERY:
{
pn_link_t *recv_link = pn_event_link(event);
pn_delivery_t *dlv = pn_event_delivery(event);
if (pn_link_is_receiver(recv_link) && !pn_delivery_partial(dlv)) {
if (cc->global->received == 0) statistics_start(cc->global->stats);
size_t encoded_size = pn_delivery_pending(dlv);
cc->global->encoded_data = ensure_buffer(cc->global->encoded_data, encoded_size,
&cc->global->encoded_data_size);
check(cc->global->encoded_data, "decoding buffer realloc failure");
ssize_t n = pn_link_recv(recv_link, cc->global->encoded_data, encoded_size);
check(n == (ssize_t) encoded_size, "message data read fail");
pn_message_t *msg = cc->global->message;
int err = pn_message_decode(msg, cc->global->encoded_data, n);
check(err == 0, "message decode error");
cc->global->received++;
pn_delivery_settle(dlv);
statistics_msg_received(cc->global->stats, msg);
if (replying) {
const char *reply_addr = pn_message_get_reply_to(msg);
if (reply_addr) {
pn_link_t *rl = cc->reply_link;
check(pn_link_credit(rl) > 0, "message received without corresponding reply credit");
LOG("Replying to: %s\n", reply_addr );
pn_message_set_address(msg, reply_addr);
pn_message_set_creation_time(msg, msgr_now());
char tag[8];
void *ptr = &tag;
*((uint64_t *) ptr) = cc->global->sent;
pn_delivery_t *dlv = pn_delivery(rl, pn_dtag(tag, 8));
size_t size = cc->global->encoded_data_size;
int err = pn_message_encode(msg, cc->global->encoded_data, &size);
check(err == 0, "message encoding error");
pn_link_send(rl, cc->global->encoded_data, size);
pn_delivery_settle(dlv);
cc->global->sent++;
}
}
}
if (cc->global->received >= cc->global->opts->msg_count) {
global_shutdown(cc->global);
}
}
break;
case PN_CONNECTION_UNBOUND:
{
pn_connection_t *conn = pn_event_connection(event);
pn_list_remove(cc->global->active_connections, conn);
pn_connection_release(conn);
}
break;
default:
break;
}
}
ERL_NIF_TERM
final_encode(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ERL_NIF_TERM head = argv[0];
ERL_NIF_TERM term;
double number;
encode_ctx ctx;
ctx.env = env;
ctx.fill_offset = 0;
ctx.error = 0;
if (!enif_alloc_binary_compat(env, 100, &ctx.bin)) {
return no_mem_error(env);
}
while(enif_get_list_cell(env, head, &term, &head)) {
ErlNifBinary termbin;
const ERL_NIF_TERM* array;
int arity;
int code;
// We scan the list, looking for things to write into the binary, or
// encode and then write into the binary. We encode values that are
// tuples tagged with a type and a value: {Type, Value} where Type
// is a an Integer and Value is what is to be encoded
if (enif_get_tuple(env, term, &arity, &array)) {
// It's a tuple to encode and copy
if (arity != 2 || !enif_get_int(env, array[0], &code)) {
// not arity 2 or the first element isn't an int
ctx.error = BADARG;
goto done;
}
if (code == 0) {
// {0, String}
if (encode_string(&ctx, array[1]) != SUCCESS) {
goto done;
}
}
else {
// {1, Double}
if(!enif_get_double(env, array[1], &number)) {
ctx.error = BADARG;
goto done;
}
// We can't encode these.
if (isnan(number) || isinf(number)) {
ctx.error = BADARG;
goto done;
}
if ((ctx.error = ensure_buffer(&ctx, 32)) != SUCCESS) {
goto done;
}
// write the string into the buffer
snprintf((char*)ctx.bin.data+ctx.fill_offset, 32,
"%.16g", number);
// increment the length
ctx.fill_offset += strlen((char*)ctx.bin.data+ctx.fill_offset);
}
} else if (enif_inspect_binary(env, term, &termbin)) {
// this is a regular binary, copy the contents into the buffer
fill_buffer(&ctx, (char*)termbin.data, termbin.size);
if (ctx.error) {
goto done;
}
}
else {
//not a binary, not a tuple, wtf!
ctx.error = BADARG;
goto done;
}
}
done:
if (ctx.error == NOMEM) {
enif_release_binary_compat(env, &ctx.bin);
return no_mem_error(env);
} else if (ctx.error == BADARG) {
enif_release_binary_compat(env, &ctx.bin);
return enif_make_badarg(env);
}
// Resize the binary to our exact final size
if(!enif_realloc_binary_compat(env, &(ctx.bin), ctx.fill_offset)) {
enif_release_binary_compat(env, &ctx.bin);
return no_mem_error(env);
}
// make the binary term which transfers ownership
return enif_make_binary(env, &ctx.bin);
}
static void
do_mysql_comms(int to_server, int from_server)
{
struct sql_request req;
static char *buffer = 0;
static int buflen = 0;
static char *serial;
Timer_ID id;
Var args;
Var result;
set_server_cmdline("(MOO mysql-client slave)");
my_handle = moomysql_open_connection(SQLHOST, SQLUSER, SQLPASS, SQLDB, SQLPORT, 0);
for (;;) {
oklog("MYSQL CHILD: ready to read!\n");
if (robust_read(from_server, &req, sizeof(req)) != sizeof(req))
end_sql();
oklog("MYSQL CHILD read!\n");
if (req.length) {
ensure_buffer(&buffer, &buflen, req.length + 1);
if (robust_read(from_server, buffer, req.length)
!= req.length)
end_sql();
buffer[req.length] = '\0';
oklog("MYSQL CHILD got stuff!\n");
args = deserialize(buffer);
}
id = set_timer(req.timeout, timeout_proc, 0);
if (req.kind == SQLREQ_DO_QUERY) {
oklog("MYSQL CHILD: doing query '%s'\n", args.v.list[1].v.str);
result = moomysql_send_query(my_handle, args.v.list[1].v.str);
oklog("got result: %s\n", value2str(result));
serial = serialize(result);
oklog("MYSQL CHILD: serialized!\n");
req.length = strlen(serial);
oklog("MYSQL CHILD: strlenned!\n");
} else if (req.kind == SQLREQ_GET_ROW) {
result = moomysql_next_row(my_handle);
serial = serialize(result);
req.length = strlen(serial);
} else {
req.kind = SQLREQ_ERROR;
req.length = 0;
}
oklog("MYSQL CHILD: writing..\n");
write(to_server, &req, sizeof(req));
oklog("MYSQL CHILD: wrote req..\n");
if (req.length) {
write(to_server, serial, req.length);
oklog("MYSQL CHILD: wrote serial..\n");
free(serial);
oklog("MYSQL CHILD: freed serial!\n");
}
}
}
void
connection_dispatch ( pn_handler_t *h, pn_event_t *event, pn_event_type_t type )
{
connection_context_t *cc = connection_context(h);
switch ( type )
{
case PN_LINK_REMOTE_OPEN:
{
pn_link_t *link = pn_event_link(event);
if (pn_link_is_receiver(link)) {
check(cc->recv_link == NULL, "Multiple incomming links on one connection");
cc->recv_link = link;
pn_connection_t *conn = pn_event_connection(event);
pn_list_add(cc->global->active_connections, conn);
if (cc->global->shutting_down) {
pn_connection_close(conn);
break;
}
pn_flowcontroller_t *fc = pn_flowcontroller(1024);
pn_handler_add(h, fc);
pn_decref(fc);
}
}
break;
case PN_DELIVERY:
{
pn_link_t *recv_link = pn_event_link(event);
pn_delivery_t *dlv = pn_event_delivery(event);
if (pn_link_is_receiver(recv_link) && !pn_delivery_partial(dlv)) {
if (cc->global->received == 0) statistics_start(cc->global->stats);
size_t encoded_size = pn_delivery_pending(dlv);
cc->global->encoded_data = ensure_buffer(cc->global->encoded_data, encoded_size,
&cc->global->encoded_data_size);
check(cc->global->encoded_data, "decoding buffer realloc failure");
/*
If this was the first message received,
initialize our reporting.
*/
if ( ! cc->global->received )
rr_init ( & cc->global->resource_reporter );
ssize_t n = pn_link_recv(recv_link, cc->global->encoded_data, encoded_size);
check(n == (ssize_t) encoded_size, "message data read fail");
//fprintf ( stderr, "MDEBUG encoded_size == %d\n", encoded_size );
pn_message_t *msg = cc->global->message;
int err = pn_message_decode ( msg, cc->global->encoded_data, n );
check ( err == 0, "message decode error" );
/* MICK -- annotate! ================================ */
if ( cc->global->opts->timestamping )
{
double message_timestamp;
if ( get_message_timestamp ( msg, & message_timestamp ) )
{
double now = now_timestamp ( );
cc->global->total_latency += (now - message_timestamp);
}
else
{
fprintf ( stderr,
"receiver: no timestamp at msg count %d.\n",
cc->global->received
);
exit ( 1 );
}
}
/* MICK -- end annotate! ============================= */
cc->global->received++;
/*---------------------------------------
Do a report
---------------------------------------*/
if ( ! ( cc->global->received % cc->global->opts->report_frequency ) )
{
static bool first_time = true;
double cpu_percentage;
int rss;
double sslr = rr_seconds_since_last_report ( & cc->global->resource_reporter );
rr_report ( & cc->global->resource_reporter, & cpu_percentage, & rss );
double throughput = (double)(cc->global->opts->report_frequency) / sslr;
if ( first_time )
{
if ( cc->global->opts->timestamping )
{
if ( cc->global->opts->print_message_size )
fprintf(cc->global->report_fp, "msg_size\trecv_msgs\tcpu\trss\tthroughput\tlatency\n");
else
fprintf(cc->global->report_fp, "recv_msgs\tcpu\trss\tthroughput\tlatency\n");
}
else
{
if ( cc->global->opts->print_message_size )
fprintf(cc->global->report_fp, "msg_size\trecv_msgs\tcpu\trss\tthroughput\n");
else
fprintf(cc->global->report_fp, "recv_msgs\tcpu\trss\tthroughput\n");
}
first_time = false;
}
if ( cc->global->opts->timestamping )
{
double average_latency = cc->global->total_latency /
cc->global->opts->report_frequency;
average_latency *= 1000.0; // in msec.
cc->global->total_latency = 0;
fprintf ( cc->global->report_fp,
"%d\t%lf\t%d\t%lf\t%lf\n",
cc->global->received,
cpu_percentage,
rss,
throughput,
average_latency
);
}
else
{
// was:
// "recv_msgs: %10d cpu: %5.1lf rss: %6d throughput: %8.0lf\n"
if ( cc->global->opts->print_message_size )
{
fprintf ( cc->global->report_fp,
"%d\t%d\t%lf\t%d\t%lf\n",
cc->global->opts->message_size,
cc->global->received,
cpu_percentage,
rss,
throughput
);
}
else
{
fprintf ( cc->global->report_fp,
"%d\t%lf\t%d\t%lf\n",
cc->global->received,
cpu_percentage,
rss,
throughput
);
}
}
}
pn_delivery_settle(dlv); // move this up
statistics_msg_received(cc->global->stats, msg);
}
if (cc->global->received >= cc->global->opts->msg_count) {
global_shutdown(cc->global);
}
}
break;
case PN_CONNECTION_UNBOUND:
{
pn_connection_t *conn = pn_event_connection(event);
pn_list_remove(cc->global->active_connections, conn);
pn_connection_release(conn);
}
break;
default:
break;
}
}
