Documentation ¶
Overview ¶
Package httpcache provides a http.RoundTripper implementation that works as a mostly RFC-compliant cache for http responses.
It is only suitable for use as a 'private' cache (i.e. for a web-browser or an API-client and not for a shared proxy).
Index ¶
Constants ¶
const (
// XFromCache is the header added to responses that are returned from the cache
XFromCache = "X-Proxy-Cache"
)
Variables ¶
var CacheRangeContextKey = &contextKey{"cache-range"}
CacheRangeContextKey -
var ErrNoDateHeader = errors.New("no Date header")
ErrNoDateHeader indicates that the HTTP headers contained no Date header.
var FreshnessToString = map[int]string{ // contains filtered or unexported fields }
FreshnessToString map
var NotModifiedDelHeaders = []string{
"Content-Length",
"Content-Type",
"Last-Modified",
"Status",
}
NotModifiedDelHeaders -
var ProxyCachedToString = map[int]string{
0: "no-cache",
1: "cached",
}
ProxyCachedToString map
var ProxyFromCacheToString = map[int]string{
0: "miss",
1: "hit",
}
ProxyFromCacheToString map
var ProxyStaleClientToString = map[int]string{
-1: "use-none",
0: "use-cache-header",
1: "use-client-header",
}
ProxyStaleClientToString map
var ProxyWriteCacheToString = map[int]string{
0: "no-store",
1: "store",
}
ProxyWriteCacheToString map
Functions ¶
func CachedResponse ¶
CachedResponse returns the cached http.Response for req if present, and nil otherwise.
Types ¶
type Cache ¶
type Cache interface { // Has returns whether key has been cached Has(key string) (ok bool) // Get returns the []byte representation of a cached response and a bool // set to true if the value isn't empty Get(key string) (responseBytes io.ReadCloser, ok bool) // Set stores the []byte representation of a response against a key Set(key string, responseBytes io.ReadCloser) // Delete removes the value associated with the key Delete(key string) }
A Cache interface is used by the Transport to store and retrieve responses.
type MemoryCache ¶
type MemoryCache struct {
// contains filtered or unexported fields
}
MemoryCache is an implemtation of Cache that stores responses in an in-memory map.
func NewMemoryCache ¶
func NewMemoryCache() *MemoryCache
NewMemoryCache returns a new Cache that will store items in an in-memory map
func (*MemoryCache) Delete ¶
func (c *MemoryCache) Delete(key string)
Delete removes key from the cache
func (*MemoryCache) Get ¶
func (c *MemoryCache) Get(key string) (resp io.ReadCloser, ok bool)
Get returns the []byte representation of the response and true if present, false if not
func (*MemoryCache) Has ¶
func (c *MemoryCache) Has(key string) (ok bool)
Has returns whether key has been cached
func (*MemoryCache) Set ¶
func (c *MemoryCache) Set(key string, resp io.ReadCloser)
Set saves response resp to the cache with key
type Transport ¶
type Transport struct { // The RoundTripper interface actually used to make requests // If nil, http.DefaultTransport is used Transport http.RoundTripper Cache Cache // If true, responses returned from the cache will be given an extra header, X-From-Cache MarkCachedResponses bool CanCache func(req *http.Request, resp *http.Response) bool }
Transport is an implementation of http.RoundTripper that will return values from a cache where possible (avoiding a network request) and will additionally add validators (etag/if-modified-since) to repeated requests allowing servers to return 304 / Not Modified
func NewMemoryCacheTransport ¶
func NewMemoryCacheTransport() *Transport
NewMemoryCacheTransport returns a new Transport using the in-memory cache implementation
func NewTransport ¶
NewTransport returns a new Transport with the provided Cache implementation and MarkCachedResponses set to true
func (*Transport) RoundTrip ¶
RoundTrip takes a Request and returns a Response
If there is a fresh Response already in cache, then it will be returned without connecting to the server.
If there is a stale Response, then any validators it contains will be set on the new request to give the server a chance to respond with NotModified. If this happens, then the cached Response will be returned.
Directories ¶
Path | Synopsis |
---|---|
Package diskcache provides an implementation of httpcache.Cache that uses the diskv package to supplement an in-memory map with persistent storage
|
Package diskcache provides an implementation of httpcache.Cache that uses the diskv package to supplement an in-memory map with persistent storage |
Package leveldbcache provides an implementation of httpcache.Cache that uses github.com/syndtr/goleveldb/leveldb
|
Package leveldbcache provides an implementation of httpcache.Cache that uses github.com/syndtr/goleveldb/leveldb |
Package memcache provides an implementation of httpcache.Cache that uses gomemcache to store cached responses.
|
Package memcache provides an implementation of httpcache.Cache that uses gomemcache to store cached responses. |
Package redis provides a redis interface for http caching.
|
Package redis provides a redis interface for http caching. |