package wtclient import ( "container/list" "net" "sync" "github.com/lightningnetwork/lnd/watchtower/wtdb" ) // TowerCandidateIterator provides an abstraction for iterating through possible // watchtower addresses when attempting to create a new session. type TowerCandidateIterator interface { // AddCandidate adds a new candidate tower to the iterator. If the // candidate already exists, then any new addresses are added to it. AddCandidate(*wtdb.Tower) // RemoveCandidate removes an existing candidate tower from the // iterator. An optional address can be provided to indicate a stale // tower address to remove it. If it isn't provided, then the tower is // completely removed from the iterator. RemoveCandidate(wtdb.TowerID, net.Addr) // IsActive determines whether a given tower is exists within the // iterator. IsActive(wtdb.TowerID) bool // Reset clears any internal iterator state, making previously taken // candidates available as long as they remain in the set. Reset() error // Next returns the next candidate tower. The iterator is not required // to return results in any particular order. If no more candidates are // available, ErrTowerCandidatesExhausted is returned. Next() (*wtdb.Tower, error) } // towerListIterator is a linked-list backed TowerCandidateIterator. type towerListIterator struct { mu sync.Mutex queue *list.List nextCandidate *list.Element candidates map[wtdb.TowerID]*wtdb.Tower } // Compile-time constraint to ensure *towerListIterator implements the // TowerCandidateIterator interface. var _ TowerCandidateIterator = (*towerListIterator)(nil) // newTowerListIterator initializes a new towerListIterator from a variadic list // of lnwire.NetAddresses. func newTowerListIterator(candidates ...*wtdb.Tower) *towerListIterator { iter := &towerListIterator{ queue: list.New(), candidates: make(map[wtdb.TowerID]*wtdb.Tower), } for _, candidate := range candidates { iter.queue.PushBack(candidate.ID) iter.candidates[candidate.ID] = candidate } iter.Reset() return iter } // Reset clears the iterators state, and makes the address at the front of the // list the next item to be returned.. func (t *towerListIterator) Reset() error { t.mu.Lock() defer t.mu.Unlock() // Reset the next candidate to the front of the linked-list. t.nextCandidate = t.queue.Front() return nil } // Next returns the next candidate tower. This iterator will always return // candidates in the order given when the iterator was instantiated. If no more // candidates are available, ErrTowerCandidatesExhausted is returned. func (t *towerListIterator) Next() (*wtdb.Tower, error) { t.mu.Lock() defer t.mu.Unlock() for t.nextCandidate != nil { // Propose the tower at the front of the list. towerID := t.nextCandidate.Value.(wtdb.TowerID) // Check whether this tower is still considered a candidate. If // it's not, we'll proceed to the next. tower, ok := t.candidates[towerID] if !ok { nextCandidate := t.nextCandidate.Next() t.queue.Remove(t.nextCandidate) t.nextCandidate = nextCandidate continue } // Set the next candidate to the subsequent element. t.nextCandidate = t.nextCandidate.Next() return tower, nil } return nil, ErrTowerCandidatesExhausted } // AddCandidate adds a new candidate tower to the iterator. If the candidate // already exists, then any new addresses are added to it. func (t *towerListIterator) AddCandidate(candidate *wtdb.Tower) { t.mu.Lock() defer t.mu.Unlock() if tower, ok := t.candidates[candidate.ID]; !ok { t.queue.PushBack(candidate.ID) t.candidates[candidate.ID] = candidate // If we've reached the end of our queue, then this candidate // will become the next. if t.nextCandidate == nil { t.nextCandidate = t.queue.Back() } } else { for _, addr := range candidate.Addresses { tower.AddAddress(addr) } } } // RemoveCandidate removes an existing candidate tower from the iterator. An // optional address can be provided to indicate a stale tower address to remove // it. If it isn't provided, then the tower is completely removed from the // iterator. func (t *towerListIterator) RemoveCandidate(candidate wtdb.TowerID, addr net.Addr) { t.mu.Lock() defer t.mu.Unlock() tower, ok := t.candidates[candidate] if !ok { return } if addr != nil { tower.RemoveAddress(addr) } else { delete(t.candidates, candidate) } } // IsActive determines whether a given tower is exists within the iterator. func (t *towerListIterator) IsActive(tower wtdb.TowerID) bool { t.mu.Lock() defer t.mu.Unlock() _, ok := t.candidates[tower] return ok } // TODO(conner): implement graph-backed candidate iterator for public towers.