googleapis · BrennaEpp · Mar 19, 2024 · Feb 21, 2024 · Feb 21, 2024 · Mar 8, 2024
@@ -8,6 +8,7 @@ require (
  cloud.google.com/go v0.112.0
  cloud.google.com/go/compute/metadata v0.2.3
  cloud.google.com/go/iam v1.1.6
+ github.com/golang/protobuf v1.5.3
  github.com/google/go-cmp v0.6.0
  github.com/google/uuid v1.6.0
  github.com/googleapis/gax-go/v2 v2.12.0
@@ -26,7 +27,6 @@ require (
  github.com/go-logr/logr v1.4.1 // indirect
  github.com/go-logr/stdr v1.2.2 // indirect
  github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
- github.com/golang/protobuf v1.5.3 // indirect
  github.com/google/martian/v3 v3.3.2 // indirect
  github.com/google/s2a-go v0.1.7 // indirect
  github.com/googleapis/enterprise-certificate-proxy v0.3.2 // indirect

@@ -27,15 +27,18 @@
  "cloud.google.com/go/internal/trace"
  gapic "cloud.google.com/go/storage/internal/apiv2"
  "cloud.google.com/go/storage/internal/apiv2/storagepb"
+ "github.com/golang/protobuf/proto"
  "github.com/googleapis/gax-go/v2"
  "google.golang.org/api/googleapi"
  "google.golang.org/api/iterator"
  "google.golang.org/api/option"
  "google.golang.org/api/option/internaloption"
  "google.golang.org/grpc"
  "google.golang.org/grpc/codes"
+ "google.golang.org/grpc/encoding"
  "google.golang.org/grpc/metadata"
  "google.golang.org/grpc/status"
+ "google.golang.org/protobuf/encoding/protowire"
  fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
 )
 
@@ -902,12 +905,53 @@
  return r, nil
 }
 
+// bytesCodec is a grpc codec which permits sending/receiving messages as either
+// protobuf messages, or as raw []bytes.
+type bytesCodec struct {
+ encoding.Codec
+}
+
+func (bytesCodec) Marshal(v any) ([]byte, error) {
+ switch v := v.(type) {
+ case []byte:
+ return v, nil
+ case proto.Message:
+ return proto.Marshal(v)
+ default:
+ return nil, fmt.Errorf("can not marshal type %T", v)
+ }
+}
+
+func (bytesCodec) Unmarshal(data []byte, v any) error {
+ switch v := v.(type) {
+ case *[]byte:
+ // If gRPC could recycle the data []byte after unmarshaling (through
+ // buffer pools), we would need to make a copy here.
+ *v = data
+ return nil
+ case proto.Message:
+ return proto.Unmarshal(data, v)
+ default:
+ return fmt.Errorf("can not unmarshal type %T", v)
+ }
+}
+
+func (bytesCodec) Name() string {
+ // If this isn't "", then gRPC sets the content-subtype of the call to this
+ // value and we get errors.
+ return ""
+}
+
 func (c *grpcStorageClient) NewRangeReader(ctx context.Context, params *newRangeReaderParams, opts ...storageOption) (r *Reader, err error) {
  ctx = trace.StartSpan(ctx, "cloud.google.com/go/storage.grpcStorageClient.NewRangeReader")
  defer func() { trace.EndSpan(ctx, err) }()
 
  s := callSettings(c.settings, opts...)
 
+ s.gax = append(s.gax, gax.WithGRPCOptions(
+ grpc.ForceCodec(bytesCodec{}),
+ ))
+
  if s.userProject != "" {
  ctx = setUserProjectMetadata(ctx, s.userProject)
  }
@@ -923,6 +967,8 @@
  req.Generation = params.gen
  }
 
+ var databuf []byte
+
  // Define a function that initiates a Read with offset and length, assuming
  // we have already read seen bytes.
  reopen := func(seen int64) (*readStreamResponse, context.CancelFunc, error) {
@@ -957,12 +1003,23 @@
  return err
  }
 
- msg, err = stream.Recv()
+ // Receive the message as a wire-encoded message so we can use a
+ // custom decoder to avoid an extra copy at the protobuf layer.
+ err := stream.RecvMsg(&databuf)
  // These types of errors show up on the Recv call, rather than the
  // initialization of the stream via ReadObject above.
  if s, ok := status.FromError(err); ok && s.Code() == codes.NotFound {
  return ErrObjectNotExist
  }
+ if err != nil {
+ return err
+ }
+ // Use a custom decoder that uses protobuf unmarshalling for all
+ // fields except the checksummed data content.
+ // Subsequent receives in Read calls will skip all protobuf
+ // unmarshalling and directly read the content from the gRPC []byte
+ // response, since only the first call will contain other fields.
+ msg, err = readFullObjectResponse(databuf)
 
  return err
  }, s.retry, s.idempotent)
@@ -1008,6 +1065,7 @@
  leftovers: msg.GetChecksummedData().GetContent(),
  settings: s,
  zeroRange: params.length == 0,
+ databuf: databuf,
  },
  }
 
@@ -1406,6 +1464,7 @@
  stream storagepb.Storage_ReadObjectClient
  reopen func(seen int64) (*readStreamResponse, context.CancelFunc, error)
  leftovers []byte
+ databuf []byte
  cancel context.CancelFunc
  settings *settings
 }
@@ -1436,7 +1495,7 @@
  }
 
  // Attempt to Recv the next message on the stream.
- msg, err := r.recv()
+ content, err := r.recv()
  if err != nil {
  return 0, err
  }
@@ -1448,7 +1507,6 @@
  // present in the response here.
  // TODO: Figure out if we need to support decompressive transcoding
  // https://cloud.google.com/storage/docs/transcoding.
- content := msg.GetChecksummedData().GetContent()
  n = copy(p[n:], content)
  leftover := len(content) - n
  if leftover > 0 {
@@ -1471,7 +1529,7 @@
  return nil
 }
 
-// recv attempts to Recv the next message on the stream. In the event
+// recv attempts to Recv the next chunk of content on the stream. In the event
 // that a retryable error is encountered, the stream will be closed, reopened,
 // and Recv again. This will attempt to Recv until one of the following is true:
 //
@@ -1481,8 +1539,9 @@
 //
 // The last error received is the one that is returned, which could be from
 // an attempt to reopen the stream.
-func (r *gRPCReader) recv() (*storagepb.ReadObjectResponse, error) {
- msg, err := r.stream.Recv()
+func (r *gRPCReader) recv() ([]byte, error) {
+ err := r.stream.RecvMsg(&r.databuf)
+
  var shouldRetry = ShouldRetry
  if r.settings.retry != nil && r.settings.retry.shouldRetry != nil {
  shouldRetry = r.settings.retry.shouldRetry
@@ -1492,10 +1551,144 @@
  // reopen the stream, but will backoff if further attempts are necessary.
  // Reopening the stream Recvs the first message, so if retrying is
  // successful, the next logical chunk will be returned.
- msg, err = r.reopenStream()
+ msg, err := r.reopenStream()
+ return msg.GetChecksummedData().GetContent(), err
+ }
+
+ if err != nil {
+ return nil, err
+ }
+
+ return readObjectResponseContent(r.databuf)
+}
+
+// readObjectResponseContent returns the checksummed_data.content field of a
+// ReadObjectResponse message, or an error if the message is invalid.
+// This can be used on recvs of objects after the first recv, since only the
+// first message will contain non-data fields.
+func readObjectResponseContent(b []byte) ([]byte, error) {
+ const (
+ readObjectResponse_checksummedData = protowire.Number(1)
+ checksummedData_content = protowire.Number(1)
+ )
+
+ checksummedData, err := readProtoBytes(b, readObjectResponse_checksummedData)
+ if err != nil {
+ return b, fmt.Errorf("invalid ReadObjectResponse: %v", err)
+ }
+ content, err := readProtoBytes(checksummedData, checksummedData_content)
+ if err != nil {
+ return content, fmt.Errorf("invalid ReadObjectResponse: %v", err)
+ }
+
+ return content, nil
+}
+
+// readFullObjectResponse returns the ReadObjectResponse encoded in the
+// wire-encoded message buffer b, or an error if the message is invalid.
+// This is used on the first recv of an object as it may contain all fields of
+// ReadObjectResponse.
+func readFullObjectResponse(b []byte) (*storagepb.ReadObjectResponse, error) {
+ const (
+ checksummedDataField = protowire.Number(1)
+ checksummedDataContentField = protowire.Number(1)
+ checksummedDataCRC32CField = protowire.Number(2)
+ objectChecksumsField = protowire.Number(2)
+ contentRangeField = protowire.Number(3)
+ metadataField = protowire.Number(4)
+ )
+
+ checksummedData, err := readProtoBytes(b, checksummedDataField)
+ if err != nil {
+ return nil, fmt.Errorf("invalid ReadObjectResponse: %v", err)
+ }
+ content, err := readProtoBytes(checksummedData, checksummedDataContentField)
+ if err != nil {
+ return nil, fmt.Errorf("invalid ReadObjectResponse: %v", err)
+ }
+
+ // TODO: add unmarshalling for crc32c here
+ //crc32c := readProtoBytes(checksummedData, checksummedDataCRC32CField)
+
+ // Unmarshal remaining fields.
+ var checksums *storagepb.ObjectChecksums
+ bytes, err := readProtoBytes(b, objectChecksumsField)
+ if err != nil {
+ return nil, fmt.Errorf("invalid ReadObjectResponse: %v", err)
+ }
+ // If the field is not empty, unmarshal its contents
+ if len(bytes) > 0 {
+ checksums = &storagepb.ObjectChecksums{}
+ if err := proto.Unmarshal(bytes, checksums); err != nil {
+ return nil, err
+ }
+ }
+
+ var contentRange *storagepb.ContentRange
+ bytes, err = readProtoBytes(b, contentRangeField)
+ if err != nil {
+ return nil, fmt.Errorf("invalid ReadObjectResponse: %v", "err")
+ }
+ if len(bytes) > 0 {
+ contentRange = &storagepb.ContentRange{}
+ if err := proto.Unmarshal(bytes, contentRange); err != nil {
+ return nil, err
+ }
+ }
+
+ var metadata *storagepb.Object
+ bytes, err = readProtoBytes(b, metadataField)
+ if err != nil {
+ return nil, fmt.Errorf("invalid ReadObjectResponse: %v", err)
+ }
+ if len(bytes) > 0 {
+ metadata = &storagepb.Object{}
+ if err := proto.Unmarshal(bytes, metadata); err != nil {
+ return nil, err
+ }
+ }
+
+ msg := &storagepb.ReadObjectResponse{
+ ChecksummedData: &storagepb.ChecksummedData{
+ Content: content,
+ },
+ ObjectChecksums: checksums,
+ ContentRange: contentRange,
+ Metadata: metadata,
  }
 
- return msg, err
+ return msg, nil
+}
+
+// readProtoBytes returns the contents of the protobuf field with number num
+// and type bytes from a wire-encoded message. If the field cannot be found,
+// the returned slice will be nil and no error will be returned.
+//
+// It does not handle field concatenation, in which the contents of a single field
+// are split across multiple protobuf tags. Encoded data containing split fields
+// of this form is technically permissable, but uncommon.
+func readProtoBytes(b []byte, num protowire.Number) ([]byte, error) {
+ off := 0
+ for off < len(b) {
+ gotNum, gotTyp, n := protowire.ConsumeTag(b[off:])
+ if n < 0 {
+ return nil, protowire.ParseError(n)
+ }
+ off += n
+ if gotNum == num && gotTyp == protowire.BytesType {
+ b, n := protowire.ConsumeBytes(b[off:])
+ if n < 0 {
+ return nil, protowire.ParseError(n)
+ }
+ return b, nil
+ }
+ n = protowire.ConsumeFieldValue(gotNum, gotTyp, b[off:])
+ if n < 0 {
+ return nil, protowire.ParseError(n)
+ }
+ off += n
+ }
+ return nil, nil
 }
 
 // reopenStream "closes" the existing stream and attempts to reopen a stream and

@@ -1023,7 +1023,8 @@ func TestIntegration_ObjectReadChunksGRPC(t *testing.T) {
  multiTransportTest(skipHTTP("gRPC implementation specific test"), t, func(t *testing.T, ctx context.Context, bucket string, _ string, client *Client) {
  h := testHelper{t}
  // Use a larger blob to test chunking logic. This is a little over 5MB.
- content := bytes.Repeat([]byte("a"), 5<<20)
+ content := make([]byte, 5<<20)
+ rand.New(rand.NewSource(0)).Read(content)
 
  // Upload test data.
  obj := client.Bucket(bucket).Object(uidSpaceObjects.New())
@@ -1066,6 +1067,9 @@ func TestIntegration_ObjectReadChunksGRPC(t *testing.T) {
  if rem := r.Remain(); rem != 0 {
  t.Errorf("got %v bytes remaining, want 0", rem)
  }
+ if !bytes.Equal(buf, content) {
+ t.Errorf("content mismatch")
+ }
  })
 }