6e463c1634
This commit is a direct copy of the complete channeldb package. It only changes the package declaration at the top of every file. We make this full copy so that review can be focused on the actual changes made. Otherwise changes may drown in all the file moves. Linting for the new package is disabled, as it contains lots of pre-existing issues.
96 lines
2.9 KiB
Go
96 lines
2.9 KiB
Go
package migration_01_to_11
|
|
|
|
// rejectFlags is a compact representation of various metadata stored by the
|
|
// reject cache about a particular channel.
|
|
type rejectFlags uint8
|
|
|
|
const (
|
|
// rejectFlagExists is a flag indicating whether the channel exists,
|
|
// i.e. the channel is open and has a recent channel update. If this
|
|
// flag is not set, the channel is either a zombie or unknown.
|
|
rejectFlagExists rejectFlags = 1 << iota
|
|
|
|
// rejectFlagZombie is a flag indicating whether the channel is a
|
|
// zombie, i.e. the channel is open but has no recent channel updates.
|
|
rejectFlagZombie
|
|
)
|
|
|
|
// packRejectFlags computes the rejectFlags corresponding to the passed boolean
|
|
// values indicating whether the edge exists or is a zombie.
|
|
func packRejectFlags(exists, isZombie bool) rejectFlags {
|
|
var flags rejectFlags
|
|
if exists {
|
|
flags |= rejectFlagExists
|
|
}
|
|
if isZombie {
|
|
flags |= rejectFlagZombie
|
|
}
|
|
|
|
return flags
|
|
}
|
|
|
|
// unpack returns the booleans packed into the rejectFlags. The first indicates
|
|
// if the edge exists in our graph, the second indicates if the edge is a
|
|
// zombie.
|
|
func (f rejectFlags) unpack() (bool, bool) {
|
|
return f&rejectFlagExists == rejectFlagExists,
|
|
f&rejectFlagZombie == rejectFlagZombie
|
|
}
|
|
|
|
// rejectCacheEntry caches frequently accessed information about a channel,
|
|
// including the timestamps of its latest edge policies and whether or not the
|
|
// channel exists in the graph.
|
|
type rejectCacheEntry struct {
|
|
upd1Time int64
|
|
upd2Time int64
|
|
flags rejectFlags
|
|
}
|
|
|
|
// rejectCache is an in-memory cache used to improve the performance of
|
|
// HasChannelEdge. It caches information about the whether or channel exists, as
|
|
// well as the most recent timestamps for each policy (if they exists).
|
|
type rejectCache struct {
|
|
n int
|
|
edges map[uint64]rejectCacheEntry
|
|
}
|
|
|
|
// newRejectCache creates a new rejectCache with maximum capacity of n entries.
|
|
func newRejectCache(n int) *rejectCache {
|
|
return &rejectCache{
|
|
n: n,
|
|
edges: make(map[uint64]rejectCacheEntry, n),
|
|
}
|
|
}
|
|
|
|
// get returns the entry from the cache for chanid, if it exists.
|
|
func (c *rejectCache) get(chanid uint64) (rejectCacheEntry, bool) {
|
|
entry, ok := c.edges[chanid]
|
|
return entry, ok
|
|
}
|
|
|
|
// insert adds the entry to the reject cache. If an entry for chanid already
|
|
// exists, it will be replaced with the new entry. If the entry doesn't exists,
|
|
// it will be inserted to the cache, performing a random eviction if the cache
|
|
// is at capacity.
|
|
func (c *rejectCache) insert(chanid uint64, entry rejectCacheEntry) {
|
|
// If entry exists, replace it.
|
|
if _, ok := c.edges[chanid]; ok {
|
|
c.edges[chanid] = entry
|
|
return
|
|
}
|
|
|
|
// Otherwise, evict an entry at random and insert.
|
|
if len(c.edges) == c.n {
|
|
for id := range c.edges {
|
|
delete(c.edges, id)
|
|
break
|
|
}
|
|
}
|
|
c.edges[chanid] = entry
|
|
}
|
|
|
|
// remove deletes an entry for chanid from the cache, if it exists.
|
|
func (c *rejectCache) remove(chanid uint64) {
|
|
delete(c.edges, chanid)
|
|
}
|