frostfs-node/pkg/innerring/indexer.go
Evgenii Stratonikov 9f7c2d8810
All checks were successful
DCO action / DCO (pull_request) Successful in 3m0s
Vulncheck / Vulncheck (pull_request) Successful in 3m10s
Build / Build Components (1.20) (pull_request) Successful in 4m3s
Build / Build Components (1.21) (pull_request) Successful in 4m8s
Tests and linters / Staticcheck (pull_request) Successful in 5m13s
Tests and linters / Lint (pull_request) Successful in 5m44s
Tests and linters / Tests (1.20) (pull_request) Successful in 7m0s
Tests and linters / Tests (1.21) (pull_request) Successful in 7m7s
Tests and linters / Tests with -race (pull_request) Successful in 7m50s
[#752] innerring: Simplify keyPosition()
Signed-off-by: Evgenii Stratonikov <e.stratonikov@yadro.com>
2023-10-25 16:06:44 +03:00

120 lines
2.2 KiB
Go

package innerring
import (
"fmt"
"sync"
"time"
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
)
type (
irFetcher interface {
InnerRingKeys() (keys.PublicKeys, error)
}
committeeFetcher interface {
Committee() (keys.PublicKeys, error)
}
innerRingIndexer struct {
sync.RWMutex
irFetcher irFetcher
commFetcher committeeFetcher
key *keys.PublicKey
timeout time.Duration
ind indexes
lastAccess time.Time
}
indexes struct {
innerRingIndex, innerRingSize int32
alphabetIndex int32
}
)
func newInnerRingIndexer(comf committeeFetcher, irf irFetcher, key *keys.PublicKey, to time.Duration) *innerRingIndexer {
return &innerRingIndexer{
irFetcher: irf,
commFetcher: comf,
key: key,
timeout: to,
}
}
func (s *innerRingIndexer) update() (ind indexes, err error) {
s.RLock()
if time.Since(s.lastAccess) < s.timeout {
s.RUnlock()
return s.ind, nil
}
s.RUnlock()
s.Lock()
defer s.Unlock()
if time.Since(s.lastAccess) < s.timeout {
return s.ind, nil
}
innerRing, err := s.irFetcher.InnerRingKeys()
if err != nil {
return indexes{}, err
}
s.ind.innerRingIndex = keyPosition(s.key, innerRing)
s.ind.innerRingSize = int32(len(innerRing))
alphabet, err := s.commFetcher.Committee()
if err != nil {
return indexes{}, err
}
s.ind.alphabetIndex = keyPosition(s.key, alphabet)
s.lastAccess = time.Now()
return s.ind, nil
}
func (s *innerRingIndexer) InnerRingIndex() (int32, error) {
ind, err := s.update()
if err != nil {
return 0, fmt.Errorf("can't update index state: %w", err)
}
return ind.innerRingIndex, nil
}
func (s *innerRingIndexer) InnerRingSize() (int32, error) {
ind, err := s.update()
if err != nil {
return 0, fmt.Errorf("can't update index state: %w", err)
}
return ind.innerRingSize, nil
}
func (s *innerRingIndexer) AlphabetIndex() (int32, error) {
ind, err := s.update()
if err != nil {
return 0, fmt.Errorf("can't update index state: %w", err)
}
return ind.alphabetIndex, nil
}
// keyPosition returns "-1" if key is not found in the list, otherwise returns
// index of the key.
func keyPosition(key *keys.PublicKey, list keys.PublicKeys) int32 {
for i := range list {
if key.Equal(list[i]) {
return int32(i)
}
}
return -1
}