req

package module
v2.0.0-alpha.5 Latest Latest
Warning

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

Go to latest
Published: Jan 23, 2022 License: MIT Imports: 48 Imported by: 3

README

req

GoDoc

A golang http request library for humans.

Features

  • Simple and chainable methods for client and request settings, rich syntax sugar, less code and more efficiency.
  • Automatically detect charset and decode it to utf-8.
  • Powerful debugging capabilities (logging, tracing, and even dump the requests and responses' content).
  • All settings can be changed dynamically, making it possible to debug in the production environment.
  • Easy to integrate with existing code, just replace the Transport of existing http.Client, then you can dump content as req to debug APIs.

Install

go get github.com/imroc/req/v2@v2.0.0-alpha.5

Usage

Import req in your code:

import "github.com/imroc/req/v2"
Table of Contents
Quick Start

Simple GET

// Create and send a request with the global default client
resp, err := req.New().Get("https://api.github.com/users/imroc")

// Create and send a request with the custom client
client := req.C()
resp, err := client.R().Get("https://api.github.com/users/imroc")

Client Settings

client.SetUserAgent("my-custom-client").
	SetTimeout(5 * time.Second).
	DevMode()

Request Settings

var result Result
resp, err := client.R().
	SetResult(&result).
	SetHeader("Accept", "application/json").
	SetQeuryParam("page", "1").
	SetPathParam("userId", "imroc").
	Get(url)
Debug

Dump the content of request and response

// Set EnableDump to true, default dump all content to stderr,
// including both header and body of request and response
client := req.C().EnableDump(true)
client.R().Get("https://api.github.com/users/imroc")

/* Output
:authority: api.github.com
:method: GET
:path: /users/imroc
:scheme: https
user-agent: custom-client
accept-encoding: gzip

:status: 200
server: GitHub.com
date: Fri, 21 Jan 2022 09:31:43 GMT
content-type: application/json; charset=utf-8
cache-control: public, max-age=60, s-maxage=60
vary: Accept, Accept-Encoding, Accept, X-Requested-With
etag: W/"fe5acddc5c01a01153ebc4068a1f067dadfa7a7dc9a025f44b37b0a0a50e2c55"
last-modified: Thu, 08 Jul 2021 12:11:23 GMT
x-github-media-type: github.v3; format=json
access-control-expose-headers: ETag, Link, Location, Retry-After, X-GitHub-OTP, X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Used, X-RateLimit-Resource, X-RateLimit-Reset, X-OAuth-Scopes, X-Accepted-OAuth-Scopes, X-Poll-Interval, X-GitHub-Media-Type, X-GitHub-SSO, X-GitHub-Request-Id, Deprecation, Sunset
access-control-allow-origin: *
strict-transport-security: max-age=31536000; includeSubdomains; preload
x-frame-options: deny
x-content-type-options: nosniff
x-xss-protection: 0
referrer-policy: origin-when-cross-origin, strict-origin-when-cross-origin
content-security-policy: default-src 'none'
content-encoding: gzip
x-ratelimit-limit: 60
x-ratelimit-remaining: 59
x-ratelimit-reset: 1642761103
x-ratelimit-resource: core
x-ratelimit-used: 1
accept-ranges: bytes
content-length: 486
x-github-request-id: AF10:6205:BA107D:D614F2:61EA7D7E

{"login":"imroc","id":7448852,"node_id":"MDQ6VXNlcjc0NDg4NTI=","avatar_url":"https://avatars.githubusercontent.com/u/7448852?v=4","gravatar_id":"","url":"https://api.github.com/users/imroc","html_url":"https://github.com/imroc","followers_url":"https://api.github.com/users/imroc/followers","following_url":"https://api.github.com/users/imroc/following{/other_user}","gists_url":"https://api.github.com/users/imroc/gists{/gist_id}","starred_url":"https://api.github.com/users/imroc/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/imroc/subscriptions","organizations_url":"https://api.github.com/users/imroc/orgs","repos_url":"https://api.github.com/users/imroc/repos","events_url":"https://api.github.com/users/imroc/events{/privacy}","received_events_url":"https://api.github.com/users/imroc/received_events","type":"User","site_admin":false,"name":"roc","company":"Tencent","blog":"https://imroc.cc","location":"China","email":null,"hireable":true,"bio":"I'm roc","twitter_username":"imrocchan","public_repos":128,"public_gists":0,"followers":362,"following":151,"created_at":"2014-04-30T10:50:46Z","updated_at":"2021-07-08T12:11:23Z"}
*/
	
// Dump header content asynchronously and save it to file
client := req.C().
	EnableDumpOnlyHeader(). // Only dump the header of request and response
	EnableDumpAsync(). // Dump asynchronously to improve performance
	EnableDumpToFile("reqdump.log") // Dump to file without printing it out
client.Get(url)

// Enable dump with fully customized settings
opt := &req.DumpOptions{
            Output:         os.Stdout,
            RequestHeader:  true,
            ResponseBody:   true,
            RequestBody:    false,
            ResponseHeader: false,
            Async:          false,
        }
client := req.C().SetDumpOptions(opt).EnableDump(true)
client.R().Get("https://www.baidu.com/")

// Change settings dynamiclly
opt.ResponseBody = false
client.R().Get("https://www.baidu.com/")

Logging

// Logging is enabled by default, but only output warning and error message to stderr.
// EnableDebug set to true to enable debug level message logging.
client := req.C().EnableDebug(true)
client.R().Get("https://api.github.com/users/imroc")
// Output
// 2022/01/23 14:33:04.755019 DEBUG [req] GET https://api.github.com/users/imroc

// SetLogger with nil to disable all log
client.SetLogger(nil)

// Or customize the logger with your own implementation.
client.SetLogger(logger)

DevMode

If you want to enable all debug features (dump, debug logging and tracing), just call DevMode():

client := req.C().DevMode()
client.R().Get("https://imroc.cc")
PathParam and QueryParam
client := req.C().DevMode()
client.R().
    SetPathParam("owner", "imroc"). // Set a path param, which will replace the vairable in url path
    SetPathParams(map[string]string{ // Set multiple path params at once 
        "repo": "req",
        "path": "README.md",
    }).SetQueryParam("a", "a"). // Set a query param, which will be encoded as query parameter in url
    SetQueryParams(map[string]string{ // Set multiple query params at once 
        "b": "b",
        "c": "c",
    }).SetQueryString("d=d&e=e"). // Set query params as a raw query string
    Get("https://api.github.com/repos/{owner}/{repo}/contents/{path}?x=x")
/* Output
2022/01/23 14:43:59.114592 DEBUG [req] GET https://api.github.com/repos/imroc/req/contents/README.md?x=x&a=a&b=b&c=c&d=d&e=e
...
*/

// You can also set the common PathParam and QueryParam for every request on client
client.SetPathParam(k1, v1).
    SetPathParams(pathParams).
    SetQueryParam(k2, v2).
    SetQueryParams(queryParams).
    SetQueryString(queryString).
	
resp, err := client.Get(url1)
...

resp, err := client.Get(url2)
...
// Let's dump the header to see what's going on
client := req.C().EnableDumpOnlyHeader() 

// Send a request with multiple headers and cookies
resp, err := client.R().
    SetHeader("Accept", "application/json"). // Set one header
    SetHeaders(map[string]string{ // Set multiple headers at once 
        "My-Custom-Header": "My Custom Value",
        "User":             "imroc",
    }).SetCookie(&http.Cookie{ // Set one cookie
        Name:     "imroc/req",
        Value:    "This is my custome cookie value",
        Path:     "/",
        Domain:   "baidu.com",
        MaxAge:   36000,
        HttpOnly: false,
        Secure:   true,
    }).SetCookies([]*http.Cookie{ // Set multiple cookies at once 
        &http.Cookie{
            Name:     "testcookie1",
            Value:    "testcookie1 value",
            Path:     "/",
            Domain:   "baidu.com",
            MaxAge:   36000,
            HttpOnly: false,
            Secure:   true,
        },
        &http.Cookie{
            Name:     "testcookie2",
            Value:    "testcookie2 value",
            Path:     "/",
            Domain:   "baidu.com",
            MaxAge:   36000,
            HttpOnly: false,
            Secure:   true,
        },
    }).Get("https://www.baidu.com/")

/* Output
GET / HTTP/1.1
Host: www.baidu.com
User-Agent: req/v2
Accept: application/json
Cookie: imroc/req="This is my custome cookie value"; testcookie1="testcookie1 value"; testcookie2="testcookie2 value"
My-Custom-Header: My Custom Value
User: imroc
Accept-Encoding: gzip

...
*/

// You can also set the common header and cookie for every request on client.
client.SetHeader(header).
	SetHeaders(headers).
	SetCookie(cookie).
	SetCookies(cookies)

resp, err := client.R().Get(url1)
...
resp, err := client.R().Get(url2)
...

License

Req released under MIT license, refer LICENSE file.

Documentation

Index

Constants

View Source
const (
	CONTENT_TYPE_APPLICATION_JSON_UTF8 = "application/json; charset=UTF-8"
	CONTENT_TYPE_APPLICATION_XML_UTF8  = "application/xml; charset=UTF-8"
	CONTENT_TYPE_TEXT_XML_UTF8         = "text/xml; charset=UTF-8"
	CONTENT_TYPE_TEXT_HTML_UTF8        = "text/html; charset=UTF-8"
	CONTENT_TYPE_TEXT_PLAIN_UTF8       = "text/plain; charset=UTF-8"
)
View Source
const DefaultMaxIdleConnsPerHost = 2

DefaultMaxIdleConnsPerHost is the default value of Transport's MaxIdleConnsPerHost.

Variables

View Source
var ErrBodyReadAfterClose = errors.New("http: invalid Read on closed Body")

ErrBodyReadAfterClose is returned when reading a Request or Response Body after the body has been closed. This typically happens when the body is read after an HTTP Handler calls WriteHeader or Write on its ResponseWriter.

View Source
var ErrLineTooLong = internal.ErrLineTooLong

ErrLineTooLong is returned when reading request or response bodies with malformed chunked encoding.

View Source
var NoBody = noBody{}

NoBody is an io.ReadCloser with no bytes. Read always returns EOF and Close always returns nil. It can be used in an outgoing client request to explicitly signal that a request has zero bytes. An alternative, however, is to simply set Request.Body to nil.

Functions

func CanonicalMIMEHeaderKey

func CanonicalMIMEHeaderKey(s string) string

CanonicalMIMEHeaderKey returns the canonical format of the MIME header key s. The canonicalization converts the first letter and any letter following a hyphen to upper case; the rest are converted to lowercase. For example, the canonical key for "accept-encoding" is "Accept-Encoding". MIME header keys are assumed to be ASCII only. If s contains a space or invalid header field bytes, it is returned without modifications.

func ProxyFromEnvironment

func ProxyFromEnvironment(req *http.Request) (*url.URL, error)

ProxyFromEnvironment returns the URL of the proxy to use for a given request, as indicated by the environment variables HTTP_PROXY, HTTPS_PROXY and NO_PROXY (or the lowercase versions thereof). HTTPS_PROXY takes precedence over HTTP_PROXY for https requests.

The environment values may be either a complete URL or a "host[:port]", in which case the "http" scheme is assumed. The schemes "http", "https", and "socks5" are supported. An error is returned if the value is a different form.

A nil URL and nil error are returned if no proxy is defined in the environment, or a proxy should not be used for the given request, as defined by NO_PROXY.

As a special case, if req.URL.Host is "localhost" (with or without a port number), then a nil URL and nil error will be returned.

func ProxyURL

func ProxyURL(fixedURL *url.URL) func(*http.Request) (*url.URL, error)

ProxyURL returns a proxy function (for use in a Transport) that always returns the same URL.

func SetDefaultClient

func SetDefaultClient(c *Client)

SetDefaultClient override the global default Client.

Types

type Client

type Client struct {
	HostURL       string
	PathParams    map[string]string
	QueryParams   urlpkg.Values
	Headers       http.Header
	Cookies       []*http.Cookie
	JSONMarshal   func(v interface{}) ([]byte, error)
	JSONUnmarshal func(data []byte, v interface{}) error
	XMLMarshal    func(v interface{}) ([]byte, error)
	XMLUnmarshal  func(data []byte, v interface{}) error
	Debug         bool
	// contains filtered or unexported fields
}

Client is the req's http client.

func C

func C() *Client

C create a new client.

func DefaultClient

func DefaultClient() *Client

DefaultClient returns the global default Client.

func NewClient

func NewClient() *Client

NewClient is the alias of C

func (*Client) Clone

func (c *Client) Clone() *Client

Clone copy and returns the Client

func (*Client) DevMode

func (c *Client) DevMode() *Client

DevMode enables dump for requests and responses, and set user agent to pretend to be a web browser, Avoid returning abnormal data from some sites.

func (*Client) DisableAutoReadResponse

func (c *Client) DisableAutoReadResponse(disable bool) *Client

func (*Client) DisableCompression

func (c *Client) DisableCompression(disable bool) *Client

func (*Client) DisableKeepAlives

func (c *Client) DisableKeepAlives(disable bool) *Client

func (*Client) EnableAutoDecodeAllType

func (c *Client) EnableAutoDecodeAllType() *Client

EnableAutoDecodeAllType indicates that try autodetect and decode all content type.

func (*Client) EnableAutoDecodeTextType

func (c *Client) EnableAutoDecodeTextType() *Client

EnableAutoDecodeTextType indicates that only try autodetect and decode the text content type.

func (*Client) EnableDebug

func (c *Client) EnableDebug(enable bool) *Client

func (*Client) EnableDump

func (c *Client) EnableDump(enable bool) *Client

EnableDump enables dump requests and responses, allowing you to clearly see the content of all requests and responses,which is very convenient for debugging APIs.

func (*Client) EnableDumpAll

func (c *Client) EnableDumpAll() *Client

EnableDumpAll indicates that should dump both requests and responses' head and body.

func (*Client) EnableDumpAsync

func (c *Client) EnableDumpAsync() *Client

EnableDumpAsync indicates that the dump should be done asynchronously, can be used for debugging in production environment without affecting performance.

func (*Client) EnableDumpOnlyBody

func (c *Client) EnableDumpOnlyBody() *Client

EnableDumpOnlyBody indicates that should dump the body of requests and responses.

func (*Client) EnableDumpOnlyHeader

func (c *Client) EnableDumpOnlyHeader() *Client

EnableDumpOnlyHeader indicates that should dump the head of requests and responses.

func (*Client) EnableDumpOnlyRequest

func (c *Client) EnableDumpOnlyRequest() *Client

EnableDumpOnlyRequest indicates that should dump the requests' head and response.

func (*Client) EnableDumpOnlyResponse

func (c *Client) EnableDumpOnlyResponse() *Client

EnableDumpOnlyResponse indicates that should dump the responses' head and response.

func (*Client) EnableDumpTo

func (c *Client) EnableDumpTo(output io.Writer) *Client

EnableDumpTo indicates that the content should dump to the specified destination.

func (*Client) EnableDumpToFile

func (c *Client) EnableDumpToFile(filename string) *Client

EnableDumpToFile indicates that the content should dump to the specified filename.

func (*Client) GetDumpOptions

func (c *Client) GetDumpOptions() *DumpOptions

func (*Client) GetResponseOptions

func (c *Client) GetResponseOptions() *ResponseOptions

func (*Client) NewRequest

func (c *Client) NewRequest() *Request

NewRequest is the alias of R()

func (*Client) OnAfterResponse

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

func (*Client) OnBeforeRequest

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

func (*Client) R

func (c *Client) R() *Request

R create a new request.

func (*Client) SetBasicAuth

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

func (*Client) SetCertFromFile

func (c *Client) SetCertFromFile(certFile, keyFile string) *Client

SetCertFromFile helps to set client certificates from cert and key file

func (*Client) SetCerts

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

SetCerts helps to set client certificates

func (*Client) SetCookie

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

func (*Client) SetCookies

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

func (*Client) SetDumpOptions

func (c *Client) SetDumpOptions(opt *DumpOptions) *Client

SetDumpOptions configures the underlying Transport's DumpOptions

func (*Client) SetHeader

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

SetHeader set the common header for all requests.

func (*Client) SetHeaders

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

func (*Client) SetLogger

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

SetLogger set the logger for req, set to nil to disable logger.

func (*Client) SetProxy

func (c *Client) SetProxy(proxy func(*http.Request) (*urlpkg.URL, error)) *Client

SetProxy set the proxy function.

func (*Client) SetProxyFromEnv

func (c *Client) SetProxyFromEnv() *Client

func (*Client) SetProxyURL

func (c *Client) SetProxyURL(proxyUrl string) *Client

func (*Client) SetQueryParam

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

func (*Client) SetQueryParams

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

func (*Client) SetQueryString

func (c *Client) SetQueryString(query string) *Client

func (*Client) SetRedirectPolicy

func (c *Client) SetRedirectPolicy(policies ...RedirectPolicy) *Client

SetRedirectPolicy helps to set the RedirectPolicy

func (*Client) SetResponseOptions

func (c *Client) SetResponseOptions(opt *ResponseOptions) *Client

SetResponseOptions set the ResponseOptions for the underlying Transport.

func (*Client) SetRootCertFromFile

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

SetRootCertFromFile helps to set root CA cert from file

func (*Client) SetRootCertFromString

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

SetRootCertFromString helps to set root CA cert from string

func (*Client) SetScheme

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

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

client.SetScheme("http")

func (*Client) SetTLSClientConfig

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

func (*Client) SetTimeout

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

SetTimeout set the timeout for all requests.

func (*Client) SetUserAgent

func (c *Client) SetUserAgent(userAgent string) *Client

SetUserAgent set the "User-Agent" header for all requests.

type DumpOptions

type DumpOptions struct {
	Output         io.Writer
	RequestHeader  bool
	RequestBody    bool
	ResponseHeader bool
	ResponseBody   bool
	Async          bool
}

DumpOptions controls the dump behavior.

func (*DumpOptions) Clone

func (do *DumpOptions) Clone() *DumpOptions

type Logger

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 Resty. Gives control to the Resty users, choice of the logger.

type RedirectPolicy

type RedirectPolicy func(req *http.Request, via []*http.Request) error

func AllowedDomainRedirectPolicy

func AllowedDomainRedirectPolicy(hosts ...string) RedirectPolicy

AllowedDomainRedirectPolicy allows redirect only if the redirected domain match one of the domain that specified.

func AllowedHostRedirectPolicy

func AllowedHostRedirectPolicy(hosts ...string) RedirectPolicy

AllowedHostRedirectPolicy allows redirect only if the redirected host match one of the host that specified.

func MaxRedirectPolicy

func MaxRedirectPolicy(noOfRedirect int) RedirectPolicy

MaxRedirectPolicy specifies the max number of redirect

func NoRedirectPolicy

func NoRedirectPolicy() RedirectPolicy

NoRedirectPolicy disable redirect behaviour

func SameDomainRedirectPolicy

func SameDomainRedirectPolicy() RedirectPolicy

func SameHostRedirectPolicy

func SameHostRedirectPolicy() RedirectPolicy

SameHostRedirectPolicy allows redirect only if the redirected host is the same as original host, e.g. redirect to "www.imroc.cc" from "imroc.cc" is not the allowed.

type Request

type Request struct {
	URL         string
	PathParams  map[string]string
	QueryParams urlpkg.Values
	Headers     http.Header
	Cookies     []*http.Cookie
	Result      interface{}
	Error       interface{}

	RawRequest *http.Request
	// contains filtered or unexported fields
}

Request is the http request

func New

func New() *Request

New create a new request using the global default client.

func (*Request) Delete

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

Delete Send the request with DELETE method and specified url.

func (*Request) Get

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

Get Send the request with GET method and specified url.

func (*Request) Head

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

Head Send the request with HEAD method and specified url.

func (*Request) MustDelete

func (r *Request) MustDelete(url string) *Response

MustDelete like Delete, panic if error happens.

func (*Request) MustGet

func (r *Request) MustGet(url string) *Response

MustGet like Get, panic if error happens.

func (*Request) MustHead

func (r *Request) MustHead(url string) *Response

MustHead like Head, panic if error happens.

func (*Request) MustOptions

func (r *Request) MustOptions(url string) *Response

MustOptions like Options, panic if error happens.

func (*Request) MustPatch

func (r *Request) MustPatch(url string) *Response

MustPatch like Patch, panic if error happens.

func (*Request) MustPost

func (r *Request) MustPost(url string) *Response

MustPost like Post, panic if error happens.

func (*Request) MustPut

func (r *Request) MustPut(url string) *Response

MustPut like Put, panic if error happens.

func (*Request) Options

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

Options Send the request with OPTIONS method and specified url.

func (*Request) Patch

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

Patch Send the request with PATCH method and specified url.

func (*Request) Post

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

Post Send the request with POST method and specified url.

func (*Request) Put

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

Put Send the request with Put method and specified url.

func (*Request) Send

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

func (*Request) SetBasicAuth

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

func (*Request) SetBody

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

SetBody set the request body.

func (*Request) SetBodyBytes

func (r *Request) SetBodyBytes(body []byte) *Request

SetBodyBytes set the request body as []byte.

func (*Request) SetBodyJsonBytes

func (r *Request) SetBodyJsonBytes(body []byte) *Request

SetBodyJsonBytes set the request body as []byte and set Content-Type header as "application/json; charset=UTF-8"

func (*Request) SetBodyJsonMarshal

func (r *Request) SetBodyJsonMarshal(v interface{}) *Request

SetBodyJsonMarshal set the request body that marshaled from object, and set Content-Type header as "application/json; charset=UTF-8"

func (*Request) SetBodyJsonString

func (r *Request) SetBodyJsonString(body string) *Request

SetBodyJsonString set the request body as string and set Content-Type header as "application/json; charset=UTF-8"

func (*Request) SetBodyString

func (r *Request) SetBodyString(body string) *Request

SetBodyString set the request body as string.

func (*Request) SetContentType

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

func (*Request) SetCookie

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

func (*Request) SetCookies

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

func (*Request) SetError

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

func (*Request) SetHeader

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

SetHeader set the common header for all requests.

func (*Request) SetHeaders

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

func (*Request) SetOutput

func (r *Request) SetOutput(output io.WriteCloser) *Request

func (*Request) SetOutputFile

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

func (*Request) SetPathParam

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

func (*Request) SetPathParams

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

func (*Request) SetQueryParam

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

func (*Request) SetQueryParams

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

func (*Request) SetQueryString

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

func (*Request) SetResult

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

type RequestMiddleware

type RequestMiddleware func(*Client, *Request) error

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

type Response

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

Response is the http response.

func (*Response) Bytes

func (r *Response) Bytes() ([]byte, error)

func (*Response) Error

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

Error method returns the error object if it has one

func (*Response) GetContentType

func (r *Response) GetContentType() string

func (*Response) IsError

func (r *Response) IsError() bool

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

func (*Response) IsSuccess

func (r *Response) IsSuccess() bool

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

func (*Response) MustBytes

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

func (*Response) MustString

func (r *Response) MustString() string

func (*Response) MustUnmarshal

func (r *Response) MustUnmarshal(v interface{})

func (*Response) MustUnmarshalJson

func (r *Response) MustUnmarshalJson(v interface{})

func (*Response) MustUnmarshalXml

func (r *Response) MustUnmarshalXml(v interface{})

func (*Response) Result

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

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

func (*Response) String

func (r *Response) String() (string, error)

func (*Response) Unmarshal

func (r *Response) Unmarshal(v interface{}) error

func (*Response) UnmarshalJson

func (r *Response) UnmarshalJson(v interface{}) error

func (*Response) UnmarshalXml

func (r *Response) UnmarshalXml(v interface{}) error

type ResponseMiddleware

type ResponseMiddleware func(*Client, *Response) error

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

type ResponseOptions

type ResponseOptions struct {
	// DisableAutoDecode, if true, prevents auto detect response
	// body's charset and decode it to utf-8
	DisableAutoDecode bool

	// AutoDecodeContentType specifies an optional function for determine
	// whether the response body should been auto decode to utf-8.
	// Only valid when DisableAutoDecode is true.
	AutoDecodeContentType func(contentType string) bool
}

ResponseOptions determines that how should the response been processed.

type Transport

type Transport struct {

	// Proxy specifies a function to return a proxy for a given
	// Request. If the function returns a non-nil error, the
	// request is aborted with the provided error.
	//
	// The proxy type is determined by the URL scheme. "http",
	// "https", and "socks5" are supported. If the scheme is empty,
	// "http" is assumed.
	//
	// If Proxy is nil or returns a nil *URL, no proxy is used.
	Proxy func(*http.Request) (*url.URL, error)

	// DialContext specifies the dial function for creating unencrypted TCP connections.
	// If DialContext is nil (and the deprecated Dial below is also nil),
	// then the transport dials using package net.
	//
	// DialContext runs concurrently with calls to RoundTrip.
	// A RoundTrip call that initiates a dial may end up using
	// a connection dialed previously when the earlier connection
	// becomes idle before the later DialContext completes.
	DialContext func(ctx context.Context, network, addr string) (net.Conn, error)

	// Dial specifies the dial function for creating unencrypted TCP connections.
	//
	// Dial runs concurrently with calls to RoundTrip.
	// A RoundTrip call that initiates a dial may end up using
	// a connection dialed previously when the earlier connection
	// becomes idle before the later Dial completes.
	//
	// Deprecated: Use DialContext instead, which allows the transport
	// to cancel dials as soon as they are no longer needed.
	// If both are set, DialContext takes priority.
	Dial func(network, addr string) (net.Conn, error)

	// DialTLSContext specifies an optional dial function for creating
	// TLS connections for non-proxied HTTPS requests.
	//
	// If DialTLSContext is nil (and the deprecated DialTLS below is also nil),
	// DialContext and TLSClientConfig are used.
	//
	// If DialTLSContext is set, the Dial and DialContext hooks are not used for HTTPS
	// requests and the TLSClientConfig and TLSHandshakeTimeout
	// are ignored. The returned net.Conn is assumed to already be
	// past the TLS handshake.
	DialTLSContext func(ctx context.Context, network, addr string) (net.Conn, error)

	// DialTLS specifies an optional dial function for creating
	// TLS connections for non-proxied HTTPS requests.
	//
	// Deprecated: Use DialTLSContext instead, which allows the transport
	// to cancel dials as soon as they are no longer needed.
	// If both are set, DialTLSContext takes priority.
	DialTLS func(network, addr string) (net.Conn, error)

	// TLSClientConfig specifies the TLS configuration to use with
	// tls.Client.
	// If nil, the default configuration is used.
	// If non-nil, HTTP/2 support may not be enabled by default.
	TLSClientConfig *tls.Config

	// TLSHandshakeTimeout specifies the maximum amount of time waiting to
	// wait for a TLS handshake. Zero means no timeout.
	TLSHandshakeTimeout time.Duration

	// DisableKeepAlives, if true, disables HTTP keep-alives and
	// will only use the connection to the server for a single
	// HTTP request.
	//
	// This is unrelated to the similarly named TCP keep-alives.
	DisableKeepAlives bool

	// DisableCompression, if true, prevents the Transport from
	// requesting compression with an "Accept-Encoding: gzip"
	// request header when the Request contains no existing
	// Accept-Encoding value. If the Transport requests gzip on
	// its own and gets a gzipped response, it's transparently
	// decoded in the Response.Body. However, if the user
	// explicitly requested gzip it is not automatically
	// uncompressed.
	DisableCompression bool

	// MaxIdleConns controls the maximum number of idle (keep-alive)
	// connections across all hosts. Zero means no limit.
	MaxIdleConns int

	// MaxIdleConnsPerHost, if non-zero, controls the maximum idle
	// (keep-alive) connections to keep per-host. If zero,
	// DefaultMaxIdleConnsPerHost is used.
	MaxIdleConnsPerHost int

	// MaxConnsPerHost optionally limits the total number of
	// connections per host, including connections in the dialing,
	// active, and idle states. On limit violation, dials will block.
	//
	// Zero means no limit.
	MaxConnsPerHost int

	// IdleConnTimeout is the maximum amount of time an idle
	// (keep-alive) connection will remain idle before closing
	// itself.
	// Zero means no limit.
	IdleConnTimeout time.Duration

	// ResponseHeaderTimeout, if non-zero, specifies the amount of
	// time to wait for a server's response headers after fully
	// writing the request (including its body, if any). This
	// time does not include the time to read the response body.
	ResponseHeaderTimeout time.Duration

	// ExpectContinueTimeout, if non-zero, specifies the amount of
	// time to wait for a server's first response headers after fully
	// writing the request headers if the request has an
	// "Expect: 100-continue" header. Zero means no timeout and
	// causes the body to be sent immediately, without
	// waiting for the server to approve.
	// This time does not include the time to send the request header.
	ExpectContinueTimeout time.Duration

	// TLSNextProto specifies how the Transport switches to an
	// alternate protocol (such as HTTP/2) after a TLS ALPN
	// protocol negotiation. If Transport dials an TLS connection
	// with a non-empty protocol name and TLSNextProto contains a
	// map entry for that key (such as "h2"), then the func is
	// called with the request's authority (such as "example.com"
	// or "example.com:1234") and the TLS connection. The function
	// must return a http.RoundTripper that then handles the request.
	// If TLSNextProto is not nil, HTTP/2 support is not enabled
	// automatically.
	TLSNextProto map[string]func(authority string, c *tls.Conn) http.RoundTripper

	// ProxyConnectHeader optionally specifies headers to send to
	// proxies during CONNECT requests.
	// To set the header dynamically, see GetProxyConnectHeader.
	ProxyConnectHeader http.Header

	// GetProxyConnectHeader optionally specifies a func to return
	// headers to send to proxyURL during a CONNECT request to the
	// ip:port target.
	// If it returns an error, the Transport's RoundTrip fails with
	// that error. It can return (nil, nil) to not add headers.
	// If GetProxyConnectHeader is non-nil, ProxyConnectHeader is
	// ignored.
	GetProxyConnectHeader func(ctx context.Context, proxyURL *url.URL, target string) (http.Header, error)

	// MaxResponseHeaderBytes specifies a limit on how many
	// response bytes are allowed in the server's response
	// header.
	//
	// Zero means to use a default limit.
	MaxResponseHeaderBytes int64

	// WriteBufferSize specifies the size of the write buffer used
	// when writing to the transport.
	// If zero, a default (currently 4KB) is used.
	WriteBufferSize int

	// ReadBufferSize specifies the size of the read buffer used
	// when reading from the transport.
	// If zero, a default (currently 4KB) is used.
	ReadBufferSize int

	// ForceAttemptHTTP2 controls whether HTTP/2 is enabled when a non-zero
	// Dial, DialTLS, or DialContext func or TLSClientConfig is provided.
	// By default, use of any those fields conservatively disables HTTP/2.
	// To use a custom dialer or TLS config and still attempt HTTP/2
	// upgrades, set this to true.
	ForceAttemptHTTP2 bool

	*ResponseOptions
	// contains filtered or unexported fields
}

Transport is an implementation of http.RoundTripper that supports HTTP, HTTPS, and HTTP proxies (for either HTTP or HTTPS with CONNECT).

By default, Transport caches connections for future re-use. This may leave many open connections when accessing many hosts. This behavior can be managed using Transport's CloseIdleConnections method and the MaxIdleConnsPerHost and DisableKeepAlives fields.

Transports should be reused instead of created as needed. Transports are safe for concurrent use by multiple goroutines.

A Transport is a low-level primitive for making HTTP and HTTPS requests. For high-level functionality, such as cookies and redirects, see Client.

Transport uses HTTP/1.1 for HTTP URLs and either HTTP/1.1 or HTTP/2 for HTTPS URLs, depending on whether the server supports HTTP/2, and how the Transport is configured. The DefaultTransport supports HTTP/2. To explicitly enable HTTP/2 on a transport, use golang.org/x/net/http2 and call ConfigureTransport. See the package docs for more about HTTP/2.

Responses with status codes in the 1xx range are either handled automatically (100 expect-continue) or ignored. The one exception is HTTP status code 101 (Switching Protocols), which is considered a terminal status and returned by RoundTrip. To see the ignored 1xx responses, use the httptrace trace package's ClientTrace.Got1xxResponse.

Transport only retries a request upon encountering a network error if the request is idempotent and either has no body or has its Request.GetBody defined. HTTP requests are considered idempotent if they have HTTP methods GET, HEAD, OPTIONS, or TRACE; or if their Header map contains an "Idempotency-Key" or "X-Idempotency-Key" entry. If the idempotency key value is a zero-length slice, the request is treated as idempotent but the header is not sent on the wire.

func (*Transport) CancelRequest deprecated

func (t *Transport) CancelRequest(req *http.Request)

CancelRequest cancels an in-flight request by closing its connection. CancelRequest should only be called after RoundTrip has returned.

Deprecated: Use Request.WithContext to create a request with a cancelable context instead. CancelRequest cannot cancel HTTP/2 requests.

func (*Transport) Clone

func (t *Transport) Clone() *Transport

Clone returns a deep copy of t's exported fields.

func (*Transport) CloseIdleConnections

func (t *Transport) CloseIdleConnections()

CloseIdleConnections closes any connections which were previously connected from previous requests but are now sitting idle in a "keep-alive" state. It does not interrupt any connections currently in use.

func (*Transport) DisableDump

func (t *Transport) DisableDump()

func (*Transport) EnableDump

func (t *Transport) EnableDump(opt *DumpOptions)

func (*Transport) RegisterProtocol

func (t *Transport) RegisterProtocol(scheme string, rt http.RoundTripper)

RegisterProtocol registers a new protocol with scheme. The Transport will pass requests using the given scheme to rt. It is rt's responsibility to simulate HTTP request semantics.

RegisterProtocol can be used by other packages to provide implementations of protocol schemes like "ftp" or "file".

If rt.RoundTrip returns ErrSkipAltProtocol, the Transport will handle the RoundTrip itself for that one request, as if the protocol were not registered.

func (*Transport) RoundTrip

func (t *Transport) RoundTrip(req *http.Request) (resp *http.Response, err error)

RoundTrip implements the RoundTripper interface.

For higher-level HTTP client support (such as handling of cookies and redirects), see Get, Post, and the Client type.

Like the RoundTripper interface, the error types returned by RoundTrip are unspecified.

Directories

Path Synopsis
Package internal contains HTTP internals shared by net/http and net/http/httputil.
Package internal contains HTTP internals shared by net/http and net/http/httputil.
godebug
Package godebug parses the GODEBUG environment variable.
Package godebug parses the GODEBUG environment variable.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL