remove unused methods

Author: ndyakov

hitless/pool_hook_test.go

@@ -100,14 +100,6 @@ func (mp *mockPool) RemovePoolHook(hook pool.PoolHook) {
 	// Mock implementation - do nothing
 }
 
-func (mp *mockPool) TrackConn(conn *pool.Conn) {
-	// Mock implementation - do nothing
-}
-
-func (mp *mockPool) UntrackConn(conn *pool.Conn) {
-	// Mock implementation - do nothing
-}
-
 func (mp *mockPool) Close() error {
 	return nil
 }

internal/pool/hooks_test.go

@@ -10,11 +10,11 @@ import (
 
 // TestHook for testing hook functionality
 type TestHook struct {
-	OnGetCalled int
-	OnPutCalled int
-	GetError    error
-	PutError    error
-	ShouldPool  bool
+	OnGetCalled  int
+	OnPutCalled  int
+	GetError     error
+	PutError     error
+	ShouldPool   bool
 	ShouldRemove bool
 }
 
@@ -30,97 +30,97 @@ func (th *TestHook) OnPut(ctx context.Context, conn *Conn) (shouldPool bool, sho
 
 func TestPoolHookManager(t *testing.T) {
 	manager := NewPoolHookManager()
-	
+
 	// Test initial state
 	if manager.GetHookCount() != 0 {
 		t.Errorf("Expected 0 hooks initially, got %d", manager.GetHookCount())
 	}
-	
+
 	// Add hooks
 	hook1 := &TestHook{ShouldPool: true}
 	hook2 := &TestHook{ShouldPool: true}
-	
+
 	manager.AddHook(hook1)
 	manager.AddHook(hook2)
-	
+
 	if manager.GetHookCount() != 2 {
 		t.Errorf("Expected 2 hooks after adding, got %d", manager.GetHookCount())
 	}
-	
+
 	// Test ProcessOnGet
 	ctx := context.Background()
 	conn := &Conn{} // Mock connection
-	
+
 	err := manager.ProcessOnGet(ctx, conn, false)
 	if err != nil {
 		t.Errorf("ProcessOnGet should not error: %v", err)
 	}
-	
+
 	if hook1.OnGetCalled != 1 {
 		t.Errorf("Expected hook1.OnGetCalled to be 1, got %d", hook1.OnGetCalled)
 	}
-	
+
 	if hook2.OnGetCalled != 1 {
 		t.Errorf("Expected hook2.OnGetCalled to be 1, got %d", hook2.OnGetCalled)
 	}
-	
+
 	// Test ProcessOnPut
 	shouldPool, shouldRemove, err := manager.ProcessOnPut(ctx, conn)
 	if err != nil {
 		t.Errorf("ProcessOnPut should not error: %v", err)
 	}
-	
+
 	if !shouldPool {
 		t.Error("Expected shouldPool to be true")
 	}
-	
+
 	if shouldRemove {
 		t.Error("Expected shouldRemove to be false")
 	}
-	
+
 	if hook1.OnPutCalled != 1 {
 		t.Errorf("Expected hook1.OnPutCalled to be 1, got %d", hook1.OnPutCalled)
 	}
-	
+
 	if hook2.OnPutCalled != 1 {
 		t.Errorf("Expected hook2.OnPutCalled to be 1, got %d", hook2.OnPutCalled)
 	}
-	
+
 	// Remove a hook
 	manager.RemoveHook(hook1)
-	
+
 	if manager.GetHookCount() != 1 {
 		t.Errorf("Expected 1 hook after removing, got %d", manager.GetHookCount())
 	}
 }
 
 func TestHookErrorHandling(t *testing.T) {
 	manager := NewPoolHookManager()
-	
+
 	// Hook that returns error on Get
 	errorHook := &TestHook{
-		GetError: errors.New("test error"),
+		GetError:   errors.New("test error"),
 		ShouldPool: true,
 	}
-	
+
 	normalHook := &TestHook{ShouldPool: true}
-	
+
 	manager.AddHook(errorHook)
 	manager.AddHook(normalHook)
-	
+
 	ctx := context.Background()
 	conn := &Conn{}
-	
+
 	// Test that error stops processing
 	err := manager.ProcessOnGet(ctx, conn, false)
 	if err == nil {
 		t.Error("Expected error from ProcessOnGet")
 	}
-	
+
 	if errorHook.OnGetCalled != 1 {
 		t.Errorf("Expected errorHook.OnGetCalled to be 1, got %d", errorHook.OnGetCalled)
 	}
-	
+
 	// normalHook should not be called due to error
 	if normalHook.OnGetCalled != 0 {
 		t.Errorf("Expected normalHook.OnGetCalled to be 0, got %d", normalHook.OnGetCalled)
@@ -129,46 +129,44 @@ func TestHookErrorHandling(t *testing.T) {
 
 func TestHookShouldRemove(t *testing.T) {
 	manager := NewPoolHookManager()
-	
+
 	// Hook that says to remove connection
 	removeHook := &TestHook{
-		ShouldPool: false,
+		ShouldPool:   false,
 		ShouldRemove: true,
 	}
-	
+
 	normalHook := &TestHook{ShouldPool: true}
-	
+
 	manager.AddHook(removeHook)
 	manager.AddHook(normalHook)
-	
+
 	ctx := context.Background()
 	conn := &Conn{}
-	
+
 	shouldPool, shouldRemove, err := manager.ProcessOnPut(ctx, conn)
 	if err != nil {
 		t.Errorf("ProcessOnPut should not error: %v", err)
 	}
-	
+
 	if shouldPool {
 		t.Error("Expected shouldPool to be false")
 	}
-	
+
 	if !shouldRemove {
 		t.Error("Expected shouldRemove to be true")
 	}
-	
+
 	if removeHook.OnPutCalled != 1 {
 		t.Errorf("Expected removeHook.OnPutCalled to be 1, got %d", removeHook.OnPutCalled)
 	}
-	
+
 	// normalHook should not be called due to early return
 	if normalHook.OnPutCalled != 0 {
 		t.Errorf("Expected normalHook.OnPutCalled to be 0, got %d", normalHook.OnPutCalled)
 	}
 }
 
-
-
 func TestPoolWithHooks(t *testing.T) {
 	// Create a pool with hooks
 	hookManager := NewPoolHookManager()

internal/pool/pool.go

@@ -70,9 +70,6 @@ type Pooler interface {
 	AddPoolHook(hook PoolHook)
 	RemovePoolHook(hook PoolHook)
 
-	TrackConn(*Conn)
-	UntrackConn(*Conn)
-
 	Close() error
 }
 
@@ -758,15 +755,4 @@ func (p *ConnPool) isHealthyConn(cn *Conn, now time.Time) bool {
 	return true
 }
 
-func (p *ConnPool) TrackConn(cn *Conn) {
-	p.connsMu.Lock()
-	p.poolSize.Add(1)
-	p.conns[cn.GetID()] = cn
-	p.connsMu.Unlock()
-}
 
-func (p *ConnPool) UntrackConn(cn *Conn) {
-	p.connsMu.Lock()
-	delete(p.conns, cn.GetID())
-	p.connsMu.Unlock()
-}

internal/pool/pool_single.go

@@ -62,7 +62,3 @@ func (p *SingleConnPool) Stats() *Stats {
 func (p *SingleConnPool) AddPoolHook(hook PoolHook) {}
 
 func (p *SingleConnPool) RemovePoolHook(hook PoolHook) {}
-
-func (p *SingleConnPool) TrackConn(cn *Conn) {}
-
-func (p *SingleConnPool) UntrackConn(cn *Conn) {}

internal/pool/pool_sticky.go

@@ -203,7 +203,3 @@ func (p *StickyConnPool) Stats() *Stats {
 func (p *StickyConnPool) AddPoolHook(hook PoolHook) {}
 
 func (p *StickyConnPool) RemovePoolHook(hook PoolHook) {}
-
-func (p *StickyConnPool) TrackConn(cn *Conn) {}
-
-func (p *StickyConnPool) UntrackConn(cn *Conn) {}

osscluster.go

@@ -1883,7 +1883,9 @@ func (c *ClusterClient) pubSub() *PubSub {
 			return cn, nil
 		},
 		closeConn: func(cn *pool.Conn) error {
-			err := node.Client.connPool.CloseConn(cn)
+			// Untrack connection from PubSubPool
+			node.Client.pubSubPool.UntrackConn(cn)
+			err := cn.Close()
 			node = nil
 			return err
 		},

redis.go

@@ -1061,10 +1061,12 @@ func (c *Client) pubSub() *PubSub {
 				_ = cn.Close()
 				return nil, err
 			}
+			// Track connection in PubSubPool
 			c.pubSubPool.TrackConn(cn)
 			return cn, nil
 		},
 		closeConn: func(cn *pool.Conn) error {
+			// Untrack connection from PubSubPool
 			c.pubSubPool.UntrackConn(cn)
 			_ = cn.Close()
 			return nil

sentinel.go

@@ -580,22 +580,23 @@ func (c *SentinelClient) pubSub() *PubSub {
 	pubsub := &PubSub{
 		opt: c.opt,
 		newConn: func(ctx context.Context, addr string, channels []string) (*pool.Conn, error) {
-			netConn, err := c.dialHook(ctx, c.opt.Network, addr)
+			cn, err := c.pubSubPool.NewConn(ctx, c.opt.Network, addr, channels)
 			if err != nil {
 				return nil, err
 			}
-			cn := pool.NewConnWithBufferSize(netConn, c.opt.ReadBufferSize, c.opt.WriteBufferSize)
-
 			// will return nil if already initialized
 			err = c.initConn(ctx, cn)
 			if err != nil {
 				_ = cn.Close()
 				return nil, err
 			}
-
+			// Track connection in PubSubPool
+			c.pubSubPool.TrackConn(cn)
 			return cn, nil
 		},
 		closeConn: func(cn *pool.Conn) error {
+			// Untrack connection from PubSubPool
+			c.pubSubPool.UntrackConn(cn)
 			_ = cn.Close()
 			return nil
 		},