feat(GCS+gRPC): implement GetObjectMetadata (#8048)

coryan · web-flow · commit 7a9f0af4f6ed · 2022-01-21T16:24:23.000-05:00
diff --git a/generator/generator_config.textproto b/generator/generator_config.textproto
@@ -511,7 +511,6 @@ service {
     "ListNotifications",
     "ComposeObject",
     "DeleteObject",
-    "GetObject",
     "UpdateObject",
     "ListObjects",
     "RewriteObject",
diff --git a/google/cloud/storage/internal/grpc_client.cc b/google/cloud/storage/internal/grpc_client.cc
@@ -261,8 +261,13 @@ StatusOr<ObjectMetadata> GrpcClient::CopyObject(CopyObjectRequest const&) {
 }
 
 StatusOr<ObjectMetadata> GrpcClient::GetObjectMetadata(
-    GetObjectMetadataRequest const&) {
-  return Status(StatusCode::kUnimplemented, __func__);
+    GetObjectMetadataRequest const& request) {
+  auto proto = GrpcObjectRequestParser::ToProto(request);
+  grpc::ClientContext context;
+  ApplyQueryParameters(context, request, "");
+  auto response = stub_->GetObject(context, proto);
+  if (!response) return std::move(response).status();
+  return GrpcObjectMetadataParser::FromProto(*response, options_);
 }
 
 StatusOr<std::unique_ptr<ObjectReadSource>> GrpcClient::ReadObject(
diff --git a/google/cloud/storage/internal/grpc_object_request_parser.cc b/google/cloud/storage/internal/grpc_object_request_parser.cc
@@ -324,6 +324,21 @@ GrpcObjectRequestParser::ToProto(ReadObjectRangeRequest const& request) {
   return r;
 }
 
+google::storage::v2::GetObjectRequest GrpcObjectRequestParser::ToProto(
+    GetObjectMetadataRequest const& request) {
+  google::storage::v2::GetObjectRequest result;
+  SetGenerationConditions(result, request);
+  SetMetagenerationConditions(result, request);
+  SetCommonParameters(result, request);
+
+  result.set_bucket("projects/_/buckets/" + request.bucket_name());
+  result.set_object(request.object_name());
+  result.set_generation(request.GetOption<Generation>().value_or(0));
+  auto projection = request.GetOption<Projection>().value_or("");
+  if (projection == "full") result.mutable_read_mask()->add_paths("*");
+  return result;
+}
+
 }  // namespace internal
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
 }  // namespace storage
diff --git a/google/cloud/storage/internal/grpc_object_request_parser.h b/google/cloud/storage/internal/grpc_object_request_parser.h
@@ -41,6 +41,9 @@ struct GrpcObjectRequestParser {
 
   static StatusOr<google::storage::v2::ReadObjectRequest> ToProto(
       ReadObjectRangeRequest const& request);
+
+  static google::storage::v2::GetObjectRequest ToProto(
+      GetObjectMetadataRequest const& request);
 };
 
 }  // namespace internal
diff --git a/google/cloud/storage/internal/grpc_object_request_parser_test.cc b/google/cloud/storage/internal/grpc_object_request_parser_test.cc
@@ -550,6 +550,33 @@ TEST(GrpcObjectRequestParser, PredefinedAclObject) {
       GrpcObjectRequestParser::ToProtoObject(PredefinedAcl::BucketOwnerRead()));
 }
 
+TEST(GrpcObjectRequestParser, GetObjectMetadataAllFields) {
+  google::storage::v2::GetObjectRequest expected;
+  EXPECT_TRUE(google::protobuf::TextFormat::ParseFromString(
+      R"pb(
+        bucket: "projects/_/buckets/test-bucket"
+        object: "test-object"
+        generation: 7
+        if_generation_match: 1
+        if_generation_not_match: 2
+        if_metageneration_match: 3
+        if_metageneration_not_match: 4
+        common_request_params: { user_project: "test-user-project" }
+        read_mask { paths: "*" }
+      )pb",
+      &expected));
+
+  GetObjectMetadataRequest req("test-bucket", "test-object");
+  req.set_multiple_options(
+      Generation(7), IfGenerationMatch(1), IfGenerationNotMatch(2),
+      IfMetagenerationMatch(3), IfMetagenerationNotMatch(4), Projection("full"),
+      UserProject("test-user-project"), UserProject("test-user-project"),
+      QuotaUser("test-quota-user"), UserIp("test-user-ip"));
+
+  auto const actual = GrpcObjectRequestParser::ToProto(req);
+  EXPECT_THAT(actual, IsProtoEqual(expected));
+}
+
 }  // namespace
 }  // namespace internal
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
diff --git a/google/cloud/storage/internal/storage_auth_decorator.cc b/google/cloud/storage/internal/storage_auth_decorator.cc
@@ -30,6 +30,14 @@ StorageAuth::StorageAuth(
     std::shared_ptr<StorageStub> child)
     : auth_(std::move(auth)), child_(std::move(child)) {}
 
+StatusOr<google::storage::v2::Object> StorageAuth::GetObject(
+    grpc::ClientContext& context,
+    google::storage::v2::GetObjectRequest const& request) {
+  auto status = auth_->ConfigureContext(context);
+  if (!status.ok()) return status;
+  return child_->GetObject(context, request);
+}
+
 std::unique_ptr<google::cloud::internal::StreamingReadRpc<
     google::storage::v2::ReadObjectResponse>>
 StorageAuth::ReadObject(std::unique_ptr<grpc::ClientContext> context,
diff --git a/google/cloud/storage/internal/storage_auth_decorator.h b/google/cloud/storage/internal/storage_auth_decorator.h
@@ -38,6 +38,10 @@ class StorageAuth : public StorageStub {
       std::shared_ptr<google::cloud::internal::GrpcAuthenticationStrategy> auth,
       std::shared_ptr<StorageStub> child);
 
+  StatusOr<google::storage::v2::Object> GetObject(
+      grpc::ClientContext& context,
+      google::storage::v2::GetObjectRequest const& request) override;
+
   std::unique_ptr<google::cloud::internal::StreamingReadRpc<
       google::storage::v2::ReadObjectResponse>>
   ReadObject(std::unique_ptr<grpc::ClientContext> context,
diff --git a/google/cloud/storage/internal/storage_logging_decorator.cc b/google/cloud/storage/internal/storage_logging_decorator.cc
@@ -36,6 +36,17 @@ StorageLogging::StorageLogging(std::shared_ptr<StorageStub> child,
       tracing_options_(std::move(tracing_options)),
       components_(std::move(components)) {}
 
+StatusOr<google::storage::v2::Object> StorageLogging::GetObject(
+    grpc::ClientContext& context,
+    google::storage::v2::GetObjectRequest const& request) {
+  return google::cloud::internal::LogWrapper(
+      [this](grpc::ClientContext& context,
+             google::storage::v2::GetObjectRequest const& request) {
+        return child_->GetObject(context, request);
+      },
+      context, request, __func__, tracing_options_);
+}
+
 std::unique_ptr<google::cloud::internal::StreamingReadRpc<
     google::storage::v2::ReadObjectResponse>>
 StorageLogging::ReadObject(
diff --git a/google/cloud/storage/internal/storage_logging_decorator.h b/google/cloud/storage/internal/storage_logging_decorator.h
@@ -38,6 +38,10 @@ class StorageLogging : public StorageStub {
                  TracingOptions tracing_options,
                  std::set<std::string> components);
 
+  StatusOr<google::storage::v2::Object> GetObject(
+      grpc::ClientContext& context,
+      google::storage::v2::GetObjectRequest const& request) override;
+
   std::unique_ptr<google::cloud::internal::StreamingReadRpc<
       google::storage::v2::ReadObjectResponse>>
   ReadObject(std::unique_ptr<grpc::ClientContext> context,
diff --git a/google/cloud/storage/internal/storage_metadata_decorator.cc b/google/cloud/storage/internal/storage_metadata_decorator.cc
@@ -32,6 +32,13 @@ StorageMetadata::StorageMetadata(std::shared_ptr<StorageStub> child)
       api_client_header_(
           google::cloud::internal::ApiClientHeader("generator")) {}
 
+StatusOr<google::storage::v2::Object> StorageMetadata::GetObject(
+    grpc::ClientContext& context,
+    google::storage::v2::GetObjectRequest const& request) {
+  SetMetadata(context, {});
+  return child_->GetObject(context, request);
+}
+
 std::unique_ptr<google::cloud::internal::StreamingReadRpc<
     google::storage::v2::ReadObjectResponse>>
 StorageMetadata::ReadObject(
diff --git a/google/cloud/storage/internal/storage_metadata_decorator.h b/google/cloud/storage/internal/storage_metadata_decorator.h
@@ -34,6 +34,10 @@ class StorageMetadata : public StorageStub {
   ~StorageMetadata() override = default;
   explicit StorageMetadata(std::shared_ptr<StorageStub> child);
 
+  StatusOr<google::storage::v2::Object> GetObject(
+      grpc::ClientContext& context,
+      google::storage::v2::GetObjectRequest const& request) override;
+
   std::unique_ptr<google::cloud::internal::StreamingReadRpc<
       google::storage::v2::ReadObjectResponse>>
   ReadObject(std::unique_ptr<grpc::ClientContext> context,
diff --git a/google/cloud/storage/internal/storage_round_robin.cc b/google/cloud/storage/internal/storage_round_robin.cc
@@ -19,6 +19,12 @@ namespace cloud {
 namespace storage_internal {
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
 
+StatusOr<google::storage::v2::Object> StorageRoundRobin::GetObject(
+    grpc::ClientContext& context,
+    google::storage::v2::GetObjectRequest const& request) {
+  return Child()->GetObject(context, request);
+}
+
 std::unique_ptr<google::cloud::internal::StreamingReadRpc<
     google::storage::v2::ReadObjectResponse>>
 StorageRoundRobin::ReadObject(
diff --git a/google/cloud/storage/internal/storage_round_robin.h b/google/cloud/storage/internal/storage_round_robin.h
@@ -31,6 +31,10 @@ class StorageRoundRobin : public StorageStub {
       : children_(std::move(children)) {}
   ~StorageRoundRobin() override = default;
 
+  StatusOr<google::storage::v2::Object> GetObject(
+      grpc::ClientContext& context,
+      google::storage::v2::GetObjectRequest const& request) override;
+
   std::unique_ptr<google::cloud::internal::StreamingReadRpc<
       google::storage::v2::ReadObjectResponse>>
   ReadObject(std::unique_ptr<grpc::ClientContext> context,
diff --git a/google/cloud/storage/internal/storage_round_robin_test.cc b/google/cloud/storage/internal/storage_round_robin_test.cc
@@ -71,6 +71,25 @@ MakeInsertStream(std::unique_ptr<grpc::ClientContext>) {
       Status(StatusCode::kPermissionDenied, "uh-oh"));
 }
 
+TEST(StorageRoundRobinTest, GetObject) {
+  auto mocks = MakeMocks();
+  InSequence sequence;
+  for (int i = 0; i != kRepeats; ++i) {
+    for (auto& m : mocks) {
+      EXPECT_CALL(*m, GetObject)
+          .WillOnce(Return(Status(StatusCode::kPermissionDenied, "uh-oh")));
+    }
+  }
+
+  StorageRoundRobin under_test(AsPlainStubs(mocks));
+  for (size_t i = 0; i != kRepeats * mocks.size(); ++i) {
+    grpc::ClientContext context;
+    google::storage::v2::GetObjectRequest request;
+    auto response = under_test.GetObject(context, request);
+    EXPECT_THAT(response, StatusIs(StatusCode::kPermissionDenied));
+  }
+}
+
 TEST(StorageRoundRobinTest, ReadObject) {
   auto mocks = MakeMocks();
   InSequence sequence;
diff --git a/google/cloud/storage/internal/storage_stub.cc b/google/cloud/storage/internal/storage_stub.cc
@@ -30,6 +30,17 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
 
 StorageStub::~StorageStub() = default;
 
+StatusOr<google::storage::v2::Object> DefaultStorageStub::GetObject(
+    grpc::ClientContext& client_context,
+    google::storage::v2::GetObjectRequest const& request) {
+  google::storage::v2::Object response;
+  auto status = grpc_stub_->GetObject(&client_context, request, &response);
+  if (!status.ok()) {
+    return google::cloud::MakeStatusFromRpcError(status);
+  }
+  return response;
+}
+
 std::unique_ptr<google::cloud::internal::StreamingReadRpc<
     google::storage::v2::ReadObjectResponse>>
 DefaultStorageStub::ReadObject(
diff --git a/google/cloud/storage/internal/storage_stub.h b/google/cloud/storage/internal/storage_stub.h
@@ -35,6 +35,10 @@ class StorageStub {
  public:
   virtual ~StorageStub() = 0;
 
+  virtual StatusOr<google::storage::v2::Object> GetObject(
+      grpc::ClientContext& context,
+      google::storage::v2::GetObjectRequest const& request) = 0;
+
   virtual std::unique_ptr<google::cloud::internal::StreamingReadRpc<
       google::storage::v2::ReadObjectResponse>>
   ReadObject(std::unique_ptr<grpc::ClientContext> context,
@@ -66,6 +70,10 @@ class DefaultStorageStub : public StorageStub {
       std::unique_ptr<google::storage::v2::Storage::StubInterface> grpc_stub)
       : grpc_stub_(std::move(grpc_stub)) {}
 
+  StatusOr<google::storage::v2::Object> GetObject(
+      grpc::ClientContext& client_context,
+      google::storage::v2::GetObjectRequest const& request) override;
+
   std::unique_ptr<google::cloud::internal::StreamingReadRpc<
       google::storage::v2::ReadObjectResponse>>
   ReadObject(std::unique_ptr<grpc::ClientContext> client_context,
diff --git a/google/cloud/storage/testing/mock_storage_stub.h b/google/cloud/storage/testing/mock_storage_stub.h
@@ -25,6 +25,10 @@ namespace testing {
 
 class MockStorageStub : public storage_internal::StorageStub {
  public:
+  MOCK_METHOD(StatusOr<google::storage::v2::Object>, GetObject,
+              (grpc::ClientContext&,
+               google::storage::v2::GetObjectRequest const&),
+              (override));
   MOCK_METHOD(std::unique_ptr<google::cloud::internal::StreamingReadRpc<
                   google::storage::v2::ReadObjectResponse>>,
               ReadObject,
diff --git a/google/cloud/storage/tests/CMakeLists.txt b/google/cloud/storage/tests/CMakeLists.txt
@@ -26,6 +26,7 @@ set(storage_client_integration_tests
     curl_sign_blob_integration_test.cc
     error_injection_integration_test.cc
     grpc_integration_test.cc
+    grpc_object_metadata_integration_test.cc
     grpc_service_account_integration_test.cc
     key_file_integration_test.cc
     minimal_iam_credentials_rest_integration_test.cc
diff --git a/google/cloud/storage/tests/grpc_object_metadata_integration_test.cc b/google/cloud/storage/tests/grpc_object_metadata_integration_test.cc
@@ -0,0 +1,80 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if GOOGLE_CLOUD_CPP_STORAGE_HAVE_GRPC
+#include "google/cloud/storage/testing/storage_integration_test.h"
+#include "google/cloud/internal/getenv.h"
+#include "google/cloud/internal/setenv.h"
+#include "google/cloud/testing_util/scoped_environment.h"
+#include "google/cloud/testing_util/status_matchers.h"
+#include <crc32c/crc32c.h>
+#include <gmock/gmock.h>
+#include <nlohmann/json.hpp>
+#include <vector>
+
+namespace google {
+namespace cloud {
+namespace storage {
+GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
+namespace internal {
+namespace {
+
+using ::google::cloud::internal::GetEnv;
+using ::google::cloud::testing_util::ScopedEnvironment;
+using ::testing::IsEmpty;
+using ::testing::Not;
+
+// When GOOGLE_CLOUD_CPP_HAVE_GRPC is not set these tests compile, but they
+// actually just run against the regular GCS REST API. That is fine.
+class GrpcObjectMetadataIntegrationTest
+    : public google::cloud::storage::testing::StorageIntegrationTest {};
+
+TEST_F(GrpcObjectMetadataIntegrationTest, ObjectMetadataCRUD) {
+  ScopedEnvironment grpc_config("GOOGLE_CLOUD_CPP_STORAGE_GRPC_CONFIG",
+                                "metadata");
+  // TODO(#7257) - restore gRPC integration tests against production
+  if (!UsingEmulator()) GTEST_SKIP();
+
+  auto const bucket_name =
+      GetEnv("GOOGLE_CLOUD_CPP_STORAGE_TEST_BUCKET_NAME").value_or("");
+  ASSERT_THAT(bucket_name, Not(IsEmpty()))
+      << "GOOGLE_CLOUD_CPP_STORAGE_TEST_BUCKET_NAME is not set";
+
+  auto client = MakeIntegrationTestClient();
+  ASSERT_STATUS_OK(client);
+
+  auto object_name = MakeRandomObjectName();
+
+  auto insert = client->InsertObject(bucket_name, object_name, LoremIpsum(),
+                                     IfGenerationMatch(0));
+  ASSERT_STATUS_OK(insert);
+  ScheduleForDelete(*insert);
+
+  auto get = client->GetObjectMetadata(bucket_name, object_name);
+  ASSERT_STATUS_OK(get);
+  auto sans_acls = [](ObjectMetadata meta) {
+    meta.set_acl({});
+    return meta;
+  };
+  EXPECT_EQ(sans_acls(*insert), sans_acls(*get));
+}
+
+}  // namespace
+}  // namespace internal
+GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
+}  // namespace storage
+}  // namespace cloud
+}  // namespace google
+
+#endif  // GOOGLE_CLOUD_CPP_STORAGE_HAVE_GRPC
diff --git a/google/cloud/storage/tests/grpc_service_account_integration_test.cc b/google/cloud/storage/tests/grpc_service_account_integration_test.cc
@@ -38,6 +38,7 @@ class GrpcServiceAccountIntegrationTest
 TEST_F(GrpcServiceAccountIntegrationTest, GetServiceAccount) {
   ScopedEnvironment grpc_config("GOOGLE_CLOUD_CPP_STORAGE_GRPC_CONFIG",
                                 "metadata");
+  // TODO(#7257) - restore gRPC integration tests against production
   if (!UsingEmulator()) GTEST_SKIP();
 
   auto const project_id = GetEnv("GOOGLE_CLOUD_PROJECT").value_or("");
diff --git a/google/cloud/storage/tests/storage_client_integration_tests.bzl b/google/cloud/storage/tests/storage_client_integration_tests.bzl
@@ -27,6 +27,7 @@ storage_client_integration_tests = [
     "curl_sign_blob_integration_test.cc",
     "error_injection_integration_test.cc",
     "grpc_integration_test.cc",
+    "grpc_object_metadata_integration_test.cc",
     "grpc_service_account_integration_test.cc",
     "key_file_integration_test.cc",
     "minimal_iam_credentials_rest_integration_test.cc",

Original file line number	Diff line number	Diff line change
`@@ -261,8 +261,13 @@ StatusOr<ObjectMetadata> GrpcClient::CopyObject(CopyObjectRequest const&) {`
`261`	`261`	`}`
`262`	`262`
`263`	`263`	`StatusOr<ObjectMetadata> GrpcClient::GetObjectMetadata(`
`264`		`- GetObjectMetadataRequest const&) {`
`265`		`- return Status(StatusCode::kUnimplemented, __func__);`
	`264`	`+ GetObjectMetadataRequest const& request) {`
	`265`	`+ auto proto = GrpcObjectRequestParser::ToProto(request);`
	`266`	`+ grpc::ClientContext context;`
	`267`	`+ ApplyQueryParameters(context, request, "");`
	`268`	`+ auto response = stub_->GetObject(context, proto);`
	`269`	`+ if (!response) return std::move(response).status();`
	`270`	`+ return GrpcObjectMetadataParser::FromProto(*response, options_);`
`266`	`271`	`}`
`267`	`272`
`268`	`273`	`StatusOr<std::unique_ptr<ObjectReadSource>> GrpcClient::ReadObject(`