Update API: initial support
Initial pieces of the Update API callback framework.
- move the status callback params to a new object, UpdateEngineStatus to
allow for the easier addition of new params in the future.
- switch the IUpdateEngineStatusCallback to provide a
ParcelableUpdateEngineStatus instead of a series of individual params
- move the various GetStatus() methods to use the UpdateEngineStatus
object instead of a series of params (which will need future expansion)
- Add current and new product/os versions to both the UpdateEngineStatus
and the ParcelableUpdateEngineStatus.
Bug: 64808702
Test: unit tests, and performing OTAs via a test app calling
IUpdateEngine::AttemptUpdate() via UpdateManager::performUpdateNow()
Change-Id: I53f66f3511049f0809855814e1e758023cd8cc08
(cherry picked from commit 4f96ebf85022837603f2e10100a044d234b7d86f)
diff --git a/update_manager/fake_updater_provider.h b/update_manager/fake_updater_provider.h
index 44389f4..a7c15b5 100644
--- a/update_manager/fake_updater_provider.h
+++ b/update_manager/fake_updater_provider.h
@@ -53,7 +53,7 @@
return &var_new_version_;
}
- FakeVariable<int64_t>* var_payload_size() override {
+ FakeVariable<uint64_t>* var_payload_size() override {
return &var_payload_size_;
}
@@ -100,7 +100,7 @@
"stage", kVariableModePoll};
FakeVariable<std::string> var_new_version_{ // NOLINT(whitespace/braces)
"new_version", kVariableModePoll};
- FakeVariable<int64_t> var_payload_size_{ // NOLINT(whitespace/braces)
+ FakeVariable<uint64_t> var_payload_size_{// NOLINT(whitespace/braces)
"payload_size", kVariableModePoll};
FakeVariable<std::string> var_curr_channel_{ // NOLINT(whitespace/braces)
"curr_channel", kVariableModePoll};
diff --git a/update_manager/real_updater_provider.cc b/update_manager/real_updater_provider.cc
index 1a3e65a..a085f42 100644
--- a/update_manager/real_updater_provider.cc
+++ b/update_manager/real_updater_provider.cc
@@ -25,10 +25,12 @@
#include <base/time/time.h>
#include <update_engine/dbus-constants.h>
+#include "update_engine/client_library/include/update_engine/update_status.h"
#include "update_engine/common/clock_interface.h"
#include "update_engine/common/prefs.h"
#include "update_engine/omaha_request_params.h"
#include "update_engine/update_attempter.h"
+#include "update_engine/update_status_utils.h"
using base::StringPrintf;
using base::Time;
@@ -36,6 +38,7 @@
using chromeos_update_engine::OmahaRequestParams;
using chromeos_update_engine::SystemState;
using std::string;
+using update_engine::UpdateEngineStatus;
namespace chromeos_update_manager {
@@ -60,27 +63,32 @@
class GetStatusHelper {
public:
GetStatusHelper(SystemState* system_state, string* errmsg) {
- is_success_ = system_state->update_attempter()->GetStatus(
- &last_checked_time_, &progress_, &update_status_, &new_version_,
- &payload_size_);
- if (!is_success_ && errmsg)
+ is_success_ =
+ system_state->update_attempter()->GetStatus(&update_engine_status_);
+ if (!is_success_ && errmsg) {
*errmsg = "Failed to get a status update from the update engine";
+ }
}
inline bool is_success() { return is_success_; }
- inline int64_t last_checked_time() { return last_checked_time_; }
- inline double progress() { return progress_; }
- inline const string& update_status() { return update_status_; }
- inline const string& new_version() { return new_version_; }
- inline int64_t payload_size() { return payload_size_; }
+ inline int64_t last_checked_time() {
+ return update_engine_status_.last_checked_time_ms;
+ }
+ inline double progress() { return update_engine_status_.progress; }
+ inline const string update_status() {
+ return chromeos_update_engine::UpdateStatusToString(
+ update_engine_status_.status);
+ }
+ inline const string& new_version() {
+ return update_engine_status_.new_version;
+ }
+ inline uint64_t payload_size() {
+ return update_engine_status_.new_size_bytes;
+ }
private:
bool is_success_;
- int64_t last_checked_time_;
- double progress_;
- string update_status_;
- string new_version_;
- int64_t payload_size_;
+ UpdateEngineStatus update_engine_status_;
};
// A variable reporting the time when a last update check was issued.
@@ -196,24 +204,18 @@
};
// A variable reporting the size of the update being processed in bytes.
-class PayloadSizeVariable : public UpdaterVariableBase<int64_t> {
+class PayloadSizeVariable : public UpdaterVariableBase<uint64_t> {
public:
PayloadSizeVariable(const string& name, SystemState* system_state)
- : UpdaterVariableBase<int64_t>(name, kVariableModePoll, system_state) {}
+ : UpdaterVariableBase<uint64_t>(name, kVariableModePoll, system_state) {}
private:
- const int64_t* GetValue(TimeDelta /* timeout */, string* errmsg) override {
+ const uint64_t* GetValue(TimeDelta /* timeout */, string* errmsg) override {
GetStatusHelper raw(system_state(), errmsg);
if (!raw.is_success())
return nullptr;
- if (raw.payload_size() < 0) {
- if (errmsg)
- *errmsg = string("Invalid payload size: %" PRId64, raw.payload_size());
- return nullptr;
- }
-
- return new int64_t(raw.payload_size());
+ return new uint64_t(raw.payload_size());
}
DISALLOW_COPY_AND_ASSIGN(PayloadSizeVariable);
diff --git a/update_manager/real_updater_provider.h b/update_manager/real_updater_provider.h
index b99bcc5..eb8b8e6 100644
--- a/update_manager/real_updater_provider.h
+++ b/update_manager/real_updater_provider.h
@@ -64,7 +64,7 @@
return var_new_version_.get();
}
- Variable<int64_t>* var_payload_size() override {
+ Variable<uint64_t>* var_payload_size() override {
return var_payload_size_.get();
}
@@ -107,7 +107,7 @@
std::unique_ptr<Variable<double>> var_progress_;
std::unique_ptr<Variable<Stage>> var_stage_;
std::unique_ptr<Variable<std::string>> var_new_version_;
- std::unique_ptr<Variable<int64_t>> var_payload_size_;
+ std::unique_ptr<Variable<uint64_t>> var_payload_size_;
std::unique_ptr<Variable<std::string>> var_curr_channel_;
std::unique_ptr<Variable<std::string>> var_new_channel_;
std::unique_ptr<Variable<bool>> var_p2p_enabled_;
diff --git a/update_manager/real_updater_provider_unittest.cc b/update_manager/real_updater_provider_unittest.cc
index 14eb30b..f128c77 100644
--- a/update_manager/real_updater_provider_unittest.cc
+++ b/update_manager/real_updater_provider_unittest.cc
@@ -38,6 +38,7 @@
using chromeos_update_engine::OmahaRequestParams;
using std::string;
using std::unique_ptr;
+using testing::DoAll;
using testing::Return;
using testing::SetArgPointee;
using testing::_;
@@ -67,6 +68,26 @@
return Time::FromLocalExploded(exp);
}
+ACTION_P(ActionSetUpdateEngineStatusLastCheckedTime, time_ms) {
+ arg0->last_checked_time_ms = time_ms;
+};
+
+ACTION_P(ActionSetUpdateEngineStatusProgress, progress) {
+ arg0->progress = progress;
+};
+
+ACTION_P(ActionSetUpdateEngineStatusStatus, status) {
+ arg0->status = status;
+}
+
+ACTION_P(ActionSetUpdateEngineStatusNewVersion, new_version) {
+ arg0->new_version = new_version;
+}
+
+ACTION_P(ActionSetUpdateEngineStatusNewSizeBytes, new_size_bytes) {
+ arg0->new_size_bytes = new_size_bytes;
+}
+
} // namespace
namespace chromeos_update_manager {
@@ -116,225 +137,189 @@
}
TEST_F(UmRealUpdaterProviderTest, GetLastCheckedTimeOkay) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<0>(FixedTime().ToTimeT()), Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(
+ ActionSetUpdateEngineStatusLastCheckedTime(FixedTime().ToTimeT()),
+ Return(true)));
UmTestUtils::ExpectVariableHasValue(RoundedToSecond(FixedTime()),
provider_->var_last_checked_time());
}
TEST_F(UmRealUpdaterProviderTest, GetLastCheckedTimeFailNoValue) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
.WillOnce(Return(false));
UmTestUtils::ExpectVariableNotSet(provider_->var_last_checked_time());
}
TEST_F(UmRealUpdaterProviderTest, GetProgressOkayMin) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<1>(0.0), Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusProgress(0.0), Return(true)));
UmTestUtils::ExpectVariableHasValue(0.0, provider_->var_progress());
}
TEST_F(UmRealUpdaterProviderTest, GetProgressOkayMid) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<1>(0.3), Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusProgress(0.3), Return(true)));
UmTestUtils::ExpectVariableHasValue(0.3, provider_->var_progress());
}
TEST_F(UmRealUpdaterProviderTest, GetProgressOkayMax) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<1>(1.0), Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusProgress(1.0), Return(true)));
UmTestUtils::ExpectVariableHasValue(1.0, provider_->var_progress());
}
TEST_F(UmRealUpdaterProviderTest, GetProgressFailNoValue) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
.WillOnce(Return(false));
UmTestUtils::ExpectVariableNotSet(provider_->var_progress());
}
TEST_F(UmRealUpdaterProviderTest, GetProgressFailTooSmall) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<1>(-2.0), Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusProgress(-2.0), Return(true)));
UmTestUtils::ExpectVariableNotSet(provider_->var_progress());
}
TEST_F(UmRealUpdaterProviderTest, GetProgressFailTooBig) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<1>(2.0), Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusProgress(2.0), Return(true)));
UmTestUtils::ExpectVariableNotSet(provider_->var_progress());
}
TEST_F(UmRealUpdaterProviderTest, GetStageOkayIdle) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<2>(update_engine::kUpdateStatusIdle),
- Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(
+ ActionSetUpdateEngineStatusStatus(update_engine::UpdateStatus::IDLE),
+ Return(true)));
UmTestUtils::ExpectVariableHasValue(Stage::kIdle, provider_->var_stage());
}
TEST_F(UmRealUpdaterProviderTest, GetStageOkayCheckingForUpdate) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(
- SetArgPointee<2>(update_engine::kUpdateStatusCheckingForUpdate),
- Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
+ update_engine::UpdateStatus::CHECKING_FOR_UPDATE),
+ Return(true)));
UmTestUtils::ExpectVariableHasValue(Stage::kCheckingForUpdate,
provider_->var_stage());
}
TEST_F(UmRealUpdaterProviderTest, GetStageOkayUpdateAvailable) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(
- SetArgPointee<2>(update_engine::kUpdateStatusUpdateAvailable),
- Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
+ update_engine::UpdateStatus::UPDATE_AVAILABLE),
+ Return(true)));
UmTestUtils::ExpectVariableHasValue(Stage::kUpdateAvailable,
provider_->var_stage());
}
TEST_F(UmRealUpdaterProviderTest, GetStageOkayDownloading) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<2>(update_engine::kUpdateStatusDownloading),
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
+ update_engine::UpdateStatus::DOWNLOADING),
Return(true)));
UmTestUtils::ExpectVariableHasValue(Stage::kDownloading,
provider_->var_stage());
}
TEST_F(UmRealUpdaterProviderTest, GetStageOkayVerifying) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<2>(update_engine::kUpdateStatusVerifying),
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
+ update_engine::UpdateStatus::VERIFYING),
Return(true)));
UmTestUtils::ExpectVariableHasValue(Stage::kVerifying,
provider_->var_stage());
}
TEST_F(UmRealUpdaterProviderTest, GetStageOkayFinalizing) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<2>(update_engine::kUpdateStatusFinalizing),
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
+ update_engine::UpdateStatus::FINALIZING),
Return(true)));
UmTestUtils::ExpectVariableHasValue(Stage::kFinalizing,
provider_->var_stage());
}
TEST_F(UmRealUpdaterProviderTest, GetStageOkayUpdatedNeedReboot) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(
- SetArgPointee<2>(update_engine::kUpdateStatusUpdatedNeedReboot),
- Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
+ update_engine::UpdateStatus::UPDATED_NEED_REBOOT),
+ Return(true)));
UmTestUtils::ExpectVariableHasValue(Stage::kUpdatedNeedReboot,
provider_->var_stage());
}
TEST_F(UmRealUpdaterProviderTest, GetStageOkayReportingErrorEvent) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(
- SetArgPointee<2>(update_engine::kUpdateStatusReportingErrorEvent),
- Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
+ update_engine::UpdateStatus::REPORTING_ERROR_EVENT),
+ Return(true)));
UmTestUtils::ExpectVariableHasValue(Stage::kReportingErrorEvent,
provider_->var_stage());
}
TEST_F(UmRealUpdaterProviderTest, GetStageOkayAttemptingRollback) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(
- SetArgPointee<2>(update_engine::kUpdateStatusAttemptingRollback),
- Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
+ update_engine::UpdateStatus::ATTEMPTING_ROLLBACK),
+ Return(true)));
UmTestUtils::ExpectVariableHasValue(Stage::kAttemptingRollback,
provider_->var_stage());
}
TEST_F(UmRealUpdaterProviderTest, GetStageFailNoValue) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
.WillOnce(Return(false));
UmTestUtils::ExpectVariableNotSet(provider_->var_stage());
}
-TEST_F(UmRealUpdaterProviderTest, GetStageFailUnknown) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<2>("FooUpdateEngineState"),
- Return(true)));
- UmTestUtils::ExpectVariableNotSet(provider_->var_stage());
-}
-
-TEST_F(UmRealUpdaterProviderTest, GetStageFailEmpty) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<2>(""), Return(true)));
- UmTestUtils::ExpectVariableNotSet(provider_->var_stage());
-}
-
TEST_F(UmRealUpdaterProviderTest, GetNewVersionOkay) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<3>("1.2.0"), Return(true)));
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(
+ DoAll(ActionSetUpdateEngineStatusNewVersion("1.2.0"), Return(true)));
UmTestUtils::ExpectVariableHasValue(string("1.2.0"),
provider_->var_new_version());
}
TEST_F(UmRealUpdaterProviderTest, GetNewVersionFailNoValue) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
.WillOnce(Return(false));
UmTestUtils::ExpectVariableNotSet(provider_->var_new_version());
}
TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeOkayZero) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<4>(static_cast<int64_t>(0)), Return(true)));
- UmTestUtils::ExpectVariableHasValue(static_cast<int64_t>(0),
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(
+ ActionSetUpdateEngineStatusNewSizeBytes(static_cast<uint64_t>(0)),
+ Return(true)));
+ UmTestUtils::ExpectVariableHasValue(static_cast<uint64_t>(0),
provider_->var_payload_size());
}
TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeOkayArbitrary) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<4>(static_cast<int64_t>(567890)),
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusNewSizeBytes(
+ static_cast<uint64_t>(567890)),
Return(true)));
- UmTestUtils::ExpectVariableHasValue(static_cast<int64_t>(567890),
+ UmTestUtils::ExpectVariableHasValue(static_cast<uint64_t>(567890),
provider_->var_payload_size());
}
TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeOkayTwoGigabytes) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<4>(static_cast<int64_t>(1) << 31),
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
+ .WillOnce(DoAll(ActionSetUpdateEngineStatusNewSizeBytes(
+ static_cast<uint64_t>(1) << 31),
Return(true)));
- UmTestUtils::ExpectVariableHasValue(static_cast<int64_t>(1) << 31,
+ UmTestUtils::ExpectVariableHasValue(static_cast<uint64_t>(1) << 31,
provider_->var_payload_size());
}
TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeFailNoValue) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
+ EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetStatus(_))
.WillOnce(Return(false));
UmTestUtils::ExpectVariableNotSet(provider_->var_payload_size());
}
-TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeFailNegative) {
- EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
- GetStatus(_, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<4>(static_cast<int64_t>(-1024)),
- Return(true)));
- UmTestUtils::ExpectVariableNotSet(provider_->var_payload_size());
-}
-
TEST_F(UmRealUpdaterProviderTest, GetCurrChannelOkay) {
const string kChannelName("foo-channel");
OmahaRequestParams request_params(&fake_sys_state_);
diff --git a/update_manager/updater_provider.h b/update_manager/updater_provider.h
index 8048d38..549aea9 100644
--- a/update_manager/updater_provider.h
+++ b/update_manager/updater_provider.h
@@ -79,7 +79,7 @@
// A variable returning the update payload size. The payload size is
// guaranteed to be non-negative.
- virtual Variable<int64_t>* var_payload_size() = 0;
+ virtual Variable<uint64_t>* var_payload_size() = 0;
// A variable returning the current channel.
virtual Variable<std::string>* var_curr_channel() = 0;