void testCheckDuplicates2(void) {
bson b, b2;
bson_iterator it, sit;
bson_type bt;
bson_init(&b);
bson_append_start_array(&b, "array");
bson_append_int(&b, "0", 1);
bson_append_finish_array(&b);
bson_append_start_array(&b, "array");
bson_append_int(&b, "0", 3);
bson_append_int(&b, "1", 4);
bson_append_finish_array(&b);
bson_finish(&b);
CU_ASSERT_FALSE_FATAL(b.err);
CU_ASSERT_TRUE_FATAL(bson_check_duplicate_keys(&b));
bson_init(&b2);
bson_fix_duplicate_keys(&b, &b2);
bson_finish(&b2);
CU_ASSERT_FALSE_FATAL(b2.err);
CU_ASSERT_FALSE_FATAL(bson_check_duplicate_keys(&b2));
BSON_ITERATOR_INIT(&it, &b2);
bt = bson_iterator_next(&it);
CU_ASSERT_EQUAL_FATAL(bt, BSON_ARRAY);
CU_ASSERT_STRING_EQUAL_FATAL(BSON_ITERATOR_KEY(&it), "array");
BSON_ITERATOR_SUBITERATOR(&it, &sit);
bt = bson_iterator_next(&sit);
CU_ASSERT_STRING_EQUAL_FATAL(BSON_ITERATOR_KEY(&sit), "0");
CU_ASSERT_TRUE_FATAL(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL_FATAL(bson_iterator_int(&sit), 1);
bt = bson_iterator_next(&sit);
CU_ASSERT_STRING_EQUAL_FATAL(BSON_ITERATOR_KEY(&sit), "1");
CU_ASSERT_TRUE_FATAL(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL_FATAL(bson_iterator_int(&sit), 3);
bt = bson_iterator_next(&sit);
CU_ASSERT_STRING_EQUAL_FATAL(BSON_ITERATOR_KEY(&sit), "2");
CU_ASSERT_TRUE_FATAL(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL_FATAL(bson_iterator_int(&sit), 4);
bt = bson_iterator_next(&sit);
CU_ASSERT_EQUAL_FATAL(bt, BSON_EOO);
bson_destroy(&b2);
bson_destroy(&b);
}
void test_example_wikipedia_bson(size_t iterations) {
bcon_error_t ret;
size_t i;
bson b[1];
for (i = 0; i < iterations; i++) {
bson_init( b );
bson_append_string( b, "firstName", "John" );
bson_append_string( b, "lastName" , "Smith" );
bson_append_int( b, "age" , 25);
bson_append_start_object( b, "address" );
bson_append_string( b, "streetAddress", "21 2nd Street" );
bson_append_string( b, "city" , "New York" );
bson_append_string( b, "state" , "NY" );
bson_append_string( b, "postalCode" , "10021" );
bson_append_finish_object( b );
bson_append_start_array( b, "phoneNumber" );
bson_append_start_object( b, "0" );
bson_append_string( b, "type" , "home" );
bson_append_string( b, "number", "212 555-1234" );
bson_append_finish_object( b );
bson_append_start_object( b, "1" );
bson_append_string( b, "type" , "fax" );
bson_append_string( b, "number", "646 555-4567" );
bson_append_finish_object( b );
bson_append_finish_array( b );
ret = bson_finish( b );
bson_destroy( b );
}
assert(ret == BSON_OK);
}
static void _log_stacktrace(bson *b)
{
uintptr_t addrs[RETADDRCNT], count;
char number[20], sym[512];
bson_append_start_array(b, "s");
count = stacktrace(NULL, addrs, RETADDRCNT);
for (uint32_t idx = 4; idx < count; idx++) {
ultostr(idx-4, number, 10);
symbol((const uint8_t *) addrs[idx], sym, sizeof(sym)-32);
if(sym[0] != 0) {
our_snprintf(sym + our_strlen(sym),
sizeof(sym) - our_strlen(sym), " @ ");
}
our_snprintf(sym + our_strlen(sym), sizeof(sym) - our_strlen(sym),
"%p", (const uint8_t *) addrs[idx]);
bson_append_string(b, number, sym);
}
bson_append_finish_array(b);
}
void loq(int index, const char *name,
int is_success, int return_value, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
const char * fmtbak = fmt;
int argnum = 2;
int count = 1; char key = 0;
EnterCriticalSection(&g_mutex);
if(logtbl_explained[index] == 0) {
logtbl_explained[index] = 1;
const char * pname;
bson b[1];
bson_init( b );
bson_append_int( b, "I", index );
bson_append_string( b, "name", name );
bson_append_string( b, "type", "info" );
bson_append_string( b, "category", logtbl[index][1] );
bson_append_start_array( b, "args" );
bson_append_string( b, "0", "is_success" );
bson_append_string( b, "1", "retval" );
while (--count != 0 || *fmt != 0) {
// we have to find the next format specifier
if(count == 0) {
// end of format
if(*fmt == 0) break;
// set the count, possibly with a repeated format specifier
count = *fmt >= '2' && *fmt <= '9' ? *fmt++ - '0' : 1;
// the next format specifier
key = *fmt++;
}
pname = va_arg(args, const char *);
snprintf(g_istr, 4, "%u", argnum);
argnum++;
//on certain formats, we need to tell cuckoo about them for nicer display / matching
if (key == 'p' || key == 'P') {
bson_append_start_array( b, g_istr );
bson_append_string( b, "0", pname );
bson_append_string( b, "1", "p" );
bson_append_finish_array( b );
} else {
bson_append_string( b, g_istr, pname );
}
//now ignore the values
if(key == 's') {
(void) va_arg(args, const char *);
}
else if(key == 'S') {
static void log_argv(int argc, const char ** argv) {
bson_append_start_array( g_bson, g_istr );
for (int i=0; i<argc; i++) {
snprintf(g_istr, 4, "%u", i);
log_string(argv[i], -1);
}
bson_append_finish_array( g_bson );
}
static void
jbson_array_end(void *state)
{
json_to_bson_state *_state = (json_to_bson_state *) state;
if (_state->lex->lex_level == 0)
return;
bson_append_finish_array(_state->bson);
}
static void log_argv(bson *b, const char *idx, int argc, const char **argv)
{
bson_append_start_array(b, idx);
char index[5];
for (int i = 0; i < argc; i++) {
ultostr(i, index, 10);
log_string(b, index, argv[i], -1);
}
bson_append_finish_array(b);
}
void bson_from_json_type(bson *b, yajl_val value, const char* key)
{
if( YAJL_IS_STRING( value ) )
{
char* string = YAJL_GET_STRING( value );
bson_append_string( b, key, string );
}
else if( YAJL_IS_NUMBER( value ) )
{
char* string = value->u.number.r;
size_t len = strlen( string );
// Hack to detect a double, since 'flags' is always set to double.
if( memchr( string, '.', len ) ||
memchr( string, 'e', len ) ||
memchr( string, 'E', len ) )
{
double number = YAJL_GET_DOUBLE( value );
bson_append_double( b, key, number );
}
else
{
uint64_t number = YAJL_GET_INTEGER( value );
if( number <= INT_MIN && number <= INT_MAX)
bson_append_int( b, key, (int)number );
else
bson_append_long( b, key, number);
}
}
else if ( YAJL_IS_FALSE( value ) )
{
bson_append_bool( b, key, 0 );
}
else if ( YAJL_IS_TRUE( value ) )
{
bson_append_bool( b, key, 1 );
}
else if ( YAJL_IS_ARRAY( value ) )
{
bson_append_start_array( b, key );
bson_from_json_array( b, value );
bson_append_finish_array( b );
}
else if ( YAJL_IS_OBJECT( value ) )
{
bson_append_start_object( b, key );
bson_from_json_object( b, value );
bson_append_finish_object( b );
}
}
static void log_argv(bson *b, const char *idx, int argc, const char **argv)
{
bson_append_start_array(b, idx);
char index[5];
for (int i = 0; i < argc; i++) {
char *value = copy_ptr(&argv[i]);
if(value != NULL) {
ultostr(i, index, 10);
log_string(b, index, value, copy_strlen(value));
}
}
bson_append_finish_array(b);
}
bson* bson_encode(lua_State *L)
{
int type = lua_type(L,-1);
if(type == LUA_TNIL){
bson *b = cBSON_CreateNull();
return b;
}else if(type == LUA_TBOOLEAN){
int boo = lua_toboolean(L, -1);
bson* b = cBSON_CreateBool(boo);
return b;
}else if(type == LUA_TNUMBER){
double num = lua_tonumber(L, -1);
bson* b = cBSON_CreateNumber(num);
return b;
}else if(type == LUA_TSTRING){
size_t str_len;
const char *string = lua_tolstring(L, -1, &str_len);
bson* b = cBSON_CreateString(string);
return b;
}else if(type == LUA_TTABLE){
bson *item = bson_alloc();
if(item == NULL){
LOG_ERROR("null");
return NULL;
}
bson_init(item);
bson_append_start_array(item,"0");
lua_pushnil(L);
while(lua_next(L, -2) != 0){
if(lua_type(L, -2) == LUA_TSTRING){
size_t str_len = 0;
const char *k = lua_tolstring(L, -2, &str_len);
bson_encode_append(L,item,k);
}else if(lua_type(L, -2) == LUA_TNUMBER){
int k = (int)lua_tonumber(L, -2);
char kname[32];
sprintf(kname, "%d", k);
bson_encode_append(L,item,kname);
}
lua_pop(L, 1);
}
bson_append_finish_array(item);
bson_finish(item);
return item;
}
LOG_ERROR("unspport type");
return NULL;
}
void encodeArray(bson *bb, const char *name, v8::Local<v8::Value> element)
{
v8::Local<v8::Array> a = v8::Local<v8::Array>::Cast(element);
bson_append_start_array(bb, name);
for (int i = 0, l = a->Length(); i < l; i++)
{
v8::Local<v8::Value> val = a->Get(i);
char numStr[32];
sprintf(numStr, "%d", i);
encodeValue(bb, numStr, val);
}
bson_append_finish_array(bb);
}
int commit_inode(struct inode * e) {
bson cond, doc;
mongo * conn = get_conn();
char istr[4];
struct dirent * cde = e->dirents;
int res;
bson_init(&doc);
bson_append_start_object(&doc, "$set");
bson_append_start_array(&doc, "dirents");
res = 0;
while(cde) {
bson_numstr(istr, res++);
bson_append_string(&doc, istr, cde->path);
cde = cde->next;
}
bson_append_finish_array(&doc);
bson_append_int(&doc, "mode", e->mode);
bson_append_long(&doc, "owner", e->owner);
bson_append_long(&doc, "group", e->group);
bson_append_long(&doc, "size", e->size);
bson_append_time_t(&doc, "created", e->created);
bson_append_time_t(&doc, "modified", e->modified);
if(e->data && e->datalen > 0)
bson_append_string_n(&doc, "data", e->data, e->datalen);
bson_append_finish_object(&doc);
bson_finish(&doc);
bson_init(&cond);
bson_append_oid(&cond, "_id", &e->oid);
bson_finish(&cond);
res = mongo_update(conn, inodes_name, &cond, &doc,
MONGO_UPDATE_UPSERT, NULL);
bson_destroy(&cond);
bson_destroy(&doc);
if(res != MONGO_OK) {
fprintf(stderr, "Error committing inode %s\n",
mongo_get_server_err_string(conn));
return -EIO;
}
return 0;
}
static int bson_encode_append(lua_State *L,bson *b,const char *key){
int type = lua_type(L,-1);
if(type == LUA_TNIL){
}else if(type == LUA_TBOOLEAN){
cBSON_AppendBool(L,b,key);
return 0;
}else if(type == LUA_TNUMBER){
cBSON_AppendNumber(L,b,key);
return 0;
}else if(type == LUA_TSTRING){
cBSON_AppendString(L,b,key);
return 0;
}else if(type == LUA_TTABLE){
bson_append_start_array(b,"0");
lua_pushnil(L);
while(lua_next(L, -2) != 0){
if(lua_type(L, -2) == LUA_TSTRING){
size_t str_len = 0;
const char *k = lua_tolstring(L, -2, &str_len);
if(bson_encode_append(L,b,k) != 0){
LOG_ERROR("append fail");
break;
}
}else if(lua_type(L, -2) == LUA_TNUMBER){
int k = (int)lua_tonumber(L, -2);
if(b == NULL){
LOG_ERROR("null");
break;
}
char kname[32];
sprintf(kname, "%d", k);
if(bson_encode_append(L,b,kname) != 0){
LOG_ERROR("append fail");
}
}
lua_pop(L, 1);
}
bson_append_finish_array(b);
return 0;
}
LOG_ERROR("unspport type");
return 1;
}
int main() {
/*
* We assume objects in the form of {_id:<any_id>, list:[{a:<int>,b:<int>}, ...]}
*/
mongo conn[1];
mongo_init(conn);
if(MONGO_OK != mongo_client(conn, "127.0.0.1", 27017))
return 1;
bson b[1], b_result[1];
/*create the aggregation command in bson*/
bson_init(b);
bson_append_string(b, "aggregate", "agg");
bson_append_start_array(b, "pipeline");
bson_append_start_object(b,"0");
bson_append_string(b, "$unwind", "$list");
bson_append_finish_object(b);
bson_append_start_object(b,"1");
bson_append_start_object(b,"$group");
bson_append_string(b,"_id", "$list");
bson_append_start_object(b, "distinct_count");
bson_append_int(b, "$sum", 1);
bson_append_finish_object(b);
bson_append_finish_object(b);
bson_append_finish_object(b);
bson_append_finish_array(b);
bson_finish(b);
/*So you can see your command*/
bson_print(b);
/*run the command*/
mongo_run_command(conn, "test", b, b_result);
/*command results*/
bson_print(b_result);
bson_destroy(b_result);
bson_destroy(b);
mongo_destroy(conn);
return 0;
}
void test_example_awesome() {
bcon_error_t ret;
bson b[1];
/* JSON {"BSON": ["awesome", 5.05, 1986]} */
bcon awesome[] = { "BSON", "[", "awesome", BF(5.05), BI(1986), "]", BEND };
test_bson_from_bcon( awesome, BCON_OK, BSON_VALID );
if (verbose )
printf("\t--------\n");
bson_init( b );
bson_append_start_array( b, "BSON" );
bson_append_string( b, "0", "awesome" );
bson_append_double( b, "1", 5.05 );
bson_append_int( b, "2", 1986 );
bson_append_finish_array( b );
ret = bson_finish( b );
if ( verbose )
bson_print( b );
bson_destroy( b );
}
void SimpleVector<Scalar>::export_to_file(const char *filename, const char *var_name, MatrixExportFormat fmt, char* number_format)
{
if (!v)
throw Exceptions::MethodNotOverridenException("Vector<Scalar>::export_to_file");
switch (fmt)
{
case EXPORT_FORMAT_MATRIX_MARKET:
{
FILE* file = fopen(filename, "w");
if (!file)
throw Exceptions::IOException(Exceptions::IOException::Write, filename);
if (Hermes::Helpers::TypeIsReal<Scalar>::value)
fprintf(file, "%%%%MatrixMarket matrix coordinate real general\n");
else
fprintf(file, "%%%%MatrixMarket matrix coordinate complex general\n");
fprintf(file, "%d 1 %d\n", this->size, this->size);
for (unsigned int j = 0; j < this->size; j++)
{
Hermes::Helpers::fprint_coordinate_num(file, j + 1, 1, v[j], number_format);
fprintf(file, "\n");
}
fclose(file);
}
break;
case EXPORT_FORMAT_MATLAB_MATIO:
{
#ifdef WITH_MATIO
size_t dims[2];
dims[0] = this->size;
dims[1] = 1;
mat_t *mat = Mat_CreateVer(filename, "", MAT_FT_MAT5);
matvar_t *matvar;
// For complex.
double* v_re = nullptr;
double* v_im = nullptr;
void* data;
if (Hermes::Helpers::TypeIsReal<Scalar>::value)
{
data = v;
matvar = Mat_VarCreate(var_name, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, data, MAT_F_DONT_COPY_DATA);
}
else
{
v_re = malloc_with_check<SimpleVector<Scalar>, double>(this->size, this);
v_im = malloc_with_check<SimpleVector<Scalar>, double>(this->size, this);
struct mat_complex_split_t z = { v_re, v_im };
for (int i = 0; i < this->size; i++)
{
v_re[i] = ((std::complex<double>)(this->v[i])).real();
v_im[i] = ((std::complex<double>)(this->v[i])).imag();
data = &z;
}
matvar = Mat_VarCreate(var_name, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, data, MAT_F_DONT_COPY_DATA | MAT_F_COMPLEX);
}
if (matvar)
{
Mat_VarWrite(mat, matvar, MAT_COMPRESSION_ZLIB);
Mat_VarFree(matvar);
}
free_with_check(v_re);
free_with_check(v_im);
Mat_Close(mat);
if (!matvar)
throw Exceptions::IOException(Exceptions::IOException::Write, filename);
#else
throw Exceptions::Exception("MATIO not included.");
#endif
}
break;
case EXPORT_FORMAT_PLAIN_ASCII:
case EXPORT_FORMAT_MATLAB_SIMPLE:
{
FILE* file = fopen(filename, "w");
if (!file)
throw Exceptions::IOException(Exceptions::IOException::Write, filename);
for (unsigned int i = 0; i < this->size; i++)
{
Hermes::Helpers::fprint_num(file, v[i], number_format);
fprintf(file, "\n");
}
fclose(file);
}
break;
#ifdef WITH_BSON
case EXPORT_FORMAT_BSON:
{
// Init bson
bson bw;
bson_init(&bw);
// Matrix size.
bson_append_int(&bw, "size", this->size);
bson_append_start_array(&bw, "v");
for (unsigned int i = 0; i < this->size; i++)
bson_append_double(&bw, "v_i", real(this->v[i]));
bson_append_finish_array(&bw);
if (!Hermes::Helpers::TypeIsReal<Scalar>::value)
{
bson_append_start_array(&bw, "v-imag");
for (unsigned int i = 0; i < this->size; i++)
bson_append_double(&bw, "v_i", imag(this->v[i]));
bson_append_finish_array(&bw);
}
// Done.
bson_finish(&bw);
// Write to disk.
FILE *fpw;
fpw = fopen(filename, "wb");
const char *dataw = (const char *)bson_data(&bw);
fwrite(dataw, bson_size(&bw), 1, fpw);
fclose(fpw);
bson_destroy(&bw);
}
#endif
}
}
/**
* \brief This function save current version o tag group to MongoDB
*/
static void vs_mongo_taggroup_save_version(struct VSTagGroup *tg,
bson *bson_tg,
uint32 version)
{
bson bson_version;
bson bson_tag;
struct VBucket *bucket;
struct VSTag *tag;
char str_num[15];
int item_id;
bson_init(&bson_version);
bson_append_int(&bson_version, "crc32", tg->crc32);
bson_append_start_object(&bson_version, "tags");
bucket = tg->tags.lb.first;
while(bucket != NULL) {
tag = (struct VSTag*)bucket->data;
bson_init(&bson_tag);
bson_append_int(&bson_tag, "data_type", tag->data_type);
bson_append_int(&bson_tag, "count", tag->count);
bson_append_int(&bson_tag, "custom_type", tag->custom_type);
bson_append_start_array(&bson_tag, "data");
switch(tag->data_type) {
case VRS_VALUE_TYPE_UINT8:
for(item_id = 0; item_id < tag->count; item_id++) {
sprintf(str_num, "%d", item_id);
bson_append_int(&bson_tag, str_num, ((uint8*)tag->value)[item_id]);
}
break;
case VRS_VALUE_TYPE_UINT16:
for(item_id = 0; item_id < tag->count; item_id++) {
sprintf(str_num, "%d", item_id);
bson_append_int(&bson_tag, str_num, ((uint16*)tag->value)[item_id]);
}
break;
case VRS_VALUE_TYPE_UINT32:
for(item_id = 0; item_id < tag->count; item_id++) {
sprintf(str_num, "%d", item_id);
bson_append_int(&bson_tag, str_num, ((uint32*)tag->value)[item_id]);
}
break;
case VRS_VALUE_TYPE_UINT64:
for(item_id = 0; item_id < tag->count; item_id++) {
sprintf(str_num, "%d", item_id);
bson_append_long(&bson_tag, str_num, ((uint64*)tag->value)[item_id]);
}
break;
case VRS_VALUE_TYPE_REAL16:
/* TODO */
break;
case VRS_VALUE_TYPE_REAL32:
for(item_id = 0; item_id < tag->count; item_id++) {
sprintf(str_num, "%d", item_id);
bson_append_double(&bson_tag, str_num, ((float*)tag->value)[item_id]);
}
break;
case VRS_VALUE_TYPE_REAL64:
for(item_id = 0; item_id < tag->count; item_id++) {
sprintf(str_num, "%d", item_id);
bson_append_double(&bson_tag, str_num, ((double*)tag->value)[item_id]);
}
break;
case VRS_VALUE_TYPE_STRING8:
bson_append_string(&bson_tag, "0", (char*)tag->value);
break;
}
bson_append_finish_array(&bson_tag);
bson_finish(&bson_tag);
sprintf(str_num, "%d", tag->id);
bson_append_bson(&bson_version, str_num, &bson_tag);
bucket = bucket->next;
}
bson_append_finish_object(&bson_version);
bson_finish(&bson_version);
sprintf(str_num, "%u", version);
bson_append_bson(bson_tg, str_num, &bson_version);
}
INLINE void v_to_bson P3(bson *, out, char *, k, svalue_t *, v)
{
switch(v->type) {
case T_STRING:
{
if(!strcmp(k,"_id") && strlen(v->u.string) == 24){
bson_oid_t oid[1];
bson_oid_from_string(oid,v->u.string);
bson_append_oid(out,k,oid);
}else{
bson_append_string(out,k,v->u.string);
}
return;
}
case T_CLASS:
{
bson_append_string(out,k,"CLASS");
return;
}
case T_NUMBER:
{
bson_append_long(out,k,v->u.number);
return;
}
case T_REAL:
{
bson_append_double(out,k,v->u.real);
return;
}
case T_ARRAY:
{
int i;
int size;
char buf[20];
size = v->u.arr->size;
svalue_t *sv = v->u.arr->item;
bson_append_start_array(out, k);
for(i=0; i<size; i++) {
sprintf(buf,"%d",i);
v_to_bson(out,buf,sv++);
}
bson_append_finish_array( out );
return;
}
case T_MAPPING:
{
char num[25];
int j = v->u.map->table_size;
mapping_node_t **a = v->u.map->table, *elt;
bson_append_start_object(out, k);
do {
for (elt = a[j]; elt; elt = elt = elt->next) {
if(elt->values->type == T_STRING){
v_to_bson(out,elt->values->u.string,elt->values+1);
}else if(elt->values->type == T_NUMBER){
sprintf(num,"%ld",v->u.number);
v_to_bson(out,num,elt->values+1);
}else{
continue;
}
}
} while (j--);
bson_append_finish_object( out );
return;
}
}
}
static void lua_val_to_bson(lua_State *L, const char *key, int vpos, bson *bs, int tref) {
int vtype = lua_type(L, vpos);
char nbuf[TCNUMBUFSIZ];
if (key == NULL && vtype != LUA_TTABLE) {
luaL_error(L, "lua_val_to_bson: Table must be on top of lua stack");
return;
}
switch (vtype) {
case LUA_TTABLE:
{
if (vpos < 0) {
vpos = lua_gettop(L) + vpos + 1;
}
lua_checkstack(L, 3);
int bsontype_found = luaL_getmetafield(L, vpos, "__bsontype");
if (!bsontype_found) {
lua_rawgeti(L, LUA_REGISTRYINDEX, tref); //+ reg table
lua_pushvalue(L, vpos); //+ val
lua_rawget(L, -2); //-val +reg table val
if (lua_toboolean(L, -1)) { //already traversed
lua_pop(L, 2);
break;
}
lua_pop(L, 1); //-reg table val
lua_pushvalue(L, vpos);
lua_pushboolean(L, 1);
lua_rawset(L, -3);
lua_pop(L, 1); //-reg table
int len = 0;
bool query = false;
bool array = true;
if (luaL_getmetafield(L, vpos, "__query")) {
lua_pop(L, 1);
query = true;
array = false;
}
if (array) {
for (lua_pushnil(L); lua_next(L, vpos); lua_pop(L, 1)) {
++len;
if ((lua_type(L, -2) != LUA_TNUMBER) || (lua_tointeger(L, -2) != len)) {
lua_pop(L, 2);
array = false;
break;
}
}
}
if (array) {
if (key) bson_append_start_array(bs, key);
int i;
for (i = 1; i <= len; ++i, lua_pop(L, 1)) {
lua_rawgeti(L, vpos, i);
bson_numstrn(nbuf, TCNUMBUFSIZ, (int64_t) i);
lua_val_to_bson(L, nbuf, -1, bs, tref);
}
if (key) bson_append_finish_array(bs);
} else if (query) { //special query builder case
//oarr format:
//{ {fname1, v1, v2...}, {fname2, v21, v22,..}, ... }
//where: vN: {op, val} OR {val} with '__bval' metafield
//Eg: {fname : {$inc : {...}, $dec : {...}}} -> {fname, {$inc, {}}, {$dec, {}}}
lua_getfield(L, vpos, "_oarr"); //+oarr
if (!lua_istable(L, -1)) { //it is not array
lua_pop(L, 1);
break;
}
if (key) bson_append_start_object(bs, key);
//iterate over _oarr
int ipos = lua_gettop(L);
size_t ilen = lua_objlen(L, ipos);
lua_checkstack(L, 2);
size_t i;
for (i = 1; i <= ilen; ++i, lua_pop(L, 1)) {
lua_rawgeti(L, ipos, i);
//gettop == 3
if (!lua_istable(L, -1)) continue;
char *fname = NULL;
int jpos = lua_gettop(L);
size_t jlen = lua_objlen(L, jpos);
lua_checkstack(L, 3);
bool wrapped = false;
size_t j;
for (j = 1; j <= jlen; ++j, lua_pop(L, 1)) {
lua_rawgeti(L, jpos, j);
if (j == 1) {
fname = strdup(lua_tostring(L, -1));
continue;
}
if (!fname || !lua_istable(L, -1)) { //invalid state
lua_pop(L, 1); //pop val
break;
}
int vblkpos = lua_gettop(L);
if (j == 2 && luaL_getmetafield(L, -1, "__bval")) { //{val} single value +metafield
lua_pop(L, 1); //-metafield
lua_rawgeti(L, vblkpos, 1); //+val
lua_val_to_bson(L, fname, lua_gettop(L), bs, tref);
lua_pop(L, 2); //-val -lua_rawgeti
break; //Terminate due single val
} else { //{op, val} value
if (!wrapped) {
bson_append_start_object(bs, fname);
wrapped = true;
}
lua_rawgeti(L, vblkpos, 1); //+op
const char *op = lua_tostring(L, -1);
if (op) {
lua_rawgeti(L, vblkpos, 2); //+val
lua_val_to_bson(L, op, lua_gettop(L), bs, tref);
lua_pop(L, 1); //-val
}
lua_pop(L, 1); //-op
}
}
if (wrapped) {
bson_append_finish_object(bs);
}
if (fname) {
free(fname);
fname = NULL;
}
}
if (key) bson_append_finish_object(bs);
lua_pop(L, 1); //-oarr
} else {
if (key) bson_append_start_object(bs, key);
TCLIST *keys = tclistnew();
//we need to sort keys due to unordered nature of lua tables
for (lua_pushnil(L); lua_next(L, vpos);) {
lua_pop(L, 1); //-val
size_t ksize = 0;
int ktype = lua_type(L, -1);
if (ktype == LUA_TSTRING) { //accept only string keys
const char* key = lua_tolstring(L, -1, &ksize);
tclistpush(keys, key, ksize);
}
}
tclistsort(keys);
int i;
for (i = 0; i < TCLISTNUM(keys); ++i) {
int vkeysz = TCLISTVALSIZ(keys, i);
const char *vkey = TCLISTVALPTR(keys, i);
lua_pushlstring(L, vkey, vkeysz);
lua_rawget(L, vpos); //+val
if (key == NULL && lua_type(L, -1) == LUA_TSTRING &&
vkeysz == JDBIDKEYNAMEL && !strcmp(JDBIDKEYNAME, vkey)) { //root level OID as string
//pack OID as type table
lua_push_bsontype_table(L, BSON_OID); //+type table
lua_pushvalue(L, -2); //dup oid(val) on stack
lua_rawseti(L, -2, 1); //pop oid val
if (ejdbisvalidoidstr(lua_tostring(L, -2))) {
lua_val_to_bson(L, vkey, lua_gettop(L), bs, tref);
} else {
luaL_error(L, "OID _id='%s' is not valid", lua_tostring(L, -2));
}
lua_pop(L, 1); //-type table
} else {
lua_val_to_bson(L, vkey, lua_gettop(L), bs, tref);
}
lua_pop(L, 1); //-val
}
tclistdel(keys);
if (key) bson_append_finish_object(bs);
}
} else { //metafield __bsontype on top
int bson_type = lua_tointeger(L, -1);
if (!key && bson_type != BSON_OBJECT && bson_type != BSON_ARRAY) {
lua_pop(L, 1);
luaL_error(L, "Invalid object structure");
}
lua_pop(L, 1); //-metafield __bsontype
lua_rawgeti(L, -1, 1); //get first value
switch (bson_type) {
case BSON_OID:
{
const char* boid = lua_tostring(L, -1);
if (boid && strlen(boid) == 24) {
bson_oid_t oid;
bson_oid_from_string(&oid, boid);
bson_append_oid(bs, key, &oid);
}
break;
}
case BSON_DATE:
bson_append_date(bs, key, (bson_date_t) lua_tonumber(L, -1));
break;
case BSON_REGEX:
{
const char* regex = lua_tostring(L, -1);
lua_rawgeti(L, -2, 2); // re opts
const char* options = lua_tostring(L, -1);
if (regex && options) {
bson_append_regex(bs, key, regex, options);
}
lua_pop(L, 1);
break;
}
case BSON_BINDATA:
{
size_t len;
const char* cbuf = lua_tolstring(L, -1, &len);
bson_append_binary(bs, key, BSON_BIN_BINARY, cbuf, len);
break;
}
case BSON_NULL:
bson_append_null(bs, key);
break;
case BSON_UNDEFINED:
bson_append_undefined(bs, key);
break;
case BSON_OBJECT:
if (key) bson_append_start_object(bs, key);
lua_val_to_bson(L, NULL, vpos, bs, tref);
if (key) bson_append_finish_object(bs);
break;
case BSON_ARRAY:
if (key) bson_append_start_array(bs, key);
lua_val_to_bson(L, NULL, vpos, bs, tref);
if (key) bson_append_finish_array(bs);
break;
case BSON_DOUBLE:
bson_append_double(bs, key, (double) lua_tonumber(L, -1));
break;
case BSON_INT:
bson_append_int(bs, key, (int32_t) lua_tonumber(L, -1));
break;
case BSON_LONG:
bson_append_long(bs, key, (int64_t) lua_tonumber(L, -1));
break;
case BSON_BOOL:
bson_append_bool(bs, key, lua_toboolean(L, -1));
break;
default:
break;
}
lua_pop(L, 1); //-1 first value
}
break;
}
case LUA_TNIL:
bson_append_null(bs, key);
break;
case LUA_TNUMBER:
{
lua_Number numval = lua_tonumber(L, vpos);
if (numval == floor(numval)) {
int64_t iv = (int64_t) numval;
if (-(1LL << 31) <= iv && iv <= (1LL << 31)) {
bson_append_int(bs, key, iv);
} else {
bson_append_long(bs, key, iv);
}
} else {
bson_append_double(bs, key, numval);
}
break;
}
case LUA_TBOOLEAN:
bson_append_bool(bs, key, lua_toboolean(L, vpos));
break;
case LUA_TSTRING:
bson_append_string(bs, key, lua_tostring(L, vpos));
break;
}
}
void MongodbObject::FinishArray()
{
BSON_VERIFY(bson_append_finish_array(objectData->object));
}
void testBuildQuery1() {
CU_ASSERT_PTR_NOT_NULL_FATAL(jb);
/*
Query = {
"name" : Петров Петр,
"age" : 33,
"family" : {
"wife" : {
"name" : "Jeniffer",
"age" : {"$gt" : 25},
"phone" : "444-111"
},
"children" : [
{
"name" : "Dasha",
"age" : {"$in" : [1, 4, 10]}
}
]
}
*/
bson q1;
bson_init_as_query(&q1);
bson_append_string(&q1, "name", "Петров Петр");
bson_append_int(&q1, "age", 33);
bson q1family_wife;
bson_init_as_query(&q1family_wife);
bson_append_string(&q1family_wife, "name", "Jeniffer");
bson_append_start_object(&q1family_wife, "age");
bson_append_int(&q1family_wife, "$gt", 25);
bson_append_finish_object(&q1family_wife);
bson_append_string(&q1family_wife, "phone", "444-111");
bson_finish(&q1family_wife);
bson q1family_child;
bson_init_as_query(&q1family_child);
bson_append_string(&q1family_child, "name", "Dasha");
//"age" : {"$in" : [1, 4, 10]}
bson q1family_child_age_IN;
bson_init_as_query(&q1family_child_age_IN);
bson_append_start_array(&q1family_child_age_IN, "$in");
bson_append_int(&q1family_child_age_IN, "0", 1);
bson_append_int(&q1family_child_age_IN, "1", 4);
bson_append_int(&q1family_child_age_IN, "2", 10);
bson_append_finish_array(&q1family_child_age_IN);
bson_finish(&q1family_child_age_IN);
bson_append_bson(&q1family_child, "age", &q1family_child_age_IN);
bson_finish(&q1family_child);
bson q1family;
bson_init_as_query(&q1family);
bson_append_bson(&q1family, "wife", &q1family_wife);
bson_append_start_array(&q1family, "children");
bson_append_bson(&q1family, "0", &q1family_child);
bson_append_finish_array(&q1family);
bson_finish(&q1family);
bson_append_bson(&q1, "family", &q1family);
bson_finish(&q1);
CU_ASSERT_FALSE_FATAL(q1.err);
CU_ASSERT_FALSE_FATAL(q1family.err);
CU_ASSERT_FALSE_FATAL(q1family_wife.err);
CU_ASSERT_FALSE_FATAL(q1family_child.err);
CU_ASSERT_FALSE_FATAL(q1family_child_age_IN.err);
EJQ *ejq = ejdbcreatequery(jb, &q1, NULL, 0, NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(ejq);
bson_destroy(&q1);
bson_destroy(&q1family);
bson_destroy(&q1family_wife);
bson_destroy(&q1family_child);
bson_destroy(&q1family_child_age_IN);
CU_ASSERT_PTR_NOT_NULL_FATAL(ejq->qobjlist);
TCLIST *qmap = ejq->qobjlist;
CU_ASSERT_EQUAL(qmap->num, 7);
for (int i = 0; i < TCLISTNUM(qmap); ++i) {
const EJQF *qf = TCLISTVALPTR(qmap, i);
CU_ASSERT_PTR_NOT_NULL_FATAL(qf);
const char* key = qf->fpath;
switch (i) {
case 0:
{
CU_ASSERT_STRING_EQUAL(key, "name");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_STRING_EQUAL(qf->expr, "Петров Петр");
CU_ASSERT_EQUAL(qf->tcop, TDBQCSTREQ);
break;
}
case 1:
{
CU_ASSERT_STRING_EQUAL(key, "age");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_STRING_EQUAL(qf->expr, "33");
CU_ASSERT_EQUAL(qf->tcop, TDBQCNUMEQ);
break;
}
case 2:
{
CU_ASSERT_STRING_EQUAL(key, "family.wife.name");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_STRING_EQUAL(qf->expr, "Jeniffer");
CU_ASSERT_EQUAL(qf->tcop, TDBQCSTREQ);
break;
}
case 3:
{
CU_ASSERT_STRING_EQUAL(key, "family.wife.age");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_STRING_EQUAL(qf->expr, "25");
CU_ASSERT_EQUAL(qf->tcop, TDBQCNUMGT);
break;
}
case 4:
{
CU_ASSERT_STRING_EQUAL(key, "family.wife.phone");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_STRING_EQUAL(qf->expr, "444-111");
CU_ASSERT_EQUAL(qf->tcop, TDBQCSTREQ);
break;
}
case 5:
{
CU_ASSERT_STRING_EQUAL(key, "family.children.0.name");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_STRING_EQUAL(qf->expr, "Dasha");
CU_ASSERT_EQUAL(qf->tcop, TDBQCSTREQ);
break;
}
case 6:
{
CU_ASSERT_STRING_EQUAL(key, "family.children.0.age");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_EQUAL(qf->ftype, BSON_ARRAY);
TCLIST *al = tclistload(qf->expr, qf->exprsz);
char* als = tcstrjoin(al, ',');
CU_ASSERT_STRING_EQUAL(als, "1,4,10");
TCFREE(als);
tclistdel(al);
CU_ASSERT_EQUAL(qf->tcop, TDBQCNUMOREQ);
break;
}
}
}
ejdbquerydel(ejq);
}
void log_explain(uint32_t index)
{
bson b;
char argidx[4];
bson_init_size(&b, mem_suggested_size(1024));
bson_append_int(&b, "I", index);
bson_append_string(&b, "name", sig_apiname(index));
bson_append_string(&b, "type", "info");
bson_append_string(&b, "category", sig_category(index));
bson_append_start_array(&b, "args");
bson_append_string(&b, "0", "is_success");
bson_append_string(&b, "1", "retval");
const char *fmt = sig_paramtypes(index);
for (uint32_t argnum = 2; *fmt != 0; argnum++, fmt++) {
ultostr(argnum, argidx, 10);
// Ignore buffers, they are sent over separately.
if(*fmt == '!') {
argnum--;
fmt++;
continue;
}
const char *argname = sig_param_name(index, argnum-2);
// On certain formats, we need to tell cuckoo about them for
// nicer display / matching.
if(*fmt == 'p' || *fmt == 'P') {
bson_append_start_array(&b, argidx);
bson_append_string(&b, "0", argname);
bson_append_string(&b, "1", "p");
bson_append_finish_array(&b);
}
else {
bson_append_string(&b, argidx, argname);
}
}
bson_append_finish_array(&b);
bson_append_start_object(&b, "flags_value");
for (uint32_t idx = 0; sig_flag_name(index, idx) != NULL; idx++) {
const flag_repr_t *f = flag_value(sig_flag_value(index, idx));
bson_append_start_array(&b, sig_flag_name(index, idx));
for (uint32_t idx2 = 0; f->repr != NULL; idx2++, f++) {
ultostr(idx, argidx, 10);
bson_append_start_array(&b, argidx);
bson_append_int(&b, "0", f->value);
bson_append_string(&b, "1", f->repr);
bson_append_finish_array(&b);
}
bson_append_finish_array(&b);
}
bson_append_finish_object(&b);
bson_append_start_object(&b, "flags_bitmask");
for (uint32_t idx = 0; sig_flag_name(index, idx) != NULL; idx++) {
const flag_repr_t *f = flag_bitmask(sig_flag_value(index, idx));
bson_append_start_array(&b, sig_flag_name(index, idx));
for (uint32_t idx2 = 0; f->repr != NULL; idx2++, f++) {
ultostr(idx, argidx, 10);
bson_append_start_array(&b, argidx);
bson_append_int(&b, "0", f->value);
bson_append_string(&b, "1", f->repr);
bson_append_finish_array(&b);
}
bson_append_finish_array(&b);
}
bson_append_finish_object(&b);
bson_finish(&b);
log_raw(bson_data(&b), bson_size(&b));
bson_destroy(&b);
}
static switch_status_t my_on_reporting(switch_core_session_t *session)
{
switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_event_header_t *hi;
switch_caller_profile_t *caller_profile;
switch_hold_record_t *hold_record;
switch_app_log_t *app_log;
bson cdr;
int is_b;
int bson_idx, callflow_idx;
char idx_buffer[4];
char *tmp;
if (globals.shutdown) {
return SWITCH_STATUS_SUCCESS;
}
is_b = channel && switch_channel_get_originator_caller_profile(channel);
if (!globals.log_b && is_b) {
const char *force_cdr = switch_channel_get_variable(channel, SWITCH_FORCE_PROCESS_CDR_VARIABLE);
if (!switch_true(force_cdr)) {
return SWITCH_STATUS_SUCCESS;
}
}
bson_init(&cdr);
/* Channel data */
bson_append_start_object(&cdr, "channel_data");
bson_append_string(&cdr, "state", switch_channel_state_name(switch_channel_get_state(channel)));
bson_append_string(&cdr, "direction", switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");
bson_append_int(&cdr, "state_number", switch_channel_get_state(channel));
if ((tmp = switch_channel_get_flag_string(channel))) {
bson_append_string(&cdr, "flags", tmp);
free(tmp);
}
if ((tmp = switch_channel_get_cap_string(channel))) {
bson_append_string(&cdr, "caps", tmp);
free(tmp);
}
bson_append_finish_object(&cdr); /* channel_data */
/* Channel variables */
bson_append_start_object(&cdr, "variables");
if ((hi = switch_channel_variable_first(channel))) {
for (; hi; hi = hi->next) {
if (!zstr(hi->name) && !zstr(hi->value)) {
bson_append_string(&cdr, hi->name, hi->value);
}
}
switch_channel_variable_last(channel);
}
bson_append_finish_object(&cdr); /* variables */
/* App log */
if ((app_log = switch_core_session_get_app_log(session))) {
switch_app_log_t *ap;
bson_append_start_array(&cdr, "app_log");
for (ap = app_log, bson_idx = 0; ap; ap = ap->next, bson_idx++) {
switch_snprintf(idx_buffer, sizeof(idx_buffer), "%d", bson_idx);
bson_append_start_object(&cdr, idx_buffer);
bson_append_string(&cdr, "app_name", ap->app);
bson_append_string(&cdr, "app_data", switch_str_nil(ap->arg));
bson_append_long(&cdr, "app_stamp", ap->stamp);
bson_append_finish_object(&cdr); /* application */
}
bson_append_finish_array(&cdr); /* app_log */
}
/* Hold */
if ((hold_record = switch_channel_get_hold_record(channel))) {
switch_hold_record_t *hr;
bson_append_start_array(&cdr, "hold_record");
for (hr = hold_record, bson_idx = 0; hr; hr = hr->next, bson_idx++) {
switch_snprintf(idx_buffer, sizeof(idx_buffer), "%d", bson_idx);
bson_append_start_object(&cdr, idx_buffer);
bson_append_long(&cdr, "on", hr->on);
bson_append_long(&cdr, "off", hr->off);
if (hr->uuid) {
bson_append_string(&cdr, "bridged_to", hr->uuid);
}
bson_append_finish_object(&cdr);
}
bson_append_finish_array(&cdr); /* hold_record */
}
/* Callflow */
caller_profile = switch_channel_get_caller_profile(channel);
/* Start callflow array */
bson_append_start_array(&cdr, "callflow");
callflow_idx = 0;
while (caller_profile) {
snprintf(idx_buffer, sizeof(idx_buffer), "%d", callflow_idx);
bson_append_start_object(&cdr, idx_buffer);
if (!zstr(caller_profile->dialplan)) {
bson_append_string(&cdr, "dialplan", caller_profile->dialplan);
}
if (!zstr(caller_profile->profile_index)) {
bson_append_string(&cdr, "profile_index", caller_profile->profile_index);
}
if (caller_profile->caller_extension) {
switch_caller_application_t *ap;
bson_append_start_object(&cdr, "extension");
bson_append_string(&cdr, "name", switch_str_nil(caller_profile->caller_extension->extension_name));
bson_append_string(&cdr, "number", switch_str_nil(caller_profile->caller_extension->extension_number));
if (caller_profile->caller_extension->current_application) {
bson_append_string(&cdr, "current_app", caller_profile->caller_extension->current_application->application_name);
}
for (ap = caller_profile->caller_extension->applications; ap; ap = ap->next) {
bson_append_start_object(&cdr, "application");
if (ap == caller_profile->caller_extension->current_application) {
bson_append_bool(&cdr, "last_executed", 1);
}
bson_append_string(&cdr, "app_name", ap->application_name);
bson_append_string(&cdr, "app_data", switch_str_nil(ap->application_data));
bson_append_finish_object(&cdr);
}
if (caller_profile->caller_extension->children) {
switch_caller_profile_t *cp = NULL;
for (cp = caller_profile->caller_extension->children; cp; cp = cp->next) {
if (!cp->caller_extension) {
continue;
}
bson_append_start_object(&cdr, "sub_extensions");
bson_append_start_object(&cdr, "extension");
bson_append_string(&cdr, "name", cp->caller_extension->extension_name);
bson_append_string(&cdr, "number", cp->caller_extension->extension_number);
bson_append_string(&cdr, "dialplan", cp->dialplan);
if (cp->caller_extension->current_application) {
bson_append_string(&cdr, "current_app", cp->caller_extension->current_application->application_name);
}
for (ap = cp->caller_extension->applications; ap; ap = ap->next) {
bson_append_start_object(&cdr, "application");
if (ap == cp->caller_extension->current_application) {
bson_append_bool(&cdr, "last_executed", 1);
}
bson_append_string(&cdr, "app_name", ap->application_name);
bson_append_string(&cdr, "app_data", switch_str_nil(ap->application_data));
bson_append_finish_object(&cdr);
}
bson_append_finish_object(&cdr); /* extension */
bson_append_finish_object(&cdr); /* sub_extensions */
}
}
bson_append_finish_object(&cdr); /* extension */
}
bson_append_start_object(&cdr, "caller_profile");
set_bson_profile_data(&cdr, caller_profile);
if (caller_profile->origination_caller_profile) {
switch_caller_profile_t *cp = NULL;
/* Start origination array */
bson_append_start_array(&cdr, "origination");
for (cp = caller_profile->origination_caller_profile, bson_idx = 0; cp; cp = cp->next, bson_idx++) {
snprintf(idx_buffer, sizeof(idx_buffer), "%d", bson_idx);
bson_append_start_object(&cdr, idx_buffer);
set_bson_profile_data(&cdr, cp);
bson_append_finish_object(&cdr);
}
bson_append_finish_object(&cdr); /* origination */
}
if (caller_profile->originator_caller_profile) {
switch_caller_profile_t *cp = NULL;
/* Start originator array */
bson_append_start_array(&cdr, "originator");
for (cp = caller_profile->originator_caller_profile, bson_idx = 0; cp; cp = cp->next, bson_idx++) {
snprintf(idx_buffer, sizeof(idx_buffer), "%d", bson_idx);
bson_append_start_object(&cdr, idx_buffer);
set_bson_profile_data(&cdr, cp);
bson_append_finish_object(&cdr);
}
bson_append_finish_object(&cdr); /* originator */
}
if (caller_profile->originatee_caller_profile) {
switch_caller_profile_t *cp = NULL;
/* Start originatee array */
bson_append_start_array(&cdr, "originatee");
for (cp = caller_profile->originatee_caller_profile, bson_idx = 0; cp; cp = cp->next, bson_idx++) {
snprintf(idx_buffer, sizeof(idx_buffer), "%d", bson_idx);
bson_append_start_object(&cdr, idx_buffer);
set_bson_profile_data(&cdr, cp);
bson_append_finish_object(&cdr);
}
bson_append_finish_object(&cdr); /* originatee */
}
bson_append_finish_object(&cdr); /* caller_profile */
/* Timestamps */
if (caller_profile->times) {
bson_append_start_object(&cdr, "times");
/* Insert timestamps as long ints (microseconds) to preserve accuracy */
bson_append_long(&cdr, "created_time", caller_profile->times->created);
bson_append_long(&cdr, "profile_created_time", caller_profile->times->profile_created);
bson_append_long(&cdr, "progress_time", caller_profile->times->progress);
bson_append_long(&cdr, "progress_media_time", caller_profile->times->progress_media);
bson_append_long(&cdr, "answered_time", caller_profile->times->answered);
bson_append_long(&cdr, "bridged_time", caller_profile->times->bridged);
bson_append_long(&cdr, "last_hold_time", caller_profile->times->last_hold);
bson_append_long(&cdr, "hold_accum_time", caller_profile->times->hold_accum);
bson_append_long(&cdr, "hangup_time", caller_profile->times->hungup);
bson_append_long(&cdr, "resurrect_time", caller_profile->times->resurrected);
bson_append_long(&cdr, "transfer_time", caller_profile->times->transferred);
bson_append_finish_object(&cdr); /* times */
}
bson_append_finish_object(&cdr); /* callflow */
caller_profile = caller_profile->next;
callflow_idx++;
}
bson_append_finish_array(&cdr);
bson_finish(&cdr);
switch_mutex_lock(globals.mongo_mutex);
if (mongo_insert(globals.mongo_conn, globals.mongo_namespace, &cdr, NULL) != MONGO_OK) {
if (globals.mongo_conn->err == MONGO_IO_ERROR) {
mongo_error_t db_status;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "MongoDB connection failed; attempting reconnect...\n");
db_status = mongo_reconnect(globals.mongo_conn);
if (db_status != MONGO_OK) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "MongoDB reconnect failed with error code %d\n", db_status);
status = SWITCH_STATUS_FALSE;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "MongoDB connection re-established.\n");
/* Re-authentication is necessary after a reconnect */
if (globals.mongo_username && globals.mongo_password) {
status = cdr_mongo_authenticate();
}
if (mongo_insert(globals.mongo_conn, globals.mongo_namespace, &cdr, NULL) != MONGO_OK) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "mongo_insert: %s (error code %d)\n", globals.mongo_conn->errstr, globals.mongo_conn->err);
status = SWITCH_STATUS_FALSE;
}
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "mongo_insert: %s (error code %d)\n", globals.mongo_conn->errstr, globals.mongo_conn->err);
status = SWITCH_STATUS_FALSE;
}
}
switch_mutex_unlock(globals.mongo_mutex);
bson_destroy(&cdr);
return status;
}
/*
* Functions
*/
static bson *wm_create_bson (const data_set_t *ds, /* {{{ */
const value_list_t *vl,
_Bool store_rates)
{
bson *ret;
gauge_t *rates;
ret = bson_alloc (); /* matched by bson_dealloc() */
if (ret == NULL)
{
ERROR ("write_mongodb plugin: bson_create failed.");
return (NULL);
}
if (store_rates)
{
rates = uc_get_rate (ds, vl);
if (rates == NULL)
{
ERROR ("write_mongodb plugin: uc_get_rate() failed.");
return (NULL);
}
}
else
{
rates = NULL;
}
bson_init (ret); /* matched by bson_destroy() */
bson_append_date (ret, "time", (bson_date_t) CDTIME_T_TO_MS (vl->time));
bson_append_string (ret, "host", vl->host);
bson_append_string (ret, "plugin", vl->plugin);
bson_append_string (ret, "plugin_instance", vl->plugin_instance);
bson_append_string (ret, "type", vl->type);
bson_append_string (ret, "type_instance", vl->type_instance);
bson_append_start_array (ret, "values"); /* {{{ */
for (int i = 0; i < ds->ds_num; i++)
{
char key[16];
ssnprintf (key, sizeof (key), "%i", i);
if (ds->ds[i].type == DS_TYPE_GAUGE)
bson_append_double(ret, key, vl->values[i].gauge);
else if (store_rates)
bson_append_double(ret, key, (double) rates[i]);
else if (ds->ds[i].type == DS_TYPE_COUNTER)
bson_append_long(ret, key, vl->values[i].counter);
else if (ds->ds[i].type == DS_TYPE_DERIVE)
bson_append_long(ret, key, vl->values[i].derive);
else if (ds->ds[i].type == DS_TYPE_ABSOLUTE)
bson_append_long(ret, key, vl->values[i].absolute);
else
assert (23 == 42);
}
bson_append_finish_array (ret); /* }}} values */
bson_append_start_array (ret, "dstypes"); /* {{{ */
for (int i = 0; i < ds->ds_num; i++)
{
char key[16];
ssnprintf (key, sizeof (key), "%i", i);
if (store_rates)
bson_append_string (ret, key, "gauge");
else
bson_append_string (ret, key, DS_TYPE_TO_STRING (ds->ds[i].type));
}
bson_append_finish_array (ret); /* }}} dstypes */
bson_append_start_array (ret, "dsnames"); /* {{{ */
for (int i = 0; i < ds->ds_num; i++)
{
char key[16];
ssnprintf (key, sizeof (key), "%i", i);
bson_append_string (ret, key, ds->ds[i].name);
}
bson_append_finish_array (ret); /* }}} dsnames */
bson_finish (ret);
sfree (rates);
return (ret);
} /* }}} bson *wm_create_bson */
void testBSONExportImport2(void) {
EJDB *jb = ejdbnew();
CU_ASSERT_TRUE_FATAL(ejdbopen(jb, "dbt4_export", JBOWRITER | JBOCREAT | JBOTRUNC));
EJCOLL *coll = ejdbcreatecoll(jb, "col1", NULL);
if (!coll) {
eprint(jb, __LINE__, "testBSONExportImport2");
}
CU_ASSERT_TRUE(coll != NULL);
bson_oid_t oid;
const char *log = NULL;
bson bv1;
bson_init(&bv1);
bson_append_int(&bv1, "a", 1);
bson_append_string(&bv1, "c", "d");
bson_finish(&bv1);
ejdbsavebson(coll, &bv1, &oid);
bson_destroy(&bv1);
EJCOLLOPTS copts = {0};
copts.large = true;
copts.records = 200000;
coll = ejdbcreatecoll(jb, "col2", &copts);
if (!coll) {
eprint(jb, __LINE__, "testBSONExportImport2");
}
CU_ASSERT_TRUE(coll != NULL);
CU_ASSERT_TRUE(ejdbsetindex(coll, "f", JBIDXSTR | JBIDXNUM));
bson_init(&bv1);
bson_append_int(&bv1, "e", 1);
bson_append_string(&bv1, "f", "g");
bson_finish(&bv1);
ejdbsavebson(coll, &bv1, &oid);
bson_destroy(&bv1);
bson_init(&bv1);
bson_append_int(&bv1, "e", 2);
bson_append_string(&bv1, "f", "g2");
bson_finish(&bv1);
ejdbsavebson(coll, &bv1, &oid);
bson_destroy(&bv1);
bson cmd;
bson_init(&cmd);
bson_append_start_object(&cmd, "export");
bson_append_string(&cmd, "path", "testBSONExportImport2");
bson_append_start_array(&cmd, "cnames");
bson_append_string(&cmd, "0", "col1");
bson_append_string(&cmd, "1", "col2");
bson_append_finish_array(&cmd);
bson_append_finish_object(&cmd);
bson_finish(&cmd);
bson *bret = ejdbcommand(jb, &cmd);
CU_ASSERT_PTR_NOT_NULL_FATAL(bret);
bson_destroy(&cmd);
bson_iterator it;
bson_iterator_init(&it, bret);
CU_ASSERT_TRUE(bson_find_fieldpath_value("error", &it) == BSON_EOO);
bson_iterator_init(&it, bret);
CU_ASSERT_TRUE(bson_compare_long(0, bson_data(bret), "errorCode") == 0);
bson_iterator_init(&it, bret);
CU_ASSERT_TRUE(bson_find_fieldpath_value("log", &it) == BSON_STRING);
bson_del(bret);
bson *ometa = ejdbmeta(jb);
CU_ASSERT_TRUE_FATAL(ometa != NULL);
ejdbclose(jb);
ejdbdel(jb);
//Restore data:
jb = ejdbnew();
CU_ASSERT_TRUE_FATAL(ejdbopen(jb, "dbt4_export", JBOWRITER | JBOCREAT));
coll = ejdbgetcoll(jb, "col1");
CU_ASSERT_PTR_NOT_NULL_FATAL(coll);
bson_init(&bv1);
bson_append_int(&bv1, "e", 2);
bson_finish(&bv1);
CU_ASSERT_TRUE(ejdbsavebson(coll, &bv1, &oid));
bson_destroy(&bv1);
bson_init(&cmd);
bson_append_start_object(&cmd, "import");
bson_append_string(&cmd, "path", "testBSONExportImport2");
bson_append_int(&cmd, "mode", JBIMPORTREPLACE);
bson_append_start_array(&cmd, "cnames");
bson_append_string(&cmd, "0", "col1");
bson_append_string(&cmd, "1", "col2");
bson_append_finish_array(&cmd);
bson_append_finish_object(&cmd);
bson_finish(&cmd);
bret = ejdbcommand(jb, &cmd);
CU_ASSERT_PTR_NOT_NULL_FATAL(bret);
bson_destroy(&cmd);
bson_iterator_init(&it, bret);
CU_ASSERT_TRUE_FATAL(bson_find_fieldpath_value("log", &it) == BSON_STRING);
log = bson_iterator_string(&it);
CU_ASSERT_PTR_NOT_NULL(strstr(log, "Replacing all data in 'col1'"));
CU_ASSERT_PTR_NOT_NULL(strstr(log, "1 objects imported into 'col1'"));
CU_ASSERT_PTR_NOT_NULL(strstr(log, "2 objects imported into 'col2'"));
bson_del(bret);
log = NULL;
bson *nmeta = ejdbmeta(jb);
CU_ASSERT_TRUE_FATAL(nmeta != NULL);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.0.name", strlen("collections.0.name")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.0.records", strlen("collections.0.records")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.name", strlen("collections.1.name")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.records", strlen("collections.1.records")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.options.buckets", strlen("collections.1.options.buckets")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.options.large", strlen("collections.1.options.large")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.0.field", strlen("collections.1.indexes.0.field")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.0.type", strlen("collections.1.indexes.0.type")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.0.records", strlen("collections.1.indexes.0.records")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.1.field", strlen("collections.1.indexes.1.field")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.1.type", strlen("collections.1.indexes.1.type")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.1.records", strlen("collections.1.indexes.1.records")) == 0);
ejdbclose(jb);
ejdbdel(jb);
jb = ejdbnew();
CU_ASSERT_TRUE_FATAL(ejdbopen(jb, "dbt4_export", JBOWRITER | JBOCREAT | JBOTRUNC));
coll = ejdbcreatecoll(jb, "col1", NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(coll);
bson_init(&bv1);
bson_append_int(&bv1, "e", 2);
bson_finish(&bv1);
CU_ASSERT_TRUE(ejdbsavebson(coll, &bv1, &oid));
EJQ *q = ejdbcreatequery(jb, &bv1, NULL, 0, NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(q);
uint32_t count = 0;
ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL);
CU_ASSERT_EQUAL(count, 1);
bson_init(&cmd);
bson_append_start_object(&cmd, "import");
bson_append_string(&cmd, "path", "testBSONExportImport2");
bson_append_int(&cmd, "mode", JBIMPORTUPDATE);
bson_append_finish_object(&cmd);
bson_finish(&cmd);
bret = ejdbcommand(jb, &cmd);
CU_ASSERT_PTR_NOT_NULL_FATAL(bret);
bson_destroy(&cmd);
bson_del(bret);
coll = ejdbcreatecoll(jb, "col1", NULL);
ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL);
CU_ASSERT_EQUAL(count, 1);
ejdbquerydel(q);
bson_destroy(&bv1);
ejdbclose(jb);
ejdbdel(jb);
bson_del(ometa);
bson_del(nmeta);
}
/*
* simplified FSM to parse BCON structure, uses stacks for sub-documents and sub-arrays
*/
static bcon_error_t bson_append_bcon_with_state(bson *b, const bcon *bc, bcon_state_t start_state) {
bcon_error_t ret = BCON_OK;
bcon_state_t state = start_state;
char *key = 0;
char *typespec = 0;
unsigned char doc_stack[DOC_STACK_SIZE];
size_t doc_stack_pointer = 0;
size_t array_index = 0;
size_t array_index_stack[ARRAY_INDEX_STACK_SIZE];
size_t array_index_stack_pointer = 0;
char array_index_buffer[ARRAY_INDEX_BUFFER_SIZE]; /* max BSON size */
int end_of_data;
const bcon *bcp;
for (end_of_data = 0, bcp = bc; ret == BCON_OK && !end_of_data; bcp++) {
bcon bci = *bcp;
char *s = bci.s;
switch (state) {
case State_Element:
switch (bcon_token(s)) {
case Token_CloseBrace:
bson_append_finish_object( b );
DOC_POP_STATE; /* state = ...; */
break;
case Token_End:
end_of_data = 1;
break;
default:
key = s;
state = State_DocSpecValue;
break;
}
break;
case State_DocSpecValue:
switch (bcon_token(s)) {
case Token_Typespec:
typespec = s;
state = State_DocValue;
break;
case Token_OpenBrace:
bson_append_start_object( b, key );
DOC_PUSH_STATE(State_Element);
state = State_Element;
break;
case Token_OpenBracket:
bson_append_start_array( b, key );
ARRAY_PUSH_RESET_INDEX_STATE(State_Element);
state = State_ArraySpecValue;
break;
case Token_End:
end_of_data = 1;
break;
default:
ret = bson_bcon_key_value(b, key, typespec, bci);
state = State_Element;
break;
}
break;
case State_DocValue:
ret = bson_bcon_key_value(b, key, typespec, bci);
state = State_Element;
typespec = 0;
break;
case State_ArraySpecValue:
switch (bcon_token(s)) {
case Token_Typespec:
typespec = s;
state = State_ArrayValue;
break;
case Token_OpenBrace:
key = ARRAY_KEY_STRING(array_index++);
bson_append_start_object( b, key );
DOC_PUSH_STATE(State_ArraySpecValue);
state = State_Element;
break;
case Token_OpenBracket:
key = ARRAY_KEY_STRING(array_index++);
bson_append_start_array( b, key );
ARRAY_PUSH_RESET_INDEX_STATE(State_ArraySpecValue);
/* state = State_ArraySpecValue; */
break;
case Token_CloseBracket:
bson_append_finish_array( b );
ARRAY_POP_INDEX_STATE; /* state = ...; */
break;
case Token_End:
end_of_data = 1;
break;
default:
key = ARRAY_KEY_STRING(array_index++);
ret = bson_bcon_key_value(b, key, typespec, bci);
/* state = State_ArraySpecValue; */
break;
}
break;
case State_ArrayValue:
key = ARRAY_KEY_STRING(array_index++);
ret = bson_bcon_key_value(b, key, typespec, bci);
state = State_ArraySpecValue;
typespec = 0;
break;
default: assert(NOT_REACHED); break;
}
}
return state == start_state ? BCON_OK : BCON_DOCUMENT_INCOMPLETE;
}
void testCheckDuplicates(void) {
bson bs, bs2;
bson_iterator it;
bson_type bt;
bson_init(&bs);
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "b", 2);
bson_append_null(&bs, "c");
bson_append_start_object(&bs, "d");
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "e", 0);
bson_append_int(&bs, "d", 1);
bson_append_finish_object(&bs);
bson_finish(&bs);
CU_ASSERT_FALSE_FATAL(bs.err);
CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs));
bson_destroy(&bs);
bson_init(&bs);
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "b", 2);
bson_append_null(&bs, "c");
bson_append_start_object(&bs, "d");
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "e", 0);
bson_append_int(&bs, "e", 1);
bson_append_finish_object(&bs);
bson_finish(&bs);
CU_ASSERT_FALSE_FATAL(bs.err);
CU_ASSERT_TRUE(bson_check_duplicate_keys(&bs));
bson_init(&bs2);
bson_fix_duplicate_keys(&bs, &bs2);
bson_finish(&bs2);
CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs2));
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("d.e", &it);
CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL(bson_iterator_int(&it), 1);
bson_destroy(&bs2);
bson_init(&bs);
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "b", 2);
bson_append_null(&bs, "c");
bson_append_start_object(&bs, "d");
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "e", 0);
bson_append_int(&bs, "d", 1);
bson_append_finish_object(&bs);
bson_append_start_array(&bs, "f");
bson_append_start_object(&bs, "0");
bson_append_string(&bs, "a", "a");
bson_append_string(&bs, "b", "b");
bson_append_int(&bs, "c", 1);
bson_append_finish_object(&bs);
bson_append_start_object(&bs, "1");
bson_append_string(&bs, "a", "a");
bson_append_string(&bs, "b", "b");
bson_append_int(&bs, "c", 1);
bson_append_finish_object(&bs);
bson_append_finish_array(&bs);
bson_finish(&bs);
CU_ASSERT_FALSE_FATAL(bs.err);
CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs));
bson_init(&bs);
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "b", 2);
bson_append_null(&bs, "c");
bson_append_start_object(&bs, "d");
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "e", 0);
bson_append_int(&bs, "d", 1);
bson_append_start_object(&bs, "q");
bson_append_int(&bs, "w", 0);
bson_append_finish_object(&bs);
bson_append_finish_object(&bs);
bson_append_start_array(&bs, "f");
bson_append_start_object(&bs, "0");
bson_append_string(&bs, "a", "a");
bson_append_string(&bs, "b", "b");
bson_append_int(&bs, "a", 1);
bson_append_finish_object(&bs);
bson_append_start_object(&bs, "1");
bson_append_string(&bs, "a", "a");
bson_append_string(&bs, "b", "b");
bson_append_int(&bs, "c", 1);
bson_append_finish_object(&bs);
bson_append_finish_array(&bs);
bson_append_start_object(&bs, "a");
bson_append_finish_object(&bs);
bson_append_start_object(&bs, "d");
bson_append_start_object(&bs, "q");
bson_append_int(&bs, "e", 1);
bson_append_finish_object(&bs);
bson_append_finish_object(&bs);
bson_finish(&bs);
CU_ASSERT_FALSE_FATAL(bs.err);
CU_ASSERT_TRUE(bson_check_duplicate_keys(&bs));
bson_init(&bs2);
bson_fix_duplicate_keys(&bs, &bs2);
bson_finish(&bs2);
CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs2));
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("f.0.a", &it);
CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL(bson_iterator_int(&it), 1);
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("f.1.a", &it);
CU_ASSERT_TRUE(BSON_IS_STRING_TYPE(bt));
CU_ASSERT_FALSE(strcmp(bson_iterator_string(&it), "a"));
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("a", &it);
CU_ASSERT_EQUAL(bt, BSON_OBJECT);
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("d.q.w", &it);
CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL(bson_iterator_int(&it), 0);
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("d.q.e", &it);
CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL(bson_iterator_int(&it), 1);
}
static bcon_error_t bson_bcon_key_value(bson *b, const char *key, const char *typespec, const bcon bci) {
bcon_error_t ret = BCON_OK;
bson_oid_t oid;
char ptype = typespec ? typespec[1] : '_';
char utype = typespec ? typespec[2] : '_';
switch (ptype) {
case '_': /* kv(b, key, utype, bci) */
switch (utype) {
case '_': /* fall through */
case 's': bson_append_string( b, key, bci.s ); break; /* common case */
case 'f': bson_append_double( b, key, bci.f ); break;
case 'D':
bson_append_start_object( b, key );
ret = bson_append_bcon( b, bci.D );
bson_append_finish_object( b );
break;
case 'A':
bson_append_start_array( b, key );
ret = bson_append_bcon_array( b, bci.A );
bson_append_finish_array( b );
break;
case 'o': if (*bci.o == '\0') bson_oid_gen( &oid ); else bson_oid_from_string( &oid, bci.o ); bson_append_oid( b, key, &oid ); break;
case 'b': bson_append_bool( b, key, bci.b ); break;
case 't': bson_append_time_t( b, key, bci.t ); break;
case 'v': bson_append_null( b, key ); break; /* void */
case 'x': bson_append_symbol( b, key, bci.x ); break;
case 'i': bson_append_int( b, key, bci.i ); break;
case 'l': bson_append_long( b, key, bci.l ); break;
default: printf("\nptype:'%c' utype:'%c'\n", ptype, utype); assert(NOT_REACHED); break;
}
break;
case 'R': /* krv(b, key, utype, bci) */
switch (utype) {
case 'f': bson_append_double( b, key, *bci.Rf ); break;
case 's': bson_append_string( b, key, bci.Rs ); break;
case 'D':
bson_append_start_object( b, key );
ret = bson_append_bcon( b, bci.RD );
bson_append_finish_object( b );
break;
case 'A':
bson_append_start_array( b, key );
ret = bson_append_bcon_array( b, bci.RA );
bson_append_finish_array( b );
break;
case 'o': if (*bci.o == '\0') bson_oid_gen( &oid ); else bson_oid_from_string( &oid, bci.o ); bson_append_oid( b, key, &oid ); break;
case 'b': bson_append_bool( b, key, *bci.Rb ); break;
case 't': bson_append_time_t( b, key, *bci.Rt ); break;
case 'x': bson_append_symbol( b, key, bci.Rx ); break;
case 'i': bson_append_int( b, key, *bci.Ri ); break;
case 'l': bson_append_long( b, key, *bci.Rl ); break;
default: printf("\nptype:'%c' utype:'%c'\n", ptype, utype); assert(NOT_REACHED); break;
}
break;
case 'P': /* kpv(b, key, utype, bci) */
if (*bci.Pv != 0) {
switch (utype) {
case 'f': bson_append_double( b, key, **bci.Pf ); break;
case 's': bson_append_string( b, key, *bci.Ps ); break;
case 'D':
bson_append_start_object( b, key );
ret = bson_append_bcon( b, *bci.PD );
bson_append_finish_object( b );
break;
case 'A':
bson_append_start_array( b, key );
ret = bson_append_bcon_array( b, *bci.PA );
bson_append_finish_array( b );
break;
case 'o': if (**bci.Po == '\0') bson_oid_gen( &oid );
else bson_oid_from_string( &oid, *bci.Po );
bson_append_oid( b, key, &oid );
break;
case 'b': bson_append_bool( b, key, **bci.Pb ); break;
case 't': bson_append_time_t( b, key, **bci.Pt ); break;
case 'x': if (*bci.Px != 0) bson_append_symbol( b, key, *bci.Px ); break;
case 'i': bson_append_int( b, key, **bci.Pi ); break;
case 'l': bson_append_long( b, key, **bci.Pl ); break;
default: printf("\nptype:'%c' utype:'%c'\n", ptype, utype); assert(NOT_REACHED); break;
}
}
break;
default:
printf("\nptype:'%c' utype:'%c'\n", ptype, utype); assert(NOT_REACHED);
break;
}
return ret;
}
void CSMatrix<Scalar>::export_to_file(const char *filename, const char *var_name, MatrixExportFormat fmt, char* number_format, bool invert_storage)
{
switch (fmt)
{
case EXPORT_FORMAT_MATRIX_MARKET:
{
FILE* file = fopen(filename, "w");
if (!file)
throw Exceptions::IOException(Exceptions::IOException::Write, filename);
if (Hermes::Helpers::TypeIsReal<Scalar>::value)
fprintf(file, "%%%%MatrixMarket matrix coordinate real general\n");
else
fprintf(file, "%%%%MatrixMarket matrix coordinate complex general\n");
fprintf(file, "%d %d %d\n", this->size, this->size, this->nnz);
if (invert_storage)
this->switch_orientation();
for (unsigned int j = 0; j < this->size; j++)
{
for (int i = Ap[j]; i < Ap[j + 1]; i++)
{
Hermes::Helpers::fprint_coordinate_num(file, i_coordinate(Ai[i] + 1, j + 1, invert_storage), j_coordinate(Ai[i] + 1, j + 1, invert_storage), Ax[i], number_format);
fprintf(file, "\n");
}
}
if (invert_storage)
this->switch_orientation();
fclose(file);
}
break;
case EXPORT_FORMAT_MATLAB_MATIO:
{
#ifdef WITH_MATIO
mat_sparse_t sparse;
sparse.nzmax = this->nnz;
if (invert_storage)
this->switch_orientation();
sparse.nir = this->nnz;
sparse.ir = Ai;
sparse.njc = this->size + 1;
sparse.jc = (int *)Ap;
sparse.ndata = this->nnz;
size_t dims[2];
dims[0] = this->size;
dims[1] = this->size;
mat_t *mat = Mat_CreateVer(filename, "", MAT_FT_MAT5);
matvar_t *matvar;
// For complex. No allocation here.
double* Ax_re = nullptr;
double* Ax_im = nullptr;
// For real.
if (Hermes::Helpers::TypeIsReal<Scalar>::value)
{
sparse.data = Ax;
matvar = Mat_VarCreate(var_name, MAT_C_SPARSE, MAT_T_DOUBLE, 2, dims, &sparse, MAT_F_DONT_COPY_DATA);
}
else
{
// For complex.
Ax_re = malloc_with_check<CSMatrix<Scalar>, double>(this->nnz, this);
Ax_im = malloc_with_check<CSMatrix<Scalar>, double>(this->nnz, this);
struct mat_complex_split_t z = { Ax_re, Ax_im };
for (int i = 0; i < this->nnz; i++)
{
Ax_re[i] = ((std::complex<double>)(this->Ax[i])).real();
Ax_im[i] = ((std::complex<double>)(this->Ax[i])).imag();
sparse.data = &z;
}
matvar = Mat_VarCreate(var_name, MAT_C_SPARSE, MAT_T_DOUBLE, 2, dims, &sparse, MAT_F_DONT_COPY_DATA | MAT_F_COMPLEX);
}
if (matvar)
{
Mat_VarWrite(mat, matvar, MAT_COMPRESSION_ZLIB);
Mat_VarFree(matvar);
}
if (invert_storage)
this->switch_orientation();
free_with_check(Ax_re);
free_with_check(Ax_im);
Mat_Close(mat);
if (!matvar)
throw Exceptions::IOException(Exceptions::IOException::Write, filename);
#endif
}
break;
case EXPORT_FORMAT_PLAIN_ASCII:
{
FILE* file = fopen(filename, "w");
if (!file)
throw Exceptions::IOException(Exceptions::IOException::Write, filename);
if (invert_storage)
this->switch_orientation();
for (unsigned int j = 0; j < this->size; j++)
{
for (int i = Ap[j]; i < Ap[j + 1]; i++)
{
Helpers::fprint_coordinate_num(file, i_coordinate(Ai[i], j, invert_storage), j_coordinate(Ai[i], j, invert_storage), Ax[i], number_format);
fprintf(file, "\n");
}
}
if (invert_storage)
this->switch_orientation();
fclose(file);
}
break;
#ifdef WITH_BSON
case EXPORT_FORMAT_BSON:
{
// Init bson
bson bw;
bson_init(&bw);
// Matrix size.
bson_append_int(&bw, "size", this->size);
// Nonzeros.
bson_append_int(&bw, "nnz", this->nnz);
if (invert_storage)
this->switch_orientation();
bson_append_start_array(&bw, "Ap");
for (unsigned int i = 0; i < this->size; i++)
bson_append_int(&bw, "p", this->Ap[i]);
bson_append_finish_array(&bw);
bson_append_start_array(&bw, "Ai");
for (unsigned int i = 0; i < this->nnz; i++)
bson_append_int(&bw, "i", this->Ai[i]);
bson_append_finish_array(&bw);
bson_append_start_array(&bw, "Ax");
for (unsigned int i = 0; i < this->nnz; i++)
bson_append_double(&bw, "x", real(this->Ax[i]));
bson_append_finish_array(&bw);
if (!Hermes::Helpers::TypeIsReal<Scalar>::value)
{
bson_append_start_array(&bw, "Ax-imag");
for (unsigned int i = 0; i < this->nnz; i++)
bson_append_double(&bw, "x-i", imag(this->Ax[i]));
bson_append_finish_array(&bw);
}
bson_append_finish_array(&bw);
if (invert_storage)
this->switch_orientation();
// Done.
bson_finish(&bw);
// Write to disk.
FILE *fpw;
fpw = fopen(filename, "wb");
const char *dataw = (const char *)bson_data(&bw);
fwrite(dataw, bson_size(&bw), 1, fpw);
fclose(fpw);
bson_destroy(&bw);
}
break;
#endif
}
}
void Namespace::parseJSON(bson* &p, const char* json, jsmntok_t *tokens,
int &tokenCursor, bool createNew, int elementCount)
{
if (_DEBUG)
LOGI("parse");
char buf[100];
int autoKey = 0;
char firstChar;
int count = 0;
char keyBuf[255];
char valueBuf[1024];
bool tokenIsKey = false;
for (int i(0); i < elementCount; i++)
{
jsmntok_t token = tokens[tokenCursor];
tokenIsKey = false;
// check if the token contains a key (look for ':' within 5 chars after its end
for (int k(0); k < 5; k++)
{
{
if (json[token.end + k] == ':')
{
memcpy(keyBuf, &json[token.start], token.end - token.start);
keyBuf[token.end - token.start] = '\0';
tokenIsKey = true;
break;
}
}
}
if (tokenIsKey)
{
tokenCursor++;
continue; // that token was key, continue with the rest
}
switch (token.type)
{
case JSMN_ARRAY:
count = token.size;
bson_append_start_array(p, keyBuf);
tokenCursor++;
parseJSON(p, json, tokens, tokenCursor, false, token.size);
bson_append_finish_array(p);
break;
case JSMN_OBJECT:
if (createNew)
{
createNew = false;
tokenCursor++;
parseJSON(p, json, tokens, tokenCursor, false, token.size);
}
else
{
bson_append_start_object(p, keyBuf);
tokenCursor++;
parseJSON(p, json, tokens, tokenCursor, false, token.size);
bson_append_finish_object(p);
}
break;
case JSMN_STRING:
memcpy(valueBuf, &json[token.start], token.end - token.start);
valueBuf[token.end - token.start] = '\0';
bson_append_string(p, keyBuf, valueBuf);
tokenCursor++;
break;
case JSMN_PRIMITIVE:
firstChar = json[token.start];
if (firstChar == 't' || firstChar == 'f')
{
// todo: wrong boolean parameter
memcpy(valueBuf, &json[token.start], token.end - token.start);
valueBuf[token.end - token.start] = '\0';
bson_append_bool(p, keyBuf, atoi(valueBuf));
}
else if (firstChar == 'n')
{
bson_append_null(p, keyBuf);
}
else
{
memcpy(valueBuf, &json[token.start], token.end - token.start);
valueBuf[token.end - token.start] = '\0';
double v = atof(valueBuf);
if (fmod(v, 1) == 0)
{
/* variable is an integer */
bson_append_int(p, keyBuf, (int) v);
}
else
{
bson_append_double(p, keyBuf, v);
}
}
tokenCursor++;
break;
default:
break;
}
}
}
