README
¶
httpcache
Package httpcache provides a http.RoundTripper implementation that works as a mostly RFC 7234 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).
This project isn't actively maintained; it works for what I, and seemingly others, want to do with it, and I consider it "done". That said, if you find any issues, please open a Pull Request and I will try to review it. Any changes now that change the public API won't be considered.
Cache Backends
- The built-in 'memory' cache stores responses in an in-memory map.
github.com/gregjones/httpcache/diskcacheprovides a filesystem-backed cache using the diskv library.github.com/gregjones/httpcache/memcacheprovides memcache implementations, for both App Engine and 'normal' memcache servers.sourcegraph.com/sourcegraph/s3cacheuses Amazon S3 for storage.github.com/gregjones/httpcache/leveldbcacheprovides a filesystem-backed cache using leveldb.github.com/die-net/lrucacheprovides an in-memory cache that will evict least-recently used entries.github.com/die-net/lrucache/twotierallows caches to be combined, for example to use lrucache above with a persistent disk-cache.github.com/birkelund/boltdbcacheprovides a BoltDB implementation (based on the bbolt fork).
If you implement any other backend and wish it to be linked here, please send a PR editing this file.
License
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-From-Cache"
)
Variables ¶
var ErrNoDateHeader = errors.New("no Date header")
ErrNoDateHeader indicates that the HTTP headers contained no Date header.
Functions ¶
func CachedResponse ¶
CachedResponse returns the cached http.Response for req if present, and nil otherwise.
func DumpResponse ¶
DumpResponse is mostly a copy of httputil.DumpResponse, but it supports copying with more efficient memory usage. The only change is that the helper drainBody method now takes in an expected length, so that the byte buffer can be properly allocated ahead of time.
Types ¶
type Cache ¶
type Cache interface {
// 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 []byte, ok bool)
// Set stores the []byte representation of a response against a key
Set(key string, responseBytes []byte)
// 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 []byte, ok bool)
Get returns the []byte representation of the response and true if present, false if not
func (*MemoryCache) Set ¶
func (c *MemoryCache) Set(key string, resp []byte)
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
// A map of strings representing values in a "Vary" header. When specified, values in the
// VaryIgnoreMask will not be assessed when determining whether a request should hit or
// bypass the cache. It will also prevent the addition of a `"X-Varied"+header` in the
// response. This is useful, for example, if you don't want to cache the contents of
// an Authorization header. Strings passed into this mask should be canonical headers.
VaryIgnoreMask map[string]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 ¶
func NewTransport(c Cache, options ...TransportOption) *Transport
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.
type TransportOption ¶
func WithVaryIgnoreMask ¶
func WithVaryIgnoreMask(headers ...string) TransportOption
Adds the provided headers to the VaryIgnoreMask on the Transport.
Source Files
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. |