GOMODULES
/
fiber
mirror of https://github.com/gofiber/fiber.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

🧹 chore: Update documentation for Fiber client (#3249) 

* Update client package inline documentation

* Update inline docs

* Update Client Request docs

* Fix formatting issues

* Update docs

* Update docs/client/response.md

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

* Add missing space

* Remove return statement

* Update request.go

* Update docs/client/response.md

* Update docs/client/hooks.md

---------

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
Co-authored-by: RW <rene@gofiber.io>
pull/3105/head^2
Juan Calderon-Perez 2024-12-16 08:25:15 -05:00 committed by GitHub
parent 154c74d578
commit c2b557c5ac
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
10 changed files with 827 additions and 995 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

294
client/client.go
View File

@ -24,16 +24,13 @@ import (
var ErrFailedToAppendCert = errors.New("failed to append certificate")
// The Client is used to create a Fiber Client with
// client-level settings that apply to all requests
// raise from the client.
// Client is used to create a Fiber client with client-level settings that
// apply to all requests made by the client.
//
// Fiber Client also provides an option to override
// or merge most of the client settings at the request.
// The Fiber client also provides an option to override or merge most of the
// client settings at the request level.
type Client struct {
// logger
logger log.CommonLogger
logger log.CommonLogger
fasthttp *fasthttp.Client
header *Header
@ -48,45 +45,32 @@ type Client struct {
cborMarshal utils.CBORMarshal
cborUnmarshal utils.CBORUnmarshal
cookieJar *CookieJar
// retry
retryConfig *RetryConfig
baseURL string
userAgent string
referer string
// user defined request hooks
userRequestHooks []RequestHook
// client package defined request hooks
builtinRequestHooks []RequestHook
// user defined response hooks
userResponseHooks []ResponseHook
// client package defined response hooks
cookieJar *CookieJar
retryConfig *RetryConfig
baseURL string
userAgent string
referer string
userRequestHooks []RequestHook
builtinRequestHooks []RequestHook
userResponseHooks []ResponseHook
builtinResponseHooks []ResponseHook
timeout time.Duration
mu sync.RWMutex
debug bool
mu sync.RWMutex
debug bool
}
// R raise a request from the client.
// R creates a new Request associated with the client.
func (c *Client) R() *Request {
return AcquireRequest().SetClient(c)
}
// RequestHook Request returns user-defined request hooks.
// RequestHook returns the user-defined request hooks.
func (c *Client) RequestHook() []RequestHook {
return c.userRequestHooks
}
// AddRequestHook Add user-defined request hooks.
// AddRequestHook adds user-defined request hooks.
func (c *Client) AddRequestHook(h ...RequestHook) *Client {
c.mu.Lock()
defer c.mu.Unlock()
@ -95,12 +79,12 @@ func (c *Client) AddRequestHook(h ...RequestHook) *Client {
return c
}
// ResponseHook return user-define response hooks.
// ResponseHook returns the user-defined response hooks.
func (c *Client) ResponseHook() []ResponseHook {
return c.userResponseHooks
}
// AddResponseHook Add user-defined response hooks.
// AddResponseHook adds user-defined response hooks.
func (c *Client) AddResponseHook(h ...ResponseHook) *Client {
c.mu.Lock()
defer c.mu.Unlock()
@ -109,74 +93,74 @@ func (c *Client) AddResponseHook(h ...ResponseHook) *Client {
return c
}
// JSONMarshal returns json marshal function in Core.
// JSONMarshal returns the JSON marshal function used by the client.
func (c *Client) JSONMarshal() utils.JSONMarshal {
return c.jsonMarshal
}
// SetJSONMarshal sets the JSON encoder.
// SetJSONMarshal sets the JSON marshal function to use.
func (c *Client) SetJSONMarshal(f utils.JSONMarshal) *Client {
c.jsonMarshal = f
return c
}
// JSONUnmarshal returns json unmarshal function in Core.
// JSONUnmarshal returns the JSON unmarshal function used by the client.
func (c *Client) JSONUnmarshal() utils.JSONUnmarshal {
return c.jsonUnmarshal
}
// Set json decoder.
// SetJSONUnmarshal sets the JSON unmarshal function to use.
func (c *Client) SetJSONUnmarshal(f utils.JSONUnmarshal) *Client {
c.jsonUnmarshal = f
return c
}
// XMLMarshal returns xml marshal function in Core.
// XMLMarshal returns the XML marshal function used by the client.
func (c *Client) XMLMarshal() utils.XMLMarshal {
return c.xmlMarshal
}
// SetXMLMarshal Set xml encoder.
// SetXMLMarshal sets the XML marshal function to use.
func (c *Client) SetXMLMarshal(f utils.XMLMarshal) *Client {
c.xmlMarshal = f
return c
}
// XMLUnmarshal returns xml unmarshal function in Core.
// XMLUnmarshal returns the XML unmarshal function used by the client.
func (c *Client) XMLUnmarshal() utils.XMLUnmarshal {
return c.xmlUnmarshal
}
// SetXMLUnmarshal Set xml decoder.
// SetXMLUnmarshal sets the XML unmarshal function to use.
func (c *Client) SetXMLUnmarshal(f utils.XMLUnmarshal) *Client {
c.xmlUnmarshal = f
return c
}
// CBORMarshal returns CBOR marshal function in Core.
// CBORMarshal returns the CBOR marshal function used by the client.
func (c *Client) CBORMarshal() utils.CBORMarshal {
return c.cborMarshal
}
// SetCBORMarshal sets CBOR encoder.
// SetCBORMarshal sets the CBOR marshal function to use.
func (c *Client) SetCBORMarshal(f utils.CBORMarshal) *Client {
c.cborMarshal = f
return c
}
// CBORUnmarshal returns CBOR unmarshal function in Core.
// CBORUnmarshal returns the CBOR unmarshal function used by the client.
func (c *Client) CBORUnmarshal() utils.CBORUnmarshal {
return c.cborUnmarshal
}
// SetCBORUnmarshal sets CBOR decoder.
// SetCBORUnmarshal sets the CBOR unmarshal function to use.
func (c *Client) SetCBORUnmarshal(f utils.CBORUnmarshal) *Client {
c.cborUnmarshal = f
return c
}
// TLSConfig returns tlsConfig in client.
// If client don't have tlsConfig, this function will init it.
// TLSConfig returns the client's TLS configuration.
// If none is set, it initializes a new one.
func (c *Client) TLSConfig() *tls.Config {
if c.fasthttp.TLSConfig == nil {
c.fasthttp.TLSConfig = &tls.Config{
@ -187,20 +171,20 @@ func (c *Client) TLSConfig() *tls.Config {
return c.fasthttp.TLSConfig
}
// SetTLSConfig sets tlsConfig in client.
// SetTLSConfig sets the TLS configuration for the client.
func (c *Client) SetTLSConfig(config *tls.Config) *Client {
c.fasthttp.TLSConfig = config
return c
}
// SetCertificates method sets client certificates into client.
// SetCertificates adds certificates to the client's TLS configuration.
func (c *Client) SetCertificates(certs ...tls.Certificate) *Client {
config := c.TLSConfig()
config.Certificates = append(config.Certificates, certs...)
return c
}
// SetRootCertificate adds one or more root certificates into client.
// SetRootCertificate adds one or more root certificates to the client's TLS configuration.
func (c *Client) SetRootCertificate(path string) *Client {
cleanPath := filepath.Clean(path)
file, err := os.Open(cleanPath)
@ -230,7 +214,7 @@ func (c *Client) SetRootCertificate(path string) *Client {
return c
}
// SetRootCertificateFromString method adds one or more root certificates into client.
// SetRootCertificateFromString adds one or more root certificates from a string to the client's TLS configuration.
func (c *Client) SetRootCertificateFromString(pem string) *Client {
config := c.TLSConfig()
@ -245,19 +229,18 @@ func (c *Client) SetRootCertificateFromString(pem string) *Client {
return c
}
// SetProxyURL sets proxy url in client. It will apply via core to hostclient.
// SetProxyURL sets the proxy URL for the client. This affects all subsequent requests.
func (c *Client) SetProxyURL(proxyURL string) error {
c.fasthttp.Dial = fasthttpproxy.FasthttpHTTPDialer(proxyURL)
return nil
}
// RetryConfig returns retry config in client.
// RetryConfig returns the current retry configuration.
func (c *Client) RetryConfig() *RetryConfig {
return c.retryConfig
}
// SetRetryConfig sets retry config in client which is impl by addon/retry package.
// SetRetryConfig sets the retry configuration for the client.
func (c *Client) SetRetryConfig(config *RetryConfig) *Client {
c.mu.Lock()
defer c.mu.Unlock()
@ -266,58 +249,49 @@ func (c *Client) SetRetryConfig(config *RetryConfig) *Client {
return c
}
// BaseURL returns baseurl in Client instance.
// BaseURL returns the client's base URL.
func (c *Client) BaseURL() string {
return c.baseURL
}
// SetBaseURL Set baseUrl which is prefix of real url.
// SetBaseURL sets the base URL prefix for all requests made by the client.
func (c *Client) SetBaseURL(url string) *Client {
c.baseURL = url
return c
}
// Header method returns header value via key,
// this method will visit all field in the header,
// then sort them.
// Header returns all header values associated with the provided key.
func (c *Client) Header(key string) []string {
return c.header.PeekMultiple(key)
}
// AddHeader method adds a single header field and its value in the client instance.
// These headers will be applied to all requests raised from this client instance.
// Also, it can be overridden at request level header options.
// AddHeader adds a single header field and its value to the client. These headers apply to all requests.
func (c *Client) AddHeader(key, val string) *Client {
c.header.Add(key, val)
return c
}
// SetHeader method sets a single header field and its value in the client instance.
// These headers will be applied to all requests raised from this client instance.
// Also, it can be overridden at request level header options.
// SetHeader sets a single header field and its value in the client.
func (c *Client) SetHeader(key, val string) *Client {
c.header.Set(key, val)
return c
}
// AddHeaders method adds multiple headers field and its values at one go in the client instance.
// These headers will be applied to all requests raised from this client instance. Also it can be
// overridden at request level headers options.
// AddHeaders adds multiple header fields and their values to the client.
func (c *Client) AddHeaders(h map[string][]string) *Client {
c.header.AddHeaders(h)
return c
}
// SetHeaders method sets multiple headers field and its values at one go in the client instance.
// These headers will be applied to all requests raised from this client instance. Also it can be
// These headers will be applied to all requests created from this client instance. Also it can be
// overridden at request level headers options.
func (c *Client) SetHeaders(h map[string]string) *Client {
c.header.SetHeaders(h)
return c
}
// Param method returns params value via key,
// this method will visit all field in the query param.
// Param returns all values of the specified query parameter.
func (c *Client) Param(key string) []string {
res := []string{}
tmp := c.params.PeekMulti(key)
@ -328,47 +302,38 @@ func (c *Client) Param(key string) []string {
return res
}
// AddParam method adds a single query param field and its value in the client instance.
// These params will be applied to all requests raised from this client instance.
// Also, it can be overridden at request level param options.
// AddParam adds a single query parameter and its value to the client.
// These params will be applied to all requests created from this client instance.
func (c *Client) AddParam(key, val string) *Client {
c.params.Add(key, val)
return c
}
// SetParam method sets a single query param field and its value in the client instance.
// These params will be applied to all requests raised from this client instance.
// Also, it can be overridden at request level param options.
// SetParam sets a single query parameter and its value in the client.
func (c *Client) SetParam(key, val string) *Client {
c.params.Set(key, val)
return c
}
// AddParams method adds multiple query params field and its values at one go in the client instance.
// These params will be applied to all requests raised from this client instance. Also it can be
// overridden at request level params options.
// AddParams adds multiple query parameters and their values to the client.
func (c *Client) AddParams(m map[string][]string) *Client {
c.params.AddParams(m)
return c
}
// SetParams method sets multiple params field and its values at one go in the client instance.
// These params will be applied to all requests raised from this client instance. Also it can be
// overridden at request level params options.
// SetParams sets multiple query parameters and their values in the client.
func (c *Client) SetParams(m map[string]string) *Client {
c.params.SetParams(m)
return c
}
// SetParamsWithStruct method sets multiple params field and its values at one go in the client instance.
// These params will be applied to all requests raised from this client instance. Also it can be
// overridden at request level params options.
// SetParamsWithStruct sets multiple query parameters and their values using a struct.
func (c *Client) SetParamsWithStruct(v any) *Client {
c.params.SetParamsWithStruct(v)
return c
}
// DelParams method deletes single or multiple params field and its values in client.
// DelParams deletes one or more query parameters and their values from the client.
func (c *Client) DelParams(key ...string) *Client {
for _, v := range key {
c.params.Del(v)
@ -376,64 +341,51 @@ func (c *Client) DelParams(key ...string) *Client {
return c
}
// SetUserAgent method sets userAgent field and its value in the client instance.
// This ua will be applied to all requests raised from this client instance.
// Also it can be overridden at request level ua options.
// SetUserAgent sets the User-Agent header for the client.
func (c *Client) SetUserAgent(ua string) *Client {
c.userAgent = ua
return c
}
// SetReferer method sets referer field and its value in the client instance.
// This referer will be applied to all requests raised from this client instance.
// Also it can be overridden at request level referer options.
// SetReferer sets the Referer header for the client.
func (c *Client) SetReferer(r string) *Client {
c.referer = r
return c
}
// PathParam returns the path param be set in request instance.
// if path param doesn't exist, return empty string.
// PathParam returns the value of the specified path parameter. Returns an empty string if it does not exist.
func (c *Client) PathParam(key string) string {
if val, ok := (*c.path)[key]; ok {
return val
}
return ""
}
// SetPathParam method sets a single path param field and its value in the client instance.
// These path params will be applied to all requests raised from this client instance.
// Also it can be overridden at request level path params options.
// SetPathParam sets a single path parameter and its value in the client.
func (c *Client) SetPathParam(key, val string) *Client {
c.path.SetParam(key, val)
return c
}
// SetPathParams method sets multiple path params field and its values at one go in the client instance.
// These path params will be applied to all requests raised from this client instance. Also it can be
// overridden at request level path params options.
// SetPathParams sets multiple path parameters and their values in the client.
func (c *Client) SetPathParams(m map[string]string) *Client {
c.path.SetParams(m)
return c
}
// SetPathParamsWithStruct method sets multiple path params field and its values at one go in the client instance.
// These path params will be applied to all requests raised from this client instance. Also it can be
// overridden at request level path params options.
// SetPathParamsWithStruct sets multiple path parameters and their values using a struct.
func (c *Client) SetPathParamsWithStruct(v any) *Client {
c.path.SetParamsWithStruct(v)
return c
}
// DelPathParams method deletes single or multiple path params field and its values in client.
// DelPathParams deletes one or more path parameters and their values from the client.
func (c *Client) DelPathParams(key ...string) *Client {
c.path.DelParams(key...)
return c
}
// Cookie returns the cookie be set in request instance.
// if cookie doesn't exist, return empty string.
// Cookie returns the value of the specified cookie. Returns an empty string if it does not exist.
func (c *Client) Cookie(key string) string {
if val, ok := (*c.cookies)[key]; ok {
return val
@ -441,127 +393,111 @@ func (c *Client) Cookie(key string) string {
return ""
}
// SetCookie method sets a single cookie field and its value in the client instance.
// These cookies will be applied to all requests raised from this client instance.
// Also it can be overridden at request level cookie options.
// SetCookie sets a single cookie and its value in the client.
func (c *Client) SetCookie(key, val string) *Client {
c.cookies.SetCookie(key, val)
return c
}
// SetCookies method sets multiple cookies field and its values at one go in the client instance.
// These cookies will be applied to all requests raised from this client instance. Also it can be
// overridden at request level cookie options.
// SetCookies sets multiple cookies and their values in the client.
func (c *Client) SetCookies(m map[string]string) *Client {
c.cookies.SetCookies(m)
return c
}
// SetCookiesWithStruct method sets multiple cookies field and its values at one go in the client instance.
// These cookies will be applied to all requests raised from this client instance. Also it can be
// overridden at request level cookies options.
// SetCookiesWithStruct sets multiple cookies and their values using a struct.
func (c *Client) SetCookiesWithStruct(v any) *Client {
c.cookies.SetCookiesWithStruct(v)
return c
}
// DelCookies method deletes single or multiple cookies field and its values in client.
// DelCookies deletes one or more cookies and their values from the client.
func (c *Client) DelCookies(key ...string) *Client {
c.cookies.DelCookies(key...)
return c
}
// SetTimeout method sets timeout val in client instance.
// This value will be applied to all requests raised from this client instance.
// Also, it can be overridden at request level timeout options.
// SetTimeout sets the timeout value for the client. This applies to all requests unless overridden at the request level.
func (c *Client) SetTimeout(t time.Duration) *Client {
c.timeout = t
return c
}
// Debug enable log debug level output.
// Debug enables debug-level logging output.
func (c *Client) Debug() *Client {
c.debug = true
return c
}
// DisableDebug disables log debug level output.
// DisableDebug disables debug-level logging output.
func (c *Client) DisableDebug() *Client {
c.debug = false
return c
}
// SetCookieJar sets cookie jar in client instance.
// SetCookieJar sets the cookie jar for the client.
func (c *Client) SetCookieJar(cookieJar *CookieJar) *Client {
c.cookieJar = cookieJar
return c
}
// Get provide an API like axios which send get request.
// Get sends a GET request to the specified URL, similar to axios.
func (c *Client) Get(url string, cfg ...Config) (*Response, error) {
req := AcquireRequest().SetClient(c)
setConfigToRequest(req, cfg...)
return req.Get(url)
}
// Post provide an API like axios which send post request.
// Post sends a POST request to the specified URL, similar to axios.
func (c *Client) Post(url string, cfg ...Config) (*Response, error) {
req := AcquireRequest().SetClient(c)
setConfigToRequest(req, cfg...)
return req.Post(url)
}
// Head provide a API like axios which send head request.
// Head sends a HEAD request to the specified URL, similar to axios.
func (c *Client) Head(url string, cfg ...Config) (*Response, error) {
req := AcquireRequest().SetClient(c)
setConfigToRequest(req, cfg...)
return req.Head(url)
}
// Put provide an API like axios which send put request.
// Put sends a PUT request to the specified URL, similar to axios.
func (c *Client) Put(url string, cfg ...Config) (*Response, error) {
req := AcquireRequest().SetClient(c)
setConfigToRequest(req, cfg...)
return req.Put(url)
}
// Delete provide an API like axios which send delete request.
// Delete sends a DELETE request to the specified URL, similar to axios.
func (c *Client) Delete(url string, cfg ...Config) (*Response, error) {
req := AcquireRequest().SetClient(c)
setConfigToRequest(req, cfg...)
return req.Delete(url)
}
// Options provide an API like axios which send options request.
// Options sends an OPTIONS request to the specified URL, similar to axios.
func (c *Client) Options(url string, cfg ...Config) (*Response, error) {
req := AcquireRequest().SetClient(c)
setConfigToRequest(req, cfg...)
return req.Options(url)
}
// Patch provide an API like axios which send patch request.
// Patch sends a PATCH request to the specified URL, similar to axios.
func (c *Client) Patch(url string, cfg ...Config) (*Response, error) {
req := AcquireRequest().SetClient(c)
setConfigToRequest(req, cfg...)
return req.Patch(url)
}
// Custom provide an API like axios which send custom request.
// Custom sends a request with a custom method to the specified URL, similar to axios.
func (c *Client) Custom(url, method string, cfg ...Config) (*Response, error) {
req := AcquireRequest().SetClient(c)
setConfigToRequest(req, cfg...)
return req.Custom(url, method)
}
// SetDial sets dial function in client.
// SetDial sets the custom dial function for the client.
func (c *Client) SetDial(dial fasthttp.DialFunc) *Client {
c.mu.Lock()
defer c.mu.Unlock()
@ -570,7 +506,7 @@ func (c *Client) SetDial(dial fasthttp.DialFunc) *Client {
return c
}
// SetLogger sets logger instance in client.
// SetLogger sets the logger instance used by the client.
func (c *Client) SetLogger(logger log.CommonLogger) *Client {
c.mu.Lock()
defer c.mu.Unlock()
@ -579,12 +515,12 @@ func (c *Client) SetLogger(logger log.CommonLogger) *Client {
return c
}
// Logger returns logger instance of client.
// Logger returns the logger instance used by the client.
func (c *Client) Logger() log.CommonLogger {
return c.logger
}
// Reset clears the Client object
// Reset resets the client to its default state, clearing most configurations.
func (c *Client) Reset() {
c.fasthttp = &fasthttp.Client{}
c.baseURL = ""
@ -605,31 +541,25 @@ func (c *Client) Reset() {
c.params.Reset()
}
// Config for easy to set the request parameters, it should be
// noted that when setting the request body will use JSON as
// the default serialization mechanism, while the priority of
// Body is higher than FormData, and the priority of FormData
// is higher than File.
// Config is used to easily set request parameters. Note that when setting a request body,
// JSON is used as the default serialization mechanism. The priority is:
// Body > FormData > File.
type Config struct {
Ctx context.Context //nolint:containedctx // It's needed to be stored in the config.
Body any
Header map[string]string
Param map[string]string
Cookie map[string]string
PathParam map[string]string
FormData map[string]string
UserAgent string
Referer string
File []*File
Ctx context.Context //nolint:containedctx // It's needed to be stored in the config.
Body any
Header map[string]string
Param map[string]string
Cookie map[string]string
PathParam map[string]string
FormData map[string]string
UserAgent string
Referer string
File []*File
Timeout time.Duration
MaxRedirects int
}
// setConfigToRequest Set the parameters passed via Config to Request.
// setConfigToRequest sets the parameters passed via Config to the Request.
func setConfigToRequest(req *Request, config ...Config) {
if len(config) == 0 {
return
@ -694,21 +624,19 @@ var (
defaultUserAgent = "fiber"
)
// init acquire a default client.
func init() {
defaultClient = New()
}
// New creates and returns a new Client object.
func New() *Client {
// FOllOW-UP performance optimization
// trie to use a pool to reduce the cost of memory allocation
// for the fiber client and the fasthttp client
// if possible also for other structs -> request header, cookie, query param, path param...
// Follow-up performance optimizations:
// Try to use a pool to reduce the memory allocation cost for the Fiber client and the fasthttp client.
// If possible, also consider pooling other structs (e.g., request headers, cookies, query parameters, path parameters).
return NewWithClient(&fasthttp.Client{})
}
// NewWithClient creates and returns a new Client object from an existing client.
// NewWithClient creates and returns a new Client object from an existing fasthttp.Client.
func NewWithClient(c *fasthttp.Client) *Client {
if c == nil {
panic("fasthttp.Client must not be nil")
@ -738,12 +666,12 @@ func NewWithClient(c *fasthttp.Client) *Client {
}
}
// C get default client.
// C returns the default client.
func C() *Client {
return defaultClient
}
// Replace the defaultClient, the returned function can undo.
// Replace replaces the defaultClient with a new one, returning a function to restore the old client.
func Replace(c *Client) func() {
replaceMu.Lock()
defer replaceMu.Unlock()
@ -759,37 +687,37 @@ func Replace(c *Client) func() {
}
}
// Get send a get request use defaultClient, a convenient method.
// Get sends a GET request using the default client.
func Get(url string, cfg ...Config) (*Response, error) {
return C().Get(url, cfg...)
}
// Post send a post request use defaultClient, a convenient method.
// Post sends a POST request using the default client.
func Post(url string, cfg ...Config) (*Response, error) {
return C().Post(url, cfg...)
}
// Head send a head request use defaultClient, a convenient method.
// Head sends a HEAD request using the default client.
func Head(url string, cfg ...Config) (*Response, error) {
return C().Head(url, cfg...)
}
// Put send a put request use defaultClient, a convenient method.
// Put sends a PUT request using the default client.
func Put(url string, cfg ...Config) (*Response, error) {
return C().Put(url, cfg...)
}
// Delete send a delete request use defaultClient, a convenient method.
// Delete sends a DELETE request using the default client.
func Delete(url string, cfg ...Config) (*Response, error) {
return C().Delete(url, cfg...)
}
// Options send a options request use defaultClient, a convenient method.
// Options sends an OPTIONS request using the default client.
func Options(url string, cfg ...Config) (*Response, error) {
return C().Options(url, cfg...)
}
// Patch send a patch request use defaultClient, a convenient method.
// Patch sends a PATCH request using the default client.
func Patch(url string, cfg ...Config) (*Response, error) {
return C().Patch(url, cfg...)
}

86
client/cookiejar.go
View File

@ -1,4 +1,4 @@
// The code has been taken from https://github.com/valyala/fasthttp/pull/526 originally.
// The code was originally taken from https://github.com/valyala/fasthttp/pull/526.
package client
import (
@ -18,7 +18,7 @@ var cookieJarPool = sync.Pool{
},
}
// AcquireCookieJar returns an empty CookieJar object from pool.
// AcquireCookieJar returns an empty CookieJar object from the pool.
func AcquireCookieJar() *CookieJar {
jar, ok := cookieJarPool.Get().(*CookieJar)
if !ok {
@ -28,22 +28,23 @@ func AcquireCookieJar() *CookieJar {
return jar
}
// ReleaseCookieJar returns CookieJar to the pool.
// ReleaseCookieJar returns a CookieJar object to the pool.
func ReleaseCookieJar(c *CookieJar) {
c.Release()
cookieJarPool.Put(c)
}
// CookieJar manages cookie storage. It is used by the client to store cookies.
// CookieJar manages cookie storage for the client. It stores cookies keyed by host.
type CookieJar struct {
hostCookies map[string][]*fasthttp.Cookie
mu sync.Mutex
}
// Get returns the cookies stored from a specific domain.
// If there were no cookies related with host returned slice will be nil.
// Get returns all cookies stored for a given URI. If there are no cookies for the
// provided host, the returned slice will be nil.
//
// CookieJar keeps a copy of the cookies, so the returned cookies can be released safely.
// The CookieJar keeps its own copies of cookies, so it is safe to release the returned
// cookies after use.
func (cj *CookieJar) Get(uri *fasthttp.URI) []*fasthttp.Cookie {
if uri == nil {
return nil
@ -52,7 +53,7 @@ func (cj *CookieJar) Get(uri *fasthttp.URI) []*fasthttp.Cookie {
return cj.getByHostAndPath(uri.Host(), uri.Path())
}
// get returns the cookies stored from a specific host and path.
// getByHostAndPath returns cookies stored for a specific host and path.
func (cj *CookieJar) getByHostAndPath(host, path []byte) []*fasthttp.Cookie {
if cj.hostCookies == nil {
return nil
@ -84,8 +85,7 @@ func (cj *CookieJar) getByHostAndPath(host, path []byte) []*fasthttp.Cookie {
return newCookies
}
// getCookiesByHost returns the cookies stored from a specific host.
// If cookies are expired they will be deleted.
// getCookiesByHost returns cookies stored for a specific host, removing any that have expired.
func (cj *CookieJar) getCookiesByHost(host string) []*fasthttp.Cookie {
cj.mu.Lock()
defer cj.mu.Unlock()
@ -95,7 +95,8 @@ func (cj *CookieJar) getCookiesByHost(host string) []*fasthttp.Cookie {
for i := 0; i < len(cookies); i++ {
c := cookies[i]
if !c.Expire().Equal(fasthttp.CookieExpireUnlimited) && c.Expire().Before(now) { // release cookie if expired
// Remove expired cookies.
if !c.Expire().Equal(fasthttp.CookieExpireUnlimited) && c.Expire().Before(now) {
cookies = append(cookies[:i], cookies[i+1:]...)
fasthttp.ReleaseCookie(c)
i--
@ -105,23 +106,21 @@ func (cj *CookieJar) getCookiesByHost(host string) []*fasthttp.Cookie {
return cookies
}
// Set sets cookies for a specific host.
// The host is get from uri.Host().
// If the cookie key already exists it will be replaced by the new cookie value.
// Set stores the given cookies for the specified URI host. If a cookie key already exists,
// it will be replaced by the new cookie value.
//
// CookieJar keeps a copy of the cookies, so the parsed cookies can be released safely.
// CookieJar stores copies of the provided cookies, so they may be safely released after use.
func (cj *CookieJar) Set(uri *fasthttp.URI, cookies ...*fasthttp.Cookie) {
if uri == nil {
return
}
cj.SetByHost(uri.Host(), cookies...)
}
// SetByHost sets cookies for a specific host.
// If the cookie key already exists it will be replaced by the new cookie value.
// SetByHost stores the given cookies for the specified host. If a cookie key already exists,
// it will be replaced by the new cookie value.
//
// CookieJar keeps a copy of the cookies, so the parsed cookies can be released safely.
// CookieJar stores copies of the provided cookies, so they may be safely released after use.
func (cj *CookieJar) SetByHost(host []byte, cookies ...*fasthttp.Cookie) {
hostStr := utils.UnsafeString(host)
@ -134,26 +133,25 @@ func (cj *CookieJar) SetByHost(host []byte, cookies ...*fasthttp.Cookie) {
hostCookies, ok := cj.hostCookies[hostStr]
if !ok {
// If the key does not exist in the map, then we must make a copy for the key to avoid unsafe usage.
// If the key does not exist in the map, make a copy to avoid unsafe usage.
hostStr = string(host)
}
for _, cookie := range cookies {
c := searchCookieByKeyAndPath(cookie.Key(), cookie.Path(), hostCookies)
if c == nil {
// If the cookie does not exist in the slice, let's acquire new cookie and store it.
c = fasthttp.AcquireCookie()
hostCookies = append(hostCookies, c)
existing := searchCookieByKeyAndPath(cookie.Key(), cookie.Path(), hostCookies)
if existing == nil {
// If the cookie does not exist, acquire a new one.
existing = fasthttp.AcquireCookie()
hostCookies = append(hostCookies, existing)
}
c.CopyTo(cookie) // override cookie properties
existing.CopyTo(cookie) // Override cookie properties.
}
cj.hostCookies[hostStr] = hostCookies
}
// SetKeyValue sets a cookie by key and value for a specific host.
// SetKeyValue sets a cookie for the specified host with the given key and value.
//
// This function prevents extra allocations by making repeated cookies
// not being duplicated.
// This function helps prevent extra allocations by avoiding duplication of repeated cookies.
func (cj *CookieJar) SetKeyValue(host, key, value string) {
c := fasthttp.AcquireCookie()
c.SetKey(key)
@ -162,10 +160,9 @@ func (cj *CookieJar) SetKeyValue(host, key, value string) {
cj.SetByHost(utils.UnsafeBytes(host), c)
}
// SetKeyValueBytes sets a cookie by key and value for a specific host.
// SetKeyValueBytes sets a cookie for the specified host using byte slices for the key and value.
//
// This function prevents extra allocations by making repeated cookies
// not being duplicated.
// This function helps prevent extra allocations by avoiding duplication of repeated cookies.
func (cj *CookieJar) SetKeyValueBytes(host string, key, value []byte) {
c := fasthttp.AcquireCookie()
c.SetKeyBytes(key)
@ -174,17 +171,16 @@ func (cj *CookieJar) SetKeyValueBytes(host string, key, value []byte) {
cj.SetByHost(utils.UnsafeBytes(host), c)
}
// dumpCookiesToReq dumps the stored cookies to the request.
// dumpCookiesToReq writes the stored cookies to the given request.
func (cj *CookieJar) dumpCookiesToReq(req *fasthttp.Request) {
uri := req.URI()
cookies := cj.getByHostAndPath(uri.Host(), uri.Path())
for _, cookie := range cookies {
req.Header.SetCookieBytesKV(cookie.Key(), cookie.Value())
}
}
// parseCookiesFromResp parses the response cookies and stores them.
// parseCookiesFromResp parses the cookies from the response and stores them for the specified host and path.
func (cj *CookieJar) parseCookiesFromResp(host, path []byte, resp *fasthttp.Response) {
hostStr := utils.UnsafeString(host)
@ -194,35 +190,36 @@ func (cj *CookieJar) parseCookiesFromResp(host, path []byte, resp *fasthttp.Resp
if cj.hostCookies == nil {
cj.hostCookies = make(map[string][]*fasthttp.Cookie)
}
cookies, ok := cj.hostCookies[hostStr]
if !ok {
// If the key does not exist in the map then
// we must make a copy for the key to avoid unsafe usage.
// If the key does not exist in the map, make a copy to avoid unsafe usage.
hostStr = string(host)
}
now := time.Now()
resp.Header.VisitAllCookie(func(key, value []byte) {
isCreated := false
created := false
c := searchCookieByKeyAndPath(key, path, cookies)
if c == nil {
c, isCreated = fasthttp.AcquireCookie(), true
c, created = fasthttp.AcquireCookie(), true
}
_ = c.ParseBytes(value) //nolint:errcheck // ignore error
if c.Expire().Equal(fasthttp.CookieExpireUnlimited) || c.Expire().After(now) {
cookies = append(cookies, c)
} else if isCreated {
} else if created {
fasthttp.ReleaseCookie(c)
}
})
cj.hostCookies[hostStr] = cookies
}
// Release releases all cookie values.
// Release releases all stored cookies. After this, the CookieJar is empty.
func (cj *CookieJar) Release() {
// FOllOW-UP performance optimization
// currently a race condition is found because the reset method modifies a value which is not a copy but a reference -> solution should be to make a copy
// FOLLOW-UP performance optimization:
// Currently, a race condition is found because the reset method modifies a value
// that is not a copy but a reference. A solution would be to make a copy.
// for _, v := range cj.hostCookies {
// for _, c := range v {
// fasthttp.ReleaseCookie(c)
@ -231,7 +228,7 @@ func (cj *CookieJar) Release() {
cj.hostCookies = nil
}
// searchCookieByKeyAndPath searches for a cookie by key and path.
// searchCookieByKeyAndPath looks up a cookie by its key and path from the provided slice of cookies.
func searchCookieByKeyAndPath(key, path []byte, cookies []*fasthttp.Cookie) *fasthttp.Cookie {
for _, c := range cookies {
if bytes.Equal(key, c.Key()) {
@ -240,6 +237,5 @@ func searchCookieByKeyAndPath(key, path []byte, cookies []*fasthttp.Cookie) *fas
}
}
}
return nil
}

102
client/core.go
View File

@ -16,23 +16,21 @@ import (
var boundary = "--FiberFormBoundary"
// RequestHook is a function that receives Agent and Request,
// it can change the data in Request and Agent.
//
// Called before a request is sent.
// RequestHook is a function invoked before the request is sent.
// It receives a Client and a Request, allowing you to modify the Request or Client data.
type RequestHook func(*Client, *Request) error
// ResponseHook is a function that receives Agent, Response and Request,
// it can change the data is Response or deal with some effects.
//
// Called after a response has been received.
// ResponseHook is a function invoked after a response is received.
// It receives a Client, Response, and Request, allowing you to modify the Response data
// or perform actions based on the response.
type ResponseHook func(*Client, *Response, *Request) error
// RetryConfig is an alias for config in the `addon/retry` package.
// RetryConfig is an alias for the `retry.Config` type from the `addon/retry` package.
type RetryConfig = retry.Config
// addMissingPort will add the corresponding port number for host.
func addMissingPort(addr string, isTLS bool) string { //revive:disable-line:flag-parameter // Accepting a bool param named isTLS if fine here
// addMissingPort appends the appropriate port number to the given address if it doesn't have one.
// If isTLS is true, it uses port 443; otherwise, it uses port 80.
func addMissingPort(addr string, isTLS bool) string { //revive:disable-line:flag-parameter
n := strings.Index(addr, ":")
if n >= 0 {
return addr
@ -44,15 +42,14 @@ func addMissingPort(addr string, isTLS bool) string { //revive:disable-line:flag
return net.JoinHostPort(addr, strconv.Itoa(port))
}
// `core` stores middleware and plugin definitions,
// and defines the execution process
// core stores middleware and plugin definitions and defines the request execution process.
type core struct {
client *Client
req *Request
ctx context.Context //nolint:containedctx // It's needed to be stored in the core.
ctx context.Context //nolint:containedctx // Context is needed here.
}
// getRetryConfig returns the retry configuration of the client.
// getRetryConfig returns a copy of the client's retry configuration.
func (c *core) getRetryConfig() *RetryConfig {
c.client.mu.RLock()
defer c.client.mu.RUnlock()
@ -70,19 +67,16 @@ func (c *core) getRetryConfig() *RetryConfig {
}
}
// execFunc is the core function of the client.
// It sends the request and receives the response.
// execFunc is the core logic to send the request and receive the response.
// It leverages the fasthttp client, optionally with retries or redirects.
func (c *core) execFunc() (*Response, error) {
resp := AcquireResponse()
resp.setClient(c.client)
resp.setRequest(c.req)
// To avoid memory allocation reuse of data structures such as errch.
done := int32(0)
errCh, reqv := acquireErrChan(), fasthttp.AcquireRequest()
defer func() {
releaseErrChan(errCh)
}()
defer releaseErrChan(errCh)
c.req.RawRequest.CopyTo(reqv)
cfg := c.getRetryConfig()
@ -96,11 +90,11 @@ func (c *core) execFunc() (*Response, error) {
}()
if cfg != nil {
// Use an exponential backoff retry strategy.
err = retry.NewExponentialBackoff(*cfg).Retry(func() error {
if c.req.maxRedirects > 0 && (string(reqv.Header.Method()) == fiber.MethodGet || string(reqv.Header.Method()) == fiber.MethodHead) {
return c.client.fasthttp.DoRedirects(reqv, respv, c.req.maxRedirects)
}
return c.client.fasthttp.Do(reqv, respv)
})
} else {
@ -124,7 +118,7 @@ func (c *core) execFunc() (*Response, error) {
select {
case err := <-errCh:
if err != nil {
// When get error should release Response
// Release the response if an error occurs.
ReleaseResponse(resp)
return nil, err
}
@ -136,21 +130,19 @@ func (c *core) execFunc() (*Response, error) {
}
}
// preHooks Exec request hook
// preHooks runs all request hooks before sending the request.
func (c *core) preHooks() error {
c.client.mu.Lock()
defer c.client.mu.Unlock()
for _, f := range c.client.userRequestHooks {
err := f(c.client, c.req)
if err != nil {
if err := f(c.client, c.req); err != nil {
return err
}
}
for _, f := range c.client.builtinRequestHooks {
err := f(c.client, c.req)
if err != nil {
if err := f(c.client, c.req); err != nil {
return err
}
}
@ -158,21 +150,19 @@ func (c *core) preHooks() error {
return nil
}
// afterHooks Exec response hooks
// afterHooks runs all response hooks after receiving the response.
func (c *core) afterHooks(resp *Response) error {
c.client.mu.Lock()
defer c.client.mu.Unlock()
for _, f := range c.client.builtinResponseHooks {
err := f(c.client, resp, c.req)
if err != nil {
if err := f(c.client, resp, c.req); err != nil {
return err
}
}
for _, f := range c.client.userResponseHooks {
err := f(c.client, resp, c.req)
if err != nil {
if err := f(c.client, resp, c.req); err != nil {
return err
}
}
@ -180,7 +170,7 @@ func (c *core) afterHooks(resp *Response) error {
return nil
}
// timeout deals with timeout
// timeout applies the configured timeout to the request, if any.
func (c *core) timeout() context.CancelFunc {
var cancel context.CancelFunc
@ -193,35 +183,32 @@ func (c *core) timeout() context.CancelFunc {
return cancel
}
// execute will exec each hooks and plugins.
// execute runs all hooks, applies timeouts, sends the request, and runs response hooks.
func (c *core) execute(ctx context.Context, client *Client, req *Request) (*Response, error) {
// keep a reference, because pass param is boring
// Store references locally.
c.ctx = ctx
c.client = client
c.req = req
// The built-in hooks will be executed only
// after the user-defined hooks are executed.
err := c.preHooks()
if err != nil {
// Execute pre request hooks (user-defined and built-in).
if err := c.preHooks(); err != nil {
return nil, err
}
// Apply timeout if specified.
cancel := c.timeout()
if cancel != nil {
defer cancel()
}
// Do http request
// Perform the actual HTTP request.
resp, err := c.execFunc()
if err != nil {
return nil, err
}
// The built-in hooks will be executed only
// before the user-defined hooks are executed.
err = c.afterHooks(resp)
if err != nil {
// Execute after response hooks (built-in and then user-defined).
if err := c.afterHooks(resp); err != nil {
resp.Close()
return nil, err
}
@ -235,38 +222,35 @@ var errChanPool = &sync.Pool{
},
}
// acquireErrChan returns an empty error chan from the pool.
// acquireErrChan returns an empty error channel from the pool.
//
// The returned error chan may be returned to the pool with releaseErrChan when no longer needed.
// This allows reducing GC load.
// The returned channel may be returned to the pool with releaseErrChan when no longer needed,
// reducing GC load.
func acquireErrChan() chan error {
ch, ok := errChanPool.Get().(chan error)
if !ok {
panic(errors.New("failed to type-assert to chan error"))
}
return ch
}
// releaseErrChan returns the object acquired via acquireErrChan to the pool.
// releaseErrChan returns the error channel to the pool.
//
// Do not access the released core object, otherwise data races may occur.
// Do not use the released channel afterward to avoid data races.
func releaseErrChan(ch chan error) {
errChanPool.Put(ch)
}
// newCore returns an empty core object.
// newCore returns a new core object.
func newCore() *core {
c := &core{}
return c
return &core{}
}
var (
ErrTimeoutOrCancel = errors.New("timeout or cancel")
ErrURLFormat = errors.New("the url is a mistake")
ErrNotSupportSchema = errors.New("the protocol is not support, only http or https")
ErrFileNoName = errors.New("the file should have name")
ErrURLFormat = errors.New("the URL is incorrect")
ErrNotSupportSchema = errors.New("protocol not supported; only http or https are allowed")
ErrFileNoName = errors.New("the file should have a name")
ErrBodyType = errors.New("the body type should be []byte")
ErrNotSupportSaveMethod = errors.New("file path and io.Writer are supported")
ErrNotSupportSaveMethod = errors.New("only file paths and io.Writer are supported")
)

87
client/hooks.go
View File

@ -30,10 +30,10 @@ var (
letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
letterIdxBits = 6 // 6 bits to represent a letter index
letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
letterIdxMax = 63 / letterIdxBits // # of letter indices fitting in 63 bits
letterIdxMax = 63 / letterIdxBits // # of letter indices fitting into 63 bits
)
// randString returns a random string with n length
// randString returns a random string of length n.
func randString(n int) string {
b := make([]byte, n)
length := len(letterBytes)
@ -55,17 +55,14 @@ func randString(n int) string {
return utils.UnsafeString(b)
}
// parserRequestURL will set the options for the hostclient
// and normalize the url.
// The baseUrl will be merge with request uri.
// Query params and path params deal in this function.
// parserRequestURL sets options for the hostclient and normalizes the URL.
// It merges the baseURL with the request URI if needed and applies query and path parameters.
func parserRequestURL(c *Client, req *Request) error {
splitURL := strings.Split(req.url, "?")
// I don't want to judge splitURL length.
// Ensure splitURL has at least two elements.
splitURL = append(splitURL, "")
// Determine whether to superimpose baseurl based on
// whether the URL starts with the protocol
// If the URL doesn't start with http/https, prepend the baseURL.
uri := splitURL[0]
if !protocolCheck.MatchString(uri) {
uri = c.baseURL + uri
@ -74,7 +71,7 @@ func parserRequestURL(c *Client, req *Request) error {
}
}
// set path params
// Set path parameters from the request and client.
req.path.VisitAll(func(key, val string) {
uri = strings.ReplaceAll(uri, ":"+key, val)
})
@ -82,47 +79,47 @@ func parserRequestURL(c *Client, req *Request) error {
uri = strings.ReplaceAll(uri, ":"+key, val)
})
// set uri to request and other related setting
// Set the URI in the raw request.
req.RawRequest.SetRequestURI(uri)
// merge query params
// Merge query parameters.
hashSplit := strings.Split(splitURL[1], "#")
hashSplit = append(hashSplit, "")
args := fasthttp.AcquireArgs()
defer func() {
fasthttp.ReleaseArgs(args)
}()
defer fasthttp.ReleaseArgs(args)
args.Parse(hashSplit[0])
c.params.VisitAll(func(key, value []byte) {
args.AddBytesKV(key, value)
})
req.params.VisitAll(func(key, value []byte) {
args.AddBytesKV(key, value)
})
req.RawRequest.URI().SetQueryStringBytes(utils.CopyBytes(args.QueryString()))
req.RawRequest.URI().SetHash(hashSplit[1])
return nil
}
// parserRequestHeader will make request header up.
// It will merge headers from client and request.
// Header should be set automatically based on data.
// User-Agent should be set.
// parserRequestHeader merges client and request headers, and sets headers automatically based on the request data.
// It also sets the User-Agent and Referer headers, and applies any cookies from the cookie jar.
func parserRequestHeader(c *Client, req *Request) error {
// set method
// Set HTTP method.
req.RawRequest.Header.SetMethod(req.Method())
// merge header
// Merge headers from the client.
c.header.VisitAll(func(key, value []byte) {
req.RawRequest.Header.AddBytesKV(key, value)
})
// Merge headers from the request.
req.header.VisitAll(func(key, value []byte) {
req.RawRequest.Header.AddBytesKV(key, value)
})
// according to data set content-type
// Set Content-Type and Accept headers based on the request body type.
switch req.bodyType {
case jsonBody:
req.RawRequest.Header.SetContentType(applicationJSON)
@ -135,15 +132,16 @@ func parserRequestHeader(c *Client, req *Request) error {
req.RawRequest.Header.SetContentType(applicationForm)
case filesBody:
req.RawRequest.Header.SetContentType(multipartFormData)
// set boundary
// If boundary is default, append a random string to it.
if req.boundary == boundary {
req.boundary += randString(16)
}
req.RawRequest.Header.SetMultipartFormBoundary(req.boundary)
default:
// noBody or rawBody do not require special handling here.
}
// set useragent
// Set User-Agent header.
req.RawRequest.Header.SetUserAgent(defaultUserAgent)
if c.userAgent != "" {
req.RawRequest.Header.SetUserAgent(c.userAgent)
@ -152,22 +150,23 @@ func parserRequestHeader(c *Client, req *Request) error {
req.RawRequest.Header.SetUserAgent(req.userAgent)
}
// set referer
// Set Referer header.
req.RawRequest.Header.SetReferer(c.referer)
if req.referer != "" {
req.RawRequest.Header.SetReferer(req.referer)
}
// set cookie
// add cookie form jar to req
// Set cookies from the cookie jar if available.
if c.cookieJar != nil {
c.cookieJar.dumpCookiesToReq(req.RawRequest)
}
// Set cookies from the client.
c.cookies.VisitAll(func(key, val string) {
req.RawRequest.Header.SetCookie(key, val)
})
// Set cookies from the request.
req.cookies.VisitAll(func(key, val string) {
req.RawRequest.Header.SetCookie(key, val)
})
@ -175,8 +174,7 @@ func parserRequestHeader(c *Client, req *Request) error {
return nil
}
// parserRequestBody automatically serializes the data according to
// the data type and stores it in the body of the rawRequest
// parserRequestBody serializes the request body based on its type and sets it into the RawRequest.
func parserRequestBody(c *Client, req *Request) error {
switch req.bodyType {
case jsonBody:
@ -208,14 +206,14 @@ func parserRequestBody(c *Client, req *Request) error {
return ErrBodyType
}
case noBody:
// No body to set.
return nil
}
return nil
}
// parserRequestBodyFile parses request body if body type is file
// this is an addition of parserRequestBody.
// parserRequestBodyFile handles the case where the request contains files to be uploaded.
func parserRequestBodyFile(req *Request) error {
mw := multipart.NewWriter(req.RawRequest.BodyWriter())
err := mw.SetBoundary(req.boundary)
@ -223,13 +221,14 @@ func parserRequestBodyFile(req *Request) error {
return fmt.Errorf("set boundary error: %w", err)
}
defer func() {
err := mw.Close()
if err != nil {
e := mw.Close()
if e != nil {
// Close errors are typically ignored.
return
}
}()
// add formdata
// Add form data.
req.formData.VisitAll(func(key, value []byte) {
if err != nil {
return
@ -240,25 +239,25 @@ func parserRequestBodyFile(req *Request) error {
return fmt.Errorf("write formdata error: %w", err)
}
// add files
fileBuf := make([]byte, 1<<20) // Allocate 1MB buffer
// Add files.
fileBuf := make([]byte, 1<<20) // 1MB buffer
for i, v := range req.files {
if v.name == "" && v.path == "" {
return ErrFileNoName
}
// if name is not exist, set name
// Set the file name if not provided.
if v.name == "" && v.path != "" {
v.path = filepath.Clean(v.path)
v.name = filepath.Base(v.path)
}
// if field name is not exist, set it
// Set the field name if not provided.
if v.fieldName == "" {
v.fieldName = "file" + strconv.Itoa(i+1)
}
// check the reader
// If reader is not set, open the file.
if v.reader == nil {
v.reader, err = os.Open(v.path)
if err != nil {
@ -266,13 +265,12 @@ func parserRequestBodyFile(req *Request) error {
}
}
// write file
// Create form file and copy the content.
w, err := mw.CreateFormFile(v.fieldName, v.name)
if err != nil {
return fmt.Errorf("create file error: %w", err)
}
// Copy the file from reader to multipart writer
if _, err := io.CopyBuffer(w, v.reader, fileBuf); err != nil {
return fmt.Errorf("failed to copy file data: %w", err)
}
@ -285,7 +283,7 @@ func parserRequestBodyFile(req *Request) error {
return nil
}
// parserResponseCookie will parse the response header and store it in the response
// parserResponseCookie parses the Set-Cookie headers from the response and stores them.
func parserResponseCookie(c *Client, resp *Response, req *Request) error {
var err error
resp.RawResponse.Header.VisitAllCookie(func(key, value []byte) {
@ -295,7 +293,6 @@ func parserResponseCookie(c *Client, resp *Response, req *Request) error {
return
}
cookie.SetKeyBytes(key)
resp.cookie = append(resp.cookie, cookie)
})
@ -303,7 +300,7 @@ func parserResponseCookie(c *Client, resp *Response, req *Request) error {
return err
}
// store cookies to jar
// Store cookies in the cookie jar if available.
if c.cookieJar != nil {
c.cookieJar.parseCookiesFromResp(req.RawRequest.URI().Host(), req.RawRequest.URI().Path(), resp.RawResponse)
}
@ -311,7 +308,7 @@ func parserResponseCookie(c *Client, resp *Response, req *Request) error {
return nil
}
// logger is a response hook that logs the request and response
// logger is a response hook that logs request and response data if debug mode is enabled.
func logger(c *Client, resp *Response, req *Request) error {
if !c.debug {
return nil

382
client/request.go
View File

File diff suppressed because it is too large Load Diff

73
client/response.go
View File

@ -15,7 +15,7 @@ import (
"github.com/valyala/fasthttp"
)
// Response is the result of a request. This object is used to access the response data.
// Response represents the result of a request. It provides access to the response data.
type Response struct {
client *Client
request *Request
@ -24,47 +24,44 @@ type Response struct {
cookie []*fasthttp.Cookie
}
// setClient method sets client object in response instance.
// Use core object in the client.
// setClient sets the client instance in the response. The client object is used by core functionalities.
func (r *Response) setClient(c *Client) {
r.client = c
}
// setRequest method sets Request object in response instance.
// The request will be released when the Response.Close is called.
// setRequest sets the request object in the response. The request is released when Response.Close is called.
func (r *Response) setRequest(req *Request) {
r.request = req
}
// Status method returns the HTTP status string for the executed request.
// Status returns the HTTP status message of the executed request.
func (r *Response) Status() string {
return string(r.RawResponse.Header.StatusMessage())
}
// StatusCode method returns the HTTP status code for the executed request.
// StatusCode returns the HTTP status code of the executed request.
func (r *Response) StatusCode() int {
return r.RawResponse.StatusCode()
}
// Protocol method returns the HTTP response protocol used for the request.
// Protocol returns the HTTP protocol used for the request.
func (r *Response) Protocol() string {
return string(r.RawResponse.Header.Protocol())
}
// Header method returns the response headers.
// Header returns the value of the specified response header field.
func (r *Response) Header(key string) string {
return utils.UnsafeString(r.RawResponse.Header.Peek(key))
}
// Headers returns all headers in the response using an iterator.
// You can use maps.Collect() to collect all headers into a map.
// Use maps.Collect() to gather them into a map if needed.
//
// The returned value is valid until the response object is released.
// Any future calls to Headers method will return the modified value. Do not store references to returned value. Make copies instead.
// The returned values are valid only until the response object is released.
// Do not store references to returned values; make copies instead.
func (r *Response) Headers() iter.Seq2[string, []string] {
return func(yield func(string, []string) bool) {
keys := r.RawResponse.Header.PeekKeys()
for _, key := range keys {
vals := r.RawResponse.Header.PeekAll(utils.UnsafeString(key))
valsStr := make([]string, len(vals))
@ -79,47 +76,49 @@ func (r *Response) Headers() iter.Seq2[string, []string] {
}
}
// Cookies method to access all the response cookies.
// Cookies returns all cookies set by the response.
//
// The returned value is valid until the response object is released.
// Any future calls to Cookies method will return the modified value. Do not store references to returned value. Make copies instead.
// The returned values are valid only until the response object is released.
// Do not store references to returned values; make copies instead.
func (r *Response) Cookies() []*fasthttp.Cookie {
return r.cookie
}
// Body method returns HTTP response as []byte array for the executed request.
// Body returns the HTTP response body as a byte slice.
func (r *Response) Body() []byte {
return r.RawResponse.Body()
}
// String method returns the body of the server response as String.
// String returns the response body as a trimmed string.
func (r *Response) String() string {
return utils.Trim(string(r.Body()), ' ')
}
// JSON method will unmarshal body to json.
// JSON unmarshals the response body into the given interface{} using JSON.
func (r *Response) JSON(v any) error {
return r.client.jsonUnmarshal(r.Body(), v)
}
// CBOR method will unmarshal body to CBOR.
// CBOR unmarshals the response body into the given interface{} using CBOR.
func (r *Response) CBOR(v any) error {
return r.client.cborUnmarshal(r.Body(), v)
}
// XML method will unmarshal body to xml.
// XML unmarshals the response body into the given interface{} using XML.
func (r *Response) XML(v any) error {
return r.client.xmlUnmarshal(r.Body(), v)
}
// Save method will save the body to a file or io.Writer.
// Save writes the response body to a file or io.Writer.
// If a string path is provided, it creates directories if needed, then writes to a file.
// If an io.Writer is provided, it writes directly to it.
func (r *Response) Save(v any) error {
switch p := v.(type) {
case string:
file := filepath.Clean(p)
dir := filepath.Dir(file)
// create directory
// Create directory if it doesn't exist
if _, err := os.Stat(dir); err != nil {
if !errors.Is(err, fs.ErrNotExist) {
return fmt.Errorf("failed to check directory: %w", err)
@ -130,22 +129,21 @@ func (r *Response) Save(v any) error {
}
}
// create file
// Create and write to file
outFile, err := os.Create(file)
if err != nil {
return fmt.Errorf("failed to create file: %w", err)
}
defer func() { _ = outFile.Close() }() //nolint:errcheck // not needed
_, err = io.Copy(outFile, bytes.NewReader(r.Body()))
if err != nil {
if _, err = io.Copy(outFile, bytes.NewReader(r.Body())); err != nil {
return fmt.Errorf("failed to write response body to file: %w", err)
}
return nil
case io.Writer:
_, err := io.Copy(p, bytes.NewReader(r.Body()))
if err != nil {
if _, err := io.Copy(p, bytes.NewReader(r.Body())); err != nil {
return fmt.Errorf("failed to write response body to io.Writer: %w", err)
}
defer func() {
@ -153,14 +151,14 @@ func (r *Response) Save(v any) error {
_ = pc.Close() //nolint:errcheck // not needed
}
}()
return nil
default:
return ErrNotSupportSaveMethod
}
}
// Reset clears the Response object.
// Reset clears the Response object, making it ready for reuse.
func (r *Response) Reset() {
r.client = nil
r.request = nil
@ -174,8 +172,8 @@ func (r *Response) Reset() {
r.RawResponse.Reset()
}
// Close method will release Request object and Response object,
// after call Close please don't use these object.
// Close releases both the Request and Response objects back to their pools.
// After calling Close, do not use these objects.
func (r *Response) Close() {
if r.request != nil {
tmp := r.request
@ -194,10 +192,8 @@ var responsePool = &sync.Pool{
},
}
// AcquireResponse returns an empty response object from the pool.
//
// The returned response may be returned to the pool with ReleaseResponse when no longer needed.
// This allows reducing GC load.
// AcquireResponse returns a new (pooled) Response object.
// When done, release it with ReleaseResponse to reduce GC load.
func AcquireResponse() *Response {
resp, ok := responsePool.Get().(*Response)
if !ok {
@ -206,9 +202,8 @@ func AcquireResponse() *Response {
return resp
}
// ReleaseResponse returns the object acquired via AcquireResponse to the pool.
//
// Do not access the released Response object, otherwise data races may occur.
// ReleaseResponse returns the Response object to the pool.
// Do not use the released Response afterward to avoid data races.
func ReleaseResponse(resp *Response) {
resp.Reset()
responsePool.Put(resp)

72
docs/client/hooks.md
View File

@ -2,19 +2,35 @@
id: hooks
title: 🎣 Hooks
description: >-
Hooks are used to manipulate request/response process of Fiber client.
Hooks are used to manipulate the request/response process of the Fiber client.
sidebar_position: 4
---
With hooks, you can manipulate the client on before request/after response stages or more complex logging/tracing cases.
Hooks allow you to intercept and modify the request or response flow of the Fiber client. They are particularly useful for:
There are 2 kinds of hooks:
- Changing request parameters (e.g., URL, headers) before sending the request.
- Logging request and response details.
- Integrating complex tracing or monitoring tools.
- Handling authentication, retries, or other custom logic.
There are two kinds of hooks:
## Request Hooks
They are called before the HTTP request has been sent. You can use them make changes on Request object.
**Request hooks** are functions executed before the HTTP request is sent. They follow the signature:
You need to use `RequestHook func(*Client, *Request) error` function signature while creating the hooks. You can use request hooks to change host URL, log request properties etc. Here is an example about how to create request hooks:
```go
type RequestHook func(*Client, *Request) error
```
A request hook receives both the `Client` and the `Request` objects, allowing you to modify the request before it leaves your application. For example, you could:
- Change the host URL.
- Log request details (method, URL, headers).
- Add or modify headers or query parameters.
- Intercept and apply custom authentication logic.
**Example:**
```go
type Repository struct {
@ -31,9 +47,9 @@ type Repository struct {
func main() {
cc := client.New()
// Add a request hook that modifies the request URL before sending.
cc.AddRequestHook(func(c *client.Client, r *client.Request) error {
r.SetURL("https://api.github.com/" + r.URL())
return nil
})
@ -48,7 +64,6 @@ func main() {
}
fmt.Printf("Status code: %d\n", resp.StatusCode())
fmt.Printf("Repository: %s\n", repo.FullName)
fmt.Printf("Description: %s\n", repo.Description)
fmt.Printf("Homepage: %s\n", repo.Homepage)
@ -73,18 +88,20 @@ Full Name: gofiber/fiber
</details>
There are also some builtin request hooks provide some functionalities for Fiber client. Here is a list of them:
### Built-in Request Hooks
- [parserRequestURL](https://github.com/gofiber/fiber/blob/main/client/hooks.go#L62): parserRequestURL customizes the URL according to the path params and query params. It's necessary for `PathParam` and `QueryParam` methods.
Fiber provides some built-in request hooks:
- [parserRequestHeader](https://github.com/gofiber/fiber/blob/main/client/hooks.go#L113): parserRequestHeader sets request headers, cookies, body type, referer, user agent according to client and request properties. It's necessary to make request header and cookiejar methods functional.
- [parserRequestBody](https://github.com/gofiber/fiber/blob/main/client/hooks.go#L178): parserRequestBody serializes the body automatically. It is useful for XML, JSON, form, file bodies.
- **parserRequestURL**: Normalizes and customizes the URL based on path and query parameters. Required for `PathParam` and `QueryParam` methods.
- **parserRequestHeader**: Sets request headers, cookies, content type, referer, and user agent based on client and request properties.
- **parserRequestBody**: Automatically serializes the request body (JSON, XML, form, file uploads, etc.).
:::info
If any error returns from request hook execution, it will interrupt the request and return the error.
If any request hook returns an error, the request is interrupted and the error is returned immediately.
:::
**Example with Multiple Hooks:**
```go
func main() {
cc := client.New()
@ -123,9 +140,15 @@ exit status 2
## Response Hooks
They are called after the HTTP response has been completed. You can use them to get some information about response and request.
**Response hooks** are functions executed after the HTTP response is received. They follow the signature:
You need to use `ResponseHook func(*Client, *Response, *Request) error` function signature while creating the hooks. You can use response hook for logging, tracing etc. Here is an example about how to create response hooks:
```go
type ResponseHook func(*Client, *Response, *Request) error
```
A response hook receives the `Client`, `Response`, and `Request` objects, allowing you to inspect and modify the response or perform additional actions such as logging, tracing, or processing response data.
**Example:**
```go
func main() {
@ -173,16 +196,19 @@ X-Cache: HIT
</details>
There are also some builtin request hooks provide some functionalities for Fiber client. Here is a list of them:
### Built-in Response Hooks
- [parserResponseCookie](https://github.com/gofiber/fiber/blob/main/client/hooks.go#L293): parserResponseCookie parses cookies and saves into the response objects and cookiejar if it's exists.
Fiber provides built-in response hooks:
- [logger](https://github.com/gofiber/fiber/blob/main/client/hooks.go#L319): logger prints some RawRequest and RawResponse information. It uses [log.CommonLogger](https://github.com/gofiber/fiber/blob/main/log/log.go#L49) interface for logging.
- **parserResponseCookie**: Parses cookies from the response and stores them in the response object and cookie jar if available.
- **logger**: Logs information about the raw request and response. It uses the `log.CommonLogger` interface.
:::info
If any error is returned from executing the response hook, it will return the error without executing other response hooks.
If a response hook returns an error, it stops executing any further hooks and returns the error.
:::
**Example with Multiple Response Hooks:**
```go
func main() {
cc := client.New()
@ -225,9 +251,11 @@ exit status 2
</details>
:::info
Hooks work as FIFO (first-in-first-out). You need to check the order while adding the hooks.
:::
## Hook Execution Order
Hooks run in FIFO order (First-In-First-Out). That means hooks are executed in the order they were added. Keep this in mind when adding multiple hooks, as the order can affect the outcome.
**Example:**
```go
func main() {

302
docs/client/request.md
View File

File diff suppressed because it is too large Load Diff

77
docs/client/response.md
View File

@ -6,30 +6,27 @@ description: >-
sidebar_position: 3
---
The `Response` structure in Gofiber's HTTP client represents the server's response to an HTTP request. It contains all the necessary information received from the server. This includes:
The `Response` structure in Gofiber's HTTP client represents the server's response to an HTTP request. It includes:
- **Status Code**: The HTTP status code returned by the server (e.g., 200 OK, 404 Not Found).
- **Headers**: HTTP headers received from the server that provide additional information about the response.
- **Body**: The data received from the server, typically in the form of a JSON, XML, or plain text format.
- **Cookies**: Any cookies sent by the server along with the response.
- **Status Code**: The HTTP status code returned by the server (e.g., `200 OK`, `404 Not Found`).
- **Headers**: All HTTP headers returned by the server, providing additional response-related information.
- **Body**: The response body content, which can be JSON, XML, plain text, or other formats.
- **Cookies**: Any cookies the server sent along with the response.
This structure allows users to easily access and manage the data returned by the server, facilitating efficient handling of HTTP responses.
This structure makes it easy to inspect and handle the data sent back by the server.
```go
type Response struct {
client *Client
request *Request
cookie []*fasthttp.Cookie
client *Client
request *Request
cookie []*fasthttp.Cookie
RawResponse *fasthttp.Response
}
```
## AcquireResponse
AcquireResponse returns an empty response object from the pool.
The returned response may be returned to the pool with ReleaseResponse when no longer needed.
This allows reducing GC load.
**AcquireResponse** returns a new (pooled) `Response` object. When finished, release it using `ReleaseResponse` to reduce GC overhead.
```go title="Signature"
func AcquireResponse() *Response
@ -37,8 +34,7 @@ func AcquireResponse() *Response
## ReleaseResponse
ReleaseResponse returns the object acquired via AcquireResponse to the pool.
Do not access the released Response object; otherwise, data races may occur.
**ReleaseResponse** returns the `Response` object to the pool. Avoid using the response after releasing it to prevent data races.
```go title="Signature"
func ReleaseResponse(resp *Response)
@ -46,7 +42,7 @@ func ReleaseResponse(resp *Response)
## Status
Status method returns the HTTP status string for the executed request.
**Status** returns the HTTP status message (e.g., `OK`, `Not Found`) associated with the response.
```go title="Signature"
func (r *Response) Status() string
@ -54,7 +50,7 @@ func (r *Response) Status() string
## StatusCode
StatusCode method returns the HTTP status code for the executed request.
**StatusCode** returns the numeric HTTP status code of the response.
```go title="Signature"
func (r *Response) StatusCode() int
@ -62,7 +58,7 @@ func (r *Response) StatusCode() int
## Protocol
Protocol method returns the HTTP response protocol used for the request.
**Protocol** returns the HTTP protocol used (e.g., `HTTP/1.1`, `HTTP/2`) for the response.
```go title="Signature"
func (r *Response) Protocol() string
@ -80,6 +76,8 @@ if err != nil {
fmt.Println(resp.Protocol())
```
**Output:**
```text
HTTP/1.1
```
@ -88,7 +86,7 @@ HTTP/1.1
## Header
Header method returns the response headers.
**Header** retrieves the value of a specific response header by key. If multiple values exist for the same header, this returns the first one.
```go title="Signature"
func (r *Response) Header(key string) string
@ -96,8 +94,7 @@ func (r *Response) Header(key string) string
## Headers
Headers returns all headers in the response using an iterator. You can use `maps.Collect()` to collect all headers into a map.
The returned value is valid until the response object is released. Any future calls to Headers method will return the modified value. Do not store references to returned value. Make copies instead.
**Headers** returns an iterator over all response headers. Use `maps.Collect()` to convert them into a map if desired. The returned values are only valid until the response is released, so make copies if needed.
```go title="Signature"
func (r *Response) Headers() iter.Seq2[string, []string]
@ -117,6 +114,8 @@ for key, values := range resp.Headers() {
}
```
**Output:**
```text
Date => Wed, 04 Dec 2024 15:28:29 GMT
Connection => keep-alive
@ -135,12 +134,14 @@ if err != nil {
panic(err)
}
headers := maps.Collect(resp.Headers()) // Collect all headers into a map
headers := maps.Collect(resp.Headers())
for key, values := range headers {
fmt.Printf("%s => %s\n", key, strings.Join(values, ", "))
}
```
**Output:**
```text
Date => Wed, 04 Dec 2024 15:28:29 GMT
Connection => keep-alive
@ -152,8 +153,7 @@ Access-Control-Allow-Credentials => true
## Cookies
Cookies method to access all the response cookies.
The returned value is valid until the response object is released. Any future calls to Cookies method will return the modified value. Do not store references to returned value. Make copies instead.
**Cookies** returns a slice of all cookies set by the server in this response. The slice is only valid until the response is released.
```go title="Signature"
func (r *Response) Cookies() []*fasthttp.Cookie
@ -174,6 +174,8 @@ for _, cookie := range cookies {
}
```
**Output:**
```text
go => fiber
```
@ -182,7 +184,7 @@ go => fiber
## Body
Body method returns HTTP response as []byte array for the executed request.
**Body** returns the raw response body as a byte slice.
```go title="Signature"
func (r *Response) Body() []byte
@ -190,7 +192,7 @@ func (r *Response) Body() []byte
## String
String method returns the body of the server response as String.
**String** returns the response body as a trimmed string.
```go title="Signature"
func (r *Response) String() string
@ -198,7 +200,7 @@ func (r *Response) String() string
## JSON
JSON method will unmarshal body to json.
**JSON** unmarshals the response body into the provided variable `v` using JSON. `v` should be a pointer to a struct or a type compatible with JSON unmarshalling.
```go title="Signature"
func (r *Response) JSON(v any) error
@ -222,14 +224,15 @@ if err != nil {
panic(err)
}
err = resp.JSON(&out)
if err != nil {
if err = resp.JSON(&out); err != nil {
panic(err)
}
fmt.Printf("%+v\n", out)
```
**Output:**
```text
{Slideshow:{Author:Yours Truly Date:date of publication Title:Sample Slide Show}}
```
@ -238,7 +241,7 @@ fmt.Printf("%+v\n", out)
## XML
XML method will unmarshal body to xml.
**XML** unmarshals the response body into the provided variable `v` using XML decoding.
```go title="Signature"
func (r *Response) XML(v any) error
@ -246,7 +249,7 @@ func (r *Response) XML(v any) error
## CBOR
CBOR method will unmarshal body to CBOR.
**CBOR** unmarshals the response body into `v` using CBOR decoding.
```go title="Signature"
func (r *Response) CBOR(v any) error
@ -254,7 +257,7 @@ func (r *Response) CBOR(v any) error
## Save
Save method will save the body to a file or io.Writer.
**Save** writes the response body to a file or an `io.Writer`. If `v` is a string, it interprets it as a file path, creates the file (and directories if needed), and writes the response to it. If `v` is an `io.Writer`, it writes directly to it.
```go title="Signature"
func (r *Response) Save(v any) error
@ -262,15 +265,19 @@ func (r *Response) Save(v any) error
## Reset
Reset clears the Response object.
**Reset** clears the `Response` object, making it ready for reuse by `ReleaseResponse`.
```go title="Signature"
func (r *Response) Reset()
func (r *Response) Reset()
```
## Close
Close method will release the Request and Response objects; after calling Close, please do not use these objects.
**Close** releases both the associated `Request` and `Response` objects back to their pools.
:::warning
After calling `Close`, any attempt to use the request or response may result in data races or undefined behavior. Ensure all processing is complete before closing.
:::
```go title="Signature"
func (r *Response) Close()

347
docs/client/rest.md
View File

@ -7,18 +7,18 @@ sidebar_position: 1
toc_max_heading_level: 5
---
The Fiber Client for Fiber v3 is a powerful HTTP client optimized for high performance and ease of use in server-side applications. Built on top of the robust FastHTTP library, it inherits FastHTTP's high-speed HTTP protocol implementation. The client is designed to make HTTP requests both internally within services or externally to other web services.
The Fiber Client for Fiber v3 is a powerful HTTP client optimized for high performance and ease of use in server-side applications. Built atop the FastHTTP library, it inherits FastHTTP's high-speed HTTP protocol implementation. The client is designed for making both internal requests (within a microservices architecture) and external requests to other web services.
## Features
- **Lightweight & Fast**: Leveraging the minimalistic design of FastHTTP, the Fiber Client is lightweight and extremely fast.
- **Flexible Configuration**: Configure client-level settings such as timeouts, headers, and more, which apply to all requests. Specific requests can further override or merge these settings.
- **Connection Pooling**: Manages a pool of persistent connections that reduce the overhead of repeatedly establishing connections.
- **Timeouts & Retries**: Supports setting request timeouts and retry mechanisms to handle transient failures.
- **Lightweight & Fast**: Due to its FastHTTP foundation, the Fiber Client is both lightweight and extremely performant.
- **Flexible Configuration**: Set client-level configurations (e.g., timeouts, headers) that apply to all requests, while still allowing overrides at the individual request level.
- **Connection Pooling**: Maintains a pool of persistent connections, minimizing the overhead of establishing new connections for each request.
- **Timeouts & Retries**: Supports request-level timeouts and configurable retries to handle transient errors gracefully.
## Usage
To use the Fiber Client, instantiate it with the desired configuration. Here's a simple example:
Instantiate the Fiber Client with your desired configurations, then send requests:
```go
package main
@ -34,7 +34,7 @@ func main() {
cc := client.New()
cc.SetTimeout(10 * time.Second)
// Get request
// Send a GET request
resp, err := cc.Get("https://httpbin.org/get")
if err != nil {
panic(err)
@ -45,7 +45,7 @@ func main() {
}
```
You can check out [examples](examples.md) for more examples!
Check out [examples](examples.md) for more detailed usage examples.
```go
type Client struct {
@ -65,16 +65,16 @@ type Client struct {
timeout time.Duration
// user defined request hooks
// user-defined request hooks
userRequestHooks []RequestHook
// client package defined request hooks
// client package-defined request hooks
builtinRequestHooks []RequestHook
// user defined response hooks
// user-defined response hooks
userResponseHooks []ResponseHook
// client package defined response hooks
// client package-defined response hooks
builtinResponseHooks []ResponseHook
jsonMarshal utils.JSONMarshal
@ -99,7 +99,7 @@ type Client struct {
### New
New creates and returns a new Client object.
**New** creates and returns a new Client object.
```go title="Signature"
func New() *Client
@ -107,7 +107,7 @@ func New() *Client
### NewWithClient
NewWithClient creates and returns a new Client object from an existing client object.
**NewWithClient** creates and returns a new Client object from an existing `fasthttp.Client`.
```go title="Signature"
func NewWithClient(c *fasthttp.Client) *Client
@ -115,9 +115,11 @@ func NewWithClient(c *fasthttp.Client) *Client
## REST Methods
The following methods send HTTP requests using the configured client:
### Get
Get provides an API like axios which sends a get request.
Sends a GET request, similar to axios.
```go title="Signature"
func (c *Client) Get(url string, cfg ...Config) (*Response, error)
@ -125,7 +127,7 @@ func (c *Client) Get(url string, cfg ...Config) (*Response, error)
### Post
Post provides an API like axios which send post request.
Sends a POST request, similar to axios.
```go title="Signature"
func (c *Client) Post(url string, cfg ...Config) (*Response, error)
@ -133,7 +135,7 @@ func (c *Client) Post(url string, cfg ...Config) (*Response, error)
### Put
Put provides an API like axios which send put request.
Sends a PUT request, similar to axios.
```go title="Signature"
func (c *Client) Put(url string, cfg ...Config) (*Response, error)
@ -141,7 +143,7 @@ func (c *Client) Put(url string, cfg ...Config) (*Response, error)
### Patch
Patch provides an API like axios which send patch request.
Sends a PATCH request, similar to axios.
```go title="Signature"
func (c *Client) Patch(url string, cfg ...Config) (*Response, error)
@ -149,7 +151,7 @@ func (c *Client) Patch(url string, cfg ...Config) (*Response, error)
### Delete
Delete provides an API like axios which send delete request.
Sends a DELETE request, similar to axios.
```go title="Signature"
func (c *Client) Delete(url string, cfg ...Config) (*Response, error)
@ -157,7 +159,7 @@ func (c *Client) Delete(url string, cfg ...Config) (*Response, error)
### Head
Head provides an API like axios which send head request.
Sends a HEAD request, similar to axios.
```go title="Signature"
func (c *Client) Head(url string, cfg ...Config) (*Response, error)
@ -165,7 +167,7 @@ func (c *Client) Head(url string, cfg ...Config) (*Response, error)
### Options
Options provides an API like axios which send options request.
Sends an OPTIONS request, similar to axios.
```go title="Signature"
func (c *Client) Options(url string, cfg ...Config) (*Response, error)
@ -173,7 +175,7 @@ func (c *Client) Options(url string, cfg ...Config) (*Response, error)
### Custom
Custom provides an API like axios which send custom request.
Sends a custom HTTP request, similar to axios, allowing you to specify any method.
```go title="Signature"
func (c *Client) Custom(url, method string, cfg ...Config) (*Response, error)
@ -181,9 +183,11 @@ func (c *Client) Custom(url, method string, cfg ...Config) (*Response, error)
## Request Configuration
Config for easy to set the request parameters, it should be noted that when setting the request body will use JSON as the default serialization mechanism, while the priority of Body is higher than FormData, and the priority of FormData is higher than File.
The `Config` type helps configure request parameters. When setting the request body, JSON is used as the default serialization. The priority of the body sources is:
It can be used to configure request data while sending requests using Get, Post, etc.
1. Body
2. FormData
3. File
```go
type Config struct {
@ -205,221 +209,223 @@ type Config struct {
}
```
### R
## R
R raise a request from the client.
It acquires a request from the pool. You have to release it using `ReleaseRequest()` when it's no longer needed.
**R** creates a new `Request` object from the client's request pool. Use `ReleaseRequest()` to return it to the pool when done.
```go title="Signature"
func (c *Client) R() *Request
```
### Hooks
## Hooks
#### RequestHook
Hooks allow you to add custom logic before a request is sent or after a response is received.
RequestHook Request returns user-defined request hooks.
### RequestHook
**RequestHook** returns user-defined request hooks.
```go title="Signature"
func (c *Client) RequestHook() []RequestHook
```
#### ResponseHook
### ResponseHook
ResponseHook return user-define response hooks.
**ResponseHook** returns user-defined response hooks.
```go title="Signature"
func (c *Client) ResponseHook() []ResponseHook
```
#### AddRequestHook
### AddRequestHook
AddRequestHook Add user-defined request hooks.
Adds one or more user-defined request hooks.
```go title="Signature"
func (c *Client) AddRequestHook(h ...RequestHook) *Client
```
#### AddResponseHook
### AddResponseHook
AddResponseHook Add user-defined response hooks.
Adds one or more user-defined response hooks.
```go title="Signature"
func (c *Client) AddResponseHook(h ...ResponseHook) *Client
```
### JSON
## JSON
#### JSONMarshal
### JSONMarshal
JSONMarshal returns json marshal function in Core.
Returns the JSON marshaler function used by the client.
```go title="Signature"
func (c *Client) JSONMarshal() utils.JSONMarshal
```
#### JSONUnmarshal
### JSONUnmarshal
JSONUnmarshal returns json unmarshal function in Core.
Returns the JSON unmarshaller function used by the client.
```go title="Signature"
func (c *Client) JSONUnmarshal() utils.JSONUnmarshal
```
#### SetJSONMarshal
### SetJSONMarshal
SetJSONMarshal sets the JSON encoder.
Sets a custom JSON marshaler.
```go title="Signature"
func (c *Client) SetJSONMarshal(f utils.JSONMarshal) *Client
```
#### SetJSONUnmarshal
### SetJSONUnmarshal
Set the JSON decoder.
Sets a custom JSON unmarshaller.
```go title="Signature"
func (c *Client) SetJSONUnmarshal(f utils.JSONUnmarshal) *Client
```
### XML
## XML
#### XMLMarshal
### XMLMarshal
XMLMarshal returns xml marshal function in Core.
Returns the XML marshaler function used by the client.
```go title="Signature"
func (c *Client) XMLMarshal() utils.XMLMarshal
```
#### XMLUnmarshal
### XMLUnmarshal
XMLUnmarshal returns xml unmarshal function in Core.
Returns the XML unmarshaller function used by the client.
```go title="Signature"
func (c *Client) XMLUnmarshal() utils.XMLUnmarshal
```
#### SetXMLMarshal
### SetXMLMarshal
SetXMLMarshal sets the XML encoder.
Sets a custom XML marshaler.
```go title="Signature"
func (c *Client) SetXMLMarshal(f utils.XMLMarshal) *Client
```
#### SetXMLUnmarshal
### SetXMLUnmarshal
SetXMLUnmarshal sets the XML decoder.
Sets a custom XML unmarshaller.
```go title="Signature"
func (c *Client) SetXMLUnmarshal(f utils.XMLUnmarshal) *Client
```
### CBOR
## CBOR
#### CBORMarshal
### CBORMarshal
CBORMarshal returns CBOR marshal function in Core.
Returns the CBOR marshaler function used by the client.
```go title="Signature"
func (c *Client) CBORMarshal() utils.CBORMarshal
```
#### CBORUnmarshal
### CBORUnmarshal
CBORUnmarshal returns CBOR unmarshal function in Core.
Returns the CBOR unmarshaller function used by the client.
```go title="Signature"
func (c *Client) CBORUnmarshal() utils.CBORUnmarshal
```
#### SetCBORMarshal
### SetCBORMarshal
SetCBORMarshal sets CBOR encoder.
Sets a custom CBOR marshaler.
```go title="Signature"
func (c *Client) SetCBORMarshal(f utils.CBORMarshal) *Client
```
#### SetCBORUnmarshal
### SetCBORUnmarshal
SetCBORUnmarshal sets CBOR decoder.
Sets a custom CBOR unmarshaller.
```go title="Signature"
func (c *Client) SetCBORUnmarshal(f utils.CBORUnmarshal) *Client
```
### TLS
## TLS
#### TLSConfig
### TLSConfig
TLSConfig returns tlsConfig in client.
If the client doesn't have a tlsConfig, this function will initialize it.
Returns the client's TLS configuration. If none is set, it initializes a new one.
```go title="Signature"
func (c *Client) TLSConfig() *tls.Config
```
#### SetTLSConfig
### SetTLSConfig
SetTLSConfig sets tlsConfig in client.
Sets the TLS configuration for the client.
```go title="Signature"
func (c *Client) SetTLSConfig(config *tls.Config) *Client
```
#### SetCertificates
### SetCertificates
SetCertificates method sets client certificates into client.
Adds client certificates to the TLS configuration.
```go title="Signature"
func (c *Client) SetCertificates(certs ...tls.Certificate) *Client
```
#### SetRootCertificate
### SetRootCertificate
SetRootCertificate adds one or more root certificates into client.
Adds one or more root certificates to the client's trust store.
```go title="Signature"
func (c *Client) SetRootCertificate(path string) *Client
```
#### SetRootCertificateFromString
### SetRootCertificateFromString
SetRootCertificateFromString method adds one or more root certificates into the client.
Adds one or more root certificates from a string.
```go title="Signature"
func (c *Client) SetRootCertificateFromString(pem string) *Client
```
### SetProxyURL
## SetProxyURL
SetProxyURL sets proxy url in client. It will apply via core to hostclient.
Sets a proxy URL for the client. All subsequent requests will use this proxy.
```go title="Signature"
func (c *Client) SetProxyURL(proxyURL string) error
```
### RetryConfig
## RetryConfig
RetryConfig returns retry config in client.
Returns the retry configuration of the client.
```go title="Signature"
func (c *Client) RetryConfig() *RetryConfig
```
### SetRetryConfig
## SetRetryConfig
SetRetryConfig sets retry config in client, which is impl by addon/retry package.
Sets the retry configuration for the client.
```go title="Signature"
func (c *Client) SetRetryConfig(config *RetryConfig) *Client
```
## BaseURL
### BaseURL
BaseURL returns baseurl in Client instance.
**BaseURL** returns the base URL currently set in the client.
```go title="Signature"
func (c *Client) BaseURL() string
@ -427,12 +433,14 @@ func (c *Client) BaseURL() string
### SetBaseURL
SetBaseURL Set baseUrl which is prefix of real url.
Sets a base URL prefix for all requests made by the client.
```go title="Signature"
func (c *Client) SetBaseURL(url string) *Client
```
**Example:**
```go title="Example"
cc := client.New()
cc.SetBaseURL("https://httpbin.org/")
@ -450,132 +458,118 @@ fmt.Println(string(resp.Body()))
```json
{
"args": {},
"args": {},
...
}
```
</details>
## Headers
### Header
Header method returns header value via key, this method will visit all field in the header
Retrieves all values of a header key at the client level. The returned values apply to all requests.
```go title="Signature"
func (c *Client) Header(key string) []string
```
#### AddHeader
### AddHeader
AddHeader method adds a single header field and its value in the client instance.
These headers will be applied to all requests raised from this client instance.
Also, it can be overridden at request level header options.
Adds a single header to all requests initiated by this client.
```go title="Signature"
func (c *Client) AddHeader(key, val string) *Client
```
#### SetHeader
### SetHeader
SetHeader method sets a single header field and its value in the client instance.
These headers will be applied to all requests raised from this client instance.
Also, it can be overridden at request level header options.
Sets a single header, overriding any existing headers with the same key.
```go title="Signature"
func (c *Client) SetHeader(key, val string) *Client
```
#### AddHeaders
### AddHeaders
AddHeaders method adds multiple headers field and its values at one go in the client instance.
These headers will be applied to all requests raised from this client instance.
Also it can be overridden at request level headers options.
Adds multiple headers at once, all applying to all future requests from this client.
```go title="Signature"
func (c *Client) AddHeaders(h map[string][]string) *Client
```
#### SetHeaders
### SetHeaders
SetHeaders method sets multiple headers field and its values at one go in the client instance.
These headers will be applied to all requests raised from this client instance.
Also it can be overridden at request level headers options.
Sets multiple headers at once, overriding previously set headers.
```go title="Signature"
func (c *Client) SetHeaders(h map[string]string) *Client
```
## Query Parameters
### Param
Param method returns params value via key, this method will visit all field in the query param.
Returns the values for a given query parameter key.
```go title="Signature"
func (c *Client) Param(key string) []string
```
#### AddParam
### AddParam
AddParam method adds a single query param field and its value in the client instance.
These params will be applied to all requests raised from this client instance.
Also, it can be overridden at request level param options.
Adds a single query parameter for all requests.
```go title="Signature"
func (c *Client) AddParam(key, val string) *Client
```
#### SetParam
### SetParam
SetParam method sets a single query param field and its value in the client instance.
These params will be applied to all requests raised from this client instance.
Also, it can be overridden at request level param options.
Sets a single query parameter, overriding previously set values.
```go title="Signature"
func (c *Client) SetParam(key, val string) *Client
```
#### AddParams
### AddParams
AddParams method adds multiple query params field and its values at one go in the client instance.
These params will be applied to all requests raised from this client instance.
Also it can be overridden at request level params options.
Adds multiple query parameters from a map of string slices.
```go title="Signature"
func (c *Client) AddParams(m map[string][]string) *Client
```
#### SetParams
### SetParams
SetParams method sets multiple params field and its values at one go in the client instance.
These params will be applied to all requests raised from this client instance.
Also it can be overridden at request level params options.
Sets multiple query parameters from a map, overriding previously set values.
```go title="Signature"
func (c *Client) SetParams(m map[string]string) *Client
```
#### SetParamsWithStruct
### SetParamsWithStruct
SetParamsWithStruct method sets multiple params field and its values at one go in the client instance.
These params will be applied to all requests raised from this client instance.
Also it can be overridden at request level params options.
Sets multiple query parameters from a struct. Nested structs are not currently supported.
```go title="Signature"
func (c *Client) SetParamsWithStruct(v any) *Client
```
#### DelParams
### DelParams
DelParams method deletes single or multiple params field and its values in client.
Deletes one or more query parameters.
```go title="Signature"
func (c *Client) DelParams(key ...string) *Client
```
## UserAgent & Referer
### SetUserAgent
SetUserAgent method sets the userAgent field and its value in the client instance.
This ua will be applied to all requests raised from this client instance.
Also it can be overridden at request level ua options.
Sets the user agent header for all requests.
```go title="Signature"
func (c *Client) SetUserAgent(ua string) *Client
@ -583,80 +577,74 @@ func (c *Client) SetUserAgent(ua string) *Client
### SetReferer
SetReferer method sets referer field and its value in the client instance.
This referer will be applied to all requests raised from this client instance.
Also it can be overridden at request level referer options.
Sets the referer header for all requests.
```go title="Signature"
func (c *Client) SetReferer(r string) *Client
```
## Path Parameters
### PathParam
PathParam returns the path param be set in request instance.
If the path param doesn't exist, return empty string.
Returns the value of a named path parameter, if set.
```go title="Signature"
func (c *Client) PathParam(key string) string
```
#### SetPathParam
### SetPathParam
SetPathParam method sets a single path param field and its value in the client instance.
These path params will be applied to all requests raised from this client instance.
Also it can be overridden at request level path params options.
Sets a single path parameter.
```go title="Signature"
func (c *Client) SetPathParam(key, val string) *Client
```
#### SetPathParams
### SetPathParams
SetPathParams method sets multiple path params field and its values at one go in the client instance.
These path params will be applied to all requests raised from this client instance.
Also it can be overridden at request level path params options.
Sets multiple path parameters at once.
```go title="Signature"
func (c *Client) SetPathParams(m map[string]string) *Client
```
#### SetPathParamsWithStruct
### SetPathParamsWithStruct
SetPathParamsWithStruct method sets multiple path params field and its values at one go in the client instance.
These path params will be applied to all requests raised from this client instance.
Also it can be overridden at request level path params options.
Sets multiple path parameters from a struct.
```go title="Signature"
func (c *Client) SetPathParamsWithStruct(v any) *Client
```
#### DelPathParams
### DelPathParams
DelPathParams method deletes single or multiple path params field and its values in client.
Deletes one or more path parameters.
```go title="Signature"
func (c *Client) DelPathParams(key ...string) *Client
```
## Cookies
### Cookie
Cookie returns the cookie be set in request instance.
If cookie doesn't exist, return empty string.
Returns the value of a named cookie if set at the client level.
```go title="Signature"
func (c *Client) Cookie(key string) string
```
#### SetCookie
### SetCookie
SetCookie method sets a single cookie field and its value in the client instance.
These cookies will be applied to all requests raised from this client instance.
Also it can be overridden at request level cookie options.
Sets a single cookie for all requests.
```go title="Signature"
func (c *Client) SetCookie(key, val string) *Client
```
**Example:**
```go title="Example"
cc := client.New()
cc.SetCookie("john", "doe")
@ -682,71 +670,73 @@ fmt.Println(string(resp.Body()))
</details>
#### SetCookies
### SetCookies
SetCookies method sets multiple cookies field and its values at one go in the client instance.
These cookies will be applied to all requests raised from this client instance.
Also it can be overridden at request level cookie options.
Sets multiple cookies at once.
```go title="Signature"
func (c *Client) SetCookies(m map[string]string) *Client
```
#### SetCookiesWithStruct
### SetCookiesWithStruct
SetCookiesWithStruct method sets multiple cookies field and its values at one go in the client instance.
These cookies will be applied to all requests raised from this client instance.
Also it can be overridden at request level cookies options.
Sets multiple cookies from a struct.
```go title="Signature"
func (c *Client) SetCookiesWithStruct(v any) *Client
```
#### DelCookies
### DelCookies
DelCookies method deletes single or multiple cookies field and its values in client.
Deletes one or more cookies.
```go title="Signature"
func (c *Client) DelCookies(key ...string) *Client
```
## Timeout
### SetTimeout
SetTimeout method sets timeout val in client instance.
This value will be applied to all requests raised from this client instance.
Also, it can be overridden at request level timeout options.
Sets a default timeout for all requests, which can be overridden per request.
```go title="Signature"
func (c *Client) SetTimeout(t time.Duration) *Client
```
## Debugging
### Debug
Debug enable log debug level output.
Enables debug-level logging output.
```go title="Signature"
func (c *Client) Debug() *Client
```
#### DisableDebug
### DisableDebug
DisableDebug disables log debug level output.
Disables debug-level logging output.
```go title="Signature"
func (c *Client) DisableDebug() *Client
```
## Cookie Jar
### SetCookieJar
SetCookieJar sets cookie jar in client instance.
Assigns a cookie jar to the client to store and manage cookies across requests.
```go title="Signature"
func (c *Client) SetCookieJar(cookieJar *CookieJar) *Client
```
## Dial & Logger
### SetDial
SetDial sets dial function in client.
Sets a custom dial function.
```go title="Signature"
func (c *Client) SetDial(dial fasthttp.DialFunc) *Client
@ -754,7 +744,7 @@ func (c *Client) SetDial(dial fasthttp.DialFunc) *Client
### SetLogger
SetLogger sets logger instance in client.
Sets the logger instance used by the client.
```go title="Signature"
func (c *Client) SetLogger(logger log.CommonLogger) *Client
@ -762,15 +752,17 @@ func (c *Client) SetLogger(logger log.CommonLogger) *Client
### Logger
Logger returns logger instance of client.
Returns the current logger instance.
```go title="Signature"
func (c *Client) Logger() log.CommonLogger
```
## Reset
### Reset
Reset clears the Client object
Clears and resets the client to its default state.
```go title="Signature"
func (c *Client) Reset()
@ -778,12 +770,11 @@ func (c *Client) Reset()
## Default Client
Default client is default client object of Gofiber and created using `New()`.
You can configurate it as you wish or replace it with another clients.
Fiber provides a default client (created with `New()`). You can configure it or replace it as needed.
### C
C gets default client.
**C** returns the default client.
```go title="Signature"
func C() *Client
@ -847,10 +838,10 @@ func Options(url string, cfg ...Config) (*Response, error)
### Replace
Replace the defaultClient, the returned function can undo.
**Replace** replaces the default client with a new one. It returns a function that can restore the old client.
:::caution
The default client should not be changed concurrently.
Do not modify the default client concurrently.
:::
```go title="Signature"