Files
coder/coderd/externalauth/gitprovider/conditional.go
T
Michael Suchacz e8dcf9a3f1 fix: anchor golangci .git exclusion and fix hidden findings (#30621)
Stack context: two-layer stack tightening Go lint gates. This bottom
layer fixes the lint exclusion; the layer above adds new rules.

Why: a `.git` path exclusion in the golangci config was hiding Go files,
masking 70 findings. This fixes the exclusion, fixes the findings
(`agent/agentgit` now runs git through `agentexec.Execer`), and adds a
`make lint/go` check that fails when an exclusion hides Go files. `make
lint/go` now waits for a concurrent golangci-lint run instead of
failing. The exhaustruct exclusion rule for `scripts/*` had the same
problem: as a regex it also matched `agent/agentscripts` and
`coderd/agentapi/scripts.go`, so it is now `^scripts/`.

Validation: full-tree lint reports 0 issues; the new check fails on the
old entry and passes on the new one.

> Xum acted for Mike to open and update this PR.
2026-10-13 07:57:56 +00:00

138 lines
4.2 KiB
Go

package gitprovider
import (
"bytes"
"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. Sized above the gitsync worker's steady-state
// working set: defaultBatchSize (50) rows re-acquired every
// DiffStatusTTL (120s) over defaultInterval (10s) ticks, at 2-3
// cache keys per row. See coderd/x/gitsync.
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. The returned body aliases
// the cache's copy and must not be mutated.
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 := cachedEntry(elem)
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
}
stored := bytes.Clone(body)
c.mu.Lock()
defer c.mu.Unlock()
if elem, found := c.entries[key]; found {
c.ll.MoveToFront(elem)
cr := cachedEntry(elem)
cr.etag = etag
// Replace the body slice entirely; never write into the
// existing slice in place. A concurrent reader may hold a
// reference to the old slice while json.Unmarshal is reading
// it.
cr.body = stored
return
}
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, cachedEntry(elem).key)
}
func cachedEntry(elem *list.Element) *cachedResponse {
//nolint:forcetypeassert // Only *cachedResponse values enter c.ll.
return elem.Value.(*cachedResponse)
}
// 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[:])
}