anon

type Backoff ¶

type Backoff func(min, max time.Duration, attemptNum int, resp *http.Response) time.Duration

Backoff specifies a policy for how long to wait between retries. It is called after a failing request to determine the amount of time that should pass before trying again.

type CheckRetry ¶

type CheckRetry func(ctx context.Context, resp *http.Response, err error) (bool, error)

CheckRetry specifies a policy for handling retries. It is called following each request with the response and error values returned by the http.Client. If CheckRetry returns false, the Client stops retrying and returns the response to the caller. If CheckRetry returns an error, that error value is returned in lieu of the error from the request. The Client will close any response body when retrying, but if the retry is aborted it is up to the CheckResponse callback to properly close any response body before returning.

type Client ¶

type Client struct {
	HTTPClient *http.Client   // Internal HTTP client.
	Region     string         // Region of the Tor Exit Node
	Conf       Config         // Client Config
	Logger     *logrus.Logger // Customer logger instance.

	Tor       *tor.Tor        // Tor process
	Transport *http.Transport // Transport for tor socks5 proxy

	RetryWaitMin time.Duration // Minimum time to wait
	RetryWaitMax time.Duration // Maximum time to wait
	RetryMax     int           // Maximum number of retries

	// RequestLogHook allows a user-supplied function to be called
	// before each retry.
	RequestLogHook RequestLogHook

	// ResponseLogHook allows a user-supplied function to be called
	// with the response from each HTTP request executed.
	ResponseLogHook ResponseLogHook

	// CheckRetry specifies the policy for handling retries, and is called
	// after each request. The default policy is DefaultRetryPolicy.
	CheckRetry CheckRetry

	// Backoff specifies the policy for how long to wait between retries
	Backoff Backoff

	// ErrorHandler specifies the custom error handler to use, if any
	ErrorHandler ErrorHandler

	// GeoIPData of Tor Exit Node
	GeoIPData *GeoIPData
}

Client is used to make HTTP requests. It adds additional functionality like automatic retries to tolerate minor outages.

func NewClient(conf Config) (*Client, error)

func (c *Client) Close() error

func (c *Client) Debug(frmt string, i ...interface{})

func (c *Client) Do(req *Request) (*http.Response, error)

func (c *Client) Get(url string) (*http.Response, error)

func (c *Client) GetGeoIPData(ip string) (*GeoIPData, error)

func (c *Client) Head(url string) (*http.Response, error)

func (c *Client) NewRemoteIP() error

func (c *Client) Post(url, bodyType string, body interface{}) (*http.Response, error)

func (c *Client) PostForm(url string, data url.Values) (*http.Response, error)

func (c *Client) SetGeoData(ip string) error

func (c *Client) Shutdown() error

type Config ¶

type Config struct {
	Debug  bool
	Logger *logrus.Logger
	Region string
}

type ErrorHandler ¶

type ErrorHandler func(resp *http.Response, err error, numTries int) (*http.Response, error)

ErrorHandler is called if retries are expired, containing the last status from the http library. If not specified, default behavior for the library is to close the body and return an error indicating how many tries were attempted. If overriding this, be sure to close the body if needed.

type GeoIPData ¶

type GeoIPData struct {
	Status      string  `json:"status"`
	Country     string  `json:"country"`
	CountryCode string  `json:"countryCode"`
	Region      string  `json:"region"`
	RegionName  string  `json:"regionName"`
	City        string  `json:"city"`
	Zip         string  `json:"zip"`
	Lat         float64 `json:"lat"`
	Lon         float64 `json:"lon"`
	Timezone    string  `json:"timezone"`
	Isp         string  `json:"isp"`
	Org         string  `json:"org"`
	As          string  `json:"as"`
	Query       string  `json:"query"`
}

GeoIPData stores a geo ip response from ip-api.com

type LenReader ¶

type LenReader interface {
	Len() int
}

LenReader is an interface implemented by many in-memory io.Reader's. Used for automatically sending the right Content-Length header when possible.

type ReaderFunc ¶

type ReaderFunc func() (io.Reader, error)

ReaderFunc is the type of function that can be given natively to NewRequest

type Request ¶

type Request struct {

	// Embed an HTTP request directly. This makes a *Request act exactly
	// like an *http.Request so that all meta methods are supported.
	*http.Request
	// contains filtered or unexported fields
}

Request wraps the metadata needed to create HTTP requests.

func NewRequest(method, url string, rawBody interface{}) (*Request, error)

func (r *Request) BodyBytes() ([]byte, error)

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

type RequestLogHook ¶

type RequestLogHook func(*logrus.Logger, *http.Request, int)

RequestLogHook allows a function to run before each retry. The HTTP request which will be made, and the retry number (0 for the initial request) are available to users. The internal logger is exposed to consumers.

type ResponseLogHook ¶

type ResponseLogHook func(*logrus.Logger, *http.Response)

ResponseLogHook is like RequestLogHook, but allows running a function on each HTTP response. This function will be invoked at the end of every HTTP request executed, regardless of whether a subsequent retry needs to be performed or not. If the response body is read or closed from this method, this will affect the response returned from Do().