12428593038

Committed 20 Dec 2024 09:02AM UTC coverage: 58.33% (-0.2%) from 58.576%

Build # 12428593038

Build Type

Pull #9382

github

Committed by

guggero

Commit Message

.golangci.yml: speed up linter by updating start commit

With this we allow the linter to only look at recent changes, since
everything between that old commit and this most recent one has been
linted correctly anyway.

Pull Request Pull Request #9382: lint: deprecate old linters, use new ref commit

Run Details

133769 of 229330 relevant lines covered (58.33%)

19284.53 hits per line

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

86.36

/blockcache/blockcache.go

package blockcache

import (
        "github.com/btcsuite/btcd/btcutil"
        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/btcsuite/btcd/wire"
        "github.com/lightninglabs/neutrino"
        "github.com/lightninglabs/neutrino/cache"
        "github.com/lightninglabs/neutrino/cache/lru"
        "github.com/lightningnetwork/lnd/lntypes"
        "github.com/lightningnetwork/lnd/multimutex"
)

// BlockCache is an lru cache for blocks.
type BlockCache struct {
        Cache     *lru.Cache[wire.InvVect, *neutrino.CacheableBlock]
        HashMutex *multimutex.Mutex[lntypes.Hash]
}

// NewBlockCache creates a new BlockCache with the given maximum capacity.
func NewBlockCache(capacity uint64) *BlockCache {
        return &BlockCache{
                Cache: lru.NewCache[wire.InvVect, *neutrino.CacheableBlock](
                        capacity,
                ),
                HashMutex: multimutex.NewMutex[lntypes.Hash](),
        }
}

// GetBlock first checks to see if the BlockCache already contains the block
// with the given hash. If it does then the block is fetched from the cache and
// returned. Otherwise the getBlockImpl function is used in order to fetch the
// new block and then it is stored in the block cache and returned.
func (bc *BlockCache) GetBlock(hash *chainhash.Hash,
        getBlockImpl func(hash *chainhash.Hash) (*wire.MsgBlock,
                error)) (*wire.MsgBlock, error) {

        bc.HashMutex.Lock(lntypes.Hash(*hash))
        defer bc.HashMutex.Unlock(lntypes.Hash(*hash))

        // Create an inv vector for getting the block.
        inv := wire.NewInvVect(wire.InvTypeWitnessBlock, hash)

        // Check if the block corresponding to the given hash is already
        // stored in the blockCache and return it if it is.
        cacheBlock, err := bc.Cache.Get(*inv)
        if err != nil && err != cache.ErrElementNotFound {
                return nil, err
        }
        if cacheBlock != nil {
                return cacheBlock.MsgBlock(), nil
        }

        // Fetch the block from the chain backends.
        msgBlock, err := getBlockImpl(hash)
        if err != nil {
                return nil, err
        }

        // Make a copy of the block so it won't escape to the heap.
        msgBlockCopy := msgBlock.Copy()
        block := btcutil.NewBlock(msgBlockCopy)

        // Add the new block to blockCache. If the Cache is at its maximum
        // capacity then the LFU item will be evicted in favour of this new
        // block.
        _, err = bc.Cache.Put(
                *inv, &neutrino.CacheableBlock{
                        Block: block,
                },
        )
        if err != nil {
                return nil, err
        }

        return msgBlockCopy, nil
}

1	package blockcache
2
3	import (
4	"github.com/btcsuite/btcd/btcutil"
5	"github.com/btcsuite/btcd/chaincfg/chainhash"
6	"github.com/btcsuite/btcd/wire"
7	"github.com/lightninglabs/neutrino"
8	"github.com/lightninglabs/neutrino/cache"
9	"github.com/lightninglabs/neutrino/cache/lru"
10	"github.com/lightningnetwork/lnd/lntypes"
11	"github.com/lightningnetwork/lnd/multimutex"
12	)
13
14	// BlockCache is an lru cache for blocks.
15	type BlockCache struct {
16	Cache lru.Cache[wire.InvVect, neutrino.CacheableBlock]
17	HashMutex *multimutex.Mutex[lntypes.Hash]
18	}
19
20	// NewBlockCache creates a new BlockCache with the given maximum capacity.
21	func NewBlockCache(capacity uint64) *BlockCache {	33✔
22	return &BlockCache{	33✔
23	Cache: lru.NewCache[wire.InvVect, *neutrino.CacheableBlock](	33✔
24	capacity,	33✔
25	),	33✔
26	HashMutex: multimutex.NewMutex[lntypes.Hash](),	33✔
27	}	33✔
28	}	33✔
29
30	// GetBlock first checks to see if the BlockCache already contains the block
31	// with the given hash. If it does then the block is fetched from the cache and
32	// returned. Otherwise the getBlockImpl function is used in order to fetch the
33	// new block and then it is stored in the block cache and returned.
34	func (bc BlockCache) GetBlock(hash chainhash.Hash,
35	getBlockImpl func(hash chainhash.Hash) (wire.MsgBlock,
36	error)) (*wire.MsgBlock, error) {	1,468✔
37		1,468✔
38	bc.HashMutex.Lock(lntypes.Hash(*hash))	1,468✔
39	defer bc.HashMutex.Unlock(lntypes.Hash(*hash))	1,468✔
40		1,468✔
41	// Create an inv vector for getting the block.	1,468✔
42	inv := wire.NewInvVect(wire.InvTypeWitnessBlock, hash)	1,468✔
43		1,468✔
44	// Check if the block corresponding to the given hash is already	1,468✔
45	// stored in the blockCache and return it if it is.	1,468✔
46	cacheBlock, err := bc.Cache.Get(*inv)	1,468✔
47	if err != nil && err != cache.ErrElementNotFound {	1,468✔
48	return nil, err	×
49	}	×
50	if cacheBlock != nil {	1,668✔
51	return cacheBlock.MsgBlock(), nil	200✔
52	}	200✔
53
54	// Fetch the block from the chain backends.
55	msgBlock, err := getBlockImpl(hash)	1,269✔
56	if err != nil {	1,269✔
57	return nil, err	×
58	}	×
59
60	// Make a copy of the block so it won't escape to the heap.
61	msgBlockCopy := msgBlock.Copy()	1,269✔
62	block := btcutil.NewBlock(msgBlockCopy)	1,269✔
63		1,269✔
64	// Add the new block to blockCache. If the Cache is at its maximum	1,269✔
65	// capacity then the LFU item will be evicted in favour of this new	1,269✔
66	// block.	1,269✔
67	_, err = bc.Cache.Put(	1,269✔
68	*inv, &neutrino.CacheableBlock{	1,269✔
69	Block: block,	1,269✔
70	},	1,269✔
71	)	1,269✔
72	if err != nil {	1,269✔
73	return nil, err	×
74	}	×
75
76	return msgBlockCopy, nil	1,269✔
77	}

lightningnetwork / lnd / 12428593038

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