diff options
Diffstat (limited to 'src/test/librbd/migration')
| -rw-r--r-- | src/test/librbd/migration/test_mock_FileStream.cc | 217 | ||||
| -rw-r--r-- | src/test/librbd/migration/test_mock_HttpClient.cc | 890 | ||||
| -rw-r--r-- | src/test/librbd/migration/test_mock_HttpStream.cc | 194 | ||||
| -rw-r--r-- | src/test/librbd/migration/test_mock_QCOWFormat.cc | 1259 | ||||
| -rw-r--r-- | src/test/librbd/migration/test_mock_RawFormat.cc | 523 | ||||
| -rw-r--r-- | src/test/librbd/migration/test_mock_RawSnapshot.cc | 255 | ||||
| -rw-r--r-- | src/test/librbd/migration/test_mock_S3Stream.cc | 238 | ||||
| -rw-r--r-- | src/test/librbd/migration/test_mock_Utils.cc | 47 |
8 files changed, 3623 insertions, 0 deletions
diff --git a/src/test/librbd/migration/test_mock_FileStream.cc b/src/test/librbd/migration/test_mock_FileStream.cc new file mode 100644 index 000000000..3688b56dd --- /dev/null +++ b/src/test/librbd/migration/test_mock_FileStream.cc @@ -0,0 +1,217 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include "test/librbd/test_mock_fixture.h" +#include "test/librbd/test_support.h" +#include "include/rbd_types.h" +#include "common/ceph_mutex.h" +#include "librbd/migration/FileStream.h" +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include "json_spirit/json_spirit.h" +#if __has_include(<filesystem>) +#include <filesystem> +namespace fs = std::filesystem; +#else +#include <experimental/filesystem> +namespace fs = std::experimental::filesystem; +#endif + +namespace librbd { +namespace { + +struct MockTestImageCtx : public MockImageCtx { + MockTestImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace +} // namespace librbd + +#include "librbd/migration/FileStream.cc" + +namespace librbd { +namespace migration { + +using ::testing::Invoke; + +class TestMockMigrationFileStream : public TestMockFixture { +public: + typedef FileStream<MockTestImageCtx> MockFileStream; + + librbd::ImageCtx *m_image_ctx; + + void SetUp() override { + TestMockFixture::SetUp(); + + ASSERT_EQ(0, open_image(m_image_name, &m_image_ctx)); + file_name = fs::temp_directory_path() / "TestMockMigrationFileStream"; + file_name += stringify(getpid()); + json_object["file_path"] = file_name; + } + + void TearDown() override { + fs::remove(file_name); + TestMockFixture::TearDown(); + } + + std::string file_name; + json_spirit::mObject json_object; +}; + +TEST_F(TestMockMigrationFileStream, OpenClose) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + bufferlist bl; + ASSERT_EQ(0, bl.write_file(file_name.c_str())); + + MockFileStream mock_file_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_file_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + mock_file_stream.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationFileStream, GetSize) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + bufferlist expect_bl; + expect_bl.append(std::string(128, '1')); + ASSERT_EQ(0, expect_bl.write_file(file_name.c_str())); + + MockFileStream mock_file_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_file_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + uint64_t size; + mock_file_stream.get_size(&size, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + ASSERT_EQ(128, size); + + C_SaferCond ctx3; + mock_file_stream.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationFileStream, Read) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + bufferlist expect_bl; + expect_bl.append(std::string(128, '1')); + ASSERT_EQ(0, expect_bl.write_file(file_name.c_str())); + + MockFileStream mock_file_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_file_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + bufferlist bl; + mock_file_stream.read({{0, 128}}, &bl, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + ASSERT_EQ(expect_bl, bl); + + C_SaferCond ctx3; + mock_file_stream.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationFileStream, SeekRead) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + bufferlist write_bl; + write_bl.append(std::string(32, '1')); + write_bl.append(std::string(64, '2')); + write_bl.append(std::string(16, '3')); + ASSERT_EQ(0, write_bl.write_file(file_name.c_str())); + + MockFileStream mock_file_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_file_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + bufferlist bl; + mock_file_stream.read({{96, 16}, {32, 64}, {0, 32}}, &bl, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + + bufferlist expect_bl; + expect_bl.append(std::string(16, '3')); + expect_bl.append(std::string(64, '2')); + expect_bl.append(std::string(32, '1')); + ASSERT_EQ(expect_bl, bl); + + C_SaferCond ctx3; + mock_file_stream.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationFileStream, DNE) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + MockFileStream mock_file_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_file_stream.open(&ctx1); + ASSERT_EQ(-ENOENT, ctx1.wait()); + + C_SaferCond ctx2; + mock_file_stream.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationFileStream, SeekError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + bufferlist bl; + ASSERT_EQ(0, bl.write_file(file_name.c_str())); + + MockFileStream mock_file_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_file_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + mock_file_stream.read({{128, 128}}, &bl, &ctx2); + ASSERT_EQ(-ERANGE, ctx2.wait()); + + C_SaferCond ctx3; + mock_file_stream.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationFileStream, ShortReadError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + bufferlist expect_bl; + expect_bl.append(std::string(128, '1')); + ASSERT_EQ(0, expect_bl.write_file(file_name.c_str())); + + MockFileStream mock_file_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_file_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + bufferlist bl; + mock_file_stream.read({{0, 256}}, &bl, &ctx2); + ASSERT_EQ(-ERANGE, ctx2.wait()); + + C_SaferCond ctx3; + mock_file_stream.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +} // namespace migration +} // namespace librbd diff --git a/src/test/librbd/migration/test_mock_HttpClient.cc b/src/test/librbd/migration/test_mock_HttpClient.cc new file mode 100644 index 000000000..f3888755c --- /dev/null +++ b/src/test/librbd/migration/test_mock_HttpClient.cc @@ -0,0 +1,890 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include "test/librbd/test_mock_fixture.h" +#include "test/librbd/test_support.h" +#include "include/rbd_types.h" +#include "common/ceph_mutex.h" +#include "librbd/migration/HttpClient.h" +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include <unistd.h> +#include <boost/asio/ip/tcp.hpp> +#include <boost/beast/core.hpp> +#include <boost/beast/http.hpp> + +namespace librbd { +namespace { + +struct MockTestImageCtx : public MockImageCtx { + MockTestImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace + +namespace util { + +inline ImageCtx *get_image_ctx(MockTestImageCtx *image_ctx) { + return image_ctx->image_ctx; +} + +} // namespace util +} // namespace librbd + +#include "librbd/migration/HttpClient.cc" + +using EmptyHttpRequest = boost::beast::http::request< + boost::beast::http::empty_body>; +using HttpResponse = boost::beast::http::response< + boost::beast::http::string_body>; + +namespace boost { +namespace beast { +namespace http { + +template <typename Body> +bool operator==(const boost::beast::http::request<Body>& lhs, + const boost::beast::http::request<Body>& rhs) { + return (lhs.method() == rhs.method() && + lhs.target() == rhs.target()); +} + +template <typename Body> +bool operator==(const boost::beast::http::response<Body>& lhs, + const boost::beast::http::response<Body>& rhs) { + return (lhs.result() == rhs.result() && + lhs.body() == rhs.body()); +} + +} // namespace http +} // namespace beast +} // namespace boost + +namespace librbd { +namespace migration { + +using ::testing::Invoke; + +class TestMockMigrationHttpClient : public TestMockFixture { +public: + typedef HttpClient<MockTestImageCtx> MockHttpClient; + + void SetUp() override { + TestMockFixture::SetUp(); + + ASSERT_EQ(0, open_image(m_image_name, &m_image_ctx)); + + create_acceptor(false); + } + + void TearDown() override { + m_acceptor.reset(); + + TestMockFixture::TearDown(); + } + + // if we have a racing where another thread manages to bind and listen the + // port picked by this acceptor, try again. + static constexpr int MAX_BIND_RETRIES = 60; + + void create_acceptor(bool reuse) { + for (int retries = 0;; retries++) { + try { + m_acceptor.emplace(*m_image_ctx->asio_engine, + boost::asio::ip::tcp::endpoint( + boost::asio::ip::tcp::v4(), m_server_port), reuse); + // yay! + break; + } catch (const boost::system::system_error& e) { + if (retries == MAX_BIND_RETRIES) { + throw; + } + if (e.code() != boost::system::errc::address_in_use) { + throw; + } + } + // backoff a little bit + sleep(1); + } + m_server_port = m_acceptor->local_endpoint().port(); + } + + std::string get_local_url(UrlScheme url_scheme) { + std::stringstream sstream; + switch (url_scheme) { + case URL_SCHEME_HTTP: + sstream << "http://127.0.0.1"; + break; + case URL_SCHEME_HTTPS: + sstream << "https://localhost"; + break; + default: + ceph_assert(false); + break; + } + + sstream << ":" << m_server_port << "/target"; + return sstream.str(); + } + + void client_accept(boost::asio::ip::tcp::socket* socket, bool close, + Context* on_connect) { + m_acceptor->async_accept( + boost::asio::make_strand(m_image_ctx->asio_engine->get_executor()), + [socket, close, on_connect] + (auto ec, boost::asio::ip::tcp::socket in_socket) { + if (close) { + in_socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both); + } else { + ASSERT_FALSE(ec) << "Unexpected error: " << ec; + *socket = std::move(in_socket); + } + on_connect->complete(0); + }); + } + + template <typename Body> + void client_read_request(boost::asio::ip::tcp::socket& socket, + boost::beast::http::request<Body>& expected_req) { + boost::beast::http::request<Body> req; + boost::beast::error_code ec; + boost::beast::http::read(socket, m_buffer, req, ec); + ASSERT_FALSE(ec) << "Unexpected errror: " << ec; + + expected_req.target("/target"); + ASSERT_EQ(expected_req, req); + } + + void client_write_response(boost::asio::ip::tcp::socket& socket, + HttpResponse& expected_res) { + expected_res.set(boost::beast::http::field::server, + BOOST_BEAST_VERSION_STRING); + expected_res.set(boost::beast::http::field::content_type, "text/plain"); + expected_res.content_length(expected_res.body().size()); + expected_res.prepare_payload(); + + boost::beast::error_code ec; + boost::beast::http::write(socket, expected_res, ec); + ASSERT_FALSE(ec) << "Unexpected errror: " << ec; + } + + template <typename Stream> + void client_ssl_handshake(Stream& stream, bool ignore_failure, + Context* on_handshake) { + stream.async_handshake( + boost::asio::ssl::stream_base::server, + [ignore_failure, on_handshake](auto ec) { + ASSERT_FALSE(!ignore_failure && ec) << "Unexpected error: " << ec; + on_handshake->complete(-ec.value()); + }); + } + + template <typename Stream> + void client_ssl_shutdown(Stream& stream, Context* on_shutdown) { + stream.async_shutdown( + [on_shutdown](auto ec) { + ASSERT_FALSE(ec) << "Unexpected error: " << ec; + on_shutdown->complete(-ec.value()); + }); + } + + void load_server_certificate(boost::asio::ssl::context& ctx) { + ctx.set_options( + boost::asio::ssl::context::default_workarounds | + boost::asio::ssl::context::no_sslv2 | + boost::asio::ssl::context::single_dh_use); + ctx.use_certificate_chain( + boost::asio::buffer(CERTIFICATE.data(), CERTIFICATE.size())); + ctx.use_private_key( + boost::asio::buffer(KEY.data(), KEY.size()), + boost::asio::ssl::context::file_format::pem); + ctx.use_tmp_dh( + boost::asio::buffer(DH.data(), DH.size())); + } + + // dummy self-signed cert for localhost + const std::string CERTIFICATE = + "-----BEGIN CERTIFICATE-----\n" + "MIIDXzCCAkegAwIBAgIUYH6rAaq66LC6yJ3XK1WEMIfmY4cwDQYJKoZIhvcNAQEL\n" + "BQAwPzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAlZBMQ8wDQYDVQQHDAZNY0xlYW4x\n" + "EjAQBgNVBAMMCWxvY2FsaG9zdDAeFw0yMDExMDIyMTM5NTVaFw00ODAzMjAyMTM5\n" + "NTVaMD8xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJWQTEPMA0GA1UEBwwGTWNMZWFu\n" + "MRIwEAYDVQQDDAlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n" + "AoIBAQCeRkyxjP0eNHxzj4/R+Bg/31p7kEjB5d/LYtrzBIYNe+3DN8gdReixEpR5\n" + "lgTLDsl8gfk2HRz4cnAiseqYL6GKtw/cFadzLyXTbW4iavmTWiGYw/8RJlKunbhA\n" + "hDjM6H99ysLf0NS6t14eK+bEJIW1PiTYRR1U5I4kSIjpCX7+nJVuwMEZ2XBpN3og\n" + "nHhv2hZYTdzEkQEyZHz4V/ApfD7rlja5ecd/vJfPJeA8nudnGCh3Uo6f8I9TObAj\n" + "8hJdfRiRBvnA4NnkrMrxW9UtVjScnw9Xia11FM/IGJIgMpLQ5dqBw930p6FxMYtn\n" + "tRD1AF9sT+YjoCaHv0hXZvBEUEF3AgMBAAGjUzBRMB0GA1UdDgQWBBTQoIiX3+p/\n" + "P4Xz2vwERz6pbjPGhzAfBgNVHSMEGDAWgBTQoIiX3+p/P4Xz2vwERz6pbjPGhzAP\n" + "BgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQCVKoYAw+D1qqWRDSh3\n" + "2KlKMnT6sySo7XmReGArj8FTKiZUprByj5CfAtaiDSdPOpcg3EazWbdasZbMmSQm\n" + "+jpe5WoKnxL9b12lwwUYHrLl6RlrDHVkIVlXLNbJFY5TpfjvZfHpwVAygF3fnbgW\n" + "PPuODUNAS5NDwST+t29jBZ/wwU0pyW0CS4K5d3XMGHBc13j2V/FyvmsZ5xfA4U9H\n" + "oEnmZ/Qm+FFK/nR40rTAZ37cuv4ysKFtwvatNgTfHGJwaBUkKFdDbcyxt9abCi6x\n" + "/K+ScoJtdIeVcfx8Fnc5PNtSpy8bHI3Zy4IEyw4kOqwwI1h37iBafZ2WdQkTxlAx\n" + "JIDj\n" + "-----END CERTIFICATE-----\n"; + const std::string KEY = + "-----BEGIN PRIVATE KEY-----\n" + "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCeRkyxjP0eNHxz\n" + "j4/R+Bg/31p7kEjB5d/LYtrzBIYNe+3DN8gdReixEpR5lgTLDsl8gfk2HRz4cnAi\n" + "seqYL6GKtw/cFadzLyXTbW4iavmTWiGYw/8RJlKunbhAhDjM6H99ysLf0NS6t14e\n" + "K+bEJIW1PiTYRR1U5I4kSIjpCX7+nJVuwMEZ2XBpN3ognHhv2hZYTdzEkQEyZHz4\n" + "V/ApfD7rlja5ecd/vJfPJeA8nudnGCh3Uo6f8I9TObAj8hJdfRiRBvnA4NnkrMrx\n" + "W9UtVjScnw9Xia11FM/IGJIgMpLQ5dqBw930p6FxMYtntRD1AF9sT+YjoCaHv0hX\n" + "ZvBEUEF3AgMBAAECggEACCaYpoAbPOX5Dr5y6p47KXboIvrgNFQRPVke62rtOF6M\n" + "dQQ3YwKJpCzPxp8qKgbd63KKEfZX2peSHMdKzIGPcSRSRcQ7tlvUN9on1M/rgGIg\n" + "3swhI5H0qhdnOLNWdX73qdO6S2pmuiLdTvJ11N4IoLfNj/GnPAr1Ivs1ScL6bkQv\n" + "UybaNQ/g2lB0tO7vUeVe2W/AqsIb1eQlf2g+SH7xRj2bGQkr4cWTylqfiVoL/Xic\n" + "QVTCks3BWaZhYIhTFgvqVhXZpp52O9J+bxsWJItKQrrCBemxwp82xKbiW/KoI9L1\n" + "wSnKvxx7Q3RUN5EvXeOpTRR8QIpBoxP3TTeoj+EOMQKBgQDQb/VfLDlLgfYJpgRC\n" + "hKCLW90un9op3nA2n9Dmm9TTLYOmUyiv5ub8QDINEw/YK/NE2JsTSUk2msizqTLL\n" + "Z82BFbz9kPlDbJ5MgxG5zXeLvOLurAFmZk/z5JJO+65PKjf0QVLncSAJvMCeNFuC\n" + "2yZrEzbrItrjQsN6AedWdx6TTwKBgQDCZAsSI3lQgOh2q1GSxjuIzRAc7JnSGBvD\n" + "nG8+SkfKAy7BWe638772Dgx8KYO7TLI4zlm8c9Tr/nkZsGWmM5S2DMI69PWOQWNa\n" + "R6QzOFFwNg2JETH7ow+x8+9Q9d3WsPzROz3r5uDXgEk0glthaymVoPILFOiYpz3r\n" + "heUbd6mFWQKBgQCCJBVJGhyf54IOHij0u0heGrpr/QTDNY5MnNZa1hs4y2cydyOl\n" + "SH8aKp7ViPxQlYhriO6ySQS8YkJD4rXDSImIOmFo1Ja9oVjpHsD3iLFGf2YVbTHm\n" + "lKUA+8raI8x+wzZyfELeHMTLL534aWpltp0zJ6kXgQi38pyIVh3x36gogwKBgQCt\n" + "nba5k49VVFzLKEXqBjzD+QqMGtFjcH7TnZNJmgQ2K9OFgzIPf5atomyKNHXgQibn\n" + "T32cMAQaZqR4SjDvWSBX3FtZVtE+Ja57woKn8IPj6ZL7Oa1fpwpskIbM01s31cln\n" + "gjbSy9lC/+PiDw9YmeKBLkcfmKQJO021Xlf6yUxRuQKBgBWPODUO8oKjkuJXNI/w\n" + "El9hNWkd+/SZDfnt93dlVyXTtTF0M5M95tlOgqvLtWKSyB/BOnoZYWqR8luMl15d\n" + "bf75j5mB0lHMWtyQgvZSkFqe9Or7Zy7hfTShDlZ/w+OXK7PGesaE1F14irShXSji\n" + "yn5DZYAZ5pU52xreJeYvDngO\n" + "-----END PRIVATE KEY-----\n"; + const std::string DH = + "-----BEGIN DH PARAMETERS-----\n" + "MIIBCAKCAQEA4+DA1j0gDWS71okwHpnvA65NmmR4mf+B3H39g163zY5S+cnWS2LI\n" + "dvqnUDpw13naWtQ+Nu7I4rk1XoPaxOPSTu1MTbtYOxxU9M1ceBu4kQjDeHwasPVM\n" + "zyEs1XXX3tsbPUxAuayX+AgW6QQAQUEjKDnv3FzVnQTFjwI49LqjnrSjbgQcoMaH\n" + "EdGGUc6t1/We2vtsJZx0/dbaMkzFYO8dAbEYHL4sPKQb2mLpCPJZC3vwzpFkHFCd\n" + "QSnLW2qRhy+66Mf8shdr6uvpoMcnKMOAvjKdXl9PBeJM9eJPz2lC4tnTiM3DqNzK\n" + "Hn8+Pu3KkSIFL/5uBVu1fZSq+lFIEI23wwIBAg==\n" + "-----END DH PARAMETERS-----\n"; + + librbd::ImageCtx *m_image_ctx; + + std::optional<boost::asio::ip::tcp::acceptor> m_acceptor; + boost::beast::flat_buffer m_buffer; + uint64_t m_server_port = 0; +}; + +TEST_F(TestMockMigrationHttpClient, OpenCloseHttp) { + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx; + client_accept(&socket, false, &on_connect_ctx); + + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTP)); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx.wait()); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + http_client.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationHttpClient, OpenCloseHttps) { + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx; + client_accept(&socket, false, &on_connect_ctx); + + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTPS)); + http_client.set_ignore_self_signed_cert(true); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx.wait()); + + boost::asio::ssl::context ssl_context{boost::asio::ssl::context::tlsv12}; + load_server_certificate(ssl_context); + boost::beast::ssl_stream<boost::beast::tcp_stream> ssl_stream{ + std::move(socket), ssl_context}; + + C_SaferCond on_ssl_handshake_ctx; + client_ssl_handshake(ssl_stream, false, &on_ssl_handshake_ctx); + ASSERT_EQ(0, on_ssl_handshake_ctx.wait()); + + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + http_client.close(&ctx2); + + C_SaferCond on_ssl_shutdown_ctx; + client_ssl_shutdown(ssl_stream, &on_ssl_shutdown_ctx); + ASSERT_EQ(0, on_ssl_shutdown_ctx.wait()); + + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationHttpClient, OpenHttpsHandshakeFail) { + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx; + client_accept(&socket, false, &on_connect_ctx); + + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTPS)); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx.wait()); + + boost::asio::ssl::context ssl_context{boost::asio::ssl::context::tlsv12}; + load_server_certificate(ssl_context); + boost::beast::ssl_stream<boost::beast::tcp_stream> ssl_stream{ + std::move(socket), ssl_context}; + + C_SaferCond on_ssl_handshake_ctx; + client_ssl_handshake(ssl_stream, true, &on_ssl_handshake_ctx); + ASSERT_NE(0, on_ssl_handshake_ctx.wait()); + ASSERT_NE(0, ctx1.wait()); +} + +TEST_F(TestMockMigrationHttpClient, OpenInvalidUrl) { + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, "ftp://nope/"); + + C_SaferCond ctx; + http_client.open(&ctx); + ASSERT_EQ(-EINVAL, ctx.wait()); +} + +TEST_F(TestMockMigrationHttpClient, OpenResolveFail) { + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, "http://foo.example"); + + C_SaferCond ctx; + http_client.open(&ctx); + ASSERT_EQ(-ENOENT, ctx.wait()); +} + +TEST_F(TestMockMigrationHttpClient, OpenConnectFail) { + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + "http://localhost:2/"); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(-ECONNREFUSED, ctx1.wait()); +} + +TEST_F(TestMockMigrationHttpClient, IssueHead) { + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx; + client_accept(&socket, false, &on_connect_ctx); + + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTP)); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx.wait()); + ASSERT_EQ(0, ctx1.wait()); + + EmptyHttpRequest req; + req.method(boost::beast::http::verb::head); + + C_SaferCond ctx2; + HttpResponse res; + http_client.issue(EmptyHttpRequest{req}, + [&ctx2, &res](int r, HttpResponse&& response) mutable { + res = std::move(response); + ctx2.complete(r); + }); + + HttpResponse expected_res; + client_read_request(socket, req); + client_write_response(socket, expected_res); + + ASSERT_EQ(0, ctx2.wait()); + ASSERT_EQ(expected_res, res); + + C_SaferCond ctx3; + http_client.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationHttpClient, IssueGet) { + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx; + client_accept(&socket, false, &on_connect_ctx); + + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTP)); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx.wait()); + ASSERT_EQ(0, ctx1.wait()); + + EmptyHttpRequest req; + req.method(boost::beast::http::verb::get); + + C_SaferCond ctx2; + HttpResponse res; + http_client.issue(EmptyHttpRequest{req}, + [&ctx2, &res](int r, HttpResponse&& response) mutable { + res = std::move(response); + ctx2.complete(r); + }); + + HttpResponse expected_res; + expected_res.body() = "test"; + client_read_request(socket, req); + client_write_response(socket, expected_res); + + ASSERT_EQ(0, ctx2.wait()); + ASSERT_EQ(expected_res, res); + + C_SaferCond ctx3; + http_client.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationHttpClient, IssueSendFailed) { + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx1; + client_accept(&socket, false, &on_connect_ctx1); + + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTP)); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx1.wait()); + ASSERT_EQ(0, ctx1.wait()); + + // close connection to client + boost::system::error_code ec; + socket.close(ec); + + C_SaferCond on_connect_ctx2; + client_accept(&socket, false, &on_connect_ctx2); + + // send request via closed connection + EmptyHttpRequest req; + req.method(boost::beast::http::verb::get); + + C_SaferCond ctx2; + http_client.issue(EmptyHttpRequest{req}, + [&ctx2](int r, HttpResponse&&) mutable { + ctx2.complete(r); + }); + + // connection will be reset and request retried + ASSERT_EQ(0, on_connect_ctx2.wait()); + HttpResponse expected_res; + expected_res.body() = "test"; + client_read_request(socket, req); + client_write_response(socket, expected_res); + ASSERT_EQ(0, ctx2.wait()); + + C_SaferCond ctx3; + http_client.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationHttpClient, IssueReceiveFailed) { + boost::asio::ip::tcp::socket socket1(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx1; + client_accept(&socket1, false, &on_connect_ctx1); + + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTP)); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx1.wait()); + ASSERT_EQ(0, ctx1.wait()); + + // send request via closed connection + EmptyHttpRequest req; + req.method(boost::beast::http::verb::get); + + C_SaferCond ctx2; + http_client.issue(EmptyHttpRequest{req}, + [&ctx2](int r, HttpResponse&&) mutable { + ctx2.complete(r); + }); + + // close connection to client after reading request + client_read_request(socket1, req); + + C_SaferCond on_connect_ctx2; + boost::asio::ip::tcp::socket socket2(*m_image_ctx->asio_engine); + client_accept(&socket2, false, &on_connect_ctx2); + + boost::system::error_code ec; + socket1.close(ec); + ASSERT_EQ(0, on_connect_ctx2.wait()); + + // connection will be reset and request retried + HttpResponse expected_res; + expected_res.body() = "test"; + client_read_request(socket2, req); + client_write_response(socket2, expected_res); + ASSERT_EQ(0, ctx2.wait()); + + C_SaferCond ctx3; + http_client.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationHttpClient, IssueResetFailed) { + m_server_port = 0; + create_acceptor(true); + + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx1; + client_accept(&socket, false, &on_connect_ctx1); + + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTP)); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx1.wait()); + ASSERT_EQ(0, ctx1.wait()); + + // send requests then close connection + EmptyHttpRequest req; + req.method(boost::beast::http::verb::get); + + C_SaferCond ctx2; + http_client.issue(EmptyHttpRequest{req}, + [&ctx2](int r, HttpResponse&&) mutable { + ctx2.complete(r); + }); + + C_SaferCond ctx3; + http_client.issue(EmptyHttpRequest{req}, + [&ctx3](int r, HttpResponse&&) mutable { + ctx3.complete(r); + }); + + client_read_request(socket, req); + client_read_request(socket, req); + + // close connection to client and verify requests are failed + m_acceptor.reset(); + boost::system::error_code ec; + socket.close(ec); + + ASSERT_EQ(-ECONNREFUSED, ctx2.wait()); + ASSERT_EQ(-ECONNREFUSED, ctx3.wait()); + + // additional request will retry the failed connection + create_acceptor(true); + + C_SaferCond on_connect_ctx2; + client_accept(&socket, false, &on_connect_ctx2); + + C_SaferCond ctx4; + http_client.issue(EmptyHttpRequest{req}, + [&ctx4](int r, HttpResponse&&) mutable { + ctx4.complete(r); + }); + + ASSERT_EQ(0, on_connect_ctx2.wait()); + client_read_request(socket, req); + + HttpResponse expected_res; + expected_res.body() = "test"; + client_write_response(socket, expected_res); + ASSERT_EQ(0, ctx4.wait()); + + C_SaferCond ctx5; + http_client.close(&ctx5); + ASSERT_EQ(0, ctx5.wait()); +} + +TEST_F(TestMockMigrationHttpClient, IssuePipelined) { + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx; + client_accept(&socket, false, &on_connect_ctx); + + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTP)); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx.wait()); + ASSERT_EQ(0, ctx1.wait()); + + // issue two pipelined (concurrent) get requests + EmptyHttpRequest req1; + req1.method(boost::beast::http::verb::get); + + C_SaferCond ctx2; + HttpResponse res1; + http_client.issue(EmptyHttpRequest{req1}, + [&ctx2, &res1](int r, HttpResponse&& response) mutable { + res1 = std::move(response); + ctx2.complete(r); + }); + + EmptyHttpRequest req2; + req2.method(boost::beast::http::verb::get); + + C_SaferCond ctx3; + HttpResponse res2; + http_client.issue(EmptyHttpRequest{req2}, + [&ctx3, &res2](int r, HttpResponse&& response) mutable { + res2 = std::move(response); + ctx3.complete(r); + }); + + client_read_request(socket, req1); + client_read_request(socket, req2); + + // read the responses sequentially + HttpResponse expected_res1; + expected_res1.body() = "test"; + client_write_response(socket, expected_res1); + ASSERT_EQ(0, ctx2.wait()); + ASSERT_EQ(expected_res1, res1); + + HttpResponse expected_res2; + expected_res2.body() = "test"; + client_write_response(socket, expected_res2); + ASSERT_EQ(0, ctx3.wait()); + ASSERT_EQ(expected_res2, res2); + + C_SaferCond ctx4; + http_client.close(&ctx4); + ASSERT_EQ(0, ctx4.wait()); +} + +TEST_F(TestMockMigrationHttpClient, IssuePipelinedRestart) { + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx1; + client_accept(&socket, false, &on_connect_ctx1); + + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTP)); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx1.wait()); + ASSERT_EQ(0, ctx1.wait()); + + // issue two pipelined (concurrent) get requests + EmptyHttpRequest req1; + req1.keep_alive(false); + req1.method(boost::beast::http::verb::get); + + C_SaferCond on_connect_ctx2; + client_accept(&socket, false, &on_connect_ctx2); + + C_SaferCond ctx2; + HttpResponse res1; + http_client.issue(EmptyHttpRequest{req1}, + [&ctx2, &res1](int r, HttpResponse&& response) mutable { + res1 = std::move(response); + ctx2.complete(r); + }); + + EmptyHttpRequest req2; + req2.method(boost::beast::http::verb::get); + + C_SaferCond ctx3; + HttpResponse res2; + http_client.issue(EmptyHttpRequest{req2}, + [&ctx3, &res2](int r, HttpResponse&& response) mutable { + res2 = std::move(response); + ctx3.complete(r); + }); + + client_read_request(socket, req1); + client_read_request(socket, req2); + + // read the responses sequentially + HttpResponse expected_res1; + expected_res1.body() = "test"; + expected_res1.keep_alive(false); + client_write_response(socket, expected_res1); + ASSERT_EQ(0, ctx2.wait()); + ASSERT_EQ(expected_res1, res1); + + // second request will need to be re-sent due to 'need_eof' condition + ASSERT_EQ(0, on_connect_ctx2.wait()); + client_read_request(socket, req2); + + HttpResponse expected_res2; + expected_res2.body() = "test"; + client_write_response(socket, expected_res2); + ASSERT_EQ(0, ctx3.wait()); + ASSERT_EQ(expected_res2, res2); + + C_SaferCond ctx4; + http_client.close(&ctx4); + ASSERT_EQ(0, ctx4.wait()); +} + +TEST_F(TestMockMigrationHttpClient, ShutdownInFlight) { + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx; + client_accept(&socket, false, &on_connect_ctx); + + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTP)); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx.wait()); + ASSERT_EQ(0, ctx1.wait()); + + EmptyHttpRequest req; + req.method(boost::beast::http::verb::get); + + C_SaferCond ctx2; + http_client.issue(EmptyHttpRequest{req}, + [&ctx2](int r, HttpResponse&&) mutable { + ctx2.complete(r); + }); + + client_read_request(socket, req); + + C_SaferCond ctx3; + http_client.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); + ASSERT_EQ(-ESHUTDOWN, ctx2.wait()); +} + +TEST_F(TestMockMigrationHttpClient, GetSize) { + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTP)); + + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx; + client_accept(&socket, false, &on_connect_ctx); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx.wait()); + ASSERT_EQ(0, ctx1.wait()); + + uint64_t size = 0; + C_SaferCond ctx2; + http_client.get_size(&size, &ctx2); + + EmptyHttpRequest expected_req; + expected_req.method(boost::beast::http::verb::head); + client_read_request(socket, expected_req); + + HttpResponse expected_res; + expected_res.body() = std::string(123, '1'); + client_write_response(socket, expected_res); + + ASSERT_EQ(0, ctx2.wait()); + ASSERT_EQ(123, size); + + C_SaferCond ctx3; + http_client.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationHttpClient, GetSizeError) { + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTP)); + + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx; + client_accept(&socket, false, &on_connect_ctx); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx.wait()); + ASSERT_EQ(0, ctx1.wait()); + + uint64_t size = 0; + C_SaferCond ctx2; + http_client.get_size(&size, &ctx2); + + EmptyHttpRequest expected_req; + expected_req.method(boost::beast::http::verb::head); + client_read_request(socket, expected_req); + + HttpResponse expected_res; + expected_res.result(boost::beast::http::status::internal_server_error); + client_write_response(socket, expected_res); + + ASSERT_EQ(-EIO, ctx2.wait()); + + C_SaferCond ctx3; + http_client.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationHttpClient, Read) { + MockTestImageCtx mock_test_image_ctx(*m_image_ctx); + MockHttpClient http_client(&mock_test_image_ctx, + get_local_url(URL_SCHEME_HTTP)); + + boost::asio::ip::tcp::socket socket(*m_image_ctx->asio_engine); + C_SaferCond on_connect_ctx; + client_accept(&socket, false, &on_connect_ctx); + + C_SaferCond ctx1; + http_client.open(&ctx1); + ASSERT_EQ(0, on_connect_ctx.wait()); + ASSERT_EQ(0, ctx1.wait()); + + bufferlist bl; + C_SaferCond ctx2; + http_client.read({{0, 128}, {256, 64}}, &bl, &ctx2); + + EmptyHttpRequest expected_req1; + expected_req1.method(boost::beast::http::verb::get); + expected_req1.set(boost::beast::http::field::range, "bytes=0-127"); + client_read_request(socket, expected_req1); + + EmptyHttpRequest expected_req2; + expected_req2.method(boost::beast::http::verb::get); + expected_req2.set(boost::beast::http::field::range, "bytes=256-319"); + client_read_request(socket, expected_req2); + + HttpResponse expected_res1; + expected_res1.result(boost::beast::http::status::partial_content); + expected_res1.body() = std::string(128, '1'); + client_write_response(socket, expected_res1); + + HttpResponse expected_res2; + expected_res2.result(boost::beast::http::status::partial_content); + expected_res2.body() = std::string(64, '2'); + client_write_response(socket, expected_res2); + + ASSERT_EQ(192, ctx2.wait()); + + bufferlist expect_bl; + expect_bl.append(std::string(128, '1')); + expect_bl.append(std::string(64, '2')); + ASSERT_EQ(expect_bl, bl); + + C_SaferCond ctx3; + http_client.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +} // namespace migration +} // namespace librbd diff --git a/src/test/librbd/migration/test_mock_HttpStream.cc b/src/test/librbd/migration/test_mock_HttpStream.cc new file mode 100644 index 000000000..aff22b757 --- /dev/null +++ b/src/test/librbd/migration/test_mock_HttpStream.cc @@ -0,0 +1,194 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include "test/librbd/test_mock_fixture.h" +#include "test/librbd/test_support.h" +#include "include/rbd_types.h" +#include "common/ceph_mutex.h" +#include "librbd/migration/HttpClient.h" +#include "librbd/migration/HttpStream.h" +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include "json_spirit/json_spirit.h" +#include <boost/beast/http.hpp> + +namespace librbd { +namespace { + +struct MockTestImageCtx : public MockImageCtx { + MockTestImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace + +namespace migration { + +template <> +struct HttpClient<MockTestImageCtx> { + static HttpClient* s_instance; + static HttpClient* create(MockTestImageCtx*, const std::string&) { + ceph_assert(s_instance != nullptr); + return s_instance; + } + + MOCK_METHOD1(open, void(Context*)); + MOCK_METHOD1(close, void(Context*)); + MOCK_METHOD2(get_size, void(uint64_t*, Context*)); + MOCK_METHOD3(do_read, void(const io::Extents&, bufferlist*, Context*)); + void read(io::Extents&& extents, bufferlist* bl, Context* ctx) { + do_read(extents, bl, ctx); + } + + HttpClient() { + s_instance = this; + } +}; + +HttpClient<MockTestImageCtx>* HttpClient<MockTestImageCtx>::s_instance = nullptr; + +} // namespace migration +} // namespace librbd + +#include "librbd/migration/HttpStream.cc" + +namespace librbd { +namespace migration { + +using ::testing::_; +using ::testing::Invoke; +using ::testing::InSequence; +using ::testing::WithArgs; + +class TestMockMigrationHttpStream : public TestMockFixture { +public: + typedef HttpStream<MockTestImageCtx> MockHttpStream; + typedef HttpClient<MockTestImageCtx> MockHttpClient; + + librbd::ImageCtx *m_image_ctx; + + void SetUp() override { + TestMockFixture::SetUp(); + + ASSERT_EQ(0, open_image(m_image_name, &m_image_ctx)); + json_object["url"] = "http://some.site/file"; + } + + void expect_open(MockHttpClient& mock_http_client, int r) { + EXPECT_CALL(mock_http_client, open(_)) + .WillOnce(Invoke([r](Context* ctx) { ctx->complete(r); })); + } + + void expect_close(MockHttpClient& mock_http_client, int r) { + EXPECT_CALL(mock_http_client, close(_)) + .WillOnce(Invoke([r](Context* ctx) { ctx->complete(r); })); + } + + void expect_get_size(MockHttpClient& mock_http_client, uint64_t size, int r) { + EXPECT_CALL(mock_http_client, get_size(_, _)) + .WillOnce(Invoke([size, r](uint64_t* out_size, Context* ctx) { + *out_size = size; + ctx->complete(r); + })); + } + + void expect_read(MockHttpClient& mock_http_client, io::Extents byte_extents, + const bufferlist& bl, int r) { + uint64_t len = 0; + for (auto [_, byte_len] : byte_extents) { + len += byte_len; + } + EXPECT_CALL(mock_http_client, do_read(byte_extents, _, _)) + .WillOnce(WithArgs<1, 2>(Invoke( + [len, bl, r](bufferlist* out_bl, Context* ctx) { + *out_bl = bl; + ctx->complete(r < 0 ? r : len); + }))); + } + + json_spirit::mObject json_object; +}; + +TEST_F(TestMockMigrationHttpStream, OpenClose) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + + auto mock_http_client = new MockHttpClient(); + expect_open(*mock_http_client, 0); + + expect_close(*mock_http_client, 0); + + MockHttpStream mock_http_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_http_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + mock_http_stream.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationHttpStream, GetSize) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + + auto mock_http_client = new MockHttpClient(); + expect_open(*mock_http_client, 0); + + expect_get_size(*mock_http_client, 128, 0); + + expect_close(*mock_http_client, 0); + + MockHttpStream mock_http_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_http_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + uint64_t size; + mock_http_stream.get_size(&size, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + ASSERT_EQ(128, size); + + C_SaferCond ctx3; + mock_http_stream.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationHttpStream, Read) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + + auto mock_http_client = new MockHttpClient(); + expect_open(*mock_http_client, 0); + + bufferlist expect_bl; + expect_bl.append(std::string(192, '1')); + expect_read(*mock_http_client, {{0, 128}, {256, 64}}, expect_bl, 0); + + expect_close(*mock_http_client, 0); + + MockHttpStream mock_http_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_http_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + bufferlist bl; + mock_http_stream.read({{0, 128}, {256, 64}}, &bl, &ctx2); + ASSERT_EQ(192, ctx2.wait()); + ASSERT_EQ(expect_bl, bl); + + C_SaferCond ctx3; + mock_http_stream.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +} // namespace migration +} // namespace librbd diff --git a/src/test/librbd/migration/test_mock_QCOWFormat.cc b/src/test/librbd/migration/test_mock_QCOWFormat.cc new file mode 100644 index 000000000..6e7225d22 --- /dev/null +++ b/src/test/librbd/migration/test_mock_QCOWFormat.cc @@ -0,0 +1,1259 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include "test/librbd/test_mock_fixture.h" +#include "test/librbd/test_support.h" +#include "test/librbd/mock/migration/MockStreamInterface.h" +#include "include/rbd_types.h" +#include "common/ceph_mutex.h" +#include "librbd/migration/QCOWFormat.h" +#include "librbd/migration/SourceSpecBuilder.h" +#include "acconfig.h" +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include "json_spirit/json_spirit.h" + +namespace librbd { +namespace { + +struct MockTestImageCtx : public MockImageCtx { + MockTestImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace + +namespace migration { + +template<> +struct SourceSpecBuilder<librbd::MockTestImageCtx> { + + MOCK_CONST_METHOD2(build_stream, int(const json_spirit::mObject&, + std::shared_ptr<StreamInterface>*)); + +}; + +} // namespace migration + +bool operator==(const SnapInfo& lhs, const SnapInfo& rhs) { + return (lhs.name == rhs.name && + lhs.size == rhs.size); +} + +} // namespace librbd + +#include "librbd/migration/QCOWFormat.cc" + +using ::testing::_; +using ::testing::InSequence; +using ::testing::Invoke; +using ::testing::ReturnRef; +using ::testing::WithArg; +using ::testing::WithArgs; + +namespace librbd { +namespace migration { + +using ::testing::Invoke; + +class TestMockMigrationQCOWFormat : public TestMockFixture { +public: + typedef QCOWFormat<MockTestImageCtx> MockQCOWFormat; + typedef SourceSpecBuilder<MockTestImageCtx> MockSourceSpecBuilder; + + librbd::ImageCtx *m_image_ctx; + + void SetUp() override { + TestMockFixture::SetUp(); + + ASSERT_EQ(0, open_image(m_image_name, &m_image_ctx)); + + json_spirit::mObject stream_obj; + stream_obj["type"] = "file"; + json_object["stream"] = stream_obj; + } + + void expect_build_stream(MockSourceSpecBuilder& mock_source_spec_builder, + MockStreamInterface* mock_stream_interface, int r) { + EXPECT_CALL(mock_source_spec_builder, build_stream(_, _)) + .WillOnce(WithArgs<1>(Invoke([mock_stream_interface, r] + (std::shared_ptr<StreamInterface>* ptr) { + ptr->reset(mock_stream_interface); + return r; + }))); + } + + void expect_stream_open(MockStreamInterface& mock_stream_interface, int r) { + EXPECT_CALL(mock_stream_interface, open(_)) + .WillOnce(Invoke([r](Context* ctx) { ctx->complete(r); })); + } + + void expect_stream_close(MockStreamInterface& mock_stream_interface, int r) { + EXPECT_CALL(mock_stream_interface, close(_)) + .WillOnce(Invoke([r](Context* ctx) { ctx->complete(r); })); + } + + void expect_stream_read(MockStreamInterface& mock_stream_interface, + const io::Extents& byte_extents, + const bufferlist& bl, int r) { + EXPECT_CALL(mock_stream_interface, read(byte_extents, _, _)) + .WillOnce(WithArgs<1, 2>(Invoke([bl, r] + (bufferlist* out_bl, Context* ctx) { + *out_bl = bl; + ctx->complete(r); + }))); + } + + void expect_probe_header(MockStreamInterface& mock_stream_interface, + uint32_t magic, uint32_t version, int r) { + magic = htobe32(magic); + version = htobe32(version); + + bufferlist probe_bl; + probe_bl.append(std::string_view(reinterpret_cast<char*>(&magic), 4)); + probe_bl.append(std::string_view(reinterpret_cast<char*>(&version), 4)); + expect_stream_read(mock_stream_interface, {{0, 8}}, probe_bl, r); + } + + void expect_read_header(MockStreamInterface& mock_stream_interface, + uint32_t snapshot_count, int r) { + QCowHeader qcow_header; + memset(&qcow_header, 0, sizeof(qcow_header)); + qcow_header.magic = htobe32(QCOW_MAGIC); + qcow_header.version = htobe32(2); + qcow_header.size = htobe64(1<<30); + qcow_header.cluster_bits = htobe32(16); + qcow_header.l1_size = htobe32(2); + qcow_header.l1_table_offset = htobe64(1<<20); + if (snapshot_count > 0) { + qcow_header.nb_snapshots = htobe32(snapshot_count); + qcow_header.snapshots_offset = htobe64(1<<21); + } + + bufferlist header_bl; + header_bl.append(std::string_view(reinterpret_cast<char*>(&qcow_header), + sizeof(qcow_header))); + expect_stream_read(mock_stream_interface, {{0, sizeof(qcow_header)}}, + header_bl, r); + } + + void expect_read_l1_table(MockStreamInterface& mock_stream_interface, + std::optional<std::vector<uint64_t>>&& l1_table, + int r) { + bufferlist l1_table_bl; + if (!l1_table) { + l1_table.emplace(2); + } + + l1_table->resize(2); + for (size_t idx = 0; idx < l1_table->size(); ++idx) { + (*l1_table)[idx] = htobe64((*l1_table)[idx]); + } + + l1_table_bl.append( + std::string_view(reinterpret_cast<char*>(l1_table->data()), 16)); + expect_stream_read(mock_stream_interface, {{1<<20, 16}}, l1_table_bl, r); + } + + void expect_read_l2_table(MockStreamInterface& mock_stream_interface, + uint64_t l2_table_offset, + std::optional<std::vector<uint64_t>>&& l2_table, + int r) { + size_t l2_table_size = 1<<(16 - 3); // cluster_bit - 3 bits for offset + bufferlist l2_table_bl; + if (!l2_table) { + l2_table.emplace(l2_table_size); + } + + l2_table->resize(l2_table_size); + for (size_t idx = 0; idx < l2_table->size(); ++idx) { + (*l2_table)[idx] = htobe64((*l2_table)[idx]); + } + + l2_table_bl.append( + std::string_view(reinterpret_cast<char*>(l2_table->data()), + l2_table->size() * sizeof(uint64_t))); + expect_stream_read(mock_stream_interface, + {{l2_table_offset, l2_table->size() * sizeof(uint64_t)}}, + l2_table_bl, r); + } + + void expect_read_cluster(MockStreamInterface& mock_stream_interface, + uint64_t cluster_offset, uint32_t offset, + const bufferlist& bl, int r) { + uint32_t cluster_size = 1<<16; + + bufferlist cluster_bl; + if (offset > 0) { + cluster_size -= offset; + cluster_bl.append_zero(offset); + } + + cluster_size -= bl.length(); + cluster_bl.append(bl); + + if (cluster_size > 0) { + cluster_bl.append_zero(cluster_size); + } + + expect_stream_read(mock_stream_interface, + {{cluster_offset, cluster_bl.length()}}, cluster_bl, r); + } + + void expect_open(MockStreamInterface& mock_stream_interface, + std::optional<std::vector<uint64_t>>&& l1_table) { + expect_stream_open(mock_stream_interface, 0); + + expect_probe_header(mock_stream_interface, QCOW_MAGIC, 2, 0); + + expect_read_header(mock_stream_interface, 0, 0); + + expect_read_l1_table(mock_stream_interface, std::move(l1_table), 0); + } + + void expect_read_snapshot_header(MockStreamInterface& mock_stream_interface, + const std::string& id, + const std::string& name, + uint64_t l1_table_offset, + uint64_t* snapshot_offset, int r) { + QCowSnapshotHeader snapshot_header; + memset(&snapshot_header, 0, sizeof(snapshot_header)); + snapshot_header.id_str_size = htobe16(id.size()); + snapshot_header.name_size = htobe16(name.size()); + snapshot_header.extra_data_size = htobe32(16); + snapshot_header.l1_size = htobe32(1); + snapshot_header.l1_table_offset = htobe64(l1_table_offset); + + bufferlist snapshot_header_bl; + snapshot_header_bl.append( + std::string_view(reinterpret_cast<char*>(&snapshot_header), + sizeof(snapshot_header))); + expect_stream_read(mock_stream_interface, + {{*snapshot_offset, sizeof(snapshot_header)}}, + snapshot_header_bl, r); + *snapshot_offset += sizeof(snapshot_header); + } + + void expect_read_snapshot_header_extra( + MockStreamInterface& mock_stream_interface, + const std::string& id, const std::string& name, uint64_t size, + uint64_t* snapshot_offset, int r) { + QCowSnapshotExtraData snapshot_header_extra; + memset(&snapshot_header_extra, 0, sizeof(snapshot_header_extra)); + snapshot_header_extra.disk_size = htobe64(size); + + bufferlist snapshot_header_extra_bl; + snapshot_header_extra_bl.append( + std::string_view(reinterpret_cast<char*>(&snapshot_header_extra), 16)); + snapshot_header_extra_bl.append(id); + snapshot_header_extra_bl.append(name); + expect_stream_read(mock_stream_interface, + {{*snapshot_offset, 16 + id.size() + name.size()}}, + snapshot_header_extra_bl, r); + + *snapshot_offset += 16 + id.size() + name.size(); + *snapshot_offset = p2roundup(*snapshot_offset, static_cast<uint64_t>(8)); + } + + void expect_read_snapshot_l1_table(MockStreamInterface& mock_stream_interface, + uint64_t l1_table_offset, int r) { + uint64_t l2_table_cluster = htobe64(l1_table_offset); + + bufferlist snapshot_l1_table_bl; + snapshot_l1_table_bl.append( + std::string_view(reinterpret_cast<char*>(&l2_table_cluster), 8)); + expect_stream_read(mock_stream_interface, {{l1_table_offset, 8}}, + snapshot_l1_table_bl, r); + } + + + void expect_read_snapshot(MockStreamInterface& mock_stream_interface, + const std::string& id, const std::string& name, + uint64_t size, uint64_t l1_table_offset, + uint64_t* snapshot_offset) { + expect_read_snapshot_header(mock_stream_interface, id, name, + l1_table_offset, snapshot_offset, 0); + expect_read_snapshot_header_extra(mock_stream_interface, id, name, + size, snapshot_offset, 0); + expect_read_snapshot_l1_table(mock_stream_interface, l1_table_offset, 0); + } + + json_spirit::mObject json_object; +}; + +TEST_F(TestMockMigrationQCOWFormat, OpenCloseV1) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + int expected_open_ret_val = 0; + QCowHeaderV1 qcow_header; + memset(&qcow_header, 0, sizeof(qcow_header)); + qcow_header.magic = htobe32(QCOW_MAGIC); + qcow_header.version = htobe32(1); + qcow_header.size = htobe64(1<<30); + qcow_header.l1_table_offset = htobe64(1<<20); + qcow_header.cluster_bits = 16; + qcow_header.l2_bits = 13; + + bufferlist probe_bl; + probe_bl.append(std::string_view(reinterpret_cast<char*>(&qcow_header), 8)); + expect_stream_read(*mock_stream_interface, {{0, 8}}, probe_bl, 0); + +#ifdef WITH_RBD_MIGRATION_FORMAT_QCOW_V1 + + bufferlist header_bl; + header_bl.append(std::string_view(reinterpret_cast<char*>(&qcow_header), + sizeof(qcow_header))); + expect_stream_read(*mock_stream_interface, {{0, sizeof(qcow_header)}}, + header_bl, 0); + + bufferlist l1_table_bl; + l1_table_bl.append_zero(16); + expect_stream_read(*mock_stream_interface, {{1<<20, 16}}, l1_table_bl, 0); + +#else // WITH_RBD_MIGRATION_FORMAT_QCOW_V1 + + expected_open_ret_val = -ENOTSUP; + +#endif // WITH_RBD_MIGRATION_FORMAT_QCOW_V1 + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(expected_open_ret_val, ctx1.wait()); + + C_SaferCond ctx2; + mock_qcow_format.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, OpenCloseV2) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_open(*mock_stream_interface, {}); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + mock_qcow_format.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ProbeInvalidMagic) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, 0, 2, 0); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(-EINVAL, ctx1.wait()); + + C_SaferCond ctx2; + mock_qcow_format.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ProbeInvalidVersion) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, QCOW_MAGIC, 0, 0); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(-EINVAL, ctx1.wait()); + + C_SaferCond ctx2; + mock_qcow_format.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ProbeError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, QCOW_MAGIC, 2, -EIO); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(-EIO, ctx1.wait()); + + C_SaferCond ctx2; + mock_qcow_format.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +#ifdef WITH_RBD_MIGRATION_FORMAT_QCOW_V1 + +TEST_F(TestMockMigrationQCOWFormat, ReadHeaderV1Error) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, QCOW_MAGIC, 1, 0); + + QCowHeaderV1 qcow_header; + memset(&qcow_header, 0, sizeof(qcow_header)); + qcow_header.magic = htobe32(QCOW_MAGIC); + qcow_header.version = htobe32(1); + qcow_header.size = htobe64(1<<30); + qcow_header.l1_table_offset = htobe64(1<<20); + qcow_header.cluster_bits = 16; + qcow_header.l2_bits = 13; + + bufferlist header_bl; + header_bl.append(std::string_view(reinterpret_cast<char*>(&qcow_header), + sizeof(qcow_header))); + expect_stream_read(*mock_stream_interface, {{0, sizeof(qcow_header)}}, + header_bl, -EPERM); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(-EPERM, ctx1.wait()); + + C_SaferCond ctx2; + mock_qcow_format.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +#endif // WITH_RBD_MIGRATION_FORMAT_QCOW_V1 + +TEST_F(TestMockMigrationQCOWFormat, ReadHeaderV2Error) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, QCOW_MAGIC, 2, 0); + + expect_read_header(*mock_stream_interface, 0, -EIO); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(-EIO, ctx1.wait()); + + C_SaferCond ctx2; + mock_qcow_format.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ReadL1TableError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, QCOW_MAGIC, 2, 0); + + expect_read_header(*mock_stream_interface, 0, 0); + + expect_read_l1_table(*mock_stream_interface, {}, -EPERM); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(-EPERM, ctx1.wait()); + + C_SaferCond ctx2; + mock_qcow_format.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, Snapshots) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, QCOW_MAGIC, 2, 0); + + expect_read_header(*mock_stream_interface, 2, 0); + + uint64_t snapshot_offset = 1<<21; + expect_read_snapshot(*mock_stream_interface, "1", "snap1", 1<<29, 1<<22, + &snapshot_offset); + expect_read_snapshot(*mock_stream_interface, "2", "snap2", 1<<29, 1<<22, + &snapshot_offset); + + expect_read_l1_table(*mock_stream_interface, {}, 0); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + FormatInterface::SnapInfos snap_infos; + C_SaferCond ctx2; + mock_qcow_format.get_snapshots(&snap_infos, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + + FormatInterface::SnapInfos expected_snap_infos{ + {1, {"snap1", cls::rbd::UserSnapshotNamespace{}, 1<<29, {}, 0, 0, {}}}, + {2, {"snap2", cls::rbd::UserSnapshotNamespace{}, 1<<29, {}, 0, 0, {}}}}; + ASSERT_EQ(expected_snap_infos, snap_infos); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, SnapshotHeaderError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, QCOW_MAGIC, 2, 0); + + expect_read_header(*mock_stream_interface, 2, 0); + + uint64_t snapshot_offset = 1<<21; + expect_read_snapshot_header(*mock_stream_interface, "1", "snap1", + 1<<22, &snapshot_offset, -EINVAL); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(-EINVAL, ctx1.wait()); + + C_SaferCond ctx2; + mock_qcow_format.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, SnapshotExtraError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, QCOW_MAGIC, 2, 0); + + expect_read_header(*mock_stream_interface, 2, 0); + + uint64_t snapshot_offset = 1<<21; + expect_read_snapshot_header(*mock_stream_interface, "1", "snap1", + 1<<22, &snapshot_offset, 0); + expect_read_snapshot_header_extra(*mock_stream_interface, "1", "snap1", + 1<<29, &snapshot_offset, -EINVAL); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(-EINVAL, ctx1.wait()); + + C_SaferCond ctx2; + mock_qcow_format.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, SnapshotL1TableError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, QCOW_MAGIC, 2, 0); + + expect_read_header(*mock_stream_interface, 2, 0); + + uint64_t snapshot_offset = 1<<21; + expect_read_snapshot_header(*mock_stream_interface, "1", "snap1", + 1<<22, &snapshot_offset, 0); + expect_read_snapshot_header_extra(*mock_stream_interface, "1", "snap1", + 1<<29, &snapshot_offset, 0); + expect_read_snapshot_l1_table(*mock_stream_interface, 1<<22, -EINVAL); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(-EINVAL, ctx1.wait()); + + C_SaferCond ctx2; + mock_qcow_format.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, GetImageSize) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_open(*mock_stream_interface, {}); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + uint64_t size = 0; + C_SaferCond ctx2; + mock_qcow_format.get_image_size(CEPH_NOSNAP, &size, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + ASSERT_EQ(1<<30, size); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, GetImageSizeSnap) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, QCOW_MAGIC, 2, 0); + + expect_read_header(*mock_stream_interface, 1, 0); + + uint64_t snapshot_offset = 1<<21; + expect_read_snapshot(*mock_stream_interface, "1", "snap1", 1<<29, 1<<22, + &snapshot_offset); + + expect_read_l1_table(*mock_stream_interface, {}, 0); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + uint64_t size = 0; + C_SaferCond ctx2; + mock_qcow_format.get_image_size(1U, &size, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + ASSERT_EQ(1<<29, size); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, GetImageSizeSnapDNE) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_open(*mock_stream_interface, {}); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + uint64_t size = 0; + C_SaferCond ctx2; + mock_qcow_format.get_image_size(1U, &size, &ctx2); + ASSERT_EQ(-ENOENT, ctx2.wait()); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, Read) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_open(*mock_stream_interface, {{1ULL<<40}}); + + expect_read_l2_table(*mock_stream_interface, 1ULL<<40, + {{0, 1ULL<<32}}, 0); + + bufferlist expect_bl; + expect_bl.append(std::string(123, '1')); + expect_read_cluster(*mock_stream_interface, 1ULL<<32, 123, expect_bl, 0); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + auto aio_comp = io::AioCompletion::create_and_start( + &ctx2, m_image_ctx, io::AIO_TYPE_READ); + bufferlist bl; + io::ReadResult read_result{&bl}; + ASSERT_TRUE(mock_qcow_format.read(aio_comp, CEPH_NOSNAP, {{65659, 123}}, + std::move(read_result), 0, 0, {})); + ASSERT_EQ(123, ctx2.wait()); + ASSERT_EQ(expect_bl, bl); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ReadL1DNE) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_open(*mock_stream_interface, {}); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + auto aio_comp = io::AioCompletion::create_and_start( + &ctx2, m_image_ctx, io::AIO_TYPE_READ); + bufferlist bl; + io::ReadResult read_result{&bl}; + ASSERT_TRUE(mock_qcow_format.read(aio_comp, CEPH_NOSNAP, {{234, 123}}, + std::move(read_result), 0, 0, {})); + ASSERT_EQ(123, ctx2.wait()); + bufferlist expect_bl; + expect_bl.append_zero(123); + ASSERT_EQ(expect_bl, bl); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ReadL2DNE) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_open(*mock_stream_interface, {{1ULL<<40}}); + + expect_read_l2_table(*mock_stream_interface, 1ULL<<40, + {{0, 1ULL<<32}}, 0); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + auto aio_comp = io::AioCompletion::create_and_start( + &ctx2, m_image_ctx, io::AIO_TYPE_READ); + bufferlist bl; + io::ReadResult read_result{&bl}; + ASSERT_TRUE(mock_qcow_format.read(aio_comp, CEPH_NOSNAP, {{234, 123}}, + std::move(read_result), 0, 0, {})); + ASSERT_EQ(123, ctx2.wait()); + bufferlist expect_bl; + expect_bl.append_zero(123); + ASSERT_EQ(expect_bl, bl); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ReadZero) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_open(*mock_stream_interface, {{1ULL<<40}}); + + expect_read_l2_table(*mock_stream_interface, 1ULL<<40, + {{0, QCOW_OFLAG_ZERO}}, 0); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + auto aio_comp = io::AioCompletion::create_and_start( + &ctx2, m_image_ctx, io::AIO_TYPE_READ); + bufferlist bl; + io::ReadResult read_result{&bl}; + ASSERT_TRUE(mock_qcow_format.read(aio_comp, CEPH_NOSNAP, {{65659, 123}}, + std::move(read_result), 0, 0, {})); + ASSERT_EQ(123, ctx2.wait()); + bufferlist expect_bl; + expect_bl.append_zero(123); + ASSERT_EQ(expect_bl, bl); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ReadSnap) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, QCOW_MAGIC, 2, 0); + + expect_read_header(*mock_stream_interface, 1, 0); + + uint64_t snapshot_offset = 1<<21; + expect_read_snapshot(*mock_stream_interface, "1", "snap1", 1<<29, 1<<22, + &snapshot_offset); + + expect_read_l1_table(*mock_stream_interface, {}, 0); + + expect_read_l2_table(*mock_stream_interface, 1<<22, + {{0, 1ULL<<32}}, 0); + + bufferlist expect_bl; + expect_bl.append(std::string(123, '1')); + expect_read_cluster(*mock_stream_interface, 1ULL<<32, 123, expect_bl, 0); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + auto aio_comp = io::AioCompletion::create_and_start( + &ctx2, m_image_ctx, io::AIO_TYPE_READ); + bufferlist bl; + io::ReadResult read_result{&bl}; + ASSERT_TRUE(mock_qcow_format.read(aio_comp, 1, {{65659, 123}}, + std::move(read_result), 0, 0, {})); + ASSERT_EQ(123, ctx2.wait()); + ASSERT_EQ(expect_bl, bl); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ReadSnapDNE) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_open(*mock_stream_interface, {{1ULL<<40}}); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + auto aio_comp = io::AioCompletion::create_and_start( + &ctx2, m_image_ctx, io::AIO_TYPE_READ); + bufferlist bl; + io::ReadResult read_result{&bl}; + ASSERT_TRUE(mock_qcow_format.read(aio_comp, 1, {{65659, 123}}, + std::move(read_result), 0, 0, {})); + ASSERT_EQ(-ENOENT, ctx2.wait()); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ReadClusterCacheHit) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_open(*mock_stream_interface, {{1ULL<<40}}); + + expect_read_l2_table(*mock_stream_interface, 1ULL<<40, + {{0, 1ULL<<32}}, 0); + + bufferlist expect_bl1; + expect_bl1.append(std::string(123, '1')); + + bufferlist expect_bl2; + expect_bl2.append(std::string(234, '2')); + + bufferlist cluster_bl; + cluster_bl.append_zero(123); + cluster_bl.append(expect_bl1); + cluster_bl.append_zero(234); + cluster_bl.append(expect_bl2); + + expect_read_cluster(*mock_stream_interface, 1ULL<<32, 0, cluster_bl, 0); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + auto aio_comp1 = io::AioCompletion::create_and_start( + &ctx2, m_image_ctx, io::AIO_TYPE_READ); + bufferlist bl1; + io::ReadResult read_result1{&bl1}; + ASSERT_TRUE(mock_qcow_format.read(aio_comp1, CEPH_NOSNAP, {{65659, 123}}, + std::move(read_result1), 0, 0, {})); + ASSERT_EQ(123, ctx2.wait()); + ASSERT_EQ(expect_bl1, bl1); + + C_SaferCond ctx3; + auto aio_comp2 = io::AioCompletion::create_and_start( + &ctx3, m_image_ctx, io::AIO_TYPE_READ); + bufferlist bl2; + io::ReadResult read_result2{&bl2}; + ASSERT_TRUE(mock_qcow_format.read(aio_comp2, CEPH_NOSNAP, {{66016, 234}}, + std::move(read_result2), 0, 0, {})); + ASSERT_EQ(234, ctx3.wait()); + ASSERT_EQ(expect_bl2, bl2); + + C_SaferCond ctx4; + mock_qcow_format.close(&ctx4); + ASSERT_EQ(0, ctx4.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ReadClusterError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_open(*mock_stream_interface, {{1ULL<<40}}); + + expect_read_l2_table(*mock_stream_interface, 1ULL<<40, + {{0, 1ULL<<32}}, 0); + + bufferlist expect_bl; + expect_bl.append(std::string(123, '1')); + expect_read_cluster(*mock_stream_interface, 1ULL<<32, 123, expect_bl, -EIO); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + auto aio_comp = io::AioCompletion::create_and_start( + &ctx2, m_image_ctx, io::AIO_TYPE_READ); + bufferlist bl; + io::ReadResult read_result{&bl}; + ASSERT_TRUE(mock_qcow_format.read(aio_comp, CEPH_NOSNAP, {{65659, 123}}, + std::move(read_result), 0, 0, {})); + ASSERT_EQ(-EIO, ctx2.wait()); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ReadL2TableError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_open(*mock_stream_interface, {{1ULL<<40}}); + + expect_read_l2_table(*mock_stream_interface, 1ULL<<40, + {{0, 1ULL<<32}}, -EIO); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + auto aio_comp = io::AioCompletion::create_and_start( + &ctx2, m_image_ctx, io::AIO_TYPE_READ); + bufferlist bl; + io::ReadResult read_result{&bl}; + ASSERT_TRUE(mock_qcow_format.read(aio_comp, CEPH_NOSNAP, {{65659, 123}}, + std::move(read_result), 0, 0, {})); + ASSERT_EQ(-EIO, ctx2.wait()); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationQCOWFormat, ListSnaps) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + + expect_probe_header(*mock_stream_interface, QCOW_MAGIC, 2, 0); + + expect_read_header(*mock_stream_interface, 2, 0); + + uint64_t snapshot_offset = 1<<21; + expect_read_snapshot(*mock_stream_interface, "1", "snap1", 1<<29, 1<<22, + &snapshot_offset); + expect_read_snapshot(*mock_stream_interface, "2", "snap2", 1<<29, 1<<23, + &snapshot_offset); + + expect_read_l1_table(*mock_stream_interface, {{1ULL<<28}}, 0); + + io::SparseExtents sparse_extents_1; + sparse_extents_1.insert(0, 196608, {io::SPARSE_EXTENT_STATE_DATA, 196608}); + expect_read_l2_table(*mock_stream_interface, 1ULL<<22, + {{1ULL<<23, 1ULL<<24, 1ULL<<25}}, 0); + + io::SparseExtents sparse_extents_2; + sparse_extents_2.insert(0, 65536, {io::SPARSE_EXTENT_STATE_DATA, 65536}); + sparse_extents_2.insert(65536, 65536, + {io::SPARSE_EXTENT_STATE_ZEROED, 65536}); + expect_read_l2_table(*mock_stream_interface, 1ULL<<23, + {{1ULL<<26, QCOW_OFLAG_ZERO, 1ULL<<25}}, 0); + + io::SparseExtents sparse_extents_head; + sparse_extents_head.insert(131072, 65536, + {io::SPARSE_EXTENT_STATE_DATA, 65536}); + expect_read_l2_table(*mock_stream_interface, 1ULL<<28, + {{1ULL<<26, QCOW_OFLAG_ZERO, 1ULL<<27}}, 0); + + expect_stream_close(*mock_stream_interface, 0); + + MockQCOWFormat mock_qcow_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_qcow_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + io::SnapshotDelta snapshot_delta; + mock_qcow_format.list_snaps({{0, 196608}}, {1, CEPH_NOSNAP}, 0, + &snapshot_delta, {}, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + + io::SnapshotDelta expected_snapshot_delta; + expected_snapshot_delta[{1, 1}] = sparse_extents_1; + expected_snapshot_delta[{CEPH_NOSNAP, 2}] = sparse_extents_2; + expected_snapshot_delta[{CEPH_NOSNAP, CEPH_NOSNAP}] = sparse_extents_head; + ASSERT_EQ(expected_snapshot_delta, snapshot_delta); + + C_SaferCond ctx3; + mock_qcow_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +} // namespace migration +} // namespace librbd diff --git a/src/test/librbd/migration/test_mock_RawFormat.cc b/src/test/librbd/migration/test_mock_RawFormat.cc new file mode 100644 index 000000000..6b69bf20c --- /dev/null +++ b/src/test/librbd/migration/test_mock_RawFormat.cc @@ -0,0 +1,523 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include "test/librbd/test_mock_fixture.h" +#include "test/librbd/test_support.h" +#include "test/librbd/mock/migration/MockSnapshotInterface.h" +#include "include/rbd_types.h" +#include "common/ceph_mutex.h" +#include "librbd/migration/RawFormat.h" +#include "librbd/migration/SourceSpecBuilder.h" +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include "json_spirit/json_spirit.h" + +namespace librbd { +namespace { + +struct MockTestImageCtx : public MockImageCtx { + MockTestImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace + +namespace migration { + +template<> +struct SourceSpecBuilder<librbd::MockTestImageCtx> { + + MOCK_CONST_METHOD3(build_snapshot, int(const json_spirit::mObject&, uint64_t, + std::shared_ptr<SnapshotInterface>*)); + +}; + +} // namespace migration +} // namespace librbd + +#include "librbd/migration/RawFormat.cc" + +using ::testing::_; +using ::testing::InSequence; +using ::testing::Invoke; +using ::testing::ReturnRef; +using ::testing::WithArg; +using ::testing::WithArgs; + +namespace librbd { +namespace migration { + +using ::testing::Invoke; + +class TestMockMigrationRawFormat : public TestMockFixture { +public: + typedef RawFormat<MockTestImageCtx> MockRawFormat; + typedef SourceSpecBuilder<MockTestImageCtx> MockSourceSpecBuilder; + + librbd::ImageCtx *m_image_ctx; + + void SetUp() override { + TestMockFixture::SetUp(); + + ASSERT_EQ(0, open_image(m_image_name, &m_image_ctx)); + + json_spirit::mObject stream_obj; + stream_obj["type"] = "file"; + json_object["stream"] = stream_obj; + } + + void expect_build_snapshot(MockSourceSpecBuilder& mock_source_spec_builder, + uint64_t index, + MockSnapshotInterface* mock_snapshot_interface, + int r) { + EXPECT_CALL(mock_source_spec_builder, build_snapshot(_, index, _)) + .WillOnce(WithArgs<2>(Invoke([mock_snapshot_interface, r] + (std::shared_ptr<SnapshotInterface>* ptr) { + ptr->reset(mock_snapshot_interface); + return r; + }))); + } + + void expect_snapshot_open(MockSnapshotInterface& mock_snapshot_interface, + int r) { + EXPECT_CALL(mock_snapshot_interface, open(_, _)) + .WillOnce(WithArg<1>(Invoke([r](Context* ctx) { ctx->complete(r); }))); + } + + void expect_snapshot_close(MockSnapshotInterface& mock_snapshot_interface, + int r) { + EXPECT_CALL(mock_snapshot_interface, close(_)) + .WillOnce(Invoke([r](Context* ctx) { ctx->complete(r); })); + } + + void expect_snapshot_get_info(MockSnapshotInterface& mock_snapshot_interface, + const SnapInfo& snap_info) { + EXPECT_CALL(mock_snapshot_interface, get_snap_info()) + .WillOnce(ReturnRef(snap_info)); + } + + void expect_snapshot_read(MockSnapshotInterface& mock_snapshot_interface, + const io::Extents& image_extents, + const bufferlist& bl, int r) { + EXPECT_CALL(mock_snapshot_interface, read(_, image_extents, _)) + .WillOnce(WithArgs<0, 2>(Invoke([bl, image_extents, r] + (io::AioCompletion* aio_comp, io::ReadResult& read_result) { + aio_comp->read_result = std::move(read_result); + aio_comp->read_result.set_image_extents(image_extents); + aio_comp->set_request_count(1); + auto ctx = new io::ReadResult::C_ImageReadRequest(aio_comp, 0, + image_extents); + ctx->bl = std::move(bl); + ctx->complete(r); + }))); + } + + void expect_snapshot_list_snap(MockSnapshotInterface& mock_snapshot_interface, + const io::Extents& image_extents, + const io::SparseExtents& sparse_extents, + int r) { + EXPECT_CALL(mock_snapshot_interface, list_snap(image_extents, _, _)) + .WillOnce(WithArgs<1, 2>(Invoke( + [sparse_extents, r](io::SparseExtents* out_sparse_extents, + Context* ctx) { + out_sparse_extents->insert(sparse_extents); + ctx->complete(r); + }))); + } + + void expect_close(MockTestImageCtx &mock_image_ctx, int r) { + EXPECT_CALL(*mock_image_ctx.state, close(_)) + .WillOnce(Invoke([r](Context* ctx) { + ctx->complete(r); + })); + } + + json_spirit::mObject json_object; +}; + +TEST_F(TestMockMigrationRawFormat, OpenClose) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_snapshot_interface = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, CEPH_NOSNAP, + mock_snapshot_interface, 0); + + expect_snapshot_open(*mock_snapshot_interface, 0); + + expect_snapshot_close(*mock_snapshot_interface, 0); + + MockRawFormat mock_raw_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_raw_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + mock_raw_format.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationRawFormat, OpenError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_snapshot_interface = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, CEPH_NOSNAP, + mock_snapshot_interface, 0); + + expect_snapshot_open(*mock_snapshot_interface, -ENOENT); + + expect_snapshot_close(*mock_snapshot_interface, 0); + expect_close(mock_image_ctx, 0); + + MockRawFormat mock_raw_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx; + mock_raw_format.open(&ctx); + ASSERT_EQ(-ENOENT, ctx.wait()); +} + +TEST_F(TestMockMigrationRawFormat, OpenSnapshotError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_snapshot_interface_head = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, CEPH_NOSNAP, + mock_snapshot_interface_head, 0); + + auto mock_snapshot_interface_1 = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, 1, + mock_snapshot_interface_1, 0); + + expect_snapshot_open(*mock_snapshot_interface_1, -ENOENT); + expect_snapshot_open(*mock_snapshot_interface_head, 0); + + expect_snapshot_close(*mock_snapshot_interface_1, 0); + expect_snapshot_close(*mock_snapshot_interface_head, 0); + expect_close(mock_image_ctx, 0); + + json_spirit::mArray snapshots; + snapshots.push_back(json_spirit::mObject{}); + json_object["snapshots"] = snapshots; + + MockRawFormat mock_raw_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx; + mock_raw_format.open(&ctx); + ASSERT_EQ(-ENOENT, ctx.wait()); +} + +TEST_F(TestMockMigrationRawFormat, GetSnapshots) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_snapshot_interface = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, CEPH_NOSNAP, + mock_snapshot_interface, 0); + + expect_snapshot_open(*mock_snapshot_interface, 0); + + expect_snapshot_close(*mock_snapshot_interface, 0); + + MockRawFormat mock_raw_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_raw_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + FormatInterface::SnapInfos snap_infos; + mock_raw_format.get_snapshots(&snap_infos, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + ASSERT_TRUE(snap_infos.empty()); + + C_SaferCond ctx3; + mock_raw_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationRawFormat, GetImageSize) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_snapshot_interface = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, CEPH_NOSNAP, + mock_snapshot_interface, 0); + + expect_snapshot_open(*mock_snapshot_interface, 0); + + SnapInfo snap_info{{}, {}, 123, {}, 0, 0, {}}; + expect_snapshot_get_info(*mock_snapshot_interface, snap_info); + + expect_snapshot_close(*mock_snapshot_interface, 0); + + MockRawFormat mock_raw_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_raw_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + uint64_t size; + mock_raw_format.get_image_size(CEPH_NOSNAP, &size, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + ASSERT_EQ(size, 123); + + C_SaferCond ctx3; + mock_raw_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationRawFormat, GetImageSizeSnapshotDNE) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_snapshot_interface = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, CEPH_NOSNAP, + mock_snapshot_interface, 0); + + expect_snapshot_open(*mock_snapshot_interface, 0); + + expect_snapshot_close(*mock_snapshot_interface, 0); + + MockRawFormat mock_raw_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_raw_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + uint64_t size; + mock_raw_format.get_image_size(0, &size, &ctx2); + ASSERT_EQ(-ENOENT, ctx2.wait()); + + C_SaferCond ctx3; + mock_raw_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationRawFormat, Read) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_snapshot_interface = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, CEPH_NOSNAP, + mock_snapshot_interface, 0); + + expect_snapshot_open(*mock_snapshot_interface, 0); + + bufferlist expect_bl; + expect_bl.append(std::string(123, '1')); + expect_snapshot_read(*mock_snapshot_interface, {{123, 123}}, expect_bl, 0); + + expect_snapshot_close(*mock_snapshot_interface, 0); + + MockRawFormat mock_raw_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_raw_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + auto aio_comp = io::AioCompletion::create_and_start( + &ctx2, m_image_ctx, io::AIO_TYPE_READ); + bufferlist bl; + io::ReadResult read_result{&bl}; + ASSERT_TRUE(mock_raw_format.read(aio_comp, CEPH_NOSNAP, {{123, 123}}, + std::move(read_result), 0, 0, {})); + ASSERT_EQ(123, ctx2.wait()); + ASSERT_EQ(expect_bl, bl); + + C_SaferCond ctx3; + mock_raw_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationRawFormat, ListSnaps) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_snapshot_interface = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, CEPH_NOSNAP, + mock_snapshot_interface, 0); + + expect_snapshot_open(*mock_snapshot_interface, 0); + + SnapInfo snap_info{{}, {}, 123, {}, 0, 0, {}}; + expect_snapshot_get_info(*mock_snapshot_interface, snap_info); + io::SparseExtents sparse_extents; + sparse_extents.insert(0, 123, {io::SPARSE_EXTENT_STATE_DATA, 123}); + expect_snapshot_list_snap(*mock_snapshot_interface, {{0, 123}}, + sparse_extents, 0); + + expect_snapshot_close(*mock_snapshot_interface, 0); + + MockRawFormat mock_raw_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_raw_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + io::SnapshotDelta snapshot_delta; + mock_raw_format.list_snaps({{0, 123}}, {CEPH_NOSNAP}, 0, &snapshot_delta, {}, + &ctx2); + ASSERT_EQ(0, ctx2.wait()); + + io::SnapshotDelta expected_snapshot_delta; + expected_snapshot_delta[{CEPH_NOSNAP, CEPH_NOSNAP}] = sparse_extents; + ASSERT_EQ(expected_snapshot_delta, snapshot_delta); + + C_SaferCond ctx3; + mock_raw_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationRawFormat, ListSnapsError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_snapshot_interface = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, CEPH_NOSNAP, + mock_snapshot_interface, 0); + + + expect_snapshot_open(*mock_snapshot_interface, 0); + + SnapInfo snap_info{{}, {}, 123, {}, 0, 0, {}}; + expect_snapshot_get_info(*mock_snapshot_interface, snap_info); + io::SparseExtents sparse_extents; + sparse_extents.insert(0, 123, {io::SPARSE_EXTENT_STATE_DATA, 123}); + expect_snapshot_list_snap(*mock_snapshot_interface, {{0, 123}}, + sparse_extents, -EINVAL); + + expect_snapshot_close(*mock_snapshot_interface, 0); + + MockRawFormat mock_raw_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_raw_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + io::SnapshotDelta snapshot_delta; + mock_raw_format.list_snaps({{0, 123}}, {CEPH_NOSNAP}, 0, &snapshot_delta, {}, + &ctx2); + ASSERT_EQ(-EINVAL, ctx2.wait()); + + C_SaferCond ctx3; + mock_raw_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationRawFormat, ListSnapsMerge) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_snapshot_interface_head = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, CEPH_NOSNAP, + mock_snapshot_interface_head, 0); + + auto mock_snapshot_interface_1 = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, 1, + mock_snapshot_interface_1, 0); + + auto mock_snapshot_interface_2 = new MockSnapshotInterface(); + expect_build_snapshot(mock_source_spec_builder, 2, + mock_snapshot_interface_2, 0); + + + expect_snapshot_open(*mock_snapshot_interface_1, 0); + expect_snapshot_open(*mock_snapshot_interface_2, 0); + expect_snapshot_open(*mock_snapshot_interface_head, 0); + + SnapInfo snap_info_head{{}, {}, 256, {}, 0, 0, {}}; + SnapInfo snap_info_1{snap_info_head}; + snap_info_1.size = 123; + expect_snapshot_get_info(*mock_snapshot_interface_1, snap_info_1); + io::SparseExtents sparse_extents_1; + sparse_extents_1.insert(0, 123, {io::SPARSE_EXTENT_STATE_DATA, 123}); + expect_snapshot_list_snap(*mock_snapshot_interface_1, {{0, 123}}, + sparse_extents_1, 0); + + SnapInfo snap_info_2{snap_info_head}; + snap_info_2.size = 64; + expect_snapshot_get_info(*mock_snapshot_interface_2, snap_info_2); + io::SparseExtents sparse_extents_2; + sparse_extents_2.insert(0, 32, {io::SPARSE_EXTENT_STATE_DATA, 32}); + expect_snapshot_list_snap(*mock_snapshot_interface_2, {{0, 123}}, + sparse_extents_2, 0); + + expect_snapshot_get_info(*mock_snapshot_interface_head, snap_info_head); + io::SparseExtents sparse_extents_head; + sparse_extents_head.insert(0, 16, {io::SPARSE_EXTENT_STATE_DATA, 16}); + expect_snapshot_list_snap(*mock_snapshot_interface_head, {{0, 123}}, + sparse_extents_head, 0); + + expect_snapshot_close(*mock_snapshot_interface_1, 0); + expect_snapshot_close(*mock_snapshot_interface_2, 0); + expect_snapshot_close(*mock_snapshot_interface_head, 0); + + json_spirit::mArray snapshots; + snapshots.push_back(json_spirit::mObject{}); + snapshots.push_back(json_spirit::mObject{}); + json_object["snapshots"] = snapshots; + + MockRawFormat mock_raw_format(&mock_image_ctx, json_object, + &mock_source_spec_builder); + + C_SaferCond ctx1; + mock_raw_format.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + io::SnapshotDelta snapshot_delta; + mock_raw_format.list_snaps({{0, 123}}, {1, CEPH_NOSNAP}, 0, &snapshot_delta, + {}, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + + io::SnapshotDelta expected_snapshot_delta; + expected_snapshot_delta[{1, 1}] = sparse_extents_1; + sparse_extents_2.erase(0, 16); + sparse_extents_2.insert(64, 59, {io::SPARSE_EXTENT_STATE_ZEROED, 59}); + expected_snapshot_delta[{CEPH_NOSNAP, 2}] = sparse_extents_2; + expected_snapshot_delta[{CEPH_NOSNAP, CEPH_NOSNAP}] = sparse_extents_head; + ASSERT_EQ(expected_snapshot_delta, snapshot_delta); + + C_SaferCond ctx3; + mock_raw_format.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +} // namespace migration +} // namespace librbd diff --git a/src/test/librbd/migration/test_mock_RawSnapshot.cc b/src/test/librbd/migration/test_mock_RawSnapshot.cc new file mode 100644 index 000000000..3ce4b5c9d --- /dev/null +++ b/src/test/librbd/migration/test_mock_RawSnapshot.cc @@ -0,0 +1,255 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include "test/librbd/test_mock_fixture.h" +#include "test/librbd/test_support.h" +#include "test/librbd/mock/migration/MockStreamInterface.h" +#include "include/rbd_types.h" +#include "common/ceph_mutex.h" +#include "librbd/migration/FileStream.h" +#include "librbd/migration/RawSnapshot.h" +#include "librbd/migration/SourceSpecBuilder.h" +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include "json_spirit/json_spirit.h" + +namespace librbd { +namespace { + +struct MockTestImageCtx : public MockImageCtx { + MockTestImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace + +namespace migration { + +template<> +struct SourceSpecBuilder<librbd::MockTestImageCtx> { + + MOCK_CONST_METHOD2(build_stream, int(const json_spirit::mObject&, + std::shared_ptr<StreamInterface>*)); + +}; + +} // namespace migration +} // namespace librbd + +#include "librbd/migration/RawSnapshot.cc" + +using ::testing::_; +using ::testing::InSequence; +using ::testing::Invoke; +using ::testing::WithArgs; + +namespace librbd { +namespace migration { + +using ::testing::Invoke; + +class TestMockMigrationRawSnapshot : public TestMockFixture { +public: + typedef RawSnapshot<MockTestImageCtx> MockRawSnapshot; + typedef SourceSpecBuilder<MockTestImageCtx> MockSourceSpecBuilder; + + librbd::ImageCtx *m_image_ctx; + + void SetUp() override { + TestMockFixture::SetUp(); + + ASSERT_EQ(0, open_image(m_image_name, &m_image_ctx)); + + json_spirit::mObject stream_obj; + stream_obj["type"] = "file"; + json_object["stream"] = stream_obj; + } + + void expect_build_stream(MockSourceSpecBuilder& mock_source_spec_builder, + MockStreamInterface* mock_stream_interface, int r) { + EXPECT_CALL(mock_source_spec_builder, build_stream(_, _)) + .WillOnce(WithArgs<1>(Invoke([mock_stream_interface, r] + (std::shared_ptr<StreamInterface>* ptr) { + ptr->reset(mock_stream_interface); + return r; + }))); + } + + void expect_stream_open(MockStreamInterface& mock_stream_interface, int r) { + EXPECT_CALL(mock_stream_interface, open(_)) + .WillOnce(Invoke([r](Context* ctx) { ctx->complete(r); })); + } + + void expect_stream_close(MockStreamInterface& mock_stream_interface, int r) { + EXPECT_CALL(mock_stream_interface, close(_)) + .WillOnce(Invoke([r](Context* ctx) { ctx->complete(r); })); + } + + void expect_stream_get_size(MockStreamInterface& mock_stream_interface, + uint64_t size, int r) { + EXPECT_CALL(mock_stream_interface, get_size(_, _)) + .WillOnce(Invoke([size, r](uint64_t* out_size, Context* ctx) { + *out_size = size; + ctx->complete(r); + })); + } + + void expect_stream_read(MockStreamInterface& mock_stream_interface, + const io::Extents& byte_extents, + const bufferlist& bl, int r) { + EXPECT_CALL(mock_stream_interface, read(byte_extents, _, _)) + .WillOnce(WithArgs<1, 2>(Invoke([bl, r] + (bufferlist* out_bl, Context* ctx) { + *out_bl = bl; + ctx->complete(r); + }))); + } + + json_spirit::mObject json_object; +}; + +TEST_F(TestMockMigrationRawSnapshot, OpenClose) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + expect_stream_get_size(*mock_stream_interface, 123, 0); + + expect_stream_close(*mock_stream_interface, 0); + + json_object["name"] = "snap1"; + MockRawSnapshot mock_raw_snapshot(&mock_image_ctx, json_object, + &mock_source_spec_builder, 1); + + C_SaferCond ctx1; + mock_raw_snapshot.open(nullptr, &ctx1); + ASSERT_EQ(0, ctx1.wait()); + + auto snap_info = mock_raw_snapshot.get_snap_info(); + ASSERT_EQ("snap1", snap_info.name); + ASSERT_EQ(123, snap_info.size); + + C_SaferCond ctx2; + mock_raw_snapshot.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationRawSnapshot, OpenError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, -ENOENT); + + MockRawSnapshot mock_raw_snapshot(&mock_image_ctx, json_object, + &mock_source_spec_builder, 0); + + C_SaferCond ctx; + mock_raw_snapshot.open(nullptr, &ctx); + ASSERT_EQ(-ENOENT, ctx.wait()); +} + +TEST_F(TestMockMigrationRawSnapshot, GetSizeError) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + expect_stream_get_size(*mock_stream_interface, 0, -EINVAL); + + expect_stream_close(*mock_stream_interface, 0); + + MockRawSnapshot mock_raw_snapshot(&mock_image_ctx, json_object, + &mock_source_spec_builder, 0); + + C_SaferCond ctx; + mock_raw_snapshot.open(nullptr, &ctx); + ASSERT_EQ(-EINVAL, ctx.wait()); +} + +TEST_F(TestMockMigrationRawSnapshot, Read) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + expect_stream_get_size(*mock_stream_interface, 0, 0); + + bufferlist expect_bl; + expect_bl.append(std::string(123, '1')); + expect_stream_read(*mock_stream_interface, {{123, 123}}, expect_bl, 0); + + expect_stream_close(*mock_stream_interface, 0); + + MockRawSnapshot mock_raw_snapshot(&mock_image_ctx, json_object, + &mock_source_spec_builder, 0); + + C_SaferCond ctx1; + mock_raw_snapshot.open(nullptr, &ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + auto aio_comp = io::AioCompletion::create_and_start( + &ctx2, m_image_ctx, io::AIO_TYPE_READ); + bufferlist bl; + io::ReadResult read_result{&bl}; + mock_raw_snapshot.read(aio_comp, {{123, 123}}, std::move(read_result), 0, 0, + {}); + ASSERT_EQ(123, ctx2.wait()); + ASSERT_EQ(expect_bl, bl); + + C_SaferCond ctx3; + mock_raw_snapshot.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationRawSnapshot, ListSnap) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + MockSourceSpecBuilder mock_source_spec_builder; + + auto mock_stream_interface = new MockStreamInterface(); + expect_build_stream(mock_source_spec_builder, mock_stream_interface, 0); + + expect_stream_open(*mock_stream_interface, 0); + expect_stream_get_size(*mock_stream_interface, 0, 0); + + expect_stream_close(*mock_stream_interface, 0); + + MockRawSnapshot mock_raw_snapshot(&mock_image_ctx, json_object, + &mock_source_spec_builder, 0); + + C_SaferCond ctx1; + mock_raw_snapshot.open(nullptr, &ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + io::SparseExtents sparse_extents; + mock_raw_snapshot.list_snap({{0, 123}}, 0, &sparse_extents, {}, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + + C_SaferCond ctx3; + mock_raw_snapshot.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +} // namespace migration +} // namespace librbd diff --git a/src/test/librbd/migration/test_mock_S3Stream.cc b/src/test/librbd/migration/test_mock_S3Stream.cc new file mode 100644 index 000000000..2f2097f79 --- /dev/null +++ b/src/test/librbd/migration/test_mock_S3Stream.cc @@ -0,0 +1,238 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include "test/librbd/test_mock_fixture.h" +#include "test/librbd/test_support.h" +#include "include/rbd_types.h" +#include "common/ceph_mutex.h" +#include "librbd/migration/HttpClient.h" +#include "librbd/migration/S3Stream.h" +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include "json_spirit/json_spirit.h" +#include <boost/algorithm/string/predicate.hpp> +#include <boost/beast/http.hpp> + +namespace librbd { +namespace { + +struct MockTestImageCtx : public MockImageCtx { + MockTestImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace + +namespace migration { + +template <> +struct HttpClient<MockTestImageCtx> { + static HttpClient* s_instance; + static HttpClient* create(MockTestImageCtx*, const std::string&) { + ceph_assert(s_instance != nullptr); + return s_instance; + } + + HttpProcessorInterface* http_processor = nullptr; + void set_http_processor(HttpProcessorInterface* http_processor) { + this->http_processor = http_processor; + } + + MOCK_METHOD1(open, void(Context*)); + MOCK_METHOD1(close, void(Context*)); + MOCK_METHOD2(get_size, void(uint64_t*, Context*)); + MOCK_METHOD3(do_read, void(const io::Extents&, bufferlist*, Context*)); + void read(io::Extents&& extents, bufferlist* bl, Context* ctx) { + do_read(extents, bl, ctx); + } + + HttpClient() { + s_instance = this; + } +}; + +HttpClient<MockTestImageCtx>* HttpClient<MockTestImageCtx>::s_instance = nullptr; + +} // namespace migration +} // namespace librbd + +#include "librbd/migration/S3Stream.cc" + +namespace librbd { +namespace migration { + +using ::testing::_; +using ::testing::Invoke; +using ::testing::InSequence; +using ::testing::WithArgs; + +class TestMockMigrationS3Stream : public TestMockFixture { +public: + typedef S3Stream<MockTestImageCtx> MockS3Stream; + typedef HttpClient<MockTestImageCtx> MockHttpClient; + + using EmptyBody = boost::beast::http::empty_body; + using EmptyRequest = boost::beast::http::request<EmptyBody>; + + librbd::ImageCtx *m_image_ctx; + + void SetUp() override { + TestMockFixture::SetUp(); + + ASSERT_EQ(0, open_image(m_image_name, &m_image_ctx)); + json_object["url"] = "http://some.site/bucket/file"; + json_object["access_key"] = "0555b35654ad1656d804"; + json_object["secret_key"] = "h7GhxuBLTrlhVUyxSPUKUV8r/2EI4ngqJxD7iBdBYLhwluN30JaT3Q=="; + } + + void expect_open(MockHttpClient& mock_http_client, int r) { + EXPECT_CALL(mock_http_client, open(_)) + .WillOnce(Invoke([r](Context* ctx) { ctx->complete(r); })); + } + + void expect_close(MockHttpClient& mock_http_client, int r) { + EXPECT_CALL(mock_http_client, close(_)) + .WillOnce(Invoke([r](Context* ctx) { ctx->complete(r); })); + } + + void expect_get_size(MockHttpClient& mock_http_client, uint64_t size, int r) { + EXPECT_CALL(mock_http_client, get_size(_, _)) + .WillOnce(Invoke([size, r](uint64_t* out_size, Context* ctx) { + *out_size = size; + ctx->complete(r); + })); + } + + void expect_read(MockHttpClient& mock_http_client, io::Extents byte_extents, + const bufferlist& bl, int r) { + uint64_t len = 0; + for (auto [_, byte_len] : byte_extents) { + len += byte_len; + } + EXPECT_CALL(mock_http_client, do_read(byte_extents, _, _)) + .WillOnce(WithArgs<1, 2>(Invoke( + [len, bl, r](bufferlist* out_bl, Context* ctx) { + *out_bl = bl; + ctx->complete(r < 0 ? r : len); + }))); + } + + json_spirit::mObject json_object; +}; + +TEST_F(TestMockMigrationS3Stream, OpenClose) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + + auto mock_http_client = new MockHttpClient(); + expect_open(*mock_http_client, 0); + + expect_close(*mock_http_client, 0); + + MockS3Stream mock_http_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_http_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + mock_http_stream.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +TEST_F(TestMockMigrationS3Stream, GetSize) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + + auto mock_http_client = new MockHttpClient(); + expect_open(*mock_http_client, 0); + + expect_get_size(*mock_http_client, 128, 0); + + expect_close(*mock_http_client, 0); + + MockS3Stream mock_http_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_http_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + uint64_t size; + mock_http_stream.get_size(&size, &ctx2); + ASSERT_EQ(0, ctx2.wait()); + ASSERT_EQ(128, size); + + C_SaferCond ctx3; + mock_http_stream.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationS3Stream, Read) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + + auto mock_http_client = new MockHttpClient(); + expect_open(*mock_http_client, 0); + + bufferlist expect_bl; + expect_bl.append(std::string(192, '1')); + expect_read(*mock_http_client, {{0, 128}, {256, 64}}, expect_bl, 0); + + expect_close(*mock_http_client, 0); + + MockS3Stream mock_http_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_http_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + C_SaferCond ctx2; + bufferlist bl; + mock_http_stream.read({{0, 128}, {256, 64}}, &bl, &ctx2); + ASSERT_EQ(192, ctx2.wait()); + ASSERT_EQ(expect_bl, bl); + + C_SaferCond ctx3; + mock_http_stream.close(&ctx3); + ASSERT_EQ(0, ctx3.wait()); +} + +TEST_F(TestMockMigrationS3Stream, ProcessRequest) { + MockTestImageCtx mock_image_ctx(*m_image_ctx); + + InSequence seq; + + auto mock_http_client = new MockHttpClient(); + expect_open(*mock_http_client, 0); + + expect_close(*mock_http_client, 0); + + MockS3Stream mock_http_stream(&mock_image_ctx, json_object); + + C_SaferCond ctx1; + mock_http_stream.open(&ctx1); + ASSERT_EQ(0, ctx1.wait()); + + EmptyRequest request; + request.method(boost::beast::http::verb::get); + request.target("/bucket/resource"); + mock_http_client->http_processor->process_request(request); + + // basic test for date and known portion of authorization + ASSERT_EQ(1U, request.count(boost::beast::http::field::date)); + ASSERT_EQ(1U, request.count(boost::beast::http::field::authorization)); + ASSERT_TRUE(boost::algorithm::starts_with( + request[boost::beast::http::field::authorization], + "AWS 0555b35654ad1656d804:")); + + C_SaferCond ctx2; + mock_http_stream.close(&ctx2); + ASSERT_EQ(0, ctx2.wait()); +} + +} // namespace migration +} // namespace librbd diff --git a/src/test/librbd/migration/test_mock_Utils.cc b/src/test/librbd/migration/test_mock_Utils.cc new file mode 100644 index 000000000..917c191dd --- /dev/null +++ b/src/test/librbd/migration/test_mock_Utils.cc @@ -0,0 +1,47 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include "test/librbd/test_mock_fixture.h" +#include "test/librbd/test_support.h" +#include "librbd/migration/Utils.h" +#include "gtest/gtest.h" +#include "gmock/gmock.h" + +namespace librbd { +namespace migration { +namespace util { + +class TestMockMigrationUtils : public TestMockFixture { +public: +}; + +TEST_F(TestMockMigrationUtils, ParseUrl) { + UrlSpec url_spec; + ASSERT_EQ(-EINVAL, parse_url(g_ceph_context, "", &url_spec)); + ASSERT_EQ(-EINVAL, parse_url(g_ceph_context, "jttp://google.com/path", + &url_spec)); + ASSERT_EQ(-EINVAL, parse_url(g_ceph_context, "http://google.com:absd/path", + &url_spec)); + + ASSERT_EQ(0, parse_url(g_ceph_context, "ceph.io/path", &url_spec)); + ASSERT_EQ(UrlSpec(URL_SCHEME_HTTP, "ceph.io", "80", "/path"), url_spec); + + ASSERT_EQ(0, parse_url(g_ceph_context, "http://google.com/path", &url_spec)); + ASSERT_EQ(UrlSpec(URL_SCHEME_HTTP, "google.com", "80", "/path"), url_spec); + + ASSERT_EQ(0, parse_url(g_ceph_context, "https://ceph.io/", &url_spec)); + ASSERT_EQ(UrlSpec(URL_SCHEME_HTTPS, "ceph.io", "443", "/"), url_spec); + + ASSERT_EQ(0, parse_url(g_ceph_context, + "http://google.com:1234/some/other/path", &url_spec)); + ASSERT_EQ(UrlSpec(URL_SCHEME_HTTP, "google.com", "1234", "/some/other/path"), + url_spec); + + ASSERT_EQ(0, parse_url(g_ceph_context, + "http://1.2.3.4/", &url_spec)); + ASSERT_EQ(UrlSpec(URL_SCHEME_HTTP, "1.2.3.4", "80", "/"), url_spec); +} + +} // namespace util +} // namespace migration +} // namespace librbd |