common

Documentation

Index

• Constants
• Variables
• func DurationToMicros(d time.Duration) int64
• func FillInDefaults(request *proto.ForwardEchoRequest)
• func GetCount(request *proto.ForwardEchoRequest) int
• func GetHeaders(request *proto.ForwardEchoRequest) http.Header
• func GetTimeout(request *proto.ForwardEchoRequest) time.Duration
• func HTTPToProtoHeaders(headers http.Header) []*proto.Header
• func IsWebSocketRequest(r *http.Request) bool
• func MicrosToDuration(micros int64) time.Duration
• func ProtoToHTTPHeaders(headers []*proto.Header) http.Header
• func SetWebSocketHeader(headers http.Header)
• type Dialer
  • func (d Dialer) FillInDefaults() Dialer
• type EchoMetrics
• type GRPCDialFunc
• type HTTPDoFunc
• type Port
• type PortList
• type TCPDialFunc
• type TLSSettings
• type WebsocketDialFunc

Constants

const (
	ConnectionTimeout = 2 * time.Second
	DefaultCount      = 1
)

Variables

var (
	// DefaultGRPCDialFunc just calls grpc.Dial directly, with no alterations to the arguments.
	DefaultGRPCDialFunc = grpc.DialContext
	// DefaultWebsocketDialFunc just calls dialer.Dial, with no alterations to the arguments.
	DefaultWebsocketDialFunc = func(dialer *websocket.Dialer, urlStr string, requestHeader http.Header) (*websocket.Conn, *http.Response, error) {
		return dialer.Dial(urlStr, requestHeader)
	}
	// DefaultHTTPDoFunc just calls client.Do with no alterations to the arguments.
	DefaultHTTPDoFunc = func(client *http.Client, req *http.Request) (*http.Response, error) {
		return client.Do(req)
	}
	// DefaultTCPDialFunc just calls dialer.Dial, with no alterations to the arguments.
	DefaultTCPDialFunc = func(dialer net.Dialer, ctx context.Context, address string) (net.Conn, error) {
		return dialer.DialContext(ctx, "tcp", address)
	}
	// DefaultDialer is provides defaults for all dial functions.
	DefaultDialer = Dialer{
		GRPC:      DefaultGRPCDialFunc,
		Websocket: DefaultWebsocketDialFunc,
		HTTP:      DefaultHTTPDoFunc,
		TCP:       DefaultTCPDialFunc,
	}
)

var (
	PortLabel = monitoring.CreateLabel("port")
	Metrics   = &EchoMetrics{
		HTTPRequests: monitoring.NewSum(
			"istio_echo_http_requests_total",
			"The number of http requests total",
		),
		GrpcRequests: monitoring.NewSum(
			"istio_echo_grpc_requests_total",
			"The number of grpc requests total",
		),
		TCPRequests: monitoring.NewSum(
			"istio_echo_tcp_requests_total",
			"The number of tcp requests total",
		),
	}
)

var DefaultRequestTimeout = 5 * time.Second

var ServerFirstMagicString = "server-first-protocol\n"

Functions

func DurationToMicros

func DurationToMicros(d time.Duration) int64

DurationToMicros converts the given duration to microseconds.

func FillInDefaults

func FillInDefaults(request *proto.ForwardEchoRequest)

FillInDefaults fills in the timeout and count if not specified in the given message.

func GetCount

func GetCount(request *proto.ForwardEchoRequest) int

GetCount returns the count value or DefaultCount if not set.

func GetHeaders

func GetHeaders(request *proto.ForwardEchoRequest) http.Header

GetHeaders returns the headers for the message.

func GetTimeout

func GetTimeout(request *proto.ForwardEchoRequest) time.Duration

GetTimeout returns the timeout value as a time.Duration or DefaultRequestTimeout if not set.

func HTTPToProtoHeaders

func HTTPToProtoHeaders(headers http.Header) []*proto.Header

func IsWebSocketRequest

func IsWebSocketRequest(r *http.Request) bool

IsWebSocketRequest indicates whether the request contains the header that triggers an upgrade to the WebSocket protocol.

func MicrosToDuration

func MicrosToDuration(micros int64) time.Duration

MicrosToDuration converts the given microseconds to a time.Duration.

func ProtoToHTTPHeaders

func ProtoToHTTPHeaders(headers []*proto.Header) http.Header

func SetWebSocketHeader

func SetWebSocketHeader(headers http.Header)

SetWebSocketHeader sets the header on the request which will trigger an upgrade to the WebSocket protocol.

Types

type Dialer

type Dialer struct {
	GRPC      GRPCDialFunc
	Websocket WebsocketDialFunc
	HTTP      HTTPDoFunc
	TCP       TCPDialFunc
}

Dialer is a replaceable set of functions for creating client-side connections for various protocols, allowing a test application to intercept the connection creation.

func (Dialer) FillInDefaults

func (d Dialer) FillInDefaults() Dialer

FillInDefaults fills in any missing dial functions with defaults

type EchoMetrics

type EchoMetrics struct {
	HTTPRequests monitoring.Metric
	GrpcRequests monitoring.Metric
	TCPRequests  monitoring.Metric
}

type GRPCDialFunc

type GRPCDialFunc func(ctx context.Context, address string, opts ...grpc.DialOption) (*grpc.ClientConn, error)

GRPCDialFunc a function for establishing a GRPC connection.

type HTTPDoFunc

type HTTPDoFunc func(client *http.Client, req *http.Request) (*http.Response, error)

HTTPDoFunc a function for executing an HTTP request.

type Port

type Port struct {
	// Name ascribes a human readable name for the port object. When a
	// service has multiple ports, the name field is mandatory
	Name string

	// Port number where the service can be reached. Does not necessarily
	// map to the corresponding port numbers for the instances behind the
	// service.
	Port int

	// Protocol to be used for the port.
	Protocol protocol.Instance

	// TLS determines if the port will use TLS.
	TLS bool

	// ServerFirst if a port will be server first
	ServerFirst bool

	// InstanceIP determines if echo will listen on the instance IP, or wildcard
	InstanceIP bool

	// LocalhostIP determines if echo will listen on the localhost IP; otherwise, it will listen on wildcard
	LocalhostIP bool

	// XDSServer, for gRPC servers, will use the xds.NewGRPCServer constructor to rely on XDS configuration.
	// If this flag is set but the environment variable feature gates aren't, we should fail due to gRPC internals.
	XDSServer bool

	// XDSTestBootstrap allows settings per-endpoint bootstrap without using the GRPC_XDS_BOOTSTRAP env var
	XDSTestBootstrap []byte

	// XDSReadinessTLS determines if the XDS server should expect a TLS server, used for readiness probes
	XDSReadinessTLS bool

	// ProxyProtocol indicates this listener should terminate HA PROXY protocol (v1 or v2)
	ProxyProtocol bool
}

Port represents a network port where a service is listening for connections. The port should be annotated with the type of protocol used by the port.

type PortList

type PortList []*Port

PortList is a set of ports

type TCPDialFunc

type TCPDialFunc func(dialer net.Dialer, ctx context.Context, address string) (net.Conn, error)

TCPDialFunc a function for establishing a TCP connection.

type TLSSettings

type TLSSettings struct {
	// If not empty, RootCert supplies the extra root cert that will be appended to the system cert pool.
	RootCert   string
	ClientCert string
	Key        string
	// If provided, override the host name used for the connection
	// This needed for integration tests, as we are connecting using a port-forward (127.0.0.1), so
	// any DNS certs will not validate.
	Hostname string
	// If set to true, the cert will be provisioned by proxy, and extra cert volume will be mounted.
	ProxyProvision bool
	// AcceptAnyALPN, if true, will make the server accept ANY ALPNs. This comes at the expense of
	// allowing h2 negotiation and being able to detect the negotiated ALPN (as there is none), because
	// Golang doesn't like us doing this (https://github.com/golang/go/issues/46310).
	// This is useful when the server is simulating Envoy which does unconventional things with ALPN.
	AcceptAnyALPN bool
}

TLSSettings defines TLS configuration for Echo server

type WebsocketDialFunc

type WebsocketDialFunc func(dialer *websocket.Dialer, urlStr string, requestHeader http.Header) (*websocket.Conn, *http.Response, error)

WebsocketDialFunc a function for establishing a Websocket connection.