mirror of
https://github.com/tendermint/tendermint.git
synced 2026-02-03 18:42:14 +00:00
851d2e3bde
Addresses one of the concerns with #7041. Provides a mechanism (via the RPC interface) to delete a single transaction, described by its hash, from the mempool. The method returns an error if the transaction cannot be found. Once the transaction is removed it remains in the cache and cannot be resubmitted until the cache is cleared or it expires from the cache.
108 lines
2.4 KiB
Go
108 lines
2.4 KiB
Go
package mempool
|
|
|
|
import (
|
|
"container/list"
|
|
|
|
tmsync "github.com/tendermint/tendermint/internal/libs/sync"
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
// TxCache defines an interface for raw transaction caching in a mempool.
|
|
// Currently, a TxCache does not allow direct reading or getting of transaction
|
|
// values. A TxCache is used primarily to push transactions and removing
|
|
// transactions. Pushing via Push returns a boolean telling the caller if the
|
|
// transaction already exists in the cache or not.
|
|
type TxCache interface {
|
|
// Reset resets the cache to an empty state.
|
|
Reset()
|
|
|
|
// Push adds the given raw transaction to the cache and returns true if it was
|
|
// newly added. Otherwise, it returns false.
|
|
Push(tx types.Tx) bool
|
|
|
|
// Remove removes the given raw transaction from the cache.
|
|
Remove(tx types.Tx)
|
|
}
|
|
|
|
var _ TxCache = (*LRUTxCache)(nil)
|
|
|
|
// LRUTxCache maintains a thread-safe LRU cache of raw transactions. The cache
|
|
// only stores the hash of the raw transaction.
|
|
type LRUTxCache struct {
|
|
mtx tmsync.Mutex
|
|
size int
|
|
cacheMap map[types.TxKey]*list.Element
|
|
list *list.List
|
|
}
|
|
|
|
func NewLRUTxCache(cacheSize int) *LRUTxCache {
|
|
return &LRUTxCache{
|
|
size: cacheSize,
|
|
cacheMap: make(map[types.TxKey]*list.Element, cacheSize),
|
|
list: list.New(),
|
|
}
|
|
}
|
|
|
|
// GetList returns the underlying linked-list that backs the LRU cache. Note,
|
|
// this should be used for testing purposes only!
|
|
func (c *LRUTxCache) GetList() *list.List {
|
|
return c.list
|
|
}
|
|
|
|
func (c *LRUTxCache) Reset() {
|
|
c.mtx.Lock()
|
|
defer c.mtx.Unlock()
|
|
|
|
c.cacheMap = make(map[types.TxKey]*list.Element, c.size)
|
|
c.list.Init()
|
|
}
|
|
|
|
func (c *LRUTxCache) Push(tx types.Tx) bool {
|
|
c.mtx.Lock()
|
|
defer c.mtx.Unlock()
|
|
|
|
key := tx.Key()
|
|
|
|
moved, ok := c.cacheMap[key]
|
|
if ok {
|
|
c.list.MoveToBack(moved)
|
|
return false
|
|
}
|
|
|
|
if c.list.Len() >= c.size {
|
|
front := c.list.Front()
|
|
if front != nil {
|
|
frontKey := front.Value.(types.TxKey)
|
|
delete(c.cacheMap, frontKey)
|
|
c.list.Remove(front)
|
|
}
|
|
}
|
|
|
|
e := c.list.PushBack(key)
|
|
c.cacheMap[key] = e
|
|
|
|
return true
|
|
}
|
|
|
|
func (c *LRUTxCache) Remove(tx types.Tx) {
|
|
c.mtx.Lock()
|
|
defer c.mtx.Unlock()
|
|
|
|
key := tx.Key()
|
|
e := c.cacheMap[key]
|
|
delete(c.cacheMap, key)
|
|
|
|
if e != nil {
|
|
c.list.Remove(e)
|
|
}
|
|
}
|
|
|
|
// NopTxCache defines a no-op raw transaction cache.
|
|
type NopTxCache struct{}
|
|
|
|
var _ TxCache = (*NopTxCache)(nil)
|
|
|
|
func (NopTxCache) Reset() {}
|
|
func (NopTxCache) Push(types.Tx) bool { return true }
|
|
func (NopTxCache) Remove(types.Tx) {}
|