489 lines
13 KiB
C
489 lines
13 KiB
C
|
|
/*
|
|
** This file contains tests related to recovery following application
|
|
** and system crashes (power failures) while writing to the database.
|
|
*/
|
|
|
|
#include "lsmtest.h"
|
|
|
|
/*
|
|
** Structure used by testCksumDatabase() to accumulate checksum values in.
|
|
*/
|
|
typedef struct Cksum Cksum;
|
|
struct Cksum {
|
|
int nRow;
|
|
int cksum1;
|
|
int cksum2;
|
|
};
|
|
|
|
/*
|
|
** tdb_scan() callback used by testCksumDatabase()
|
|
*/
|
|
static void scanCksumDb(
|
|
void *pCtx,
|
|
void *pKey, int nKey,
|
|
void *pVal, int nVal
|
|
){
|
|
Cksum *p = (Cksum *)pCtx;
|
|
int i;
|
|
|
|
p->nRow++;
|
|
for(i=0; i<nKey; i++){
|
|
p->cksum1 += ((u8 *)pKey)[i];
|
|
p->cksum2 += p->cksum1;
|
|
}
|
|
for(i=0; i<nVal; i++){
|
|
p->cksum1 += ((u8 *)pVal)[i];
|
|
p->cksum2 += p->cksum1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** tdb_scan() callback used by testCountDatabase()
|
|
*/
|
|
static void scanCountDb(
|
|
void *pCtx,
|
|
void *pKey, int nKey,
|
|
void *pVal, int nVal
|
|
){
|
|
Cksum *p = (Cksum *)pCtx;
|
|
p->nRow++;
|
|
|
|
unused_parameter(pKey);
|
|
unused_parameter(nKey);
|
|
unused_parameter(pVal);
|
|
unused_parameter(nVal);
|
|
}
|
|
|
|
|
|
/*
|
|
** Iterate through the entire contents of database pDb. Write a checksum
|
|
** string based on the db contents into buffer zOut before returning. A
|
|
** checksum string is at most 29 (TEST_CKSUM_BYTES) bytes in size:
|
|
**
|
|
** * 32-bit integer (10 bytes)
|
|
** * 1 space (1 byte)
|
|
** * 32-bit hex (8 bytes)
|
|
** * 1 space (1 byte)
|
|
** * 32-bit hex (8 bytes)
|
|
** * nul-terminator (1 byte)
|
|
**
|
|
** The number of entries in the database is returned.
|
|
*/
|
|
int testCksumDatabase(
|
|
TestDb *pDb, /* Database handle */
|
|
char *zOut /* Buffer to write checksum to */
|
|
){
|
|
Cksum cksum;
|
|
memset(&cksum, 0, sizeof(Cksum));
|
|
tdb_scan(pDb, (void *)&cksum, 0, 0, 0, 0, 0, scanCksumDb);
|
|
sprintf(zOut, "%d %x %x",
|
|
cksum.nRow, (u32)cksum.cksum1, (u32)cksum.cksum2
|
|
);
|
|
assert( strlen(zOut)<TEST_CKSUM_BYTES );
|
|
return cksum.nRow;
|
|
}
|
|
|
|
int testCountDatabase(TestDb *pDb){
|
|
Cksum cksum;
|
|
memset(&cksum, 0, sizeof(Cksum));
|
|
tdb_scan(pDb, (void *)&cksum, 0, 0, 0, 0, 0, scanCountDb);
|
|
return cksum.nRow;
|
|
}
|
|
|
|
/*
|
|
** This function is a no-op if *pRc is not 0 when it is called.
|
|
**
|
|
** Otherwise, the two nul-terminated strings z1 and z1 are compared. If
|
|
** they are the same, the function returns without doing anything. Otherwise,
|
|
** an error message is printed, *pRc is set to 1 and the test_failed()
|
|
** function called.
|
|
*/
|
|
void testCompareStr(const char *z1, const char *z2, int *pRc){
|
|
if( *pRc==0 ){
|
|
if( strcmp(z1, z2) ){
|
|
testPrintError("testCompareStr: \"%s\" != \"%s\"\n", z1, z2);
|
|
*pRc = 1;
|
|
test_failed();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** This function is a no-op if *pRc is not 0 when it is called.
|
|
**
|
|
** Otherwise, the two integers i1 and i2 are compared. If they are equal,
|
|
** the function returns without doing anything. Otherwise, an error message
|
|
** is printed, *pRc is set to 1 and the test_failed() function called.
|
|
*/
|
|
void testCompareInt(int i1, int i2, int *pRc){
|
|
if( *pRc==0 && i1!=i2 ){
|
|
testPrintError("testCompareInt: %d != %d\n", i1, i2);
|
|
*pRc = 1;
|
|
test_failed();
|
|
}
|
|
}
|
|
|
|
void testCaseStart(int *pRc, char *zFmt, ...){
|
|
va_list ap;
|
|
va_start(ap, zFmt);
|
|
vprintf(zFmt, ap);
|
|
printf(" ...");
|
|
va_end(ap);
|
|
*pRc = 0;
|
|
fflush(stdout);
|
|
}
|
|
|
|
/*
|
|
** This function is a no-op if *pRc is non-zero when it is called. Zero
|
|
** is returned in this case.
|
|
**
|
|
** Otherwise, the zFmt (a printf style format string) and following arguments
|
|
** are used to create a test case name. If zPattern is NULL or a glob pattern
|
|
** that matches the test case name, 1 is returned and the test case started.
|
|
** Otherwise, zero is returned and the test case does not start.
|
|
*/
|
|
int testCaseBegin(int *pRc, const char *zPattern, const char *zFmt, ...){
|
|
int res = 0;
|
|
if( *pRc==0 ){
|
|
char *zTest;
|
|
va_list ap;
|
|
|
|
va_start(ap, zFmt);
|
|
zTest = testMallocVPrintf(zFmt, ap);
|
|
va_end(ap);
|
|
if( zPattern==0 || testGlobMatch(zPattern, zTest) ){
|
|
printf("%-50s ...", zTest);
|
|
res = 1;
|
|
}
|
|
testFree(zTest);
|
|
fflush(stdout);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
void testCaseFinish(int rc){
|
|
if( rc==0 ){
|
|
printf("Ok\n");
|
|
}else{
|
|
printf("FAILED\n");
|
|
}
|
|
fflush(stdout);
|
|
}
|
|
|
|
void testCaseSkip(){
|
|
printf("Skipped\n");
|
|
}
|
|
|
|
void testSetupSavedLsmdb(
|
|
const char *zCfg,
|
|
const char *zFile,
|
|
Datasource *pData,
|
|
int nRow,
|
|
int *pRc
|
|
){
|
|
if( *pRc==0 ){
|
|
int rc;
|
|
TestDb *pDb;
|
|
rc = tdb_lsm_open(zCfg, zFile, 1, &pDb);
|
|
if( rc==0 ){
|
|
testWriteDatasourceRange(pDb, pData, 0, nRow, &rc);
|
|
testClose(&pDb);
|
|
if( rc==0 ) testSaveDb(zFile, "log");
|
|
}
|
|
*pRc = rc;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** This function is a no-op if *pRc is non-zero when it is called.
|
|
**
|
|
** Open the LSM database identified by zFile and compute its checksum
|
|
** (a string, as returned by testCksumDatabase()). If the checksum is
|
|
** identical to zExpect1 or, if it is not NULL, zExpect2, the test passes.
|
|
** Otherwise, print an error message and set *pRc to 1.
|
|
*/
|
|
static void testCompareCksumLsmdb(
|
|
const char *zFile, /* Path to LSM database */
|
|
int bCompress, /* True if db is compressed */
|
|
const char *zExpect1, /* Expected checksum 1 */
|
|
const char *zExpect2, /* Expected checksum 2 (or NULL) */
|
|
int *pRc /* IN/OUT: Test case error code */
|
|
){
|
|
if( *pRc==0 ){
|
|
char zCksum[TEST_CKSUM_BYTES];
|
|
TestDb *pDb;
|
|
|
|
*pRc = tdb_lsm_open((bCompress?"compression=1 mmap=0":""), zFile, 0, &pDb);
|
|
testCksumDatabase(pDb, zCksum);
|
|
testClose(&pDb);
|
|
|
|
if( *pRc==0 ){
|
|
int r1 = 0;
|
|
int r2 = -1;
|
|
|
|
r1 = strcmp(zCksum, zExpect1);
|
|
if( zExpect2 ) r2 = strcmp(zCksum, zExpect2);
|
|
if( r1 && r2 ){
|
|
if( zExpect2 ){
|
|
testPrintError("testCompareCksumLsmdb: \"%s\" != (\"%s\" OR \"%s\")",
|
|
zCksum, zExpect1, zExpect2
|
|
);
|
|
}else{
|
|
testPrintError("testCompareCksumLsmdb: \"%s\" != \"%s\"",
|
|
zCksum, zExpect1
|
|
);
|
|
}
|
|
*pRc = 1;
|
|
test_failed();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#if 0 /* not used */
|
|
static void testCompareCksumBtdb(
|
|
const char *zFile, /* Path to LSM database */
|
|
const char *zExpect1, /* Expected checksum 1 */
|
|
const char *zExpect2, /* Expected checksum 2 (or NULL) */
|
|
int *pRc /* IN/OUT: Test case error code */
|
|
){
|
|
if( *pRc==0 ){
|
|
char zCksum[TEST_CKSUM_BYTES];
|
|
TestDb *pDb;
|
|
|
|
*pRc = tdb_open("bt", zFile, 0, &pDb);
|
|
testCksumDatabase(pDb, zCksum);
|
|
testClose(&pDb);
|
|
|
|
if( *pRc==0 ){
|
|
int r1 = 0;
|
|
int r2 = -1;
|
|
|
|
r1 = strcmp(zCksum, zExpect1);
|
|
if( zExpect2 ) r2 = strcmp(zCksum, zExpect2);
|
|
if( r1 && r2 ){
|
|
if( zExpect2 ){
|
|
testPrintError("testCompareCksumLsmdb: \"%s\" != (\"%s\" OR \"%s\")",
|
|
zCksum, zExpect1, zExpect2
|
|
);
|
|
}else{
|
|
testPrintError("testCompareCksumLsmdb: \"%s\" != \"%s\"",
|
|
zCksum, zExpect1
|
|
);
|
|
}
|
|
*pRc = 1;
|
|
test_failed();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif /* not used */
|
|
|
|
/* Above this point are reusable test routines. Not clear that they
|
|
** should really be in this file.
|
|
*************************************************************************/
|
|
|
|
/*
|
|
** This test verifies that if a system crash occurs while doing merge work
|
|
** on the db, no data is lost.
|
|
*/
|
|
static void crash_test1(int bCompress, int *pRc){
|
|
const char *DBNAME = "testdb.lsm";
|
|
const DatasourceDefn defn = {TEST_DATASOURCE_RANDOM, 12, 16, 200, 200};
|
|
|
|
const int nRow = 5000; /* Database size */
|
|
const int nIter = 200; /* Number of test iterations */
|
|
const int nWork = 20; /* Maximum lsm_work() calls per iteration */
|
|
const int nPage = 15; /* Pages per lsm_work call */
|
|
|
|
int i;
|
|
int iDot = 0;
|
|
Datasource *pData;
|
|
CksumDb *pCksumDb;
|
|
TestDb *pDb;
|
|
char *zCfg;
|
|
|
|
const char *azConfig[2] = {
|
|
"page_size=1024 block_size=65536 autoflush=16384 safety=2 mmap=0",
|
|
"page_size=1024 block_size=65536 autoflush=16384 safety=2 "
|
|
" compression=1 mmap=0"
|
|
};
|
|
assert( bCompress==0 || bCompress==1 );
|
|
|
|
/* Allocate datasource. And calculate the expected checksums. */
|
|
pData = testDatasourceNew(&defn);
|
|
pCksumDb = testCksumArrayNew(pData, nRow, nRow, 1);
|
|
|
|
/* Setup and save the initial database. */
|
|
|
|
zCfg = testMallocPrintf("%s automerge=7", azConfig[bCompress]);
|
|
testSetupSavedLsmdb(zCfg, DBNAME, pData, 5000, pRc);
|
|
testFree(zCfg);
|
|
|
|
for(i=0; i<nIter && *pRc==0; i++){
|
|
int iWork;
|
|
int testrc = 0;
|
|
|
|
testCaseProgress(i, nIter, testCaseNDot(), &iDot);
|
|
|
|
/* Restore and open the database. */
|
|
testRestoreDb(DBNAME, "log");
|
|
testrc = tdb_lsm_open(azConfig[bCompress], DBNAME, 0, &pDb);
|
|
assert( testrc==0 );
|
|
|
|
/* Call lsm_work() on the db */
|
|
tdb_lsm_prepare_sync_crash(pDb, 1 + (i%(nWork*2)));
|
|
for(iWork=0; testrc==0 && iWork<nWork; iWork++){
|
|
int nWrite = 0;
|
|
lsm_db *db = tdb_lsm(pDb);
|
|
testrc = lsm_work(db, 0, nPage, &nWrite);
|
|
/* assert( testrc!=0 || nWrite>0 ); */
|
|
if( testrc==0 ) testrc = lsm_checkpoint(db, 0);
|
|
}
|
|
tdb_close(pDb);
|
|
|
|
/* Check that the database content is still correct */
|
|
testCompareCksumLsmdb(DBNAME,
|
|
bCompress, testCksumArrayGet(pCksumDb, nRow), 0, pRc);
|
|
}
|
|
|
|
testCksumArrayFree(pCksumDb);
|
|
testDatasourceFree(pData);
|
|
}
|
|
|
|
/*
|
|
** This test verifies that if a system crash occurs while committing a
|
|
** transaction to the log file, no earlier transactions are lost or damaged.
|
|
*/
|
|
static void crash_test2(int bCompress, int *pRc){
|
|
const char *DBNAME = "testdb.lsm";
|
|
const DatasourceDefn defn = {TEST_DATASOURCE_RANDOM, 12, 16, 1000, 1000};
|
|
|
|
const int nIter = 200;
|
|
const int nInsert = 20;
|
|
|
|
int i;
|
|
int iDot = 0;
|
|
Datasource *pData;
|
|
CksumDb *pCksumDb;
|
|
TestDb *pDb;
|
|
|
|
/* Allocate datasource. And calculate the expected checksums. */
|
|
pData = testDatasourceNew(&defn);
|
|
pCksumDb = testCksumArrayNew(pData, 100, 100+nInsert, 1);
|
|
|
|
/* Setup and save the initial database. */
|
|
testSetupSavedLsmdb("", DBNAME, pData, 100, pRc);
|
|
|
|
for(i=0; i<nIter && *pRc==0; i++){
|
|
int iIns;
|
|
int testrc = 0;
|
|
|
|
testCaseProgress(i, nIter, testCaseNDot(), &iDot);
|
|
|
|
/* Restore and open the database. */
|
|
testRestoreDb(DBNAME, "log");
|
|
testrc = tdb_lsm_open("safety=2", DBNAME, 0, &pDb);
|
|
assert( testrc==0 );
|
|
|
|
/* Insert nInsert records into the database. Crash midway through. */
|
|
tdb_lsm_prepare_sync_crash(pDb, 1 + (i%(nInsert+2)));
|
|
for(iIns=0; iIns<nInsert; iIns++){
|
|
void *pKey; int nKey;
|
|
void *pVal; int nVal;
|
|
|
|
testDatasourceEntry(pData, 100+iIns, &pKey, &nKey, &pVal, &nVal);
|
|
testrc = tdb_write(pDb, pKey, nKey, pVal, nVal);
|
|
if( testrc ) break;
|
|
}
|
|
tdb_close(pDb);
|
|
|
|
/* Check that no data was lost when the system crashed. */
|
|
testCompareCksumLsmdb(DBNAME, bCompress,
|
|
testCksumArrayGet(pCksumDb, 100 + iIns),
|
|
testCksumArrayGet(pCksumDb, 100 + iIns + 1),
|
|
pRc
|
|
);
|
|
}
|
|
|
|
testDatasourceFree(pData);
|
|
testCksumArrayFree(pCksumDb);
|
|
}
|
|
|
|
|
|
/*
|
|
** This test verifies that if a system crash occurs when checkpointing
|
|
** the database, data is not lost (assuming that any writes not synced
|
|
** to the db have been synced into the log file).
|
|
*/
|
|
static void crash_test3(int bCompress, int *pRc){
|
|
const char *DBNAME = "testdb.lsm";
|
|
const int nIter = 100;
|
|
const DatasourceDefn defn = {TEST_DATASOURCE_RANDOM, 12, 16, 1000, 1000};
|
|
|
|
int i;
|
|
int iDot = 0;
|
|
Datasource *pData;
|
|
CksumDb *pCksumDb;
|
|
TestDb *pDb;
|
|
|
|
/* Allocate datasource. And calculate the expected checksums. */
|
|
pData = testDatasourceNew(&defn);
|
|
pCksumDb = testCksumArrayNew(pData, 110, 150, 10);
|
|
|
|
/* Setup and save the initial database. */
|
|
testSetupSavedLsmdb("", DBNAME, pData, 100, pRc);
|
|
|
|
for(i=0; i<nIter && *pRc==0; i++){
|
|
int iOpen;
|
|
testCaseProgress(i, nIter, testCaseNDot(), &iDot);
|
|
testRestoreDb(DBNAME, "log");
|
|
|
|
for(iOpen=0; iOpen<5; iOpen++){
|
|
/* Open the database. Insert 10 more records. */
|
|
pDb = testOpen("lsm", 0, pRc);
|
|
testWriteDatasourceRange(pDb, pData, 100+iOpen*10, 10, pRc);
|
|
|
|
/* Schedule a crash simulation then close the db. */
|
|
tdb_lsm_prepare_sync_crash(pDb, 1 + (i%2));
|
|
tdb_close(pDb);
|
|
|
|
/* Open the database and check that the crash did not cause any
|
|
** data loss. */
|
|
testCompareCksumLsmdb(DBNAME, bCompress,
|
|
testCksumArrayGet(pCksumDb, 110 + iOpen*10), 0,
|
|
pRc
|
|
);
|
|
}
|
|
}
|
|
|
|
testDatasourceFree(pData);
|
|
testCksumArrayFree(pCksumDb);
|
|
}
|
|
|
|
void do_crash_test(const char *zPattern, int *pRc){
|
|
struct Test {
|
|
const char *zTest;
|
|
void (*x)(int, int *);
|
|
int bCompress;
|
|
} aTest [] = {
|
|
{ "crash.lsm.1", crash_test1, 0 },
|
|
#ifdef HAVE_ZLIB
|
|
{ "crash.lsm_zip.1", crash_test1, 1 },
|
|
#endif
|
|
{ "crash.lsm.2", crash_test2, 0 },
|
|
{ "crash.lsm.3", crash_test3, 0 },
|
|
};
|
|
int i;
|
|
|
|
for(i=0; *pRc==LSM_OK && i<ArraySize(aTest); i++){
|
|
struct Test *p = &aTest[i];
|
|
if( testCaseBegin(pRc, zPattern, "%s", p->zTest) ){
|
|
p->x(p->bCompress, pRc);
|
|
testCaseFinish(*pRc);
|
|
}
|
|
}
|
|
}
|