Documentation

Index

Constants

View Source
const (
	DefaultBodyLimit            = 4 * 1024 * 1024
	DefaultConcurrency          = 256 * 1024
	DefaultReadBufferSize       = 4096
	DefaultWriteBufferSize      = 4096
	DefaultCompressedFileSuffix = ".fiber.gz"
)

    Default Config values

    View Source
    const (
    	MethodGet     = "GET"     // RFC 7231, 4.3.1
    	MethodHead    = "HEAD"    // RFC 7231, 4.3.2
    	MethodPost    = "POST"    // RFC 7231, 4.3.3
    	MethodPut     = "PUT"     // RFC 7231, 4.3.4
    	MethodPatch   = "PATCH"   // RFC 5789
    	MethodDelete  = "DELETE"  // RFC 7231, 4.3.5
    	MethodConnect = "CONNECT" // RFC 7231, 4.3.6
    	MethodOptions = "OPTIONS" // RFC 7231, 4.3.7
    	MethodTrace   = "TRACE"   // RFC 7231, 4.3.8
    
    )

      HTTP methods were copied from net/http.

      View Source
      const (
      	MIMETextXML               = "text/xml"
      	MIMETextHTML              = "text/html"
      	MIMETextPlain             = "text/plain"
      	MIMEApplicationXML        = "application/xml"
      	MIMEApplicationJSON       = "application/json"
      	MIMEApplicationJavaScript = "application/javascript"
      	MIMEApplicationForm       = "application/x-www-form-urlencoded"
      	MIMEOctetStream           = "application/octet-stream"
      	MIMEMultipartForm         = "multipart/form-data"
      
      	MIMETextXMLCharsetUTF8               = "text/xml; charset=utf-8"
      	MIMETextHTMLCharsetUTF8              = "text/html; charset=utf-8"
      	MIMETextPlainCharsetUTF8             = "text/plain; charset=utf-8"
      	MIMEApplicationXMLCharsetUTF8        = "application/xml; charset=utf-8"
      	MIMEApplicationJSONCharsetUTF8       = "application/json; charset=utf-8"
      	MIMEApplicationJavaScriptCharsetUTF8 = "application/javascript; charset=utf-8"
      )

        MIME types that are commonly used

        View Source
        const (
        	StatusContinue                      = 100 // RFC 7231, 6.2.1
        	StatusSwitchingProtocols            = 101 // RFC 7231, 6.2.2
        	StatusProcessing                    = 102 // RFC 2518, 10.1
        	StatusEarlyHints                    = 103 // RFC 8297
        	StatusOK                            = 200 // RFC 7231, 6.3.1
        	StatusCreated                       = 201 // RFC 7231, 6.3.2
        	StatusAccepted                      = 202 // RFC 7231, 6.3.3
        	StatusNonAuthoritativeInformation   = 203 // RFC 7231, 6.3.4
        	StatusNoContent                     = 204 // RFC 7231, 6.3.5
        	StatusResetContent                  = 205 // RFC 7231, 6.3.6
        	StatusPartialContent                = 206 // RFC 7233, 4.1
        	StatusMultiStatus                   = 207 // RFC 4918, 11.1
        	StatusAlreadyReported               = 208 // RFC 5842, 7.1
        	StatusIMUsed                        = 226 // RFC 3229, 10.4.1
        	StatusMultipleChoices               = 300 // RFC 7231, 6.4.1
        	StatusMovedPermanently              = 301 // RFC 7231, 6.4.2
        	StatusFound                         = 302 // RFC 7231, 6.4.3
        	StatusSeeOther                      = 303 // RFC 7231, 6.4.4
        	StatusNotModified                   = 304 // RFC 7232, 4.1
        	StatusUseProxy                      = 305 // RFC 7231, 6.4.5
        	StatusTemporaryRedirect             = 307 // RFC 7231, 6.4.7
        	StatusPermanentRedirect             = 308 // RFC 7538, 3
        	StatusBadRequest                    = 400 // RFC 7231, 6.5.1
        	StatusUnauthorized                  = 401 // RFC 7235, 3.1
        	StatusPaymentRequired               = 402 // RFC 7231, 6.5.2
        	StatusForbidden                     = 403 // RFC 7231, 6.5.3
        	StatusNotFound                      = 404 // RFC 7231, 6.5.4
        	StatusMethodNotAllowed              = 405 // RFC 7231, 6.5.5
        	StatusNotAcceptable                 = 406 // RFC 7231, 6.5.6
        	StatusProxyAuthRequired             = 407 // RFC 7235, 3.2
        	StatusRequestTimeout                = 408 // RFC 7231, 6.5.7
        	StatusConflict                      = 409 // RFC 7231, 6.5.8
        	StatusGone                          = 410 // RFC 7231, 6.5.9
        	StatusLengthRequired                = 411 // RFC 7231, 6.5.10
        	StatusPreconditionFailed            = 412 // RFC 7232, 4.2
        	StatusRequestEntityTooLarge         = 413 // RFC 7231, 6.5.11
        	StatusRequestURITooLong             = 414 // RFC 7231, 6.5.12
        	StatusUnsupportedMediaType          = 415 // RFC 7231, 6.5.13
        	StatusRequestedRangeNotSatisfiable  = 416 // RFC 7233, 4.4
        	StatusExpectationFailed             = 417 // RFC 7231, 6.5.14
        	StatusTeapot                        = 418 // RFC 7168, 2.3.3
        	StatusMisdirectedRequest            = 421 // RFC 7540, 9.1.2
        	StatusUnprocessableEntity           = 422 // RFC 4918, 11.2
        	StatusLocked                        = 423 // RFC 4918, 11.3
        	StatusFailedDependency              = 424 // RFC 4918, 11.4
        	StatusTooEarly                      = 425 // RFC 8470, 5.2.
        	StatusUpgradeRequired               = 426 // RFC 7231, 6.5.15
        	StatusPreconditionRequired          = 428 // RFC 6585, 3
        	StatusTooManyRequests               = 429 // RFC 6585, 4
        	StatusRequestHeaderFieldsTooLarge   = 431 // RFC 6585, 5
        	StatusUnavailableForLegalReasons    = 451 // RFC 7725, 3
        	StatusInternalServerError           = 500 // RFC 7231, 6.6.1
        	StatusNotImplemented                = 501 // RFC 7231, 6.6.2
        	StatusBadGateway                    = 502 // RFC 7231, 6.6.3
        	StatusServiceUnavailable            = 503 // RFC 7231, 6.6.4
        	StatusGatewayTimeout                = 504 // RFC 7231, 6.6.5
        	StatusHTTPVersionNotSupported       = 505 // RFC 7231, 6.6.6
        	StatusVariantAlsoNegotiates         = 506 // RFC 2295, 8.1
        	StatusInsufficientStorage           = 507 // RFC 4918, 11.5
        	StatusLoopDetected                  = 508 // RFC 5842, 7.2
        	StatusNotExtended                   = 510 // RFC 2774, 7
        	StatusNetworkAuthenticationRequired = 511 // RFC 6585, 6
        )

          HTTP status codes were copied from net/http.

          View Source
          const (
          	HeaderAuthorization                   = "Authorization"
          	HeaderProxyAuthenticate               = "Proxy-Authenticate"
          	HeaderProxyAuthorization              = "Proxy-Authorization"
          	HeaderWWWAuthenticate                 = "WWW-Authenticate"
          	HeaderAge                             = "Age"
          	HeaderCacheControl                    = "Cache-Control"
          	HeaderClearSiteData                   = "Clear-Site-Data"
          	HeaderExpires                         = "Expires"
          	HeaderPragma                          = "Pragma"
          	HeaderWarning                         = "Warning"
          	HeaderAcceptCH                        = "Accept-CH"
          	HeaderAcceptCHLifetime                = "Accept-CH-Lifetime"
          	HeaderContentDPR                      = "Content-DPR"
          	HeaderDPR                             = "DPR"
          	HeaderEarlyData                       = "Early-Data"
          	HeaderSaveData                        = "Save-Data"
          	HeaderViewportWidth                   = "Viewport-Width"
          	HeaderWidth                           = "Width"
          	HeaderETag                            = "ETag"
          	HeaderIfMatch                         = "If-Match"
          	HeaderIfModifiedSince                 = "If-Modified-Since"
          	HeaderIfNoneMatch                     = "If-None-Match"
          	HeaderIfUnmodifiedSince               = "If-Unmodified-Since"
          	HeaderLastModified                    = "Last-Modified"
          	HeaderVary                            = "Vary"
          	HeaderConnection                      = "Connection"
          	HeaderKeepAlive                       = "Keep-Alive"
          	HeaderAccept                          = "Accept"
          	HeaderAcceptCharset                   = "Accept-Charset"
          	HeaderAcceptEncoding                  = "Accept-Encoding"
          	HeaderAcceptLanguage                  = "Accept-Language"
          	HeaderCookie                          = "Cookie"
          	HeaderExpect                          = "Expect"
          	HeaderMaxForwards                     = "Max-Forwards"
          	HeaderSetCookie                       = "Set-Cookie"
          	HeaderAccessControlAllowCredentials   = "Access-Control-Allow-Credentials"
          	HeaderAccessControlAllowHeaders       = "Access-Control-Allow-Headers"
          	HeaderAccessControlAllowMethods       = "Access-Control-Allow-Methods"
          	HeaderAccessControlAllowOrigin        = "Access-Control-Allow-Origin"
          	HeaderAccessControlExposeHeaders      = "Access-Control-Expose-Headers"
          	HeaderAccessControlMaxAge             = "Access-Control-Max-Age"
          	HeaderAccessControlRequestHeaders     = "Access-Control-Request-Headers"
          	HeaderAccessControlRequestMethod      = "Access-Control-Request-Method"
          	HeaderOrigin                          = "Origin"
          	HeaderTimingAllowOrigin               = "Timing-Allow-Origin"
          	HeaderXPermittedCrossDomainPolicies   = "X-Permitted-Cross-Domain-Policies"
          	HeaderDNT                             = "DNT"
          	HeaderTk                              = "Tk"
          	HeaderContentDisposition              = "Content-Disposition"
          	HeaderContentEncoding                 = "Content-Encoding"
          	HeaderContentLanguage                 = "Content-Language"
          	HeaderContentLength                   = "Content-Length"
          	HeaderContentLocation                 = "Content-Location"
          	HeaderContentType                     = "Content-Type"
          	HeaderForwarded                       = "Forwarded"
          	HeaderVia                             = "Via"
          	HeaderXForwardedFor                   = "X-Forwarded-For"
          	HeaderXForwardedHost                  = "X-Forwarded-Host"
          	HeaderXForwardedProto                 = "X-Forwarded-Proto"
          	HeaderXForwardedProtocol              = "X-Forwarded-Protocol"
          	HeaderXForwardedSsl                   = "X-Forwarded-Ssl"
          	HeaderXUrlScheme                      = "X-Url-Scheme"
          	HeaderLocation                        = "Location"
          	HeaderFrom                            = "From"
          	HeaderHost                            = "Host"
          	HeaderReferer                         = "Referer"
          	HeaderReferrerPolicy                  = "Referrer-Policy"
          	HeaderUserAgent                       = "User-Agent"
          	HeaderAllow                           = "Allow"
          	HeaderServer                          = "Server"
          	HeaderAcceptRanges                    = "Accept-Ranges"
          	HeaderContentRange                    = "Content-Range"
          	HeaderIfRange                         = "If-Range"
          	HeaderRange                           = "Range"
          	HeaderContentSecurityPolicy           = "Content-Security-Policy"
          	HeaderContentSecurityPolicyReportOnly = "Content-Security-Policy-Report-Only"
          	HeaderCrossOriginResourcePolicy       = "Cross-Origin-Resource-Policy"
          	HeaderExpectCT                        = "Expect-CT"
          	HeaderFeaturePolicy                   = "Feature-Policy"
          	HeaderPublicKeyPins                   = "Public-Key-Pins"
          	HeaderPublicKeyPinsReportOnly         = "Public-Key-Pins-Report-Only"
          	HeaderStrictTransportSecurity         = "Strict-Transport-Security"
          	HeaderUpgradeInsecureRequests         = "Upgrade-Insecure-Requests"
          	HeaderXContentTypeOptions             = "X-Content-Type-Options"
          	HeaderXDownloadOptions                = "X-Download-Options"
          	HeaderXFrameOptions                   = "X-Frame-Options"
          	HeaderXPoweredBy                      = "X-Powered-By"
          	HeaderXXSSProtection                  = "X-XSS-Protection"
          	HeaderLastEventID                     = "Last-Event-ID"
          	HeaderNEL                             = "NEL"
          	HeaderPingFrom                        = "Ping-From"
          	HeaderPingTo                          = "Ping-To"
          	HeaderReportTo                        = "Report-To"
          	HeaderTE                              = "TE"
          	HeaderTrailer                         = "Trailer"
          	HeaderTransferEncoding                = "Transfer-Encoding"
          	HeaderSecWebSocketAccept              = "Sec-WebSocket-Accept"
          	HeaderSecWebSocketExtensions          = "Sec-WebSocket-Extensions"
          	HeaderSecWebSocketKey                 = "Sec-WebSocket-Key"
          	HeaderSecWebSocketProtocol            = "Sec-WebSocket-Protocol"
          	HeaderSecWebSocketVersion             = "Sec-WebSocket-Version"
          	HeaderAcceptPatch                     = "Accept-Patch"
          	HeaderAcceptPushPolicy                = "Accept-Push-Policy"
          	HeaderAcceptSignature                 = "Accept-Signature"
          	HeaderAltSvc                          = "Alt-Svc"
          	HeaderDate                            = "Date"
          	HeaderIndex                           = "Index"
          	HeaderLargeAllocation                 = "Large-Allocation"
          	HeaderLink                            = "Link"
          	HeaderPushPolicy                      = "Push-Policy"
          	HeaderRetryAfter                      = "Retry-After"
          	HeaderServerTiming                    = "Server-Timing"
          	HeaderSignature                       = "Signature"
          	HeaderSignedHeaders                   = "Signed-Headers"
          	HeaderSourceMap                       = "SourceMap"
          	HeaderUpgrade                         = "Upgrade"
          	HeaderXDNSPrefetchControl             = "X-DNS-Prefetch-Control"
          	HeaderXPingback                       = "X-Pingback"
          	HeaderXRequestID                      = "X-Request-ID"
          	HeaderXRequestedWith                  = "X-Requested-With"
          	HeaderXRobotsTag                      = "X-Robots-Tag"
          	HeaderXUACompatible                   = "X-UA-Compatible"
          )

            HTTP Headers were copied from net/http.

            View Source
            const (
            	NetworkTCP  = "tcp"
            	NetworkTCP4 = "tcp4"
            	NetworkTCP6 = "tcp6"
            )

              Network types that are commonly used

              View Source
              const Version = "2.8.0"

                Version of current fiber package

                Variables

                View Source
                var (
                	ErrRangeMalformed     = errors.New("range: malformed range header string")
                	ErrRangeUnsatisfiable = errors.New("range: unsatisfiable range")
                )
                View Source
                var (
                	ErrBadRequest                    = NewError(StatusBadRequest)                    // RFC 7231, 6.5.1
                	ErrUnauthorized                  = NewError(StatusUnauthorized)                  // RFC 7235, 3.1
                	ErrPaymentRequired               = NewError(StatusPaymentRequired)               // RFC 7231, 6.5.2
                	ErrForbidden                     = NewError(StatusForbidden)                     // RFC 7231, 6.5.3
                	ErrNotFound                      = NewError(StatusNotFound)                      // RFC 7231, 6.5.4
                	ErrMethodNotAllowed              = NewError(StatusMethodNotAllowed)              // RFC 7231, 6.5.5
                	ErrNotAcceptable                 = NewError(StatusNotAcceptable)                 // RFC 7231, 6.5.6
                	ErrProxyAuthRequired             = NewError(StatusProxyAuthRequired)             // RFC 7235, 3.2
                	ErrRequestTimeout                = NewError(StatusRequestTimeout)                // RFC 7231, 6.5.7
                	ErrConflict                      = NewError(StatusConflict)                      // RFC 7231, 6.5.8
                	ErrGone                          = NewError(StatusGone)                          // RFC 7231, 6.5.9
                	ErrLengthRequired                = NewError(StatusLengthRequired)                // RFC 7231, 6.5.10
                	ErrPreconditionFailed            = NewError(StatusPreconditionFailed)            // RFC 7232, 4.2
                	ErrRequestEntityTooLarge         = NewError(StatusRequestEntityTooLarge)         // RFC 7231, 6.5.11
                	ErrRequestURITooLong             = NewError(StatusRequestURITooLong)             // RFC 7231, 6.5.12
                	ErrUnsupportedMediaType          = NewError(StatusUnsupportedMediaType)          // RFC 7231, 6.5.13
                	ErrRequestedRangeNotSatisfiable  = NewError(StatusRequestedRangeNotSatisfiable)  // RFC 7233, 4.4
                	ErrExpectationFailed             = NewError(StatusExpectationFailed)             // RFC 7231, 6.5.14
                	ErrTeapot                        = NewError(StatusTeapot)                        // RFC 7168, 2.3.3
                	ErrMisdirectedRequest            = NewError(StatusMisdirectedRequest)            // RFC 7540, 9.1.2
                	ErrUnprocessableEntity           = NewError(StatusUnprocessableEntity)           // RFC 4918, 11.2
                	ErrLocked                        = NewError(StatusLocked)                        // RFC 4918, 11.3
                	ErrFailedDependency              = NewError(StatusFailedDependency)              // RFC 4918, 11.4
                	ErrTooEarly                      = NewError(StatusTooEarly)                      // RFC 8470, 5.2.
                	ErrUpgradeRequired               = NewError(StatusUpgradeRequired)               // RFC 7231, 6.5.15
                	ErrPreconditionRequired          = NewError(StatusPreconditionRequired)          // RFC 6585, 3
                	ErrTooManyRequests               = NewError(StatusTooManyRequests)               // RFC 6585, 4
                	ErrRequestHeaderFieldsTooLarge   = NewError(StatusRequestHeaderFieldsTooLarge)   // RFC 6585, 5
                	ErrUnavailableForLegalReasons    = NewError(StatusUnavailableForLegalReasons)    // RFC 7725, 3
                	ErrInternalServerError           = NewError(StatusInternalServerError)           // RFC 7231, 6.6.1
                	ErrNotImplemented                = NewError(StatusNotImplemented)                // RFC 7231, 6.6.2
                	ErrBadGateway                    = NewError(StatusBadGateway)                    // RFC 7231, 6.6.3
                	ErrServiceUnavailable            = NewError(StatusServiceUnavailable)            // RFC 7231, 6.6.4
                	ErrGatewayTimeout                = NewError(StatusGatewayTimeout)                // RFC 7231, 6.6.5
                	ErrHTTPVersionNotSupported       = NewError(StatusHTTPVersionNotSupported)       // RFC 7231, 6.6.6
                	ErrVariantAlsoNegotiates         = NewError(StatusVariantAlsoNegotiates)         // RFC 2295, 8.1
                	ErrInsufficientStorage           = NewError(StatusInsufficientStorage)           // RFC 4918, 11.5
                	ErrLoopDetected                  = NewError(StatusLoopDetected)                  // RFC 5842, 7.2
                	ErrNotExtended                   = NewError(StatusNotExtended)                   // RFC 2774, 7
                	ErrNetworkAuthenticationRequired = NewError(StatusNetworkAuthenticationRequired) // RFC 6585, 6
                )

                  Errors

                  View Source
                  var DefaultErrorHandler = func(c *Ctx, err error) error {
                  	code := StatusInternalServerError
                  	if e, ok := err.(*Error); ok {
                  		code = e.Code
                  	}
                  	c.Set(HeaderContentType, MIMETextPlainCharsetUTF8)
                  	return c.Status(code).SendString(err.Error())
                  }

                    DefaultErrorHandler that process return errors from handlers

                    Functions

                    func GetTrimmedParam

                    func GetTrimmedParam(param string) string

                      GetTrimmedParam trims the ':' & '?' from a string

                      func IsChild

                      func IsChild() bool

                        IsChild determines if the current process is a result of Prefork

                        func ReleaseAgent

                        func ReleaseAgent(a *Agent)

                          ReleaseAgent returns a acquired via AcquireAgent to Agent pool.

                          It is forbidden accessing req and/or its' members after returning it to Agent pool.

                          func ReleaseArgs

                          func ReleaseArgs(a *Args)

                            ReleaseArgs returns the object acquired via AcquireArgs to the pool.

                            String not access the released Args object, otherwise data races may occur. Copy from fasthttp

                            func ReleaseClient

                            func ReleaseClient(c *Client)

                              ReleaseClient returns c acquired via AcquireClient to client pool.

                              It is forbidden accessing req and/or its' members after returning it to client pool.

                              func ReleaseFormFile

                              func ReleaseFormFile(ff *FormFile)

                                ReleaseFormFile returns the object acquired via AcquireFormFile to the pool.

                                String not access the released FormFile object, otherwise data races may occur.

                                func ReleaseResponse

                                func ReleaseResponse(resp *Response)

                                  ReleaseResponse return resp acquired via AcquireResponse to response pool.

                                  It is forbidden accessing resp and/or its' members after returning it to response pool. Copy from fasthttp

                                  func RemoveEscapeChar

                                  func RemoveEscapeChar(word string) string

                                    RemoveEscapeChar remove escape characters

                                    Types

                                    type Agent

                                    type Agent struct {
                                    	// Name is used in User-Agent request header.
                                    	Name string
                                    
                                    	// NoDefaultUserAgentHeader when set to true, causes the default
                                    	// User-Agent header to be excluded from the Request.
                                    	NoDefaultUserAgentHeader bool
                                    
                                    	// HostClient is an embedded fasthttp HostClient
                                    	*fasthttp.HostClient
                                    	// contains filtered or unexported fields
                                    }

                                      Agent is an object storing all request data for client. Agent instance MUST NOT be used from concurrently running goroutines.

                                      func AcquireAgent

                                      func AcquireAgent() *Agent

                                        AcquireAgent returns an empty Agent instance from Agent pool.

                                        The returned Agent instance may be passed to ReleaseAgent when it is no longer needed. This allows Agent recycling, reduces GC pressure and usually improves performance.

                                        func Delete

                                        func Delete(url string) *Agent

                                          Delete sends DELETE request to the given url.

                                          func Get

                                          func Get(url string) *Agent

                                            Get returns a agent with http method GET.

                                            func Head(url string) *Agent

                                              Head returns a agent with http method HEAD.

                                              func Patch

                                              func Patch(url string) *Agent

                                                Patch sends PATCH request to the given url.

                                                func Post

                                                func Post(url string) *Agent

                                                  Post sends POST request to the given url.

                                                  func Put

                                                  func Put(url string) *Agent

                                                    Put sends PUT request to the given url.

                                                    func (*Agent) Add

                                                    func (a *Agent) Add(k, v string) *Agent

                                                      Add adds the given 'key: value' header.

                                                      Multiple headers with the same key may be added with this function. Use Set for setting a single header for the given key.

                                                      func (*Agent) AddBytesK

                                                      func (a *Agent) AddBytesK(k []byte, v string) *Agent

                                                        AddBytesK adds the given 'key: value' header.

                                                        Multiple headers with the same key may be added with this function. Use SetBytesK for setting a single header for the given key.

                                                        func (*Agent) AddBytesKV

                                                        func (a *Agent) AddBytesKV(k []byte, v []byte) *Agent

                                                          AddBytesKV adds the given 'key: value' header.

                                                          Multiple headers with the same key may be added with this function. Use SetBytesKV for setting a single header for the given key.

                                                          func (*Agent) AddBytesV

                                                          func (a *Agent) AddBytesV(k string, v []byte) *Agent

                                                            AddBytesV adds the given 'key: value' header.

                                                            Multiple headers with the same key may be added with this function. Use SetBytesV for setting a single header for the given key.

                                                            func (*Agent) BasicAuth

                                                            func (a *Agent) BasicAuth(username, password string) *Agent

                                                              BasicAuth sets URI username and password.

                                                              func (*Agent) BasicAuthBytes

                                                              func (a *Agent) BasicAuthBytes(username, password []byte) *Agent

                                                                BasicAuthBytes sets URI username and password.

                                                                func (*Agent) Body

                                                                func (a *Agent) Body(body []byte) *Agent

                                                                  Body sets request body.

                                                                  func (*Agent) BodyStream

                                                                  func (a *Agent) BodyStream(bodyStream io.Reader, bodySize int) *Agent

                                                                    BodyStream sets request body stream and, optionally body size.

                                                                    If bodySize is >= 0, then the bodyStream must provide exactly bodySize bytes before returning io.EOF.

                                                                    If bodySize < 0, then bodyStream is read until io.EOF.

                                                                    bodyStream.Close() is called after finishing reading all body data if it implements io.Closer.

                                                                    Note that GET and HEAD requests cannot have body.

                                                                    func (*Agent) BodyString

                                                                    func (a *Agent) BodyString(bodyString string) *Agent

                                                                      BodyString sets request body.

                                                                      func (*Agent) Boundary

                                                                      func (a *Agent) Boundary(boundary string) *Agent

                                                                        Boundary sets boundary for multipart form request.

                                                                        func (*Agent) Bytes

                                                                        func (a *Agent) Bytes() (code int, body []byte, errs []error)

                                                                          Bytes returns the status code, bytes body and errors of url.

                                                                          func (*Agent) ConnectionClose

                                                                          func (a *Agent) ConnectionClose() *Agent

                                                                            ConnectionClose sets 'Connection: close' header.

                                                                            func (*Agent) ContentType

                                                                            func (a *Agent) ContentType(contentType string) *Agent

                                                                              ContentType sets Content-Type header value.

                                                                              func (*Agent) ContentTypeBytes

                                                                              func (a *Agent) ContentTypeBytes(contentType []byte) *Agent

                                                                                ContentTypeBytes sets Content-Type header value.

                                                                                func (*Agent) Cookie

                                                                                func (a *Agent) Cookie(key, value string) *Agent

                                                                                  Cookie sets one 'key: value' cookie.

                                                                                  func (*Agent) CookieBytesK

                                                                                  func (a *Agent) CookieBytesK(key []byte, value string) *Agent

                                                                                    CookieBytesK sets one 'key: value' cookie.

                                                                                    func (*Agent) CookieBytesKV

                                                                                    func (a *Agent) CookieBytesKV(key, value []byte) *Agent

                                                                                      CookieBytesKV sets one 'key: value' cookie.

                                                                                      func (*Agent) Cookies

                                                                                      func (a *Agent) Cookies(kv ...string) *Agent

                                                                                        Cookies sets multiple 'key: value' cookies.

                                                                                        func (*Agent) CookiesBytesKV

                                                                                        func (a *Agent) CookiesBytesKV(kv ...[]byte) *Agent

                                                                                          CookiesBytesKV sets multiple 'key: value' cookies.

                                                                                          func (*Agent) Debug

                                                                                          func (a *Agent) Debug(w ...io.Writer) *Agent

                                                                                            Debug mode enables logging request and response detail

                                                                                            func (*Agent) Dest

                                                                                            func (a *Agent) Dest(dest []byte) *Agent

                                                                                              Dest sets custom dest.

                                                                                              The contents of dest will be replaced by the response body, if the dest is too small a new slice will be allocated.

                                                                                              func (*Agent) FileData

                                                                                              func (a *Agent) FileData(formFiles ...*FormFile) *Agent

                                                                                                FileData appends files for multipart form request.

                                                                                                It is recommended obtaining formFile via AcquireFormFile and release it manually in performance-critical code.

                                                                                                func (*Agent) Form

                                                                                                func (a *Agent) Form(args *Args) *Agent

                                                                                                  Form sends form request with body if args is non-nil.

                                                                                                  It is recommended obtaining args via AcquireArgs and release it manually in performance-critical code.

                                                                                                  func (*Agent) Host

                                                                                                  func (a *Agent) Host(host string) *Agent

                                                                                                    Host sets host for the uri.

                                                                                                    func (*Agent) HostBytes

                                                                                                    func (a *Agent) HostBytes(host []byte) *Agent

                                                                                                      HostBytes sets host for the URI.

                                                                                                      func (*Agent) InsecureSkipVerify

                                                                                                      func (a *Agent) InsecureSkipVerify() *Agent

                                                                                                        InsecureSkipVerify controls whether the Agent verifies the server certificate chain and host name.

                                                                                                        func (*Agent) JSON

                                                                                                        func (a *Agent) JSON(v interface{}) *Agent

                                                                                                          JSON sends a JSON request.

                                                                                                          func (*Agent) JSONDecoder

                                                                                                          func (a *Agent) JSONDecoder(jsonDecoder utils.JSONUnmarshal) *Agent

                                                                                                            JSONDecoder sets custom json decoder.

                                                                                                            func (*Agent) JSONEncoder

                                                                                                            func (a *Agent) JSONEncoder(jsonEncoder utils.JSONMarshal) *Agent

                                                                                                              JSONEncoder sets custom json encoder.

                                                                                                              func (*Agent) MaxRedirectsCount

                                                                                                              func (a *Agent) MaxRedirectsCount(count int) *Agent

                                                                                                                MaxRedirectsCount sets max redirect count for GET and HEAD.

                                                                                                                func (*Agent) MultipartForm

                                                                                                                func (a *Agent) MultipartForm(args *Args) *Agent

                                                                                                                  MultipartForm sends multipart form request with k-v and files.

                                                                                                                  It is recommended obtaining args via AcquireArgs and release it manually in performance-critical code.

                                                                                                                  func (*Agent) Parse

                                                                                                                  func (a *Agent) Parse() error

                                                                                                                    Parse initializes URI and HostClient.

                                                                                                                    func (*Agent) QueryString

                                                                                                                    func (a *Agent) QueryString(queryString string) *Agent

                                                                                                                      QueryString sets URI query string.

                                                                                                                      func (*Agent) QueryStringBytes

                                                                                                                      func (a *Agent) QueryStringBytes(queryString []byte) *Agent

                                                                                                                        QueryStringBytes sets URI query string.

                                                                                                                        func (*Agent) Referer

                                                                                                                        func (a *Agent) Referer(referer string) *Agent

                                                                                                                          Referer sets Referer header value.

                                                                                                                          func (*Agent) RefererBytes

                                                                                                                          func (a *Agent) RefererBytes(referer []byte) *Agent

                                                                                                                            RefererBytes sets Referer header value.

                                                                                                                            func (*Agent) Request

                                                                                                                            func (a *Agent) Request() *Request

                                                                                                                              Request returns Agent request instance.

                                                                                                                              func (*Agent) Reuse

                                                                                                                              func (a *Agent) Reuse() *Agent

                                                                                                                                Reuse enables the Agent instance to be used again after one request.

                                                                                                                                If agent is reusable, then it should be released manually when it is no longer used.

                                                                                                                                func (*Agent) SendFile

                                                                                                                                func (a *Agent) SendFile(filename string, fieldname ...string) *Agent

                                                                                                                                  SendFile reads file and appends it to multipart form request.

                                                                                                                                  func (*Agent) SendFiles

                                                                                                                                  func (a *Agent) SendFiles(filenamesAndFieldnames ...string) *Agent

                                                                                                                                    SendFiles reads files and appends them to multipart form request.

                                                                                                                                    Examples:

                                                                                                                                    SendFile("/path/to/file1", "fieldname1", "/path/to/file2")
                                                                                                                                    

                                                                                                                                    func (*Agent) Set

                                                                                                                                    func (a *Agent) Set(k, v string) *Agent

                                                                                                                                      Set sets the given 'key: value' header.

                                                                                                                                      Use Add for setting multiple header values under the same key.

                                                                                                                                      func (*Agent) SetBytesK

                                                                                                                                      func (a *Agent) SetBytesK(k []byte, v string) *Agent

                                                                                                                                        SetBytesK sets the given 'key: value' header.

                                                                                                                                        Use AddBytesK for setting multiple header values under the same key.

                                                                                                                                        func (*Agent) SetBytesKV

                                                                                                                                        func (a *Agent) SetBytesKV(k []byte, v []byte) *Agent

                                                                                                                                          SetBytesKV sets the given 'key: value' header.

                                                                                                                                          Use AddBytesKV for setting multiple header values under the same key.

                                                                                                                                          func (*Agent) SetBytesV

                                                                                                                                          func (a *Agent) SetBytesV(k string, v []byte) *Agent

                                                                                                                                            SetBytesV sets the given 'key: value' header.

                                                                                                                                            Use AddBytesV for setting multiple header values under the same key.

                                                                                                                                            func (*Agent) SetResponse

                                                                                                                                            func (a *Agent) SetResponse(customResp *Response) *Agent

                                                                                                                                              SetResponse sets custom response for the Agent instance.

                                                                                                                                              It is recommended obtaining custom response via AcquireResponse and release it manually in performance-critical code.

                                                                                                                                              func (*Agent) String

                                                                                                                                              func (a *Agent) String() (int, string, []error)

                                                                                                                                                String returns the status code, string body and errors of url.

                                                                                                                                                func (*Agent) Struct

                                                                                                                                                func (a *Agent) Struct(v interface{}) (code int, body []byte, errs []error)

                                                                                                                                                  Struct returns the status code, bytes body and errors of url. And bytes body will be unmarshalled to given v.

                                                                                                                                                  func (*Agent) TLSConfig

                                                                                                                                                  func (a *Agent) TLSConfig(config *tls.Config) *Agent

                                                                                                                                                    TLSConfig sets tls config.

                                                                                                                                                    func (*Agent) Timeout

                                                                                                                                                    func (a *Agent) Timeout(timeout time.Duration) *Agent

                                                                                                                                                      Timeout sets request timeout duration.

                                                                                                                                                      func (*Agent) UserAgent

                                                                                                                                                      func (a *Agent) UserAgent(userAgent string) *Agent

                                                                                                                                                        UserAgent sets User-Agent header value.

                                                                                                                                                        func (*Agent) UserAgentBytes

                                                                                                                                                        func (a *Agent) UserAgentBytes(userAgent []byte) *Agent

                                                                                                                                                          UserAgentBytes sets User-Agent header value.

                                                                                                                                                          func (*Agent) XML

                                                                                                                                                          func (a *Agent) XML(v interface{}) *Agent

                                                                                                                                                            XML sends an XML request.

                                                                                                                                                            type App

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

                                                                                                                                                              App denotes the Fiber application.

                                                                                                                                                              func New

                                                                                                                                                              func New(config ...Config) *App

                                                                                                                                                                New creates a new Fiber named instance.

                                                                                                                                                                app := fiber.New()
                                                                                                                                                                

                                                                                                                                                                You can pass optional configuration options by passing a Config struct:

                                                                                                                                                                app := fiber.New(fiber.Config{
                                                                                                                                                                    Prefork: true,
                                                                                                                                                                    ServerHeader: "Fiber",
                                                                                                                                                                })
                                                                                                                                                                

                                                                                                                                                                func (*App) AcquireCtx

                                                                                                                                                                func (app *App) AcquireCtx(fctx *fasthttp.RequestCtx) *Ctx

                                                                                                                                                                  AcquireCtx retrieves a new Ctx from the pool.

                                                                                                                                                                  func (*App) Add

                                                                                                                                                                  func (app *App) Add(method, path string, handlers ...Handler) Router

                                                                                                                                                                    Add allows you to specify a HTTP method to register a route

                                                                                                                                                                    func (*App) All

                                                                                                                                                                    func (app *App) All(path string, handlers ...Handler) Router

                                                                                                                                                                      All will register the handler on all HTTP methods

                                                                                                                                                                      func (*App) Config

                                                                                                                                                                      func (app *App) Config() Config

                                                                                                                                                                        Config returns the app config as value ( read-only ).

                                                                                                                                                                        func (*App) Connect

                                                                                                                                                                        func (app *App) Connect(path string, handlers ...Handler) Router

                                                                                                                                                                          Connect registers a route for CONNECT methods that establishes a tunnel to the server identified by the target resource.

                                                                                                                                                                          func (*App) Delete

                                                                                                                                                                          func (app *App) Delete(path string, handlers ...Handler) Router

                                                                                                                                                                            Delete registers a route for DELETE methods that deletes the specified resource.

                                                                                                                                                                            func (*App) Get

                                                                                                                                                                            func (app *App) Get(path string, handlers ...Handler) Router

                                                                                                                                                                              Get registers a route for GET methods that requests a representation of the specified resource. Requests using GET should only retrieve data.

                                                                                                                                                                              func (*App) Group

                                                                                                                                                                              func (app *App) Group(prefix string, handlers ...Handler) Router

                                                                                                                                                                                Group is used for Routes with common prefix to define a new sub-router with optional middleware.

                                                                                                                                                                                api := app.Group("/api")
                                                                                                                                                                                api.Get("/users", handler)
                                                                                                                                                                                

                                                                                                                                                                                func (*App) Handler

                                                                                                                                                                                func (app *App) Handler() fasthttp.RequestHandler

                                                                                                                                                                                  Handler returns the server handler.

                                                                                                                                                                                  func (*App) Head

                                                                                                                                                                                  func (app *App) Head(path string, handlers ...Handler) Router

                                                                                                                                                                                    Head registers a route for HEAD methods that asks for a response identical to that of a GET request, but without the response body.

                                                                                                                                                                                    func (*App) Listen

                                                                                                                                                                                    func (app *App) Listen(addr string) error

                                                                                                                                                                                      Listen serves HTTP requests from the given addr.

                                                                                                                                                                                      app.Listen(":8080")
                                                                                                                                                                                      app.Listen("127.0.0.1:8080")
                                                                                                                                                                                      

                                                                                                                                                                                      func (*App) ListenTLS

                                                                                                                                                                                      func (app *App) ListenTLS(addr, certFile, keyFile string) error

                                                                                                                                                                                        app.ListenTLS(":8080", "./cert.pem", "./cert.key") app.ListenTLS(":8080", "./cert.pem", "./cert.key")

                                                                                                                                                                                        func (*App) Listener

                                                                                                                                                                                        func (app *App) Listener(ln net.Listener) error

                                                                                                                                                                                          Listener can be used to pass a custom listener.

                                                                                                                                                                                          func (*App) Mount

                                                                                                                                                                                          func (app *App) Mount(prefix string, fiber *App) Router

                                                                                                                                                                                            Mount attaches another app instance as a sub-router along a routing path. It's very useful to split up a large API as many independent routers and compose them as a single service using Mount.

                                                                                                                                                                                            func (*App) Options

                                                                                                                                                                                            func (app *App) Options(path string, handlers ...Handler) Router

                                                                                                                                                                                              Options registers a route for OPTIONS methods that is used to describe the communication options for the target resource.

                                                                                                                                                                                              func (*App) Patch

                                                                                                                                                                                              func (app *App) Patch(path string, handlers ...Handler) Router

                                                                                                                                                                                                Patch registers a route for PATCH methods that is used to apply partial modifications to a resource.

                                                                                                                                                                                                func (*App) Post

                                                                                                                                                                                                func (app *App) Post(path string, handlers ...Handler) Router

                                                                                                                                                                                                  Post registers a route for POST methods that is used to submit an entity to the specified resource, often causing a change in state or side effects on the server.

                                                                                                                                                                                                  func (*App) Put

                                                                                                                                                                                                  func (app *App) Put(path string, handlers ...Handler) Router

                                                                                                                                                                                                    Put registers a route for PUT methods that replaces all current representations of the target resource with the request payload.

                                                                                                                                                                                                    func (*App) ReleaseCtx

                                                                                                                                                                                                    func (app *App) ReleaseCtx(c *Ctx)

                                                                                                                                                                                                      ReleaseCtx releases the ctx back into the pool.

                                                                                                                                                                                                      func (*App) Server

                                                                                                                                                                                                      func (app *App) Server() *fasthttp.Server

                                                                                                                                                                                                        Server returns the underlying fasthttp server

                                                                                                                                                                                                        func (*App) Shutdown

                                                                                                                                                                                                        func (app *App) Shutdown() error

                                                                                                                                                                                                          Shutdown gracefully shuts down the server without interrupting any active connections. Shutdown works by first closing all open listeners and then waiting indefinitely for all connections to return to idle and then shut down.

                                                                                                                                                                                                          Make sure the program doesn't exit and waits instead for Shutdown to return.

                                                                                                                                                                                                          Shutdown does not close keepalive connections so its recommended to set ReadTimeout to something else than 0.

                                                                                                                                                                                                          func (*App) Stack

                                                                                                                                                                                                          func (app *App) Stack() [][]*Route

                                                                                                                                                                                                            Stack returns the raw router stack.

                                                                                                                                                                                                            func (*App) Static

                                                                                                                                                                                                            func (app *App) Static(prefix, root string, config ...Static) Router

                                                                                                                                                                                                              Static will create a file server serving static files

                                                                                                                                                                                                              func (*App) Test

                                                                                                                                                                                                              func (app *App) Test(req *http.Request, msTimeout ...int) (resp *http.Response, err error)

                                                                                                                                                                                                                Test is used for internal debugging by passing a *http.Request. Timeout is optional and defaults to 1s, -1 will disable it completely.

                                                                                                                                                                                                                func (*App) Trace

                                                                                                                                                                                                                func (app *App) Trace(path string, handlers ...Handler) Router

                                                                                                                                                                                                                  Trace registers a route for TRACE methods that performs a message loop-back test along the path to the target resource.

                                                                                                                                                                                                                  func (*App) Use

                                                                                                                                                                                                                  func (app *App) Use(args ...interface{}) Router

                                                                                                                                                                                                                    Use registers a middleware route that will match requests with the provided prefix (which is optional and defaults to "/").

                                                                                                                                                                                                                    app.Use(func(c *fiber.Ctx) error {
                                                                                                                                                                                                                         return c.Next()
                                                                                                                                                                                                                    })
                                                                                                                                                                                                                    app.Use("/api", func(c *fiber.Ctx) error {
                                                                                                                                                                                                                         return c.Next()
                                                                                                                                                                                                                    })
                                                                                                                                                                                                                    app.Use("/api", handler, func(c *fiber.Ctx) error {
                                                                                                                                                                                                                         return c.Next()
                                                                                                                                                                                                                    })
                                                                                                                                                                                                                    

                                                                                                                                                                                                                    This method will match all HTTP verbs: GET, POST, PUT, HEAD etc...

                                                                                                                                                                                                                    type Args

                                                                                                                                                                                                                    type Args = fasthttp.Args

                                                                                                                                                                                                                      Args represents query arguments.

                                                                                                                                                                                                                      It is forbidden copying Args instances. Create new instances instead and use CopyTo().

                                                                                                                                                                                                                      Args instance MUST NOT be used from concurrently running goroutines. Copy from fasthttp

                                                                                                                                                                                                                      func AcquireArgs

                                                                                                                                                                                                                      func AcquireArgs() *Args

                                                                                                                                                                                                                        AcquireArgs returns an empty Args object from the pool.

                                                                                                                                                                                                                        The returned Args may be returned to the pool with ReleaseArgs when no longer needed. This allows reducing GC load. Copy from fasthttp

                                                                                                                                                                                                                        type Client

                                                                                                                                                                                                                        type Client struct {
                                                                                                                                                                                                                        	// UserAgent is used in User-Agent request header.
                                                                                                                                                                                                                        	UserAgent string
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// NoDefaultUserAgentHeader when set to true, causes the default
                                                                                                                                                                                                                        	// User-Agent header to be excluded from the Request.
                                                                                                                                                                                                                        	NoDefaultUserAgentHeader bool
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// When set by an external client of Fiber it will use the provided implementation of a
                                                                                                                                                                                                                        	// JSONMarshal
                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                        	// Allowing for flexibility in using another json library for encoding
                                                                                                                                                                                                                        	JSONEncoder utils.JSONMarshal
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// When set by an external client of Fiber it will use the provided implementation of a
                                                                                                                                                                                                                        	// JSONUnmarshal
                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                        	// Allowing for flexibility in using another json library for decoding
                                                                                                                                                                                                                        	JSONDecoder utils.JSONUnmarshal
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          Client implements http client.

                                                                                                                                                                                                                          It is safe calling Client methods from concurrently running goroutines.

                                                                                                                                                                                                                          func AcquireClient

                                                                                                                                                                                                                          func AcquireClient() *Client

                                                                                                                                                                                                                            AcquireClient returns an empty Client instance from client pool.

                                                                                                                                                                                                                            The returned Client instance may be passed to ReleaseClient when it is no longer needed. This allows Client recycling, reduces GC pressure and usually improves performance.

                                                                                                                                                                                                                            func (*Client) Delete

                                                                                                                                                                                                                            func (c *Client) Delete(url string) *Agent

                                                                                                                                                                                                                              Delete sends DELETE request to the given url.

                                                                                                                                                                                                                              func (*Client) Get

                                                                                                                                                                                                                              func (c *Client) Get(url string) *Agent

                                                                                                                                                                                                                                Get returns a agent with http method GET.

                                                                                                                                                                                                                                func (*Client) Head

                                                                                                                                                                                                                                func (c *Client) Head(url string) *Agent

                                                                                                                                                                                                                                  Head returns a agent with http method GET.

                                                                                                                                                                                                                                  func (*Client) Patch

                                                                                                                                                                                                                                  func (c *Client) Patch(url string) *Agent

                                                                                                                                                                                                                                    Patch sends PATCH request to the given url.

                                                                                                                                                                                                                                    func (*Client) Post

                                                                                                                                                                                                                                    func (c *Client) Post(url string) *Agent

                                                                                                                                                                                                                                      Post sends POST request to the given url.

                                                                                                                                                                                                                                      func (*Client) Put

                                                                                                                                                                                                                                      func (c *Client) Put(url string) *Agent

                                                                                                                                                                                                                                        Put sends PUT request to the given url.

                                                                                                                                                                                                                                        type Config

                                                                                                                                                                                                                                        type Config struct {
                                                                                                                                                                                                                                        	// When set to true, this will spawn multiple Go processes listening on the same port.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	Prefork bool `json:"prefork"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Enables the "Server: value" HTTP header.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: ""
                                                                                                                                                                                                                                        	ServerHeader string `json:"server_header"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// When set to true, the router treats "/foo" and "/foo/" as different.
                                                                                                                                                                                                                                        	// By default this is disabled and both "/foo" and "/foo/" will execute the same handler.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	StrictRouting bool `json:"strict_routing"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// When set to true, enables case sensitive routing.
                                                                                                                                                                                                                                        	// E.g. "/FoO" and "/foo" are treated as different routes.
                                                                                                                                                                                                                                        	// By default this is disabled and both "/FoO" and "/foo" will execute the same handler.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	CaseSensitive bool `json:"case_sensitive"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// When set to true, this relinquishes the 0-allocation promise in certain
                                                                                                                                                                                                                                        	// cases in order to access the handler values (e.g. request bodies) in an
                                                                                                                                                                                                                                        	// immutable fashion so that these values are available even if you return
                                                                                                                                                                                                                                        	// from handler.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	Immutable bool `json:"immutable"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// When set to true, converts all encoded characters in the route back
                                                                                                                                                                                                                                        	// before setting the path for the context, so that the routing,
                                                                                                                                                                                                                                        	// the returning of the current url from the context `ctx.Path()`
                                                                                                                                                                                                                                        	// and the paramters `ctx.Params(%key%)` with decoded characters will work
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	UnescapePath bool `json:"unescape_path"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Enable or disable ETag header generation, since both weak and strong etags are generated
                                                                                                                                                                                                                                        	// using the same hashing method (CRC-32). Weak ETags are the default when enabled.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	ETag bool `json:"etag"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Max body size that the server accepts.
                                                                                                                                                                                                                                        	// -1 will decline any body size
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: 4 * 1024 * 1024
                                                                                                                                                                                                                                        	BodyLimit int `json:"body_limit"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Maximum number of concurrent connections.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: 256 * 1024
                                                                                                                                                                                                                                        	Concurrency int `json:"concurrency"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Views is the interface that wraps the Render function.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: nil
                                                                                                                                                                                                                                        	Views Views `json:"-"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The amount of time allowed to read the full request including body.
                                                                                                                                                                                                                                        	// It is reset after the request handler has returned.
                                                                                                                                                                                                                                        	// The connection's read deadline is reset when the connection opens.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: unlimited
                                                                                                                                                                                                                                        	ReadTimeout time.Duration `json:"read_timeout"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The maximum duration before timing out writes of the response.
                                                                                                                                                                                                                                        	// It is reset after the request handler has returned.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: unlimited
                                                                                                                                                                                                                                        	WriteTimeout time.Duration `json:"write_timeout"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The maximum amount of time to wait for the next request when keep-alive is enabled.
                                                                                                                                                                                                                                        	// If IdleTimeout is zero, the value of ReadTimeout is used.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: unlimited
                                                                                                                                                                                                                                        	IdleTimeout time.Duration `json:"idle_timeout"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Per-connection buffer size for requests' reading.
                                                                                                                                                                                                                                        	// This also limits the maximum header size.
                                                                                                                                                                                                                                        	// Increase this buffer if your clients send multi-KB RequestURIs
                                                                                                                                                                                                                                        	// and/or multi-KB headers (for example, BIG cookies).
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: 4096
                                                                                                                                                                                                                                        	ReadBufferSize int `json:"read_buffer_size"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Per-connection buffer size for responses' writing.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: 4096
                                                                                                                                                                                                                                        	WriteBufferSize int `json:"write_buffer_size"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// CompressedFileSuffix adds suffix to the original file name and
                                                                                                                                                                                                                                        	// tries saving the resulting compressed file under the new file name.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: ".fiber.gz"
                                                                                                                                                                                                                                        	CompressedFileSuffix string `json:"compressed_file_suffix"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// ProxyHeader will enable c.IP() to return the value of the given header key
                                                                                                                                                                                                                                        	// By default c.IP() will return the Remote IP from the TCP connection
                                                                                                                                                                                                                                        	// This property can be useful if you are behind a load balancer: X-Forwarded-*
                                                                                                                                                                                                                                        	// NOTE: headers are easily spoofed and the detected IP addresses are unreliable.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: ""
                                                                                                                                                                                                                                        	ProxyHeader string `json:"proxy_header"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// GETOnly rejects all non-GET requests if set to true.
                                                                                                                                                                                                                                        	// This option is useful as anti-DoS protection for servers
                                                                                                                                                                                                                                        	// accepting only GET requests. The request size is limited
                                                                                                                                                                                                                                        	// by ReadBufferSize if GETOnly is set.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	GETOnly bool `json:"get_only"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// ErrorHandler is executed when an error is returned from fiber.Handler.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: DefaultErrorHandler
                                                                                                                                                                                                                                        	ErrorHandler ErrorHandler `json:"-"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// When set to true, disables keep-alive connections.
                                                                                                                                                                                                                                        	// The server will close incoming connections after sending the first response to client.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	DisableKeepalive bool `json:"disable_keepalive"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// When set to true, causes the default date header to be excluded from the response.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	DisableDefaultDate bool `json:"disable_default_date"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// When set to true, causes the default Content-Type header to be excluded from the response.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	DisableDefaultContentType bool `json:"disable_default_content_type"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// When set to true, disables header normalization.
                                                                                                                                                                                                                                        	// By default all header names are normalized: conteNT-tYPE -> Content-Type.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	DisableHeaderNormalizing bool `json:"disable_header_normalizing"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// When set to true, it will not print out the «Fiber» ASCII art and listening address.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	DisableStartupMessage bool `json:"disable_startup_message"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Aggressively reduces memory usage at the cost of higher CPU usage
                                                                                                                                                                                                                                        	// if set to true.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Try enabling this option only if the server consumes too much memory
                                                                                                                                                                                                                                        	// serving mostly idle keep-alive connections. This may reduce memory
                                                                                                                                                                                                                                        	// usage by more than 50%.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: false
                                                                                                                                                                                                                                        	ReduceMemoryUsage bool `json:"reduce_memory_usage"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// When set by an external client of Fiber it will use the provided implementation of a
                                                                                                                                                                                                                                        	// JSONMarshal
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Allowing for flexibility in using another json library for encoding
                                                                                                                                                                                                                                        	// Default: json.Marshal
                                                                                                                                                                                                                                        	JSONEncoder utils.JSONMarshal `json:"-"`
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Known networks are "tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only)
                                                                                                                                                                                                                                        	// WARNING: When prefork is set to true, only "tcp4" and "tcp6" can be chose.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// Default: NetworkTCP4
                                                                                                                                                                                                                                        	Network string
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          Config is a struct holding the server settings.

                                                                                                                                                                                                                                          type Cookie struct {
                                                                                                                                                                                                                                          	Name     string    `json:"name"`
                                                                                                                                                                                                                                          	Value    string    `json:"value"`
                                                                                                                                                                                                                                          	Path     string    `json:"path"`
                                                                                                                                                                                                                                          	Domain   string    `json:"domain"`
                                                                                                                                                                                                                                          	MaxAge   int       `json:"max_age"`
                                                                                                                                                                                                                                          	Expires  time.Time `json:"expires"`
                                                                                                                                                                                                                                          	Secure   bool      `json:"secure"`
                                                                                                                                                                                                                                          	HTTPOnly bool      `json:"http_only"`
                                                                                                                                                                                                                                          	SameSite string    `json:"same_site"`
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            Cookie data for c.Cookie

                                                                                                                                                                                                                                            type Ctx

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

                                                                                                                                                                                                                                              Ctx represents the Context which hold the HTTP request and response. It has methods for the request query string, parameters, body, HTTP headers and so on.

                                                                                                                                                                                                                                              func (*Ctx) Accepts

                                                                                                                                                                                                                                              func (c *Ctx) Accepts(offers ...string) string

                                                                                                                                                                                                                                                Accepts checks if the specified extensions or content types are acceptable.

                                                                                                                                                                                                                                                func (*Ctx) AcceptsCharsets

                                                                                                                                                                                                                                                func (c *Ctx) AcceptsCharsets(offers ...string) string

                                                                                                                                                                                                                                                  AcceptsCharsets checks if the specified charset is acceptable.

                                                                                                                                                                                                                                                  func (*Ctx) AcceptsEncodings

                                                                                                                                                                                                                                                  func (c *Ctx) AcceptsEncodings(offers ...string) string

                                                                                                                                                                                                                                                    AcceptsEncodings checks if the specified encoding is acceptable.

                                                                                                                                                                                                                                                    func (*Ctx) AcceptsLanguages

                                                                                                                                                                                                                                                    func (c *Ctx) AcceptsLanguages(offers ...string) string

                                                                                                                                                                                                                                                      AcceptsLanguages checks if the specified language is acceptable.

                                                                                                                                                                                                                                                      func (*Ctx) App

                                                                                                                                                                                                                                                      func (c *Ctx) App() *App

                                                                                                                                                                                                                                                        App returns the *App reference to the instance of the Fiber application

                                                                                                                                                                                                                                                        func (*Ctx) Append

                                                                                                                                                                                                                                                        func (c *Ctx) Append(field string, values ...string)

                                                                                                                                                                                                                                                          Append the specified value to the HTTP response header field. If the header is not already set, it creates the header with the specified value.

                                                                                                                                                                                                                                                          func (*Ctx) Attachment

                                                                                                                                                                                                                                                          func (c *Ctx) Attachment(filename ...string)

                                                                                                                                                                                                                                                            Attachment sets the HTTP response Content-Disposition header field to attachment.

                                                                                                                                                                                                                                                            func (*Ctx) BaseURL

                                                                                                                                                                                                                                                            func (c *Ctx) BaseURL() string

                                                                                                                                                                                                                                                              BaseURL returns (protocol + host + base path).

                                                                                                                                                                                                                                                              func (*Ctx) Body

                                                                                                                                                                                                                                                              func (c *Ctx) Body() []byte

                                                                                                                                                                                                                                                                Body contains the raw body submitted in a POST request. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting instead.

                                                                                                                                                                                                                                                                func (*Ctx) BodyParser

                                                                                                                                                                                                                                                                func (c *Ctx) BodyParser(out interface{}) error

                                                                                                                                                                                                                                                                  BodyParser binds the request body to a struct. It supports decoding the following content types based on the Content-Type header: application/json, application/xml, application/x-www-form-urlencoded, multipart/form-data If none of the content types above are matched, it will return a ErrUnprocessableEntity error

                                                                                                                                                                                                                                                                  func (*Ctx) ClearCookie

                                                                                                                                                                                                                                                                  func (c *Ctx) ClearCookie(key ...string)

                                                                                                                                                                                                                                                                    ClearCookie expires a specific cookie by key on the client side. If no key is provided it expires all cookies that came with the request.

                                                                                                                                                                                                                                                                    func (*Ctx) Context

                                                                                                                                                                                                                                                                    func (c *Ctx) Context() *fasthttp.RequestCtx

                                                                                                                                                                                                                                                                      Context returns *fasthttp.RequestCtx that carries a deadline a cancellation signal, and other values across API boundaries.

                                                                                                                                                                                                                                                                      func (*Ctx) Cookie

                                                                                                                                                                                                                                                                      func (c *Ctx) Cookie(cookie *Cookie)

                                                                                                                                                                                                                                                                        Cookie sets a cookie by passing a cookie struct.

                                                                                                                                                                                                                                                                        func (*Ctx) Cookies

                                                                                                                                                                                                                                                                        func (c *Ctx) Cookies(key string, defaultValue ...string) string

                                                                                                                                                                                                                                                                          Cookies is used for getting a cookie value by key. Defaults to the empty string "" if the cookie doesn't exist. If a default value is given, it will return that value if the cookie doesn't exist. The returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting to use the value outside the Handler.

                                                                                                                                                                                                                                                                          func (*Ctx) Download

                                                                                                                                                                                                                                                                          func (c *Ctx) Download(file string, filename ...string) error

                                                                                                                                                                                                                                                                            Download transfers the file from path as an attachment. Typically, browsers will prompt the user for download. By default, the Content-Disposition header filename= parameter is the filepath (this typically appears in the browser dialog). Override this default with the filename parameter.

                                                                                                                                                                                                                                                                            func (*Ctx) FormFile

                                                                                                                                                                                                                                                                            func (c *Ctx) FormFile(key string) (*multipart.FileHeader, error)

                                                                                                                                                                                                                                                                              FormFile returns the first file by key from a MultipartForm.

                                                                                                                                                                                                                                                                              func (*Ctx) FormValue

                                                                                                                                                                                                                                                                              func (c *Ctx) FormValue(key string, defaultValue ...string) string

                                                                                                                                                                                                                                                                                FormValue returns the first value by key from a MultipartForm. Defaults to the empty string "" if the form value doesn't exist. If a default value is given, it will return that value if the form value does not exist. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting instead.

                                                                                                                                                                                                                                                                                func (*Ctx) Format

                                                                                                                                                                                                                                                                                func (c *Ctx) Format(body interface{}) error

                                                                                                                                                                                                                                                                                  Format performs content-negotiation on the Accept HTTP header. It uses Accepts to select a proper format. If the header is not specified or there is no proper format, text/plain is used.

                                                                                                                                                                                                                                                                                  func (*Ctx) Fresh

                                                                                                                                                                                                                                                                                  func (c *Ctx) Fresh() bool

                                                                                                                                                                                                                                                                                    Fresh returns true when the response is still “fresh” in the client's cache, otherwise false is returned to indicate that the client cache is now stale and the full response should be sent. When a client sends the Cache-Control: no-cache request header to indicate an end-to-end reload request, this module will return false to make handling these requests transparent. https://github.com/jshttp/fresh/blob/10e0471669dbbfbfd8de65bc6efac2ddd0bfa057/index.js#L33

                                                                                                                                                                                                                                                                                    func (*Ctx) Get

                                                                                                                                                                                                                                                                                    func (c *Ctx) Get(key string, defaultValue ...string) string

                                                                                                                                                                                                                                                                                      Get returns the HTTP request header specified by field. Field names are case-insensitive Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting instead.

                                                                                                                                                                                                                                                                                      func (*Ctx) Hostname

                                                                                                                                                                                                                                                                                      func (c *Ctx) Hostname() string

                                                                                                                                                                                                                                                                                        Hostname contains the hostname derived from the Host HTTP header. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting instead.

                                                                                                                                                                                                                                                                                        func (*Ctx) IP

                                                                                                                                                                                                                                                                                        func (c *Ctx) IP() string

                                                                                                                                                                                                                                                                                          IP returns the remote IP address of the request.

                                                                                                                                                                                                                                                                                          func (*Ctx) IPs

                                                                                                                                                                                                                                                                                          func (c *Ctx) IPs() (ips []string)

                                                                                                                                                                                                                                                                                            IPs returns an string slice of IP addresses specified in the X-Forwarded-For request header.

                                                                                                                                                                                                                                                                                            func (*Ctx) Is

                                                                                                                                                                                                                                                                                            func (c *Ctx) Is(extension string) bool

                                                                                                                                                                                                                                                                                              Is returns the matching content type, if the incoming request's Content-Type HTTP header field matches the MIME type specified by the type parameter

                                                                                                                                                                                                                                                                                              func (*Ctx) JSON

                                                                                                                                                                                                                                                                                              func (c *Ctx) JSON(data interface{}) error

                                                                                                                                                                                                                                                                                                JSON converts any interface or string to JSON. Array and slice values encode as JSON arrays, except that []byte encodes as a base64-encoded string, and a nil slice encodes as the null JSON value. This method also sets the content header to application/json.

                                                                                                                                                                                                                                                                                                func (*Ctx) JSONP

                                                                                                                                                                                                                                                                                                func (c *Ctx) JSONP(data interface{}, callback ...string) error

                                                                                                                                                                                                                                                                                                  JSONP sends a JSON response with JSONP support. This method is identical to JSON, except that it opts-in to JSONP callback support. By default, the callback name is simply callback.

                                                                                                                                                                                                                                                                                                  func (c *Ctx) Links(link ...string)

                                                                                                                                                                                                                                                                                                    Links joins the links followed by the property to populate the response's Link HTTP header field.

                                                                                                                                                                                                                                                                                                    func (*Ctx) Locals

                                                                                                                                                                                                                                                                                                    func (c *Ctx) Locals(key string, value ...interface{}) (val interface{})

                                                                                                                                                                                                                                                                                                      Locals makes it possible to pass interface{} values under string keys scoped to the request and therefore available to all following routes that match the request.

                                                                                                                                                                                                                                                                                                      func (*Ctx) Location

                                                                                                                                                                                                                                                                                                      func (c *Ctx) Location(path string)

                                                                                                                                                                                                                                                                                                        Location sets the response Location HTTP header to the specified path parameter.

                                                                                                                                                                                                                                                                                                        func (*Ctx) Method

                                                                                                                                                                                                                                                                                                        func (c *Ctx) Method(override ...string) string

                                                                                                                                                                                                                                                                                                          Method contains a string corresponding to the HTTP method of the request: GET, POST, PUT and so on.

                                                                                                                                                                                                                                                                                                          func (*Ctx) MultipartForm

                                                                                                                                                                                                                                                                                                          func (c *Ctx) MultipartForm() (*multipart.Form, error)

                                                                                                                                                                                                                                                                                                            MultipartForm parse form entries from binary. This returns a map[string][]string, so given a key the value will be a string slice.

                                                                                                                                                                                                                                                                                                            func (*Ctx) Next

                                                                                                                                                                                                                                                                                                            func (c *Ctx) Next() (err error)

                                                                                                                                                                                                                                                                                                              Next executes the next method in the stack that matches the current route.

                                                                                                                                                                                                                                                                                                              func (*Ctx) OriginalURL

                                                                                                                                                                                                                                                                                                              func (c *Ctx) OriginalURL() string

                                                                                                                                                                                                                                                                                                                OriginalURL contains the original request URL. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting to use the value outside the Handler.

                                                                                                                                                                                                                                                                                                                func (*Ctx) Params

                                                                                                                                                                                                                                                                                                                func (c *Ctx) Params(key string, defaultValue ...string) string

                                                                                                                                                                                                                                                                                                                  Params is used to get the route parameters. Defaults to empty string "" if the param doesn't exist. If a default value is given, it will return that value if the param doesn't exist. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting to use the value outside the Handler.

                                                                                                                                                                                                                                                                                                                  func (*Ctx) ParamsInt

                                                                                                                                                                                                                                                                                                                  func (c *Ctx) ParamsInt(key string) (int, error)

                                                                                                                                                                                                                                                                                                                    ParamsInt is used to get an integer from the route parameters it defaults to zero if the parameter is not found or if the parameter cannot be converted to an integer

                                                                                                                                                                                                                                                                                                                    func (*Ctx) Path

                                                                                                                                                                                                                                                                                                                    func (c *Ctx) Path(override ...string) string

                                                                                                                                                                                                                                                                                                                      Path returns the path part of the request URL. Optionally, you could override the path.

                                                                                                                                                                                                                                                                                                                      func (*Ctx) Protocol

                                                                                                                                                                                                                                                                                                                      func (c *Ctx) Protocol() string

                                                                                                                                                                                                                                                                                                                        Protocol contains the request protocol string: http or https for TLS requests.

                                                                                                                                                                                                                                                                                                                        func (*Ctx) Query

                                                                                                                                                                                                                                                                                                                        func (c *Ctx) Query(key string, defaultValue ...string) string

                                                                                                                                                                                                                                                                                                                          Query returns the query string parameter in the url. Defaults to empty string "" if the query doesn't exist. If a default value is given, it will return that value if the query doesn't exist. Returned value is only valid within the handler. Do not store any references. Make copies or use the Immutable setting to use the value outside the Handler.

                                                                                                                                                                                                                                                                                                                          func (*Ctx) QueryParser

                                                                                                                                                                                                                                                                                                                          func (c *Ctx) QueryParser(out interface{}) error

                                                                                                                                                                                                                                                                                                                            QueryParser binds the query string to a struct.

                                                                                                                                                                                                                                                                                                                            func (*Ctx) Range

                                                                                                                                                                                                                                                                                                                            func (c *Ctx) Range(size int) (rangeData Range, err error)

                                                                                                                                                                                                                                                                                                                              Range returns a struct containing the type and a slice of ranges.

                                                                                                                                                                                                                                                                                                                              func (*Ctx) Redirect

                                                                                                                                                                                                                                                                                                                              func (c *Ctx) Redirect(location string, status ...int) error

                                                                                                                                                                                                                                                                                                                                Redirect to the URL derived from the specified path, with specified status. If status is not specified, status defaults to 302 Found.

                                                                                                                                                                                                                                                                                                                                func (*Ctx) Render

                                                                                                                                                                                                                                                                                                                                func (c *Ctx) Render(name string, bind interface{}, layouts ...string) error

                                                                                                                                                                                                                                                                                                                                  Render a template with data and sends a text/html response. We support the following engines: html, amber, handlebars, mustache, pug

                                                                                                                                                                                                                                                                                                                                  func (*Ctx) Request

                                                                                                                                                                                                                                                                                                                                  func (c *Ctx) Request() *fasthttp.Request

                                                                                                                                                                                                                                                                                                                                    Request return the *fasthttp.Request object This allows you to use all fasthttp request methods https://godoc.org/github.com/valyala/fasthttp#Request

                                                                                                                                                                                                                                                                                                                                    func (*Ctx) Response

                                                                                                                                                                                                                                                                                                                                    func (c *Ctx) Response() *fasthttp.Response

                                                                                                                                                                                                                                                                                                                                      Response return the *fasthttp.Response object This allows you to use all fasthttp response methods https://godoc.org/github.com/valyala/fasthttp#Response

                                                                                                                                                                                                                                                                                                                                      func (*Ctx) Route

                                                                                                                                                                                                                                                                                                                                      func (c *Ctx) Route() *Route

                                                                                                                                                                                                                                                                                                                                        Route returns the matched Route struct.

                                                                                                                                                                                                                                                                                                                                        func (*Ctx) SaveFile

                                                                                                                                                                                                                                                                                                                                        func (c *Ctx) SaveFile(fileheader *multipart.FileHeader, path string) error

                                                                                                                                                                                                                                                                                                                                          SaveFile saves any multipart file to disk.

                                                                                                                                                                                                                                                                                                                                          func (*Ctx) Secure

                                                                                                                                                                                                                                                                                                                                          func (c *Ctx) Secure() bool

                                                                                                                                                                                                                                                                                                                                            Secure returns a boolean property, that is true, if a TLS connection is established.

                                                                                                                                                                                                                                                                                                                                            func (*Ctx) Send

                                                                                                                                                                                                                                                                                                                                            func (c *Ctx) Send(body []byte) error

                                                                                                                                                                                                                                                                                                                                              Send sets the HTTP response body without copying it. From this point onward the body argument must not be changed.

                                                                                                                                                                                                                                                                                                                                              func (*Ctx) SendFile

                                                                                                                                                                                                                                                                                                                                              func (c *Ctx) SendFile(file string, compress ...bool) error

                                                                                                                                                                                                                                                                                                                                                SendFile transfers the file from the given path. The file is not compressed by default, enable this by passing a 'true' argument Sets the Content-Type response HTTP header field based on the filenames extension.

                                                                                                                                                                                                                                                                                                                                                func (*Ctx) SendStatus

                                                                                                                                                                                                                                                                                                                                                func (c *Ctx) SendStatus(status int) error

                                                                                                                                                                                                                                                                                                                                                  SendStatus sets the HTTP status code and if the response body is empty, it sets the correct status message in the body.

                                                                                                                                                                                                                                                                                                                                                  func (*Ctx) SendStream

                                                                                                                                                                                                                                                                                                                                                  func (c *Ctx) SendStream(stream io.Reader, size ...int) error

                                                                                                                                                                                                                                                                                                                                                    SendStream sets response body stream and optional body size.

                                                                                                                                                                                                                                                                                                                                                    func (*Ctx) SendString

                                                                                                                                                                                                                                                                                                                                                    func (c *Ctx) SendString(body string) error

                                                                                                                                                                                                                                                                                                                                                      SendString sets the HTTP response body for string types. This means no type assertion, recommended for faster performance

                                                                                                                                                                                                                                                                                                                                                      func (*Ctx) Set

                                                                                                                                                                                                                                                                                                                                                      func (c *Ctx) Set(key string, val string)

                                                                                                                                                                                                                                                                                                                                                        Set sets the response's HTTP header field to the specified key, value.

                                                                                                                                                                                                                                                                                                                                                        func (*Ctx) Stale

                                                                                                                                                                                                                                                                                                                                                        func (c *Ctx) Stale() bool

                                                                                                                                                                                                                                                                                                                                                          Stale is not implemented yet, pull requests are welcome!

                                                                                                                                                                                                                                                                                                                                                          func (*Ctx) Status

                                                                                                                                                                                                                                                                                                                                                          func (c *Ctx) Status(status int) *Ctx

                                                                                                                                                                                                                                                                                                                                                            Status sets the HTTP status for the response. This method is chainable.

                                                                                                                                                                                                                                                                                                                                                            func (*Ctx) String

                                                                                                                                                                                                                                                                                                                                                            func (c *Ctx) String() string

                                                                                                                                                                                                                                                                                                                                                              String returns unique string representation of the ctx.

                                                                                                                                                                                                                                                                                                                                                              The returned value may be useful for logging.

                                                                                                                                                                                                                                                                                                                                                              func (*Ctx) Subdomains

                                                                                                                                                                                                                                                                                                                                                              func (c *Ctx) Subdomains(offset ...int) []string

                                                                                                                                                                                                                                                                                                                                                                Subdomains returns a string slice of subdomains in the domain name of the request. The subdomain offset, which defaults to 2, is used for determining the beginning of the subdomain segments.

                                                                                                                                                                                                                                                                                                                                                                func (*Ctx) Type

                                                                                                                                                                                                                                                                                                                                                                func (c *Ctx) Type(extension string, charset ...string) *Ctx

                                                                                                                                                                                                                                                                                                                                                                  Type sets the Content-Type HTTP header to the MIME type specified by the file extension.

                                                                                                                                                                                                                                                                                                                                                                  func (*Ctx) Vary

                                                                                                                                                                                                                                                                                                                                                                  func (c *Ctx) Vary(fields ...string)

                                                                                                                                                                                                                                                                                                                                                                    Vary adds the given header field to the Vary response header. This will append the header, if not already listed, otherwise leaves it listed in the current location.

                                                                                                                                                                                                                                                                                                                                                                    func (*Ctx) Write

                                                                                                                                                                                                                                                                                                                                                                    func (c *Ctx) Write(p []byte) (int, error)

                                                                                                                                                                                                                                                                                                                                                                      Write appends p into response body.

                                                                                                                                                                                                                                                                                                                                                                      func (*Ctx) WriteString

                                                                                                                                                                                                                                                                                                                                                                      func (c *Ctx) WriteString(s string) (int, error)

                                                                                                                                                                                                                                                                                                                                                                        WriteString appends s to response body.

                                                                                                                                                                                                                                                                                                                                                                        func (*Ctx) XHR

                                                                                                                                                                                                                                                                                                                                                                        func (c *Ctx) XHR() bool

                                                                                                                                                                                                                                                                                                                                                                          XHR returns a Boolean property, that is true, if the request's X-Requested-With header field is XMLHttpRequest, indicating that the request was issued by a client library (such as jQuery).

                                                                                                                                                                                                                                                                                                                                                                          type Error

                                                                                                                                                                                                                                                                                                                                                                          type Error struct {
                                                                                                                                                                                                                                                                                                                                                                          	Code    int    `json:"code"`
                                                                                                                                                                                                                                                                                                                                                                          	Message string `json:"message"`
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                            Error represents an error that occurred while handling a request.

                                                                                                                                                                                                                                                                                                                                                                            func NewError

                                                                                                                                                                                                                                                                                                                                                                            func NewError(code int, message ...string) *Error

                                                                                                                                                                                                                                                                                                                                                                              NewError creates a new Error instance with an optional message

                                                                                                                                                                                                                                                                                                                                                                              func (*Error) Error

                                                                                                                                                                                                                                                                                                                                                                              func (e *Error) Error() string

                                                                                                                                                                                                                                                                                                                                                                                Error makes it compatible with the `error` interface.

                                                                                                                                                                                                                                                                                                                                                                                type ErrorHandler

                                                                                                                                                                                                                                                                                                                                                                                type ErrorHandler = func(*Ctx, error) error

                                                                                                                                                                                                                                                                                                                                                                                  ErrorHandler defines a function that will process all errors returned from any handlers in the stack

                                                                                                                                                                                                                                                                                                                                                                                  cfg := fiber.Config{}
                                                                                                                                                                                                                                                                                                                                                                                  cfg.ErrorHandler = func(c *Ctx, err error) error {
                                                                                                                                                                                                                                                                                                                                                                                   code := StatusInternalServerError
                                                                                                                                                                                                                                                                                                                                                                                   if e, ok := err.(*Error); ok {
                                                                                                                                                                                                                                                                                                                                                                                     code = e.Code
                                                                                                                                                                                                                                                                                                                                                                                   }
                                                                                                                                                                                                                                                                                                                                                                                   c.Set(HeaderContentType, MIMETextPlainCharsetUTF8)
                                                                                                                                                                                                                                                                                                                                                                                   return c.Status(code).SendString(err.Error())
                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                  app := fiber.New(cfg)
                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                  type FormFile

                                                                                                                                                                                                                                                                                                                                                                                  type FormFile struct {
                                                                                                                                                                                                                                                                                                                                                                                  	// Fieldname is form file's field name
                                                                                                                                                                                                                                                                                                                                                                                  	Fieldname string
                                                                                                                                                                                                                                                                                                                                                                                  	// Name is form file's name
                                                                                                                                                                                                                                                                                                                                                                                  	Name string
                                                                                                                                                                                                                                                                                                                                                                                  	// Content is form file's content
                                                                                                                                                                                                                                                                                                                                                                                  	Content []byte
                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                    FormFile represents multipart form file

                                                                                                                                                                                                                                                                                                                                                                                    func AcquireFormFile

                                                                                                                                                                                                                                                                                                                                                                                    func AcquireFormFile() *FormFile

                                                                                                                                                                                                                                                                                                                                                                                      AcquireFormFile returns an empty FormFile object from the pool.

                                                                                                                                                                                                                                                                                                                                                                                      The returned FormFile may be returned to the pool with ReleaseFormFile when no longer needed. This allows reducing GC load.

                                                                                                                                                                                                                                                                                                                                                                                      type Group

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

                                                                                                                                                                                                                                                                                                                                                                                        Group struct

                                                                                                                                                                                                                                                                                                                                                                                        func (*Group) Add

                                                                                                                                                                                                                                                                                                                                                                                        func (grp *Group) Add(method, path string, handlers ...Handler) Router

                                                                                                                                                                                                                                                                                                                                                                                          Add allows you to specify a HTTP method to register a route

                                                                                                                                                                                                                                                                                                                                                                                          func (*Group) All

                                                                                                                                                                                                                                                                                                                                                                                          func (grp *Group) All(path string, handlers ...Handler) Router

                                                                                                                                                                                                                                                                                                                                                                                            All will register the handler on all HTTP methods

                                                                                                                                                                                                                                                                                                                                                                                            func (*Group) Connect

                                                                                                                                                                                                                                                                                                                                                                                            func (grp *Group) Connect(path string, handlers ...Handler) Router

                                                                                                                                                                                                                                                                                                                                                                                              Connect registers a route for CONNECT methods that establishes a tunnel to the server identified by the target resource.

                                                                                                                                                                                                                                                                                                                                                                                              func (*Group) Delete

                                                                                                                                                                                                                                                                                                                                                                                              func (grp *Group) Delete(path string, handlers ...Handler) Router

                                                                                                                                                                                                                                                                                                                                                                                                Delete registers a route for DELETE methods that deletes the specified resource.

                                                                                                                                                                                                                                                                                                                                                                                                func (*Group) Get

                                                                                                                                                                                                                                                                                                                                                                                                func (grp *Group) Get(path string, handlers ...Handler) Router

                                                                                                                                                                                                                                                                                                                                                                                                  Get registers a route for GET methods that requests a representation of the specified resource. Requests using GET should only retrieve data.

                                                                                                                                                                                                                                                                                                                                                                                                  func (*Group) Group

                                                                                                                                                                                                                                                                                                                                                                                                  func (grp *Group) Group(prefix string, handlers ...Handler) Router

                                                                                                                                                                                                                                                                                                                                                                                                    Group is used for Routes with common prefix to define a new sub-router with optional middleware.

                                                                                                                                                                                                                                                                                                                                                                                                    api := app.Group("/api")
                                                                                                                                                                                                                                                                                                                                                                                                    api.Get("/users", handler)
                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                    func (*Group) Head

                                                                                                                                                                                                                                                                                                                                                                                                    func (grp *Group) Head(path string, handlers ...Handler) Router

                                                                                                                                                                                                                                                                                                                                                                                                      Head registers a route for HEAD methods that asks for a response identical to that of a GET request, but without the response body.

                                                                                                                                                                                                                                                                                                                                                                                                      func (*Group) Mount

                                                                                                                                                                                                                                                                                                                                                                                                      func (grp *Group) Mount(prefix string, fiber *App) Router

                                                                                                                                                                                                                                                                                                                                                                                                        Mount attaches another app instance as a sub-router along a routing path. It's very useful to split up a large API as many independent routers and compose them as a single service using Mount.

                                                                                                                                                                                                                                                                                                                                                                                                        func (*Group) Options

                                                                                                                                                                                                                                                                                                                                                                                                        func (grp *Group) Options(path string, handlers ...Handler) Router

                                                                                                                                                                                                                                                                                                                                                                                                          Options registers a route for OPTIONS methods that is used to describe the communication options for the target resource.

                                                                                                                                                                                                                                                                                                                                                                                                          func (*Group) Patch

                                                                                                                                                                                                                                                                                                                                                                                                          func (grp *Group) Patch(path string, handlers ...Handler) Router

                                                                                                                                                                                                                                                                                                                                                                                                            Patch registers a route for PATCH methods that is used to apply partial modifications to a resource.

                                                                                                                                                                                                                                                                                                                                                                                                            func (*Group) Post

                                                                                                                                                                                                                                                                                                                                                                                                            func (grp *Group) Post(path string, handlers ...Handler) Router

                                                                                                                                                                                                                                                                                                                                                                                                              Post registers a route for POST methods that is used to submit an entity to the specified resource, often causing a change in state or side effects on the server.

                                                                                                                                                                                                                                                                                                                                                                                                              func (*Group) Put

                                                                                                                                                                                                                                                                                                                                                                                                              func (grp *Group) Put(path string, handlers ...Handler) Router

                                                                                                                                                                                                                                                                                                                                                                                                                Put registers a route for PUT methods that replaces all current representations of the target resource with the request payload.

                                                                                                                                                                                                                                                                                                                                                                                                                func (*Group) Static

                                                                                                                                                                                                                                                                                                                                                                                                                func (grp *Group) Static(prefix, root string, config ...Static) Router

                                                                                                                                                                                                                                                                                                                                                                                                                  Static will create a file server serving static files

                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Group) Trace

                                                                                                                                                                                                                                                                                                                                                                                                                  func (grp *Group) Trace(path string, handlers ...Handler) Router

                                                                                                                                                                                                                                                                                                                                                                                                                    Trace registers a route for TRACE methods that performs a message loop-back test along the path to the target resource.

                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Group) Use

                                                                                                                                                                                                                                                                                                                                                                                                                    func (grp *Group) Use(args ...interface{}) Router

                                                                                                                                                                                                                                                                                                                                                                                                                      Use registers a middleware route that will match requests with the provided prefix (which is optional and defaults to "/").

                                                                                                                                                                                                                                                                                                                                                                                                                      app.Use(func(c *fiber.Ctx) error {
                                                                                                                                                                                                                                                                                                                                                                                                                           return c.Next()
                                                                                                                                                                                                                                                                                                                                                                                                                      })
                                                                                                                                                                                                                                                                                                                                                                                                                      app.Use("/api", func(c *fiber.Ctx) error {
                                                                                                                                                                                                                                                                                                                                                                                                                           return c.Next()
                                                                                                                                                                                                                                                                                                                                                                                                                      })
                                                                                                                                                                                                                                                                                                                                                                                                                      app.Use("/api", handler, func(c *fiber.Ctx) error {
                                                                                                                                                                                                                                                                                                                                                                                                                           return c.Next()
                                                                                                                                                                                                                                                                                                                                                                                                                      })
                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                      This method will match all HTTP verbs: GET, POST, PUT, HEAD etc...

                                                                                                                                                                                                                                                                                                                                                                                                                      type Handler

                                                                                                                                                                                                                                                                                                                                                                                                                      type Handler = func(*Ctx) error

                                                                                                                                                                                                                                                                                                                                                                                                                        Handler defines a function to serve HTTP requests.

                                                                                                                                                                                                                                                                                                                                                                                                                        type Map

                                                                                                                                                                                                                                                                                                                                                                                                                        type Map map[string]interface{}

                                                                                                                                                                                                                                                                                                                                                                                                                          Map is a shortcut for map[string]interface{}, useful for JSON returns

                                                                                                                                                                                                                                                                                                                                                                                                                          type Range

                                                                                                                                                                                                                                                                                                                                                                                                                          type Range struct {
                                                                                                                                                                                                                                                                                                                                                                                                                          	Type   string
                                                                                                                                                                                                                                                                                                                                                                                                                          	Ranges []struct {
                                                                                                                                                                                                                                                                                                                                                                                                                          		Start int
                                                                                                                                                                                                                                                                                                                                                                                                                          		End   int
                                                                                                                                                                                                                                                                                                                                                                                                                          	}
                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                            Range data for c.Range

                                                                                                                                                                                                                                                                                                                                                                                                                            type Request

                                                                                                                                                                                                                                                                                                                                                                                                                            type Request = fasthttp.Request

                                                                                                                                                                                                                                                                                                                                                                                                                              Request represents HTTP request.

                                                                                                                                                                                                                                                                                                                                                                                                                              It is forbidden copying Request instances. Create new instances and use CopyTo instead.

                                                                                                                                                                                                                                                                                                                                                                                                                              Request instance MUST NOT be used from concurrently running goroutines. Copy from fasthttp

                                                                                                                                                                                                                                                                                                                                                                                                                              type Response

                                                                                                                                                                                                                                                                                                                                                                                                                              type Response = fasthttp.Response

                                                                                                                                                                                                                                                                                                                                                                                                                                Response represents HTTP response.

                                                                                                                                                                                                                                                                                                                                                                                                                                It is forbidden copying Response instances. Create new instances and use CopyTo instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                Response instance MUST NOT be used from concurrently running goroutines. Copy from fasthttp

                                                                                                                                                                                                                                                                                                                                                                                                                                func AcquireResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                func AcquireResponse() *Response

                                                                                                                                                                                                                                                                                                                                                                                                                                  AcquireResponse returns an empty Response instance from response pool.

                                                                                                                                                                                                                                                                                                                                                                                                                                  The returned Response instance may be passed to ReleaseResponse when it is no longer needed. This allows Response recycling, reduces GC pressure and usually improves performance. Copy from fasthttp

                                                                                                                                                                                                                                                                                                                                                                                                                                  type Route

                                                                                                                                                                                                                                                                                                                                                                                                                                  type Route struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Public fields
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Method   string    `json:"method"` // HTTP method
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Path     string    `json:"path"`   // Original registered route path
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Params   []string  `json:"params"` // Case sensitive param keys
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Handlers []Handler `json:"-"`      // Ctx handlers
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                    Route is a struct that holds all metadata for each registered handler

                                                                                                                                                                                                                                                                                                                                                                                                                                    type Router

                                                                                                                                                                                                                                                                                                                                                                                                                                    type Router interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Use(args ...interface{}) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Get(path string, handlers ...Handler) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Head(path string, handlers ...Handler) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Post(path string, handlers ...Handler) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Put(path string, handlers ...Handler) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Delete(path string, handlers ...Handler) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Connect(path string, handlers ...Handler) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Options(path string, handlers ...Handler) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Trace(path string, handlers ...Handler) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Patch(path string, handlers ...Handler) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Add(method, path string, handlers ...Handler) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Static(prefix, root string, config ...Static) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    	All(path string, handlers ...Handler) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Group(prefix string, handlers ...Handler) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Mount(prefix string, fiber *App) Router
                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                      Router defines all router handle interface includes app and group router.

                                                                                                                                                                                                                                                                                                                                                                                                                                      type Static

                                                                                                                                                                                                                                                                                                                                                                                                                                      type Static struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// When set to true, the server tries minimizing CPU usage by caching compressed files.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This works differently than the github.com/gofiber/compression middleware.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Optional. Default value false
                                                                                                                                                                                                                                                                                                                                                                                                                                      	Compress bool `json:"compress"`
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// When set to true, enables byte range requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Optional. Default value false
                                                                                                                                                                                                                                                                                                                                                                                                                                      	ByteRange bool `json:"byte_range"`
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// When set to true, enables directory browsing.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Optional. Default value false.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	Browse bool `json:"browse"`
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of the index file for serving a directory.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Optional. Default value "index.html".
                                                                                                                                                                                                                                                                                                                                                                                                                                      	Index string `json:"index"`
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Expiration duration for inactive file handlers.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Use a negative time.Duration to disable it.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Optional. Default value 10 * time.Second.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	CacheDuration time.Duration `json:"cache_duration"`
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The value for the Cache-Control HTTP-header
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// that is set on the file response. MaxAge is defined in seconds.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Optional. Default value 0.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	MaxAge int `json:"max_age"`
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Next defines a function to skip this middleware when returned true.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Optional. Default: nil
                                                                                                                                                                                                                                                                                                                                                                                                                                      	Next func(c *Ctx) bool
                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                        Static defines configuration options when defining static assets.

                                                                                                                                                                                                                                                                                                                                                                                                                                        type Storage

                                                                                                                                                                                                                                                                                                                                                                                                                                        type Storage interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Get gets the value for the given key.
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// It returns ErrNotFound if the storage does not contain the key.
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Get(key string) ([]byte, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Set stores the given value for the given key along with a
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// time-to-live expiration value, 0 means live for ever
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Empty key or value will be ignored without an error.
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Set(key string, val []byte, ttl time.Duration) error
                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Delete deletes the value for the given key.
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// It returns no error if the storage does not contain the key,
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Delete(key string) error
                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Reset resets the storage and delete all keys.
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Reset() error
                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Close closes the storage and will stop any running garbage
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// collectors and open connections.
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Close() error
                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                          Storage interface for communicating with different database/key-value providers

                                                                                                                                                                                                                                                                                                                                                                                                                                          type Views

                                                                                                                                                                                                                                                                                                                                                                                                                                          type Views interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                          	Load() error
                                                                                                                                                                                                                                                                                                                                                                                                                                          	Render(io.Writer, string, interface{}, ...string) error
                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                            Views is the interface that wraps the Render function.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Directories

                                                                                                                                                                                                                                                                                                                                                                                                                                            Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                                                                            middleware
                                                                                                                                                                                                                                                                                                                                                                                                                                            cache
                                                                                                                                                                                                                                                                                                                                                                                                                                            Special thanks to @codemicro for moving this to fiber core Original middleware: github.com/codemicro/fiber-cache
                                                                                                                                                                                                                                                                                                                                                                                                                                            Special thanks to @codemicro for moving this to fiber core Original middleware: github.com/codemicro/fiber-cache
                                                                                                                                                                                                                                                                                                                                                                                                                                            internal
                                                                                                                                                                                                                                                                                                                                                                                                                                            fasttemplate
                                                                                                                                                                                                                                                                                                                                                                                                                                            Package fasttemplate implements simple and fast template library.
                                                                                                                                                                                                                                                                                                                                                                                                                                            Package fasttemplate implements simple and fast template library.
                                                                                                                                                                                                                                                                                                                                                                                                                                            fwd
                                                                                                                                                                                                                                                                                                                                                                                                                                            The `fwd` package provides a buffered reader and writer.
                                                                                                                                                                                                                                                                                                                                                                                                                                            The `fwd` package provides a buffered reader and writer.
                                                                                                                                                                                                                                                                                                                                                                                                                                            msgp
                                                                                                                                                                                                                                                                                                                                                                                                                                            This package is the support library for the msgp code generator (http://github.com/tinylib/msgp).
                                                                                                                                                                                                                                                                                                                                                                                                                                            This package is the support library for the msgp code generator (http://github.com/tinylib/msgp).
                                                                                                                                                                                                                                                                                                                                                                                                                                            schema
                                                                                                                                                                                                                                                                                                                                                                                                                                            Package gorilla/schema fills a struct with form values.
                                                                                                                                                                                                                                                                                                                                                                                                                                            Package gorilla/schema fills a struct with form values.
                                                                                                                                                                                                                                                                                                                                                                                                                                            uuid
                                                                                                                                                                                                                                                                                                                                                                                                                                            Package uuid generates and inspects UUIDs.
                                                                                                                                                                                                                                                                                                                                                                                                                                            Package uuid generates and inspects UUIDs.
                                                                                                                                                                                                                                                                                                                                                                                                                                            wmi
                                                                                                                                                                                                                                                                                                                                                                                                                                            Package wmi provides a WQL interface for WMI on Windows.
                                                                                                                                                                                                                                                                                                                                                                                                                                            Package wmi provides a WQL interface for WMI on Windows.