refactor: rename Next to NextServer

Author: cloud-j-luna

internal/proxy/balancer.go

@@ -21,8 +21,8 @@ const ProxyKeyHeader = "X-PROXY-KEY"
 type LoadBalancer interface {
 	// Update updates the list of available servers.
 	Update([]*Server)
-	// Next returns the next server to be used based on the load balancing algorithm.
-	Next(*http.Request) *Server
+	// NextServer returns the next server to be used based on the load balancing algorithm.
+	NextServer(*http.Request) *Server
 }
 
 // RoundRobin is a simple load balancer that distributes incoming requests
@@ -45,9 +45,9 @@ func NewRoundRobin(log *slog.Logger) *RoundRobin {
 	}
 }
 
-// Next returns the next server to be used based on the round-robin algorithm.
+// NextServer returns the next server to be used based on the round-robin algorithm.
 // If the selected server is unhealthy, it will recursively try the next server.
-func (rr *RoundRobin) Next(_ *http.Request) *Server {
+func (rr *RoundRobin) NextServer(r *http.Request) *Server {
 	rr.mu.Lock()
 	if len(rr.servers) == 0 {
 		return nil
@@ -60,7 +60,7 @@ func (rr *RoundRobin) Next(_ *http.Request) *Server {
 		return server
 	}
 	rr.log.Warn("server is unhealthy, trying next", "name", server.name)
-	return rr.Next(nil)
+	return rr.NextServer(r)
 }
 
 // Update updates the list of available servers.
@@ -100,15 +100,15 @@ func NewLatencyBased(log *slog.Logger) *LatencyBased {
 	}
 }
 
-// Next returns the next server based on the weighted random selection,
+// NextServer returns the next server based on the weighted random selection,
 // where the weight is determined by the latency Rate of each server. The cumulative
 // approach is used to select a server, effectively creating a "range" for each
 // server in the interval [0, 1]. For example, if the rates are [0.5, 0.3, 0.2],
 // the ranges would be: Server 1: [0, 0.5), Server 2: [0.5, 0.8), Server 3: [0.8, 1).
 // The random number will fall into one of these ranges, effectively selecting
 // a server based on its latency rate. This approach works regardless of the order of
 // the servers, so there's no need to sort them based on latency or rate.
-func (rr *LatencyBased) Next(_ *http.Request) *Server {
+func (rr *LatencyBased) NextServer(_ *http.Request) *Server {
 	rr.mu.Lock()
 	defer rr.mu.Unlock()
 
@@ -204,13 +204,13 @@ func NewStickyLatencyBased(log *slog.Logger, sessionTimeout time.Duration) *Stic
 	return slb
 }
 
-// Next returns the next server based on session affinity and latency.
+// NextServer returns the next server based on session affinity and latency.
 // It first checks for existing session identifiers in headers or cookies,
 // then falls back to the embedded LatencyBased selection for new sessions.
-func (slb *StickyLatencyBased) Next(req *http.Request) *Server {
+func (slb *StickyLatencyBased) NextServer(req *http.Request) *Server {
 	if req == nil {
 		slb.log.Warn("provided request is nil")
-		return slb.LatencyBased.Next(nil)
+		return slb.LatencyBased.NextServer(req)
 	}
 
 	slb.LatencyBased.mu.Lock()
@@ -256,7 +256,7 @@ func (slb *StickyLatencyBased) Next(req *http.Request) *Server {
 		}
 	}
 
-	server := slb.LatencyBased.Next(req)
+	server := slb.LatencyBased.NextServer(req)
 
 	if server != nil && sessionID != "" {
 		slb.sessionMu.Lock()

internal/proxy/balancer_test.go

@@ -17,7 +17,7 @@ import (
 	"github.com/akash-network/rpc-proxy/internal/seed"
 )
 
-func TestRoundRobin_Next(t *testing.T) {
+func TestRoundRobin_NextServer(t *testing.T) {
 	servers := []*Server{
 		{
 			name:         "a",
@@ -67,7 +67,7 @@ func TestRoundRobin_Next(t *testing.T) {
 			defer wg.Done()
 			for j := 0; j < n; j++ {
 				t.Logf("goroutine %d: ", id)
-				lb.Next(nil)
+				lb.NextServer(nil)
 			}
 		}(i)
 	}
@@ -79,7 +79,7 @@ func TestRoundRobin_Next(t *testing.T) {
 	}
 }
 
-func TestLatencyBased_Next(t *testing.T) {
+func TestLatencyBased_NextServer(t *testing.T) {
 	servers := []*Server{
 		{
 			name:         "a",
@@ -142,7 +142,7 @@ func TestLatencyBased_Next(t *testing.T) {
 		go func(id int) {
 			for j := 0; j < n; j++ {
 				t.Logf("goroutine %d: ", id)
-				queue <- lb.Next(nil)
+				queue <- lb.NextServer(nil)
 			}
 			wg.Done()
 		}(i)
@@ -190,7 +190,7 @@ func TestStickyLatencyBased_SessionAffinity(t *testing.T) {
 	req1.Header.Set(ProxyKeyHeader, "session123")
 
 	// First request should select a server (using weighted random selection)
-	server1 := lb.Next(req1)
+	server1 := lb.NextServer(req1)
 	if server1 == nil {
 		t.Fatal("expected a server to be selected")
 	}
@@ -199,7 +199,7 @@ func TestStickyLatencyBased_SessionAffinity(t *testing.T) {
 	// Second request with same session ID should go to same server
 	req2 := createTestRequest()
 	req2.Header.Set(ProxyKeyHeader, "session123")
-	server2 := lb.Next(req2)
+	server2 := lb.NextServer(req2)
 
 	if server2.name != server1.name {
 		t.Errorf("expected same server %s, got %s", server1.name, server2.name)
@@ -208,7 +208,7 @@ func TestStickyLatencyBased_SessionAffinity(t *testing.T) {
 	// Different session ID should potentially select different server (but likely same due to latency)
 	req3 := createTestRequest()
 	req3.Header.Set(ProxyKeyHeader, "session456")
-	server3 := lb.Next(req3)
+	server3 := lb.NextServer(req3)
 
 	if server3 == nil {
 		t.Fatal("expected a server to be selected")
@@ -230,7 +230,7 @@ func TestStickyLatencyBased_NoProxyKey(t *testing.T) {
 	req1 := createTestRequest()
 	// No X-PROXY-KEY header set
 
-	server1 := lb.Next(req1)
+	server1 := lb.NextServer(req1)
 	if server1 == nil {
 		t.Fatal("expected a server to be selected")
 	}
@@ -241,7 +241,7 @@ func TestStickyLatencyBased_NoProxyKey(t *testing.T) {
 
 	// Second request without X-PROXY-KEY should also use latency-based selection
 	req2 := createTestRequest()
-	server2 := lb.Next(req2)
+	server2 := lb.NextServer(req2)
 
 	if server2 == nil {
 		t.Fatal("expected a server to be selected")
@@ -265,15 +265,15 @@ func TestStickyLatencyBased_SessionPersistence(t *testing.T) {
 	req1 := createTestRequest()
 	req1.Header.Set(ProxyKeyHeader, "session123")
 
-	server1 := lb.Next(req1)
+	server1 := lb.NextServer(req1)
 	if server1 == nil {
 		t.Fatal("expected a server to be selected")
 	}
 
 	// Second request with same session should go to same server
 	req2 := createTestRequest()
 	req2.Header.Set(ProxyKeyHeader, "session123")
-	server2 := lb.Next(req2)
+	server2 := lb.NextServer(req2)
 
 	if server2 == nil {
 		t.Fatal("expected a server to be selected")
@@ -304,7 +304,7 @@ func TestStickyLatencyBased_SessionTimeout(t *testing.T) {
 	req1 := createTestRequest()
 	req1.Header.Set(ProxyKeyHeader, "session123")
 
-	server1 := lb.Next(req1)
+	server1 := lb.NextServer(req1)
 	if server1 == nil {
 		t.Fatal("expected a server to be selected")
 	}
@@ -344,7 +344,7 @@ func TestStickyLatencyBased_CacheHitMiss(t *testing.T) {
 	req.Header.Set(ProxyKeyHeader, "cache-test")
 
 	// First request - cache miss, should create new session
-	server1 := lb.Next(req)
+	server1 := lb.NextServer(req)
 	if server1 == nil {
 		t.Fatal("expected a server to be selected")
 	}
@@ -362,7 +362,7 @@ func TestStickyLatencyBased_CacheHitMiss(t *testing.T) {
 	}
 
 	// Second request within timeout - cache hit, should return same server
-	server2 := lb.Next(req)
+	server2 := lb.NextServer(req)
 	if server2 != server1 {
 		t.Error("expected same server for cache hit")
 	}
@@ -371,7 +371,7 @@ func TestStickyLatencyBased_CacheHitMiss(t *testing.T) {
 	time.Sleep(150 * time.Millisecond)
 
 	// Third request after timeout - cache miss due to expiry, should trigger inline cleanup
-	server3 := lb.Next(req)
+	server3 := lb.NextServer(req)
 	if server3 == nil {
 		t.Fatal("expected a server to be selected after timeout")
 	}
@@ -412,7 +412,7 @@ func TestStickyLatencyBased_ProxyKeyHeader(t *testing.T) {
 	req1 := createTestRequest()
 	req1.Header.Set(ProxyKeyHeader, "session-priority")
 
-	server1 := lb.Next(req1)
+	server1 := lb.NextServer(req1)
 	if server1 == nil {
 		t.Fatal("expected a server to be selected")
 	}
@@ -421,7 +421,7 @@ func TestStickyLatencyBased_ProxyKeyHeader(t *testing.T) {
 	req2 := createTestRequest()
 	req2.Header.Set(ProxyKeyHeader, "session-priority")
 
-	server2 := lb.Next(req2)
+	server2 := lb.NextServer(req2)
 	if server2.name != server1.name {
 		t.Errorf("expected same server %s, got %s", server1.name, server2.name)
 	}
@@ -455,7 +455,7 @@ func TestStickyLatencyBased_ConcurrentAccess(t *testing.T) {
 				req := createTestRequest()
 				req.Header.Set(ProxyKeyHeader, sessionID)
 
-				server := lb.Next(req)
+				server := lb.NextServer(req)
 				if server == nil {
 					t.Errorf("goroutine %d: expected a server to be selected", goroutineID)
 					return
@@ -490,7 +490,7 @@ func TestStickyLatencyBased_ServerUpdate(t *testing.T) {
 	req := createTestRequest()
 	req.Header.Set(ProxyKeyHeader, "session123")
 
-	server1 := lb.Next(req)
+	server1 := lb.NextServer(req)
 	if server1 == nil {
 		t.Fatal("expected a server to be selected")
 	}
@@ -503,7 +503,7 @@ func TestStickyLatencyBased_ServerUpdate(t *testing.T) {
 	lb.Update(updatedServers)
 
 	// Request with same session should now go to a different server since server1 is gone
-	server2 := lb.Next(req)
+	server2 := lb.NextServer(req)
 	if server2 == nil {
 		t.Fatal("expected a server to be selected")
 	}

internal/proxy/grpc.go

@@ -44,7 +44,7 @@ func (p *GRPCProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if srv := p.lb.Next(r); srv != nil {
+	if srv := p.lb.NextServer(r); srv != nil {
 
 		// Create the reverse proxy
 		proxy := httputil.ReverseProxy{

internal/proxy/proxy_test.go

@@ -50,7 +50,6 @@ func TestRPCProxy(t *testing.T) {
 
 	stats := proxy.Stats()
 	require.Len(t, stats, 3)
-
 }
 
 func TestRestProxy(t *testing.T) {
@@ -319,6 +318,6 @@ type MockLoadBalancer struct{}
 
 func (m *MockLoadBalancer) Update(servers []*Server) {}
 
-func (m *MockLoadBalancer) Next(*http.Request) *Server {
+func (m *MockLoadBalancer) NextServer(*http.Request) *Server {
 	return nil
 }

internal/proxy/rest.go

@@ -47,7 +47,7 @@ func (p *RestProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 
 	r.URL.Path = strings.TrimPrefix(r.URL.Path, "/rest")
-	if srv := p.lb.Next(r); srv != nil {
+	if srv := p.lb.NextServer(r); srv != nil {
 		proxy := newRedirectFollowingReverseProxy(srv, p.log, "rest")
 		proxy.ServeHTTP(w, r)
 		metrics.IncrementRequestCount("rest", srv.Url.String())

internal/proxy/rpc.go

@@ -47,7 +47,7 @@ func (p *RPCProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 
 	r.URL.Path = strings.TrimPrefix(r.URL.Path, "/rpc")
-	if srv := p.lb.Next(r); srv != nil {
+	if srv := p.lb.NextServer(r); srv != nil {
 		proxy := newRedirectFollowingReverseProxy(srv, p.log, "rpc")
 		proxy.ServeHTTP(w, r)
 		metrics.IncrementRequestCount("rpc", srv.Url.String())