fhttp

Documentation

Index

• Variables
• func GetMaxAge(reqCtx *fasthttp.RequestCtx) entry.LifeChanger
• func NoCache(reqCtx *fasthttp.RequestCtx)
• type ClientHandler
  • func NewClientHandler(bodyHandler fasthttp.RequestHandler, life time.Duration, remote string) *ClientHandler
  • func (h *ClientHandler) AddRule(r rule.Rule) *ClientHandler
  • func (h *ClientHandler) Rule(r rule.Rule) *ClientHandler
  • func (h *ClientHandler) ServeHTTP(reqCtx *fasthttp.RequestCtx)
• type Handler
  • func NewHandler(bodyHandler fasthttp.RequestHandler, expireDuration time.Duration) *Handler
  • func (h *Handler) AddRule(r rule.Rule) *Handler
  • func (h *Handler) Rule(r rule.Rule) *Handler
  • func (h *Handler) ServeHTTP(reqCtx *fasthttp.RequestCtx)

Variables

var ClientFasthttp = &fasthttp.Client{WriteTimeout: cfg.RequestCacheTimeout, ReadTimeout: cfg.RequestCacheTimeout}

ClientFasthttp is used inside the global RequestFasthttp function this client is an exported variable because the maybe the remote cache service is running behind ssl, in that case you are able to set a Transport inside it

var DefaultRuleSet = rule.Chained(

	rule.HeaderClaim(ruleset.AuthorizationRule),

	rule.HeaderClaim(ruleset.MustRevalidateRule),
	rule.HeaderClaim(ruleset.ZeroMaxAgeRule),

	rule.Header(ruleset.NoCacheRule, ruleset.NoCacheRule),
)

DefaultRuleSet is a list of the default pre-cache validators which exists in ALL handlers, local and remote.

Functions

func GetMaxAge

func GetMaxAge(reqCtx *fasthttp.RequestCtx) entry.LifeChanger

GetMaxAge parses the "Cache-Control" header and returns a LifeChanger which can be passed to the response's Reset

func NoCache

func NoCache(reqCtx *fasthttp.RequestCtx)

NoCache called when a particular handler is not valid for cache. If this function called inside a handler then the handler is not cached.

Types

type ClientHandler

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

ClientHandler is the client-side handler for each of the cached route paths's response register one client handler per route.

it's just calls a remote cache service server/handler,

which lives on other, external machine.

func NewClientHandler

func NewClientHandler(bodyHandler fasthttp.RequestHandler, life time.Duration, remote string) *ClientHandler

NewClientHandler returns a new remote client handler which asks the remote handler the cached entry's response with a GET request, or add a response with POST request these all are done automatically, users can use this handler as they use the local.go/NewHandler

the ClientHandler is useful when user wants to apply horizontal scaling to the app and has a central http server which handles

func (*ClientHandler) AddRule

func (h *ClientHandler) AddRule(r rule.Rule) *ClientHandler

AddRule adds a rule in the chain, the default rules are executed first.

returns itself.

func (*ClientHandler) Rule

func (h *ClientHandler) Rule(r rule.Rule) *ClientHandler

Rule sets the ruleset for this handler. returns itself.

func (*ClientHandler) ServeHTTP

func (h *ClientHandler) ServeHTTP(reqCtx *fasthttp.RequestCtx)

ServeHTTP , or remote cache client whatever you like, it's the client-side function of the ServeHTTP sends a request to the server-side remote cache Service and sends the cached response to the frontend client it is used only when you achieved something like horizontal scaling (separate machines) look ../remote/remote.ServeHTTP for more

if cache din't find then it sends a POST request and save the bodyHandler's body to the remote cache.

It takes 3 parameters the first is the remote address (it's the address you started your http server which handled by the Service.ServeHTTP) the second is the handler (or the mux) you want to cache and the third is the, optionally, cache expiration, which is used to set cache duration of this specific cache entry to the remote cache service if <=minimumAllowedCacheDuration then the server will try to parse from "cache-control" header

client-side function

type Handler

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

Handler the fasthttp cache service handler

func NewHandler

func NewHandler(bodyHandler fasthttp.RequestHandler,
	expireDuration time.Duration) *Handler

NewHandler returns a new cached handler

func (*Handler) AddRule

func (h *Handler) AddRule(r rule.Rule) *Handler

AddRule adds a rule in the chain, the default rules are executed first.

returns itself.

func (*Handler) Rule

func (h *Handler) Rule(r rule.Rule) *Handler

Rule sets the rule for this handler, see internal/net/http/rule.go for more information.

returns itself.

func (*Handler) ServeHTTP

func (h *Handler) ServeHTTP(reqCtx *fasthttp.RequestCtx)