11216766535

Committed 07 Oct 2024 01:37PM UTC coverage: 57.817% (-1.0%) from 58.817%

Build # 11216766535

Build Type

Pull #9148

github

Committed by

ProofOfKeags

Commit Message

lnwire: remove kickoff feerate from propose/commit

Pull Request Pull Request #9148: DynComms [2/n]: lnwire: add authenticated wire messages for Dyn*

Run Details

571 of 879 new or added lines in 16 files covered. (64.96%)

23253 existing lines in 251 files now uncovered.

99022 of 171268 relevant lines covered (57.82%)

38420.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

30.49

/channelnotifier/channelnotifier.go

package channelnotifier

import (
        "sync"

        "github.com/btcsuite/btcd/wire"
        "github.com/lightningnetwork/lnd/channeldb"
        "github.com/lightningnetwork/lnd/subscribe"
)

// ChannelNotifier is a subsystem which all active, inactive, and closed channel
// events pipe through. It takes subscriptions for its events, and whenever
// it receives a new event it notifies its subscribers over the proper channel.
type ChannelNotifier struct {
        started sync.Once
        stopped sync.Once

        ntfnServer *subscribe.Server

        chanDB *channeldb.ChannelStateDB
}

// PendingOpenChannelEvent represents a new event where a new channel has
// entered a pending open state.
type PendingOpenChannelEvent struct {
        // ChannelPoint is the channel outpoint for the new channel.
        ChannelPoint *wire.OutPoint

        // PendingChannel is the channel configuration for the newly created
        // channel. This might not have been persisted to the channel DB yet
        // because we are still waiting for the final message from the remote
        // peer.
        PendingChannel *channeldb.OpenChannel
}

// OpenChannelEvent represents a new event where a channel goes from pending
// open to open.
type OpenChannelEvent struct {
        // Channel is the channel that has become open.
        Channel *channeldb.OpenChannel
}

// ActiveLinkEvent represents a new event where the link becomes active in the
// switch. This happens before the ActiveChannelEvent.
type ActiveLinkEvent struct {
        // ChannelPoint is the channel point for the newly active channel.
        ChannelPoint *wire.OutPoint
}

// InactiveLinkEvent represents a new event where the link becomes inactive in
// the switch.
type InactiveLinkEvent struct {
        // ChannelPoint is the channel point for the inactive channel.
        ChannelPoint *wire.OutPoint
}

// ActiveChannelEvent represents a new event where a channel becomes active.
type ActiveChannelEvent struct {
        // ChannelPoint is the channelpoint for the newly active channel.
        ChannelPoint *wire.OutPoint
}

// InactiveChannelEvent represents a new event where a channel becomes inactive.
type InactiveChannelEvent struct {
        // ChannelPoint is the channelpoint for the newly inactive channel.
        ChannelPoint *wire.OutPoint
}

// ClosedChannelEvent represents a new event where a channel becomes closed.
type ClosedChannelEvent struct {
        // CloseSummary is the summary of the channel close that has occurred.
        CloseSummary *channeldb.ChannelCloseSummary
}

// FullyResolvedChannelEvent represents a new event where a channel becomes
// fully resolved.
type FullyResolvedChannelEvent struct {
        // ChannelPoint is the channelpoint for the newly fully resolved
        // channel.
        ChannelPoint *wire.OutPoint
}

// New creates a new channel notifier. The ChannelNotifier gets channel
// events from peers and from the chain arbitrator, and dispatches them to
// its clients.
func New(chanDB *channeldb.ChannelStateDB) *ChannelNotifier {
        return &ChannelNotifier{
                ntfnServer: subscribe.NewServer(),
                chanDB:     chanDB,
        }
}

// Start starts the ChannelNotifier and all goroutines it needs to carry out its task.
func (c *ChannelNotifier) Start() error {
        var err error
        c.started.Do(func() {
                log.Info("ChannelNotifier starting")
                err = c.ntfnServer.Start()
        })
        return err
}

// Stop signals the notifier for a graceful shutdown.
func (c *ChannelNotifier) Stop() error {
        var err error
        c.stopped.Do(func() {
                log.Info("ChannelNotifier shutting down...")
                defer log.Debug("ChannelNotifier shutdown complete")

                err = c.ntfnServer.Stop()
        })
        return err
}

// SubscribeChannelEvents returns a subscribe.Client that will receive updates
// any time the Server is made aware of a new event. The subscription provides
// channel events from the point of subscription onwards.
//
// TODO(carlaKC): update  to allow subscriptions to specify a block height from
// which we would like to subscribe to events.
func (c *ChannelNotifier) SubscribeChannelEvents() (*subscribe.Client, error) {
        return c.ntfnServer.Subscribe()
}

// NotifyPendingOpenChannelEvent notifies the channelEventNotifier goroutine
// that a new channel is pending. The pending channel is passed as a parameter
// instead of read from the database because it might not yet have been
// persisted to the DB because we still wait for the final message from the
// remote peer.
func (c *ChannelNotifier) NotifyPendingOpenChannelEvent(chanPoint wire.OutPoint,
        pendingChan *channeldb.OpenChannel) {

        event := PendingOpenChannelEvent{
                ChannelPoint:   &chanPoint,
                PendingChannel: pendingChan,
        }

        if err := c.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send pending open channel update: %v", err)
        }
}

// NotifyOpenChannelEvent notifies the channelEventNotifier goroutine that a
// channel has gone from pending open to open.
func (c *ChannelNotifier) NotifyOpenChannelEvent(chanPoint wire.OutPoint) {
        // Fetch the relevant channel from the database.
        channel, err := c.chanDB.FetchChannel(nil, chanPoint)
        if err != nil {
                log.Warnf("Unable to fetch open channel from the db: %v", err)
        }

        // Send the open event to all channel event subscribers.
        event := OpenChannelEvent{Channel: channel}
        if err := c.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send open channel update: %v", err)
        }
}

// NotifyClosedChannelEvent notifies the channelEventNotifier goroutine that a
// channel has closed.
func (c *ChannelNotifier) NotifyClosedChannelEvent(chanPoint wire.OutPoint) {
        // Fetch the relevant closed channel from the database.
        closeSummary, err := c.chanDB.FetchClosedChannel(&chanPoint)
        if err != nil {
                log.Warnf("Unable to fetch closed channel summary from the db: %v", err)
        }

        // Send the closed event to all channel event subscribers.
        event := ClosedChannelEvent{CloseSummary: closeSummary}
        if err := c.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send closed channel update: %v", err)
        }
}

// NotifyFullyResolvedChannelEvent notifies the channelEventNotifier goroutine
// that a channel was fully resolved on chain.
func (c *ChannelNotifier) NotifyFullyResolvedChannelEvent(
        chanPoint wire.OutPoint) {

        // Send the resolved event to all channel event subscribers.
        event := FullyResolvedChannelEvent{ChannelPoint: &chanPoint}
        if err := c.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send resolved channel update: %v", err)
        }
}

// NotifyActiveLinkEvent notifies the channelEventNotifier goroutine that a
// link has been added to the switch.
func (c *ChannelNotifier) NotifyActiveLinkEvent(chanPoint wire.OutPoint) {
        event := ActiveLinkEvent{ChannelPoint: &chanPoint}
        if err := c.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send active link update: %v", err)
        }
}

// NotifyActiveChannelEvent notifies the channelEventNotifier goroutine that a
// channel is active.
func (c *ChannelNotifier) NotifyActiveChannelEvent(chanPoint wire.OutPoint) {
        event := ActiveChannelEvent{ChannelPoint: &chanPoint}
        if err := c.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send active channel update: %v", err)
        }
}

// NotifyInactiveLinkEvent notifies the channelEventNotifier goroutine that a
// link has been removed from the switch.
func (c *ChannelNotifier) NotifyInactiveLinkEvent(chanPoint wire.OutPoint) {
        event := InactiveLinkEvent{ChannelPoint: &chanPoint}
        if err := c.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send inactive link update: %v", err)
        }
}

// NotifyInactiveChannelEvent notifies the channelEventNotifier goroutine that a
// channel is inactive.
func (c *ChannelNotifier) NotifyInactiveChannelEvent(chanPoint wire.OutPoint) {
        event := InactiveChannelEvent{ChannelPoint: &chanPoint}
        if err := c.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send inactive channel update: %v", err)
        }
}

1	package channelnotifier
2
3	import (
4	"sync"
5
6	"github.com/btcsuite/btcd/wire"
7	"github.com/lightningnetwork/lnd/channeldb"
8	"github.com/lightningnetwork/lnd/subscribe"
9	)
10
11	// ChannelNotifier is a subsystem which all active, inactive, and closed channel
12	// events pipe through. It takes subscriptions for its events, and whenever
13	// it receives a new event it notifies its subscribers over the proper channel.
14	type ChannelNotifier struct {
15	started sync.Once
16	stopped sync.Once
17
18	ntfnServer *subscribe.Server
19
20	chanDB *channeldb.ChannelStateDB
21	}
22
23	// PendingOpenChannelEvent represents a new event where a new channel has
24	// entered a pending open state.
25	type PendingOpenChannelEvent struct {
26	// ChannelPoint is the channel outpoint for the new channel.
27	ChannelPoint *wire.OutPoint
28
29	// PendingChannel is the channel configuration for the newly created
30	// channel. This might not have been persisted to the channel DB yet
31	// because we are still waiting for the final message from the remote
32	// peer.
33	PendingChannel *channeldb.OpenChannel
34	}
35
36	// OpenChannelEvent represents a new event where a channel goes from pending
37	// open to open.
38	type OpenChannelEvent struct {
39	// Channel is the channel that has become open.
40	Channel *channeldb.OpenChannel
41	}
42
43	// ActiveLinkEvent represents a new event where the link becomes active in the
44	// switch. This happens before the ActiveChannelEvent.
45	type ActiveLinkEvent struct {
46	// ChannelPoint is the channel point for the newly active channel.
47	ChannelPoint *wire.OutPoint
48	}
49
50	// InactiveLinkEvent represents a new event where the link becomes inactive in
51	// the switch.
52	type InactiveLinkEvent struct {
53	// ChannelPoint is the channel point for the inactive channel.
54	ChannelPoint *wire.OutPoint
55	}
56
57	// ActiveChannelEvent represents a new event where a channel becomes active.
58	type ActiveChannelEvent struct {
59	// ChannelPoint is the channelpoint for the newly active channel.
60	ChannelPoint *wire.OutPoint
61	}
62
63	// InactiveChannelEvent represents a new event where a channel becomes inactive.
64	type InactiveChannelEvent struct {
65	// ChannelPoint is the channelpoint for the newly inactive channel.
66	ChannelPoint *wire.OutPoint
67	}
68
69	// ClosedChannelEvent represents a new event where a channel becomes closed.
70	type ClosedChannelEvent struct {
71	// CloseSummary is the summary of the channel close that has occurred.
72	CloseSummary *channeldb.ChannelCloseSummary
73	}
74
75	// FullyResolvedChannelEvent represents a new event where a channel becomes
76	// fully resolved.
77	type FullyResolvedChannelEvent struct {
78	// ChannelPoint is the channelpoint for the newly fully resolved
79	// channel.
80	ChannelPoint *wire.OutPoint
81	}
82
83	// New creates a new channel notifier. The ChannelNotifier gets channel
84	// events from peers and from the chain arbitrator, and dispatches them to
85	// its clients.
86	func New(chanDB channeldb.ChannelStateDB) ChannelNotifier {	19✔
87	return &ChannelNotifier{	19✔
88	ntfnServer: subscribe.NewServer(),	19✔
89	chanDB: chanDB,	19✔
90	}	19✔
91	}	19✔
92
93	// Start starts the ChannelNotifier and all goroutines it needs to carry out its task.
94	func (c *ChannelNotifier) Start() error {	19✔
95	var err error	19✔
96	c.started.Do(func() {	38✔
97	log.Info("ChannelNotifier starting")	19✔
98	err = c.ntfnServer.Start()	19✔
99	})	19✔
100	return err	19✔
101	}
102
103	// Stop signals the notifier for a graceful shutdown.
104	func (c *ChannelNotifier) Stop() error {	19✔
105	var err error	19✔
106	c.stopped.Do(func() {	38✔
107	log.Info("ChannelNotifier shutting down...")	19✔
108	defer log.Debug("ChannelNotifier shutdown complete")	19✔
109		19✔
110	err = c.ntfnServer.Stop()	19✔
111	})	19✔
112	return err	19✔
113	}
114
115	// SubscribeChannelEvents returns a subscribe.Client that will receive updates
116	// any time the Server is made aware of a new event. The subscription provides
117	// channel events from the point of subscription onwards.
118	//
119	// TODO(carlaKC): update to allow subscriptions to specify a block height from
120	// which we would like to subscribe to events.
121	func (c ChannelNotifier) SubscribeChannelEvents() (subscribe.Client, error) {	3✔
122	return c.ntfnServer.Subscribe()	3✔
123	}	3✔
124
125	// NotifyPendingOpenChannelEvent notifies the channelEventNotifier goroutine
126	// that a new channel is pending. The pending channel is passed as a parameter
127	// instead of read from the database because it might not yet have been
128	// persisted to the DB because we still wait for the final message from the
129	// remote peer.
130	func (c *ChannelNotifier) NotifyPendingOpenChannelEvent(chanPoint wire.OutPoint,
UNCOV 131	pendingChan *channeldb.OpenChannel) {	×
UNCOV 132		×
UNCOV 133	event := PendingOpenChannelEvent{	×
UNCOV 134	ChannelPoint: &chanPoint,	×
UNCOV 135	PendingChannel: pendingChan,	×
UNCOV 136	}	×
UNCOV 137		×
UNCOV 138	if err := c.ntfnServer.SendUpdate(event); err != nil {	×
139	log.Warnf("Unable to send pending open channel update: %v", err)	×
140	}	×
141	}
142
143	// NotifyOpenChannelEvent notifies the channelEventNotifier goroutine that a
144	// channel has gone from pending open to open.
UNCOV 145	func (c *ChannelNotifier) NotifyOpenChannelEvent(chanPoint wire.OutPoint) {	×
UNCOV 146	// Fetch the relevant channel from the database.	×
UNCOV 147	channel, err := c.chanDB.FetchChannel(nil, chanPoint)	×
UNCOV 148	if err != nil {	×
149	log.Warnf("Unable to fetch open channel from the db: %v", err)	×
150	}	×
151
152	// Send the open event to all channel event subscribers.
UNCOV 153	event := OpenChannelEvent{Channel: channel}	×
UNCOV 154	if err := c.ntfnServer.SendUpdate(event); err != nil {	×
155	log.Warnf("Unable to send open channel update: %v", err)	×
156	}	×
157	}
158
159	// NotifyClosedChannelEvent notifies the channelEventNotifier goroutine that a
160	// channel has closed.
UNCOV 161	func (c *ChannelNotifier) NotifyClosedChannelEvent(chanPoint wire.OutPoint) {	×
UNCOV 162	// Fetch the relevant closed channel from the database.	×
UNCOV 163	closeSummary, err := c.chanDB.FetchClosedChannel(&chanPoint)	×
UNCOV 164	if err != nil {	×
165	log.Warnf("Unable to fetch closed channel summary from the db: %v", err)	×
166	}	×
167
168	// Send the closed event to all channel event subscribers.
UNCOV 169	event := ClosedChannelEvent{CloseSummary: closeSummary}	×
UNCOV 170	if err := c.ntfnServer.SendUpdate(event); err != nil {	×
171	log.Warnf("Unable to send closed channel update: %v", err)	×
172	}	×
173	}
174
175	// NotifyFullyResolvedChannelEvent notifies the channelEventNotifier goroutine
176	// that a channel was fully resolved on chain.
177	func (c *ChannelNotifier) NotifyFullyResolvedChannelEvent(
UNCOV 178	chanPoint wire.OutPoint) {	×
UNCOV 179		×
UNCOV 180	// Send the resolved event to all channel event subscribers.	×
UNCOV 181	event := FullyResolvedChannelEvent{ChannelPoint: &chanPoint}	×
UNCOV 182	if err := c.ntfnServer.SendUpdate(event); err != nil {	×
183	log.Warnf("Unable to send resolved channel update: %v", err)	×
184	}	×
185	}
186
187	// NotifyActiveLinkEvent notifies the channelEventNotifier goroutine that a
188	// link has been added to the switch.
UNCOV 189	func (c *ChannelNotifier) NotifyActiveLinkEvent(chanPoint wire.OutPoint) {	×
UNCOV 190	event := ActiveLinkEvent{ChannelPoint: &chanPoint}	×
UNCOV 191	if err := c.ntfnServer.SendUpdate(event); err != nil {	×
192	log.Warnf("Unable to send active link update: %v", err)	×
193	}	×
194	}
195
196	// NotifyActiveChannelEvent notifies the channelEventNotifier goroutine that a
197	// channel is active.
UNCOV 198	func (c *ChannelNotifier) NotifyActiveChannelEvent(chanPoint wire.OutPoint) {	×
UNCOV 199	event := ActiveChannelEvent{ChannelPoint: &chanPoint}	×
UNCOV 200	if err := c.ntfnServer.SendUpdate(event); err != nil {	×
201	log.Warnf("Unable to send active channel update: %v", err)	×
202	}	×
203	}
204
205	// NotifyInactiveLinkEvent notifies the channelEventNotifier goroutine that a
206	// link has been removed from the switch.
UNCOV 207	func (c *ChannelNotifier) NotifyInactiveLinkEvent(chanPoint wire.OutPoint) {	×
UNCOV 208	event := InactiveLinkEvent{ChannelPoint: &chanPoint}	×
UNCOV 209	if err := c.ntfnServer.SendUpdate(event); err != nil {	×
210	log.Warnf("Unable to send inactive link update: %v", err)	×
211	}	×
212	}
213
214	// NotifyInactiveChannelEvent notifies the channelEventNotifier goroutine that a
215	// channel is inactive.
UNCOV 216	func (c *ChannelNotifier) NotifyInactiveChannelEvent(chanPoint wire.OutPoint) {	×
UNCOV 217	event := InactiveChannelEvent{ChannelPoint: &chanPoint}	×
UNCOV 218	if err := c.ntfnServer.SendUpdate(event); err != nil {	×
219	log.Warnf("Unable to send inactive channel update: %v", err)	×
220	}	×
221	}

lightningnetwork / lnd / 11216766535

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous