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:
ArthurKoba
2026-11-07 16:29:52 +03:00
committed by GitHub
parent 72d67c80f2
commit 3c7b347d7b
28 changed files with 1873 additions and 45 deletions
@@ -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))
}
}
+2
View File
@@ -5,6 +5,8 @@
package node
const (
errInvalidNodeListQuery = "invalid node list parameters"
errListNodesFailed = "Failed to load nodes"
errNodeNameRequired = "节点名不能为空"
errNodeIPTooLong = "节点 IP 不能超过 64 个字符"
errNodeIPInvalid = "节点 IP 格式无效"
+5 -1
View File
@@ -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
+103
View File
@@ -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
}
+277
View File
@@ -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
}
+5 -1
View File
@@ -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
+70
View File
@@ -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))
}
@@ -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;
@@ -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;
+10
View File
@@ -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)