README
¶
sniperkit-httpcache
=========
[WIP]
Summary
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).
Cache Backends
Defaults
- The built-in 'memory' cache stores responses in an in-memory map.
Memory
plugins/lruprovides an in-memory cache that will evict least-recently used entries. (original:github.com/die-net/lrucache)plugins/lru/twotierallows caches to be combined, for example to use lrucache above with a persistent disk-cache. (original:github.com/die-net/lrucache/twotier)
File System - Storage
Local
github.com/gregjones/httpcache/diskcacheprovides a filesystem-backed cache using the diskv library.plugins/bboltplugins/boltdb-gzipplugins/boltdb-ttlplugins/stormplugins/leveldbprovides a filesystem-backed cache using leveldb.
Cloud
plugins/azurestorageuses Azure Storage service. (original:github.com/PaulARoy/azurestoragecache)plugins/gcsuses Google cloud service engine. (original:github.com/PaulARoy/azurestoragecache)plugins/diskv/s3uses Amazon S3 for storage. (original:github.com/sourcegraph/s3cache)
KV
plugins/etcd/v2provides etcd api v2 implentationplugins/etcd/v3provides etcd api v3 implentationplugins/e3chprovides etcd api v3 implentation with hierarchyplugins/memcacheprovides memcache implementations, for both App Engine and 'normal' memcache servers. (Original:memcache)
RDB
plugins/gormprovides gorm implementations, mainly for debugging and development
Getting started
Below is a basic example of usage.
func httpCacheExample() {
numOfRequests := 0
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Cache-Control", fmt.Sprintf("private, max-age=10"))
if numOfRequests == 0 {
w.Write([]byte("Hello!"))
} else {
w.Write([]byte("Goodbye!"))
}
numOfRequests++
}))
httpClient := &http.Client{
Transport: httpcache.NewMemoryCacheTransport(),
}
makeRequest(ts, httpClient) // "Hello!"
// The second request is under max-age, so the cache is used rather than hitting the server
makeRequest(ts, httpClient) // "Hello!"
// Sleep so the max-age is passed
time.Sleep(time.Second * 11)
makeRequest(ts, httpClient) // "Goodbye!"
}
func makeRequest(ts *httptest.Server, httpClient *http.Client) {
resp, _ := httpClient.Get(ts.URL)
var buf bytes.Buffer
io.Copy(&buf, resp.Body)
println(buf.String())
}
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
- Variables
- func CachedResponse(c Cache, req *http.Request) (resp *http.Response, err error)
- func Date(respHeaders http.Header) (date time.Time, err error)
- func NewBlockingTransport(rt http.RoundTripper) http.RoundTripper
- type BlockingTransport
- type Cache
- type CustomTransport
- type ETagTransport
- type MemoryCache
- type NotFound
- type Transport
Constants ¶
View Source
const (
XFromCache = "X-From-Cache" // XFromCache is the header added to responses that are returned from the cache
)
Variables ¶
View Source
var ( RequestBufferSize int = 8192 ResponseBufferSize int = 8192 Verbose bool Debug bool )
View Source
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 NewBlockingTransport ¶
func NewBlockingTransport(rt http.RoundTripper) http.RoundTripper
Types ¶
type BlockingTransport ¶
type BlockingTransport struct {
Transport http.RoundTripper
// contains filtered or unexported fields
}
type Cache ¶
type Cache interface {
Get(key string) (responseBytes []byte, ok bool) // Get returns the []byte representation of a cached response and a bool set to true if the value isn't empty
Set(key string, responseBytes []byte) // Set stores the []byte representation of a response against a key
Delete(key string) // Delete removes the value associated with the key
}
A Cache interface is used by the Transport to store and retrieve responses.
type CustomTransport ¶
type CustomTransport struct {
Transport http.RoundTripper
MaxStale int //seconds
Debug bool
}
type ETagTransport ¶
type ETagTransport struct {
ETag string
}
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
Debug bool
// contains filtered or unexported fields
}
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) Pester ¶
Refs: - https://github.com/evepraisal/go-evepraisal/blob/master/evepraisal/app.go#L48-L71
control the resiliency
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.
Source Files
¶
Directories
¶
| Path | Synopsis |
|---|---|
|
plugins
|
|
|
azurestorage
Package azurestorage provides an implementation of httpcache.Cache that stores and retrieves data using Azure Storage.
|
Package azurestorage provides an implementation of httpcache.Cache that stores and retrieves data using Azure Storage. |
|
bolt-lru
This package provides a simple LRU cache backed by boltdb It is based on the LRU implementation in groupcache: https://github.com/golang/groupcache/tree/master/lru
|
This package provides a simple LRU cache backed by boltdb It is based on the LRU implementation in groupcache: https://github.com/golang/groupcache/tree/master/lru |
|
couchdb
Package couchcache provides an implementation of httpcache.Cache that stores and retrieves data using Couchdb.
|
Package couchcache provides an implementation of httpcache.Cache that stores and retrieves data using Couchdb. |
|
diskv
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 |
|
diskv/s3/s3cache
Package s3cache provides an httpcache.Cache implementation that stores cached values on Amazon S3.
|
Package s3cache provides an httpcache.Cache implementation that stores cached values on Amazon S3. |
|
forward/consistenthash
Package consistenthash provides an implementation of a ring hash.
|
Package consistenthash provides an implementation of a ring hash. |
|
forward/lru
Package lru provides an lru cache algorithm over an existing cache.
|
Package lru provides an lru cache algorithm over an existing cache. |
|
leveldb
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 |
|
lru
Package lrucache provides a byte-size-limited implementation of httpcache.Cache that stores data in memory.
|
Package lrucache provides a byte-size-limited implementation of httpcache.Cache that stores data in memory. |
|
lru/twotier
Package twotier provides a wrapper for two httpcache.Cache instances, allowing you to use both a small and fast cache for popular objects and fall back to a larger and slower cache for less popular ones.
|
Package twotier provides a wrapper for two httpcache.Cache instances, allowing you to use both a small and fast cache for popular objects and fall back to a larger and slower cache for less popular ones. |
|
memcache
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. |
|
memcached
Package couchcache provides an implementation of httpcache.Cache that stores and retrieves data using Memcached.
|
Package couchcache provides an implementation of httpcache.Cache that stores and retrieves data using Memcached. |
|
redigo
Package redis provides a redis interface for http caching.
|
Package redis provides a redis interface for http caching. |
|
redis
Package rediscache provides an implementation of httpcache.Cache that stores and retrieves data using Redis.
|
Package rediscache provides an implementation of httpcache.Cache that stores and retrieves data using Redis. |
|
seaweedfs
Package seaweedfscache provides an implementation of httpcache.Cache that stores and retrieves data using Seaweedfs.
|
Package seaweedfscache provides an implementation of httpcache.Cache that stores and retrieves data using Seaweedfs. |
Click to show internal directories.
Click to hide internal directories.