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

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.MustCreateLabel("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 ServerFirstMagicString = "server-first-protocol\n"

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

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

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

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

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
}

type PortList []*Port

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

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
}

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