From 6c027e2bc9993d655de53cdfa7123424f80dd5ba Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Thu, 20 Dec 2018 18:52:27 +0100 Subject: [PATCH] htlcswitch: remove lnrpc dependency This commits removes an unwanted dependency that prevents moving parts of rpcserver to a sub server. --- htlcswitch/switch.go | 7 ++--- peer.go | 31 +++++++++++---------- peer_test.go | 5 ++-- rpcserver.go | 66 ++++++++++++++++++++++++++++++-------------- 4 files changed, 68 insertions(+), 41 deletions(-) diff --git a/htlcswitch/switch.go b/htlcswitch/switch.go index 11faf286..ce2bfc58 100644 --- a/htlcswitch/switch.go +++ b/htlcswitch/switch.go @@ -17,7 +17,6 @@ import ( "github.com/lightningnetwork/lnd/chainntnfs" "github.com/lightningnetwork/lnd/channeldb" "github.com/lightningnetwork/lnd/contractcourt" - "github.com/lightningnetwork/lnd/lnrpc" "github.com/lightningnetwork/lnd/lnwallet" "github.com/lightningnetwork/lnd/lnwire" "github.com/lightningnetwork/lnd/ticker" @@ -119,7 +118,7 @@ type ChanClose struct { // Updates is used by request creator to receive the notifications about // execution of the close channel request. - Updates chan *lnrpc.CloseStatusUpdate + Updates chan interface{} // Err is used by request creator to receive request execution error. Err chan error @@ -1415,11 +1414,11 @@ func (s *Switch) teardownCircuit(pkt *htlcPacket) error { // then the last parameter should be the ideal fee-per-kw that will be used as // a starting point for close negotiation. func (s *Switch) CloseLink(chanPoint *wire.OutPoint, closeType ChannelCloseType, - targetFeePerKw lnwallet.SatPerKWeight) (chan *lnrpc.CloseStatusUpdate, + targetFeePerKw lnwallet.SatPerKWeight) (chan interface{}, chan error) { // TODO(roasbeef) abstract out the close updates. - updateChan := make(chan *lnrpc.CloseStatusUpdate, 2) + updateChan := make(chan interface{}, 2) errChan := make(chan error, 1) command := &ChanClose{ diff --git a/peer.go b/peer.go index a4963de9..bf367a4a 100644 --- a/peer.go +++ b/peer.go @@ -23,7 +23,6 @@ import ( "github.com/lightningnetwork/lnd/contractcourt" "github.com/lightningnetwork/lnd/htlcswitch" "github.com/lightningnetwork/lnd/lnpeer" - "github.com/lightningnetwork/lnd/lnrpc" "github.com/lightningnetwork/lnd/lnwallet" "github.com/lightningnetwork/lnd/lnwire" "github.com/lightningnetwork/lnd/ticker" @@ -85,6 +84,18 @@ type chanSnapshotReq struct { resp chan []*channeldb.ChannelSnapshot } +// pendingUpdate describes the pending state of a closing channel. +type pendingUpdate struct { + Txid []byte + OutputIndex uint32 +} + +// channelCloseUpdate contains the outcome of the close channel operation. +type channelCloseUpdate struct { + ClosingTxid []byte + Success bool +} + // peer is an active peer on the Lightning Network. This struct is responsible // for managing any channel state related to this peer. To do so, it has // several helper goroutines to handle events such as HTLC timeouts, new @@ -2037,12 +2048,8 @@ func (p *peer) finalizeChanClosure(chanCloser *channelCloser) { // If this is a locally requested shutdown, update the caller with a // new event detailing the current pending state of this request. if closeReq != nil { - closeReq.Updates <- &lnrpc.CloseStatusUpdate{ - Update: &lnrpc.CloseStatusUpdate_ClosePending{ - ClosePending: &lnrpc.PendingUpdate{ - Txid: closingTxid[:], - }, - }, + closeReq.Updates <- &pendingUpdate{ + Txid: closingTxid[:], } } @@ -2052,13 +2059,9 @@ func (p *peer) finalizeChanClosure(chanCloser *channelCloser) { // Respond to the local subsystem which requested the // channel closure. if closeReq != nil { - closeReq.Updates <- &lnrpc.CloseStatusUpdate{ - Update: &lnrpc.CloseStatusUpdate_ChanClose{ - ChanClose: &lnrpc.ChannelCloseUpdate{ - ClosingTxid: closingTxid[:], - Success: true, - }, - }, + closeReq.Updates <- &channelCloseUpdate{ + ClosingTxid: closingTxid[:], + Success: true, } } }) diff --git a/peer_test.go b/peer_test.go index ccb7cd41..61251cd1 100644 --- a/peer_test.go +++ b/peer_test.go @@ -10,7 +10,6 @@ import ( "github.com/btcsuite/btcutil" "github.com/lightningnetwork/lnd/chainntnfs" "github.com/lightningnetwork/lnd/htlcswitch" - "github.com/lightningnetwork/lnd/lnrpc" "github.com/lightningnetwork/lnd/lnwallet" "github.com/lightningnetwork/lnd/lnwire" ) @@ -121,7 +120,7 @@ func TestPeerChannelClosureAcceptFeeInitiator(t *testing.T) { defer cleanUp() // We make the initiator send a shutdown request. - updateChan := make(chan *lnrpc.CloseStatusUpdate, 1) + updateChan := make(chan interface{}, 1) errChan := make(chan error, 1) closeCommand := &htlcswitch.ChanClose{ CloseType: htlcswitch.CloseRegular, @@ -410,7 +409,7 @@ func TestPeerChannelClosureFeeNegotiationsInitiator(t *testing.T) { defer cleanUp() // We make the initiator send a shutdown request. - updateChan := make(chan *lnrpc.CloseStatusUpdate, 1) + updateChan := make(chan interface{}, 1) errChan := make(chan error, 1) closeCommand := &htlcswitch.ChanClose{ CloseType: htlcswitch.CloseRegular, diff --git a/rpcserver.go b/rpcserver.go index 874dadd9..ca22c939 100644 --- a/rpcserver.go +++ b/rpcserver.go @@ -1419,7 +1419,7 @@ func (r *rpcServer) CloseChannel(in *lnrpc.CloseChannelRequest, chanPoint, force) var ( - updateChan chan *lnrpc.CloseStatusUpdate + updateChan chan interface{} errChan chan error ) @@ -1472,13 +1472,9 @@ func (r *rpcServer) CloseChannel(in *lnrpc.CloseChannelRequest, // With the transaction broadcast, we send our first update to // the client. - updateChan = make(chan *lnrpc.CloseStatusUpdate, 2) - updateChan <- &lnrpc.CloseStatusUpdate{ - Update: &lnrpc.CloseStatusUpdate_ClosePending{ - ClosePending: &lnrpc.PendingUpdate{ - Txid: closingTxid[:], - }, - }, + updateChan = make(chan interface{}, 2) + updateChan <- &pendingUpdate{ + Txid: closingTxid[:], } errChan = make(chan error, 1) @@ -1487,13 +1483,9 @@ func (r *rpcServer) CloseChannel(in *lnrpc.CloseChannelRequest, &closingTxid, closingTx.TxOut[0].PkScript, func() { // Respond to the local subsystem which // requested the channel closure. - updateChan <- &lnrpc.CloseStatusUpdate{ - Update: &lnrpc.CloseStatusUpdate_ChanClose{ - ChanClose: &lnrpc.ChannelCloseUpdate{ - ClosingTxid: closingTxid[:], - Success: true, - }, - }, + updateChan <- &channelCloseUpdate{ + ClosingTxid: closingTxid[:], + Success: true, } }) } else { @@ -1544,18 +1536,26 @@ out: "ChannelPoint(%v): %v", chanPoint, err) return err case closingUpdate := <-updateChan: + rpcClosingUpdate, err := createRPCCloseUpdate( + closingUpdate, + ) + if err != nil { + return err + } + rpcsLog.Tracef("[closechannel] sending update: %v", - closingUpdate) - if err := updateStream.Send(closingUpdate); err != nil { + rpcClosingUpdate) + + if err := updateStream.Send(rpcClosingUpdate); err != nil { return err } // If a final channel closing updates is being sent, // then we can break out of our dispatch loop as we no // longer need to process any further updates. - switch closeUpdate := closingUpdate.Update.(type) { - case *lnrpc.CloseStatusUpdate_ChanClose: - h, _ := chainhash.NewHash(closeUpdate.ChanClose.ClosingTxid) + switch closeUpdate := closingUpdate.(type) { + case *channelCloseUpdate: + h, _ := chainhash.NewHash(closeUpdate.ClosingTxid) rpcsLog.Infof("[closechannel] close completed: "+ "txid(%v)", h) break out @@ -1568,6 +1568,32 @@ out: return nil } +func createRPCCloseUpdate(update interface{}) ( + *lnrpc.CloseStatusUpdate, error) { + + switch u := update.(type) { + case *channelCloseUpdate: + return &lnrpc.CloseStatusUpdate{ + Update: &lnrpc.CloseStatusUpdate_ChanClose{ + ChanClose: &lnrpc.ChannelCloseUpdate{ + ClosingTxid: u.ClosingTxid, + }, + }, + }, nil + case *pendingUpdate: + return &lnrpc.CloseStatusUpdate{ + Update: &lnrpc.CloseStatusUpdate_ClosePending{ + ClosePending: &lnrpc.PendingUpdate{ + Txid: u.Txid, + OutputIndex: u.OutputIndex, + }, + }, + }, nil + } + + return nil, errors.New("unknown close status update") +} + // AbandonChannel removes all channel state from the database except for a // close summary. This method can be used to get rid of permanently unusable // channels due to bugs fixed in newer versions of lnd.