From e1ca8d28cb0126308ebb34898264db2d5ea83e91 Mon Sep 17 00:00:00 2001 From: bajajnehaa Date: Mon, 29 Sep 2025 15:29:09 +0000 Subject: [PATCH 1/5] feat(storage): take async client out of experimental --- google/cloud/storage/async/bucket_name.cc | 4 +- google/cloud/storage/async/bucket_name.h | 4 +- .../cloud/storage/async/bucket_name_test.cc | 4 +- google/cloud/storage/async/client.cc | 55 +++---- google/cloud/storage/async/client.h | 12 +- google/cloud/storage/async/client_test.cc | 4 +- google/cloud/storage/async/connection.h | 27 ++-- .../cloud/storage/async/idempotency_policy.cc | 35 +++-- .../cloud/storage/async/idempotency_policy.h | 16 +- .../storage/async/idempotency_policy_test.cc | 8 +- .../cloud/storage/async/object_descriptor.cc | 6 +- .../cloud/storage/async/object_descriptor.h | 4 +- .../async/object_descriptor_connection.h | 4 +- .../storage/async/object_descriptor_test.cc | 14 +- .../cloud/storage/async/object_responses.cc | 4 +- google/cloud/storage/async/object_responses.h | 4 +- google/cloud/storage/async/options.h | 4 +- google/cloud/storage/async/read_all.cc | 4 +- google/cloud/storage/async/read_all.h | 4 +- google/cloud/storage/async/read_all_test.cc | 7 +- google/cloud/storage/async/reader.cc | 14 +- google/cloud/storage/async/reader.h | 4 +- .../cloud/storage/async/reader_connection.h | 4 +- google/cloud/storage/async/reader_test.cc | 7 +- google/cloud/storage/async/resume_policy.cc | 4 +- google/cloud/storage/async/resume_policy.h | 4 +- .../cloud/storage/async/resume_policy_test.cc | 4 +- google/cloud/storage/async/retry_policy.h | 43 +++--- .../cloud/storage/async/retry_policy_test.cc | 36 ++--- google/cloud/storage/async/rewriter.cc | 17 +- google/cloud/storage/async/rewriter.h | 4 +- .../cloud/storage/async/rewriter_connection.h | 4 +- google/cloud/storage/async/rewriter_test.cc | 4 +- google/cloud/storage/async/token.h | 4 +- google/cloud/storage/async/token_test.cc | 4 +- google/cloud/storage/async/write_payload.h | 4 +- google/cloud/storage/async/writer.cc | 25 +-- google/cloud/storage/async/writer.h | 4 +- .../cloud/storage/async/writer_connection.h | 4 +- google/cloud/storage/async/writer_test.cc | 8 +- .../benchmarks/async_throughput_benchmark.cc | 41 +++-- .../storage/internal/async/connection_impl.cc | 145 ++++++++---------- .../storage/internal/async/connection_impl.h | 41 +++-- .../connection_impl_appendable_upload_test.cc | 10 +- .../async/connection_impl_insert_test.cc | 41 +++-- .../async/connection_impl_open_test.cc | 8 +- .../async/connection_impl_read_hash_test.cc | 142 ++++++++--------- .../async/connection_impl_read_test.cc | 51 +++--- .../internal/async/connection_impl_test.cc | 14 +- .../async/connection_impl_upload_hash_test.cc | 94 +++++------- .../async/connection_impl_upload_test.cc | 6 +- .../internal/async/connection_tracing.cc | 66 ++++---- .../internal/async/connection_tracing.h | 5 +- .../internal/async/connection_tracing_test.cc | 142 ++++++++--------- .../storage/internal/async/default_options.cc | 26 ++-- .../internal/async/default_options_test.cc | 38 ++--- .../object_descriptor_connection_tracing.cc | 13 +- .../object_descriptor_connection_tracing.h | 4 +- ...ject_descriptor_connection_tracing_test.cc | 9 +- .../internal/async/object_descriptor_impl.cc | 12 +- .../internal/async/object_descriptor_impl.h | 19 ++- .../async/object_descriptor_impl_test.cc | 54 +++---- .../internal/async/object_descriptor_reader.h | 3 +- .../async/object_descriptor_reader_test.cc | 2 +- .../async/object_descriptor_reader_tracing.cc | 7 +- .../async/object_descriptor_reader_tracing.h | 2 +- .../internal/async/read_payload_impl.h | 20 +-- .../internal/async/read_payload_impl_test.cc | 2 +- .../storage/internal/async/read_range.cc | 2 +- .../cloud/storage/internal/async/read_range.h | 8 +- .../storage/internal/async/read_range_test.cc | 2 +- .../async/reader_connection_factory.h | 6 +- .../internal/async/reader_connection_impl.h | 3 +- .../async/reader_connection_impl_test.cc | 53 +++---- .../async/reader_connection_resume.cc | 14 +- .../internal/async/reader_connection_resume.h | 16 +- .../async/reader_connection_resume_test.cc | 35 ++--- .../async/reader_connection_tracing.cc | 14 +- .../async/reader_connection_tracing.h | 5 +- .../async/reader_connection_tracing_test.cc | 4 +- .../async/rewriter_connection_impl.cc | 3 +- .../internal/async/rewriter_connection_impl.h | 2 +- .../async/rewriter_connection_impl_test.cc | 5 +- .../async/rewriter_connection_tracing.cc | 17 +- .../async/rewriter_connection_tracing.h | 5 +- .../storage/internal/async/token_impl.cc | 4 +- .../cloud/storage/internal/async/token_impl.h | 6 +- .../internal/async/write_payload_impl.h | 10 +- .../internal/async/write_payload_impl_test.cc | 2 +- .../async/writer_connection_buffered.cc | 37 ++--- .../async/writer_connection_buffered.h | 9 +- .../async/writer_connection_buffered_test.cc | 14 +- .../async/writer_connection_finalized.cc | 8 +- .../async/writer_connection_finalized.h | 9 +- .../internal/async/writer_connection_impl.cc | 9 +- .../internal/async/writer_connection_impl.h | 9 +- .../async/writer_connection_impl_test.cc | 2 +- .../async/writer_connection_resumed.cc | 34 ++-- .../async/writer_connection_resumed.h | 5 +- .../async/writer_connection_resumed_test.cc | 4 +- .../async/writer_connection_tracing.cc | 18 +-- .../async/writer_connection_tracing.h | 5 +- .../async/writer_connection_tracing_test.cc | 2 +- .../storage/mocks/mock_async_connection.h | 57 +++---- .../mock_async_object_descriptor_connection.h | 6 +- .../mocks/mock_async_reader_connection.h | 3 +- .../mocks/mock_async_rewriter_connection.h | 3 +- .../mocks/mock_async_writer_connection.h | 11 +- .../storage/quickstart/quickstart_async.cc | 44 +++--- .../storage/testing/mock_resume_policy.h | 4 +- .../tests/async_client_integration_test.cc | 12 +- .../cloud/storage/tests/smoke_test_async.cc | 4 +- 112 files changed, 895 insertions(+), 1073 deletions(-) diff --git a/google/cloud/storage/async/bucket_name.cc b/google/cloud/storage/async/bucket_name.cc index 47d7941e37299..dada26fdcf320 100644 --- a/google/cloud/storage/async/bucket_name.cc +++ b/google/cloud/storage/async/bucket_name.cc @@ -23,7 +23,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -56,6 +56,6 @@ StatusOr MakeBucketName(absl::string_view full_name) { } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/bucket_name.h b/google/cloud/storage/async/bucket_name.h index 0df76005a0851..454c7f1cc2456 100644 --- a/google/cloud/storage/async/bucket_name.h +++ b/google/cloud/storage/async/bucket_name.h @@ -23,7 +23,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -79,7 +79,7 @@ class BucketName { StatusOr MakeBucketName(absl::string_view full_name); GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/bucket_name_test.cc b/google/cloud/storage/async/bucket_name_test.cc index 68f6d161bd36b..fb858580e7fef 100644 --- a/google/cloud/storage/async/bucket_name_test.cc +++ b/google/cloud/storage/async/bucket_name_test.cc @@ -21,7 +21,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -77,6 +77,6 @@ TEST(BucketName, MakeBucketName) { } // namespace GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/client.cc b/google/cloud/storage/async/client.cc index 509b6294a7a96..9f9baf89da6ca 100644 --- a/google/cloud/storage/async/client.cc +++ b/google/cloud/storage/async/client.cc @@ -25,7 +25,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN using ::google::cloud::internal::MakeBackgroundThreadsFactory; @@ -46,7 +46,8 @@ future> AsyncClient::InsertObject( Options opts) { return connection_->InsertObject( {std::move(request), std::move(contents), - internal::MergeOptions(std::move(opts), connection_->options())}); + google::cloud::internal::MergeOptions(std::move(opts), + connection_->options())}); } future> AsyncClient::Open( @@ -60,8 +61,8 @@ future> AsyncClient::Open( future> AsyncClient::Open( google::storage::v2::BidiReadObjectSpec spec, Options opts) { return connection_ - ->Open({std::move(spec), - internal::MergeOptions(std::move(opts), connection_->options())}) + ->Open({std::move(spec), google::cloud::internal::MergeOptions( + std::move(opts), connection_->options())}) .then([](auto f) -> StatusOr { auto connection = f.get(); if (!connection) return std::move(connection).status(); @@ -81,8 +82,8 @@ future>> AsyncClient::ReadObject( google::storage::v2::ReadObjectRequest request, Options opts) { return connection_ ->ReadObject( - {std::move(request), - internal::MergeOptions(std::move(opts), connection_->options())}) + {std::move(request), google::cloud::internal::MergeOptions( + std::move(opts), connection_->options())}) .then([](auto f) -> StatusOr> { auto impl = f.get(); if (!impl) return std::move(impl).status(); @@ -108,8 +109,8 @@ future> AsyncClient::ReadObjectRange( request.set_read_limit(limit); return connection_->ReadObjectRange( - {std::move(request), - internal::MergeOptions(std::move(opts), connection_->options())}); + {std::move(request), google::cloud::internal::MergeOptions( + std::move(opts), connection_->options())}); } future>> @@ -131,8 +132,8 @@ AsyncClient::StartAppendableObjectUpload( google::storage::v2::BidiWriteObjectRequest request, Options opts) { return connection_ ->StartAppendableObjectUpload( - {std::move(request), - internal::MergeOptions(std::move(opts), connection_->options())}) + {std::move(request), google::cloud::internal::MergeOptions( + std::move(opts), connection_->options())}) .then([](auto f) -> StatusOr> { auto w = f.get(); if (!w) return std::move(w).status(); @@ -155,8 +156,8 @@ AsyncClient::ResumeAppendableObjectUpload(BucketName const& bucket_name, return connection_ ->ResumeAppendableObjectUpload( - {std::move(request), - internal::MergeOptions(std::move(opts), connection_->options())}) + {std::move(request), google::cloud::internal::MergeOptions( + std::move(opts), connection_->options())}) .then([](auto f) -> StatusOr> { auto w = f.get(); if (!w) return std::move(w).status(); @@ -180,8 +181,8 @@ AsyncClient::StartBufferedUpload( google::storage::v2::StartResumableWriteRequest request, Options opts) { return connection_ ->StartBufferedUpload( - {std::move(request), - internal::MergeOptions(std::move(opts), connection_->options())}) + {std::move(request), google::cloud::internal::MergeOptions( + std::move(opts), connection_->options())}) .then([](auto f) -> StatusOr> { auto w = f.get(); if (!w) return std::move(w).status(); @@ -205,8 +206,8 @@ AsyncClient::ResumeBufferedUpload( google::storage::v2::QueryWriteStatusRequest request, Options opts) { return connection_ ->ResumeBufferedUpload( - {std::move(request), - internal::MergeOptions(std::move(opts), connection_->options())}) + {std::move(request), google::cloud::internal::MergeOptions( + std::move(opts), connection_->options())}) .then([](auto f) -> StatusOr> { auto w = f.get(); if (!w) return std::move(w).status(); @@ -233,8 +234,8 @@ AsyncClient::StartUnbufferedUpload( google::storage::v2::StartResumableWriteRequest request, Options opts) { return connection_ ->StartUnbufferedUpload( - {std::move(request), - internal::MergeOptions(std::move(opts), connection_->options())}) + {std::move(request), google::cloud::internal::MergeOptions( + std::move(opts), connection_->options())}) .then([](auto f) -> StatusOr> { auto w = f.get(); if (!w) return std::move(w).status(); @@ -258,8 +259,8 @@ AsyncClient::ResumeUnbufferedUpload( google::storage::v2::QueryWriteStatusRequest request, Options opts) { return connection_ ->ResumeUnbufferedUpload( - {std::move(request), - internal::MergeOptions(std::move(opts), connection_->options())}) + {std::move(request), google::cloud::internal::MergeOptions( + std::move(opts), connection_->options())}) .then([](auto f) -> StatusOr> { auto w = f.get(); if (!w) return std::move(w).status(); @@ -288,8 +289,8 @@ future> AsyncClient::ComposeObject( future> AsyncClient::ComposeObject( google::storage::v2::ComposeObjectRequest request, Options opts) { return connection_->ComposeObject( - {std::move(request), - internal::MergeOptions(std::move(opts), connection_->options())}); + {std::move(request), google::cloud::internal::MergeOptions( + std::move(opts), connection_->options())}); } future AsyncClient::DeleteObject(BucketName const& bucket_name, @@ -315,8 +316,8 @@ future AsyncClient::DeleteObject(BucketName const& bucket_name, future AsyncClient::DeleteObject( google::storage::v2::DeleteObjectRequest request, Options opts) { return connection_->DeleteObject( - {std::move(request), - internal::MergeOptions(std::move(opts), connection_->options())}); + {std::move(request), google::cloud::internal::MergeOptions( + std::move(opts), connection_->options())}); } std::pair AsyncClient::StartRewrite( @@ -353,13 +354,13 @@ std::pair AsyncClient::ResumeRewrite( std::pair AsyncClient::ResumeRewrite( google::storage::v2::RewriteObjectRequest request, Options opts) { auto c = connection_->RewriteObject( - {std::move(request), - internal::MergeOptions(std::move(opts), connection_->options())}); + {std::move(request), google::cloud::internal::MergeOptions( + std::move(opts), connection_->options())}); auto token = storage_internal::MakeAsyncToken(c.get()); return std::make_pair(AsyncRewriter(std::move(c)), std::move(token)); } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/client.h b/google/cloud/storage/async/client.h index f1514a810f54d..49903eb12ac86 100644 --- a/google/cloud/storage/async/client.h +++ b/google/cloud/storage/async/client.h @@ -36,20 +36,12 @@ namespace google { namespace cloud { -/** - * Contains experimental features for the GCS C++ Client Library. - * - * @warning The types, functions, aliases, and objects in this namespace are - * subject to change without notice. - */ -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** * A client for Google Cloud Storage offering asynchronous operations. * - * @note This class is experimental, it is subject to change without notice. - * * @par Example: create a client instance * @snippet storage_async_samples.cc async-client * @@ -903,7 +895,7 @@ class AsyncClient { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/client_test.cc b/google/cloud/storage/async/client_test.cc index 7feddd2627a64..ae50c9f167413 100644 --- a/google/cloud/storage/async/client_test.cc +++ b/google/cloud/storage/async/client_test.cc @@ -29,7 +29,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -1399,6 +1399,6 @@ TEST(AsyncClient, ResumeRewrite2) { } // namespace GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/connection.h b/google/cloud/storage/async/connection.h index 5a03c7678a6a4..5d554a07144b4 100644 --- a/google/cloud/storage/async/connection.h +++ b/google/cloud/storage/async/connection.h @@ -29,7 +29,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN class AsyncReaderConnection; class AsyncRewriterConnection; @@ -88,9 +88,8 @@ class AsyncConnection { }; /// Open an object to perform multiple reads. - virtual future>> - Open(OpenParams p) = 0; + virtual future>> Open( + OpenParams p) = 0; /** * A thin wrapper around the `ReadObject()` parameters. @@ -128,13 +127,11 @@ class AsyncConnection { }; /// Start an appendable upload configured for persistent sources. - virtual future< - StatusOr>> + virtual future>> StartAppendableObjectUpload(AppendableUploadParams p) = 0; /// Resume an appendable upload configured for persistent sources. - virtual future< - StatusOr>> + virtual future>> ResumeAppendableObjectUpload(AppendableUploadParams p) = 0; /** @@ -153,13 +150,11 @@ class AsyncConnection { }; /// Start (or resume) an upload configured for persistent sources. - virtual future< - StatusOr>> + virtual future>> StartUnbufferedUpload(UploadParams p) = 0; /// Start (or resume) an upload configured for streaming sources. - virtual future< - StatusOr>> + virtual future>> StartBufferedUpload(UploadParams p) = 0; /** @@ -179,13 +174,11 @@ class AsyncConnection { }; /// Resume an upload configured for persistent sources. - virtual future< - StatusOr>> + virtual future>> ResumeUnbufferedUpload(ResumeUploadParams p) = 0; /// Resume an upload configured for streaming sources. - virtual future< - StatusOr>> + virtual future>> ResumeBufferedUpload(ResumeUploadParams p) = 0; /** @@ -248,7 +241,7 @@ class AsyncConnection { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/idempotency_policy.cc b/google/cloud/storage/async/idempotency_policy.cc index 570e62d199ea8..b39a58d0bb06a 100644 --- a/google/cloud/storage/async/idempotency_policy.cc +++ b/google/cloud/storage/async/idempotency_policy.cc @@ -17,18 +17,18 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { -class StrictIdempotencyPolicy : public IdempotencyPolicy { +class StrictAsyncIdempotencyPolicy : public AsyncIdempotencyPolicy { public: - ~StrictIdempotencyPolicy() override = default; + ~StrictAsyncIdempotencyPolicy() override = default; }; -class AlwaysRetryIdempotencyPolicy : public IdempotencyPolicy { +class AlwaysRetryAsyncIdempotencyPolicy : public AsyncIdempotencyPolicy { public: - ~AlwaysRetryIdempotencyPolicy() override = default; + ~AlwaysRetryAsyncIdempotencyPolicy() override = default; google::cloud::Idempotency ReadObject( google::storage::v2::ReadObjectRequest const&) override { @@ -63,15 +63,15 @@ class AlwaysRetryIdempotencyPolicy : public IdempotencyPolicy { } // namespace -IdempotencyPolicy::~IdempotencyPolicy() = default; +AsyncIdempotencyPolicy::~AsyncIdempotencyPolicy() = default; -google::cloud::Idempotency IdempotencyPolicy::ReadObject( +google::cloud::Idempotency AsyncIdempotencyPolicy::ReadObject( google::storage::v2::ReadObjectRequest const&) { // Read operations are always idempotent. return Idempotency::kIdempotent; } -google::cloud::Idempotency IdempotencyPolicy::InsertObject( +google::cloud::Idempotency AsyncIdempotencyPolicy::InsertObject( google::storage::v2::WriteObjectRequest const& request) { auto const& spec = request.write_object_spec(); if (spec.has_if_generation_match() || spec.has_if_metageneration_match()) { @@ -80,7 +80,7 @@ google::cloud::Idempotency IdempotencyPolicy::InsertObject( return Idempotency::kNonIdempotent; } -google::cloud::Idempotency IdempotencyPolicy::WriteObject( +google::cloud::Idempotency AsyncIdempotencyPolicy::WriteObject( google::storage::v2::WriteObjectRequest const&) { // Write requests for resumable uploads are (each part) always idempotent. // The initial StartResumableWrite() request has no visible side-effects. It @@ -91,7 +91,7 @@ google::cloud::Idempotency IdempotencyPolicy::WriteObject( return Idempotency::kIdempotent; } -google::cloud::Idempotency IdempotencyPolicy::ComposeObject( +google::cloud::Idempotency AsyncIdempotencyPolicy::ComposeObject( google::storage::v2::ComposeObjectRequest const& request) { // Either of these pre-conditions will fail once the operation succeeds. Their // presence makes the operation idempotent. @@ -102,7 +102,7 @@ google::cloud::Idempotency IdempotencyPolicy::ComposeObject( return Idempotency::kNonIdempotent; } -google::cloud::Idempotency IdempotencyPolicy::DeleteObject( +google::cloud::Idempotency AsyncIdempotencyPolicy::DeleteObject( google::storage::v2::DeleteObjectRequest const& request) { if (request.generation() != 0 || request.has_if_generation_match() || request.has_if_metageneration_match()) { @@ -111,23 +111,24 @@ google::cloud::Idempotency IdempotencyPolicy::DeleteObject( return Idempotency::kNonIdempotent; } -google::cloud::Idempotency IdempotencyPolicy::RewriteObject( +google::cloud::Idempotency AsyncIdempotencyPolicy::RewriteObject( google::storage::v2::RewriteObjectRequest const&) { // Rewrite requests are idempotent because they can only succeed once. return Idempotency::kIdempotent; } /// Creates an idempotency policy where only safe operations are retried. -std::unique_ptr MakeStrictIdempotencyPolicy() { - return std::make_unique(); +std::unique_ptr MakeStrictAsyncIdempotencyPolicy() { + return std::make_unique(); } /// Creates an idempotency policy that retries all operations. -std::unique_ptr MakeAlwaysRetryIdempotencyPolicy() { - return std::make_unique(); +std::unique_ptr +MakeAlwaysRetryAsyncIdempotencyPolicy() { + return std::make_unique(); } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/idempotency_policy.h b/google/cloud/storage/async/idempotency_policy.h index bbe020d02c847..eeeebaa53d4e5 100644 --- a/google/cloud/storage/async/idempotency_policy.h +++ b/google/cloud/storage/async/idempotency_policy.h @@ -23,7 +23,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -53,9 +53,9 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN * configure the library to retry all operations, regardless of whether the * operations are idempotent or not. */ -class IdempotencyPolicy { +class AsyncIdempotencyPolicy { public: - virtual ~IdempotencyPolicy() = 0; + virtual ~AsyncIdempotencyPolicy() = 0; /// Determine if a google.storage.v2.ReadObjectRequest is idempotent. virtual google::cloud::Idempotency ReadObject( @@ -85,20 +85,20 @@ class IdempotencyPolicy { }; /// Creates an idempotency policy where only safe operations are retried. -std::unique_ptr MakeStrictIdempotencyPolicy(); +std::unique_ptr MakeStrictAsyncIdempotencyPolicy(); /// Creates an idempotency policy that retries all operations. -std::unique_ptr MakeAlwaysRetryIdempotencyPolicy(); +std::unique_ptr MakeAlwaysRetryAsyncIdempotencyPolicy(); /** * An option (see `google::cloud::Options`) to set the idempotency policy. */ -struct IdempotencyPolicyOption { - using Type = std::function()>; +struct AsyncIdempotencyPolicyOption { + using Type = std::function()>; }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/idempotency_policy_test.cc b/google/cloud/storage/async/idempotency_policy_test.cc index 741f4a5eb3d6b..26f396165bda5 100644 --- a/google/cloud/storage/async/idempotency_policy_test.cc +++ b/google/cloud/storage/async/idempotency_policy_test.cc @@ -18,7 +18,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -32,7 +32,7 @@ auto TestMessage(char const* text, M m) { } TEST(IdempotencyPolicy, Strict) { - auto policy = MakeStrictIdempotencyPolicy(); + auto policy = MakeStrictAsyncIdempotencyPolicy(); ASSERT_THAT(policy, NotNull()); EXPECT_EQ(policy->ReadObject(google::storage::v2::ReadObjectRequest{}), @@ -86,7 +86,7 @@ TEST(IdempotencyPolicy, Strict) { } TEST(IdempotencyPolicy, AlwaysRetry) { - auto policy = MakeAlwaysRetryIdempotencyPolicy(); + auto policy = MakeAlwaysRetryAsyncIdempotencyPolicy(); ASSERT_THAT(policy, NotNull()); EXPECT_EQ(policy->ReadObject(google::storage::v2::ReadObjectRequest{}), Idempotency::kIdempotent); @@ -104,6 +104,6 @@ TEST(IdempotencyPolicy, AlwaysRetry) { } // namespace GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/object_descriptor.cc b/google/cloud/storage/async/object_descriptor.cc index dd197e0109419..54041edd914e9 100644 --- a/google/cloud/storage/async/object_descriptor.cc +++ b/google/cloud/storage/async/object_descriptor.cc @@ -18,7 +18,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN absl::optional ObjectDescriptor::metadata() const { @@ -31,7 +31,7 @@ std::pair ObjectDescriptor::Read(std::int64_t offset, // revisit it after benchmarking our code. // std::int64_t max_range = - // impl_->options().get(); + // impl_->options().get(); // if (limit > max_range) { // impl_->MakeSubsequentStream(); // } @@ -55,6 +55,6 @@ std::pair ObjectDescriptor::ReadLast( } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/object_descriptor.h b/google/cloud/storage/async/object_descriptor.h index dace25c5b7812..c826859d7a027 100644 --- a/google/cloud/storage/async/object_descriptor.h +++ b/google/cloud/storage/async/object_descriptor.h @@ -27,7 +27,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -81,7 +81,7 @@ class ObjectDescriptor { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/object_descriptor_connection.h b/google/cloud/storage/async/object_descriptor_connection.h index b1a602fad426d..5c03ac39f44a1 100644 --- a/google/cloud/storage/async/object_descriptor_connection.h +++ b/google/cloud/storage/async/object_descriptor_connection.h @@ -25,7 +25,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -64,7 +64,7 @@ class ObjectDescriptorConnection { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/object_descriptor_test.cc b/google/cloud/storage/async/object_descriptor_test.cc index f1541fab05363..3e163c23f960c 100644 --- a/google/cloud/storage/async/object_descriptor_test.cc +++ b/google/cloud/storage/async/object_descriptor_test.cc @@ -21,7 +21,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -29,10 +29,8 @@ using ::google::cloud::storage_mocks::MockAsyncObjectDescriptorConnection; using ::google::cloud::storage_mocks::MockAsyncReaderConnection; using ::testing::ElementsAre; using ::testing::Return; -using ReadParams = ::google::cloud::storage_experimental:: - ObjectDescriptorConnection::ReadParams; -using ReadResponse = - ::google::cloud::storage_experimental::AsyncReaderConnection::ReadResponse; +using ReadParams = ObjectDescriptorConnection::ReadParams; +using ReadResponse = AsyncReaderConnection::ReadResponse; TEST(ObjectDescriptor, Basic) { auto mock = std::make_shared(); @@ -153,9 +151,7 @@ TEST(ObjectDescriptor, ReadExceedsMaxRange) { auto mock = std::make_shared(); auto constexpr kMaxRange = 1024; EXPECT_CALL(*mock, options) - .WillRepeatedly( - Return(Options{}.set( - kMaxRange))); + .WillRepeatedly(Return(Options{}.set(kMaxRange))); EXPECT_CALL(*mock, MakeSubsequentStream).Times(1); @@ -193,6 +189,6 @@ TEST(ObjectDescriptor, ReadExceedsMaxRange) { } // namespace GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/object_responses.cc b/google/cloud/storage/async/object_responses.cc index f6d5cc4d1de40..b74f525ef3bf6 100644 --- a/google/cloud/storage/async/object_responses.cc +++ b/google/cloud/storage/async/object_responses.cc @@ -19,7 +19,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN ReadPayload::ReadPayload(std::string contents) @@ -32,6 +32,6 @@ ReadPayload::ReadPayload(std::vector contents) { } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/object_responses.h b/google/cloud/storage/async/object_responses.h index bfab046429183..bd0421056504b 100644 --- a/google/cloud/storage/async/object_responses.h +++ b/google/cloud/storage/async/object_responses.h @@ -31,7 +31,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -128,7 +128,7 @@ class ReadPayload { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/options.h b/google/cloud/storage/async/options.h index acadb8f29a46d..22ea8b410bf19 100644 --- a/google/cloud/storage/async/options.h +++ b/google/cloud/storage/async/options.h @@ -21,7 +21,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -87,7 +87,7 @@ struct MaximumRangeSizeOption { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/read_all.cc b/google/cloud/storage/async/read_all.cc index 17b9c006bcfad..3589c0f160c92 100644 --- a/google/cloud/storage/async/read_all.cc +++ b/google/cloud/storage/async/read_all.cc @@ -21,7 +21,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -88,6 +88,6 @@ future> ReadAll( } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/read_all.h b/google/cloud/storage/async/read_all.h index d39caf161dde2..c4eaa1989dd90 100644 --- a/google/cloud/storage/async/read_all.h +++ b/google/cloud/storage/async/read_all.h @@ -24,7 +24,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -50,7 +50,7 @@ future> ReadAll( future>> pending_read); GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/read_all_test.cc b/google/cloud/storage/async/read_all_test.cc index 804fcbe9e9937..edbec521b69a7 100644 --- a/google/cloud/storage/async/read_all_test.cc +++ b/google/cloud/storage/async/read_all_test.cc @@ -25,7 +25,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN using ::google::cloud::storage::testing::canonical_errors::PermanentError; @@ -36,8 +36,7 @@ using ::testing::ElementsAre; using ::testing::IsEmpty; using ::testing::Optional; -using ReadResponse = - ::google::cloud::storage_experimental::AsyncReaderConnection::ReadResponse; +using ReadResponse = AsyncReaderConnection::ReadResponse; TEST(ReadAll, Basic) { auto mock = std::make_unique(); @@ -168,6 +167,6 @@ TEST(ReadAll, Error) { } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/reader.cc b/google/cloud/storage/async/reader.cc index 71be31755eac9..f1f5b105bda8a 100644 --- a/google/cloud/storage/async/reader.cc +++ b/google/cloud/storage/async/reader.cc @@ -20,18 +20,20 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { StatusOr> InvalidTokenError( - internal::ErrorInfoBuilder eib) { - return internal::InvalidArgumentError("invalid token", std::move(eib)); + google::cloud::internal::ErrorInfoBuilder eib) { + return google::cloud::internal::InvalidArgumentError("invalid token", + std::move(eib)); } StatusOr> ClosedStreamError( - internal::ErrorInfoBuilder eib) { - return internal::CancelledError("closed stream", std::move(eib)); + google::cloud::internal::ErrorInfoBuilder eib) { + return google::cloud::internal::CancelledError("closed stream", + std::move(eib)); } class Discard : public std::enable_shared_from_this { @@ -93,6 +95,6 @@ RpcMetadata AsyncReader::GetRequestMetadata() { } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/reader.h b/google/cloud/storage/async/reader.h index 4f7d50db2fb73..a117ad83c7c79 100644 --- a/google/cloud/storage/async/reader.h +++ b/google/cloud/storage/async/reader.h @@ -25,7 +25,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -99,7 +99,7 @@ class AsyncReader { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/reader_connection.h b/google/cloud/storage/async/reader_connection.h index fb9c51633d86d..031eab6562cc6 100644 --- a/google/cloud/storage/async/reader_connection.h +++ b/google/cloud/storage/async/reader_connection.h @@ -24,7 +24,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -84,7 +84,7 @@ class AsyncReaderConnection { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/reader_test.cc b/google/cloud/storage/async/reader_test.cc index 6cac4b105efea..1406c4bc45461 100644 --- a/google/cloud/storage/async/reader_test.cc +++ b/google/cloud/storage/async/reader_test.cc @@ -24,7 +24,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -38,8 +38,7 @@ using ::testing::Pair; using ::testing::Return; using ::testing::UnorderedElementsAre; -using ReadResponse = - ::google::cloud::storage_experimental::AsyncReaderConnection::ReadResponse; +using ReadResponse = AsyncReaderConnection::ReadResponse; TEST(AsyncReader, Basic) { auto mock = std::make_unique(); @@ -187,6 +186,6 @@ TEST(AsyncReader, ErrorWithMismatchedToken) { } // namespace GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/resume_policy.cc b/google/cloud/storage/async/resume_policy.cc index 24e086b965038..f23df8dec198e 100644 --- a/google/cloud/storage/async/resume_policy.cc +++ b/google/cloud/storage/async/resume_policy.cc @@ -17,7 +17,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -78,6 +78,6 @@ ResumePolicyFactory StopOnConsecutiveErrorsResumePolicy() { } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/resume_policy.h b/google/cloud/storage/async/resume_policy.h index cd2f5a4c87296..cd8982c0bf452 100644 --- a/google/cloud/storage/async/resume_policy.h +++ b/google/cloud/storage/async/resume_policy.h @@ -22,7 +22,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -68,7 +68,7 @@ ResumePolicyFactory LimitedErrorCountResumePolicy(int maximum_resumes); ResumePolicyFactory StopOnConsecutiveErrorsResumePolicy(); GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/resume_policy_test.cc b/google/cloud/storage/async/resume_policy_test.cc index 8767473b33cc4..596d087376f3d 100644 --- a/google/cloud/storage/async/resume_policy_test.cc +++ b/google/cloud/storage/async/resume_policy_test.cc @@ -18,7 +18,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -70,6 +70,6 @@ TEST(ResumePolicy, StopOnConsecutiveErrorsResumePolicy) { } // namespace GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/retry_policy.h b/google/cloud/storage/async/retry_policy.h index 98b0b5d6d2c07..e07040ef30561 100644 --- a/google/cloud/storage/async/retry_policy.h +++ b/google/cloud/storage/async/retry_policy.h @@ -23,11 +23,11 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace internal { /// Defines what error codes are permanent errors. -struct StatusTraits { +struct AsyncStatusTraits { static bool IsPermanentFailure(Status const& status) { return status.code() != StatusCode::kDeadlineExceeded && status.code() != StatusCode::kInternal && @@ -59,7 +59,7 @@ class AsyncRetryPolicy : public google::cloud::RetryPolicy { * - [`kUnavailable`](@ref google::cloud::StatusCode) * - [`kAborted`](@ref google::cloud::StatusCode) */ -class LimitedErrorCountRetryPolicy : public AsyncRetryPolicy { +class LimitedErrorCountAsyncRetryPolicy : public AsyncRetryPolicy { public: /** * Create an instance that tolerates up to @p maximum_failures transient @@ -68,13 +68,15 @@ class LimitedErrorCountRetryPolicy : public AsyncRetryPolicy { * @note Disable the retry loop by providing an instance of this policy with * @p maximum_failures == 0. */ - explicit LimitedErrorCountRetryPolicy(int maximum_failures) + explicit LimitedErrorCountAsyncRetryPolicy(int maximum_failures) : impl_(maximum_failures) {} - LimitedErrorCountRetryPolicy(LimitedErrorCountRetryPolicy&& rhs) noexcept - : LimitedErrorCountRetryPolicy(rhs.maximum_failures()) {} - LimitedErrorCountRetryPolicy(LimitedErrorCountRetryPolicy const& rhs) noexcept - : LimitedErrorCountRetryPolicy(rhs.maximum_failures()) {} + LimitedErrorCountAsyncRetryPolicy( + LimitedErrorCountAsyncRetryPolicy&& rhs) noexcept + : LimitedErrorCountAsyncRetryPolicy(rhs.maximum_failures()) {} + LimitedErrorCountAsyncRetryPolicy( + LimitedErrorCountAsyncRetryPolicy const& rhs) noexcept + : LimitedErrorCountAsyncRetryPolicy(rhs.maximum_failures()) {} int maximum_failures() const { return impl_.maximum_failures(); } @@ -84,7 +86,7 @@ class LimitedErrorCountRetryPolicy : public AsyncRetryPolicy { return impl_.IsPermanentFailure(s); } std::unique_ptr clone() const override { - return std::make_unique( + return std::make_unique( impl_.maximum_failures()); } @@ -92,7 +94,8 @@ class LimitedErrorCountRetryPolicy : public AsyncRetryPolicy { using BaseType = AsyncRetryPolicy; private: - google::cloud::internal::LimitedErrorCountRetryPolicy + google::cloud::internal::LimitedErrorCountRetryPolicy< + internal::AsyncStatusTraits> impl_; }; @@ -110,7 +113,7 @@ class LimitedErrorCountRetryPolicy : public AsyncRetryPolicy { * - [`kUnavailable`](@ref google::cloud::StatusCode) * - [`kAborted`](@ref google::cloud::StatusCode) */ -class LimitedTimeRetryPolicy : public AsyncRetryPolicy { +class LimitedTimeAsyncRetryPolicy : public AsyncRetryPolicy { public: /** * Constructor given a `std::chrono::duration<>` object. @@ -133,14 +136,14 @@ class LimitedTimeRetryPolicy : public AsyncRetryPolicy { * about `std::chrono::duration`. */ template - explicit LimitedTimeRetryPolicy( + explicit LimitedTimeAsyncRetryPolicy( std::chrono::duration maximum_duration) : impl_(maximum_duration) {} - LimitedTimeRetryPolicy(LimitedTimeRetryPolicy&& rhs) noexcept - : LimitedTimeRetryPolicy(rhs.maximum_duration()) {} - LimitedTimeRetryPolicy(LimitedTimeRetryPolicy const& rhs) noexcept - : LimitedTimeRetryPolicy(rhs.maximum_duration()) {} + LimitedTimeAsyncRetryPolicy(LimitedTimeAsyncRetryPolicy&& rhs) noexcept + : LimitedTimeAsyncRetryPolicy(rhs.maximum_duration()) {} + LimitedTimeAsyncRetryPolicy(LimitedTimeAsyncRetryPolicy const& rhs) noexcept + : LimitedTimeAsyncRetryPolicy(rhs.maximum_duration()) {} std::chrono::milliseconds maximum_duration() const { return impl_.maximum_duration(); @@ -152,14 +155,16 @@ class LimitedTimeRetryPolicy : public AsyncRetryPolicy { return impl_.IsPermanentFailure(s); } std::unique_ptr clone() const override { - return std::make_unique(impl_.maximum_duration()); + return std::make_unique( + impl_.maximum_duration()); } // This is provided only for backwards compatibility. using BaseType = RetryPolicy; private: - google::cloud::internal::LimitedTimeRetryPolicy impl_; + google::cloud::internal::LimitedTimeRetryPolicy + impl_; }; /// The backoff policy base class. @@ -175,7 +180,7 @@ struct AsyncRetryPolicyOption { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/retry_policy_test.cc b/google/cloud/storage/async/retry_policy_test.cc index 22168b98eef3e..41a0653d4aed0 100644 --- a/google/cloud/storage/async/retry_policy_test.cc +++ b/google/cloud/storage/async/retry_policy_test.cc @@ -17,50 +17,50 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace internal { namespace { TEST(RetryPolicyTest, PermanentFailure) { - EXPECT_TRUE(StatusTraits::IsPermanentFailure( + EXPECT_TRUE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kCancelled, "cancelled"))); - EXPECT_TRUE(StatusTraits::IsPermanentFailure( + EXPECT_TRUE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kUnknown, "unknown"))); - EXPECT_TRUE(StatusTraits::IsPermanentFailure( + EXPECT_TRUE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kInvalidArgument, "invalid argument"))); - EXPECT_TRUE(StatusTraits::IsPermanentFailure( + EXPECT_TRUE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kNotFound, "not found"))); - EXPECT_TRUE(StatusTraits::IsPermanentFailure( + EXPECT_TRUE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kAlreadyExists, "already exists"))); - EXPECT_TRUE(StatusTraits::IsPermanentFailure( + EXPECT_TRUE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kPermissionDenied, "permission denied"))); - EXPECT_TRUE(StatusTraits::IsPermanentFailure( + EXPECT_TRUE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kFailedPrecondition, "failed precondition"))); - EXPECT_TRUE(StatusTraits::IsPermanentFailure( + EXPECT_TRUE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kOutOfRange, "out of range"))); - EXPECT_TRUE(StatusTraits::IsPermanentFailure( + EXPECT_TRUE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kUnimplemented, "unimplemented"))); - EXPECT_TRUE(StatusTraits::IsPermanentFailure( + EXPECT_TRUE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kDataLoss, "data loss"))); - EXPECT_TRUE(StatusTraits::IsPermanentFailure( + EXPECT_TRUE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kUnauthenticated, "unauthenticated"))); - EXPECT_FALSE(StatusTraits::IsPermanentFailure( + EXPECT_FALSE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kDeadlineExceeded, "deadline exceeded"))); - EXPECT_FALSE(StatusTraits::IsPermanentFailure( + EXPECT_FALSE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kResourceExhausted, "resource exhausted"))); - EXPECT_FALSE(StatusTraits::IsPermanentFailure( + EXPECT_FALSE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kAborted, "aborted"))); - EXPECT_FALSE(StatusTraits::IsPermanentFailure( + EXPECT_FALSE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kInternal, "internal"))); - EXPECT_FALSE(StatusTraits::IsPermanentFailure( + EXPECT_FALSE(AsyncStatusTraits::IsPermanentFailure( Status(StatusCode::kUnavailable, "unavailable"))); } } // namespace } // namespace internal GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/rewriter.cc b/google/cloud/storage/async/rewriter.cc index d2a84a02a3c85..137ed03bef596 100644 --- a/google/cloud/storage/async/rewriter.cc +++ b/google/cloud/storage/async/rewriter.cc @@ -19,20 +19,21 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { template -future> TokenError(internal::ErrorInfoBuilder eib) { - return make_ready_future(StatusOr( - internal::InvalidArgumentError("invalid token", std::move(eib)))); +future> TokenError(google::cloud::internal::ErrorInfoBuilder eib) { + return make_ready_future( + StatusOr(google::cloud::internal::InvalidArgumentError( + "invalid token", std::move(eib)))); } template -future> NullImpl(internal::ErrorInfoBuilder eib) { - return make_ready_future( - StatusOr(internal::CancelledError("null impl", std::move(eib)))); +future> NullImpl(google::cloud::internal::ErrorInfoBuilder eib) { + return make_ready_future(StatusOr( + google::cloud::internal::CancelledError("null impl", std::move(eib)))); } using IterateResponse = @@ -60,6 +61,6 @@ future> AsyncRewriter::Iterate(AsyncToken token) { } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/rewriter.h b/google/cloud/storage/async/rewriter.h index 922b006eaa6fd..55c90a700a83c 100644 --- a/google/cloud/storage/async/rewriter.h +++ b/google/cloud/storage/async/rewriter.h @@ -30,7 +30,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -75,7 +75,7 @@ class AsyncRewriter { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/rewriter_connection.h b/google/cloud/storage/async/rewriter_connection.h index e7f9829e49e3d..08ee405707caf 100644 --- a/google/cloud/storage/async/rewriter_connection.h +++ b/google/cloud/storage/async/rewriter_connection.h @@ -22,7 +22,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -49,7 +49,7 @@ class AsyncRewriterConnection { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/rewriter_test.cc b/google/cloud/storage/async/rewriter_test.cc index 67b76a3665636..242f8b1d33cc4 100644 --- a/google/cloud/storage/async/rewriter_test.cc +++ b/google/cloud/storage/async/rewriter_test.cc @@ -22,7 +22,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -156,6 +156,6 @@ TEST(AsyncRewriter, ErrorWithMismatchedToken) { } // namespace GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/token.h b/google/cloud/storage/async/token.h index c413b604809e6..4333a7533891f 100644 --- a/google/cloud/storage/async/token.h +++ b/google/cloud/storage/async/token.h @@ -22,7 +22,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -83,7 +83,7 @@ class AsyncToken { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/token_test.cc b/google/cloud/storage/async/token_test.cc index c6adbe9a92243..c6eec94fe2188 100644 --- a/google/cloud/storage/async/token_test.cc +++ b/google/cloud/storage/async/token_test.cc @@ -19,7 +19,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -70,6 +70,6 @@ TEST(AsyncToken, MoveAssignment) { } // namespace GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/write_payload.h b/google/cloud/storage/async/write_payload.h index d8ec5e0c074a6..a0cbd08a1e154 100644 --- a/google/cloud/storage/async/write_payload.h +++ b/google/cloud/storage/async/write_payload.h @@ -26,7 +26,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -84,7 +84,7 @@ class WritePayload { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/writer.cc b/google/cloud/storage/async/writer.cc index 299b57ee860ee..85eb88d427c11 100644 --- a/google/cloud/storage/async/writer.cc +++ b/google/cloud/storage/async/writer.cc @@ -20,20 +20,21 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { template -future> TokenError(internal::ErrorInfoBuilder eib) { - return make_ready_future(StatusOr( - internal::InvalidArgumentError("invalid token", std::move(eib)))); +future> TokenError(google::cloud::internal::ErrorInfoBuilder eib) { + return make_ready_future( + StatusOr(google::cloud::internal::InvalidArgumentError( + "invalid token", std::move(eib)))); } template -future> StreamError(internal::ErrorInfoBuilder eib) { - return make_ready_future( - StatusOr(internal::CancelledError("closed stream", std::move(eib)))); +future> StreamError(google::cloud::internal::ErrorInfoBuilder eib) { + return make_ready_future(StatusOr(google::cloud::internal::CancelledError( + "closed stream", std::move(eib)))); } } // namespace @@ -88,8 +89,8 @@ future> AsyncWriter::Finalize( future AsyncWriter::Flush() { if (!impl_) { - return make_ready_future( - internal::CancelledError("closed stream", GCP_ERROR_INFO())); + return make_ready_future(google::cloud::internal::CancelledError( + "closed stream", GCP_ERROR_INFO())); } return impl_->Flush(WritePayload{}).then([impl = impl_](auto f) { @@ -99,8 +100,8 @@ future AsyncWriter::Flush() { future AsyncWriter::Close() { if (!impl_) { - return make_ready_future( - internal::CancelledError("closed stream", GCP_ERROR_INFO())); + return make_ready_future(google::cloud::internal::CancelledError( + "closed stream", GCP_ERROR_INFO())); } return impl_->Flush(WritePayload{}).then([impl = std::move(impl_)](auto f) { @@ -113,6 +114,6 @@ RpcMetadata AsyncWriter::GetRequestMetadata() const { } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/writer.h b/google/cloud/storage/async/writer.h index b012ef97f407b..ed83d449367ff 100644 --- a/google/cloud/storage/async/writer.h +++ b/google/cloud/storage/async/writer.h @@ -29,7 +29,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -158,7 +158,7 @@ class AsyncWriter { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/writer_connection.h b/google/cloud/storage/async/writer_connection.h index e921b7942b855..6c72f19b6728e 100644 --- a/google/cloud/storage/async/writer_connection.h +++ b/google/cloud/storage/async/writer_connection.h @@ -29,7 +29,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /** @@ -145,7 +145,7 @@ struct BufferedUploadLwmOption { }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/async/writer_test.cc b/google/cloud/storage/async/writer_test.cc index 6404e039b490d..fc5e57eee282d 100644 --- a/google/cloud/storage/async/writer_test.cc +++ b/google/cloud/storage/async/writer_test.cc @@ -23,12 +23,11 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { using ::google::cloud::storage::testing::canonical_errors::PermanentError; -using ::google::cloud::storage_experimental::WritePayload; using ::google::cloud::storage_mocks::MockAsyncWriterConnection; using ::google::cloud::testing_util::StatusIs; using ::testing::ElementsAre; @@ -281,8 +280,7 @@ TEST(AsyncWriterTest, ErrorWithInvalidToken) { auto mock = std::make_unique(); AsyncWriter writer(std::move(mock)); - auto const actual = - writer.Write(storage_experimental::AsyncToken(), WritePayload{}).get(); + auto const actual = writer.Write(AsyncToken(), WritePayload{}).get(); EXPECT_THAT(actual, StatusIs(StatusCode::kInvalidArgument)); } @@ -300,6 +298,6 @@ TEST(AsyncWriterTest, ErrorWithMismatchedToken) { } // namespace GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/benchmarks/async_throughput_benchmark.cc b/google/cloud/storage/benchmarks/async_throughput_benchmark.cc index ec6a0c044f6f6..bf2ac557b287c 100644 --- a/google/cloud/storage/benchmarks/async_throughput_benchmark.cc +++ b/google/cloud/storage/benchmarks/async_throughput_benchmark.cc @@ -52,7 +52,7 @@ namespace { auto constexpr kDescription = R"""( This program benchmarks concurrent uploads to and downloads from Google Cloud -Storage (GCS) using the `google::cloud::storage_experimental::AsyncClient APIs. +Storage (GCS) using the `google::cloud::storage::AsyncClient APIs. The benchmark tries to answer the following questions: @@ -172,7 +172,6 @@ benchmark results against the implementation in other languages. namespace g = google::cloud; namespace gcs = google::cloud::storage; -namespace gcs_ex = google::cloud::storage_experimental; using ::google::cloud::storage_benchmarks::kMiB; @@ -311,14 +310,14 @@ auto MapPath(std::string_view path) { auto MakeAsyncClients(Configuration const& cfg, std::set const& clients, int background_threads) { - std::map result; + std::map result; for (auto const& cc : clients) { if (cc.client != kAsyncClientName) continue; result.emplace( - cc, gcs_ex::AsyncClient(g::Options() - .set( - background_threads) - .set(MapPath(cc.path)))); + cc, gcs::AsyncClient(g::Options() + .set( + background_threads) + .set(MapPath(cc.path)))); } return result; } @@ -494,13 +493,13 @@ Result MakeErrorResult(Configuration const& cfg, IterationConfig iteration, g::future DownloadOne(Configuration const& cfg, IterationConfig iteration, int repeat, - gcs_ex::AsyncClient client, + gcs::AsyncClient client, std::chrono::system_clock::time_point batch_start, std::string object_name) try { auto const transfer_start = std::chrono::system_clock::now(); auto const start = std::chrono::steady_clock::now(); auto [reader, token] = - (co_await client.ReadObject(gcs_ex::BucketName(cfg.bucket), object_name)) + (co_await client.ReadObject(gcs::BucketName(cfg.bucket), object_name)) .value(); std::int64_t generation = 0; @@ -525,7 +524,7 @@ g::future DownloadOne(Configuration const& cfg, g::future Download(Configuration const& cfg, IterationConfig iteration, int repeat, - gcs_ex::AsyncClient client, + gcs::AsyncClient client, std::vector object_names) { std::vector> batch; auto const batch_start = std::chrono::system_clock::now(); @@ -538,17 +537,17 @@ g::future Download(Configuration const& cfg, } g::future UploadOne(Configuration const& cfg, IterationConfig iteration, - int repeat, gcs_ex::AsyncClient client, + int repeat, gcs::AsyncClient client, std::chrono::system_clock::time_point batch_start, std::shared_ptr data, std::string object_name) try { auto const transfer_start = std::chrono::system_clock::now(); auto const start = std::chrono::steady_clock::now(); auto [writer, token] = (co_await client.StartUnbufferedUpload( - gcs_ex::BucketName(cfg.bucket), object_name)) + gcs::BucketName(cfg.bucket), object_name)) .value(); - using google::cloud::storage_experimental::WritePayload; + using google::cloud::storage::WritePayload; for (auto remaining = iteration.transfer_size; remaining != 0;) { if (!token.valid()) break; auto const n = @@ -573,7 +572,7 @@ g::future UploadOne(Configuration const& cfg, IterationConfig iteration, g::future Upload(Configuration const& cfg, IterationConfig iteration, int repeat, - gcs_ex::AsyncClient client, + gcs::AsyncClient client, std::shared_ptr data, std::vector object_names) { std::vector> batch; @@ -766,15 +765,15 @@ void RunBenchmark(Configuration const& cfg) { std::cout << Header() << "\n"; auto last_upload = std::chrono::steady_clock::now(); - auto delete_client = gcs_ex::AsyncClient(); + auto delete_client = gcs::AsyncClient(); std::vector> pending_deletes; - auto delete_all = [](gcs_ex::AsyncClient client, std::string bucket, + auto delete_all = [](gcs::AsyncClient client, std::string bucket, std::vector names) -> g::future { std::vector> pending(names.size()); - std::transform( - names.begin(), names.end(), pending.begin(), [&](auto const& name) { - return client.DeleteObject(gcs_ex::BucketName(bucket), name); - }); + std::transform(names.begin(), names.end(), pending.begin(), + [&](auto const& name) { + return client.DeleteObject(gcs::BucketName(bucket), name); + }); names.clear(); for (auto& p : pending) co_await std::move(p); }; @@ -953,7 +952,7 @@ int main(int argc, char* argv[]) try { #include int main() { - std::cout << "The storage_experimental::AsyncClient benchmarks require" + std::cout << "The storage::AsyncClient benchmarks require" << " C++20 coroutines and the GCS+gRPC plugin\n"; return 0; } diff --git a/google/cloud/storage/internal/async/connection_impl.cc b/google/cloud/storage/internal/async/connection_impl.cc index 4881a4eefc2f6..32ae9a4e9f0e0 100644 --- a/google/cloud/storage/internal/async/connection_impl.cc +++ b/google/cloud/storage/internal/async/connection_impl.cc @@ -64,42 +64,39 @@ namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { -inline std::unique_ptr retry_policy( +inline std::unique_ptr retry_policy( Options const& options) { - return options.get()->clone(); + return options.get()->clone(); } inline std::unique_ptr backoff_policy(Options const& options) { return options.get()->clone(); } -inline std::unique_ptr -idempotency_policy(Options const& options) { - return options.get()(); +inline std::unique_ptr idempotency_policy( + Options const& options) { + return options.get()(); } std::unique_ptr CreateHashFunction( Options const& options) { auto crc32c = std::unique_ptr(); - if (options.has()) { + if (options.has()) { crc32c = std::make_unique( storage::internal::HashValues{ - Crc32cFromProto( - options.get()), + Crc32cFromProto(options.get()), /*.md5=*/{}}); - } else if (options - .get()) { + } else if (options.get()) { crc32c = std::make_unique(); } auto md5 = std::unique_ptr(); - if (options.has()) { + if (options.has()) { md5 = std::make_unique( storage::internal::HashValues{ /*.crc32=*/{}, - MD5FromProto( - options.get())}); - } else if (options.get()) { + MD5FromProto(options.get())}); + } else if (options.get()) { md5 = storage::internal::MD5HashFunction::Create(); } @@ -120,9 +117,8 @@ std::unique_ptr CreateHashValidator( if (is_ranged_read) return storage::internal::CreateNullHashValidator(); auto const enable_crc32c = - options.get(); - auto const enable_md5 = - options.get(); + options.get(); + auto const enable_md5 = options.get(); if (enable_crc32c && enable_md5) { return std::make_unique( @@ -191,18 +187,16 @@ future> AsyncConnectionImpl::InsertObject( std::move(current), std::move(request), __func__); } -future< - StatusOr>> +future>> AsyncConnectionImpl::Open(OpenParams p) { auto initial_request = google::storage::v2::BidiReadObjectRequest{}; *initial_request.mutable_read_object_spec() = p.read_spec; auto current = internal::MakeImmutableOptions(p.options); // Get the policy factory and immediately create a policy. - auto resume_policy = - current->get()(); + auto resume_policy = current->get()(); - auto retry = std::shared_ptr( - retry_policy(*current)); + auto retry = + std::shared_ptr(retry_policy(*current)); auto backoff = std::shared_ptr(backoff_policy(*current)); auto const* function_name = __func__; @@ -236,8 +230,7 @@ AsyncConnectionImpl::Open(OpenParams p) { }); auto pending = factory(std::move(initial_request)); - using ReturnType = - std::shared_ptr; + using ReturnType = std::shared_ptr; return pending.then( [rp = std::move(resume_policy), fa = std::move(factory), rs = std::move(p.read_spec), @@ -253,15 +246,13 @@ AsyncConnectionImpl::Open(OpenParams p) { }); } -future>> +future>> AsyncConnectionImpl::ReadObject(ReadObjectParams p) { - using ReturnType = - StatusOr>; + using ReturnType = StatusOr>; auto current = internal::MakeImmutableOptions(std::move(p.options)); // Get the policy factory and immediately create a policy. - auto resume_policy = - current->get()(); + auto resume_policy = current->get()(); // Create the hash function and validator based on the original request. Note // that p.request will be moved-from, so we have to do it relatively early in // this function. @@ -279,40 +270,40 @@ AsyncConnectionImpl::ReadObject(ReadObjectParams p) { return make_ready_future(ReturnType(std::move(connection))); } -future> -AsyncConnectionImpl::ReadObjectRange(ReadObjectParams p) { +future> AsyncConnectionImpl::ReadObjectRange( + ReadObjectParams p) { return ReadObject(std::move(p)) - .then([](auto f) -> future> { + .then([](auto f) -> future> { auto r = f.get(); if (!r) { - return make_ready_future(StatusOr( - std::move(r).status())); + return make_ready_future( + StatusOr(std::move(r).status())); } auto token = storage_internal::MakeAsyncToken(r->get()); - return storage_experimental::ReadAll( - storage_experimental::AsyncReader(*std::move(r)), std::move(token)); + return storage::ReadAll(storage::AsyncReader(*std::move(r)), + std::move(token)); }); } -future>> +future>> AsyncConnectionImpl::StartAppendableObjectUpload(AppendableUploadParams p) { return AppendableObjectUploadImpl(std::move(p)); } -future>> +future>> AsyncConnectionImpl::ResumeAppendableObjectUpload(AppendableUploadParams p) { return AppendableObjectUploadImpl(std::move(p)); } -future>> +future>> AsyncConnectionImpl::AppendableObjectUploadImpl(AppendableUploadParams p) { auto current = internal::MakeImmutableOptions(std::move(p.options)); auto request = p.request; std::int64_t persisted_size = 0; std::shared_ptr hash_function = CreateHashFunction(*current); - auto retry = std::shared_ptr( - retry_policy(*current)); + auto retry = + std::shared_ptr(retry_policy(*current)); auto backoff = std::shared_ptr(backoff_policy(*current)); using StreamingRpcTimeout = @@ -380,8 +371,7 @@ AsyncConnectionImpl::AppendableObjectUploadImpl(AppendableUploadParams p) { return pending.then( [current, request = std::move(p.request), persisted_size, hash = std::move(hash_function), fa = std::move(factory)](auto f) mutable - -> StatusOr< - std::unique_ptr> { + -> StatusOr> { auto rpc = f.get(); if (!rpc) return std::move(rpc).status(); std::unique_ptr impl; @@ -401,7 +391,7 @@ AsyncConnectionImpl::AppendableObjectUploadImpl(AppendableUploadParams p) { }); } -future>> +future>> AsyncConnectionImpl::StartUnbufferedUpload(UploadParams p) { auto current = internal::MakeImmutableOptions(std::move(p.options)); @@ -414,12 +404,12 @@ AsyncConnectionImpl::StartUnbufferedUpload(UploadParams p) { std::move(request), f.get()); } return make_ready_future( - StatusOr>( + StatusOr>( internal::CancelledError("Cannot lock self", GCP_ERROR_INFO()))); }); } -future>> +future>> AsyncConnectionImpl::StartBufferedUpload(UploadParams p) { auto current = internal::MakeImmutableOptions(p.options); auto async_write_object = [c = current, start = p.request, @@ -431,14 +421,13 @@ AsyncConnectionImpl::StartBufferedUpload(UploadParams p) { start.common_object_request_params(); if (auto self = w.lock()) return self->ResumeUpload(c, std::move(query)); return make_ready_future( - StatusOr>{ + StatusOr>{ internal::CancelledError("Cannot lock self", GCP_ERROR_INFO())}); }; return StartUnbufferedUpload(std::move(p)) .then([current = std::move(current), async_write_object = std::move(async_write_object)](auto f) mutable - -> StatusOr< - std::unique_ptr> { + -> StatusOr> { auto w = f.get(); if (!w) return std::move(w).status(); auto factory = [upload_id = (*w)->UploadId(), @@ -450,13 +439,13 @@ AsyncConnectionImpl::StartBufferedUpload(UploadParams p) { }); } -future>> +future>> AsyncConnectionImpl::ResumeUnbufferedUpload(ResumeUploadParams p) { auto current = internal::MakeImmutableOptions(std::move(p.options)); return ResumeUpload(current, std::move(p.request)); } -future>> +future>> AsyncConnectionImpl::ResumeBufferedUpload(ResumeUploadParams p) { auto current = internal::MakeImmutableOptions(std::move(p.options)); // This is a factory to create unbuffered writer connections. We will call @@ -467,21 +456,19 @@ AsyncConnectionImpl::ResumeBufferedUpload(ResumeUploadParams p) { w = WeakFromThis()]() mutable { if (auto self = w.lock()) return self->ResumeUpload(c, std::move(query)); return make_ready_future( - StatusOr>{ + StatusOr>{ internal::CancelledError("Cannot lock self", GCP_ERROR_INFO())}); }; auto f = make_unbuffered(); - return f.then( - [current = std::move(current), - make_unbuffered = std::move(make_unbuffered)](auto f) mutable - -> StatusOr< - std::unique_ptr> { - auto w = f.get(); - if (!w) return std::move(w).status(); - return MakeWriterConnectionBuffered(std::move(make_unbuffered), - *std::move(w), *current); - }); + return f.then([current = std::move(current), + make_unbuffered = std::move(make_unbuffered)](auto f) mutable + -> StatusOr> { + auto w = f.get(); + if (!w) return std::move(w).status(); + return MakeWriterConnectionBuffered(std::move(make_unbuffered), + *std::move(w), *current); + }); } future> @@ -522,7 +509,7 @@ future AsyncConnectionImpl::DeleteObject(DeleteObjectParams p) { std::move(current), std::move(p.request), __func__); } -std::shared_ptr +std::shared_ptr AsyncConnectionImpl::RewriteObject(RewriteObjectParams p) { auto current = internal::MakeImmutableOptions(std::move(p.options)); @@ -579,11 +566,10 @@ AsyncReaderConnectionFactory AsyncConnectionImpl::MakeReaderConnectionFactory( // Make this mutable, because it is called only once and we can // `std::move()` the captured values. auto transform = [current, hash_function](auto f) mutable - -> StatusOr< - std::unique_ptr> { + -> StatusOr> { auto rpc = f.get(); if (!rpc) return std::move(rpc).status(); - return std::unique_ptr( + return std::unique_ptr( std::make_unique( std::move(current), *std::move(rpc), std::move(hash_function))); }; @@ -647,7 +633,7 @@ AsyncConnectionImpl::QueryWriteStatus( } // Combines a call to QueryWriteStatus and creates an unbuffered upload. -future>> +future>> AsyncConnectionImpl::ResumeUpload( internal::ImmutableOptions current, google::storage::v2::QueryWriteStatusRequest query) { @@ -660,19 +646,19 @@ AsyncConnectionImpl::ResumeUpload( f.get()); } return make_ready_future( - StatusOr>( + StatusOr>( internal::CancelledError("Cannot lock self", GCP_ERROR_INFO()))); }); } -future>> +future>> AsyncConnectionImpl::StartUnbufferedUploadImpl( internal::ImmutableOptions current, google::storage::v2::StartResumableWriteRequest request, StatusOr response) { if (!response) { return make_ready_future( - StatusOr>( + StatusOr>( std::move(response).status())); } auto hash_function = CreateHashFunction(*current); @@ -690,19 +676,19 @@ AsyncConnectionImpl::StartUnbufferedUploadImpl( std::move(proto), std::move(hash_function), 0); } -future>> +future>> AsyncConnectionImpl::ResumeUnbufferedUploadImpl( internal::ImmutableOptions current, google::storage::v2::QueryWriteStatusRequest query, StatusOr response) { if (!response) { return make_ready_future( - StatusOr>( + StatusOr>( std::move(response).status())); } if (response->has_resource()) { return make_ready_future( - StatusOr>( + StatusOr>( std::make_unique( std::move(*query.mutable_upload_id()), std::move(*response->mutable_resource())))); @@ -729,7 +715,7 @@ AsyncConnectionImpl::ResumeUnbufferedUploadImpl( response->persisted_size()); } -future>> +future>> AsyncConnectionImpl::UnbufferedUploadImpl( internal::ImmutableOptions current, std::function configure_context, @@ -773,11 +759,10 @@ AsyncConnectionImpl::UnbufferedUploadImpl( auto transform = [current, request = std::move(request), persisted_size, hash = std::move(hash_function)](auto f) mutable - -> StatusOr< - std::unique_ptr> { + -> StatusOr> { auto rpc = f.get(); if (!rpc) return std::move(rpc).status(); - return std::unique_ptr( + return std::unique_ptr( std::make_unique( current, std::move(request), *std::move(rpc), std::move(hash), persisted_size, true)); @@ -792,7 +777,7 @@ AsyncConnectionImpl::UnbufferedUploadImpl( .then(std::move(transform)); } -std::shared_ptr MakeAsyncConnection( +std::shared_ptr MakeAsyncConnection( CompletionQueue cq, Options options) { options = DefaultOptionsAsync(std::move(options)); EnableGrpcMetrics(options); @@ -802,7 +787,7 @@ std::shared_ptr MakeAsyncConnection( std::move(options)); } -std::shared_ptr MakeAsyncConnection( +std::shared_ptr MakeAsyncConnection( CompletionQueue cq, std::shared_ptr stub, Options options) { return std::make_shared( std::move(cq), std::shared_ptr{}, std::move(stub), diff --git a/google/cloud/storage/internal/async/connection_impl.h b/google/cloud/storage/internal/async/connection_impl.h index b3afe674e93b9..ad83d3ce098d9 100644 --- a/google/cloud/storage/internal/async/connection_impl.h +++ b/google/cloud/storage/internal/async/connection_impl.h @@ -46,7 +46,7 @@ class GrpcChannelRefresh; class StorageStub; class AsyncConnectionImpl - : public storage_experimental::AsyncConnection, + : public storage::AsyncConnection, public std::enable_shared_from_this { public: explicit AsyncConnectionImpl(CompletionQueue cq, @@ -60,32 +60,31 @@ class AsyncConnectionImpl future> InsertObject( InsertObjectParams p) override; - future>> - Open(OpenParams p) override; + future>> Open( + OpenParams p) override; - future>> - ReadObject(ReadObjectParams p) override; + future>> ReadObject( + ReadObjectParams p) override; - future> ReadObjectRange( + future> ReadObjectRange( ReadObjectParams p) override; - future>> + future>> StartAppendableObjectUpload(AppendableUploadParams p) override; - future>> + future>> ResumeAppendableObjectUpload(AppendableUploadParams p) override; - future>> + future>> StartUnbufferedUpload(UploadParams p) override; - future>> + future>> StartBufferedUpload(UploadParams p) override; - future>> + future>> ResumeUnbufferedUpload(ResumeUploadParams p) override; - future>> + future>> ResumeBufferedUpload(ResumeUploadParams p) override; future> ComposeObject( @@ -93,7 +92,7 @@ class AsyncConnectionImpl future DeleteObject(DeleteObjectParams p) override; - std::shared_ptr RewriteObject( + std::shared_ptr RewriteObject( RewriteObjectParams p) override; // Expose this function for testing purposes. It creates a factory to create @@ -116,23 +115,23 @@ class AsyncConnectionImpl QueryWriteStatus(internal::ImmutableOptions current, google::storage::v2::QueryWriteStatusRequest request); - future>> + future>> ResumeUpload(internal::ImmutableOptions current, google::storage::v2::QueryWriteStatusRequest query); - future>> + future>> StartUnbufferedUploadImpl( internal::ImmutableOptions current, google::storage::v2::StartResumableWriteRequest request, StatusOr response); - future>> + future>> ResumeUnbufferedUploadImpl( internal::ImmutableOptions current, google::storage::v2::QueryWriteStatusRequest query, StatusOr response); - future>> + future>> UnbufferedUploadImpl( internal::ImmutableOptions current, std::function configure_context, @@ -140,7 +139,7 @@ class AsyncConnectionImpl std::shared_ptr hash_function, std::int64_t persisted_size); - future>> + future>> AppendableObjectUploadImpl(AppendableUploadParams p); CompletionQueue cq_; @@ -151,11 +150,11 @@ class AsyncConnectionImpl }; /// Create a connection and the default stub. -std::shared_ptr MakeAsyncConnection( +std::shared_ptr MakeAsyncConnection( CompletionQueue cq, Options options = Options{}); /// Create a connection with a custom stub (usually a mock). -std::shared_ptr MakeAsyncConnection( +std::shared_ptr MakeAsyncConnection( CompletionQueue cq, std::shared_ptr stub, Options options); GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END diff --git a/google/cloud/storage/internal/async/connection_impl_appendable_upload_test.cc b/google/cloud/storage/internal/async/connection_impl_appendable_upload_test.cc index 9252445c15a12..85ce51a10f31d 100644 --- a/google/cloud/storage/internal/async/connection_impl_appendable_upload_test.cc +++ b/google/cloud/storage/internal/async/connection_impl_appendable_upload_test.cc @@ -55,15 +55,15 @@ auto TestOptions(Options options = {}) { std::move(options), Options{} .set(1) - .set( - storage_experimental::LimitedErrorCountRetryPolicy(2).clone()) + .set( + storage::LimitedErrorCountAsyncRetryPolicy(2).clone()) .set( storage::ExponentialBackoffPolicy(ms(1), ms(2), 2.0).clone())); return DefaultOptionsAsync(std::move(options)); } // Creates a test connection with a mock stub. -std::shared_ptr MakeTestConnection( +std::shared_ptr MakeTestConnection( CompletionQueue cq, std::shared_ptr mock, Options options = {}) { return MakeAsyncConnection(std::move(cq), std::move(mock), @@ -206,7 +206,7 @@ TEST_F(AsyncConnectionImplAppendableTest, StartAppendableObjectUploadSuccess) { // An empty payload might be a no-op in the implementation, which would // prevent the mock from being triggered and cause the sequencer to hang. // We provide a non-empty payload to ensure the Write RPC is sent. - auto w1 = writer->Write(storage_experimental::WritePayload("some data")); + auto w1 = writer->Write(storage::WritePayload("some data")); next = sequencer.PopFrontWithName(); EXPECT_EQ(next.second, "Write(data)"); next.first.set_value(true); @@ -272,7 +272,7 @@ TEST_F(AsyncConnectionImplAppendableTest, ResumeAppendableObjectUploadSuccess) { // Verify the persisted state is correctly reported. EXPECT_EQ(absl::get(writer->PersistedState()), kPersistedSize); - auto w1 = writer->Write(storage_experimental::WritePayload("some more data")); + auto w1 = writer->Write(storage::WritePayload("some more data")); next = sequencer.PopFrontWithName(); EXPECT_EQ(next.second, "Write(data)"); next.first.set_value(true); diff --git a/google/cloud/storage/internal/async/connection_impl_insert_test.cc b/google/cloud/storage/internal/async/connection_impl_insert_test.cc index 1091b751fd62b..ac314fc898a0c 100644 --- a/google/cloud/storage/internal/async/connection_impl_insert_test.cc +++ b/google/cloud/storage/internal/async/connection_impl_insert_test.cc @@ -73,14 +73,14 @@ auto TestOptions(Options options = {}) { std::move(options), Options{} .set(1) - .set( - storage_experimental::LimitedErrorCountRetryPolicy(2).clone()) + .set( + storage::LimitedErrorCountAsyncRetryPolicy(2).clone()) .set( storage::ExponentialBackoffPolicy(ms(1), ms(2), 2.0).clone())); return DefaultOptionsAsync(std::move(options)); } -std::shared_ptr MakeTestConnection( +std::shared_ptr MakeTestConnection( CompletionQueue cq, std::shared_ptr mock, Options options = {}) { return MakeAsyncConnection(std::move(cq), std::move(mock), @@ -177,9 +177,9 @@ TEST_F(AsyncConnectionImplTest, AsyncInsertObject) { std::chrono::seconds(0))); auto request = google::storage::v2::WriteObjectRequest{}; ASSERT_TRUE(TextFormat::ParseFromString(kExpectedRequest, &request)); - auto pending = connection->InsertObject({std::move(request), - storage_experimental::WritePayload(), - /*.options=*/connection->options()}); + auto pending = + connection->InsertObject({std::move(request), storage::WritePayload(), + /*.options=*/connection->options()}); // Simulate a transient failure. auto next = sequencer.PopFrontWithName(); @@ -253,10 +253,9 @@ TEST_F(AsyncConnectionImplTest, AsyncInsertObjectWithTimeout) { Options{} .set(std::chrono::seconds(1)) .set(2 * 1024 * 1024L)); - auto pending = - connection->InsertObject({google::storage::v2::WriteObjectRequest{}, - storage_experimental::WritePayload(), - /*.options=*/connection->options()}); + auto pending = connection->InsertObject( + {google::storage::v2::WriteObjectRequest{}, storage::WritePayload(), + /*.options=*/connection->options()}); // Because the timeout parameters are configured, the first thing to happen is // that a timer is set. @@ -293,10 +292,9 @@ TEST_F(AsyncConnectionImplTest, AsyncInsertObjectPermanentError) { internal::AutomaticallyCreatedBackgroundThreads pool(1); auto connection = MakeTestConnection(pool.cq(), mock); - auto pending = - connection->InsertObject({google::storage::v2::WriteObjectRequest{}, - storage_experimental::WritePayload(), - /*.options=*/connection->options()}); + auto pending = connection->InsertObject( + {google::storage::v2::WriteObjectRequest{}, storage::WritePayload(), + /*.options=*/connection->options()}); auto next = sequencer.PopFrontWithName(); EXPECT_EQ(next.second, "Start"); @@ -318,14 +316,13 @@ TEST_F(AsyncConnectionImplTest, AsyncInsertObjectTooManyTransients) { }); internal::AutomaticallyCreatedBackgroundThreads pool(1); - auto connection = MakeTestConnection( - pool.cq(), mock, - Options{}.set( - storage_experimental::MakeAlwaysRetryIdempotencyPolicy)); - auto pending = - connection->InsertObject({google::storage::v2::WriteObjectRequest{}, - storage_experimental::WritePayload(), - /*.options=*/connection->options()}); + auto connection = + MakeTestConnection(pool.cq(), mock, + Options{}.set( + storage::MakeAlwaysRetryAsyncIdempotencyPolicy)); + auto pending = connection->InsertObject( + {google::storage::v2::WriteObjectRequest{}, storage::WritePayload(), + /*.options=*/connection->options()}); for (int i = 0; i != 3; ++i) { auto next = sequencer.PopFrontWithName(); diff --git a/google/cloud/storage/internal/async/connection_impl_open_test.cc b/google/cloud/storage/internal/async/connection_impl_open_test.cc index 6d72d6f40a6ea..57b46d9493fe4 100644 --- a/google/cloud/storage/internal/async/connection_impl_open_test.cc +++ b/google/cloud/storage/internal/async/connection_impl_open_test.cc @@ -66,10 +66,10 @@ auto TestOptions(Options options = {}) { // By default, disable timeouts, most tests are simpler without them. .set(std::chrono::seconds(0)) // By default, disable resumes, most tests are simpler without them. - .set( - storage_experimental::LimitedErrorCountResumePolicy(0)) - .set( - storage_experimental::LimitedErrorCountRetryPolicy(kRetryAttempts) + .set( + storage::LimitedErrorCountResumePolicy(0)) + .set( + storage::LimitedErrorCountAsyncRetryPolicy(kRetryAttempts) .clone()) .set( storage::ExponentialBackoffPolicy(ms(1), ms(2), 2.0).clone())); diff --git a/google/cloud/storage/internal/async/connection_impl_read_hash_test.cc b/google/cloud/storage/internal/async/connection_impl_read_hash_test.cc index d0816c50fbff4..4638a4b486014 100644 --- a/google/cloud/storage/internal/async/connection_impl_read_hash_test.cc +++ b/google/cloud/storage/internal/async/connection_impl_read_hash_test.cc @@ -77,16 +77,15 @@ std::ostream& operator<<(std::ostream& os, HashTestCase const& rhs) { os << "expected_status_code=" << rhs.expected_status_code // << std::boolalpha // << ", enable_crc32c_validation=" - << rhs.options.get(); - if (rhs.options.has()) { + << rhs.options.get(); + if (rhs.options.has()) { os << ", use_crc32_value=" - << rhs.options.get(); + << rhs.options.get(); } os << ", enable_md5_validation=" - << rhs.options.get(); - if (rhs.options.has()) { - os << ", use_md5_value=" - << rhs.options.get(); + << rhs.options.get(); + if (rhs.options.has()) { + os << ", use_md5_value=" << rhs.options.get(); } os << "}, generated={" << google::cloud::internal::DebugString(GeneratedObjectChecksums(rhs), @@ -131,105 +130,92 @@ INSTANTIATE_TEST_SUITE_P( // service returns both CRC32C and MD5 values. StatusCode::kOk, Options{} - .set(true) - .set(false), + .set(true) + .set(false), kQuickFoxCrc32cChecksum, kQuickFoxMD5Hash}, HashTestCase{ // This is also common, the service does not return a MD5 value. StatusCode::kOk, Options{} - .set(true) - .set(false), + .set(true) + .set(false), kQuickFoxCrc32cChecksum, ""}, // Make sure things work when both hashes are validated too. - HashTestCase{ - StatusCode::kOk, - Options{} - .set(true) - .set(true), - kQuickFoxCrc32cChecksum, kQuickFoxMD5Hash}, + HashTestCase{StatusCode::kOk, + Options{} + .set(true) + .set(true), + kQuickFoxCrc32cChecksum, kQuickFoxMD5Hash}, // In the next three cases we verify that disabling some validation // works. - HashTestCase{ - StatusCode::kOk, - Options{} - .set(true) - .set(false), - kQuickFoxCrc32cChecksum, kQuickFoxMD5HashBad}, - HashTestCase{ - StatusCode::kOk, - Options{} - .set(false) - .set(true), - kQuickFoxCrc32cChecksumBad, kQuickFoxMD5Hash}, - HashTestCase{ - StatusCode::kOk, - Options{} - .set(false) - .set(false), - kQuickFoxCrc32cChecksumBad, kQuickFoxMD5HashBad}, + HashTestCase{StatusCode::kOk, + Options{} + .set(true) + .set(false), + kQuickFoxCrc32cChecksum, kQuickFoxMD5HashBad}, + HashTestCase{StatusCode::kOk, + Options{} + .set(false) + .set(true), + kQuickFoxCrc32cChecksumBad, kQuickFoxMD5Hash}, + HashTestCase{StatusCode::kOk, + Options{} + .set(false) + .set(false), + kQuickFoxCrc32cChecksumBad, kQuickFoxMD5HashBad}, // In the next three cases we verify that validation works when the // returned values are not correct. - HashTestCase{ - StatusCode::kInvalidArgument, - Options{} - .set(false) - .set(true), - kQuickFoxCrc32cChecksumBad, kQuickFoxMD5HashBad}, - HashTestCase{ - StatusCode::kInvalidArgument, - Options{} - .set(true) - .set(false), - kQuickFoxCrc32cChecksumBad, kQuickFoxMD5HashBad}, - HashTestCase{ - StatusCode::kInvalidArgument, - Options{} - .set(true) - .set(true), - kQuickFoxCrc32cChecksumBad, kQuickFoxMD5HashBad}, + HashTestCase{StatusCode::kInvalidArgument, + Options{} + .set(false) + .set(true), + kQuickFoxCrc32cChecksumBad, kQuickFoxMD5HashBad}, + HashTestCase{StatusCode::kInvalidArgument, + Options{} + .set(true) + .set(false), + kQuickFoxCrc32cChecksumBad, kQuickFoxMD5HashBad}, + HashTestCase{StatusCode::kInvalidArgument, + Options{} + .set(true) + .set(true), + kQuickFoxCrc32cChecksumBad, kQuickFoxMD5HashBad}, // The application may know what the values should be. Verify the // validation works correctly when the application provides correct // values. HashTestCase{ StatusCode::kOk, Options{} - .set(true) - .set(true) - .set( - kQuickFoxCrc32cChecksum) - .set( - BinaryMD5(kQuickFoxMD5Hash)), + .set(true) + .set(true) + .set(kQuickFoxCrc32cChecksum) + .set(BinaryMD5(kQuickFoxMD5Hash)), kQuickFoxCrc32cChecksum, kQuickFoxMD5Hash}, // Verify bad values are detected HashTestCase{ StatusCode::kInvalidArgument, Options{} - .set(true) - .set(true) - .set( - kQuickFoxCrc32cChecksumBad) - .set( - BinaryMD5(kQuickFoxMD5Hash)), + .set(true) + .set(true) + .set(kQuickFoxCrc32cChecksumBad) + .set(BinaryMD5(kQuickFoxMD5Hash)), kQuickFoxCrc32cChecksum, kQuickFoxMD5Hash}, HashTestCase{ StatusCode::kInvalidArgument, Options{} - .set(true) - .set(true) - .set( - kQuickFoxCrc32cChecksum) - .set( + .set(true) + .set(true) + .set(kQuickFoxCrc32cChecksum) + .set( BinaryMD5(kQuickFoxMD5HashBad)), kQuickFoxCrc32cChecksum, kQuickFoxMD5Hash}, HashTestCase{ StatusCode::kInvalidArgument, Options{} - .set(true) - .set(true) - .set( - kQuickFoxCrc32cChecksumBad) - .set( + .set(true) + .set(true) + .set(kQuickFoxCrc32cChecksumBad) + .set( BinaryMD5(kQuickFoxMD5HashBad)), kQuickFoxCrc32cChecksum, kQuickFoxMD5Hash})); @@ -299,7 +285,7 @@ TEST_P(AsyncConnectionImplReadHashTest, ValidateFullChecksums) { next = sequencer.PopFrontWithName(); EXPECT_EQ(next.second, "Read"); next.first.set_value(true); - EXPECT_THAT(data.get(), VariantWith(_)); + EXPECT_THAT(data.get(), VariantWith(_)); // The last Read() triggers the end of stream message, including a call to // `Finish()`. It should detect the invalid checksum. @@ -385,7 +371,7 @@ TEST_P(AsyncConnectionImplReadHashTest, ReadFromOffsetNoValidate) { next = sequencer.PopFrontWithName(); EXPECT_EQ(next.second, "Read"); next.first.set_value(true); - EXPECT_THAT(data.get(), VariantWith(_)); + EXPECT_THAT(data.get(), VariantWith(_)); // The last Read() triggers the end of stream message, including a call to // `Finish()`. It should detect the invalid checksum. @@ -470,7 +456,7 @@ TEST_P(AsyncConnectionImplReadHashTest, PartialReadNoValidate) { next = sequencer.PopFrontWithName(); EXPECT_EQ(next.second, "Read"); next.first.set_value(true); - EXPECT_THAT(data.get(), VariantWith(_)); + EXPECT_THAT(data.get(), VariantWith(_)); // The last Read() triggers the end of stream message, including a call to // `Finish()`. It should detect the invalid checksum. diff --git a/google/cloud/storage/internal/async/connection_impl_read_test.cc b/google/cloud/storage/internal/async/connection_impl_read_test.cc index 200a9fc28b14d..8f2c2f0a20d22 100644 --- a/google/cloud/storage/internal/async/connection_impl_read_test.cc +++ b/google/cloud/storage/internal/async/connection_impl_read_test.cc @@ -77,14 +77,14 @@ auto TestOptions(Options options = {}) { std::move(options), Options{} .set(1) - .set( - storage_experimental::LimitedErrorCountRetryPolicy(2).clone()) + .set( + storage::LimitedErrorCountAsyncRetryPolicy(2).clone()) .set( storage::ExponentialBackoffPolicy(ms(1), ms(2), 2.0).clone())); return DefaultOptionsAsync(std::move(options)); } -std::shared_ptr MakeTestConnection( +std::shared_ptr MakeTestConnection( CompletionQueue cq, std::shared_ptr mock, Options options = {}) { return MakeAsyncConnection(std::move(cq), std::move(mock), @@ -211,8 +211,7 @@ TEST_F(AsyncConnectionImplTest, ReadObject) { EXPECT_EQ(next.second, "Read"); next.first.set_value(true); auto response = data.get(); - ASSERT_TRUE( - absl::holds_alternative(response)); + ASSERT_TRUE(absl::holds_alternative(response)); // The `Read()` and `Finish()` calls must happen before the second `Read()` is // satisfied. @@ -312,8 +311,7 @@ TEST_F(AsyncConnectionImplTest, ReadObjectWithTimeout) { next.first.set_value(true); auto response = data.get(); - ASSERT_TRUE( - absl::holds_alternative(response)); + ASSERT_TRUE(absl::holds_alternative(response)); // Trigger another read. Since this closes the stream, the `Read()` and // `Finish()` calls must happen before the second `Read()` is satisfied. @@ -534,19 +532,18 @@ TEST_F(AsyncConnectionImplTest, ReadObjectDetectBadMessageChecksum) { }); auto mock_resume_policy_factory = - []() -> std::unique_ptr { + []() -> std::unique_ptr { auto policy = std::make_unique(); EXPECT_CALL(*policy, OnStartSuccess).Times(0); // Never resumed EXPECT_CALL(*policy, OnFinish(StatusIs(StatusCode::kInvalidArgument))) - .WillOnce(Return(storage_experimental::ResumePolicy::kStop)); + .WillOnce(Return(storage::ResumePolicy::kStop)); return policy; }; internal::AutomaticallyCreatedBackgroundThreads pool(1); auto connection = MakeTestConnection( pool.cq(), mock, - Options{}.set( - mock_resume_policy_factory)); + Options{}.set(mock_resume_policy_factory)); auto pending = connection->ReadObject( {google::storage::v2::ReadObjectRequest{}, connection->options()}); @@ -629,7 +626,7 @@ TEST_F(AsyncConnectionImplTest, ReadObjectDetectBadFullChecksum) { }); auto mock_resume_policy_factory = - []() -> std::unique_ptr { + []() -> std::unique_ptr { auto policy = std::make_unique(); EXPECT_CALL(*policy, OnStartSuccess).Times(2); // Per Read() success EXPECT_CALL(*policy, OnFinish).Times(0); @@ -637,10 +634,10 @@ TEST_F(AsyncConnectionImplTest, ReadObjectDetectBadFullChecksum) { }; internal::AutomaticallyCreatedBackgroundThreads pool(1); - auto connection = MakeTestConnection( - pool.cq(), mock, - TestOptions(Options{}.set( - mock_resume_policy_factory))); + auto connection = + MakeTestConnection(pool.cq(), mock, + TestOptions(Options{}.set( + mock_resume_policy_factory))); auto pending = connection->ReadObject( {google::storage::v2::ReadObjectRequest{}, connection->options()}); @@ -661,12 +658,11 @@ TEST_F(AsyncConnectionImplTest, ReadObjectDetectBadFullChecksum) { EXPECT_EQ(next.second, "Read"); next.first.set_value(true); auto response = data.get(); - EXPECT_THAT(response, VariantWith(ResultOf( - "payload contents", - [](storage_experimental::ReadPayload const& p) { - return p.contents(); - }, - ElementsAre(std::string(kQuick))))); + EXPECT_THAT(response, + VariantWith(ResultOf( + "payload contents", + [](storage::ReadPayload const& p) { return p.contents(); }, + ElementsAre(std::string(kQuick))))); // Trigger the second `Read()` and simulate its behavior. data = reader->Read(); @@ -674,12 +670,11 @@ TEST_F(AsyncConnectionImplTest, ReadObjectDetectBadFullChecksum) { EXPECT_EQ(next.second, "Read"); next.first.set_value(true); response = data.get(); - EXPECT_THAT(response, VariantWith(ResultOf( - "payload contents", - [](storage_experimental::ReadPayload const& p) { - return p.contents(); - }, - ElementsAre(std::string(kQuick))))); + EXPECT_THAT(response, + VariantWith(ResultOf( + "payload contents", + [](storage::ReadPayload const& p) { return p.contents(); }, + ElementsAre(std::string(kQuick))))); // The last Read() triggers the end of stream message, including a call to // `Finish()`. It should detect the invalid checksum. diff --git a/google/cloud/storage/internal/async/connection_impl_test.cc b/google/cloud/storage/internal/async/connection_impl_test.cc index ac4e0dda4b42a..03a3738d3a3b9 100644 --- a/google/cloud/storage/internal/async/connection_impl_test.cc +++ b/google/cloud/storage/internal/async/connection_impl_test.cc @@ -69,14 +69,14 @@ auto TestOptions(Options options = {}) { std::move(options), Options{} .set(1) - .set( - storage_experimental::LimitedErrorCountRetryPolicy(2).clone()) + .set( + storage::LimitedErrorCountAsyncRetryPolicy(2).clone()) .set( storage::ExponentialBackoffPolicy(ms(1), ms(2), 2.0).clone())); return DefaultOptionsAsync(std::move(options)); } -std::shared_ptr MakeTestConnection( +std::shared_ptr MakeTestConnection( CompletionQueue cq, std::shared_ptr mock, Options options = {}) { return MakeAsyncConnection(std::move(cq), std::move(mock), @@ -173,10 +173,10 @@ TEST_F(AsyncConnectionImplTest, ComposeObjectTooManyTransients) { internal::AutomaticallyCreatedBackgroundThreads pool(1); // Use a policy that makes a default-initialized request retryable. - auto connection = MakeTestConnection( - pool.cq(), mock, - Options{}.set( - storage_experimental::MakeAlwaysRetryIdempotencyPolicy)); + auto connection = + MakeTestConnection(pool.cq(), mock, + Options{}.set( + storage::MakeAlwaysRetryAsyncIdempotencyPolicy)); auto pending = connection->ComposeObject( {google::storage::v2::ComposeObjectRequest{}, connection->options()}); diff --git a/google/cloud/storage/internal/async/connection_impl_upload_hash_test.cc b/google/cloud/storage/internal/async/connection_impl_upload_hash_test.cc index af6fb60c9fec5..368b1cdc196a3 100644 --- a/google/cloud/storage/internal/async/connection_impl_upload_hash_test.cc +++ b/google/cloud/storage/internal/async/connection_impl_upload_hash_test.cc @@ -70,16 +70,15 @@ std::ostream& operator<<(std::ostream& os, HashTestCase const& rhs) { os << "HashTestCase={options={"; os << std::boolalpha // << "enable_crc32c_validation=" - << rhs.options.get(); - if (rhs.options.has()) { + << rhs.options.get(); + if (rhs.options.has()) { os << ", use_crc32_value=" - << rhs.options.get(); + << rhs.options.get(); } os << ", enable_md5_validation=" - << rhs.options.get(); - if (rhs.options.has()) { - os << ", use_md5_value=" - << rhs.options.get(); + << rhs.options.get(); + if (rhs.options.has()) { + os << ", use_md5_value=" << rhs.options.get(); } os << "}, expected={" << google::cloud::internal::DebugString(ExpectedObjectChecksums(rhs), @@ -117,58 +116,49 @@ auto constexpr kQuickFox = "The quick brown fox jumps over the lazy dog"; INSTANTIATE_TEST_SUITE_P( Computed, AsyncConnectionImplUploadHashTest, ::testing::Values( - HashTestCase{ - Options{} - .set(true) - .set(true), - kQuickFoxCrc32cChecksum, kQuickFoxMD5Hash}, - HashTestCase{ - Options{} - .set(true) - .set(false), - kQuickFoxCrc32cChecksum, ""}, - HashTestCase{ - Options{} - .set(false) - .set(true), - absl::nullopt, kQuickFoxMD5Hash}, - HashTestCase{ - Options{} - .set(false) - .set(false), - absl::nullopt, ""})); + HashTestCase{Options{} + .set(true) + .set(true), + kQuickFoxCrc32cChecksum, kQuickFoxMD5Hash}, + HashTestCase{Options{} + .set(true) + .set(false), + kQuickFoxCrc32cChecksum, ""}, + HashTestCase{Options{} + .set(false) + .set(true), + absl::nullopt, kQuickFoxMD5Hash}, + HashTestCase{Options{} + .set(false) + .set(false), + absl::nullopt, ""})); INSTANTIATE_TEST_SUITE_P( PreComputed, AsyncConnectionImplUploadHashTest, ::testing::Values( HashTestCase{ Options{} - .set(false) - .set(false) - .set( - kQuickFoxCrc32cChecksum) - .set( - BinaryMD5(kQuickFoxMD5Hash)), + .set(false) + .set(false) + .set(kQuickFoxCrc32cChecksum) + .set(BinaryMD5(kQuickFoxMD5Hash)), kQuickFoxCrc32cChecksum, kQuickFoxMD5Hash}, HashTestCase{ Options{} - .set(false) - .set(false) - .set( - kQuickFoxCrc32cChecksum), + .set(false) + .set(false) + .set(kQuickFoxCrc32cChecksum), kQuickFoxCrc32cChecksum, ""}, HashTestCase{ Options{} - .set(false) - .set(false) - .set( - BinaryMD5(kQuickFoxMD5Hash)), + .set(false) + .set(false) + .set(BinaryMD5(kQuickFoxMD5Hash)), absl::nullopt, kQuickFoxMD5Hash}, - HashTestCase{ - Options{} - .set(false) - .set(false), - absl::nullopt, ""})); + HashTestCase{Options{} + .set(false) + .set(false), + absl::nullopt, ""})); TEST_P(AsyncConnectionImplUploadHashTest, StartUnbuffered) { auto const& param = GetParam(); @@ -247,7 +237,7 @@ TEST_P(AsyncConnectionImplUploadHashTest, StartUnbuffered) { EXPECT_EQ(writer->UploadId(), "test-upload-id"); EXPECT_EQ(absl::get(writer->PersistedState()), 0); - auto w2 = writer->Finalize(storage_experimental::WritePayload(kQuickFox)); + auto w2 = writer->Finalize(storage::WritePayload(kQuickFox)); next = sequencer.PopFrontWithName(); EXPECT_EQ(next.second, "Write"); next.first.set_value(true); @@ -347,7 +337,7 @@ TEST_P(AsyncConnectionImplUploadHashTest, EXPECT_EQ(writer->UploadId(), "resume-upload-id"); EXPECT_EQ(absl::get(writer->PersistedState()), 0); - auto w2 = writer->Finalize(storage_experimental::WritePayload(kQuickFox)); + auto w2 = writer->Finalize(storage::WritePayload(kQuickFox)); next = sequencer.PopFrontWithName(); EXPECT_EQ(next.second, "Write"); next.first.set_value(true); @@ -445,7 +435,7 @@ TEST_P(AsyncConnectionImplUploadHashTest, ResumeUnbufferedWithPersistedData) { EXPECT_EQ(writer->UploadId(), "resume-upload-id"); EXPECT_EQ(absl::get(writer->PersistedState()), 256 * 1024); - auto w2 = writer->Finalize(storage_experimental::WritePayload(kQuickFox)); + auto w2 = writer->Finalize(storage::WritePayload(kQuickFox)); next = sequencer.PopFrontWithName(); EXPECT_EQ(next.second, "Write"); next.first.set_value(true); @@ -542,7 +532,7 @@ TEST_P(AsyncConnectionImplUploadHashTest, StartBuffered) { EXPECT_EQ(writer->UploadId(), "test-upload-id"); EXPECT_EQ(absl::get(writer->PersistedState()), 0); - auto w2 = writer->Finalize(storage_experimental::WritePayload(kQuickFox)); + auto w2 = writer->Finalize(storage::WritePayload(kQuickFox)); next = sequencer.PopFrontWithName(); EXPECT_EQ(next.second, "Write"); next.first.set_value(true); @@ -641,7 +631,7 @@ TEST_P(AsyncConnectionImplUploadHashTest, ResumeBufferedWithoutPersistedData) { EXPECT_EQ(writer->UploadId(), "resume-upload-id"); EXPECT_EQ(absl::get(writer->PersistedState()), 0); - auto w2 = writer->Finalize(storage_experimental::WritePayload(kQuickFox)); + auto w2 = writer->Finalize(storage::WritePayload(kQuickFox)); next = sequencer.PopFrontWithName(); EXPECT_EQ(next.second, "Write"); next.first.set_value(true); @@ -739,7 +729,7 @@ TEST_P(AsyncConnectionImplUploadHashTest, ResumeBufferedWithPersistedData) { EXPECT_EQ(writer->UploadId(), "resume-upload-id"); EXPECT_EQ(absl::get(writer->PersistedState()), 256 * 1024); - auto w2 = writer->Finalize(storage_experimental::WritePayload(kQuickFox)); + auto w2 = writer->Finalize(storage::WritePayload(kQuickFox)); next = sequencer.PopFrontWithName(); EXPECT_EQ(next.second, "Write"); next.first.set_value(true); diff --git a/google/cloud/storage/internal/async/connection_impl_upload_test.cc b/google/cloud/storage/internal/async/connection_impl_upload_test.cc index 3f3b8ff1882b0..2bf0c633dec0b 100644 --- a/google/cloud/storage/internal/async/connection_impl_upload_test.cc +++ b/google/cloud/storage/internal/async/connection_impl_upload_test.cc @@ -70,14 +70,14 @@ auto TestOptions(Options options = {}) { std::move(options), Options{} .set(1) - .set( - storage_experimental::LimitedErrorCountRetryPolicy(2).clone()) + .set( + storage::LimitedErrorCountAsyncRetryPolicy(2).clone()) .set( storage::ExponentialBackoffPolicy(ms(1), ms(2), 2.0).clone())); return DefaultOptionsAsync(std::move(options)); } -std::shared_ptr MakeTestConnection( +std::shared_ptr MakeTestConnection( CompletionQueue cq, std::shared_ptr mock, Options options = {}) { return MakeAsyncConnection(std::move(cq), std::move(mock), diff --git a/google/cloud/storage/internal/async/connection_tracing.cc b/google/cloud/storage/internal/async/connection_tracing.cc index 66b89607f4031..284a340b65d71 100644 --- a/google/cloud/storage/internal/async/connection_tracing.cc +++ b/google/cloud/storage/internal/async/connection_tracing.cc @@ -31,10 +31,10 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { -class AsyncConnectionTracing : public storage_experimental::AsyncConnection { +class AsyncConnectionTracing : public storage::AsyncConnection { public: explicit AsyncConnectionTracing( - std::shared_ptr impl) + std::shared_ptr impl) : impl_(std::move(impl)) {} Options options() const override { return impl_->options(); } @@ -47,16 +47,15 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { impl_->InsertObject(std::move(p))); } - future>> - Open(OpenParams p) override { + future>> Open( + OpenParams p) override { auto span = internal::MakeSpan("storage::AsyncConnection::Open"); internal::OTelScope scope(span); return impl_->Open(std::move(p)) .then([oc = opentelemetry::context::RuntimeContext::GetCurrent(), span = std::move(span)](auto f) - -> StatusOr> { + -> StatusOr< + std::shared_ptr> { auto result = f.get(); internal::DetachOTelContext(oc); if (!result) { @@ -67,14 +66,13 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { }); } - future>> - ReadObject(ReadObjectParams p) override { + future>> ReadObject( + ReadObjectParams p) override { auto span = internal::MakeSpan("storage::AsyncConnection::ReadObject"); internal::OTelScope scope(span); auto wrap = [oc = opentelemetry::context::RuntimeContext::GetCurrent(), span = std::move(span)](auto f) - -> StatusOr< - std::unique_ptr> { + -> StatusOr> { auto reader = f.get(); internal::DetachOTelContext(oc); if (!reader) return internal::EndSpan(*span, std::move(reader).status()); @@ -83,7 +81,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { return impl_->ReadObject(std::move(p)).then(std::move(wrap)); } - future> ReadObjectRange( + future> ReadObjectRange( ReadObjectParams p) override { auto span = internal::MakeSpan("storage::AsyncConnection::ReadObjectRange"); internal::OTelScope scope(span); @@ -96,7 +94,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { }); } - future>> + future>> StartAppendableObjectUpload(AppendableUploadParams p) override { auto span = internal::MakeSpan( "storage::AsyncConnection::StartAppendableObjectUpload"); @@ -104,8 +102,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { return impl_->StartAppendableObjectUpload(std::move(p)) .then([oc = opentelemetry::context::RuntimeContext::GetCurrent(), span = std::move(span)](auto f) - -> StatusOr> { + -> StatusOr> { auto w = f.get(); internal::DetachOTelContext(oc); if (!w) return internal::EndSpan(*span, std::move(w).status()); @@ -113,7 +110,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { }); } - future>> + future>> ResumeAppendableObjectUpload(AppendableUploadParams p) override { auto span = internal::MakeSpan( "storage::AsyncConnection::ResumeAppendableObjectUpload"); @@ -121,8 +118,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { return impl_->ResumeAppendableObjectUpload(std::move(p)) .then([oc = opentelemetry::context::RuntimeContext::GetCurrent(), span = std::move(span)](auto f) - -> StatusOr> { + -> StatusOr> { auto w = f.get(); internal::DetachOTelContext(oc); if (!w) return internal::EndSpan(*span, std::move(w).status()); @@ -130,7 +126,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { }); } - future>> + future>> StartUnbufferedUpload(UploadParams p) override { auto span = internal::MakeSpan("storage::AsyncConnection::StartUnbufferedUpload"); @@ -138,8 +134,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { return impl_->StartUnbufferedUpload(std::move(p)) .then([oc = opentelemetry::context::RuntimeContext::GetCurrent(), span = std::move(span)](auto f) - -> StatusOr> { + -> StatusOr> { auto w = f.get(); internal::DetachOTelContext(oc); if (!w) return internal::EndSpan(*span, std::move(w).status()); @@ -147,7 +142,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { }); } - future>> + future>> StartBufferedUpload(UploadParams p) override { auto span = internal::MakeSpan("storage::AsyncConnection::StartBufferedUpload"); @@ -155,8 +150,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { return impl_->StartBufferedUpload(std::move(p)) .then([oc = opentelemetry::context::RuntimeContext::GetCurrent(), span = std::move(span)](auto f) - -> StatusOr> { + -> StatusOr> { auto w = f.get(); internal::DetachOTelContext(oc); if (!w) return internal::EndSpan(*span, std::move(w).status()); @@ -164,7 +158,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { }); } - future>> + future>> ResumeUnbufferedUpload(ResumeUploadParams p) override { auto span = internal::MakeSpan("storage::AsyncConnection::ResumeUnbufferedUpload"); @@ -172,8 +166,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { return impl_->ResumeUnbufferedUpload(std::move(p)) .then([oc = opentelemetry::context::RuntimeContext::GetCurrent(), span = std::move(span)](auto f) - -> StatusOr> { + -> StatusOr> { auto w = f.get(); internal::DetachOTelContext(oc); if (!w) return internal::EndSpan(*span, std::move(w).status()); @@ -181,7 +174,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { }); } - future>> + future>> ResumeBufferedUpload(ResumeUploadParams p) override { auto span = internal::MakeSpan("storage::AsyncConnection::ResumeBufferedUpload"); @@ -189,8 +182,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { return impl_->ResumeBufferedUpload(std::move(p)) .then([oc = opentelemetry::context::RuntimeContext::GetCurrent(), span = std::move(span)](auto f) - -> StatusOr> { + -> StatusOr> { auto w = f.get(); internal::DetachOTelContext(oc); if (!w) return internal::EndSpan(*span, std::move(w).status()); @@ -213,7 +205,7 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { impl_->DeleteObject(std::move(p))); } - std::shared_ptr RewriteObject( + std::shared_ptr RewriteObject( RewriteObjectParams p) override { auto const enabled = internal::TracingEnabled(p.options); return MakeTracingAsyncRewriterConnection( @@ -221,23 +213,21 @@ class AsyncConnectionTracing : public storage_experimental::AsyncConnection { } private: - std::shared_ptr impl_; + std::shared_ptr impl_; }; } // namespace -std::shared_ptr -MakeTracingAsyncConnection( - std::shared_ptr impl) { +std::shared_ptr MakeTracingAsyncConnection( + std::shared_ptr impl) { if (!internal::TracingEnabled(impl->options())) return impl; return std::make_unique(std::move(impl)); } #else -std::shared_ptr -MakeTracingAsyncConnection( - std::shared_ptr impl) { +std::shared_ptr MakeTracingAsyncConnection( + std::shared_ptr impl) { return impl; } diff --git a/google/cloud/storage/internal/async/connection_tracing.h b/google/cloud/storage/internal/async/connection_tracing.h index 2e62b106a0288..8807980652756 100644 --- a/google/cloud/storage/internal/async/connection_tracing.h +++ b/google/cloud/storage/internal/async/connection_tracing.h @@ -25,9 +25,8 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -std::shared_ptr -MakeTracingAsyncConnection( - std::shared_ptr impl); +std::shared_ptr MakeTracingAsyncConnection( + std::shared_ptr impl); GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END } // namespace storage_internal diff --git a/google/cloud/storage/internal/async/connection_tracing_test.cc b/google/cloud/storage/internal/async/connection_tracing_test.cc index 72bbfaaddf676..0171b22875d17 100644 --- a/google/cloud/storage/internal/async/connection_tracing_test.cc +++ b/google/cloud/storage/internal/async/connection_tracing_test.cc @@ -34,9 +34,9 @@ namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { +using ::google::cloud::storage::AsyncConnection; +using ::google::cloud::storage::ObjectDescriptorConnection; using ::google::cloud::storage::testing::canonical_errors::PermanentError; -using ::google::cloud::storage_experimental::AsyncConnection; -using ::google::cloud::storage_experimental::ObjectDescriptorConnection; using ::google::cloud::storage_mocks::MockAsyncConnection; using ::google::cloud::storage_mocks::MockAsyncObjectDescriptorConnection; using ::google::cloud::storage_mocks::MockAsyncReaderConnection; @@ -120,7 +120,7 @@ TEST(ConnectionTracing, InsertObject) { TEST(ConnectionTracing, ReadObjectError) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -130,9 +130,8 @@ TEST(ConnectionTracing, ReadObjectError) { auto result = actual->ReadObject(AsyncConnection::ReadObjectParams{}) .then(expect_no_context); - p.set_value( - StatusOr>( - PermanentError())); + p.set_value(StatusOr>( + PermanentError())); EXPECT_THAT(result.get(), StatusIs(PermanentError().code())); auto spans = span_catcher->GetSpans(); @@ -146,7 +145,7 @@ TEST(ConnectionTracing, ReadObjectError) { TEST(ConnectionTracing, ReadObjectSuccess) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -157,14 +156,13 @@ TEST(ConnectionTracing, ReadObjectSuccess) { auto f = actual->ReadObject(AsyncConnection::ReadObjectParams{}) .then(expect_no_context); - using Response = ::google::cloud::storage_experimental:: - AsyncReaderConnection::ReadResponse; + using Response = + ::google::cloud::storage::AsyncReaderConnection::ReadResponse; auto mock_reader = std::make_unique(); EXPECT_CALL(*mock_reader, Read) .WillOnce(Return(ByMove(make_ready_future(Response(Status{}))))); - p.set_value( - StatusOr>( - std::move(mock_reader))); + p.set_value(StatusOr>( + std::move(mock_reader))); auto result = f.get(); ASSERT_STATUS_OK(result); @@ -180,7 +178,7 @@ TEST(ConnectionTracing, ReadObjectSuccess) { TEST(ConnectionTracing, ReadObjectRange) { auto span_catcher = InstallSpanCatcher(); - PromiseWithOTelContext> p; + PromiseWithOTelContext> p; auto mock = std::make_unique(); EXPECT_CALL(*mock, options).WillOnce(Return(TracingEnabled())); @@ -188,7 +186,7 @@ TEST(ConnectionTracing, ReadObjectRange) { auto actual = MakeTracingAsyncConnection(std::move(mock)); auto result = actual->ReadObjectRange(AsyncConnection::ReadObjectParams{}) .then(expect_no_context); - p.set_value(storage_experimental::ReadPayload{}); + p.set_value(storage::ReadPayload{}); ASSERT_STATUS_OK(result.get()); auto spans = span_catcher->GetSpans(); @@ -201,7 +199,7 @@ TEST(ConnectionTracing, ReadObjectRange) { TEST(ConnectionTracing, StartUnbufferedUploadError) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -211,9 +209,8 @@ TEST(ConnectionTracing, StartUnbufferedUploadError) { auto result = actual->StartUnbufferedUpload(AsyncConnection::UploadParams{}) .then(expect_no_context); - p.set_value( - StatusOr>( - PermanentError())); + p.set_value(StatusOr>( + PermanentError())); EXPECT_THAT(result.get(), StatusIs(PermanentError().code())); auto spans = span_catcher->GetSpans(); @@ -227,7 +224,7 @@ TEST(ConnectionTracing, StartUnbufferedUploadError) { TEST(ConnectionTracing, StartUnbufferedUploadSuccess) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -242,14 +239,13 @@ TEST(ConnectionTracing, StartUnbufferedUploadSuccess) { EXPECT_CALL(*mock_reader, Finalize) .WillOnce(Return(ByMove( make_ready_future(make_status_or(google::storage::v2::Object{}))))); - p.set_value( - StatusOr>( - std::move(mock_reader))); + p.set_value(StatusOr>( + std::move(mock_reader))); auto result = f.get(); ASSERT_STATUS_OK(result); auto reader = *std::move(result); - auto r = reader->Finalize(storage_experimental::WritePayload{}).get(); + auto r = reader->Finalize(storage::WritePayload{}).get(); EXPECT_STATUS_OK(r); auto spans = span_catcher->GetSpans(); @@ -263,7 +259,7 @@ TEST(ConnectionTracing, StartUnbufferedUploadSuccess) { TEST(ConnectionTracing, StartBufferedUploadError) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -273,9 +269,8 @@ TEST(ConnectionTracing, StartBufferedUploadError) { auto result = actual->StartBufferedUpload(AsyncConnection::UploadParams{}) .then(expect_no_context); - p.set_value( - StatusOr>( - PermanentError())); + p.set_value(StatusOr>( + PermanentError())); EXPECT_THAT(result.get(), StatusIs(PermanentError().code())); auto spans = span_catcher->GetSpans(); @@ -289,7 +284,7 @@ TEST(ConnectionTracing, StartBufferedUploadError) { TEST(ConnectionTracing, StartBufferedUploadSuccess) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -304,14 +299,13 @@ TEST(ConnectionTracing, StartBufferedUploadSuccess) { EXPECT_CALL(*mock_reader, Finalize) .WillOnce(Return(ByMove( make_ready_future(make_status_or(google::storage::v2::Object{}))))); - p.set_value( - StatusOr>( - std::move(mock_reader))); + p.set_value(StatusOr>( + std::move(mock_reader))); auto result = f.get(); ASSERT_STATUS_OK(result); auto reader = *std::move(result); - auto r = reader->Finalize(storage_experimental::WritePayload{}).get(); + auto r = reader->Finalize(storage::WritePayload{}).get(); EXPECT_STATUS_OK(r); auto spans = span_catcher->GetSpans(); @@ -325,7 +319,7 @@ TEST(ConnectionTracing, StartBufferedUploadSuccess) { TEST(ConnectionTracing, ResumeUnbufferedUploadError) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -336,9 +330,8 @@ TEST(ConnectionTracing, ResumeUnbufferedUploadError) { actual->ResumeUnbufferedUpload(AsyncConnection::ResumeUploadParams{}) .then(expect_no_context); - p.set_value( - StatusOr>( - PermanentError())); + p.set_value(StatusOr>( + PermanentError())); EXPECT_THAT(result.get(), StatusIs(PermanentError().code())); auto spans = span_catcher->GetSpans(); @@ -352,7 +345,7 @@ TEST(ConnectionTracing, ResumeUnbufferedUploadError) { TEST(ConnectionTracing, ResumeUnbufferedUploadSuccess) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -367,14 +360,13 @@ TEST(ConnectionTracing, ResumeUnbufferedUploadSuccess) { EXPECT_CALL(*mock_reader, Finalize) .WillOnce(Return(ByMove( make_ready_future(make_status_or(google::storage::v2::Object{}))))); - p.set_value( - StatusOr>( - std::move(mock_reader))); + p.set_value(StatusOr>( + std::move(mock_reader))); auto result = f.get(); ASSERT_STATUS_OK(result); auto reader = *std::move(result); - auto r = reader->Finalize(storage_experimental::WritePayload{}).get(); + auto r = reader->Finalize(storage::WritePayload{}).get(); EXPECT_STATUS_OK(r); auto spans = span_catcher->GetSpans(); @@ -388,7 +380,7 @@ TEST(ConnectionTracing, ResumeUnbufferedUploadSuccess) { TEST(ConnectionTracing, ResumeBufferedUploadError) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -399,9 +391,8 @@ TEST(ConnectionTracing, ResumeBufferedUploadError) { actual->ResumeBufferedUpload(AsyncConnection::ResumeUploadParams{}) .then(expect_no_context); - p.set_value( - StatusOr>( - PermanentError())); + p.set_value(StatusOr>( + PermanentError())); EXPECT_THAT(result.get(), StatusIs(PermanentError().code())); auto spans = span_catcher->GetSpans(); @@ -415,7 +406,7 @@ TEST(ConnectionTracing, ResumeBufferedUploadError) { TEST(ConnectionTracing, ResumeBufferedUploadSuccess) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -430,14 +421,13 @@ TEST(ConnectionTracing, ResumeBufferedUploadSuccess) { EXPECT_CALL(*mock_reader, Finalize) .WillOnce(Return(ByMove( make_ready_future(make_status_or(google::storage::v2::Object{}))))); - p.set_value( - StatusOr>( - std::move(mock_reader))); + p.set_value(StatusOr>( + std::move(mock_reader))); auto result = f.get(); ASSERT_STATUS_OK(result); auto reader = *std::move(result); - auto r = reader->Finalize(storage_experimental::WritePayload{}).get(); + auto r = reader->Finalize(storage::WritePayload{}).get(); EXPECT_STATUS_OK(r); auto spans = span_catcher->GetSpans(); @@ -550,8 +540,8 @@ TEST(ConnectionTracing, RewriteObject) { TEST(ConnectionTracing, OpenError) { auto span_catcher = InstallSpanCatcher(); - PromiseWithOTelContext>> + PromiseWithOTelContext< + StatusOr>> p; auto mock = std::make_unique(); @@ -561,10 +551,8 @@ TEST(ConnectionTracing, OpenError) { auto result = actual->Open(AsyncConnection::OpenParams{}).then(expect_no_context); - p.set_value( - StatusOr< - std::shared_ptr>( - PermanentError())); + p.set_value(StatusOr>( + PermanentError())); EXPECT_THAT(result.get(), StatusIs(PermanentError().code())); auto spans = span_catcher->GetSpans(); @@ -577,8 +565,8 @@ TEST(ConnectionTracing, OpenError) { TEST(ConnectionTracing, OpenSuccess) { auto span_catcher = InstallSpanCatcher(); - PromiseWithOTelContext>> + PromiseWithOTelContext< + StatusOr>> p; auto mock = std::make_unique(); EXPECT_CALL(*mock, options).WillOnce(Return(TracingEnabled())); @@ -589,10 +577,8 @@ TEST(ConnectionTracing, OpenSuccess) { auto mock_descriptor = std::make_shared(); - p.set_value( - StatusOr< - std::shared_ptr>( - std::move(mock_descriptor))); + p.set_value(StatusOr>( + std::move(mock_descriptor))); auto result = f.get(); ASSERT_STATUS_OK(result); auto descriptor = *std::move(result); @@ -608,7 +594,7 @@ TEST(ConnectionTracing, OpenSuccess) { TEST(ConnectionTracing, StartAppendableObjectUploadSuccess) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -625,14 +611,13 @@ TEST(ConnectionTracing, StartAppendableObjectUploadSuccess) { EXPECT_CALL(*mock_header, Finalize) .WillOnce(Return(ByMove( make_ready_future(make_status_or(google::storage::v2::Object{}))))); - p.set_value( - StatusOr>( - std::move(mock_header))); + p.set_value(StatusOr>( + std::move(mock_header))); auto result = f.get(); ASSERT_STATUS_OK(result); auto writer = *std::move(result); - auto w = writer->Finalize(storage_experimental::WritePayload{}).get(); + auto w = writer->Finalize(storage::WritePayload{}).get(); EXPECT_STATUS_OK(w); auto spans = span_catcher->GetSpans(); @@ -647,7 +632,7 @@ TEST(ConnectionTracing, StartAppendableObjectUploadSuccess) { TEST(ConnectionTracing, StartAppendableObjectUploadError) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -657,9 +642,8 @@ TEST(ConnectionTracing, StartAppendableObjectUploadError) { auto result = actual->StartAppendableObjectUpload( AsyncConnection::AppendableUploadParams{}); - p.set_value( - StatusOr>( - PermanentError())); + p.set_value(StatusOr>( + PermanentError())); EXPECT_THAT(result.get(), StatusIs(PermanentError().code())); auto spans = span_catcher->GetSpans(); @@ -674,7 +658,7 @@ TEST(ConnectionTracing, StartAppendableObjectUploadError) { TEST(ConnectionTracing, ResumeAppendableObjectUploadSuccess) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -691,14 +675,13 @@ TEST(ConnectionTracing, ResumeAppendableObjectUploadSuccess) { EXPECT_CALL(*mock_writer, Finalize) .WillOnce(Return(ByMove( make_ready_future(make_status_or(google::storage::v2::Object{}))))); - p.set_value( - StatusOr>( - std::move(mock_writer))); + p.set_value(StatusOr>( + std::move(mock_writer))); auto result = f.get(); ASSERT_STATUS_OK(result); auto writer = *std::move(result); - auto w = writer->Finalize(storage_experimental::WritePayload{}).get(); + auto w = writer->Finalize(storage::WritePayload{}).get(); EXPECT_STATUS_OK(w); auto spans = span_catcher->GetSpans(); @@ -713,7 +696,7 @@ TEST(ConnectionTracing, ResumeAppendableObjectUploadSuccess) { TEST(ConnectionTracing, ResumeAppendableObjectUploadError) { auto span_catcher = InstallSpanCatcher(); PromiseWithOTelContext< - StatusOr>> + StatusOr>> p; auto mock = std::make_unique(); @@ -725,9 +708,8 @@ TEST(ConnectionTracing, ResumeAppendableObjectUploadError) { AsyncConnection::AppendableUploadParams{}) .then(expect_no_context); - p.set_value( - StatusOr>( - PermanentError())); + p.set_value(StatusOr>( + PermanentError())); EXPECT_THAT(result.get(), StatusIs(PermanentError().code())); auto spans = span_catcher->GetSpans(); diff --git a/google/cloud/storage/internal/async/default_options.cc b/google/cloud/storage/internal/async/default_options.cc index a15a4af690b66..9c34616c73f38 100644 --- a/google/cloud/storage/internal/async/default_options.cc +++ b/google/cloud/storage/internal/async/default_options.cc @@ -39,7 +39,7 @@ std::size_t MaxLwmValue() { } auto Lwm(Options const& opts) { - auto v = opts.get(); + auto v = opts.get(); if (v < MinLwmValue()) return MinLwmValue(); if (v >= MaxLwmValue()) return MaxLwmValue(); return v; @@ -47,15 +47,15 @@ auto Lwm(Options const& opts) { auto Hwm(Options const& opts) { auto lwm = Lwm(opts); - auto v = opts.get(); + auto v = opts.get(); if (v < 2 * lwm) return 2 * lwm; if (v >= 2 * MaxLwmValue()) return 2 * MaxLwmValue(); return v; } auto Adjust(Options opts) { - opts.set(Lwm(opts)); - opts.set(Hwm(opts)); + opts.set(Lwm(opts)); + opts.set(Hwm(opts)); return opts; } @@ -67,17 +67,15 @@ Options DefaultOptionsAsync(Options opts) { opts = internal::MergeOptions( std::move(opts), Options{} - .set( - storage_experimental::LimitedTimeRetryPolicy( - kDefaultMaxRetryPeriod) + .set( + storage::LimitedTimeAsyncRetryPolicy(kDefaultMaxRetryPeriod) .clone()) - .set( - storage_experimental::StopOnConsecutiveErrorsResumePolicy()) - .set( - storage_experimental::MakeStrictIdempotencyPolicy) - .set(true) - .set(128 * 1024 * - 1024L)); + .set( + storage::StopOnConsecutiveErrorsResumePolicy()) + .set( + storage::MakeStrictAsyncIdempotencyPolicy) + .set(true) + .set(128 * 1024 * 1024L)); return Adjust(DefaultOptionsGrpc(std::move(opts))); } diff --git a/google/cloud/storage/internal/async/default_options_test.cc b/google/cloud/storage/internal/async/default_options_test.cc index 940b3c9bdaa3e..6703720a797c4 100644 --- a/google/cloud/storage/internal/async/default_options_test.cc +++ b/google/cloud/storage/internal/async/default_options_test.cc @@ -32,8 +32,8 @@ using ::testing::NotNull; TEST(DefaultOptionsAsync, BufferedWaterMarks) { auto const options = DefaultOptionsAsync({}); - auto const lwm = options.get(); - auto const hwm = options.get(); + auto const lwm = options.get(); + auto const hwm = options.get(); EXPECT_GE(lwm, 256 * 1024); EXPECT_LT(lwm, hwm); } @@ -48,8 +48,8 @@ TEST(DefaultOptionsAsync, Endpoint) { TEST(DefaultOptionsAsync, ResumePolicy) { auto const options = DefaultOptionsAsync({}); // Verify the ResumePolicyOption is set and it creates valid policies. - EXPECT_TRUE(options.has()); - auto factory = options.get(); + EXPECT_TRUE(options.has()); + auto factory = options.get(); EXPECT_TRUE(static_cast(factory)); auto policy = factory(); EXPECT_THAT(policy, NotNull()); @@ -57,9 +57,10 @@ TEST(DefaultOptionsAsync, ResumePolicy) { TEST(DefaultOptionsAsync, IdempotencyPolicy) { auto const options = DefaultOptionsAsync({}); - // Verify the IdempotencyPolicyOption is set and it creates valid policies. - EXPECT_TRUE(options.has()); - auto factory = options.get(); + // Verify the AsyncIdempotencyPolicyOption is set and it creates valid + // policies. + EXPECT_TRUE(options.has()); + auto factory = options.get(); EXPECT_TRUE(static_cast(factory)); auto policy = factory(); EXPECT_THAT(policy, NotNull()); @@ -67,20 +68,19 @@ TEST(DefaultOptionsAsync, IdempotencyPolicy) { TEST(DefaultOptionsAsync, Hashes) { auto const options = DefaultOptionsAsync({}); - EXPECT_TRUE( - options.get()); - EXPECT_FALSE(options.get()); - EXPECT_FALSE(options.has()); - EXPECT_FALSE(options.has()); + EXPECT_TRUE(options.get()); + EXPECT_FALSE(options.get()); + EXPECT_FALSE(options.has()); + EXPECT_FALSE(options.has()); } TEST(DefaultOptionsAsync, Adjust) { - auto const options = DefaultOptionsAsync( - Options{} - .set(16 * 1024) - .set(8 * 1024)); - auto const lwm = options.get(); - auto const hwm = options.get(); + auto const options = + DefaultOptionsAsync(Options{} + .set(16 * 1024) + .set(8 * 1024)); + auto const lwm = options.get(); + auto const hwm = options.get(); EXPECT_GE(lwm, 256 * 1024); EXPECT_LT(lwm, hwm); } @@ -88,7 +88,7 @@ TEST(DefaultOptionsAsync, Adjust) { TEST(DefaultOptionsAsync, MaximumRangeSizeOption) { auto const options = DefaultOptionsAsync({}); auto const max_range_size_option = - options.get(); + options.get(); EXPECT_EQ(max_range_size_option, 128 * 1024 * 1024L); } diff --git a/google/cloud/storage/internal/async/object_descriptor_connection_tracing.cc b/google/cloud/storage/internal/async/object_descriptor_connection_tracing.cc index 379eb343bdc8d..e1e7b65f4a8fd 100644 --- a/google/cloud/storage/internal/async/object_descriptor_connection_tracing.cc +++ b/google/cloud/storage/internal/async/object_descriptor_connection_tracing.cc @@ -34,11 +34,11 @@ namespace { namespace sc = ::opentelemetry::trace::SemanticConventions; class AsyncObjectDescriptorConnectionTracing - : public storage_experimental::ObjectDescriptorConnection { + : public storage::ObjectDescriptorConnection { public: explicit AsyncObjectDescriptorConnectionTracing( opentelemetry::nostd::shared_ptr span, - std::shared_ptr impl) + std::shared_ptr impl) : span_(std::move(span)), impl_(std::move(impl)) {} ~AsyncObjectDescriptorConnectionTracing() override { @@ -51,8 +51,7 @@ class AsyncObjectDescriptorConnectionTracing return impl_->metadata(); } - std::unique_ptr Read( - ReadParams p) override { + std::unique_ptr Read(ReadParams p) override { internal::OTelScope scope(span_); auto result = impl_->Read(p); span_->AddEvent("gl-cpp.open.read", @@ -68,15 +67,15 @@ class AsyncObjectDescriptorConnectionTracing private: opentelemetry::nostd::shared_ptr span_; - std::shared_ptr impl_; + std::shared_ptr impl_; }; } // namespace -std::shared_ptr +std::shared_ptr MakeTracingObjectDescriptorConnection( opentelemetry::nostd::shared_ptr span, - std::shared_ptr impl) { + std::shared_ptr impl) { return std::make_unique( std::move(span), std::move(impl)); } diff --git a/google/cloud/storage/internal/async/object_descriptor_connection_tracing.h b/google/cloud/storage/internal/async/object_descriptor_connection_tracing.h index cff3325993113..ff0ee34a52389 100644 --- a/google/cloud/storage/internal/async/object_descriptor_connection_tracing.h +++ b/google/cloud/storage/internal/async/object_descriptor_connection_tracing.h @@ -27,10 +27,10 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN #ifdef GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY -std::shared_ptr +std::shared_ptr MakeTracingObjectDescriptorConnection( opentelemetry::nostd::shared_ptr span, - std::shared_ptr impl); + std::shared_ptr impl); #endif // GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY diff --git a/google/cloud/storage/internal/async/object_descriptor_connection_tracing_test.cc b/google/cloud/storage/internal/async/object_descriptor_connection_tracing_test.cc index 46c1e049c2208..0dbe97d99b68f 100644 --- a/google/cloud/storage/internal/async/object_descriptor_connection_tracing_test.cc +++ b/google/cloud/storage/internal/async/object_descriptor_connection_tracing_test.cc @@ -32,9 +32,9 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { using ReadResponse = - ::google::cloud::storage_experimental::AsyncReaderConnection::ReadResponse; -using ::google::cloud::storage_experimental::ObjectDescriptorConnection; -using ::google::cloud::storage_experimental::ReadPayload; + ::google::cloud::storage::AsyncReaderConnection::ReadResponse; +using ::google::cloud::storage::ObjectDescriptorConnection; +using ::google::cloud::storage::ReadPayload; using ::google::cloud::storage_mocks::MockAsyncObjectDescriptorConnection; using ::google::cloud::storage_mocks::MockAsyncReaderConnection; using ::google::cloud::testing_util::EventNamed; @@ -111,8 +111,7 @@ TEST(ObjectDescriptorConnectionTracing, ReadThenRead) { EXPECT_CALL(*mock_connection, Read) .WillOnce([&](ObjectDescriptorConnection::ReadParams) { - return std::unique_ptr( - mock_reader_ptr); + return std::unique_ptr(mock_reader_ptr); }); auto connection = MakeTracingObjectDescriptorConnection( diff --git a/google/cloud/storage/internal/async/object_descriptor_impl.cc b/google/cloud/storage/internal/async/object_descriptor_impl.cc index cebca0a2bbfc5..5b7c7ae789c99 100644 --- a/google/cloud/storage/internal/async/object_descriptor_impl.cc +++ b/google/cloud/storage/internal/async/object_descriptor_impl.cc @@ -30,7 +30,7 @@ namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN ObjectDescriptorImpl::ObjectDescriptorImpl( - std::unique_ptr resume_policy, + std::unique_ptr resume_policy, OpenStreamFactory make_stream, google::storage::v2::BidiReadObjectSpec read_object_spec, std::shared_ptr stream, Options options) @@ -78,12 +78,12 @@ void ObjectDescriptorImpl::MakeSubsequentStream() { OnRead(std::move(stream_result->first_response)); } -std::unique_ptr -ObjectDescriptorImpl::Read(ReadParams p) { +std::unique_ptr ObjectDescriptorImpl::Read( + ReadParams p) { std::shared_ptr hash_function = std::shared_ptr( storage::internal::CreateNullHashFunction()); - if (options_.has()) { + if (options_.has()) { hash_function = std::make_shared( storage::internal::CreateNullHashFunction()); @@ -100,7 +100,7 @@ ObjectDescriptorImpl::Read(ReadParams p) { Flush(std::move(lk)); if (!internal::TracingEnabled(options_)) { - return std::unique_ptr( + return std::unique_ptr( std::make_unique(std::move(range))); } @@ -250,7 +250,7 @@ bool ObjectDescriptorImpl::IsResumable( } std::unique_lock lk(mu_); return streams_.back().resume_policy->OnFinish(status) == - storage_experimental::ResumePolicy::kContinue; + storage::ResumePolicy::kContinue; } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END diff --git a/google/cloud/storage/internal/async/object_descriptor_impl.h b/google/cloud/storage/internal/async/object_descriptor_impl.h index f4c467de5c42e..ca1797ab5edaa 100644 --- a/google/cloud/storage/internal/async/object_descriptor_impl.h +++ b/google/cloud/storage/internal/async/object_descriptor_impl.h @@ -36,22 +36,22 @@ namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN class ObjectDescriptorImpl - : public storage_experimental::ObjectDescriptorConnection, + : public storage::ObjectDescriptorConnection, public std::enable_shared_from_this { private: struct Stream { std::shared_ptr stream; std::unordered_map> active_ranges; - std::unique_ptr resume_policy; + std::unique_ptr resume_policy; bool write_pending = false; }; public: - ObjectDescriptorImpl( - std::unique_ptr resume_policy, - OpenStreamFactory make_stream, - google::storage::v2::BidiReadObjectSpec read_object_spec, - std::shared_ptr stream, Options options = {}); + ObjectDescriptorImpl(std::unique_ptr resume_policy, + OpenStreamFactory make_stream, + google::storage::v2::BidiReadObjectSpec read_object_spec, + std::shared_ptr stream, + Options options = {}); ~ObjectDescriptorImpl() override; // Start the read loop. @@ -67,8 +67,7 @@ class ObjectDescriptorImpl absl::optional metadata() const override; // Start a new ranged read. - std::unique_ptr Read( - ReadParams p) override; + std::unique_ptr Read(ReadParams p) override; void MakeSubsequentStream() override; @@ -104,7 +103,7 @@ class ObjectDescriptorImpl bool IsResumable(Status const& status, google::rpc::Status const& proto_status); - std::unique_ptr resume_policy_prototype_; + std::unique_ptr resume_policy_prototype_; OpenStreamFactory make_stream_; mutable std::mutex mu_; diff --git a/google/cloud/storage/internal/async/object_descriptor_impl_test.cc b/google/cloud/storage/internal/async/object_descriptor_impl_test.cc index 595dd34231b6d..e9f882c239cb7 100644 --- a/google/cloud/storage/internal/async/object_descriptor_impl_test.cc +++ b/google/cloud/storage/internal/async/object_descriptor_impl_test.cc @@ -60,9 +60,7 @@ auto constexpr kMetadataText = R"pb( generation: 42 )pb"; -auto NoResume() { - return storage_experimental::LimitedErrorCountResumePolicy(0)(); -} +auto NoResume() { return storage::LimitedErrorCountResumePolicy(0)(); } MATCHER_P(IsProtoEqualModuloRepeatedFieldOrdering, value, "Checks whether protos are equal, ignoring repeated field ordering") { @@ -205,11 +203,9 @@ TEST(ObjectDescriptorImpl, ReadSingleRange) { // The future returned by `Read()` should become satisfied at this point. // We expect it to contain the right data. EXPECT_THAT(s1r1.get(), - VariantWith(ResultOf( + VariantWith(ResultOf( "contents are", - [](storage_experimental::ReadPayload const& p) { - return p.contents(); - }, + [](storage::ReadPayload const& p) { return p.contents(); }, ElementsAre(absl::string_view{ "The quick brown fox jumps over the lazy dog"})))); // Since the `range_end()` flag is set, we expect the stream to finish with @@ -344,11 +340,9 @@ TEST(ObjectDescriptorImpl, ReadMultipleRanges) { // The future returned by `Read()` should become satisfied at this point. // We expect it to contain the right data. EXPECT_THAT(s1r1.get(), - VariantWith(ResultOf( + VariantWith(ResultOf( "contents are", - [](storage_experimental::ReadPayload const& p) { - return p.contents(); - }, + [](storage::ReadPayload const& p) { return p.contents(); }, ElementsAre(absl::string_view{ "The quick brown fox jumps over the lazy dog"})))); // Since the `range_end()` flag is set, we expect the stream to finish with @@ -473,11 +467,9 @@ TEST(ObjectDescriptorImpl, ReadSingleRangeManyMessages) { // The future returned by `Read()` should become satisfied at this point. // We expect it to contain the right data. EXPECT_THAT(s1r1.get(), - VariantWith(ResultOf( + VariantWith(ResultOf( "contents are", - [](storage_experimental::ReadPayload const& p) { - return p.contents(); - }, + [](storage::ReadPayload const& p) { return p.contents(); }, ElementsAre(absl::string_view{ "The quick brown fox jumps over the lazy dog"})))); @@ -491,11 +483,9 @@ TEST(ObjectDescriptorImpl, ReadSingleRangeManyMessages) { // The future returned by `Read()` should become satisfied at this point. // We expect it to contain the right data. EXPECT_THAT(s1r2.get(), - VariantWith(ResultOf( + VariantWith(ResultOf( "contents are", - [](storage_experimental::ReadPayload const& p) { - return p.contents(); - }, + [](storage::ReadPayload const& p) { return p.contents(); }, ElementsAre(absl::string_view{ "The quick brown fox jumps over the lazy dog"})))); @@ -730,9 +720,8 @@ TEST(ObjectDescriptorImpl, ResumeRangesOnRecoverableError) { auto spec = google::storage::v2::BidiReadObjectSpec{}; ASSERT_TRUE(TextFormat::ParseFromString(kReadSpecText, &spec)); auto tested = std::make_shared( - storage_experimental::LimitedErrorCountResumePolicy(1)(), - factory.AsStdFunction(), spec, - std::make_shared(InitialStream(sequencer))); + storage::LimitedErrorCountResumePolicy(1)(), factory.AsStdFunction(), + spec, std::make_shared(InitialStream(sequencer))); auto response = Response{}; EXPECT_TRUE(TextFormat::ParseFromString(kResponse0, &response)); tested->Start(std::move(response)); @@ -779,9 +768,9 @@ TEST(ObjectDescriptorImpl, ResumeRangesOnRecoverableError) { EXPECT_TRUE(s2r1.is_ready()); EXPECT_TRUE(s3r1.is_ready()); - auto expected_r1 = VariantWith(ResultOf( + auto expected_r1 = VariantWith(ResultOf( "contents are", - [](storage_experimental::ReadPayload const& p) { return p.contents(); }, + [](storage::ReadPayload const& p) { return p.contents(); }, ElementsAre(absl::string_view{"0123456789"}))); EXPECT_THAT(s1r1.get(), expected_r1); @@ -999,9 +988,8 @@ TEST(ObjectDescriptorImpl, ResumeUsesRouting) { auto spec = google::storage::v2::BidiReadObjectSpec{}; ASSERT_TRUE(TextFormat::ParseFromString(kReadSpecText, &spec)); auto tested = std::make_shared( - storage_experimental::LimitedErrorCountResumePolicy(1)(), - factory.AsStdFunction(), spec, - std::make_shared(initial_stream())); + storage::LimitedErrorCountResumePolicy(1)(), factory.AsStdFunction(), + spec, std::make_shared(initial_stream())); auto response = Response{}; EXPECT_TRUE(TextFormat::ParseFromString(kResponse0, &response)); tested->Start(std::move(response)); @@ -1320,11 +1308,9 @@ TEST(ObjectDescriptorImpl, ReadWithSubsequentStream) { read1.first.set_value(true); EXPECT_THAT(future1.get(), - VariantWith(ResultOf( + VariantWith(ResultOf( "contents are", - [](storage_experimental::ReadPayload const& p) { - return p.contents(); - }, + [](storage::ReadPayload const& p) { return p.contents(); }, ElementsAre(absl::string_view{"payload-for-stream-1"})))); EXPECT_THAT(reader1->Read().get(), VariantWith(IsOk())); @@ -1356,11 +1342,9 @@ TEST(ObjectDescriptorImpl, ReadWithSubsequentStream) { read2.first.set_value(true); EXPECT_THAT(future2.get(), - VariantWith(ResultOf( + VariantWith(ResultOf( "contents are", - [](storage_experimental::ReadPayload const& p) { - return p.contents(); - }, + [](storage::ReadPayload const& p) { return p.contents(); }, ElementsAre(absl::string_view{"payload-for-stream-2"})))); EXPECT_THAT(reader2->Read().get(), VariantWith(IsOk())); diff --git a/google/cloud/storage/internal/async/object_descriptor_reader.h b/google/cloud/storage/internal/async/object_descriptor_reader.h index 657dce0fa9917..64ddb7c6e6899 100644 --- a/google/cloud/storage/internal/async/object_descriptor_reader.h +++ b/google/cloud/storage/internal/async/object_descriptor_reader.h @@ -32,8 +32,7 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN * need to implement the `AsyncReaderConnection` interface, using `ReadRange` as * the underlying implementation. */ -class ObjectDescriptorReader - : public storage_experimental::AsyncReaderConnection { +class ObjectDescriptorReader : public storage::AsyncReaderConnection { public: explicit ObjectDescriptorReader(std::shared_ptr impl); ~ObjectDescriptorReader() override = default; diff --git a/google/cloud/storage/internal/async/object_descriptor_reader_test.cc b/google/cloud/storage/internal/async/object_descriptor_reader_test.cc index 1fc6c86c3b93c..3523ba082f959 100644 --- a/google/cloud/storage/internal/async/object_descriptor_reader_test.cc +++ b/google/cloud/storage/internal/async/object_descriptor_reader_test.cc @@ -22,7 +22,7 @@ namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { -using ::google::cloud::storage_experimental::ReadPayload; +using ::google::cloud::storage::ReadPayload; using ::google::protobuf::TextFormat; using ::testing::ElementsAre; using ::testing::ResultOf; diff --git a/google/cloud/storage/internal/async/object_descriptor_reader_tracing.cc b/google/cloud/storage/internal/async/object_descriptor_reader_tracing.cc index 3754120c02ed9..e1b8eae09e40a 100644 --- a/google/cloud/storage/internal/async/object_descriptor_reader_tracing.cc +++ b/google/cloud/storage/internal/async/object_descriptor_reader_tracing.cc @@ -50,8 +50,7 @@ class ObjectDescriptorReaderTracing : public ObjectDescriptorReader { auto result = f.get(); internal::DetachOTelContext(oc); if (!absl::holds_alternative(result)) { - auto const& payload = - absl::get(result); + auto const& payload = absl::get(result); span->AddEvent( "gl-cpp.read-range", @@ -73,14 +72,14 @@ class ObjectDescriptorReaderTracing : public ObjectDescriptorReader { } // namespace -std::unique_ptr +std::unique_ptr MakeTracingObjectDescriptorReader(std::shared_ptr impl) { return std::make_unique(std::move(impl)); } #else // GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY -std::unique_ptr +std::unique_ptr MakeTracingObjectDescriptorReader(std::shared_ptr impl) { return std::make_unique(std::move(impl)); } diff --git a/google/cloud/storage/internal/async/object_descriptor_reader_tracing.h b/google/cloud/storage/internal/async/object_descriptor_reader_tracing.h index 039dd01be9e9d..1a010cdbb366b 100644 --- a/google/cloud/storage/internal/async/object_descriptor_reader_tracing.h +++ b/google/cloud/storage/internal/async/object_descriptor_reader_tracing.h @@ -24,7 +24,7 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -std::unique_ptr +std::unique_ptr MakeTracingObjectDescriptorReader(std::shared_ptr impl); GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END diff --git a/google/cloud/storage/internal/async/read_payload_impl.h b/google/cloud/storage/internal/async/read_payload_impl.h index c8c5bada6016f..73339576edf83 100644 --- a/google/cloud/storage/internal/async/read_payload_impl.h +++ b/google/cloud/storage/internal/async/read_payload_impl.h @@ -34,8 +34,8 @@ struct ReadPayloadImpl { * We don't want a public constructor, because `absl::Cord` is not stable * enough for public APIs. */ - static storage_experimental::ReadPayload Make(absl::Cord contents) { - return storage_experimental::ReadPayload(std::move(contents)); + static storage::ReadPayload Make(absl::Cord contents) { + return storage::ReadPayload(std::move(contents)); } /** @@ -45,13 +45,13 @@ struct ReadPayloadImpl { * uses `std::string` or `absl::Cord` depending on how the protos were * compiled. */ - static storage_experimental::ReadPayload Make(std::string contents) { - return storage_experimental::ReadPayload(std::move(contents)); + static storage::ReadPayload Make(std::string contents) { + return storage::ReadPayload(std::move(contents)); } /// Append the data from @p rhs to @p lhs. - static void Accumulate(storage_experimental::ReadPayload& lhs, - storage_experimental::ReadPayload&& rhs) { + static void Accumulate(storage::ReadPayload& lhs, + storage::ReadPayload&& rhs) { if (lhs.impl_.empty()) { lhs = std::move(rhs); return; @@ -61,18 +61,18 @@ struct ReadPayloadImpl { /// Get the object hashes (by move) from the payload. static absl::optional GetObjectHashes( - storage_experimental::ReadPayload& payload) { + storage::ReadPayload& payload) { return std::move(payload.object_hash_values_); } /// Set the object hashes in the payload. - static void SetObjectHashes(storage_experimental::ReadPayload& payload, + static void SetObjectHashes(storage::ReadPayload& payload, storage::internal::HashValues hashes) { payload.object_hash_values_ = std::move(hashes); } - static void Append(storage_experimental::ReadPayload& payload, - storage_experimental::ReadPayload new_data) { + static void Append(storage::ReadPayload& payload, + storage::ReadPayload new_data) { payload.impl_.Append(std::move(new_data.impl_)); } }; diff --git a/google/cloud/storage/internal/async/read_payload_impl_test.cc b/google/cloud/storage/internal/async/read_payload_impl_test.cc index 70d03ce5c0dd7..80a29c934de5d 100644 --- a/google/cloud/storage/internal/async/read_payload_impl_test.cc +++ b/google/cloud/storage/internal/async/read_payload_impl_test.cc @@ -58,7 +58,7 @@ TEST(ReadPayload, FromString) { } TEST(ReadPayload, FromVector) { - auto const actual = storage_experimental::ReadPayload( + auto const actual = storage::ReadPayload( std::vector({std::string(kQuick), std::string(kQuick)})); EXPECT_THAT(actual.contents(), ElementsAre(absl::string_view(kQuick), absl::string_view(kQuick))); diff --git a/google/cloud/storage/internal/async/read_range.cc b/google/cloud/storage/internal/async/read_range.cc index 516688067e533..9ac78833c206c 100644 --- a/google/cloud/storage/internal/async/read_range.cc +++ b/google/cloud/storage/internal/async/read_range.cc @@ -92,7 +92,7 @@ void ReadRange::OnRead(google::storage::v2::ObjectRangeData data) { } void ReadRange::Notify(std::unique_lock lk, - storage_experimental::ReadPayload p) { + storage::ReadPayload p) { auto wait = std::move(*wait_); wait_.reset(); payload_.reset(); diff --git a/google/cloud/storage/internal/async/read_range.h b/google/cloud/storage/internal/async/read_range.h index f955e15291c72..fd808ef96a29b 100644 --- a/google/cloud/storage/internal/async/read_range.h +++ b/google/cloud/storage/internal/async/read_range.h @@ -42,8 +42,7 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN */ class ReadRange { public: - using ReadResponse = - storage_experimental::AsyncReaderConnection::ReadResponse; + using ReadResponse = storage::AsyncReaderConnection::ReadResponse; ReadRange(std::int64_t offset, std::int64_t length, std::shared_ptr hash_function = @@ -63,13 +62,12 @@ class ReadRange { void OnRead(google::storage::v2::ObjectRangeData data); private: - void Notify(std::unique_lock lk, - storage_experimental::ReadPayload p); + void Notify(std::unique_lock lk, storage::ReadPayload p); mutable std::mutex mu_; std::int64_t offset_; std::int64_t length_; - absl::optional payload_; + absl::optional payload_; absl::optional status_; absl::optional> wait_; std::shared_ptr hash_function_; diff --git a/google/cloud/storage/internal/async/read_range_test.cc b/google/cloud/storage/internal/async/read_range_test.cc index 3a4cd28a140ba..ac0bcfb15feb6 100644 --- a/google/cloud/storage/internal/async/read_range_test.cc +++ b/google/cloud/storage/internal/async/read_range_test.cc @@ -35,9 +35,9 @@ namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { +using ::google::cloud::storage::ReadPayload; using ::google::cloud::storage::testing::MockHashFunction; using ::google::cloud::storage::testing::canonical_errors::PermanentError; -using ::google::cloud::storage_experimental::ReadPayload; using ::google::cloud::testing_util::IsOk; using ::google::cloud::testing_util::IsProtoEqual; using ::google::cloud::testing_util::StatusIs; diff --git a/google/cloud/storage/internal/async/reader_connection_factory.h b/google/cloud/storage/internal/async/reader_connection_factory.h index 733689c35081f..2d6b9d69f5e99 100644 --- a/google/cloud/storage/internal/async/reader_connection_factory.h +++ b/google/cloud/storage/internal/async/reader_connection_factory.h @@ -36,9 +36,9 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN * This is used when resuming a download, the `AsyncConnection` creates an * object of this type, encapsulating all the steps to create a new download. */ -using AsyncReaderConnectionFactory = std::function>>( - storage::Generation generation, std::int64_t received_bytes)>; +using AsyncReaderConnectionFactory = std::function< + future>>( + storage::Generation generation, std::int64_t received_bytes)>; /// Updates a `ReadObjectRequest` to resume assuming using @p generation in new /// requests. diff --git a/google/cloud/storage/internal/async/reader_connection_impl.h b/google/cloud/storage/internal/async/reader_connection_impl.h index 3b2fa229452fe..fc5d7d866e408 100644 --- a/google/cloud/storage/internal/async/reader_connection_impl.h +++ b/google/cloud/storage/internal/async/reader_connection_impl.h @@ -31,8 +31,7 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -class AsyncReaderConnectionImpl - : public storage_experimental::AsyncReaderConnection { +class AsyncReaderConnectionImpl : public storage::AsyncReaderConnection { public: using ProtoPayload = google::storage::v2::ReadObjectResponse; using StreamingRpc = diff --git a/google/cloud/storage/internal/async/reader_connection_impl_test.cc b/google/cloud/storage/internal/async/reader_connection_impl_test.cc index aeecf53977806..f866567602552 100644 --- a/google/cloud/storage/internal/async/reader_connection_impl_test.cc +++ b/google/cloud/storage/internal/async/reader_connection_impl_test.cc @@ -31,10 +31,10 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN +using ::google::cloud::storage::ReadPayload; using ::google::cloud::storage::internal::HashValues; using ::google::cloud::storage::testing::MockHashFunction; using ::google::cloud::storage::testing::canonical_errors::PermanentError; -using ::google::cloud::storage_experimental::ReadPayload; using ::google::cloud::testing_util::AsyncSequencer; using ::google::cloud::testing_util::IsOk; using ::google::cloud::testing_util::StatusIs; @@ -55,7 +55,7 @@ using ::testing::VariantWith; using MockStream = google::cloud::testing_util::MockAsyncStreamingReadRpc< google::storage::v2::ReadObjectResponse>; using ReadResponse = - google::cloud::storage_experimental::AsyncReaderConnection::ReadResponse; + google::cloud::storage::AsyncReaderConnection::ReadResponse; google::cloud::internal::ImmutableOptions TestOptions() { return google::cloud::internal::MakeImmutableOptions( @@ -110,35 +110,30 @@ TEST(ReaderConnectionImpl, CleanFinish) { AsyncReaderConnectionImpl tested(TestOptions(), std::move(mock), std::move(hash_function)); - EXPECT_THAT(tested.Read().get(), - VariantWith( - AllOf(ResultOf( - "contents match", - [](storage_experimental::ReadPayload const& p) { - return p.contents(); - }, - ElementsAre("test-only-1")), - ResultOf( - "metadata.size", - [](storage_experimental::ReadPayload const& p) { - return p.metadata() - .value_or(google::storage::v2::Object{}) - .size(); - }, - 4096), - ResultOf( - "offset", - [](storage_experimental::ReadPayload const& p) { - return p.offset(); - }, - 1024)))); + EXPECT_THAT( + tested.Read().get(), + VariantWith( + AllOf(ResultOf( + "contents match", + [](storage::ReadPayload const& p) { return p.contents(); }, + ElementsAre("test-only-1")), + ResultOf( + "metadata.size", + [](storage::ReadPayload const& p) { + return p.metadata() + .value_or(google::storage::v2::Object{}) + .size(); + }, + 4096), + ResultOf( + "offset", + [](storage::ReadPayload const& p) { return p.offset(); }, + 1024)))); EXPECT_THAT(tested.Read().get(), VariantWith(ResultOf( "contents match", - [](storage_experimental::ReadPayload const& p) { - return p.contents(); - }, + [](storage::ReadPayload const& p) { return p.contents(); }, ElementsAre("test-only-2")))); EXPECT_THAT(tested.Read().get(), VariantWith(IsOk())); @@ -247,7 +242,7 @@ TEST(ReaderConnectionImpl, FullHashes) { EXPECT_THAT(tested.Read().get(), VariantWith(ResultOf( "read payload without hash values", - [](storage_experimental::ReadPayload p) { + [](storage::ReadPayload p) { return ReadPayloadImpl::GetObjectHashes(p); }, Eq(absl::nullopt)))); @@ -255,7 +250,7 @@ TEST(ReaderConnectionImpl, FullHashes) { auto has_hash_values = [](HashValues const& expected) { return ResultOf( "read response has hash values", - [](storage_experimental::ReadPayload p) { + [](storage::ReadPayload p) { return ReadPayloadImpl::GetObjectHashes(p); }, AllOf(Optional(Field("crc32c", &HashValues::crc32c, expected.crc32c)), diff --git a/google/cloud/storage/internal/async/reader_connection_resume.cc b/google/cloud/storage/internal/async/reader_connection_resume.cc index aaec3f626f36f..6ffb491d4b897 100644 --- a/google/cloud/storage/internal/async/reader_connection_resume.cc +++ b/google/cloud/storage/internal/async/reader_connection_resume.cc @@ -22,10 +22,10 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -using ::google::cloud::storage_experimental::AsyncReaderConnection; -using ::google::cloud::storage_experimental::ResumePolicy; +using ::google::cloud::storage::AsyncReaderConnection; +using ::google::cloud::storage::ResumePolicy; using ReadResponse = - google::cloud::storage_experimental::AsyncReaderConnection::ReadResponse; + google::cloud::storage::AsyncReaderConnection::ReadResponse; void AsyncReaderConnectionResume::Cancel() { if (auto impl = CurrentImpl()) return impl->Cancel(); @@ -54,9 +54,9 @@ future AsyncReaderConnectionResume::Read( } future AsyncReaderConnectionResume::OnRead(ReadResponse r) { - if (absl::holds_alternative(r)) { + if (absl::holds_alternative(r)) { resume_policy_->OnStartSuccess(); - auto response = absl::get(std::move(r)); + auto response = absl::get(std::move(r)); hash_validator_->ProcessHashValues( ReadPayloadImpl::GetObjectHashes(response).value_or( storage::internal::HashValues{})); @@ -103,12 +103,12 @@ future AsyncReaderConnectionResume::OnResume( return Read(std::move(lk)); } -std::shared_ptr +std::shared_ptr AsyncReaderConnectionResume::CurrentImpl(std::unique_lock const&) { return impl_; } -std::shared_ptr +std::shared_ptr AsyncReaderConnectionResume::CurrentImpl() { return CurrentImpl(std::unique_lock(mu_)); } diff --git a/google/cloud/storage/internal/async/reader_connection_resume.h b/google/cloud/storage/internal/async/reader_connection_resume.h index 2f3ab2b2d94a4..3d70585de5e41 100644 --- a/google/cloud/storage/internal/async/reader_connection_resume.h +++ b/google/cloud/storage/internal/async/reader_connection_resume.h @@ -35,11 +35,10 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -class AsyncReaderConnectionResume - : public storage_experimental::AsyncReaderConnection { +class AsyncReaderConnectionResume : public storage::AsyncReaderConnection { public: explicit AsyncReaderConnectionResume( - std::unique_ptr resume_policy, + std::unique_ptr resume_policy, std::shared_ptr hash, std::unique_ptr validator, AsyncReaderConnectionFactory reader_factory) @@ -58,20 +57,19 @@ class AsyncReaderConnectionResume future OnRead(ReadResponse r); future Reconnect(); future OnResume( - StatusOr> - connection); - std::shared_ptr CurrentImpl( + StatusOr> connection); + std::shared_ptr CurrentImpl( std::unique_lock const&); - std::shared_ptr CurrentImpl(); + std::shared_ptr CurrentImpl(); - std::unique_ptr resume_policy_; + std::unique_ptr resume_policy_; std::shared_ptr hash_function_; std::unique_ptr hash_validator_; AsyncReaderConnectionFactory reader_factory_; storage::Generation generation_; std::int64_t received_bytes_ = 0; std::mutex mu_; - std::shared_ptr impl_; + std::shared_ptr impl_; }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END diff --git a/google/cloud/storage/internal/async/reader_connection_resume_test.cc b/google/cloud/storage/internal/async/reader_connection_resume_test.cc index 8f645b5e0f174..1352a872c5875 100644 --- a/google/cloud/storage/internal/async/reader_connection_resume_test.cc +++ b/google/cloud/storage/internal/async/reader_connection_resume_test.cc @@ -36,12 +36,12 @@ namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { +using ::google::cloud::storage::ReadPayload; +using ::google::cloud::storage::ResumePolicy; using ::google::cloud::storage::testing::MockHashFunction; using ::google::cloud::storage::testing::MockHashValidator; using ::google::cloud::storage::testing::MockResumePolicy; using ::google::cloud::storage::testing::canonical_errors::TransientError; -using ::google::cloud::storage_experimental::ReadPayload; -using ::google::cloud::storage_experimental::ResumePolicy; using ::google::cloud::testing_util::IsOk; using ::google::cloud::testing_util::IsProtoEqual; using ::google::cloud::testing_util::StatusIs; @@ -60,11 +60,11 @@ using ::testing::VariantWith; using MockReader = ::google::cloud::storage_mocks::MockAsyncReaderConnection; using ReadResponse = - ::google::cloud::storage_experimental::AsyncReaderConnection::ReadResponse; + ::google::cloud::storage::AsyncReaderConnection::ReadResponse; -using MockAsyncReaderConnectionFactory = ::testing::MockFunction>>( - storage::Generation, std::int64_t)>; +using MockAsyncReaderConnectionFactory = ::testing::MockFunction< + future>>( + storage::Generation, std::int64_t)>; auto WithGeneration(std::int64_t expected) { return ::testing::ResultOf( @@ -96,7 +96,7 @@ auto constexpr kReadSize = 500; auto constexpr kRangeStart = 10000; auto MakeMockReaderPartial(std::int64_t offset) - -> std::unique_ptr { + -> std::unique_ptr { auto mock = std::make_unique(); EXPECT_CALL(*mock, Read) .WillOnce([offset] { @@ -117,7 +117,7 @@ auto MakeMockReaderPartial(std::int64_t offset) } auto MakeMockReaderFull(int offset) - -> std::unique_ptr { + -> std::unique_ptr { auto mock = std::make_unique(); { ::testing::InSequence sequence; @@ -138,12 +138,12 @@ auto MakeMockReaderFull(int offset) } auto MakeMockReaderTransient() - -> StatusOr> { + -> StatusOr> { return TransientError(); } auto MakeMockReaderStartAndTransient() - -> std::unique_ptr { + -> std::unique_ptr { auto mock = std::make_unique(); EXPECT_CALL(*mock, Read).WillOnce([] { return make_ready_future(ReadResponse(TransientError())); @@ -252,8 +252,7 @@ TEST(AsyncReaderConnectionResume, HashValidation) { }) .WillOnce([] { return make_ready_future(ReadResponse(Status{})); }); return make_ready_future(make_status_or( - std::unique_ptr( - std::move(mock)))); + std::unique_ptr(std::move(mock)))); }); auto resume_policy = std::make_unique(); @@ -312,8 +311,7 @@ TEST(AsyncReaderConnectionResume, HashValidationWithError) { }) .WillOnce([] { return make_ready_future(ReadResponse(Status{})); }); return make_ready_future(make_status_or( - std::unique_ptr( - std::move(mock)))); + std::unique_ptr(std::move(mock)))); }); auto resume_policy = std::make_unique(); @@ -340,8 +338,7 @@ TEST(AsyncReaderConnectionResume, Cancel) { return make_ready_future(ReadResponse(TransientError())); }); return make_ready_future(make_status_or( - std::unique_ptr( - std::move(mock)))); + std::unique_ptr(std::move(mock)))); }); auto resume_policy = std::make_unique(); @@ -369,8 +366,7 @@ TEST(AsyncReaderConnectionResume, GetRequestMetadata) { .WillOnce(Return(RpcMetadata{{{"hk0", "v0"}, {"hk1", "v1"}}, {{"tk0", "v0"}, {"tk1", "v1"}}})); return make_ready_future(make_status_or( - std::unique_ptr( - std::move(mock)))); + std::unique_ptr(std::move(mock)))); }); auto resume_policy = std::make_unique(); @@ -478,8 +474,7 @@ TEST(AsyncReaderConnectionResume, StopAfterTooManyReconnects) { }); EXPECT_CALL(*mock, GetRequestMetadata).Times(AtMost(1)); return make_ready_future(make_status_or( - std::unique_ptr( - std::move(mock)))); + std::unique_ptr(std::move(mock)))); }); auto resume_policy = std::make_unique(); diff --git a/google/cloud/storage/internal/async/reader_connection_tracing.cc b/google/cloud/storage/internal/async/reader_connection_tracing.cc index cf27bd19275b1..7fca064d8ead9 100644 --- a/google/cloud/storage/internal/async/reader_connection_tracing.cc +++ b/google/cloud/storage/internal/async/reader_connection_tracing.cc @@ -29,12 +29,11 @@ namespace { namespace sc = ::opentelemetry::trace::SemanticConventions; -class AsyncReaderConnectionTracing - : public storage_experimental::AsyncReaderConnection { +class AsyncReaderConnectionTracing : public storage::AsyncReaderConnection { public: explicit AsyncReaderConnectionTracing( opentelemetry::nostd::shared_ptr span, - std::unique_ptr impl) + std::unique_ptr impl) : span_(std::move(span)), impl_(std::move(impl)) {} void Cancel() override { @@ -61,7 +60,7 @@ class AsyncReaderConnectionTracing }); return internal::EndSpan(*span, absl::get(std::move(r))); } - auto const& payload = absl::get(r); + auto const& payload = absl::get(r); span->AddEvent( "gl-cpp.read", { @@ -86,16 +85,15 @@ class AsyncReaderConnectionTracing private: opentelemetry::nostd::shared_ptr span_; - std::unique_ptr impl_; + std::unique_ptr impl_; std::int64_t count_ = 0; }; } // namespace -std::unique_ptr -MakeTracingReaderConnection( +std::unique_ptr MakeTracingReaderConnection( opentelemetry::nostd::shared_ptr span, - std::unique_ptr impl) { + std::unique_ptr impl) { return std::make_unique(std::move(span), std::move(impl)); } diff --git a/google/cloud/storage/internal/async/reader_connection_tracing.h b/google/cloud/storage/internal/async/reader_connection_tracing.h index ed74f7756bfc3..ce986bf5feef9 100644 --- a/google/cloud/storage/internal/async/reader_connection_tracing.h +++ b/google/cloud/storage/internal/async/reader_connection_tracing.h @@ -28,10 +28,9 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -std::unique_ptr -MakeTracingReaderConnection( +std::unique_ptr MakeTracingReaderConnection( opentelemetry::nostd::shared_ptr span, - std::unique_ptr impl); + std::unique_ptr impl); GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END } // namespace storage_internal diff --git a/google/cloud/storage/internal/async/reader_connection_tracing_test.cc b/google/cloud/storage/internal/async/reader_connection_tracing_test.cc index 2e68b1f04ed3f..b8710e8d654e4 100644 --- a/google/cloud/storage/internal/async/reader_connection_tracing_test.cc +++ b/google/cloud/storage/internal/async/reader_connection_tracing_test.cc @@ -30,10 +30,10 @@ namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { +using ::google::cloud::storage::ReadPayload; using ::google::cloud::storage::testing::canonical_errors::PermanentError; -using ::google::cloud::storage_experimental::ReadPayload; using ReadResponse = - ::google::cloud::storage_experimental::AsyncReaderConnection::ReadResponse; + ::google::cloud::storage::AsyncReaderConnection::ReadResponse; using ::google::cloud::storage_mocks::MockAsyncReaderConnection; using ::google::cloud::testing_util::EventNamed; using ::google::cloud::testing_util::InstallSpanCatcher; diff --git a/google/cloud/storage/internal/async/rewriter_connection_impl.cc b/google/cloud/storage/internal/async/rewriter_connection_impl.cc index 748b32a2f4d64..6b6a987929b28 100644 --- a/google/cloud/storage/internal/async/rewriter_connection_impl.cc +++ b/google/cloud/storage/internal/async/rewriter_connection_impl.cc @@ -44,8 +44,7 @@ RewriterConnectionImpl::RewriterConnectionImpl( future> RewriterConnectionImpl::Iterate() { - auto policy = - current_->get()(); + auto policy = current_->get()(); return google::cloud::internal::AsyncRetryLoop( current_->get()->clone(), current_->get()->clone(), diff --git a/google/cloud/storage/internal/async/rewriter_connection_impl.h b/google/cloud/storage/internal/async/rewriter_connection_impl.h index 7bf703b23b8a4..d27f388e6b56a 100644 --- a/google/cloud/storage/internal/async/rewriter_connection_impl.h +++ b/google/cloud/storage/internal/async/rewriter_connection_impl.h @@ -31,7 +31,7 @@ namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN class RewriterConnectionImpl - : public storage_experimental::AsyncRewriterConnection, + : public storage::AsyncRewriterConnection, public std::enable_shared_from_this { public: RewriterConnectionImpl(CompletionQueue cq, std::shared_ptr stub, diff --git a/google/cloud/storage/internal/async/rewriter_connection_impl_test.cc b/google/cloud/storage/internal/async/rewriter_connection_impl_test.cc index 8a9c50a412d75..7e37f8884a5a0 100644 --- a/google/cloud/storage/internal/async/rewriter_connection_impl_test.cc +++ b/google/cloud/storage/internal/async/rewriter_connection_impl_test.cc @@ -65,11 +65,10 @@ auto PermanentError() { auto MakeRequest() { google::storage::v2::RewriteObjectRequest request; - request.set_source_bucket( - storage_experimental::BucketName("source-bucket").FullName()); + request.set_source_bucket(storage::BucketName("source-bucket").FullName()); request.set_source_object("source-object"); request.set_destination_bucket( - storage_experimental::BucketName("destination-bucket").FullName()); + storage::BucketName("destination-bucket").FullName()); request.set_destination_name("destination-object"); return request; } diff --git a/google/cloud/storage/internal/async/rewriter_connection_tracing.cc b/google/cloud/storage/internal/async/rewriter_connection_tracing.cc index 197b7bfe4cf7a..cd84526b33509 100644 --- a/google/cloud/storage/internal/async/rewriter_connection_tracing.cc +++ b/google/cloud/storage/internal/async/rewriter_connection_tracing.cc @@ -27,11 +27,10 @@ namespace { using google::cloud::internal::EndSpan; -class AsyncRewriterTracingConnection - : public storage_experimental::AsyncRewriterConnection { +class AsyncRewriterTracingConnection : public storage::AsyncRewriterConnection { public: AsyncRewriterTracingConnection( - std::shared_ptr impl, + std::shared_ptr impl, opentelemetry::nostd::shared_ptr span) : impl_(std::move(impl)), span_(std::move(span)) {} ~AsyncRewriterTracingConnection() override { EndSpan(*span_, Status{}); } @@ -60,16 +59,15 @@ class AsyncRewriterTracingConnection } private: - std::shared_ptr impl_; + std::shared_ptr impl_; opentelemetry::nostd::shared_ptr span_; }; } // namespace -std::shared_ptr +std::shared_ptr MakeTracingAsyncRewriterConnection( - std::shared_ptr impl, - bool enabled) { + std::shared_ptr impl, bool enabled) { if (!enabled) return impl; auto span = internal::MakeSpan("storage::AsyncConnection::RewriteObject"); return std::make_shared(std::move(impl), @@ -78,10 +76,9 @@ MakeTracingAsyncRewriterConnection( #else -std::shared_ptr +std::shared_ptr MakeTracingAsyncRewriterConnection( - std::shared_ptr impl, - bool /*enabled*/) { + std::shared_ptr impl, bool /*enabled*/) { return impl; } diff --git a/google/cloud/storage/internal/async/rewriter_connection_tracing.h b/google/cloud/storage/internal/async/rewriter_connection_tracing.h index 7f532ee5cd176..a81a76601e843 100644 --- a/google/cloud/storage/internal/async/rewriter_connection_tracing.h +++ b/google/cloud/storage/internal/async/rewriter_connection_tracing.h @@ -25,10 +25,9 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -std::shared_ptr +std::shared_ptr MakeTracingAsyncRewriterConnection( - std::shared_ptr impl, - bool enabled); + std::shared_ptr impl, bool enabled); GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END } // namespace storage_internal diff --git a/google/cloud/storage/internal/async/token_impl.cc b/google/cloud/storage/internal/async/token_impl.cc index a17d32dc4f9b7..5ae7e0fdfc224 100644 --- a/google/cloud/storage/internal/async/token_impl.cc +++ b/google/cloud/storage/internal/async/token_impl.cc @@ -20,8 +20,8 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -storage_experimental::AsyncToken MakeAsyncToken(void const* tag) { - return storage_experimental::AsyncToken(tag); +storage::AsyncToken MakeAsyncToken(void const* tag) { + return storage::AsyncToken(tag); } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END diff --git a/google/cloud/storage/internal/async/token_impl.h b/google/cloud/storage/internal/async/token_impl.h index 3c4720c936565..6eb12709a67c8 100644 --- a/google/cloud/storage/internal/async/token_impl.h +++ b/google/cloud/storage/internal/async/token_impl.h @@ -19,18 +19,18 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN class AsyncToken; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -storage_experimental::AsyncToken MakeAsyncToken(void const* tag); +storage::AsyncToken MakeAsyncToken(void const* tag); GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END } // namespace storage_internal diff --git a/google/cloud/storage/internal/async/write_payload_impl.h b/google/cloud/storage/internal/async/write_payload_impl.h index 93888e110c45f..b24a37d0f41e3 100644 --- a/google/cloud/storage/internal/async/write_payload_impl.h +++ b/google/cloud/storage/internal/async/write_payload_impl.h @@ -27,14 +27,12 @@ namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN /// Groups helpers to access implementation details in -/// `storage_experimental::WritePayload`. +/// `storage::WritePayload`. struct WritePayloadImpl { - static storage_experimental::WritePayload Make(absl::Cord impl) { - return storage_experimental::WritePayload(std::move(impl)); - } - static absl::Cord GetImpl(storage_experimental::WritePayload const& p) { - return p.impl_; + static storage::WritePayload Make(absl::Cord impl) { + return storage::WritePayload(std::move(impl)); } + static absl::Cord GetImpl(storage::WritePayload const& p) { return p.impl_; } }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END diff --git a/google/cloud/storage/internal/async/write_payload_impl_test.cc b/google/cloud/storage/internal/async/write_payload_impl_test.cc index 2e5fb741ff1e8..6ae255f66787b 100644 --- a/google/cloud/storage/internal/async/write_payload_impl_test.cc +++ b/google/cloud/storage/internal/async/write_payload_impl_test.cc @@ -27,7 +27,7 @@ using ::testing::IsEmpty; using ::testing::Not; TEST(WritePayloadImpl, Default) { - auto const actual = storage_experimental::WritePayload(); + auto const actual = storage::WritePayload(); EXPECT_TRUE(actual.empty()); EXPECT_EQ(actual.size(), 0); EXPECT_THAT(actual.payload(), IsEmpty()); diff --git a/google/cloud/storage/internal/async/writer_connection_buffered.cc b/google/cloud/storage/internal/async/writer_connection_buffered.cc index 67ce86c4d28ac..3bc9229808a70 100644 --- a/google/cloud/storage/internal/async/writer_connection_buffered.cc +++ b/google/cloud/storage/internal/async/writer_connection_buffered.cc @@ -64,7 +64,7 @@ class AsyncWriterConnectionBufferedState public: AsyncWriterConnectionBufferedState( WriterConnectionFactory factory, - std::unique_ptr impl, + std::unique_ptr impl, std::size_t buffer_size_lwm, std::size_t buffer_size_hwm) : factory_(std::move(factory)), buffer_size_lwm_(buffer_size_lwm), @@ -100,14 +100,14 @@ class AsyncWriterConnectionBufferedState return Impl(std::unique_lock(mu_))->PersistedState(); } - future Write(storage_experimental::WritePayload const& p) { + future Write(storage::WritePayload const& p) { std::unique_lock lk(mu_); resend_buffer_.Append(WritePayloadImpl::GetImpl(p)); return HandleNewData(std::move(lk)); } future> Finalize( - storage_experimental::WritePayload const& p) { + storage::WritePayload const& p) { std::unique_lock lk(mu_); resend_buffer_.Append(WritePayloadImpl::GetImpl(p)); finalize_ = true; @@ -115,9 +115,7 @@ class AsyncWriterConnectionBufferedState return std::move(finalized_future_); } - future Flush(storage_experimental::WritePayload const& p) { - return Write(p); - } + future Flush(storage::WritePayload const& p) { return Write(p); } future> Query() { return Impl(std::unique_lock(mu_))->Query(); @@ -285,8 +283,7 @@ class AsyncWriterConnectionBufferedState } void OnResume( - StatusOr> - impl) { + StatusOr> impl) { std::unique_lock lk(mu_); if (!impl) return SetError(std::move(lk), std::move(impl).status()); impl_ = *std::move(impl); @@ -331,7 +328,7 @@ class AsyncWriterConnectionBufferedState finalized.set_value(std::move(status)); } - std::shared_ptr Impl( + std::shared_ptr Impl( std::unique_lock const& /*lk*/) const { return impl_; } @@ -363,7 +360,7 @@ class AsyncWriterConnectionBufferedState Status resume_status_; // The current writer. - std::shared_ptr impl_; + std::shared_ptr impl_; // The result of calling `Finalize()`. Note that only one such call is ever // made. @@ -446,12 +443,11 @@ class AsyncWriterConnectionBufferedState * * The loop also ends if there are no more bytes to send in the resend buffer. */ -class AsyncWriterConnectionBuffered - : public storage_experimental::AsyncWriterConnection { +class AsyncWriterConnectionBuffered : public storage::AsyncWriterConnection { public: explicit AsyncWriterConnectionBuffered( WriterConnectionFactory factory, - std::unique_ptr impl, + std::unique_ptr impl, std::size_t buffer_size_lwm, std::size_t buffer_size_hwm) : state_(std::make_shared( std::move(factory), std::move(impl), buffer_size_lwm, @@ -466,16 +462,16 @@ class AsyncWriterConnectionBuffered return state_->PersistedState(); } - future Write(storage_experimental::WritePayload p) override { + future Write(storage::WritePayload p) override { return state_->Write(std::move(p)); } future> Finalize( - storage_experimental::WritePayload p) override { + storage::WritePayload p) override { return state_->Finalize(std::move(p)); } - future Flush(storage_experimental::WritePayload p) override { + future Flush(storage::WritePayload p) override { return Write(std::move(p)); } @@ -491,15 +487,14 @@ class AsyncWriterConnectionBuffered } // namespace -std::unique_ptr -MakeWriterConnectionBuffered( +std::unique_ptr MakeWriterConnectionBuffered( WriterConnectionFactory factory, - std::unique_ptr impl, + std::unique_ptr impl, Options const& options) { return absl::make_unique( std::move(factory), std::move(impl), - options.get(), - options.get()); + options.get(), + options.get()); } GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END diff --git a/google/cloud/storage/internal/async/writer_connection_buffered.h b/google/cloud/storage/internal/async/writer_connection_buffered.h index 3a7ecc2bc8311..878b20f1163ef 100644 --- a/google/cloud/storage/internal/async/writer_connection_buffered.h +++ b/google/cloud/storage/internal/async/writer_connection_buffered.h @@ -29,13 +29,12 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -using WriterConnectionFactory = std::function>>()>; +using WriterConnectionFactory = std::function< + future>>()>; -std::unique_ptr -MakeWriterConnectionBuffered( +std::unique_ptr MakeWriterConnectionBuffered( WriterConnectionFactory factory, - std::unique_ptr impl, + std::unique_ptr impl, Options const& options); GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END diff --git a/google/cloud/storage/internal/async/writer_connection_buffered_test.cc b/google/cloud/storage/internal/async/writer_connection_buffered_test.cc index 5180dbc221233..39685933f9b19 100644 --- a/google/cloud/storage/internal/async/writer_connection_buffered_test.cc +++ b/google/cloud/storage/internal/async/writer_connection_buffered_test.cc @@ -27,8 +27,8 @@ namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { +using ::google::cloud::storage::AsyncWriterConnection; using ::google::cloud::storage::testing::canonical_errors::TransientError; -using ::google::cloud::storage_experimental::AsyncWriterConnection; using ::google::cloud::storage_mocks::MockAsyncWriterConnection; using ::google::cloud::testing_util::AsyncSequencer; using ::google::cloud::testing_util::IsOkAndHolds; @@ -44,13 +44,13 @@ using ::testing::Return; using ::testing::UnorderedElementsAre; using ::testing::VariantWith; -using MockFactory = ::testing::MockFunction>>()>; +using MockFactory = ::testing::MockFunction< + future>>()>; Options TestOptions() { return Options{} - .set(16 * 1024) - .set(32 * 1024); + .set(16 * 1024) + .set(32 * 1024); } absl::variant MakePersistedState( @@ -65,8 +65,8 @@ auto TestObject() { return object; } -storage_experimental::WritePayload TestPayload(std::size_t n) { - return storage_experimental::WritePayload(std::string(n, 'A')); +storage::WritePayload TestPayload(std::size_t n) { + return storage::WritePayload(std::string(n, 'A')); } TEST(WriteConnectionBuffered, FinalizeEmpty) { diff --git a/google/cloud/storage/internal/async/writer_connection_finalized.cc b/google/cloud/storage/internal/async/writer_connection_finalized.cc index b947584c39d76..d0bbf8aed935c 100644 --- a/google/cloud/storage/internal/async/writer_connection_finalized.cc +++ b/google/cloud/storage/internal/async/writer_connection_finalized.cc @@ -45,19 +45,17 @@ AsyncWriterConnectionFinalized::PersistedState() const { return object_; } -future AsyncWriterConnectionFinalized::Write( - storage_experimental::WritePayload) { +future AsyncWriterConnectionFinalized::Write(storage::WritePayload) { return make_ready_future(MakeError(GCP_ERROR_INFO())); } future> -AsyncWriterConnectionFinalized::Finalize(storage_experimental::WritePayload) { +AsyncWriterConnectionFinalized::Finalize(storage::WritePayload) { return make_ready_future( StatusOr(MakeError(GCP_ERROR_INFO()))); } -future AsyncWriterConnectionFinalized::Flush( - storage_experimental::WritePayload) { +future AsyncWriterConnectionFinalized::Flush(storage::WritePayload) { return make_ready_future(MakeError(GCP_ERROR_INFO())); } diff --git a/google/cloud/storage/internal/async/writer_connection_finalized.h b/google/cloud/storage/internal/async/writer_connection_finalized.h index b9960f886ab66..46fe58b1d2448 100644 --- a/google/cloud/storage/internal/async/writer_connection_finalized.h +++ b/google/cloud/storage/internal/async/writer_connection_finalized.h @@ -42,8 +42,7 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN * underlying streaming RPC. No such RPC is needed or can successfully upload * additional data. */ -class AsyncWriterConnectionFinalized - : public storage_experimental::AsyncWriterConnection { +class AsyncWriterConnectionFinalized : public storage::AsyncWriterConnection { public: explicit AsyncWriterConnectionFinalized(std::string upload_id, google::storage::v2::Object object); @@ -55,10 +54,10 @@ class AsyncWriterConnectionFinalized absl::variant PersistedState() const override; - future Write(storage_experimental::WritePayload payload) override; + future Write(storage::WritePayload payload) override; future> Finalize( - storage_experimental::WritePayload) override; - future Flush(storage_experimental::WritePayload payload) override; + storage::WritePayload) override; + future Flush(storage::WritePayload payload) override; future> Query() override; RpcMetadata GetRequestMetadata() override; diff --git a/google/cloud/storage/internal/async/writer_connection_impl.cc b/google/cloud/storage/internal/async/writer_connection_impl.cc index fbbd345da62d0..f85f45d3fb2c4 100644 --- a/google/cloud/storage/internal/async/writer_connection_impl.cc +++ b/google/cloud/storage/internal/async/writer_connection_impl.cc @@ -111,8 +111,7 @@ AsyncWriterConnectionImpl::PersistedState() const { return persisted_state_; } -future AsyncWriterConnectionImpl::Write( - storage_experimental::WritePayload payload) { +future AsyncWriterConnectionImpl::Write(storage::WritePayload payload) { auto write = MakeRequest(); auto p = WritePayloadImpl::GetImpl(payload); auto size = p.size(); @@ -126,8 +125,7 @@ future AsyncWriterConnectionImpl::Write( } future> -AsyncWriterConnectionImpl::Finalize( - storage_experimental::WritePayload payload) { +AsyncWriterConnectionImpl::Finalize(storage::WritePayload payload) { auto write = MakeRequest(); write.set_finish_write(true); @@ -144,8 +142,7 @@ AsyncWriterConnectionImpl::Finalize( }); } -future AsyncWriterConnectionImpl::Flush( - storage_experimental::WritePayload payload) { +future AsyncWriterConnectionImpl::Flush(storage::WritePayload payload) { auto write = MakeRequest(); auto p = WritePayloadImpl::GetImpl(payload); auto size = p.size(); diff --git a/google/cloud/storage/internal/async/writer_connection_impl.h b/google/cloud/storage/internal/async/writer_connection_impl.h index a1333cc5f27aa..b37fcaed23cf2 100644 --- a/google/cloud/storage/internal/async/writer_connection_impl.h +++ b/google/cloud/storage/internal/async/writer_connection_impl.h @@ -30,8 +30,7 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -class AsyncWriterConnectionImpl - : public storage_experimental::AsyncWriterConnection { +class AsyncWriterConnectionImpl : public storage::AsyncWriterConnection { public: using StreamingRpc = google::cloud::AsyncStreamingReadWriteRpc< google::storage::v2::BidiWriteObjectRequest, @@ -57,10 +56,10 @@ class AsyncWriterConnectionImpl absl::variant PersistedState() const override; - future Write(storage_experimental::WritePayload payload) override; + future Write(storage::WritePayload payload) override; future> Finalize( - storage_experimental::WritePayload) override; - future Flush(storage_experimental::WritePayload payload) override; + storage::WritePayload) override; + future Flush(storage::WritePayload payload) override; future> Query() override; RpcMetadata GetRequestMetadata() override; diff --git a/google/cloud/storage/internal/async/writer_connection_impl_test.cc b/google/cloud/storage/internal/async/writer_connection_impl_test.cc index 1c0bf5cb39536..e5e92758144f8 100644 --- a/google/cloud/storage/internal/async/writer_connection_impl_test.cc +++ b/google/cloud/storage/internal/async/writer_connection_impl_test.cc @@ -30,9 +30,9 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN +using ::google::cloud::storage::WritePayload; using ::google::cloud::storage::testing::MockHashFunction; using ::google::cloud::storage::testing::canonical_errors::PermanentError; -using ::google::cloud::storage_experimental::WritePayload; using ::google::cloud::testing_util::AsyncSequencer; using ::google::cloud::testing_util::IsOk; using ::google::cloud::testing_util::IsOkAndHolds; diff --git a/google/cloud/storage/internal/async/writer_connection_resumed.cc b/google/cloud/storage/internal/async/writer_connection_resumed.cc index eb9e38f84a5ec..3ec81fbc3ac11 100644 --- a/google/cloud/storage/internal/async/writer_connection_resumed.cc +++ b/google/cloud/storage/internal/async/writer_connection_resumed.cc @@ -61,7 +61,7 @@ class AsyncWriterConnectionResumedState public: AsyncWriterConnectionResumedState( WriterResultFactory factory, - std::unique_ptr impl, + std::unique_ptr impl, google::storage::v2::BidiWriteObjectRequest initial_request, std::shared_ptr hash_function, google::storage::v2::BidiWriteObjectResponse const& first_response, @@ -101,14 +101,14 @@ class AsyncWriterConnectionResumedState return Impl(std::unique_lock(mu_))->PersistedState(); } - future Write(storage_experimental::WritePayload const& p) { + future Write(storage::WritePayload const& p) { std::unique_lock lk(mu_); resend_buffer_.Append(WritePayloadImpl::GetImpl(p)); return HandleNewData(std::move(lk)); } future> Finalize( - storage_experimental::WritePayload const& p) { + storage::WritePayload const& p) { std::unique_lock lk(mu_); resend_buffer_.Append(WritePayloadImpl::GetImpl(p)); finalize_ = true; @@ -117,7 +117,7 @@ class AsyncWriterConnectionResumedState return std::move(finalized_future_); } - future Flush(storage_experimental::WritePayload const& p) { + future Flush(storage::WritePayload const& p) { std::unique_lock lk(mu_); // Create a new promise for this flush operation. promise current_flush_promise; @@ -225,7 +225,7 @@ class AsyncWriterConnectionResumedState auto impl = Impl(lk); lk.unlock(); // Finalize with an empty payload. - (void)impl->Finalize(storage_experimental::WritePayload{}) + (void)impl->Finalize(storage::WritePayload{}) .then([w = WeakFromThis()](auto f) { if (auto self = w.lock()) return self->OnFinalize(f.get()); }); @@ -499,7 +499,7 @@ class AsyncWriterConnectionResumedState p.set_value(status); } - std::shared_ptr Impl( + std::shared_ptr Impl( std::unique_lock const& /*lk*/) const { return impl_; } @@ -524,7 +524,7 @@ class AsyncWriterConnectionResumedState Status resume_status_; // The current writer. - std::shared_ptr impl_; + std::shared_ptr impl_; // The initial request. google::storage::v2::BidiWriteObjectRequest initial_request_; @@ -632,12 +632,11 @@ class AsyncWriterConnectionResumedState * * The loop also ends if there are no more bytes to send in the resend buffer. */ -class AsyncWriterConnectionResumed - : public storage_experimental::AsyncWriterConnection { +class AsyncWriterConnectionResumed : public storage::AsyncWriterConnection { public: explicit AsyncWriterConnectionResumed( WriterResultFactory factory, - std::unique_ptr impl, + std::unique_ptr impl, google::storage::v2::BidiWriteObjectRequest initial_request, std::shared_ptr hash_function, google::storage::v2::BidiWriteObjectResponse const& first_response, @@ -645,8 +644,8 @@ class AsyncWriterConnectionResumed : state_(std::make_shared( std::move(factory), std::move(impl), std::move(initial_request), std::move(hash_function), first_response, options, - options.get(), - options.get())) {} + options.get(), + options.get())) {} void Cancel() override { return state_->Cancel(); } @@ -657,16 +656,16 @@ class AsyncWriterConnectionResumed return state_->PersistedState(); } - future Write(storage_experimental::WritePayload p) override { + future Write(storage::WritePayload p) override { return state_->Write(std::move(p)); } future> Finalize( - storage_experimental::WritePayload p) override { + storage::WritePayload p) override { return state_->Finalize(std::move(p)); } - future Flush(storage_experimental::WritePayload p) override { + future Flush(storage::WritePayload p) override { return state_->Flush(std::move(p)); } @@ -682,10 +681,9 @@ class AsyncWriterConnectionResumed } // namespace -std::unique_ptr -MakeWriterConnectionResumed( +std::unique_ptr MakeWriterConnectionResumed( WriterResultFactory factory, - std::unique_ptr impl, + std::unique_ptr impl, google::storage::v2::BidiWriteObjectRequest initial_request, std::shared_ptr hash_function, google::storage::v2::BidiWriteObjectResponse const& first_response, diff --git a/google/cloud/storage/internal/async/writer_connection_resumed.h b/google/cloud/storage/internal/async/writer_connection_resumed.h index dd659a6186f42..5f923056aee28 100644 --- a/google/cloud/storage/internal/async/writer_connection_resumed.h +++ b/google/cloud/storage/internal/async/writer_connection_resumed.h @@ -36,10 +36,9 @@ using WriterResultFactory = std::function>( google::storage::v2::BidiWriteObjectRequest)>; -std::unique_ptr -MakeWriterConnectionResumed( +std::unique_ptr MakeWriterConnectionResumed( WriterResultFactory factory, - std::unique_ptr impl, + std::unique_ptr impl, google::storage::v2::BidiWriteObjectRequest initial_request, std::shared_ptr hash_function, google::storage::v2::BidiWriteObjectResponse const& first_response, diff --git a/google/cloud/storage/internal/async/writer_connection_resumed_test.cc b/google/cloud/storage/internal/async/writer_connection_resumed_test.cc index a3c7abd81b327..66bb097981244 100644 --- a/google/cloud/storage/internal/async/writer_connection_resumed_test.cc +++ b/google/cloud/storage/internal/async/writer_connection_resumed_test.cc @@ -51,8 +51,8 @@ absl::variant MakePersistedState( return persisted_size; } -storage_experimental::WritePayload TestPayload(std::size_t n) { - return storage_experimental::WritePayload(std::string(n, 'A')); +storage::WritePayload TestPayload(std::size_t n) { + return storage::WritePayload(std::string(n, 'A')); } auto TestObject() { diff --git a/google/cloud/storage/internal/async/writer_connection_tracing.cc b/google/cloud/storage/internal/async/writer_connection_tracing.cc index 3bb930e6e9b3c..dfa705cf5dec8 100644 --- a/google/cloud/storage/internal/async/writer_connection_tracing.cc +++ b/google/cloud/storage/internal/async/writer_connection_tracing.cc @@ -28,12 +28,11 @@ namespace { namespace sc = ::opentelemetry::trace::SemanticConventions; -class AsyncWriterConnectionTracing - : public storage_experimental::AsyncWriterConnection { +class AsyncWriterConnectionTracing : public storage::AsyncWriterConnection { public: explicit AsyncWriterConnectionTracing( opentelemetry::nostd::shared_ptr span, - std::unique_ptr impl) + std::unique_ptr impl) : span_(std::move(span)), impl_(std::move(impl)) {} void Cancel() override { @@ -56,7 +55,7 @@ class AsyncWriterConnectionTracing return impl_->PersistedState(); } - future Write(storage_experimental::WritePayload p) override { + future Write(storage::WritePayload p) override { internal::OTelScope scope(span_); auto size = static_cast(p.size()); return impl_->Write(std::move(p)) @@ -76,7 +75,7 @@ class AsyncWriterConnectionTracing } future> Finalize( - storage_experimental::WritePayload p) override { + storage::WritePayload p) override { internal::OTelScope scope(span_); auto size = static_cast(p.size()); return impl_->Finalize(std::move(p)) @@ -93,7 +92,7 @@ class AsyncWriterConnectionTracing }); } - future Flush(storage_experimental::WritePayload p) override { + future Flush(storage::WritePayload p) override { internal::OTelScope scope(span_); auto size = static_cast(p.size()); return impl_->Flush(std::move(p)) @@ -134,17 +133,16 @@ class AsyncWriterConnectionTracing private: opentelemetry::nostd::shared_ptr span_; - std::unique_ptr impl_; + std::unique_ptr impl_; std::int64_t sent_count_ = 0; std::int64_t recv_count_ = 0; }; } // namespace -std::unique_ptr -MakeTracingWriterConnection( +std::unique_ptr MakeTracingWriterConnection( opentelemetry::nostd::shared_ptr span, - std::unique_ptr impl) { + std::unique_ptr impl) { return std::make_unique(std::move(span), std::move(impl)); } diff --git a/google/cloud/storage/internal/async/writer_connection_tracing.h b/google/cloud/storage/internal/async/writer_connection_tracing.h index 92ca8838a6d73..e8a6ccb8fa993 100644 --- a/google/cloud/storage/internal/async/writer_connection_tracing.h +++ b/google/cloud/storage/internal/async/writer_connection_tracing.h @@ -28,10 +28,9 @@ namespace cloud { namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -std::unique_ptr -MakeTracingWriterConnection( +std::unique_ptr MakeTracingWriterConnection( opentelemetry::nostd::shared_ptr span, - std::unique_ptr impl); + std::unique_ptr impl); GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END } // namespace storage_internal diff --git a/google/cloud/storage/internal/async/writer_connection_tracing_test.cc b/google/cloud/storage/internal/async/writer_connection_tracing_test.cc index 8d156a9a5ab6c..4e46b11a1b86f 100644 --- a/google/cloud/storage/internal/async/writer_connection_tracing_test.cc +++ b/google/cloud/storage/internal/async/writer_connection_tracing_test.cc @@ -31,8 +31,8 @@ namespace storage_internal { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { +using ::google::cloud::storage::WritePayload; using ::google::cloud::storage::testing::canonical_errors::PermanentError; -using ::google::cloud::storage_experimental::WritePayload; using ::google::cloud::storage_mocks::MockAsyncWriterConnection; using ::google::cloud::testing_util::EventNamed; using ::google::cloud::testing_util::InstallSpanCatcher; diff --git a/google/cloud/storage/mocks/mock_async_connection.h b/google/cloud/storage/mocks/mock_async_connection.h index e72f9a0695698..44610ba56142f 100644 --- a/google/cloud/storage/mocks/mock_async_connection.h +++ b/google/cloud/storage/mocks/mock_async_connection.h @@ -29,50 +29,37 @@ namespace cloud { namespace storage_mocks { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -class MockAsyncConnection : public storage_experimental::AsyncConnection { +class MockAsyncConnection : public storage::AsyncConnection { public: MOCK_METHOD(Options, options, (), (const, override)); MOCK_METHOD(future>, InsertObject, (InsertObjectParams), (override)); MOCK_METHOD( - future>>, + future>>, Open, (OpenParams), (override)); - MOCK_METHOD( - future>>, - ReadObject, (ReadObjectParams), (override)); - MOCK_METHOD(future>, - ReadObjectRange, (ReadObjectParams), (override)); - MOCK_METHOD( - future>>, - StartAppendableObjectUpload, (AppendableUploadParams), (override)); - MOCK_METHOD( - future>>, - ResumeAppendableObjectUpload, (AppendableUploadParams), (override)); - MOCK_METHOD( - future>>, - StartUnbufferedUpload, (UploadParams), (override)); - MOCK_METHOD( - future>>, - StartBufferedUpload, (UploadParams), (override)); - MOCK_METHOD( - future>>, - ResumeUnbufferedUpload, (ResumeUploadParams), (override)); - MOCK_METHOD( - future>>, - ResumeBufferedUpload, (ResumeUploadParams), (override)); + MOCK_METHOD(future>>, + ReadObject, (ReadObjectParams), (override)); + MOCK_METHOD(future>, ReadObjectRange, + (ReadObjectParams), (override)); + MOCK_METHOD(future>>, + StartAppendableObjectUpload, (AppendableUploadParams), + (override)); + MOCK_METHOD(future>>, + ResumeAppendableObjectUpload, (AppendableUploadParams), + (override)); + MOCK_METHOD(future>>, + StartUnbufferedUpload, (UploadParams), (override)); + MOCK_METHOD(future>>, + StartBufferedUpload, (UploadParams), (override)); + MOCK_METHOD(future>>, + ResumeUnbufferedUpload, (ResumeUploadParams), (override)); + MOCK_METHOD(future>>, + ResumeBufferedUpload, (ResumeUploadParams), (override)); MOCK_METHOD(future>, ComposeObject, (ComposeObjectParams), (override)); MOCK_METHOD(future, DeleteObject, (DeleteObjectParams), (override)); - MOCK_METHOD(std::shared_ptr, - RewriteObject, (RewriteObjectParams), (override)); + MOCK_METHOD(std::shared_ptr, RewriteObject, + (RewriteObjectParams), (override)); }; GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END diff --git a/google/cloud/storage/mocks/mock_async_object_descriptor_connection.h b/google/cloud/storage/mocks/mock_async_object_descriptor_connection.h index 90e6efda7b9f3..f0e089ac4dada 100644 --- a/google/cloud/storage/mocks/mock_async_object_descriptor_connection.h +++ b/google/cloud/storage/mocks/mock_async_object_descriptor_connection.h @@ -25,12 +25,12 @@ namespace storage_mocks { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN class MockAsyncObjectDescriptorConnection - : public storage_experimental::ObjectDescriptorConnection { + : public storage::ObjectDescriptorConnection { public: MOCK_METHOD(absl::optional, metadata, (), (const, override)); - MOCK_METHOD(std::unique_ptr, - Read, (ReadParams), (override)); + MOCK_METHOD(std::unique_ptr, Read, + (ReadParams), (override)); MOCK_METHOD(void, MakeSubsequentStream, (), (override)); MOCK_METHOD(Options, options, (), (const, override)); }; diff --git a/google/cloud/storage/mocks/mock_async_reader_connection.h b/google/cloud/storage/mocks/mock_async_reader_connection.h index 991148df1fcd7..aea7cc935f431 100644 --- a/google/cloud/storage/mocks/mock_async_reader_connection.h +++ b/google/cloud/storage/mocks/mock_async_reader_connection.h @@ -24,8 +24,7 @@ namespace cloud { namespace storage_mocks { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -class MockAsyncReaderConnection - : public storage_experimental::AsyncReaderConnection { +class MockAsyncReaderConnection : public storage::AsyncReaderConnection { public: MOCK_METHOD(void, Cancel, (), (override)); MOCK_METHOD(future, Read, (), (override)); diff --git a/google/cloud/storage/mocks/mock_async_rewriter_connection.h b/google/cloud/storage/mocks/mock_async_rewriter_connection.h index 04039c5ebe4cd..11df15ac10628 100644 --- a/google/cloud/storage/mocks/mock_async_rewriter_connection.h +++ b/google/cloud/storage/mocks/mock_async_rewriter_connection.h @@ -24,8 +24,7 @@ namespace cloud { namespace storage_mocks { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -class MockAsyncRewriterConnection - : public storage_experimental::AsyncRewriterConnection { +class MockAsyncRewriterConnection : public storage::AsyncRewriterConnection { public: MOCK_METHOD(future>, Iterate, (), (override)); diff --git a/google/cloud/storage/mocks/mock_async_writer_connection.h b/google/cloud/storage/mocks/mock_async_writer_connection.h index 529ccdd7aa056..3e4be09b0825a 100644 --- a/google/cloud/storage/mocks/mock_async_writer_connection.h +++ b/google/cloud/storage/mocks/mock_async_writer_connection.h @@ -25,19 +25,16 @@ namespace cloud { namespace storage_mocks { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN -class MockAsyncWriterConnection - : public storage_experimental::AsyncWriterConnection { +class MockAsyncWriterConnection : public storage::AsyncWriterConnection { public: MOCK_METHOD(void, Cancel, (), (override)); MOCK_METHOD(std::string, UploadId, (), (const, override)); MOCK_METHOD((absl::variant), PersistedState, (), (const, override)); - MOCK_METHOD(future, Write, (storage_experimental::WritePayload), - (override)); + MOCK_METHOD(future, Write, (storage::WritePayload), (override)); MOCK_METHOD(future>, Finalize, - (storage_experimental::WritePayload), (override)); - MOCK_METHOD(future, Flush, (storage_experimental::WritePayload), - (override)); + (storage::WritePayload), (override)); + MOCK_METHOD(future, Flush, (storage::WritePayload), (override)); MOCK_METHOD(future>, Query, (), (override)); MOCK_METHOD(RpcMetadata, GetRequestMetadata, (), (override)); }; diff --git a/google/cloud/storage/quickstart/quickstart_async.cc b/google/cloud/storage/quickstart/quickstart_async.cc index 060042a849b4a..9018fac3f6be7 100644 --- a/google/cloud/storage/quickstart/quickstart_async.cc +++ b/google/cloud/storage/quickstart/quickstart_async.cc @@ -24,15 +24,15 @@ int main(int argc, char* argv[]) { } std::string const bucket_name = argv[1]; - namespace gcs_ex = ::google::cloud::storage_experimental; + namespace gcs = ::google::cloud::storage; // Create a client to communicate with Google Cloud Storage. This client // uses the default configuration for authentication and project id. - auto client = gcs_ex::AsyncClient(); + auto client = gcs::AsyncClient(); auto constexpr kObjectName = "quickstart-async.txt"; auto done = client - .InsertObject(gcs_ex::BucketName(bucket_name), kObjectName, + .InsertObject(gcs::BucketName(bucket_name), kObjectName, "Hello World!") .then([](auto f) { auto metadata = f.get(); @@ -47,26 +47,24 @@ int main(int argc, char* argv[]) { }); done.get(); - done = client - .ReadObjectRange(gcs_ex::BucketName(bucket_name), kObjectName, 0, - 1000) - .then([](auto f) { - auto payload = f.get(); - if (!payload) { - std::cerr << "Error reading object: " << payload.status() - << "\n"; - std::exit(1); - } - if (payload->metadata()) { - std::cout << "The object metadata is " - << payload->metadata()->DebugString() << "\n"; - } - std::cout << "Object contents:\n"; - for (auto const& s : payload->contents()) { - std::cout << s; - } - std::cout << "\n"; - }); + done = + client.ReadObjectRange(gcs::BucketName(bucket_name), kObjectName, 0, 1000) + .then([](auto f) { + auto payload = f.get(); + if (!payload) { + std::cerr << "Error reading object: " << payload.status() << "\n"; + std::exit(1); + } + if (payload->metadata()) { + std::cout << "The object metadata is " + << payload->metadata()->DebugString() << "\n"; + } + std::cout << "Object contents:\n"; + for (auto const& s : payload->contents()) { + std::cout << s; + } + std::cout << "\n"; + }); done.get(); return 0; diff --git a/google/cloud/storage/testing/mock_resume_policy.h b/google/cloud/storage/testing/mock_resume_policy.h index 0183f26185ea2..abec89ef3f35d 100644 --- a/google/cloud/storage/testing/mock_resume_policy.h +++ b/google/cloud/storage/testing/mock_resume_policy.h @@ -23,11 +23,11 @@ namespace cloud { namespace storage { namespace testing { -class MockResumePolicy : public storage_experimental::ResumePolicy { +class MockResumePolicy : public storage::ResumePolicy { public: ~MockResumePolicy() override = default; - MOCK_METHOD(std::unique_ptr, clone, (), + MOCK_METHOD(std::unique_ptr, clone, (), (const, override)); MOCK_METHOD(void, OnStartSuccess, (), (override)); MOCK_METHOD(ResumePolicy::Action, OnFinish, (Status const&), (override)); diff --git a/google/cloud/storage/tests/async_client_integration_test.cc b/google/cloud/storage/tests/async_client_integration_test.cc index 384df663caa89..7175f703eedcc 100644 --- a/google/cloud/storage/tests/async_client_integration_test.cc +++ b/google/cloud/storage/tests/async_client_integration_test.cc @@ -36,7 +36,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -85,8 +85,8 @@ auto TestOptions() { } auto AlwaysRetry() { - return TestOptions().set( - MakeAlwaysRetryIdempotencyPolicy); + return TestOptions().set( + MakeAlwaysRetryAsyncIdempotencyPolicy); } TEST_F(AsyncClientIntegrationTest, ObjectCRUD) { @@ -1006,8 +1006,8 @@ TEST_F(AsyncClientIntegrationTest, Open) { TEST_F(AsyncClientIntegrationTest, OpenExceedMaximumRange) { GTEST_SKIP(); - auto async = AsyncClient( - TestOptions().set(1024)); + auto async = + AsyncClient(TestOptions().set(1024)); auto client = MakeIntegrationTestClient(true, TestOptions()); auto object_name = MakeRandomObjectName(); @@ -1061,7 +1061,7 @@ TEST_F(AsyncClientIntegrationTest, OpenExceedMaximumRange) { } // namespace GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google diff --git a/google/cloud/storage/tests/smoke_test_async.cc b/google/cloud/storage/tests/smoke_test_async.cc index 964fda45a86f1..b72739d603fcb 100644 --- a/google/cloud/storage/tests/smoke_test_async.cc +++ b/google/cloud/storage/tests/smoke_test_async.cc @@ -27,7 +27,7 @@ namespace google { namespace cloud { -namespace storage_experimental { +namespace storage { GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN namespace { @@ -72,7 +72,7 @@ TEST(SmokeTest, Grpc) { } // namespace GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END -} // namespace storage_experimental +} // namespace storage } // namespace cloud } // namespace google From fd02dc08c1ecff85004a6a82d01a8ea1d339d932 Mon Sep 17 00:00:00 2001 From: bajajnehaa Date: Wed, 1 Oct 2025 12:08:47 +0000 Subject: [PATCH 2/5] fix ci failures --- .../examples/storage_async_mock_samples.cc | 26 +- .../storage/examples/storage_async_samples.cc | 294 +++++++++--------- 2 files changed, 154 insertions(+), 166 deletions(-) diff --git a/google/cloud/storage/examples/storage_async_mock_samples.cc b/google/cloud/storage/examples/storage_async_mock_samples.cc index 212866d39fb88..ddb9baccc4513 100644 --- a/google/cloud/storage/examples/storage_async_mock_samples.cc +++ b/google/cloud/storage/examples/storage_async_mock_samples.cc @@ -32,16 +32,16 @@ using ::testing::Return; /// Shows how to mock simple APIs, including `DeleteObject` and `ComposeObject`. TEST(StorageAsyncMockingSamples, MockDeleteObject) { namespace gc = ::google::cloud; - namespace gcs_ex = ::google::cloud::storage_experimental; + namespace gcs = ::google::cloud::storage; auto mock = std::make_shared(); EXPECT_CALL(*mock, options); EXPECT_CALL(*mock, DeleteObject) .WillOnce(Return(ByMove(gc::make_ready_future(gc::Status{})))); - auto client = gcs_ex::AsyncClient(mock); + auto client = gcs::AsyncClient(mock); auto actual = - client.DeleteObject(gcs_ex::BucketName("test-bucket"), "test-object") + client.DeleteObject(gcs::BucketName("test-bucket"), "test-object") .get(); EXPECT_TRUE(actual.ok()); } @@ -51,13 +51,13 @@ TEST(StorageAsyncMockingSamples, MockDeleteObject) { /// Shows how to mock more complex APIs, such as `ReadObject()`. TEST(StorageAsyncMockingSamples, MockReadObject) { namespace gc = ::google::cloud; - namespace gcs_ex = ::google::cloud::storage_experimental; + namespace gcs = ::google::cloud::storage; auto mock = std::make_shared(); EXPECT_CALL(*mock, options); EXPECT_CALL(*mock, ReadObject).WillOnce([] { - using ReadResponse = gcs_ex::AsyncReaderConnection::ReadResponse; - using ReadPayload = gcs_ex::ReadPayload; + using ReadResponse = gcs::AsyncReaderConnection::ReadResponse; + using ReadPayload = gcs::ReadPayload; auto reader = std::make_unique< google::cloud::storage_mocks::MockAsyncReaderConnection>(); EXPECT_CALL(*reader, Read) @@ -74,22 +74,22 @@ TEST(StorageAsyncMockingSamples, MockReadObject) { return gc::make_ready_future(ReadResponse(gc::Status{})); }); return gc::make_ready_future(gc::make_status_or( - std::unique_ptr(std::move(reader)))); + std::unique_ptr(std::move(reader)))); }); - auto client = gcs_ex::AsyncClient(mock); + auto client = gcs::AsyncClient(mock); // To simplify the test we use .get() to "block" until the gc::future is // ready, and then use `.value()` to get the `StatusOr<>` values or an // exception. - gcs_ex::AsyncReader reader; - gcs_ex::AsyncToken token; + gcs::AsyncReader reader; + gcs::AsyncToken token; std::tie(reader, token) = - client.ReadObject(gcs_ex::BucketName("test-bucket"), "test-object") + client.ReadObject(gcs::BucketName("test-bucket"), "test-object") .get() .value(); - gcs_ex::ReadPayload payload; - gcs_ex::AsyncToken t; // Avoid use-after-move warnings from clang-tidy. + gcs::ReadPayload payload; + gcs::AsyncToken t; // Avoid use-after-move warnings from clang-tidy. std::tie(payload, t) = reader.Read(std::move(token)).get().value(); token = std::move(t); EXPECT_THAT(payload.contents(), ElementsAre("test-contents")); diff --git a/google/cloud/storage/examples/storage_async_samples.cc b/google/cloud/storage/examples/storage_async_samples.cc index 853b8225cc567..7f47a24fde99e 100644 --- a/google/cloud/storage/examples/storage_async_samples.cc +++ b/google/cloud/storage/examples/storage_async_samples.cc @@ -40,7 +40,7 @@ namespace examples = ::google::cloud::storage::examples; void CreateClient() { //! [async-client] - auto client = google::cloud::storage_experimental::AsyncClient(); + auto client = google::cloud::storage::AsyncClient(); // Use the client. //! [async-client] } @@ -48,21 +48,21 @@ void CreateClient() { //! [async-client-with-dp] void CreateClientWithDP() { namespace g = ::google::cloud; - auto client = google::cloud::storage_experimental::AsyncClient( + auto client = google::cloud::storage::AsyncClient( g::Options{}.set( "google-c2p:///storage.googleapis.com")); // Use the client. } //! [async-client-with-dp] -void InsertObject(google::cloud::storage_experimental::AsyncClient& client, +void InsertObject(google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [insert-object] - namespace gcs_ex = google::cloud::storage_experimental; - [](gcs_ex::AsyncClient& client, std::string bucket_name, + namespace gcs = google::cloud::storage; + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) { auto object = client.InsertObject( - gcs_ex::BucketName(std::move(bucket_name)), std::move(object_name), + gcs::BucketName(std::move(bucket_name)), std::move(object_name), std::string("Hello World!\n")); // Attach a callback, this is called when the upload completes. auto done = object.then([](auto f) { @@ -79,15 +79,15 @@ void InsertObject(google::cloud::storage_experimental::AsyncClient& client, } void InsertObjectVectorStrings( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [insert-object-vs] - namespace gcs_ex = google::cloud::storage_experimental; - [](gcs_ex::AsyncClient& client, std::string bucket_name, + namespace gcs = google::cloud::storage; + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) { auto contents = std::vector{"Hello", " ", "World!"}; auto object = - client.InsertObject(gcs_ex::BucketName(std::move(bucket_name)), + client.InsertObject(gcs::BucketName(std::move(bucket_name)), std::move(object_name), std::move(contents)); // Attach a callback, this is called when the upload completes. auto done = object.then([](auto f) { @@ -104,15 +104,15 @@ void InsertObjectVectorStrings( } void InsertObjectVector( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [insert-object-v] - namespace gcs_ex = google::cloud::storage_experimental; - [](gcs_ex::AsyncClient& client, std::string bucket_name, + namespace gcs = google::cloud::storage; + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) { auto contents = std::vector(1024, 0xFF); auto object = - client.InsertObject(gcs_ex::BucketName(std::move(bucket_name)), + client.InsertObject(gcs::BucketName(std::move(bucket_name)), std::move(object_name), std::move(contents)); // Attach a callback, this is called when the upload completes. auto done = object.then([](auto f) { @@ -129,17 +129,17 @@ void InsertObjectVector( } void InsertObjectVectorVectors( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [insert-object-vv] - namespace gcs_ex = google::cloud::storage_experimental; - [](gcs_ex::AsyncClient& client, std::string bucket_name, + namespace gcs = google::cloud::storage; + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) { using Buffer = std::vector; auto contents = std::vector{Buffer(1024, 'a'), Buffer(1024, 'b'), Buffer(1024, 'c')}; auto object = - client.InsertObject(gcs_ex::BucketName(std::move(bucket_name)), + client.InsertObject(gcs::BucketName(std::move(bucket_name)), std::move(object_name), std::move(contents)); // Attach a callback, this is called when the upload completes. auto done = object.then([](auto f) { @@ -157,17 +157,16 @@ void InsertObjectVectorVectors( #if GOOGLE_CLOUD_CPP_HAVE_COROUTINES void OpenObjectSingleRangedRead( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [open-object-single-ranged-read] - // [START storage_open_object_single_ranged_read] - namespace gcs_ex = google::cloud::storage_experimental; + namespace gcs = google::cloud::storage; // Helper coroutine to count newlines returned by an AsyncReader. // This helps consume the data from the read operation. auto count_newlines = - [](gcs_ex::AsyncReader reader, - gcs_ex::AsyncToken token) -> google::cloud::future { + [](gcs::AsyncReader reader, + gcs::AsyncToken token) -> google::cloud::future { std::uint64_t count = 0; while (token.valid()) { auto [payload, t] = (co_await reader.Read(std::move(token))).value(); @@ -181,10 +180,10 @@ void OpenObjectSingleRangedRead( auto coro = [&count_newlines]( - gcs_ex::AsyncClient& client, std::string bucket_name, + gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { auto descriptor = - (co_await client.Open(gcs_ex::BucketName(std::move(bucket_name)), + (co_await client.Open(gcs::BucketName(std::move(bucket_name)), std::move(object_name))) .value(); @@ -202,16 +201,16 @@ void OpenObjectSingleRangedRead( } void OpenObjectMultipleRangedRead( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [open-object-multiple-ranged-read] // [START storage_open_object_multiple_ranged_read] - namespace gcs_ex = google::cloud::storage_experimental; + namespace gcs = google::cloud::storage; // Helper coroutine to count newlines returned by an AsyncReader. auto count_newlines = - [](gcs_ex::AsyncReader reader, - gcs_ex::AsyncToken token) -> google::cloud::future { + [](gcs::AsyncReader reader, + gcs::AsyncToken token) -> google::cloud::future { std::uint64_t count = 0; while (token.valid()) { auto [payload, t] = (co_await reader.Read(std::move(token))).value(); @@ -225,10 +224,10 @@ void OpenObjectMultipleRangedRead( auto coro = [&count_newlines]( - gcs_ex::AsyncClient& client, std::string bucket_name, + gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { auto descriptor = - (co_await client.Open(gcs_ex::BucketName(std::move(bucket_name)), + (co_await client.Open(gcs::BucketName(std::move(bucket_name)), std::move(object_name))) .value(); @@ -251,17 +250,17 @@ void OpenObjectMultipleRangedRead( } void OpenObjectReadFullObject( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [open-object-read-full-object] // [START storage_open_object_read_full_object] - namespace gcs_ex = google::cloud::storage_experimental; + namespace gcs = google::cloud::storage; // Helper coroutine to count newlines returned by an AsyncReader. // This helps consume the data from the read operation. auto count_newlines = - [](gcs_ex::AsyncReader reader, - gcs_ex::AsyncToken token) -> google::cloud::future { + [](gcs::AsyncReader reader, + gcs::AsyncToken token) -> google::cloud::future { std::uint64_t count = 0; while (token.valid()) { auto [payload, t] = (co_await reader.Read(std::move(token))).value(); @@ -275,10 +274,10 @@ void OpenObjectReadFullObject( auto coro = [&count_newlines]( - gcs_ex::AsyncClient& client, std::string bucket_name, + gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { auto descriptor = - (co_await client.Open(gcs_ex::BucketName(std::move(bucket_name)), + (co_await client.Open(gcs::BucketName(std::move(bucket_name)), std::move(object_name))) .value(); @@ -360,16 +359,16 @@ void OpenMultipleObjectsRangedRead( coro(client, argv.at(0), argv.at(1), argv.at(2), argv.at(3)).get(); } -void ReadObject(google::cloud::storage_experimental::AsyncClient& client, +void ReadObject(google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [read-object] // [START storage_read_object] - namespace gcs_ex = google::cloud::storage_experimental; + namespace gcs = google::cloud::storage; auto coro = - [](gcs_ex::AsyncClient& client, std::string bucket_name, + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { auto [reader, token] = - (co_await client.ReadObject(gcs_ex::BucketName(std::move(bucket_name)), + (co_await client.ReadObject(gcs::BucketName(std::move(bucket_name)), std::move(object_name))) .value(); std::uint64_t count = 0; @@ -390,18 +389,18 @@ void ReadObject(google::cloud::storage_experimental::AsyncClient& client, std::cout << "The object contains " << count << " lines\n"; } -void ReadAll(google::cloud::storage_experimental::AsyncClient& client, +void ReadAll(google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [read-all] // [START storage_read_all] - namespace gcs_ex = google::cloud::storage_experimental; + namespace gcs = google::cloud::storage; auto coro = - [](gcs_ex::AsyncClient& client, std::string bucket_name, + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { // For small objects, consider `ReadAll()` which accumulates all the // contents in memory using background threads. - auto payload = (co_await gcs_ex::ReadAll(client.ReadObject( - gcs_ex::BucketName(std::move(bucket_name)), + auto payload = (co_await gcs::ReadAll(client.ReadObject( + gcs::BucketName(std::move(bucket_name)), std::move(object_name)))) .value(); std::uint64_t count = 0; @@ -419,17 +418,16 @@ void ReadAll(google::cloud::storage_experimental::AsyncClient& client, } void ReadObjectWithOptions( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [read-object-with-options] namespace gcs = google::cloud::storage; - namespace gcs_ex = google::cloud::storage_experimental; auto coro = - [](gcs_ex::AsyncClient& client, std::string bucket_name, + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name, std::int64_t generation) -> google::cloud::future { auto request = google::storage::v2::ReadObjectRequest{}; - request.set_bucket(gcs_ex::BucketName(std::move(bucket_name)).FullName()); + request.set_bucket(gcs::BucketName(std::move(bucket_name)).FullName()); request.set_object(std::move(object_name)); request.set_generation(generation); auto [reader, token] = @@ -452,17 +450,17 @@ void ReadObjectWithOptions( std::cout << "The object contains " << count << " lines\n"; } -void ReadObjectRange(google::cloud::storage_experimental::AsyncClient& client, +void ReadObjectRange(google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [read-object-range] // [START storage_read_object_range] - namespace gcs_ex = google::cloud::storage_experimental; + namespace gcs = google::cloud::storage; auto coro = - [](gcs_ex::AsyncClient& client, std::string bucket_name, + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { // Read the first 8 bytes of the object. auto payload = (co_await client.ReadObjectRange( - gcs_ex::BucketName(std::move(bucket_name)), + gcs::BucketName(std::move(bucket_name)), std::move(object_name), /*offset=*/0, /*limit=*/8)) .value(); auto contents = payload.contents(); @@ -481,20 +479,19 @@ void ReadObjectRange(google::cloud::storage_experimental::AsyncClient& client, } void StartBufferedUpload( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storag::AsyncClient& client, std::vector const& argv) { //! [start-buffered-upload] namespace gcs = google::cloud::storage; - namespace gcs_ex = google::cloud::storage_experimental; - auto coro = [](gcs_ex::AsyncClient& client, std::string bucket_name, + auto coro = [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { auto [writer, token] = (co_await client.StartBufferedUpload( - gcs_ex::BucketName(std::move(bucket_name)), + gcs::BucketName(std::move(bucket_name)), std::move(object_name))) .value(); for (int i = 0; i != 1000; ++i) { - auto line = gcs_ex::WritePayload(std::vector{ + auto line = gcs::WritePayload(std::vector{ std::string("line number "), std::to_string(i), std::string("\n")}); token = (co_await writer.Write(std::move(token), std::move(line))).value(); @@ -509,13 +506,12 @@ void StartBufferedUpload( } std::string SuspendBufferedUpload( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [suspend-buffered-upload] namespace gcs = google::cloud::storage; - namespace gcs_ex = google::cloud::storage_experimental; auto coro = - [](gcs_ex::AsyncClient& client, std::string bucket_name, + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { // Use the overload consuming // `google::storage::v2::StartResumableWriteRequest` and show how to set @@ -523,7 +519,7 @@ std::string SuspendBufferedUpload( auto request = google::storage::v2::StartResumableWriteRequest{}; auto& spec = *request.mutable_write_object_spec(); spec.mutable_resource()->set_bucket( - gcs_ex::BucketName(bucket_name).FullName()); + gcs::BucketName(bucket_name).FullName()); spec.mutable_resource()->set_name(std::move(object_name)); spec.mutable_resource()->mutable_metadata()->emplace("custom-field", "example"); @@ -544,12 +540,11 @@ std::string SuspendBufferedUpload( } void ResumeBufferedUpload( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [resume-buffered-upload] namespace gcs = google::cloud::storage; - namespace gcs_ex = google::cloud::storage_experimental; - auto coro = [](gcs_ex::AsyncClient& client, std::string upload_id) + auto coro = [](gcs::AsyncClient& client, std::string upload_id) -> google::cloud::future { auto [writer, token] = (co_await client.ResumeBufferedUpload(std::move(upload_id))).value(); @@ -567,7 +562,7 @@ void ResumeBufferedUpload( throw std::invalid_argument("example cannot resume after partial upload"); } for (int i = 0; i != 1000; ++i) { - auto line = gcs_ex::WritePayload(std::vector{ + auto line = gcs::WritePayload(std::vector{ std::string("line number "), std::to_string(i), std::string("\n")}); token = (co_await writer.Write(std::move(token), std::move(line))).value(); @@ -582,19 +577,18 @@ void ResumeBufferedUpload( } void StartUnbufferedUpload( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [start-unbuffered-upload] namespace gcs = google::cloud::storage; - namespace gcs_ex = google::cloud::storage_experimental; - auto coro = [](gcs_ex::AsyncClient& client, std::string bucket_name, + auto coro = [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name, std::string const& filename) -> google::cloud::future { std::ifstream is(filename); if (is.bad()) throw std::runtime_error("Cannot read " + filename); auto [writer, token] = (co_await client.StartUnbufferedUpload( - gcs_ex::BucketName(std::move(bucket_name)), + gcs::BucketName(std::move(bucket_name)), std::move(object_name))) .value(); is.seekg(0); // clear EOF bit @@ -603,7 +597,7 @@ void StartUnbufferedUpload( is.read(buffer.data(), buffer.size()); buffer.resize(is.gcount()); token = (co_await writer.Write(std::move(token), - gcs_ex::WritePayload(std::move(buffer)))) + gcs::WritePayload(std::move(buffer)))) .value(); } co_return (co_await writer.Finalize(std::move(token))).value(); @@ -616,13 +610,12 @@ void StartUnbufferedUpload( } std::string SuspendUnbufferedUpload( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [suspend-unbuffered-upload] namespace gcs = google::cloud::storage; - namespace gcs_ex = google::cloud::storage_experimental; auto coro = - [](gcs_ex::AsyncClient& client, std::string bucket_name, + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name, std::string const& filename) -> google::cloud::future { std::ifstream is(filename); @@ -634,7 +627,7 @@ std::string SuspendUnbufferedUpload( auto request = google::storage::v2::StartResumableWriteRequest{}; auto& spec = *request.mutable_write_object_spec(); spec.mutable_resource()->set_bucket( - gcs_ex::BucketName(bucket_name).FullName()); + gcs::BucketName(bucket_name).FullName()); spec.mutable_resource()->set_name(std::move(object_name)); spec.mutable_resource()->mutable_metadata()->emplace("custom-field", "example"); @@ -649,7 +642,7 @@ std::string SuspendUnbufferedUpload( is.read(buffer.data(), buffer.size()); buffer.resize(is.gcount()); token = (co_await writer.Write(std::move(token), - gcs_ex::WritePayload(std::move(buffer)))) + gcs::WritePayload(std::move(buffer)))) .value(); // This example does not finalize the upload, so it can be resumed in a @@ -665,12 +658,11 @@ std::string SuspendUnbufferedUpload( } void ResumeUnbufferedUpload( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [resume-unbuffered-upload] namespace gcs = google::cloud::storage; - namespace gcs_ex = google::cloud::storage_experimental; - auto coro = [](gcs_ex::AsyncClient& client, std::string upload_id, + auto coro = [](gcs::AsyncClient& client, std::string upload_id, std::string filename) -> google::cloud::future { std::ifstream is(filename); @@ -692,7 +684,7 @@ void ResumeUnbufferedUpload( is.read(buffer.data(), buffer.size()); buffer.resize(is.gcount()); token = (co_await writer.Write(std::move(token), - gcs_ex::WritePayload(std::move(buffer)))) + gcs::WritePayload(std::move(buffer)))) .value(); } co_return (co_await writer.Finalize(std::move(token))).value(); @@ -705,22 +697,22 @@ void ResumeUnbufferedUpload( } void CreateAndWriteAppendableObject( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [create-and-write-appendable-object] // [START storage_create_and_write_appendable_object] - namespace gcs_ex = google::cloud::storage_experimental; - auto coro = [](gcs_ex::AsyncClient& client, std::string bucket_name, + namespace gcs = google::cloud::storage; + auto coro = [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { auto [writer, token] = (co_await client.StartAppendableObjectUpload( - gcs_ex::BucketName(std::move(bucket_name)), + gcs::BucketName(std::move(bucket_name)), std::move(object_name))) .value(); std::cout << "Appendable upload started for object " << object_name "\n"; token = (co_await writer.Write(std::move(token), - gcs_ex::WritePayload("Some data\n"))) + gcs::WritePayload("Some data\n"))) .value(); std::cout << "Wrote initial data.\n"; @@ -735,7 +727,7 @@ void CreateAndWriteAppendableObject( // The writer is still open. We can write more data. token = (co_await writer.Write(std::move(token), - gcs_ex::WritePayload("Some more data\n"))) + gcs::WritePayload("Some more data\n"))) .value(); std::cout << "Wrote more data.\n"; @@ -751,22 +743,21 @@ void CreateAndWriteAppendableObject( } void PauseAndResumeAppendableUpload( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [pause-and-resume-appendable-upload] // [START storage_pause_and_resume_appendable_upload] namespace gcs = google::cloud::storage; - namespace gcs_ex = google::cloud::storage_experimental; - auto coro = [](gcs_ex::AsyncClient& client, std::string bucket_name, + auto coro = [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { // Start an appendable upload and write some data. auto [writer, token] = (co_await client.StartAppendableObjectUpload( - gcs_ex::BucketName(bucket_name), object_name)) + gcs::BucketName(bucket_name), object_name)) .value(); std::cout << "Appendable upload started.\n"; token = (co_await writer.Write(std::move(token), - gcs_ex::WritePayload("paused data\n"))) + gcs::WritePayload("paused data\n"))) .value(); // The writer is closed, but the upload is not finalized. This "pauses" the @@ -784,7 +775,7 @@ void PauseAndResumeAppendableUpload( // Now resume the upload. std::tie(writer, token) = (co_await client.ResumeAppendableObjectUpload( - gcs_ex::BucketName(bucket_name), object_name, + gcs::BucketName(bucket_name), object_name, metadata.generation())) .value(); std::cout << "Upload resumed from offset " @@ -792,7 +783,7 @@ void PauseAndResumeAppendableUpload( // Append the rest of the data. token = (co_await writer.Write(std::move(token), - gcs_ex::WritePayload("resumed data\n"))) + gcs::WritePayload("resumed data\n"))) .value(); // Finalize the upload and return the object metadata. @@ -808,17 +799,17 @@ void PauseAndResumeAppendableUpload( } void FinalizeAppendableObjectUpload( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [finalize-appendable-object-upload] // [START storage_finalize_appendable_object_upload] - namespace gcs_ex = google::cloud::storage_experimental; - auto coro = [](gcs_ex::AsyncClient& client, std::string bucket_name, + namespace gcs = google::cloud::storage; + auto coro = [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { // Start an appendable upload. auto [writer, token] = (co_await client.StartAppendableObjectUpload( - gcs_ex::BucketName(std::move(bucket_name)), + gcs::BucketName(std::move(bucket_name)), std::move(object_name))) .value(); std::cout << "Appendable upload started. \n"; @@ -826,7 +817,7 @@ void FinalizeAppendableObjectUpload( // Write some data. token = (co_await writer.Write(std::move(token), - gcs_ex::WritePayload("some data to finalize\n"))) + gcs::WritePayload("some data to finalize\n"))) .value(); // Finalize the upload. This makes the object non-appendable. @@ -847,8 +838,7 @@ void ReadAppendableObjectTail( //! [read-appendable-object-tail] // [START storage_read_appendable_object_tail] namespace gcs = google::cloud::storage; - namespace gcs_ex = google::cloud::storage_experimental; - auto coro = [](gcs_ex::AsyncClient& client, std::string bucket_name, + auto coro = [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { // This coroutine simulates a "tail -f" command on a GCS object. It // repeatedly polls an appendable object for new content. In a real @@ -858,7 +848,7 @@ void ReadAppendableObjectTail( // Start an appendable upload. In a real application this would be done by // a separate process, and this application would only know the object name. auto [writer, token] = (co_await client.StartAppendableObjectUpload( - gcs_ex::BucketName(bucket_name), object_name)) + gcs::BucketName(bucket_name), object_name)) .value(); std::int64_t bytes_read = 0; @@ -868,13 +858,13 @@ void ReadAppendableObjectTail( auto content = "More data for tail example, iteration " + std::to_string(i) + "\n"; token = (co_await writer.Write(std::move(token), - gcs_ex::WritePayload(content))) + gcs::WritePayload(content))) .value(); (void)co_await writer.Flush(); // Poll for new content by reading from the last known offset. auto payload = - (co_await client.ReadObjectRange(gcs_ex::BucketName(bucket_name), + (co_await client.ReadObjectRange(gcs::BucketName(bucket_name), object_name, bytes_read, -1)) .value(); for (auto const& buffer : payload.contents()) { @@ -890,18 +880,17 @@ void ReadAppendableObjectTail( coro(client, argv.at(0), argv.at(1)).get(); } -void RewriteObject(google::cloud::storage_experimental::AsyncClient& client, +void RewriteObject(google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [rewrite-object] namespace g = google::cloud; namespace gcs = g::storage; - namespace gcs_ex = g::storage_experimental; - auto coro = [](gcs_ex::AsyncClient& client, std::string bucket_name, + auto coro = [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name, std::string destination_name) -> g::future { auto [rewriter, token] = - client.StartRewrite(gcs_ex::BucketName(bucket_name), object_name, - gcs_ex::BucketName(bucket_name), destination_name); + client.StartRewrite(gcs::BucketName(bucket_name), object_name, + gcs::BucketName(bucket_name), destination_name); while (token.valid()) { auto [progress, t] = (co_await rewriter.Iterate(std::move(token))).value(); @@ -920,19 +909,18 @@ void RewriteObject(google::cloud::storage_experimental::AsyncClient& client, std::cout << "Object successfully rewritten " << object.DebugString() << "\n"; } -void ResumeRewrite(google::cloud::storage_experimental::AsyncClient& client, +void ResumeRewrite(google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [resume-rewrite] namespace g = google::cloud; namespace gcs = g::storage; - namespace gcs_ex = g::storage_experimental; - auto start = [](gcs_ex::AsyncClient& client, std::string bucket_name, + auto start = [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name, std::string destination_name) -> g::future { // First start a rewrite. In this example we will limit the number of bytes // rewritten by each iteration, then capture the token, and then resume the // rewrite operation. - auto bucket = gcs_ex::BucketName(std::move(bucket_name)); + auto bucket = gcs::BucketName(std::move(bucket_name)); auto request = google::storage::v2::RewriteObjectRequest{}; request.set_destination_name(destination_name); request.set_destination_bucket(bucket.FullName()); @@ -944,12 +932,12 @@ void ResumeRewrite(google::cloud::storage_experimental::AsyncClient& client, co_return progress.rewrite_token(); }; auto resume = - [](gcs_ex::AsyncClient& client, std::string bucket_name, + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name, std::string destination_name, std::string rewrite_token) -> g::future { // Continue rewriting, this could happen on a separate process, or even // after the application restarts. - auto bucket = gcs_ex::BucketName(std::move(bucket_name)); + auto bucket = gcs::BucketName(std::move(bucket_name)); auto request = google::storage::v2::RewriteObjectRequest(); request.set_destination_bucket(bucket.FullName()); request.set_destination_name(std::move(destination_name)); @@ -980,98 +968,98 @@ void ResumeRewrite(google::cloud::storage_experimental::AsyncClient& client, #else void OpenObjectSingleRangedRead( - google::cloud::storage_experimental::AsyncClient&, + google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::Open() example requires coroutines\n"; } void OpenObjectMultipleRangedRead( - google::cloud::storage_experimental::AsyncClient&, + google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::Open() example requires coroutines\n"; } void OpenMultipleObjectsRangedRead( - google::cloud::storage_experimental::AsyncClient&, + google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::Open() example requires coroutines\n"; } -void OpenObjectReadFullObject(google::cloud::storage_experimental::AsyncClient&, +void OpenObjectReadFullObject(google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::Open() example requires coroutines\n"; } -void ReadObject(google::cloud::storage_experimental::AsyncClient&, +void ReadObject(google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::ReadObject() example requires coroutines\n"; } -void ReadAll(google::cloud::storage_experimental::AsyncClient&, +void ReadAll(google::cloud::storage::AsyncClient&, std::vector const&) { - std::cerr << "google::cloud::storage_experimental::ReadAll()" + std::cerr << "google::cloud::storage::ReadAll()" << " example requires coroutines\n"; } -void ReadObjectRange(google::cloud::storage_experimental::AsyncClient&, +void ReadObjectRange(google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::ReadObjectRange() example requires coroutines\n"; } -void ReadObjectWithOptions(google::cloud::storage_experimental::AsyncClient&, +void ReadObjectWithOptions(google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::ReadObject() example requires coroutines\n"; } -void StartBufferedUpload(google::cloud::storage_experimental::AsyncClient&, +void StartBufferedUpload(google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::StartBufferedUpload() example requires coroutines\n"; } std::string SuspendBufferedUpload( - google::cloud::storage_experimental::AsyncClient&, + google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::StartBufferedUpload() example requires coroutines\n"; return {}; } -void ResumeBufferedUpload(google::cloud::storage_experimental::AsyncClient&, +void ResumeBufferedUpload(google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::ResumeBufferedUpload() example requires coroutines\n"; } -void StartUnbufferedUpload(google::cloud::storage_experimental::AsyncClient&, +void StartUnbufferedUpload(google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::StartUnbufferedUpload() example requires coroutines\n"; } std::string SuspendUnbufferedUpload( - google::cloud::storage_experimental::AsyncClient&, + google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::StartUnbufferedUpload() example requires coroutines\n"; return {}; } -void ResumeUnbufferedUpload(google::cloud::storage_experimental::AsyncClient&, +void ResumeUnbufferedUpload(google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::ResumeUnbufferedUpload() example requires coroutines\n"; } void CreateAndWriteAppendableObject( - google::cloud::storage_experimental::AsyncClient&, + google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::CreateAndWriteAppendableObject() example requires " "coroutines\n"; } void PauseAndResumeAppendableUpload( - google::cloud::storage_experimental::AsyncClient&, + google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::PauseAndResumeAppendableUpload() example requires " "coroutines\n"; @@ -1090,23 +1078,23 @@ void ReadAppendableObjectTail(google::cloud::storage_experimental::AsyncClient&, "coroutines\n"; } -void RewriteObject(google::cloud::storage_experimental::AsyncClient&, +void RewriteObject(google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::RewriteObject() example requires coroutines\n"; } -void ResumeRewrite(google::cloud::storage_experimental::AsyncClient&, +void ResumeRewrite(google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::ResumeRewrite() example requires coroutines\n"; } #endif // GOOGLE_CLOUD_CPP -void ComposeObject(google::cloud::storage_experimental::AsyncClient& client, +void ComposeObject(google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [compose-object] namespace g = google::cloud; - namespace gcs_ex = g::storage_experimental; - [](gcs_ex::AsyncClient& client, std::string bucket_name, + namespace gcs = g::storage; + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name, std::string name1, std::string name2) { auto make_source = [](std::string name) { google::storage::v2::ComposeObjectRequest::SourceObject source; @@ -1115,7 +1103,7 @@ void ComposeObject(google::cloud::storage_experimental::AsyncClient& client, }; client .ComposeObject( - gcs_ex::BucketName(std::move(bucket_name)), std::move(object_name), + gcs::BucketName(std::move(bucket_name)), std::move(object_name), {make_source(std::move(name1)), make_source(std::move(name2))}) .then([](auto f) { auto metadata = f.get(); @@ -1130,16 +1118,16 @@ void ComposeObject(google::cloud::storage_experimental::AsyncClient& client, } void ComposeObjectRequest( - google::cloud::storage_experimental::AsyncClient& client, + google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [compose-object-request] namespace g = google::cloud; - namespace gcs_ex = g::storage_experimental; - [](gcs_ex::AsyncClient& client, std::string bucket_name, + namespace gcs = g::storage; + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name, std::string name1, std::string name2) { google::storage::v2::ComposeObjectRequest request; request.mutable_destination()->set_bucket( - gcs_ex::BucketName(std::move(bucket_name)).FullName()); + gcs::BucketName(std::move(bucket_name)).FullName()); request.mutable_destination()->set_name(std::move(object_name)); // Only create the destination object if it does not already exist. request.set_if_generation_match(0); @@ -1161,15 +1149,15 @@ void ComposeObjectRequest( // We would like to call this function `DeleteObject()`, but that conflicts with // a global `DeleteObject()` function on Windows. -void AsyncDeleteObject(google::cloud::storage_experimental::AsyncClient& client, +void AsyncDeleteObject(google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [delete-object] namespace g = google::cloud; - namespace gcs_ex = google::cloud::storage_experimental; - [](gcs_ex::AsyncClient& client, std::string bucket_name, + namespace gcs = google::cloud::storage; + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) { client - .DeleteObject(gcs_ex::BucketName(std::move(bucket_name)), + .DeleteObject(gcs::BucketName(std::move(bucket_name)), std::move(object_name)) .then([](auto f) { auto status = f.get(); @@ -1221,7 +1209,7 @@ void AutoRun(std::vector const& argv) { std::cout << "Running AsyncClientWithDP() example" << std::endl; CreateClientWithDPCommand({}); - auto client = google::cloud::storage_experimental::AsyncClient(); + auto client = google::cloud::storage::AsyncClient(); // We need different object names because writing to the same object within // a second exceeds the service's quota. @@ -1308,7 +1296,7 @@ void AutoRun(std::vector const& argv) { auto response = client .ReadObjectRange( - google::cloud::storage_experimental::BucketName(bucket_name), + google::cloud::storage::BucketName(bucket_name), composed_name, 0, 1) .get(); if (!response.ok()) throw std::move(response).status(); @@ -1368,7 +1356,7 @@ void AutoRun(std::vector const& argv) { auto const rewrite_source = object_name; (void)client .InsertObject( - google::cloud::storage_experimental::BucketName(bucket_name), + google::cloud::storage::BucketName(bucket_name), object_name, std::string(4 * 1024 * 1024, 'A')) .get() .value(); @@ -1426,7 +1414,7 @@ void AutoRun(std::vector const& argv) { scheduled_for_delete.push_back(std::move(object_name)); object_name = examples::MakeRandomObjectName(generator, "object-"); - auto bucket = google::cloud::storage_experimental::BucketName(bucket_name); + auto bucket = google::cloud::storage::BucketName(bucket_name); namespace g = ::google::cloud; std::vector> pending(scheduled_for_delete.size()); std::transform(scheduled_for_delete.begin(), scheduled_for_delete.end(), @@ -1440,7 +1428,7 @@ void AutoRun(std::vector const& argv) { int main(int argc, char* argv[]) try { using Command = - std::function)>; auto make_entry = [](std::string const& name, std::vector arg_names, @@ -1457,7 +1445,7 @@ int main(int argc, char* argv[]) try { } throw examples::Usage{std::move(os).str()}; } - auto client = google::cloud::storage_experimental::AsyncClient(); + auto client = google::cloud::storage::AsyncClient(); command(client, argv); }; return {name, std::move(adapter)}; @@ -1477,7 +1465,7 @@ int main(int argc, char* argv[]) try { } throw examples::Usage{std::move(os).str()}; } - auto client = google::cloud::storage_experimental::AsyncClient(); + auto client = google::cloud::storage::AsyncClient(); command(client, argv); }; return {name, std::move(adapter)}; From 4250a626a5f0a40002d7bfb759e59fe65e9c7883 Mon Sep 17 00:00:00 2001 From: bajajnehaa Date: Wed, 1 Oct 2025 12:16:21 +0000 Subject: [PATCH 3/5] checkers fix --- .../examples/storage_async_mock_samples.cc | 3 +- .../storage/examples/storage_async_samples.cc | 149 ++++++++---------- 2 files changed, 68 insertions(+), 84 deletions(-) diff --git a/google/cloud/storage/examples/storage_async_mock_samples.cc b/google/cloud/storage/examples/storage_async_mock_samples.cc index ddb9baccc4513..c24ee018cc589 100644 --- a/google/cloud/storage/examples/storage_async_mock_samples.cc +++ b/google/cloud/storage/examples/storage_async_mock_samples.cc @@ -41,8 +41,7 @@ TEST(StorageAsyncMockingSamples, MockDeleteObject) { auto client = gcs::AsyncClient(mock); auto actual = - client.DeleteObject(gcs::BucketName("test-bucket"), "test-object") - .get(); + client.DeleteObject(gcs::BucketName("test-bucket"), "test-object").get(); EXPECT_TRUE(actual.ok()); } //! [mock-async-delete-object] diff --git a/google/cloud/storage/examples/storage_async_samples.cc b/google/cloud/storage/examples/storage_async_samples.cc index 7f47a24fde99e..75c48dee8e527 100644 --- a/google/cloud/storage/examples/storage_async_samples.cc +++ b/google/cloud/storage/examples/storage_async_samples.cc @@ -48,8 +48,8 @@ void CreateClient() { //! [async-client-with-dp] void CreateClientWithDP() { namespace g = ::google::cloud; - auto client = google::cloud::storage::AsyncClient( - g::Options{}.set( + auto client = + google::cloud::storage::AsyncClient(g::Options{}.set( "google-c2p:///storage.googleapis.com")); // Use the client. } @@ -61,9 +61,9 @@ void InsertObject(google::cloud::storage::AsyncClient& client, namespace gcs = google::cloud::storage; [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) { - auto object = client.InsertObject( - gcs::BucketName(std::move(bucket_name)), std::move(object_name), - std::string("Hello World!\n")); + auto object = client.InsertObject(gcs::BucketName(std::move(bucket_name)), + std::move(object_name), + std::string("Hello World!\n")); // Attach a callback, this is called when the upload completes. auto done = object.then([](auto f) { auto metadata = f.get(); @@ -78,9 +78,8 @@ void InsertObject(google::cloud::storage::AsyncClient& client, (client, argv.at(0), argv.at(1)); } -void InsertObjectVectorStrings( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void InsertObjectVectorStrings(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [insert-object-vs] namespace gcs = google::cloud::storage; [](gcs::AsyncClient& client, std::string bucket_name, @@ -103,9 +102,8 @@ void InsertObjectVectorStrings( (client, argv.at(0), argv.at(1)); } -void InsertObjectVector( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void InsertObjectVector(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [insert-object-v] namespace gcs = google::cloud::storage; [](gcs::AsyncClient& client, std::string bucket_name, @@ -128,9 +126,8 @@ void InsertObjectVector( (client, argv.at(0), argv.at(1)); } -void InsertObjectVectorVectors( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void InsertObjectVectorVectors(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [insert-object-vv] namespace gcs = google::cloud::storage; [](gcs::AsyncClient& client, std::string bucket_name, @@ -156,9 +153,8 @@ void InsertObjectVectorVectors( } #if GOOGLE_CLOUD_CPP_HAVE_COROUTINES -void OpenObjectSingleRangedRead( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void OpenObjectSingleRangedRead(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [open-object-single-ranged-read] namespace gcs = google::cloud::storage; @@ -200,9 +196,8 @@ void OpenObjectSingleRangedRead( std::cout << "The range contains " << count << " newlines\n"; } -void OpenObjectMultipleRangedRead( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void OpenObjectMultipleRangedRead(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [open-object-multiple-ranged-read] // [START storage_open_object_multiple_ranged_read] namespace gcs = google::cloud::storage; @@ -249,9 +244,8 @@ void OpenObjectMultipleRangedRead( std::cout << "The ranges contain " << count << " newlines\n"; } -void OpenObjectReadFullObject( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void OpenObjectReadFullObject(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [open-object-read-full-object] // [START storage_open_object_read_full_object] namespace gcs = google::cloud::storage; @@ -399,10 +393,10 @@ void ReadAll(google::cloud::storage::AsyncClient& client, std::string object_name) -> google::cloud::future { // For small objects, consider `ReadAll()` which accumulates all the // contents in memory using background threads. - auto payload = (co_await gcs::ReadAll(client.ReadObject( - gcs::BucketName(std::move(bucket_name)), - std::move(object_name)))) - .value(); + auto payload = + (co_await gcs::ReadAll(client.ReadObject( + gcs::BucketName(std::move(bucket_name)), std::move(object_name)))) + .value(); std::uint64_t count = 0; for (auto const& buffer : payload.contents()) { count += std::count(buffer.begin(), buffer.end(), '\n'); @@ -417,9 +411,8 @@ void ReadAll(google::cloud::storage::AsyncClient& client, std::cout << "The object contains " << count << " lines\n"; } -void ReadObjectWithOptions( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void ReadObjectWithOptions(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [read-object-with-options] namespace gcs = google::cloud::storage; auto coro = @@ -478,18 +471,17 @@ void ReadObjectRange(google::cloud::storage::AsyncClient& client, std::cout << "The object range contains " << count << " lines\n"; } -void StartBufferedUpload( - google::cloud::storag::AsyncClient& client, - std::vector const& argv) { +void StartBufferedUpload(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [start-buffered-upload] namespace gcs = google::cloud::storage; auto coro = [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { - auto [writer, token] = (co_await client.StartBufferedUpload( - gcs::BucketName(std::move(bucket_name)), - std::move(object_name))) - .value(); + auto [writer, token] = + (co_await client.StartBufferedUpload( + gcs::BucketName(std::move(bucket_name)), std::move(object_name))) + .value(); for (int i = 0; i != 1000; ++i) { auto line = gcs::WritePayload(std::vector{ std::string("line number "), std::to_string(i), std::string("\n")}); @@ -505,9 +497,8 @@ void StartBufferedUpload( std::cout << "Object successfully uploaded " << object.DebugString() << "\n"; } -std::string SuspendBufferedUpload( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +std::string SuspendBufferedUpload(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [suspend-buffered-upload] namespace gcs = google::cloud::storage; auto coro = @@ -539,9 +530,8 @@ std::string SuspendBufferedUpload( return upload_id; } -void ResumeBufferedUpload( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void ResumeBufferedUpload(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [resume-buffered-upload] namespace gcs = google::cloud::storage; auto coro = [](gcs::AsyncClient& client, std::string upload_id) @@ -576,9 +566,8 @@ void ResumeBufferedUpload( std::cout << "Object successfully uploaded " << object.DebugString() << "\n"; } -void StartUnbufferedUpload( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void StartUnbufferedUpload(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [start-unbuffered-upload] namespace gcs = google::cloud::storage; auto coro = [](gcs::AsyncClient& client, std::string bucket_name, @@ -587,10 +576,10 @@ void StartUnbufferedUpload( std::ifstream is(filename); if (is.bad()) throw std::runtime_error("Cannot read " + filename); - auto [writer, token] = (co_await client.StartUnbufferedUpload( - gcs::BucketName(std::move(bucket_name)), - std::move(object_name))) - .value(); + auto [writer, token] = + (co_await client.StartUnbufferedUpload( + gcs::BucketName(std::move(bucket_name)), std::move(object_name))) + .value(); is.seekg(0); // clear EOF bit while (token.valid() && !is.eof()) { std::vector buffer(1024 * 1024); @@ -609,9 +598,8 @@ void StartUnbufferedUpload( std::cout << "File successfully uploaded " << object.DebugString() << "\n"; } -std::string SuspendUnbufferedUpload( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +std::string SuspendUnbufferedUpload(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [suspend-unbuffered-upload] namespace gcs = google::cloud::storage; auto coro = @@ -657,9 +645,8 @@ std::string SuspendUnbufferedUpload( return upload_id; } -void ResumeUnbufferedUpload( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void ResumeUnbufferedUpload(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [resume-unbuffered-upload] namespace gcs = google::cloud::storage; auto coro = [](gcs::AsyncClient& client, std::string upload_id, @@ -967,13 +954,17 @@ void ResumeRewrite(google::cloud::storage::AsyncClient& client, } #else -void OpenObjectSingleRangedRead( - google::cloud::storage::AsyncClient&, - std::vector const&) { +void OpenObjectSingleRangedRead(google::cloud::storage::AsyncClient&, + std::vector const&) { + std::cerr << "AsyncClient::Open() example requires coroutines\n"; +} + +void OpenObjectMultipleRangedRead(google::cloud::storage::AsyncClient&, + std::vector const&) { std::cerr << "AsyncClient::Open() example requires coroutines\n"; } -void OpenObjectMultipleRangedRead( +void OpenMultipleObjectsRangedRead( google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::Open() example requires coroutines\n"; @@ -1017,9 +1008,8 @@ void StartBufferedUpload(google::cloud::storage::AsyncClient&, << "AsyncClient::StartBufferedUpload() example requires coroutines\n"; } -std::string SuspendBufferedUpload( - google::cloud::storage::AsyncClient&, - std::vector const&) { +std::string SuspendBufferedUpload(google::cloud::storage::AsyncClient&, + std::vector const&) { std::cerr << "AsyncClient::StartBufferedUpload() example requires coroutines\n"; return {}; @@ -1037,9 +1027,8 @@ void StartUnbufferedUpload(google::cloud::storage::AsyncClient&, << "AsyncClient::StartUnbufferedUpload() example requires coroutines\n"; } -std::string SuspendUnbufferedUpload( - google::cloud::storage::AsyncClient&, - std::vector const&) { +std::string SuspendUnbufferedUpload(google::cloud::storage::AsyncClient&, + std::vector const&) { std::cerr << "AsyncClient::StartUnbufferedUpload() example requires coroutines\n"; return {}; @@ -1094,8 +1083,8 @@ void ComposeObject(google::cloud::storage::AsyncClient& client, //! [compose-object] namespace g = google::cloud; namespace gcs = g::storage; - [](gcs::AsyncClient& client, std::string bucket_name, - std::string object_name, std::string name1, std::string name2) { + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name, + std::string name1, std::string name2) { auto make_source = [](std::string name) { google::storage::v2::ComposeObjectRequest::SourceObject source; source.set_name(std::move(name)); @@ -1117,14 +1106,13 @@ void ComposeObject(google::cloud::storage::AsyncClient& client, (client, argv.at(0), argv.at(1), argv.at(2), argv.at(3)); } -void ComposeObjectRequest( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void ComposeObjectRequest(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [compose-object-request] namespace g = google::cloud; namespace gcs = g::storage; - [](gcs::AsyncClient& client, std::string bucket_name, - std::string object_name, std::string name1, std::string name2) { + [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name, + std::string name1, std::string name2) { google::storage::v2::ComposeObjectRequest request; request.mutable_destination()->set_bucket( gcs::BucketName(std::move(bucket_name)).FullName()); @@ -1295,9 +1283,8 @@ void AutoRun(std::vector const& argv) { std::cout << "Retrieving object metadata" << std::endl; auto response = client - .ReadObjectRange( - google::cloud::storage::BucketName(bucket_name), - composed_name, 0, 1) + .ReadObjectRange(google::cloud::storage::BucketName(bucket_name), + composed_name, 0, 1) .get(); if (!response.ok()) throw std::move(response).status(); @@ -1355,9 +1342,8 @@ void AutoRun(std::vector const& argv) { std::cout << "Running the ResumeRewrite() example" << std::endl; auto const rewrite_source = object_name; (void)client - .InsertObject( - google::cloud::storage::BucketName(bucket_name), - object_name, std::string(4 * 1024 * 1024, 'A')) + .InsertObject(google::cloud::storage::BucketName(bucket_name), + object_name, std::string(4 * 1024 * 1024, 'A')) .get() .value(); scheduled_for_delete.push_back(std::move(object_name)); @@ -1427,9 +1413,8 @@ void AutoRun(std::vector const& argv) { } // namespace int main(int argc, char* argv[]) try { - using Command = - std::function)>; + using Command = std::function)>; auto make_entry = [](std::string const& name, std::vector arg_names, Command const& command) -> examples::Commands::value_type { From 783d3ba0925a124286e9196ab44009361d928889 Mon Sep 17 00:00:00 2001 From: bajajnehaa Date: Tue, 7 Oct 2025 08:19:19 +0000 Subject: [PATCH 4/5] No default for MaximumRangeSizeOption till we decide one --- .../storage/examples/storage_async_samples.cc | 99 +++++++++---------- .../storage/examples/storage_otel_samples.cc | 11 +-- .../storage/internal/async/default_options.cc | 6 +- .../internal/async/default_options_test.cc | 3 + .../tests/async_client_integration_test.cc | 2 + 5 files changed, 58 insertions(+), 63 deletions(-) diff --git a/google/cloud/storage/examples/storage_async_samples.cc b/google/cloud/storage/examples/storage_async_samples.cc index 75c48dee8e527..576c6f448a057 100644 --- a/google/cloud/storage/examples/storage_async_samples.cc +++ b/google/cloud/storage/examples/storage_async_samples.cc @@ -288,17 +288,16 @@ void OpenObjectReadFullObject(google::cloud::storage::AsyncClient& client, std::cout << "The range contains " << count << " newlines\n"; } -void OpenMultipleObjectsRangedRead( - google::cloud::storage_experimental::AsyncClient& client, - std::vector const& argv) { +void OpenMultipleObjectsRangedRead(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [open-multiple-objects-ranged-read] // [START storage_open_multiple_objects_ranged_read] - namespace gcs_ex = google::cloud::storage_experimental; + namespace gcs = google::cloud::storage; // Helper coroutine to count newlines returned by an AsyncReader. auto count_newlines = - [](gcs_ex::AsyncReader reader, - gcs_ex::AsyncToken token) -> google::cloud::future { + [](gcs::AsyncReader reader, + gcs::AsyncToken token) -> google::cloud::future { std::uint64_t count = 0; while (token.valid()) { auto [payload, t] = (co_await reader.Read(std::move(token))).value(); @@ -311,7 +310,7 @@ void OpenMultipleObjectsRangedRead( }; auto coro = [&count_newlines]( - gcs_ex::AsyncClient& client, std::string bucket_name, + gcs::AsyncClient& client, std::string bucket_name, std::string object_name1, std::string object_name2, std::string object_name3) -> google::cloud::future { // List of object names to read (passed as arguments) @@ -323,7 +322,7 @@ void OpenMultipleObjectsRangedRead( // This example opens multiple objects, not one object multiple times. for (auto const& name : object_names) { auto descriptor = - (co_await client.Open(gcs_ex::BucketName(bucket_name), name)).value(); + (co_await client.Open(gcs::BucketName(bucket_name), name)).value(); auto [reader, token] = descriptor.Read(0, 1024); futures.push_back(count_newlines(std::move(reader), std::move(token))); } @@ -387,7 +386,7 @@ void ReadAll(google::cloud::storage::AsyncClient& client, std::vector const& argv) { //! [read-all] // [START storage_read_all] - namespace gcs = google::cloud::storage; + namespace gcs = google::cloud::storage; auto coro = [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { @@ -683,19 +682,18 @@ void ResumeUnbufferedUpload(google::cloud::storage::AsyncClient& client, std::cout << "Object successfully uploaded " << object.DebugString() << "\n"; } -void CreateAndWriteAppendableObject( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void CreateAndWriteAppendableObject(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [create-and-write-appendable-object] // [START storage_create_and_write_appendable_object] namespace gcs = google::cloud::storage; auto coro = [](gcs::AsyncClient& client, std::string bucket_name, std::string object_name) -> google::cloud::future { - auto [writer, token] = (co_await client.StartAppendableObjectUpload( - gcs::BucketName(std::move(bucket_name)), - std::move(object_name))) - .value(); + auto [writer, token] = + (co_await client.StartAppendableObjectUpload( + gcs::BucketName(std::move(bucket_name)), std::move(object_name))) + .value(); std::cout << "Appendable upload started for object " << object_name "\n"; token = (co_await writer.Write(std::move(token), @@ -729,9 +727,8 @@ void CreateAndWriteAppendableObject( std::cout << "File successfully uploaded " << object.DebugString() << "\n"; } -void PauseAndResumeAppendableUpload( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void PauseAndResumeAppendableUpload(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [pause-and-resume-appendable-upload] // [START storage_pause_and_resume_appendable_upload] namespace gcs = google::cloud::storage; @@ -761,10 +758,10 @@ void PauseAndResumeAppendableUpload( std::cout << "Object generation is " << metadata.generation() << "\n"; // Now resume the upload. - std::tie(writer, token) = (co_await client.ResumeAppendableObjectUpload( - gcs::BucketName(bucket_name), object_name, - metadata.generation())) - .value(); + std::tie(writer, token) = + (co_await client.ResumeAppendableObjectUpload( + gcs::BucketName(bucket_name), object_name, metadata.generation())) + .value(); std::cout << "Upload resumed from offset " << absl::get(writer.PersistedState()) << "\n"; @@ -785,9 +782,8 @@ void PauseAndResumeAppendableUpload( << object.DebugString() << "\n"; } -void FinalizeAppendableObjectUpload( - google::cloud::storage::AsyncClient& client, - std::vector const& argv) { +void FinalizeAppendableObjectUpload(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [finalize-appendable-object-upload] // [START storage_finalize_appendable_object_upload] namespace gcs = google::cloud::storage; @@ -795,10 +791,10 @@ void FinalizeAppendableObjectUpload( std::string object_name) -> google::cloud::future { // Start an appendable upload. - auto [writer, token] = (co_await client.StartAppendableObjectUpload( - gcs::BucketName(std::move(bucket_name)), - std::move(object_name))) - .value(); + auto [writer, token] = + (co_await client.StartAppendableObjectUpload( + gcs::BucketName(std::move(bucket_name)), std::move(object_name))) + .value(); std::cout << "Appendable upload started. \n"; // Write some data. @@ -819,9 +815,8 @@ void FinalizeAppendableObjectUpload( std::cout << "Finalized object: " << object.DebugString() << "\n"; } -void ReadAppendableObjectTail( - google::cloud::storage_experimental::AsyncClient& client, - std::vector const& argv) { +void ReadAppendableObjectTail(google::cloud::storage::AsyncClient& client, + std::vector const& argv) { //! [read-appendable-object-tail] // [START storage_read_appendable_object_tail] namespace gcs = google::cloud::storage; @@ -844,9 +839,9 @@ void ReadAppendableObjectTail( // We simulate this by writing to the object. auto content = "More data for tail example, iteration " + std::to_string(i) + "\n"; - token = (co_await writer.Write(std::move(token), - gcs::WritePayload(content))) - .value(); + token = + (co_await writer.Write(std::move(token), gcs::WritePayload(content))) + .value(); (void)co_await writer.Flush(); // Poll for new content by reading from the last known offset. @@ -964,15 +959,13 @@ void OpenObjectMultipleRangedRead(google::cloud::storage::AsyncClient&, std::cerr << "AsyncClient::Open() example requires coroutines\n"; } -void OpenMultipleObjectsRangedRead( - google::cloud::storage::AsyncClient&, - std::vector const&) { +void OpenMultipleObjectsRangedRead(google::cloud::storage::AsyncClient&, + std::vector const&) { std::cerr << "AsyncClient::Open() example requires coroutines\n"; } -void OpenMultipleObjectsRangedRead( - google::cloud::storage::AsyncClient&, - std::vector const&) { +void OpenMultipleObjectsRangedRead(google::cloud::storage::AsyncClient&, + std::vector const&) { std::cerr << "AsyncClient::Open() example requires coroutines\n"; } @@ -1040,28 +1033,25 @@ void ResumeUnbufferedUpload(google::cloud::storage::AsyncClient&, << "AsyncClient::ResumeUnbufferedUpload() example requires coroutines\n"; } -void CreateAndWriteAppendableObject( - google::cloud::storage::AsyncClient&, - std::vector const&) { +void CreateAndWriteAppendableObject(google::cloud::storage::AsyncClient&, + std::vector const&) { std::cerr << "AsyncClient::CreateAndWriteAppendableObject() example requires " "coroutines\n"; } -void PauseAndResumeAppendableUpload( - google::cloud::storage::AsyncClient&, - std::vector const&) { +void PauseAndResumeAppendableUpload(google::cloud::storage::AsyncClient&, + std::vector const&) { std::cerr << "AsyncClient::PauseAndResumeAppendableUpload() example requires " "coroutines\n"; } -void FinalizeAppendableObjectUpload( - google::cloud::storage_experimental::AsyncClient&, - std::vector const&) { +void FinalizeAppendableObjectUpload(google::cloud::storage::AsyncClient&, + std::vector const&) { std::cerr << "AsyncClient::FinalizeAppendableObjectUpload() example requires " "coroutines\n"; } -void ReadAppendableObjectTail(google::cloud::storage_experimental::AsyncClient&, +void ReadAppendableObjectTail(google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::ReadAppendableObjectTail() example requires " "coroutines\n"; @@ -1379,9 +1369,8 @@ void AutoRun(std::vector const& argv) { // Create a dummy object for the tail example to read. In a real // application another process would be writing to this object. (void)client - .InsertObject( - google::cloud::storage_experimental::BucketName(bucket_name), - object_name, "content for tail example\n") + .InsertObject(google::cloud::storage::BucketName(bucket_name), + object_name, "content for tail example\n") .get() .value(); ReadAppendableObjectTail(client, {bucket_name, object_name}); diff --git a/google/cloud/storage/examples/storage_otel_samples.cc b/google/cloud/storage/examples/storage_otel_samples.cc index 27f6560cc39ef..1b9d569f43a70 100644 --- a/google/cloud/storage/examples/storage_otel_samples.cc +++ b/google/cloud/storage/examples/storage_otel_samples.cc @@ -41,13 +41,12 @@ void InstrumentedClient(std::vector const& argv) { } //! [instrumented-client] namespace gc = ::google::cloud; - namespace gcs_ex = ::google::cloud::storage_experimental; [](std::string const& project_id, std::string const& bucket_name, std::string const& object_name) { auto configuration = gc::otel::ConfigureBasicTracing(gc::Project(project_id)); - auto client = google::cloud::storage_experimental::AsyncClient( + auto client = google::cloud::storage::AsyncClient( gc::Options{}.set(true)); auto coro = [&]() -> gc::future { @@ -55,12 +54,12 @@ void InstrumentedClient(std::vector const& argv) { std::generate(data.begin(), data.end(), [n = 0]() mutable { return std::to_string(++n) + "\n"; }); auto metadata = co_await client.InsertObject( - gcs_ex::BucketName(bucket_name), object_name, std::move(data)); + gcs::BucketName(bucket_name), object_name, std::move(data)); if (!metadata) throw std::move(metadata).status(); std::int64_t count = 0; auto [reader, token] = (co_await client.ReadObject( - gcs_ex::BucketName(bucket_name), object_name)) + gcs::BucketName(bucket_name), object_name)) .value(); while (token.valid()) { auto [payload, t] = (co_await reader.Read(std::move(token))).value(); @@ -71,8 +70,8 @@ void InstrumentedClient(std::vector const& argv) { } std::cout << "Counted " << count << " 7's in the GCS object\n"; - auto deleted = co_await client.DeleteObject( - gcs_ex::BucketName(bucket_name), object_name); + auto deleted = co_await client.DeleteObject(gcs::BucketName(bucket_name), + object_name); if (!deleted.ok()) throw gc::Status(std::move(deleted)); co_return; diff --git a/google/cloud/storage/internal/async/default_options.cc b/google/cloud/storage/internal/async/default_options.cc index 9c34616c73f38..0e092f945764f 100644 --- a/google/cloud/storage/internal/async/default_options.cc +++ b/google/cloud/storage/internal/async/default_options.cc @@ -74,8 +74,10 @@ Options DefaultOptionsAsync(Options opts) { storage::StopOnConsecutiveErrorsResumePolicy()) .set( storage::MakeStrictAsyncIdempotencyPolicy) - .set(true) - .set(128 * 1024 * 1024L)); + .set(true)); + // TODO(15340): This change is causing performance regression. We need to + // revisit it after benchmarking our code. + // .set(128 * 1024 * 1024L)); return Adjust(DefaultOptionsGrpc(std::move(opts))); } diff --git a/google/cloud/storage/internal/async/default_options_test.cc b/google/cloud/storage/internal/async/default_options_test.cc index 6703720a797c4..e622ac9dc9feb 100644 --- a/google/cloud/storage/internal/async/default_options_test.cc +++ b/google/cloud/storage/internal/async/default_options_test.cc @@ -86,6 +86,9 @@ TEST(DefaultOptionsAsync, Adjust) { } TEST(DefaultOptionsAsync, MaximumRangeSizeOption) { + // TODO(15340): This change is causing performance regression. We need to + // revisit it after benchmarking our code. + GTEST_SKIP(); auto const options = DefaultOptionsAsync({}); auto const max_range_size_option = options.get(); diff --git a/google/cloud/storage/tests/async_client_integration_test.cc b/google/cloud/storage/tests/async_client_integration_test.cc index 7175f703eedcc..0f5cfad060712 100644 --- a/google/cloud/storage/tests/async_client_integration_test.cc +++ b/google/cloud/storage/tests/async_client_integration_test.cc @@ -1005,6 +1005,8 @@ TEST_F(AsyncClientIntegrationTest, Open) { } TEST_F(AsyncClientIntegrationTest, OpenExceedMaximumRange) { + // TODO(15340): This change is causing performance regression. We need to + // revisit it after benchmarking our code. GTEST_SKIP(); auto async = AsyncClient(TestOptions().set(1024)); From 14d53d1cf945cd533bc732034e901fd576f1a782 Mon Sep 17 00:00:00 2001 From: bajajnehaa Date: Tue, 7 Oct 2025 15:42:23 +0000 Subject: [PATCH 5/5] fix ci failures --- google/cloud/storage/examples/storage_async_samples.cc | 5 ----- 1 file changed, 5 deletions(-) diff --git a/google/cloud/storage/examples/storage_async_samples.cc b/google/cloud/storage/examples/storage_async_samples.cc index 576c6f448a057..25dbc88016967 100644 --- a/google/cloud/storage/examples/storage_async_samples.cc +++ b/google/cloud/storage/examples/storage_async_samples.cc @@ -964,11 +964,6 @@ void OpenMultipleObjectsRangedRead(google::cloud::storage::AsyncClient&, std::cerr << "AsyncClient::Open() example requires coroutines\n"; } -void OpenMultipleObjectsRangedRead(google::cloud::storage::AsyncClient&, - std::vector const&) { - std::cerr << "AsyncClient::Open() example requires coroutines\n"; -} - void OpenObjectReadFullObject(google::cloud::storage::AsyncClient&, std::vector const&) { std::cerr << "AsyncClient::Open() example requires coroutines\n";