814 lines
22 KiB
Go
814 lines
22 KiB
Go
package netann_test
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/rand"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"io"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/btcsuite/btcd/btcec"
|
|
"github.com/btcsuite/btcd/wire"
|
|
"github.com/lightningnetwork/lnd/channeldb"
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
|
"github.com/lightningnetwork/lnd/netann"
|
|
)
|
|
|
|
// randOutpoint creates a random wire.Outpoint.
|
|
func randOutpoint(t *testing.T) wire.OutPoint {
|
|
t.Helper()
|
|
|
|
var buf [36]byte
|
|
_, err := io.ReadFull(rand.Reader, buf[:])
|
|
if err != nil {
|
|
t.Fatalf("unable to generate random outpoint: %v", err)
|
|
}
|
|
|
|
op := wire.OutPoint{}
|
|
copy(op.Hash[:], buf[:32])
|
|
op.Index = binary.BigEndian.Uint32(buf[32:])
|
|
|
|
return op
|
|
}
|
|
|
|
var shortChanIDs uint64
|
|
|
|
// createChannel generates a channeldb.OpenChannel with a random chanpoint and
|
|
// short channel id.
|
|
func createChannel(t *testing.T) *channeldb.OpenChannel {
|
|
t.Helper()
|
|
|
|
sid := atomic.AddUint64(&shortChanIDs, 1)
|
|
|
|
return &channeldb.OpenChannel{
|
|
ShortChannelID: lnwire.NewShortChanIDFromInt(sid),
|
|
ChannelFlags: lnwire.FFAnnounceChannel,
|
|
FundingOutpoint: randOutpoint(t),
|
|
}
|
|
}
|
|
|
|
// createEdgePolicies generates an edge info and two directional edge policies.
|
|
// The remote party's public key is generated randomly, and then sorted against
|
|
// our `pubkey` with the direction bit set appropriately in the policies. Our
|
|
// update will be created with the disabled bit set if startEnabled is false.
|
|
func createEdgePolicies(t *testing.T, channel *channeldb.OpenChannel,
|
|
pubkey *btcec.PublicKey, startEnabled bool) (*channeldb.ChannelEdgeInfo,
|
|
*channeldb.ChannelEdgePolicy, *channeldb.ChannelEdgePolicy) {
|
|
|
|
var (
|
|
pubkey1 [33]byte
|
|
pubkey2 [33]byte
|
|
dir1 lnwire.ChanUpdateChanFlags
|
|
dir2 lnwire.ChanUpdateChanFlags
|
|
)
|
|
|
|
// Set pubkey1 to OUR pubkey.
|
|
copy(pubkey1[:], pubkey.SerializeCompressed())
|
|
|
|
// Set the disabled bit appropriately on our update.
|
|
if !startEnabled {
|
|
dir1 |= lnwire.ChanUpdateDisabled
|
|
}
|
|
|
|
// Generate and set pubkey2 for THEIR pubkey.
|
|
privKey2, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Fatalf("unable to generate key pair: %v", err)
|
|
}
|
|
copy(pubkey2[:], privKey2.PubKey().SerializeCompressed())
|
|
|
|
// Set pubkey1 to the lower of the two pubkeys.
|
|
if bytes.Compare(pubkey2[:], pubkey1[:]) < 0 {
|
|
pubkey1, pubkey2 = pubkey2, pubkey1
|
|
dir1, dir2 = dir2, dir1
|
|
}
|
|
|
|
// Now that the ordering has been established, set pubkey2's direction
|
|
// bit.
|
|
dir2 |= lnwire.ChanUpdateDirection
|
|
|
|
return &channeldb.ChannelEdgeInfo{
|
|
ChannelPoint: channel.FundingOutpoint,
|
|
NodeKey1Bytes: pubkey1,
|
|
NodeKey2Bytes: pubkey2,
|
|
},
|
|
&channeldb.ChannelEdgePolicy{
|
|
ChannelID: channel.ShortChanID().ToUint64(),
|
|
ChannelFlags: dir1,
|
|
LastUpdate: time.Now(),
|
|
SigBytes: make([]byte, 64),
|
|
},
|
|
&channeldb.ChannelEdgePolicy{
|
|
ChannelID: channel.ShortChanID().ToUint64(),
|
|
ChannelFlags: dir2,
|
|
LastUpdate: time.Now(),
|
|
SigBytes: make([]byte, 64),
|
|
}
|
|
}
|
|
|
|
type mockGraph struct {
|
|
mu sync.Mutex
|
|
channels []*channeldb.OpenChannel
|
|
chanInfos map[wire.OutPoint]*channeldb.ChannelEdgeInfo
|
|
chanPols1 map[wire.OutPoint]*channeldb.ChannelEdgePolicy
|
|
chanPols2 map[wire.OutPoint]*channeldb.ChannelEdgePolicy
|
|
sidToCid map[lnwire.ShortChannelID]wire.OutPoint
|
|
|
|
updates chan *lnwire.ChannelUpdate
|
|
}
|
|
|
|
func newMockGraph(t *testing.T, numChannels int,
|
|
startActive, startEnabled bool, pubKey *btcec.PublicKey) *mockGraph {
|
|
|
|
g := &mockGraph{
|
|
channels: make([]*channeldb.OpenChannel, 0, numChannels),
|
|
chanInfos: make(map[wire.OutPoint]*channeldb.ChannelEdgeInfo),
|
|
chanPols1: make(map[wire.OutPoint]*channeldb.ChannelEdgePolicy),
|
|
chanPols2: make(map[wire.OutPoint]*channeldb.ChannelEdgePolicy),
|
|
sidToCid: make(map[lnwire.ShortChannelID]wire.OutPoint),
|
|
updates: make(chan *lnwire.ChannelUpdate, 2*numChannels),
|
|
}
|
|
|
|
for i := 0; i < numChannels; i++ {
|
|
c := createChannel(t)
|
|
|
|
info, pol1, pol2 := createEdgePolicies(
|
|
t, c, pubKey, startEnabled,
|
|
)
|
|
|
|
g.addChannel(c)
|
|
g.addEdgePolicy(c, info, pol1, pol2)
|
|
}
|
|
|
|
return g
|
|
}
|
|
|
|
func (g *mockGraph) FetchAllOpenChannels() ([]*channeldb.OpenChannel, error) {
|
|
return g.chans(), nil
|
|
}
|
|
|
|
func (g *mockGraph) FetchChannelEdgesByOutpoint(
|
|
op *wire.OutPoint) (*channeldb.ChannelEdgeInfo,
|
|
*channeldb.ChannelEdgePolicy, *channeldb.ChannelEdgePolicy, error) {
|
|
|
|
g.mu.Lock()
|
|
defer g.mu.Unlock()
|
|
|
|
info, ok := g.chanInfos[*op]
|
|
if !ok {
|
|
return nil, nil, nil, channeldb.ErrEdgeNotFound
|
|
}
|
|
|
|
pol1 := g.chanPols1[*op]
|
|
pol2 := g.chanPols2[*op]
|
|
|
|
return info, pol1, pol2, nil
|
|
}
|
|
|
|
func (g *mockGraph) ApplyChannelUpdate(update *lnwire.ChannelUpdate) error {
|
|
g.mu.Lock()
|
|
defer g.mu.Unlock()
|
|
|
|
outpoint, ok := g.sidToCid[update.ShortChannelID]
|
|
if !ok {
|
|
return fmt.Errorf("unknown short channel id: %v",
|
|
update.ShortChannelID)
|
|
}
|
|
|
|
pol1 := g.chanPols1[outpoint]
|
|
pol2 := g.chanPols2[outpoint]
|
|
|
|
// Determine which policy we should update by making the flags on the
|
|
// policies and updates, and seeing which match up.
|
|
var update1 bool
|
|
switch {
|
|
case update.ChannelFlags&lnwire.ChanUpdateDirection ==
|
|
pol1.ChannelFlags&lnwire.ChanUpdateDirection:
|
|
update1 = true
|
|
|
|
case update.ChannelFlags&lnwire.ChanUpdateDirection ==
|
|
pol2.ChannelFlags&lnwire.ChanUpdateDirection:
|
|
update1 = false
|
|
|
|
default:
|
|
return fmt.Errorf("unable to find policy to update")
|
|
}
|
|
|
|
timestamp := time.Unix(int64(update.Timestamp), 0)
|
|
|
|
policy := &channeldb.ChannelEdgePolicy{
|
|
ChannelID: update.ShortChannelID.ToUint64(),
|
|
ChannelFlags: update.ChannelFlags,
|
|
LastUpdate: timestamp,
|
|
SigBytes: make([]byte, 64),
|
|
}
|
|
|
|
if update1 {
|
|
g.chanPols1[outpoint] = policy
|
|
} else {
|
|
g.chanPols2[outpoint] = policy
|
|
}
|
|
|
|
// Send the update to network. This channel should be sufficiently
|
|
// buffered to avoid deadlocking.
|
|
g.updates <- update
|
|
|
|
return nil
|
|
}
|
|
|
|
func (g *mockGraph) chans() []*channeldb.OpenChannel {
|
|
g.mu.Lock()
|
|
defer g.mu.Unlock()
|
|
|
|
channels := make([]*channeldb.OpenChannel, 0, len(g.channels))
|
|
channels = append(channels, g.channels...)
|
|
|
|
return channels
|
|
}
|
|
|
|
func (g *mockGraph) addChannel(channel *channeldb.OpenChannel) {
|
|
g.mu.Lock()
|
|
defer g.mu.Unlock()
|
|
|
|
g.channels = append(g.channels, channel)
|
|
}
|
|
|
|
func (g *mockGraph) addEdgePolicy(c *channeldb.OpenChannel,
|
|
info *channeldb.ChannelEdgeInfo,
|
|
pol1, pol2 *channeldb.ChannelEdgePolicy) {
|
|
|
|
g.mu.Lock()
|
|
defer g.mu.Unlock()
|
|
|
|
g.chanInfos[c.FundingOutpoint] = info
|
|
g.chanPols1[c.FundingOutpoint] = pol1
|
|
g.chanPols2[c.FundingOutpoint] = pol2
|
|
g.sidToCid[c.ShortChanID()] = c.FundingOutpoint
|
|
}
|
|
|
|
func (g *mockGraph) removeChannel(channel *channeldb.OpenChannel) {
|
|
g.mu.Lock()
|
|
defer g.mu.Unlock()
|
|
|
|
for i, c := range g.channels {
|
|
if c.FundingOutpoint != channel.FundingOutpoint {
|
|
continue
|
|
}
|
|
|
|
g.channels = append(g.channels[:i], g.channels[i+1:]...)
|
|
delete(g.chanInfos, c.FundingOutpoint)
|
|
delete(g.chanPols1, c.FundingOutpoint)
|
|
delete(g.chanPols2, c.FundingOutpoint)
|
|
delete(g.sidToCid, c.ShortChanID())
|
|
return
|
|
}
|
|
}
|
|
|
|
type mockSwitch struct {
|
|
mu sync.Mutex
|
|
isActive map[lnwire.ChannelID]bool
|
|
}
|
|
|
|
func newMockSwitch() *mockSwitch {
|
|
return &mockSwitch{
|
|
isActive: make(map[lnwire.ChannelID]bool),
|
|
}
|
|
}
|
|
|
|
func (s *mockSwitch) HasActiveLink(chanID lnwire.ChannelID) bool {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
// If the link is found, we will returns it's active status. In the
|
|
// real switch, it returns EligibleToForward().
|
|
active, ok := s.isActive[chanID]
|
|
if ok {
|
|
return active
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func (s *mockSwitch) SetStatus(chanID lnwire.ChannelID, active bool) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
s.isActive[chanID] = active
|
|
}
|
|
|
|
func newManagerCfg(t *testing.T, numChannels int,
|
|
startEnabled bool) (*netann.ChanStatusConfig, *mockGraph, *mockSwitch) {
|
|
|
|
t.Helper()
|
|
|
|
privKey, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Fatalf("unable to generate key pair: %v", err)
|
|
}
|
|
|
|
graph := newMockGraph(
|
|
t, numChannels, startEnabled, startEnabled, privKey.PubKey(),
|
|
)
|
|
htlcSwitch := newMockSwitch()
|
|
|
|
cfg := &netann.ChanStatusConfig{
|
|
ChanStatusSampleInterval: 50 * time.Millisecond,
|
|
ChanEnableTimeout: 500 * time.Millisecond,
|
|
ChanDisableTimeout: time.Second,
|
|
OurPubKey: privKey.PubKey(),
|
|
MessageSigner: netann.NewNodeSigner(privKey),
|
|
IsChannelActive: htlcSwitch.HasActiveLink,
|
|
ApplyChannelUpdate: graph.ApplyChannelUpdate,
|
|
DB: graph,
|
|
Graph: graph,
|
|
}
|
|
|
|
return cfg, graph, htlcSwitch
|
|
}
|
|
|
|
type testHarness struct {
|
|
t *testing.T
|
|
numChannels int
|
|
graph *mockGraph
|
|
htlcSwitch *mockSwitch
|
|
mgr *netann.ChanStatusManager
|
|
ourPubKey *btcec.PublicKey
|
|
safeDisableTimeout time.Duration
|
|
}
|
|
|
|
// newHarness returns a new testHarness for testing a ChanStatusManager. The
|
|
// mockGraph will be populated with numChannels channels. The startActive and
|
|
// startEnabled govern the initial state of the channels wrt the htlcswitch and
|
|
// the network, respectively.
|
|
func newHarness(t *testing.T, numChannels int,
|
|
startActive, startEnabled bool) testHarness {
|
|
|
|
cfg, graph, htlcSwitch := newManagerCfg(t, numChannels, startEnabled)
|
|
|
|
mgr, err := netann.NewChanStatusManager(cfg)
|
|
if err != nil {
|
|
t.Fatalf("unable to create chan status manager: %v", err)
|
|
}
|
|
|
|
err = mgr.Start()
|
|
if err != nil {
|
|
t.Fatalf("unable to start chan status manager: %v", err)
|
|
}
|
|
|
|
h := testHarness{
|
|
t: t,
|
|
numChannels: numChannels,
|
|
graph: graph,
|
|
htlcSwitch: htlcSwitch,
|
|
mgr: mgr,
|
|
ourPubKey: cfg.OurPubKey,
|
|
safeDisableTimeout: (3 * cfg.ChanDisableTimeout) / 2, // 1.5x
|
|
}
|
|
|
|
// Initialize link status as requested.
|
|
if startActive {
|
|
h.markActive(h.graph.channels)
|
|
} else {
|
|
h.markInactive(h.graph.channels)
|
|
}
|
|
|
|
return h
|
|
}
|
|
|
|
// markActive updates the active status of the passed channels within the mock
|
|
// switch to active.
|
|
func (h *testHarness) markActive(channels []*channeldb.OpenChannel) {
|
|
h.t.Helper()
|
|
|
|
for _, channel := range channels {
|
|
chanID := lnwire.NewChanIDFromOutPoint(&channel.FundingOutpoint)
|
|
h.htlcSwitch.SetStatus(chanID, true)
|
|
}
|
|
}
|
|
|
|
// markInactive updates the active status of the passed channels within the mock
|
|
// switch to inactive.
|
|
func (h *testHarness) markInactive(channels []*channeldb.OpenChannel) {
|
|
h.t.Helper()
|
|
|
|
for _, channel := range channels {
|
|
chanID := lnwire.NewChanIDFromOutPoint(&channel.FundingOutpoint)
|
|
h.htlcSwitch.SetStatus(chanID, false)
|
|
}
|
|
}
|
|
|
|
// assertEnables requests enables for all of the passed channels, and asserts
|
|
// that the errors returned from RequestEnable matches expErr.
|
|
func (h *testHarness) assertEnables(channels []*channeldb.OpenChannel, expErr error) {
|
|
h.t.Helper()
|
|
|
|
for _, channel := range channels {
|
|
h.assertEnable(channel.FundingOutpoint, expErr)
|
|
}
|
|
}
|
|
|
|
// assertDisables requests disables for all of the passed channels, and asserts
|
|
// that the errors returned from RequestDisable matches expErr.
|
|
func (h *testHarness) assertDisables(channels []*channeldb.OpenChannel, expErr error) {
|
|
h.t.Helper()
|
|
|
|
for _, channel := range channels {
|
|
h.assertDisable(channel.FundingOutpoint, expErr)
|
|
}
|
|
}
|
|
|
|
// assertEnable requests an enable for the given outpoint, and asserts that the
|
|
// returned error matches expErr.
|
|
func (h *testHarness) assertEnable(outpoint wire.OutPoint, expErr error) {
|
|
h.t.Helper()
|
|
|
|
err := h.mgr.RequestEnable(outpoint)
|
|
if err != expErr {
|
|
h.t.Fatalf("expected enable error: %v, got %v", expErr, err)
|
|
}
|
|
}
|
|
|
|
// assertDisable requests a disable for the given outpoint, and asserts that the
|
|
// returned error matches expErr.
|
|
func (h *testHarness) assertDisable(outpoint wire.OutPoint, expErr error) {
|
|
h.t.Helper()
|
|
|
|
err := h.mgr.RequestDisable(outpoint)
|
|
if err != expErr {
|
|
h.t.Fatalf("expected disable error: %v, got %v", expErr, err)
|
|
}
|
|
}
|
|
|
|
// assertNoUpdates waits for the specified duration, and asserts that no updates
|
|
// are announced on the network.
|
|
func (h *testHarness) assertNoUpdates(duration time.Duration) {
|
|
h.t.Helper()
|
|
|
|
h.assertUpdates(nil, false, duration)
|
|
}
|
|
|
|
// assertUpdates waits for the specified duration, asserting that an update
|
|
// are receive on the network for each of the passed OpenChannels, and that all
|
|
// of their disable bits are set to match expEnabled. The expEnabled parameter
|
|
// is ignored if channels is nil.
|
|
func (h *testHarness) assertUpdates(channels []*channeldb.OpenChannel,
|
|
expEnabled bool, duration time.Duration) {
|
|
|
|
h.t.Helper()
|
|
|
|
// Compute an index of the expected short channel ids for which we want
|
|
// to received updates.
|
|
expSids := sidsFromChans(channels)
|
|
|
|
timeout := time.After(duration)
|
|
recvdSids := make(map[lnwire.ShortChannelID]struct{})
|
|
for {
|
|
select {
|
|
case upd := <-h.graph.updates:
|
|
// Assert that the received short channel id is one that
|
|
// we expect. If no updates were expected, this will
|
|
// always fail on the first update received.
|
|
if _, ok := expSids[upd.ShortChannelID]; !ok {
|
|
h.t.Fatalf("received update for unexpected "+
|
|
"short chan id: %v", upd.ShortChannelID)
|
|
}
|
|
|
|
// Assert that the disabled bit is set properly.
|
|
enabled := upd.ChannelFlags&lnwire.ChanUpdateDisabled !=
|
|
lnwire.ChanUpdateDisabled
|
|
if expEnabled != enabled {
|
|
h.t.Fatalf("expected enabled: %v, actual: %v",
|
|
expEnabled, enabled)
|
|
}
|
|
|
|
recvdSids[upd.ShortChannelID] = struct{}{}
|
|
|
|
case <-timeout:
|
|
// Time is up, assert that the correct number of unique
|
|
// updates was received.
|
|
if len(recvdSids) == len(channels) {
|
|
return
|
|
}
|
|
|
|
h.t.Fatalf("expected %d updates, got %d",
|
|
len(channels), len(recvdSids))
|
|
}
|
|
}
|
|
}
|
|
|
|
// sidsFromChans returns an index contain the short channel ids of each channel
|
|
// provided in the list of OpenChannels.
|
|
func sidsFromChans(
|
|
channels []*channeldb.OpenChannel) map[lnwire.ShortChannelID]struct{} {
|
|
|
|
sids := make(map[lnwire.ShortChannelID]struct{})
|
|
for _, channel := range channels {
|
|
sids[channel.ShortChanID()] = struct{}{}
|
|
}
|
|
return sids
|
|
}
|
|
|
|
type stateMachineTest struct {
|
|
name string
|
|
startEnabled bool
|
|
startActive bool
|
|
fn func(testHarness)
|
|
}
|
|
|
|
var stateMachineTests = []stateMachineTest{
|
|
{
|
|
name: "active and enabled is stable",
|
|
startActive: true,
|
|
startEnabled: true,
|
|
fn: func(h testHarness) {
|
|
// No updates should be sent because being active and
|
|
// enabled should be a stable state.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
},
|
|
},
|
|
{
|
|
name: "inactive and disabled is stable",
|
|
startActive: false,
|
|
startEnabled: false,
|
|
fn: func(h testHarness) {
|
|
// No updates should be sent because being inactive and
|
|
// disabled should be a stable state.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
},
|
|
},
|
|
{
|
|
name: "start disabled request enable",
|
|
startActive: true, // can't request enable unless active
|
|
startEnabled: false,
|
|
fn: func(h testHarness) {
|
|
// Request enables for all channels.
|
|
h.assertEnables(h.graph.chans(), nil)
|
|
// Expect to see them all enabled on the network.
|
|
h.assertUpdates(
|
|
h.graph.chans(), true, h.safeDisableTimeout,
|
|
)
|
|
},
|
|
},
|
|
{
|
|
name: "start enabled request disable",
|
|
startActive: true,
|
|
startEnabled: true,
|
|
fn: func(h testHarness) {
|
|
// Request disables for all channels.
|
|
h.assertDisables(h.graph.chans(), nil)
|
|
// Expect to see them all disabled on the network.
|
|
h.assertUpdates(
|
|
h.graph.chans(), false, h.safeDisableTimeout,
|
|
)
|
|
},
|
|
},
|
|
{
|
|
name: "request enable already enabled",
|
|
startActive: true,
|
|
startEnabled: true,
|
|
fn: func(h testHarness) {
|
|
// Request enables for already enabled channels.
|
|
h.assertEnables(h.graph.chans(), nil)
|
|
// Manager shouldn't send out any updates.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
},
|
|
},
|
|
{
|
|
name: "request disabled already disabled",
|
|
startActive: false,
|
|
startEnabled: false,
|
|
fn: func(h testHarness) {
|
|
// Request disables for already enabled channels.
|
|
h.assertDisables(h.graph.chans(), nil)
|
|
// Manager shouldn't sent out any updates.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
},
|
|
},
|
|
{
|
|
name: "detect and disable inactive",
|
|
startActive: true,
|
|
startEnabled: true,
|
|
fn: func(h testHarness) {
|
|
// Simulate disconnection and have links go inactive.
|
|
h.markInactive(h.graph.chans())
|
|
// Should see all channels passively disabled.
|
|
h.assertUpdates(
|
|
h.graph.chans(), false, h.safeDisableTimeout,
|
|
)
|
|
},
|
|
},
|
|
{
|
|
name: "quick flap stays active",
|
|
startActive: true,
|
|
startEnabled: true,
|
|
fn: func(h testHarness) {
|
|
// Simulate disconnection and have links go inactive.
|
|
h.markInactive(h.graph.chans())
|
|
// Allow 2 sample intervals to pass, but not long
|
|
// enough for a disable to occur.
|
|
time.Sleep(100 * time.Millisecond)
|
|
// Simulate reconnect by making channels active.
|
|
h.markActive(h.graph.chans())
|
|
// Request that all channels be reenabled.
|
|
h.assertEnables(h.graph.chans(), nil)
|
|
// Pending disable should have been canceled, and
|
|
// no updates sent. Channels remain enabled on the
|
|
// network.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
},
|
|
},
|
|
{
|
|
name: "no passive enable from becoming active",
|
|
startActive: false,
|
|
startEnabled: false,
|
|
fn: func(h testHarness) {
|
|
// Simulate reconnect by making channels active.
|
|
h.markActive(h.graph.chans())
|
|
// No updates should be sent without explicit enable.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
},
|
|
},
|
|
{
|
|
name: "enable inactive channel fails",
|
|
startActive: false,
|
|
startEnabled: false,
|
|
fn: func(h testHarness) {
|
|
// Request enable of inactive channels, expect error
|
|
// indicating that channel was not active.
|
|
h.assertEnables(
|
|
h.graph.chans(), netann.ErrEnableInactiveChan,
|
|
)
|
|
// No updates should be sent as a result of the failure.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
},
|
|
},
|
|
{
|
|
name: "enable unknown channel fails",
|
|
startActive: false,
|
|
startEnabled: false,
|
|
fn: func(h testHarness) {
|
|
// Create channels unknown to the graph.
|
|
unknownChans := []*channeldb.OpenChannel{
|
|
createChannel(h.t),
|
|
createChannel(h.t),
|
|
createChannel(h.t),
|
|
}
|
|
// Request that they be enabled, which should return an
|
|
// error as the graph doesn't have an edge for them.
|
|
h.assertEnables(
|
|
unknownChans, channeldb.ErrEdgeNotFound,
|
|
)
|
|
// No updates should be sent as a result of the failure.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
},
|
|
},
|
|
{
|
|
name: "disable unknown channel fails",
|
|
startActive: false,
|
|
startEnabled: false,
|
|
fn: func(h testHarness) {
|
|
// Create channels unknown to the graph.
|
|
unknownChans := []*channeldb.OpenChannel{
|
|
createChannel(h.t),
|
|
createChannel(h.t),
|
|
createChannel(h.t),
|
|
}
|
|
// Request that they be disabled, which should return an
|
|
// error as the graph doesn't have an edge for them.
|
|
h.assertDisables(
|
|
unknownChans, channeldb.ErrEdgeNotFound,
|
|
)
|
|
// No updates should be sent as a result of the failure.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
},
|
|
},
|
|
{
|
|
name: "add new channels",
|
|
startActive: false,
|
|
startEnabled: false,
|
|
fn: func(h testHarness) {
|
|
// Allow the manager to enter a steady state for the
|
|
// initial channel set.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
|
|
// Add a new channels to the graph, but don't yet add
|
|
// the edge policies. We should see no updates sent
|
|
// since the manager can't access the policies.
|
|
newChans := []*channeldb.OpenChannel{
|
|
createChannel(h.t),
|
|
createChannel(h.t),
|
|
createChannel(h.t),
|
|
}
|
|
for _, c := range newChans {
|
|
h.graph.addChannel(c)
|
|
}
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
|
|
// Check that trying to enable the channel with unknown
|
|
// edges results in a failure.
|
|
h.assertEnables(newChans, channeldb.ErrEdgeNotFound)
|
|
|
|
// Now, insert edge policies for the channel into the
|
|
// graph, starting with the channel enabled, and mark
|
|
// the link active.
|
|
for _, c := range newChans {
|
|
info, pol1, pol2 := createEdgePolicies(
|
|
h.t, c, h.ourPubKey, true,
|
|
)
|
|
h.graph.addEdgePolicy(c, info, pol1, pol2)
|
|
}
|
|
h.markActive(newChans)
|
|
|
|
// We expect no updates to be sent since the channel is
|
|
// enabled and active.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
|
|
// Finally, assert that enabling the channel doesn't
|
|
// return an error now that everything is in place.
|
|
h.assertEnables(newChans, nil)
|
|
},
|
|
},
|
|
{
|
|
name: "remove channels then disable",
|
|
startActive: true,
|
|
startEnabled: true,
|
|
fn: func(h testHarness) {
|
|
// Allow the manager to enter a steady state for the
|
|
// initial channel set.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
|
|
// Select half of the current channels to remove.
|
|
channels := h.graph.chans()
|
|
rmChans := channels[:len(channels)/2]
|
|
|
|
// Mark the channel inactive and remove them from the
|
|
// graph. This should trigger the manager to attempt a
|
|
// mark the channel disabled, but will unable to do so
|
|
// because it can't find the edge policies.
|
|
h.markInactive(rmChans)
|
|
for _, c := range rmChans {
|
|
h.graph.removeChannel(c)
|
|
}
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
|
|
// Check that trying to enable the channel with unknown
|
|
// edges results in a failure.
|
|
h.assertDisables(rmChans, channeldb.ErrEdgeNotFound)
|
|
},
|
|
},
|
|
{
|
|
name: "disable channels then remove",
|
|
startActive: true,
|
|
startEnabled: true,
|
|
fn: func(h testHarness) {
|
|
// Allow the manager to enter a steady state for the
|
|
// initial channel set.
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
|
|
// Select half of the current channels to remove.
|
|
channels := h.graph.chans()
|
|
rmChans := channels[:len(channels)/2]
|
|
|
|
// Check that trying to enable the channel with unknown
|
|
// edges results in a failure.
|
|
h.assertDisables(rmChans, nil)
|
|
|
|
// Since the channels are still in the graph, we expect
|
|
// these channels to be disabled on the network.
|
|
h.assertUpdates(rmChans, false, h.safeDisableTimeout)
|
|
|
|
// Finally, remove the channels from the graph and
|
|
// assert no more updates are sent.
|
|
for _, c := range rmChans {
|
|
h.graph.removeChannel(c)
|
|
}
|
|
h.assertNoUpdates(h.safeDisableTimeout)
|
|
},
|
|
},
|
|
}
|
|
|
|
// TestChanStatusManagerStateMachine tests the possible state transitions that
|
|
// can be taken by the ChanStatusManager.
|
|
func TestChanStatusManagerStateMachine(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, test := range stateMachineTests {
|
|
tc := test
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const numChannels = 10
|
|
h := newHarness(
|
|
t, numChannels, tc.startActive, tc.startEnabled,
|
|
)
|
|
defer h.mgr.Stop()
|
|
|
|
tc.fn(h)
|
|
})
|
|
}
|
|
}
|