cache

README

caddy cache

This is a simple caching plugin for caddy server

Notice: Although this plugin works with static content it is not advised. Static content will not see great benefits. It should be used when there are slow responses, for example when using caddy as a proxy to a slow backend.

Build

Notice: Build requires Go 1.12 or higher.

To use it you need to compile your own version of caddy with this plugin. First fetch the code

• export GO111MODULE=on
• go get -u github.com/caddyserver/caddy/...
• go get -u github.com/nicolasazrak/caddy-cache/...

Then update the file in $GOPATH/src/github.com/caddyserver/caddy/caddy/caddymain/run.go and import _ "github.com/nicolasazrak/caddy-cache".

And finally build caddy with:

• cd $GOPATH/src/github.com/caddyserver/caddy/caddy
• ./build.bash

This will produce the caddy binary in that same folder. For more information about how plugins work read this doc.

Usage

Example minimal usage in Caddyfile

caddy.test {
    proxy / yourserver:5000
    cache
}

This will store in cache responses that specifically have a Cache-control, Expires or Last-Modified header set.

For more advanced usages you can use the following parameters:

• match_path: Paths to cache. For example match_path /assets will cache all successful responses for requests that start with /assets and are not marked as private.
• match_header: Matches responses that have the selected headers. For example match_header Content-Type image/png image/jpg will cache all successful responses that with content type image/png OR image/jpg. Note that if more than one is specified, anyone that matches will make the response cacheable.
• path: Path where to store the cached responses. By default it will use the operating system temp folder.
• default_max_age: Max-age to use for matched responses that do not have an explicit expiration. (Default: 5 minutes)
• status_header: Sets a header to add to the response indicating the status. It will respond with: skip, miss or hit. (Default: X-Cache-Status)
• cache_key: Configures the cache key using Placeholders, it supports any of the request placeholders. (Default: {method} {host}{path}?{query})

caddy.test {
    proxy / yourserver:5000
    cache {
        match_path /assets
        match_header Content-Type image/jpg image/png
        status_header X-Cache-Status
        default_max_age 15m
        path /tmp/caddy-cache
    }
}

Logs

Caddy-cache adds a {cache_status} placeholder that can be used in logs.

Benchmarks

Benchmark files are in benchmark folder. Tests were run on my Lenovo G480 with Intel i3 3220 and 8gb of ram.

• First test: Download sherlock.txt (608 Kb) file from the root (caddy.test3), a proxy to root server (caddy.test2) and a proxy to root server with cache (caddy.test).

  wrk -c 400 -d 30s --latency -t 4 http://caddy.test:2015/sherlock.txt

  	Req/s	Throughput	99th Latency
  proxy + cache	4548.03	2.64 GB/s	561.39 ms
  proxy	1043.61	619.65 MB/s	1.00 s
  root	3668.14	2.13 GB/s	612.39 ms

• Second test: Download montecristo.txt (2,6 Mb) file from the root (caddy.test3), a proxy to root server (caddy.test2) and a proxy to root server with cache (caddy.test).

  wrk -c 400 -d 30s --latency -t 4 http://caddy.test:2015/montecristo.txt

  	Req/s	Throughput	99th Latency
  proxy + cache	1199.81	3.01 GB/s	1.65 s
  proxy	473.14	1.20 GB/s	1.81 s
  root	1064.44	2.66 GB/s	1.71 s

• Third test: Download pg31674.txt (41 Kb) a root server (caddy.test5) with gzip and a proxy to root server with cache (caddy.test4).

  wrk -c 50 -d 30s --latency -H 'Accept-Encoding: gzip' -t 4 http://caddy.test4:2015/pg31674.txt

  	Req/s	Throughput	99th Latency
  proxy + cache	16547.84	242.05 MB/s	22.48ms
  root	792.08	11.60 MB/s	109.98ms

Todo list

• Support vary header
• Add header with cache status
• Stream responses while fetching them from upstream
• Locking concurrent requests to the same path
• File disk storage for larger objects
• Add a configuration to not use query params in cache key (via cache_key directive)
• Purge cache entries #1
• Serve stale content if proxy is down
• Punch hole cache
• Do conditional requests to revalidate data
• Max entries size

Documentation

Index

• func Setup(c *caddy.Controller) error
• type CacheRule
• type Config
• type HTTPCache
  • func NewHTTPCache(cacheKeyTemplate string) *HTTPCache
  • func (cache *HTTPCache) Get(request *http.Request) (*HTTPCacheEntry, bool)
  • func (cache *HTTPCache) Put(request *http.Request, entry *HTTPCacheEntry)
• type HTTPCacheEntry
  • func NewHTTPCacheEntry(key string, request *http.Request, response *Response, config *Config) *HTTPCacheEntry
  • func (e *HTTPCacheEntry) Clean() error
  • func (e *HTTPCacheEntry) Fresh() bool
  • func (e *HTTPCacheEntry) Key() string
  • func (e *HTTPCacheEntry) WriteBodyTo(w http.ResponseWriter) error
• type Handler
  • func NewHandler(Next httpserver.Handler, config *Config) *Handler
  • func (handler *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error)
• type HeaderCacheRule
• type PathCacheRule
• type Response
  • func NewResponse() *Response
  • func (rw *Response) Clean() error
  • func (rw *Response) Close() error
  • func (rw *Response) CloseNotify() <-chan bool
  • func (rw *Response) Flush()
  • func (rw *Response) Header() http.Header
  • func (rw *Response) SetBody(body storage.ResponseStorage)
  • func (rw *Response) WaitBody()
  • func (rw *Response) WaitClose()
  • func (rw *Response) WaitHeaders()
  • func (rw *Response) Write(buf []byte) (int, error)
  • func (rw *Response) WriteHeader(code int)
• type URLLock
  • func NewURLLock() *URLLock
  • func (allLocks *URLLock) Adquire(key string) *sync.Mutex

Functions

func Setup

func Setup(c *caddy.Controller) error

Setup creates a new cache middleware

Types

type CacheRule

type CacheRule interface {
	// contains filtered or unexported methods
}

CacheRule determines if a request should be cached

type Config

type Config struct {
	StatusHeader     string
	DefaultMaxAge    time.Duration
	LockTimeout      time.Duration
	CacheRules       []CacheRule
	Path             string
	CacheKeyTemplate string
}

type HTTPCache

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

func NewHTTPCache

func NewHTTPCache(cacheKeyTemplate string) *HTTPCache

func (*HTTPCache) Get

func (cache *HTTPCache) Get(request *http.Request) (*HTTPCacheEntry, bool)

func (*HTTPCache) Put

func (cache *HTTPCache) Put(request *http.Request, entry *HTTPCacheEntry)

type HTTPCacheEntry

type HTTPCacheEntry struct {
	Request  *http.Request
	Response *Response
	// contains filtered or unexported fields
}

HTTPCacheEntry saves the request response of an http request

func NewHTTPCacheEntry

func NewHTTPCacheEntry(key string, request *http.Request, response *Response, config *Config) *HTTPCacheEntry

NewHTTPCacheEntry creates a new HTTPCacheEntry for the given request and response and it also calculates if the response is public

func (*HTTPCacheEntry) Clean

func (e *HTTPCacheEntry) Clean() error

Clean removes the response if it has an associated file

func (*HTTPCacheEntry) Fresh

func (e *HTTPCacheEntry) Fresh() bool

Fresh returns if the entry is still fresh

func (*HTTPCacheEntry) Key

func (e *HTTPCacheEntry) Key() string

func (*HTTPCacheEntry) WriteBodyTo

func (e *HTTPCacheEntry) WriteBodyTo(w http.ResponseWriter) error

WriteBodyTo sends the body to the http.ResponseWritter

type Handler

type Handler struct {
	// Handler configuration
	Config *Config

	// Cache is where entries are stored
	Cache *HTTPCache

	// Next handler
	Next httpserver.Handler

	// Handles locking for different URLs
	URLLocks *URLLock
}

Handler is the main cache middleware

func NewHandler

func NewHandler(Next httpserver.Handler, config *Config) *Handler

NewHandler creates a new Handler using Next middleware

func (*Handler) ServeHTTP

func (handler *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error)

type HeaderCacheRule

type HeaderCacheRule struct {
	Header string
	Value  []string
}

HeaderCacheRule matches if given Header matches any of the values

type PathCacheRule

type PathCacheRule struct {
	Path string
}

PathCacheRule matches if the request starts with given Path

type Response

type Response struct {
	Code      int         // the HTTP response code from WriteHeader
	HeaderMap http.Header // the HTTP response headers
	// contains filtered or unexported fields
}

func NewResponse

func NewResponse() *Response

NewResponse returns an initialized Response.

func (*Response) Clean

func (rw *Response) Clean() error

Clean the body if it is set

func (*Response) Close

func (rw *Response) Close() error

Close means there won't be any more Writes It closes body if it was set before It should be called after SetBody using WaitBody() Otherwise body won't be closed blocking the response

func (*Response) CloseNotify

func (rw *Response) CloseNotify() <-chan bool

TODO check this

func (*Response) Flush

func (rw *Response) Flush()

func (*Response) Header

func (rw *Response) Header() http.Header

Header returns the response headers.

func (*Response) SetBody

func (rw *Response) SetBody(body storage.ResponseStorage)

func (*Response) WaitBody

func (rw *Response) WaitBody()

WaitBody blocks until body is Set

func (*Response) WaitClose

func (rw *Response) WaitClose()

WaitClose blocks until Close is called

func (*Response) WaitHeaders

func (rw *Response) WaitHeaders()

WaitHeaders blocks until headers are sent

func (*Response) Write

func (rw *Response) Write(buf []byte) (int, error)

Write is the io.Writer interface with the modification required To wait the body. This will wait until SetBody is called with The desired storage.

func (*Response) WriteHeader

func (rw *Response) WriteHeader(code int)

type URLLock

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

func NewURLLock

func NewURLLock() *URLLock

func (*URLLock) Adquire

func (allLocks *URLLock) Adquire(key string) *sync.Mutex

Adquire a lock for given key