Repository navigation
Expand file tree
/
Copy pathconditional.go
More file actions
127 lines (111 loc) · 3.7 KB
/
Copy pathconditional.go
File metadata and controls
127 lines (111 loc) · 3.7 KB
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package gitprovider
import (
"container/list"
"crypto/sha256"
"encoding/hex"
"sync"
)
// Defaults for the conditional-request response cache. These bound
// the memory used by cached GitHub responses while still covering a
// realistic working set of actively-polled pull requests.
const (
// defaultResponseCacheEntries is the maximum number of cached
// responses retained. Once exceeded, the least-recently-used
// entry is evicted.
defaultResponseCacheEntries = 2048
// maxCachedBodyBytes is the largest response body that will be
// cached. Larger bodies are still returned to the caller but are
// not stored, so a single oversized response cannot blow up the
// cache's memory footprint.
maxCachedBodyBytes = 1 << 20 // 1 MiB
)
// cachedResponse holds the data needed to satisfy a future
// conditional request: the validator (ETag) to echo back via
// If-None-Match and the body to reuse on a 304 Not Modified.
type cachedResponse struct {
key string
etag string
body []byte
}
// responseCache is a small, concurrency-safe LRU cache of GitHub
// responses keyed by request URL and auth scope. It enables
// conditional requests (ETag / If-None-Match): when GitHub replies
// 304 Not Modified the cached body is reused, avoiding a full
// re-download. Conditional requests that return 304 also do not
// count against the primary REST rate limit, which matters for the
// diff-status worker that polls open PRs on a short interval.
type responseCache struct {
mu sync.Mutex
maxSize int
ll *list.List
entries map[string]*list.Element
}
// newResponseCache constructs an empty cache retaining at most
// maxSize entries. A non-positive maxSize falls back to the default.
func newResponseCache(maxSize int) *responseCache {
if maxSize <= 0 {
maxSize = defaultResponseCacheEntries
}
return &responseCache{
maxSize: maxSize,
ll: list.New(),
entries: make(map[string]*list.Element),
}
}
// load returns the cached ETag and body for key, if present, and
// marks the entry as most-recently-used.
func (c *responseCache) load(key string) (etag string, body []byte, ok bool) {
c.mu.Lock()
defer c.mu.Unlock()
elem, found := c.entries[key]
if !found {
return "", nil, false
}
c.ll.MoveToFront(elem)
cr := elem.Value.(*cachedResponse)
return cr.etag, cr.body, true
}
// store records the ETag and body for key, evicting the
// least-recently-used entry when the cache is full. Empty ETags and
// bodies larger than maxCachedBodyBytes are not stored.
func (c *responseCache) store(key, etag string, body []byte) {
if etag == "" || len(body) > maxCachedBodyBytes {
return
}
c.mu.Lock()
defer c.mu.Unlock()
if elem, found := c.entries[key]; found {
c.ll.MoveToFront(elem)
cr := elem.Value.(*cachedResponse)
cr.etag = etag
cr.body = body
return
}
// Copy the body so we never retain a slice that the caller may
// later reuse or mutate.
stored := make([]byte, len(body))
copy(stored, body)
elem := c.ll.PushFront(&cachedResponse{key: key, etag: etag, body: stored})
c.entries[key] = elem
if c.ll.Len() > c.maxSize {
c.evictOldest()
}
}
// evictOldest removes the least-recently-used entry. The caller must
// hold c.mu.
func (c *responseCache) evictOldest() {
elem := c.ll.Back()
if elem == nil {
return
}
c.ll.Remove(elem)
delete(c.entries, elem.Value.(*cachedResponse).key)
}
// responseCacheKey derives a cache key that isolates responses by
// request URL and auth scope. The token is hashed rather than stored
// so that a cached entry for one user's token is never served to
// another, without keeping raw credentials in memory.
func responseCacheKey(requestURL, token string) string {
sum := sha256.Sum256([]byte(token))
return requestURL + "\x00" + hex.EncodeToString(sum[:8])
}