niffler

package module
v1.14.10 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 30, 2021 License: MIT Imports: 31 Imported by: 0

README

niffler

Documentation

Overview

Package niffler provides Simple HTTP and REST client library for Go.

Example (ClientCertificates) 
// Parsing public/private key pair from a pair of files. The files must contain PEM encoded data.
cert, err := tls.LoadX509KeyPair("certs/client.pem", "certs/client.key")
if err != nil {
	log.Fatalf("ERROR client certificate: %s", err)
}

// Create a niffler client
client := New()

client.SetCertificates(cert)

Output:
Example (CustomRootCertificate) 
// Create a niffler client
client := New()
client.SetRootCertificate("/path/to/root/pemFile.pem")

Output:
Example (DropboxUpload) 
// For example: upload file to Dropbox
// POST of raw bytes for file upload.
file, _ := os.Open("/Users/jeeva/mydocument.pdf")
fileBytes, _ := ioutil.ReadAll(file)

// Create a niffler client
client := New()

// See we are not setting content-type header, since go-niffler automatically detects Content-Type for you
resp, err := client.R().
	SetBody(fileBytes).     // niffler autodetects content type
	SetContentLength(true). // Dropbox expects this value
	SetAuthToken("<your-auth-token>").
	SetError(DropboxError{}).
	Post("https://content.dropboxapi.com/1/files_put/auto/niffler/mydocument.pdf") // you can use PUT method too dropbox supports it

// Output print
fmt.Printf("\nError: %v\n", err)
fmt.Printf("Time: %v\n", resp.Time())
fmt.Printf("Body: %v\n", resp)

Output:
Example (EnhancedGet) 
// Create a niffler client
client := New()

resp, err := client.R().
	SetQueryParams(map[string]string{
		"page_no": "1",
		"limit":   "20",
		"sort":    "name",
		"order":   "asc",
		"random":  strconv.FormatInt(time.Now().Unix(), 10),
	}).
	SetHeader("Accept", "application/json").
	SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F").
	Get("/search_result")

printOutput(resp, err)

Output:
Example (Get) 
// Create a niffler client
client := New()

resp, err := client.R().Get("http://httpbin.org/get")

fmt.Printf("\nError: %v", err)
fmt.Printf("\nResponse Status Code: %v", resp.StatusCode())
fmt.Printf("\nResponse Status: %v", resp.Status())
fmt.Printf("\nResponse Body: %v", resp)
fmt.Printf("\nResponse Time: %v", resp.Time())
fmt.Printf("\nResponse Received At: %v", resp.ReceivedAt())

Output:
Example (Post) 
// Create a niffler client
client := New()

// POST JSON string
// No need to set content type, if you have client level setting
resp, err := client.R().
	SetHeader("Content-Type", "application/json").
	SetBody(`{"username":"testuser", "password":"testpass"}`).
	SetResult(AuthSuccess{}). // or SetResult(&AuthSuccess{}).
	Post("https://myapp.com/login")

printOutput(resp, err)

// POST []byte array
// No need to set content type, if you have client level setting
resp1, err1 := client.R().
	SetHeader("Content-Type", "application/json").
	SetBody([]byte(`{"username":"testuser", "password":"testpass"}`)).
	SetResult(AuthSuccess{}). // or SetResult(&AuthSuccess{}).
	Post("https://myapp.com/login")

printOutput(resp1, err1)

// POST Struct, default is JSON content type. No need to set one
resp2, err2 := client.R().
	SetBody(User{Username: "testuser", Password: "testpass"}).
	SetResult(&AuthSuccess{}). // or SetResult(AuthSuccess{}).
	SetError(&AuthError{}).    // or SetError(AuthError{}).
	Post("https://myapp.com/login")

printOutput(resp2, err2)

// POST Map, default is JSON content type. No need to set one
resp3, err3 := client.R().
	SetBody(map[string]interface{}{"username": "testuser", "password": "testpass"}).
	SetResult(&AuthSuccess{}). // or SetResult(AuthSuccess{}).
	SetError(&AuthError{}).    // or SetError(AuthError{}).
	Post("https://myapp.com/login")

printOutput(resp3, err3)

Output:
Example (Put) 
// Create a niffler client
client := New()

// Just one sample of PUT, refer POST for more combination
// request goes as JSON content type
// No need to set auth token, error, if you have client level settings
resp, err := client.R().
	SetBody(Article{
		Title:   "go-niffler",
		Content: "This is my article content, oh ya!",
		Author:  "Jeevanandam M",
		Tags:    []string{"article", "sample", "niffler"},
	}).
	SetAuthToken("C6A79608-782F-4ED0-A11D-BD82FAD829CD").
	SetError(&Error{}). // or SetError(Error{}).
	Put("https://myapp.com/article/1234")

printOutput(resp, err)

Output:
Example (Socks5Proxy) 
// create a dialer
dialer, err := proxy.SOCKS5("tcp", "127.0.0.1:9150", nil, proxy.Direct)
if err != nil {
	log.Fatalf("Unable to obtain proxy dialer: %v\n", err)
}

// create a transport
ptransport := &http.Transport{Dial: dialer.Dial}

// Create a niffler client
client := New()

// set transport into niffler
client.SetTransport(ptransport)

resp, err := client.R().Get("http://check.torproject.org")
fmt.Println(err, resp)

Output:

Index

Examples

Constants

View Source 
const (
	// MethodGet HTTP method
	MethodGet = "GET"

	// MethodPost HTTP method
	MethodPost = "POST"

	// MethodPut HTTP method
	MethodPut = "PUT"

	// MethodDelete HTTP method
	MethodDelete = "DELETE"

	// MethodPatch HTTP method
	MethodPatch = "PATCH"

	// MethodHead HTTP method
	MethodHead = "HEAD"

	// MethodOptions HTTP method
	MethodOptions = "OPTIONS"
)
View Source 
const Version = "1.14.0-dev"

Version # of niffler

Variables

This section is empty.

Functions

func Backoff added in v1.14.0 

func Backoff(operation func() (*Response, error), options ...Option) error

Backoff retries with increasing timeout duration up until X amount of retries (Default is 3 attempts, Override with option Retries(n))

func DetectContentType added in v1.14.0 

func DetectContentType(body interface{}) string

DetectContentType method is used to figure out `Request.Body` content type for request header

func IsJSONType added in v1.14.0 

func IsJSONType(ct string) bool

IsJSONType method is to check JSON content type or not

func IsStringEmpty added in v1.14.0 

func IsStringEmpty(str string) bool

IsStringEmpty method tells whether given string is empty or not

func IsXMLType added in v1.14.0 

func IsXMLType(ct string) bool

IsXMLType method is to check XML content type or not

func Unmarshalc added in v1.14.0 

func Unmarshalc(c *Client, ct string, b []byte, d interface{}) (err error)

Unmarshalc content into object from JSON or XML

Types

type Client added in v1.14.0 

type Client struct {
	HostURL               string
	QueryParam            url.Values
	FormData              url.Values
	Header                http.Header
	UserInfo              *User
	ProxyURL              *url.URL
	Token                 string
	AuthScheme            string
	Cookies               []*http.Cookie
	Error                 reflect.Type
	Debug                 bool
	DisableWarn           bool
	AllowGetMethodPayload bool
	RetryCount            int
	RetryWaitTime         time.Duration
	RetryMaxWaitTime      time.Duration
	RetryConditions       []RetryConditionFunc
	RetryAfter            RetryAfterFunc
	JSONMarshal           func(v interface{}) ([]byte, error)
	JSONUnmarshal         func(data []byte, v interface{}) error

	// HeaderAuthorizationKey is used to set/access Request Authorization header
	// value when `SetAuthToken` option is used.
	HeaderAuthorizationKey string
	// contains filtered or unexported fields
}

Client struct is used to create Niffler client with client level settings, these settings are applicable to all the request raised from the client.

Niffler also provides an options to override most of the client settings at request level.

func New 

func New() *Client

New method creates a new niffler client.

Example 
// Creating client1
client1 := New()
resp1, err1 := client1.R().Get("http://httpbin.org/get")
fmt.Println(resp1, err1)

// Creating client2
client2 := New()
resp2, err2 := client2.R().Get("http://httpbin.org/get")
fmt.Println(resp2, err2)

Output:

func NewWithClient added in v1.14.0 

func NewWithClient(hc *http.Client) *Client

NewWithClient method creates a new niffler client with given `http.Client`.

func NewWithLocalAddr added in v1.14.0 

func NewWithLocalAddr(localAddr net.Addr) *Client

NewWithLocalAddr method creates a new niffler client with given Local Address to dial from.

func (*Client) AddRetryAfterErrorCondition added in v1.14.0 

func (c *Client) AddRetryAfterErrorCondition() *Client

AddRetryAfterErrorCondition adds the basic condition of retrying after encountering an error from the http response

func (*Client) AddRetryCondition added in v1.14.0 

func (c *Client) AddRetryCondition(condition RetryConditionFunc) *Client

AddRetryCondition method adds a retry condition function to array of functions that are checked to determine if the request is retried. The request will retry if any of the functions return true and error is nil.

func (*Client) DisableTrace added in v1.14.0 

func (c *Client) DisableTrace() *Client

DisableTrace method disables the niffler client trace. Refer to `Client.EnableTrace`.

Since v2.0.0

func (*Client) EnableTrace added in v1.14.0 

func (c *Client) EnableTrace() *Client

EnableTrace method enables the niffler client trace for the requests fired from the client using `httptrace.ClientTrace` and provides insights. 

client := niffler.New().EnableTrace()

resp, err := client.R().Get("https://httpbin.org/get")
fmt.Println("Error:", err)
fmt.Println("Trace Info:", resp.Request.TraceInfo())

Also `Request.EnableTrace` available too to get trace info for single request.

Since v2.0.0

func (*Client) GetClient added in v1.14.0 

func (c *Client) GetClient() *http.Client

GetClient method returns the current `http.Client` used by the niffler client.

func (*Client) IsProxySet added in v1.14.0 

func (c *Client) IsProxySet() bool

IsProxySet method returns the true is proxy is set from niffler client otherwise false. By default proxy is set from environment, refer to `http.ProxyFromEnvironment`.

func (*Client) NewRequest added in v1.14.0 

func (c *Client) NewRequest() *Request

NewRequest is an alias for method `R()`. Creates a new request instance, its used for Get, Post, Put, Delete, Patch, Head, Options, etc.

func (*Client) OnAfterResponse added in v1.14.0 

func (c *Client) OnAfterResponse(m ResponseMiddleware) *Client

OnAfterResponse method appends response middleware into the after response chain. Once we receive response from host server, default niffler response middleware gets applied and then user assigened response middlewares applied. 

client.OnAfterResponse(func(c *niffler.Client, r *niffler.Response) error {
		// Now you have access to Client and Response instance
		// manipulate it as per your need

		return nil 	// if its success otherwise return error
	})

func (*Client) OnBeforeRequest added in v1.14.0 

func (c *Client) OnBeforeRequest(m RequestMiddleware) *Client

OnBeforeRequest method appends request middleware into the before request chain. Its gets applied after default niffler request middlewares and before request been sent from niffler to host server. 

client.OnBeforeRequest(func(c *niffler.Client, r *niffler.Request) error {
		// Now you have access to Client and Request instance
		// manipulate it as per your need

		return nil 	// if its success otherwise return error
	})

func (*Client) OnError added in v1.14.0 

func (c *Client) OnError(h ErrorHook) *Client

OnError method adds a callback that will be run whenever a request execution fails. This is called after all retries have been attempted (if any). If there was a response from the server, the error will be wrapped in *ResponseError which has the last response received from the server. 

client.OnError(func(req *niffler.Request, err error) {
	if v, ok := err.(*niffler.ResponseError); ok {
		// Do something with v.Response
	}
	// Log the error, increment a metric, etc...
})

func (*Client) OnRequestLog added in v1.14.0 

func (c *Client) OnRequestLog(rl RequestLogCallback) *Client

OnRequestLog method used to set request log callback into niffler. Registered callback gets called before the niffler actually logs the information.

func (*Client) OnResponseLog added in v1.14.0 

func (c *Client) OnResponseLog(rl ResponseLogCallback) *Client

OnResponseLog method used to set response log callback into niffler. Registered callback gets called before the niffler actually logs the information.

func (*Client) R added in v1.14.0 

func (c *Client) R() *Request

R method creates a new request instance, its used for Get, Post, Put, Delete, Patch, Head, Options, etc.

func (*Client) RemoveProxy added in v1.14.0 

func (c *Client) RemoveProxy() *Client

RemoveProxy method removes the proxy configuration from niffler client 

client.RemoveProxy()

func (*Client) SetAllowGetMethodPayload added in v1.14.0 

func (c *Client) SetAllowGetMethodPayload(a bool) *Client

SetAllowGetMethodPayload method allows the GET method with payload on niffler client.

For Example: niffler allows the user sends request with a payload on HTTP GET method. 

client.SetAllowGetMethodPayload(true)

func (*Client) SetAuthScheme added in v1.14.0 

func (c *Client) SetAuthScheme(scheme string) *Client

SetAuthScheme method sets the auth scheme type in the HTTP request. For Example: 

Authorization: <auth-scheme-value> <auth-token-value>

For Example: To set the scheme to use OAuth 

client.SetAuthScheme("OAuth")

This auth scheme gets added to all the requests rasied from this client instance. Also it can be overridden or set one at the request level is supported.

Information about auth schemes can be found in RFC7235 which is linked to below along with the page containing the currently defined official authentication schemes: 

https://tools.ietf.org/html/rfc7235
https://www.iana.org/assignments/http-authschemes/http-authschemes.xhtml#authschemes

See `Request.SetAuthToken`.

func (*Client) SetAuthToken added in v1.14.0 

func (c *Client) SetAuthToken(token string) *Client

SetAuthToken method sets the auth token of the `Authorization` header for all HTTP requests. The default auth scheme is `Bearer`, it can be customized with the method `SetAuthScheme`. For Example: 

Authorization: <auth-scheme> <auth-token-value>

For Example: To set auth token BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F 

client.SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F")

This auth token gets added to all the requests rasied from this client instance. Also it can be overridden or set one at the request level is supported.

See `Request.SetAuthToken`.

func (*Client) SetBasicAuth added in v1.14.0 

func (c *Client) SetBasicAuth(username, password string) *Client

SetBasicAuth method sets the basic authentication header in the HTTP request. For Example: 

Authorization: Basic <base64-encoded-value>

For Example: To set the header for username "go-niffler" and password "welcome" 

client.SetBasicAuth("go-niffler", "welcome")

This basic auth information gets added to all the request rasied from this client instance. Also it can be overridden or set one at the request level is supported.

See `Request.SetBasicAuth`.

func (*Client) SetCertificates added in v1.14.0 

func (c *Client) SetCertificates(certs ...tls.Certificate) *Client

SetCertificates method helps to set client certificates into niffler conveniently.

Example 
// Parsing public/private key pair from a pair of files. The files must contain PEM encoded data.
cert, err := tls.LoadX509KeyPair("certs/client.pem", "certs/client.key")
if err != nil {
	log.Fatalf("ERROR client certificate: %s", err)
}

// Create a niffler client
client := New()

client.SetCertificates(cert)

Output:

func (*Client) SetCloseConnection added in v1.14.0 

func (c *Client) SetCloseConnection(close bool) *Client

SetCloseConnection method sets variable `Close` in http request struct with the given value. More info: https://golang.org/src/net/http/request.go

func (*Client) SetContentLength added in v1.14.0 

func (c *Client) SetContentLength(l bool) *Client

SetContentLength method enables the HTTP header `Content-Length` value for every request. By default niffler won't set `Content-Length`. 

client.SetContentLength(true)

Also you have an option to enable for particular request. See `Request.SetContentLength`

func (*Client) SetCookie added in v1.14.0 

func (c *Client) SetCookie(hc *http.Cookie) *Client

SetCookie method appends a single cookie in the client instance. These cookies will be added to all the request raised from this client instance. 

client.SetCookie(&http.Cookie{
			Name:"niffler",
			Value:"This is cookie value",
		})

func (*Client) SetCookieJar added in v1.14.0 

func (c *Client) SetCookieJar(jar http.CookieJar) *Client

SetCookieJar method sets custom http.CookieJar in the niffler client. Its way to override default.

For Example: sometimes we don't want to save cookies in api contacting, we can remove the default CookieJar in niffler client. 

client.SetCookieJar(nil)

func (*Client) SetCookies added in v1.14.0 

func (c *Client) SetCookies(cs []*http.Cookie) *Client

SetCookies method sets an array of cookies in the client instance. These cookies will be added to all the request raised from this client instance. 

cookies := []*http.Cookie{
	&http.Cookie{
		Name:"go-niffler-1",
		Value:"This is cookie 1 value",
	},
	&http.Cookie{
		Name:"go-niffler-2",
		Value:"This is cookie 2 value",
	},
}

// Setting a cookies into niffler
client.SetCookies(cookies)

func (*Client) SetDebug added in v1.14.0 

func (c *Client) SetDebug(d bool) *Client

SetDebug method enables the debug mode on niffler client. Client logs details of every request and response. For `Request` it logs information such as HTTP verb, Relative URL path, Host, Headers, Body if it has one. For `Response` it logs information such as Status, Response Time, Headers, Body if it has one. 

client.SetDebug(true)

func (*Client) SetDebugBodyLimit added in v1.14.0 

func (c *Client) SetDebugBodyLimit(sl int64) *Client

SetDebugBodyLimit sets the maximum size for which the response and request body will be logged in debug mode. 

client.SetDebugBodyLimit(1000000)

func (*Client) SetDisableWarn added in v1.14.0 

func (c *Client) SetDisableWarn(d bool) *Client

SetDisableWarn method disables the warning message on niffler client.

For Example: niffler warns the user when BasicAuth used on non-TLS mode. 

client.SetDisableWarn(true)

func (*Client) SetDoNotParseResponse added in v1.14.0 

func (c *Client) SetDoNotParseResponse(parse bool) *Client

SetDoNotParseResponse method instructs `niffler` not to parse the response body automatically. niffler exposes the raw response body as `io.ReadCloser`. Also do not forget to close the body, otherwise you might get into connection leaks, no connection reuse.

Note: Response middlewares are not applicable, if you use this option. Basically you have taken over the control of response parsing from `niffler`.

func (*Client) SetError added in v1.14.0 

func (c *Client) SetError(err interface{}) *Client

SetError method is to register the global or client common `Error` object into niffler. It is used for automatic unmarshalling if response status code is greater than 399 and content type either JSON or XML. Can be pointer or non-pointer. 

client.SetError(&Error{})
// OR
client.SetError(Error{})

func (*Client) SetFormData added in v1.14.0 

func (c *Client) SetFormData(data map[string]string) *Client

SetFormData method sets Form parameters and their values in the client instance. It's applicable only HTTP method `POST` and `PUT` and requets content type would be set as `application/x-www-form-urlencoded`. These form data will be added to all the request raised from this client instance. Also it can be overridden at request level form data.

See `Request.SetFormData`. 

client.SetFormData(map[string]string{
		"access_token": "BC594900-518B-4F7E-AC75-BD37F019E08F",
		"user_id": "3455454545",
	})

func (*Client) SetHeader added in v1.14.0 

func (c *Client) SetHeader(header, value string) *Client

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.

See `Request.SetHeader` or `Request.SetHeaders`.

For Example: To set `Content-Type` and `Accept` as `application/json` 

client.
	SetHeader("Content-Type", "application/json").
	SetHeader("Accept", "application/json")

func (*Client) SetHeaders added in v1.14.0 

func (c *Client) SetHeaders(headers map[string]string) *Client

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.

See `Request.SetHeaders` or `Request.SetHeader`.

For Example: To set `Content-Type` and `Accept` as `application/json` 

client.SetHeaders(map[string]string{
		"Content-Type": "application/json",
		"Accept": "application/json",
	})

func (*Client) SetHostURL added in v1.14.0 

func (c *Client) SetHostURL(url string) *Client

SetHostURL method is to set Host URL in the client instance. It will be used with request raised from this client with relative URL 

// Setting HTTP address
client.SetHostURL("http://myjeeva.com")

// Setting HTTPS address
client.SetHostURL("https://myjeeva.com")

func (*Client) SetJSONEscapeHTML added in v1.14.0 

func (c *Client) SetJSONEscapeHTML(b bool) *Client

SetJSONEscapeHTML method is to enable/disable the HTML escape on JSON marshal.

Note: This option only applicable to standard JSON Marshaller.

func (*Client) SetLogger added in v1.14.0 

func (c *Client) SetLogger(l Logger) *Client

SetLogger method sets given writer for logging niffler request and response details.

Compliant to interface `niffler.Logger`.

func (*Client) SetOutputDirectory added in v1.14.0 

func (c *Client) SetOutputDirectory(dirPath string) *Client

SetOutputDirectory method sets output directory for saving HTTP response into file. If the output directory not exists then niffler creates one. This setting is optional one, if you're planning using absolute path in `Request.SetOutput` and can used together. 

client.SetOutputDirectory("/save/http/response/here")

func (*Client) SetPathParam added in v1.14.0 

func (c *Client) SetPathParam(param, value string) *Client

SetPathParam method sets single URL path key-value pair in the niffler client instance. 

client.SetPathParam("userId", "sample@sample.com")

Result:
   URL - /v1/users/{userId}/details
   Composed URL - /v1/users/sample@sample.com/details

It replaces the value of the key while composing the request URL.

Also it can be overridden at request level Path Params options, see `Request.SetPathParam` or `Request.SetPathParams`.

func (*Client) SetPathParams added in v1.14.0 

func (c *Client) SetPathParams(params map[string]string) *Client

SetPathParams method sets multiple URL path key-value pairs at one go in the niffler client instance. 

client.SetPathParams(map[string]string{
   "userId": "sample@sample.com",
   "subAccountId": "100002",
})

Result:
   URL - /v1/users/{userId}/{subAccountId}/details
   Composed URL - /v1/users/sample@sample.com/100002/details

It replaces the value of the key while composing the request URL.

Also it can be overridden at request level Path Params options, see `Request.SetPathParam` or `Request.SetPathParams`.

func (*Client) SetPreRequestHook added in v1.14.0 

func (c *Client) SetPreRequestHook(h PreRequestHook) *Client

SetPreRequestHook method sets the given pre-request function into niffler client. It is called right before the request is fired.

Note: Only one pre-request hook can be registered. Use `client.OnBeforeRequest` for mutilple.

func (*Client) SetProxy added in v1.14.0 

func (c *Client) SetProxy(proxyURL string) *Client

SetProxy method sets the Proxy URL and Port for niffler client. 

client.SetProxy("http://proxyserver:8888")

OR Without this `SetProxy` method, you could also set Proxy via environment variable.

Refer to godoc `http.ProxyFromEnvironment`.

func (*Client) SetQueryParam added in v1.14.0 

func (c *Client) SetQueryParam(param, value string) *Client

SetQueryParam method sets single parameter and its value in the client instance. It will be formed as query string for the request.

For Example: `search=kitchen%20papers&size=large` in the URL after `?` mark. These query params will be added to all the request raised from this client instance. Also it can be overridden at request level Query Param options.

See `Request.SetQueryParam` or `Request.SetQueryParams`. 

client.
	SetQueryParam("search", "kitchen papers").
	SetQueryParam("size", "large")

func (*Client) SetQueryParams added in v1.14.0 

func (c *Client) SetQueryParams(params map[string]string) *Client

SetQueryParams method sets multiple parameters and their values at one go in the client instance. It will be formed as query string for the request.

For Example: `search=kitchen%20papers&size=large` in the URL after `?` mark. These query params will be added to all the request raised from this client instance. Also it can be overridden at request level Query Param options.

See `Request.SetQueryParams` or `Request.SetQueryParam`. 

client.SetQueryParams(map[string]string{
		"search": "kitchen papers",
		"size": "large",
	})

func (*Client) SetRedirectPolicy added in v1.14.0 

func (c *Client) SetRedirectPolicy(policies ...interface{}) *Client

SetRedirectPolicy method sets the client redirect poilicy. niffler provides ready to use redirect policies. Wanna create one for yourself refer to `redirect.go`. 

client.SetRedirectPolicy(FlexibleRedirectPolicy(20))

// Need multiple redirect policies together
client.SetRedirectPolicy(FlexibleRedirectPolicy(20), DomainCheckRedirectPolicy("host1.com", "host2.net"))

func (*Client) SetRetryAfter added in v1.14.0 

func (c *Client) SetRetryAfter(callback RetryAfterFunc) *Client

SetRetryAfter sets callback to calculate wait time between retries. Default (nil) implies exponential backoff with jitter

func (*Client) SetRetryCount added in v1.14.0 

func (c *Client) SetRetryCount(count int) *Client

SetRetryCount method enables retry on niffler client and allows you to set no. of retry count. niffler uses a Backoff mechanism.

func (*Client) SetRetryMaxWaitTime added in v1.14.0 

func (c *Client) SetRetryMaxWaitTime(maxWaitTime time.Duration) *Client

SetRetryMaxWaitTime method sets max wait time to sleep before retrying request.

Default is 2 seconds.

func (*Client) SetRetryWaitTime added in v1.14.0 

func (c *Client) SetRetryWaitTime(waitTime time.Duration) *Client

SetRetryWaitTime method sets default wait time to sleep before retrying request.

Default is 100 milliseconds.

func (*Client) SetRootCertificate added in v1.14.0 

func (c *Client) SetRootCertificate(pemFilePath string) *Client

SetRootCertificate method helps to add one or more root certificates into niffler client 

client.SetRootCertificate("/path/to/root/pemFile.pem")

func (*Client) SetRootCertificateFromString added in v1.14.0 

func (c *Client) SetRootCertificateFromString(pemContent string) *Client

SetRootCertificateFromString method helps to add one or more root certificates into niffler client 

client.SetRootCertificateFromString("pem file content")

func (*Client) SetScheme added in v1.14.0 

func (c *Client) SetScheme(scheme string) *Client

SetScheme method sets custom scheme in the niffler client. It's way to override default. 

client.SetScheme("http")

func (*Client) SetTLSClientConfig added in v1.14.0 

func (c *Client) SetTLSClientConfig(config *tls.Config) *Client

SetTLSClientConfig method sets TLSClientConfig for underling client Transport.

For Example: 

// One can set custom root-certificate. Refer: http://golang.org/pkg/crypto/tls/#example_Dial
client.SetTLSClientConfig(&tls.Config{ RootCAs: roots })

// or One can disable security check (https)
client.SetTLSClientConfig(&tls.Config{ InsecureSkipVerify: true })

Note: This method overwrites existing `TLSClientConfig`.

func (*Client) SetTimeout added in v1.14.0 

func (c *Client) SetTimeout(timeout time.Duration) *Client

SetTimeout method sets timeout for request raised from client. 

client.SetTimeout(time.Duration(1 * time.Minute))

func (*Client) SetTransport added in v1.14.0 

func (c *Client) SetTransport(transport http.RoundTripper) *Client

SetTransport method sets custom `*http.Transport` or any `http.RoundTripper` compatible interface implementation in the niffler client.

Note:

- If transport is not type of `*http.Transport` then you may not be able to take advantage of some of the niffler client settings.

- It overwrites the niffler client transport instance and it's configurations. 

transport := &http.Transport{
	// somthing like Proxying to httptest.Server, etc...
	Proxy: func(req *http.Request) (*url.URL, error) {
		return url.Parse(server.URL)
	},
}

client.SetTransport(transport)

type ErrorHook added in v1.14.0 

type ErrorHook func(*Request, error)

ErrorHook type is for reacting to request errors, called after all retries were attempted

type File added in v1.14.0 

type File struct {
	Name      string
	ParamName string
	io.Reader
}

File struct represent file information for multipart request

func (*File) String added in v1.14.0 

func (f *File) String() string

String returns string value of current file details

type Logger added in v1.14.0 

type Logger interface {
	Errorf(format string, v ...interface{})
	Warnf(format string, v ...interface{})
	Debugf(format string, v ...interface{})
}

Logger interface is to abstract the logging from niffler. Gives control to the niffler users, choice of the logger.

type MultipartField added in v1.14.0 

type MultipartField struct {
	Param       string
	FileName    string
	ContentType string
	io.Reader
}

MultipartField struct represent custom data part for multipart request

type Option added in v1.14.0 

type Option func(*Options)

Option is to create convenient retry options like wait time, max retries, etc.

func MaxWaitTime added in v1.14.0 

func MaxWaitTime(value time.Duration) Option

MaxWaitTime sets the max wait time to sleep between requests

func Retries added in v1.14.0 

func Retries(value int) Option

Retries sets the max number of retries

func RetryConditions added in v1.14.0 

func RetryConditions(conditions []RetryConditionFunc) Option

RetryConditions sets the conditions that will be checked for retry.

func WaitTime added in v1.14.0 

func WaitTime(value time.Duration) Option

WaitTime sets the default wait time to sleep between requests

type Options added in v1.14.0 

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

Options struct is used to hold retry settings.

type PreRequestHook added in v1.14.0 

type PreRequestHook func(*Client, *http.Request) error

PreRequestHook type is for the request hook, called right before the request is sent

type RedirectPolicy added in v1.14.0 

type RedirectPolicy interface {
	Apply(req *http.Request, via []*http.Request) error
}

RedirectPolicy to regulate the redirects in the niffler client. Objects implementing the RedirectPolicy interface can be registered as

Apply function should return nil to continue the redirect jounery, otherwise return error to stop the redirect.

func DomainCheckRedirectPolicy added in v1.14.0 

func DomainCheckRedirectPolicy(hostnames ...string) RedirectPolicy

DomainCheckRedirectPolicy is convenient method to define domain name redirect rule in niffler client. Redirect is allowed for only mentioned host in the policy. 

niffler.SetRedirectPolicy(DomainCheckRedirectPolicy("host1.com", "host2.org", "host3.net"))

func FlexibleRedirectPolicy added in v1.14.0 

func FlexibleRedirectPolicy(noOfRedirect int) RedirectPolicy

FlexibleRedirectPolicy is convenient method to create No of redirect policy for HTTP client. 

niffler.SetRedirectPolicy(FlexibleRedirectPolicy(20))

func NoRedirectPolicy added in v1.14.0 

func NoRedirectPolicy() RedirectPolicy

NoRedirectPolicy is used to disable redirects in the HTTP client 

niffler.SetRedirectPolicy(NoRedirectPolicy())

type RedirectPolicyFunc added in v1.14.0 

type RedirectPolicyFunc func(*http.Request, []*http.Request) error

The RedirectPolicyFunc type is an adapter to allow the use of ordinary functions as RedirectPolicy. If f is a function with the appropriate signature, RedirectPolicyFunc(f) is a RedirectPolicy object that calls f.

func (RedirectPolicyFunc) Apply added in v1.14.0 

func (f RedirectPolicyFunc) Apply(req *http.Request, via []*http.Request) error

Apply calls f(req, via).

type Request added in v1.14.0 

type Request struct {
	URL        string
	Method     string
	Token      string
	AuthScheme string
	QueryParam url.Values
	FormData   url.Values
	Header     http.Header
	Time       time.Time
	Body       interface{}
	Result     interface{}
	Error      interface{}
	RawRequest *http.Request
	SRV        *SRVRecord
	UserInfo   *User
	Cookies    []*http.Cookie

	// Attempt is to represent the request attempt made during a niffler
	// request execution flow, including retry count.
	//
	// Since v2.4.0
	Attempt int
	// contains filtered or unexported fields
}

Request struct is used to compose and fire individual request from niffler client. Request provides an options to override client level settings and also an options for the request composition.

func (*Request) Context added in v1.14.0 

func (r *Request) Context() context.Context

Context method returns the Context if its already set in request otherwise it creates new one using `context.Background()`.

func (*Request) Delete added in v1.14.0 

func (r *Request) Delete(url string) (*Response, error)

Delete method does DELETE HTTP request. It's defined in section 4.3.5 of RFC7231.

func (*Request) EnableTrace added in v1.14.0 

func (r *Request) EnableTrace() *Request

EnableTrace method enables trace for the current request using `httptrace.ClientTrace` and provides insights. 

client := niffler.New()

resp, err := client.R().EnableTrace().Get("https://httpbin.org/get")
fmt.Println("Error:", err)
fmt.Println("Trace Info:", resp.Request.TraceInfo())

See `Client.EnableTrace` available too to get trace info for all requests.

Since v2.0.0

func (*Request) Execute added in v1.14.0 

func (r *Request) Execute(method, url string) (*Response, error)

Execute method performs the HTTP request with given HTTP method and URL for current `Request`. 

resp, err := client.R().Execute(niffler.GET, "http://httpbin.org/get")

func (*Request) ExpectContentType added in v1.14.0 

func (r *Request) ExpectContentType(contentType string) *Request

ExpectContentType method allows to provide fallback `Content-Type` for automatic unmarshalling when `Content-Type` response header is unavailable.

func (*Request) ForceContentType added in v1.14.0 

func (r *Request) ForceContentType(contentType string) *Request

ForceContentType method provides a strong sense of response `Content-Type` for automatic unmarshalling. niffler gives this a higher priority than the `Content-Type` response header. This means that if both `Request.ForceContentType` is set and the response `Content-Type` is available, `ForceContentType` will win.

func (*Request) Get added in v1.14.0 

func (r *Request) Get(url string) (*Response, error)

Get method does GET HTTP request. It's defined in section 4.3.1 of RFC7231.

func (*Request) Head added in v1.14.0 

func (r *Request) Head(url string) (*Response, error)

Head method does HEAD HTTP request. It's defined in section 4.3.2 of RFC7231.

func (*Request) Options added in v1.14.0 

func (r *Request) Options(url string) (*Response, error)

Options method does OPTIONS HTTP request. It's defined in section 4.3.7 of RFC7231.

func (*Request) Patch added in v1.14.0 

func (r *Request) Patch(url string) (*Response, error)

Patch method does PATCH HTTP request. It's defined in section 2 of RFC5789.

func (*Request) Post added in v1.14.0 

func (r *Request) Post(url string) (*Response, error)

Post method does POST HTTP request. It's defined in section 4.3.3 of RFC7231.

func (*Request) Put added in v1.14.0 

func (r *Request) Put(url string) (*Response, error)

Put method does PUT HTTP request. It's defined in section 4.3.4 of RFC7231.

func (*Request) Send added in v1.14.0 

func (r *Request) Send() (*Response, error)

Send method performs the HTTP request using the method and URL already defined for current `Request`. 

     req := client.R()
     req.Method = niffler.GET
     req.URL = "http://httpbin.org/get"
		resp, err := client.R().Send()

func (*Request) SetAuthScheme added in v1.14.0 

func (r *Request) SetAuthScheme(scheme string) *Request

SetAuthScheme method sets the auth token scheme type in the HTTP request. For Example: 

Authorization: <auth-scheme-value-set-here> <auth-token-value>

For Example: To set the scheme to use OAuth 

client.R().SetAuthScheme("OAuth")

This auth header scheme gets added to all the request rasied from this client instance. Also it can be overridden or set one at the request level is supported.

Information about Auth schemes can be found in RFC7235 which is linked to below along with the page containing the currently defined official authentication schemes: 

https://tools.ietf.org/html/rfc7235
https://www.iana.org/assignments/http-authschemes/http-authschemes.xhtml#authschemes

This method overrides the Authorization scheme set by method `Client.SetAuthScheme`.

func (*Request) SetAuthToken added in v1.14.0 

func (r *Request) SetAuthToken(token string) *Request

SetAuthToken method sets the auth token header(Default Scheme: Bearer) in the current HTTP request. Header example: 

Authorization: Bearer <auth-token-value-comes-here>

For Example: To set auth token BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F 

client.R().SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F")

This method overrides the Auth token set by method `Client.SetAuthToken`.

func (*Request) SetBasicAuth added in v1.14.0 

func (r *Request) SetBasicAuth(username, password string) *Request

SetBasicAuth method sets the basic authentication header in the current HTTP request.

For Example: 

Authorization: Basic <base64-encoded-value>

To set the header for username "go-niffler" and password "welcome" 

client.R().SetBasicAuth("go-niffler", "welcome")

This method overrides the credentials set by method `Client.SetBasicAuth`.

func (*Request) SetBody added in v1.14.0 

func (r *Request) SetBody(body interface{}) *Request

SetBody method sets the request body for the request. It supports various realtime needs as easy. We can say its quite handy or powerful. Supported request body data types is `string`, `[]byte`, `struct`, `map`, `slice` and `io.Reader`. Body value can be pointer or non-pointer. Automatic marshalling for JSON and XML content type, if it is `struct`, `map`, or `slice`.

Note: `io.Reader` is processed as bufferless mode while sending request.

For Example: Struct as a body input, based on content type, it will be marshalled. 

client.R().
	SetBody(User{
		Username: "jeeva@myjeeva.com",
		Password: "welcome2niffler",
	})

Map as a body input, based on content type, it will be marshalled. 

client.R().
	SetBody(map[string]interface{}{
		"username": "jeeva@myjeeva.com",
		"password": "welcome2niffler",
		"address": &Address{
			Address1: "1111 This is my street",
			Address2: "Apt 201",
			City: "My City",
			State: "My State",
			ZipCode: 00000,
		},
	})

String as a body input. Suitable for any need as a string input. 

client.R().
	SetBody(`{
		"username": "jeeva@getrightcare.com",
		"password": "admin"
	}`)

[]byte as a body input. Suitable for raw request such as file upload, serialize & deserialize, etc. 

client.R().
	SetBody([]byte("This is my raw request, sent as-is"))

func (*Request) SetContentLength added in v1.14.0 

func (r *Request) SetContentLength(l bool) *Request

SetContentLength method sets the HTTP header `Content-Length` value for current request. By default niffler won't set `Content-Length`. Also you have an option to enable for every request.

See `Client.SetContentLength` 

client.R().SetContentLength(true)

func (*Request) SetContext added in v1.14.0 

func (r *Request) SetContext(ctx context.Context) *Request

SetContext method sets the context.Context for current Request. It allows to interrupt the request execution if ctx.Done() channel is closed. See https://blog.golang.org/context article and the "context" package documentation.

func (*Request) SetCookie added in v1.14.0 

func (r *Request) SetCookie(hc *http.Cookie) *Request

SetCookie method appends a single cookie in the current request instance. 

client.R().SetCookie(&http.Cookie{
			Name:"go-niffler",
			Value:"This is cookie value",
		})

Note: Method appends the Cookie value into existing Cookie if already existing.

Since v2.1.0

func (*Request) SetCookies added in v1.14.0 

func (r *Request) SetCookies(rs []*http.Cookie) *Request

SetCookies method sets an array of cookies in the current request instance. 

cookies := []*http.Cookie{
	&http.Cookie{
		Name:"go-niffler-1",
		Value:"This is cookie 1 value",
	},
	&http.Cookie{
		Name:"go-niffler-2",
		Value:"This is cookie 2 value",
	},
}

// Setting a cookies into niffler's current request
client.R().SetCookies(cookies)

Note: Method appends the Cookie value into existing Cookie if already existing.

Since v2.1.0

func (*Request) SetDoNotParseResponse added in v1.14.0 

func (r *Request) SetDoNotParseResponse(parse bool) *Request

SetDoNotParseResponse method instructs `niffler` not to parse the response body automatically. niffler exposes the raw response body as `io.ReadCloser`. Also do not forget to close the body, otherwise you might get into connection leaks, no connection reuse.

Note: Response middlewares are not applicable, if you use this option. Basically you have taken over the control of response parsing from `niffler`.

func (*Request) SetError added in v1.14.0 

func (r *Request) SetError(err interface{}) *Request

SetError method is to register the request `Error` object for automatic unmarshalling for the request, if response status code is greater than 399 and content type either JSON or XML.

Note: Error object can be pointer or non-pointer. 

client.R().SetError(&AuthError{})
// OR
client.R().SetError(AuthError{})

Accessing a error value from response instance. 

response.Error().(*AuthError)

func (*Request) SetFile added in v1.14.0 

func (r *Request) SetFile(param, filePath string) *Request

SetFile method is to set single file field name and its path for multipart upload. 

client.R().
	SetFile("my_file", "/Users/jeeva/Gas Bill - Sep.pdf")

func (*Request) SetFileReader added in v1.14.0 

func (r *Request) SetFileReader(param, fileName string, reader io.Reader) *Request

SetFileReader method is to set single file using io.Reader for multipart upload. 

client.R().
	SetFileReader("profile_img", "my-profile-img.png", bytes.NewReader(profileImgBytes)).
	SetFileReader("notes", "user-notes.txt", bytes.NewReader(notesBytes))

func (*Request) SetFiles added in v1.14.0 

func (r *Request) SetFiles(files map[string]string) *Request

SetFiles method is to set multiple file field name and its path for multipart upload. 

client.R().
	SetFiles(map[string]string{
			"my_file1": "/Users/jeeva/Gas Bill - Sep.pdf",
			"my_file2": "/Users/jeeva/Electricity Bill - Sep.pdf",
			"my_file3": "/Users/jeeva/Water Bill - Sep.pdf",
		})

func (*Request) SetFormData added in v1.14.0 

func (r *Request) SetFormData(data map[string]string) *Request

SetFormData method sets Form parameters and their values in the current request. It's applicable only HTTP method `POST` and `PUT` and requests content type would be set as `application/x-www-form-urlencoded`. 

client.R().
	SetFormData(map[string]string{
		"access_token": "BC594900-518B-4F7E-AC75-BD37F019E08F",
		"user_id": "3455454545",
	})

Also you can override form data value, which was set at client instance level.

func (*Request) SetFormDataFromValues added in v1.14.0 

func (r *Request) SetFormDataFromValues(data url.Values) *Request

SetFormDataFromValues method appends multiple form parameters with multi-value (`url.Values`) at one go in the current request. 

client.R().
	SetFormDataFromValues(url.Values{
		"search_criteria": []string{"book", "glass", "pencil"},
	})

Also you can override form data value, which was set at client instance level.

func (*Request) SetHeader added in v1.14.0 

func (r *Request) SetHeader(header, value string) *Request

SetHeader method is to set a single header field and its value in the current request.

For Example: To set `Content-Type` and `Accept` as `application/json`. 

client.R().
	SetHeader("Content-Type", "application/json").
	SetHeader("Accept", "application/json")

Also you can override header value, which was set at client instance level.

func (*Request) SetHeaders added in v1.14.0 

func (r *Request) SetHeaders(headers map[string]string) *Request

SetHeaders method sets multiple headers field and its values at one go in the current request.

For Example: To set `Content-Type` and `Accept` as `application/json` 

client.R().
	SetHeaders(map[string]string{
		"Content-Type": "application/json",
		"Accept": "application/json",
	})

Also you can override header value, which was set at client instance level.

func (*Request) SetJSONEscapeHTML added in v1.14.0 

func (r *Request) SetJSONEscapeHTML(b bool) *Request

SetJSONEscapeHTML method is to enable/disable the HTML escape on JSON marshal.

Note: This option only applicable to standard JSON Marshaller.

func (*Request) SetMultipartField added in v1.14.0 

func (r *Request) SetMultipartField(param, fileName, contentType string, reader io.Reader) *Request

SetMultipartField method is to set custom data using io.Reader for multipart upload.

func (*Request) SetMultipartFields added in v1.14.0 

func (r *Request) SetMultipartFields(fields ...*MultipartField) *Request

SetMultipartFields method is to set multiple data fields using io.Reader for multipart upload.

For Example: 

client.R().SetMultipartFields(
	&niffler.MultipartField{
		Param:       "uploadManifest1",
		FileName:    "upload-file-1.json",
		ContentType: "application/json",
		Reader:      strings.NewReader(`{"input": {"name": "Uploaded document 1", "_filename" : ["file1.txt"]}}`),
	},
	&niffler.MultipartField{
		Param:       "uploadManifest2",
		FileName:    "upload-file-2.json",
		ContentType: "application/json",
		Reader:      strings.NewReader(`{"input": {"name": "Uploaded document 2", "_filename" : ["file2.txt"]}}`),
	})

If you have slice already, then simply call- 

client.R().SetMultipartFields(fields...)

func (*Request) SetMultipartFormData added in v1.14.0 

func (r *Request) SetMultipartFormData(data map[string]string) *Request

SetMultipartFormData method allows simple form data to be attached to the request as `multipart:form-data`

func (*Request) SetOutput added in v1.14.0 

func (r *Request) SetOutput(file string) *Request

SetOutput method sets the output file for current HTTP request. Current HTTP response will be saved into given file. It is similar to `curl -o` flag. Absolute path or relative path can be used. If is it relative path then output file goes under the output directory, as mentioned in the `Client.SetOutputDirectory`. 

client.R().
	SetOutput("/Users/jeeva/Downloads/ReplyWithHeader-v5.1-beta.zip").
	Get("http://bit.ly/1LouEKr")

Note: In this scenario `Response.Body` might be nil.

func (*Request) SetPathParam added in v1.14.0 

func (r *Request) SetPathParam(param, value string) *Request

SetPathParam method sets single URL path key-value pair in the niffler current request instance. 

client.R().SetPathParam("userId", "sample@sample.com")

Result:
   URL - /v1/users/{userId}/details
   Composed URL - /v1/users/sample@sample.com/details

It replaces the value of the key while composing the request URL. Also you can override Path Params value, which was set at client instance level.

func (*Request) SetPathParams added in v1.14.0 

func (r *Request) SetPathParams(params map[string]string) *Request

SetPathParams method sets multiple URL path key-value pairs at one go in the niffler current request instance. 

client.R().SetPathParams(map[string]string{
   "userId": "sample@sample.com",
   "subAccountId": "100002",
})

Result:
   URL - /v1/users/{userId}/{subAccountId}/details
   Composed URL - /v1/users/sample@sample.com/100002/details

It replaces the value of the key while composing request URL. Also you can override Path Params value, which was set at client instance level.

func (*Request) SetQueryParam added in v1.14.0 

func (r *Request) SetQueryParam(param, value string) *Request

SetQueryParam method sets single parameter and its value in the current request. It will be formed as query string for the request.

For Example: `search=kitchen%20papers&size=large` in the URL after `?` mark. 

client.R().
	SetQueryParam("search", "kitchen papers").
	SetQueryParam("size", "large")

Also you can override query params value, which was set at client instance level.

func (*Request) SetQueryParams added in v1.14.0 

func (r *Request) SetQueryParams(params map[string]string) *Request

SetQueryParams method sets multiple parameters and its values at one go in the current request. It will be formed as query string for the request.

For Example: `search=kitchen%20papers&size=large` in the URL after `?` mark. 

client.R().
	SetQueryParams(map[string]string{
		"search": "kitchen papers",
		"size": "large",
	})

Also you can override query params value, which was set at client instance level.

func (*Request) SetQueryParamsFromValues added in v1.14.0 

func (r *Request) SetQueryParamsFromValues(params url.Values) *Request

SetQueryParamsFromValues method appends multiple parameters with multi-value (`url.Values`) at one go in the current request. It will be formed as query string for the request.

For Example: `status=pending&status=approved&status=open` in the URL after `?` mark. 

client.R().
	SetQueryParamsFromValues(url.Values{
		"status": []string{"pending", "approved", "open"},
	})

Also you can override query params value, which was set at client instance level.

func (*Request) SetQueryString added in v1.14.0 

func (r *Request) SetQueryString(query string) *Request

SetQueryString method provides ability to use string as an input to set URL query string for the request.

Using String as an input 

client.R().
	SetQueryString("productId=232&template=fresh-sample&cat=niffler&source=google&kw=buy a lot more")

func (*Request) SetResult added in v1.14.0 

func (r *Request) SetResult(res interface{}) *Request

SetResult method is to register the response `Result` object for automatic unmarshalling for the request, if response status code is between 200 and 299 and content type either JSON or XML.

Note: Result object can be pointer or non-pointer. 

client.R().SetResult(&AuthToken{})
// OR
client.R().SetResult(AuthToken{})

Accessing a result value from response instance. 

response.Result().(*AuthToken)

func (*Request) SetSRV added in v1.14.0 

func (r *Request) SetSRV(srv *SRVRecord) *Request

SetSRV method sets the details to query the service SRV record and execute the request. 

client.R().
	SetSRV(SRVRecord{"web", "testservice.com"}).
	Get("/get")

func (*Request) TraceInfo added in v1.14.0 

func (r *Request) TraceInfo() TraceInfo

TraceInfo method returns the trace info for the request. If either the Client or Request EnableTrace function has not been called prior to the request being made, an empty TraceInfo object will be returned.

Since v2.0.0

type RequestLog added in v1.14.0 

type RequestLog struct {
	Header http.Header
	Body   string
}

RequestLog struct is used to collected information from niffler request instance for debug logging. It sent to request log callback before niffler actually logs the information.

type RequestLogCallback added in v1.14.0 

type RequestLogCallback func(*RequestLog) error

RequestLogCallback type is for request logs, called before the request is logged

type RequestMiddleware added in v1.14.0 

type RequestMiddleware func(*Client, *Request) error

RequestMiddleware type is for request middleware, called before a request is sent

type Response added in v1.14.0 

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

Response struct holds response values of executed request.

func (*Response) Body added in v1.14.0 

func (r *Response) Body() []byte

Body method returns HTTP response as []byte array for the executed request.

Note: `Response.Body` might be nil, if `Request.SetOutput` is used.

func (*Response) Cookies added in v1.14.0 

func (r *Response) Cookies() []*http.Cookie

Cookies method to access all the response cookies

func (*Response) Error added in v1.14.0 

func (r *Response) Error() interface{}

Error method returns the error object if it has one

func (*Response) Header added in v1.14.0 

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

Header method returns the response headers

func (*Response) IsError added in v1.14.0 

func (r *Response) IsError() bool

IsError method returns true if HTTP status `code >= 400` otherwise false.

func (*Response) IsSuccess added in v1.14.0 

func (r *Response) IsSuccess() bool

IsSuccess method returns true if HTTP status `code >= 200 and <= 299` otherwise false.

func (*Response) Proto added in v1.14.0 

func (r *Response) Proto() string

Proto method returns the HTTP response protocol used for the request.

func (*Response) RawBody added in v1.14.0 

func (r *Response) RawBody() io.ReadCloser

RawBody method exposes the HTTP raw response body. Use this method in-conjunction with `SetDoNotParseResponse` option otherwise you get an error as `read err: http: read on closed response body`.

Do not forget to close the body, otherwise you might get into connection leaks, no connection reuse. Basically you have taken over the control of response parsing from `niffler`.

func (*Response) ReceivedAt added in v1.14.0 

func (r *Response) ReceivedAt() time.Time

ReceivedAt method returns when response got received from server for the request.

func (*Response) Result added in v1.14.0 

func (r *Response) Result() interface{}

Result method returns the response value as an object if it has one

func (*Response) Size added in v1.14.0 

func (r *Response) Size() int64

Size method returns the HTTP response size in bytes. Ya, you can relay on HTTP `Content-Length` header, however it won't be good for chucked transfer/compressed response. Since niffler calculates response size at the client end. You will get actual size of the http response.

func (*Response) Status added in v1.14.0 

func (r *Response) Status() string

Status method returns the HTTP status string for the executed request. 

Example: 200 OK

func (*Response) StatusCode added in v1.14.0 

func (r *Response) StatusCode() int

StatusCode method returns the HTTP status code for the executed request. 

Example: 200

func (*Response) String added in v1.14.0 

func (r *Response) String() string

String method returns the body of the server response as String.

func (*Response) Time added in v1.14.0 

func (r *Response) Time() time.Duration

Time method returns the time of HTTP response time that from request we sent and received a request.

See `Response.ReceivedAt` to know when client received response and see `Response.Request.Time` to know when client sent a request.

type ResponseError added in v1.14.0 

type ResponseError struct {
	Response *Response
	Err      error
}

ResponseError is a wrapper for including the server response with an error. Neither the err nor the response should be nil.

func (*ResponseError) Error added in v1.14.0 

func (e *ResponseError) Error() string

func (*ResponseError) Unwrap added in v1.14.0 

func (e *ResponseError) Unwrap() error

type ResponseLog added in v1.14.0 

type ResponseLog struct {
	Header http.Header
	Body   string
}

ResponseLog struct is used to collected information from niffler response instance for debug logging. It sent to response log callback before niffler actually logs the information.

type ResponseLogCallback added in v1.14.0 

type ResponseLogCallback func(*ResponseLog) error

ResponseLogCallback type is for response logs, called before the response is logged

type ResponseMiddleware added in v1.14.0 

type ResponseMiddleware func(*Client, *Response) error

ResponseMiddleware type is for response middleware, called after a response has been received

type RetryAfterFunc added in v1.14.0 

type RetryAfterFunc func(*Client, *Response) (time.Duration, error)

RetryAfterFunc returns time to wait before retry For example, it can parse HTTP Retry-After header https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html Non-nil error is returned if it is found that request is not retryable (0, nil) is a special result means 'use default algorithm'

type RetryConditionFunc added in v1.14.0 

type RetryConditionFunc func(*Response, error) bool

RetryConditionFunc type is for retry condition function input: non-nil Response OR request execution error

type SRVRecord added in v1.14.0 

type SRVRecord struct {
	Service string
	Domain  string
}

SRVRecord struct holds the data to query the SRV record for the following service.

type TraceInfo added in v1.14.0 

type TraceInfo struct {
	// DNSLookup is a duration that transport took to perform
	// DNS lookup.
	DNSLookup time.Duration

	// ConnTime is a duration that took to obtain a successful connection.
	ConnTime time.Duration

	// TCPConnTime is a duration that took to obtain the TCP connection.
	TCPConnTime time.Duration

	// TLSHandshake is a duration that TLS handshake took place.
	TLSHandshake time.Duration

	// ServerTime is a duration that server took to respond first byte.
	ServerTime time.Duration

	// ResponseTime is a duration since first response byte from server to
	// request completion.
	ResponseTime time.Duration

	// TotalTime is a duration that total request took end-to-end.
	TotalTime time.Duration

	// IsConnReused is whether this connection has been previously
	// used for another HTTP request.
	IsConnReused bool

	// IsConnWasIdle is whether this connection was obtained from an
	// idle pool.
	IsConnWasIdle bool

	// ConnIdleTime is a duration how long the connection was previously
	// idle, if IsConnWasIdle is true.
	ConnIdleTime time.Duration

	// RequestAttempt is to represent the request attempt made during a niffler
	// request execution flow, including retry count.
	RequestAttempt int

	// RemoteAddr returns the remote network address.
	RemoteAddr net.Addr
}

TraceInfo struct is used provide request trace info such as DNS lookup duration, Connection obtain duration, Server processing duration, etc.

Since v2.0.0

type User added in v1.14.0 

type User struct {
	Username, Password string
}

User type is to hold an username and password information

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.