mirror of
https://github.com/luxfi/validators.git
synced 2026-10-30 15:13:53 +00:00
zeekay
66121f3229
Lux unifies subnet (validator-set) and chain identity into a single
ChainID — every chain identifies itself by its ChainID, no separate
'subnet identifier' needed.
Wire/interface changes (BREAKING — coordinated rollout):
- node/message/wire: ChainSubnetPair struct → ChainPingEntry; collapsed
duplicate SubnetId field; ChainSubnetPairs → ChainIds
- node/proto/zap/p2p: SubnetID → ChainID
- node/vms/chainadapter: ICPBlock/ICPSubnet SubnetID → ChainID
- validators/uptime: Calculator interface params subnetID → chainID
- consensus/core/router: Connected method param subnetID → chainID
- p2p/message: outbound_msg_builder var renames
Config/UI changes (cleanup):
- genesis/pkg/genesis ChainEntry: dropped redundant SubnetID field
- tui/views/ChainStatus: dropped redundant SubnetID field
- cli: comment cleanup
- benchmarks: deploy-subnets var rename
82 lines
2.1 KiB
Go
82 lines
2.1 KiB
Go
// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved.
|
|
// See the file LICENSE for licensing terms.
|
|
|
|
package uptime
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/luxfi/ids"
|
|
)
|
|
|
|
// LockedCalculator is a wrapper for a Calculator that ensures thread-safety
|
|
type LockedCalculator interface {
|
|
Calculator
|
|
}
|
|
|
|
// NewLockedCalculator returns a new LockedCalculator with default NoOp behavior
|
|
func NewLockedCalculator() LockedCalculator {
|
|
return &lockedCalculator{
|
|
calculators: make(map[ids.ID]Calculator),
|
|
fallback: NoOpCalculator{},
|
|
}
|
|
}
|
|
|
|
// NewLockedCalculatorWithFallback returns a new LockedCalculator with a custom fallback
|
|
func NewLockedCalculatorWithFallback(fallback Calculator) LockedCalculator {
|
|
if fallback == nil {
|
|
fallback = NoOpCalculator{}
|
|
}
|
|
return &lockedCalculator{
|
|
calculators: make(map[ids.ID]Calculator),
|
|
fallback: fallback,
|
|
}
|
|
}
|
|
|
|
type lockedCalculator struct {
|
|
mu sync.RWMutex
|
|
calculators map[ids.ID]Calculator
|
|
fallback Calculator
|
|
}
|
|
|
|
func (l *lockedCalculator) CalculateUptime(nodeID ids.NodeID, chainID ids.ID) (time.Duration, time.Duration, error) {
|
|
l.mu.RLock()
|
|
defer l.mu.RUnlock()
|
|
|
|
if calc, ok := l.calculators[chainID]; ok {
|
|
return calc.CalculateUptime(nodeID, chainID)
|
|
}
|
|
return l.fallback.CalculateUptime(nodeID, chainID)
|
|
}
|
|
|
|
func (l *lockedCalculator) CalculateUptimePercent(nodeID ids.NodeID, chainID ids.ID) (float64, error) {
|
|
l.mu.RLock()
|
|
defer l.mu.RUnlock()
|
|
|
|
if calc, ok := l.calculators[chainID]; ok {
|
|
return calc.CalculateUptimePercent(nodeID, chainID)
|
|
}
|
|
return l.fallback.CalculateUptimePercent(nodeID, chainID)
|
|
}
|
|
|
|
func (l *lockedCalculator) CalculateUptimePercentFrom(nodeID ids.NodeID, chainID ids.ID, from time.Time) (float64, error) {
|
|
l.mu.RLock()
|
|
defer l.mu.RUnlock()
|
|
|
|
if calc, ok := l.calculators[chainID]; ok {
|
|
return calc.CalculateUptimePercentFrom(nodeID, chainID, from)
|
|
}
|
|
return l.fallback.CalculateUptimePercentFrom(nodeID, chainID, from)
|
|
}
|
|
|
|
func (l *lockedCalculator) SetCalculator(chainID ids.ID, calc Calculator) error {
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
|
|
if calc != nil {
|
|
l.calculators[chainID] = calc
|
|
}
|
|
return nil
|
|
}
|