mirror of
https://github.com/MHSanaei/3x-ui.git
synced 2026-09-10 20:27:15 +00:00
Sanaei
8b9cf260b6
BulkResetTraffic resolved every address with its own GetRecordByEmail call, one SELECT per email, purely to find the disabled clients it has to re-enable. Resetting 30 clients issued 30 queries before the batched transaction even started, while BulkAdjust, BulkDelete and BulkSetEnable next to it already loaded their rows with a single chunked IN query. Those three carried a verbatim copy each of both the trim/dedupe loop and the chunked record load, so the reuse is the fix: trimmedUniqueEmails now delegates to the existing uniqueNonEmptyStrings, and clientRecordsByEmail holds the one chunked lookup all four call sites share. A DB failure during the lookup now aborts the reset instead of being swallowed per email; a missing row is still skipped, as before. The new test drives BulkResetTraffic with 3 and with 30 emails and fails unless both issue the same number of SELECTs against clients.
97 lines
2.6 KiB
Go
97 lines
2.6 KiB
Go
package service
|
|
|
|
import "strings"
|
|
|
|
// sqliteMaxVars is a safe ceiling for the number of bind parameters in a
|
|
// single SQL statement. SQLite's SQLITE_MAX_VARIABLE_NUMBER is 999 on builds
|
|
// before 3.32 and 32766 after; staying under 999 keeps queries portable
|
|
// across forks/old binaries and also bounds per-query memory on truly large
|
|
// installs (>32k clients) where even modern SQLite would refuse a single IN.
|
|
const sqliteMaxVars = 900
|
|
|
|
// normalizeSubSortIndex clamps the 1-based subscription sort order. Values
|
|
// below 1 arrive from clients that predate the field (omitted form key binds
|
|
// to 0) and must not sort ahead of explicitly ranked inbounds.
|
|
func normalizeSubSortIndex(v int) int {
|
|
if v < 1 {
|
|
return 1
|
|
}
|
|
return v
|
|
}
|
|
|
|
// uniqueNonEmptyStrings returns a deduplicated copy of in with empty strings
|
|
// removed, preserving the order of first occurrence.
|
|
func uniqueNonEmptyStrings(in []string) []string {
|
|
if len(in) == 0 {
|
|
return nil
|
|
}
|
|
seen := make(map[string]struct{}, len(in))
|
|
out := make([]string, 0, len(in))
|
|
for _, v := range in {
|
|
if v == "" {
|
|
continue
|
|
}
|
|
if _, ok := seen[v]; ok {
|
|
continue
|
|
}
|
|
seen[v] = struct{}{}
|
|
out = append(out, v)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// trimmedUniqueEmails trims each address before deduplicating, so the bulk
|
|
// client operations treat " a@x " and "a@x" as the same row.
|
|
func trimmedUniqueEmails(in []string) []string {
|
|
trimmed := make([]string, 0, len(in))
|
|
for _, e := range in {
|
|
trimmed = append(trimmed, strings.TrimSpace(e))
|
|
}
|
|
return uniqueNonEmptyStrings(trimmed)
|
|
}
|
|
|
|
// uniqueInts returns a deduplicated copy of in, preserving order of first occurrence.
|
|
func uniqueInts(in []int) []int {
|
|
if len(in) == 0 {
|
|
return nil
|
|
}
|
|
seen := make(map[int]struct{}, len(in))
|
|
out := make([]int, 0, len(in))
|
|
for _, v := range in {
|
|
if _, ok := seen[v]; ok {
|
|
continue
|
|
}
|
|
seen[v] = struct{}{}
|
|
out = append(out, v)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// chunkStrings splits s into consecutive sub-slices of at most size elements.
|
|
// Returns nil for an empty input or non-positive size.
|
|
func chunkStrings(s []string, size int) [][]string {
|
|
if size <= 0 || len(s) == 0 {
|
|
return nil
|
|
}
|
|
out := make([][]string, 0, (len(s)+size-1)/size)
|
|
for i := 0; i < len(s); i += size {
|
|
end := min(i+size, len(s))
|
|
out = append(out, s[i:end])
|
|
}
|
|
return out
|
|
}
|
|
|
|
// chunkInts splits s into consecutive sub-slices of at most size elements.
|
|
// Returns nil for an empty input or non-positive size.
|
|
func chunkInts(s []int, size int) [][]int {
|
|
if size <= 0 || len(s) == 0 {
|
|
return nil
|
|
}
|
|
out := make([][]int, 0, (len(s)+size-1)/size)
|
|
for i := 0; i < len(s); i += size {
|
|
end := min(i+size, len(s))
|
|
out = append(out, s[i:end])
|
|
}
|
|
return out
|
|
}
|