/*
* wt_connect --
* Configure the WiredTiger connection.
*/
static int
wt_connect(const char *config_open)
{
static WT_EVENT_HANDLER event_handler = {
handle_error,
handle_message,
NULL,
NULL /* Close handler. */
};
int ret;
char config[128];
testutil_make_work_dir(g.home);
snprintf(config, sizeof(config),
"create,statistics=(fast),error_prefix=\"%s\",cache_size=1GB%s%s",
g.progname,
config_open == NULL ? "" : ",",
config_open == NULL ? "" : config_open);
if ((ret = wiredtiger_open(
g.home, &event_handler, config, &g.conn)) != 0)
return (log_print_err("wiredtiger_open", ret, 1));
return (0);
}
/*
* wt_connect --
* Configure the WiredTiger connection.
*/
static void
wt_connect(SHARED_CONFIG *cfg, char *config_open)
{
static WT_EVENT_HANDLER event_handler = {
handle_error,
handle_message,
NULL,
NULL /* Close handler. */
};
int ret;
char config[512];
size_t print_count;
testutil_clean_work_dir(home);
testutil_make_work_dir(home);
print_count = (size_t)snprintf(config, sizeof(config),
"create,statistics=(all),error_prefix=\"%s\",%s%s",
progname,
config_open == NULL ? "" : ",",
config_open == NULL ? "" : config_open);
if (print_count >= sizeof(config))
testutil_die(EINVAL, "Config string too long");
if ((ret = wiredtiger_open(
home, &event_handler, config, &cfg->conn)) != 0)
testutil_die(ret, "wiredtiger_open");
}
int
main(int argc, char *argv[])
{
WT_SESSION *session;
clock_t ce, cs;
pthread_t idlist[100];
uint64_t i, id;
char buf[100];
opts = &_opts;
memset(opts, 0, sizeof(*opts));
opts->table_type = TABLE_ROW;
opts->n_append_threads = N_APPEND_THREADS;
opts->nrecords = N_RECORDS;
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
snprintf(buf, sizeof(buf),
"create,"
"cache_size=%s,"
"eviction=(threads_max=5),"
"statistics=(fast)",
opts->table_type == TABLE_FIX ? "500MB" : "2GB");
testutil_check(wiredtiger_open(opts->home, NULL, buf, &opts->conn));
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
snprintf(buf, sizeof(buf),
"key_format=r,value_format=%s,"
"allocation_size=4K,leaf_page_max=64K",
opts->table_type == TABLE_FIX ? "8t" : "S");
testutil_check(session->create(session, opts->uri, buf));
testutil_check(session->close(session, NULL));
page_init(5000);
/* Force to disk and re-open. */
testutil_check(opts->conn->close(opts->conn, NULL));
testutil_check(wiredtiger_open(opts->home, NULL, NULL, &opts->conn));
(void)signal(SIGINT, onsig);
cs = clock();
id = 0;
for (i = 0; i < opts->n_append_threads; ++i, ++id) {
printf("append: %" PRIu64 "\n", id);
testutil_check(pthread_create(
&idlist[id], NULL, thread_append, (void *)opts));
}
for (i = 0; i < id; ++i)
testutil_check(pthread_join(idlist[i], NULL));
ce = clock();
printf("%" PRIu64 "M records: %.2lf processor seconds\n",
opts->max_inserted_id / MILLION,
(ce - cs) / (double)CLOCKS_PER_SEC);
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
static void
run(bool config_cache)
{
pthread_t idlist[1000];
u_int i, j;
char buf[256], home[256];
done = false;
testutil_work_dir_from_path(
home, sizeof(home), "WT_TEST.wt4333_handle_locks");
testutil_make_work_dir(home);
testutil_check(__wt_snprintf(buf, sizeof(buf),
"create"
", cache_cursors=%s"
", cache_size=5GB"
", checkpoint_sync=true"
", eviction=(threads_max=5)"
", file_manager=("
"close_handle_minimum=1,close_idle_time=1,close_scan_interval=1)"
", mmap=true"
", session_max=%u"
", statistics=(all)",
config_cache ? "true" : "false",
workers + 100));
testutil_check(wiredtiger_open(home, NULL, buf, &conn));
printf("%s: %d seconds, cache_cursors=%s, %u workers, %u files\n",
progname, PERIOD, config_cache ? "true" : "false", workers, uris);
uri_init();
/* 75% readers, 25% writers. */
for (i = 0; i < workers; ++i)
testutil_check(pthread_create(&idlist[i], NULL, wthread, NULL));
testutil_check(pthread_create(&idlist[i], NULL, vthread, NULL));
++i;
(void)alarm(PERIOD);
for (j = 0; j < i; ++j)
testutil_check(pthread_join(idlist[j], NULL));
printf(
"\t" "worker %" PRIu64
", worker_busy %" PRIu64
", verify %" PRIu64
", verify_busy %" PRIu64
"\n",
worker, worker_busy, verify, verify_busy);
if (verbose)
sweep_stats();
testutil_check(conn->close(conn, NULL));
}
int
main(int argc, char *argv[])
{
TEST_OPTS *opts, _opts;
TEST_PER_THREAD_OPTS thread_args[N_THREADS];
pthread_t ckpt_thread, mon_thread, threads[N_THREADS];
int i;
/*
* This test should not run unless long tests flag is set. The test
* runs for 15 minutes.
*/
if (!testutil_is_flag_set("TESTUTIL_ENABLE_TIMING_TESTS"))
return (EXIT_SUCCESS);
opts = &_opts;
opts->unique_id = 0;
memset(opts, 0, sizeof(*opts));
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_check(wiredtiger_open(opts->home, &event_handler,
"create,cache_size=1G,timing_stress_for_test=[checkpoint_slow]",
&opts->conn));
testutil_check(pthread_create(
&ckpt_thread, NULL, do_checkpoints, opts));
for (i = 0; i < N_THREADS; ++i) {
thread_args[i].testopts = opts;
thread_args[i].thread_counter = 0;
thread_args[i].threadnum = i;
testutil_check(pthread_create(
&threads[i], NULL, do_ops, &thread_args[i]));
}
/*
* Pass the whole array of thread arguments to the monitoring thread.
* This thread will need to monitor each threads counter to track if it
* is stuck.
*/
testutil_check(pthread_create(&mon_thread, NULL, monitor, thread_args));
for (i = 0; i < N_THREADS; ++i)
testutil_check(pthread_join(threads[i], NULL));
testutil_check(pthread_join(mon_thread, NULL));
testutil_check(pthread_join(ckpt_thread, NULL));
printf("Success\n");
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
/*
* subtest_main --
* The main program for the subtest
*/
static void
subtest_main(int argc, char *argv[], bool close_test)
{
struct rlimit rlim;
TEST_OPTS *opts, _opts;
WT_SESSION *session;
char config[1024], filename[1024];
opts = &_opts;
memset(opts, 0, sizeof(*opts));
memset(&rlim, 0, sizeof(rlim));
/* No core files during fault injection tests. */
testutil_check(setrlimit(RLIMIT_CORE, &rlim));
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
/* Redirect stderr, stdout. */
testutil_check(__wt_snprintf(
filename, sizeof(filename), "%s/%s", opts->home, STDERR_FILE));
testutil_assert(freopen(filename, "a", stderr) != NULL);
testutil_check(__wt_snprintf(
filename, sizeof(filename), "%s/%s", opts->home, STDOUT_FILE));
testutil_assert(freopen(filename, "a", stdout) != NULL);
testutil_check(__wt_snprintf(config, sizeof(config),
"create,cache_size=250M,log=(enabled),"
"transaction_sync=(enabled,method=none),extensions=("
WT_FAIL_FS_LIB
"=(early_load,config={environment=true,verbose=true})]"));
testutil_check(
wiredtiger_open(opts->home, &event_handler, config, &opts->conn));
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
testutil_check(session->create(session, "table:subtest",
"key_format=i,value_format=iiiS,"
"columns=(id,v0,v1,v2,big)"));
testutil_check(session->create(session, "table:subtest2",
"key_format=i,value_format=i"));
testutil_check(session->create(session, "index:subtest:v0",
"columns=(v0)"));
testutil_check(session->create(session, "index:subtest:v1",
"columns=(v1)"));
testutil_check(session->create(session, "index:subtest:v2",
"columns=(v2)"));
testutil_check(session->close(session, NULL));
subtest_populate(opts, close_test);
testutil_cleanup(opts);
}
int
main(int argc, char *argv[])
{
TEST_OPTS *opts, _opts;
opts = &_opts;
memset(opts, 0, sizeof(*opts));
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_check(
wiredtiger_open(opts->home, NULL, "create", &opts->conn));
/* Run the test. */
modify_run(opts->verbose);
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
/*
* wt_startup --
* Configure the WiredTiger connection.
*/
static void
wt_startup(char *config_open)
{
static WT_EVENT_HANDLER event_handler = {
handle_error,
handle_message,
NULL,
NULL /* Close handler. */
};
int ret;
char config_buf[128];
testutil_make_work_dir(home);
snprintf(config_buf, sizeof(config_buf),
"create,error_prefix=\"%s\",cache_size=5MB%s%s",
progname,
config_open == NULL ? "" : ",",
config_open == NULL ? "" : config_open);
if ((ret = wiredtiger_open(
home, &event_handler, config_buf, &conn)) != 0)
testutil_die(ret, "wiredtiger_open");
}
int
main(int argc, char *argv[])
{
enum { CACHE_SHARED, CACHE_SET, CACHE_NONE } cache;
TEST_OPTS *opts, _opts;
WT_RAND_STATE rnd;
WT_SESSION *session;
size_t len;
u_int i, j;
const char *p;
char *config;
opts = &_opts;
memset(opts, 0, sizeof(*opts));
opts->table_type = TABLE_ROW;
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_check(
wiredtiger_open(opts->home, &event_handler, "create", &opts->conn));
/* Open an LSM file so the LSM reconfiguration options make sense. */
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
testutil_check(session->create(
session, opts->uri, "type=lsm,key_format=S,value_format=S"));
/* Initialize the RNG. */
__wt_random_init_seed(NULL, &rnd);
/* Allocate memory for the config. */
len = WT_ELEMENTS(list) * 64;
config = dmalloc(len);
/* Set an alarm so we can debug hangs. */
(void)signal(SIGALRM, on_alarm);
/* A linear pass through the list. */
for (i = 0; i < WT_ELEMENTS(list); ++i)
reconfig(opts, session, list[i]);
/*
* A linear pass through the list, adding random elements.
*
* WiredTiger configurations are usually "the last one set wins", but
* "shared_cache" and "cache_set" options aren't allowed in the same
* configuration string.
*/
for (i = 0; i < WT_ELEMENTS(list); ++i) {
p = list[i];
cache = CACHE_NONE;
if (WT_PREFIX_MATCH(p, ",shared_cache"))
cache = CACHE_SHARED;
else if (WT_PREFIX_MATCH(p, ",cache_size"))
cache = CACHE_SET;
strcpy(config, p);
for (j =
(__wt_random(&rnd) % WT_ELEMENTS(list)) + 1; j > 0; --j) {
p = list[__wt_random(&rnd) % WT_ELEMENTS(list)];
if (WT_PREFIX_MATCH(p, ",shared_cache")) {
if (cache == CACHE_SET)
continue;
cache = CACHE_SHARED;
} else if (WT_PREFIX_MATCH(p, ",cache_size")) {
if (cache == CACHE_SHARED)
continue;
cache = CACHE_SET;
}
strcat(config, p);
}
reconfig(opts, session, config);
}
/*
* Turn on-close statistics off, if on-close is on and statistics were
* randomly turned off during the run, close would fail.
*/
testutil_check(opts->conn->reconfigure(
opts->conn, "statistics_log=(on_close=0)"));
free(config);
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
FILE *fp;
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
uint64_t new_offset, offset;
uint32_t count, max_key;
int ch, status, ret;
pid_t pid;
const char *working_dir;
if ((progname = strrchr(argv[0], DIR_DELIM)) == NULL)
progname = argv[0];
else
++progname;
working_dir = "WT_TEST.truncated-log";
while ((ch = __wt_getopt(progname, argc, argv, "h:")) != EOF)
switch (ch) {
case 'h':
working_dir = __wt_optarg;
break;
default:
usage();
}
argc -= __wt_optind;
argv += __wt_optind;
if (argc != 0)
usage();
testutil_work_dir_from_path(home, 512, working_dir);
testutil_make_work_dir(home);
/*
* Fork a child to insert as many items. We will then randomly
* kill the child, run recovery and make sure all items we wrote
* exist after recovery runs.
*/
if ((pid = fork()) < 0)
testutil_die(errno, "fork");
if (pid == 0) { /* child */
fill_db();
return (EXIT_SUCCESS);
}
/* parent */
/* Wait for child to kill itself. */
if (waitpid(pid, &status, 0) == -1)
testutil_die(errno, "waitpid");
/*
* !!! If we wanted to take a copy of the directory before recovery,
* this is the place to do it.
*/
if (chdir(home) != 0)
testutil_die(errno, "chdir: %s", home);
printf("Open database, run recovery and verify content\n");
if ((fp = fopen(RECORDS_FILE, "r")) == NULL)
testutil_die(errno, "fopen");
ret = fscanf(fp, "%" SCNu64 " %" SCNu32 "\n", &offset, &max_key);
if (ret != 2)
testutil_die(errno, "fscanf");
if (fclose(fp) != 0)
testutil_die(errno, "fclose");
/*
* The offset is the beginning of the last record. Truncate to
* the middle of that last record (i.e. ahead of that offset).
*/
if (offset > UINT64_MAX - V_SIZE)
testutil_die(ERANGE, "offset");
new_offset = offset + V_SIZE;
printf("Parent: Truncate to %" PRIu64 "\n", new_offset);
if ((ret = truncate(LOG_FILE_1, (wt_off_t)new_offset)) != 0)
testutil_die(errno, "truncate");
if ((ret = wiredtiger_open(NULL, NULL, ENV_CONFIG_REC, &conn)) != 0)
testutil_die(ret, "wiredtiger_open");
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
testutil_die(ret, "WT_CONNECTION:open_session");
if ((ret =
session->open_cursor(session, uri, NULL, NULL, &cursor)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", uri);
/*
* For every key in the saved file, verify that the key exists
* in the table after recovery. Since we did write-no-sync, we
* expect every key to have been recovered.
*/
count = 0;
while ((ret = cursor->next(cursor)) == 0)
++count;
if ((ret = conn->close(conn, NULL)) != 0)
testutil_die(ret, "WT_CONNECTION:close");
if (count > max_key) {
printf("expected %" PRIu32 " records found %" PRIu32 "\n",
max_key, count);
return (EXIT_FAILURE);
}
printf("%" PRIu32 " records verified\n", count);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
TEST_OPTS *opts, _opts;
WT_CURSOR *cursor, *cursor1;
WT_ITEM got, k, v;
WT_SESSION *session;
int32_t ki, vi;
opts = &_opts;
memset(opts, 0, sizeof(*opts));
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_check(wiredtiger_open(opts->home, NULL, "create",
&opts->conn));
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
testutil_check(opts->conn->add_collator(opts->conn, "index_coll",
&index_coll, NULL));
testutil_check(session->create(session,
"table:main", "key_format=u,value_format=u,columns=(k,v)"));
testutil_check(session->create(session,
"index:main:index", "columns=(v),collator=index_coll"));
printf("adding new record\n");
testutil_check(session->open_cursor(session, "table:main", NULL, NULL,
&cursor));
ki = 13;
vi = 17;
k.data = &ki; k.size = sizeof(ki);
v.data = &vi; v.size = sizeof(vi);
cursor->set_key(cursor, &k);
cursor->set_value(cursor, &v);
testutil_check(cursor->insert(cursor));
testutil_check(cursor->close(cursor));
printf("positioning index cursor\n");
testutil_check(session->open_cursor(session, "index:main:index", NULL,
NULL, &cursor));
cursor->set_key(cursor, &v);
testutil_check(cursor->search(cursor));
printf("duplicating cursor\n");
testutil_check(session->open_cursor(session, NULL, cursor, NULL,
&cursor1));
testutil_check(cursor->get_value(cursor, &got));
testutil_assert(item_to_int(&got) == 17);
testutil_check(cursor1->get_value(cursor1, &got));
testutil_assert(item_to_int(&got) == 17);
testutil_check(session->close(session, NULL));
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
POP_RECORD *p;
TEST_OPTS *opts, _opts;
WT_CURSOR *country_cursor, *country_cursor2, *cursor, *join_cursor,
*subjoin_cursor, *year_cursor;
WT_SESSION *session;
const char *country, *tablename;
char countryuri[256], joinuri[256], yearuri[256];
uint64_t recno, population;
uint16_t year;
int count, ret;
opts = &_opts;
memset(opts, 0, sizeof(*opts));
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
tablename = strchr(opts->uri, ':');
testutil_assert(tablename != NULL);
tablename++;
snprintf(countryuri, sizeof(countryuri), "index:%s:country", tablename);
snprintf(yearuri, sizeof(yearuri), "index:%s:year", tablename);
snprintf(joinuri, sizeof(joinuri), "join:%s", opts->uri);
testutil_check(wiredtiger_open(opts->home, NULL,
"create,cache_size=200M", &opts->conn));
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
testutil_check(session->create(session, opts->uri,
"key_format=r,"
"value_format=5sHQ,"
"columns=(id,country,year,population)"));
/* Create an index with a simple key. */
testutil_check(session->create(session,
countryuri, "columns=(country)"));
/* Create an immutable index. */
testutil_check(session->create(session,
yearuri, "columns=(year),immutable"));
/* Insert the records into the table. */
testutil_check(session->open_cursor(
session, opts->uri, NULL, "append", &cursor));
count = 1;
for (p = pop_data; p->year != 0; p++) {
cursor->set_key(cursor, count);
cursor->set_value(cursor, p->country, p->year, p->population);
testutil_check(cursor->insert(cursor));
count++;
}
testutil_check(cursor->close(cursor));
/* Open cursors needed by the join. */
testutil_check(session->open_cursor(session,
joinuri, NULL, NULL, &join_cursor));
testutil_check(session->open_cursor(session,
countryuri, NULL, NULL, &country_cursor));
testutil_check(session->open_cursor(session,
yearuri, NULL, NULL, &year_cursor));
/* select values WHERE country == "AU" AND year > 1900 */
country_cursor->set_key(country_cursor, "AU\0\0\0");
testutil_check(country_cursor->search(country_cursor));
testutil_check(session->join(session, join_cursor, country_cursor,
"compare=eq,count=10"));
year_cursor->set_key(year_cursor, (uint16_t)1900);
testutil_check(year_cursor->search(year_cursor));
testutil_check(session->join(session, join_cursor, year_cursor,
"compare=gt,count=10,strategy=bloom"));
count = 0;
/* List the values that are joined */
while ((ret = join_cursor->next(join_cursor)) == 0) {
testutil_check(join_cursor->get_key(join_cursor, &recno));
testutil_check(join_cursor->get_value(join_cursor, &country,
&year, &population));
printf("ID %" PRIu64, recno);
printf(
": country %s, year %" PRIu16 ", population %" PRIu64 "\n",
country, year, population);
count++;
}
testutil_assert(ret == WT_NOTFOUND);
testutil_assert(count == 2);
testutil_check(join_cursor->close(join_cursor));
testutil_check(year_cursor->close(year_cursor));
testutil_check(country_cursor->close(country_cursor));
/* Open cursors needed by the join. */
testutil_check(session->open_cursor(session,
joinuri, NULL, NULL, &join_cursor));
testutil_check(session->open_cursor(session,
joinuri, NULL, NULL, &subjoin_cursor));
testutil_check(session->open_cursor(session,
countryuri, NULL, NULL, &country_cursor));
testutil_check(session->open_cursor(session,
countryuri, NULL, NULL, &country_cursor2));
testutil_check(session->open_cursor(session,
yearuri, NULL, NULL, &year_cursor));
/*
* select values WHERE (country == "AU" OR country == "UK")
* AND year > 1900
*
* First, set up the join representing the country clause.
*/
country_cursor->set_key(country_cursor, "AU\0\0\0");
testutil_check(country_cursor->search(country_cursor));
testutil_check(session->join(session, subjoin_cursor, country_cursor,
"operation=or,compare=eq,count=10"));
country_cursor2->set_key(country_cursor2, "UK\0\0\0");
testutil_check(country_cursor2->search(country_cursor2));
testutil_check(session->join(session, subjoin_cursor, country_cursor2,
"operation=or,compare=eq,count=10"));
/* Join that to the top join, and add the year clause */
testutil_check(session->join(session, join_cursor, subjoin_cursor,
NULL));
year_cursor->set_key(year_cursor, (uint16_t)1900);
testutil_check(year_cursor->search(year_cursor));
testutil_check(session->join(session, join_cursor, year_cursor,
"compare=gt,count=10,strategy=bloom"));
count = 0;
/* List the values that are joined */
while ((ret = join_cursor->next(join_cursor)) == 0) {
testutil_check(join_cursor->get_key(join_cursor, &recno));
testutil_check(join_cursor->get_value(join_cursor, &country,
&year, &population));
printf("ID %" PRIu64, recno);
printf(
": country %s, year %" PRIu16 ", population %" PRIu64 "\n",
country, year, population);
count++;
}
testutil_assert(ret == WT_NOTFOUND);
testutil_assert(count == 4);
testutil_check(join_cursor->close(join_cursor));
testutil_check(subjoin_cursor->close(subjoin_cursor));
testutil_check(country_cursor->close(country_cursor));
testutil_check(country_cursor2->close(country_cursor2));
testutil_check(year_cursor->close(year_cursor));
testutil_check(session->close(session, NULL));
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
static void
run(CONFIG *cp, int bigkey, size_t bytes)
{
WT_CONNECTION *conn;
WT_SESSION *session;
WT_CURSOR *cursor;
uint64_t keyno;
int ret;
void *p;
big[bytes - 1] = '\0';
printf(SIZET_FMT "%s%s: %s %s big %s\n",
bytes < MEGABYTE ? bytes :
(bytes < GIGABYTE ? bytes / MEGABYTE : bytes / GIGABYTE),
bytes < MEGABYTE ? "" :
(bytes < GIGABYTE ?
(bytes % MEGABYTE == 0 ? "" : "+") :
(bytes % GIGABYTE == 0 ? "" : "+")),
bytes < MEGABYTE ? "B" : (bytes < GIGABYTE ? "MB" : "GB"),
cp->uri, cp->config, bigkey ? "key" : "value");
testutil_make_work_dir(home);
/*
* Open/create the database, connection, session and cursor; set the
* cache size large, we don't want to try and evict anything.
*/
if ((ret = wiredtiger_open(
home, NULL, "create,cache_size=10GB", &conn)) != 0)
testutil_die(ret, "wiredtiger_open");
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
testutil_die(ret, "WT_CONNECTION.open_session");
if ((ret = session->create(session, cp->uri, cp->config)) != 0)
testutil_die(ret,
"WT_SESSION.create: %s %s", cp->uri, cp->config);
if ((ret =
session->open_cursor(session, cp->uri, NULL, NULL, &cursor)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", cp->uri);
/* Set the key/value. */
if (bigkey)
cursor->set_key(cursor, big);
else if (cp->recno) {
keyno = 1;
cursor->set_key(cursor, keyno);
} else
cursor->set_key(cursor, "key001");
cursor->set_value(cursor, big);
/* Insert the record (use update, insert discards the key). */
if ((ret = cursor->update(cursor)) != 0)
testutil_die(ret, "WT_CURSOR.insert");
/* Retrieve the record and check it. */
if ((ret = cursor->search(cursor)) != 0)
testutil_die(ret, "WT_CURSOR.search");
if (bigkey && (ret = cursor->get_key(cursor, &p)) != 0)
testutil_die(ret, "WT_CURSOR.get_key");
if ((ret = cursor->get_value(cursor, &p)) != 0)
testutil_die(ret, "WT_CURSOR.get_value");
if (memcmp(p, big, bytes) != 0)
testutil_die(0,
"retrieved big key/value item did not match original");
/* Remove the record. */
if ((ret = cursor->remove(cursor)) != 0)
testutil_die(ret, "WT_CURSOR.remove");
if ((ret = conn->close(conn, NULL)) != 0)
testutil_die(ret, "WT_CONNECTION.close");
big[bytes - 1] = 'a';
}
int
main(int argc, char *argv[])
{
FILE *fp;
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
WT_RAND_STATE rnd;
uint64_t key;
uint32_t absent, count, timeout;
int ch, status, ret;
pid_t pid;
char *working_dir;
if ((progname = strrchr(argv[0], DIR_DELIM)) == NULL)
progname = argv[0];
else
++progname;
working_dir = NULL;
timeout = 10;
while ((ch = __wt_getopt(progname, argc, argv, "h:t:")) != EOF)
switch (ch) {
case 'h':
working_dir = __wt_optarg;
break;
case 't':
timeout = (uint32_t)atoi(__wt_optarg);
break;
default:
usage();
}
argc -= __wt_optind;
argv += __wt_optind;
if (argc != 0)
usage();
testutil_work_dir_from_path(home, 512, working_dir);
testutil_make_work_dir(home);
/*
* Fork a child to insert as many items. We will then randomly
* kill the child, run recovery and make sure all items we wrote
* exist after recovery runs.
*/
if ((pid = fork()) < 0)
testutil_die(errno, "fork");
if (pid == 0) { /* child */
fill_db();
return (EXIT_SUCCESS);
}
/* parent */
__wt_random_init(&rnd);
/* Sleep for the configured amount of time before killing the child. */
printf("Parent: sleep %" PRIu32 " seconds, then kill child\n", timeout);
sleep(timeout);
/*
* !!! It should be plenty long enough to make sure more than one
* log file exists. If wanted, that check would be added here.
*/
printf("Kill child\n");
if (kill(pid, SIGKILL) != 0)
testutil_die(errno, "kill");
waitpid(pid, &status, 0);
/*
* !!! If we wanted to take a copy of the directory before recovery,
* this is the place to do it.
*/
chdir(home);
printf("Open database, run recovery and verify content\n");
if ((ret = wiredtiger_open(NULL, NULL, ENV_CONFIG_REC, &conn)) != 0)
testutil_die(ret, "wiredtiger_open");
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
testutil_die(ret, "WT_CONNECTION:open_session");
if ((ret =
session->open_cursor(session, uri, NULL, NULL, &cursor)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", uri);
if ((fp = fopen(RECORDS_FILE, "r")) == NULL)
testutil_die(errno, "fopen");
/*
* For every key in the saved file, verify that the key exists
* in the table after recovery. Since we did write-no-sync, we
* expect every key to have been recovered.
*/
for (absent = count = 0;; ++count) {
ret = fscanf(fp, "%" SCNu64 "\n", &key);
if (ret != EOF && ret != 1)
testutil_die(errno, "fscanf");
if (ret == EOF)
break;
cursor->set_key(cursor, key);
if ((ret = cursor->search(cursor)) != 0) {
if (ret != WT_NOTFOUND)
testutil_die(ret, "search");
printf("no record with key %" PRIu64 "\n", key);
++absent;
}
}
fclose(fp);
if ((ret = conn->close(conn, NULL)) != 0)
testutil_die(ret, "WT_CONNECTION:close");
if (absent) {
printf("%u record(s) absent from %u\n", absent, count);
return (EXIT_FAILURE);
}
printf("%u records verified\n", count);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
FILE *fp;
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
pid_t pid;
uint64_t new_offset, offset;
uint32_t count, max_key;
int ch, ret, status;
const char *working_dir;
(void)testutil_set_progname(argv);
working_dir = "WT_TEST.truncated-log";
while ((ch = __wt_getopt(progname, argc, argv, "h:")) != EOF)
switch (ch) {
case 'h':
working_dir = __wt_optarg;
break;
default:
usage();
}
argc -= __wt_optind;
if (argc != 0)
usage();
testutil_work_dir_from_path(home, sizeof(home), working_dir);
testutil_make_work_dir(home);
/*
* Fork a child to do its work. Wait for it to exit.
*/
if ((pid = fork()) < 0)
testutil_die(errno, "fork");
if (pid == 0) { /* child */
fill_db();
return (EXIT_SUCCESS);
}
/* parent */
/* Wait for child to kill itself. */
if (waitpid(pid, &status, 0) == -1)
testutil_die(errno, "waitpid");
/*
* !!! If we wanted to take a copy of the directory before recovery,
* this is the place to do it.
*/
if (chdir(home) != 0)
testutil_die(errno, "chdir: %s", home);
printf("Open database, run recovery and verify content\n");
if ((fp = fopen(RECORDS_FILE, "r")) == NULL)
testutil_die(errno, "fopen");
ret = fscanf(fp, "%" SCNu64 " %" SCNu32 "\n", &offset, &max_key);
if (ret != 2)
testutil_die(errno, "fscanf");
if (fclose(fp) != 0)
testutil_die(errno, "fclose");
/*
* The offset is the beginning of the last record. Truncate to
* the middle of that last record (i.e. ahead of that offset).
*/
if (offset > UINT64_MAX - V_SIZE)
testutil_die(ERANGE, "offset");
new_offset = offset + V_SIZE;
printf("Parent: Log file 1: Key %" PRIu32 " at %" PRIu64 "\n",
max_key, offset);
printf("Parent: Truncate mid-record to %" PRIu64 "\n", new_offset);
if (truncate(LOG_FILE_1, (wt_off_t)new_offset) != 0)
testutil_die(errno, "truncate");
testutil_check(wiredtiger_open(NULL, NULL, ENV_CONFIG_REC, &conn));
testutil_check(conn->open_session(conn, NULL, NULL, &session));
testutil_check(session->open_cursor(session, uri, NULL, NULL, &cursor));
/*
* For every key in the saved file, verify that the key exists
* in the table after recovery. Since we did write-no-sync, we
* expect every key to have been recovered.
*/
count = 0;
while (cursor->next(cursor) == 0)
++count;
/*
* The max key in the saved file is the key we truncated, but the
* key space starts at 0 and we're counting the records here, so we
* expect the max key number of records. Add one for the system
* record for the previous LSN that the cursor will see too.
*/
if (count > (max_key + 1)) {
printf("expected %" PRIu32 " records found %" PRIu32 "\n",
max_key, count);
return (EXIT_FAILURE);
}
printf("%" PRIu32 " records verified\n", count);
/*
* Write a log record and then walk the log to make sure we can
* read that log record that is beyond the truncated record.
*/
write_and_read_new(session);
testutil_check(conn->close(conn, NULL));
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
TEST_OPTS *opts, _opts;
WT_CURSOR *rcursor, *wcursor;
WT_ITEM key, value;
WT_SESSION *session, *session2;
pthread_t thread;
uint64_t i;
char str[] = "0000000000000000";
/*
* Create a clean test directory for this run of the test program if the
* environment variable isn't already set (as is done by make check).
*/
opts = &_opts;
memset(opts, 0, sizeof(*opts));
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_check(wiredtiger_open(opts->home,
NULL, "create,cache_size=200M", &opts->conn));
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session2));
testutil_check(session->create(session, name,
"key_format=Q,value_format=S"));
/* Populate the table with some data. */
testutil_check(session->open_cursor(
session, name, NULL, "overwrite", &wcursor));
for (i = 0; i < NUM_DOCS; i++) {
wcursor->set_key(wcursor, i);
rand_str(i, str);
wcursor->set_value(wcursor, str);
testutil_check(wcursor->insert(wcursor));
}
testutil_check(wcursor->close(wcursor));
printf("%d documents inserted\n", NUM_DOCS);
/* Perform some random reads */
testutil_check(session->open_cursor(
session, name, NULL, "next_random=true", &rcursor));
query_docs(rcursor, false);
testutil_check(rcursor->close(rcursor));
/* Setup Transaction to pin the current values */
testutil_check(
session2->begin_transaction(session2, "isolation=snapshot"));
testutil_check(session2->open_cursor(
session2, name, NULL, "next_random=true", &rcursor));
/* Perform updates in a txn to confirm that we see only the original. */
testutil_check(session->open_cursor(
session, name, NULL, "overwrite", &wcursor));
for (i = 0; i < NUM_DOCS; i++) {
rand_str(i, str);
str[0] = 'A';
wcursor->set_key(wcursor, i);
wcursor->set_value(wcursor, str);
testutil_check(wcursor->update(wcursor));
}
testutil_check(wcursor->close(wcursor));
printf("%d documents set to update\n", NUM_DOCS);
/* Random reads, which should see the original values */
query_docs(rcursor, false);
testutil_check(rcursor->close(rcursor));
/* Finish the txn */
testutil_check(session2->rollback_transaction(session2, NULL));
/* Random reads, which should see the updated values */
testutil_check(session2->open_cursor(
session2, name, NULL, "next_random=true", &rcursor));
query_docs(rcursor, true);
testutil_check(rcursor->close(rcursor));
/* Setup a pre-delete txn */
testutil_check(
session2->begin_transaction(session2, "isolation=snapshot"));
testutil_check(session2->open_cursor(
session2, name, NULL, "next_random=true", &rcursor));
/* Delete all but one document */
testutil_check(session->open_cursor(
session, name, NULL, "overwrite", &wcursor));
for (i = 0; i < NUM_DOCS - 1; i++) {
wcursor->set_key(wcursor, i);
testutil_check(wcursor->remove(wcursor));
}
testutil_check(wcursor->close(wcursor));
printf("%d documents deleted\n", NUM_DOCS - 1);
/* Random reads, which should not see the deletes */
query_docs(rcursor, true);
testutil_check(rcursor->close(rcursor));
/* Rollback the txn so we can see the deletes */
testutil_check(session2->rollback_transaction(session2, NULL));
/* Find the one remaining document 3 times */
testutil_check(session2->open_cursor(
session2, name, NULL, "next_random=true", &rcursor));
for (i = 0; i < 3; i++) {
testutil_check(rcursor->next(rcursor));
testutil_check(rcursor->get_key(rcursor, &key));
testutil_check(rcursor->get_value(rcursor, &value));
/* There should only be one value available to us */
testutil_assertfmt((uint64_t)key.data == NUM_DOCS - 1,
"expected %d and got %" PRIu64,
NUM_DOCS - 1, (uint64_t)key.data);
check_str((uint64_t)key.data, (char *)value.data, true);
}
printf("Found the deleted doc 3 times\n");
testutil_check(rcursor->close(rcursor));
/* Repopulate the table for compact. */
testutil_check(session->open_cursor(
session, name, NULL, "overwrite", &wcursor));
for (i = 0; i < NUM_DOCS - 1; i++) {
wcursor->set_key(wcursor, i);
rand_str(i, str);
str[0] = 'A';
wcursor->set_value(wcursor, str);
testutil_check(wcursor->insert(wcursor));
}
testutil_check(wcursor->close(wcursor));
/* Run random cursor queries while compact is running */
testutil_check(session2->open_cursor(
session2, name, NULL, "next_random=true", &rcursor));
testutil_check(pthread_create(&thread, NULL, compact_thread, session));
query_docs(rcursor, true);
testutil_check(rcursor->close(rcursor));
testutil_check(pthread_join(thread, NULL));
/* Delete everything. Check for infinite loops */
testutil_check(session->open_cursor(
session, name, NULL, "overwrite", &wcursor));
for (i = 0; i < NUM_DOCS; i++) {
wcursor->set_key(wcursor, i);
testutil_check(wcursor->remove(wcursor));
}
testutil_check(wcursor->close(wcursor));
testutil_check(session2->open_cursor(
session2, name, NULL, "next_random=true", &rcursor));
for (i = 0; i < 3; i++)
testutil_assert(rcursor->next(rcursor) == WT_NOTFOUND);
printf("Successfully got WT_NOTFOUND\n");
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
TEST_OPTS *opts, _opts;
WT_CURSOR *cursor;
WT_SESSION *session;
pthread_t thr[NR_THREADS];
size_t t;
uint64_t f[NR_FIELDS], r, ts;
int i, ret;
char table_format[256];
opts = &_opts;
memset(opts, 0, sizeof(*opts));
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_check(wiredtiger_open(opts->home, NULL,
"create,cache_size=1G,checkpoint=(wait=30),"
"eviction_trigger=80,eviction_target=64,eviction_dirty_target=65,"
"log=(enabled,file_max=10M),"
"transaction_sync=(enabled=true,method=none)", &opts->conn));
testutil_check(opts->conn->open_session(
opts->conn, NULL, NULL, &session));
sprintf(table_format, "key_format=r,value_format=");
for (i = 0; i < NR_FIELDS; i++)
strcat(table_format, "Q");
/* recno -> timestamp + NR_FIELDS * Q */
testutil_check(session->create(
session, opts->uri, table_format));
/* timestamp -> recno */
testutil_check(session->create(session,
"table:index", "key_format=Q,value_format=Q"));
testutil_check(session->close(session, NULL));
for (t = 0; t < NR_THREADS; ++t)
testutil_check(pthread_create(
&thr[t], NULL, thread_func, (void *)opts));
for (t = 0; t < NR_THREADS; ++t)
(void)pthread_join(thr[t], NULL);
testutil_check(opts->conn->open_session(
opts->conn, NULL, NULL, &session));
/* recno -> timestamp + NR_FIELDS * Q */
testutil_check(session->create(session, opts->uri, table_format));
testutil_check(session->open_cursor(
session, opts->uri, NULL, NULL, &cursor));
while ((ret = cursor->next(cursor)) == 0) {
testutil_check(cursor->get_key(cursor, &r));
testutil_check(cursor->get_value(cursor, &ts,
&f[0], &f[1], &f[2], &f[3], &f[4], &f[5], &f[6], &f[7]));
if (!opts->verbose)
continue;
printf("(%" PRIu64 ",%llu)\t\t%" PRIu64,
(r >> 40), r & ((1ULL << 40) - 1), ts);
for (i = 0; i < NR_FIELDS; i++)
printf("\t%" PRIu64, f[i]);
printf("\n");
}
testutil_assert(ret == WT_NOTFOUND);
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
WT_CONNECTION *conn, *conn2, *conn3, *conn4;
WT_CURSOR *cursor;
WT_ITEM data;
WT_SESSION *session;
uint64_t i;
int ch, status, op, ret;
bool child;
const char *working_dir;
char cmd[512];
uint8_t buf[MAX_VAL];
if ((progname = strrchr(argv[0], DIR_DELIM)) == NULL)
progname = argv[0];
else
++progname;
/*
* Needed unaltered for system command later.
*/
saved_argv0 = argv[0];
working_dir = "WT_RD";
child = false;
op = OP_READ;
while ((ch = __wt_getopt(progname, argc, argv, "Rh:W")) != EOF)
switch (ch) {
case 'R':
child = true;
op = OP_READ;
break;
case 'W':
child = true;
op = OP_WRITE;
break;
case 'h':
working_dir = __wt_optarg;
break;
default:
usage();
}
argc -= __wt_optind;
argv += __wt_optind;
if (argc != 0)
usage();
/*
* Set up all the directory names.
*/
testutil_work_dir_from_path(home, sizeof(home), working_dir);
(void)snprintf(home_wr, sizeof(home_wr), "%s%s", home, HOME_WR_SUFFIX);
(void)snprintf(home_rd, sizeof(home_rd), "%s%s", home, HOME_RD_SUFFIX);
(void)snprintf(
home_rd2, sizeof(home_rd2), "%s%s", home, HOME_RD2_SUFFIX);
if (!child) {
testutil_make_work_dir(home);
testutil_make_work_dir(home_wr);
testutil_make_work_dir(home_rd);
testutil_make_work_dir(home_rd2);
} else
/*
* We are a child process, we just want to call
* the open_dbs with the directories we have.
* The child function will exit.
*/
open_dbs(op, home, home_wr, home_rd, home_rd2);
/*
* Parent creates a database and table. Then cleanly shuts down.
* Then copy database to read-only directory and chmod.
* Also copy database to read-only directory and remove the lock
* file. One read-only database will have a lock file in the
* file system and the other will not.
* Parent opens all databases with read-only configuration flag.
* Parent forks off child who tries to also open all databases
* with the read-only flag. It should error on the writeable
* directory, but allow it on the read-only directories.
* The child then confirms it can read all the data.
*/
/*
* Run in the home directory and create the table.
*/
if ((ret = wiredtiger_open(home, NULL, ENV_CONFIG, &conn)) != 0)
testutil_die(ret, "wiredtiger_open");
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
testutil_die(ret, "WT_CONNECTION:open_session");
if ((ret = session->create(session,
uri, "key_format=Q,value_format=u")) != 0)
testutil_die(ret, "WT_SESSION.create: %s", uri);
if ((ret =
session->open_cursor(session, uri, NULL, NULL, &cursor)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", uri);
/*
* Write data into the table and then cleanly shut down connection.
*/
memset(buf, 0, sizeof(buf));
data.data = buf;
data.size = MAX_VAL;
for (i = 0; i < MAX_KV; ++i) {
cursor->set_key(cursor, i);
cursor->set_value(cursor, &data);
if ((ret = cursor->insert(cursor)) != 0)
testutil_die(ret, "WT_CURSOR.insert");
}
if ((ret = conn->close(conn, NULL)) != 0)
testutil_die(ret, "WT_CONNECTION:close");
/*
* Copy the database. Remove any lock file from one copy
* and chmod the copies to be read-only permissions.
*/
(void)snprintf(cmd, sizeof(cmd),
"cp -rp %s/* %s; rm -f %s/WiredTiger.lock",
home, home_wr, home_wr);
if ((status = system(cmd)) < 0)
testutil_die(status, "system: %s", cmd);
(void)snprintf(cmd, sizeof(cmd),
"cp -rp %s/* %s; chmod 0555 %s; chmod -R 0444 %s/*",
home, home_rd, home_rd, home_rd);
if ((status = system(cmd)) < 0)
testutil_die(status, "system: %s", cmd);
(void)snprintf(cmd, sizeof(cmd),
"cp -rp %s/* %s; rm -f %s/WiredTiger.lock; "
"chmod 0555 %s; chmod -R 0444 %s/*",
home, home_rd2, home_rd2, home_rd2, home_rd2);
if ((status = system(cmd)) < 0)
testutil_die(status, "system: %s", cmd);
/*
* Run four scenarios. Sometimes expect errors, sometimes success.
* The writable database directories should always fail to allow the
* child to open due to the lock file. The read-only ones will only
* succeed when the child attempts read-only.
*
* 1. Parent has read-only handle to all databases. Child opens
* read-only also.
* 2. Parent has read-only handle to all databases. Child opens
* read-write.
* 3. Parent has read-write handle to writable databases and
* read-only to read-only databases. Child opens read-only.
* 4. Parent has read-write handle to writable databases and
* read-only to read-only databases. Child opens read-write.
*/
/*
* Open a connection handle to all databases.
*/
fprintf(stderr, " *** Expect several error messages from WT ***\n");
/*
* Scenario 1.
*/
if ((ret = wiredtiger_open(home, NULL, ENV_CONFIG_RD, &conn)) != 0)
testutil_die(ret, "wiredtiger_open original home");
if ((ret = wiredtiger_open(home_wr, NULL, ENV_CONFIG_RD, &conn2)) != 0)
testutil_die(ret, "wiredtiger_open write nolock");
if ((ret = wiredtiger_open(home_rd, NULL, ENV_CONFIG_RD, &conn3)) != 0)
testutil_die(ret, "wiredtiger_open readonly");
if ((ret = wiredtiger_open(home_rd2, NULL, ENV_CONFIG_RD, &conn4)) != 0)
testutil_die(ret, "wiredtiger_open readonly nolock");
/*
* Create a child to also open a connection handle to the databases.
* We cannot use fork here because using fork the child inherits the
* same memory image. Therefore the WT process structure is set in
* the child even though it should not be. So use 'system' to spawn
* an entirely new process.
*
* The child will exit with success if its test passes.
*/
(void)snprintf(
cmd, sizeof(cmd), "%s -h %s -R", saved_argv0, working_dir);
if ((status = system(cmd)) < 0)
testutil_die(status, "system: %s", cmd);
if (WEXITSTATUS(status) != 0)
testutil_die(WEXITSTATUS(status), "system: %s", cmd);
/*
* Scenario 2. Run child with writable config.
*/
(void)snprintf(
cmd, sizeof(cmd), "%s -h %s -W", saved_argv0, working_dir);
if ((status = system(cmd)) < 0)
testutil_die(status, "system: %s", cmd);
if (WEXITSTATUS(status) != 0)
testutil_die(WEXITSTATUS(status), "system: %s", cmd);
/*
* Reopen the two writable directories and rerun the child.
*/
if ((ret = conn->close(conn, NULL)) != 0)
testutil_die(ret, "WT_CONNECTION:close");
if ((ret = conn2->close(conn2, NULL)) != 0)
testutil_die(ret, "WT_CONNECTION:close");
if ((ret = wiredtiger_open(home, NULL, ENV_CONFIG_RD, &conn)) != 0)
testutil_die(ret, "wiredtiger_open original home");
if ((ret = wiredtiger_open(home_wr, NULL, ENV_CONFIG_RD, &conn2)) != 0)
testutil_die(ret, "wiredtiger_open write nolock");
/*
* Scenario 3. Child read-only.
*/
(void)snprintf(
cmd, sizeof(cmd), "%s -h %s -R", saved_argv0, working_dir);
if ((status = system(cmd)) < 0)
testutil_die(status, "system: %s", cmd);
if (WEXITSTATUS(status) != 0)
testutil_die(WEXITSTATUS(status), "system: %s", cmd);
/*
* Scenario 4. Run child with writable config.
*/
(void)snprintf(
cmd, sizeof(cmd), "%s -h %s -W", saved_argv0, working_dir);
if ((status = system(cmd)) < 0)
testutil_die(status, "system: %s", cmd);
if (WEXITSTATUS(status) != 0)
testutil_die(WEXITSTATUS(status), "system: %s", cmd);
/*
* Clean-up.
*/
if ((ret = conn->close(conn, NULL)) != 0)
testutil_die(ret, "WT_CONNECTION:close");
if ((ret = conn2->close(conn2, NULL)) != 0)
testutil_die(ret, "WT_CONNECTION:close");
if ((ret = conn3->close(conn3, NULL)) != 0)
testutil_die(ret, "WT_CONNECTION:close");
if ((ret = conn4->close(conn4, NULL)) != 0)
testutil_die(ret, "WT_CONNECTION:close");
/*
* We need to chmod the read-only databases back so that they can
* be removed by scripts.
*/
(void)snprintf(cmd, sizeof(cmd), "chmod 0777 %s %s", home_rd, home_rd2);
if ((status = system(cmd)) < 0)
testutil_die(status, "system: %s", cmd);
(void)snprintf(cmd, sizeof(cmd), "chmod -R 0666 %s/* %s/*",
home_rd, home_rd2);
if ((status = system(cmd)) < 0)
testutil_die(status, "system: %s", cmd);
printf(" *** Readonly test successful ***\n");
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
TEST_OPTS *opts, _opts;
WT_CURSOR *c;
WT_SESSION *session;
clock_t ce, cs;
pthread_t id[100];
uint64_t current_value;
int i;
opts = &_opts;
if (testutil_disable_long_tests())
return (0);
memset(opts, 0, sizeof(*opts));
opts->nthreads = 10;
opts->nrecords = 1000;
opts->table_type = TABLE_ROW;
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_check(wiredtiger_open(opts->home, NULL,
"create,"
"cache_size=2G,"
"eviction=(threads_max=5),"
"statistics=(fast)", &opts->conn));
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
testutil_check(session->create(session, opts->uri,
"key_format=Q,value_format=Q,"
"leaf_page_max=32k,"));
/* Create the single record. */
testutil_check(
session->open_cursor(session, opts->uri, NULL, NULL, &c));
c->set_key(c, 1);
c->set_value(c, 0);
testutil_check(c->insert(c));
testutil_check(c->close(c));
cs = clock();
for (i = 0; i < (int)opts->nthreads; ++i) {
testutil_check(pthread_create(
&id[i], NULL, thread_insert_race, (void *)opts));
}
while (--i >= 0)
testutil_check(pthread_join(id[i], NULL));
testutil_check(
session->open_cursor(session, opts->uri, NULL, NULL, &c));
c->set_key(c, 1);
testutil_check(c->search(c));
testutil_check(c->get_value(c, ¤t_value));
if (current_value != opts->nthreads * opts->nrecords) {
fprintf(stderr,
"ERROR: didn't get expected number of changes\n");
fprintf(stderr, "got: %" PRIu64 ", expected: %" PRIu64 "\n",
current_value, opts->nthreads * opts->nrecords);
return (EXIT_FAILURE);
}
testutil_check(session->close(session, NULL));
ce = clock();
printf("%" PRIu64 ": %.2lf\n",
opts->nrecords, (ce - cs) / (double)CLOCKS_PER_SEC);
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
TEST_OPTS *opts, _opts;
WT_CURSOR *balancecur, *flagcur, *joincur, *postcur;
WT_CURSOR *maincur;
WT_SESSION *session;
int balance, count, flag, key, key2, post, ret;
char balanceuri[256];
char cfg[128];
char flaguri[256];
char joinuri[256];
char posturi[256];
const char *tablename;
opts = &_opts;
memset(opts, 0, sizeof(*opts));
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_progress(opts, "start");
testutil_check(wiredtiger_open(opts->home, NULL,
"create,cache_size=250M", &opts->conn));
testutil_progress(opts, "wiredtiger_open");
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
testutil_progress(opts, "sessions opened");
/*
* Note: repeated primary key 'id' as 'id2'. This makes
* it easier to dump an index and know which record we're
* looking at.
*/
testutil_check(session->create(session, opts->uri,
"key_format=i,value_format=iiii,"
"columns=(id,post,balance,flag,id2)"));
tablename = strchr(opts->uri, ':');
testutil_assert(tablename != NULL);
tablename++;
testutil_check(__wt_snprintf(
posturi, sizeof(posturi), "index:%s:post", tablename));
testutil_check(__wt_snprintf(
balanceuri, sizeof(balanceuri), "index:%s:balance", tablename));
testutil_check(__wt_snprintf(
flaguri, sizeof(flaguri), "index:%s:flag", tablename));
testutil_check(__wt_snprintf(
joinuri, sizeof(joinuri), "join:%s", opts->uri));
testutil_check(session->create(session, posturi, "columns=(post)"));
testutil_check(session->create(session, balanceuri,
"columns=(balance)"));
testutil_check(session->create(session, flaguri, "columns=(flag)"));
testutil_progress(opts, "setup complete");
/*
* Insert a single record with all items we are search for,
* this makes our logic easier.
*/
testutil_check(session->open_cursor(session, opts->uri, NULL, NULL,
&maincur));
maincur->set_key(maincur, N_RECORDS);
maincur->set_value(maincur, 54321, 0, "", 0, N_RECORDS);
testutil_check(maincur->insert(maincur));
testutil_check(maincur->close(maincur));
testutil_check(session->close(session, NULL));
testutil_progress(opts, "populate start");
populate(opts);
testutil_progress(opts, "populate end");
testutil_check(opts->conn->open_session(
opts->conn, NULL, NULL, &session));
testutil_check(session->open_cursor(session,
posturi, NULL, NULL, &postcur));
testutil_check(session->open_cursor(session,
balanceuri, NULL, NULL, &balancecur));
testutil_check(session->open_cursor(session,
flaguri, NULL, NULL, &flagcur));
testutil_check(session->open_cursor(session,
joinuri, NULL, NULL, &joincur));
postcur->set_key(postcur, 54321);
testutil_check(postcur->search(postcur));
testutil_check(session->join(session, joincur, postcur,
"compare=eq"));
balancecur->set_key(balancecur, 0);
testutil_check(balancecur->search(balancecur));
testutil_check(__wt_snprintf(cfg, sizeof(cfg),
"compare=lt,strategy=bloom,count=%d", N_RECORDS / 100));
testutil_check(session->join(session, joincur, balancecur, cfg));
flagcur->set_key(flagcur, 0);
testutil_check(flagcur->search(flagcur));
testutil_check(__wt_snprintf(cfg, sizeof(cfg),
"compare=eq,strategy=bloom,count=%d", N_RECORDS / 100));
testutil_check(session->join(session, joincur, flagcur, cfg));
/* Expect no values returned */
count = 0;
while ((ret = joincur->next(joincur)) == 0) {
/*
* The values may already have been changed, but
* print them for informational purposes.
*/
testutil_check(joincur->get_key(joincur, &key));
testutil_check(joincur->get_value(joincur, &post,
&balance, &flag, &key2));
fprintf(stderr, "FAIL: "
"key=%d/%d, postal_code=%d, balance=%d, flag=%d\n",
key, key2, post, balance, flag);
count++;
}
testutil_assert(ret == WT_NOTFOUND);
testutil_assert(count == 0);
testutil_progress(opts, "cleanup starting");
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
struct stat sb;
FILE *fp;
WT_CONNECTION *conn;
WT_CURSOR *cur_coll, *cur_local, *cur_oplog, *cur_stable;
WT_RAND_STATE rnd;
WT_SESSION *session;
pid_t pid;
uint64_t absent_coll, absent_local, absent_oplog, count, key, last_key;
uint64_t first_miss, middle_coll, middle_local, middle_oplog;
uint64_t stable_fp, stable_val, val[MAX_TH+1];
uint32_t i, nth, timeout;
int ch, status, ret;
const char *working_dir;
char buf[512], fname[64], kname[64], statname[1024];
bool fatal, rand_th, rand_time, verify_only;
(void)testutil_set_progname(argv);
compat = inmem = false;
use_ts = true;
nth = MIN_TH;
rand_th = rand_time = true;
timeout = MIN_TIME;
verify_only = false;
working_dir = "WT_TEST.timestamp-abort";
while ((ch = __wt_getopt(progname, argc, argv, "Ch:mT:t:vz")) != EOF)
switch (ch) {
case 'C':
compat = true;
break;
case 'h':
working_dir = __wt_optarg;
break;
case 'm':
inmem = true;
break;
case 'T':
rand_th = false;
nth = (uint32_t)atoi(__wt_optarg);
break;
case 't':
rand_time = false;
timeout = (uint32_t)atoi(__wt_optarg);
break;
case 'v':
verify_only = true;
break;
case 'z':
use_ts = false;
break;
default:
usage();
}
argc -= __wt_optind;
argv += __wt_optind;
if (argc != 0)
usage();
testutil_work_dir_from_path(home, sizeof(home), working_dir);
/*
* If the user wants to verify they need to tell us how many threads
* there were so we can find the old record files.
*/
if (verify_only && rand_th) {
fprintf(stderr,
"Verify option requires specifying number of threads\n");
exit (EXIT_FAILURE);
}
if (!verify_only) {
testutil_make_work_dir(home);
__wt_random_init_seed(NULL, &rnd);
if (rand_time) {
timeout = __wt_random(&rnd) % MAX_TIME;
if (timeout < MIN_TIME)
timeout = MIN_TIME;
}
if (rand_th) {
nth = __wt_random(&rnd) % MAX_TH;
if (nth < MIN_TH)
nth = MIN_TH;
}
printf("Parent: compatibility: %s, "
"in-mem log sync: %s, timestamp in use: %s\n",
compat ? "true" : "false",
inmem ? "true" : "false",
use_ts ? "true" : "false");
printf("Parent: Create %" PRIu32
" threads; sleep %" PRIu32 " seconds\n", nth, timeout);
/*
* Fork a child to insert as many items. We will then randomly
* kill the child, run recovery and make sure all items we wrote
* exist after recovery runs.
*/
testutil_checksys((pid = fork()) < 0);
if (pid == 0) { /* child */
run_workload(nth);
return (EXIT_SUCCESS);
}
/* parent */
/*
* Sleep for the configured amount of time before killing
* the child. Start the timeout from the time we notice that
* the file has been created. That allows the test to run
* correctly on really slow machines. Verify the process ID
* still exists in case the child aborts for some reason we
* don't stay in this loop forever.
*/
testutil_check(__wt_snprintf(
statname, sizeof(statname), "%s/%s", home, ckpt_file));
while (stat(statname, &sb) != 0 && kill(pid, 0) == 0)
sleep(1);
sleep(timeout);
/*
* !!! It should be plenty long enough to make sure more than
* one log file exists. If wanted, that check would be added
* here.
*/
printf("Kill child\n");
testutil_checksys(kill(pid, SIGKILL) != 0);
testutil_checksys(waitpid(pid, &status, 0) == -1);
}
/*
* !!! If we wanted to take a copy of the directory before recovery,
* this is the place to do it.
*/
if (chdir(home) != 0)
testutil_die(errno, "parent chdir: %s", home);
testutil_check(__wt_snprintf(buf, sizeof(buf),
"rm -rf ../%s.SAVE && mkdir ../%s.SAVE && "
"cp -p WiredTigerLog.* ../%s.SAVE",
home, home, home));
(void)system(buf);
printf("Open database, run recovery and verify content\n");
/*
* Open the connection which forces recovery to be run.
*/
if ((ret = wiredtiger_open(NULL, NULL, ENV_CONFIG_REC, &conn)) != 0)
testutil_die(ret, "wiredtiger_open");
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
testutil_die(ret, "WT_CONNECTION:open_session");
/*
* Open a cursor on all the tables.
*/
if ((ret = session->open_cursor(session,
uri_collection, NULL, NULL, &cur_coll)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", uri_collection);
if ((ret = session->open_cursor(session,
uri_local, NULL, NULL, &cur_local)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", uri_local);
if ((ret = session->open_cursor(session,
uri_oplog, NULL, NULL, &cur_oplog)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", uri_oplog);
if ((ret = session->open_cursor(session,
stable_store, NULL, NULL, &cur_stable)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", stable_store);
/*
* Find the biggest stable timestamp value that was saved.
*/
stable_val = 0;
memset(val, 0, sizeof(val));
while (cur_stable->next(cur_stable) == 0) {
cur_stable->get_key(cur_stable, &key);
cur_stable->get_value(cur_stable, &val[key]);
if (val[key] > stable_val)
stable_val = val[key];
if (use_ts)
printf("Stable: key %" PRIu64 " value %" PRIu64 "\n",
key, val[key]);
}
if (use_ts)
printf("Got stable_val %" PRIu64 "\n", stable_val);
count = 0;
absent_coll = absent_local = absent_oplog = 0;
fatal = false;
for (i = 1; i <= nth; ++i) {
first_miss = middle_coll = middle_local = middle_oplog = 0;
testutil_check(__wt_snprintf(
fname, sizeof(fname), RECORDS_FILE, i));
if ((fp = fopen(fname, "r")) == NULL)
testutil_die(errno, "fopen: %s", fname);
/*
* For every key in the saved file, verify that the key exists
* in the table after recovery. If we're doing in-memory
* log buffering we never expect a record missing in the middle,
* but records may be missing at the end. If we did
* write-no-sync, we expect every key to have been recovered.
*/
for (last_key = UINT64_MAX;; ++count, last_key = key) {
ret = fscanf(fp, "%" SCNu64 "%" SCNu64 "\n",
&stable_fp, &key);
if (ret != EOF && ret != 2) {
/*
* If we find a partial line, consider it
* like an EOF.
*/
if (ret == 1 || ret == 0)
break;
testutil_die(errno, "fscanf");
}
if (ret == EOF)
break;
/*
* If we're unlucky, the last line may be a partially
* written key at the end that can result in a false
* negative error for a missing record. Detect it.
*/
if (last_key != UINT64_MAX && key != last_key + 1) {
printf("%s: Ignore partial record %" PRIu64
" last valid key %" PRIu64 "\n",
fname, key, last_key);
break;
}
testutil_check(__wt_snprintf(
kname, sizeof(kname), "%" PRIu64, key));
cur_coll->set_key(cur_coll, kname);
cur_local->set_key(cur_local, kname);
cur_oplog->set_key(cur_oplog, kname);
/*
* The collection table should always only have the
* data as of the checkpoint.
*/
if ((ret = cur_coll->search(cur_coll)) != 0) {
if (ret != WT_NOTFOUND)
testutil_die(ret, "search");
/*
* If we don't find a record, the stable
* timestamp written to our file better be
* larger than the saved one.
*/
if (!inmem &&
stable_fp != 0 && stable_fp <= val[i]) {
printf("%s: COLLECTION no record with "
"key %" PRIu64 " record ts %" PRIu64
" <= stable ts %" PRIu64 "\n",
fname, key, stable_fp, val[i]);
absent_coll++;
}
if (middle_coll == 0)
first_miss = key;
middle_coll = key;
} else if (middle_coll != 0) {
/*
* We should never find an existing key after
* we have detected one missing.
*/
printf("%s: COLLECTION after absent records %"
PRIu64 "-%" PRIu64 " key %" PRIu64
" exists\n",
fname, first_miss, middle_coll, key);
fatal = true;
}
/*
* The local table should always have all data.
*/
if ((ret = cur_local->search(cur_local)) != 0) {
if (ret != WT_NOTFOUND)
testutil_die(ret, "search");
if (!inmem)
printf("%s: LOCAL no record with key %"
PRIu64 "\n", fname, key);
absent_local++;
middle_local = key;
} else if (middle_local != 0) {
/*
* We should never find an existing key after
* we have detected one missing.
*/
printf("%s: LOCAL after absent record at %"
PRIu64 " key %" PRIu64 " exists\n",
fname, middle_local, key);
fatal = true;
}
/*
* The oplog table should always have all data.
*/
if ((ret = cur_oplog->search(cur_oplog)) != 0) {
if (ret != WT_NOTFOUND)
testutil_die(ret, "search");
if (!inmem)
printf("%s: OPLOG no record with key %"
PRIu64 "\n", fname, key);
absent_oplog++;
middle_oplog = key;
} else if (middle_oplog != 0) {
/*
* We should never find an existing key after
* we have detected one missing.
*/
printf("%s: OPLOG after absent record at %"
PRIu64 " key %" PRIu64 " exists\n",
fname, middle_oplog, key);
fatal = true;
}
}
testutil_checksys(fclose(fp) != 0);
}
if ((ret = conn->close(conn, NULL)) != 0)
testutil_die(ret, "WT_CONNECTION:close");
if (fatal)
return (EXIT_FAILURE);
if (!inmem && absent_coll) {
printf("COLLECTION: %" PRIu64
" record(s) absent from %" PRIu64 "\n",
absent_coll, count);
fatal = true;
}
if (!inmem && absent_local) {
printf("LOCAL: %" PRIu64 " record(s) absent from %" PRIu64 "\n",
absent_local, count);
fatal = true;
}
if (!inmem && absent_oplog) {
printf("OPLOG: %" PRIu64 " record(s) absent from %" PRIu64 "\n",
absent_oplog, count);
fatal = true;
}
if (fatal)
return (EXIT_FAILURE);
printf("%" PRIu64 " records verified\n", count);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
/*
* Add a bunch of tables so that some of the metadata ends up on
* other pages and a good number of tables are available after
* salvage completes.
*/
TABLE_INFO table_data[] = {
{ "file:aaa-file.SS", "key_format=S,value_format=S", false },
{ "file:bbb-file.rS", "key_format=r,value_format=S", false },
{ "lsm:ccc-lsm.SS", "key_format=S,value_format=S", false },
{ "table:ddd-table.SS", "key_format=S,value_format=S", false },
{ "table:eee-table.rS", "key_format=r,value_format=S", false },
{ "file:fff-file.SS", "key_format=S,value_format=S", false },
{ "file:ggg-file.rS", "key_format=r,value_format=S", false },
{ "lsm:hhh-lsm.SS", "key_format=S,value_format=S", false },
{ "table:iii-table.SS", "key_format=S,value_format=S", false },
{ "table:jjj-table.rS", "key_format=r,value_format=S", false },
{ CORRUPT, "key_format=S,value_format=S", false },
{ NULL, NULL, false }
};
TABLE_INFO *t;
TEST_OPTS *opts, _opts;
int ret;
char buf[1024];
opts = &_opts;
memset(opts, 0, sizeof(*opts));
testutil_check(testutil_parse_opts(argc, argv, opts));
/*
* Set a global. We use this everywhere.
*/
home = opts->home;
testutil_make_work_dir(home);
testutil_check(
wiredtiger_open(home, &event_handler, "create", &opts->conn));
testutil_check(opts->conn->open_session(
opts->conn, NULL, NULL, &wt_session));
/*
* Create a bunch of different tables.
*/
for (t = table_data; t->name != NULL; t++)
create_data(t);
/*
* Take some checkpoints and add more data for out of sync testing.
*/
make_database_copies(table_data);
testutil_check(opts->conn->close(opts->conn, NULL));
opts->conn = NULL;
/*
* Make copy of original directory.
*/
copy_database(SAVE);
/*
* Damage/corrupt WiredTiger.wt.
*/
printf("corrupt metadata\n");
corrupt_metadata();
testutil_check(__wt_snprintf(buf, sizeof(buf),
"cp -p %s/WiredTiger.wt ./%s.SAVE/WiredTiger.wt.CORRUPT",
home, home));
printf("copy: %s\n", buf);
if ((ret = system(buf)) < 0)
testutil_die(ret, "system: %s", buf);
run_all_verification(NULL, &table_data[0]);
out_of_sync(&table_data[0]);
/*
* We need to set up the string before we clean up
* the structure. Then after the clean up we will
* run this command.
*/
testutil_check(__wt_snprintf(buf, sizeof(buf),
"rm -rf core* %s*", home));
testutil_cleanup(opts);
/*
* We've created a lot of extra directories and possibly some core
* files from child process aborts. Manually clean them up.
*/
printf("cleanup and remove: %s\n", buf);
if ((ret = system(buf)) < 0)
testutil_die(ret, "system: %s", buf);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
struct sigaction sa;
struct stat sb;
FILE *fp;
REPORT c_rep[MAX_TH], l_rep[MAX_TH], o_rep[MAX_TH];
WT_CONNECTION *conn;
WT_CURSOR *cur_coll, *cur_local, *cur_oplog;
WT_RAND_STATE rnd;
WT_SESSION *session;
pid_t pid;
uint64_t absent_coll, absent_local, absent_oplog, count, key, last_key;
uint64_t stable_fp, stable_val;
uint32_t i, nth, timeout;
int ch, status, ret;
const char *working_dir;
char buf[512], fname[64], kname[64], statname[1024];
char ts_string[WT_TS_HEX_STRING_SIZE];
bool fatal, rand_th, rand_time, verify_only;
(void)testutil_set_progname(argv);
compat = inmem = false;
use_ts = true;
nth = MIN_TH;
rand_th = rand_time = true;
timeout = MIN_TIME;
verify_only = false;
working_dir = "WT_TEST.timestamp-abort";
while ((ch = __wt_getopt(progname, argc, argv, "Ch:LmT:t:vz")) != EOF)
switch (ch) {
case 'C':
compat = true;
break;
case 'h':
working_dir = __wt_optarg;
break;
case 'L':
table_pfx = "lsm";
break;
case 'm':
inmem = true;
break;
case 'T':
rand_th = false;
nth = (uint32_t)atoi(__wt_optarg);
if (nth > MAX_TH) {
fprintf(stderr,
"Number of threads is larger than the"
" maximum %" PRId32 "\n", MAX_TH);
return (EXIT_FAILURE);
}
break;
case 't':
rand_time = false;
timeout = (uint32_t)atoi(__wt_optarg);
break;
case 'v':
verify_only = true;
break;
case 'z':
use_ts = false;
break;
default:
usage();
}
argc -= __wt_optind;
if (argc != 0)
usage();
testutil_work_dir_from_path(home, sizeof(home), working_dir);
testutil_check(pthread_rwlock_init(&ts_lock, NULL));
/*
* If the user wants to verify they need to tell us how many threads
* there were so we can find the old record files.
*/
if (verify_only && rand_th) {
fprintf(stderr,
"Verify option requires specifying number of threads\n");
exit (EXIT_FAILURE);
}
if (!verify_only) {
testutil_make_work_dir(home);
__wt_random_init_seed(NULL, &rnd);
if (rand_time) {
timeout = __wt_random(&rnd) % MAX_TIME;
if (timeout < MIN_TIME)
timeout = MIN_TIME;
}
if (rand_th) {
nth = __wt_random(&rnd) % MAX_TH;
if (nth < MIN_TH)
nth = MIN_TH;
}
printf("Parent: compatibility: %s, "
"in-mem log sync: %s, timestamp in use: %s\n",
compat ? "true" : "false",
inmem ? "true" : "false",
use_ts ? "true" : "false");
printf("Parent: Create %" PRIu32
" threads; sleep %" PRIu32 " seconds\n", nth, timeout);
printf("CONFIG: %s%s%s%s -h %s -T %" PRIu32 " -t %" PRIu32 "\n",
progname,
compat ? " -C" : "",
inmem ? " -m" : "",
!use_ts ? " -z" : "",
working_dir, nth, timeout);
/*
* Fork a child to insert as many items. We will then randomly
* kill the child, run recovery and make sure all items we wrote
* exist after recovery runs.
*/
memset(&sa, 0, sizeof(sa));
sa.sa_handler = handler;
testutil_checksys(sigaction(SIGCHLD, &sa, NULL));
testutil_checksys((pid = fork()) < 0);
if (pid == 0) { /* child */
run_workload(nth);
return (EXIT_SUCCESS);
}
/* parent */
/*
* Sleep for the configured amount of time before killing
* the child. Start the timeout from the time we notice that
* the file has been created. That allows the test to run
* correctly on really slow machines.
*/
testutil_check(__wt_snprintf(
statname, sizeof(statname), "%s/%s", home, ckpt_file));
while (stat(statname, &sb) != 0)
testutil_sleep_wait(1, pid);
sleep(timeout);
sa.sa_handler = SIG_DFL;
testutil_checksys(sigaction(SIGCHLD, &sa, NULL));
/*
* !!! It should be plenty long enough to make sure more than
* one log file exists. If wanted, that check would be added
* here.
*/
printf("Kill child\n");
testutil_checksys(kill(pid, SIGKILL) != 0);
testutil_checksys(waitpid(pid, &status, 0) == -1);
}
/*
* !!! If we wanted to take a copy of the directory before recovery,
* this is the place to do it. Don't do it all the time because
* it can use a lot of disk space, which can cause test machine
* issues.
*/
if (chdir(home) != 0)
testutil_die(errno, "parent chdir: %s", home);
/*
* The tables can get very large, so while we'd ideally like to
* copy the entire database, we only copy the log files for now.
* Otherwise it can take far too long to run the test, particularly
* in automated testing.
*/
testutil_check(__wt_snprintf(buf, sizeof(buf),
"rm -rf ../%s.SAVE && mkdir ../%s.SAVE && "
"cp -p * ../%s.SAVE",
home, home, home));
if ((status = system(buf)) < 0)
testutil_die(status, "system: %s", buf);
printf("Open database, run recovery and verify content\n");
/*
* Open the connection which forces recovery to be run.
*/
testutil_check(wiredtiger_open(NULL, NULL, ENV_CONFIG_REC, &conn));
testutil_check(conn->open_session(conn, NULL, NULL, &session));
/*
* Open a cursor on all the tables.
*/
testutil_check(__wt_snprintf(
buf, sizeof(buf), "%s:%s", table_pfx, uri_collection));
testutil_check(session->open_cursor(session,
buf, NULL, NULL, &cur_coll));
testutil_check(__wt_snprintf(
buf, sizeof(buf), "%s:%s", table_pfx, uri_local));
testutil_check(session->open_cursor(session,
buf, NULL, NULL, &cur_local));
testutil_check(__wt_snprintf(
buf, sizeof(buf), "%s:%s", table_pfx, uri_oplog));
testutil_check(session->open_cursor(session,
buf, NULL, NULL, &cur_oplog));
/*
* Find the biggest stable timestamp value that was saved.
*/
stable_val = 0;
if (use_ts) {
testutil_check(
conn->query_timestamp(conn, ts_string, "get=recovery"));
testutil_assert(
sscanf(ts_string, "%" SCNx64, &stable_val) == 1);
printf("Got stable_val %" PRIu64 "\n", stable_val);
}
count = 0;
absent_coll = absent_local = absent_oplog = 0;
fatal = false;
for (i = 0; i < nth; ++i) {
initialize_rep(&c_rep[i]);
initialize_rep(&l_rep[i]);
initialize_rep(&o_rep[i]);
testutil_check(__wt_snprintf(
fname, sizeof(fname), RECORDS_FILE, i));
if ((fp = fopen(fname, "r")) == NULL)
testutil_die(errno, "fopen: %s", fname);
/*
* For every key in the saved file, verify that the key exists
* in the table after recovery. If we're doing in-memory
* log buffering we never expect a record missing in the middle,
* but records may be missing at the end. If we did
* write-no-sync, we expect every key to have been recovered.
*/
for (last_key = INVALID_KEY;; ++count, last_key = key) {
ret = fscanf(fp, "%" SCNu64 "%" SCNu64 "\n",
&stable_fp, &key);
if (last_key == INVALID_KEY) {
c_rep[i].first_key = key;
l_rep[i].first_key = key;
o_rep[i].first_key = key;
}
if (ret != EOF && ret != 2) {
/*
* If we find a partial line, consider it
* like an EOF.
*/
if (ret == 1 || ret == 0)
break;
testutil_die(errno, "fscanf");
}
if (ret == EOF)
break;
/*
* If we're unlucky, the last line may be a partially
* written key at the end that can result in a false
* negative error for a missing record. Detect it.
*/
if (last_key != INVALID_KEY && key != last_key + 1) {
printf("%s: Ignore partial record %" PRIu64
" last valid key %" PRIu64 "\n",
fname, key, last_key);
break;
}
testutil_check(__wt_snprintf(
kname, sizeof(kname), "%" PRIu64, key));
cur_coll->set_key(cur_coll, kname);
cur_local->set_key(cur_local, kname);
cur_oplog->set_key(cur_oplog, kname);
/*
* The collection table should always only have the
* data as of the checkpoint.
*/
if ((ret = cur_coll->search(cur_coll)) != 0) {
if (ret != WT_NOTFOUND)
testutil_die(ret, "search");
/*
* If we don't find a record, the stable
* timestamp written to our file better be
* larger than the saved one.
*/
if (!inmem &&
stable_fp != 0 && stable_fp <= stable_val) {
printf("%s: COLLECTION no record with "
"key %" PRIu64 " record ts %" PRIu64
" <= stable ts %" PRIu64 "\n",
fname, key, stable_fp, stable_val);
absent_coll++;
}
if (c_rep[i].first_miss == INVALID_KEY)
c_rep[i].first_miss = key;
c_rep[i].absent_key = key;
} else if (c_rep[i].absent_key != INVALID_KEY &&
c_rep[i].exist_key == INVALID_KEY) {
/*
* If we get here we found a record that exists
* after absent records, a hole in our data.
*/
c_rep[i].exist_key = key;
fatal = true;
} else if (!inmem &&
stable_fp != 0 && stable_fp > stable_val) {
/*
* If we found a record, the stable timestamp
* written to our file better be no larger
* than the checkpoint one.
*/
printf("%s: COLLECTION record with "
"key %" PRIu64 " record ts %" PRIu64
" > stable ts %" PRIu64 "\n",
fname, key, stable_fp, stable_val);
fatal = true;
}
/*
* The local table should always have all data.
*/
if ((ret = cur_local->search(cur_local)) != 0) {
if (ret != WT_NOTFOUND)
testutil_die(ret, "search");
if (!inmem)
printf("%s: LOCAL no record with key %"
PRIu64 "\n", fname, key);
absent_local++;
if (l_rep[i].first_miss == INVALID_KEY)
l_rep[i].first_miss = key;
l_rep[i].absent_key = key;
} else if (l_rep[i].absent_key != INVALID_KEY &&
l_rep[i].exist_key == INVALID_KEY) {
/*
* We should never find an existing key after
* we have detected one missing.
*/
l_rep[i].exist_key = key;
fatal = true;
}
/*
* The oplog table should always have all data.
*/
if ((ret = cur_oplog->search(cur_oplog)) != 0) {
if (ret != WT_NOTFOUND)
testutil_die(ret, "search");
if (!inmem)
printf("%s: OPLOG no record with key %"
PRIu64 "\n", fname, key);
absent_oplog++;
if (o_rep[i].first_miss == INVALID_KEY)
o_rep[i].first_miss = key;
o_rep[i].absent_key = key;
} else if (o_rep[i].absent_key != INVALID_KEY &&
o_rep[i].exist_key == INVALID_KEY) {
/*
* We should never find an existing key after
* we have detected one missing.
*/
o_rep[i].exist_key = key;
fatal = true;
}
}
c_rep[i].last_key = last_key;
l_rep[i].last_key = last_key;
o_rep[i].last_key = last_key;
testutil_checksys(fclose(fp) != 0);
print_missing(&c_rep[i], fname, "COLLECTION");
print_missing(&l_rep[i], fname, "LOCAL");
print_missing(&o_rep[i], fname, "OPLOG");
}
testutil_check(conn->close(conn, NULL));
if (!inmem && absent_coll) {
printf("COLLECTION: %" PRIu64
" record(s) absent from %" PRIu64 "\n",
absent_coll, count);
fatal = true;
}
if (!inmem && absent_local) {
printf("LOCAL: %" PRIu64 " record(s) absent from %" PRIu64 "\n",
absent_local, count);
fatal = true;
}
if (!inmem && absent_oplog) {
printf("OPLOG: %" PRIu64 " record(s) absent from %" PRIu64 "\n",
absent_oplog, count);
fatal = true;
}
testutil_check(pthread_rwlock_destroy(&ts_lock));
if (fatal)
return (EXIT_FAILURE);
printf("%" PRIu64 " records verified\n", count);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
SHARED_OPTS *sharedopts, _sharedopts;
TEST_OPTS *opts, _opts;
THREAD_ARGS get_args[N_GET_THREAD], insert_args[N_INSERT_THREAD];
WT_CURSOR *maincur;
WT_SESSION *session;
pthread_t get_tid[N_GET_THREAD], insert_tid[N_INSERT_THREAD];
int i, nfail;
const char *tablename;
opts = &_opts;
sharedopts = &_sharedopts;
if (testutil_disable_long_tests())
return (0);
memset(opts, 0, sizeof(*opts));
memset(sharedopts, 0, sizeof(*sharedopts));
memset(insert_args, 0, sizeof(insert_args));
memset(get_args, 0, sizeof(get_args));
nfail = 0;
sharedopts->bloom = BLOOM;
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_check(wiredtiger_open(opts->home, NULL,
"create,cache_size=1G", &opts->conn));
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
/*
* Note: id is repeated as id2. This makes it easier to
* identify the primary key in dumps of the index files.
*/
testutil_check(session->create(session, opts->uri,
"key_format=i,value_format=iiSii,"
"columns=(id,post,bal,extra,flag,id2)"));
tablename = strchr(opts->uri, ':');
testutil_assert(tablename != NULL);
tablename++;
snprintf(sharedopts->posturi, sizeof(sharedopts->posturi),
"index:%s:post", tablename);
snprintf(sharedopts->baluri, sizeof(sharedopts->baluri),
"index:%s:bal", tablename);
snprintf(sharedopts->flaguri, sizeof(sharedopts->flaguri),
"index:%s:flag", tablename);
testutil_check(session->create(session, sharedopts->posturi,
"columns=(post)"));
testutil_check(session->create(session, sharedopts->baluri,
"columns=(bal)"));
testutil_check(session->create(session, sharedopts->flaguri,
"columns=(flag)"));
/*
* Insert a single record with all items we need to
* call search() on, this makes our join logic easier.
*/
testutil_check(session->open_cursor(session, opts->uri, NULL, NULL,
&maincur));
maincur->set_key(maincur, N_RECORDS);
maincur->set_value(maincur, 54321, 0, "", 0, N_RECORDS);
testutil_check(maincur->insert(maincur));
testutil_check(maincur->close(maincur));
testutil_check(session->close(session, NULL));
for (i = 0; i < N_INSERT_THREAD; ++i) {
insert_args[i].threadnum = i;
insert_args[i].nthread = N_INSERT_THREAD;
insert_args[i].testopts = opts;
insert_args[i].sharedopts = sharedopts;
testutil_check(pthread_create(&insert_tid[i], NULL,
thread_insert, (void *)&insert_args[i]));
}
for (i = 0; i < N_GET_THREAD; ++i) {
get_args[i].threadnum = i;
get_args[i].nthread = N_GET_THREAD;
get_args[i].testopts = opts;
get_args[i].sharedopts = sharedopts;
testutil_check(pthread_create(&get_tid[i], NULL,
thread_get, (void *)&get_args[i]));
}
/*
* Wait for insert threads to finish. When they
* are done, signal get threads to complete.
*/
for (i = 0; i < N_INSERT_THREAD; ++i)
testutil_check(pthread_join(insert_tid[i], NULL));
for (i = 0; i < N_GET_THREAD; ++i)
get_args[i].done = 1;
for (i = 0; i < N_GET_THREAD; ++i)
testutil_check(pthread_join(get_tid[i], NULL));
fprintf(stderr, "\n");
for (i = 0; i < N_GET_THREAD; ++i) {
fprintf(stderr, " thread %d did %d joins (%d fails)\n", i,
get_args[i].njoins, get_args[i].nfail);
nfail += get_args[i].nfail;
}
testutil_assert(nfail == 0);
testutil_cleanup(opts);
return (0);
}
