| // |
| // Copyright (C) 2012 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| |
| #include "update_engine/p2p_manager.h" |
| |
| #include <dirent.h> |
| #include <fcntl.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <sys/xattr.h> |
| #include <unistd.h> |
| |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include <base/bind.h> |
| #include <base/callback.h> |
| #include <base/files/file_util.h> |
| #include <base/message_loop/message_loop.h> |
| #include <base/strings/stringprintf.h> |
| #include <brillo/asynchronous_signal_handler.h> |
| #include <brillo/message_loops/base_message_loop.h> |
| #include <brillo/message_loops/message_loop.h> |
| #include <brillo/message_loops/message_loop_utils.h> |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| #include <policy/libpolicy.h> |
| #include <policy/mock_device_policy.h> |
| |
| #include "update_engine/common/fake_clock.h" |
| #include "update_engine/common/prefs.h" |
| #include "update_engine/common/subprocess.h" |
| #include "update_engine/common/test_utils.h" |
| #include "update_engine/common/utils.h" |
| #include "update_engine/fake_p2p_manager_configuration.h" |
| #include "update_engine/update_manager/fake_update_manager.h" |
| #include "update_engine/update_manager/mock_policy.h" |
| |
| using base::TimeDelta; |
| using brillo::MessageLoop; |
| using std::string; |
| using std::unique_ptr; |
| using std::vector; |
| using testing::_; |
| using testing::DoAll; |
| using testing::Return; |
| using testing::SetArgPointee; |
| |
| namespace chromeos_update_engine { |
| |
| // Test fixture that sets up a testing configuration (with e.g. a |
| // temporary p2p dir) for P2PManager and cleans up when the test is |
| // done. |
| class P2PManagerTest : public testing::Test { |
| protected: |
| P2PManagerTest() : fake_um_(&fake_clock_) {} |
| ~P2PManagerTest() override {} |
| |
| // Derived from testing::Test. |
| void SetUp() override { |
| loop_.SetAsCurrent(); |
| async_signal_handler_.Init(); |
| subprocess_.Init(&async_signal_handler_); |
| test_conf_ = new FakeP2PManagerConfiguration(); |
| |
| // Allocate and install a mock policy implementation in the fake Update |
| // Manager. Note that the FakeUpdateManager takes ownership of the policy |
| // object. |
| mock_policy_ = new chromeos_update_manager::MockPolicy(&fake_clock_); |
| fake_um_.set_policy(mock_policy_); |
| |
| // Construct the P2P manager under test. |
| manager_.reset(P2PManager::Construct(test_conf_, |
| &fake_clock_, |
| &fake_um_, |
| "cros_au", |
| 3, |
| TimeDelta::FromDays(5))); |
| } |
| |
| base::MessageLoopForIO base_loop_; |
| brillo::BaseMessageLoop loop_{&base_loop_}; |
| brillo::AsynchronousSignalHandler async_signal_handler_; |
| Subprocess subprocess_; |
| |
| // The P2PManager::Configuration instance used for testing. |
| FakeP2PManagerConfiguration* test_conf_; |
| |
| FakeClock fake_clock_; |
| chromeos_update_manager::MockPolicy* mock_policy_ = nullptr; |
| chromeos_update_manager::FakeUpdateManager fake_um_; |
| |
| unique_ptr<P2PManager> manager_; |
| }; |
| |
| // Check that IsP2PEnabled() polls the policy correctly, with the value not |
| // changing between calls. |
| TEST_F(P2PManagerTest, P2PEnabledInitAndNotChanged) { |
| EXPECT_CALL(*mock_policy_, P2PEnabled(_, _, _, _)); |
| EXPECT_CALL(*mock_policy_, P2PEnabledChanged(_, _, _, _, false)); |
| |
| EXPECT_FALSE(manager_->IsP2PEnabled()); |
| brillo::MessageLoopRunMaxIterations(MessageLoop::current(), 100); |
| EXPECT_FALSE(manager_->IsP2PEnabled()); |
| } |
| |
| // Check that IsP2PEnabled() polls the policy correctly, with the value changing |
| // between calls. |
| TEST_F(P2PManagerTest, P2PEnabledInitAndChanged) { |
| EXPECT_CALL(*mock_policy_, P2PEnabled(_, _, _, _)) |
| .WillOnce(DoAll(SetArgPointee<3>(true), |
| Return(chromeos_update_manager::EvalStatus::kSucceeded))); |
| EXPECT_CALL(*mock_policy_, P2PEnabledChanged(_, _, _, _, true)); |
| EXPECT_CALL(*mock_policy_, P2PEnabledChanged(_, _, _, _, false)); |
| |
| EXPECT_TRUE(manager_->IsP2PEnabled()); |
| brillo::MessageLoopRunMaxIterations(MessageLoop::current(), 100); |
| EXPECT_FALSE(manager_->IsP2PEnabled()); |
| } |
| |
| // Check that we keep the $N newest files with the .$EXT.p2p extension. |
| TEST_F(P2PManagerTest, HousekeepingCountLimit) { |
| // Specifically pass 0 for |max_file_age| to allow files of any age. Note that |
| // we need to reallocate the test_conf_ member, whose currently aliased object |
| // will be freed. |
| test_conf_ = new FakeP2PManagerConfiguration(); |
| manager_.reset(P2PManager::Construct(test_conf_, |
| &fake_clock_, |
| &fake_um_, |
| "cros_au", |
| 3, |
| TimeDelta() /* max_file_age */)); |
| EXPECT_EQ(manager_->CountSharedFiles(), 0); |
| |
| base::Time start_time = base::Time::FromDoubleT(1246996800.); |
| // Generate files with different timestamps matching our pattern and generate |
| // other files not matching the pattern. |
| for (int n = 0; n < 5; n++) { |
| base::FilePath path = test_conf_->GetP2PDir().Append( |
| base::StringPrintf("file_%d.cros_au.p2p", n)); |
| base::Time file_time = start_time + TimeDelta::FromMinutes(n); |
| EXPECT_EQ(0, base::WriteFile(path, nullptr, 0)); |
| EXPECT_TRUE(base::TouchFile(path, file_time, file_time)); |
| |
| path = test_conf_->GetP2PDir().Append( |
| base::StringPrintf("file_%d.OTHER.p2p", n)); |
| EXPECT_EQ(0, base::WriteFile(path, nullptr, 0)); |
| EXPECT_TRUE(base::TouchFile(path, file_time, file_time)); |
| } |
| // CountSharedFiles() only counts 'cros_au' files. |
| EXPECT_EQ(manager_->CountSharedFiles(), 5); |
| |
| EXPECT_TRUE(manager_->PerformHousekeeping()); |
| |
| // At this point - after HouseKeeping - we should only have |
| // eight files left. |
| for (int n = 0; n < 5; n++) { |
| string file_name; |
| bool expect; |
| |
| expect = (n >= 2); |
| file_name = base::StringPrintf( |
| "%s/file_%d.cros_au.p2p", test_conf_->GetP2PDir().value().c_str(), n); |
| EXPECT_EQ(expect, utils::FileExists(file_name.c_str())); |
| |
| file_name = base::StringPrintf( |
| "%s/file_%d.OTHER.p2p", test_conf_->GetP2PDir().value().c_str(), n); |
| EXPECT_TRUE(utils::FileExists(file_name.c_str())); |
| } |
| // CountSharedFiles() only counts 'cros_au' files. |
| EXPECT_EQ(manager_->CountSharedFiles(), 3); |
| } |
| |
| // Check that we keep files with the .$EXT.p2p extension not older |
| // than some specific age (5 days, in this test). |
| TEST_F(P2PManagerTest, HousekeepingAgeLimit) { |
| // We set the cutoff time to be 1 billion seconds (01:46:40 UTC on 9 |
| // September 2001 - arbitrary number, but constant to avoid test |
| // flakiness) since the epoch and then we put two files before that |
| // date and three files after. |
| base::Time cutoff_time = base::Time::FromTimeT(1000000000); |
| TimeDelta age_limit = TimeDelta::FromDays(5); |
| |
| // Set the clock just so files with a timestamp before |cutoff_time| |
| // will be deleted at housekeeping. |
| fake_clock_.SetWallclockTime(cutoff_time + age_limit); |
| |
| // Specifically pass 0 for |num_files_to_keep| to allow any number of files. |
| // Note that we need to reallocate the test_conf_ member, whose currently |
| // aliased object will be freed. |
| test_conf_ = new FakeP2PManagerConfiguration(); |
| manager_.reset(P2PManager::Construct(test_conf_, |
| &fake_clock_, |
| &fake_um_, |
| "cros_au", |
| 0 /* num_files_to_keep */, |
| age_limit)); |
| EXPECT_EQ(manager_->CountSharedFiles(), 0); |
| |
| // Generate files with different timestamps matching our pattern and generate |
| // other files not matching the pattern. |
| for (int n = 0; n < 5; n++) { |
| base::FilePath path = test_conf_->GetP2PDir().Append( |
| base::StringPrintf("file_%d.cros_au.p2p", n)); |
| |
| // With five files and aiming for two of them to be before |
| // |cutoff_time|, we distribute it like this: |
| // |
| // -------- 0 -------- 1 -------- 2 -------- 3 -------- 4 -------- |
| // | |
| // cutoff_time |
| // |
| base::Time file_date = cutoff_time + (n - 2) * TimeDelta::FromDays(1) + |
| TimeDelta::FromHours(12); |
| |
| EXPECT_EQ(0, base::WriteFile(path, nullptr, 0)); |
| EXPECT_TRUE(base::TouchFile(path, file_date, file_date)); |
| |
| path = test_conf_->GetP2PDir().Append( |
| base::StringPrintf("file_%d.OTHER.p2p", n)); |
| EXPECT_EQ(0, base::WriteFile(path, nullptr, 0)); |
| EXPECT_TRUE(base::TouchFile(path, file_date, file_date)); |
| } |
| // CountSharedFiles() only counts 'cros_au' files. |
| EXPECT_EQ(manager_->CountSharedFiles(), 5); |
| |
| EXPECT_TRUE(manager_->PerformHousekeeping()); |
| |
| // At this point - after HouseKeeping - we should only have |
| // eight files left. |
| for (int n = 0; n < 5; n++) { |
| string file_name; |
| bool expect; |
| |
| expect = (n >= 2); |
| file_name = base::StringPrintf( |
| "%s/file_%d.cros_au.p2p", test_conf_->GetP2PDir().value().c_str(), n); |
| EXPECT_EQ(expect, utils::FileExists(file_name.c_str())); |
| |
| file_name = base::StringPrintf( |
| "%s/file_%d.OTHER.p2p", test_conf_->GetP2PDir().value().c_str(), n); |
| EXPECT_TRUE(utils::FileExists(file_name.c_str())); |
| } |
| // CountSharedFiles() only counts 'cros_au' files. |
| EXPECT_EQ(manager_->CountSharedFiles(), 3); |
| } |
| |
| static bool CheckP2PFile(const string& p2p_dir, |
| const string& file_name, |
| ssize_t expected_size, |
| ssize_t expected_size_xattr) { |
| string path = p2p_dir + "/" + file_name; |
| char ea_value[64] = {0}; |
| ssize_t ea_size; |
| |
| off_t p2p_size = utils::FileSize(path); |
| if (p2p_size < 0) { |
| LOG(ERROR) << "File " << path << " does not exist"; |
| return false; |
| } |
| |
| if (expected_size != 0) { |
| if (p2p_size != expected_size) { |
| LOG(ERROR) << "Expected size " << expected_size << " but size was " |
| << p2p_size; |
| return false; |
| } |
| } |
| |
| if (expected_size_xattr == 0) { |
| ea_size = getxattr( |
| path.c_str(), "user.cros-p2p-filesize", &ea_value, sizeof ea_value - 1); |
| if (ea_size == -1 && errno == ENODATA) { |
| // This is valid behavior as we support files without the xattr set. |
| } else { |
| PLOG(ERROR) << "getxattr() didn't fail with ENODATA as expected, " |
| << "ea_size=" << ea_size << ", errno=" << errno; |
| return false; |
| } |
| } else { |
| ea_size = getxattr( |
| path.c_str(), "user.cros-p2p-filesize", &ea_value, sizeof ea_value - 1); |
| if (ea_size < 0) { |
| LOG(ERROR) << "Error getting xattr attribute"; |
| return false; |
| } |
| char* endp = nullptr; |
| long long int val = strtoll(ea_value, &endp, 0); // NOLINT(runtime/int) |
| if (endp == nullptr || *endp != '\0') { |
| LOG(ERROR) << "Error parsing xattr '" << ea_value << "' as an integer"; |
| return false; |
| } |
| if (val != expected_size_xattr) { |
| LOG(ERROR) << "Expected xattr size " << expected_size_xattr |
| << " but size was " << val; |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| static bool CreateP2PFile(string p2p_dir, |
| string file_name, |
| size_t size, |
| size_t size_xattr) { |
| string path = p2p_dir + "/" + file_name; |
| |
| int fd = open(path.c_str(), O_CREAT | O_RDWR, 0644); |
| if (fd == -1) { |
| PLOG(ERROR) << "Error creating file with path " << path; |
| return false; |
| } |
| if (ftruncate(fd, size) != 0) { |
| PLOG(ERROR) << "Error truncating " << path << " to size " << size; |
| close(fd); |
| return false; |
| } |
| |
| if (size_xattr != 0) { |
| string decimal_size = std::to_string(size_xattr); |
| if (fsetxattr(fd, |
| "user.cros-p2p-filesize", |
| decimal_size.c_str(), |
| decimal_size.size(), |
| 0) != 0) { |
| PLOG(ERROR) << "Error setting xattr on " << path; |
| close(fd); |
| return false; |
| } |
| } |
| |
| close(fd); |
| return true; |
| } |
| |
| // Check that sharing a *new* file works. |
| TEST_F(P2PManagerTest, ShareFile) { |
| const int kP2PTestFileSize = 1000 * 1000; // 1 MB |
| |
| EXPECT_TRUE(manager_->FileShare("foo", kP2PTestFileSize)); |
| EXPECT_EQ(manager_->FileGetPath("foo"), |
| test_conf_->GetP2PDir().Append("foo.cros_au.p2p.tmp")); |
| EXPECT_TRUE(CheckP2PFile(test_conf_->GetP2PDir().value(), |
| "foo.cros_au.p2p.tmp", |
| 0, |
| kP2PTestFileSize)); |
| |
| // Sharing it again - with the same expected size - should return true |
| EXPECT_TRUE(manager_->FileShare("foo", kP2PTestFileSize)); |
| |
| // ... but if we use the wrong size, it should fail |
| EXPECT_FALSE(manager_->FileShare("foo", kP2PTestFileSize + 1)); |
| } |
| |
| // Check that making a shared file visible, does what is expected. |
| TEST_F(P2PManagerTest, MakeFileVisible) { |
| const int kP2PTestFileSize = 1000 * 1000; // 1 MB |
| |
| // First, check that it's not visible. |
| manager_->FileShare("foo", kP2PTestFileSize); |
| EXPECT_EQ(manager_->FileGetPath("foo"), |
| test_conf_->GetP2PDir().Append("foo.cros_au.p2p.tmp")); |
| EXPECT_TRUE(CheckP2PFile(test_conf_->GetP2PDir().value(), |
| "foo.cros_au.p2p.tmp", |
| 0, |
| kP2PTestFileSize)); |
| // Make the file visible and check that it changed its name. Do it |
| // twice to check that FileMakeVisible() is idempotent. |
| for (int n = 0; n < 2; n++) { |
| manager_->FileMakeVisible("foo"); |
| EXPECT_EQ(manager_->FileGetPath("foo"), |
| test_conf_->GetP2PDir().Append("foo.cros_au.p2p")); |
| EXPECT_TRUE(CheckP2PFile(test_conf_->GetP2PDir().value(), |
| "foo.cros_au.p2p", |
| 0, |
| kP2PTestFileSize)); |
| } |
| } |
| |
| // Check that we return the right values for existing files in P2P_DIR. |
| TEST_F(P2PManagerTest, ExistingFiles) { |
| bool visible; |
| |
| // Check that errors are returned if the file does not exist |
| EXPECT_EQ(manager_->FileGetPath("foo"), base::FilePath()); |
| EXPECT_EQ(manager_->FileGetSize("foo"), -1); |
| EXPECT_EQ(manager_->FileGetExpectedSize("foo"), -1); |
| EXPECT_FALSE(manager_->FileGetVisible("foo", nullptr)); |
| // ... then create the file ... |
| EXPECT_TRUE(CreateP2PFile( |
| test_conf_->GetP2PDir().value(), "foo.cros_au.p2p", 42, 43)); |
| // ... and then check that the expected values are returned |
| EXPECT_EQ(manager_->FileGetPath("foo"), |
| test_conf_->GetP2PDir().Append("foo.cros_au.p2p")); |
| EXPECT_EQ(manager_->FileGetSize("foo"), 42); |
| EXPECT_EQ(manager_->FileGetExpectedSize("foo"), 43); |
| EXPECT_TRUE(manager_->FileGetVisible("foo", &visible)); |
| EXPECT_TRUE(visible); |
| |
| // One more time, this time with a .tmp variant. First ensure it errors out.. |
| EXPECT_EQ(manager_->FileGetPath("bar"), base::FilePath()); |
| EXPECT_EQ(manager_->FileGetSize("bar"), -1); |
| EXPECT_EQ(manager_->FileGetExpectedSize("bar"), -1); |
| EXPECT_FALSE(manager_->FileGetVisible("bar", nullptr)); |
| // ... then create the file ... |
| EXPECT_TRUE(CreateP2PFile( |
| test_conf_->GetP2PDir().value(), "bar.cros_au.p2p.tmp", 44, 45)); |
| // ... and then check that the expected values are returned |
| EXPECT_EQ(manager_->FileGetPath("bar"), |
| test_conf_->GetP2PDir().Append("bar.cros_au.p2p.tmp")); |
| EXPECT_EQ(manager_->FileGetSize("bar"), 44); |
| EXPECT_EQ(manager_->FileGetExpectedSize("bar"), 45); |
| EXPECT_TRUE(manager_->FileGetVisible("bar", &visible)); |
| EXPECT_FALSE(visible); |
| } |
| |
| // This is a little bit ugly but short of mocking a 'p2p' service this |
| // will have to do. E.g. we essentially simulate the various |
| // behaviours of initctl(8) that we rely on. |
| TEST_F(P2PManagerTest, StartP2P) { |
| // Check that we can start the service |
| test_conf_->SetInitctlStartCommand({"true"}); |
| EXPECT_TRUE(manager_->EnsureP2PRunning()); |
| test_conf_->SetInitctlStartCommand({"false"}); |
| EXPECT_FALSE(manager_->EnsureP2PRunning()); |
| test_conf_->SetInitctlStartCommand( |
| {"sh", "-c", "echo \"initctl: Job is already running: p2p\" >&2; false"}); |
| EXPECT_TRUE(manager_->EnsureP2PRunning()); |
| test_conf_->SetInitctlStartCommand( |
| {"sh", "-c", "echo something else >&2; false"}); |
| EXPECT_FALSE(manager_->EnsureP2PRunning()); |
| } |
| |
| // Same comment as for StartP2P |
| TEST_F(P2PManagerTest, StopP2P) { |
| // Check that we can start the service |
| test_conf_->SetInitctlStopCommand({"true"}); |
| EXPECT_TRUE(manager_->EnsureP2PNotRunning()); |
| test_conf_->SetInitctlStopCommand({"false"}); |
| EXPECT_FALSE(manager_->EnsureP2PNotRunning()); |
| test_conf_->SetInitctlStopCommand( |
| {"sh", "-c", "echo \"initctl: Unknown instance \" >&2; false"}); |
| EXPECT_TRUE(manager_->EnsureP2PNotRunning()); |
| test_conf_->SetInitctlStopCommand( |
| {"sh", "-c", "echo something else >&2; false"}); |
| EXPECT_FALSE(manager_->EnsureP2PNotRunning()); |
| } |
| |
| static void ExpectUrl(const string& expected_url, const string& url) { |
| EXPECT_EQ(url, expected_url); |
| MessageLoop::current()->BreakLoop(); |
| } |
| |
| // Like StartP2P, we're mocking the different results that p2p-client |
| // can return. It's not pretty but it works. |
| TEST_F(P2PManagerTest, LookupURL) { |
| // Emulate p2p-client returning valid URL with "fooX", 42 and "cros_au" |
| // being propagated in the right places. |
| test_conf_->SetP2PClientCommand( |
| {"echo", "http://1.2.3.4/{file_id}_{minsize}"}); |
| manager_->LookupUrlForFile( |
| "fooX", |
| 42, |
| TimeDelta(), |
| base::Bind(ExpectUrl, "http://1.2.3.4/fooX.cros_au_42")); |
| loop_.Run(); |
| |
| // Emulate p2p-client returning invalid URL. |
| test_conf_->SetP2PClientCommand({"echo", "not_a_valid_url"}); |
| manager_->LookupUrlForFile( |
| "foobar", 42, TimeDelta(), base::Bind(ExpectUrl, "")); |
| loop_.Run(); |
| |
| // Emulate p2p-client conveying failure. |
| test_conf_->SetP2PClientCommand({"false"}); |
| manager_->LookupUrlForFile( |
| "foobar", 42, TimeDelta(), base::Bind(ExpectUrl, "")); |
| loop_.Run(); |
| |
| // Emulate p2p-client not existing. |
| test_conf_->SetP2PClientCommand({"/path/to/non/existent/helper/program"}); |
| manager_->LookupUrlForFile( |
| "foobar", 42, TimeDelta(), base::Bind(ExpectUrl, "")); |
| loop_.Run(); |
| |
| // Emulate p2p-client crashing. |
| test_conf_->SetP2PClientCommand({"sh", "-c", "kill -SEGV $$"}); |
| manager_->LookupUrlForFile( |
| "foobar", 42, TimeDelta(), base::Bind(ExpectUrl, "")); |
| loop_.Run(); |
| |
| // Emulate p2p-client exceeding its timeout. |
| test_conf_->SetP2PClientCommand( |
| {"sh", |
| "-c", |
| // The 'sleep' launched below could be left behind as an orphaned |
| // process when the 'sh' process is terminated by SIGTERM. As a |
| // remedy, trap SIGTERM and kill the 'sleep' process, which requires |
| // launching 'sleep' in background and then waiting for it. |
| "cleanup() { kill \"${sleep_pid}\"; exit 0; }; " |
| "trap cleanup TERM; " |
| "sleep 5 & " |
| "sleep_pid=$!; " |
| "echo http://1.2.3.4/; " |
| "wait"}); |
| manager_->LookupUrlForFile("foobar", |
| 42, |
| TimeDelta::FromMilliseconds(500), |
| base::Bind(ExpectUrl, "")); |
| loop_.Run(); |
| } |
| |
| } // namespace chromeos_update_engine |