inline void ldb_compact(struct _leveldb_stuff *ldbs) { leveldb_compact_range(ldbs->db, NULL, 0, NULL, 0); }
int main(int argc, char** argv) { leveldb_t* db; leveldb_comparator_t* cmp; leveldb_cache_t* cache; leveldb_env_t* env; leveldb_options_t* options; leveldb_readoptions_t* roptions; leveldb_writeoptions_t* woptions; char* err = NULL; int run = -1; CheckCondition(leveldb_major_version() >= 1); CheckCondition(leveldb_minor_version() >= 1); snprintf(dbname, sizeof(dbname), "%s/leveldb_c_test-%di/meta/0", GetTempDir(), ((int) geteuid())); StartPhase("create_objects"); cmp = leveldb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName); env = leveldb_create_default_env(); cache = leveldb_cache_create_lru(100000); options = leveldb_options_create(); leveldb_options_set_comparator(options, cmp); leveldb_options_set_error_if_exists(options, 1); leveldb_options_set_cache(options, cache); leveldb_options_set_env(options, env); leveldb_options_set_info_log(options, NULL); leveldb_options_set_write_buffer_size(options, 100000); leveldb_options_set_paranoid_checks(options, 1); leveldb_options_set_max_open_files(options, 10); leveldb_options_set_block_size(options, 1024); leveldb_options_set_block_restart_interval(options, 8); leveldb_options_set_compression(options, leveldb_no_compression); roptions = leveldb_readoptions_create(); leveldb_readoptions_set_verify_checksums(roptions, 1); leveldb_readoptions_set_fill_cache(roptions, 0); woptions = leveldb_writeoptions_create(); leveldb_writeoptions_set_sync(woptions, 1); StartPhase("destroy"); leveldb_destroy_db(options, dbname, &err); Free(&err); StartPhase("open"); db = leveldb_open(options, dbname, &err); CheckNoError(err); CheckGet(db, roptions, "foo", NULL); StartPhase("put"); leveldb_put(db, woptions, "foo", 3, "hello", 5, &err); CheckNoError(err); CheckGet(db, roptions, "foo", "hello"); StartPhase("compactall"); leveldb_compact_range(db, NULL, 0, NULL, 0); CheckGet(db, roptions, "foo", "hello"); StartPhase("compactrange"); leveldb_compact_range(db, "a", 1, "z", 1); CheckGet(db, roptions, "foo", "hello"); StartPhase("writebatch"); { leveldb_writebatch_t* wb = leveldb_writebatch_create(); leveldb_writebatch_put(wb, "foo", 3, "a", 1); leveldb_writebatch_clear(wb); leveldb_writebatch_put(wb, "bar", 3, "b", 1); leveldb_writebatch_put(wb, "box", 3, "c", 1); leveldb_writebatch_delete(wb, "bar", 3); leveldb_write(db, woptions, wb, &err); CheckNoError(err); CheckGet(db, roptions, "foo", "hello"); CheckGet(db, roptions, "bar", NULL); CheckGet(db, roptions, "box", "c"); int pos = 0; leveldb_writebatch_iterate(wb, &pos, CheckPut, CheckDel); CheckCondition(pos == 3); leveldb_writebatch_destroy(wb); } StartPhase("iter"); { leveldb_iterator_t* iter = leveldb_create_iterator(db, roptions); CheckCondition(!leveldb_iter_valid(iter)); leveldb_iter_seek_to_first(iter); CheckCondition(leveldb_iter_valid(iter)); CheckIter(iter, "box", "c"); leveldb_iter_next(iter); CheckIter(iter, "foo", "hello"); leveldb_iter_prev(iter); CheckIter(iter, "box", "c"); leveldb_iter_prev(iter); CheckCondition(!leveldb_iter_valid(iter)); leveldb_iter_seek_to_last(iter); CheckIter(iter, "foo", "hello"); leveldb_iter_seek(iter, "b", 1); CheckIter(iter, "box", "c"); leveldb_iter_get_error(iter, &err); CheckNoError(err); leveldb_iter_destroy(iter); } StartPhase("approximate_sizes"); { int i; int n = 20000; char keybuf[100]; char valbuf[100]; uint64_t sizes[2]; const char* start[2] = { "a", "k00000000000000010000" }; size_t start_len[2] = { 1, 21 }; const char* limit[2] = { "k00000000000000010000", "z" }; size_t limit_len[2] = { 21, 1 }; leveldb_writeoptions_set_sync(woptions, 0); for (i = 0; i < n; i++) { snprintf(keybuf, sizeof(keybuf), "k%020d", i); snprintf(valbuf, sizeof(valbuf), "v%020d", i); leveldb_put(db, woptions, keybuf, strlen(keybuf), valbuf, strlen(valbuf), &err); CheckNoError(err); } leveldb_approximate_sizes(db, 2, start, start_len, limit, limit_len, sizes); CheckCondition(sizes[0] > 0); CheckCondition(sizes[1] > 0); } StartPhase("property"); { char* prop = leveldb_property_value(db, "nosuchprop"); /* CheckCondition(prop == NULL);*/ prop = leveldb_property_value(db, "leveldb.stats"); CheckCondition(prop != NULL); Free(&prop); } StartPhase("snapshot"); { const leveldb_snapshot_t* snap; snap = leveldb_create_snapshot(db); leveldb_delete(db, woptions, "foo", 3, &err); CheckNoError(err); leveldb_readoptions_set_snapshot(roptions, snap); CheckGet(db, roptions, "foo", "hello"); leveldb_readoptions_set_snapshot(roptions, NULL); CheckGet(db, roptions, "foo", NULL); leveldb_release_snapshot(db, snap); } StartPhase("repair"); { leveldb_close(db); leveldb_options_set_error_if_exists(options, 0); leveldb_repair_db(options, dbname, &err); CheckNoError(err); db = leveldb_open(options, dbname, &err); CheckNoError(err); CheckGet(db, roptions, "foo", NULL); CheckGet(db, roptions, "bar", NULL); CheckGet(db, roptions, "box", "c"); leveldb_options_set_error_if_exists(options, 1); } StartPhase("filter"); for (run = 0; run < 2; run++) { // First run uses custom filter, second run uses bloom filter CheckNoError(err); leveldb_filterpolicy_t* policy; if (run == 0) { policy = leveldb_filterpolicy_create( NULL, FilterDestroy, FilterCreate, FilterKeyMatch, FilterName); } else { policy = leveldb_filterpolicy_create_bloom(10); } // Create new database leveldb_close(db); leveldb_destroy_db(options, dbname, &err); leveldb_options_set_filter_policy(options, policy); db = leveldb_open(options, dbname, &err); CheckNoError(err); leveldb_put(db, woptions, "foo", 3, "foovalue", 8, &err); CheckNoError(err); leveldb_put(db, woptions, "bar", 3, "barvalue", 8, &err); CheckNoError(err); leveldb_compact_range(db, NULL, 0, NULL, 0); fake_filter_result = 1; CheckGet(db, roptions, "foo", "foovalue"); CheckGet(db, roptions, "bar", "barvalue"); if (phase == 0) { // Must not find value when custom filter returns false fake_filter_result = 0; CheckGet(db, roptions, "foo", NULL); CheckGet(db, roptions, "bar", NULL); fake_filter_result = 1; CheckGet(db, roptions, "foo", "foovalue"); CheckGet(db, roptions, "bar", "barvalue"); } leveldb_options_set_filter_policy(options, NULL); leveldb_filterpolicy_destroy(policy); } StartPhase("cleanup"); leveldb_close(db); leveldb_options_destroy(options); leveldb_readoptions_destroy(roptions); leveldb_writeoptions_destroy(woptions); leveldb_cache_destroy(cache); leveldb_comparator_destroy(cmp); leveldb_env_destroy(env); fprintf(stderr, "PASS\n"); return 0; }
void db_compact_range(db_t *db, const char *skey, size_t sklen, const char *lkey, size_t lklen) { leveldb_compact_range(db, skey, sklen, lkey, lklen); }
int ldb_compact(struct _leveldb_stuff *ldbs) { leveldb_compact_range(ldbs->db, NULL, 0, NULL, 0); return 0; }
int main(int argc, char **argv) { int goopt; int listenport=8080; int numthreads=10; int tf; char *dbd=NULL; char *lpstr=NULL; char *ntstr=NULL; char *alfile=NULL; leveldb_options_t *dbopt; struct mg_context *ctx= NULL; char **mgoptions; signal(SIGINT,handlesig); signal(SIGTERM,handlesig); // command line parsing while ((goopt=getopt (argc, argv, "d:p:n:a:t:vh")) != -1) { switch (goopt) { case 'd': // database dbd=calloc(strlen((char*)optarg)+1,sizeof(char)); strncpy(dbd,(char*)optarg,strlen((char*)optarg)); break; case 'a': // access log, passed to mongoose alfile=calloc(strlen((char*)optarg)+1,sizeof(char)); strncpy(alfile,(char*)optarg,strlen((char*)optarg)); break; case 'p': // port listenport=atoi(optarg); break; case 'n': // number of threads numthreads=atoi(optarg); break; case 'v': // verbose vlevel++; break; case 'h': // help usage(NULL,EXIT_SUCCESS); break; default: // fallthrough usage(NULL,EXIT_FAILURE); } } LOG_TRACE(vlevel, _("Validation\n"),dbd); if(dbd==NULL) { usage("Must give a database dir\n",EXIT_FAILURE); } else { LOG_TRACE(vlevel, _("Using database dir: %s\n"),dbd); } if(alfile!=NULL) { if((tf=open(alfile,O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH))==-1) { LOG_FATAL(vlevel,_("Unable to open access log file: %s: %s\n"), alfile, strerror(errno)); exit(EXIT_FAILURE); } close(tf); } if(alfile!=NULL && access(alfile, W_OK)!=0) { LOG_FATAL(vlevel, _("Unable to write to access log file: %s\n"),alfile); exit(EXIT_FAILURE); } if(listenport<0 || listenport>65536) { LOG_FATAL(vlevel, _("Given port out of bounds: %i\n"),listenport); exit(EXIT_FAILURE); } if(numthreads<0 || numthreads>1024) { LOG_FATAL(vlevel, _("Given threads out of bounds: %i\n"),numthreads); exit(EXIT_FAILURE); } LOG_TRACE(vlevel, _("Setting up leveldb store in %s\n"),dbd); dbopt=leveldb_options_create(); leveldb_options_set_create_if_missing(dbopt, 1); leveldb_options_set_write_buffer_size(dbopt, 8388608); leveldb_options_set_compression(dbopt,leveldb_no_compression); dbh=leveldb_open(dbopt,dbd,&errptr); LOG_TRACE(vlevel, _("Setting leveldb read options\n")); ropt = leveldb_readoptions_create(); leveldb_readoptions_set_verify_checksums(ropt, 1); leveldb_readoptions_set_fill_cache(ropt, 0); LOG_TRACE(vlevel, _("Setting leveldb write options\n")); wopt = leveldb_writeoptions_create(); leveldb_writeoptions_set_sync(wopt, 0); // set mgoptions - XXX this needs to be handled better lpstr=calloc(7,sizeof(char)); snprintf(lpstr,6,"%i",listenport); ntstr=calloc(4,sizeof(char)); snprintf(ntstr,3,"%i",numthreads); if(alfile!=NULL) { mgoptions = calloc(9,sizeof(char*)); } else { mgoptions = calloc(7,sizeof(char*)); } mgoptions[0]="listening_ports"; mgoptions[1]=lpstr; mgoptions[2]="document_root"; mgoptions[3]="/dev/null"; mgoptions[4]="num_threads"; mgoptions[5]=ntstr; if(alfile!=NULL) { mgoptions[6]="access_log_file"; mgoptions[7]=alfile; mgoptions[8]=NULL; } else { mgoptions[6]=NULL; } // main loop LOG_INFO(vlevel, _("Starting Mongoose HTTP server loop\n")); ctx = mg_start(&mghandle, NULL, (const char**)mgoptions); if(ctx!=NULL) { while(!done) { // cleaner thread here? sleep(1); } LOG_INFO(vlevel, _("Ending Mongoose HTTP server loop\n")); mg_stop(ctx); } else { LOG_FATAL(vlevel,_("Error in creating Mongoose HTTP server\n")); } LOG_TRACE(vlevel, _("Closing database handle\n")); // close leveldb handle LOG_TRACE(vlevel, _("Cleaning up leveldb\n")); leveldb_compact_range(dbh, NULL, 0, NULL, 0); leveldb_options_destroy(dbopt); leveldb_readoptions_destroy(ropt); leveldb_writeoptions_destroy(wopt); leveldb_close(dbh); LOG_TRACE(vlevel, _("Cleaning up\n")); free(dbd); free(lpstr); free(ntstr); free(mgoptions); return EXIT_SUCCESS; }