Update dependencies

vendor/cloud.google.com/go/bigtable/admin.go

@@ -30,6 +30,8 @@ import (
 	btapb "google.golang.org/genproto/googleapis/bigtable/admin/v2"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/metadata"
+	"google.golang.org/grpc/status"
+	"google.golang.org/grpc/codes"
 )
 
 const adminAddr = "bigtableadmin.googleapis.com:443"
@@ -379,6 +381,11 @@ func (iac *InstanceAdminClient) Instances(ctx context.Context) ([]*InstanceInfo,
 	if err != nil {
 		return nil, err
 	}
+	if len(res.FailedLocations) > 0 {
+		// We don't have a good way to return a partial result in the face of some zones being unavailable.
+		// Fail the entire request.
+		return nil, status.Errorf(codes.Unavailable, "Failed locations: %v", res.FailedLocations)
+	}
 
 	var is []*InstanceInfo
 	for _, i := range res.Instances {

vendor/cloud.google.com/go/bigtable/bigtable.go

@@ -53,7 +53,13 @@ func NewClient(ctx context.Context, project, instance string, opts ...option.Cli
 		return nil, err
 	}
 	// Default to a small connection pool that can be overridden.
-	o = append(o, option.WithGRPCConnectionPool(4))
+	o = append(o,
+		option.WithGRPCConnectionPool(4),
+		// Set the max size to correspond to server-side limits.
+		option.WithGRPCDialOption(grpc.WithDefaultCallOptions(grpc.MaxCallSendMsgSize(100<<20), grpc.MaxCallRecvMsgSize(100<<20))),
+		// TODO(grpc/grpc-go#1388) using connection pool without WithBlock
+		// can cause RPCs to fail randomly. We can delete this after the issue is fixed.
+		option.WithGRPCDialOption(grpc.WithBlock()))
 	o = append(o, opts...)
 	conn, err := gtransport.Dial(ctx, o...)
 	if err != nil {
@@ -211,6 +217,7 @@ func decodeFamilyProto(r Row, row string, f *btpb.Family) {
 }
 
 // RowSet is a set of rows to be read. It is satisfied by RowList, RowRange and RowRangeList.
+// The serialized size of the RowSet must be no larger than 1MiB.
 type RowSet interface {
 	proto() *btpb.RowSet
 
@@ -391,6 +398,9 @@ type ReadOption interface {
 }
 
 // RowFilter returns a ReadOption that applies f to the contents of read rows.
+//
+// If multiple RowFilters are provided, only the last is used. To combine filters,
+// use ChainFilters or InterleaveFilters instead.
 func RowFilter(f Filter) ReadOption { return rowFilter{f} }
 
 type rowFilter struct{ f Filter }
@@ -571,7 +581,7 @@ type entryErr struct {
 	Err   error
 }
 
-// ApplyBulk applies multiple Mutations.
+// ApplyBulk applies multiple Mutations, up to a maximum of 100,000.
 // Each mutation is individually applied atomically,
 // but the set of mutations may be applied in any order.
 //

vendor/cloud.google.com/go/bigtable/bigtable_test.go

@@ -448,6 +448,24 @@ func TestClientIntegration(t *testing.T) {
 			t.Fatalf("After %s,\n got %v\nwant %v", step.desc, row, wantRow)
 		}
 	}
+
+	// Check for google-cloud-go/issues/723. RMWs that insert new rows should keep row order sorted in the emulator.
+	row, err = tbl.ApplyReadModifyWrite(ctx, "issue-723-2", appendRMW([]byte{0}))
+	if err != nil {
+		t.Fatalf("ApplyReadModifyWrite null string: %v", err)
+	}
+	row, err = tbl.ApplyReadModifyWrite(ctx, "issue-723-1", appendRMW([]byte{0}))
+	if err != nil {
+		t.Fatalf("ApplyReadModifyWrite null string: %v", err)
+	}
+	// Get only the correct row back on read.
+	r, err := tbl.ReadRow(ctx, "issue-723-1")
+	if err != nil {
+		t.Fatalf("Reading row: %v", err)
+	}
+	if r.Key() != "issue-723-1" {
+		t.Errorf("ApplyReadModifyWrite: incorrect read after RMW,\n got %v\nwant %v", r.Key(), "issue-723-1")
+	}
 	checkpoint("tested ReadModifyWrite")
 
 	// Test arbitrary timestamps more thoroughly.
@@ -465,7 +483,7 @@ func TestClientIntegration(t *testing.T) {
 	if err := tbl.Apply(ctx, "testrow", mut); err != nil {
 		t.Fatalf("Mutating row: %v", err)
 	}
-	r, err := tbl.ReadRow(ctx, "testrow")
+	r, err = tbl.ReadRow(ctx, "testrow")
 	if err != nil {
 		t.Fatalf("Reading row: %v", err)
 	}
@@ -758,7 +776,7 @@ func TestClientIntegration(t *testing.T) {
 	checkpoint("tested high concurrency")
 
 	// Large reads, writes and scans.
-	bigBytes := make([]byte, 3<<20) // 3 MB is large, but less than current gRPC max of 4 MB.
+	bigBytes := make([]byte, 5<<20) // 5 MB is larger than current default gRPC max of 4 MB, but less than the max we set.
 	nonsense := []byte("lorem ipsum dolor sit amet, ")
 	fill(bigBytes, nonsense)
 	mut = NewMutation()

vendor/cloud.google.com/go/bigtable/bttest/inmem.go

@@ -277,7 +277,6 @@ func (s *server) ReadRows(req *btpb.ReadRowsRequest, stream btpb.Bigtable_ReadRo
 	// Rows to read can be specified by a set of row keys and/or a set of row ranges.
 	// Output is a stream of sorted, de-duped rows.
 	tbl.mu.RLock()
-
 	rowSet := make(map[string]*row)
 	if req.Rows != nil {
 		// Add the explicitly given keys
@@ -624,9 +623,8 @@ func (s *server) MutateRow(ctx context.Context, req *btpb.MutateRowRequest) (*bt
 	if !ok {
 		return nil, grpc.Errorf(codes.NotFound, "table %q not found", req.TableName)
 	}
-
 	fs := tbl.columnFamilies()
-	r := tbl.mutableRow(string(req.RowKey))
+	r, _ := tbl.mutableRow(string(req.RowKey))
 	r.mu.Lock()
 	defer tbl.resortRowIndex() // Make sure the row lock is released before this grabs the table lock
 	defer r.mu.Unlock()
@@ -643,14 +641,13 @@ func (s *server) MutateRows(req *btpb.MutateRowsRequest, stream btpb.Bigtable_Mu
 	if !ok {
 		return grpc.Errorf(codes.NotFound, "table %q not found", req.TableName)
 	}
-
 	res := &btpb.MutateRowsResponse{Entries: make([]*btpb.MutateRowsResponse_Entry, len(req.Entries))}
 
 	fs := tbl.columnFamilies()
 
 	defer tbl.resortRowIndex()
 	for i, entry := range req.Entries {
-		r := tbl.mutableRow(string(entry.RowKey))
+		r, _ := tbl.mutableRow(string(entry.RowKey))
 		r.mu.Lock()
 		code, msg := int32(codes.OK), ""
 		if err := applyMutations(tbl, r, entry.Mutations, fs); err != nil {
@@ -674,12 +671,11 @@ func (s *server) CheckAndMutateRow(ctx context.Context, req *btpb.CheckAndMutate
 	if !ok {
 		return nil, grpc.Errorf(codes.NotFound, "table %q not found", req.TableName)
 	}
-
 	res := &btpb.CheckAndMutateRowResponse{}
 
 	fs := tbl.columnFamilies()
 
-	r := tbl.mutableRow(string(req.RowKey))
+	r, _ := tbl.mutableRow(string(req.RowKey))
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
@@ -830,12 +826,16 @@ func (s *server) ReadModifyWriteRow(ctx context.Context, req *btpb.ReadModifyWri
 	if !ok {
 		return nil, grpc.Errorf(codes.NotFound, "table %q not found", req.TableName)
 	}
-
 	updates := make(map[string]cell) // copy of updated cells; keyed by full column name
 
 	fs := tbl.columnFamilies()
 
-	r := tbl.mutableRow(string(req.RowKey))
+	rowKey := string(req.RowKey)
+	r, isNewRow := tbl.mutableRow(rowKey)
+	// This must be done before the row lock, acquired below, is released.
+	if isNewRow {
+		defer tbl.resortRowIndex()
+	}
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	// Assume all mutations apply to the most recent version of the cell.
@@ -1025,13 +1025,13 @@ func (t *table) columnFamilies() map[string]*columnFamily {
 	return cp
 }
 
-func (t *table) mutableRow(row string) *row {
+func (t *table) mutableRow(row string) (mutRow *row, isNewRow bool) {
 	// Try fast path first.
 	t.mu.RLock()
 	r := t.rowIndex[row]
 	t.mu.RUnlock()
 	if r != nil {
-		return r
+		return r, false
 	}
 
 	// We probably need to create the row.
@@ -1043,7 +1043,7 @@ func (t *table) mutableRow(row string) *row {
 		t.rows = append(t.rows, r)
 	}
 	t.mu.Unlock()
-	return r
+	return r, true
 }
 
 func (t *table) resortRowIndex() {

vendor/cloud.google.com/go/bigtable/cmd/loadtest/loadtest.go

@@ -36,6 +36,7 @@ import (
 	"cloud.google.com/go/bigtable/internal/stat"
 	"golang.org/x/net/context"
 	"google.golang.org/api/option"
+	"google.golang.org/grpc"
 )
 
 var (
@@ -74,7 +75,12 @@ func main() {
 
 	var options []option.ClientOption
 	if *poolSize > 1 {
-		options = append(options, option.WithGRPCConnectionPool(*poolSize))
+		options = append(options,
+			option.WithGRPCConnectionPool(*poolSize),
+
+			// TODO(grpc/grpc-go#1388) using connection pool without WithBlock
+			// can cause RPCs to fail randomly. We can delete this after the issue is fixed.
+			option.WithGRPCDialOption(grpc.WithBlock()))
 	}
 
 	var csvFile *os.File

vendor/cloud.google.com/go/bigtable/export_test.go

@@ -98,7 +98,7 @@ type EmulatedEnv struct {
 
 // NewEmulatedEnv builds and starts the emulator based environment
 func NewEmulatedEnv(config IntegrationTestConfig) (*EmulatedEnv, error) {
-	srv, err := bttest.NewServer("127.0.0.1:0")
+	srv, err := bttest.NewServer("127.0.0.1:0", grpc.MaxRecvMsgSize(200<<20), grpc.MaxSendMsgSize(100<<20))
 	if err != nil {
 		return nil, err
 	}
@@ -152,7 +152,7 @@ func (e *EmulatedEnv) NewInstanceAdminClient() (*InstanceAdminClient, error) {
 func (e *EmulatedEnv) NewClient() (*Client, error) {
 	timeout := 20 * time.Second
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
-	conn, err := grpc.Dial(e.server.Addr, grpc.WithInsecure())
+	conn, err := grpc.Dial(e.server.Addr, grpc.WithInsecure(), grpc.WithDefaultCallOptions(grpc.MaxCallSendMsgSize(100<<20), grpc.MaxCallRecvMsgSize(100<<20)))
 	if err != nil {
 		return nil, err
 	}