json_t* ciel_close_output(struct ciel_output* out) {
json_error_t error_bucket;
fflush(out->fp);
fclose(out->fp);
json_t* close_output_message = json_pack_ex(&error_bucket, 0, "[s{sisI}]", "close_output", "index", out->index, "size", out->bytes_written);
if(!close_output_message)
ciel_json_error(0, &error_bucket);
ciel_write_framed_json(close_output_message, ciel_out);
json_decref(close_output_message);
free(out);
json_t* response = ciel_read_framed_json(ciel_in);
char* response_verb;
json_t* ref;
if(json_unpack_ex(response, &error_bucket, 0, "[s{sO}]", &response_verb, "ref", &ref))
ciel_json_error(0, &error_bucket);
if(strcmp(response_verb, "close_output") != 0) {
fprintf(stderr, "close_output: bad response: %s\n", response_verb);
exit(1);
}
json_decref(response);
return ref;
}
int test_unpack()
{
int ret = -1;
int v1;
int v2;
json_error_t error;
json_t *root = json_pack("{s:i, s:i, s:i, s:i}", "n1", 1, "n2", 2, "n3", 3, "n4", 4);
if (!root)
return -1;
if (!json_unpack_ex(root, &error, JSON_STRICT, "{s:i, s:i}", "n1", &v1, "n2", &v2))
fail("Unexpected success");
if (json_error_code(&error) != json_error_end_of_input_expected) {
if (json_error_code(&error) != json_error_out_of_memory)
fail("Unexpected error code");
goto out;
}
if (strcmp(error.text, "2 object item(s) left unpacked: n3, n4"))
goto out;
ret = 0;
out:
json_decref(root);
return ret;
}
/** Update database entry with new information (if needed)
@param entry Entry to be updated
@param new_config New config
@return 0 if success, !0 in other case (reason printed)
*/
static int update_organization(organization_db_entry_t *entry,
json_t *new_config) {
int rc = 0;
json_error_t jerr;
json_int_t bytes_limit = 0;
json_t *aux_enrichment = NULL;
const int unpack_rc = json_unpack_ex(new_config, &jerr,
JSON_STRICT,
"{s?O,s?{s?I}}",
"enrichment",&aux_enrichment,
"limits","bytes",&bytes_limit);
if (0 != unpack_rc) {
const char *organization_uuid =
organization_db_entry_get_uuid(entry);
rdlog(LOG_ERR,"Couldn't unpack organization %s limits: %s",
organization_uuid, jerr.text);
rc = -1;
goto unpack_err;
}
pthread_mutex_lock(&entry->mutex);
swap_ptrs(entry->enrichment, aux_enrichment);
entry->bytes_limit.max = (uint64_t)bytes_limit;
pthread_mutex_unlock(&entry->mutex);
unpack_err:
if (aux_enrichment) {
json_decref(aux_enrichment);
}
return rc;
}
static void checkMSE8_invalid_timestamp(struct mse_array *notifications_array) {
/* No database -> output == input */
assert_int_equal(notifications_array->size, 1);
assert_int_equal(
notifications_array->data[0].string_size,
strlen(notifications_array->data[0].string)
);
json_int_t timestamp = 0;
json_error_t jerr;
json_t *ret = json_loads(notifications_array->data[0].string, 0, &jerr);
assert_non_null(ret);
const int unpack_rc = json_unpack_ex(ret, &jerr, 0,
"{s:{s:I}}",
"StreamingNotification",
"timestampMillis", ×tamp);
assert_int_equal(unpack_rc, 0);
assert_true(timestamp / 1000 != NOW);
assert_true(notifications_array->data[0].timestamp_warnings == 1);
json_decref(ret);
}
static int
_parse(model_and_data_t m,
column_reduction_t r_site,
column_reduction_t r_edge,
column_reduction_t r_trans,
int **first_idx, int **second_idx,
json_t *root)
{
json_t *model_and_data = NULL;
json_t *site_reduction = NULL;
json_t *edge_reduction = NULL;
json_t *trans_reduction = NULL;
slong site_count, edge_count, state_count;
int result = 0;
/* unpack the top level of json input */
{
size_t flags;
json_error_t err;
flags = JSON_STRICT;
result = json_unpack_ex(root, &err, flags,
"{s:o, s?o, s?o, s?o}",
"model_and_data", &model_and_data,
"site_reduction", &site_reduction,
"edge_reduction", &edge_reduction,
"trans_reduction", &trans_reduction
);
if (result)
{
fprintf(stderr, "error: on line %d: %s\n", err.line, err.text);
return result;
}
}
/* validate the model and data section of the json input */
result = validate_model_and_data(m, model_and_data);
if (result) return result;
/* initialize counts */
site_count = model_and_data_site_count(m);
edge_count = model_and_data_edge_count(m);
state_count = model_and_data_state_count(m);
/* validate the site reduction section of the json input */
result = validate_column_reduction(
r_site, site_count, "site", site_reduction);
if (result) return result;
/* validate the edge reduction section of the json input */
result = validate_column_reduction(
r_edge, edge_count, "edge", edge_reduction);
if (result) return result;
/* validate the state reduction section of the json input */
result = validate_column_pair_reduction(r_trans, first_idx, second_idx,
state_count, state_count, "trans", trans_reduction);
if (result) return result;
return result;
}
static void checkMSE8_valid_result(struct mse_array *notifications_array) {
/* No database -> output == input */
assert_int_equal(notifications_array->size, 1);
assert_int_equal(
notifications_array->data[0].string_size,
strlen(notifications_array->data[0].string)
);
const char *subscriptionName = NULL, *sensor_name = NULL;
json_int_t sensor_id = 0;
json_error_t jerr;
json_t *ret = json_loads(notifications_array->data[0].string, 0, &jerr);
assert_non_null(ret);
const int unpack_rc = json_unpack_ex(ret, &jerr, 0,
"{s:{s:s,s:s,s:i}}",
"StreamingNotification",
"subscriptionName", &subscriptionName,
"sensor_name", &sensor_name,
"sensor_id", &sensor_id);
assert_int_equal(unpack_rc, 0);
assert_string_equal(subscriptionName, "MSE_SanCarlos");
assert_string_equal(sensor_name, "MSE_testing");
assert_int_equal(sensor_id, 255);
json_decref(ret);
}
int ciel_read_ref(struct ciel_input* ref, char* buffer, int length) {
json_error_t error_bucket;
while(1) {
size_t bytes_read = fread(buffer, 1, length, ref->fp);
if(bytes_read == 0) {
if(ferror(ref->fp)) {
fprintf(stderr, "Error reading ref id %s\n", ref->refid);
return -1;
}
else {
if(ref->eof || ref->is_blocking) {
return 0;
}
else {
json_int_t threshold = ref->bytes_read + ref->chunk_size;
json_t* wait_message = json_pack_ex(&error_bucket, 0, "[s{sssI}]", "wait_stream", "id", ref->refid, "bytes", threshold);
ciel_write_framed_json(wait_message, ciel_out);
json_decref(wait_message);
json_t* response = ciel_read_framed_json(ciel_in);
char* response_verb;
int new_size;
int new_done;
int success;
if(json_unpack_ex(response, &error_bucket, 0, "[s{sisbsb}]", &response_verb, "size", &new_size, "done", &new_done, "success", &success))
ciel_json_error(0, &error_bucket);
ref->eof = new_done;
if(strcmp(response_verb, "wait_stream")) {
fprintf(stderr, "Weird response to wait_stream: %s\n", response_verb);
json_decref(response);
return -1;
}
if(!success) {
fprintf(stderr, "Error waiting for ref %s!\n", ref->refid);
json_decref(response);
return -1;
}
json_decref(response);
}
}
}
else {
ref->bytes_read += bytes_read;
return bytes_read;
}
}
}
int DrachtioController::sendRequestInsideDialog( boost::shared_ptr<JsonMsg> pMsg, const string& rid ) {
boost::shared_ptr<SipDialog> dlg ;
const char *dialogId=NULL ;
json_error_t err ;
if( 0 > json_unpack_ex(pMsg->value(), &err, 0, "{s:{s:s}}", "data", "dialogId", &dialogId) ) {
DR_LOG(log_error) << "DrachtioController::sendRequestInsideDialog - failed parsing message: " << err.text << endl ;
return -1 ;
}
if( !m_pDialogController->findDialogById( dialogId, dlg ) ) {
//DO I need to look in dialog maker also ? What about an UPDATE sent during an INVITE transaction?
return -1;
}
m_pDialogController->sendRequestInsideDialog( pMsg, rid, dlg ) ;
return 0 ;
}
json_t* ciel_get_task() {
json_error_t error_bucket;
json_t* task = ciel_read_framed_json(ciel_in);
char* command;
json_t* args;
if(json_unpack_ex(task, &error_bucket, 0, "[sO]", &command, &args))
ciel_json_error(0, &error_bucket);
if(strcmp(command, "start_task") != 0) {
fprintf(stderr, "Strange first task: %s\n", command);
exit(1);
}
json_decref(task);
return args;
}
struct ciel_input* ciel_open_ref(json_t* ref) {
json_error_t error_bucket;
json_t* open_message = json_pack_ex(&error_bucket, 0, "[s{sO}]", "open_ref", "ref", ref);
if(!open_message) {
ciel_json_error(0, &error_bucket);
return 0;
}
ciel_write_framed_json(open_message, ciel_out);
json_decref(open_message);
char* response_verb;
char* filename;
json_t* response = ciel_read_framed_json(ciel_in);
if(json_unpack_ex(response, &error_bucket, 0, "[s{ss}]", &response_verb, "filename", &filename)) {
ciel_json_error(0, &error_bucket);
return 0;
}
struct ciel_input* ret = (struct ciel_input*)malloc(sizeof(struct ciel_input));
ret->fp = fopen(filename, "r");
ret->chunk_size = 0;
ret->is_blocking = 1;
ret->must_close = 0;
ret->bytes_read = 0;
ret->eof = 0;
ret->refid = ciel_get_ref_id(ref);
json_decref(response);
return ret;
}
json_t* ciel_package_lookup(char *key) {
json_error_t error_bucket;
json_t* package_lookup_request = json_pack_ex(&error_bucket, 0, "[s{ss}]", "package_lookup", "key", key);
if (!package_lookup_request)
ciel_json_error(0, &error_bucket);
ciel_write_framed_json(package_lookup_request, ciel_out);
json_decref(package_lookup_request);
json_t* response = ciel_read_framed_json(ciel_in);
char* response_verb;
json_t* value;
if (json_unpack_ex(response, &error_bucket, 0, "[s{sO}]", &response_verb, "value", &value))
ciel_json_error(0, &error_bucket);
if (strcmp(response_verb, "package_lookup") != 0) {
fprintf(stderr, "package_lookup: bad response: %s\n", response_verb);
exit(1);
}
json_decref(response);
return value;
}
int main()
{
json_t *j, *j2;
int i1, i2, i3;
json_int_t I1;
int rv;
double f;
char *s;
json_error_t error;
/*
* Simple, valid json_pack cases
*/
/* true */
rv = json_unpack(json_true(), "b", &i1);
if(rv || !i1)
fail("json_unpack boolean failed");
/* false */
rv = json_unpack(json_false(), "b", &i1);
if(rv || i1)
fail("json_unpack boolean failed");
/* null */
if(json_unpack(json_null(), "n"))
fail("json_unpack null failed");
/* integer */
j = json_integer(42);
rv = json_unpack(j, "i", &i1);
if(rv || i1 != 42)
fail("json_unpack integer failed");
json_decref(j);
/* json_int_t */
j = json_integer(5555555);
rv = json_unpack(j, "I", &I1);
if(rv || I1 != 5555555)
fail("json_unpack json_int_t failed");
json_decref(j);
/* real */
j = json_real(1.7);
rv = json_unpack(j, "f", &f);
if(rv || f != 1.7)
fail("json_unpack real failed");
json_decref(j);
/* number */
j = json_integer(12345);
rv = json_unpack(j, "F", &f);
if(rv || f != 12345.0)
fail("json_unpack (real or) integer failed");
json_decref(j);
j = json_real(1.7);
rv = json_unpack(j, "F", &f);
if(rv || f != 1.7)
fail("json_unpack real (or integer) failed");
json_decref(j);
/* string */
j = json_string("foo");
rv = json_unpack(j, "s", &s);
if(rv || strcmp(s, "foo"))
fail("json_unpack string failed");
json_decref(j);
/* empty object */
j = json_object();
if(json_unpack(j, "{}"))
fail("json_unpack empty object failed");
json_decref(j);
/* empty list */
j = json_array();
if(json_unpack(j, "[]"))
fail("json_unpack empty list failed");
json_decref(j);
/* non-incref'd object */
j = json_object();
rv = json_unpack(j, "o", &j2);
if(j2 != j || j->refcount != 1)
fail("json_unpack object failed");
json_decref(j);
/* incref'd object */
j = json_object();
rv = json_unpack(j, "O", &j2);
if(j2 != j || j->refcount != 2)
fail("json_unpack object failed");
json_decref(j);
json_decref(j);
/* simple object */
j = json_pack("{s:i}", "foo", 42);
rv = json_unpack(j, "{s:i}", "foo", &i1);
if(rv || i1 != 42)
fail("json_unpack simple object failed");
json_decref(j);
/* simple array */
j = json_pack("[iii]", 1, 2, 3);
rv = json_unpack(j, "[i,i,i]", &i1, &i2, &i3);
if(rv || i1 != 1 || i2 != 2 || i3 != 3)
fail("json_unpack simple array failed");
json_decref(j);
/* object with many items & strict checking */
j = json_pack("{s:i, s:i, s:i}", "a", 1, "b", 2, "c", 3);
rv = json_unpack(j, "{s:i, s:i, s:i}", "a", &i1, "b", &i2, "c", &i3);
if(rv || i1 != 1 || i2 != 2 || i3 != 3)
fail("json_unpack object with many items failed");
json_decref(j);
/*
* Invalid cases
*/
j = json_integer(42);
if(!json_unpack_ex(j, &error, 0, "z"))
fail("json_unpack succeeded with invalid format character");
check_error("Unexpected format character 'z'", "<format>", 1, 1, 1);
if(!json_unpack_ex(NULL, &error, 0, "[i]"))
fail("json_unpack succeeded with NULL root");
check_error("NULL root value", "<root>", -1, -1, 0);
json_decref(j);
/* mismatched open/close array/object */
j = json_pack("[]");
if(!json_unpack_ex(j, &error, 0, "[}"))
fail("json_unpack failed to catch mismatched ']'");
check_error("Unexpected format character '}'", "<format>", 1, 2, 2);
json_decref(j);
j = json_pack("{}");
if(!json_unpack_ex(j, &error, 0, "{]"))
fail("json_unpack failed to catch mismatched '}'");
check_error("Expected format 's', got ']'", "<format>", 1, 2, 2);
json_decref(j);
/* missing close array */
j = json_pack("[]");
if(!json_unpack_ex(j, &error, 0, "["))
fail("json_unpack failed to catch missing ']'");
check_error("Unexpected end of format string", "<format>", 1, 2, 2);
json_decref(j);
/* missing close object */
j = json_pack("{}");
if(!json_unpack_ex(j, &error, 0, "{"))
fail("json_unpack failed to catch missing '}'");
check_error("Unexpected end of format string", "<format>", 1, 2, 2);
json_decref(j);
/* garbage after format string */
j = json_pack("[i]", 42);
if(!json_unpack_ex(j, &error, 0, "[i]a", &i1))
fail("json_unpack failed to catch garbage after format string");
check_error("Garbage after format string", "<format>", 1, 4, 4);
json_decref(j);
j = json_integer(12345);
if(!json_unpack_ex(j, &error, 0, "ia", &i1))
fail("json_unpack failed to catch garbage after format string");
check_error("Garbage after format string", "<format>", 1, 2, 2);
json_decref(j);
/* NULL format string */
j = json_pack("[]");
if(!json_unpack_ex(j, &error, 0, NULL))
fail("json_unpack failed to catch null format string");
check_error("NULL or empty format string", "<format>", -1, -1, 0);
json_decref(j);
/* NULL string pointer */
j = json_string("foobie");
if(!json_unpack_ex(j, &error, 0, "s", NULL))
fail("json_unpack failed to catch null string pointer");
check_error("NULL string argument", "<args>", 1, 1, 1);
json_decref(j);
/* invalid types */
j = json_integer(42);
j2 = json_string("foo");
if(!json_unpack_ex(j, &error, 0, "s"))
fail("json_unpack failed to catch invalid type");
check_error("Expected string, got integer", "<validation>", 1, 1, 1);
if(!json_unpack_ex(j, &error, 0, "n"))
fail("json_unpack failed to catch invalid type");
check_error("Expected null, got integer", "<validation>", 1, 1, 1);
if(!json_unpack_ex(j, &error, 0, "b"))
fail("json_unpack failed to catch invalid type");
check_error("Expected true or false, got integer", "<validation>", 1, 1, 1);
if(!json_unpack_ex(j2, &error, 0, "i"))
fail("json_unpack failed to catch invalid type");
check_error("Expected integer, got string", "<validation>", 1, 1, 1);
if(!json_unpack_ex(j2, &error, 0, "I"))
fail("json_unpack failed to catch invalid type");
check_error("Expected integer, got string", "<validation>", 1, 1, 1);
if(!json_unpack_ex(j, &error, 0, "f"))
fail("json_unpack failed to catch invalid type");
check_error("Expected real, got integer", "<validation>", 1, 1, 1);
if(!json_unpack_ex(j2, &error, 0, "F"))
fail("json_unpack failed to catch invalid type");
check_error("Expected real or integer, got string", "<validation>", 1, 1, 1);
if(!json_unpack_ex(j, &error, 0, "[i]"))
fail("json_unpack failed to catch invalid type");
check_error("Expected array, got integer", "<validation>", 1, 1, 1);
if(!json_unpack_ex(j, &error, 0, "{si}", "foo"))
fail("json_unpack failed to catch invalid type");
check_error("Expected object, got integer", "<validation>", 1, 1, 1);
json_decref(j);
json_decref(j2);
/* Array index out of range */
j = json_pack("[i]", 1);
if(!json_unpack_ex(j, &error, 0, "[ii]", &i1, &i2))
fail("json_unpack failed to catch index out of array bounds");
check_error("Array index 1 out of range", "<validation>", 1, 3, 3);
json_decref(j);
/* NULL object key */
j = json_pack("{si}", "foo", 42);
if(!json_unpack_ex(j, &error, 0, "{si}", NULL, &i1))
fail("json_unpack failed to catch null string pointer");
check_error("NULL object key", "<args>", 1, 2, 2);
json_decref(j);
/* Object key not found */
j = json_pack("{si}", "foo", 42);
if(!json_unpack_ex(j, &error, 0, "{si}", "baz", &i1))
fail("json_unpack failed to catch null string pointer");
check_error("Object item not found: baz", "<validation>", 1, 3, 3);
json_decref(j);
/*
* Strict validation
*/
j = json_pack("[iii]", 1, 2, 3);
rv = json_unpack(j, "[iii!]", &i1, &i2, &i3);
if(rv || i1 != 1 || i2 != 2 || i3 != 3)
fail("json_unpack array with strict validation failed");
json_decref(j);
j = json_pack("[iii]", 1, 2, 3);
if(!json_unpack_ex(j, &error, 0, "[ii!]", &i1, &i2))
fail("json_unpack array with strict validation failed");
check_error("1 array item(s) left unpacked", "<validation>", 1, 5, 5);
json_decref(j);
/* Like above, but with JSON_STRICT instead of '!' format */
j = json_pack("[iii]", 1, 2, 3);
if(!json_unpack_ex(j, &error, JSON_STRICT, "[ii]", &i1, &i2))
fail("json_unpack array with strict validation failed");
check_error("1 array item(s) left unpacked", "<validation>", 1, 4, 4);
json_decref(j);
j = json_pack("{s:s, s:i}", "foo", "bar", "baz", 42);
rv = json_unpack(j, "{sssi!}", "foo", &s, "baz", &i1);
if(rv || strcmp(s, "bar") != 0 || i1 != 42)
fail("json_unpack object with strict validation failed");
json_decref(j);
/* Unpack the same item twice */
j = json_pack("{s:s, s:i}", "foo", "bar", "baz", 42);
if(!json_unpack_ex(j, &error, 0, "{s:s,s:s!}", "foo", &s, "foo", &s))
fail("json_unpack object with strict validation failed");
check_error("1 object item(s) left unpacked", "<validation>", 1, 10, 10);
json_decref(j);
j = json_pack("[i,{s:i,s:n},[i,i]]", 1, "foo", 2, "bar", 3, 4);
if(json_unpack_ex(j, NULL, JSON_STRICT | JSON_VALIDATE_ONLY,
"[i{sisn}[ii]]", "foo", "bar"))
fail("json_unpack complex value with strict validation failed");
json_decref(j);
/* ! and * must be last */
j = json_pack("[ii]", 1, 2);
if(!json_unpack_ex(j, &error, 0, "[i!i]", &i1, &i2))
fail("json_unpack failed to catch ! in the middle of an array");
check_error("Expected ']' after '!', got 'i'", "<format>", 1, 4, 4);
if(!json_unpack_ex(j, &error, 0, "[i*i]", &i1, &i2))
fail("json_unpack failed to catch * in the middle of an array");
check_error("Expected ']' after '*', got 'i'", "<format>", 1, 4, 4);
json_decref(j);
j = json_pack("{sssi}", "foo", "bar", "baz", 42);
if(!json_unpack_ex(j, &error, 0, "{ss!si}", "foo", &s, "baz", &i1))
fail("json_unpack failed to catch ! in the middle of an object");
check_error("Expected '}' after '!', got 's'", "<format>", 1, 5, 5);
if(!json_unpack_ex(j, &error, 0, "{ss*si}", "foo", &s, "baz", &i1))
fail("json_unpack failed to catch ! in the middle of an object");
check_error("Expected '}' after '*', got 's'", "<format>", 1, 5, 5);
json_decref(j);
/* Error in nested object */
j = json_pack("{s{snsn}}", "foo", "bar", "baz");
if(!json_unpack_ex(j, &error, 0, "{s{sn!}}", "foo", "bar"))
fail("json_unpack nested object with strict validation failed");
check_error("1 object item(s) left unpacked", "<validation>", 1, 7, 7);
json_decref(j);
/* Error in nested array */
j = json_pack("[[ii]]", 1, 2);
if(!json_unpack_ex(j, &error, 0, "[[i!]]", &i1))
fail("json_unpack nested array with strict validation failed");
check_error("1 array item(s) left unpacked", "<validation>", 1, 5, 5);
json_decref(j);
return 0;
}
static int gen_jansson_value(yajl_gen gen, json_t *value) {
json_error_t jerr;
const char *str;
size_t len;
int rc;
int type = json_typeof(value);
switch(type) {
case JSON_OBJECT:
yajl_gen_map_open(gen);
gen_jansson_object(gen,value);
yajl_gen_map_close(gen);
break;
case JSON_ARRAY:
yajl_gen_array_open(gen);
gen_jansson_array(gen,value);
yajl_gen_array_close(gen);
break;
case JSON_STRING:
rc = json_unpack_ex(value, &jerr, 0, "s%", &str,&len);
if(rc != 0) {
rdlog(LOG_ERR,"Couldn't extract string: %s",jerr.text);
return 0;
}
yajl_gen_string(gen, (const unsigned char *)str, len);
break;
case JSON_INTEGER:
{
json_int_t i = json_integer_value(value);
yajl_gen_integer(gen,i);
}
break;
case JSON_REAL:
{
double d = json_number_value(value);
yajl_gen_double(gen,d);
}
break;
case JSON_TRUE:
yajl_gen_bool(gen,1);
break;
case JSON_FALSE:
yajl_gen_bool(gen,0);
break;
case JSON_NULL:
yajl_gen_null(gen);
break;
default:
rdlog(LOG_ERR,"Unkown jansson type %d",type);
break;
};
return 1;
}
// ref: borrowed reference
struct ciel_input* ciel_open_ref_async(json_t* ref, int chunk_size, int sole_consumer, int must_block) {
json_error_t error_bucket;
#ifdef CIEL_SOCKET
json_t* open_message = json_pack_ex(&error_bucket, 0, "[s{sOsisbsbsbss}]", "open_ref_async",
"ref", ref, "chunk_size", chunk_size, "sole_consumer", sole_consumer,
"make_sweetheart", 0, "must_block", must_block, "fd_socket_name", ciel_socket_name);
#else
json_t* open_message = json_pack_ex(&error_bucket, 0, "[s{sOsisbsbsb}]", "open_ref_async",
"ref", ref, "chunk_size", chunk_size, "sole_consumer", sole_consumer,
"make_sweetheart", 0, "must_block", must_block);
#endif /* CIEL_SOCKET */
if(!open_message)
ciel_json_error(0, &error_bucket);
ciel_write_framed_json(open_message, ciel_out);
json_decref(open_message);
json_t* response = ciel_read_framed_json(ciel_in);
char* response_verb;
json_t* response_args;
if(json_unpack_ex(response, &error_bucket, 0, "[so]", &response_verb, &response_args)) {
fprintf(stderr, "Failed decoding open_ref_async array\n");
ciel_json_error(0, &error_bucket);
json_decref(response);
return 0;
}
int fd_coming;
int is_blocking;
int is_done;
/*int size;*/
if(json_unpack_ex(response_args, &error_bucket, 0, "{sbsbsb}",
"sending_fd", &fd_coming, "blocking", &is_blocking,
"done", &is_done)) {
fprintf(stderr, "Failed decoding open_ref_async object\n");
ciel_json_error(0, &error_bucket);
json_decref(response);
return 0;
}
struct ciel_input* new_input = (struct ciel_input*)malloc(sizeof(struct ciel_input));
new_input->chunk_size = chunk_size;
new_input->is_blocking = is_blocking;
new_input->must_close = !is_done;
new_input->eof = is_done;
new_input->bytes_read = 0;
#ifdef CIEL_SOCKET
if(!fd_coming) {
#endif /* CIEL_SOCKET */
json_t* filename_obj = json_object_get(response_args, "filename");
if(!filename_obj) {
fprintf(stderr, "No member 'filename' in open_ref_async response\n");
json_decref(response);
return 0;
}
const char* filename = json_string_value(filename_obj);
if(!filename) {
fprintf(stderr, "Member 'filename' in open_ref_async not a string\n");
json_decref(response);
return 0;
}
new_input->fp = fopen(filename, "r");
#ifdef CIEL_SOCKET
}
else {
int recvd_fd = ciel_receive_fd();
if(recvd_fd == -1) {
fprintf(stderr, "Receive-FD failed in open_ref_async\n");
json_decref(response);
return 0;
}
new_input->fp = fdopen(recvd_fd, "r");
}
#endif /* CIEL_SOCKET */
json_decref(response);
new_input->refid = ciel_get_ref_id(ref);
return new_input;
}
struct ciel_output* ciel_open_output(int index, int may_stream, int may_pipe, int make_sweetheart) {
json_error_t error_bucket;
#ifdef CIEL_SOCKET
json_t* open_output_message = json_pack_ex(&error_bucket, 0, "[s{sisbsbsbss}]",
"open_output", "index", index,
"may_stream", may_stream, "may_pipe", may_pipe,
"make_local_sweetheart", make_sweetheart,
"fd_socket_name", ciel_socket_name);
#else
json_t* open_output_message = json_pack_ex(&error_bucket, 0, "[s{sisbsbsb}]",
"open_output", "index", index,
"may_stream", may_stream, "may_pipe", may_pipe,
"make_local_sweetheart", make_sweetheart);
#endif /* CIEL_SOCKET */
if(!open_output_message)
ciel_json_error(0, &error_bucket);
ciel_write_framed_json(open_output_message, ciel_out);
json_decref(open_output_message);
json_t* open_response = ciel_read_framed_json(ciel_in);
char* response_verb;
json_t* response_args;
if(json_unpack_ex(open_response, &error_bucket, 0, "[so]", &response_verb, &response_args))
ciel_json_error(0, &error_bucket);
if(strcmp(response_verb, "open_output") != 0) {
fprintf(stderr, "open_output: bad response: %s\n", response_verb);
exit(1);
}
json_t* sending_fd_json = json_object_get(response_args, "sending_fd");
if(!sending_fd_json) {
fprintf(stderr, "Open output response doesn't have member 'sending_fd'\n");
json_decref(open_response);
return 0;
}
struct ciel_output* ret = (struct ciel_output*)malloc(sizeof(struct ciel_output));
ret->index = index;
ret->bytes_written = 0;
#ifdef CIEL_SOCKET
if(json_typeof(sending_fd_json) == JSON_TRUE) {
int fd = ciel_receive_fd();
ret->fp = fdopen(fd, "w");
}
else {
json_t* filename_json = json_object_get(response_args, "filename");
ret->fp = fopen(json_string_value(filename_json), "w");
}
#else
json_t* filename_json = json_object_get(response_args, "filename");
ret->fp = fopen(json_string_value(filename_json), "w");
#endif /* CIEL_SOCKET */
json_decref(open_response);
return ret;
}
int
main(int argc, char **argv)
{
if(argc < 5) {
fprintf(stderr, "stream_producer needs at least 4 arguments\n");
exit(1);
}
if(strcmp(argv[1], "--write-fifo") != 0) {
fprintf(stderr, "stream_producer first arg must be --write-fifo\n");
exit(1);
}
if(strcmp(argv[3], "--read-fifo") != 0) {
fprintf(stderr, "stream producer third arg must be --read-fifo\n");
exit(1);
}
printf("C binopt: start\n");
ciel_init(argv[2], argv[4]);
json_t* task_private = ciel_get_task();
json_error_t error_bucket;
json_t* kwargs;
char* s_str;
char* k_str;
char* t_str;
char* v_str;
char* rf_str;
char* cp_str;
char* n_str;
char* chunk_str;
char* start_str;
fprintf(stderr, "doing decode\n");
if(json_unpack_ex(task_private, &error_bucket, 0, "{s[sssssssss]so}", "proc_pargs",
&s_str, &k_str, &t_str, &v_str, &rf_str, &cp_str, &n_str,
&chunk_str, &start_str, "proc_kwargs", &kwargs)) {
ciel_json_error("Failed to decode proc_pargs", &error_bucket);
exit(1);
}
fprintf(stderr, "doing conversion\n");
s = strtod(s_str, NULL);
k = strtod(k_str, NULL);
t = strtod(t_str, NULL);
v = strtod(v_str, NULL);
rf = strtod(rf_str, NULL);
cp = strtod(cp_str, NULL);
n = (int)strtod(n_str, NULL);
chunk = (int)strtod(chunk_str, NULL);
start = strcmp(start_str, "false");
fprintf(stderr, "Got arguments: %g %g %g %g %g %g %d %d %s\n", s, k, t, v, rf, cp, n, chunk, start_str);
if(!start) {
json_t* in_ref = json_object_get(kwargs, "input_ref");
binopt_ciel_in = ciel_open_ref_async(in_ref, 1, 1, 0);
ciel_set_input_unbuffered(binopt_ciel_in);
}
else {
binopt_ciel_in = 0;
}
json_decref(task_private);
binopt_ciel_out = ciel_open_output(0, 1, 0, 0);
ciel_set_output_unbuffered(binopt_ciel_out);
init_vals();
if (start == 1) {
OUTPUT(n);
gen_initial_optvals();
} else {
int rowstart=0;
INPUT(rowstart);
if (rowstart==0) {
double v;
INPUT(v);
char buf[20];
int chars_written = min(snprintf(buf, 20, "%.9f\n", v), 20);
ciel_write_output(binopt_ciel_out, buf, chars_written);
} else {
int rowto = (rowstart - chunk) > 0 ? (rowstart - chunk) : 0;
process_rows(rowstart, rowto);
}
}
if(!start) {
ciel_close_ref(binopt_ciel_in);
}
ciel_close_output(binopt_ciel_out);
ciel_exit();
return 0;
}
int main(int argc, char** argv) {
if(argc < 5) {
fprintf(stderr, "stream_producer needs at least 4 arguments\n");
exit(1);
}
if(strcmp(argv[1], "--write-fifo") != 0) {
fprintf(stderr, "stream_producer first arg must be --write-fifo\n");
exit(1);
}
if(strcmp(argv[3], "--read-fifo") != 0) {
fprintf(stderr, "stream producer third arg must be --read-fifo\n");
exit(1);
}
printf("C stream consumer: start\n");
ciel_init(argv[2], argv[4]);
printf("FIFOs open\n");
json_t* ref;
int may_stream;
int sole_consumer;
int must_block;
json_t* task_private = ciel_get_task();
json_error_t error_bucket;
if(json_unpack_ex(task_private, &error_bucket, 0, "{s[Obbb]}", "proc_pargs", &ref, &may_stream, &sole_consumer, &must_block)) {
ciel_json_error(0, &error_bucket);
exit(1);
}
json_decref(task_private);
ciel_block_on_refs(1, ref);
struct ciel_input* input;
if(may_stream)
input = ciel_open_ref_async(ref, 1024*1024*64, sole_consumer, must_block);
else
input = ciel_open_ref(ref);
char read_buffer[4096];
json_int_t bytes_read = 0;
while(1) {
int this_read = ciel_read_ref(input, read_buffer, 4096);
if(this_read == -1) {
fprintf(stderr, "Error reading input!");
exit(1);
}
else if(this_read == 0) {
break;
}
bytes_read += this_read;
}
ciel_close_ref(input);
char* response_string;
asprintf(&response_string, "Consumer read %lld bytes\n", bytes_read);
ciel_define_output_with_plain_string(0, response_string);
free(response_string);
ciel_exit();
return 0;
}
