mirror of
https://github.com/Rain-kl/OpenFlare.git
synced 2026-11-16 14:54:23 +08:00
perf(nodes): paginate node lists and fetch details directly (#54)
* perf(nodes): paginate node lists and fetch details directly * fix(nodes): preserve Unicode search and page transition state * fix(nodes): validate search using the UTF-8 byte limit
This commit is contained in:
@@ -0,0 +1,86 @@
|
||||
// Copyright 2026 Arctel.net
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
package integration
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/Rain-kl/Wavelet/internal/apps/openflare/node"
|
||||
"github.com/Rain-kl/Wavelet/internal/shared/response"
|
||||
"github.com/Rain-kl/Wavelet/internal/testhelper"
|
||||
"github.com/gin-contrib/sessions"
|
||||
"github.com/gin-contrib/sessions/cookie"
|
||||
)
|
||||
|
||||
func TestNodePageAPI(t *testing.T) {
|
||||
_, seed, cleanup := setupCoreChainTest(t)
|
||||
engine := testhelper.NewTestGinEngine(sessions.Sessions("node-page-test", cookie.NewStore([]byte("node-page-test-session-secret"))))
|
||||
mountOpenFlareTestRoutes(engine)
|
||||
t.Cleanup(cleanup)
|
||||
headers := adminAuthHeaders(seed.Token)
|
||||
created := performJSONRequest(t, engine, http.MethodPost, apiPath("/nodes"), node.Input{Name: "Searchable Edge"}, headers)
|
||||
if created.Code != http.StatusOK {
|
||||
t.Fatalf("create node status=%d body=%s", created.Code, created.Body.String())
|
||||
}
|
||||
var createdEnvelope struct {
|
||||
Data node.View `json:"data"`
|
||||
}
|
||||
if err := json.Unmarshal(created.Body.Bytes(), &createdEnvelope); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, path := range []string{"/nodes/page", fmt.Sprintf("/nodes/%d", createdEnvelope.Data.ID)} {
|
||||
unauthorized := performJSONRequest(t, engine, http.MethodGet, apiPath(path), nil, nil)
|
||||
var denied response.Any
|
||||
if err := json.Unmarshal(unauthorized.Body.Bytes(), &denied); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if unauthorized.Code != http.StatusUnauthorized || denied.Data != nil || denied.ErrorMsg == "" {
|
||||
t.Errorf("GET %s withoutauth status=%d body=%s,want401 withoutdata", path, unauthorized.Code, unauthorized.Body.String())
|
||||
}
|
||||
}
|
||||
page := performJSONRequest(t, engine, http.MethodGet, apiPath("/nodes/page?search=searchable&status=pending&node_type=edge_node"), nil, headers)
|
||||
var envelope struct {
|
||||
ErrorMsg string `json:"error_msg"`
|
||||
Data node.ListResult `json:"data"`
|
||||
}
|
||||
if err := json.Unmarshal(page.Body.Bytes(), &envelope); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if page.Code != http.StatusOK || envelope.ErrorMsg != "" || envelope.Data.Total != 1 || len(envelope.Data.Results) != 1 {
|
||||
t.Fatalf("GET page status=%d body=%s,wantone", page.Code, page.Body.String())
|
||||
}
|
||||
detail := performJSONRequest(t, engine, http.MethodGet, apiPath(fmt.Sprintf("/nodes/%d", createdEnvelope.Data.ID)), nil, headers)
|
||||
if detail.Code != http.StatusOK {
|
||||
t.Errorf("GET detail status=%d body=%s,want200", detail.Code, detail.Body.String())
|
||||
}
|
||||
missing := performJSONRequest(t, engine, http.MethodGet, apiPath("/nodes/99999"), nil, headers)
|
||||
if missing.Code != http.StatusNotFound {
|
||||
t.Errorf("GET missing node status=%d,want404", missing.Code)
|
||||
}
|
||||
invalid := []string{"page=-1", "page=no", "page=9223372036854775807&page_size=100", "page_size=-1", "page_size=no", "status=healthy", "node_type=relay", "search=" + strings.Repeat("x", 257)}
|
||||
for _, query := range invalid {
|
||||
bad := performJSONRequest(t, engine, http.MethodGet, apiPath("/nodes/page?"+query), nil, headers)
|
||||
var body response.Any
|
||||
if err := json.Unmarshal(bad.Body.Bytes(), &body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if bad.Code != http.StatusBadRequest || body.Data != nil || body.ErrorMsg == "" {
|
||||
t.Errorf("GET page?%s status=%d body=%s,want400 null data", query, bad.Code, bad.Body.String())
|
||||
}
|
||||
}
|
||||
legacy := performJSONRequest(t, engine, http.MethodGet, apiPath("/nodes"), nil, headers)
|
||||
var old struct {
|
||||
Data []node.View `json:"data"`
|
||||
}
|
||||
if err := json.Unmarshal(legacy.Body.Bytes(), &old); err != nil {
|
||||
t.Fatalf("legacy array JSON: %v", err)
|
||||
}
|
||||
if len(old.Data) != 1 {
|
||||
t.Errorf("legacy len=%d,want1", len(old.Data))
|
||||
}
|
||||
}
|
||||
@@ -5,6 +5,8 @@
|
||||
package node
|
||||
|
||||
const (
|
||||
errInvalidNodeListQuery = "invalid node list parameters"
|
||||
errListNodesFailed = "Failed to load nodes"
|
||||
errNodeNameRequired = "节点名不能为空"
|
||||
errNodeIPTooLong = "节点 IP 不能超过 64 个字符"
|
||||
errNodeIPInvalid = "节点 IP 格式无效"
|
||||
|
||||
@@ -197,6 +197,10 @@ func validateNodeGeoCoordinates(geoLatitude, geoLongitude *float64) error {
|
||||
}
|
||||
|
||||
func computeNodeStatus(node *model.OpenFlareNode) string {
|
||||
return computeNodeStatusAt(node, time.Now())
|
||||
}
|
||||
|
||||
func computeNodeStatusAt(node *model.OpenFlareNode, now time.Time) string {
|
||||
if node == nil {
|
||||
return nodeStatusOffline
|
||||
}
|
||||
@@ -206,7 +210,7 @@ func computeNodeStatus(node *model.OpenFlareNode) string {
|
||||
// 默认离线阈值 60 秒(与 node_offline_threshold 默认一致),避免在这里读取配置
|
||||
// 实际阈值会在需要精确判断的地方通过 getNodeOfflineThreshold 读取
|
||||
threshold := 60 * time.Second
|
||||
if time.Since(*node.LastSeenAt) > threshold {
|
||||
if now.Sub(*node.LastSeenAt) > threshold {
|
||||
return nodeStatusOffline
|
||||
}
|
||||
return nodeStatusOnline
|
||||
|
||||
@@ -0,0 +1,103 @@
|
||||
// Copyright 2026 Arctel.net
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
package node
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/Rain-kl/Wavelet/internal/model"
|
||||
"github.com/Rain-kl/Wavelet/internal/repository"
|
||||
)
|
||||
|
||||
const (
|
||||
defaultNodePageSize = 20
|
||||
maxNodePageSize = 100
|
||||
maxNodeSearchLength = 256
|
||||
)
|
||||
|
||||
// ListQuery filters the bounded node list.
|
||||
type ListQuery struct {
|
||||
Page int `form:"page"`
|
||||
PageSize int `form:"page_size"`
|
||||
Search string `form:"search"`
|
||||
Status string `form:"status"`
|
||||
NodeType string `form:"node_type"`
|
||||
}
|
||||
|
||||
// ListResult contains one node page and its filtered total.
|
||||
type ListResult struct {
|
||||
Total int64 `json:"total"`
|
||||
Results []*View `json:"results"`
|
||||
Page int `json:"page"`
|
||||
PageSize int `json:"page_size"`
|
||||
}
|
||||
|
||||
func normalizeListQuery(query ListQuery) (ListQuery, error) {
|
||||
if query.Page < 0 || query.PageSize < 0 {
|
||||
return query, errors.New(errInvalidNodeListQuery)
|
||||
}
|
||||
if query.Page == 0 {
|
||||
query.Page = 1
|
||||
}
|
||||
if query.PageSize == 0 {
|
||||
query.PageSize = defaultNodePageSize
|
||||
}
|
||||
if query.PageSize > maxNodePageSize {
|
||||
query.PageSize = maxNodePageSize
|
||||
}
|
||||
if query.Page-1 > int(^uint(0)>>1)/query.PageSize {
|
||||
return query, errors.New(errInvalidNodeListQuery)
|
||||
}
|
||||
query.Search = strings.TrimSpace(query.Search)
|
||||
if len(query.Search) > maxNodeSearchLength {
|
||||
return query, errors.New(errInvalidNodeListQuery)
|
||||
}
|
||||
switch query.Status {
|
||||
case "", nodeStatusPending, nodeStatusOnline, nodeStatusOffline:
|
||||
default:
|
||||
return query, errors.New(errInvalidNodeListQuery)
|
||||
}
|
||||
switch query.NodeType {
|
||||
case "", nodeTypeEdgeNode, nodeTypeTunnelRelay, nodeTypeTunnelClient:
|
||||
default:
|
||||
return query, errors.New(errInvalidNodeListQuery)
|
||||
}
|
||||
return query, nil
|
||||
}
|
||||
|
||||
// ListPage returns only the requested node page and latest apply metadata for its nodes.
|
||||
func ListPage(ctx context.Context, input ListQuery) (*ListResult, error) {
|
||||
query, err := normalizeListQuery(input)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
now := time.Now()
|
||||
nodes, total, err := repository.ListOpenFlareNodePage(ctx, model.OpenFlareNodeListQuery{
|
||||
Page: query.Page, PageSize: query.PageSize, Search: query.Search, Status: query.Status, NodeType: query.NodeType, Now: now,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
views, err := buildNodeViews(ctx, nodes, now)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &ListResult{Total: total, Results: views, Page: query.Page, PageSize: query.PageSize}, nil
|
||||
}
|
||||
|
||||
// GetNode returns a single node with the same latest apply metadata as the list.
|
||||
func GetNode(ctx context.Context, id uint) (*View, error) {
|
||||
node, err := repository.GetOpenFlareNodeByID(ctx, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
views, err := buildNodeViews(ctx, []model.OpenFlareNode{*node}, time.Now())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return views[0], nil
|
||||
}
|
||||
@@ -0,0 +1,277 @@
|
||||
// Copyright 2026 Arctel.net
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
package node
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
db "github.com/Rain-kl/Wavelet/internal/infra/persistence"
|
||||
"github.com/Rain-kl/Wavelet/internal/model"
|
||||
"github.com/Rain-kl/Wavelet/internal/repository"
|
||||
"github.com/glebarez/sqlite"
|
||||
"github.com/pressly/goose/v3"
|
||||
"gorm.io/gorm"
|
||||
"gorm.io/gorm/logger"
|
||||
)
|
||||
|
||||
func setupNodePageDB(t testing.TB, count int) *gorm.DB {
|
||||
t.Helper()
|
||||
conn, err := gorm.Open(sqlite.Open(filepath.Join(t.TempDir(), "nodes.sqlite")), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})
|
||||
if err != nil {
|
||||
t.Fatalf("open node test DB: %v", err)
|
||||
}
|
||||
sqlDB, err := conn.DB()
|
||||
if err != nil {
|
||||
t.Fatalf("get node SQL DB: %v", err)
|
||||
}
|
||||
sqlDB.SetMaxOpenConns(1)
|
||||
t.Cleanup(func() {
|
||||
db.SetDB(nil)
|
||||
if err := sqlDB.Close(); err != nil {
|
||||
t.Errorf("close node DB: %v", err)
|
||||
}
|
||||
})
|
||||
_, filename, _, ok := runtime.Caller(0)
|
||||
if !ok {
|
||||
t.Fatal("locate node migration directory")
|
||||
}
|
||||
directory := filepath.Join(filepath.Dir(filename), "..", "..", "..", "infra", "persistence", "migrator", "goose", "sqlite")
|
||||
provider, err := goose.NewProvider(goose.DialectSQLite3, sqlDB, os.DirFS(directory))
|
||||
if err != nil {
|
||||
t.Fatalf("create node migration provider: %v", err)
|
||||
}
|
||||
if _, err := provider.Up(context.Background()); err != nil {
|
||||
t.Fatalf("migrate node test DB: %v", err)
|
||||
}
|
||||
db.SetDB(conn)
|
||||
nodes := make([]model.OpenFlareNode, count)
|
||||
for i := range nodes {
|
||||
nodes[i] = model.OpenFlareNode{NodeID: fmt.Sprintf("node-%05d", i+1), Name: fmt.Sprintf("Edge %05d", i+1), NodeType: "edge_node"}
|
||||
}
|
||||
if len(nodes) > 0 {
|
||||
if err := conn.CreateInBatches(nodes, 100).Error; err != nil {
|
||||
t.Fatalf("seed %d nodes: %v", count, err)
|
||||
}
|
||||
}
|
||||
return conn
|
||||
}
|
||||
|
||||
func TestNodeListQueryValidation(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
query ListQuery
|
||||
}{
|
||||
{name: "negative page", query: ListQuery{Page: -1}},
|
||||
{name: "negative size", query: ListQuery{PageSize: -1}},
|
||||
{name: "overflow", query: ListQuery{Page: int(^uint(0) >> 1), PageSize: 100}},
|
||||
{name: "invalid status", query: ListQuery{Status: "healthy"}},
|
||||
{name: "invalid type", query: ListQuery{NodeType: "relay"}},
|
||||
{name: "long search", query: ListQuery{Search: strings.Repeat("x", 257)}},
|
||||
}
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
if _, err := normalizeListQuery(test.query); err == nil {
|
||||
t.Errorf("normalizeListQuery(%+v) error=nil, want validation error", test.query)
|
||||
}
|
||||
})
|
||||
}
|
||||
query, err := normalizeListQuery(ListQuery{})
|
||||
if err != nil || query.Page != 1 || query.PageSize != 20 {
|
||||
t.Errorf("normalizeListQuery(empty)=(%+v,%v), want page1 size20", query, err)
|
||||
}
|
||||
query, err = normalizeListQuery(ListQuery{PageSize: 1000})
|
||||
if err != nil || query.PageSize != 100 {
|
||||
t.Errorf("normalizeListQuery(size1000)=(%+v,%v), want size100", query, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNodePageTwentyThousandNodes(t *testing.T) {
|
||||
conn := setupNodePageDB(t, 20000)
|
||||
ctx := context.Background()
|
||||
if err := conn.Create(&model.OpenFlareApplyLog{NodeID: "node-20000", Result: "success", Message: "latest", Checksum: "new"}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
recorder := &nodePageSQLRecorder{Interface: conn.Logger}
|
||||
conn.Logger = recorder
|
||||
page, err := ListPage(ctx, ListQuery{})
|
||||
if err != nil {
|
||||
t.Fatalf("ListPage(empty) error=%v", err)
|
||||
}
|
||||
if page.Total != 20000 || len(page.Results) != 20 || page.Results[0].ID != 20000 || page.Results[19].ID != 19981 {
|
||||
t.Fatalf("ListPage(empty) total=%d len=%d first=%d last=%d, want20000/20/20000/19981", page.Total, len(page.Results), page.Results[0].ID, page.Results[len(page.Results)-1].ID)
|
||||
}
|
||||
if page.Results[0].LatestApplyChecksum != "new" {
|
||||
t.Errorf("ListPage latest checksum=%q,want new", page.Results[0].LatestApplyChecksum)
|
||||
}
|
||||
if len(recorder.statements) != 3 || recorder.rows > 22 {
|
||||
t.Errorf("ListPage SQL queries=%v selectedRows=%d,want3 and <=22", recorder.statements, recorder.rows)
|
||||
}
|
||||
conn.Logger = recorder.Interface
|
||||
second, err := ListPage(ctx, ListQuery{Page: 2})
|
||||
if err != nil || len(second.Results) != 20 || second.Results[0].ID != 19980 {
|
||||
t.Fatalf("ListPage(page2)=(%+v,%v),want firstID19980", second, err)
|
||||
}
|
||||
capped, err := ListPage(ctx, ListQuery{PageSize: 1000})
|
||||
if err != nil || len(capped.Results) != 100 {
|
||||
t.Errorf("ListPage(size1000) results=%v,error=%v,want100", len(capped.Results), err)
|
||||
}
|
||||
empty, err := ListPage(ctx, ListQuery{Page: 1001})
|
||||
if err != nil || len(empty.Results) != 0 || empty.Results == nil || empty.Total != 20000 {
|
||||
t.Errorf("ListPage(beyondend)=(%+v,%v),want empty nonnil results total20000", empty, err)
|
||||
}
|
||||
detail, err := GetNode(ctx, 20000)
|
||||
if err != nil || detail.LatestApplyChecksum != "new" {
|
||||
t.Errorf("GetNode(20000)=(%+v,%v),want matching apply metadata", detail, err)
|
||||
}
|
||||
legacy, err := ListNodes(ctx)
|
||||
if err != nil || len(legacy) != 20000 {
|
||||
t.Errorf("legacy ListNodes len=%d,error=%v,want20000", len(legacy), err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNodePageFiltersUseComputedStatus(t *testing.T) {
|
||||
conn := setupNodePageDB(t, 0)
|
||||
now := time.Now().UTC().Truncate(time.Second)
|
||||
cutoff := now.Add(-time.Minute)
|
||||
old := cutoff.Add(-time.Second)
|
||||
zero := time.Time{}
|
||||
nodes := []model.OpenFlareNode{
|
||||
{NodeID: "literal", Name: "EDGE 100%_!", NodeType: "edge_node", Status: "offline", LastSeenAt: &cutoff},
|
||||
{NodeID: "old", Name: "old", NodeType: "tunnel_relay", Status: "online", LastSeenAt: &old},
|
||||
{NodeID: "pending", Name: "pending", NodeType: "edge_node"},
|
||||
{NodeID: "zero", Name: "zero", NodeType: "edge_node", LastSeenAt: &zero},
|
||||
}
|
||||
if err := conn.Create(&nodes).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := conn.Model(&nodes[2]).Update("node_type", "").Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cases := []struct {
|
||||
query model.OpenFlareNodeListQuery
|
||||
want int64
|
||||
}{
|
||||
{query: model.OpenFlareNodeListQuery{Status: "online"}, want: 1},
|
||||
{query: model.OpenFlareNodeListQuery{Status: "offline"}, want: 1},
|
||||
{query: model.OpenFlareNodeListQuery{Status: "pending"}, want: 2},
|
||||
{query: model.OpenFlareNodeListQuery{NodeType: "edge_node"}, want: 3},
|
||||
{query: model.OpenFlareNodeListQuery{NodeType: "tunnel_relay"}, want: 1},
|
||||
{query: model.OpenFlareNodeListQuery{Search: "100%_!"}, want: 1},
|
||||
{query: model.OpenFlareNodeListQuery{Search: "edge"}, want: 1},
|
||||
{query: model.OpenFlareNodeListQuery{Status: "pending", NodeType: "tunnel_relay"}, want: 0},
|
||||
}
|
||||
for _, test := range cases {
|
||||
test.query.Page = 1
|
||||
test.query.PageSize = 20
|
||||
test.query.Now = now
|
||||
rows, total, err := repository.ListOpenFlareNodePage(context.Background(), test.query)
|
||||
if err != nil || total != test.want || int64(len(rows)) != test.want {
|
||||
t.Errorf("ListOpenFlareNodePage(%+v) len=%d,total=%d,error=%v,want%d", test.query, len(rows), total, err, test.want)
|
||||
}
|
||||
for _, row := range rows {
|
||||
if test.query.Status != "" && computeNodeStatusAt(&row, now) != test.query.Status {
|
||||
t.Errorf("status SQL/view mismatch query%+v node%+v", test.query, row)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestNodePageUnicodeLiteralSearch(t *testing.T) {
|
||||
conn := setupNodePageDB(t, 0)
|
||||
nodes := []model.OpenFlareNode{
|
||||
{NodeID: "unicode-latin", Name: "Étage 100%_!", NodeType: "edge_node"},
|
||||
{NodeID: "unicode-cyrillic", Name: "Москва 100%_!", NodeType: "edge_node"},
|
||||
{NodeID: "unicode-decoy", Name: "Étage 100xx!", NodeType: "edge_node"},
|
||||
}
|
||||
if err := conn.Create(&nodes).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cases := []struct {
|
||||
search string
|
||||
wantID string
|
||||
}{
|
||||
{search: "Étage 100%_!", wantID: "unicode-latin"},
|
||||
{search: "ÉTAGE 100%_!", wantID: "unicode-latin"},
|
||||
{search: "Москва 100%_!", wantID: "unicode-cyrillic"},
|
||||
{search: "unicode-CYRILLIC", wantID: "unicode-cyrillic"},
|
||||
}
|
||||
for _, test := range cases {
|
||||
page, err := ListPage(context.Background(), ListQuery{Search: test.search})
|
||||
if err != nil {
|
||||
t.Fatalf("ListPage(search=%q) error=%v", test.search, err)
|
||||
}
|
||||
if page.Total != 1 || len(page.Results) != 1 {
|
||||
t.Errorf("ListPage(search=%q) total=%d,len=%d,wantone", test.search, page.Total, len(page.Results))
|
||||
continue
|
||||
}
|
||||
if page.Results[0].NodeID != test.wantID {
|
||||
t.Errorf("ListPage(search=%q) nodeID=%q,want%q", test.search, page.Results[0].NodeID, test.wantID)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestNodePageIndexes(t *testing.T) {
|
||||
conn := setupNodePageDB(t, 20000)
|
||||
queries := []struct {
|
||||
sql string
|
||||
arg any
|
||||
index string
|
||||
}{
|
||||
{sql: "SELECT count(*) FROM of_nodes WHERE node_type = ?", arg: "tunnel_client", index: "idx_of_nodes_type_id"},
|
||||
{sql: "SELECT count(*) FROM of_nodes WHERE last_seen_at >= ?", arg: time.Now().Add(-time.Minute), index: "idx_of_nodes_last_seen_id"},
|
||||
}
|
||||
for _, query := range queries {
|
||||
var rows []struct{ Detail string }
|
||||
if err := conn.Raw("EXPLAIN QUERY PLAN "+query.sql, query.arg).Scan(&rows).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
found := false
|
||||
for _, row := range rows {
|
||||
t.Log(row.Detail)
|
||||
found = found || strings.Contains(row.Detail, query.index)
|
||||
}
|
||||
if !found {
|
||||
t.Errorf("EXPLAIN %q=%v,want index%s", query.sql, rows, query.index)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkNodeListTwentyThousand(b *testing.B) {
|
||||
setupNodePageDB(b, 20000)
|
||||
b.Run("legacy_all", func(b *testing.B) {
|
||||
b.ReportAllocs()
|
||||
for b.Loop() {
|
||||
if _, err := ListNodes(context.Background()); err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
}
|
||||
})
|
||||
b.Run("page20", func(b *testing.B) {
|
||||
b.ReportAllocs()
|
||||
for b.Loop() {
|
||||
if _, err := ListPage(context.Background(), ListQuery{}); err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
type nodePageSQLRecorder struct {
|
||||
logger.Interface
|
||||
statements []string
|
||||
rows int64
|
||||
}
|
||||
|
||||
func (recorder *nodePageSQLRecorder) Trace(_ context.Context, _ time.Time, query func() (string, int64), _ error) {
|
||||
sql, rows := query()
|
||||
recorder.statements = append(recorder.statements, sql)
|
||||
recorder.rows += rows
|
||||
}
|
||||
@@ -140,6 +140,10 @@ func ListNodes(ctx context.Context) ([]*View, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return buildNodeViews(ctx, nodes, time.Now())
|
||||
}
|
||||
|
||||
func buildNodeViews(ctx context.Context, nodes []model.OpenFlareNode, now time.Time) ([]*View, error) {
|
||||
nodeIDs := make([]string, 0, len(nodes))
|
||||
for _, node := range nodes {
|
||||
nodeIDs = append(nodeIDs, node.NodeID)
|
||||
@@ -151,7 +155,7 @@ func ListNodes(ctx context.Context) ([]*View, error) {
|
||||
views := make([]*View, 0, len(nodes))
|
||||
for _, node := range nodes {
|
||||
view := buildNodeView(&node)
|
||||
view.Status = computeNodeStatus(&node)
|
||||
view.Status = computeNodeStatusAt(&node, now)
|
||||
if log, ok := latestLogs[node.NodeID]; ok {
|
||||
view.LatestApplyResult = log.Result
|
||||
view.LatestApplyMessage = log.Message
|
||||
|
||||
@@ -11,7 +11,9 @@ import (
|
||||
|
||||
"github.com/Rain-kl/Wavelet/internal/apps/openflare/apiutil"
|
||||
"github.com/Rain-kl/Wavelet/internal/shared/response"
|
||||
"github.com/Rain-kl/Wavelet/pkg/logger"
|
||||
"github.com/gin-gonic/gin"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
func handleLogicError(c *gin.Context, err error) bool {
|
||||
@@ -321,3 +323,71 @@ func bindOptionalJSON(body io.Reader, target any) error {
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ListNodePageHandler lists a bounded page of nodes.
|
||||
// @Summary 获取分页节点列表
|
||||
// @Description 返回分页节点和筛选后的总数;旧版 /nodes 列表接口保持兼容,需要管理员权限
|
||||
// @Tags openflare-node
|
||||
// @Produce json
|
||||
// @Security SessionCookie
|
||||
// @Param page query int false "页码(默认 1)"
|
||||
// @Param page_size query int false "每页数量(默认 20,最大 100)"
|
||||
// @Param search query string false "名称、节点标识或 IP 的字面子串(最多 256 字节)"
|
||||
// @Param status query string false "pending、online 或 offline"
|
||||
// @Param node_type query string false "edge_node、tunnel_relay 或 tunnel_client"
|
||||
// @Success 200 {object} response.Any{data=node.ListResult} "节点分页"
|
||||
// @Failure 400 {object} response.Any "参数错误"
|
||||
// @Failure 401 {object} response.Any "未登录"
|
||||
// @Failure 404 {object} response.Any "无权限"
|
||||
// @Failure 500 {object} response.Any "查询失败"
|
||||
// @Router /api/v1/d/nodes/page [get]
|
||||
func ListNodePageHandler(c *gin.Context) {
|
||||
var query ListQuery
|
||||
if err := c.ShouldBindQuery(&query); err != nil {
|
||||
response.AbortBadRequest(c, errInvalidNodeListQuery)
|
||||
return
|
||||
}
|
||||
normalized, err := normalizeListQuery(query)
|
||||
if err != nil {
|
||||
response.AbortBadRequest(c, errInvalidNodeListQuery)
|
||||
return
|
||||
}
|
||||
result, err := ListPage(c.Request.Context(), normalized)
|
||||
if err != nil {
|
||||
logger.ErrorF(c.Request.Context(), "Failed to list node page: %v", err)
|
||||
response.AbortInternal(c, errListNodesFailed)
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, response.OK(result))
|
||||
}
|
||||
|
||||
// GetNodeHandler returns a single node.
|
||||
// @Summary 获取节点详情
|
||||
// @Description 返回指定节点及最新配置下发记录,需要管理员权限
|
||||
// @Tags openflare-node
|
||||
// @Produce json
|
||||
// @Security SessionCookie
|
||||
// @Param id path int true "节点 ID"
|
||||
// @Success 200 {object} response.Any{data=node.View} "节点详情"
|
||||
// @Failure 400 {object} response.Any "参数错误"
|
||||
// @Failure 401 {object} response.Any "未登录"
|
||||
// @Failure 404 {object} response.Any "无权限或不存在"
|
||||
// @Failure 500 {object} response.Any "查询失败"
|
||||
// @Router /api/v1/d/nodes/{id} [get]
|
||||
func GetNodeHandler(c *gin.Context) {
|
||||
id, ok := apiutil.IDParam(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
view, err := GetNode(c.Request.Context(), id)
|
||||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
response.AbortNotFound(c, errNodeNotFound)
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
logger.ErrorF(c.Request.Context(), "Failed to get node: %v", err)
|
||||
response.AbortInternal(c, errListNodesFailed)
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, response.OK(view))
|
||||
}
|
||||
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
-- +goose Up
|
||||
CREATE INDEX IF NOT EXISTS idx_of_nodes_type_id ON of_nodes (node_type, id);
|
||||
CREATE INDEX IF NOT EXISTS idx_of_nodes_last_seen_id ON of_nodes (last_seen_at, id);
|
||||
|
||||
-- +goose Down
|
||||
DROP INDEX IF EXISTS idx_of_nodes_last_seen_id;
|
||||
DROP INDEX IF EXISTS idx_of_nodes_type_id;
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
-- +goose Up
|
||||
CREATE INDEX IF NOT EXISTS idx_of_nodes_type_id ON of_nodes (node_type, id);
|
||||
CREATE INDEX IF NOT EXISTS idx_of_nodes_last_seen_id ON of_nodes (last_seen_at, id);
|
||||
|
||||
-- +goose Down
|
||||
DROP INDEX IF EXISTS idx_of_nodes_last_seen_id;
|
||||
DROP INDEX IF EXISTS idx_of_nodes_type_id;
|
||||
@@ -50,3 +50,13 @@ type OpenFlareNode struct {
|
||||
func (OpenFlareNode) TableName() string {
|
||||
return "of_nodes"
|
||||
}
|
||||
|
||||
// OpenFlareNodeListQuery describes a bounded node query.
|
||||
type OpenFlareNodeListQuery struct {
|
||||
Page int
|
||||
PageSize int
|
||||
Search string
|
||||
Status string
|
||||
NodeType string
|
||||
Now time.Time
|
||||
}
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
// Copyright 2026 Arctel.net
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
package repository
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
db "github.com/Rain-kl/Wavelet/internal/infra/persistence"
|
||||
"github.com/Rain-kl/Wavelet/internal/model"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
// ListOpenFlareNodePage returns a bounded page and the count for the same filters.
|
||||
func ListOpenFlareNodePage(ctx context.Context, query model.OpenFlareNodeListQuery) ([]model.OpenFlareNode, int64, error) {
|
||||
conn := db.DB(ctx)
|
||||
if conn == nil {
|
||||
return nil, 0, errors.New(errDatabaseNotInitialized)
|
||||
}
|
||||
filtered := filterOpenFlareNodes(conn.Model(&model.OpenFlareNode{}), query)
|
||||
var total int64
|
||||
if err := filtered.Count(&total).Error; err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
nodes := make([]model.OpenFlareNode, 0)
|
||||
err := filtered.Order("id DESC").Limit(query.PageSize).Offset((query.Page - 1) * query.PageSize).Find(&nodes).Error
|
||||
return nodes, total, err
|
||||
}
|
||||
|
||||
func filterOpenFlareNodes(query *gorm.DB, filters model.OpenFlareNodeListQuery) *gorm.DB {
|
||||
if filters.Search != "" {
|
||||
escaped := strings.NewReplacer("!", "!!", "%", "!%", "_", "!_").Replace(filters.Search)
|
||||
pattern := "%" + escaped + "%"
|
||||
query = query.Where("(LOWER(name) LIKE LOWER(?) ESCAPE '!' OR LOWER(node_id) LIKE LOWER(?) ESCAPE '!' OR LOWER(ip) LIKE LOWER(?) ESCAPE '!')", pattern, pattern, pattern)
|
||||
}
|
||||
if filters.NodeType == "edge_node" {
|
||||
query = query.Where("(node_type = ? OR node_type = '')", filters.NodeType)
|
||||
} else if filters.NodeType != "" {
|
||||
query = query.Where("node_type = ?", filters.NodeType)
|
||||
}
|
||||
cutoff := filters.Now.Add(-time.Minute)
|
||||
switch filters.Status {
|
||||
case "pending":
|
||||
query = query.Where("(last_seen_at IS NULL OR last_seen_at = ?)", time.Time{})
|
||||
case "online":
|
||||
query = query.Where("last_seen_at >= ? AND last_seen_at <> ?", cutoff, time.Time{})
|
||||
case "offline":
|
||||
query = query.Where("last_seen_at < ? AND last_seen_at <> ?", cutoff, time.Time{})
|
||||
}
|
||||
return query
|
||||
}
|
||||
@@ -13,6 +13,8 @@ func registerNodeRoutes(apiGroup *gin.RouterGroup) {
|
||||
nodeRoute := apiGroup.Group("/nodes")
|
||||
nodeRoute.Use(apiutil.AdminMiddlewares()...)
|
||||
{
|
||||
nodeRoute.GET("/page", node.ListNodePageHandler)
|
||||
nodeRoute.GET("/:id", node.GetNodeHandler)
|
||||
nodeRoute.GET("/bootstrap-token", node.GetBootstrapTokenHandler)
|
||||
nodeRoute.POST("/bootstrap-token/rotate", node.RotateBootstrapTokenHandler)
|
||||
apiutil.RegisterCollection(nodeRoute, "GET", node.ListNodesHandler)
|
||||
|
||||
Reference in New Issue
Block a user