ec1f89217a
Full Mattermost server source with integrated Community Enterprise features. Includes vendor directory for offline/air-gapped builds. Structure: - enterprise-impl/: Enterprise feature implementations - enterprise-community/: Init files that register implementations - enterprise/: Bridge imports (community_imports.go) - vendor/: All dependencies for offline builds Build (online): go build ./cmd/mattermost Build (offline/air-gapped): go build -mod=vendor ./cmd/mattermost 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
92 lines
2.0 KiB
Go
92 lines
2.0 KiB
Go
package int64cache
|
|
|
|
import (
|
|
"container/list"
|
|
"fmt"
|
|
"sync"
|
|
)
|
|
|
|
// Int64Cache is an in-memory TTL & LRU cache
|
|
type Int64Cache interface {
|
|
Get(key int64) (int64, error)
|
|
Set(key int64, value int64) error
|
|
}
|
|
|
|
// Impl implements the LocalCache interface
|
|
type Impl struct {
|
|
maxLen int
|
|
items map[int64]*list.Element
|
|
lru *list.List
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
type entry struct {
|
|
key int64
|
|
value int64
|
|
}
|
|
|
|
// Get retrieves an item if exist, nil + an error otherwise
|
|
func (c *Impl) Get(key int64) (int64, error) {
|
|
c.mutex.Lock()
|
|
defer c.mutex.Unlock()
|
|
node, ok := c.items[key]
|
|
if !ok {
|
|
return 0, &Miss{}
|
|
}
|
|
|
|
entry, ok := node.Value.(entry)
|
|
if !ok {
|
|
return 0, fmt.Errorf("Invalid data in cache for key %d", key)
|
|
}
|
|
|
|
c.lru.MoveToFront(node)
|
|
return entry.value, nil
|
|
}
|
|
|
|
// Set adds a new item. Since the cache being full results in removing the LRU element, this method never fails.
|
|
func (c *Impl) Set(key int64, value int64) error {
|
|
c.mutex.Lock()
|
|
defer c.mutex.Unlock()
|
|
if node, ok := c.items[key]; ok {
|
|
c.lru.MoveToFront(node)
|
|
node.Value = entry{key: key, value: value}
|
|
} else {
|
|
// Drop the LRU item on the list before adding a new one.
|
|
if c.lru.Len() == c.maxLen {
|
|
entry, ok := c.lru.Back().Value.(entry)
|
|
if !ok {
|
|
return fmt.Errorf("Invalid data in list for key %d", key)
|
|
}
|
|
key := entry.key
|
|
delete(c.items, key)
|
|
c.lru.Remove(c.lru.Back())
|
|
}
|
|
|
|
ptr := c.lru.PushFront(entry{key: key, value: value})
|
|
c.items[key] = ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// NewInt64Cache returns a new LocalCache instance of the specified size and TTL
|
|
func NewInt64Cache(maxSize int) (*Impl, error) {
|
|
if maxSize <= 0 {
|
|
return nil, fmt.Errorf("Cache size should be > 0. Is: %d", maxSize)
|
|
}
|
|
|
|
return &Impl{
|
|
maxLen: maxSize,
|
|
lru: new(list.List),
|
|
items: make(map[int64]*list.Element, maxSize),
|
|
}, nil
|
|
}
|
|
|
|
// Miss is a special error indicating the key was not found in the cache
|
|
type Miss struct {
|
|
Key int64
|
|
}
|
|
|
|
func (m *Miss) Error() string {
|
|
return fmt.Sprintf("key %d not found in cache", m.Key)
|
|
}
|