fix: protect shared rules across delivery and recovery (#560)

This commit is contained in:
sagit
2026-09-29 14:05:49 +08:00
committed by GitHub
parent 129fa0aa4c
commit c952d2fb3a
49 changed files with 5053 additions and 643 deletions
@@ -0,0 +1,15 @@
package model
// FederationPendingRelease keeps rollback work after a failed remote release.
// It is independent of tunnels, which may never have committed or be deleted.
type FederationPendingRelease struct {
ID string `gorm:"primaryKey;size:64"`
RemoteURL string `gorm:"not null"`
RemoteToken string `gorm:"not null"`
BindingID string
ReservationID string
ResourceKey string
CreatedTime int64
}
func (FederationPendingRelease) TableName() string { return "federation_pending_release" }
+38 -17
View File
@@ -354,23 +354,24 @@ type PeerShare struct {
func (PeerShare) TableName() string { return "peer_share" }
type PeerShareRuntime struct {
ID int64 `gorm:"primaryKey;autoIncrement"`
ShareID int64 `gorm:"column:share_id;not null;index:idx_peer_share_runtime_share_node_status"`
NodeID int64 `gorm:"column:node_id;not null;index:idx_peer_share_runtime_share_node_status"`
ReservationID string `gorm:"column:reservation_id;type:text;not null;uniqueIndex"`
ResourceKey string `gorm:"column:resource_key;type:text;not null;uniqueIndex"`
BindingID string `gorm:"column:binding_id;type:text;not null;default:'';index:idx_peer_share_runtime_binding_id"`
Role string `gorm:"type:text;not null;default:''"`
ChainName string `gorm:"column:chain_name;type:text;not null;default:''"`
ServiceName string `gorm:"column:service_name;type:text;not null;default:''"`
Protocol string `gorm:"type:text;not null;default:'tls'"`
Strategy string `gorm:"type:text;not null;default:'round'"`
Port int `gorm:"not null;default:0"`
Target string `gorm:"type:text;not null;default:''"`
Applied int `gorm:"not null;default:0"`
Status int `gorm:"not null;default:1;index:idx_peer_share_runtime_share_node_status"`
CreatedTime int64 `gorm:"column:created_time;not null"`
UpdatedTime int64 `gorm:"column:updated_time;not null"`
ID int64 `gorm:"primaryKey;autoIncrement"`
ShareID int64 `gorm:"column:share_id;not null;index:idx_peer_share_runtime_share_node_status"`
NodeID int64 `gorm:"column:node_id;not null;index:idx_peer_share_runtime_share_node_status"`
ReservationID string `gorm:"column:reservation_id;type:text;not null;uniqueIndex"`
ResourceKey string `gorm:"column:resource_key;type:text;not null;uniqueIndex"`
BindingID string `gorm:"column:binding_id;type:text;not null;default:'';index:idx_peer_share_runtime_binding_id"`
Role string `gorm:"type:text;not null;default:''"`
ChainName string `gorm:"column:chain_name;type:text;not null;default:''"`
ServiceName string `gorm:"column:service_name;type:text;not null;default:''"`
Protocol string `gorm:"type:text;not null;default:'tls'"`
Strategy string `gorm:"type:text;not null;default:'round'"`
Port int `gorm:"not null;default:0"`
Target string `gorm:"type:text;not null;default:''"`
Applied int `gorm:"not null;default:0"`
ReleasePending int `gorm:"column:release_pending;not null;default:0"`
Status int `gorm:"not null;default:1;index:idx_peer_share_runtime_share_node_status"`
CreatedTime int64 `gorm:"column:created_time;not null"`
UpdatedTime int64 `gorm:"column:updated_time;not null"`
}
func (PeerShareRuntime) TableName() string { return "peer_share_runtime" }
@@ -816,3 +817,23 @@ type TunnelQuality struct {
}
func (TunnelQuality) TableName() string { return "tunnel_quality" }
// PeerShareResource is the durable desired state for a namespaced peer command.
// Rows are retained as tombstones until deletion has been acknowledged.
type PeerShareResource struct {
ID int64 `gorm:"primaryKey;autoIncrement"`
ShareID int64 `gorm:"column:share_id;not null;uniqueIndex:idx_peer_share_resource_key"`
NodeID int64 `gorm:"column:node_id;not null;index"`
Kind string `gorm:"type:text;not null;uniqueIndex:idx_peer_share_resource_key"`
OriginalName string `gorm:"column:original_name;type:text;not null;uniqueIndex:idx_peer_share_resource_key"`
RuntimeName string `gorm:"column:runtime_name;type:text;not null;index"`
LegacyNames string `gorm:"column:legacy_names;type:text;not null;default:''"`
LegacyServiceBase string `gorm:"column:legacy_service_base;type:text;not null;default:''"`
ReleaseLegacyFamily bool `gorm:"column:release_legacy_family;not null;default:false"`
Config string `gorm:"type:text;not null;default:''"`
DesiredState string `gorm:"column:desired_state;type:text;not null;default:'active'"`
Applied int `gorm:"not null;default:0"`
UpdatedTime int64 `gorm:"column:updated_time;not null"`
}
func (PeerShareResource) TableName() string { return "peer_share_resource" }
@@ -0,0 +1,55 @@
package repo
import (
"errors"
"go-backend/internal/store/model"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
func (r *Repository) SavePeerShareResources(items []PeerShareResource) error {
if r == nil || r.db == nil {
return errors.New("repository not initialized")
}
if len(items) == 0 {
return nil
}
return r.db.Transaction(func(tx *gorm.DB) error {
for i := range items {
if err := tx.Clauses(clause.OnConflict{Columns: []clause.Column{{Name: "share_id"}, {Name: "kind"}, {Name: "original_name"}}, DoUpdates: clause.AssignmentColumns([]string{"node_id", "runtime_name", "legacy_names", "legacy_service_base", "release_legacy_family", "config", "desired_state", "applied", "updated_time"})}).Create(&items[i]).Error; err != nil {
return err
}
}
return nil
})
}
func (r *Repository) GetPeerShareResource(shareID int64, kind, originalName string) (*PeerShareResource, error) {
var item model.PeerShareResource
err := r.db.Where("share_id = ? AND kind = ? AND original_name = ?", shareID, kind, originalName).First(&item).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
}
return &item, err
}
func (r *Repository) ListPeerShareResourcesByNode(nodeID int64) ([]PeerShareResource, error) {
var items []PeerShareResource
err := r.db.Where("node_id = ?", nodeID).Order("id").Find(&items).Error
return items, err
}
func (r *Repository) MarkPeerShareResourceApplied(shareID int64, kind, name string) error {
return r.db.Model(&model.PeerShareResource{}).Where("share_id = ? AND kind = ? AND original_name = ?", shareID, kind, name).Update("applied", 1).Error
}
func (r *Repository) ClearPeerShareResourceLegacyNames(shareID int64, kind, name string) error {
return r.db.Model(&model.PeerShareResource{}).Where("share_id = ? AND kind = ? AND original_name = ?", shareID, kind, name).Update("legacy_names", "").Error
}
func (r *Repository) WithPeerShareResourceTransaction(fn func(*Repository) error) error {
return r.db.Transaction(func(tx *gorm.DB) error { return fn(&Repository{db: tx, dbPath: r.dbPath}) })
}
func (r *Repository) ClearPeerShareResourceLegacyFamily(shareID int64, base string) error {
return r.db.Model(&model.PeerShareResource{}).Where("share_id = ? AND legacy_service_base = ?", shareID, base).Update("legacy_service_base", "").Error
}
@@ -0,0 +1,32 @@
package repo
import (
"errors"
"go-backend/internal/store/model"
"time"
)
// A pending release remains active until the agent acknowledges deletion. This
// keeps its port reserved even if the control connection is unavailable.
func (r *Repository) SetPeerShareRuntimeReleasePending(id int64) error {
if r == nil || r.db == nil {
return errors.New("repository not initialized")
}
return r.db.Model(&model.PeerShareRuntime{}).Where("id = ? AND status = 1", id).Updates(map[string]interface{}{"release_pending": 1, "updated_time": time.Now().UnixMilli()}).Error
}
func (r *Repository) CompletePeerShareRuntimeRelease(id int64) error {
if r == nil || r.db == nil {
return errors.New("repository not initialized")
}
return r.db.Model(&model.PeerShareRuntime{}).Where("id = ?", id).Updates(map[string]interface{}{"status": 0, "applied": 0, "release_pending": 0, "updated_time": time.Now().UnixMilli()}).Error
}
func (r *Repository) ListActivePeerShareRuntimesByNode(nodeID int64) ([]model.PeerShareRuntime, error) {
if r == nil || r.db == nil {
return nil, errors.New("repository not initialized")
}
var items []model.PeerShareRuntime
err := r.db.Where("node_id = ? AND status = 1", nodeID).Order("release_pending DESC, id ASC").Find(&items).Error
return items, err
}
+17 -24
View File
@@ -43,6 +43,7 @@ type UserForwardDetail = model.UserForwardDetail
type StatisticsFlow = model.StatisticsFlow
type Node = model.Node
type PeerShare = model.PeerShare
type PeerShareResource = model.PeerShareResource
type PeerShareRuntime = model.PeerShareRuntime
type FederationTunnelBinding = model.FederationTunnelBinding
type BackupData = model.BackupData
@@ -309,7 +310,9 @@ func autoMigrateAll(db *gorm.DB) error {
&model.ViteConfig{},
&model.PeerShare{},
&model.PeerShareRuntime{},
&model.PeerShareResource{},
&model.FederationTunnelBinding{},
&model.FederationPendingRelease{},
&model.Announcement{},
&model.SchemaVersion{},
&model.NodeMetric{},
@@ -1514,7 +1517,12 @@ func (r *Repository) DeletePeerShare(id int64) error {
return errors.New("repository not initialized")
}
return r.db.Transaction(func(tx *gorm.DB) error {
tx.Where("share_id = ?", id).Delete(&model.PeerShareRuntime{})
if err := tx.Where("share_id = ?", id).Delete(&model.PeerShareRuntime{}).Error; err != nil {
return err
}
if err := tx.Where("share_id = ?", id).Delete(&model.PeerShareResource{}).Error; err != nil {
return err
}
return tx.Where("id = ?", id).Delete(&model.PeerShare{}).Error
})
}
@@ -1607,7 +1615,8 @@ func (r *Repository) UpdatePeerShareRuntime(item *model.PeerShareRuntime) error
return errors.New("runtime item is nil")
}
return r.db.Model(&model.PeerShareRuntime{}).Where("id = ?", item.ID).Updates(map[string]interface{}{
"binding_id": item.BindingID, "role": item.Role,
"reservation_id": item.ReservationID,
"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,
@@ -1755,35 +1764,19 @@ func (r *Repository) ListActiveForwardPeerShareRuntimesByNodeAndServiceName(node
return items, nil
}
func (r *Repository) ListActiveForwardPeerShareRuntimeServiceNamesByNode(nodeID int64) ([]string, error) {
func (r *Repository) ListActiveForwardPeerShareRuntimesByNode(nodeID int64) ([]model.PeerShareRuntime, error) {
if r == nil || r.db == nil {
return nil, errors.New("repository not initialized")
}
var names []string
err := r.db.Model(&model.PeerShareRuntime{}).
Where("node_id = ? AND status = 1 AND role = ? AND service_name <> ''", nodeID, "forward").
Pluck("service_name", &names).Error
var items []model.PeerShareRuntime
err := r.db.Where("node_id = ? AND status = 1 AND role = ?", nodeID, "forward").Find(&items).Error
if err != nil {
return nil, err
}
if names == nil {
names = make([]string, 0)
if items == nil {
items = make([]model.PeerShareRuntime, 0)
}
return names, nil
}
func (r *Repository) HasRecentUnboundForwardPeerShareRuntimeOnNode(nodeID int64, minUpdatedTime int64) (bool, error) {
if r == nil || r.db == nil {
return false, errors.New("repository not initialized")
}
var count int64
err := r.db.Model(&model.PeerShareRuntime{}).
Where("node_id = ? AND status = 1 AND role = ? AND applied = 0 AND updated_time >= ? AND (service_name = '' OR service_name IS NULL)", nodeID, "forward", minUpdatedTime).
Count(&count).Error
if err != nil {
return false, err
}
return count > 0, nil
return items, nil
}
func (r *Repository) GetActiveForwardPeerShareRuntimeByPort(shareID int64, port int) (*model.PeerShareRuntime, error) {
@@ -0,0 +1,55 @@
package repo
import (
"crypto/sha256"
"fmt"
"go-backend/internal/store/model"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
const FederationBindingPendingRelease = 2
func (r *Repository) ListTunnelChainNodeIDsTx(tx *gorm.DB, tunnelID int64) ([]int64, error) {
var ids []int64
err := tx.Model(&model.ChainTunnel{}).Where("tunnel_id = ?", tunnelID).Pluck("node_id", &ids).Error
return ids, err
}
func (r *Repository) ListFederationTunnelBindingsForCleanup(tunnelID int64) ([]model.FederationTunnelBinding, error) {
var rows []model.FederationTunnelBinding
err := r.db.Where("tunnel_id = ? AND status IN ?", tunnelID, []int{1, FederationBindingPendingRelease}).Order("id").Find(&rows).Error
return rows, err
}
func (r *Repository) ListPendingFederationTunnelBindings() ([]model.FederationTunnelBinding, error) {
var rows []model.FederationTunnelBinding
err := r.db.Where("status = ?", FederationBindingPendingRelease).Order("id").Find(&rows).Error
return rows, err
}
func (r *Repository) MarkFederationTunnelBindingPendingRelease(id int64) error {
return r.db.Model(&model.FederationTunnelBinding{}).Where("id = ?", id).
Updates(map[string]interface{}{"status": FederationBindingPendingRelease, "updated_time": unixMilliNow()}).Error
}
func (r *Repository) DeleteFederationTunnelBinding(id int64) error {
return r.db.Where("id = ?", id).Delete(&model.FederationTunnelBinding{}).Error
}
func (r *Repository) SavePendingFederationRelease(item *model.FederationPendingRelease) error {
item.ID = fmt.Sprintf("%x", sha256.Sum256([]byte(item.RemoteURL+"\n"+item.BindingID+"\n"+item.ReservationID+"\n"+item.ResourceKey)))
item.CreatedTime = unixMilliNow()
return r.db.Clauses(clause.OnConflict{DoNothing: true}).Create(item).Error
}
func (r *Repository) ListPendingFederationReleases() ([]model.FederationPendingRelease, error) {
var rows []model.FederationPendingRelease
err := r.db.Order("created_time, id").Find(&rows).Error
return rows, err
}
func (r *Repository) DeletePendingFederationRelease(id string) error {
return r.db.Where("id = ?", id).Delete(&model.FederationPendingRelease{}).Error
}
@@ -0,0 +1,35 @@
package repo
import (
"sort"
"go-backend/internal/store/model"
)
// Only retry unfinished operations. Successful desired state must be replayed
// on a real reconnect, not every maintenance tick while the agent stays online.
func (r *Repository) ListPendingPeerShareNodeIDs() ([]int64, error) {
var resourceNodes, runtimeNodes []int64
if err := r.db.Model(&model.PeerShareResource{}).Where("applied = 0").Distinct("node_id").Pluck("node_id", &resourceNodes).Error; err != nil {
return nil, err
}
if err := r.db.Model(&model.PeerShareRuntime{}).
Where("status = 1 AND (release_pending <> 0 OR (applied = 0 AND service_name <> '' AND role IN ?))", []string{"middle", "exit"}).
Distinct("node_id").Pluck("node_id", &runtimeNodes).Error; err != nil {
return nil, err
}
seen := make(map[int64]struct{})
for _, ids := range [][]int64{resourceNodes, runtimeNodes} {
for _, id := range ids {
if id > 0 {
seen[id] = struct{}{}
}
}
}
out := make([]int64, 0, len(seen))
for id := range seen {
out = append(out, id)
}
sort.Slice(out, func(i, j int) bool { return out[i] < out[j] })
return out, nil
}