blob: f6dd8b69d622138b51e4321e152f3b6e3e9dafa4 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
package protocol
import (
"sync"
"time"
)
// ResponseCache caches API responses to reduce CPU usage for repeated requests
type ResponseCache struct {
mu sync.RWMutex
cache map[string]*cacheEntry
ttl time.Duration
}
type cacheEntry struct {
response []byte
timestamp time.Time
}
// NewResponseCache creates a new response cache with the specified TTL
func NewResponseCache(ttl time.Duration) *ResponseCache {
return &ResponseCache{
cache: make(map[string]*cacheEntry),
ttl: ttl,
}
}
// Get retrieves a cached response if it exists and hasn't expired
func (c *ResponseCache) Get(key string) ([]byte, bool) {
c.mu.RLock()
defer c.mu.RUnlock()
entry, exists := c.cache[key]
if !exists {
return nil, false
}
// Check if entry has expired
if time.Since(entry.timestamp) > c.ttl {
return nil, false
}
return entry.response, true
}
// Put stores a response in the cache
func (c *ResponseCache) Put(key string, response []byte) {
c.mu.Lock()
defer c.mu.Unlock()
c.cache[key] = &cacheEntry{
response: response,
timestamp: time.Now(),
}
}
// Cleanup removes expired entries from the cache
func (c *ResponseCache) Cleanup() {
c.mu.Lock()
defer c.mu.Unlock()
now := time.Now()
for key, entry := range c.cache {
if now.Sub(entry.timestamp) > c.ttl {
delete(c.cache, key)
}
}
}
// StartCleanupLoop starts a background goroutine to periodically clean up expired entries
func (c *ResponseCache) StartCleanupLoop(interval time.Duration) {
go func() {
ticker := time.NewTicker(interval)
defer ticker.Stop()
for range ticker.C {
c.Cleanup()
}
}()
}
|
