Merge pull request #114 from getlantern/set-url-overrides

Add SetURLOverrides for live config updates

Author: myleshorton

adapter/group.go

@@ -12,6 +12,11 @@ type MutableOutboundGroup interface {
 	Remove(tags ...string) (n int, err error)
 }
 
+// URLOverrideSetter is implemented by outbound groups that support per-outbound URL test overrides.
+type URLOverrideSetter interface {
+	SetURLOverrides(overrides map[string]string)
+}
+
 // TaggedConn is a net.Conn tagged with the outbound tag used to create it.
 type TaggedConn struct {
 	net.Conn

adapter/groups/manager.go

@@ -159,6 +159,26 @@ func (m *MutableGroupManager) addToGroup(outGroup adapter.MutableOutboundGroup,
 	return nil
 }
 
+// SetURLOverrides updates the per-outbound URL test overrides for the specified group.
+// The group must implement [adapter.URLOverrideSetter].
+func (m *MutableGroupManager) SetURLOverrides(group string, overrides map[string]string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.closed.Load() {
+		return ErrIsClosed
+	}
+	outGroup, ok := m.groups[group]
+	if !ok {
+		return fmt.Errorf("group %q not found", group)
+	}
+	setter, ok := outGroup.(adapter.URLOverrideSetter)
+	if !ok {
+		return fmt.Errorf("group %q does not support URL overrides", group)
+	}
+	setter.SetURLOverrides(overrides)
+	return nil
+}
+
 // RemoveFromGroup removes an outbound/endpoint from the specified group.
 func (m *MutableGroupManager) RemoveFromGroup(group, tag string) error {
 	m.mu.Lock()

adapter/groups/manager_test.go

@@ -11,6 +11,8 @@ import (
 	"github.com/sagernet/sing-box/log"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	lbAdapter "github.com/getlantern/lantern-box/adapter"
 )
 
 func TestRemovalQueue(t *testing.T) {
@@ -105,6 +107,81 @@ func TestRemovalQueue(t *testing.T) {
 	}
 }
 
+func TestSetURLOverrides(t *testing.T) {
+	logger := log.NewNOPFactory().Logger()
+
+	t.Run("delegates to URLOverrideSetter group", func(t *testing.T) {
+		mock := &mockURLOverrideGroup{urlOverrides: nil}
+		mgr := &MutableGroupManager{
+			groups: map[string]lbAdapter.MutableOutboundGroup{"auto-test": mock},
+			removalQueue: newRemovalQueue(
+				logger, &mockOutboundManager{}, &mockEndpointManager{}, &mockConnectionManager{},
+				pollInterval, forceAfter,
+			),
+		}
+		overrides := map[string]string{"out1": "https://example.com/cb"}
+		err := mgr.SetURLOverrides("auto-test", overrides)
+		require.NoError(t, err)
+		assert.Equal(t, overrides, mock.urlOverrides)
+	})
+
+	t.Run("error when group not found", func(t *testing.T) {
+		mgr := &MutableGroupManager{
+			groups: map[string]lbAdapter.MutableOutboundGroup{},
+			removalQueue: newRemovalQueue(
+				logger, &mockOutboundManager{}, &mockEndpointManager{}, &mockConnectionManager{},
+				pollInterval, forceAfter,
+			),
+		}
+		err := mgr.SetURLOverrides("nonexistent", nil)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "not found")
+	})
+
+	t.Run("error when group does not implement URLOverrideSetter", func(t *testing.T) {
+		mock := &mockPlainGroup{}
+		mgr := &MutableGroupManager{
+			groups: map[string]lbAdapter.MutableOutboundGroup{"plain": mock},
+			removalQueue: newRemovalQueue(
+				logger, &mockOutboundManager{}, &mockEndpointManager{}, &mockConnectionManager{},
+				pollInterval, forceAfter,
+			),
+		}
+		err := mgr.SetURLOverrides("plain", nil)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "does not support URL overrides")
+	})
+
+	t.Run("error when manager is closed", func(t *testing.T) {
+		mock := &mockURLOverrideGroup{}
+		mgr := &MutableGroupManager{
+			groups: map[string]lbAdapter.MutableOutboundGroup{"auto-test": mock},
+			removalQueue: newRemovalQueue(
+				logger, &mockOutboundManager{}, &mockEndpointManager{}, &mockConnectionManager{},
+				pollInterval, forceAfter,
+			),
+		}
+		mgr.closed.Store(true)
+		err := mgr.SetURLOverrides("auto-test", nil)
+		assert.ErrorIs(t, err, ErrIsClosed)
+	})
+}
+
+// mockURLOverrideGroup implements both MutableOutboundGroup and URLOverrideSetter.
+type mockURLOverrideGroup struct {
+	lbAdapter.MutableOutboundGroup
+	urlOverrides map[string]string
+}
+
+func (m *mockURLOverrideGroup) SetURLOverrides(overrides map[string]string) {
+	m.urlOverrides = overrides
+}
+
+// mockPlainGroup implements MutableOutboundGroup but NOT URLOverrideSetter.
+type mockPlainGroup struct {
+	lbAdapter.MutableOutboundGroup
+}
+
 type mockOutboundManager struct {
 	adapter.OutboundManager
 	tags []string

protocol/group/mutableurltest.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"io"
 	"log/slog"
+	"maps"
 	"net"
 	"net/http"
 	"net/url"
@@ -131,6 +132,11 @@ func (s *MutableURLTest) Remove(tags ...string) (n int, err error) {
 	return s.group.Remove(tags)
 }
 
+// SetURLOverrides replaces the per-outbound URL override map used during URL testing.
+func (s *MutableURLTest) SetURLOverrides(overrides map[string]string) {
+	s.group.SetURLOverrides(overrides)
+}
+
 func (s *MutableURLTest) URLTest(ctx context.Context) (map[string]uint16, error) {
 	return s.group.URLTest(ctx)
 }
@@ -363,6 +369,12 @@ func (g *urlTestGroup) Add(tags []string) (n int, err error) {
 	return n, nil
 }
 
+func (g *urlTestGroup) SetURLOverrides(overrides map[string]string) {
+	g.access.Lock()
+	defer g.access.Unlock()
+	g.urlOverrides = maps.Clone(overrides)
+}
+
 func (g *urlTestGroup) Remove(tags []string) (n int, err error) {
 	g.access.Lock()
 	defer g.access.Unlock()

protocol/group/mutableurltest_test.go

@@ -69,6 +69,67 @@ func TestTestURLForTag_DefaultURL(t *testing.T) {
 	assert.Equal(t, "https://default.example.com", g.testURLForTag("unknown"))
 }
 
+func TestSetURLOverrides(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	g := newURLTestGroup(
+		ctx,
+		&mockOutboundManager{outbounds: map[string]adapter.Outbound{
+			"out1": nil, "out2": nil, "out3": nil,
+		}},
+		sboxLog.NewNOPFactory().Logger(),
+		[]string{"out1", "out2", "out3"},
+		"https://default.example.com",
+		nil, // start with no overrides
+		time.Minute, time.Minute, 50,
+	)
+
+	// Initially all tags use the default URL
+	assert.Equal(t, "https://default.example.com", g.testURLForTag("out1"))
+
+	// Set overrides
+	g.SetURLOverrides(map[string]string{
+		"out1": "https://new-override.example.com",
+		"out3": "https://out3-override.example.com",
+	})
+	assert.Equal(t, "https://new-override.example.com", g.testURLForTag("out1"))
+	assert.Equal(t, "https://default.example.com", g.testURLForTag("out2"))
+	assert.Equal(t, "https://out3-override.example.com", g.testURLForTag("out3"))
+
+	// Replace with different overrides
+	g.SetURLOverrides(map[string]string{
+		"out2": "https://out2-override.example.com",
+	})
+	assert.Equal(t, "https://default.example.com", g.testURLForTag("out1"))
+	assert.Equal(t, "https://out2-override.example.com", g.testURLForTag("out2"))
+
+	// Clear overrides
+	g.SetURLOverrides(nil)
+	assert.Equal(t, "https://default.example.com", g.testURLForTag("out1"))
+	assert.Equal(t, "https://default.example.com", g.testURLForTag("out2"))
+}
+
+func TestSetURLOverrides_DoesNotMutateCallerMap(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	g := newURLTestGroup(
+		ctx,
+		&mockOutboundManager{outbounds: map[string]adapter.Outbound{"out1": nil}},
+		sboxLog.NewNOPFactory().Logger(),
+		[]string{"out1"},
+		"https://default.example.com",
+		nil,
+		time.Minute, time.Minute, 50,
+	)
+
+	callerMap := map[string]string{"out1": "https://original.example.com"}
+	g.SetURLOverrides(callerMap)
+
+	// Mutating the caller's map after SetURLOverrides should not affect the group
+	callerMap["out1"] = "https://mutated.example.com"
+	assert.Equal(t, "https://original.example.com", g.testURLForTag("out1"))
+}
+
 func TestTestURLForTag_WithOverrides(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()