mirror of
https://github.com/Sagit-chu/flvx.git
synced 2026-11-17 01:44:23 +08:00
feat: add optional sequential port allocation with atomic reservations
Adapt the port allocation option from #583 by xigua761 without its commercial licensing changes. Serialize forward, chain, peer runtime, cleanup and import reservations across SQLite/PostgreSQL instances. Co-authored-by: xigua761 <xigua1166@outlook.com>
This commit is contained in:
@@ -1609,7 +1609,15 @@ func (r *Repository) CreatePeerShareRuntime(item *model.PeerShareRuntime) error
|
||||
if item == nil {
|
||||
return errors.New("runtime item is nil")
|
||||
}
|
||||
return r.db.Create(item).Error
|
||||
return r.db.Transaction(func(tx *gorm.DB) error {
|
||||
if err := lockPortAllocationTx(tx); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := r.checkPeerRuntimePortTx(tx, item); err != nil {
|
||||
return err
|
||||
}
|
||||
return tx.Create(item).Error
|
||||
})
|
||||
}
|
||||
|
||||
func (r *Repository) UpdatePeerShareRuntime(item *model.PeerShareRuntime) error {
|
||||
@@ -1619,17 +1627,34 @@ func (r *Repository) UpdatePeerShareRuntime(item *model.PeerShareRuntime) error
|
||||
if item == nil {
|
||||
return errors.New("runtime item is nil")
|
||||
}
|
||||
return r.db.Model(&model.PeerShareRuntime{}).Where("id = ?", item.ID).Updates(map[string]interface{}{
|
||||
"reservation_id": item.ReservationID,
|
||||
"relay_auth": item.RelayAuth,
|
||||
"relay_auth_version": item.RelayAuthVersion,
|
||||
"binding_id": item.BindingID, "role": item.Role,
|
||||
"chain_name": item.ChainName, "service_name": item.ServiceName,
|
||||
"protocol": item.Protocol, "strategy": item.Strategy,
|
||||
"port": item.Port, "target": item.Target,
|
||||
"applied": item.Applied, "status": item.Status,
|
||||
"updated_time": item.UpdatedTime,
|
||||
}).Error
|
||||
return r.db.Transaction(func(tx *gorm.DB) error {
|
||||
if err := lockPortAllocationTx(tx); err != nil {
|
||||
return err
|
||||
}
|
||||
var current model.PeerShareRuntime
|
||||
if err := tx.Where("id = ?", item.ID).First(¤t).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
if current.NodeID != item.NodeID {
|
||||
return errors.New("runtime node cannot change")
|
||||
}
|
||||
if !(current.Status == 1 && current.Port == item.Port) {
|
||||
if err := r.checkPeerRuntimePortTx(tx, item); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return tx.Model(&model.PeerShareRuntime{}).Where("id = ?", item.ID).Updates(map[string]interface{}{
|
||||
"reservation_id": item.ReservationID,
|
||||
"relay_auth": item.RelayAuth,
|
||||
"relay_auth_version": item.RelayAuthVersion,
|
||||
"binding_id": item.BindingID, "role": item.Role,
|
||||
"chain_name": item.ChainName, "service_name": item.ServiceName,
|
||||
"protocol": item.Protocol, "strategy": item.Strategy,
|
||||
"port": item.Port, "target": item.Target,
|
||||
"applied": item.Applied, "status": item.Status,
|
||||
"updated_time": item.UpdatedTime,
|
||||
}).Error
|
||||
})
|
||||
}
|
||||
|
||||
func (r *Repository) MarkPeerShareRuntimeReleased(id int64, updatedTime int64) error {
|
||||
@@ -2664,6 +2689,15 @@ func importTunnels(tx *gorm.DB, tunnels []model.TunnelBackup, now int64) (int, e
|
||||
return count, err
|
||||
}
|
||||
for _, ct := range t.ChainTunnels {
|
||||
if ct.Port > 0 {
|
||||
used, err := (&Repository{}).usedPortSetTx(tx, ct.NodeID, 0, ct.TunnelID)
|
||||
if err != nil {
|
||||
return count, err
|
||||
}
|
||||
if used[ct.Port] {
|
||||
return count, errors.New("导入链路端口已占用")
|
||||
}
|
||||
}
|
||||
chainItem := model.ChainTunnel{
|
||||
ID: ct.ID,
|
||||
TunnelID: ct.TunnelID,
|
||||
@@ -2735,6 +2769,13 @@ func importForwards(tx *gorm.DB, forwards []model.ForwardBackup, now int64) (int
|
||||
return count, err
|
||||
}
|
||||
for _, fp := range *f.ForwardPorts {
|
||||
used, err := (&Repository{}).usedPortSetTx(tx, fp.NodeID, f.ID, 0)
|
||||
if err != nil {
|
||||
return count, err
|
||||
}
|
||||
if used[fp.Port] {
|
||||
return count, errors.New("导入转发端口已占用")
|
||||
}
|
||||
if err := tx.Create(&model.ForwardPort{ForwardID: f.ID, NodeID: fp.NodeID, Port: fp.Port}).Error; err != nil {
|
||||
return count, err
|
||||
}
|
||||
|
||||
@@ -18,7 +18,12 @@ var errBackupImportBusy = errors.New("database is busy; retry the backup import"
|
||||
func backupImportTransaction(db *gorm.DB, importRows func(*gorm.DB) error) error {
|
||||
var err error
|
||||
for attempt := 0; attempt < 10; attempt++ {
|
||||
err = db.Transaction(importRows)
|
||||
err = db.Transaction(func(tx *gorm.DB) error {
|
||||
if err := lockPortAllocationTx(tx); err != nil {
|
||||
return err
|
||||
}
|
||||
return importRows(tx)
|
||||
})
|
||||
if !errors.Is(err, errBackupImportBusy) {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -146,19 +146,13 @@ func (r *Repository) CreateFederationTunnel(name string, tunnelType int, protoco
|
||||
InIP: sql.NullString{String: "", Valid: false},
|
||||
}
|
||||
err := r.db.Transaction(func(tx *gorm.DB) error {
|
||||
if err := lockPortAllocationTx(tx); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := tx.Create(&tunnel).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
ct := model.ChainTunnel{
|
||||
TunnelID: tunnel.ID,
|
||||
ChainType: "1",
|
||||
NodeID: nodeID,
|
||||
Port: sql.NullInt64{Int64: int64(remotePort), Valid: true},
|
||||
Strategy: sql.NullString{String: "fifo", Valid: true},
|
||||
Inx: sql.NullInt64{Int64: 0, Valid: true},
|
||||
Protocol: sql.NullString{String: protocol, Valid: true},
|
||||
}
|
||||
if err := tx.Create(&ct).Error; err != nil {
|
||||
if err := r.CreateChainTunnelTx(tx, tunnel.ID, "1", nodeID, sql.NullInt64{Int64: int64(remotePort), Valid: true}, "fifo", 0, protocol, ""); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
|
||||
@@ -160,6 +160,9 @@ func TestForwardRepositoryPersistsPerIPLimits(t *testing.T) {
|
||||
defer r.Close()
|
||||
|
||||
now := time.Now().UnixMilli()
|
||||
if err := r.db.Create(&model.Node{ID: 3, Port: "1000-65535"}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
forwardID, err := r.CreateForwardTx(1, "admin", "per-ip-forward", 2, "1.1.1.1:443", "fifo", now, 1, []int64{3}, 24000, "", nil, 0, 5, int64(21), 0, 0, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("CreateForwardTx: %v", err)
|
||||
@@ -224,6 +227,9 @@ func TestForwardRepositoryPersistsProxyProtocolReceiveAndSend(t *testing.T) {
|
||||
defer r.Close()
|
||||
|
||||
now := time.Now().UnixMilli()
|
||||
if err := r.db.Create(&model.Node{ID: 3, Port: "1000-65535"}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
forwardID, err := r.CreateForwardTx(1, "admin", "proxy-protocol-forward", 2, "1.1.1.1:443", "fifo", now, 1, []int64{3}, 24000, "", nil, 0, 0, nil, 0, 1, 2)
|
||||
if err != nil {
|
||||
t.Fatalf("CreateForwardTx: %v", err)
|
||||
@@ -301,7 +307,10 @@ func TestRollbackForwardFieldsRestoresPerIPLimits(t *testing.T) {
|
||||
defer r.Close()
|
||||
|
||||
now := time.Now().UnixMilli()
|
||||
forwardID, err := r.CreateForwardTx(1, "admin", "rollback-per-ip-forward", 2, "1.1.1.1:443", "fifo", now, 1, nil, 0, "", nil, 7, 5, int64(21), 2, 0, 2)
|
||||
if err := r.db.Create(&model.Node{ID: 3, Port: "1000-65535"}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
forwardID, err := r.CreateForwardTx(1, "admin", "rollback-per-ip-forward", 2, "1.1.1.1:443", "fifo", now, 1, []int64{3}, 24000, "", nil, 7, 5, int64(21), 2, 0, 2)
|
||||
if err != nil {
|
||||
t.Fatalf("CreateForwardTx: %v", err)
|
||||
}
|
||||
|
||||
@@ -448,7 +448,14 @@ func (r *Repository) BeginTx() *gorm.DB {
|
||||
if r == nil || r.db == nil {
|
||||
return nil
|
||||
}
|
||||
return r.db.Begin()
|
||||
tx := r.db.Begin()
|
||||
if tx.Error == nil {
|
||||
if err := lockPortAllocationTx(tx); err != nil {
|
||||
tx.Rollback()
|
||||
tx.AddError(err)
|
||||
}
|
||||
}
|
||||
return tx
|
||||
}
|
||||
|
||||
func (r *Repository) UpdateTunnelOrder(tunnelID int64, inx int, now int64) {
|
||||
@@ -492,6 +499,18 @@ func (r *Repository) CreateChainTunnelTx(tx *gorm.DB, tunnelID int64, chainType
|
||||
if tx == nil {
|
||||
return errors.New("database unavailable")
|
||||
}
|
||||
if port.Valid && port.Int64 > 0 {
|
||||
if err := r.LockPortNodesTx(tx, []int64{nodeID}); err != nil {
|
||||
return err
|
||||
}
|
||||
used, err := r.usedPortSetTx(tx, nodeID, 0, tunnelID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if used[int(port.Int64)] {
|
||||
return errors.New("端口已占用")
|
||||
}
|
||||
}
|
||||
ct := model.ChainTunnel{
|
||||
TunnelID: tunnelID,
|
||||
ChainType: chainType,
|
||||
@@ -538,6 +557,9 @@ func (r *Repository) pickNodePortTx(tx *gorm.DB, nodeID int64, allocated map[int
|
||||
if nodeID <= 0 {
|
||||
return 0, errors.New("节点不存在")
|
||||
}
|
||||
if err := r.LockPortNodesTx(tx, []int64{nodeID}); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if port, ok := allocated[nodeID]; ok && port > 0 {
|
||||
return port, nil
|
||||
}
|
||||
@@ -556,47 +578,16 @@ func (r *Repository) pickNodePortTx(tx *gorm.DB, nodeID int64, allocated map[int
|
||||
return 0, errors.New("节点端口已满,无可用端口")
|
||||
}
|
||||
|
||||
used := make(map[int]struct{})
|
||||
|
||||
chainQuery := tx.Model(&model.ChainTunnel{}).Where("node_id = ? AND port > 0", nodeID)
|
||||
if excludeTunnelID > 0 {
|
||||
chainQuery = chainQuery.Where("tunnel_id != ?", excludeTunnelID)
|
||||
}
|
||||
var chainPorts []int
|
||||
if err := chainQuery.Pluck("port", &chainPorts).Error; err != nil {
|
||||
return 0, err
|
||||
}
|
||||
for _, p := range chainPorts {
|
||||
if p > 0 {
|
||||
used[p] = struct{}{}
|
||||
}
|
||||
}
|
||||
|
||||
var forwardPorts []int
|
||||
if err := tx.Model(&model.ForwardPort{}).
|
||||
Where("node_id = ? AND port > 0", nodeID).
|
||||
Pluck("port", &forwardPorts).Error; err != nil {
|
||||
return 0, err
|
||||
}
|
||||
for _, p := range forwardPorts {
|
||||
if p > 0 {
|
||||
used[p] = struct{}{}
|
||||
}
|
||||
}
|
||||
|
||||
pendingPorts, err := r.PendingTunnelCleanupPortsTx(tx, nodeID, excludeTunnelID)
|
||||
used, err := r.usedPortSetTx(tx, nodeID, 0, excludeTunnelID)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
for _, port := range pendingPorts {
|
||||
used[port] = struct{}{}
|
||||
}
|
||||
var available []int
|
||||
for _, candidate := range candidates {
|
||||
if candidate <= 0 {
|
||||
continue
|
||||
}
|
||||
if _, ok := used[candidate]; ok {
|
||||
if used[candidate] {
|
||||
continue
|
||||
}
|
||||
available = append(available, candidate)
|
||||
@@ -836,11 +827,64 @@ func (r *Repository) ReplaceForwardPorts(forwardID int64, entries []struct {
|
||||
NodeID int64
|
||||
Port int
|
||||
InIP string
|
||||
}) error {
|
||||
}, sequential ...bool) error {
|
||||
return r.replaceForwardPorts(forwardID, entries, len(sequential) > 0 && sequential[0], false)
|
||||
}
|
||||
|
||||
// ReplaceForwardPortsIndividually preserves independent ports when adding entry nodes.
|
||||
func (r *Repository) ReplaceForwardPortsIndividually(forwardID int64, entries []struct {
|
||||
NodeID int64
|
||||
Port int
|
||||
InIP string
|
||||
}, sequential bool) error {
|
||||
return r.replaceForwardPorts(forwardID, entries, sequential, true)
|
||||
}
|
||||
|
||||
func (r *Repository) replaceForwardPorts(forwardID int64, entries []struct {
|
||||
NodeID int64
|
||||
Port int
|
||||
InIP string
|
||||
}, sequential, individually bool) error {
|
||||
if r == nil || r.db == nil {
|
||||
return errors.New("repository not initialized")
|
||||
}
|
||||
return r.db.Transaction(func(tx *gorm.DB) error {
|
||||
ids := make([]int64, 0, len(entries))
|
||||
autoIDs := []int64{}
|
||||
for _, e := range entries {
|
||||
ids = append(ids, e.NodeID)
|
||||
if e.Port <= 0 {
|
||||
autoIDs = append(autoIDs, e.NodeID)
|
||||
}
|
||||
}
|
||||
if err := r.LockPortNodesTx(tx, ids); err != nil {
|
||||
return err
|
||||
}
|
||||
autoPort := 0
|
||||
if len(autoIDs) > 0 && !individually {
|
||||
var err error
|
||||
autoPort, err = r.selectForwardPortTx(tx, autoIDs, 0, forwardID, sequential)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
entries = append(entries[:0:0], entries...)
|
||||
for i := range entries {
|
||||
if entries[i].Port <= 0 {
|
||||
if individually {
|
||||
var err error
|
||||
entries[i].Port, err = r.selectForwardPortTx(tx, []int64{entries[i].NodeID}, 0, forwardID, sequential)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
entries[i].Port = autoPort
|
||||
}
|
||||
}
|
||||
if _, err := r.selectForwardPortTx(tx, []int64{entries[i].NodeID}, entries[i].Port, forwardID, false); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if err := tx.Where("forward_id = ?", forwardID).Delete(&model.ForwardPort{}).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -1362,13 +1406,21 @@ func (r *Repository) EnsureUserTunnelGrant(userID, tunnelID int64) (int64, bool,
|
||||
return ut.ID, true, nil
|
||||
}
|
||||
|
||||
func (r *Repository) CreateForwardTx(userID int64, userName, name string, tunnelID int64, remoteAddr, strategy string, now int64, inx int, entryNodeIDs []int64, port int, inIp string, speedID interface{}, maxConn int, ipMaxConn int, ipSpeedID interface{}, proxyProtocol int, proxyProtocolReceive int, proxyProtocolSend int) (int64, error) {
|
||||
func (r *Repository) CreateForwardTx(userID int64, userName, name string, tunnelID int64, remoteAddr, strategy string, now int64, inx int, entryNodeIDs []int64, port int, inIp string, speedID interface{}, maxConn int, ipMaxConn int, ipSpeedID interface{}, proxyProtocol int, proxyProtocolReceive int, proxyProtocolSend int, sequential ...bool) (int64, error) {
|
||||
if r == nil || r.db == nil {
|
||||
return 0, errors.New("repository not initialized")
|
||||
}
|
||||
_, proxyProtocolSend = normalizeForwardProxyProtocol(proxyProtocol, proxyProtocolReceive, proxyProtocolSend)
|
||||
var forwardID int64
|
||||
err := r.db.Transaction(func(tx *gorm.DB) error {
|
||||
if err := r.LockPortNodesTx(tx, entryNodeIDs); err != nil {
|
||||
return err
|
||||
}
|
||||
selectedPort, err := r.selectForwardPortTx(tx, entryNodeIDs, port, 0, len(sequential) > 0 && sequential[0])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
port = selectedPort
|
||||
fwd := model.Forward{
|
||||
UserID: userID,
|
||||
UserName: userName,
|
||||
|
||||
@@ -0,0 +1,184 @@
|
||||
package repo
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"go-backend/internal/store/model"
|
||||
"gorm.io/gorm"
|
||||
"math/big"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// lockPortAllocationTx serializes reservation mutations across processes sharing a database.
|
||||
// PostgreSQL uses a transaction-scoped advisory lock; SQLite acquires its writer
|
||||
// lock without changing any row, including when the node table is empty.
|
||||
// All panel instances sharing this database must use this protocol; mixed old
|
||||
// binaries and out-of-band SQL writes are not protected by advisory locks.
|
||||
func lockPortAllocationTx(tx *gorm.DB) error {
|
||||
if tx.Dialector.Name() == "postgres" {
|
||||
return tx.Exec("SELECT pg_advisory_xact_lock(?)", int64(0x464c5658504f5254)).Error
|
||||
}
|
||||
if tx.Dialector.Name() == "sqlite" {
|
||||
return tx.Model(&model.Node{}).Where("1 = 0").UpdateColumn("id", gorm.Expr("id")).Error
|
||||
}
|
||||
return errors.New("unsupported database for atomic port allocation")
|
||||
}
|
||||
|
||||
// LockPortNodesTx must precede occupancy reads and reservation writes.
|
||||
func (r *Repository) LockPortNodesTx(tx *gorm.DB, ids []int64) error {
|
||||
if err := lockPortAllocationTx(tx); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, id := range ids {
|
||||
if id <= 0 {
|
||||
return errors.New("节点不存在")
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Repository) usedPortSetTx(tx *gorm.DB, nodeID, excludeForwardID, excludeTunnelID int64, excludeRuntimeIDs ...int64) (map[int]bool, error) {
|
||||
used := map[int]bool{}
|
||||
var ports []int
|
||||
if err := tx.Model(&model.ForwardPort{}).Where("node_id = ? AND forward_id <> ?", nodeID, excludeForwardID).Pluck("port", &ports).Error; err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, p := range ports {
|
||||
used[p] = true
|
||||
}
|
||||
query := tx.Model(&model.ChainTunnel{}).Where("node_id = ? AND port > 0", nodeID)
|
||||
if excludeTunnelID > 0 {
|
||||
query = query.Where("tunnel_id <> ?", excludeTunnelID)
|
||||
}
|
||||
if err := query.Pluck("port", &ports).Error; err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, p := range ports {
|
||||
used[p] = true
|
||||
}
|
||||
runtimeQuery := tx.Model(&model.PeerShareRuntime{}).Where("node_id = ? AND (status = 1 OR release_pending <> 0) AND port > 0", nodeID)
|
||||
if len(excludeRuntimeIDs) > 0 {
|
||||
runtimeQuery = runtimeQuery.Where("id <> ?", excludeRuntimeIDs[0])
|
||||
}
|
||||
if err := runtimeQuery.Pluck("port", &ports).Error; err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, p := range ports {
|
||||
used[p] = true
|
||||
}
|
||||
pending, err := r.PendingTunnelCleanupPortsTx(tx, nodeID, excludeTunnelID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, p := range pending {
|
||||
used[p] = true
|
||||
}
|
||||
return used, nil
|
||||
}
|
||||
|
||||
// Selection and insert must be in the same transaction after locking all nodes.
|
||||
func (r *Repository) selectForwardPortTx(tx *gorm.DB, ids []int64, requested int, excludeForwardID int64, sequential bool) (int, error) {
|
||||
if len(ids) == 0 {
|
||||
return 0, errors.New("隧道没有可用入口节点")
|
||||
}
|
||||
var common []int
|
||||
for i, id := range ids {
|
||||
var node model.Node
|
||||
if err := tx.Where("id = ?", id).First(&node).Error; err != nil {
|
||||
return 0, err
|
||||
}
|
||||
spec := strings.TrimSpace(node.Port)
|
||||
if spec == "" {
|
||||
spec = "1000-65535"
|
||||
if requested > 0 {
|
||||
spec = "1-65535"
|
||||
}
|
||||
}
|
||||
candidates := parsePortRangeSpec(spec)
|
||||
used, err := r.usedPortSetTx(tx, id, excludeForwardID, 0)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
var remote struct {
|
||||
Start int `json:"portRangeStart"`
|
||||
End int `json:"portRangeEnd"`
|
||||
}
|
||||
if node.IsRemote == 1 {
|
||||
_ = json.Unmarshal([]byte(node.RemoteConfig.String), &remote)
|
||||
}
|
||||
available := map[int]bool{}
|
||||
for _, p := range candidates {
|
||||
if p <= 65535 && !used[p] && (remote.Start <= 0 || remote.End <= 0 || (p >= remote.Start && p <= remote.End)) {
|
||||
available[p] = true
|
||||
}
|
||||
}
|
||||
if requested > 0 {
|
||||
if !available[requested] {
|
||||
return 0, errors.New("端口已占用或不在节点允许范围内")
|
||||
}
|
||||
continue
|
||||
}
|
||||
if i == 0 {
|
||||
for _, p := range candidates {
|
||||
if available[p] {
|
||||
common = append(common, p)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
filtered := common[:0]
|
||||
for _, p := range common {
|
||||
if available[p] {
|
||||
filtered = append(filtered, p)
|
||||
}
|
||||
}
|
||||
common = filtered
|
||||
}
|
||||
}
|
||||
if requested > 0 {
|
||||
return requested, nil
|
||||
}
|
||||
if len(common) == 0 {
|
||||
return 0, errors.New("节点端口已满,无可用端口")
|
||||
}
|
||||
if sequential {
|
||||
return common[0], nil
|
||||
}
|
||||
idx, err := rand.Int(rand.Reader, big.NewInt(int64(len(common))))
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return common[idx.Int64()], nil
|
||||
}
|
||||
|
||||
// checkPeerRuntimePortTx permits only a verified federation-forward attachment
|
||||
// to share its owning chain reservation. Other new reservations must be free.
|
||||
func (r *Repository) checkPeerRuntimePortTx(tx *gorm.DB, item *model.PeerShareRuntime) error {
|
||||
if item.Port <= 0 || (item.Status != 1 && item.ReleasePending == 0) {
|
||||
return nil
|
||||
}
|
||||
var ownedTunnel int64
|
||||
if item.Role == "forward" {
|
||||
var shareID, tunnelID int64
|
||||
var port int
|
||||
_, err := fmt.Sscanf(item.ResourceKey, "federation-forward-%d-%d-%d", &shareID, &tunnelID, &port)
|
||||
if err == nil && shareID == item.ShareID && port == item.Port && item.ResourceKey == fmt.Sprintf("federation-forward-%d-%d-%d", shareID, tunnelID, port) {
|
||||
var count int64
|
||||
if err := tx.Model(&model.ChainTunnel{}).Where("tunnel_id = ? AND node_id = ? AND port = ?", tunnelID, item.NodeID, item.Port).Count(&count).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
if count > 0 {
|
||||
ownedTunnel = tunnelID
|
||||
}
|
||||
}
|
||||
}
|
||||
used, err := r.usedPortSetTx(tx, item.NodeID, 0, ownedTunnel, item.ID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if used[item.Port] {
|
||||
return errors.New("端口已占用")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,326 @@
|
||||
package repo
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"net/url"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"go-backend/internal/store/model"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
func portTestCreate(r *Repository, port int, nodes ...int64) (int64, error) {
|
||||
return r.CreateForwardTx(1, "admin", "concurrent", 1, "127.0.0.1:80", "fifo", time.Now().UnixMilli(), 0, nodes, port, "", nil, 0, 0, nil, 0, 0, 0, true)
|
||||
}
|
||||
func TestAtomicPortAllocationAcrossRepositories(t *testing.T) {
|
||||
path := filepath.Join(t.TempDir(), "ports.db")
|
||||
a, err := Open(path)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer a.Close()
|
||||
b, err := Open(path)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer b.Close()
|
||||
runConcurrentPortAllocation(t, a, b)
|
||||
}
|
||||
|
||||
func runConcurrentPortAllocation(t *testing.T, a, b *Repository) {
|
||||
for _, id := range []int64{1, 2} {
|
||||
if err := a.db.Create(&model.Node{ID: id, Name: fmt.Sprint(id), Port: "20000-20031"}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
const count = 16
|
||||
start := make(chan struct{})
|
||||
errs := make(chan error, count)
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < count; i++ {
|
||||
wg.Add(1)
|
||||
go func(i int) {
|
||||
defer wg.Done()
|
||||
<-start
|
||||
r := a
|
||||
if i%2 == 1 {
|
||||
r = b
|
||||
}
|
||||
_, err := portTestCreate(r, 0, 1, 2)
|
||||
errs <- err
|
||||
}(i)
|
||||
}
|
||||
close(start)
|
||||
wg.Wait()
|
||||
close(errs)
|
||||
for err := range errs {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
var rows []model.ForwardPort
|
||||
if err := a.db.Order("port").Find(&rows).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(rows) != count*2 {
|
||||
t.Fatalf("got %d reservations", len(rows))
|
||||
}
|
||||
seen := map[string]bool{}
|
||||
for _, row := range rows {
|
||||
k := fmt.Sprintf("%d:%d", row.NodeID, row.Port)
|
||||
if seen[k] {
|
||||
t.Fatalf("duplicate %s", k)
|
||||
}
|
||||
seen[k] = true
|
||||
}
|
||||
explicitStart := make(chan struct{})
|
||||
explicitResults := make(chan error, 2)
|
||||
for _, r := range []*Repository{a, b} {
|
||||
go func(r *Repository) { <-explicitStart; _, err := portTestCreate(r, 20031, 1, 2); explicitResults <- err }(r)
|
||||
}
|
||||
close(explicitStart)
|
||||
success := 0
|
||||
for i := 0; i < 2; i++ {
|
||||
if <-explicitResults == nil {
|
||||
success++
|
||||
}
|
||||
}
|
||||
if success != 1 {
|
||||
t.Fatalf("explicit port race: %d successes, want exactly 1", success)
|
||||
}
|
||||
for p := 20000; p < 20000+count; p++ {
|
||||
for _, n := range []int{1, 2} {
|
||||
if !seen[fmt.Sprintf("%d:%d", n, p)] {
|
||||
t.Fatalf("gap at %d:%d", n, p)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
func TestAtomicPortAllocationRejectsConflictsAndExhaustion(t *testing.T) {
|
||||
r, err := Open(":memory:")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer r.Close()
|
||||
if err := r.db.Create(&model.Node{ID: 1, Port: "21000-21001"}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
id, err := portTestCreate(r, 21000, 1)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := portTestCreate(r, 21000, 1); err == nil {
|
||||
t.Fatal("explicit collision accepted")
|
||||
}
|
||||
if err := r.db.Transaction(func(tx *gorm.DB) error {
|
||||
return r.CreateChainTunnelTx(tx, 2, "2", 1, sql.NullInt64{Int64: 21000, Valid: true}, "", 0, "", "")
|
||||
}); err == nil {
|
||||
t.Fatal("chain collision accepted")
|
||||
}
|
||||
if _, err := portTestCreate(r, 0, 1); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := portTestCreate(r, 0, 1); err == nil {
|
||||
t.Fatal("exhausted range accepted")
|
||||
}
|
||||
entries := []struct {
|
||||
NodeID int64
|
||||
Port int
|
||||
InIP string
|
||||
}{{1, 21001, ""}}
|
||||
if err := r.ReplaceForwardPorts(id, entries, true); err == nil {
|
||||
t.Fatal("replacement collision accepted")
|
||||
}
|
||||
var old model.ForwardPort
|
||||
if err := r.db.Where("forward_id = ?", id).First(&old).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if old.Port != 21000 {
|
||||
t.Fatal("failed replacement lost original reservation")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAtomicPortAllocationPostgresAcrossRepositories(t *testing.T) {
|
||||
dsn := os.Getenv("FLVX_POSTGRES_TEST_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("set FLVX_POSTGRES_TEST_DSN for isolated PostgreSQL allocation test")
|
||||
}
|
||||
admin, err := sql.Open("pgx", dsn)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
schema := fmt.Sprintf("port_allocation_%d", time.Now().UnixNano())
|
||||
if _, err := admin.Exec("CREATE SCHEMA " + schema); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { admin.Exec("DROP SCHEMA " + schema + " CASCADE"); admin.Close() })
|
||||
scoped := dsn + " search_path=" + schema
|
||||
if strings.Contains(dsn, "://") {
|
||||
u, err := url.Parse(dsn)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
q := u.Query()
|
||||
q.Set("search_path", schema)
|
||||
u.RawQuery = q.Encode()
|
||||
scoped = u.String()
|
||||
}
|
||||
a, err := OpenPostgres(scoped)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer a.Close()
|
||||
b, err := OpenPostgres(scoped)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer b.Close()
|
||||
runConcurrentPortAllocation(t, a, b)
|
||||
}
|
||||
|
||||
func TestAtomicPortAllocationRespectsRangesAndPendingCleanup(t *testing.T) {
|
||||
r, err := Open(":memory:")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer r.Close()
|
||||
nodes := []model.Node{{ID: 1, Port: "23004,23000-23002", IsRemote: 1, RemoteConfig: sql.NullString{String: `{"portRangeStart":23001,"portRangeEnd":23004}`, Valid: true}}, {ID: 2, Port: "23001-23004"}}
|
||||
if err := r.db.Create(&nodes).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := r.db.Create(&model.TunnelRuntimeCleanup{TunnelID: 2, NodeID: 2, Kind: "service", Port: 23001}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
id, err := portTestCreate(r, 0, 1, 2)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := r.GetMinForwardPort(id).Int64; got != 23002 {
|
||||
t.Fatalf("got %d, want23002", got)
|
||||
}
|
||||
id2, err := portTestCreate(r, 0, 1, 2)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := r.GetMinForwardPort(id2).Int64; got != 23004 {
|
||||
t.Fatalf("got %d, want23004", got)
|
||||
}
|
||||
if err := r.DeleteForwardCascade(id); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
id3, err := portTestCreate(r, 0, 1, 2)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := r.GetMinForwardPort(id3).Int64; got != 23002 {
|
||||
t.Fatalf("released gap not reused: %d", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAtomicPortAllocationIndependentNewEntries(t *testing.T) {
|
||||
r, err := Open(":memory:")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer r.Close()
|
||||
if err := r.db.Create(&[]model.Node{{ID: 1, Port: "24000-24001"}, {ID: 2, Port: "25000-25001"}}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
entries := []struct {
|
||||
NodeID int64
|
||||
Port int
|
||||
InIP string
|
||||
}{{1, 0, ""}, {2, 0, ""}}
|
||||
if err := r.ReplaceForwardPortsIndividually(1, entries, true); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var rows []model.ForwardPort
|
||||
if err := r.db.Order("node_id").Find(&rows).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(rows) != 2 || rows[0].Port != 24000 || rows[1].Port != 25000 {
|
||||
t.Fatalf("unexpected independent allocation: %+v", rows)
|
||||
}
|
||||
if _, err := r.CreateFederationTunnel("conflict", 1, "tcp", 0, 1, 24000); err == nil {
|
||||
t.Fatal("federation collision accepted")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAtomicPortPeerRuntimeConflicts(t *testing.T) {
|
||||
path := filepath.Join(t.TempDir(), "mixed.db")
|
||||
a, err := Open(path)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer a.Close()
|
||||
b, err := Open(path)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer b.Close()
|
||||
if err := a.db.Create(&model.Node{ID: 1, Port: "25000-25010"}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runtime := func(key string, port int) *model.PeerShareRuntime {
|
||||
return &model.PeerShareRuntime{ShareID: 1, NodeID: 1, Port: port, ResourceKey: key, ReservationID: key, Status: 1}
|
||||
}
|
||||
start := make(chan struct{})
|
||||
results := make(chan error, 2)
|
||||
go func() { <-start; _, err := portTestCreate(a, 25000, 1); results <- err }()
|
||||
go func() { <-start; results <- b.CreatePeerShareRuntime(runtime("peer", 25000)) }()
|
||||
close(start)
|
||||
success := 0
|
||||
for i := 0; i < 2; i++ {
|
||||
if <-results == nil {
|
||||
success++
|
||||
}
|
||||
}
|
||||
if success != 1 {
|
||||
t.Fatalf("mixed reservation race succeeded %d times", success)
|
||||
}
|
||||
first := runtime("first", 25001)
|
||||
if err := a.CreatePeerShareRuntime(first); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := b.CreatePeerShareRuntime(runtime("second", 25001)); err == nil {
|
||||
t.Fatal("duplicate peer port accepted")
|
||||
}
|
||||
first.Role = "middle"
|
||||
first.Applied = 1
|
||||
if err := a.UpdatePeerShareRuntime(first); err != nil {
|
||||
t.Fatalf("own metadata update: %v", err)
|
||||
}
|
||||
owned := runtime("federation-forward-1-22-25002", 25002)
|
||||
owned.Role = "forward"
|
||||
if err := a.db.Transaction(func(tx *gorm.DB) error {
|
||||
return a.CreateChainTunnelTx(tx, 22, "1", 1, sql.NullInt64{Int64: 25002, Valid: true}, "fifo", 0, "tcp", "")
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := a.CreatePeerShareRuntime(runtime("federation-forward-1-22-25002", 25002)); err == nil {
|
||||
t.Fatal("generic spoof of ownership accepted")
|
||||
}
|
||||
if err := a.CreatePeerShareRuntime(owned); err != nil {
|
||||
t.Fatalf("valid attachment rejected: %v", err)
|
||||
}
|
||||
other := runtime("other-forward", 25002)
|
||||
other.Role = "forward"
|
||||
if err := b.CreatePeerShareRuntime(other); err == nil {
|
||||
t.Fatal("unowned forward attachment accepted")
|
||||
}
|
||||
pending := runtime("pending", 25003)
|
||||
pending.Status = 0
|
||||
pending.ReleasePending = 1
|
||||
if err := a.db.Create(pending).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := portTestCreate(b, 25003, 1); err == nil {
|
||||
t.Fatal("pending runtime reservation reused")
|
||||
}
|
||||
}
|
||||
@@ -7,6 +7,9 @@ import (
|
||||
)
|
||||
|
||||
func (r *Repository) QueueTunnelRuntimeCleanupTx(tx *gorm.DB, items []model.TunnelRuntimeCleanup) error {
|
||||
if err := lockPortAllocationTx(tx); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, item := range items {
|
||||
var node model.Node
|
||||
if err := tx.Select("id", "is_remote").Where("id = ?", item.NodeID).First(&node).Error; err != nil {
|
||||
|
||||
Reference in New Issue
Block a user