updater: Add TransferList class. (f8811bbd) · Commits · e / os / android_bootable_recovery

tests/component/updater_test.cpp

+12 −10

Original line number	Diff line number	Diff line
		@@ -56,8 +56,6 @@ using namespace std::string_literals;

		using PackageEntries = std::unordered_map<std::string, std::string>;

		static constexpr size_t kTransferListHeaderLines = 4;

		struct selabel_handle* sehandle = nullptr;

		static void expect(const char* expected, const std::string& expr_str, CauseCode cause_code,
		@@ -846,7 +844,8 @@ TEST_F(UpdaterTest, last_command_update) {
		};

		// "2\nstash " + block3_hash + " 2,2,3"
		std::string last_command_content = "2\n" + transfer_list_fail[kTransferListHeaderLines + 2];
		std::string last_command_content =
		"2\n" + transfer_list_fail[TransferList::kTransferListHeaderLines + 2];

		RunBlockImageUpdate(false, entries, image_file_, "");

		@@ -895,7 +894,8 @@ TEST_F(UpdaterTest, last_command_update_unresumable) {

		ASSERT_TRUE(android::base::WriteStringToFile(block1 + block1, image_file_));

		std::string last_command_content = "0\n" + transfer_list_unresumable[kTransferListHeaderLines];
		std::string last_command_content =
		"0\n" + transfer_list_unresumable[TransferList::kTransferListHeaderLines];
		ASSERT_TRUE(android::base::WriteStringToFile(last_command_content, last_command_file_));

		RunBlockImageUpdate(false, entries, image_file_, "");
		@@ -934,7 +934,8 @@ TEST_F(UpdaterTest, last_command_verify) {
		ASSERT_TRUE(android::base::WriteStringToFile(block1 + block1 + block3, image_file_));

		// Last command: "move " + block1_hash + " 2,1,2 1 2,0,1"
		std::string last_command_content = "2\n" + transfer_list_verify[kTransferListHeaderLines + 2];
		std::string last_command_content =
		"2\n" + transfer_list_verify[TransferList::kTransferListHeaderLines + 2];

		// First run: expect the verification to succeed and the last_command_file is intact.
		ASSERT_TRUE(android::base::WriteStringToFile(last_command_content, last_command_file_));
		@@ -1129,16 +1130,17 @@ static const std::vector<std::string> g_transfer_list = GenerateTransferList();

		INSTANTIATE_TEST_CASE_P(InterruptAfterEachCommand, ResumableUpdaterTest,
		::testing::Range(static_cast<size_t>(0),
		g_transfer_list.size() - kTransferListHeaderLines));
		g_transfer_list.size() -
		TransferList::kTransferListHeaderLines));

		TEST_P(ResumableUpdaterTest, InterruptVerifyResume) {
		ASSERT_TRUE(android::base::WriteStringToFile(g_source_image, image_file_));

		LOG(INFO) << "Interrupting at line " << index_ << " ("
		<< g_transfer_list[kTransferListHeaderLines + index_] << ")";
		<< g_transfer_list[TransferList::kTransferListHeaderLines + index_] << ")";

		std::vector<std::string> transfer_list_copy{ g_transfer_list };
		transfer_list_copy[kTransferListHeaderLines + index_] = "abort";
		transfer_list_copy[TransferList::kTransferListHeaderLines + index_] = "abort";

		g_entries["transfer_list"] = android::base::Join(transfer_list_copy, '\n');

		@@ -1151,8 +1153,8 @@ TEST_P(ResumableUpdaterTest, InterruptVerifyResume) {
		if (index_ == 0) {
		ASSERT_EQ(-1, access(last_command_file_.c_str(), R_OK));
		} else {
		last_command_expected =
		std::to_string(index_ - 1) + "\n" + g_transfer_list[kTransferListHeaderLines + index_ - 1];
		last_command_expected = std::to_string(index_ - 1) + "\n" +
		g_transfer_list[TransferList::kTransferListHeaderLines + index_ - 1];
		std::string last_command_actual;
		ASSERT_TRUE(android::base::ReadFileToString(last_command_file_, &last_command_actual));
		ASSERT_EQ(last_command_expected, last_command_actual);

tests/unit/commands_test.cpp

+56 −0

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		#include <algorithm>
		#include <string>

		#include <android-base/strings.h>
		#include <gtest/gtest.h>
		#include <openssl/sha.h>

		@@ -496,3 +497,58 @@ TEST(SourceInfoTest, ReadAll_FailingReader) {
		auto failing_stash_reader = [](const std::string&, std::vector<uint8_t>*) -> int { return -1; };
		ASSERT_FALSE(source.ReadAll(&buffer, kBlockSize, block_reader, failing_stash_reader));
		}

		TEST(TransferListTest, Parse) {
		std::vector<std::string> input_lines{
		"4", // version
		"2", // total blocks
		"1", // max stashed entries
		"1", // max stashed blocks
		"stash 1d74d1a60332fd38cf9405f1bae67917888da6cb 2,0,1",
		"move 1d74d1a60332fd38cf9405f1bae67917888da6cb 2,0,1 1 2,0,1",
		};

		std::string err;
		TransferList transfer_list = TransferList::Parse(android::base::Join(input_lines, '\n'), &err);
		ASSERT_TRUE(static_cast<bool>(transfer_list));
		ASSERT_EQ(4, transfer_list.version());
		ASSERT_EQ(2, transfer_list.total_blocks());
		ASSERT_EQ(1, transfer_list.stash_max_entries());
		ASSERT_EQ(1, transfer_list.stash_max_blocks());
		ASSERT_EQ(2U, transfer_list.commands().size());
		ASSERT_EQ(Command::Type::STASH, transfer_list.commands()[0].type());
		ASSERT_EQ(Command::Type::MOVE, transfer_list.commands()[1].type());
		}

		TEST(TransferListTest, Parse_InvalidCommand) {
		std::vector<std::string> input_lines{
		"4", // version
		"2", // total blocks
		"1", // max stashed entries
		"1", // max stashed blocks
		"stash 1d74d1a60332fd38cf9405f1bae67917888da6cb 2,0,1",
		"move 1d74d1a60332fd38cf9405f1bae67917888da6cb 2,0,1 1",
		};

		std::string err;
		TransferList transfer_list = TransferList::Parse(android::base::Join(input_lines, '\n'), &err);
		ASSERT_FALSE(static_cast<bool>(transfer_list));
		}

		TEST(TransferListTest, Parse_ZeroTotalBlocks) {
		std::vector<std::string> input_lines{
		"4", // version
		"0", // total blocks
		"0", // max stashed entries
		"0", // max stashed blocks
		};

		std::string err;
		TransferList transfer_list = TransferList::Parse(android::base::Join(input_lines, '\n'), &err);
		ASSERT_TRUE(static_cast<bool>(transfer_list));
		ASSERT_EQ(4, transfer_list.version());
		ASSERT_EQ(0, transfer_list.total_blocks());
		ASSERT_EQ(0, transfer_list.stash_max_entries());
		ASSERT_EQ(0, transfer_list.stash_max_blocks());
		ASSERT_TRUE(transfer_list.commands().empty());
		}

updater/commands.cpp

+51 −0

Original line number	Diff line number	Diff line
		@@ -401,3 +401,54 @@ std::ostream& operator<<(std::ostream& os, const SourceInfo& source) {
		}
		return os;
		}

		TransferList TransferList::Parse(const std::string& transfer_list_str, std::string* err) {
		TransferList result{};

		std::vector<std::string> lines = android::base::Split(transfer_list_str, "\n");
		if (lines.size() < kTransferListHeaderLines) {
		*err = android::base::StringPrintf("too few lines in the transfer list [%zu]", lines.size());
		return TransferList{};
		}

		// First line in transfer list is the version number.
		if (!android::base::ParseInt(lines[0], &result.version_, 3, 4)) {
		*err = "unexpected transfer list version ["s + lines[0] + "]";
		return TransferList{};
		}

		// Second line in transfer list is the total number of blocks we expect to write.
		if (!android::base::ParseUint(lines[1], &result.total_blocks_)) {
		*err = "unexpected block count ["s + lines[1] + "]";
		return TransferList{};
		}

		// Third line is how many stash entries are needed simultaneously.
		if (!android::base::ParseUint(lines[2], &result.stash_max_entries_)) {
		return TransferList{};
		}

		// Fourth line is the maximum number of blocks that will be stashed simultaneously.
		if (!android::base::ParseUint(lines[3], &result.stash_max_blocks_)) {
		*err = "unexpected maximum stash blocks ["s + lines[3] + "]";
		return TransferList{};
		}

		// Subsequent lines are all individual transfer commands.
		for (size_t i = kTransferListHeaderLines; i < lines.size(); i++) {
		const std::string& line = lines[i];
		if (line.empty()) continue;

		size_t cmdindex = i - kTransferListHeaderLines;
		std::string parsing_error;
		Command command = Command::Parse(line, cmdindex, &parsing_error);
		if (!command) {
		*err = android::base::StringPrintf("Failed to parse command %zu [%s]: %s", cmdindex,
		line.c_str(), parsing_error.c_str());
		return TransferList{};
		}
		result.commands_.push_back(command);
		}

		return result;
		}

updater/include/private/commands.h

+67 −0

Original line number	Diff line number	Diff line
		@@ -406,3 +406,70 @@ class Command {
		};

		std::ostream& operator<<(std::ostream& os, const Command& command);

		// TransferList represents the info for a transfer list, which is parsed from input text lines
		// containing commands to transfer data from one place to another on the target partition.
		//
		// The creator of the transfer list will guarantee that no block is read (i.e., used as the source
		// for a patch or move) after it has been written.
		//
		// The creator will guarantee that a given stash is loaded (with a stash command) before it's used
		// in a move/bsdiff/imgdiff command.
		//
		// Within one command the source and target ranges may overlap so in general we need to read the
		// entire source into memory before writing anything to the target blocks.
		//
		// All the patch data is concatenated into one patch_data file in the update package. It must be
		// stored uncompressed because we memory-map it in directly from the archive. (Since patches are
		// already compressed, we lose very little by not compressing their concatenation.)
		//
		// Commands that read data from the partition (i.e. move/bsdiff/imgdiff/stash) have one or more
		// additional hashes before the range parameters, which are used to check if the command has
		// already been completed and verify the integrity of the source data.
		class TransferList {
		public:
		// Number of header lines.
		static constexpr size_t kTransferListHeaderLines = 4;

		TransferList() = default;

		// Parses the given input string and returns a TransferList object. Sets error message if any.
		static TransferList Parse(const std::string& transfer_list_str, std::string* err);

		int version() const {
		return version_;
		}

		size_t total_blocks() const {
		return total_blocks_;
		}

		size_t stash_max_entries() const {
		return stash_max_entries_;
		}

		size_t stash_max_blocks() const {
		return stash_max_blocks_;
		}

		const std::vector<Command>& commands() const {
		return commands_;
		}

		// Returns whether the TransferList is valid.
		constexpr explicit operator bool() const {
		return version_ != 0;
		}

		private:
		// BBOTA version.
		int version_{ 0 };
		// Total number of blocks to be written in this transfer.
		size_t total_blocks_;
		// Maximum number of stashes that exist at the same time.
		size_t stash_max_entries_;
		// Maximum number of blocks to be stashed.
		size_t stash_max_blocks_;
		// Commands in this transfer.
		std::vector<Command> commands_;
		};