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()); }
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, snapshot_restoration_on_a_clone) { const auto wrns_parent(make_random_namespace()); const std::string parent_name(wrns_parent->ns().str()); SharedVolumePtr parent = newVolume(VolumeId(parent_name), be::Namespace(parent_name)); const std::string pattern1("before-parent-snapshot"); writeToVolume(*parent, 0, parent->getClusterSize(), pattern1); const SnapshotName parent_snap("parent-snapshot"); parent->createSnapshot(parent_snap); waitForThisBackendWrite(*parent); const auto wrns_clone(make_random_namespace()); const std::string clone_name(wrns_clone->ns().str()); SharedVolumePtr clone = createClone(clone_name, be::Namespace(clone_name), be::Namespace(parent_name), parent_snap); const std::string pattern2("before-clone-snapshot"); writeToVolume(*clone, 0, clone->getClusterSize(), pattern2); const SnapshotName clone_snap("clone-snapshot"); clone->createSnapshot(clone_snap); waitForThisBackendWrite(*clone); const std::string pattern3("after-clone-snapshot"); writeToVolume(*clone, 0, clone->getClusterSize(), pattern3); checkVolume(*clone, 0, clone->getClusterSize(), pattern3); restoreSnapshot(*clone, clone_snap); checkVolume(*clone, 0, clone->getClusterSize(), pattern2); }
void startVolume() { ASSERT(not vol_); startVolManager(); vol_ = newVolume("volume1", getNamespace()); ASSERT(vol_); dStore_ = vol_->getDataStore(); ASSERT(dStore_); }
void VlcWidgetVolumeSlider::setVolume(const int &volume) { if (_currentVolume == volume) return; lock(); _currentVolume = volume; setValue(_currentVolume); emit newVolume(_currentVolume); unlock(); }
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); }
void VlcWidgetVolumeSlider::setVolume(const int &volume) { if (_currentVolume == volume) return; lock(); _currentVolume = volume; _slider->setValue(_currentVolume); _label->setText(QString().number(_currentVolume)); emit newVolume(_currentVolume); unlock(); }
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()); }
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); }
SharedVolumePtr make_volume(const be::BackendTestSetup::WithRandomNamespace& wrns) { return newVolume(make_volume_params(wrns)); }
/* * Items needed: * mr.PoolId must be set * mr.StorageId should also be set * mr.ScratchPoolId could be set (used if create==true) * jcr->wstore * jcr->db * jcr->pool * MEDIA_DBR mr with PoolId set * create -- whether or not to create a new volume */ int find_next_volume_for_append(JCR *jcr, MEDIA_DBR *mr, int index, bool create, bool prune) { int retry = 0; bool ok; bool InChanger; STORE *store = jcr->wstore; bstrncpy(mr->MediaType, store->media_type, sizeof(mr->MediaType)); Dmsg3(100, "find_next_vol_for_append: JobId=%u PoolId=%d, MediaType=%s\n", (uint32_t)jcr->JobId, (int)mr->PoolId, mr->MediaType); /* * If we are using an Autochanger, restrict Volume * search to the Autochanger on the first pass */ InChanger = store->autochanger; /* * Find the Next Volume for Append */ db_lock(jcr->db); for ( ;; ) { bstrncpy(mr->VolStatus, "Append", sizeof(mr->VolStatus)); /* want only appendable volumes */ /* * 1. Look for volume with "Append" status. */ ok = db_find_next_volume(jcr, jcr->db, index, InChanger, mr); if (!ok) { Dmsg4(150, "after find_next_vol ok=%d index=%d InChanger=%d Vstat=%s\n", ok, index, InChanger, mr->VolStatus); /* * 2. Try finding a recycled volume */ ok = find_recycled_volume(jcr, InChanger, mr); Dmsg2(150, "find_recycled_volume ok=%d FW=%d\n", ok, mr->FirstWritten); if (!ok) { /* * 3. Try recycling any purged volume */ ok = recycle_oldest_purged_volume(jcr, InChanger, mr); if (!ok) { /* * 4. Try pruning Volumes */ if (prune) { Dmsg0(150, "Call prune_volumes\n"); prune_volumes(jcr, InChanger, mr); } ok = recycle_oldest_purged_volume(jcr, InChanger, mr); if (!ok && create) { Dmsg4(150, "after prune volumes_vol ok=%d index=%d InChanger=%d Vstat=%s\n", ok, index, InChanger, mr->VolStatus); /* * 5. Try pulling a volume from the Scratch pool */ ok = get_scratch_volume(jcr, InChanger, mr); Dmsg4(150, "after get scratch volume ok=%d index=%d InChanger=%d Vstat=%s\n", ok, index, InChanger, mr->VolStatus); } /* * If we are using an Autochanger and have not found * a volume, retry looking for any volume. */ if (!ok && InChanger) { InChanger = false; continue; /* retry again accepting any volume */ } } } if (!ok && create) { /* * 6. Try "creating" a new Volume */ ok = newVolume(jcr, mr); } /* * Look at more drastic ways to find an Appendable Volume */ if (!ok && (jcr->pool->purge_oldest_volume || jcr->pool->recycle_oldest_volume)) { Dmsg2(200, "No next volume found. PurgeOldest=%d\n RecyleOldest=%d", jcr->pool->purge_oldest_volume, jcr->pool->recycle_oldest_volume); /* Find oldest volume to recycle */ ok = db_find_next_volume(jcr, jcr->db, -1, InChanger, mr); Dmsg1(200, "Find oldest=%d Volume\n", ok); if (ok && prune) { UAContext *ua; Dmsg0(200, "Try purge Volume.\n"); /* * 7. Try to purging oldest volume only if not UA calling us. */ ua = new_ua_context(jcr); if (jcr->pool->purge_oldest_volume && create) { Jmsg(jcr, M_INFO, 0, _("Purging oldest volume \"%s\"\n"), mr->VolumeName); ok = purge_jobs_from_volume(ua, mr); /* * 8. or try recycling the oldest volume */ } else if (jcr->pool->recycle_oldest_volume) { Jmsg(jcr, M_INFO, 0, _("Pruning oldest volume \"%s\"\n"), mr->VolumeName); ok = prune_volume(ua, mr); } free_ua_context(ua); if (ok) { ok = recycle_volume(jcr, mr); Dmsg1(400, "Recycle after purge oldest=%d\n", ok); } } } } Dmsg2(100, "VolJobs=%d FirstWritten=%d\n", mr->VolJobs, mr->FirstWritten); if (ok) { /* If we can use the volume, check if it is expired */ if (has_volume_expired(jcr, mr)) { if (retry++ < 200) { /* sanity check */ continue; /* try again from the top */ } else { Jmsg(jcr, M_ERROR, 0, _( "We seem to be looping trying to find the next volume. I give up.\n")); } } } break; } /* end for loop */ db_unlock(jcr->db); Dmsg1(150, "return ok=%d find_next_vol\n", ok); return ok; }
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); }