Merge branch 'master' into accounts-sql-fix

Author: timrettop

CHANGELOG.md

@@ -1,3 +1,10 @@
+## 2.3.3 (2025-06-20)
+
+### Fixes
+
+- Prevent new v1 contracts from being formed post hardfork activation.
+- Prevent revising rejected contracts.
+
 ## 2.3.2 (2025-06-17)
 
 ### Fixes

api/api.go

@@ -57,7 +57,10 @@ type (
 		LastAnnouncement() (settings.Announcement, error)
 
 		UpdateDDNS(force bool) error
+	}
 
+	// Connectivity tests the host's connectivity to the network
+	Connectivity interface {
 		TestConnection(context.Context) (explorer.TestResult, bool, error)
 	}
 
@@ -170,15 +173,16 @@ type (
 
 		sqlite3Store SQLite3Store
 
-		syncer    Syncer
-		chain     ChainManager
-		accounts  AccountManager
-		contracts ContractManager
-		volumes   VolumeManager
-		wallet    Wallet
-		metrics   MetricManager
-		settings  Settings
-		index     Index
+		syncer       Syncer
+		chain        ChainManager
+		accounts     AccountManager
+		contracts    ContractManager
+		volumes      VolumeManager
+		wallet       Wallet
+		metrics      MetricManager
+		settings     Settings
+		connectivity Connectivity
+		index        Index
 
 		explorerDisabled bool
 		explorer         *explorer.Explorer

api/endpoints.go

@@ -749,7 +749,11 @@ func (a *api) handleDELETEWebhooks(jc jape.Context) {
 }
 
 func (a *api) handlePUTSystemConnectTest(jc jape.Context) {
-	result, _, err := a.settings.TestConnection(jc.Request.Context())
+	if a.connectivity == nil {
+		jc.Error(errors.New("connectivity test not enabled"), http.StatusBadRequest)
+		return
+	}
+	result, _, err := a.connectivity.TestConnection(jc.Request.Context())
 	if err != nil {
 		jc.Error(err, http.StatusInternalServerError)
 		return

api/options.go

@@ -18,6 +18,13 @@ func WithAlerts(al Alerts) ServerOption {
 	}
 }
 
+// WithConnectivity sets the connectivity manager for the API server.
+func WithConnectivity(c Connectivity) ServerOption {
+	return func(a *api) {
+		a.connectivity = c
+	}
+}
+
 // WithSQLite3Store sets the SQLite3 store for the API server.
 //
 // This option is not required since it is only used for backups and there

cmd/hostd/run.go

@@ -29,6 +29,7 @@ import (
 	"go.sia.tech/hostd/v2/certificates/providers/nomad"
 	"go.sia.tech/hostd/v2/config"
 	"go.sia.tech/hostd/v2/explorer"
+	"go.sia.tech/hostd/v2/explorer/connectivity"
 	"go.sia.tech/hostd/v2/host/accounts"
 	"go.sia.tech/hostd/v2/host/contracts"
 	"go.sia.tech/hostd/v2/host/registry"
@@ -610,13 +611,22 @@ func runRootCmd(ctx context.Context, cfg config.Config, walletKey types.PrivateK
 
 	if !cfg.Explorer.Disable {
 		apiOpts = append(apiOpts, api.WithExplorer(exp))
+
+		// enable price pinning
 		pm, err := pin.NewManager(store, sm, exp, pin.WithLogger(log.Named("pin")))
 		if err != nil {
 			return fmt.Errorf("failed to create pin manager: %w", err)
 		}
 		defer pm.Close()
 
-		apiOpts = append(apiOpts, api.WithPinnedSettings(pm))
+		// enable connectivity tests
+		connectivity, err := connectivity.NewManager(hostKey.PublicKey(), sm, exp, connectivity.WithLog(log.Named("connectivity")), connectivity.WithAlerts(am))
+		if err != nil {
+			return fmt.Errorf("failed to create connectivity manager: %w", err)
+		}
+		defer connectivity.Close()
+
+		apiOpts = append(apiOpts, api.WithPinnedSettings(pm), api.WithConnectivity(connectivity))
 	}
 	go version.RunVersionCheck(ctx, am, log.Named("version"))
 	web := http.Server{

explorer/connectivity/connectivity.go

@@ -0,0 +1,154 @@
+package connectivity
+
+import (
+	"context"
+	"math"
+	"time"
+
+	"go.sia.tech/core/types"
+	"go.sia.tech/coreutils/chain"
+	"go.sia.tech/hostd/v2/alerts"
+	"go.sia.tech/hostd/v2/explorer"
+	"go.sia.tech/hostd/v2/internal/threadgroup"
+	"go.uber.org/zap"
+)
+
+type (
+	// Explorer is an interface to run connectivity tests on an external
+	// service
+	Explorer interface {
+		TestConnection(ctx context.Context, host explorer.Host) (explorer.TestResult, error)
+	}
+
+	// Settings is an interface to access the host's settings, specifically
+	// the RHP4 net addresses.
+	Settings interface {
+		RHP4NetAddresses() []chain.NetAddress
+	}
+
+	// Alerts is an interface to register and dismiss alerts related to
+	// connectivity issues.
+	Alerts interface {
+		Register(alerts.Alert)
+		DismissCategory(category string)
+	}
+
+	// An Option is a functional option to configure the connectivity
+	// manager.
+	Option func(*Manager)
+
+	// Manager is a connectivity manager that periodically tests the host's
+	// connectivity to renters and registers alerts if the host is not
+	// reachable.
+	Manager struct {
+		hostKey types.PublicKey
+
+		tg       *threadgroup.ThreadGroup
+		alerts   Alerts
+		settings Settings
+		explorer Explorer
+		log      *zap.Logger
+
+		maxCheckInterval time.Duration
+		backoffFn        func(int) time.Duration
+	}
+)
+
+// Close stops the connectivity manager and cleans up any resources
+// it is using.
+func (m *Manager) Close() error {
+	m.tg.Stop()
+	return nil
+}
+
+// WithLog sets the logger for the connectivity manager.
+func WithLog(log *zap.Logger) Option {
+	return func(m *Manager) {
+		m.log = log
+	}
+}
+
+// WithAlerts sets the alerts manager for the connectivity manager.
+func WithAlerts(alerts Alerts) Option {
+	return func(m *Manager) {
+		m.alerts = alerts
+	}
+}
+
+// WithMaxCheckInterval sets the maximum interval between connectivity tests.
+// If the backoff function returns a longer duration, it will be clamped to
+// this value.
+//
+// The default value is 2 hours.
+func WithMaxCheckInterval(d time.Duration) Option {
+	return func(m *Manager) {
+		m.maxCheckInterval = d
+	}
+}
+
+// WithBackoff sets the backoff function for the connectivity manager.
+// The function should take the number of consecutive failures and return
+// the duration to wait before the next connectivity test.
+//
+// It will be clamped to the maximum check interval set by
+// WithMaxCheckInterval.
+func WithBackoff(fn func(failures int) time.Duration) Option {
+	return func(m *Manager) {
+		m.backoffFn = fn
+	}
+}
+
+// NewManager creates a new connectivity manager that periodically tests the
+// host's connectivity to renters.
+func NewManager(hostKey types.PublicKey, settings Settings, explorer Explorer, opts ...Option) (*Manager, error) {
+	m := &Manager{
+		hostKey: hostKey,
+
+		tg:       threadgroup.New(),
+		settings: settings,
+		explorer: explorer,
+		log:      zap.NewNop(),
+
+		maxCheckInterval: 2 * time.Hour,
+		backoffFn: func(failures int) time.Duration {
+			return time.Minute * time.Duration(math.Pow(2, float64(failures)))
+		},
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+
+	ctx, cancel, err := m.tg.AddContext(context.Background())
+	if err != nil {
+		return nil, err
+	}
+	go func() {
+		defer cancel()
+
+		var consecutiveFailures int
+		var nextTestTime time.Duration
+		for {
+			select {
+			case <-time.After(nextTestTime):
+				result, ok, err := m.TestConnection(context.Background())
+				if err != nil {
+					m.log.Error("failed to test connection", zap.Error(err))
+				} else {
+					m.log.Debug("connection test result", zap.Bool("ok", ok), zap.Any("result", result))
+				}
+
+				if !ok {
+					consecutiveFailures++
+					nextTestTime = min(m.maxCheckInterval, m.backoffFn(consecutiveFailures))
+				} else {
+					consecutiveFailures = 0
+					nextTestTime = m.maxCheckInterval
+				}
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+
+	return m, nil
+}