impl(GCS+gRPC): InsertObjectRequest for AsyncClient (googleapis#12503)

We need a class to represent requests that insert objects via the
`AsyncClient`. We cannot use the class from the synchronous client
because that uses non-owning types for the data payload. And we also
want the class in the public API (eventually) as it is needed for
mocking.

Author: coryan

google/cloud/storage/async_object_requests.h

@@ -62,6 +62,54 @@ class WritePayload {
   absl::Cord impl_;
 };
 
+/**
+ * A request to insert object sans the data payload.
+ *
+ * This class can hold all the mandatory and optional parameters to insert an
+ * object **except** for the data payload. The ideal representation for the data
+ * payload depends on the type of request. For asynchronous requests the data
+ * must be in an owning type, such as `WritePayload`. For blocking request, a
+ * non-owning type (such as `absl::string_view`) can reduce data copying.
+ *
+ * This class is the public API for the library because it is required for
+ * mocking.
+ */
+class InsertObjectRequest {
+ public:
+  InsertObjectRequest() = default;
+  InsertObjectRequest(std::string bucket_name, std::string object_name)
+      : impl_(std::move(bucket_name), std::move(object_name)) {}
+
+  std::string const& bucket_name() const { return impl_.bucket_name(); }
+  std::string const& object_name() const { return impl_.object_name(); }
+
+  template <typename... O>
+  InsertObjectRequest& set_multiple_options(O&&... o) & {
+    impl_.set_multiple_options(std::forward<O>(o)...);
+    return *this;
+  }
+  template <typename... O>
+  InsertObjectRequest&& set_multiple_options(O&&... o) && {
+    return std::move(set_multiple_options(std::forward<O>(o)...));
+  }
+
+  template <typename O>
+  bool HasOption() const {
+    return impl_.HasOption<O>();
+  }
+  template <typename O>
+  O GetOption() const {
+    return impl_.GetOption<O>();
+  }
+
+ protected:
+  struct Impl : public storage::internal::InsertObjectRequestImpl<Impl> {
+    using storage::internal::InsertObjectRequestImpl<
+        Impl>::InsertObjectRequestImpl;
+  };
+  Impl impl_;
+};
+
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
 }  // namespace storage_experimental
 }  // namespace cloud

google/cloud/storage/internal/grpc/configure_client_context.cc

@@ -43,6 +43,15 @@ void ApplyRoutingHeaders(
                                                      request.bucket_name()));
 }
 
+void ApplyRoutingHeaders(
+    grpc::ClientContext& context,
+    storage_experimental::InsertObjectRequest const& request) {
+  context.AddMetadata(
+      "x-goog-request-params",
+      "bucket=" + google::cloud::internal::UrlEncode("projects/_/buckets/" +
+                                                     request.bucket_name()));
+}
+
 void ApplyRoutingHeaders(grpc::ClientContext& context,
                          storage::internal::UploadChunkRequest const& request) {
   static auto* slash_format =

google/cloud/storage/internal/grpc/configure_client_context.h

@@ -15,6 +15,7 @@
 #ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_INTERNAL_GRPC_CONFIGURE_CLIENT_CONTEXT_H
 #define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_INTERNAL_GRPC_CONFIGURE_CLIENT_CONTEXT_H
 
+#include "google/cloud/storage/async_object_requests.h"
 #include "google/cloud/storage/internal/generic_request.h"
 #include "google/cloud/storage/internal/object_requests.h"
 #include "google/cloud/storage/version.h"
@@ -76,6 +77,11 @@ void ApplyRoutingHeaders(
     grpc::ClientContext& context,
     storage::internal::InsertObjectMediaRequest const& request);
 
+/// @copydoc ApplyRoutingHeaders(grpc::ClientContext&,)
+void ApplyRoutingHeaders(
+    grpc::ClientContext& context,
+    storage_experimental::InsertObjectRequest const& request);
+
 /**
  * The generated `StorageMetadata` stub can not handle dynamic routing headers
  * for client side streaming. So we manually match and extract the headers in

google/cloud/storage/internal/grpc/configure_client_context_test.cc

@@ -145,6 +145,17 @@ TEST_F(GrpcConfigureClientContext, ApplyRoutingHeadersInsertObjectMedia) {
                             "bucket=projects%2F_%2Fbuckets%2Ftest-bucket")));
 }
 
+TEST_F(GrpcConfigureClientContext, ApplyRoutingHeadersInsertObject) {
+  storage_experimental::InsertObjectRequest req("test-bucket", "test-object");
+
+  grpc::ClientContext context;
+  ApplyRoutingHeaders(context, req);
+  auto metadata = GetMetadata(context);
+  EXPECT_THAT(metadata,
+              Contains(Pair("x-goog-request-params",
+                            "bucket=projects%2F_%2Fbuckets%2Ftest-bucket")));
+}
+
 TEST_F(GrpcConfigureClientContext, ApplyRoutingHeadersUploadChunkMatchSlash) {
   storage::internal::UploadChunkRequest req(
       "projects/_/buckets/test-bucket/blah/blah", 0, {},

google/cloud/storage/internal/grpc/object_request_parser.cc

@@ -209,6 +209,29 @@ Status PatchTemporaryHold(Object& o, nlohmann::json const& p) {
   return Status{};
 }
 
+template <typename Request>
+StatusOr<google::storage::v2::WriteObjectRequest> ToProtoImpl(
+    Request const& request) {
+  google::storage::v2::WriteObjectRequest r;
+  auto& object_spec = *r.mutable_write_object_spec();
+  auto& resource = *object_spec.mutable_resource();
+  SetResourceOptions(resource, request);
+  auto status = SetObjectMetadata(resource, request);
+  if (!status.ok()) return status;
+  SetStorageClass(resource, request);
+  SetPredefinedAcl(object_spec, request);
+  SetGenerationConditions(object_spec, request);
+  SetMetagenerationConditions(object_spec, request);
+  status = SetCommonObjectParameters(r, request);
+  if (!status.ok()) return status;
+
+  resource.set_bucket(GrpcBucketIdToName(request.bucket_name()));
+  resource.set_name(request.object_name());
+  r.set_write_offset(0);
+
+  return r;
+}
+
 }  // namespace
 
 StatusOr<google::storage::v2::ComposeObjectRequest> ToProto(
@@ -455,25 +478,13 @@ StatusOr<google::storage::v2::UpdateObjectRequest> ToProto(
 }
 
 StatusOr<google::storage::v2::WriteObjectRequest> ToProto(
-    storage::internal::InsertObjectMediaRequest const& request) {
-  google::storage::v2::WriteObjectRequest r;
-  auto& object_spec = *r.mutable_write_object_spec();
-  auto& resource = *object_spec.mutable_resource();
-  SetResourceOptions(resource, request);
-  auto status = SetObjectMetadata(resource, request);
-  if (!status.ok()) return status;
-  SetStorageClass(resource, request);
-  SetPredefinedAcl(object_spec, request);
-  SetGenerationConditions(object_spec, request);
-  SetMetagenerationConditions(object_spec, request);
-  status = SetCommonObjectParameters(r, request);
-  if (!status.ok()) return status;
-
-  resource.set_bucket(GrpcBucketIdToName(request.bucket_name()));
-  resource.set_name(request.object_name());
-  r.set_write_offset(0);
+    storage_experimental::InsertObjectRequest const& request) {
+  return ToProtoImpl(request);
+}
 
-  return r;
+StatusOr<google::storage::v2::WriteObjectRequest> ToProto(
+    storage::internal::InsertObjectMediaRequest const& request) {
+  return ToProtoImpl(request);
 }
 
 storage::internal::QueryResumableUploadResponse FromProto(

google/cloud/storage/internal/grpc/object_request_parser.h

@@ -15,6 +15,7 @@
 #ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_INTERNAL_GRPC_OBJECT_REQUEST_PARSER_H
 #define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_INTERNAL_GRPC_OBJECT_REQUEST_PARSER_H
 
+#include "google/cloud/storage/async_object_requests.h"
 #include "google/cloud/storage/internal/storage_connection.h"
 #include "google/cloud/storage/version.h"
 #include "google/cloud/internal/grpc_request_metadata.h"
@@ -42,6 +43,8 @@ StatusOr<google::storage::v2::UpdateObjectRequest> ToProto(
 StatusOr<google::storage::v2::UpdateObjectRequest> ToProto(
     storage::internal::UpdateObjectRequest const& request);
 
+StatusOr<google::storage::v2::WriteObjectRequest> ToProto(
+    storage_experimental::InsertObjectRequest const& request);
 StatusOr<google::storage::v2::WriteObjectRequest> ToProto(
     storage::internal::InsertObjectMediaRequest const& request);
 storage::internal::QueryResumableUploadResponse FromProto(

google/cloud/storage/internal/grpc/object_request_parser_test.cc

@@ -729,6 +729,88 @@ TEST(GrpcObjectRequestParser, InsertObjectMediaRequestWithObjectMetadata) {
   EXPECT_THAT(actual, IsProtoEqual(expected));
 }
 
+TEST(GrpcObjectRequestParser, InsertObjectRequestSimple) {
+  storage_proto::WriteObjectRequest expected;
+  EXPECT_TRUE(TextFormat::ParseFromString(
+      R"pb(
+        write_object_spec: {
+          resource: {
+            bucket: "projects/_/buckets/test-bucket-name"
+            name: "test-object-name"
+          }
+        }
+      )pb",
+      &expected));
+
+  storage_experimental::InsertObjectRequest request("test-bucket-name",
+                                                    "test-object-name");
+  auto actual = ToProto(request).value();
+  EXPECT_THAT(actual, IsProtoEqual(expected));
+}
+
+TEST(GrpcObjectRequestParser, InsertObjectRequestAllOptions) {
+  auto constexpr kTextProto = R"pb(
+    write_object_spec {
+      resource: {
+        bucket: "projects/_/buckets/test-bucket-name"
+        name: "test-object-name"
+        content_type: "test-content-type"
+        content_encoding: "test-content-encoding"
+        # Should not be set, the proto file says these values should
+        # not be included in the upload
+        #     crc32c:
+        #     md5_hash:
+        kms_key: "test-kms-key-name"
+      }
+      predefined_acl: "private"
+      if_generation_match: 0
+      if_generation_not_match: 7
+      if_metageneration_match: 42
+      if_metageneration_not_match: 84
+    })pb";
+  storage_proto::WriteObjectRequest expected;
+  EXPECT_TRUE(TextFormat::ParseFromString(kTextProto, &expected));
+  *expected.mutable_common_object_request_params() =
+      ExpectedCommonObjectRequestParams();
+
+  auto constexpr kContents = "The quick brown fox jumps over the lazy dog";
+
+  storage_experimental::InsertObjectRequest request("test-bucket-name",
+                                                    "test-object-name");
+  request.set_multiple_options(
+      storage::ContentType("test-content-type"),
+      storage::ContentEncoding("test-content-encoding"),
+      storage::Crc32cChecksumValue(storage::ComputeCrc32cChecksum(kContents)),
+      storage::MD5HashValue(storage::ComputeMD5Hash(kContents)),
+      storage::PredefinedAcl("private"), storage::IfGenerationMatch(0),
+      storage::IfGenerationNotMatch(7), storage::IfMetagenerationMatch(42),
+      storage::IfMetagenerationNotMatch(84), storage::Projection::Full(),
+      storage::UserProject("test-user-project"),
+      storage::QuotaUser("test-quota-user"), storage::UserIp("test-user-ip"),
+      storage::EncryptionKey::FromBinaryKey("01234567"),
+      storage::KmsKeyName("test-kms-key-name"));
+
+  auto actual = ToProto(request).value();
+  EXPECT_THAT(actual, IsProtoEqual(expected));
+}
+
+TEST(GrpcObjectRequestParser, InsertObjectRequestWithObjectMetadata) {
+  storage_proto::WriteObjectRequest expected;
+  auto& resource = *expected.mutable_write_object_spec()->mutable_resource();
+  resource = ExpectedFullObjectMetadata();
+  resource.set_bucket("projects/_/buckets/test-bucket-name");
+  resource.set_name("test-object-name");
+  resource.set_storage_class("STANDARD");
+
+  storage_experimental::InsertObjectRequest request("test-bucket-name",
+                                                    "test-object-name");
+  request.set_multiple_options(storage::WithObjectMetadata(
+      FullObjectMetadata().set_storage_class("STANDARD")));
+
+  auto actual = ToProto(request).value();
+  EXPECT_THAT(actual, IsProtoEqual(expected));
+}
+
 TEST(GrpcObjectRequestParser, WriteObjectResponseSimple) {
   google::storage::v2::WriteObjectResponse input;
   ASSERT_TRUE(TextFormat::ParseFromString(

google/cloud/storage/internal/hash_function.cc

@@ -21,38 +21,26 @@ namespace cloud {
 namespace storage {
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
 namespace internal {
-namespace {
-std::unique_ptr<HashFunction> CreateHashFunction(bool disable_crc32c,
-                                                 bool disable_md5) {
-  if (disable_md5 && disable_crc32c) {
-    return std::make_unique<NullHashFunction>();
-  }
-  if (disable_md5) return std::make_unique<Crc32cHashFunction>();
-  if (disable_crc32c) return std::make_unique<MD5HashFunction>();
-  return std::make_unique<CompositeFunction>(
-      std::make_unique<Crc32cHashFunction>(),
-      std::make_unique<MD5HashFunction>());
-}
 
-template <typename Request>
-std::unique_ptr<HashFunction> CreateUploadHashFunction(Request const& request) {
+std::unique_ptr<HashFunction> CreateHashFunction(
+    Crc32cChecksumValue const& crc32c_value,
+    DisableCrc32cChecksum const& crc32c_disabled, MD5HashValue const& md5_value,
+    DisableMD5Hash const& md5_disabled) {
   auto crc32c = std::unique_ptr<HashFunction>();
-  auto crc32c_value =
-      request.template GetOption<Crc32cChecksumValue>().value_or("");
-  if (!crc32c_value.empty()) {
+  auto crc32c_v = crc32c_value.value_or("");
+  if (!crc32c_v.empty()) {
     crc32c = std::make_unique<PrecomputedHashFunction>(
-        HashValues{/*.crc32c=*/std::move(crc32c_value), /*md5=*/{}});
-  } else if (!request.template GetOption<DisableCrc32cChecksum>().value_or(
-                 false)) {
+        HashValues{/*.crc32c=*/std::move(crc32c_v), /*md5=*/{}});
+  } else if (!crc32c_disabled.value_or(false)) {
     crc32c = std::make_unique<Crc32cHashFunction>();
   }
 
   auto md5 = std::unique_ptr<HashFunction>();
-  auto md5_value = request.template GetOption<MD5HashValue>().value_or("");
-  if (!md5_value.empty()) {
+  auto md5_v = md5_value.value_or("");
+  if (!md5_v.empty()) {
     md5 = std::make_unique<PrecomputedHashFunction>(
-        HashValues{/*.crc32c=*/{}, /*.md5=*/std::move(md5_value)});
-  } else if (!request.template GetOption<DisableMD5Hash>().value_or(false)) {
+        HashValues{/*.crc32c=*/{}, /*.md5=*/std::move(md5_v)});
+  } else if (!md5_disabled.value_or(false)) {
     md5 = std::make_unique<MD5HashFunction>();
   }
 
@@ -63,18 +51,25 @@ std::unique_ptr<HashFunction> CreateUploadHashFunction(Request const& request) {
   return std::make_unique<CompositeFunction>(std::move(crc32c), std::move(md5));
 }
 
-}  // namespace
-
 std::unique_ptr<HashFunction> CreateNullHashFunction() {
   return std::make_unique<NullHashFunction>();
 }
 
 std::unique_ptr<HashFunction> CreateHashFunction(
     ReadObjectRangeRequest const& request) {
   if (request.RequiresRangeHeader()) return CreateNullHashFunction();
-  return CreateHashFunction(
-      request.GetOption<DisableCrc32cChecksum>().value_or(false),
-      request.GetOption<DisableMD5Hash>().value_or(false));
+
+  auto const disable_crc32c =
+      request.GetOption<DisableCrc32cChecksum>().value_or(false);
+  auto const disable_md5 = request.GetOption<DisableMD5Hash>().value_or(false);
+  if (disable_md5 && disable_crc32c) {
+    return std::make_unique<NullHashFunction>();
+  }
+  if (disable_md5) return std::make_unique<Crc32cHashFunction>();
+  if (disable_crc32c) return std::make_unique<MD5HashFunction>();
+  return std::make_unique<CompositeFunction>(
+      std::make_unique<Crc32cHashFunction>(),
+      std::make_unique<MD5HashFunction>());
 }
 
 std::unique_ptr<HashFunction> CreateHashFunction(
@@ -84,12 +79,10 @@ std::unique_ptr<HashFunction> CreateHashFunction(
     // for previous values is lost.
     return CreateNullHashFunction();
   }
-  return CreateUploadHashFunction(request);
-}
-
-std::unique_ptr<HashFunction> CreateHashFunction(
-    InsertObjectMediaRequest const& request) {
-  return CreateUploadHashFunction(request);
+  return CreateHashFunction(request.GetOption<Crc32cChecksumValue>(),
+                            request.GetOption<DisableCrc32cChecksum>(),
+                            request.GetOption<MD5HashValue>(),
+                            request.GetOption<DisableMD5Hash>());
 }
 
 }  // namespace internal