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 eDVBVolumecontrol::setVolume(int left, int right)
{
/* left, right is 0..100 */
leftVol = checkVolume(left);
rightVol = checkVolume(right);
#ifdef HAVE_ALSA
if (mainVolume) snd_mixer_selem_set_playback_volume_all(mainVolume, muted ? 0 : leftVol);
#else
/* convert to -1dB steps */
left = 63 - leftVol * 63 / 100;
right = 63 - rightVol * 63 / 100;
/* now range is 63..0, where 0 is loudest */
#if HAVE_DVB_API_VERSION < 3
audioMixer_t mixer;
#else
audio_mixer_t mixer;
#endif
#if HAVE_DVB_API_VERSION < 3
/* convert to linear scale. 0 = loudest, ..63 */
mixer.volume_left = 63.0-pow(1.068241, 63-left);
mixer.volume_right = 63.0-pow(1.068241, 63-right);
#else
mixer.volume_left = left;
mixer.volume_right = right;
#endif
eDebug("Setvolume: %d %d (raw)", leftVol, rightVol);
eDebug("Setvolume: %d %d (-1db)", left, right);
#if HAVE_DVB_API_VERSION < 3
eDebug("Setvolume: %d %d (lin)", mixer.volume_left, mixer.volume_right);
#endif
int fd = openMixer();
if (fd >= 0)
{
#ifdef HAVE_DVB_API_VERSION
ioctl(fd, AUDIO_SET_MIXER, &mixer);
#endif
closeMixer(fd);
return;
}
//HACK?
FILE *f;
if((f = fopen("/proc/stb/avs/0/volume", "wb")) == NULL) {
eDebug("cannot open /proc/stb/avs/0/volume(%m)");
return;
}
fprintf(f, "%d", left); /* in -1dB */
fclose(f);
#endif
}
SoftwareVolume::SoftwareVolume(QObject *parent)
: VolumeControl(parent)
{
QSettings settings(PlayerUtils::configFile(), QSettings::IniFormat);
left_ = settings.value("Volume/left", 80).toInt();
right_ = settings.value("Volume/right", 80).toInt();
blockSignals(TRUE);
checkVolume();
blockSignals(FALSE);
QTimer::singleShot(125, this, SLOT(checkVolume()));
instance_ = this;
}
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, 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);
}
}
void eDVBVolumecontrol::setVolume(int left, int right)
{
/* left, right is 0..100 */
leftVol = checkVolume(left);
rightVol = checkVolume(right);
#ifdef HAVE_ALSA
eDebug("[eDVBVolumecontrol] Setvolume: ALSA leftVol=%d", leftVol);
if (mainVolume)
snd_mixer_selem_set_playback_volume_all(mainVolume, muted ? 0 : leftVol);
#else
/* convert to -1dB steps */
left = 63 - leftVol * 63 / 100;
right = 63 - rightVol * 63 / 100;
/* now range is 63..0, where 0 is loudest */
#if 0
audio_mixer_t mixer;
mixer.volume_left = left;
mixer.volume_right = right;
eDebug("[eDVBVolumecontrol] Setvolume: raw: %d %d, -1db: %d %d", leftVol, rightVol, left, right);
int fd = openMixer();
if (fd >= 0)
{
#ifdef DVB_API_VERSION
if (ioctl(fd, AUDIO_SET_MIXER, &mixer) < 0) {
eDebug("[eDVBVolumecontrol] Setvolume failed: %m");
}
#endif
closeMixer(fd);
return;
}
else {
eDebug("[eDVBVolumecontrol] SetVolume failed to open mixer: %m");
}
#endif
//HACK?
CFile::writeInt("/proc/stb/avs/0/volume", left); /* in -1dB */
#endif
}
SoundPref::SoundPref(QWidget *parent)
: PrefWidget(parent)
{
ui.setupUi(this);
AmeDirs *ame = AmeDirs::global();
stg1 = new AmeSettings(ame->stdDir(AmeDirs::Configs) + "/Sound", QSettings::IniFormat);
readSettings();
// Sound effects tab
ui.soundsLst->setColumnCount(2);
ui.soundsLst->setColumnWidth(0, 420);
QStringList hdr;
hdr << "Name" << "Enabled";
ui.soundsLst->setHeaderLabels(hdr);
Sounds lst = AmeSoundTheme::global()->getAll();
for (int i=0; i<lst.size(); i++) {
QTreeWidgetItem *it = new QTreeWidgetItem(ui.soundsLst);
it->setText(0, lst.at(i)->name);
it->setText(1, "");
if (lst.at(i)->enabled)
it->setCheckState(1, Qt::Checked);
else
it->setCheckState(1, Qt::Unchecked);
it->setData(1, Qt::UserRole, QVariant(lst.at(i)->soundId));
}
connect(ui.soundsLst, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(onSoundItemChange(QTreeWidgetItem *, int)));
connect(ui.soundsLst, SIGNAL(itemActivated(QTreeWidgetItem*, int)), this, SLOT(onSoundItem(QTreeWidgetItem *, int)));
ui.volumeSldr->setMinimum(0);
ui.volumeSldr->setMaximum(100);
connect(ui.volumeSldr, SIGNAL(sliderMoved(int)), this, SLOT(onSlider(int)));
connect(ui.volumeSldr, SIGNAL(sliderReleased()), this, SLOT(onSliderRelease()));
connect(ui.muteChk, SIGNAL(clicked()), this, SLOT(onMute()));
connect(ui.sndVolFeedbackChk, SIGNAL(clicked()),this, SLOT(onVolumeFeedback()));
connect(ui.showCtrlChk, SIGNAL(clicked()), this, SLOT(onShowHideVolumeCtrl()));
timer = new QTimer();
connect(timer, SIGNAL(timeout()), this, SLOT(checkVolume()));
timer->start(100);
// Output settings tab
hwList = new hwDevices();
getHwList(modePlayback);
getMixerDevices(modePlayback);
connect(ui.playbackMixerDeviceCmb, SIGNAL(activated(const QString &)), this, SLOT(onMixerDevice(const QString &)));
refresh();
moduleName = "Sound";
}
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);
}
}
void
worker(Volume& v,
std::atomic<bool>& stop)
{
size_t worker_iterations = 0;
auto make_pattern([](size_t i,
size_t c) -> std::string
{
return "iteration-"s +
boost::lexical_cast<std::string>(i) +
"-cluster-"s +
boost::lexical_cast<std::string>(c);
});
const size_t csize = v.getClusterSize();
const size_t clusters = v.getSize() < csize;
while (not stop)
{
for (size_t i = 0; i < clusters; ++i)
{
writeToVolume(*&v,
i * v.getClusterMultiplier(),
csize,
make_pattern(worker_iterations,
i));
}
v.scheduleBackendSync();
for (size_t i = 0; i < clusters; ++i)
{
checkVolume(*&v,
i * v.getClusterMultiplier(),
csize,
make_pattern(worker_iterations,
i));
}
++worker_iterations;
}
LOG_INFO("worker exiting after " << worker_iterations << " iterations");
}
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);
}
VolumeControl *VolumeControl::create(QObject *parent)
{
QSettings settings(PlayerUtils::configFile(), QSettings::IniFormat);
if (settings.value("Volume/software_volume", FALSE).toBool())
{
return new SoftwareVolume(parent);
}
VolumeControl *control = 0;
if (Output::currentFactory())
{
control = Output::currentFactory()->createVolumeControl(parent);
}
if (!control)
{
return new SoftwareVolume(parent);
}
QTimer *timer_ = new QTimer(control);
connect(timer_, SIGNAL(timeout()), control, SLOT(checkVolume()));
timer_->start(125);
return control;
}
void
test_after_tlog(bool failover)
{
const auto wrns(make_random_namespace());
SharedVolumePtr v = make_volume(*wrns);
const std::string pattern1("Hairdresser On Fire");
{
SCOPED_BLOCK_BACKEND(*v);
writeToVolume(*v,
v->getClusterMultiplier() * CachePage::capacity(),
v->getClusterSize(),
pattern1);
}
v->scheduleBackendSync();
waitForThisBackendWrite(*v);
const std::string pattern2("Such A Little Thing Makes Such A Big Difference");
writeToVolume(*v,
2 * v->getClusterMultiplier() * CachePage::capacity(),
v->getClusterSize(),
pattern2);
const auto ncfgs(node_configs());
if (failover)
{
mds_manager_->stop_one(ncfgs[0]);
checkVolume(*v,
0,
v->getClusterSize(),
"");
}
else
{
const std::vector<MDSNodeConfig> ncfgs2{ ncfgs[1],
ncfgs[0] };
v->updateMetaDataBackendConfig(MDSMetaDataBackendConfig(ncfgs2,
ApplyRelocationsToSlaves::T));
}
check_config(*v,
ncfgs,
true);
checkVolume(*v,
v->getClusterMultiplier() * CachePage::capacity(),
v->getClusterSize(),
pattern1);
checkVolume(*v,
2 * v->getClusterMultiplier() * CachePage::capacity(),
v->getClusterSize(),
pattern2);
destroyVolume(v,
DeleteLocalData::F,
RemoveVolumeCompletely::F);
v = localRestart(wrns->ns());
check_config(*v,
ncfgs,
true);
checkVolume(*v,
v->getClusterMultiplier() * CachePage::capacity(),
v->getClusterSize(),
pattern1);
checkVolume(*v,
2 * v->getClusterMultiplier() * CachePage::capacity(),
v->getClusterSize(),
pattern2);
}
void
test_before_tlog(bool failover)
{
const auto wrns(make_random_namespace());
SharedVolumePtr v = make_volume(*wrns);
const auto ncfgs(node_configs());
const std::string pattern("King Leer");
{
SCOPED_BLOCK_BACKEND(*v);
writeToVolume(*v,
v->getClusterMultiplier() * CachePage::capacity(),
v->getClusterSize(),
pattern);
if (failover)
{
mds_manager_->stop_one(ncfgs[0]);
checkVolume(*v,
0,
v->getClusterSize(),
"");
}
else
{
const std::vector<MDSNodeConfig> ncfgs2{ ncfgs[1],
ncfgs[0] };
v->updateMetaDataBackendConfig(MDSMetaDataBackendConfig(ncfgs2,
ApplyRelocationsToSlaves::T));
}
check_config(*v,
ncfgs,
true);
checkVolume(*v,
v->getClusterMultiplier() * CachePage::capacity(),
v->getClusterSize(),
pattern);
}
destroyVolume(v,
DeleteLocalData::F,
RemoveVolumeCompletely::F);
v = localRestart(wrns->ns());
check_config(*v,
ncfgs,
true);
checkVolume(*v,
v->getClusterMultiplier() * CachePage::capacity(),
v->getClusterSize(),
pattern);
}
void pkg_node::checkVolume( char *filename)
{
lfu_t_volref *volref;
int volref_cnt;
pwr_tVid vol_vid;
pwr_tCid vol_cid;
pwr_tTime vol_time;
char vol_name[80];
bool found;
pwr_tStatus sts;
char fname[200];
sts = lfu_GetVolume( filename, vol_name, &vol_vid, &vol_cid, &vol_time);
if ( EVEN(sts)) throw wb_error(sts);
found = false;
for ( int i = 0; i < (int)m_volumelist.size(); i++) {
if ( m_volumelist[i].m_vid == vol_vid) {
found = true;
if ( m_volumelist[i].m_time.tv_sec != vol_time.tv_sec) {
char msg[200];
sprintf( msg, "Version mismatch volume %s in %s", (volref+i)->name, filename);
MsgWindow::message( 'E', msg, msgw_ePop_No);
m_errors++;
}
break;
}
}
if ( !found) {
pkg_volume vol( vol_name, filename, vol_vid, vol_time);
m_volumelist.push_back( vol);
}
if ( vol_cid == pwr_eClass_DetachedClassVolume)
// No check of referenced volumes
return;
sts = lfu_GetVolRef( filename, &volref, &volref_cnt);
if ( EVEN(sts)) throw wb_error(sts);
for ( int i = 0; i < volref_cnt; i++) {
wb_erep::volumeNameToFilename( &sts, (volref+i)->name, fname);
if ( EVEN(sts)) {
char msg[200];
sprintf( msg, "Loadfile not found: %s", (volref+i)->name);
MsgWindow::message( 'E', msg, msgw_ePop_No);
m_errors++;
continue;
}
checkVolume( fname);
for ( int j = 0; j < (int)m_volumelist.size(); j++) {
if ( m_volumelist[j].m_vid == (volref+i)->vid) {
if ( m_volumelist[j].m_time.tv_sec != (volref+i)->version.tv_sec) {
char msg[200];
sprintf( msg, "Version mismatch volume %s in %s and %s", (volref+i)->name, filename, m_volumelist[j].m_filename);
MsgWindow::message( 'E', msg, msgw_ePop_No);
m_errors++;
}
break;
}
}
}
free( (char *)volref);
}
void SoftwareVolume::setVolume(int left, int right)
{
left_ = left;
right_ = right;
checkVolume();
}
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);
}