END_TEST START_TEST(test_bf_shared_compatible_persist) { bloom_filter_params params = {0, 0, 1e6, 1e-4}; bf_params_for_capacity(¶ms); bloom_bitmap map; bloom_bloomfilter filter; fail_unless(bitmap_from_filename("/tmp/shared_compat_persist.mmap", params.bytes, 1, PERSISTENT, &map) == 0); fail_unless(bf_from_bitmap(&map, params.k_num, 1, &filter) == 0); fchmod(map.fileno, 0777); // Check all the keys get added char buf[100]; int res; for (int i=0;i<1000;i++) { snprintf((char*)&buf, 100, "test%d", i); res = bf_add(&filter, (char*)&buf); fail_unless(res == 1); } fail_unless(bf_close(&filter) == 0); // Test all the keys are contained fail_unless(bitmap_from_filename("/tmp/shared_compat_persist.mmap", params.bytes, 1, SHARED, &map) == 0); fail_unless(bf_from_bitmap(&map, params.k_num, 1, &filter) == 0); for (int i=0;i<1000;i++) { snprintf((char*)&buf, 100, "test%d", i); res = bf_contains(&filter, (char*)&buf); fail_unless(res == 1); } unlink("/tmp/shared_compat_persist.mmap"); }
END_TEST START_TEST(test_sbf_close_does_flush) { bloom_sbf_params params = SBF_DEFAULT_PARAMS; params.initial_capacity = 1e3; params.fp_probability = 1e-4; nextfile next; next.format = "/tmp/mmap_close.%d.data"; next.num = 0; bloom_sbf sbf; int res = sbf_from_filters(¶ms, sbf_make_callback, &next, 0, NULL, &sbf); fail_unless(res == 0); char buf[100]; for (int i=0;i<2000;i++) { snprintf((char*)&buf, 100, "foobar%d", i); sbf_add(&sbf, (char*)&buf); } fail_unless(sbf_close(&sbf) == 0); bloom_bitmap maps[2]; bitmap_from_filename("/tmp/mmap_close.0.data", get_size("/tmp/mmap_close.0.data"), 1, 1, SHARED, (bloom_bitmap*)&maps); bitmap_from_filename("/tmp/mmap_close.1.data", get_size("/tmp/mmap_close.1.data"), 1, 1, SHARED, ((bloom_bitmap*)&maps)+1); bloom_bloomfilter filters[2]; bf_from_bitmap((bloom_bitmap*)&maps, 1, 0, (bloom_bloomfilter*)&filters); bf_from_bitmap(((bloom_bitmap*)&maps)+1, 1, 0, ((bloom_bloomfilter*)&filters)+1); bloom_bloomfilter **filter_map = calloc(2, sizeof(bloom_bloomfilter*)); filter_map[0] = (bloom_bloomfilter*)&filters; filter_map[1] = ((bloom_bloomfilter*)&filters)+1; res = sbf_from_filters(¶ms, sbf_make_callback, &next, 2, filter_map, &sbf); fail_unless(res == 0); fail_unless(sbf_size(&sbf) == 2000); fail_unless(sbf_total_capacity(&sbf) == 5*1e3); for (int i=0;i<2000;i++) { snprintf((char*)&buf, 100, "foobar%d", i); res = sbf_contains(&sbf, (char*)&buf); fail_unless(res == 1); } unlink("/tmp/mmap_close.0.data"); unlink("/tmp/mmap_close.1.data"); }
END_TEST START_TEST(make_bf_fresh_then_restore) { // Use -1 for anonymous bloom_bitmap map; bloom_bloomfilter filter; bitmap_from_file(-1, 4096, ANONYMOUS, &map); int res = bf_from_bitmap(&map, 10, 1, &filter); // Make fresh fail_unless(res == 0); bloom_bloomfilter filter2; res = bf_from_bitmap(&map, 10, 0, &filter2); // Restore now fail_unless(res == 0); }
END_TEST START_TEST(test_bf_fp_prob_extended) { bloom_filter_params params = {0, 0, 1e6, 0.001}; bf_params_for_capacity(¶ms); bloom_bitmap map; bloom_bloomfilter filter; fail_unless(bitmap_from_file(-1, params.bytes, ANONYMOUS, &map) == 0); fail_unless(bf_from_bitmap(&map, params.k_num, 1, &filter) == 0); // Check all the keys get added char buf[100]; int res; int num_wrong = 0; for (int i=0;i<1e6;i++) { snprintf((char*)&buf, 100, "test%d", i); res = bf_add(&filter, (char*)&buf); if (res == 0) num_wrong++; } // We added 1M items, with a capacity of 1M and error of 1/1000. // Technically we should have 1K false positives fail_unless(num_wrong <= 1000); }
END_TEST START_TEST(test_length) { bloom_filter_params params = {0, 0, 1e6, 1e-4}; bf_params_for_capacity(¶ms); bloom_bitmap map; bitmap_from_file(-1, params.bytes, ANONYMOUS, &map); bloom_bloomfilter filter; bf_from_bitmap(&map, params.k_num, 1, &filter); // Check the size fail_unless(bf_size(&filter) == 0); // Check all the keys get added char buf[100]; int res; for (int i=0;i<1000;i++) { snprintf((char*)&buf, 100, "test%d", i); res = bf_add(&filter, (char*)&buf); fail_unless(res == 1); } // Check the size fail_unless(bf_size(&filter) == 1000); }
END_TEST START_TEST(make_bf_no_map) { // Use -1 for anonymous bloom_bloomfilter filter; int res = bf_from_bitmap(NULL, 10, 1, &filter); fail_unless(res == -EINVAL); }
END_TEST START_TEST(make_bf_fresh_not_new) { // Use -1 for anonymous bloom_bitmap map; bloom_bloomfilter filter; bitmap_from_file(-1, 4096, ANONYMOUS, &map); int res = bf_from_bitmap(&map, 10, 0, &filter); fail_unless(res == -1); }
END_TEST START_TEST(make_bf_zero_k) { // Use -1 for anonymous bloom_bitmap map; bloom_bloomfilter filter; bitmap_from_file(-1, 4096, ANONYMOUS, &map); int res = bf_from_bitmap(&map, 0, 1, &filter); fail_unless(res == -EINVAL); }
END_TEST START_TEST(test_bf_double_close) { bloom_filter_params params = {0, 0, 1e6, 1e-4}; bf_params_for_capacity(¶ms); bloom_bitmap map; bloom_bloomfilter filter; bitmap_from_file(-1, params.bytes, ANONYMOUS, &map); bf_from_bitmap(&map, params.k_num, 1, &filter); fail_unless(bf_close(&filter) == 0); fail_unless(bf_close(&filter) == -1); }
END_TEST START_TEST(test_bf_value_sanity) { // Use -1 for anonymous bloom_bitmap map; bloom_bloomfilter filter; bitmap_from_file(-1, 4096, ANONYMOUS, &map); int res = bf_from_bitmap(&map, 10, 1, &filter); // Make fresh fail_unless(res == 0); fail_unless(filter.bitmap_size == 28672); // Should be the bitmap size fail_unless(filter.offset == 2867); // Should be size / 10 fail_unless(filter.header->k_num == 10); fail_unless(filter.header->count == 0); }
END_TEST START_TEST(test_flush_close) { bloom_filter_params params = {0, 0, 1e6, 1e-4}; bf_params_for_capacity(¶ms); bloom_bitmap map; bloom_bloomfilter filter; bitmap_from_filename("/tmp/test_flush_close.mmap", params.bytes, 1, SHARED, &map); bf_from_bitmap(&map, params.k_num, 1, &filter); fail_unless(bf_flush(&filter) == 0); fail_unless(bf_close(&filter) == 0); unlink("/tmp/test_flush_close.mmap"); }
/** * This beast mode method scans the data directory * belonging to this filter for any existing filters, * and restores the SBF * @return 0 on success. -1 on error. */ static int discover_existing_filters(bloom_filter *f) { // Scan through the folder looking for data files struct dirent **namelist; int num; // Filter only data dirs, in sorted order num = scandir(f->full_path, &namelist, filter_data_files, alphasort); if (num == -1) { syslog(LOG_ERR, "Failed to scan files for filter '%s'. %s", f->filter_name, strerror(errno)); return -1; } syslog(LOG_INFO, "Found %d files for filter %s.", num, f->filter_name); // Speical case when there are no filters if (num == 0) { int res = create_sbf(f, 0, NULL); return res; } // Allocate space for all the filter bloom_bitmap **maps = malloc(num * sizeof(bloom_bitmap*)); bloom_bloomfilter **filters = malloc(num * sizeof(bloom_bloomfilter*)); // Initialize the bitmaps and bloom filters int res; int err = 0; uint64_t size; bitmap_mode mode = (f->config->use_mmap) ? SHARED : PERSISTENT; for (int i=0; i < num && !err; i++) { // Get the full path to the bitmap char *bitmap_path = join_path(f->full_path, namelist[i]->d_name); syslog(LOG_INFO, "Discovered bloom filter: %s.", bitmap_path); // Get the size size = get_size(bitmap_path); if (size == 0) { err = 1; syslog(LOG_ERR, "Failed to get the filesize for: %s. %s", bitmap_path, strerror(errno)); free(bitmap_path); break; } // Create the bitmap bloom_bitmap *bitmap = maps[num - i - 1] = malloc(sizeof(bloom_bitmap)); res = bitmap_from_filename(bitmap_path, size, 0, mode, bitmap); if (res != 0) { err = 1; syslog(LOG_ERR, "Failed to load bitmap for: %s. %s", bitmap_path, strerror(errno)); free(bitmap); free(bitmap_path); break; } // Create the bloom filter bloom_bloomfilter *filter = filters[num - i - 1] = malloc(sizeof(bloom_bloomfilter)); res = bf_from_bitmap(bitmap, 1, 0, filter); if (res != 0) { err = 1; syslog(LOG_ERR, "Failed to load bloom filter for: %s. [%d]", bitmap_path, res); free(filter); bitmap_close(bitmap); free(bitmap); free(bitmap_path); break; } // Cleanup free(bitmap_path); } // Free the memory associated with scandir for (int i=0; i < num; i++) free(namelist[i]); free(namelist); // Return if there was an error if (err) return -1; // Create the SBF res = create_sbf(f, num, filters); // Cleanup on err if (res != 0) { syslog(LOG_ERR, "Failed to make scalable bloom filter for: %s.", f->filter_name); // For f***s sake. We need to clean up so much shit now. for (int i=0; i < num; i++) { bf_close(filters[i]); bitmap_close(maps[i]); free(filters[i]); free(maps[i]); } } // Increase our page ins f->counters.page_ins += 1; // Remove the filters list free(maps); free(filters); return (err) ? -1 : 0; }