2026-10-24 13:45:46 -07:00
|
|
|
package sub
|
|
|
|
|
|
|
|
|
|
import (
|
|
|
|
|
"fmt"
|
|
|
|
|
"strings"
|
|
|
|
|
"sync"
|
|
|
|
|
"sync/atomic"
|
|
|
|
|
"testing"
|
|
|
|
|
"time"
|
|
|
|
|
|
|
|
|
|
"github.com/mhsanaei/3x-ui/v3/internal/database"
|
|
|
|
|
"github.com/mhsanaei/3x-ui/v3/internal/database/model"
|
|
|
|
|
"github.com/mhsanaei/3x-ui/v3/internal/web/service"
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
func TestInboundSettingsCacheHitExpiryAndPurge(t *testing.T) {
|
|
|
|
|
now := time.Unix(1_000_000, 0)
|
|
|
|
|
cache := newInboundSettingsCache(10 * time.Second)
|
|
|
|
|
cache.now = func() time.Time { return now }
|
|
|
|
|
var loads atomic.Int32
|
|
|
|
|
load := func() (string, error) {
|
|
|
|
|
loads.Add(1)
|
|
|
|
|
return `{"clients":[{"email":"a@e"}],"decryption":"none"}`, nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
got, err := cache.settingsFor(1, load)
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("miss: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if got != `{"decryption":"none"}` {
|
|
|
|
|
t.Fatalf("settings = %s, want the clients array dropped", got)
|
|
|
|
|
}
|
|
|
|
|
if _, err := cache.settingsFor(1, load); err != nil || loads.Load() != 1 {
|
|
|
|
|
t.Fatalf("hit reloaded: loads = %d, err = %v", loads.Load(), err)
|
|
|
|
|
}
|
|
|
|
|
now = now.Add(11 * time.Second)
|
|
|
|
|
if _, err := cache.settingsFor(1, load); err != nil || loads.Load() != 2 {
|
|
|
|
|
t.Fatalf("expired entry must reload: loads = %d, err = %v", loads.Load(), err)
|
|
|
|
|
}
|
|
|
|
|
cache.purgeAll()
|
|
|
|
|
if _, err := cache.settingsFor(1, load); err != nil || loads.Load() != 3 {
|
|
|
|
|
t.Fatalf("purged entry must reload: loads = %d, err = %v", loads.Load(), err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestInboundSettingsCacheSingleFlight(t *testing.T) {
|
|
|
|
|
cache := newInboundSettingsCache(time.Minute)
|
|
|
|
|
release := make(chan struct{})
|
|
|
|
|
var loads atomic.Int32
|
|
|
|
|
load := func() (string, error) {
|
|
|
|
|
loads.Add(1)
|
|
|
|
|
<-release
|
|
|
|
|
return `{"method":"aes-128-gcm"}`, nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const callers = 8
|
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
|
for range callers {
|
|
|
|
|
wg.Go(func() {
|
|
|
|
|
if got, err := cache.settingsFor(7, load); err != nil || got != `{"method":"aes-128-gcm"}` {
|
|
|
|
|
t.Errorf("settingsFor = %q, %v", got, err)
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
// Let every caller reach the shared load before releasing it.
|
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
|
close(release)
|
|
|
|
|
wg.Wait()
|
|
|
|
|
if loads.Load() != 1 {
|
|
|
|
|
t.Fatalf("%d concurrent misses ran %d loads, want 1", callers, loads.Load())
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// A load that a panel edit overlaps may have read the row before the edit; it is served once but
|
|
|
|
|
// must not be kept, or the edit would stay invisible for a whole TTL.
|
|
|
|
|
func TestInboundSettingsCacheDropsALoadOverlappingAPurge(t *testing.T) {
|
|
|
|
|
cache := newInboundSettingsCache(time.Minute)
|
|
|
|
|
var loads atomic.Int32
|
|
|
|
|
load := func() (string, error) {
|
|
|
|
|
if loads.Add(1) == 1 {
|
|
|
|
|
cache.purgeAll()
|
|
|
|
|
}
|
|
|
|
|
return `{"decryption":"none"}`, nil
|
|
|
|
|
}
|
|
|
|
|
if _, err := cache.settingsFor(3, load); err != nil {
|
|
|
|
|
t.Fatalf("first read: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if _, err := cache.settingsFor(3, load); err != nil {
|
|
|
|
|
t.Fatalf("second read: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if loads.Load() != 2 {
|
|
|
|
|
t.Fatalf("loads = %d, want 2: a load that overlapped a purge was kept", loads.Load())
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const (
|
|
|
|
|
parityServerKey = "c2VydmVya2V5MTIzNDU2Nw=="
|
|
|
|
|
parityClientKey = "Y2xpZW50a2V5MTIzNDU2Nw=="
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
// seedParitySubscription gives subscriber "par" a VLESS, a Shadowsocks 2022 and a WireGuard
|
|
|
|
|
// inbound, whose links read the top-level settings, the server key and the peers respectively.
|
|
|
|
|
func seedParitySubscription(t *testing.T) {
|
|
|
|
|
t.Helper()
|
|
|
|
|
db := database.GetDB()
|
|
|
|
|
seedSubProtocolInbound(t, "par", "pv", 4701, 1, `{"network":"tcp","security":"tls","tlsSettings":{"serverName":"base.sni"}}`, model.VLESS)
|
|
|
|
|
ss := seedSubProtocolInbound(t, "par", "ps", 4702, 2, `{"network":"tcp","security":"none"}`, model.Shadowsocks)
|
|
|
|
|
ssSettings := fmt.Sprintf(`{"method":"2022-blake3-aes-128-gcm","password":%q,"network":"tcp,udp","clients":[{"email":"ps@e","password":%q,"subId":"par","enable":true}]}`, parityServerKey, parityClientKey)
|
|
|
|
|
if err := db.Model(ss).Update("settings", ssSettings).Error; err != nil {
|
|
|
|
|
t.Fatalf("shadowsocks settings: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if err := db.Model(&model.ClientRecord{}).Where("email = ?", "ps@e").Update("password", parityClientKey).Error; err != nil {
|
|
|
|
|
t.Fatalf("shadowsocks client password: %v", err)
|
|
|
|
|
}
|
|
|
|
|
serverPriv, _ := mustWireguardKeypair(t)
|
|
|
|
|
clientPriv, _ := mustWireguardKeypair(t)
|
|
|
|
|
wgSettings := fmt.Sprintf(`{"secretKey":%q,"clients":[{"email":"pw@e","privateKey":%q,"allowedIPs":["10.0.0.2/32"],"enable":true}]}`, serverPriv, clientPriv)
|
|
|
|
|
seedTunnelSubInbound(t, model.WireGuard, "pw", "par", "pw@e", wgSettings, 4703)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// renderSubscription is everything a subscriber can fetch: the raw links, the JSON and the Clash body.
|
|
|
|
|
func renderSubscription(t *testing.T, svc *SubService) []string {
|
|
|
|
|
t.Helper()
|
|
|
|
|
req := svc.ForRequest("req.example.com")
|
|
|
|
|
req.subscriptionBody = true
|
|
|
|
|
links, _, _, _, err := req.getSubs("par")
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("getSubs: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if len(links) != 3 {
|
|
|
|
|
t.Fatalf("links = %d, want one per inbound: %v", len(links), links)
|
|
|
|
|
}
|
|
|
|
|
jsonBody, _, err := NewSubJsonService("", "", "", "", svc).GetJson("par", "req.example.com", false)
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("GetJson: %v", err)
|
|
|
|
|
}
|
|
|
|
|
clashBody, _, err := NewSubClashService(false, "", false, svc).GetClash("par", "req.example.com")
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("GetClash: %v", err)
|
|
|
|
|
}
|
|
|
|
|
return []string{strings.Join(links, "\n"), jsonBody, clashBody}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// The cache hands generators settings without the clients array; every format must still render
|
|
|
|
|
// exactly what the full settings render, from the miss and from the hit alike.
|
|
|
|
|
func TestSettingsCacheRendersTheSameSubscription(t *testing.T) {
|
|
|
|
|
seedSubDB(t)
|
|
|
|
|
seedParitySubscription(t)
|
|
|
|
|
|
|
|
|
|
want := renderSubscription(t, NewSubService(""))
|
|
|
|
|
cached := NewSubService("")
|
|
|
|
|
t.Cleanup(cached.enableSettingsCache())
|
|
|
|
|
for round := range 2 {
|
|
|
|
|
got := renderSubscription(t, cached)
|
|
|
|
|
for i, format := range []string{"raw", "json", "clash"} {
|
|
|
|
|
if got[i] != want[i] {
|
|
|
|
|
t.Fatalf("round %d %s differs with the settings cache:\n got: %s\nwant: %s", round, format, got[i], want[i])
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if !strings.Contains(want[0], "ss://") {
|
|
|
|
|
t.Fatalf("raw subscription lost its shadowsocks link: %s", want[0])
|
|
|
|
|
}
|
|
|
|
|
if n := len(cached.settingsCache.entries); n != 2 {
|
|
|
|
|
t.Fatalf("cached %d inbounds, want 2: VLESS and Shadowsocks, never the WireGuard peers", n)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2026-11-02 06:27:49 -08:00
|
|
|
func TestSettingsCachePreservesTuicSubscriptions(t *testing.T) {
|
|
|
|
|
seedSubDB(t)
|
|
|
|
|
ib := seedSubProtocolInbound(t, "tuic-sub", "tuic", 4704, 1, `{}`, model.TUIC)
|
|
|
|
|
settings := `{"server":{"sni":"tuic.example.com"},"clients":[{"uuid":"11111111-2222-4333-8444-000000004704","password":"tuic-password","email":"tuic@e","subId":"tuic-sub","enable":true}]}`
|
|
|
|
|
if err := database.GetDB().Model(ib).Update("settings", settings).Error; err != nil {
|
|
|
|
|
t.Fatal(err)
|
|
|
|
|
}
|
|
|
|
|
if err := database.GetDB().Model(&model.ClientRecord{}).Where("email = ?", "tuic@e").Update("password", "tuic-password").Error; err != nil {
|
|
|
|
|
t.Fatal(err)
|
|
|
|
|
}
|
|
|
|
|
render := func(svc *SubService) []string {
|
|
|
|
|
t.Helper()
|
|
|
|
|
req := svc.ForRequest("req.example.com")
|
|
|
|
|
req.subscriptionBody = true
|
|
|
|
|
links, _, _, _, err := req.getSubs("tuic-sub")
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatal(err)
|
|
|
|
|
}
|
|
|
|
|
if len(links) != 1 || !strings.HasPrefix(links[0], "tuic://") {
|
|
|
|
|
t.Fatalf("TUIC link missing from subscription: %v", links)
|
|
|
|
|
}
|
|
|
|
|
clash, _, err := NewSubClashService(false, "", false, svc).GetClash("tuic-sub", "req.example.com")
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatal(err)
|
|
|
|
|
}
|
|
|
|
|
if !strings.Contains(clash, "tuic-password") {
|
|
|
|
|
t.Fatalf("TUIC credentials missing from Clash subscription: %s", clash)
|
|
|
|
|
}
|
|
|
|
|
return []string{links[0], clash}
|
|
|
|
|
}
|
|
|
|
|
want := render(NewSubService(""))
|
|
|
|
|
cached := NewSubService("")
|
|
|
|
|
t.Cleanup(cached.enableSettingsCache())
|
|
|
|
|
for round := range 2 {
|
|
|
|
|
got := render(cached)
|
|
|
|
|
for i, format := range []string{"raw", "clash"} {
|
|
|
|
|
if got[i] != want[i] {
|
|
|
|
|
t.Fatalf("round %d %s differs with settings cache:\n got: %s\nwant: %s", round, format, got[i], want[i])
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2026-10-24 13:45:46 -07:00
|
|
|
// Only the settings blob is cached: the inbound row is read on every fetch, so a port change or a
|
|
|
|
|
// disabled inbound reaches the next fetch, while settings wait for a panel edit's purge.
|
|
|
|
|
func TestSettingsCacheReadsTheInboundRowFresh(t *testing.T) {
|
|
|
|
|
seedSubDB(t)
|
|
|
|
|
ib := seedSubInbound(t, "s1", "fresh", 4611, 1, `{"network":"tcp","security":"none"}`)
|
|
|
|
|
cached := NewSubService("")
|
|
|
|
|
t.Cleanup(cached.enableSettingsCache())
|
|
|
|
|
cached.subscriptionBody = true
|
|
|
|
|
|
|
|
|
|
if _, err := cached.getInboundsBySubId("s1"); err != nil {
|
|
|
|
|
t.Fatalf("priming read: %v", err)
|
|
|
|
|
}
|
|
|
|
|
db := database.GetDB()
|
|
|
|
|
if err := db.Model(ib).Updates(map[string]any{"port": 4612, "settings": `{"clients":[],"decryption":"changed"}`}).Error; err != nil {
|
|
|
|
|
t.Fatalf("edit inbound: %v", err)
|
|
|
|
|
}
|
|
|
|
|
inbounds, err := cached.getInboundsBySubId("s1")
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("hit read: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if len(inbounds) != 1 || inbounds[0].Port != 4612 {
|
|
|
|
|
t.Fatalf("inbounds = %+v, want the new port on the next fetch", inbounds)
|
|
|
|
|
}
|
|
|
|
|
if strings.Contains(inbounds[0].Settings, "changed") {
|
|
|
|
|
t.Fatal("settings changed without a purge must still come from the cache")
|
|
|
|
|
}
|
|
|
|
|
service.InvalidateSubData()
|
|
|
|
|
inbounds, err = cached.getInboundsBySubId("s1")
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("post-purge read: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if len(inbounds) != 1 || !strings.Contains(inbounds[0].Settings, "changed") {
|
|
|
|
|
t.Fatalf("settings = %+v, want the edit after a purge", inbounds)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if err := db.Model(ib).Update("enable", false).Error; err != nil {
|
|
|
|
|
t.Fatalf("disable inbound: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if inbounds, err = cached.getInboundsBySubId("s1"); err != nil || len(inbounds) != 0 {
|
|
|
|
|
t.Fatalf("disabled inbound still served: %d inbounds, err %v", len(inbounds), err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Host rows have no invalidation hooks, so a cached fetch must still read them fresh: a host added
|
|
|
|
|
// between two reads has to show up on the second.
|
|
|
|
|
func TestGetInboundsBySubIdLoadsHostsOnCacheHit(t *testing.T) {
|
|
|
|
|
seedSubDB(t)
|
|
|
|
|
ib := seedSubInbound(t, "s1", "hh", 4603, 1, `{"network":"tcp","security":"none"}`)
|
|
|
|
|
cached := NewSubService("")
|
|
|
|
|
t.Cleanup(cached.enableSettingsCache())
|
|
|
|
|
cached.subscriptionBody = true
|
|
|
|
|
|
|
|
|
|
if _, err := cached.getInboundsBySubId("s1"); err != nil {
|
|
|
|
|
t.Fatalf("priming read: %v", err)
|
|
|
|
|
}
|
|
|
|
|
seedHost(t, &model.Host{InboundId: ib.Id, Remark: "edge", Address: "edge.example.com", SortOrder: 1})
|
|
|
|
|
if _, err := cached.getInboundsBySubId("s1"); err != nil {
|
|
|
|
|
t.Fatalf("hit read: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if len(cached.hostsByInbound[ib.Id]) != 1 {
|
|
|
|
|
t.Fatalf("cache hit did not load fresh host rows: %+v", cached.hostsByInbound)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Panel link rendering registered an invalidator per render and nothing ever unregistered one; a
|
|
|
|
|
// released invalidator must stop running.
|
|
|
|
|
func TestSubDataInvalidatorRelease(t *testing.T) {
|
|
|
|
|
var calls atomic.Int32
|
|
|
|
|
release := service.RegisterSubDataInvalidator(func() { calls.Add(1) })
|
|
|
|
|
service.InvalidateSubData()
|
|
|
|
|
release()
|
|
|
|
|
service.InvalidateSubData()
|
|
|
|
|
if calls.Load() != 1 {
|
|
|
|
|
t.Fatalf("invalidator ran %d times, want 1: a released invalidator kept running", calls.Load())
|
|
|
|
|
}
|
|
|
|
|
}
|