2026-06-01 13:54:56 -07:00
|
|
|
package service
|
|
|
|
|
|
|
|
|
|
import (
|
2026-06-11 05:28:09 -07:00
|
|
|
"fmt"
|
2026-06-01 13:54:56 -07:00
|
|
|
"path/filepath"
|
2026-07-02 04:37:06 -07:00
|
|
|
"strings"
|
2026-06-01 13:54:56 -07:00
|
|
|
"testing"
|
|
|
|
|
|
style: adopt golangci-lint v2 and resolve all findings
Add .golangci.yml (v2): the standard linters plus bodyclose, errorlint, noctx, misspell, rowserrcheck, sqlclosecheck, unconvert, usestdlibvars, with gofumpt + goimports formatters. Enable the std-error-handling exclusion preset for idiomatic Close/Remove/Setenv ignores; scope-exclude SA1019 (parser.ParseDir in tools/openapigen) and ST1005 (intentional capitalized user-facing error copy that tests assert verbatim). No inline nolint directives were introduced.
Resolve all 217 findings behavior-preserving: gofumpt/goimports formatting, explicit blank assignment on intentionally ignored errors, errors.Is/errors.As and %w wrapping, context-aware stdlib calls (CommandContext/QueryContext/NewRequestWithContext/Dialer), staticcheck simplifications, removed redundant conversions, http.StatusOK and http.MethodGet, inlined the go:fix intPtr helper, and deferred sql rows Close. Add a golangci CI job mirroring the existing Go jobs.
2026-06-27 06:42:22 -07:00
|
|
|
"gorm.io/gorm"
|
|
|
|
|
|
refactor: focused service files, leaf subpackages, and an internal/ layout (#5167)
* refactor(service): split client.go into focused files
client.go had grown to 4455 lines mixing ~10 responsibilities. Split it
verbatim into cohesive same-package files (no behavior change):
client.go foundation: ClientService, ClientWithAttachments,
ClientCreatePayload, ErrClientNotInInbound, sqlInChunk
client_locks.go inbound mutation locks, delete tombstones, compactOrphans
client_lookup.go read-only lookups (GetByID, List, EffectiveFlow, ...)
client_link.go inbound association sync (SyncInbound, DetachInbound, ...)
client_crud.go single-client CRUD + validation + protocol defaults
client_inbound_apply.go low-level inbound-settings mutators + by-email setters
client_bulk.go bulk attach/detach/adjust/delete/create + DelDepleted
client_traffic.go traffic-reset paths
client_groups.go client group management
client_paging.go paged listing, filtering, sorting, summary
Every declaration moved unchanged (verified: identical func/type/const/var
signature set before vs after). Imports redistributed per file via goimports.
go build ./..., go vet, and go test ./web/service/... all pass.
* refactor(service): split inbound.go into focused files
inbound.go was 4100 lines. Split it verbatim into cohesive same-package
files (no behavior change):
inbound.go core inbound CRUD + InboundService (keeps pkg doc)
inbound_protocol.go protocol / stream capability helpers
inbound_node.go node/runtime/remote coordination + online tracking
inbound_traffic.go traffic accounting, reset, client stats
inbound_client_ips.go per-client IP tracking
inbound_clients.go client lookups within inbounds + copy-clients
inbound_disable.go auto-disable invalid inbounds/clients
inbound_migration.go DB migrations
inbound_sublink.go subscription link providers
inbound_util.go generic slice/string helpers
Identical func/type/const/var signature set before vs after; package doc
comment preserved on inbound.go. Imports redistributed via goimports.
Build, vet, and go test ./web/service/... all pass.
* refactor(service): split tgbot.go into focused files
tgbot.go was 3738 lines dominated by a 1246-line answerCallback. Split it
verbatim into cohesive same-package files (no behavior change):
tgbot.go lifecycle, bot setup, caches, small utils
tgbot_router.go incoming update / command / callback dispatch
tgbot_send.go outbound messaging primitives
tgbot_client.go client views, actions, subscription links
tgbot_inbound.go inbound listing / pickers
tgbot_report.go server usage, exhausted, online, backups, notifications
Identical func/type/const/var signature set before vs after. Imports
redistributed via goimports. Build, vet, and go test ./web/service/... pass.
* refactor(client): dedupe single-field by-email setters
ResetClientIpLimitByEmail, ResetClientExpiryTimeByEmail, and
ResetClientTrafficLimitByEmail shared an identical ~50-line body that
resolves the inbound by email, confirms the client exists, rewrites a
single-client settings payload, and delegates to UpdateInboundClient.
Extract that into applyClientFieldByEmail(inboundSvc, email, mutate) and
reduce each setter to a 3-line wrapper. Behavior is unchanged: same checks
and error strings, same single-client payload contract, same totalGB guard.
SetClientTelegramUserID (resolves by traffic id, different error text) and
ToggleClientEnableByEmail/SetClientEnableByEmail (different return shape and
a pre-read of the old state) intentionally keep their own bodies.
* refactor(service): extract panel/ subpackage
Move the panel-administration leaf services out of the flat service
package into web/service/panel/ (package panel):
user.go UserService (auth / 2FA / LDAP)
panel.go PanelService (restart / self-update) + version helpers
panel_other.go non-unix RestartPanel
panel_unix.go unix RestartPanel
api_token.go ApiTokenService
websocket.go WebSocketService
panel_test.go version/shellQuote unit tests
These are leaves: they depend on core (SettingService, Release) but no
core file references them, so the extraction creates no import cycle.
Core references are now qualified (service.SettingService, service.Release);
callers in main.go, web/web.go, and web/controller/* updated to panel.*.
Build, vet, and go test ./web/... pass.
* refactor(service): extract integration/ subpackage
Move the external-provider integration leaves into web/service/integration/
(package integration):
warp.go WarpService (Cloudflare WARP)
nord.go NordService (NordVPN)
custom_geo.go CustomGeoService (custom geo asset management)
*_test.go custom_geo / panel-proxy tests
These depend on core (SettingService, ServerService, XraySettingService) but
no core file references them. xray_setting.go stays in core because it calls
the unexported SettingService.saveSetting. The shared isBlockedIP SSRF helper
(used by core url_safety.go and by custom_geo) now has a small copy in each
package rather than being exported. Core references qualified; callers in
web/web.go, web/job/*, and web/controller/* updated to integration.*.
Build, vet, and go test ./web/... pass.
* refactor(service): extract tgbot/ subpackage
Move the Telegram bot (6 files + test) into web/service/tgbot/ (package
tgbot). It is a leaf: it embeds five core services (Inbound/Client/Setting/
Server/Xray) and the core never references it, so no import cycle.
To support the package boundary without changing behavior:
- core exposes XrayProcess() *xray.Process so tgbot keeps calling the
exact same running-process methods it used via the package-level `p`;
- three core methods tgbot calls are exported: ClientService.checkIs-
EnabledByEmail -> CheckIsEnabledByEmail, InboundService.getAllEmails ->
GetAllEmails (callers updated in-package);
- tgbot's embedded-field types and the few core type refs (Status,
ClientCreatePayload, SanitizePublicHTTPURL) are now service-qualified.
Callers in main.go, web/web.go, web/job/*, and web/controller/* updated to
tgbot.*. Build, vet, and go test ./web/... pass.
* refactor(service): extract outbound/ subpackage
OutboundService (outbound.go) imports only neutral packages (config,
database, model, xray) and its production code is referenced by no core or
sibling service file — only by web/controller/xray_setting.go and
web/job/xray_traffic_job.go. Move it to web/service/outbound/ (package
outbound); no core qualification needed inside. Callers updated to outbound.*.
The one coupling was a tiny pure test helper, outboundsContainTag, used by
both outbound.go and the core outbound_subscription_test.go; it now has a
small copy in that test file rather than being shared across the boundary.
Build, vet, and go test ./web/... pass.
* refactor(util): move wireguard into its own subpackage
util/wireguard.go was the lone file of the root `util` package (24 lines,
one exported func GenerateWireguardKeypair), while every other util concern
lives in a focused subpackage (util/common, util/crypto, util/netsafe, ...).
Move it to util/wireguard/ (package wireguard) for consistency; its only
importer, web/service/integration/warp.go, is updated. The root `util`
package no longer exists.
* refactor(sub): drop redundant sub prefix from filenames
Inside package sub the subXxx.go prefix just repeats the package name
(like client_*.go did inside service). Rename for consistency; content and
type names are unchanged:
subController.go -> controller.go
subService.go -> service.go
subClashService.go -> clash_service.go
subJsonService.go -> json_service.go
(+ matching _test.go files)
* refactor(controller): rename xui.go -> spa.go
XUIController serves the panel's single-page-app shell; spa.go names that
role plainly (the other controller files are domain-named). File rename only
— the type stays XUIController. api_docs_test.go keys route base paths by
filename, so its "xui.go" case is updated to "spa.go".
* refactor: move backend packages under internal/
Adopt the idiomatic Go application layout: the backend packages now live
under internal/ (a boundary the toolchain enforces), signalling private
implementation instead of a library-style flat root. No runtime behavior
changes — only import paths and a few build/config paths move.
Moved: config, database, logger, mtproto, sub, util, web, xray -> internal/.
main.go stays at the repo root and tools/openapigen stays under tools/ (both
still import internal/* because the internal rule keys off the module root).
The module path github.com/mhsanaei/3x-ui/v3 is unchanged; 149 .go files had
their import prefix rewritten to .../internal/<pkg>.
Couplings the Go compiler can't see, updated to the new layout:
- frontend i18n imports of web/translation (react.ts, setup.components.ts)
- vite outDir + eslint/tsconfig ignore globs -> internal/web/dist
- Dockerfile COPY paths for web/dist and web/translation
- locale.go os.DirFS("web") disk fallback -> "internal/web"
- .gitignore and ci.yml go:embed stub for internal/web/dist
- api_docs_test.go repo-root relative walk (one level deeper)
- tools/openapigen filesystem package paths; ApiTokenView repointed to the
web/service/panel subpackage and codegen regenerated (clears a stale
type the ci.yml codegen check was failing on)
Verified: go build/vet/test (all packages), and frontend typecheck, lint,
vitest (478 tests), and production build into internal/web/dist.
* fix(config): keep test runs from writing logs into the source tree
GetLogFolder() returns a CWD-relative "./log" on Windows. Under `go test`
the working directory is each package's own folder, so InitLogger (called by
tests in web/job, web/service, xray, web/websocket) created stray log/
directories scattered through the source tree (e.g. internal/web/job/log/).
Redirect to a shared temp folder when testing.Testing() reports a test run.
Production behavior is unchanged: Windows still uses ./log next to the binary
and Linux /var/log/x-ui. The log files were always gitignored (*.log) and
never committed; this just stops the noise at the source.
* docs: move subscription-template guide out of root into docs/
sub_templates/ was a top-level folder holding only a README and no actual
templates (3x-ui ships none by design), referenced nowhere and unlinked from
any doc — it read like an empty placeholder cluttering the repo root.
Move the guide to docs/custom-subscription-templates.md (a proper docs home),
reword its intro to read as documentation rather than a folder note, link it
from the Features list in README.md, and drop the empty sub_templates/ folder.
* fix: update stale web/ path references after the internal/ move
The internal/ migration rewrote Go import paths but left some references to
the old top-level layout in docs, comments, and a few runtime disk paths.
Functional (dev-mode only): the disk-serving fallbacks that read the Vite
build from disk when running from source still pointed at web/dist/, which
moved to internal/web/dist/ — so `os.DirFS`/`os.Stat`/`os.ReadFile` in
internal/web/web.go and internal/sub/{sub,controller}.go are corrected.
Production was unaffected (it serves the embedded FS; verified by the Docker
build), but `go run` with a live frontend build silently fell back to embed.
Docs/comments: frontend/README.md, CONTRIBUTING.md, the claude-issue-bot and
release workflows, the openapigen -root help text, and assorted Go comments
now reference internal/web, internal/database, internal/sub, internal/xray,
etc. Package-name mentions (the "web" package), root paths (main.go,
frontend/, install scripts, /etc/x-ui), routes (/panel/api/xray), and the
historical "web/assets no longer exists" note were intentionally left as-is.
* refactor(web): remove the legacy /xui -> /panel redirect middleware
RedirectMiddleware existed only for backward compatibility with the old
`/xui` URL scheme (301-redirecting /xui and /xui/API to /panel and
/panel/api). That cutover was long ago, so drop the middleware, its
registration in initRouter, and the now-inaccurate "URL redirection"
mention in the middleware package doc. Old /xui URLs now 404 like any other
unknown path. HTTPS auto-redirect and auth redirects are unrelated and stay.
* build: fix .dockerignore for internal/ layout and exclude runtime dir
- web/dist -> internal/web/dist: the embedded frontend moved under internal/,
so the stale exclude no longer matched and the locally-built dist could be
sent to the build context (the frontend stage rebuilds it fresh anyway).
- exclude x-ui/: the local runtime directory (SQLite db, geo .dat files, xray
binaries, certs — ~150MB) was being shipped into the build context for no
reason. Verified the pattern excludes only the directory and still keeps
x-ui.sh, which the Dockerfile copies to /usr/bin/x-ui.
2026-06-10 06:19:22 -07:00
|
|
|
"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/runtime"
|
|
|
|
|
"github.com/mhsanaei/3x-ui/v3/internal/xray"
|
2026-06-01 13:54:56 -07:00
|
|
|
)
|
|
|
|
|
|
|
|
|
|
func initTrafficTestDB(t *testing.T) *gorm.DB {
|
|
|
|
|
t.Helper()
|
|
|
|
|
dbDir := t.TempDir()
|
|
|
|
|
t.Setenv("XUI_DB_FOLDER", dbDir)
|
|
|
|
|
if err := database.InitDB(filepath.Join(dbDir, "x-ui.db")); err != nil {
|
|
|
|
|
t.Fatalf("InitDB: %v", err)
|
|
|
|
|
}
|
|
|
|
|
t.Cleanup(func() { _ = database.CloseDB() })
|
|
|
|
|
return database.GetDB()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func createNodeInbound(t *testing.T, db *gorm.DB, nodeID int, tag string, port int) {
|
|
|
|
|
t.Helper()
|
|
|
|
|
nid := nodeID
|
|
|
|
|
ib := &model.Inbound{UserId: 1, Tag: tag, Enable: true, Port: port, Protocol: model.VLESS, NodeID: &nid}
|
|
|
|
|
if err := db.Create(ib).Error; err != nil {
|
|
|
|
|
t.Fatalf("create node inbound %q: %v", tag, err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2026-06-11 05:28:09 -07:00
|
|
|
// createNodeInboundWithClient mirrors createNodeInbound but stores the client
|
perf(clients): write client_inbounds deltas and check identity from the clients table
Client CRUD latency scaled with the number of client-inbound edges rather
than with the size of the change. On a 5k-client / 8-inbound / ~56k-edge
PostgreSQL panel, creating one client took 60-120s (#6252).
Two independent causes, both confirmed by the reporter's pg_stat_statements
and reproduced locally at their topology.
SyncInbound deleted every client_inbounds row for an inbound and re-inserted
the whole set, so a one-client edit rewrote thousands of unrelated rows. The
dominant caller was not user CRUD: the node traffic poll re-syncs every node
inbound from its snapshot every 5s, so the panel churned the entire
membership table continuously in the background. SyncInbound now reads the
current links and writes only the difference - insert missing, update a
changed flow_override, delete departed. Callers are unchanged, so every
reconciliation path benefits, and the four hot client CRUD paths additionally
pass only the clients they touched via ApplyInboundClientDelta.
The insert needs clause.OnConflict: the unconditional delete it replaces also
serialized concurrent syncs of one inbound, and the node poll commits in its
own transaction outside the serialized writer, where a duplicate key would
abort the whole poll on PostgreSQL.
Identity and membership questions expanded every inbound's settings.clients
JSON - 5.75s per call under the reporter's load. They now read the indexed
clients and client_inbounds tables, which every read path already trusts,
over just the emails being checked. A LOWER(email) expression index keeps
the case-insensitive matching indexed; a struct tag cannot declare one.
Measured on PostgreSQL 17 at 8 inbounds x 6000 clients, rows written to
client_inbounds per operation, before -> after:
create across 8 inbounds 48008 ins / 48000 del -> 8 ins / 0 del
update the client 48008 ins / 48008 del -> 0 ins / 0 del
detach from 4 inbounds 24000 ins / 24004 del -> 0 ins / 4 del
delete the client 24000 ins / 24004 del -> 0 ins / 4 del
Two behavior changes worth naming. An email seen with two different subIds
across two inbounds' JSON used to be locked so that no add could claim it,
including the one with the correct subId; the clients row now adjudicates.
And on an install whose settings JSON holds an email with no matching link,
"is this email on another inbound" now answers no, so deleting it elsewhere
purges its traffic rows; compactOrphans and the startup heal already
converge such drift.
Every added test was verified against a hand-written mutation of this change,
so none of them pass regardless of the fix. One mutation survives on purpose:
swapping OnConflict DoUpdates for DoNothing is only observable when two
transactions race the same row, and a timing-dependent test would be flaky.
Per-node batching of remote pushes and the metadata-only inbounds list from
the same report are deliberately not in this change.
Closes #6252
2026-08-19 19:09:57 -07:00
|
|
|
// in the settings JSON, which the node sync turns into a client_inbounds link.
|
2026-06-11 05:28:09 -07:00
|
|
|
func createNodeInboundWithClient(t *testing.T, db *gorm.DB, nodeID int, tag string, port int, email string) {
|
|
|
|
|
t.Helper()
|
|
|
|
|
nid := nodeID
|
|
|
|
|
settings := fmt.Sprintf(`{"clients": [{"email": %q, "enable": true}]}`, email)
|
|
|
|
|
ib := &model.Inbound{UserId: 1, Tag: tag, Enable: true, Port: port, Protocol: model.VLESS, NodeID: &nid, Settings: settings}
|
|
|
|
|
if err := db.Create(ib).Error; err != nil {
|
|
|
|
|
t.Fatalf("create node inbound %q: %v", tag, err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2026-06-01 13:54:56 -07:00
|
|
|
func syncNode(t *testing.T, svc *InboundService, nodeID int, tag string, stats ...xray.ClientTraffic) {
|
|
|
|
|
t.Helper()
|
|
|
|
|
snap := &runtime.TrafficSnapshot{
|
|
|
|
|
Inbounds: []*model.Inbound{{Tag: tag, ClientStats: stats}},
|
|
|
|
|
}
|
2026-06-04 17:26:57 -07:00
|
|
|
if _, err := svc.setRemoteTrafficLocked(nodeID, snap, false); err != nil {
|
2026-06-01 13:54:56 -07:00
|
|
|
t.Fatalf("setRemoteTrafficLocked node %d: %v", nodeID, err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2026-06-11 05:28:09 -07:00
|
|
|
// syncNodeWithSettings mirrors syncNode but carries a real settings JSON on
|
|
|
|
|
// the snapshot inbound, like production nodes do — the sync mirrors snapshot
|
|
|
|
|
// settings onto the central row, and the shared-accumulator guard reads the
|
|
|
|
|
// clients out of those settings.
|
|
|
|
|
func syncNodeWithSettings(t *testing.T, svc *InboundService, nodeID int, tag, settings string, stats ...xray.ClientTraffic) {
|
|
|
|
|
t.Helper()
|
|
|
|
|
snap := &runtime.TrafficSnapshot{
|
|
|
|
|
Inbounds: []*model.Inbound{{Tag: tag, Settings: settings, ClientStats: stats}},
|
|
|
|
|
}
|
|
|
|
|
if _, err := svc.setRemoteTrafficLocked(nodeID, snap, false); err != nil {
|
|
|
|
|
t.Fatalf("setRemoteTrafficLocked node %d: %v", nodeID, err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2026-06-01 13:54:56 -07:00
|
|
|
func readTraffic(t *testing.T, db *gorm.DB, email string) xray.ClientTraffic {
|
|
|
|
|
t.Helper()
|
|
|
|
|
var ct xray.ClientTraffic
|
|
|
|
|
if err := db.Model(xray.ClientTraffic{}).Where("email = ?", email).First(&ct).Error; err != nil {
|
|
|
|
|
t.Fatalf("read client_traffics %q: %v", email, err)
|
|
|
|
|
}
|
|
|
|
|
return ct
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func assertUpDown(t *testing.T, ct xray.ClientTraffic, wantUp, wantDown int64, when string) {
|
|
|
|
|
t.Helper()
|
|
|
|
|
if ct.Up != wantUp || ct.Down != wantDown {
|
|
|
|
|
t.Errorf("%s: up=%d down=%d, want %d/%d", when, ct.Up, ct.Down, wantUp, wantDown)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestTwoNodesShareEmail_SumsCorrectly(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
createNodeInbound(t, db, 1, "n1-in", 41001)
|
|
|
|
|
createNodeInbound(t, db, 2, "n2-in", 41002)
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "shared"
|
|
|
|
|
|
2026-06-19 15:36:35 -07:00
|
|
|
// First-ever sync from each node: the row is created at 0 and the current
|
|
|
|
|
// node counters become the baseline. Only deltas beyond those baselines count.
|
2026-06-01 13:54:56 -07:00
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 100, Down: 100, Enable: true})
|
|
|
|
|
syncNode(t, svc, 2, "n2-in", xray.ClientTraffic{Email: email, Up: 200, Down: 200, Enable: true})
|
|
|
|
|
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 0, 0, "after baselines — historical node traffic not imported")
|
2026-06-01 13:54:56 -07:00
|
|
|
|
|
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 150, Down: 150, Enable: true})
|
|
|
|
|
syncNode(t, svc, 2, "n2-in", xray.ClientTraffic{Email: email, Up: 260, Down: 260, Enable: true})
|
|
|
|
|
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 110, 110, "after both nodes grow — deltas (50+60) accrue")
|
2026-06-01 13:54:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestSingleNode_MirrorsCorrectly(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
createNodeInbound(t, db, 1, "n1-in", 41001)
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "solo"
|
2026-06-19 15:36:35 -07:00
|
|
|
// First sync: row seeded at 0, current counter becomes the baseline.
|
2026-06-01 13:54:56 -07:00
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 500, Down: 600, Enable: true})
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 0, 0, "first sync — historical traffic not imported")
|
2026-06-01 13:54:56 -07:00
|
|
|
|
2026-06-19 15:36:35 -07:00
|
|
|
// Second sync: delta (700-500=200 / 800-600=200) accrues normally.
|
2026-06-01 13:54:56 -07:00
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 700, Down: 800, Enable: true})
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 200, 200, "second sync — delta accrues")
|
2026-06-01 13:54:56 -07:00
|
|
|
}
|
|
|
|
|
|
2026-06-25 12:19:27 -07:00
|
|
|
func TestNodeAdd_ImportsClientHistoryWithNewInbound(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "newnode-client"
|
|
|
|
|
const histUp, histDown int64 = 6_000_000_000, 200_000_000_000
|
|
|
|
|
|
|
|
|
|
syncNode(t, svc, 1, "fresh-in", xray.ClientTraffic{Email: email, Up: histUp, Down: histDown, Enable: true})
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), histUp, histDown, "node-add: client history imported with its brand-new inbound")
|
|
|
|
|
|
|
|
|
|
syncNode(t, svc, 1, "fresh-in", xray.ClientTraffic{Email: email, Up: histUp + 1024, Down: histDown + 2048, Enable: true})
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), histUp+1024, histDown+2048, "post-import delta accrues, no double count")
|
|
|
|
|
}
|
|
|
|
|
|
2026-07-02 04:37:06 -07:00
|
|
|
// TestStaleSnapshot_DeletedClientNotResurrected reproduces #5739: a snapshot
|
|
|
|
|
// fetched just before a client's deletion still names the email. Applying it
|
|
|
|
|
// must neither recreate the client_traffics row (at zero) nor re-add the
|
|
|
|
|
// client to the central inbound's settings while the delete tombstone lives.
|
|
|
|
|
func TestStaleSnapshot_DeletedClientNotResurrected(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
createNodeInboundWithClient(t, db, 1, "n1-in", 41001, "victim-5739")
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "victim-5739"
|
|
|
|
|
withClient := fmt.Sprintf(`{"clients": [{"email": %q, "enable": true}]}`, email)
|
|
|
|
|
syncNodeWithSettings(t, svc, 1, "n1-in", withClient, xray.ClientTraffic{Email: email, Up: 100, Down: 100, Enable: true})
|
|
|
|
|
|
|
|
|
|
if err := db.Model(&model.Inbound{}).Where("tag = ?", "n1-in").
|
|
|
|
|
Update("settings", `{"clients": []}`).Error; err != nil {
|
|
|
|
|
t.Fatalf("clear central settings: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if err := db.Where("email = ?", email).Delete(&xray.ClientTraffic{}).Error; err != nil {
|
|
|
|
|
t.Fatalf("delete stats row: %v", err)
|
|
|
|
|
}
|
|
|
|
|
tombstoneClientEmail(email)
|
|
|
|
|
|
|
|
|
|
syncNodeWithSettings(t, svc, 1, "n1-in", withClient, xray.ClientTraffic{Email: email, Up: 120, Down: 120, Enable: true})
|
|
|
|
|
|
|
|
|
|
var rows int64
|
|
|
|
|
if err := db.Model(xray.ClientTraffic{}).Where("email = ?", email).Count(&rows).Error; err != nil {
|
|
|
|
|
t.Fatalf("count stats rows: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if rows != 0 {
|
|
|
|
|
t.Errorf("deleted client's stats row resurrected by stale snapshot (%d rows)", rows)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var ib model.Inbound
|
|
|
|
|
if err := db.Where("tag = ?", "n1-in").First(&ib).Error; err != nil {
|
|
|
|
|
t.Fatalf("load inbound: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if strings.Contains(ib.Settings, email) {
|
|
|
|
|
t.Errorf("deleted client re-added to central settings: %s", ib.Settings)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2026-06-25 12:19:27 -07:00
|
|
|
func TestNodeAdd_TombstonedClientNotResurrected(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "deleted-ghost"
|
|
|
|
|
const stale int64 = 50_000_000_000
|
|
|
|
|
|
|
|
|
|
tombstoneClientEmail(email)
|
|
|
|
|
syncNode(t, svc, 1, "fresh-in", xray.ClientTraffic{Email: email, Up: stale, Down: stale, Enable: true})
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), 0, 0, "tombstoned client must not resurrect via node-add seed")
|
|
|
|
|
}
|
|
|
|
|
|
2026-06-01 13:54:56 -07:00
|
|
|
func TestUpgrade_PreExistingRow_NoDoubleCount(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
createNodeInbound(t, db, 1, "n1-in", 41001)
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "legacy"
|
|
|
|
|
var ib model.Inbound
|
|
|
|
|
if err := db.Where("tag = ?", "n1-in").First(&ib).Error; err != nil {
|
|
|
|
|
t.Fatalf("load inbound: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if err := db.Create(&xray.ClientTraffic{InboundId: ib.Id, Email: email, Up: 1000, Down: 2000, Enable: true}).Error; err != nil {
|
|
|
|
|
t.Fatalf("seed pre-existing row: %v", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 1000, Down: 2000, Enable: true})
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), 1000, 2000, "first snapshot must not double-count")
|
|
|
|
|
|
|
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 1100, Down: 2100, Enable: true})
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), 1100, 2100, "growth after upgrade accrues")
|
|
|
|
|
}
|
|
|
|
|
|
2026-06-19 15:36:35 -07:00
|
|
|
// TestGhostData_NoPhantomTraffic reproduces the 50 GB phantom traffic bug:
|
|
|
|
|
// a node retains stale data for a deleted client (e.g. de-1 was offline during
|
|
|
|
|
// deletion). When the master first syncs this email again it must NOT import the
|
|
|
|
|
// stale counter — it sets Up=0 and records the current node value as the
|
|
|
|
|
// baseline so only future deltas count.
|
|
|
|
|
func TestGhostData_NoPhantomTraffic(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
createNodeInbound(t, db, 1, "de1-in", 41001)
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "pouya"
|
|
|
|
|
const staleBytes int64 = 50 * 1024 * 1024 * 1024 // 50 GB stale on de-1
|
|
|
|
|
|
|
|
|
|
// Node reports a client with a large pre-existing counter (ghost data from a
|
|
|
|
|
// deleted account that survived on the node). Master has no row for this email.
|
|
|
|
|
syncNode(t, svc, 1, "de1-in", xray.ClientTraffic{Email: email, Up: staleBytes, Down: staleBytes, Enable: true})
|
|
|
|
|
|
|
|
|
|
ct := readTraffic(t, db, email)
|
|
|
|
|
if ct.Up >= staleBytes || ct.Down >= staleBytes {
|
|
|
|
|
t.Errorf("ghost data imported: up=%d down=%d; stale node counter must not count as new traffic", ct.Up, ct.Down)
|
|
|
|
|
}
|
|
|
|
|
assertUpDown(t, ct, 0, 0, "first sync of ghost email — imported as 0, not 50 GB")
|
|
|
|
|
|
|
|
|
|
// Subsequent syncs only add incremental usage beyond the baseline.
|
|
|
|
|
syncNode(t, svc, 1, "de1-in", xray.ClientTraffic{Email: email, Up: staleBytes + 1024, Down: staleBytes + 2048, Enable: true})
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), 1024, 2048, "only incremental traffic beyond baseline counts")
|
|
|
|
|
}
|
|
|
|
|
|
fix: resolve a batch of open bug-tagged issues (traffic accounting, share strategy, sub address, CPU) (#5477)
* fix(node): never re-add a node's full counter on reset/restart (#5456, #5476, #5390)
When a node's per-client counter dips below the master's stored baseline
(node reboot, xray restart, or a reset propagated to the node), the delta
accounting clamped delta to the node's whole current counter and re-added it
to the master total — double-counting a client's lifetime usage in a single
sync and often pushing them over quota. Treat a backward-moving counter as a
reset: add 0 and rebaseline to the reported value, so only genuine post-reset
usage accrues.
Resets also now clear the per-node NodeClientTraffic baseline (ResetClient
TrafficByEmail, resetClientTrafficLocked, BulkResetTraffic, resetAllClient
TrafficsLocked), mirroring the delete paths. Without this the node's pre-reset
cumulative — including traffic it had counted but not yet synced — leaks back
onto the master after a reset, which is the 'reset reverts after a while'
report. The next sync then takes the clean delta=0 + rebaseline path regardless
of node state.
Updates TestNodeCounterReset (was _Clamped, now _NoReAdd) to assert rebaseline
instead of re-add, and adds TestCentralResetClearsNodeBaseline_NoLeak.
* fix(inbound): keep persisted node share strategy on edit (#5375)
Opening the edit modal silently reverted shareAddrStrategy from 'node' to
'listen'. The downgrade effect fires before the form settles: availableNodes
is an empty placeholder until /nodes/list resolves, and Form.useWatch('protocol')
is briefly empty on the first edit render — both transiently make the node
option look unavailable, so the effect clobbered the saved value.
Gate the downgrade on availableNodesFetched (threaded from useNodesQuery through
InboundsPage) and on the protocol watch being settled, so a persisted strategy
is only downgraded when the node option is genuinely unavailable. Adds a
rerender-based regression test covering the nodes-loading race.
* <3
* perf(traffic): skip cross-panel quota subquery when no globals exist (#5392, #5389)
disableInvalidClients ran a correlated EXISTS against client_global_traffics
on the full client_traffics table every 5s. On a panel no master pushes to,
that table is empty so the subquery can never match — yet it forced a full
scan that pegged Postgres at 100% CPU on large client counts. Probe the table
first and drop the EXISTS branch when it's empty (the common case), and add an
idx_client_global_email index so the subquery is an index lookup when globals
are present. Cross-panel enforcement is unchanged (TestGlobalUsage_DisablesClient).
This also relieves #5389 ('traffic writer queue full' / panel freeze): the
heavy query runs inside the serialized traffic write, so a slow DB backs the
shared writer queue up until request handlers block.
* fix(sub): don't advertise a leaked client IP for local wildcard inbounds (#5425)
For a local inbound with no node, no custom share address, and a wildcard/blank
listen, resolveInboundAddress fell straight through to the subscriber's request
host. Behind NAT/proxy/CDN that Host can be the requesting client's own IP, so
the subscription wrote the client's address into the inbound instead of the
server's — while the panel's own share link (which doesn't use the request host)
stayed correct.
Prefer the admin's configured public host (Sub/Web domain) over the raw request
host for this last-resort fallback. With no configured host the request host
still stands, so existing single-domain setups are unaffected.
2026-06-21 15:22:28 -07:00
|
|
|
func TestNodeCounterReset_NoReAdd(t *testing.T) {
|
2026-06-01 13:54:56 -07:00
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
createNodeInbound(t, db, 1, "n1-in", 41001)
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "restart"
|
2026-06-19 15:36:35 -07:00
|
|
|
// First sync seeds at 0 (baseline=900). Second sync adds delta 950-900=50.
|
2026-06-01 13:54:56 -07:00
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 900, Down: 900, Enable: true})
|
|
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 950, Down: 950, Enable: true})
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 50, 50, "before node reset")
|
2026-06-01 13:54:56 -07:00
|
|
|
|
fix: resolve a batch of open bug-tagged issues (traffic accounting, share strategy, sub address, CPU) (#5477)
* fix(node): never re-add a node's full counter on reset/restart (#5456, #5476, #5390)
When a node's per-client counter dips below the master's stored baseline
(node reboot, xray restart, or a reset propagated to the node), the delta
accounting clamped delta to the node's whole current counter and re-added it
to the master total — double-counting a client's lifetime usage in a single
sync and often pushing them over quota. Treat a backward-moving counter as a
reset: add 0 and rebaseline to the reported value, so only genuine post-reset
usage accrues.
Resets also now clear the per-node NodeClientTraffic baseline (ResetClient
TrafficByEmail, resetClientTrafficLocked, BulkResetTraffic, resetAllClient
TrafficsLocked), mirroring the delete paths. Without this the node's pre-reset
cumulative — including traffic it had counted but not yet synced — leaks back
onto the master after a reset, which is the 'reset reverts after a while'
report. The next sync then takes the clean delta=0 + rebaseline path regardless
of node state.
Updates TestNodeCounterReset (was _Clamped, now _NoReAdd) to assert rebaseline
instead of re-add, and adds TestCentralResetClearsNodeBaseline_NoLeak.
* fix(inbound): keep persisted node share strategy on edit (#5375)
Opening the edit modal silently reverted shareAddrStrategy from 'node' to
'listen'. The downgrade effect fires before the form settles: availableNodes
is an empty placeholder until /nodes/list resolves, and Form.useWatch('protocol')
is briefly empty on the first edit render — both transiently make the node
option look unavailable, so the effect clobbered the saved value.
Gate the downgrade on availableNodesFetched (threaded from useNodesQuery through
InboundsPage) and on the protocol watch being settled, so a persisted strategy
is only downgraded when the node option is genuinely unavailable. Adds a
rerender-based regression test covering the nodes-loading race.
* <3
* perf(traffic): skip cross-panel quota subquery when no globals exist (#5392, #5389)
disableInvalidClients ran a correlated EXISTS against client_global_traffics
on the full client_traffics table every 5s. On a panel no master pushes to,
that table is empty so the subquery can never match — yet it forced a full
scan that pegged Postgres at 100% CPU on large client counts. Probe the table
first and drop the EXISTS branch when it's empty (the common case), and add an
idx_client_global_email index so the subquery is an index lookup when globals
are present. Cross-panel enforcement is unchanged (TestGlobalUsage_DisablesClient).
This also relieves #5389 ('traffic writer queue full' / panel freeze): the
heavy query runs inside the serialized traffic write, so a slow DB backs the
shared writer queue up until request handlers block.
* fix(sub): don't advertise a leaked client IP for local wildcard inbounds (#5425)
For a local inbound with no node, no custom share address, and a wildcard/blank
listen, resolveInboundAddress fell straight through to the subscriber's request
host. Behind NAT/proxy/CDN that Host can be the requesting client's own IP, so
the subscription wrote the client's address into the inbound instead of the
server's — while the panel's own share link (which doesn't use the request host)
stayed correct.
Prefer the admin's configured public host (Sub/Web domain) over the raw request
host for this last-resort fallback. With no configured host the request host
still stands, so existing single-domain setups are unaffected.
2026-06-21 15:22:28 -07:00
|
|
|
// Node reboot drops the counter to 50. delta=50-950=-900 is a counter reset,
|
|
|
|
|
// not new traffic: add 0 and rebaseline to 50, never re-add the node's full
|
|
|
|
|
// cumulative counter onto the master total (#5456).
|
2026-06-01 13:54:56 -07:00
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 50, Down: 50, Enable: true})
|
|
|
|
|
ct := readTraffic(t, db, email)
|
|
|
|
|
if ct.Up < 0 || ct.Down < 0 {
|
|
|
|
|
t.Fatalf("row went negative after node reset: up=%d down=%d", ct.Up, ct.Down)
|
|
|
|
|
}
|
fix: resolve a batch of open bug-tagged issues (traffic accounting, share strategy, sub address, CPU) (#5477)
* fix(node): never re-add a node's full counter on reset/restart (#5456, #5476, #5390)
When a node's per-client counter dips below the master's stored baseline
(node reboot, xray restart, or a reset propagated to the node), the delta
accounting clamped delta to the node's whole current counter and re-added it
to the master total — double-counting a client's lifetime usage in a single
sync and often pushing them over quota. Treat a backward-moving counter as a
reset: add 0 and rebaseline to the reported value, so only genuine post-reset
usage accrues.
Resets also now clear the per-node NodeClientTraffic baseline (ResetClient
TrafficByEmail, resetClientTrafficLocked, BulkResetTraffic, resetAllClient
TrafficsLocked), mirroring the delete paths. Without this the node's pre-reset
cumulative — including traffic it had counted but not yet synced — leaks back
onto the master after a reset, which is the 'reset reverts after a while'
report. The next sync then takes the clean delta=0 + rebaseline path regardless
of node state.
Updates TestNodeCounterReset (was _Clamped, now _NoReAdd) to assert rebaseline
instead of re-add, and adds TestCentralResetClearsNodeBaseline_NoLeak.
* fix(inbound): keep persisted node share strategy on edit (#5375)
Opening the edit modal silently reverted shareAddrStrategy from 'node' to
'listen'. The downgrade effect fires before the form settles: availableNodes
is an empty placeholder until /nodes/list resolves, and Form.useWatch('protocol')
is briefly empty on the first edit render — both transiently make the node
option look unavailable, so the effect clobbered the saved value.
Gate the downgrade on availableNodesFetched (threaded from useNodesQuery through
InboundsPage) and on the protocol watch being settled, so a persisted strategy
is only downgraded when the node option is genuinely unavailable. Adds a
rerender-based regression test covering the nodes-loading race.
* <3
* perf(traffic): skip cross-panel quota subquery when no globals exist (#5392, #5389)
disableInvalidClients ran a correlated EXISTS against client_global_traffics
on the full client_traffics table every 5s. On a panel no master pushes to,
that table is empty so the subquery can never match — yet it forced a full
scan that pegged Postgres at 100% CPU on large client counts. Probe the table
first and drop the EXISTS branch when it's empty (the common case), and add an
idx_client_global_email index so the subquery is an index lookup when globals
are present. Cross-panel enforcement is unchanged (TestGlobalUsage_DisablesClient).
This also relieves #5389 ('traffic writer queue full' / panel freeze): the
heavy query runs inside the serialized traffic write, so a slow DB backs the
shared writer queue up until request handlers block.
* fix(sub): don't advertise a leaked client IP for local wildcard inbounds (#5425)
For a local inbound with no node, no custom share address, and a wildcard/blank
listen, resolveInboundAddress fell straight through to the subscriber's request
host. Behind NAT/proxy/CDN that Host can be the requesting client's own IP, so
the subscription wrote the client's address into the inbound instead of the
server's — while the panel's own share link (which doesn't use the request host)
stayed correct.
Prefer the admin's configured public host (Sub/Web domain) over the raw request
host for this last-resort fallback. With no configured host the request host
still stands, so existing single-domain setups are unaffected.
2026-06-21 15:22:28 -07:00
|
|
|
assertUpDown(t, ct, 50, 50, "after node counter reset: rebaselined, not re-added")
|
|
|
|
|
|
|
|
|
|
// Post-reset accrual resumes from the new baseline: 80-50=30.
|
|
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 80, Down: 80, Enable: true})
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), 80, 80, "post-reset delta accrues from rebaselined counter")
|
2026-06-01 13:54:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestCentralReset_NoReAdd(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
createNodeInbound(t, db, 1, "n1-in", 41001)
|
|
|
|
|
createNodeInbound(t, db, 2, "n2-in", 41002)
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "reset"
|
|
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 100, Down: 100, Enable: true})
|
|
|
|
|
syncNode(t, svc, 2, "n2-in", xray.ClientTraffic{Email: email, Up: 100, Down: 100, Enable: true})
|
|
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 200, Down: 200, Enable: true})
|
|
|
|
|
syncNode(t, svc, 2, "n2-in", xray.ClientTraffic{Email: email, Up: 200, Down: 200, Enable: true})
|
|
|
|
|
|
|
|
|
|
if err := db.Model(xray.ClientTraffic{}).Where("email = ?", email).
|
|
|
|
|
Updates(map[string]any{"up": 0, "down": 0}).Error; err != nil {
|
|
|
|
|
t.Fatalf("simulate central reset: %v", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 210, Down: 210, Enable: true})
|
|
|
|
|
syncNode(t, svc, 2, "n2-in", xray.ClientTraffic{Email: email, Up: 205, Down: 205, Enable: true})
|
|
|
|
|
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), 15, 15, "after central reset only increments accrue")
|
|
|
|
|
}
|
|
|
|
|
|
fix: resolve a batch of open bug-tagged issues (traffic accounting, share strategy, sub address, CPU) (#5477)
* fix(node): never re-add a node's full counter on reset/restart (#5456, #5476, #5390)
When a node's per-client counter dips below the master's stored baseline
(node reboot, xray restart, or a reset propagated to the node), the delta
accounting clamped delta to the node's whole current counter and re-added it
to the master total — double-counting a client's lifetime usage in a single
sync and often pushing them over quota. Treat a backward-moving counter as a
reset: add 0 and rebaseline to the reported value, so only genuine post-reset
usage accrues.
Resets also now clear the per-node NodeClientTraffic baseline (ResetClient
TrafficByEmail, resetClientTrafficLocked, BulkResetTraffic, resetAllClient
TrafficsLocked), mirroring the delete paths. Without this the node's pre-reset
cumulative — including traffic it had counted but not yet synced — leaks back
onto the master after a reset, which is the 'reset reverts after a while'
report. The next sync then takes the clean delta=0 + rebaseline path regardless
of node state.
Updates TestNodeCounterReset (was _Clamped, now _NoReAdd) to assert rebaseline
instead of re-add, and adds TestCentralResetClearsNodeBaseline_NoLeak.
* fix(inbound): keep persisted node share strategy on edit (#5375)
Opening the edit modal silently reverted shareAddrStrategy from 'node' to
'listen'. The downgrade effect fires before the form settles: availableNodes
is an empty placeholder until /nodes/list resolves, and Form.useWatch('protocol')
is briefly empty on the first edit render — both transiently make the node
option look unavailable, so the effect clobbered the saved value.
Gate the downgrade on availableNodesFetched (threaded from useNodesQuery through
InboundsPage) and on the protocol watch being settled, so a persisted strategy
is only downgraded when the node option is genuinely unavailable. Adds a
rerender-based regression test covering the nodes-loading race.
* <3
* perf(traffic): skip cross-panel quota subquery when no globals exist (#5392, #5389)
disableInvalidClients ran a correlated EXISTS against client_global_traffics
on the full client_traffics table every 5s. On a panel no master pushes to,
that table is empty so the subquery can never match — yet it forced a full
scan that pegged Postgres at 100% CPU on large client counts. Probe the table
first and drop the EXISTS branch when it's empty (the common case), and add an
idx_client_global_email index so the subquery is an index lookup when globals
are present. Cross-panel enforcement is unchanged (TestGlobalUsage_DisablesClient).
This also relieves #5389 ('traffic writer queue full' / panel freeze): the
heavy query runs inside the serialized traffic write, so a slow DB backs the
shared writer queue up until request handlers block.
* fix(sub): don't advertise a leaked client IP for local wildcard inbounds (#5425)
For a local inbound with no node, no custom share address, and a wildcard/blank
listen, resolveInboundAddress fell straight through to the subscriber's request
host. Behind NAT/proxy/CDN that Host can be the requesting client's own IP, so
the subscription wrote the client's address into the inbound instead of the
server's — while the panel's own share link (which doesn't use the request host)
stayed correct.
Prefer the admin's configured public host (Sub/Web domain) over the raw request
host for this last-resort fallback. With no configured host the request host
still stands, so existing single-domain setups are unaffected.
2026-06-21 15:22:28 -07:00
|
|
|
// A real reset (ResetClientTrafficByEmail) must clear the per-node baseline so
|
|
|
|
|
// the node's pre-reset cumulative — including traffic it counted but had not yet
|
|
|
|
|
// synced — cannot leak back onto the master after the reset (#5476, #5390).
|
|
|
|
|
func TestCentralResetClearsNodeBaseline_NoLeak(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
createNodeInbound(t, db, 1, "n1-in", 41001)
|
|
|
|
|
StartTrafficWriter()
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "reset-revert"
|
|
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 100, Down: 100, Enable: true})
|
|
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 300, Down: 300, Enable: true})
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), 200, 200, "before reset")
|
|
|
|
|
|
|
|
|
|
if err := svc.ResetClientTrafficByEmail(email); err != nil {
|
|
|
|
|
t.Fatalf("ResetClientTrafficByEmail: %v", err)
|
|
|
|
|
}
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), 0, 0, "right after reset")
|
|
|
|
|
|
|
|
|
|
var baselines int64
|
|
|
|
|
if err := db.Model(&model.NodeClientTraffic{}).Where("email = ?", email).Count(&baselines).Error; err != nil {
|
|
|
|
|
t.Fatalf("count baselines: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if baselines != 0 {
|
|
|
|
|
t.Fatalf("reset must clear node baseline rows, found %d", baselines)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Node still reports its pre-reset cumulative (340 > last synced 300: usage it
|
|
|
|
|
// had not synced before the reset). It must not revert the reset.
|
|
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 340, Down: 340, Enable: true})
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), 0, 0, "stale node counter must not revert reset")
|
|
|
|
|
|
|
|
|
|
// Genuine post-reset usage accrues from the rebaselined counter: 370-340=30.
|
|
|
|
|
syncNode(t, svc, 1, "n1-in", xray.ClientTraffic{Email: email, Up: 370, Down: 370, Enable: true})
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), 30, 30, "post-reset usage accrues")
|
|
|
|
|
}
|
|
|
|
|
|
2026-06-11 05:28:09 -07:00
|
|
|
func TestInboundRemoval_KeepsSharedEmailRow(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
createNodeInboundWithClient(t, db, 1, "n1-in", 41001, "shared")
|
|
|
|
|
createNodeInboundWithClient(t, db, 2, "n2-in", 41002, "shared")
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "shared"
|
|
|
|
|
settings := fmt.Sprintf(`{"clients": [{"email": %q, "enable": true}]}`, email)
|
2026-06-19 15:36:35 -07:00
|
|
|
// Baselines set: node1=100, node2=200. Row seeded at 0.
|
2026-06-11 05:28:09 -07:00
|
|
|
syncNodeWithSettings(t, svc, 1, "n1-in", settings, xray.ClientTraffic{Email: email, Up: 100, Down: 100, Enable: true})
|
|
|
|
|
syncNodeWithSettings(t, svc, 2, "n2-in", settings, xray.ClientTraffic{Email: email, Up: 200, Down: 200, Enable: true})
|
2026-06-19 15:36:35 -07:00
|
|
|
// node1 delta=50, node2 delta=60 → total=110.
|
2026-06-11 05:28:09 -07:00
|
|
|
syncNodeWithSettings(t, svc, 1, "n1-in", settings, xray.ClientTraffic{Email: email, Up: 150, Down: 150, Enable: true})
|
|
|
|
|
syncNodeWithSettings(t, svc, 2, "n2-in", settings, xray.ClientTraffic{Email: email, Up: 260, Down: 260, Enable: true})
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 110, 110, "baseline sum")
|
2026-06-11 05:28:09 -07:00
|
|
|
|
|
|
|
|
// Node 1 rebuilt (reinstall / another master's reconcile): its inbound
|
|
|
|
|
// vanishes from the snapshot. The shared accumulator must survive — losing
|
|
|
|
|
// it would let the next node sync re-seed the row with that node's counter
|
|
|
|
|
// alone, showing only the last panel's number instead of the sum.
|
|
|
|
|
if _, err := svc.setRemoteTrafficLocked(1, &runtime.TrafficSnapshot{}, false); err != nil {
|
|
|
|
|
t.Fatalf("sync node 1 with empty snapshot: %v", err)
|
|
|
|
|
}
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 110, 110, "after node 1 inbound removal")
|
2026-06-11 05:28:09 -07:00
|
|
|
|
2026-06-19 15:36:35 -07:00
|
|
|
// Node 2 keeps accruing onto the surviving row. node2 delta=300-260=40 → 150.
|
2026-06-11 05:28:09 -07:00
|
|
|
syncNodeWithSettings(t, svc, 2, "n2-in", settings, xray.ClientTraffic{Email: email, Up: 300, Down: 300, Enable: true})
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 150, 150, "after node 2 grows")
|
2026-06-11 05:28:09 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestClientGoneFromOneNode_KeepsSharedEmailRow(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
createNodeInboundWithClient(t, db, 1, "n1-in", 41001, "shared")
|
|
|
|
|
createNodeInboundWithClient(t, db, 2, "n2-in", 41002, "shared")
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "shared"
|
|
|
|
|
settings := fmt.Sprintf(`{"clients": [{"email": %q, "enable": true}]}`, email)
|
2026-06-19 15:36:35 -07:00
|
|
|
// First syncs set baselines (node1=100, node2=200). Row seeded at 0.
|
2026-06-11 05:28:09 -07:00
|
|
|
syncNodeWithSettings(t, svc, 1, "n1-in", settings, xray.ClientTraffic{Email: email, Up: 100, Down: 100, Enable: true})
|
|
|
|
|
syncNodeWithSettings(t, svc, 2, "n2-in", settings, xray.ClientTraffic{Email: email, Up: 200, Down: 200, Enable: true})
|
|
|
|
|
|
|
|
|
|
// Client detached from node 1's inbound only: its stats vanish from that
|
|
|
|
|
// inbound's snapshot while node 2 still hosts the email.
|
|
|
|
|
syncNodeWithSettings(t, svc, 1, "n1-in", `{"clients": []}`)
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 0, 0, "after client left node 1 — row unchanged at 0")
|
2026-06-11 05:28:09 -07:00
|
|
|
|
2026-06-19 15:36:35 -07:00
|
|
|
// Node 2 delta: 240-200=40 → accrues to 40.
|
2026-06-11 05:28:09 -07:00
|
|
|
syncNodeWithSettings(t, svc, 2, "n2-in", settings, xray.ClientTraffic{Email: email, Up: 240, Down: 240, Enable: true})
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 40, 40, "node 2 keeps accruing")
|
2026-06-11 05:28:09 -07:00
|
|
|
}
|
|
|
|
|
|
2026-06-11 12:20:38 -07:00
|
|
|
// TestStatsUnderSiblingInbound_KeepsNodeBaseline reproduces the recurring
|
|
|
|
|
// sweep bug behind #5202: the client is attached to two inbounds of the SAME
|
|
|
|
|
// node, the node reports its stats under n1-a only, but the master-side row
|
|
|
|
|
// is owned by n1-b's mirror. The per-email sweep for n1-b must not drop the
|
|
|
|
|
// (node, email) baseline that n1-a's delta computation needs — doing so every
|
|
|
|
|
// cycle froze the client's counter permanently.
|
|
|
|
|
func TestStatsUnderSiblingInbound_KeepsNodeBaseline(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
createNodeInboundWithClient(t, db, 1, "n1-a", 41001, "fresh")
|
|
|
|
|
createNodeInbound(t, db, 1, "n1-b", 41002)
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "fresh"
|
|
|
|
|
var ibB model.Inbound
|
|
|
|
|
if err := db.Where("tag = ?", "n1-b").First(&ibB).Error; err != nil {
|
|
|
|
|
t.Fatalf("load n1-b: %v", err)
|
|
|
|
|
}
|
|
|
|
|
// Master-side row created when the client was added on the panel, owned by
|
|
|
|
|
// n1-b's mirror (e.g. the client form targeted that inbound).
|
|
|
|
|
if err := db.Create(&xray.ClientTraffic{InboundId: ibB.Id, Email: email, Enable: true}).Error; err != nil {
|
|
|
|
|
t.Fatalf("seed master row: %v", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
settings := fmt.Sprintf(`{"clients": [{"email": %q, "enable": true}]}`, email)
|
|
|
|
|
sync := func(up, down int64) {
|
|
|
|
|
t.Helper()
|
|
|
|
|
snap := &runtime.TrafficSnapshot{Inbounds: []*model.Inbound{
|
|
|
|
|
{Tag: "n1-a", Settings: settings, ClientStats: []xray.ClientTraffic{{Email: email, Up: up, Down: down, Enable: true}}},
|
|
|
|
|
{Tag: "n1-b", Settings: `{"clients": []}`},
|
|
|
|
|
}}
|
|
|
|
|
if _, err := svc.setRemoteTrafficLocked(1, snap, false); err != nil {
|
|
|
|
|
t.Fatalf("sync: %v", err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sync(630, 630)
|
|
|
|
|
var baselines int64
|
|
|
|
|
if err := db.Model(&model.NodeClientTraffic{}).Where("node_id = ? AND email = ?", 1, email).Count(&baselines).Error; err != nil {
|
|
|
|
|
t.Fatalf("count baselines: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if baselines != 1 {
|
|
|
|
|
t.Fatalf("baseline must survive the sibling-inbound sweep, found %d rows", baselines)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sync(700, 700)
|
|
|
|
|
assertUpDown(t, readTraffic(t, db, email), 70, 70, "delta accrues once baseline survives")
|
|
|
|
|
}
|
|
|
|
|
|
2026-06-15 10:31:57 -07:00
|
|
|
// TestMultiAttach_SameNode_DivergentSiblings reproduces #5274: a client is
|
|
|
|
|
// attached to several inbounds of the SAME node. Xray reports client traffic
|
|
|
|
|
// globally per email, so the node's enriched inbound list copies one shared
|
|
|
|
|
// counter onto every inbound the client is on. When those copies diverge — a
|
|
|
|
|
// legacy per-inbound row surviving the v3.2.x→v3.3.x upgrade, or any drift —
|
|
|
|
|
// the per-inbound delta loop used to treat the lower sibling as a node-counter
|
|
|
|
|
// reset and re-add its full value, inflating the client far past real usage.
|
|
|
|
|
// The merge must collapse the email to its node-wide total and count it once.
|
|
|
|
|
func TestMultiAttach_SameNode_DivergentSiblings(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
createNodeInboundWithClient(t, db, 1, "n1-a", 41001, "multi")
|
|
|
|
|
createNodeInboundWithClient(t, db, 1, "n1-b", 41002, "multi")
|
|
|
|
|
createNodeInboundWithClient(t, db, 1, "n1-c", 41003, "multi")
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "multi"
|
|
|
|
|
settings := fmt.Sprintf(`{"clients": [{"email": %q, "enable": true}]}`, email)
|
|
|
|
|
|
|
|
|
|
// The three inbounds report the same email with diverging values; the
|
|
|
|
|
// node's true per-email total is the largest (the shared global counter).
|
|
|
|
|
sync := func(a, b, c int64) {
|
|
|
|
|
t.Helper()
|
|
|
|
|
snap := &runtime.TrafficSnapshot{Inbounds: []*model.Inbound{
|
|
|
|
|
{Tag: "n1-a", Settings: settings, ClientStats: []xray.ClientTraffic{{Email: email, Up: a, Down: a, Enable: true}}},
|
|
|
|
|
{Tag: "n1-b", Settings: settings, ClientStats: []xray.ClientTraffic{{Email: email, Up: b, Down: b, Enable: true}}},
|
|
|
|
|
{Tag: "n1-c", Settings: settings, ClientStats: []xray.ClientTraffic{{Email: email, Up: c, Down: c, Enable: true}}},
|
|
|
|
|
}}
|
|
|
|
|
if _, err := svc.setRemoteTrafficLocked(1, snap, false); err != nil {
|
|
|
|
|
t.Fatalf("sync: %v", err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2026-06-19 15:36:35 -07:00
|
|
|
// First-ever sync: row seeded at 0, canon (max of siblings = 100) becomes the
|
|
|
|
|
// baseline. The node total is NOT imported as historical traffic — this prevents
|
|
|
|
|
// ghost data from a previously-deleted account being counted as real usage.
|
2026-06-15 10:31:57 -07:00
|
|
|
sync(100, 50, 80)
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 0, 0, "first sync seeds at 0 — not the sum (230) nor the max (100)")
|
2026-06-15 10:31:57 -07:00
|
|
|
|
2026-06-19 15:36:35 -07:00
|
|
|
// Second sync: canon grew from 100→150, delta=50 accrues. Siblings 60 and 90
|
|
|
|
|
// do not re-add their full values — the canon clamp prevents inflation.
|
2026-06-15 10:31:57 -07:00
|
|
|
sync(150, 60, 90)
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 50, 50, "second sync: only the 50-unit increment counts, not every sibling")
|
2026-06-15 10:31:57 -07:00
|
|
|
|
2026-06-19 15:36:35 -07:00
|
|
|
// Equal siblings (the healthy current-schema case): canon grew from 150→200,
|
|
|
|
|
// delta=50 accrues once.
|
2026-06-15 10:31:57 -07:00
|
|
|
sync(200, 200, 200)
|
2026-06-19 15:36:35 -07:00
|
|
|
assertUpDown(t, readTraffic(t, db, email), 100, 100, "equal siblings accrue the single increment")
|
2026-06-15 10:31:57 -07:00
|
|
|
}
|
|
|
|
|
|
2026-06-01 13:54:56 -07:00
|
|
|
func TestDelClientStat_CleansNodeBaselines(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
svc := &InboundService{}
|
|
|
|
|
|
|
|
|
|
const email = "gone"
|
|
|
|
|
if err := db.Create(&xray.ClientTraffic{InboundId: 1, Email: email, Enable: true}).Error; err != nil {
|
|
|
|
|
t.Fatalf("seed client_traffics: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if err := db.Create(&model.NodeClientTraffic{NodeId: 1, Email: email, Up: 10, Down: 10}).Error; err != nil {
|
|
|
|
|
t.Fatalf("seed node baseline 1: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if err := db.Create(&model.NodeClientTraffic{NodeId: 2, Email: email, Up: 20, Down: 20}).Error; err != nil {
|
|
|
|
|
t.Fatalf("seed node baseline 2: %v", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if err := svc.DelClientStat(db, email); err != nil {
|
|
|
|
|
t.Fatalf("DelClientStat: %v", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var cnt int64
|
|
|
|
|
if err := db.Model(&model.NodeClientTraffic{}).Where("email = ?", email).Count(&cnt).Error; err != nil {
|
|
|
|
|
t.Fatalf("count baselines: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if cnt != 0 {
|
|
|
|
|
t.Errorf("expected node baselines cleaned, found %d", cnt)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestNodeDelete_CleansNodeBaselines(t *testing.T) {
|
|
|
|
|
db := initTrafficTestDB(t)
|
|
|
|
|
nodeSvc := NodeService{}
|
|
|
|
|
|
|
|
|
|
if err := db.Create(&model.NodeClientTraffic{NodeId: 7, Email: "a", Up: 1, Down: 1}).Error; err != nil {
|
|
|
|
|
t.Fatalf("seed node 7 a: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if err := db.Create(&model.NodeClientTraffic{NodeId: 7, Email: "b", Up: 2, Down: 2}).Error; err != nil {
|
|
|
|
|
t.Fatalf("seed node 7 b: %v", err)
|
|
|
|
|
}
|
|
|
|
|
if err := db.Create(&model.NodeClientTraffic{NodeId: 8, Email: "c", Up: 3, Down: 3}).Error; err != nil {
|
|
|
|
|
t.Fatalf("seed node 8 c: %v", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if err := nodeSvc.Delete(7); err != nil {
|
|
|
|
|
t.Fatalf("NodeService.Delete(7): %v", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var sevenCnt, eightCnt int64
|
|
|
|
|
db.Model(&model.NodeClientTraffic{}).Where("node_id = ?", 7).Count(&sevenCnt)
|
|
|
|
|
db.Model(&model.NodeClientTraffic{}).Where("node_id = ?", 8).Count(&eightCnt)
|
|
|
|
|
if sevenCnt != 0 {
|
|
|
|
|
t.Errorf("node 7 baselines not cleaned: %d remain", sevenCnt)
|
|
|
|
|
}
|
|
|
|
|
if eightCnt != 1 {
|
|
|
|
|
t.Errorf("node 8 baseline should survive, found %d", eightCnt)
|
|
|
|
|
}
|
|
|
|
|
}
|