sharedhttpcache

type CacheConfig struct {

	//CacheableMethods is a list of request methods for which responses may be cached.
	// It is not advisable to cache unsafe methods like POST. Tho it is possible to do so
	// Note that unsafe methods will not be cached even if they are in this list as per section 4 of RFC7234
	//
	// WARNING values must be uppercase, no case conversion is done at runtime
	CacheableMethods []string

	//SafeMethods is a list of "safe" request methods as defined in section 4.2.1 of RFC7231
	// Any method not in this list is considered unsafe and will not be cached
	// If a request is made with a unsafe method it may cause invalidation as per section 4.4 of RFC7234
	SafeMethods []string

	//StatusCodeDefaultExpirationTimes is a map of times index by the http response code
	//
	// These times will be used as default expiration time unless the response contains a header which specifies a different
	//
	// Not all responses should be cached for the same duration.
	// A 307 Temporary Redirect for example should be cached for less time than a 301 Moved Permanently
	//
	// Codes not appearing in this list will be considered NOT understood and thus make a response uncacheable according to section 3 of RFC7234.
	StatusCodeDefaultExpirationTimes map[int]time.Duration

	//CacheableFileExtensions is a list of cacheable file extensions
	// File extensions are used instead of MIME types because the same file extension can have separate MIME types
	// It is advised to only use static file types like stylesheets or images and not dynamic content like html
	CacheableFileExtensions []string

	//CacheIncompleteResponses enables or disables the optional feature mentioned in section 3.1 of RFC7234
	// Caching of incomplete requests will cache responses with status code 206 (Partial Content)
	//
	// Note that this carries a performance impact because ranges have to be accounted for when storing and querying the cached content
	CacheIncompleteResponses bool

	//CombinePartialResponses enables or disables the optional feature mentioned in section 3.3 of RFC7234
	// When this feature is enabled and incomplete responses are enabled
	// the caching server attempts to combine multiple incomplete responses into a complete response.
	//
	// Note that this carries a performance impact because at every time a new incomplete range is received reconstruction of the full resource will be attempted
	CombinePartialResponses bool

	//If ServeStaleOnError is true the cache will attempt to serve a stale response in case revalidation fails because the origin server returned a 5xx code or is unreachable
	//This setting respects the Cache-Control header of the client and server.
	ServeStaleOnError bool

	//If HTTPWarnings is true warnings as described in section 5.5 of RFC7234 will be added to HTTP responses
	// This is a option because the feature will be removed from future HTTP specs https://github.com/httpwg/http-core/issues/139
	HTTPWarnings bool
}

type CacheConfigResolver interface {

	//GetCacheConfig is called to resolve a CacheConfig depending on the request
	// If nil is returned the default config will be used
	GetCacheConfig(req *http.Request) *CacheConfig
}

type CacheController struct {

	//The default config is used if no host could be matched
	// if nil on first usage the default config CacheConfig from NewCacheConfig will be used
	DefaultCacheConfig *CacheConfig

	//CacheConfigResolver can optionally be set.
	// If not nil the CacheConfigResolver will be used to determine which cache config to use for a given request
	// If the CacheConfigResolver is not set the default config will always be used
	CacheConfigResolver CacheConfigResolver

	//The default transport used to contact the origin server
	// If nil the http.DefaultTransport will be used
	DefaultTransport http.RoundTripper

	//TransportResolver can optionally be set.
	// If not nil the TransportResolver will be used to determine which transport to use for a given request
	// If the TransportResolver is not set the default transport will always be used
	TransportResolver TransportResolver

	//The default config used to forward requests to the origin server
	// If nil all requests using the default config will return a 503 error
	DefaultForwardConfig *ForwardConfig

	//ForwardConfigResolver can optionally be set.
	// If not nil the ForwardConfigResolver will be used to determin which forwardConfig to use for a given request
	// If the ForwardConfigResolver is not set the DefaultForwardConfig will be used
	ForwardConfigResolver ForwardConfigResolver

	//The storage layers which will be searched, the layers are searched in order
	// Layers should be arranged from fastest to slowest
	// Faster caching layers typically have less capacity and thus will replace content sooner
	Layers []layer.CacheLayer

	//The Logger which will be used for logging
	// if nil the default logger will be used
	Logger *logrus.Logger
}

type ForwardConfig struct {
	//Can be a Hostname or a IP address and optionally the tcp port
	// if no port is specified the default http or https port is used based on the TLS variable
	Host string

	//If a https (http over TLS) connection should be used
	TLS bool
}

type ForwardConfigResolver interface {

	//GetForwardConfig is called to resolve a ForwardConfig depending on the request
	// If nil is returned the default forwardConfig will be used
	GetForwardConfig(req *http.Request) *ForwardConfig
}

type ForwardConfigResolverFunc func(req *http.Request) *ForwardConfig

type TransportResolver interface {

	//GetTransport is called to resolve a CacheConfig depending on the request
	// If nil is returned the default transport will be used
	GetTransport(req *http.Request) http.RoundTripper
}

type TransportResolverFunc func(req *http.Request) http.RoundTripper