gridfs.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/* gridfs.h                                                           */
/* Author: Christopher Triolo                                         */
/*--------------------------------------------------------------------*/

#include "mongo.h"
#include "bson.h"
#include "platform_hacks.h"
#include <stdio.h>
#ifndef GRIDFS_INCLUDED
#define GRIDFS_INCLUDED

enum {DEFAULT_CHUNK_SIZE = 256 * 1024};

typedef uint64_t gridfs_offset;

/* A GridFS contains a db connection, a root database name, and an
   optional prefix */
typedef struct {
  /* The client to db-connection. */
  mongo_connection* client;
  /* The root database name */
  const char* dbname;
  /* The prefix of the GridFS's collections, default is NULL */
  const char* prefix;
  /* The namespace where the file's metadata is stored */
  const char* files_ns;
  /* The namespace where the files's data is stored in chunks */
  const char* chunks_ns;

} gridfs;

/* The state of a gridfile. This is used for incrementally writing buffers
 * to a single GridFS file.
 */

/* A GridFile contains the GridFS it is located in and the file
   metadata */
typedef struct {
  /* The GridFS where the GridFile is located */
  gridfs* gfs;
  /* The GridFile's bson object where all its metadata is located */
  bson* meta;
  /* The position is the offset in the file */
  gridfs_offset pos;
  /* The files_id of the gridfile */
  bson_oid_t id;
  /* The name of the gridfile as a string */
  const char* remote_name;
  /* The gridfile's content type */
  const char* content_type;
  /* The length of this gridfile */
  gridfs_offset length;
  /* The number of the current chunk being written to */
  int chunk_num;
  /* A buffer storing data still to be written to chunks */
  char* pending_data;
  /* Length of pending data */
  int pending_len;

} gridfile;

/*--------------------------------------------------------------------*/

int gridfs_init(mongo_connection* client, const char* dbname,
  const char* prefix, gridfs* gfs);

void gridfs_destroy( gridfs* gfs );

void gridfile_writer_init( gridfile* gfile, gridfs* gfs, const char* remote_name,
    const char* content_type );

void gridfile_write_buffer( gridfile* gfile, const char* data,
    gridfs_offset length );

bson gridfile_writer_done( gridfile* gfile );

bson gridfs_store_buffer(gridfs* gfs, const char* data, gridfs_offset length,
    const char* remotename,
    const char * contenttype);

bson gridfs_store_file(gridfs* gfs, const char* filename,
         const char* remotename, const char* contenttype);

void gridfs_remove_filename(gridfs* gfs, const char* filename);

int gridfs_find_query(gridfs* gfs, bson* query, gridfile* gfile );

int gridfs_find_filename(gridfs* gfs, const char *filename,
         gridfile* gfile);

/*--------------------------------------------------------------------*/


int gridfile_init(gridfs* gfs, bson* meta, gridfile* gfile);

void gridfile_destroy(gridfile* gfile);

int gridfile_exists(gridfile* gfile);

const char * gridfile_get_filename(gridfile* gfile);

int gridfile_get_chunksize(gridfile* gfile);

gridfs_offset gridfile_get_contentlength(gridfile* gfile);

const char* gridfile_get_contenttype(gridfile* gfile);

bson_date_t gridfile_get_uploaddate(gridfile* gfile);

const char* gridfile_get_md5(gridfile* gfile);

const char *gridfile_get_field(gridfile* gfile,
                                 const char* name);

bson_bool_t gridfile_get_boolean(gridfile* gfile,
                                 const char* name);

bson gridfile_get_metadata(gridfile* gfile);

int gridfile_get_numchunks(gridfile* gfile);

bson gridfile_get_chunk(gridfile* gfile, int n);

mongo_cursor* gridfile_get_chunks(gridfile* gfile, int start, int size);

gridfs_offset gridfile_write_file(gridfile* gfile, FILE* stream);

gridfs_offset gridfile_read(gridfile* gfile, gridfs_offset size, char* buf);

gridfs_offset gridfile_seek(gridfile* gfile, gridfs_offset offset);

#endif