TEST_P(DtlCheckerTest, auto_recovery)
{
auto ns_ptr = make_random_namespace();
const backend::Namespace& ns = ns_ptr->ns();
SharedVolumePtr v = newVolume("vol1",
ns);
const auto port = get_next_foc_port();
ASSERT_THROW(v->setFailOverCacheConfig(FailOverCacheConfig(FailOverCacheTestSetup::host(),
port,
GetParam().foc_mode())),
fungi::IOException);
ASSERT_EQ(VolumeFailOverState::DEGRADED,
v->getVolumeFailOverState());
auto foc_ctx(start_one_foc());
ASSERT_EQ(port,
foc_ctx->port());
boost::this_thread::sleep_for(2 * dtl_check_interval_);
ASSERT_EQ(VolumeFailOverState::OK_SYNC,
v->getVolumeFailOverState());
}
// OVS-2204: there were errors even on retry with a new connection which actually
// should have succeeded - try to get to the bottom of that
TEST_F(BackendInterfaceTest, retry_on_error)
{
const std::string oname("some-object");
const fs::path opath(path_ / oname);
const yt::CheckSum cs(createTestFile(opath,
4096,
"some pattern"));
yt::CheckSum wrong_cs(1);
ASSERT_NE(wrong_cs,
cs);
std::unique_ptr<be::BackendTestSetup::WithRandomNamespace>
nspace(make_random_namespace());
const size_t retries = 7;
ASSERT_LE(retries,
cm_->capacity());
be::BackendInterfacePtr bi(cm_->newBackendInterface(nspace->ns(),
retries));
ASSERT_THROW(bi->write(opath,
oname,
OverwriteObject::F,
&wrong_cs),
be::BackendInputException);
ASSERT_EQ(retries + 1,
cm_->size());
}
TEST_P(BigReadWriteTest, bigReadsOnFull)
{
auto ns_ptr = make_random_namespace();
SharedVolumePtr v = newVolume(VolumeId("volume1"),
ns_ptr->ns());
SCOPED_BLOCK_BACKEND(*v);
size_t csz = v->getClusterSize();
size_t lba_size = v->getLBASize();
const std::string pattern(csz,'a');
size_t scoMul = v->getSCOMultiplier();
for(size_t i = 0;i < 50*scoMul; ++i)
{
writeToVolume(*v, i* csz / lba_size, csz, pattern);
}
// Stop here to manually delete sco's to check error handling
for(size_t i = 0; i < scoMul; ++i)
{
checkVolume(*v,0, csz*scoMul, pattern);
}
}
TEST_P(SnapshotRestoreTest, TestFailOver)
{
auto foc_ctx(start_one_foc());
auto ns_ptr = make_random_namespace();
SharedVolumePtr v = newVolume(VolumeId("volume1"),
ns_ptr->ns(),
VolumeSize((1 << 18) * 512),
SCOMultiplier(1));
v->setFailOverCacheConfig(foc_ctx->config(GetParam().foc_mode()));
VolumeConfig cfg = v->get_config();
v->createSnapshot(SnapshotName("snap0"));
for(int i = 0; i < 5; ++i)
{
writeToVolume(*v,
0,
4096,
"a");
}
waitForThisBackendWrite(*v);
v->restoreSnapshot(SnapshotName("snap0"));
for(int i = 0; i < 7; ++i)
{
writeToVolume(*v,
8,
4096,
"d");
}
flushFailOverCache(*v);
destroyVolume(v,
DeleteLocalData::T,
RemoveVolumeCompletely::F);
SharedVolumePtr v1 = 0;
v1 = getVolume(VolumeId("volume1"));
ASSERT_FALSE(v1);
restartVolume(cfg);
v1 = getVolume(VolumeId("volume1"));
ASSERT_TRUE(v1 != nullptr);
checkVolume(*v1,0,4096, "\0");
checkVolume(*v1,8,4096, "d");
checkCurrentBackendSize(*v1);
}
TEST_P(BigReadWriteTest, bigReadsOnEmpty)
{
auto ns_ptr = make_random_namespace();
SharedVolumePtr v = newVolume(VolumeId("volume1"),
ns_ptr->ns());
size_t csz = v->getClusterSize();
const std::string pattern(csz,'\0');
size_t scoMul = v->getSCOMultiplier();
for(size_t i = 0; i < scoMul; ++i)
{
checkVolume(*v,0, csz*scoMul, pattern);
}
}
TEST_P(BigReadWriteTest, OneBigWriteOneBigRead)
{
auto ns_ptr = make_random_namespace();
SharedVolumePtr v = newVolume(VolumeId("volume1"),
ns_ptr->ns());
SCOPED_BLOCK_BACKEND(*v);
size_t csz = v->getClusterSize();
const std::string pattern(csz,'a');
size_t scoMul = v->getSCOMultiplier();
writeToVolume(*v, 0, csz * scoMul, pattern);
// Stop here to manually delete sco's to check error handling
checkVolume(*v,0, csz*scoMul, pattern);
}
TEST_P(SnapshotRestoreTest, RestoreAndWriteAgain1)
{
auto ns_ptr = make_random_namespace();
SharedVolumePtr v = newVolume(VolumeId("volume1"),
ns_ptr->ns(),
VolumeSize(1 << 26),
SCOMultiplier(1));
const std::string pattern("e-manual");
v->createSnapshot(SnapshotName("snap1"));
waitForThisBackendWrite(*v);
writeToVolume(*v, 0, 5 * 4096, pattern);
waitForThisBackendWrite(*v);
restoreSnapshot(*v,"snap1");
writeToVolume(*v, 0, 4*4096, pattern);
waitForThisBackendWrite(*v);
checkCurrentBackendSize(*v);
}
TEST_P(SnapshotRestoreTest, HaltOnError)
{
auto ns_ptr = make_random_namespace();
SharedVolumePtr v = newVolume(VolumeId("volume1"),
ns_ptr->ns());
const std::string pattern1("blah");
const TLogId tlog_id(v->getSnapshotManagement().getCurrentTLogId());
writeToVolume(*v, 0, 4096, pattern1);
v->createSnapshot(SnapshotName("snap1"));
waitForThisBackendWrite(*v);
EXPECT_THROW(restoreSnapshot(*v, "snap42"),
std::exception);
EXPECT_FALSE(v->is_halted());
v->getBackendInterface()->remove(boost::lexical_cast<std::string>(tlog_id));
EXPECT_THROW(restoreSnapshot(*v, "snap1"),
std::exception);
EXPECT_TRUE(v->is_halted());
}
// OVS-2204: for some reason the count of open fds goes up after an error, but
// valgrind does not report a leak. Try to figure our what's going on here.
TEST_F(ConnectionManagerTest, limited_pool_on_errors)
{
std::async(std::launch::async,
[&]
{
pin_to_cpu_0();
const std::string oname("some-object");
const fs::path opath(path_ / oname);
const yt::CheckSum cs(createTestFile(opath,
4096,
"some pattern"));
yt::CheckSum wrong_cs(1);
ASSERT_NE(wrong_cs,
cs);
std::unique_ptr<be::BackendTestSetup::WithRandomNamespace>
nspace(make_random_namespace());
be::BackendInterfacePtr bi(bi_(nspace->ns()));
const size_t count = 2 * cm_->capacity();
for (size_t i = 0; i < count; ++i)
{
ASSERT_THROW(bi->write(opath,
oname,
OverwriteObject::F,
&wrong_cs),
be::BackendInputException);
}
ASSERT_EQ(cm_->capacity() / cm_->shards(),
cm_->size());
}).wait();
}
TEST_P(PrefetchThreadTest, test_one)
{
auto ns_ptr = make_random_namespace();
const backend::Namespace& ns = ns_ptr->ns();
Volume* v = newVolume("v1",
ns);
const size_t numwrites = 20;
for(size_t i = 0; i < numwrites; ++i)
{
writeToVolume(v,
0,
4096,
"Superflous");
}
syncToBackend(v);
destroyVolume(v,
DeleteLocalData::T,
RemoveVolumeCompletely::F);
}
void
SetUp() override final
{
BackendTestBase::SetUp();
nspace_ = make_random_namespace();
}
TEST_P(PrefetchThreadTest, test_two)
{
// backend::Namespace n1;
auto ns_ptr = make_random_namespace();
const backend::Namespace& n1 = ns_ptr->ns();
Volume* v = newVolume("v1",
n1);
// Y42 put in VolManagerTestSetup
const VolumeConfig cfg = v->get_config();
const uint64_t scoSize = cfg.getSCOSize();
const size_t numwrites = 20;
for(size_t i = 0; i < numwrites; ++i)
{
writeToVolume(v,
0,
scoSize,
"Superflous");
}
syncToBackend(v);
SCONameList list;
VolManager::get()->getSCOCache()->getSCONameList(n1,
list,
true);
ASSERT_EQ(numwrites, list.size());
for(SCONameList::const_iterator it = list.begin();
it != list.end();
++it)
{
VolManager::get()->getSCOCache()->removeSCO(n1,
*it,
false);
}
{
SCONameList list;
VolManager::get()->getSCOCache()->getSCONameList(n1,
list,
true);
ASSERT_TRUE(list.empty());
}
//fill the cache with 1 SCO
SCONameList::const_iterator it = list.begin();
v->getPrefetchData().addSCO(*it, 1);
++it;
//make sure cachedXValMin_ is set
VolManager::get()->getSCOCache()->cleanup();
//make sure next SCO's with low sap are also prefetched as cache is not full
float sap = 0.01;
for( ; it != list.end(); ++it)
{
v->getPrefetchData().addSCO(*it, sap);
sap *= 0.9;
}
SCONameList list2;
size_t counter = 0;
while(list2.size() != numwrites and counter < 60)
{
boost::this_thread::sleep(boost::posix_time::seconds(1));
list2.clear();
++counter;
VolManager::get()->getSCOCache()->getSCONameList(n1,
list2,
true);
}
ASSERT_EQ(numwrites, list2.size());
destroyVolume(v,
DeleteLocalData::T,
RemoveVolumeCompletely::F);
}
TEST_P(SnapshotRestoreTest, SimpleRestore)
{
auto ns_ptr = make_random_namespace();
SharedVolumePtr v = newVolume(VolumeId("volume1"),
ns_ptr->ns());
const std::string pattern1("Frederik");
writeToVolume(*v, 0, 4096, pattern1);
waitForThisBackendWrite(*v);
v->createSnapshot(SnapshotName("snap1"));
const std::string pattern2("Frederik");
writeToVolume(*v, 0, 4096, pattern2);
waitForThisBackendWrite(*v);
v->createSnapshot(SnapshotName("snap2"));
const std::string pattern3("Arne");
writeToVolume(*v, 0, 4096, pattern3);
waitForThisBackendWrite(*v);
v->createSnapshot(SnapshotName("snap3"));
const std::string pattern4("Bart");
writeToVolume(*v, 0, 4096, pattern4);
waitForThisBackendWrite(*v);
v->createSnapshot(SnapshotName("snap4"));
const std::string pattern5("Wouter");
writeToVolume(*v, 0, 4096, pattern5);
checkVolume(*v,0,4096,pattern5);
waitForThisBackendWrite(*v);
EXPECT_NO_THROW(restoreSnapshot(*v,
"snap4"));
checkVolume(*v,0,4096,pattern4);
writeToVolume(*v, 0, 4096, "Bollocks");
waitForThisBackendWrite(*v);
v->createSnapshot(SnapshotName("snapper"));
waitForThisBackendWrite(*v);
EXPECT_NO_THROW(restoreSnapshot(*v,
"snap3"));
checkVolume(*v,0,4096,pattern3);
writeToVolume(*v, 0, 4096, "Bollocks");
waitForThisBackendWrite(*v);
v->createSnapshot(SnapshotName("snapper"));
waitForThisBackendWrite(*v);
EXPECT_NO_THROW(restoreSnapshot(*v,
"snap2"));
checkVolume(*v,0,4096,pattern2);
writeToVolume(*v, 0, 4096, "Bollocks");
waitForThisBackendWrite(*v);
v->createSnapshot(SnapshotName("snapper"));
waitForThisBackendWrite(*v);
EXPECT_NO_THROW(restoreSnapshot(*v,
"snap1"));
checkVolume(*v,0,4096,pattern1);
writeToVolume(*v, 0, 4096, "Bollocks");
waitForThisBackendWrite(*v);
v->createSnapshot(SnapshotName("snapper"));
waitForThisBackendWrite(*v);
checkCurrentBackendSize(*v);
}
