* Fixed re-opening case after close lazy-initialized clients

* Removed dependency of call context for initializing lazy table client

Author: asmyasnikov

CHANGELOG.md

@@ -1,3 +1,6 @@
+* Fixed re-opening case after close lazy-initialized clients
+* Removed dependency of call context for initializing lazy table client
+
 ## v3.23.0
 * Added `WithTLSConfig` option for redefine TLS config
 * Added `sugar.LoadCertificatesFromFile` and `sugar.LoadCertificatesFromPem` helpers

internal/lazy/coordiantion.go

@@ -66,9 +66,6 @@ func (c *lazyCoordination) Close(ctx context.Context) (err error) {
 	if c.c == nil {
 		return nil
 	}
-	defer func() {
-		c.c = nil
-	}()
 	err = c.c.Close(ctx)
 	if err != nil {
 		return xerrors.WithStackTrace(err)

internal/lazy/ratelimiter.go

@@ -33,9 +33,6 @@ func (r *lazyRatelimiter) Close(ctx context.Context) (err error) {
 	if r.c == nil {
 		return nil
 	}
-	defer func() {
-		r.c = nil
-	}()
 	err = r.c.Close(ctx)
 	if err != nil {
 		return xerrors.WithStackTrace(err)

internal/lazy/scheme.go

@@ -42,9 +42,6 @@ func (s *lazyScheme) Close(ctx context.Context) (err error) {
 	if s.c == nil {
 		return nil
 	}
-	defer func() {
-		s.c = nil
-	}()
 	err = s.c.Close(ctx)
 	if err != nil {
 		return xerrors.WithStackTrace(err)

internal/lazy/scripting.go

@@ -63,9 +63,6 @@ func (s *lazyScripting) Close(ctx context.Context) (err error) {
 	if s.c == nil {
 		return nil
 	}
-	defer func() {
-		s.c = nil
-	}()
 	err = s.c.Close(ctx)
 	if err != nil {
 		return xerrors.WithStackTrace(err)

internal/lazy/table.go

@@ -26,15 +26,15 @@ func Table(db database.Connection, options []config.Option) table.Client {
 }
 
 func (t *lazyTable) CreateSession(ctx context.Context, opts ...table.Option) (s table.ClosableSession, err error) {
-	return t.client(ctx).CreateSession(ctx, opts...)
+	return t.client().CreateSession(ctx, opts...)
 }
 
 func (t *lazyTable) Do(ctx context.Context, op table.Operation, opts ...table.Option) (err error) {
-	return t.client(ctx).Do(ctx, op, opts...)
+	return t.client().Do(ctx, op, opts...)
 }
 
 func (t *lazyTable) DoTx(ctx context.Context, op table.TxOperation, opts ...table.Option) (err error) {
-	return t.client(ctx).DoTx(ctx, op, opts...)
+	return t.client().DoTx(ctx, op, opts...)
 }
 
 func (t *lazyTable) Close(ctx context.Context) (err error) {
@@ -43,21 +43,18 @@ func (t *lazyTable) Close(ctx context.Context) (err error) {
 	if t.c == nil {
 		return nil
 	}
-	defer func() {
-		t.c = nil
-	}()
 	err = t.c.Close(ctx)
 	if err != nil {
 		return xerrors.WithStackTrace(err)
 	}
 	return nil
 }
 
-func (t *lazyTable) client(ctx context.Context) table.Client {
+func (t *lazyTable) client() table.Client {
 	t.m.Lock()
 	defer t.m.Unlock()
 	if t.c == nil {
-		t.c = builder.New(ctx, t.db, t.options...)
+		t.c = builder.New(t.db, t.options)
 	}
 	return t.c
 }

internal/table/client.go

@@ -24,9 +24,9 @@ import (
 )
 
 var (
-	// errSessionPoolClosed returned by a client instance to indicate
-	// that client is closed and not able to complete requested operation.
-	errSessionPoolClosed = xerrors.Wrap(fmt.Errorf("session pool is closed"))
+	// errAlreadyClosed returned by a client instance to indicate
+	// that client is closed early and not able to complete requested operation.
+	errAlreadyClosed = xerrors.Wrap(fmt.Errorf("table client closed early"))
 
 	// errSessionPoolOverflow returned by a client instance to indicate
 	// that the client is full and requested operation is not able to complete.
@@ -52,18 +52,20 @@ type Client interface {
 	CloseSession(ctx context.Context, s Session) (err error)
 }
 
-func New(ctx context.Context, cc grpc.ClientConnInterface, opts ...config.Option) Client {
+func New(cc grpc.ClientConnInterface, opts []config.Option) Client {
 	config := config.New(opts...)
-	return newClient(ctx, cc, nil, config)
+	return newClient(cc, nil, config)
 }
 
 func newClient(
-	ctx context.Context,
 	cc grpc.ClientConnInterface,
 	builder SessionBuilder,
 	config config.Config,
 ) *client {
-	onDone := trace.TableOnInit(config.Trace(), &ctx)
+	var (
+		ctx    = context.Background()
+		onDone = trace.TableOnInit(config.Trace(), &ctx)
+	)
 	if builder == nil {
 		builder = func(ctx context.Context) (s Session, err error) {
 			return newSession(ctx, cc, config)
@@ -315,7 +317,7 @@ func (c *client) get(ctx context.Context, opts ...getOption) (s Session, err err
 	const maxAttempts = 100
 	for ; s == nil && err == nil && i < maxAttempts; i++ {
 		if c.isClosed() {
-			return nil, xerrors.WithStackTrace(errSessionPoolClosed)
+			return nil, xerrors.WithStackTrace(errAlreadyClosed)
 		}
 
 		// First, we try to get session from idle
@@ -415,7 +417,7 @@ func (c *client) waitFromCh(ctx context.Context, t trace.Table) (s Session, err
 
 // Put returns session to the client for further reuse.
 // If client is already closed Put() calls s.Close(ctx) and returns
-// errSessionPoolClosed.
+// errAlreadyClosed.
 // If client is overflow calls s.Close(ctx) and returns
 // errSessionPoolOverflow.
 //
@@ -432,7 +434,7 @@ func (c *client) Put(ctx context.Context, s Session) (err error) {
 
 	switch {
 	case c.closed:
-		err = xerrors.WithStackTrace(errSessionPoolClosed)
+		err = xerrors.WithStackTrace(errAlreadyClosed)
 
 	case c.idle.Len() >= c.limit:
 		err = xerrors.WithStackTrace(errSessionPoolOverflow)
@@ -473,7 +475,7 @@ func (c *client) Close(ctx context.Context) (err error) {
 	}()
 
 	if c.isClosed() {
-		return
+		return xerrors.WithStackTrace(errAlreadyClosed)
 	}
 
 	c.mu.Lock()
@@ -540,7 +542,7 @@ func retryOptions(trace trace.Table, opts ...table.Option) table.Options {
 // Warning: if deadline without deadline or cancellation func Retry will be worked infinite
 func (c *client) Do(ctx context.Context, op table.Operation, opts ...table.Option) (err error) {
 	if c.isClosed() {
-		return xerrors.WithStackTrace(errSessionPoolClosed)
+		return xerrors.WithStackTrace(errAlreadyClosed)
 	}
 	opts = append(opts, table.WithTrace(c.config.Trace()))
 	return do(
@@ -554,7 +556,7 @@ func (c *client) Do(ctx context.Context, op table.Operation, opts ...table.Optio
 
 func (c *client) DoTx(ctx context.Context, op table.TxOperation, opts ...table.Option) (err error) {
 	if c.isClosed() {
-		return xerrors.WithStackTrace(errSessionPoolClosed)
+		return xerrors.WithStackTrace(errAlreadyClosed)
 	}
 	return doTx(
 		ctx,

internal/table/client_test.go

@@ -230,10 +230,10 @@ func TestSessionPoolCloseWhenWaiting(t *testing.T) {
 			const timeout = time.Second
 			select {
 			case err := <-got:
-				if !xerrors.Is(err, errSessionPoolClosed) {
+				if !xerrors.Is(err, errAlreadyClosed) {
 					t.Fatalf(
 						"unexpected error: %v; want %v",
-						err, errSessionPoolClosed,
+						err, errAlreadyClosed,
 					)
 				}
 			case <-time.After(timeout):
@@ -310,10 +310,10 @@ func TestSessionPoolClose(t *testing.T) {
 		t.Fatalf("unexpected session close")
 	}
 
-	if err := p.Put(context.Background(), s3); !xerrors.Is(err, errSessionPoolClosed) {
+	if err := p.Put(context.Background(), s3); !xerrors.Is(err, errAlreadyClosed) {
 		t.Errorf(
 			"unexpected Put() error: %v; want %v",
-			err, errSessionPoolClosed,
+			err, errAlreadyClosed,
 		)
 	}
 	wg.Wait()
@@ -366,7 +366,7 @@ func TestRaceWgClosed(t *testing.T) {
 								return nil
 							},
 						)
-						if xerrors.Is(err, errSessionPoolClosed) {
+						if xerrors.Is(err, errAlreadyClosed) {
 							return
 						}
 					}
@@ -474,7 +474,6 @@ func TestSessionPoolRacyGet(t *testing.T) {
 	}
 	create := make(chan createReq)
 	p := newClient(
-		context.Background(),
 		nil,
 		(&StubBuilder{
 			Limit: 1,
@@ -1357,7 +1356,6 @@ func newClientWithStubBuilder(
 	options ...config.Option,
 ) *client {
 	return newClient(
-		context.Background(),
 		cc,
 		(&StubBuilder{
 			T:     t,

internal/table/session_test.go

@@ -331,7 +331,6 @@ func TestSessionOperationModeOnExecuteDataQuery(t *testing.T) {
 				for _, srcDst := range fromTo {
 					t.Run(srcDst.srcMode.String()+"->"+srcDst.dstMode.String(), func(t *testing.T) {
 						client := newClient(
-							context.Background(),
 							testutil.NewDB(
 								testutil.WithInvokeHandlers(
 									testutil.InvokeHandlers{