httpcache: github.com/gregjones/httpcache Index | Files | Directories

package httpcache

import "github.com/gregjones/httpcache"

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

Package Files

httpcache.go

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.

func CachedResponse Uses

func CachedResponse(c Cache, req *http.Request) (resp *http.Response, err error)

CachedResponse returns the cached http.Response for req if present, and nil otherwise.

func Date Uses

func Date(respHeaders http.Header) (date time.Time, err error)

Date parses and returns the value of the Date header.

type Cache Uses

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 Uses

type MemoryCache struct {
    // contains filtered or unexported fields
}

MemoryCache is an implemtation of Cache that stores responses in an in-memory map.

func NewMemoryCache Uses

func NewMemoryCache() *MemoryCache

NewMemoryCache returns a new Cache that will store items in an in-memory map

func (*MemoryCache) Delete Uses

func (c *MemoryCache) Delete(key string)

Delete removes key from the cache

func (*MemoryCache) Get Uses

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 Uses

func (c *MemoryCache) Set(key string, resp []byte)

Set saves response resp to the cache with key

type Transport Uses

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
}

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 Uses

func NewMemoryCacheTransport() *Transport

NewMemoryCacheTransport returns a new Transport using the in-memory cache implementation

func NewTransport Uses

func NewTransport(c Cache) *Transport

NewTransport returns a new Transport with the provided Cache implementation and MarkCachedResponses set to true

func (*Transport) Client Uses

func (t *Transport) Client() *http.Client

Client returns an *http.Client that caches responses.

func (*Transport) RoundTrip Uses

func (t *Transport) RoundTrip(req *http.Request) (resp *http.Response, err error)

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

PathSynopsis
diskcachePackage diskcache provides an implementation of httpcache.Cache that uses the diskv package to supplement an in-memory map with persistent storage
leveldbcachePackage leveldbcache provides an implementation of httpcache.Cache that uses github.com/syndtr/goleveldb/leveldb
memcachePackage memcache provides an implementation of httpcache.Cache that uses gomemcache to store cached responses.
redisPackage redis provides a redis interface for http caching.

Package httpcache imports 10 packages (graph) and is imported by 175 packages. Updated 2018-11-10. Refresh now. Tools for package owners.