diff options
Diffstat (limited to 'test/bbackupd/testbbackupd.cpp')
-rw-r--r-- | test/bbackupd/testbbackupd.cpp | 1224 |
1 files changed, 928 insertions, 296 deletions
diff --git a/test/bbackupd/testbbackupd.cpp b/test/bbackupd/testbbackupd.cpp index 27ca4ecb..63ee5a15 100644 --- a/test/bbackupd/testbbackupd.cpp +++ b/test/bbackupd/testbbackupd.cpp @@ -43,6 +43,7 @@ #include "BackupClientRestore.h" #include "BackupDaemon.h" #include "BackupDaemonConfigVerify.h" +#include "BackupQueries.h" #include "BackupStoreConstants.h" #include "BackupStoreDirectory.h" #include "BackupStoreException.h" @@ -82,13 +83,21 @@ // utility macro for comparing two strings in a line #define TEST_EQUAL(expected, found, line) \ { \ - std::string exp_str = expected; \ - std::string found_str = found; \ + std::ostringstream _oss1; \ + _oss1 << expected; \ + std::string exp_str = _oss1.str(); \ + \ + std::ostringstream _oss2; \ + _oss2 << found; \ + std::string found_str = _oss2.str(); \ + \ TEST_THAT(exp_str == found_str); \ + std::string _line = line; \ + \ if(exp_str != found_str) \ { \ printf("Expected <%s> but found <%s> in <%s>\n", \ - exp_str.c_str(), found_str.c_str(), line.c_str()); \ + exp_str.c_str(), found_str.c_str(), _line.c_str()); \ } \ } @@ -336,7 +345,11 @@ int test_basics() #endif BackupClientFileAttributes t3; - TEST_CHECK_THROWS(t3.ReadAttributes("doesn't exist"), CommonException, OSFileError); + { + Logging::Guard guard(Log::ERROR); + TEST_CHECK_THROWS(t3.ReadAttributes("doesn't exist"), + CommonException, OSFileError); + } // Create some more files FILE *f = fopen("testfiles/test1_n", "w"); @@ -353,8 +366,13 @@ int test_basics() #endif #ifndef WIN32 - TEST_CHECK_THROWS(t1.WriteAttributes("testfiles/test1_nXX"), CommonException, OSFileError); - TEST_CHECK_THROWS(t3.WriteAttributes("doesn't exist"), BackupStoreException, AttributesNotLoaded); + { + Logging::Guard guard(Log::ERROR); + TEST_CHECK_THROWS(t1.WriteAttributes("testfiles/test1_nXX"), + CommonException, OSFileError); + TEST_CHECK_THROWS(t3.WriteAttributes("doesn't exist"), + BackupStoreException, AttributesNotLoaded); + } // Test that attributes are vaguely similar TEST_THAT(attrmatch("testfiles/test1", "testfiles/test1_n")); @@ -650,6 +668,7 @@ int start_internal_daemon() { // ensure that no child processes end up running tests! int own_pid = getpid(); + BOX_TRACE("Test PID is " << own_pid); // this is a quick hack to allow passing some options to the daemon const char* argv[] = { @@ -669,14 +688,10 @@ int start_internal_daemon() result = daemon.Main("testfiles/bbackupd.conf", 1, argv); } - TEST_THAT(result == 0); - if (result != 0) - { - printf("Daemon exited with code %d\n", result); - } + TEST_EQUAL(0, result, "Daemon exit code"); // ensure that no child processes end up running tests! - TEST_THAT(getpid() == own_pid); + TEST_EQUAL(own_pid, getpid(), "Forking test problem"); if (getpid() != own_pid) { // abort! @@ -799,12 +814,40 @@ int lstat_test_hook(int ver, const char *file_name, struct stat *buf) int lstat_test_hook(const char *file_name, struct stat *buf) #endif { - // TRACE1("lstat hook triggered for %s", file_name); + // TRACE1("lstat hook triggered for %s", file_name); memset(buf, 0, sizeof(*buf)); buf->st_mode = S_IFREG; return 0; } +// Simulate a symlink that is on a different device than the file +// that it points to. +int lstat_test_post_hook(int old_ret, const char *file_name, struct stat *buf) +{ + BOX_TRACE("lstat post hook triggered for " << file_name); + if (old_ret == 0 && + strcmp(file_name, "testfiles/symlink-to-TestDir1") == 0) + { + buf->st_dev ^= 0xFFFF; + } + return old_ret; +} + +bool test_entry_deleted(BackupStoreDirectory& rDir, + const std::string& rName) +{ + BackupStoreDirectory::Iterator i(rDir); + + BackupStoreDirectory::Entry *en = i.FindMatchingClearName( + BackupStoreFilenameClear(rName)); + TEST_THAT(en != 0); + if (en == 0) return false; + + int16_t flags = en->GetFlags(); + TEST_THAT(flags && BackupStoreDirectory::Entry::Flags_Deleted); + return flags && BackupStoreDirectory::Entry::Flags_Deleted; +} + int test_bbackupd() { // First, wait for a normal period to make sure the last changes @@ -818,6 +861,23 @@ int test_bbackupd() "testfiles/clientPrivKey.pem", "testfiles/clientTrustedCAs.pem"); + printf("\n==== Testing that ReadDirectory on nonexistent directory " + "does not crash\n"); + { + std::auto_ptr<BackupProtocolClient> client = ConnectAndLogin( + context, 0 /* read-write */); + + { + Logging::Guard guard(Log::ERROR); + TEST_CHECK_THROWS(ReadDirectory(*client, 0x12345678), + ConnectionException, + Conn_Protocol_UnexpectedReply); + } + + client->QueryFinished(); + sSocket.Close(); + } + // unpack the files for the initial test TEST_THAT(::system("rm -rf testfiles/TestDir1") == 0); TEST_THAT(::mkdir("testfiles/TestDir1", 0777) == 0); @@ -852,7 +912,8 @@ int test_bbackupd() char buffer[10000]; memset(buffer, 0, sizeof(buffer)); - TEST_THAT(write(fd, buffer, sizeof(buffer)) == sizeof(buffer)); + TEST_EQUAL(sizeof(buffer), write(fd, buffer, sizeof(buffer)), + "Buffer write"); TEST_THAT(close(fd) == 0); int pid = start_internal_daemon(); @@ -867,11 +928,13 @@ int test_bbackupd() TEST_THAT(unlink("testfiles/bbackupd.log") == 0); pid = start_internal_daemon(); + intercept_clear_setup(); fd = open("testfiles/TestDir1/spacetest/f1", O_WRONLY); TEST_THAT(fd > 0); // write again, to update the file's timestamp - TEST_THAT(write(fd, buffer, sizeof(buffer)) == sizeof(buffer)); + TEST_EQUAL(sizeof(buffer), write(fd, buffer, sizeof(buffer)), + "Buffer write"); TEST_THAT(close(fd) == 0); wait_for_backup_operation(); @@ -937,11 +1000,13 @@ int test_bbackupd() intercept_setup_delay("testfiles/TestDir1/spacetest/f1", 0, 4000, SYS_read, 1); pid = start_internal_daemon(); + intercept_clear_setup(); fd = open("testfiles/TestDir1/spacetest/f1", O_WRONLY); TEST_THAT(fd > 0); // write again, to update the file's timestamp - TEST_THAT(write(fd, buffer, sizeof(buffer)) == sizeof(buffer)); + TEST_EQUAL(sizeof(buffer), write(fd, buffer, sizeof(buffer)), + "Buffer write"); TEST_THAT(close(fd) == 0); wait_for_backup_operation(); @@ -970,9 +1035,9 @@ int test_bbackupd() std::string line; TEST_THAT(reader.GetLine(line)); std::string comp = "Receive Success(0x"; - TEST_THAT(line.substr(0, comp.size()) == comp); + TEST_EQUAL(comp, line.substr(0, comp.size()), line); TEST_THAT(reader.GetLine(line)); - TEST_THAT(line == "Receiving stream, size 124"); + TEST_EQUAL("Receiving stream, size 124", line, line); // delaying for 4 seconds in one step means that // the diff timer and the keepalive timer will @@ -997,11 +1062,13 @@ int test_bbackupd() intercept_setup_delay("testfiles/TestDir1/spacetest/f1", 0, 1000, SYS_read, 3); pid = start_internal_daemon(); + intercept_clear_setup(); fd = open("testfiles/TestDir1/spacetest/f1", O_WRONLY); TEST_THAT(fd > 0); // write again, to update the file's timestamp - TEST_THAT(write(fd, buffer, sizeof(buffer)) == sizeof(buffer)); + TEST_EQUAL(sizeof(buffer), write(fd, buffer, sizeof(buffer)), + "Buffer write"); TEST_THAT(close(fd) == 0); wait_for_backup_operation(); @@ -1030,9 +1097,9 @@ int test_bbackupd() std::string line; TEST_THAT(reader.GetLine(line)); std::string comp = "Receive Success(0x"; - TEST_THAT(line.substr(0, comp.size()) == comp); + TEST_EQUAL(comp, line.substr(0, comp.size()), line); TEST_THAT(reader.GetLine(line)); - TEST_THAT(line == "Receiving stream, size 124"); + TEST_EQUAL("Receiving stream, size 124", line, line); // delaying for 3 seconds in steps of 1 second // means that the keepalive timer will expire 3 times, @@ -1041,13 +1108,13 @@ int test_bbackupd() // only two keepalives. TEST_THAT(reader.GetLine(line)); - TEST_THAT(line == "Send GetIsAlive()"); + TEST_EQUAL("Send GetIsAlive()", line, line); TEST_THAT(reader.GetLine(line)); - TEST_THAT(line == "Receive IsAlive()"); + TEST_EQUAL("Receive IsAlive()", line, line); TEST_THAT(reader.GetLine(line)); - TEST_THAT(line == "Send GetIsAlive()"); + TEST_EQUAL("Send GetIsAlive()", line, line); TEST_THAT(reader.GetLine(line)); - TEST_THAT(line == "Receive IsAlive()"); + TEST_EQUAL("Receive IsAlive()", line, line); // but two matching blocks should have been found // already, so the upload should be a diff. @@ -1078,6 +1145,7 @@ int test_bbackupd() readdir_stop_time = time(NULL) + 12 + 2; pid = start_internal_daemon(); + intercept_clear_setup(); std::string touchfile = "testfiles/TestDir1/spacetest/d1/touch-me"; @@ -1085,7 +1153,8 @@ int test_bbackupd() fd = open(touchfile.c_str(), O_CREAT | O_WRONLY); TEST_THAT(fd > 0); // write again, to update the file's timestamp - TEST_THAT(write(fd, buffer, sizeof(buffer)) == sizeof(buffer)); + TEST_EQUAL(sizeof(buffer), write(fd, buffer, sizeof(buffer)), + "Buffer write"); TEST_THAT(close(fd) == 0); wait_for_backup_operation(); @@ -1158,7 +1227,7 @@ int test_bbackupd() #endif // PLATFORM_CLIB_FNS_INTERCEPTION_IMPOSSIBLE std::string cmd = BBACKUPD " " + bbackupd_args + - " testfiles/bbackupd-temploc.conf"; + " testfiles/bbackupd.conf"; bbackupd_pid = LaunchServer(cmd, "testfiles/bbackupd.pid"); TEST_THAT(bbackupd_pid != -1 && bbackupd_pid != 0); @@ -1169,6 +1238,368 @@ int test_bbackupd() if (!ServerIsAlive(bbackupd_pid)) return 1; if (!ServerIsAlive(bbstored_pid)) return 1; + if(bbackupd_pid > 0) + { + printf("\n==== Testing that backup pauses when " + "store is full\n"); + + // wait for files to be uploaded + BOX_TRACE("Waiting for all outstanding files to be uploaded") + wait_for_sync_end(); + BOX_TRACE("done.") + + // Set limit to something very small + // 26 blocks will be used at this point. + // (12 files + location * 2 for raidfile) + // 20 is what we'll need in a minute + // set soft limit to 0 to ensure that all deleted files + // are deleted immediately by housekeeping + TEST_THAT_ABORTONFAIL(::system(BBSTOREACCOUNTS " -c " + "testfiles/bbstored.conf setlimit 01234567 0B 20B") + == 0); + TestRemoteProcessMemLeaks("bbstoreaccounts.memleaks"); + + // Unpack some more files + #ifdef WIN32 + TEST_THAT(::system("tar xzvf testfiles/spacetest2.tgz " + "-C testfiles/TestDir1") == 0); + #else + TEST_THAT(::system("gzip -d < testfiles/spacetest2.tgz " + "| ( cd testfiles/TestDir1 && tar xf - )") == 0); + #endif + + // Delete a file and a directory + TEST_THAT(::unlink("testfiles/TestDir1/spacetest/f1") == 0); + TEST_THAT(::system("rm -rf testfiles/TestDir1/spacetest/d7") == 0); + + // The following files should be on the server: + // 00000001 -d---- 00002 (root) + // 00000002 -d---- 00002 Test1 + // 00000003 -d---- 00002 Test1/spacetest + // 00000004 f-X--- 00002 Test1/spacetest/f1 + // 00000005 f----- 00002 Test1/spacetest/f2 + // 00000006 -d---- 00002 Test1/spacetest/d1 + // 00000007 f----- 00002 Test1/spacetest/d1/f3 + // 00000008 f----- 00002 Test1/spacetest/d1/f4 + // 00000009 -d---- 00002 Test1/spacetest/d2 + // 0000000a -d---- 00002 Test1/spacetest/d3 + // 0000000b -d---- 00002 Test1/spacetest/d3/d4 + // 0000000c f----- 00002 Test1/spacetest/d3/d4/f5 + // 0000000d -d---- 00002 Test1/spacetest/d6 + // 0000000e -dX--- 00002 Test1/spacetest/d7 + // This is 28 blocks total, of which 2 in deleted files + // and 18 in directories. Note that f1 and d7 may or may + // not be deleted yet. + // + // spacetest1 + spacetest2 = 16 files = 32 blocks with raidfile + // minus one file and one dir is 28 blocks + // + // d2/f6, d6/d8 and d6/d8/f7 are new + // even if the client marks f1 and d7 as deleted, and + // housekeeping deleted them, the backup cannot complete + // if the limit is 20 blocks. + + BOX_TRACE("Waiting for bbackupd to notice that the " + "store is full"); + wait_for_sync_end(); + BOX_TRACE("done."); + + BOX_TRACE("Compare to check that there are differences"); + int compareReturnValue = ::system(BBACKUPQUERY " " + "-c testfiles/bbackupd.conf " + "-l testfiles/query0a.log " + "-Werror \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Different); + TestRemoteProcessMemLeaks("bbackupquery.memleaks"); + BOX_TRACE("done."); + + // Check that the notify script was run + TEST_THAT(TestFileExists("testfiles/notifyran.store-full.1")); + // But only once! + TEST_THAT(!TestFileExists("testfiles/notifyran.store-full.2")); + + // Kill the daemon + terminate_bbackupd(bbackupd_pid); + + BOX_TRACE("Wait for housekeeping to remove the deleted files"); + wait_for_backup_operation(5); + BOX_TRACE("done."); + + // This removes f1 and d7, which were previously marked + // as deleted, so total usage drops by 4 blocks to 24. + + // BLOCK + { + std::auto_ptr<BackupProtocolClient> client = + ConnectAndLogin(context, 0 /* read-write */); + + std::auto_ptr<BackupProtocolClientAccountUsage> usage( + client->QueryGetAccountUsage()); + TEST_EQUAL(24, usage->GetBlocksUsed(), "blocks used"); + TEST_EQUAL(0, usage->GetBlocksInDeletedFiles(), + "deleted blocks"); + TEST_EQUAL(16, usage->GetBlocksInDirectories(), + "directory blocks"); + + client->QueryFinished(); + sSocket.Close(); + } + + BOX_TRACE("Restart bbackupd with more exclusions"); + // Start again with a new config that excludes d3 and f2, + // and hence also d3/d4 and d3/d4/f5. bbackupd should mark + // them as deleted and housekeeping should clean up, + // making space to upload the new files. + // total required: (13-2-4+3)*2 = 20 blocks + /* + cmd = BBACKUPD " " + bbackupd_args + + " testfiles/bbackupd-exclude.conf"; + bbackupd_pid = LaunchServer(cmd, "testfiles/bbackupd.pid"); + TEST_THAT(bbackupd_pid != -1 && bbackupd_pid != 0); + ::safe_sleep(1); + TEST_THAT(ServerIsAlive(bbackupd_pid)); + TEST_THAT(ServerIsAlive(bbstored_pid)); + if (!ServerIsAlive(bbackupd_pid)) return 1; + if (!ServerIsAlive(bbstored_pid)) return 1; + */ + BackupDaemon bbackupd; + bbackupd.Configure("testfiles/bbackupd-exclude.conf"); + bbackupd.InitCrypto(); + BOX_TRACE("done."); + + // Should be marked as deleted by this run + // wait_for_sync_end(); + { + Logging::Guard guard(Log::ERROR); + bbackupd.RunSyncNow(); + } + + TEST_THAT(bbackupd.StorageLimitExceeded()); + + // Check that the notify script was run + // TEST_THAT(TestFileExists("testfiles/notifyran.store-full.2")); + // But only twice! + // TEST_THAT(!TestFileExists("testfiles/notifyran.store-full.3")); + + // All these should be marked as deleted but hopefully + // not removed by housekeeping yet: + // f1 deleted + // f2 excluded + // d1 excluded (why?) + // d1/f3 excluded (why?) + // d3 excluded + // d3/d4 excluded + // d3/d4/f5 excluded + // d7 deleted + // Careful with timing here, these files can already be + // deleted by housekeeping. + + BOX_TRACE("Find out whether bbackupd marked files as deleted"); + { + std::auto_ptr<BackupProtocolClient> client = + ConnectAndLogin(context, 0 /* read-write */); + + std::auto_ptr<BackupStoreDirectory> rootDir = + ReadDirectory(*client, + BackupProtocolClientListDirectory::RootDirectory); + + int64_t testDirId = SearchDir(*rootDir, "Test1"); + TEST_THAT(testDirId != 0); + + std::auto_ptr<BackupStoreDirectory> Test1_dir = + ReadDirectory(*client, testDirId); + + int64_t spacetestDirId = SearchDir(*Test1_dir, + "spacetest"); + TEST_THAT(spacetestDirId != 0); + + std::auto_ptr<BackupStoreDirectory> spacetest_dir = + ReadDirectory(*client, spacetestDirId); + + TEST_THAT(SearchDir(*spacetest_dir, "f1") == 0); + TEST_THAT(test_entry_deleted(*spacetest_dir, "f2")); + TEST_THAT(test_entry_deleted(*spacetest_dir, "d3")); + TEST_THAT(SearchDir(*spacetest_dir, "d7") == 0); + + int64_t d3_id = SearchDir(*spacetest_dir, "d3"); + TEST_THAT(d3_id != 0); + + std::auto_ptr<BackupStoreDirectory> d3_dir = + ReadDirectory(*client, d3_id); + TEST_THAT(test_entry_deleted(*d3_dir, "d4")); + + int64_t d4_id = SearchDir(*d3_dir, "d4"); + TEST_THAT(d4_id != 0); + + std::auto_ptr<BackupStoreDirectory> d4_dir = + ReadDirectory(*client, d4_id); + TEST_THAT(test_entry_deleted(*d4_dir, "f5")); + + std::auto_ptr<BackupProtocolClientAccountUsage> usage( + client->QueryGetAccountUsage()); + TEST_EQUAL(24, usage->GetBlocksUsed(), "blocks used"); + TEST_EQUAL(4, usage->GetBlocksInDeletedFiles(), + "deleted blocks"); + TEST_EQUAL(16, usage->GetBlocksInDirectories(), + "directory blocks"); + // d1/f3 and d1/f4 are the only two files on the + // server which are not deleted, they use 2 blocks + // each, the rest is directories and 2 deleted files + // (f1 and d3/d4/f5) + + // Log out. + client->QueryFinished(); + sSocket.Close(); + } + BOX_TRACE("done."); + + // Wait for housekeeping to run + BOX_TRACE("Wait for housekeeping to remove the deleted files"); + wait_for_backup_operation(5); + BOX_TRACE("done."); + + BOX_TRACE("Check that the files were removed"); + { + std::auto_ptr<BackupProtocolClient> client = + ConnectAndLogin(context, 0 /* read-write */); + + std::auto_ptr<BackupStoreDirectory> rootDir = + ReadDirectory(*client, + BackupProtocolClientListDirectory::RootDirectory); + + int64_t testDirId = SearchDir(*rootDir, "Test1"); + TEST_THAT(testDirId != 0); + + std::auto_ptr<BackupStoreDirectory> Test1_dir = + ReadDirectory(*client, testDirId); + + int64_t spacetestDirId = SearchDir(*Test1_dir, + "spacetest"); + TEST_THAT(spacetestDirId != 0); + + std::auto_ptr<BackupStoreDirectory> spacetest_dir = + ReadDirectory(*client, spacetestDirId); + + TEST_THAT(SearchDir(*spacetest_dir, "f1") == 0); + TEST_THAT(SearchDir(*spacetest_dir, "f2") == 0); + TEST_THAT(SearchDir(*spacetest_dir, "d3") == 0); + TEST_THAT(SearchDir(*spacetest_dir, "d7") == 0); + + std::auto_ptr<BackupProtocolClientAccountUsage> usage( + client->QueryGetAccountUsage()); + TEST_EQUAL(16, usage->GetBlocksUsed(), "blocks used"); + TEST_EQUAL(0, usage->GetBlocksInDeletedFiles(), + "deleted blocks"); + TEST_EQUAL(12, usage->GetBlocksInDirectories(), + "directory blocks"); + // d1/f3 and d1/f4 are the only two files on the + // server, they use 2 blocks each, the rest is + // directories. + + // Log out. + client->QueryFinished(); + sSocket.Close(); + } + + // Need 22 blocks free to upload everything + TEST_THAT_ABORTONFAIL(::system(BBSTOREACCOUNTS " -c " + "testfiles/bbstored.conf setlimit 01234567 0B 22B") + == 0); + TestRemoteProcessMemLeaks("bbstoreaccounts.memleaks"); + + // Run another backup, now there should be enough space + // for everything we want to upload. + { + Logging::Guard guard(Log::ERROR); + bbackupd.RunSyncNow(); + } + TEST_THAT(!bbackupd.StorageLimitExceeded()); + + // Check that the contents of the store are the same + // as the contents of the disc + // (-a = all, -c = give result in return code) + BOX_TRACE("Check that all files were uploaded successfully"); + compareReturnValue = ::system(BBACKUPQUERY " " + "-c testfiles/bbackupd-exclude.conf " + "-l testfiles/query1.log " + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); + TestRemoteProcessMemLeaks("bbackupquery.memleaks"); + BOX_TRACE("done."); + + // BLOCK + { + std::auto_ptr<BackupProtocolClient> client = + ConnectAndLogin(context, 0 /* read-write */); + + std::auto_ptr<BackupProtocolClientAccountUsage> usage( + client->QueryGetAccountUsage()); + TEST_EQUAL(22, usage->GetBlocksUsed(), "blocks used"); + TEST_EQUAL(0, usage->GetBlocksInDeletedFiles(), + "deleted blocks"); + TEST_EQUAL(14, usage->GetBlocksInDirectories(), + "directory blocks"); + // d2/f6, d6/d8 and d6/d8/f7 are new + // i.e. 2 new files, 1 new directory + + client->QueryFinished(); + sSocket.Close(); + } + + // Put the limit back + TEST_THAT_ABORTONFAIL(::system(BBSTOREACCOUNTS " -c " + "testfiles/bbstored.conf setlimit 01234567 " + "1000B 2000B") == 0); + TestRemoteProcessMemLeaks("bbstoreaccounts.memleaks"); + + // Start again with the old config + BOX_TRACE("Restart bbackupd with original configuration"); + // terminate_bbackupd(); + cmd = BBACKUPD " " + bbackupd_args + + " testfiles/bbackupd.conf"; + bbackupd_pid = LaunchServer(cmd, "testfiles/bbackupd.pid"); + TEST_THAT(bbackupd_pid != -1 && bbackupd_pid != 0); + ::safe_sleep(1); + TEST_THAT(ServerIsAlive(bbackupd_pid)); + TEST_THAT(ServerIsAlive(bbstored_pid)); + if (!ServerIsAlive(bbackupd_pid)) return 1; + if (!ServerIsAlive(bbstored_pid)) return 1; + BOX_TRACE("done."); + + // unpack the initial files again + #ifdef WIN32 + TEST_THAT(::system("tar xzvf testfiles/test_base.tgz " + "-C testfiles") == 0); + #else + TEST_THAT(::system("gzip -d < testfiles/test_base.tgz " + "| ( cd testfiles && tar xf - )") == 0); + #endif + + BOX_TRACE("Wait for bbackupd to upload more files"); + wait_for_backup_operation(); + BOX_TRACE("done."); + + // Check that the contents of the store are the same + // as the contents of the disc + // (-a = all, -c = give result in return code) + BOX_TRACE("Check that all files were uploaded successfully"); + compareReturnValue = ::system(BBACKUPQUERY " " + "-c testfiles/bbackupd.conf " + "-l testfiles/query1.log " + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); + TestRemoteProcessMemLeaks("bbackupquery.memleaks"); + BOX_TRACE("done."); + + TEST_THAT(ServerIsAlive(bbackupd_pid)); + TEST_THAT(ServerIsAlive(bbstored_pid)); + if (!ServerIsAlive(bbackupd_pid)) return 1; + if (!ServerIsAlive(bbstored_pid)) return 1; + } + #ifndef WIN32 printf("\n==== Testing that absolute symlinks are not followed " "during restore\n"); @@ -1204,11 +1635,12 @@ int test_bbackupd() ::sync_and_wait(); // Check that the backup was successful, i.e. no differences - int compareReturnValue = ::system(BBACKUPQUERY " -q " + int compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query1.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // now stop bbackupd and update the test file, @@ -1227,9 +1659,10 @@ int test_bbackupd() // check that we can restore it compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " - "-q \"restore Test1 testfiles/restore-symlink\" " + "-Wwarning \"restore Test1 testfiles/restore-symlink\" " "quit"); - TEST_RETURN(compareReturnValue, 0); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Command_OK); // make it accessible again TEST_THAT(chmod(SYM_DIR, 0755) == 0); @@ -1240,10 +1673,52 @@ int test_bbackupd() std::string line; TEST_THAT(gl.GetLine(line)); TEST_THAT(line != "before"); - TEST_THAT(line == "after"); + TEST_EQUAL("after", line, line); #undef SYM_DIR + /* + // This is not worth testing or fixing. + // + #ifndef PLATFORM_CLIB_FNS_INTERCEPTION_IMPOSSIBLE + printf("\n==== Testing that symlinks to other filesystems " + "can be backed up as roots\n"); + + intercept_setup_lstat_post_hook(lstat_test_post_hook); + TEST_THAT(symlink("TestDir1", "testfiles/symlink-to-TestDir1") + == 0); + + struct stat stat_st, lstat_st; + TEST_THAT(stat("testfiles/symlink-to-TestDir1", &stat_st) == 0); + TEST_THAT(lstat("testfiles/symlink-to-TestDir1", &lstat_st) == 0); + TEST_EQUAL((stat_st.st_dev ^ 0xFFFF), lstat_st.st_dev, + "stat vs lstat"); + + BackupDaemon bbackupd; + bbackupd.Configure("testfiles/bbackupd-symlink.conf"); + bbackupd.InitCrypto(); + bbackupd.RunSyncNow(); + intercept_clear_setup(); + + compareReturnValue = ::system(BBACKUPQUERY " " + "-c testfiles/bbackupd.conf " + "-l testfiles/query0a.log " + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); + TestRemoteProcessMemLeaks("bbackupquery.memleaks"); + + // and again using the symlink during compare + compareReturnValue = ::system(BBACKUPQUERY " " + "-c testfiles/bbackupd-symlink.conf " + "-l testfiles/query0a.log " + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); + TestRemoteProcessMemLeaks("bbackupquery.memleaks"); + #endif + */ + bbackupd_pid = LaunchServer(cmd, "testfiles/bbackupd.pid"); TEST_THAT(bbackupd_pid != -1 && bbackupd_pid != 0); ::safe_sleep(1); @@ -1257,7 +1732,27 @@ int test_bbackupd() printf("\n==== Testing that redundant locations are deleted on time\n"); + // BLOCK { + // Kill the daemon + terminate_bbackupd(bbackupd_pid); + + // Start it with a config that has a temporary location + // that will be created on the server + std::string cmd = BBACKUPD " " + bbackupd_args + + " testfiles/bbackupd-temploc.conf"; + + bbackupd_pid = LaunchServer(cmd, "testfiles/bbackupd.pid"); + TEST_THAT(bbackupd_pid != -1 && bbackupd_pid != 0); + ::safe_sleep(1); + + TEST_THAT(ServerIsAlive(bbackupd_pid)); + TEST_THAT(ServerIsAlive(bbstored_pid)); + if (!ServerIsAlive(bbackupd_pid)) return 1; + if (!ServerIsAlive(bbstored_pid)) return 1; + + sync_and_wait(); + { std::auto_ptr<BackupProtocolClient> client = ConnectAndLogin(context, @@ -1266,16 +1761,9 @@ int test_bbackupd() std::auto_ptr<BackupStoreDirectory> dir = ReadDirectory(*client, BackupProtocolClientListDirectory::RootDirectory); - - // int64_t testDirId = SearchDir(*dir, "Test2"); - // TEST_THAT(testDirId == 0); - - sync_and_wait(); - - dir = ReadDirectory(*client, - BackupProtocolClientListDirectory::RootDirectory); int64_t testDirId = SearchDir(*dir, "Test2"); TEST_THAT(testDirId != 0); + client->QueryFinished(); sSocket.Close(); } @@ -1283,6 +1771,7 @@ int test_bbackupd() // Kill the daemon terminate_bbackupd(bbackupd_pid); + // Start it again with the normal config (no Test2) cmd = BBACKUPD " " + bbackupd_args + " testfiles/bbackupd.conf"; bbackupd_pid = LaunchServer(cmd, "testfiles/bbackupd.pid"); @@ -1301,6 +1790,8 @@ int test_bbackupd() wait_for_sync_end(); wait_for_sync_end(); + // not yet! should still be there + { std::auto_ptr<BackupProtocolClient> client = ConnectAndLogin(context, @@ -1311,30 +1802,26 @@ int test_bbackupd() BackupProtocolClientListDirectory::RootDirectory); int64_t testDirId = SearchDir(*dir, "Test2"); TEST_THAT(testDirId != 0); + client->QueryFinished(); sSocket.Close(); } wait_for_sync_end(); + // NOW it should be gone + { std::auto_ptr<BackupProtocolClient> client = ConnectAndLogin(context, BackupProtocolClientLogin::Flags_ReadOnly); - std::auto_ptr<BackupStoreDirectory> dir = + std::auto_ptr<BackupStoreDirectory> root_dir = ReadDirectory(*client, BackupProtocolClientListDirectory::RootDirectory); - int64_t testDirId = SearchDir(*dir, "Test2"); - TEST_THAT(testDirId != 0); - BackupStoreDirectory::Iterator i(*dir); - BackupStoreFilenameClear dirname("Test2"); - BackupStoreDirectory::Entry *en = - i.FindMatchingClearName(dirname); - TEST_THAT(en != 0); - int16_t en_flags = en->GetFlags(); - TEST_THAT(en_flags && BackupStoreDirectory::Entry::Flags_Deleted); + TEST_THAT(test_entry_deleted(*root_dir, "Test2")); + client->QueryFinished(); sSocket.Close(); } @@ -1347,82 +1834,6 @@ int test_bbackupd() if(bbackupd_pid > 0) { - printf("\n==== Testing that backup pauses when store is full\n"); - - // wait for files to be uploaded - wait_for_backup_operation(); - - // Set limit to something very small - // About 28 blocks will be used at this point. bbackupd - // will only pause if the size used is greater than - // soft limit + 1/3 of (hard - soft). Set small values - // for limits accordingly. - TEST_THAT_ABORTONFAIL(::system(BBSTOREACCOUNTS " -c " - "testfiles/bbstored.conf setlimit 01234567 9B 10B") - == 0); - TestRemoteProcessMemLeaks("bbstoreaccounts.memleaks"); - - // Unpack some more files - #ifdef WIN32 - TEST_THAT(::system("tar xzvf testfiles/spacetest2.tgz " - "-C testfiles/TestDir1") == 0); - #else - TEST_THAT(::system("gzip -d < testfiles/spacetest2.tgz " - "| ( cd testfiles/TestDir1 && tar xf - )") == 0); - #endif - - // Delete a file and a directory - TEST_THAT(::unlink("testfiles/TestDir1/spacetest/d1/f3") == 0); - TEST_THAT(::system("rm -rf testfiles/TestDir1/spacetest/d3/d4") == 0); - wait_for_backup_operation(); - - // Make sure there are some differences - int compareReturnValue = ::system(BBACKUPQUERY " -q " - "-c testfiles/bbackupd.conf " - "-l testfiles/query0a.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 2); - TestRemoteProcessMemLeaks("bbackupquery.memleaks"); - - // Put the limit back - TEST_THAT_ABORTONFAIL(::system(BBSTOREACCOUNTS " -c " - "testfiles/bbstored.conf setlimit 01234567 " - "1000B 2000B") == 0); - TestRemoteProcessMemLeaks("bbstoreaccounts.memleaks"); - - // Check that the notify script was run - TEST_THAT(TestFileExists("testfiles/notifyran.store-full.1")); - // But only once! - TEST_THAT(!TestFileExists("testfiles/notifyran.store-full.2")); - - // unpack the initial files again - #ifdef WIN32 - TEST_THAT(::system("tar xzvf testfiles/test_base.tgz " - "-C testfiles") == 0); - #else - TEST_THAT(::system("gzip -d < testfiles/test_base.tgz " - "| ( cd testfiles && tar xf - )") == 0); - #endif - - // wait for it to do it's stuff - wait_for_backup_operation(); - - // Check that the contents of the store are the same - // as the contents of the disc - // (-a = all, -c = give result in return code) - compareReturnValue = ::system(BBACKUPQUERY " -q " - "-c testfiles/bbackupd.conf " - "-l testfiles/query1.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); - TestRemoteProcessMemLeaks("bbackupquery.memleaks"); - - TEST_THAT(ServerIsAlive(bbackupd_pid)); - TEST_THAT(ServerIsAlive(bbstored_pid)); - if (!ServerIsAlive(bbackupd_pid)) return 1; - if (!ServerIsAlive(bbstored_pid)) return 1; - - printf("\n==== Check that read-only directories and " "their contents can be restored.\n"); @@ -1438,27 +1849,33 @@ int test_bbackupd() wait_for_sync_end(); // too new wait_for_sync_end(); // should be backed up now - compareReturnValue = ::system(BBACKUPQUERY " " + int compareReturnValue = ::system(BBACKUPQUERY " " + "-Wwarning " "-c testfiles/bbackupd.conf " - "-q \"compare -cEQ Test1 testfiles/TestDir1\" " + "\"compare -cEQ Test1 testfiles/TestDir1\" " "quit"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // check that we can restore it compareReturnValue = ::system(BBACKUPQUERY " " + "-Wwarning " "-c testfiles/bbackupd.conf " - "-q \"restore Test1 testfiles/restore1\" " + "\"restore Test1 testfiles/restore1\" " "quit"); - TEST_RETURN(compareReturnValue, 0); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Command_OK); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // check that it restored properly compareReturnValue = ::system(BBACKUPQUERY " " + "-Wwarning " "-c testfiles/bbackupd.conf " - "-q \"compare -cEQ Test1 testfiles/restore1\" " + "\"compare -cEQ Test1 testfiles/restore1\" " "quit"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // put the permissions back to sensible values @@ -1513,7 +1930,7 @@ int test_bbackupd() std::string filepath(dirpath + "/" + filename); char cwdbuf[1024]; - TEST_THAT(getcwd(cwdbuf, sizeof(cwdbuf)) == cwdbuf); + TEST_EQUAL(cwdbuf, getcwd(cwdbuf, sizeof(cwdbuf)), "getcwd"); std::string cwd = cwdbuf; // Test that our emulated chdir() works properly @@ -1544,52 +1961,61 @@ int test_bbackupd() // test that bbackupd will let us lcd into the local // directory using a relative path - std::string command = BBACKUPQUERY " -q " + std::string command = BBACKUPQUERY " " + "-Wwarning " "-c testfiles/bbackupd.conf " "\"lcd testfiles/TestDir1/" + systemDirName + "\" " "quit"; compareReturnValue = ::system(command.c_str()); - TEST_RETURN(compareReturnValue, 0); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Command_OK); // and back out again - command = BBACKUPQUERY " -q " + command = BBACKUPQUERY " " + "-Wwarning " "-c testfiles/bbackupd.conf " "\"lcd testfiles/TestDir1/" + systemDirName + "\" " "\"lcd ..\" quit"; compareReturnValue = ::system(command.c_str()); - TEST_RETURN(compareReturnValue, 0); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Command_OK); // and using an absolute path - command = BBACKUPQUERY " -q " + command = BBACKUPQUERY " " + "-Wwarning " "-c testfiles/bbackupd.conf " "\"lcd " + cwd + "/testfiles/TestDir1/" + systemDirName + "\" quit"; compareReturnValue = ::system(command.c_str()); - TEST_RETURN(compareReturnValue, 0); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Command_OK); // and back out again - command = BBACKUPQUERY " -q " + command = BBACKUPQUERY " " + "-Wwarning " "-c testfiles/bbackupd.conf " "\"lcd " + cwd + "/testfiles/TestDir1/" + systemDirName + "\" " "\"lcd ..\" quit"; compareReturnValue = ::system(command.c_str()); - TEST_RETURN(compareReturnValue, 0); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Command_OK); { FileStream fs(filepath.c_str(), O_CREAT | O_RDWR); std::string data("hello world\n"); fs.Write(data.c_str(), data.size()); - TEST_THAT(fs.GetPosition() == 12); + TEST_EQUAL(12, fs.GetPosition(), "FileStream position"); fs.Close(); } wait_for_backup_operation(); // Compare to check that the file was uploaded - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " -Wwarning " "-c testfiles/bbackupd.conf \"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // Check that we can find it in directory listing @@ -1615,9 +2041,8 @@ int test_bbackupd() sSocket.Close(); } - // Check that bbackupquery shows the dir in console encoding - command = BBACKUPQUERY " -q " + command = BBACKUPQUERY " -Wwarning " "-c testfiles/bbackupd.conf " "-q \"list Test1\" quit"; pid_t bbackupquery_pid; @@ -1647,7 +2072,7 @@ int test_bbackupd() // on the command line in system encoding, and shows // the file in console encoding command = BBACKUPQUERY " -c testfiles/bbackupd.conf " - "-q \"list Test1/" + systemDirName + "\" quit"; + "-Wwarning \"list Test1/" + systemDirName + "\" quit"; queryout = LocalProcessStream(command.c_str(), bbackupquery_pid); TEST_THAT(queryout.get() != NULL); @@ -1671,31 +2096,34 @@ int test_bbackupd() // Check that bbackupquery can compare the dir when given // on the command line in system encoding. command = BBACKUPQUERY " -c testfiles/bbackupd.conf " - "-q \"compare -cEQ Test1/" + systemDirName + + "-Wwarning \"compare -cEQ Test1/" + systemDirName + " testfiles/TestDir1/" + systemDirName + "\" quit"; compareReturnValue = ::system(command.c_str()); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries:ReturnCode::Compare_Same); // Check that bbackupquery can restore the dir when given // on the command line in system encoding. command = BBACKUPQUERY " -c testfiles/bbackupd.conf " - "-q \"restore Test1/" + systemDirName + + "-Wwarning \"restore Test1/" + systemDirName + " testfiles/restore-" + systemDirName + "\" quit"; compareReturnValue = ::system(command.c_str()); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); - TEST_RETURN(compareReturnValue, 0); + TEST_RETURN(compareReturnValue, + BackupQueries:ReturnCode::Command_OK); // Compare to make sure it was restored properly. command = BBACKUPQUERY " -c testfiles/bbackupd.conf " - "-q \"compare -cEQ Test1/" + systemDirName + + "-Wwarning \"compare -cEQ Test1/" + systemDirName + " testfiles/restore-" + systemDirName + "\" quit"; compareReturnValue = ::system(command.c_str()); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); std::string fileToUnlink = "testfiles/restore-" + dirname + "/" + filename; @@ -1704,22 +2132,25 @@ int test_bbackupd() // Check that bbackupquery can get the file when given // on the command line in system encoding. command = BBACKUPQUERY " -c testfiles/bbackupd.conf " - "-q \"get Test1/" + systemDirName + "/" + + "-Wwarning \"get Test1/" + systemDirName + "/" + systemFileName + " " + "testfiles/restore-" + systemDirName + "/" + systemFileName + "\" quit"; compareReturnValue = ::system(command.c_str()); - TEST_RETURN(compareReturnValue, 0); + TEST_RETURN(compareReturnValue, + BackupQueries:ReturnCode::Command_OK); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // And after changing directory to a relative path - command = BBACKUPQUERY " -c testfiles/bbackupd.conf -q " + command = BBACKUPQUERY " -c testfiles/bbackupd.conf " + "-Wwarning " "\"lcd testfiles\" " "\"cd Test1/" + systemDirName + "\" " + "\"get " + systemFileName + "\" quit"; compareReturnValue = ::system(command.c_str()); - TEST_RETURN(compareReturnValue, 0); + TEST_RETURN(compareReturnValue, + BackupQueries:ReturnCode::Command_OK); TestRemoteProcessMemLeaks("testfiles/bbackupquery.memleaks"); // cannot overwrite a file that exists, so delete it @@ -1727,34 +2158,38 @@ int test_bbackupd() TEST_THAT(::unlink(tmp.c_str()) == 0); // And after changing directory to an absolute path - command = BBACKUPQUERY " -c testfiles/bbackupd.conf -q " + command = BBACKUPQUERY " -c testfiles/bbackupd.conf -Wwarning " "\"lcd " + cwd + "/testfiles\" " "\"cd Test1/" + systemDirName + "\" " + "\"get " + systemFileName + "\" quit"; compareReturnValue = ::system(command.c_str()); - TEST_RETURN(compareReturnValue, 0); + TEST_RETURN(compareReturnValue, + BackupQueries:ReturnCode::Command_OK); TestRemoteProcessMemLeaks("testfiles/bbackupquery.memleaks"); // Compare to make sure it was restored properly. // The Get command does not restore attributes, so // we must compare without them (-A) to succeed. - command = BBACKUPQUERY " -c testfiles/bbackupd.conf " - "-q \"compare -cAEQ Test1/" + systemDirName + + command = BBACKUPQUERY " " + "-c testfiles/bbackupd.conf " + "-Wwarning \"compare -cAEQ Test1/" + systemDirName + " testfiles/restore-" + systemDirName + "\" quit"; compareReturnValue = ::system(command.c_str()); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries:ReturnCode::Compare_Same); // Compare without attributes. This should fail. - command = BBACKUPQUERY " -c testfiles/bbackupd.conf " - "-q \"compare -cEQ Test1/" + systemDirName + + command = BBACKUPQUERY " " + "-c testfiles/bbackupd.conf " + "-Werror \"compare -cEQ Test1/" + systemDirName + " testfiles/restore-" + systemDirName + "\" quit"; - compareReturnValue = ::system(command.c_str()); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); - TEST_RETURN(compareReturnValue, 2); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Different); #endif // WIN32 TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -1831,11 +2266,13 @@ int test_bbackupd() long start_time = time(NULL); // check that no backup has run (compare fails) - compareReturnValue = ::system(BBACKUPQUERY " -q " + int compareReturnValue = ::system(BBACKUPQUERY " " + "-Werror " "-c testfiles/bbackupd.conf " "-l testfiles/query3.log " "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 2); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Different); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(unlink(sync_control_file) == 0); @@ -1851,11 +2288,13 @@ int test_bbackupd() wait_for_sync_end(); // check that backup has run (compare succeeds) - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " + "-Wwarning " "-c testfiles/bbackupd.conf " "-l testfiles/query3a.log " "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); if (failures > 0) @@ -1900,19 +2339,21 @@ int test_bbackupd() // wait for backup daemon to do it's stuff, and compare again wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + int compareReturnValue = ::system(BBACKUPQUERY " -Wwarning " "-c testfiles/bbackupd.conf " "-l testfiles/query2.log " "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // Try a quick compare, just for fun - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query2q.log " - "\"compare -acqQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acqQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -1922,12 +2363,15 @@ int test_bbackupd() // Check that store errors are reported neatly printf("\n==== Create store error\n"); + + // break the store TEST_THAT(::rename("testfiles/0_0/backup/01234567/info.rf", "testfiles/0_0/backup/01234567/info.rf.bak") == 0); TEST_THAT(::rename("testfiles/0_1/backup/01234567/info.rf", "testfiles/0_1/backup/01234567/info.rf.bak") == 0); TEST_THAT(::rename("testfiles/0_2/backup/01234567/info.rf", "testfiles/0_2/backup/01234567/info.rf.bak") == 0); + // Create a file to trigger an upload { int fd1 = open("testfiles/TestDir1/force-upload", @@ -1935,50 +2379,189 @@ int test_bbackupd() TEST_THAT(fd1 > 0); TEST_THAT(write(fd1, "just do it", 10) == 10); TEST_THAT(close(fd1) == 0); - wait_for_backup_operation(4); } - // Wait and test... - wait_for_backup_operation(); - // Check that it was reported correctly + + wait_for_backup_operation(4); + // Check that an error was reported just once TEST_THAT(TestFileExists("testfiles/notifyran.backup-error.1")); - // Check that the error was only reported once TEST_THAT(!TestFileExists("testfiles/notifyran.backup-error.2")); - // Fix the store + // Now kill bbackupd and start one that's running in + // snapshot mode, check that it automatically syncs after + // an error, without waiting for another sync command. + terminate_bbackupd(bbackupd_pid); + std::string cmd = BBACKUPD " " + bbackupd_args + + " testfiles/bbackupd-snapshot.conf"; + bbackupd_pid = LaunchServer(cmd, "testfiles/bbackupd.pid"); + TEST_THAT(bbackupd_pid != -1 && bbackupd_pid != 0); + ::safe_sleep(1); + TEST_THAT(ServerIsAlive(bbackupd_pid)); + TEST_THAT(ServerIsAlive(bbstored_pid)); + if (!ServerIsAlive(bbackupd_pid)) return 1; + if (!ServerIsAlive(bbstored_pid)) return 1; + + sync_and_wait(); + + // Check that the error was reported once more + TEST_THAT(TestFileExists("testfiles/notifyran.backup-error.1")); + TEST_THAT(TestFileExists("testfiles/notifyran.backup-error.2")); + TEST_THAT(!TestFileExists("testfiles/notifyran.backup-error.3")); + // Fix the store (so that bbackupquery compare works) TEST_THAT(::rename("testfiles/0_0/backup/01234567/info.rf.bak", "testfiles/0_0/backup/01234567/info.rf") == 0); TEST_THAT(::rename("testfiles/0_1/backup/01234567/info.rf.bak", "testfiles/0_1/backup/01234567/info.rf") == 0); TEST_THAT(::rename("testfiles/0_2/backup/01234567/info.rf.bak", "testfiles/0_2/backup/01234567/info.rf") == 0); + + // Check that we DO get errors on compare (cannot do this + // until after we fix the store, which creates a race) + compareReturnValue = ::system(BBACKUPQUERY " " + "-c testfiles/bbackupd.conf " + "-l testfiles/query3b.log " + "-Werror \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Different); + TestRemoteProcessMemLeaks("bbackupquery.memleaks"); + + // Test initial state + TEST_THAT(!TestFileExists("testfiles/" + "notifyran.backup-start.wait-snapshot.1")); + + // Set a tag for the notify script to distinguist from + // previous runs. + { + int fd1 = open("testfiles/notifyscript.tag", + O_CREAT | O_EXCL | O_WRONLY, 0700); + TEST_THAT(fd1 > 0); + TEST_THAT(write(fd1, "wait-snapshot", 13) == 13); + TEST_THAT(close(fd1) == 0); + } + + // bbackupd should pause for about 90 seconds + wait_for_backup_operation(85); + TEST_THAT(!TestFileExists("testfiles/" + "notifyran.backup-start.wait-snapshot.1")); + + // Should not have backed up, should still get errors + compareReturnValue = ::system(BBACKUPQUERY " " + "-c testfiles/bbackupd.conf " + "-l testfiles/query3b.log " + "-Werror \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Different); + TestRemoteProcessMemLeaks("bbackupquery.memleaks"); + + // wait another 10 seconds, bbackup should have run + wait_for_backup_operation(10); + TEST_THAT(TestFileExists("testfiles/" + "notifyran.backup-start.wait-snapshot.1")); - // Check that we DO get errors on compare - compareReturnValue = ::system(BBACKUPQUERY " -q " + // Check that it did get uploaded, and we have no more errors + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3b.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 2); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); + TEST_THAT(::unlink("testfiles/notifyscript.tag") == 0); + + // Stop the snapshot bbackupd + terminate_bbackupd(bbackupd_pid); + + // Break the store again + TEST_THAT(::rename("testfiles/0_0/backup/01234567/info.rf", + "testfiles/0_0/backup/01234567/info.rf.bak") == 0); + TEST_THAT(::rename("testfiles/0_1/backup/01234567/info.rf", + "testfiles/0_1/backup/01234567/info.rf.bak") == 0); + TEST_THAT(::rename("testfiles/0_2/backup/01234567/info.rf", + "testfiles/0_2/backup/01234567/info.rf.bak") == 0); + + // Modify a file to trigger an upload + { + int fd1 = open("testfiles/TestDir1/force-upload", + O_WRONLY, 0700); + TEST_THAT(fd1 > 0); + TEST_THAT(write(fd1, "and again", 9) == 9); + TEST_THAT(close(fd1) == 0); + } + + // Restart the old bbackupd, in automatic mode + cmd = BBACKUPD " " + bbackupd_args + + " testfiles/bbackupd.conf"; + bbackupd_pid = LaunchServer(cmd, "testfiles/bbackupd.pid"); + TEST_THAT(bbackupd_pid != -1 && bbackupd_pid != 0); + ::safe_sleep(1); TEST_THAT(ServerIsAlive(bbackupd_pid)); TEST_THAT(ServerIsAlive(bbstored_pid)); if (!ServerIsAlive(bbackupd_pid)) return 1; if (!ServerIsAlive(bbstored_pid)) return 1; - // Wait until bbackupd recovers from the exception - wait_for_backup_operation(100); - - // Ensure that the force-upload file gets uploaded, - // meaning that bbackupd recovered sync_and_wait(); + // Fix the store again + TEST_THAT(::rename("testfiles/0_0/backup/01234567/info.rf.bak", + "testfiles/0_0/backup/01234567/info.rf") == 0); + TEST_THAT(::rename("testfiles/0_1/backup/01234567/info.rf.bak", + "testfiles/0_1/backup/01234567/info.rf") == 0); + TEST_THAT(::rename("testfiles/0_2/backup/01234567/info.rf.bak", + "testfiles/0_2/backup/01234567/info.rf") == 0); + + // Check that we DO get errors on compare (cannot do this + // until after we fix the store, which creates a race) + compareReturnValue = ::system(BBACKUPQUERY " " + "-c testfiles/bbackupd.conf " + "-l testfiles/query3b.log " + "-Werror \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Different); + TestRemoteProcessMemLeaks("bbackupquery.memleaks"); + + // Test initial state + TEST_THAT(!TestFileExists("testfiles/" + "notifyran.backup-start.wait-automatic.1")); + + // Set a tag for the notify script to distinguist from + // previous runs. + { + int fd1 = open("testfiles/notifyscript.tag", + O_CREAT | O_EXCL | O_WRONLY, 0700); + TEST_THAT(fd1 > 0); + TEST_THAT(write(fd1, "wait-automatic", 14) == 14); + TEST_THAT(close(fd1) == 0); + } + + // bbackupd should pause for at least 90 seconds + wait_for_backup_operation(85); + TEST_THAT(!TestFileExists("testfiles/" + "notifyran.backup-start.wait-automatic.1")); + + // Should not have backed up, should still get errors + compareReturnValue = ::system(BBACKUPQUERY " " + "-c testfiles/bbackupd.conf " + "-l testfiles/query3b.log " + "-Werror \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Different); + TestRemoteProcessMemLeaks("bbackupquery.memleaks"); + + // wait another 10 seconds, bbackup should have run + wait_for_backup_operation(10); + TEST_THAT(TestFileExists("testfiles/" + "notifyran.backup-start.wait-automatic.1")); + // Check that it did get uploaded, and we have no more errors - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3b.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); + TEST_THAT(::unlink("testfiles/notifyscript.tag") == 0); + TEST_THAT(ServerIsAlive(bbackupd_pid)); TEST_THAT(ServerIsAlive(bbstored_pid)); if (!ServerIsAlive(bbackupd_pid)) return 1; @@ -2008,11 +2591,12 @@ int test_bbackupd() #endif wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3c.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2036,11 +2620,12 @@ int test_bbackupd() #endif wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3d.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2067,11 +2652,12 @@ int test_bbackupd() #endif wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3e.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2098,11 +2684,12 @@ int test_bbackupd() #endif wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3f.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2129,11 +2716,12 @@ int test_bbackupd() wait_for_operation(5); // back up both files wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3g.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); #ifdef WIN32 @@ -2146,11 +2734,12 @@ int test_bbackupd() TEST_THAT(!TestFileExists("testfiles/TestDir1/untracked-1")); TEST_THAT( TestFileExists("testfiles/TestDir1/untracked-2")); wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3g.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2180,11 +2769,12 @@ int test_bbackupd() wait_for_operation(5); // back up both files wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3h.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); #ifdef WIN32 @@ -2197,11 +2787,12 @@ int test_bbackupd() TEST_THAT(!TestFileExists("testfiles/TestDir1/tracked-1")); TEST_THAT( TestFileExists("testfiles/TestDir1/tracked-2")); wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3i.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2217,11 +2808,12 @@ int test_bbackupd() "testfiles/TestDir1/x1/dsfdsfs98.fd") == 0); wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3j.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2251,11 +2843,12 @@ int test_bbackupd() // Wait and test wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3k.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2309,11 +2902,12 @@ int test_bbackupd() wait_for_sync_end(); // files too new wait_for_sync_end(); // should (not) be backed up this time - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3l.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2337,19 +2931,21 @@ int test_bbackupd() wait_for_sync_end(); // compare with exclusions, should not find differences - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3m.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // compare without exclusions, should find differences - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3n.log " - "\"compare -acEQ\" quit"); - TEST_RETURN(compareReturnValue, 2); + "-Werror \"compare -acEQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Different); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2421,13 +3017,14 @@ int test_bbackupd() // Wait and test... wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3o.log " - "\"compare -acQ\" quit"); + "-Werror \"compare -acQ\" quit"); // should find differences - TEST_RETURN(compareReturnValue, 3); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Error); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // Check that it was reported correctly @@ -2524,11 +3121,12 @@ int test_bbackupd() // Wait and test wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query4.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Werror \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); printf("\n==== Restore files and directories\n"); @@ -2573,13 +3171,18 @@ int test_bbackupd() == Restore_Complete); // Make sure you can't restore to a nonexistant path - printf("\n\n==== Try to restore to a path " + printf("\n==== Try to restore to a path " "that doesn't exist\n"); fflush(stdout); - TEST_THAT(BackupClientRestore(*client, restoredirid, - "testfiles/no-such-path/subdir", - true /* print progress dots */) - == Restore_TargetPathNotFound); + + { + Logging::Guard guard(Log::FATAL); + TEST_THAT(BackupClientRestore(*client, + restoredirid, + "testfiles/no-such-path/subdir", + true /* print progress dots */) + == Restore_TargetPathNotFound); + } // Log out client->QueryFinished(); @@ -2587,12 +3190,14 @@ int test_bbackupd() } // Compare the restored files - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query10.log " + "-Wwarning " "\"compare -cEQ Test1 testfiles/restore-Test1\" " "quit"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2606,12 +3211,14 @@ int test_bbackupd() "testfiles\\restore-Test1\\f1.dat"); TEST_RETURN(compareReturnValue, 0); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query10a.log " + "-Werror " "\"compare -cEQ Test1 testfiles/restore-Test1\" " "quit"); - TEST_RETURN(compareReturnValue, 2); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Different); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // set it back, expect no failures @@ -2619,11 +3226,13 @@ int test_bbackupd() "testfiles\\restore-Test1\\f1.dat"); TEST_RETURN(compareReturnValue, 0); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf -l testfiles/query10a.log " + "-Wwarning " "\"compare -cEQ Test1 testfiles/restore-Test1\" " "quit"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // change the timestamp on a file, expect a compare failure @@ -2643,46 +3252,54 @@ int test_bbackupd() // a compare failure TEST_THAT(set_file_time(testfile, dummyTime, lastModTime, lastAccessTime)); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query10a.log " + "-Werror " "\"compare -cEQ Test1 testfiles/restore-Test1\" " "quit"); - TEST_RETURN(compareReturnValue, 2); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Different); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // last access time is not backed up, so it cannot be compared TEST_THAT(set_file_time(testfile, creationTime, lastModTime, dummyTime)); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query10a.log " + "-Wwarning " "\"compare -cEQ Test1 testfiles/restore-Test1\" " "quit"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // last write time is backed up, so changing it should cause // a compare failure TEST_THAT(set_file_time(testfile, creationTime, dummyTime, lastAccessTime)); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query10a.log " + "-Werror " "\"compare -cEQ Test1 testfiles/restore-Test1\" " "quit"); - TEST_RETURN(compareReturnValue, 2); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Different); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // set back to original values, check that compare succeeds TEST_THAT(set_file_time(testfile, creationTime, lastModTime, lastAccessTime)); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query10a.log " + "-Wwarning " "\"compare -cEQ Test1 testfiles/restore-Test1\" " "quit"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); #endif // WIN32 @@ -2705,11 +3322,12 @@ int test_bbackupd() // Wait and test wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query5.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2722,19 +3340,21 @@ int test_bbackupd() TEST_THAT(rename("testfiles/TestDir1/sub23/dhsfdss", "testfiles/TestDir1/renamed-dir") == 0); wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query6.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // and again, but with quick flag - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query6q.log " - "\"compare -acqQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acqQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // Rename some files -- one under the threshold, others above @@ -2746,11 +3366,12 @@ int test_bbackupd() TEST_THAT(rename("testfiles/TestDir1/sub23/find2perl", "testfiles/TestDir1/find2perl-ren") == 0); wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query6.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2788,11 +3409,12 @@ int test_bbackupd() // Wait and test wait_for_backup_operation(); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query3e.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2856,11 +3478,12 @@ int test_bbackupd() // Wait and test that there *are* differences wait_for_backup_operation((TIME_TO_WAIT_FOR_BACKUP_OPERATION * 3) / 2); // little bit longer than usual - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query6.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 2); + "-Werror \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Different); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); TEST_THAT(ServerIsAlive(bbackupd_pid)); @@ -2914,12 +3537,13 @@ int test_bbackupd() sSocket.Close(); // Then check it has restored the correct stuff - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query14.log " - "\"compare -cEQ Test1 " + "-Wwarning \"compare -cEQ Test1 " "testfiles/restore-interrupt\" quit"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); } #endif // !WIN32 @@ -2947,12 +3571,14 @@ int test_bbackupd() sSocket.Close(); // Do a compare with the now undeleted files - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query11.log " + "-Wwarning " "\"compare -cEQ Test1/x1 " "testfiles/restore-Test1-x1-2\" quit"); - TEST_RETURN(compareReturnValue, 1); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); } @@ -3002,11 +3628,12 @@ int test_bbackupd() // compare, and check that it works // reports the correct error message (and finishes) - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query15a.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // open the file again, compare and check that compare @@ -3015,22 +3642,24 @@ int test_bbackupd() O_LOCK, 0); TEST_THAT(handle != INVALID_HANDLE_VALUE); - compareReturnValue = ::system(BBACKUPQUERY - " -q -c testfiles/bbackupd.conf " + compareReturnValue = ::system(BBACKUPQUERY " " + "-c testfiles/bbackupd.conf " "-l testfiles/query15.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 3); + "-Werror \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Error); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // close the file again, check that compare // works again CloseHandle(handle); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query15a.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); } #endif @@ -3055,11 +3684,12 @@ int test_bbackupd() // Wait and compare (a little bit longer than usual) wait_for_backup_operation( (TIME_TO_WAIT_FOR_BACKUP_OPERATION*3) / 2); - compareReturnValue = ::system(BBACKUPQUERY " -q " + compareReturnValue = ::system(BBACKUPQUERY " " "-c testfiles/bbackupd.conf " "-l testfiles/query4a.log " - "\"compare -acQ\" quit"); - TEST_RETURN(compareReturnValue, 1); + "-Wwarning \"compare -acQ\" quit"); + TEST_RETURN(compareReturnValue, + BackupQueries::ReturnCode::Compare_Same); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); // Kill it again @@ -3067,10 +3697,12 @@ int test_bbackupd() } } - // List the files on the server + /* + // List the files on the server - why? ::system(BBACKUPQUERY " -q -c testfiles/bbackupd.conf " "-l testfiles/queryLIST.log \"list -rotdh\" quit"); TestRemoteProcessMemLeaks("bbackupquery.memleaks"); + */ #ifndef WIN32 if(::getuid() == 0) |