phttp

Documentation

Overview

package phttp (pandora http) contains pandora extension points for HTTP related protocols.

Index

• Constants
• func GetBody(req *http.Request) []byte
• func NewDialer(conf DialerConfig) netutil.Dialer
• func NewHTTP2Transport(conf TransportConfig, dial netutil.DialerFunc, target string) *http.Transport
• func NewTransport(conf TransportConfig, dial netutil.DialerFunc, target string) *http.Transport
• func WrapGun(g Gun) core.Gun
• type Ammo
• type AnswLogConfig
• type AutoTagConfig
• type BaseGun
  • func (b *BaseGun) Bind(aggregator netsample.Aggregator, deps core.GunDeps) error
  • func (b *BaseGun) Close() error
  • func (b *BaseGun) Shoot(ammo Ammo)
• type BaseGunConfig
  • func DefaultBaseGunConfig() BaseGunConfig
• type Client
• type ClientConfig
  • func DefaultClientConfig() ClientConfig
• type ClientGunConfig
  • func DefaultClientGunConfig() ClientGunConfig
• type ConnectGun
  • func NewConnectGun(conf ConnectGunConfig, answLog *zap.Logger) *ConnectGun
  • func (g *ConnectGun) Do(req *http.Request) (*http.Response, error)
• type ConnectGunConfig
  • func DefaultConnectGunConfig() ConnectGunConfig
• type DialerConfig
  • func DefaultDialerConfig() DialerConfig
• type Gun
• type HTTP2GunConfig
  • func DefaultHTTP2GunConfig() HTTP2GunConfig
• type HTTPGun
  • func NewClientGun(client Client, conf ClientGunConfig, answLog *zap.Logger, ...) *HTTPGun
  • func NewHTTP2Gun(conf HTTP2GunConfig, answLog *zap.Logger, targetResolved string) (*HTTPGun, error)
  • func NewHTTPGun(conf HTTPGunConfig, answLog *zap.Logger, targetResolved string) *HTTPGun
  • func (g *HTTPGun) Do(req *http.Request) (*http.Response, error)
• type HTTPGunConfig
  • func DefaultHTTPGunConfig() HTTPGunConfig
• type HTTPTraceConfig
• type TraceTimings
  • func CreateHTTPTrace() (*httptrace.ClientTrace, *TraceTimings)
  • func (t *TraceTimings) GetConnectTime() time.Duration
  • func (t *TraceTimings) GetLatency() time.Duration
  • func (t *TraceTimings) GetReceiveTime() time.Duration
  • func (t *TraceTimings) GetSendTime() time.Duration
• type TransportConfig
  • func DefaultTransportConfig() TransportConfig

Constants

const (
	EmptyTag = "__EMPTY__"
)

Functions

func GetBody

func GetBody(req *http.Request) []byte

func NewDialer

func NewDialer(conf DialerConfig) netutil.Dialer

func NewHTTP2Transport

func NewHTTP2Transport(conf TransportConfig, dial netutil.DialerFunc, target string) *http.Transport

func NewTransport

func NewTransport(conf TransportConfig, dial netutil.DialerFunc, target string) *http.Transport

func WrapGun

func WrapGun(g Gun) core.Gun

Types

type Ammo

type Ammo interface {
	// TODO(skipor): instead of sample use it wrapper with httptrace and more usable interface.
	Request() (*http.Request, *netsample.Sample)
	// Id unique ammo id. Usually equals to ammo num got from provider.
	ID() uint64
	IsInvalid() bool
}

Ammo ammo interface for http based guns. http ammo providers should produce ammo that implements Ammo. http guns should use convert ammo to Ammo, not to specific implementation. Returned request have

type AnswLogConfig

type AnswLogConfig struct {
	Enabled bool   `config:"enabled"`
	Path    string `config:"path"`
	Filter  string `config:"filter" valid:"oneof=all warning error"`
}

type AutoTagConfig

type AutoTagConfig struct {
	Enabled     bool `config:"enabled"`
	URIElements int  `config:"uri-elements" validate:"min=1"` // URI elements used to autotagging
	NoTagOnly   bool `config:"no-tag-only"`                   // When true, autotagged only ammo that has no tag before.
}

AutoTagConfig configure automatic tags generation based on ammo URI. First AutoTag URI path elements becomes tag. Example: /my/very/deep/page?id=23&param=33 -> /my/very when uri-elements: 2.

type BaseGun

type BaseGun struct {
	DebugLog   bool // Automaticaly set in Bind if Log accepts debug messages.
	Config     BaseGunConfig
	Do         func(r *http.Request) (*http.Response, error) // Required.
	Connect    func(ctx context.Context) error               // Optional hook.
	OnClose    func() error                                  // Optional. Called on Close().
	Aggregator netsample.Aggregator                          // Lazy set via BindResultTo.
	AnswLog    *zap.Logger
	core.GunDeps
}

func (*BaseGun) Bind

func (b *BaseGun) Bind(aggregator netsample.Aggregator, deps core.GunDeps) error

func (*BaseGun) Close

func (b *BaseGun) Close() error

func (*BaseGun) Shoot

func (b *BaseGun) Shoot(ammo Ammo)

Shoot is thread safe iff Do and Connect hooks are thread safe.

type BaseGunConfig

type BaseGunConfig struct {
	AutoTag   AutoTagConfig   `config:"auto-tag"`
	AnswLog   AnswLogConfig   `config:"answlog"`
	HTTPTrace HTTPTraceConfig `config:"httptrace"`
}

func DefaultBaseGunConfig

func DefaultBaseGunConfig() BaseGunConfig

type Client

type Client interface {
	Do(req *http.Request) (*http.Response, error)
	CloseIdleConnections() // We should close idle conns after gun close.
}

type ClientConfig

type ClientConfig struct {
	Redirect  bool            // When true, follow HTTP redirects.
	Dialer    DialerConfig    `config:"dial"`
	Transport TransportConfig `config:",squash"`
}

func DefaultClientConfig

func DefaultClientConfig() ClientConfig

type ClientGunConfig

type ClientGunConfig struct {
	Target string `validate:"endpoint,required"`
	SSL    bool
	Base   BaseGunConfig `config:",squash"`
}

func DefaultClientGunConfig

func DefaultClientGunConfig() ClientGunConfig

type ConnectGun

type ConnectGun struct {
	BaseGun
	// contains filtered or unexported fields
}

func NewConnectGun

func NewConnectGun(conf ConnectGunConfig, answLog *zap.Logger) *ConnectGun

func (*ConnectGun) Do

func (g *ConnectGun) Do(req *http.Request) (*http.Response, error)

type ConnectGunConfig

type ConnectGunConfig struct {
	Target        string       `validate:"endpoint,required"`
	ConnectSSL    bool         `config:"connect-ssl"` // Defines if tunnel encrypted.
	SSL           bool         // As in HTTP gun, defines scheme for http requests.
	Client        ClientConfig `config:",squash"`
	BaseGunConfig `config:",squash"`
}

func DefaultConnectGunConfig

func DefaultConnectGunConfig() ConnectGunConfig

type DialerConfig

type DialerConfig struct {
	DNSCache bool `config:"dns-cache" map:"-"`

	Timeout   time.Duration `config:"timeout"`
	DualStack bool          `config:"dual-stack"`

	// IPv4/IPv6 settings should not matter really,
	// because target should be dialed using pre-resolved addr.
	FallbackDelay time.Duration `config:"fallback-delay"`
	KeepAlive     time.Duration `config:"keep-alive"`
}

DialerConfig can be mapped on net.Dialer. Set net.Dialer for details.

func DefaultDialerConfig

func DefaultDialerConfig() DialerConfig

type Gun

type Gun interface {
	Shoot(ammo Ammo)
	Bind(sample netsample.Aggregator, deps core.GunDeps) error
}

type HTTP2GunConfig

type HTTP2GunConfig struct {
	Gun    ClientGunConfig `config:",squash"`
	Client ClientConfig    `config:",squash"`
}

func DefaultHTTP2GunConfig

func DefaultHTTP2GunConfig() HTTP2GunConfig

type HTTPGun

type HTTPGun struct {
	BaseGun
	// contains filtered or unexported fields
}

func NewClientGun

func NewClientGun(client Client, conf ClientGunConfig, answLog *zap.Logger, targetResolved string) *HTTPGun

func NewHTTP2Gun

func NewHTTP2Gun(conf HTTP2GunConfig, answLog *zap.Logger, targetResolved string) (*HTTPGun, error)

NewHTTP2Gun return simple HTTP/2 gun that can shoot sequentially through one connection.

func NewHTTPGun

func NewHTTPGun(conf HTTPGunConfig, answLog *zap.Logger, targetResolved string) *HTTPGun

func (*HTTPGun) Do

func (g *HTTPGun) Do(req *http.Request) (*http.Response, error)

type HTTPGunConfig

type HTTPGunConfig struct {
	Gun    ClientGunConfig `config:",squash"`
	Client ClientConfig    `config:",squash"`
}

func DefaultHTTPGunConfig

func DefaultHTTPGunConfig() HTTPGunConfig

type HTTPTraceConfig

type HTTPTraceConfig struct {
	DumpEnabled  bool `config:"dump"`
	TraceEnabled bool `config:"trace"`
}

type TraceTimings

type TraceTimings struct {
	GotConnTime          time.Time
	GetConnTime          time.Time
	DNSStartTime         time.Time
	DNSDoneTime          time.Time
	ConnectDoneTime      time.Time
	ConnectStartTime     time.Time
	WroteRequestTime     time.Time
	GotFirstResponseByte time.Time
}

func CreateHTTPTrace

func CreateHTTPTrace() (*httptrace.ClientTrace, *TraceTimings)

func (*TraceTimings) GetConnectTime

func (t *TraceTimings) GetConnectTime() time.Duration

func (*TraceTimings) GetLatency

func (t *TraceTimings) GetLatency() time.Duration

func (*TraceTimings) GetReceiveTime

func (t *TraceTimings) GetReceiveTime() time.Duration

func (*TraceTimings) GetSendTime

func (t *TraceTimings) GetSendTime() time.Duration

type TransportConfig

type TransportConfig struct {
	TLSHandshakeTimeout   time.Duration `config:"tls-handshake-timeout"`
	DisableKeepAlives     bool          `config:"disable-keep-alives"`
	DisableCompression    bool          `config:"disable-compression"`
	MaxIdleConns          int           `config:"max-idle-conns"`
	MaxIdleConnsPerHost   int           `config:"max-idle-conns-per-host"`
	IdleConnTimeout       time.Duration `config:"idle-conn-timeout"`
	ResponseHeaderTimeout time.Duration `config:"response-header-timeout"`
	ExpectContinueTimeout time.Duration `config:"expect-continue-timeout"`
}

TransportConfig can be mapped on http.Transport. See http.Transport for details.

func DefaultTransportConfig

func DefaultTransportConfig() TransportConfig