Skip to content

Commit 9d16ff3

Browse files
coryancoryan
authored
cleanup(GCS+gRPC): remove redundant overload (#13985)
1 parent 8480f80 commit 9d16ff3

5 files changed

Lines changed: 30 additions & 99 deletions

File tree

‎google/cloud/storage/async/client.cc‎

Lines changed: 10 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -69,21 +69,11 @@ std::pair<AsyncRewriter, AsyncToken> AsyncClient::StartRewrite(
6969
BucketName const& source_bucket, std::string source_object_name,
7070
BucketName const& destination_bucket, std::string destination_object_name,
7171
Options opts) {
72-
return StartRewrite(source_bucket, std::move(source_object_name),
73-
destination_bucket, std::move(destination_object_name),
74-
google::storage::v2::RewriteObjectRequest{},
75-
std::move(opts));
76-
}
77-
78-
std::pair<AsyncRewriter, AsyncToken> AsyncClient::StartRewrite(
79-
BucketName const& source_bucket, std::string source_object_name,
80-
BucketName const& destination_bucket, std::string destination_object_name,
81-
google::storage::v2::RewriteObjectRequest request, Options opts) {
72+
auto request = google::storage::v2::RewriteObjectRequest{};
8273
request.set_destination_name(std::move(destination_object_name));
8374
request.set_destination_bucket(destination_bucket.FullName());
8475
request.set_source_object(std::move(source_object_name));
8576
request.set_source_bucket(source_bucket.FullName());
86-
request.mutable_rewrite_token()->clear();
8777
return ResumeRewrite(std::move(request), std::move(opts));
8878
}
8979

@@ -93,15 +83,6 @@ std::pair<AsyncRewriter, AsyncToken> AsyncClient::StartRewrite(
9383
return ResumeRewrite(std::move(request), std::move(opts));
9484
}
9585

96-
std::pair<AsyncRewriter, AsyncToken> AsyncClient::ResumeRewrite(
97-
google::storage::v2::RewriteObjectRequest request, Options opts) {
98-
auto c = connection_->RewriteObject(
99-
{std::move(request),
100-
internal::MergeOptions(std::move(opts), connection_->options())});
101-
auto token = storage_internal::MakeAsyncToken(c.get());
102-
return std::make_pair(AsyncRewriter(std::move(c)), std::move(token));
103-
}
104-
10586
std::pair<AsyncRewriter, AsyncToken> AsyncClient::ResumeRewrite(
10687
BucketName const& source_bucket, std::string source_object_name,
10788
BucketName const& destination_bucket, std::string destination_object_name,
@@ -115,6 +96,15 @@ std::pair<AsyncRewriter, AsyncToken> AsyncClient::ResumeRewrite(
11596
return ResumeRewrite(std::move(request), std::move(opts));
11697
}
11798

99+
std::pair<AsyncRewriter, AsyncToken> AsyncClient::ResumeRewrite(
100+
google::storage::v2::RewriteObjectRequest request, Options opts) {
101+
auto c = connection_->RewriteObject(
102+
{std::move(request),
103+
internal::MergeOptions(std::move(opts), connection_->options())});
104+
auto token = storage_internal::MakeAsyncToken(c.get());
105+
return std::make_pair(AsyncRewriter(std::move(c)), std::move(token));
106+
}
107+
118108
GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
119109
} // namespace storage_experimental
120110
} // namespace cloud

‎google/cloud/storage/async/client.h‎

Lines changed: 0 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -632,25 +632,6 @@ class AsyncClient {
632632
BucketName const& destination_bucket, std::string destination_object_name,
633633
Options opts = {});
634634

635-
/**
636-
* Creates an `AsyncRewriter` to copy the source object.
637-
*
638-
* @snippet{doc} async/client.h start-rewrite-common
639-
*
640-
* @param source_bucket the name of the bucket containing the source object.
641-
* @param source_object_name the name of the source object.
642-
* @param destination_bucket the name of the bucket for the new object.
643-
* @param destination_object_name what to name the destination object.
644-
* @param request any additional parameters modifying the request, such as
645-
* pre-conditions, and overrides for the destination object metadata.
646-
* @param opts options controlling the behavior of this RPC, for example
647-
* the application may change the retry policy.
648-
*/
649-
std::pair<AsyncRewriter, AsyncToken> StartRewrite(
650-
BucketName const& source_bucket, std::string source_object_name,
651-
BucketName const& destination_bucket, std::string destination_object_name,
652-
google::storage::v2::RewriteObjectRequest request, Options opts = {});
653-
654635
/**
655636
* Creates an `AsyncRewriter` to copy the source object.
656637
*

‎google/cloud/storage/async/client_test.cc‎

Lines changed: 0 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -506,53 +506,6 @@ TEST(AsyncClient, StartRewrite2) {
506506
.WillRepeatedly(
507507
Return(Options{}.set<TestOption<0>>("O0").set<TestOption<1>>("O1")));
508508

509-
EXPECT_CALL(*mock, RewriteObject)
510-
.WillOnce([](AsyncConnection::RewriteObjectParams const& p) {
511-
EXPECT_THAT(p.options.get<TestOption<0>>(), "O0");
512-
EXPECT_THAT(p.options.get<TestOption<1>>(), "O1-function");
513-
EXPECT_THAT(p.options.get<TestOption<2>>(), "O2-function");
514-
auto constexpr kExpected = R"pb(
515-
source_bucket: "projects/_/buckets/src-bucket"
516-
source_object: "src-object"
517-
destination_bucket: "projects/_/buckets/dst-bucket"
518-
destination_name: "dst-object"
519-
if_generation_match: 42
520-
)pb";
521-
EXPECT_THAT(p.request, MatchRewriteRequest(kExpected));
522-
auto rewriter = std::make_shared<MockAsyncRewriterConnection>();
523-
EXPECT_CALL(*rewriter, Iterate).WillOnce([] {
524-
RewriteResponse response;
525-
response.set_total_bytes_rewritten(3000);
526-
response.set_object_size(3000);
527-
response.mutable_resource()->set_size(3000);
528-
return make_ready_future(make_status_or(MakeRewriteResponse()));
529-
});
530-
return rewriter;
531-
});
532-
533-
auto client = AsyncClient(mock);
534-
AsyncRewriter rewriter;
535-
AsyncToken token;
536-
RewriteObjectRequest request;
537-
request.set_if_generation_match(42);
538-
std::tie(rewriter, token) =
539-
client.StartRewrite(BucketName("src-bucket"), "src-object",
540-
BucketName("dst-bucket"), "dst-object", request,
541-
Options{}
542-
.set<TestOption<1>>("O1-function")
543-
.set<TestOption<2>>("O2-function"));
544-
auto rt = rewriter.Iterate(std::move(token)).get();
545-
ASSERT_STATUS_OK(rt);
546-
EXPECT_FALSE(rt->second.valid());
547-
EXPECT_THAT(rt->first, MatchRewriteResponse());
548-
}
549-
550-
TEST(AsyncClient, StartRewrite3) {
551-
auto mock = std::make_shared<MockAsyncConnection>();
552-
EXPECT_CALL(*mock, options)
553-
.WillRepeatedly(
554-
Return(Options{}.set<TestOption<0>>("O0").set<TestOption<1>>("O1")));
555-
556509
EXPECT_CALL(*mock, RewriteObject)
557510
.WillOnce([](AsyncConnection::RewriteObjectParams const& p) {
558511
EXPECT_THAT(p.options.get<TestOption<0>>(), "O0");

‎google/cloud/storage/examples/storage_async_samples.cc‎

Lines changed: 10 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -371,11 +371,14 @@ void ResumeRewrite(google::cloud::storage_experimental::AsyncClient& client,
371371
// First start a rewrite. In this example we will limit the number of bytes
372372
// rewritten by each iteration, then capture the token, and then resume the
373373
// rewrite operation.
374-
auto bucket = gcs_ex::BucketName(bucket_name);
375-
auto request = google::storage::v2::RewriteObjectRequest();
374+
auto bucket = gcs_ex::BucketName(std::move(bucket_name));
375+
auto request = google::storage::v2::RewriteObjectRequest{};
376+
request.set_destination_name(destination_name);
377+
request.set_destination_bucket(bucket.FullName());
378+
request.set_source_object(std::move(object_name));
379+
request.set_source_bucket(bucket.FullName());
376380
request.set_max_bytes_rewritten_per_call(1024 * 1024);
377-
auto [rewriter, token] = client.StartRewrite(
378-
bucket, object_name, bucket, destination_name, std::move(request));
381+
auto [rewriter, token] = client.StartRewrite(std::move(request));
379382
auto [progress, t] = (co_await rewriter.Iterate(std::move(token))).value();
380383
co_return progress.rewrite_token();
381384
};
@@ -385,12 +388,12 @@ void ResumeRewrite(google::cloud::storage_experimental::AsyncClient& client,
385388
std::string rewrite_token) -> g::future<google::storage::v2::Object> {
386389
// Continue rewriting, this could happen on a separate process, or even
387390
// after the application restarts.
388-
auto bucket = gcs_ex::BucketName(bucket_name);
391+
auto bucket = gcs_ex::BucketName(std::move(bucket_name));
389392
auto request = google::storage::v2::RewriteObjectRequest();
390393
request.set_destination_bucket(bucket.FullName());
391-
request.set_destination_name(destination_name);
394+
request.set_destination_name(std::move(destination_name));
392395
request.set_source_bucket(bucket.FullName());
393-
request.set_source_object(object_name);
396+
request.set_source_object(std::move(object_name));
394397
request.set_rewrite_token(std::move(rewrite_token));
395398
request.set_max_bytes_rewritten_per_call(1024 * 1024);
396399
auto [rewriter, token] = client.ResumeRewrite(std::move(request));

‎google/cloud/storage/tests/async_client_integration_test.cc‎

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -419,10 +419,12 @@ TEST_F(AsyncClientIntegrationTest, RewriteObject) {
419419
AsyncRewriter rewriter;
420420
AsyncToken token;
421421
google::storage::v2::RewriteObjectRequest request;
422+
request.set_destination_name(o2);
423+
request.set_destination_bucket(BucketName(bucket_name()).FullName());
424+
request.set_source_object(o1);
425+
request.set_source_bucket(BucketName(bucket_name()).FullName());
422426
request.set_max_bytes_rewritten_per_call(1024 * 1024);
423-
std::tie(rewriter, token) =
424-
async.StartRewrite(BucketName(bucket_name()), o1,
425-
BucketName(bucket_name()), o2, std::move(request));
427+
std::tie(rewriter, token) = async.StartRewrite(std::move(request));
426428
while (token.valid()) {
427429
auto rt = rewriter.Iterate(std::move(token)).get();
428430
ASSERT_STATUS_OK(rt);
@@ -464,10 +466,12 @@ TEST_F(AsyncClientIntegrationTest, RewriteObjectResume) {
464466
AsyncToken token;
465467
auto const expected_name = MakeRandomObjectName();
466468
google::storage::v2::RewriteObjectRequest start_request;
469+
start_request.set_destination_name(expected_name);
470+
start_request.set_destination_bucket(BucketName(*destination).FullName());
471+
start_request.set_source_object(source->name());
472+
start_request.set_source_bucket(BucketName(bucket_name()).FullName());
467473
start_request.set_max_bytes_rewritten_per_call(1024 * 1024);
468-
std::tie(rewriter, token) = async.StartRewrite(
469-
BucketName(source->bucket()), source->name(), BucketName(*destination),
470-
expected_name, start_request);
474+
std::tie(rewriter, token) = async.StartRewrite(start_request);
471475

472476
auto rt = rewriter.Iterate(std::move(token)).get();
473477
ASSERT_STATUS_OK(rt);

0 commit comments

Comments
 (0)