static bson_buffer * bson_append_estart( bson_buffer * b , int type , const char * name , const int dataSize ){
const int sl = strlen(name) + 1;
if ( ! bson_ensure_space( b , 1 + sl + dataSize ) )
return 0;
bson_append_byte( b , (char)type );
bson_append( b , name , sl );
return b;
}
char * bson_buffer_finish( bson_buffer * b ){
int i;
if ( ! b->finished ){
if ( ! bson_ensure_space( b , 1 ) ) return 0;
bson_append_byte( b , 0 );
i = b->cur - b->buf;
bson_little_endian32(b->buf, &i);
b->finished = 1;
}
return b->buf;
}
int bson_append_finish_object( bson *b ) {
char *start;
int i;
if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR;
bson_append_byte( b , 0 );
start = b->data + b->stack[ --b->stackPos ];
i = b->cur - start;
bson_little_endian32( start, &i );
return BSON_OK;
}
bson_buffer * bson_append_finish_object( bson_buffer * b ){
char * start;
int i;
if ( ! bson_ensure_space( b , 1 ) ) return 0;
bson_append_byte( b , 0 );
start = b->buf + b->stack[ --b->stackPos ];
i = b->cur - start;
bson_little_endian32(start, &i);
return b;
}
/**
* Add null byte, mark as finished, and return buffer.
* Note that the buffer will now be owned by the bson
* object created from a call to bson_from_buffer.
* This buffer is then deallocated by calling
* bson_destroy().
*/
int bson_buffer_finish( bson_buffer * b ){
int i;
if ( ! b->finished ){
if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR;
bson_append_byte( b, 0 );
i = b->cur - b->buf;
bson_little_endian32(b->buf, &i);
b->finished = 1;
}
return BSON_OK;
}
static bson_buffer * bson_append_estart( bson_buffer * b , int type , const char * name , const int dataSize ){
const int len = strlen(name) + 1;
if ( ! bson_ensure_space( b , 1 + len + dataSize ) )
return 0;
if( !bson_check_field_name( b, (unsigned char* )name, len - 1 ) ) {
bson_builder_error( b );
return 0;
}
bson_append_byte( b , (char)type );
bson_append( b , name , len );
return b;
}
static int bson_append_estart( bson_buffer * b, int type, const char * name, const int dataSize ){
const int len = strlen(name) + 1;
if ( bson_ensure_space( b, 1 + len + dataSize ) == BSON_ERROR ) {
return BSON_ERROR;
}
if( bson_check_field_name( b, (unsigned char* )name, len - 1 ) == BSON_ERROR ) {
bson_builder_error( b );
return BSON_ERROR;
}
bson_append_byte( b, (char)type );
bson_append( b, name, len );
return BSON_OK;
}
int bson_finish( bson *b ) {
int i;
if( b->err & BSON_NOT_UTF8 )
return BSON_ERROR;
if ( ! b->finished ) {
if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR;
bson_append_byte( b, 0 );
i = b->cur - b->data;
bson_little_endian32( b->data, &i );
b->finished = 1;
}
return BSON_OK;
}
MONGO_EXPORT int bson_append_finish_object( bson *b ) {
char *start;
int i;
if (!b) return BSON_ERROR;
if (!b->stackPos) { b->err = BSON_NOT_IN_SUBOBJECT; return BSON_ERROR; }
if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR;
bson_append_byte( b , 0 );
start = b->data + b->stack[ --b->stackPos ];
if ( b->cur - start >= INT32_MAX ) {
b->err = BSON_SIZE_OVERFLOW;
return BSON_ERROR;
}
i = ( int )( b->cur - start );
bson_little_endian32( start, &i );
return BSON_OK;
}
bson_buffer * bson_append_element( bson_buffer * b, const char * name_or_null, const bson_iterator* elem){
bson_iterator next = *elem;
int size;
bson_iterator_next(&next);
size = next.cur - elem->cur;
if (name_or_null == NULL){
bson_ensure_space(b, size);
bson_append(b, elem->cur, size);
}else{
int data_size = size - 2 - strlen(bson_iterator_key(elem));
bson_append_estart(b, elem->cur[0], name_or_null, data_size);
bson_append(b, bson_iterator_value(elem), data_size);
}
return b;
}
MONGO_EXPORT int bson_append_element( bson *b, const char *name_or_null, const bson_iterator *elem ) {
bson_iterator next = *elem;
size_t size;
bson_iterator_next( &next );
size = next.cur - elem->cur;
if ( name_or_null == NULL ) {
if( bson_ensure_space( b, size ) == BSON_ERROR )
return BSON_ERROR;
bson_append( b, elem->cur, size );
}
else {
size_t data_size = size - 2 - strlen( bson_iterator_key( elem ) );
bson_append_estart( b, elem->cur[0], name_or_null, data_size );
bson_append( b, bson_iterator_value( elem ), data_size );
}
return BSON_OK;
}
MONGO_EXPORT int bson_finish( bson *b ) {
int i;
if( b->err & BSON_NOT_UTF8 )
return BSON_ERROR;
if ( ! b->finished ) {
if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR;
bson_append_byte( b, 0 );
if ( b->cur - b->data >= INT32_MAX ) {
b->err = BSON_SIZE_OVERFLOW;
return BSON_ERROR;
}
i = ( int )( b->cur - b->data );
bson_little_endian32( b->data, &i );
b->finished = 1;
}
return BSON_OK;
}
static int bson_append_estart( bson *b, int type, const char *name, const int dataSize ) {
const int len = strlen( name ) + 1;
if ( b->finished ) {
b->err |= BSON_ALREADY_FINISHED;
return BSON_ERROR;
}
if ( bson_ensure_space( b, 1 + len + dataSize ) == BSON_ERROR ) {
return BSON_ERROR;
}
if( bson_check_field_name( b, ( const char * )name, len - 1 ) == BSON_ERROR ) {
bson_builder_error( b );
return BSON_ERROR;
}
bson_append_byte( b, ( char )type );
bson_append( b, name, len );
return BSON_OK;
}
MONGO_EXPORT int bson_finish( bson *b ) {
int i;
if( b->err & BSON_NOT_UTF8 )
return BSON_ERROR;
if ( ! b->finished ) {
bson_fatal_msg(!b->stackPos, "Subobject not finished before bson_finish().");
if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR;
bson_append_byte( b, 0 );
if ( _bson_position(b) >= INT32_MAX ) {
b->err = BSON_SIZE_OVERFLOW;
return BSON_ERROR;
}
i = ( int ) _bson_position(b);
bson_little_endian32( b->data, &i );
b->finished = 1;
}
return BSON_OK;
}
/**
* Build perfSONAR data block.
*/
bson *nlcali_psdata(T self, const char *event, const char *m_id,
int32_t sample_num)
{
struct timeval now;
bson_buffer bb;
bson *bp = NULL;
assert(self && event && m_id);
gettimeofday(&now, NULL);
if (self->dirty) {
nlcali_calc(self);
}
bson_buffer_init(&bb);
bson_ensure_space(&bb, LOG_BUFSZ);
bson_append_string(&bb, "mid", m_id);
bson_append_start_array(&bb, "data");
bson_append_double(&bb, "ts", now.tv_sec + now.tv_usec/1e6);
bson_append_int(&bb, "_sample", sample_num);
bson_append_double(&bb, "sum_v", self->vsm.sum);
bson_append_double(&bb, "min_v", self->vsm.min);
bson_append_double(&bb, "max_v", self->vsm.max);
bson_append_double(&bb, "mean_v", self->vsm.mean);
bson_append_double(&bb, "sd_v", self->vsm.sd);
bson_append_double(&bb, "sum_r", self->rsm.sum);
bson_append_double(&bb, "min_r", self->rsm.min);
bson_append_double(&bb, "max_r", self->rsm.max);
bson_append_double(&bb, "sd_r", self->rsm.sd);
bson_append_double(&bb, "sum_g", self->gsm.sum);
bson_append_double(&bb, "min_g", self->gsm.min);
bson_append_double(&bb, "max_g", self->gsm.max);
bson_append_double(&bb, "sd_g", self->gsm.sd);
bson_append_int(&bb, "count", self->vsm.count);
bson_append_double(&bb, "dur", self->dur);
bson_append_double(&bb, "dur_inst", self->dur_sum);
/* add histogram data, if being recorded */
if (NL_HIST_HAS_DATA(self)) {
int i;
char idx[16];
/* rate hist */
bson_append_double(&bb, "h_rm", self->h_rmin);
bson_append_double(&bb, "h_rw", self->h_rwidth);
bson_append_start_array(&bb, "h_rd");
for (i=0; i < self->h_num; i++) {
sprintf(idx, "%d", i);
bson_append_int(&bb, idx, self->h_rdata[i]);
}
bson_append_finish_object(&bb);
/* gap hist */
bson_append_double(&bb, "h_gm", self->h_gmin);
bson_append_double(&bb, "h_gw", self->h_gwidth);
bson_append_start_array(&bb, "h_gd");
for (i=0; i < self->h_num; i++) {
sprintf(idx, "%d", i);
bson_append_int(&bb, idx, self->h_gdata[i]);
}
bson_append_finish_object(&bb);
}
bson_append_finish_object(&bb);
bp = malloc(sizeof(bson));
bson_from_buffer(bp, &bb);
return(bp);
error:
if (bp) {
bson_destroy(bp);
free(bp);
}
bson_buffer_destroy(&bb);
return(NULL);
}
