EXPORT int mongo_gridfile_read(struct gridfile_* gf, mxArray* data) {
gridfile* gf_ = (gridfile*)gf;
uint64_t size;
void* p;
gridfs_offset remaining;
int cplx = mxIsComplex(data);
if (cplx && mxGetClassID(data) != mxDOUBLE_CLASS)
mexErrMsgTxt("Gridfile:read - only complex values of type double are supported");
p = calcSize(data, &size);
remaining = gridfile_get_contentlength(gf_) - gf_->pos;
if (size > remaining || cplx && size*2 > remaining)
return 0;
if (size) gridfile_read(gf_, size, (char*)p);
if (size && cplx)
gridfile_read(gf_, size, (char*)mxGetPi(data));
return 1;
}
void test_gridfile(gridfs *gfs, char *data_before, uint64_t length, char *filename, char *content_type) {
gridfile gfile[1];
char *data_after = malloc( LARGE );
if( data_after == NULL ) {
printf("Failed to allocated memory");
exit(1);
}
FILE * fd;
mongo_md5_state_t pms[1];
mongo_md5_byte_t digest[16];
char hex_digest[33];
uint64_t i = length;
int n;
gridfs_find_filename(gfs, filename, gfile);
ASSERT(gridfile_exists(gfile));
fd = fopen("output", "w+");
gridfile_write_file(gfile, fd);
fseek(fd, 0, SEEK_SET);
ASSERT(fread(data_after, length, sizeof(char), fd));
fclose(fd);
ASSERT( strncmp(data_before, data_after, length) == 0 );
gridfile_read( gfile, length, data_after );
ASSERT( strncmp(data_before, data_after, length) == 0 );
ASSERT( strcmp( gridfile_get_filename( gfile ), filename ) == 0 );
ASSERT( gridfile_get_contentlength( gfile ) == length );
ASSERT( gridfile_get_chunksize( gfile ) == DEFAULT_CHUNK_SIZE );
ASSERT( strcmp( gridfile_get_contenttype( gfile ), content_type ) == 0) ;
ASSERT( strncmp( data_before, data_after, length ) == 0 );
mongo_md5_init(pms);
n = 0;
while( i > INT_MAX ) {
mongo_md5_append(pms, (const mongo_md5_byte_t *)data_before + (n * INT_MAX), INT_MAX);
i -= INT_MAX;
n += 1;
}
if( i > 0 )
mongo_md5_append(pms, (const mongo_md5_byte_t *)data_before + (n * INT_MAX), i);
mongo_md5_finish(pms, digest);
digest2hex(digest, hex_digest);
ASSERT( strcmp( gridfile_get_md5( gfile ), hex_digest ) == 0 );
gridfile_destroy(gfile);
gridfs_remove_filename(gfs, filename);
free( data_after );
}
SEXP mongo_gridfile_read(SEXP gfile, SEXP size) {
gridfile* _gfile = _checkGridfile(gfile);
gridfs_offset _size = asReal(size);
gridfs_offset remaining = gridfile_get_contentlength(_gfile) - _gfile->pos;
if (_size > remaining) _size = remaining;
SEXP ret;
PROTECT(ret = allocVector(RAWSXP, _size));
if (_size) gridfile_read(_gfile, _size, (char*)RAW(ret));
UNPROTECT(1);
return ret;
}
void test_gridfile(gridfs *gfs, char *data_before, size_t length, char *filename, char *content_type) {
gridfile gfile[1];
char data_after[UPPER];
FILE * fd;
mongo_md5_state_t pms[1];
mongo_md5_byte_t digest[16];
char hex_digest[33];
gridfs_find_filename(gfs, filename, gfile);
ASSERT(gridfile_exists(gfile));
fd = fopen("output", "w+");
gridfile_write_file(gfile, fd);
fseek(fd, 0, SEEK_SET);
ASSERT(fread(data_after, length, sizeof(char), fd));
fclose(fd);
ASSERT( strncmp(data_before, data_after, length) == 0 );
gridfile_read( gfile, length, data_after);
ASSERT( strncmp(data_before, data_after, length) == 0 );
ASSERT( strcmp( gridfile_get_filename( gfile ), filename ) == 0 );
ASSERT( gridfile_get_contentlength( gfile ) == length );
ASSERT( gridfile_get_chunksize( gfile ) == DEFAULT_CHUNK_SIZE );
ASSERT( strcmp( gridfile_get_contenttype( gfile ), content_type ) == 0) ;
mongo_md5_init(pms);
mongo_md5_append(pms, (const mongo_md5_byte_t *)data_before, (int)length);
mongo_md5_finish(pms, digest);
digest2hex(digest, hex_digest);
ASSERT( strcmp( gridfile_get_md5( gfile ), hex_digest ) == 0 );
gridfile_destroy(gfile);
gridfs_remove_filename(gfs, filename);
}
//! Read raster data from MongoDB
int clsRasterData::ReadFromMongoDB(gridfs *gfs, const char* remoteFilename)
{
gridfile gfile[1];
bson b[1];
bson_init(b);
bson_append_string(b, "filename", remoteFilename);
bson_finish(b);
int flag = gridfs_find_query(gfs, b, gfile);
if(0 != flag)
{
throw ModelException("clsRasterData", "ReadFromMongoDB", "The file " + string(remoteFilename) + " does not exist.");
}
size_t length = (size_t)gridfile_get_contentlength(gfile);
char* buf = (char*)malloc(length);
gridfile_read (gfile, length, buf);
float *data = (float*)buf;
bson bmeta[1];
gridfile_get_metadata(gfile, bmeta);
bson_iterator iterator[1];
if ( bson_find( iterator, bmeta, "NCOLS" ))
m_headers["NCOLS"] = (float)bson_iterator_int(iterator);
if ( bson_find( iterator, bmeta, "NROWS" ))
m_headers["NROWS"] = (float)bson_iterator_int(iterator);
if ( bson_find( iterator, bmeta, "NODATA_VALUE" ))
m_headers["NODATA_VALUE"] = (float)bson_iterator_double(iterator);
if ( bson_find( iterator, bmeta, "XLLCENTER" ))
m_headers["XLLCENTER"] = (float)bson_iterator_double(iterator);
if ( bson_find( iterator, bmeta, "YLLCENTER" ))
m_headers["YLLCENTER"] = (float)bson_iterator_double(iterator);
if ( bson_find( iterator, bmeta, "CELLSIZE" ))
{
m_headers["CELLSIZE"] = (float)bson_iterator_double(iterator);
//m_headers["DY"] = m_headers["DX"];
}
int nRows = (int)m_headers["NROWS"];
int nCols = (int)m_headers["NCOLS"];
vector<float> values;
vector<int> positionRows;
vector<int> positionCols;
//get all valid values
float nodataFloat = m_headers["NODATA_VALUE"];
for (int i = 0; i < nRows; ++i)
{
for (int j = 0; j < nCols; ++j)
{
int index = i*nCols + j;
float value = data[index];
if(FloatEqual(nodataFloat, value))
continue;
values.push_back(value);
positionRows.push_back(i);
positionCols.push_back(j);
}
}
//create float array
m_nRows = values.size();
m_rasterData = new float[m_nRows];
m_rasterPositionData = new float*[m_nRows];
for (int i = 0; i < m_nRows; ++i)
{
m_rasterData[i] = values.at(i);
m_rasterPositionData[i] = new float[2];
m_rasterPositionData[i][0] = float(positionRows.at(i));
m_rasterPositionData[i][1] = float(positionCols.at(i));
}
bson_destroy(b);
gridfile_destroy(gfile);
free(buf);
return 0;
}
//! Read raster data from MongoDB and select by mask
int clsRasterData::ReadFromMongoDB(gridfs *gfs, const char* remoteFilename,clsRasterData* mask)
{
if(mask == NULL) ReadFromMongoDB(gfs, remoteFilename);
else
{
//clock_t start = clock();
gridfile gfile[1];
bson b[1];
bson_init(b);
bson_append_string(b, "filename", remoteFilename);
bson_finish(b);
int flag = gridfs_find_query(gfs, b, gfile);
if(0 != flag)
{
//cout << "Failed in ReadFromMongoDB, Remote file: " << remoteFilename << endl;
return -1;
}
size_t length = (size_t)gridfile_get_contentlength(gfile);
char* buf = (char*)malloc(length);
gridfile_read (gfile, length, buf);
float *data = (float*)buf;
//clock_t end = clock();
//cout << "Read data: " << end - start << endl;
//start = clock();
//get the data posotion from mask
int nRows;
float** validPosition;
mask->getRasterPositionData(&nRows,&validPosition);
m_nRows = nRows;
m_mask = mask;
//set header
m_headers["NCOLS"] = mask->getASCCols();
m_headers["NROWS"] = mask->getASCRows();
m_headers["NODATA_VALUE"] = mask->getNoDataValue();
m_headers["CELLSIZE"] = mask->getCellWidth();
//m_headers["DY"] = mask->getCellWidth();
m_headers["XLLCENTER"] = mask->getXllCenter();
m_headers["YLLCENTER"] = mask->getYllCenter();
//read data
m_rasterData = new float[nRows];
int ascCols = mask->getASCCols();
int ascRows = mask->getASCRows();
//int index = 0;
//for (int i = 0; i < ascRows; ++i)
//{
// for (int j = 0; j < ascCols; ++j)
// {
// float value = data[i*ascCols + j];
// if(index < nRows)
// {
// if(validPosition[index][0] == i && validPosition[index][1] == j)
// {
// m_rasterData[index] = value;
// index++;
// }
// }
// }
//}
for(int index = 0; index < nRows; index++)
{
int i = validPosition[index][0];
int j = validPosition[index][1];
int rasterIndex = i*ascCols + j;
m_rasterData[index] = data[rasterIndex];
}
//end = clock();
//cout << "Rearrange data: " << end-start << endl;
bson_destroy(b);
gridfile_destroy(gfile);
free(buf);
}
return 0;
}
static ngx_int_t ngx_http_gridfs_handler(ngx_http_request_t* request) {
ngx_http_gridfs_loc_conf_t* gridfs_conf;
ngx_http_core_loc_conf_t* core_conf;
ngx_buf_t* buffer;
ngx_chain_t out;
ngx_str_t location_name;
ngx_str_t full_uri;
char* value;
gridfs gfs;
gridfile gfile;
gridfs_offset length;
char* data;
ngx_uint_t chunksize;
ngx_uint_t numchunks;
ngx_uint_t chunklength;
char* contenttype;
ngx_uint_t i;
ngx_int_t rc = NGX_OK;
bson query;
bson_buffer buf;
bson_oid_t oid;
gridfs_conf = ngx_http_get_module_loc_conf(request, ngx_http_gridfs_module);
core_conf = ngx_http_get_module_loc_conf(request, ngx_http_core_module);
location_name = core_conf->name;
full_uri = request->uri;
/* defensive */
if (full_uri.len < location_name.len) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Invalid location name or uri.");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
/* Extract the value from the uri */
value = (char*)malloc(sizeof(char) * (full_uri.len - location_name.len + 1));
if (value == NULL) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Failed to allocate memory for value buffer.");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
memcpy(value, full_uri.data + location_name.len, full_uri.len - location_name.len);
value[full_uri.len - location_name.len] = '\0';
/* URL Decoding */
if (!url_decode(value)) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Malformed request.");
free(value);
return NGX_HTTP_BAD_REQUEST;
}
/* If no mongo connection, create a default connection */
/* TODO: Find a better place for this logic */
if (!gridfs_conf->gridfs_conn->connected) {
switch (mongo_connect(gridfs_conf->gridfs_conn, NULL)) {
case mongo_conn_success:
break;
case mongo_conn_bad_arg:
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Mongo Exception: Bad Arguments");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
case mongo_conn_no_socket:
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Mongo Exception: No Socket");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
case mongo_conn_fail:
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Mongo Exception: Connection Failure");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
case mongo_conn_not_master:
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Mongo Exception: Not Master");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
default:
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Mongo Exception: Unknown Error");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
}
/* Find the GridFile */
gridfs_init(gridfs_conf->gridfs_conn,
(const char*)gridfs_conf->gridfs_db.data,
(const char*)gridfs_conf->gridfs_root_collection.data,
&gfs);
bson_buffer_init(&buf);
switch (gridfs_conf->gridfs_type) {
case bson_oid:
bson_oid_from_string(&oid, value);
bson_append_oid(&buf, (char*)gridfs_conf->gridfs_field.data, &oid);
break;
case bson_int:
bson_append_int(&buf, (char*)gridfs_conf->gridfs_field.data, atoi(value));
break;
case bson_string:
bson_append_string(&buf, (char*)gridfs_conf->gridfs_field.data, value);
break;
}
bson_from_buffer(&query, &buf);
if(!gridfs_find_query(&gfs, &query, &gfile)){
bson_destroy(&query);
free(value);
return NGX_HTTP_NOT_FOUND;
}
bson_destroy(&query);
free(value);
/* Get information about the file */
length = gridfile_get_contentlength(&gfile);
chunksize = gridfile_get_chunksize(&gfile);
numchunks = gridfile_get_numchunks(&gfile);
contenttype = (char*)gridfile_get_contenttype(&gfile);
/* Set the headers */
request->headers_out.status = NGX_HTTP_OK;
request->headers_out.content_length_n = length;
if (contenttype != NULL) {
request->headers_out.content_type.len = strlen(contenttype);
request->headers_out.content_type.data = (u_char*)contenttype;
}
else ngx_http_set_content_type(request);
ngx_http_send_header(request);
/* Read and serve chunk by chunk */
for (i = 0; i < numchunks; i++) {
/* Allocate space for the response buffer */
buffer = ngx_pcalloc(request->pool, sizeof(ngx_buf_t));
if (buffer == NULL) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Failed to allocate response buffer");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
/* Allocate space for the buffer of data */
data = ngx_pcalloc(request->pool, sizeof(char)*chunksize);
if (data == NULL) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Failed to allocate buffer for data");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
/* Set up the buffer chain */
chunklength = gridfile_read(&gfile, chunksize, data);
buffer->pos = (u_char*)data;
buffer->last = (u_char*)data + chunklength;
buffer->memory = 1;
buffer->last_buf = (i == numchunks-1);
out.buf = buffer;
out.next = NULL;
/* Serve the Chunk */
rc = ngx_http_output_filter(request, &out);
/* TODO: More Codes to Catch? */
if (rc == NGX_ERROR) {
return NGX_ERROR;
}
}
return rc;
}
void test_gridfile( gridfs *gfs, char *data_before, int64_t length, char *filename, char *content_type ) {
gridfile gfile[1];
FILE *stream;
mongo_md5_state_t pms[1];
mongo_md5_byte_t digest[16];
char hex_digest[33];
int64_t i = length;
int n;
char *data_after = (char*)bson_malloc( LARGE );
int truncBytes;
char* lowerName;
ASSERT(gridfs_find_filename( gfs, filename, gfile ) == MONGO_OK);
ASSERT( gridfile_exists( gfile ) );
stream = fopen( "output", "w+" );
gridfile_write_file( gfile, stream );
fseek( stream, 0, SEEK_SET );
ASSERT( fread( data_after, (size_t)length, sizeof( char ), stream ) );
fclose( stream );
ASSERT( memcmp( data_before, data_after, (size_t)length ) == 0 );
gridfile_read( gfile, length, data_after );
ASSERT( memcmp( data_before, data_after, (size_t)length ) == 0 );
lowerName = (char*) bson_malloc( (int)strlen( filename ) + 1);
strcpy( lowerName, filename);
_strlwr( lowerName );
ASSERT( strcmp( gridfile_get_filename( gfile ), lowerName ) == 0 );
bson_free( lowerName );
ASSERT( gridfile_get_contentlength( gfile ) == (size_t)length );
ASSERT( gridfile_get_chunksize( gfile ) == DEFAULT_CHUNK_SIZE );
ASSERT( strcmp( gridfile_get_contenttype( gfile ), content_type ) == 0 ) ;
ASSERT( memcmp( data_before, data_after, (size_t)length ) == 0 );
if( !( gfile->flags & GRIDFILE_COMPRESS ) ) {
mongo_md5_init( pms );
n = 0;
while( i > INT_MAX ) {
mongo_md5_append( pms, ( const mongo_md5_byte_t * )data_before + ( n * INT_MAX ), INT_MAX );
i -= INT_MAX;
n += 1;
}
if( i > 0 )
mongo_md5_append( pms, ( const mongo_md5_byte_t * )data_before + ( n * INT_MAX ), (int)i );
mongo_md5_finish( pms, digest );
digest2hex( digest, hex_digest );
ASSERT( strcmp( gridfile_get_md5( gfile ), hex_digest ) == 0 );
}
truncBytes = (int) (length > DEFAULT_CHUNK_SIZE * 4 ? length - DEFAULT_CHUNK_SIZE * 2 - 13 : 23);
gridfile_writer_init( gfile, gfs, filename, content_type, GRIDFILE_DEFAULT);
ASSERT( gridfile_truncate(gfile, (size_t)(length - truncBytes)) == (size_t)(length - truncBytes));
gridfile_writer_done( gfile );
gridfile_seek(gfile, 0);
ASSERT( gridfile_get_contentlength( gfile ) == (size_t)(length - truncBytes) );
ASSERT( gridfile_read( gfile, length, data_after ) == (size_t)(length - truncBytes));
ASSERT( memcmp( data_before, data_after, (size_t)(length - truncBytes) ) == 0 );
gridfile_writer_init( gfile, gfs, filename, content_type, GRIDFILE_DEFAULT);
gridfile_truncate(gfile, 0);
gridfile_writer_done( gfile );
ASSERT( gridfile_get_contentlength( gfile ) == 0 );
ASSERT( gridfile_read( gfile, length, data_after ) == 0 );
gridfile_destroy( gfile );
gridfs_remove_filename( gfs, filename );
free( data_after );
_unlink( "output" );
}
void test_large( void ) {
mongo conn[1];
gridfs gfs[1];
gridfile gfile[1];
FILE *fd;
size_t i, n;
char *buffer = (char*)bson_malloc( LARGE );
char *read_buf = (char*)bson_malloc( LARGE );
int64_t filesize = ( int64_t )1024 * ( int64_t )LARGE;
mongo_write_concern wc;
bson lastError;
bson lastErrorCmd;
srand( (unsigned int) time( NULL ) );
INIT_SOCKETS_FOR_WINDOWS;
if ( mongo_client( conn, TEST_SERVER, 27017 ) ) {
printf( "failed to connect 1\n" );
exit( 1 );
}
mongo_write_concern_init(&wc);
wc.j = 1;
mongo_write_concern_finish(&wc);
mongo_set_write_concern(conn, &wc);
gridfs_init( conn, "test", "fs", gfs );
fd = fopen( "bigfile", "r" );
if( fd ) {
fclose( fd );
} else {
/* Create a very large file */
fill_buffer_randomly( buffer, ( int64_t )LARGE );
fd = fopen( "bigfile", "w" );
for( i=0; i<1024; i++ ) {
fwrite( buffer, 1, LARGE, fd );
}
fclose( fd );
}
/* Now read the file into GridFS */
gridfs_remove_filename( gfs, "bigfile" );
gridfs_store_file( gfs, "bigfile", "bigfile", "text/html", GRIDFILE_NOMD5 | GRIDFILE_COMPRESS);
gridfs_find_filename( gfs, "bigfile", gfile );
ASSERT( strcmp( gridfile_get_filename( gfile ), "bigfile" ) == 0 );
ASSERT( gridfile_get_contentlength( gfile ) == filesize );
fd = fopen( "bigfile", "r" );
while( ( n = fread( buffer, 1, MEDIUM, fd ) ) != 0 ) {
ASSERT( gridfile_read( gfile, MEDIUM, read_buf ) == n );
ASSERT( memcmp( buffer, read_buf, n ) == 0 );
}
fclose( fd );
gridfile_destroy( gfile );
/* Read the file using the streaming interface */
gridfs_remove_filename( gfs, "bigfile" );
gridfs_remove_filename( gfs, "bigfile-stream" );
gridfile_writer_init( gfile, gfs, "bigfile-stream", "text/html", GRIDFILE_NOMD5 | GRIDFILE_COMPRESS );
mongo_write_concern_destroy( &wc );
mongo_write_concern_init(&wc);
wc.j = 0; /* Let's reset write concern j field to zero, we will manually call getLastError with j = 1 */
mongo_write_concern_finish(&wc);
mongo_set_write_concern(conn, &wc);
fd = fopen( "bigfile", "r" );
i = 0;
while( ( n = fread( buffer, 1, READ_WRITE_BUF_SIZE, fd ) ) != 0 ) {
gridfile_write_buffer( gfile, buffer, n );
if(i++ % 10 == 0) {
bson_init( &lastErrorCmd );
bson_append_int( &lastErrorCmd, "getLastError", 1);
bson_append_int( &lastErrorCmd, "j", 1);
bson_finish( &lastErrorCmd );
bson_init( &lastError );
mongo_run_command( conn, "test", &lastErrorCmd, &lastError );
bson_destroy( &lastError );
bson_destroy( &lastErrorCmd );
}
}
mongo_write_concern_destroy( &wc );
mongo_write_concern_init(&wc);
wc.j = 1; /* Let's reset write concern j field to 1 */
mongo_write_concern_finish(&wc);
mongo_set_write_concern(conn, &wc);
fclose( fd );
gridfile_writer_done( gfile );
gridfs_find_filename( gfs, "bigfile-stream", gfile );
ASSERT( strcmp( gridfile_get_filename( gfile ), "bigfile-stream" ) == 0 );
ASSERT( gridfile_get_contentlength( gfile ) == filesize );
gridfs_remove_filename( gfs, "bigfile-stream" );
gridfs_destroy( gfs );
mongo_disconnect( conn );
mongo_destroy( conn );
bson_free( buffer );
bson_free( read_buf );
mongo_write_concern_destroy( &wc );
}
void test_random_write() {
mongo conn[1];
gridfs gfs[1];
gridfile* gfile;
char *data_before = (char*)bson_malloc( UPPER );
char *random_data = (char*)bson_malloc( UPPER );
char *buf = (char*) bson_malloc( UPPER );
int64_t i;
FILE *fd;
srand((unsigned int) time( NULL ) );
INIT_SOCKETS_FOR_WINDOWS;
if ( mongo_connect( conn, TEST_SERVER, 27017 ) ) {
printf( "failed to connect 2\n" );
exit( 1 );
}
gridfs_init( conn, "test", "fs", gfs );
fill_buffer_randomly( data_before, UPPER );
fill_buffer_randomly( random_data, UPPER );
for ( i = LOWER; i <= UPPER; i += DELTA ) {
int64_t j = i / 2 - 3;
int n, bytes_to_write_first;
/* Input from buffer */
gridfs_store_buffer( gfs, data_before, i, "input-buffer", "text/html", GRIDFILE_DEFAULT );
if ( i > DEFAULT_CHUNK_SIZE * 4 ) {
n = DEFAULT_CHUNK_SIZE * 3 + 6;
memcpy(&data_before[j], random_data, n); // Let's overwrite the buffer with bytes crossing multiple chunks
bytes_to_write_first = 10;
} else {
n = 6;
memcpy(random_data, "123456", n);
strncpy(&data_before[j], random_data, n); // Let's overwrite the buffer with a few some bytes
bytes_to_write_first = 0;
}
gfile = gridfile_create();
ASSERT(gridfs_find_filename(gfs, "input-buffer", gfile) == 0);
gridfile_writer_init(gfile, gfs, "input-buffer", "text/html", GRIDFILE_DEFAULT );
gridfile_seek(gfile, j); // Seek into the same buffer position within the GridFS file
if ( bytes_to_write_first ) {
gridfile_write_buffer(gfile, random_data, bytes_to_write_first); // Let's write 10 bytes first, and later the rest
}
gridfile_write_buffer(gfile, &random_data[bytes_to_write_first], n - bytes_to_write_first); // Try to write to the existing GridFS file on the position given by j
gridfile_seek(gfile, j);
gridfile_read( gfile, n, buf );
ASSERT(memcmp( buf, &data_before[j], n) == 0);
gridfile_writer_done(gfile);
ASSERT(gfile->pos == j + n);
gridfile_dispose(gfile);
test_gridfile( gfs, data_before, j + n > i ? j + n : i, "input-buffer", "text/html" );
/* Input from file */
fd = fopen( "input-file", "w" );
fwrite( data_before, sizeof( char ), (size_t) (j + n > i ? j + n : i), fd );
fclose( fd );
gridfs_store_file( gfs, "input-file", "input-file", "text/html", GRIDFILE_DEFAULT );
test_gridfile( gfs, data_before, j + n > i ? j + n : i, "input-file", "text/html" );
}
gridfs_destroy( gfs );
mongo_disconnect( conn );
mongo_destroy( conn );
free( data_before );
free( random_data );
free( buf );
/* Clean up files. */
_unlink( "input-file" );
_unlink( "output" );
}
