core

package
v0.0.0-...-113c6ea Latest Latest
Warning

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

 Go to latest Published: Nov 27, 2019 License: Apache-2.0 Imports: 16 Imported by: 0

Documentation

Overview

Package core is a generated protocol buffer package.

It is generated from these files: 

envoy/api/v2/core/address.proto
envoy/api/v2/core/base.proto
envoy/api/v2/core/config_source.proto
envoy/api/v2/core/grpc_service.proto
envoy/api/v2/core/health_check.proto
envoy/api/v2/core/http_uri.proto
envoy/api/v2/core/protocol.proto

It has these top-level messages: 

Pipe
SocketAddress
TcpKeepalive
BindConfig
Address
CidrRange
Locality
Node
Metadata
RuntimeUInt32
HeaderValue
HeaderValueOption
DataSource
TransportSocket
SocketOption
ApiConfigSource
AggregatedConfigSource
ConfigSource
GrpcService
HealthCheck
HttpUri
TcpProtocolOptions
HttpProtocolOptions
Http1ProtocolOptions
Http2ProtocolOptions
GrpcProtocolOptions

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrInvalidLengthAddress = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAddress   = fmt.Errorf("proto: integer overflow")
)
View Source 
var (
	ErrInvalidLengthBase = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBase   = fmt.Errorf("proto: integer overflow")
)
View Source 
var (
	ErrInvalidLengthConfigSource = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowConfigSource   = fmt.Errorf("proto: integer overflow")
)
View Source 
var (
	ErrInvalidLengthGrpcService = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGrpcService   = fmt.Errorf("proto: integer overflow")
)
View Source 
var (
	ErrInvalidLengthHealthCheck = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowHealthCheck   = fmt.Errorf("proto: integer overflow")
)
View Source 
var (
	ErrInvalidLengthHttpUri = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowHttpUri   = fmt.Errorf("proto: integer overflow")
)
View Source 
var (
	ErrInvalidLengthProtocol = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowProtocol   = fmt.Errorf("proto: integer overflow")
)
View Source 
var ApiConfigSource_ApiType_name = map[int32]string{
	0: "REST_LEGACY",
	1: "REST",
	2: "GRPC",
}
View Source 
var ApiConfigSource_ApiType_value = map[string]int32{
	"REST_LEGACY": 0,
	"REST":        1,
	"GRPC":        2,
}
View Source 
var HealthStatus_name = map[int32]string{
	0: "UNKNOWN",
	1: "HEALTHY",
	2: "UNHEALTHY",
	3: "DRAINING",
	4: "TIMEOUT",
}
View Source 
var HealthStatus_value = map[string]int32{
	"UNKNOWN":   0,
	"HEALTHY":   1,
	"UNHEALTHY": 2,
	"DRAINING":  3,
	"TIMEOUT":   4,
}
View Source 
var RequestMethod_name = map[int32]string{
	0: "METHOD_UNSPECIFIED",
	1: "GET",
	2: "HEAD",
	3: "POST",
	4: "PUT",
	5: "DELETE",
	6: "CONNECT",
	7: "OPTIONS",
	8: "TRACE",
}
View Source 
var RequestMethod_value = map[string]int32{
	"METHOD_UNSPECIFIED": 0,
	"GET":                1,
	"HEAD":               2,
	"POST":               3,
	"PUT":                4,
	"DELETE":             5,
	"CONNECT":            6,
	"OPTIONS":            7,
	"TRACE":              8,
}
View Source 
var RoutingPriority_name = map[int32]string{
	0: "DEFAULT",
	1: "HIGH",
}
View Source 
var RoutingPriority_value = map[string]int32{
	"DEFAULT": 0,
	"HIGH":    1,
}
View Source 
var SocketAddress_Protocol_name = map[int32]string{
	0: "TCP",
	1: "UDP",
}
View Source 
var SocketAddress_Protocol_value = map[string]int32{
	"TCP": 0,
	"UDP": 1,
}
View Source 
var SocketOption_SocketState_name = map[int32]string{
	0: "STATE_PREBIND",
	1: "STATE_BOUND",
	2: "STATE_LISTENING",
}
View Source 
var SocketOption_SocketState_value = map[string]int32{
	"STATE_PREBIND":   0,
	"STATE_BOUND":     1,
	"STATE_LISTENING": 2,
}

Functions

This section is empty.

Types

type Address 

type Address struct {
	// Types that are valid to be assigned to Address:
	//	*Address_SocketAddress
	//	*Address_Pipe
	Address isAddress_Address `protobuf_oneof:"address"`
}

Addresses specify either a logical or physical address and port, which are used to tell Envoy where to bind/listen, connect to upstream and find management servers.

func (*Address) Descriptor 

func (*Address) Descriptor() ([]byte, []int)

func (*Address) Equal 

func (this *Address) Equal(that interface{}) bool

func (*Address) GetAddress 

func (m *Address) GetAddress() isAddress_Address

func (*Address) GetPipe 

func (m *Address) GetPipe() *Pipe

func (*Address) GetSocketAddress 

func (m *Address) GetSocketAddress() *SocketAddress

func (*Address) Marshal 

func (m *Address) Marshal() (dAtA []byte, err error)

func (*Address) MarshalTo 

func (m *Address) MarshalTo(dAtA []byte) (int, error)

func (*Address) ProtoMessage 

func (*Address) ProtoMessage()

func (*Address) Reset 

func (m *Address) Reset()

func (*Address) Size 

func (m *Address) Size() (n int)

func (*Address) String 

func (m *Address) String() string

func (*Address) Unmarshal 

func (m *Address) Unmarshal(dAtA []byte) error

func (*Address) Validate 

func (m *Address) Validate() error

Validate checks the field values on Address with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

func (*Address) XXX_OneofFuncs 

func (*Address) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type AddressValidationError 

type AddressValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

AddressValidationError is the validation error returned by Address.Validate if the designated constraints aren't met.

func (AddressValidationError) Error 

func (e AddressValidationError) Error() string

Error satisfies the builtin error interface

type Address_Pipe 

type Address_Pipe struct {
	Pipe *Pipe `protobuf:"bytes,2,opt,name=pipe,oneof"`
}

func (*Address_Pipe) Equal 

func (this *Address_Pipe) Equal(that interface{}) bool

func (*Address_Pipe) MarshalTo 

func (m *Address_Pipe) MarshalTo(dAtA []byte) (int, error)

func (*Address_Pipe) Size 

func (m *Address_Pipe) Size() (n int)

type Address_SocketAddress 

type Address_SocketAddress struct {
	SocketAddress *SocketAddress `protobuf:"bytes,1,opt,name=socket_address,json=socketAddress,oneof"`
}

func (*Address_SocketAddress) Equal 

func (this *Address_SocketAddress) Equal(that interface{}) bool

func (*Address_SocketAddress) MarshalTo 

func (m *Address_SocketAddress) MarshalTo(dAtA []byte) (int, error)

func (*Address_SocketAddress) Size 

func (m *Address_SocketAddress) Size() (n int)

type AggregatedConfigSource 

type AggregatedConfigSource struct {
}

Aggregated Discovery Service (ADS) options. This is currently empty, but when set in :ref:`ConfigSource <envoy_api_msg_core.ConfigSource>` can be used to specify that ADS is to be used.

func (*AggregatedConfigSource) Descriptor 

func (*AggregatedConfigSource) Descriptor() ([]byte, []int)

func (*AggregatedConfigSource) Equal 

func (this *AggregatedConfigSource) Equal(that interface{}) bool

func (*AggregatedConfigSource) Marshal 

func (m *AggregatedConfigSource) Marshal() (dAtA []byte, err error)

func (*AggregatedConfigSource) MarshalTo 

func (m *AggregatedConfigSource) MarshalTo(dAtA []byte) (int, error)

func (*AggregatedConfigSource) ProtoMessage 

func (*AggregatedConfigSource) ProtoMessage()

func (*AggregatedConfigSource) Reset 

func (m *AggregatedConfigSource) Reset()

func (*AggregatedConfigSource) Size 

func (m *AggregatedConfigSource) Size() (n int)

func (*AggregatedConfigSource) String 

func (m *AggregatedConfigSource) String() string

func (*AggregatedConfigSource) Unmarshal 

func (m *AggregatedConfigSource) Unmarshal(dAtA []byte) error

func (*AggregatedConfigSource) Validate 

func (m *AggregatedConfigSource) Validate() error

Validate checks the field values on AggregatedConfigSource with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type AggregatedConfigSourceValidationError 

type AggregatedConfigSourceValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

AggregatedConfigSourceValidationError is the validation error returned by AggregatedConfigSource.Validate if the designated constraints aren't met.

func (AggregatedConfigSourceValidationError) Error 

func (e AggregatedConfigSourceValidationError) Error() string

Error satisfies the builtin error interface

type ApiConfigSource 

type ApiConfigSource struct {
	ApiType ApiConfigSource_ApiType `` /* 130-byte string literal not displayed */
	// Cluster names should be used only with REST_LEGACY/REST. If > 1
	// cluster is defined, clusters will be cycled through if any kind of failure
	// occurs.
	//
	// .. note::
	//
	//  The cluster with name “cluster_name“ must be statically defined and its
	//  type must not be “EDS“.
	ClusterNames []string `protobuf:"bytes,2,rep,name=cluster_names,json=clusterNames" json:"cluster_names,omitempty"`
	// Multiple gRPC services be provided for GRPC. If > 1 cluster is defined,
	// services will be cycled through if any kind of failure occurs.
	GrpcServices []*GrpcService `protobuf:"bytes,4,rep,name=grpc_services,json=grpcServices" json:"grpc_services,omitempty"`
	// For REST APIs, the delay between successive polls.
	RefreshDelay *time.Duration `protobuf:"bytes,3,opt,name=refresh_delay,json=refreshDelay,stdduration" json:"refresh_delay,omitempty"`
}

API configuration source. This identifies the API type and cluster that Envoy will use to fetch an xDS API.

func (*ApiConfigSource) Descriptor 

func (*ApiConfigSource) Descriptor() ([]byte, []int)

func (*ApiConfigSource) Equal 

func (this *ApiConfigSource) Equal(that interface{}) bool

func (*ApiConfigSource) GetApiType 

func (m *ApiConfigSource) GetApiType() ApiConfigSource_ApiType

func (*ApiConfigSource) GetClusterNames 

func (m *ApiConfigSource) GetClusterNames() []string

func (*ApiConfigSource) GetGrpcServices 

func (m *ApiConfigSource) GetGrpcServices() []*GrpcService

func (*ApiConfigSource) GetRefreshDelay 

func (m *ApiConfigSource) GetRefreshDelay() *time.Duration

func (*ApiConfigSource) Marshal 

func (m *ApiConfigSource) Marshal() (dAtA []byte, err error)

func (*ApiConfigSource) MarshalTo 

func (m *ApiConfigSource) MarshalTo(dAtA []byte) (int, error)

func (*ApiConfigSource) ProtoMessage 

func (*ApiConfigSource) ProtoMessage()

func (*ApiConfigSource) Reset 

func (m *ApiConfigSource) Reset()

func (*ApiConfigSource) Size 

func (m *ApiConfigSource) Size() (n int)

func (*ApiConfigSource) String 

func (m *ApiConfigSource) String() string

func (*ApiConfigSource) Unmarshal 

func (m *ApiConfigSource) Unmarshal(dAtA []byte) error

func (*ApiConfigSource) Validate 

func (m *ApiConfigSource) Validate() error

Validate checks the field values on ApiConfigSource with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type ApiConfigSourceValidationError 

type ApiConfigSourceValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

ApiConfigSourceValidationError is the validation error returned by ApiConfigSource.Validate if the designated constraints aren't met.

func (ApiConfigSourceValidationError) Error 

func (e ApiConfigSourceValidationError) Error() string

Error satisfies the builtin error interface

type ApiConfigSource_ApiType 

type ApiConfigSource_ApiType int32

APIs may be fetched via either REST or gRPC. 

const (
	// REST-JSON legacy corresponds to the v1 API.
	ApiConfigSource_REST_LEGACY ApiConfigSource_ApiType = 0
	// REST-JSON v2 API. The `canonical JSON encoding
	// <https://developers.google.com/protocol-buffers/docs/proto3#json>`_ for
	// the v2 protos is used.
	ApiConfigSource_REST ApiConfigSource_ApiType = 1
	// gRPC v2 API.
	ApiConfigSource_GRPC ApiConfigSource_ApiType = 2
)

func (ApiConfigSource_ApiType) EnumDescriptor 

func (ApiConfigSource_ApiType) EnumDescriptor() ([]byte, []int)

func (ApiConfigSource_ApiType) String 

func (x ApiConfigSource_ApiType) String() string

type BindConfig 

type BindConfig struct {
	// The address to bind to when creating a socket.
	SourceAddress SocketAddress `protobuf:"bytes,1,opt,name=source_address,json=sourceAddress" json:"source_address"`
	// Whether to set the *IP_FREEBIND* option when creating the socket. When this
	// flag is set to true, allows the :ref:`source_address
	// <envoy_api_field_UpstreamBindConfig.source_address>` to be an IP address
	// that is not configured on the system running Envoy. When this flag is set
	// to false, the option *IP_FREEBIND* is disabled on the socket. When this
	// flag is not set (default), the socket is not modified, i.e. the option is
	// neither enabled nor disabled.
	Freebind *google_protobuf1.BoolValue `protobuf:"bytes,2,opt,name=freebind" json:"freebind,omitempty"`
	// Additional socket options that may not be present in Envoy source code or
	// precompiled binaries.
	SocketOptions []*SocketOption `protobuf:"bytes,3,rep,name=socket_options,json=socketOptions" json:"socket_options,omitempty"`
}

func (*BindConfig) Descriptor 

func (*BindConfig) Descriptor() ([]byte, []int)

func (*BindConfig) Equal 

func (this *BindConfig) Equal(that interface{}) bool

func (*BindConfig) GetFreebind 

func (m *BindConfig) GetFreebind() *google_protobuf1.BoolValue

func (*BindConfig) GetSocketOptions 

func (m *BindConfig) GetSocketOptions() []*SocketOption

func (*BindConfig) GetSourceAddress 

func (m *BindConfig) GetSourceAddress() SocketAddress

func (*BindConfig) Marshal 

func (m *BindConfig) Marshal() (dAtA []byte, err error)

func (*BindConfig) MarshalTo 

func (m *BindConfig) MarshalTo(dAtA []byte) (int, error)

func (*BindConfig) ProtoMessage 

func (*BindConfig) ProtoMessage()

func (*BindConfig) Reset 

func (m *BindConfig) Reset()

func (*BindConfig) Size 

func (m *BindConfig) Size() (n int)

func (*BindConfig) String 

func (m *BindConfig) String() string

func (*BindConfig) Unmarshal 

func (m *BindConfig) Unmarshal(dAtA []byte) error

func (*BindConfig) Validate 

func (m *BindConfig) Validate() error

Validate checks the field values on BindConfig with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type BindConfigValidationError 

type BindConfigValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

BindConfigValidationError is the validation error returned by BindConfig.Validate if the designated constraints aren't met.

func (BindConfigValidationError) Error 

func (e BindConfigValidationError) Error() string

Error satisfies the builtin error interface

type CidrRange 

type CidrRange struct {
	// IPv4 or IPv6 address, e.g. “192.0.0.0“ or “2001:db8::“.
	AddressPrefix string `protobuf:"bytes,1,opt,name=address_prefix,json=addressPrefix,proto3" json:"address_prefix,omitempty"`
	// Length of prefix, e.g. 0, 32.
	PrefixLen *google_protobuf1.UInt32Value `protobuf:"bytes,2,opt,name=prefix_len,json=prefixLen" json:"prefix_len,omitempty"`
}

CidrRange specifies an IP Address and a prefix length to construct the subnet mask for a `CIDR <https://tools.ietf.org/html/rfc4632>`_ range.

func (*CidrRange) Descriptor 

func (*CidrRange) Descriptor() ([]byte, []int)

func (*CidrRange) Equal 

func (this *CidrRange) Equal(that interface{}) bool

func (*CidrRange) GetAddressPrefix 

func (m *CidrRange) GetAddressPrefix() string

func (*CidrRange) GetPrefixLen 

func (m *CidrRange) GetPrefixLen() *google_protobuf1.UInt32Value

func (*CidrRange) Marshal 

func (m *CidrRange) Marshal() (dAtA []byte, err error)

func (*CidrRange) MarshalTo 

func (m *CidrRange) MarshalTo(dAtA []byte) (int, error)

func (*CidrRange) ProtoMessage 

func (*CidrRange) ProtoMessage()

func (*CidrRange) Reset 

func (m *CidrRange) Reset()

func (*CidrRange) Size 

func (m *CidrRange) Size() (n int)

func (*CidrRange) String 

func (m *CidrRange) String() string

func (*CidrRange) Unmarshal 

func (m *CidrRange) Unmarshal(dAtA []byte) error

func (*CidrRange) Validate 

func (m *CidrRange) Validate() error

Validate checks the field values on CidrRange with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type CidrRangeValidationError 

type CidrRangeValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

CidrRangeValidationError is the validation error returned by CidrRange.Validate if the designated constraints aren't met.

func (CidrRangeValidationError) Error 

func (e CidrRangeValidationError) Error() string

Error satisfies the builtin error interface

type ConfigSource 

type ConfigSource struct {
	// Types that are valid to be assigned to ConfigSourceSpecifier:
	//	*ConfigSource_Path
	//	*ConfigSource_ApiConfigSource
	//	*ConfigSource_Ads
	ConfigSourceSpecifier isConfigSource_ConfigSourceSpecifier `protobuf_oneof:"config_source_specifier"`
}

Configuration for :ref:`listeners <config_listeners>`, :ref:`clusters <config_cluster_manager_cluster>`, :ref:`routes <config_http_conn_man_route_table>`, :ref:`endpoints <arch_overview_service_discovery>` etc. may either be sourced from the filesystem or from an xDS API source. Filesystem configs are watched with inotify for updates.

func (*ConfigSource) Descriptor 

func (*ConfigSource) Descriptor() ([]byte, []int)

func (*ConfigSource) Equal 

func (this *ConfigSource) Equal(that interface{}) bool

func (*ConfigSource) GetAds 

func (m *ConfigSource) GetAds() *AggregatedConfigSource

func (*ConfigSource) GetApiConfigSource 

func (m *ConfigSource) GetApiConfigSource() *ApiConfigSource

func (*ConfigSource) GetConfigSourceSpecifier 

func (m *ConfigSource) GetConfigSourceSpecifier() isConfigSource_ConfigSourceSpecifier

func (*ConfigSource) GetPath 

func (m *ConfigSource) GetPath() string

func (*ConfigSource) Marshal 

func (m *ConfigSource) Marshal() (dAtA []byte, err error)

func (*ConfigSource) MarshalTo 

func (m *ConfigSource) MarshalTo(dAtA []byte) (int, error)

func (*ConfigSource) ProtoMessage 

func (*ConfigSource) ProtoMessage()

func (*ConfigSource) Reset 

func (m *ConfigSource) Reset()

func (*ConfigSource) Size 

func (m *ConfigSource) Size() (n int)

func (*ConfigSource) String 

func (m *ConfigSource) String() string

func (*ConfigSource) Unmarshal 

func (m *ConfigSource) Unmarshal(dAtA []byte) error

func (*ConfigSource) Validate 

func (m *ConfigSource) Validate() error

Validate checks the field values on ConfigSource with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

func (*ConfigSource) XXX_OneofFuncs 

func (*ConfigSource) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type ConfigSourceValidationError 

type ConfigSourceValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

ConfigSourceValidationError is the validation error returned by ConfigSource.Validate if the designated constraints aren't met.

func (ConfigSourceValidationError) Error 

func (e ConfigSourceValidationError) Error() string

Error satisfies the builtin error interface

type ConfigSource_Ads 

type ConfigSource_Ads struct {
	Ads *AggregatedConfigSource `protobuf:"bytes,3,opt,name=ads,oneof"`
}

func (*ConfigSource_Ads) Equal 

func (this *ConfigSource_Ads) Equal(that interface{}) bool

func (*ConfigSource_Ads) MarshalTo 

func (m *ConfigSource_Ads) MarshalTo(dAtA []byte) (int, error)

func (*ConfigSource_Ads) Size 

func (m *ConfigSource_Ads) Size() (n int)

type ConfigSource_ApiConfigSource 

type ConfigSource_ApiConfigSource struct {
	ApiConfigSource *ApiConfigSource `protobuf:"bytes,2,opt,name=api_config_source,json=apiConfigSource,oneof"`
}

func (*ConfigSource_ApiConfigSource) Equal 

func (this *ConfigSource_ApiConfigSource) Equal(that interface{}) bool

func (*ConfigSource_ApiConfigSource) MarshalTo 

func (m *ConfigSource_ApiConfigSource) MarshalTo(dAtA []byte) (int, error)

func (*ConfigSource_ApiConfigSource) Size 

func (m *ConfigSource_ApiConfigSource) Size() (n int)

type ConfigSource_Path 

type ConfigSource_Path struct {
	Path string `protobuf:"bytes,1,opt,name=path,proto3,oneof"`
}

func (*ConfigSource_Path) Equal 

func (this *ConfigSource_Path) Equal(that interface{}) bool

func (*ConfigSource_Path) MarshalTo 

func (m *ConfigSource_Path) MarshalTo(dAtA []byte) (int, error)

func (*ConfigSource_Path) Size 

func (m *ConfigSource_Path) Size() (n int)

type DataSource 

type DataSource struct {
	// Types that are valid to be assigned to Specifier:
	//	*DataSource_Filename
	//	*DataSource_InlineBytes
	//	*DataSource_InlineString
	Specifier isDataSource_Specifier `protobuf_oneof:"specifier"`
}

Data source consisting of either a file or an inline value.

func (*DataSource) Descriptor 

func (*DataSource) Descriptor() ([]byte, []int)

func (*DataSource) Equal 

func (this *DataSource) Equal(that interface{}) bool

func (*DataSource) GetFilename 

func (m *DataSource) GetFilename() string

func (*DataSource) GetInlineBytes 

func (m *DataSource) GetInlineBytes() []byte

func (*DataSource) GetInlineString 

func (m *DataSource) GetInlineString() string

func (*DataSource) GetSpecifier 

func (m *DataSource) GetSpecifier() isDataSource_Specifier

func (*DataSource) Marshal 

func (m *DataSource) Marshal() (dAtA []byte, err error)

func (*DataSource) MarshalTo 

func (m *DataSource) MarshalTo(dAtA []byte) (int, error)

func (*DataSource) ProtoMessage 

func (*DataSource) ProtoMessage()

func (*DataSource) Reset 

func (m *DataSource) Reset()

func (*DataSource) Size 

func (m *DataSource) Size() (n int)

func (*DataSource) String 

func (m *DataSource) String() string

func (*DataSource) Unmarshal 

func (m *DataSource) Unmarshal(dAtA []byte) error

func (*DataSource) Validate 

func (m *DataSource) Validate() error

Validate checks the field values on DataSource with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

func (*DataSource) XXX_OneofFuncs 

func (*DataSource) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type DataSourceValidationError 

type DataSourceValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

DataSourceValidationError is the validation error returned by DataSource.Validate if the designated constraints aren't met.

func (DataSourceValidationError) Error 

func (e DataSourceValidationError) Error() string

Error satisfies the builtin error interface

type DataSource_Filename 

type DataSource_Filename struct {
	Filename string `protobuf:"bytes,1,opt,name=filename,proto3,oneof"`
}

func (*DataSource_Filename) Equal 

func (this *DataSource_Filename) Equal(that interface{}) bool

func (*DataSource_Filename) MarshalTo 

func (m *DataSource_Filename) MarshalTo(dAtA []byte) (int, error)

func (*DataSource_Filename) Size 

func (m *DataSource_Filename) Size() (n int)

type DataSource_InlineBytes 

type DataSource_InlineBytes struct {
	InlineBytes []byte `protobuf:"bytes,2,opt,name=inline_bytes,json=inlineBytes,proto3,oneof"`
}

func (*DataSource_InlineBytes) Equal 

func (this *DataSource_InlineBytes) Equal(that interface{}) bool

func (*DataSource_InlineBytes) MarshalTo 

func (m *DataSource_InlineBytes) MarshalTo(dAtA []byte) (int, error)

func (*DataSource_InlineBytes) Size 

func (m *DataSource_InlineBytes) Size() (n int)

type DataSource_InlineString 

type DataSource_InlineString struct {
	InlineString string `protobuf:"bytes,3,opt,name=inline_string,json=inlineString,proto3,oneof"`
}

func (*DataSource_InlineString) Equal 

func (this *DataSource_InlineString) Equal(that interface{}) bool

func (*DataSource_InlineString) MarshalTo 

func (m *DataSource_InlineString) MarshalTo(dAtA []byte) (int, error)

func (*DataSource_InlineString) Size 

func (m *DataSource_InlineString) Size() (n int)

type GrpcProtocolOptions 

type GrpcProtocolOptions struct {
	Http2ProtocolOptions *Http2ProtocolOptions `protobuf:"bytes,1,opt,name=http2_protocol_options,json=http2ProtocolOptions" json:"http2_protocol_options,omitempty"`
}

[#not-implemented-hide:]

func (*GrpcProtocolOptions) Descriptor 

func (*GrpcProtocolOptions) Descriptor() ([]byte, []int)

func (*GrpcProtocolOptions) Equal 

func (this *GrpcProtocolOptions) Equal(that interface{}) bool

func (*GrpcProtocolOptions) GetHttp2ProtocolOptions 

func (m *GrpcProtocolOptions) GetHttp2ProtocolOptions() *Http2ProtocolOptions

func (*GrpcProtocolOptions) Marshal 

func (m *GrpcProtocolOptions) Marshal() (dAtA []byte, err error)

func (*GrpcProtocolOptions) MarshalTo 

func (m *GrpcProtocolOptions) MarshalTo(dAtA []byte) (int, error)

func (*GrpcProtocolOptions) ProtoMessage 

func (*GrpcProtocolOptions) ProtoMessage()

func (*GrpcProtocolOptions) Reset 

func (m *GrpcProtocolOptions) Reset()

func (*GrpcProtocolOptions) Size 

func (m *GrpcProtocolOptions) Size() (n int)

func (*GrpcProtocolOptions) String 

func (m *GrpcProtocolOptions) String() string

func (*GrpcProtocolOptions) Unmarshal 

func (m *GrpcProtocolOptions) Unmarshal(dAtA []byte) error

func (*GrpcProtocolOptions) Validate 

func (m *GrpcProtocolOptions) Validate() error

Validate checks the field values on GrpcProtocolOptions with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type GrpcProtocolOptionsValidationError 

type GrpcProtocolOptionsValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

GrpcProtocolOptionsValidationError is the validation error returned by GrpcProtocolOptions.Validate if the designated constraints aren't met.

func (GrpcProtocolOptionsValidationError) Error 

func (e GrpcProtocolOptionsValidationError) Error() string

Error satisfies the builtin error interface

type GrpcService 

type GrpcService struct {
	// Types that are valid to be assigned to TargetSpecifier:
	//	*GrpcService_EnvoyGrpc_
	//	*GrpcService_GoogleGrpc_
	TargetSpecifier isGrpcService_TargetSpecifier `protobuf_oneof:"target_specifier"`
	// The timeout for the gRPC request. This is the timeout for a specific
	// request.
	Timeout *google_protobuf3.Duration `protobuf:"bytes,3,opt,name=timeout" json:"timeout,omitempty"`
	// Additional metadata to include in streams initiated to the GrpcService.
	// This can be used for scenarios in which additional ad hoc authorization
	// headers (e.g. `x-foo-bar: baz-key`) are to be injected.
	InitialMetadata []*HeaderValue `protobuf:"bytes,5,rep,name=initial_metadata,json=initialMetadata" json:"initial_metadata,omitempty"`
}

gRPC service configuration. This is used by :ref:`ApiConfigSource <envoy_api_msg_core.ApiConfigSource>` and filter configurations.

func (*GrpcService) Descriptor 

func (*GrpcService) Descriptor() ([]byte, []int)

func (*GrpcService) Equal 

func (this *GrpcService) Equal(that interface{}) bool

func (*GrpcService) GetEnvoyGrpc 

func (m *GrpcService) GetEnvoyGrpc() *GrpcService_EnvoyGrpc

func (*GrpcService) GetGoogleGrpc 

func (m *GrpcService) GetGoogleGrpc() *GrpcService_GoogleGrpc

func (*GrpcService) GetInitialMetadata 

func (m *GrpcService) GetInitialMetadata() []*HeaderValue

func (*GrpcService) GetTargetSpecifier 

func (m *GrpcService) GetTargetSpecifier() isGrpcService_TargetSpecifier

func (*GrpcService) GetTimeout 

func (m *GrpcService) GetTimeout() *google_protobuf3.Duration

func (*GrpcService) Marshal 

func (m *GrpcService) Marshal() (dAtA []byte, err error)

func (*GrpcService) MarshalTo 

func (m *GrpcService) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService) ProtoMessage 

func (*GrpcService) ProtoMessage()

func (*GrpcService) Reset 

func (m *GrpcService) Reset()

func (*GrpcService) Size 

func (m *GrpcService) Size() (n int)

func (*GrpcService) String 

func (m *GrpcService) String() string

func (*GrpcService) Unmarshal 

func (m *GrpcService) Unmarshal(dAtA []byte) error

func (*GrpcService) Validate 

func (m *GrpcService) Validate() error

Validate checks the field values on GrpcService with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

func (*GrpcService) XXX_OneofFuncs 

func (*GrpcService) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type GrpcServiceValidationError 

type GrpcServiceValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

GrpcServiceValidationError is the validation error returned by GrpcService.Validate if the designated constraints aren't met.

func (GrpcServiceValidationError) Error 

func (e GrpcServiceValidationError) Error() string

Error satisfies the builtin error interface

type GrpcService_EnvoyGrpc 

type GrpcService_EnvoyGrpc struct {
	// The name of the upstream gRPC cluster. SSL credentials will be supplied
	// in the :ref:`Cluster <envoy_api_msg_Cluster>` :ref:`tls_context
	// <envoy_api_field_Cluster.tls_context>`.
	ClusterName string `protobuf:"bytes,1,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"`
}

func (*GrpcService_EnvoyGrpc) Descriptor 

func (*GrpcService_EnvoyGrpc) Descriptor() ([]byte, []int)

func (*GrpcService_EnvoyGrpc) Equal 

func (this *GrpcService_EnvoyGrpc) Equal(that interface{}) bool

func (*GrpcService_EnvoyGrpc) GetClusterName 

func (m *GrpcService_EnvoyGrpc) GetClusterName() string

func (*GrpcService_EnvoyGrpc) Marshal 

func (m *GrpcService_EnvoyGrpc) Marshal() (dAtA []byte, err error)

func (*GrpcService_EnvoyGrpc) MarshalTo 

func (m *GrpcService_EnvoyGrpc) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_EnvoyGrpc) ProtoMessage 

func (*GrpcService_EnvoyGrpc) ProtoMessage()

func (*GrpcService_EnvoyGrpc) Reset 

func (m *GrpcService_EnvoyGrpc) Reset()

func (*GrpcService_EnvoyGrpc) Size 

func (m *GrpcService_EnvoyGrpc) Size() (n int)

func (*GrpcService_EnvoyGrpc) String 

func (m *GrpcService_EnvoyGrpc) String() string

func (*GrpcService_EnvoyGrpc) Unmarshal 

func (m *GrpcService_EnvoyGrpc) Unmarshal(dAtA []byte) error

func (*GrpcService_EnvoyGrpc) Validate 

func (m *GrpcService_EnvoyGrpc) Validate() error

Validate checks the field values on GrpcService_EnvoyGrpc with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type GrpcService_EnvoyGrpcValidationError 

type GrpcService_EnvoyGrpcValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

GrpcService_EnvoyGrpcValidationError is the validation error returned by GrpcService_EnvoyGrpc.Validate if the designated constraints aren't met.

func (GrpcService_EnvoyGrpcValidationError) Error 

func (e GrpcService_EnvoyGrpcValidationError) Error() string

Error satisfies the builtin error interface

type GrpcService_EnvoyGrpc_ 

type GrpcService_EnvoyGrpc_ struct {
	EnvoyGrpc *GrpcService_EnvoyGrpc `protobuf:"bytes,1,opt,name=envoy_grpc,json=envoyGrpc,oneof"`
}

func (*GrpcService_EnvoyGrpc_) Equal 

func (this *GrpcService_EnvoyGrpc_) Equal(that interface{}) bool

func (*GrpcService_EnvoyGrpc_) MarshalTo 

func (m *GrpcService_EnvoyGrpc_) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_EnvoyGrpc_) Size 

func (m *GrpcService_EnvoyGrpc_) Size() (n int)

type GrpcService_GoogleGrpc 

type GrpcService_GoogleGrpc struct {
	// The target URI when using the `Google C++ gRPC client
	// <https://github.com/grpc/grpc>`_. SSL credentials will be supplied in
	// :ref:`channel_credentials <envoy_api_field_core.GrpcService.GoogleGrpc.channel_credentials>`.
	TargetUri          string                                     `protobuf:"bytes,1,opt,name=target_uri,json=targetUri,proto3" json:"target_uri,omitempty"`
	ChannelCredentials *GrpcService_GoogleGrpc_ChannelCredentials `protobuf:"bytes,2,opt,name=channel_credentials,json=channelCredentials" json:"channel_credentials,omitempty"`
	// A set of call credentials that can be composed with `channel credentials
	// <https://grpc.io/docs/guides/auth.html#credential-types>`_.
	CallCredentials []*GrpcService_GoogleGrpc_CallCredentials `protobuf:"bytes,3,rep,name=call_credentials,json=callCredentials" json:"call_credentials,omitempty"`
	// The human readable prefix to use when emitting statistics for the gRPC
	// service.
	//
	// .. csv-table::
	//    :header: Name, Type, Description
	//    :widths: 1, 1, 2
	//
	//    streams_total, Counter, Total number of streams opened
	//    streams_closed_<gRPC status code>, Counter, Total streams closed with <gRPC status code>
	StatPrefix string `protobuf:"bytes,4,opt,name=stat_prefix,json=statPrefix,proto3" json:"stat_prefix,omitempty"`
	// The name of the Google gRPC credentials factory to use. This must have been registered with
	// Envoy. If this is empty, a default credentials factory will be used that sets up channel
	// credentials based on other configuration parameters.
	CredentialsFactoryName string `` /* 129-byte string literal not displayed */
	// Additional configuration for site-specific customizations of the Google
	// gRPC library.
	Config *google_protobuf.Struct `protobuf:"bytes,6,opt,name=config" json:"config,omitempty"`
}

[#proto-status: draft]

func (*GrpcService_GoogleGrpc) Descriptor 

func (*GrpcService_GoogleGrpc) Descriptor() ([]byte, []int)

func (*GrpcService_GoogleGrpc) Equal 

func (this *GrpcService_GoogleGrpc) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc) GetCallCredentials 

func (m *GrpcService_GoogleGrpc) GetCallCredentials() []*GrpcService_GoogleGrpc_CallCredentials

func (*GrpcService_GoogleGrpc) GetChannelCredentials 

func (m *GrpcService_GoogleGrpc) GetChannelCredentials() *GrpcService_GoogleGrpc_ChannelCredentials

func (*GrpcService_GoogleGrpc) GetConfig 

func (m *GrpcService_GoogleGrpc) GetConfig() *google_protobuf.Struct

func (*GrpcService_GoogleGrpc) GetCredentialsFactoryName 

func (m *GrpcService_GoogleGrpc) GetCredentialsFactoryName() string

func (*GrpcService_GoogleGrpc) GetStatPrefix 

func (m *GrpcService_GoogleGrpc) GetStatPrefix() string

func (*GrpcService_GoogleGrpc) GetTargetUri 

func (m *GrpcService_GoogleGrpc) GetTargetUri() string

func (*GrpcService_GoogleGrpc) Marshal 

func (m *GrpcService_GoogleGrpc) Marshal() (dAtA []byte, err error)

func (*GrpcService_GoogleGrpc) MarshalTo 

func (m *GrpcService_GoogleGrpc) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc) ProtoMessage 

func (*GrpcService_GoogleGrpc) ProtoMessage()

func (*GrpcService_GoogleGrpc) Reset 

func (m *GrpcService_GoogleGrpc) Reset()

func (*GrpcService_GoogleGrpc) Size 

func (m *GrpcService_GoogleGrpc) Size() (n int)

func (*GrpcService_GoogleGrpc) String 

func (m *GrpcService_GoogleGrpc) String() string

func (*GrpcService_GoogleGrpc) Unmarshal 

func (m *GrpcService_GoogleGrpc) Unmarshal(dAtA []byte) error

func (*GrpcService_GoogleGrpc) Validate 

func (m *GrpcService_GoogleGrpc) Validate() error

Validate checks the field values on GrpcService_GoogleGrpc with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type GrpcService_GoogleGrpcValidationError 

type GrpcService_GoogleGrpcValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

GrpcService_GoogleGrpcValidationError is the validation error returned by GrpcService_GoogleGrpc.Validate if the designated constraints aren't met.

func (GrpcService_GoogleGrpcValidationError) Error 

func (e GrpcService_GoogleGrpcValidationError) Error() string

Error satisfies the builtin error interface

type GrpcService_GoogleGrpc_ 

type GrpcService_GoogleGrpc_ struct {
	GoogleGrpc *GrpcService_GoogleGrpc `protobuf:"bytes,2,opt,name=google_grpc,json=googleGrpc,oneof"`
}

func (*GrpcService_GoogleGrpc_) Equal 

func (this *GrpcService_GoogleGrpc_) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_) MarshalTo 

func (m *GrpcService_GoogleGrpc_) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_) Size 

func (m *GrpcService_GoogleGrpc_) Size() (n int)

type GrpcService_GoogleGrpc_CallCredentials 

type GrpcService_GoogleGrpc_CallCredentials struct {
	// Types that are valid to be assigned to CredentialSpecifier:
	//	*GrpcService_GoogleGrpc_CallCredentials_AccessToken
	//	*GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine
	//	*GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken
	//	*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess
	//	*GrpcService_GoogleGrpc_CallCredentials_GoogleIam
	//	*GrpcService_GoogleGrpc_CallCredentials_FromPlugin
	CredentialSpecifier isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier `protobuf_oneof:"credential_specifier"`
}

func (*GrpcService_GoogleGrpc_CallCredentials) Descriptor 

func (*GrpcService_GoogleGrpc_CallCredentials) Descriptor() ([]byte, []int)

func (*GrpcService_GoogleGrpc_CallCredentials) Equal 

func (this *GrpcService_GoogleGrpc_CallCredentials) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_CallCredentials) GetAccessToken 

func (m *GrpcService_GoogleGrpc_CallCredentials) GetAccessToken() string

func (*GrpcService_GoogleGrpc_CallCredentials) GetCredentialSpecifier 

func (m *GrpcService_GoogleGrpc_CallCredentials) GetCredentialSpecifier() isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier

func (*GrpcService_GoogleGrpc_CallCredentials) GetFromPlugin 

func (m *GrpcService_GoogleGrpc_CallCredentials) GetFromPlugin() *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin

func (*GrpcService_GoogleGrpc_CallCredentials) GetGoogleComputeEngine 

func (m *GrpcService_GoogleGrpc_CallCredentials) GetGoogleComputeEngine() *google_protobuf5.Empty

func (*GrpcService_GoogleGrpc_CallCredentials) GetGoogleIam 

func (m *GrpcService_GoogleGrpc_CallCredentials) GetGoogleIam() *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials

func (*GrpcService_GoogleGrpc_CallCredentials) GetGoogleRefreshToken 

func (m *GrpcService_GoogleGrpc_CallCredentials) GetGoogleRefreshToken() string

func (*GrpcService_GoogleGrpc_CallCredentials) GetServiceAccountJwtAccess 

func (m *GrpcService_GoogleGrpc_CallCredentials) GetServiceAccountJwtAccess() *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials

func (*GrpcService_GoogleGrpc_CallCredentials) Marshal 

func (m *GrpcService_GoogleGrpc_CallCredentials) Marshal() (dAtA []byte, err error)

func (*GrpcService_GoogleGrpc_CallCredentials) MarshalTo 

func (m *GrpcService_GoogleGrpc_CallCredentials) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_CallCredentials) ProtoMessage 

func (*GrpcService_GoogleGrpc_CallCredentials) ProtoMessage()

func (*GrpcService_GoogleGrpc_CallCredentials) Reset 

func (m *GrpcService_GoogleGrpc_CallCredentials) Reset()

func (*GrpcService_GoogleGrpc_CallCredentials) Size 

func (m *GrpcService_GoogleGrpc_CallCredentials) Size() (n int)

func (*GrpcService_GoogleGrpc_CallCredentials) String 

func (m *GrpcService_GoogleGrpc_CallCredentials) String() string

func (*GrpcService_GoogleGrpc_CallCredentials) Unmarshal 

func (m *GrpcService_GoogleGrpc_CallCredentials) Unmarshal(dAtA []byte) error

func (*GrpcService_GoogleGrpc_CallCredentials) Validate 

func (m *GrpcService_GoogleGrpc_CallCredentials) Validate() error

Validate checks the field values on GrpcService_GoogleGrpc_CallCredentials with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

func (*GrpcService_GoogleGrpc_CallCredentials) XXX_OneofFuncs 

func (*GrpcService_GoogleGrpc_CallCredentials) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type GrpcService_GoogleGrpc_CallCredentialsValidationError 

type GrpcService_GoogleGrpc_CallCredentialsValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

GrpcService_GoogleGrpc_CallCredentialsValidationError is the validation error returned by GrpcService_GoogleGrpc_CallCredentials.Validate if the designated constraints aren't met.

func (GrpcService_GoogleGrpc_CallCredentialsValidationError) Error 

func (e GrpcService_GoogleGrpc_CallCredentialsValidationError) Error() string

Error satisfies the builtin error interface

type GrpcService_GoogleGrpc_CallCredentials_AccessToken 

type GrpcService_GoogleGrpc_CallCredentials_AccessToken struct {
	AccessToken string `protobuf:"bytes,1,opt,name=access_token,json=accessToken,proto3,oneof"`
}

func (*GrpcService_GoogleGrpc_CallCredentials_AccessToken) Equal 

func (this *GrpcService_GoogleGrpc_CallCredentials_AccessToken) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_CallCredentials_AccessToken) MarshalTo 

func (m *GrpcService_GoogleGrpc_CallCredentials_AccessToken) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_CallCredentials_AccessToken) Size 

func (m *GrpcService_GoogleGrpc_CallCredentials_AccessToken) Size() (n int)

type GrpcService_GoogleGrpc_CallCredentials_FromPlugin 

type GrpcService_GoogleGrpc_CallCredentials_FromPlugin struct {
	FromPlugin *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin `protobuf:"bytes,6,opt,name=from_plugin,json=fromPlugin,oneof"`
}

func (*GrpcService_GoogleGrpc_CallCredentials_FromPlugin) Equal 

func (this *GrpcService_GoogleGrpc_CallCredentials_FromPlugin) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_CallCredentials_FromPlugin) MarshalTo 

func (m *GrpcService_GoogleGrpc_CallCredentials_FromPlugin) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_CallCredentials_FromPlugin) Size 

func (m *GrpcService_GoogleGrpc_CallCredentials_FromPlugin) Size() (n int)

type GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine 

type GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine struct {
	GoogleComputeEngine *google_protobuf5.Empty `protobuf:"bytes,2,opt,name=google_compute_engine,json=googleComputeEngine,oneof"`
}

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine) Equal 

func (this *GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine) MarshalTo 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine) Size 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine) Size() (n int)

type GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials 

type GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials struct {
	AuthorizationToken string `protobuf:"bytes,1,opt,name=authorization_token,json=authorizationToken,proto3" json:"authorization_token,omitempty"`
	AuthoritySelector  string `protobuf:"bytes,2,opt,name=authority_selector,json=authoritySelector,proto3" json:"authority_selector,omitempty"`
}

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Descriptor 

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Descriptor() ([]byte, []int)

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Equal 

func (this *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) GetAuthoritySelector 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) GetAuthoritySelector() string

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) GetAuthorizationToken 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) GetAuthorizationToken() string

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Marshal 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Marshal() (dAtA []byte, err error)

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) MarshalTo 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) ProtoMessage 

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) ProtoMessage()

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Reset 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Reset()

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Size 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Size() (n int)

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) String 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) String() string

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Unmarshal 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Unmarshal(dAtA []byte) error

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Validate 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Validate() error

Validate checks the field values on GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentialsValidationError 

type GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentialsValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentialsValidationError is the validation error returned by GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials.Validate if the designated constraints aren't met.

func (GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentialsValidationError) Error 

func (e GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentialsValidationError) Error() string

Error satisfies the builtin error interface

type GrpcService_GoogleGrpc_CallCredentials_GoogleIam 

type GrpcService_GoogleGrpc_CallCredentials_GoogleIam struct {
	GoogleIam *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials `protobuf:"bytes,5,opt,name=google_iam,json=googleIam,oneof"`
}

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIam) Equal 

func (this *GrpcService_GoogleGrpc_CallCredentials_GoogleIam) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIam) MarshalTo 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleIam) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIam) Size 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleIam) Size() (n int)

type GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken 

type GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken struct {
	GoogleRefreshToken string `protobuf:"bytes,3,opt,name=google_refresh_token,json=googleRefreshToken,proto3,oneof"`
}

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken) Equal 

func (this *GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken) MarshalTo 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken) Size 

func (m *GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken) Size() (n int)

type GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin 

type GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin struct {
	Name   string                  `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Config *google_protobuf.Struct `protobuf:"bytes,2,opt,name=config" json:"config,omitempty"`
}

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Descriptor 

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Descriptor() ([]byte, []int)

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Equal 

func (this *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) GetConfig 

func (m *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) GetConfig() *google_protobuf.Struct

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) GetName 

func (m *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) GetName() string

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Marshal 

func (m *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Marshal() (dAtA []byte, err error)

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) MarshalTo 

func (m *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) ProtoMessage 

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) ProtoMessage()

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Reset 

func (m *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Reset()

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Size 

func (m *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Size() (n int)

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) String 

func (m *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) String() string

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Unmarshal 

func (m *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Unmarshal(dAtA []byte) error

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Validate 

func (m *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Validate() error

Validate checks the field values on GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPluginValidationError 

type GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPluginValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPluginValidationError is the validation error returned by GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin.Validate if the designated constraints aren't met.

func (GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPluginValidationError) Error 

func (e GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPluginValidationError) Error() string

Error satisfies the builtin error interface

type GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials 

type GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials struct {
	JsonKey              string `protobuf:"bytes,1,opt,name=json_key,json=jsonKey,proto3" json:"json_key,omitempty"`
	TokenLifetimeSeconds uint64 `protobuf:"varint,2,opt,name=token_lifetime_seconds,json=tokenLifetimeSeconds,proto3" json:"token_lifetime_seconds,omitempty"`
}

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Descriptor 

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Descriptor() ([]byte, []int)

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Equal 

func (this *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) GetJsonKey 

func (m *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) GetJsonKey() string

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) GetTokenLifetimeSeconds 

func (m *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) GetTokenLifetimeSeconds() uint64

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Marshal 

func (m *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Marshal() (dAtA []byte, err error)

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) MarshalTo 

func (m *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) ProtoMessage 

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) ProtoMessage()

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Reset 

func (m *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Reset()

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Size 

func (m *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Size() (n int)

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) String 

func (m *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) String() string

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Unmarshal 

func (m *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Unmarshal(dAtA []byte) error

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Validate 

func (m *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Validate() error

Validate checks the field values on GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentialsValidationError 

type GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentialsValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentialsValidationError is the validation error returned by GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials.Validate if the designated constraints aren't met.

func (GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentialsValidationError) Error 

func (e GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentialsValidationError) Error() string

Error satisfies the builtin error interface

type GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess 

type GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess struct {
	ServiceAccountJwtAccess *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials `protobuf:"bytes,4,opt,name=service_account_jwt_access,json=serviceAccountJwtAccess,oneof"`
}

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess) Equal 

func (this *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess) MarshalTo 

func (m *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess) Size 

func (m *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess) Size() (n int)

type GrpcService_GoogleGrpc_ChannelCredentials 

type GrpcService_GoogleGrpc_ChannelCredentials struct {
	// Types that are valid to be assigned to CredentialSpecifier:
	//	*GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials
	//	*GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault
	CredentialSpecifier isGrpcService_GoogleGrpc_ChannelCredentials_CredentialSpecifier `protobuf_oneof:"credential_specifier"`
}

See https://grpc.io/docs/guides/auth.html#credential-types to understand Channel and Call credential types.

func (*GrpcService_GoogleGrpc_ChannelCredentials) Descriptor 

func (*GrpcService_GoogleGrpc_ChannelCredentials) Descriptor() ([]byte, []int)

func (*GrpcService_GoogleGrpc_ChannelCredentials) Equal 

func (this *GrpcService_GoogleGrpc_ChannelCredentials) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_ChannelCredentials) GetCredentialSpecifier 

func (m *GrpcService_GoogleGrpc_ChannelCredentials) GetCredentialSpecifier() isGrpcService_GoogleGrpc_ChannelCredentials_CredentialSpecifier

func (*GrpcService_GoogleGrpc_ChannelCredentials) GetGoogleDefault 

func (m *GrpcService_GoogleGrpc_ChannelCredentials) GetGoogleDefault() *google_protobuf5.Empty

func (*GrpcService_GoogleGrpc_ChannelCredentials) GetSslCredentials 

func (m *GrpcService_GoogleGrpc_ChannelCredentials) GetSslCredentials() *GrpcService_GoogleGrpc_SslCredentials

func (*GrpcService_GoogleGrpc_ChannelCredentials) Marshal 

func (m *GrpcService_GoogleGrpc_ChannelCredentials) Marshal() (dAtA []byte, err error)

func (*GrpcService_GoogleGrpc_ChannelCredentials) MarshalTo 

func (m *GrpcService_GoogleGrpc_ChannelCredentials) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_ChannelCredentials) ProtoMessage 

func (*GrpcService_GoogleGrpc_ChannelCredentials) ProtoMessage()

func (*GrpcService_GoogleGrpc_ChannelCredentials) Reset 

func (m *GrpcService_GoogleGrpc_ChannelCredentials) Reset()

func (*GrpcService_GoogleGrpc_ChannelCredentials) Size 

func (m *GrpcService_GoogleGrpc_ChannelCredentials) Size() (n int)

func (*GrpcService_GoogleGrpc_ChannelCredentials) String 

func (m *GrpcService_GoogleGrpc_ChannelCredentials) String() string

func (*GrpcService_GoogleGrpc_ChannelCredentials) Unmarshal 

func (m *GrpcService_GoogleGrpc_ChannelCredentials) Unmarshal(dAtA []byte) error

func (*GrpcService_GoogleGrpc_ChannelCredentials) Validate 

func (m *GrpcService_GoogleGrpc_ChannelCredentials) Validate() error

Validate checks the field values on GrpcService_GoogleGrpc_ChannelCredentials with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

func (*GrpcService_GoogleGrpc_ChannelCredentials) XXX_OneofFuncs 

func (*GrpcService_GoogleGrpc_ChannelCredentials) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type GrpcService_GoogleGrpc_ChannelCredentialsValidationError 

type GrpcService_GoogleGrpc_ChannelCredentialsValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

GrpcService_GoogleGrpc_ChannelCredentialsValidationError is the validation error returned by GrpcService_GoogleGrpc_ChannelCredentials.Validate if the designated constraints aren't met.

func (GrpcService_GoogleGrpc_ChannelCredentialsValidationError) Error 

func (e GrpcService_GoogleGrpc_ChannelCredentialsValidationError) Error() string

Error satisfies the builtin error interface

type GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault 

type GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault struct {
	GoogleDefault *google_protobuf5.Empty `protobuf:"bytes,2,opt,name=google_default,json=googleDefault,oneof"`
}

func (*GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault) Equal 

func (this *GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault) MarshalTo 

func (m *GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault) Size 

func (m *GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault) Size() (n int)

type GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials 

type GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials struct {
	SslCredentials *GrpcService_GoogleGrpc_SslCredentials `protobuf:"bytes,1,opt,name=ssl_credentials,json=sslCredentials,oneof"`
}

func (*GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials) Equal 

func (this *GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials) MarshalTo 

func (m *GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials) Size 

func (m *GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials) Size() (n int)

type GrpcService_GoogleGrpc_SslCredentials 

type GrpcService_GoogleGrpc_SslCredentials struct {
	// PEM encoded server root certificates.
	RootCerts *DataSource `protobuf:"bytes,1,opt,name=root_certs,json=rootCerts" json:"root_certs,omitempty"`
	// PEM encoded client private key.
	PrivateKey *DataSource `protobuf:"bytes,2,opt,name=private_key,json=privateKey" json:"private_key,omitempty"`
	// PEM encoded client certificate chain.
	CertChain *DataSource `protobuf:"bytes,3,opt,name=cert_chain,json=certChain" json:"cert_chain,omitempty"`
}

See https://grpc.io/grpc/cpp/structgrpc_1_1_ssl_credentials_options.html.

func (*GrpcService_GoogleGrpc_SslCredentials) Descriptor 

func (*GrpcService_GoogleGrpc_SslCredentials) Descriptor() ([]byte, []int)

func (*GrpcService_GoogleGrpc_SslCredentials) Equal 

func (this *GrpcService_GoogleGrpc_SslCredentials) Equal(that interface{}) bool

func (*GrpcService_GoogleGrpc_SslCredentials) GetCertChain 

func (m *GrpcService_GoogleGrpc_SslCredentials) GetCertChain() *DataSource

func (*GrpcService_GoogleGrpc_SslCredentials) GetPrivateKey 

func (m *GrpcService_GoogleGrpc_SslCredentials) GetPrivateKey() *DataSource

func (*GrpcService_GoogleGrpc_SslCredentials) GetRootCerts 

func (m *GrpcService_GoogleGrpc_SslCredentials) GetRootCerts() *DataSource

func (*GrpcService_GoogleGrpc_SslCredentials) Marshal 

func (m *GrpcService_GoogleGrpc_SslCredentials) Marshal() (dAtA []byte, err error)

func (*GrpcService_GoogleGrpc_SslCredentials) MarshalTo 

func (m *GrpcService_GoogleGrpc_SslCredentials) MarshalTo(dAtA []byte) (int, error)

func (*GrpcService_GoogleGrpc_SslCredentials) ProtoMessage 

func (*GrpcService_GoogleGrpc_SslCredentials) ProtoMessage()

func (*GrpcService_GoogleGrpc_SslCredentials) Reset 

func (m *GrpcService_GoogleGrpc_SslCredentials) Reset()

func (*GrpcService_GoogleGrpc_SslCredentials) Size 

func (m *GrpcService_GoogleGrpc_SslCredentials) Size() (n int)

func (*GrpcService_GoogleGrpc_SslCredentials) String 

func (m *GrpcService_GoogleGrpc_SslCredentials) String() string

func (*GrpcService_GoogleGrpc_SslCredentials) Unmarshal 

func (m *GrpcService_GoogleGrpc_SslCredentials) Unmarshal(dAtA []byte) error

func (*GrpcService_GoogleGrpc_SslCredentials) Validate 

func (m *GrpcService_GoogleGrpc_SslCredentials) Validate() error

Validate checks the field values on GrpcService_GoogleGrpc_SslCredentials with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type GrpcService_GoogleGrpc_SslCredentialsValidationError 

type GrpcService_GoogleGrpc_SslCredentialsValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

GrpcService_GoogleGrpc_SslCredentialsValidationError is the validation error returned by GrpcService_GoogleGrpc_SslCredentials.Validate if the designated constraints aren't met.

func (GrpcService_GoogleGrpc_SslCredentialsValidationError) Error 

func (e GrpcService_GoogleGrpc_SslCredentialsValidationError) Error() string

Error satisfies the builtin error interface

type HeaderValue 

type HeaderValue struct {
	// Header name.
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// Header value.
	//
	// The same :ref:`format specifier <config_access_log_format>` as used for
	// :ref:`HTTP access logging <config_access_log>` applies here, however
	// unknown header values are replaced with the empty string instead of `-`.
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

Header name/value pair.

func (*HeaderValue) Descriptor 

func (*HeaderValue) Descriptor() ([]byte, []int)

func (*HeaderValue) Equal 

func (this *HeaderValue) Equal(that interface{}) bool

func (*HeaderValue) GetKey 

func (m *HeaderValue) GetKey() string

func (*HeaderValue) GetValue 

func (m *HeaderValue) GetValue() string

func (*HeaderValue) Marshal 

func (m *HeaderValue) Marshal() (dAtA []byte, err error)

func (*HeaderValue) MarshalTo 

func (m *HeaderValue) MarshalTo(dAtA []byte) (int, error)

func (*HeaderValue) ProtoMessage 

func (*HeaderValue) ProtoMessage()

func (*HeaderValue) Reset 

func (m *HeaderValue) Reset()

func (*HeaderValue) Size 

func (m *HeaderValue) Size() (n int)

func (*HeaderValue) String 

func (m *HeaderValue) String() string

func (*HeaderValue) Unmarshal 

func (m *HeaderValue) Unmarshal(dAtA []byte) error

func (*HeaderValue) Validate 

func (m *HeaderValue) Validate() error

Validate checks the field values on HeaderValue with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type HeaderValueOption 

type HeaderValueOption struct {
	// Header name/value pair that this option applies to.
	Header *HeaderValue `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
	// Should the value be appended? If true (default), the value is appended to
	// existing values.
	Append *google_protobuf1.BoolValue `protobuf:"bytes,2,opt,name=append" json:"append,omitempty"`
}

Header name/value pair plus option to control append behavior.

func (*HeaderValueOption) Descriptor 

func (*HeaderValueOption) Descriptor() ([]byte, []int)

func (*HeaderValueOption) Equal 

func (this *HeaderValueOption) Equal(that interface{}) bool

func (*HeaderValueOption) GetAppend 

func (m *HeaderValueOption) GetAppend() *google_protobuf1.BoolValue

func (*HeaderValueOption) GetHeader 

func (m *HeaderValueOption) GetHeader() *HeaderValue

func (*HeaderValueOption) Marshal 

func (m *HeaderValueOption) Marshal() (dAtA []byte, err error)

func (*HeaderValueOption) MarshalTo 

func (m *HeaderValueOption) MarshalTo(dAtA []byte) (int, error)

func (*HeaderValueOption) ProtoMessage 

func (*HeaderValueOption) ProtoMessage()

func (*HeaderValueOption) Reset 

func (m *HeaderValueOption) Reset()

func (*HeaderValueOption) Size 

func (m *HeaderValueOption) Size() (n int)

func (*HeaderValueOption) String 

func (m *HeaderValueOption) String() string

func (*HeaderValueOption) Unmarshal 

func (m *HeaderValueOption) Unmarshal(dAtA []byte) error

func (*HeaderValueOption) Validate 

func (m *HeaderValueOption) Validate() error

Validate checks the field values on HeaderValueOption with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type HeaderValueOptionValidationError 

type HeaderValueOptionValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

HeaderValueOptionValidationError is the validation error returned by HeaderValueOption.Validate if the designated constraints aren't met.

func (HeaderValueOptionValidationError) Error 

func (e HeaderValueOptionValidationError) Error() string

Error satisfies the builtin error interface

type HeaderValueValidationError 

type HeaderValueValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

HeaderValueValidationError is the validation error returned by HeaderValue.Validate if the designated constraints aren't met.

func (HeaderValueValidationError) Error 

func (e HeaderValueValidationError) Error() string

Error satisfies the builtin error interface

type HealthCheck 

type HealthCheck struct {
	// The time to wait for a health check response. If the timeout is reached the
	// health check attempt will be considered a failure.
	Timeout *time.Duration `protobuf:"bytes,1,opt,name=timeout,stdduration" json:"timeout,omitempty"`
	// The interval between health checks.
	Interval *time.Duration `protobuf:"bytes,2,opt,name=interval,stdduration" json:"interval,omitempty"`
	// An optional jitter amount in millseconds. If specified, during every
	// interval Envoy will add 0 to interval_jitter to the wait time.
	IntervalJitter *google_protobuf3.Duration `protobuf:"bytes,3,opt,name=interval_jitter,json=intervalJitter" json:"interval_jitter,omitempty"`
	// An optional jitter amount as a percentage of interval_ms. If specified,
	// during every interval Envoy will add 0 to interval_ms *
	// interval_jitter_percent / 100 to the wait time.
	//
	// If interval_jitter_ms and interval_jitter_percent are both set, both of
	// them will be used to increase the wait time.
	IntervalJitterPercent uint32 `` /* 128-byte string literal not displayed */
	// The number of unhealthy health checks required before a host is marked
	// unhealthy. Note that for *http* health checking if a host responds with 503
	// this threshold is ignored and the host is considered unhealthy immediately.
	UnhealthyThreshold *google_protobuf1.UInt32Value `protobuf:"bytes,4,opt,name=unhealthy_threshold,json=unhealthyThreshold" json:"unhealthy_threshold,omitempty"`
	// The number of healthy health checks required before a host is marked
	// healthy. Note that during startup, only a single successful health check is
	// required to mark a host healthy.
	HealthyThreshold *google_protobuf1.UInt32Value `protobuf:"bytes,5,opt,name=healthy_threshold,json=healthyThreshold" json:"healthy_threshold,omitempty"`
	// [#not-implemented-hide:] Non-serving port for health checking.
	AltPort *google_protobuf1.UInt32Value `protobuf:"bytes,6,opt,name=alt_port,json=altPort" json:"alt_port,omitempty"`
	// Reuse health check connection between health checks. Default is true.
	ReuseConnection *google_protobuf1.BoolValue `protobuf:"bytes,7,opt,name=reuse_connection,json=reuseConnection" json:"reuse_connection,omitempty"`
	// Types that are valid to be assigned to HealthChecker:
	//	*HealthCheck_HttpHealthCheck_
	//	*HealthCheck_TcpHealthCheck_
	//	*HealthCheck_GrpcHealthCheck_
	//	*HealthCheck_CustomHealthCheck_
	HealthChecker isHealthCheck_HealthChecker `protobuf_oneof:"health_checker"`
	// The "no traffic interval" is a special health check interval that is used when a cluster has
	// never had traffic routed to it. This lower interval allows cluster information to be kept up to
	// date, without sending a potentially large amount of active health checking traffic for no
	// reason. Once a cluster has been used for traffic routing, Envoy will shift back to using the
	// standard health check interval that is defined. Note that this interval takes precedence over
	// any other.
	//
	// The default value for "no traffic interval" is 60 seconds.
	NoTrafficInterval *google_protobuf3.Duration `protobuf:"bytes,12,opt,name=no_traffic_interval,json=noTrafficInterval" json:"no_traffic_interval,omitempty"`
	// The "unhealthy interval" is a health check interval that is used for hosts that are marked as
	// unhealthy. As soon as the host is marked as healthy, Envoy will shift back to using the
	// standard health check interval that is defined.
	//
	// The default value for "unhealthy interval" is the same as "interval".
	UnhealthyInterval *google_protobuf3.Duration `protobuf:"bytes,14,opt,name=unhealthy_interval,json=unhealthyInterval" json:"unhealthy_interval,omitempty"`
	// The "unhealthy edge interval" is a special health check interval that is used for the first
	// health check right after a host is marked as unhealthy. For subsequent health checks
	// Envoy will shift back to using either "unhealthy interval" if present or the standard health
	// check interval that is defined.
	//
	// The default value for "unhealthy edge interval" is the same as "unhealthy interval".
	UnhealthyEdgeInterval *google_protobuf3.Duration `protobuf:"bytes,15,opt,name=unhealthy_edge_interval,json=unhealthyEdgeInterval" json:"unhealthy_edge_interval,omitempty"`
	// The "healthy edge interval" is a special health check interval that is used for the first
	// health check right after a host is marked as healthy. For subsequent health checks
	// Envoy will shift back to using the standard health check interval that is defined.
	//
	// The default value for "healthy edge interval" is the same as the default interval.
	HealthyEdgeInterval *google_protobuf3.Duration `protobuf:"bytes,16,opt,name=healthy_edge_interval,json=healthyEdgeInterval" json:"healthy_edge_interval,omitempty"`
	// Specifies the path to the :ref:`health check event log <arch_overview_health_check_logging>`.
	// If empty, no event log will be written.
	EventLogPath string `protobuf:"bytes,17,opt,name=event_log_path,json=eventLogPath,proto3" json:"event_log_path,omitempty"`
}

func (*HealthCheck) Descriptor 

func (*HealthCheck) Descriptor() ([]byte, []int)

func (*HealthCheck) Equal 

func (this *HealthCheck) Equal(that interface{}) bool

func (*HealthCheck) GetAltPort 

func (m *HealthCheck) GetAltPort() *google_protobuf1.UInt32Value

func (*HealthCheck) GetCustomHealthCheck 

func (m *HealthCheck) GetCustomHealthCheck() *HealthCheck_CustomHealthCheck

func (*HealthCheck) GetEventLogPath 

func (m *HealthCheck) GetEventLogPath() string

func (*HealthCheck) GetGrpcHealthCheck 

func (m *HealthCheck) GetGrpcHealthCheck() *HealthCheck_GrpcHealthCheck

func (*HealthCheck) GetHealthChecker 

func (m *HealthCheck) GetHealthChecker() isHealthCheck_HealthChecker

func (*HealthCheck) GetHealthyEdgeInterval 

func (m *HealthCheck) GetHealthyEdgeInterval() *google_protobuf3.Duration

func (*HealthCheck) GetHealthyThreshold 

func (m *HealthCheck) GetHealthyThreshold() *google_protobuf1.UInt32Value

func (*HealthCheck) GetHttpHealthCheck 

func (m *HealthCheck) GetHttpHealthCheck() *HealthCheck_HttpHealthCheck

func (*HealthCheck) GetInterval 

func (m *HealthCheck) GetInterval() *time.Duration

func (*HealthCheck) GetIntervalJitter 

func (m *HealthCheck) GetIntervalJitter() *google_protobuf3.Duration

func (*HealthCheck) GetIntervalJitterPercent 

func (m *HealthCheck) GetIntervalJitterPercent() uint32

func (*HealthCheck) GetNoTrafficInterval 

func (m *HealthCheck) GetNoTrafficInterval() *google_protobuf3.Duration

func (*HealthCheck) GetReuseConnection 

func (m *HealthCheck) GetReuseConnection() *google_protobuf1.BoolValue

func (*HealthCheck) GetTcpHealthCheck 

func (m *HealthCheck) GetTcpHealthCheck() *HealthCheck_TcpHealthCheck

func (*HealthCheck) GetTimeout 

func (m *HealthCheck) GetTimeout() *time.Duration

func (*HealthCheck) GetUnhealthyEdgeInterval 

func (m *HealthCheck) GetUnhealthyEdgeInterval() *google_protobuf3.Duration

func (*HealthCheck) GetUnhealthyInterval 

func (m *HealthCheck) GetUnhealthyInterval() *google_protobuf3.Duration

func (*HealthCheck) GetUnhealthyThreshold 

func (m *HealthCheck) GetUnhealthyThreshold() *google_protobuf1.UInt32Value

func (*HealthCheck) Marshal 

func (m *HealthCheck) Marshal() (dAtA []byte, err error)

func (*HealthCheck) MarshalTo 

func (m *HealthCheck) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck) ProtoMessage 

func (*HealthCheck) ProtoMessage()

func (*HealthCheck) Reset 

func (m *HealthCheck) Reset()

func (*HealthCheck) Size 

func (m *HealthCheck) Size() (n int)

func (*HealthCheck) String 

func (m *HealthCheck) String() string

func (*HealthCheck) Unmarshal 

func (m *HealthCheck) Unmarshal(dAtA []byte) error

func (*HealthCheck) Validate 

func (m *HealthCheck) Validate() error

Validate checks the field values on HealthCheck with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

func (*HealthCheck) XXX_OneofFuncs 

func (*HealthCheck) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type HealthCheckValidationError 

type HealthCheckValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

HealthCheckValidationError is the validation error returned by HealthCheck.Validate if the designated constraints aren't met.

func (HealthCheckValidationError) Error 

func (e HealthCheckValidationError) Error() string

Error satisfies the builtin error interface

type HealthCheck_CustomHealthCheck 

type HealthCheck_CustomHealthCheck struct {
	// The registered name of the custom health checker.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// A custom health checker specific configuration which depends on the custom health checker
	// being instantiated. See :api:`envoy/config/health_checker` for reference.
	Config *google_protobuf.Struct `protobuf:"bytes,2,opt,name=config" json:"config,omitempty"`
}

Custom health check.

func (*HealthCheck_CustomHealthCheck) Descriptor 

func (*HealthCheck_CustomHealthCheck) Descriptor() ([]byte, []int)

func (*HealthCheck_CustomHealthCheck) Equal 

func (this *HealthCheck_CustomHealthCheck) Equal(that interface{}) bool

func (*HealthCheck_CustomHealthCheck) GetConfig 

func (m *HealthCheck_CustomHealthCheck) GetConfig() *google_protobuf.Struct

func (*HealthCheck_CustomHealthCheck) GetName 

func (m *HealthCheck_CustomHealthCheck) GetName() string

func (*HealthCheck_CustomHealthCheck) Marshal 

func (m *HealthCheck_CustomHealthCheck) Marshal() (dAtA []byte, err error)

func (*HealthCheck_CustomHealthCheck) MarshalTo 

func (m *HealthCheck_CustomHealthCheck) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck_CustomHealthCheck) ProtoMessage 

func (*HealthCheck_CustomHealthCheck) ProtoMessage()

func (*HealthCheck_CustomHealthCheck) Reset 

func (m *HealthCheck_CustomHealthCheck) Reset()

func (*HealthCheck_CustomHealthCheck) Size 

func (m *HealthCheck_CustomHealthCheck) Size() (n int)

func (*HealthCheck_CustomHealthCheck) String 

func (m *HealthCheck_CustomHealthCheck) String() string

func (*HealthCheck_CustomHealthCheck) Unmarshal 

func (m *HealthCheck_CustomHealthCheck) Unmarshal(dAtA []byte) error

func (*HealthCheck_CustomHealthCheck) Validate 

func (m *HealthCheck_CustomHealthCheck) Validate() error

Validate checks the field values on HealthCheck_CustomHealthCheck with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type HealthCheck_CustomHealthCheckValidationError 

type HealthCheck_CustomHealthCheckValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

HealthCheck_CustomHealthCheckValidationError is the validation error returned by HealthCheck_CustomHealthCheck.Validate if the designated constraints aren't met.

func (HealthCheck_CustomHealthCheckValidationError) Error 

func (e HealthCheck_CustomHealthCheckValidationError) Error() string

Error satisfies the builtin error interface

type HealthCheck_CustomHealthCheck_ 

type HealthCheck_CustomHealthCheck_ struct {
	CustomHealthCheck *HealthCheck_CustomHealthCheck `protobuf:"bytes,13,opt,name=custom_health_check,json=customHealthCheck,oneof"`
}

func (*HealthCheck_CustomHealthCheck_) Equal 

func (this *HealthCheck_CustomHealthCheck_) Equal(that interface{}) bool

func (*HealthCheck_CustomHealthCheck_) MarshalTo 

func (m *HealthCheck_CustomHealthCheck_) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck_CustomHealthCheck_) Size 

func (m *HealthCheck_CustomHealthCheck_) Size() (n int)

type HealthCheck_GrpcHealthCheck 

type HealthCheck_GrpcHealthCheck struct {
	// An optional service name parameter which will be sent to gRPC service in
	// `grpc.health.v1.HealthCheckRequest
	// <https://github.com/grpc/grpc/blob/master/src/proto/grpc/health/v1/health.proto#L20>`_.
	// message. See `gRPC health-checking overview
	// <https://github.com/grpc/grpc/blob/master/doc/health-checking.md>`_ for more information.
	ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
}

`grpc.health.v1.Health <https://github.com/grpc/grpc/blob/master/src/proto/grpc/health/v1/health.proto>`_-based healthcheck. See `gRPC doc <https://github.com/grpc/grpc/blob/master/doc/health-checking.md>`_ for details.

func (*HealthCheck_GrpcHealthCheck) Descriptor 

func (*HealthCheck_GrpcHealthCheck) Descriptor() ([]byte, []int)

func (*HealthCheck_GrpcHealthCheck) Equal 

func (this *HealthCheck_GrpcHealthCheck) Equal(that interface{}) bool

func (*HealthCheck_GrpcHealthCheck) GetServiceName 

func (m *HealthCheck_GrpcHealthCheck) GetServiceName() string

func (*HealthCheck_GrpcHealthCheck) Marshal 

func (m *HealthCheck_GrpcHealthCheck) Marshal() (dAtA []byte, err error)

func (*HealthCheck_GrpcHealthCheck) MarshalTo 

func (m *HealthCheck_GrpcHealthCheck) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck_GrpcHealthCheck) ProtoMessage 

func (*HealthCheck_GrpcHealthCheck) ProtoMessage()

func (*HealthCheck_GrpcHealthCheck) Reset 

func (m *HealthCheck_GrpcHealthCheck) Reset()

func (*HealthCheck_GrpcHealthCheck) Size 

func (m *HealthCheck_GrpcHealthCheck) Size() (n int)

func (*HealthCheck_GrpcHealthCheck) String 

func (m *HealthCheck_GrpcHealthCheck) String() string

func (*HealthCheck_GrpcHealthCheck) Unmarshal 

func (m *HealthCheck_GrpcHealthCheck) Unmarshal(dAtA []byte) error

func (*HealthCheck_GrpcHealthCheck) Validate 

func (m *HealthCheck_GrpcHealthCheck) Validate() error

Validate checks the field values on HealthCheck_GrpcHealthCheck with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type HealthCheck_GrpcHealthCheckValidationError 

type HealthCheck_GrpcHealthCheckValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

HealthCheck_GrpcHealthCheckValidationError is the validation error returned by HealthCheck_GrpcHealthCheck.Validate if the designated constraints aren't met.

func (HealthCheck_GrpcHealthCheckValidationError) Error 

func (e HealthCheck_GrpcHealthCheckValidationError) Error() string

Error satisfies the builtin error interface

type HealthCheck_GrpcHealthCheck_ 

type HealthCheck_GrpcHealthCheck_ struct {
	GrpcHealthCheck *HealthCheck_GrpcHealthCheck `protobuf:"bytes,11,opt,name=grpc_health_check,json=grpcHealthCheck,oneof"`
}

func (*HealthCheck_GrpcHealthCheck_) Equal 

func (this *HealthCheck_GrpcHealthCheck_) Equal(that interface{}) bool

func (*HealthCheck_GrpcHealthCheck_) MarshalTo 

func (m *HealthCheck_GrpcHealthCheck_) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck_GrpcHealthCheck_) Size 

func (m *HealthCheck_GrpcHealthCheck_) Size() (n int)

type HealthCheck_HttpHealthCheck 

type HealthCheck_HttpHealthCheck struct {
	// The value of the host header in the HTTP health check request. If
	// left empty (default value), the name of the cluster this health check is associated
	// with will be used.
	Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
	// Specifies the HTTP path that will be requested during health checking. For example
	// */healthcheck*.
	Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	// [#not-implemented-hide:] HTTP specific payload.
	Send *HealthCheck_Payload `protobuf:"bytes,3,opt,name=send" json:"send,omitempty"`
	// [#not-implemented-hide:] HTTP specific response.
	Receive *HealthCheck_Payload `protobuf:"bytes,4,opt,name=receive" json:"receive,omitempty"`
	// An optional service name parameter which is used to validate the identity of
	// the health checked cluster. See the :ref:`architecture overview
	// <arch_overview_health_checking_identity>` for more information.
	ServiceName string `protobuf:"bytes,5,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	// Specifies a list of HTTP headers that should be added to each request that is sent to the
	// health checked cluster.
	RequestHeadersToAdd []*HeaderValueOption `protobuf:"bytes,6,rep,name=request_headers_to_add,json=requestHeadersToAdd" json:"request_headers_to_add,omitempty"`
	// If set, health checks will be made using http/2.
	UseHttp2 bool `protobuf:"varint,7,opt,name=use_http2,json=useHttp2,proto3" json:"use_http2,omitempty"`
}

func (*HealthCheck_HttpHealthCheck) Descriptor 

func (*HealthCheck_HttpHealthCheck) Descriptor() ([]byte, []int)

func (*HealthCheck_HttpHealthCheck) Equal 

func (this *HealthCheck_HttpHealthCheck) Equal(that interface{}) bool

func (*HealthCheck_HttpHealthCheck) GetHost 

func (m *HealthCheck_HttpHealthCheck) GetHost() string

func (*HealthCheck_HttpHealthCheck) GetPath 

func (m *HealthCheck_HttpHealthCheck) GetPath() string

func (*HealthCheck_HttpHealthCheck) GetReceive 

func (m *HealthCheck_HttpHealthCheck) GetReceive() *HealthCheck_Payload

func (*HealthCheck_HttpHealthCheck) GetRequestHeadersToAdd 

func (m *HealthCheck_HttpHealthCheck) GetRequestHeadersToAdd() []*HeaderValueOption

func (*HealthCheck_HttpHealthCheck) GetSend 

func (m *HealthCheck_HttpHealthCheck) GetSend() *HealthCheck_Payload

func (*HealthCheck_HttpHealthCheck) GetServiceName 

func (m *HealthCheck_HttpHealthCheck) GetServiceName() string

func (*HealthCheck_HttpHealthCheck) GetUseHttp2 

func (m *HealthCheck_HttpHealthCheck) GetUseHttp2() bool

func (*HealthCheck_HttpHealthCheck) Marshal 

func (m *HealthCheck_HttpHealthCheck) Marshal() (dAtA []byte, err error)

func (*HealthCheck_HttpHealthCheck) MarshalTo 

func (m *HealthCheck_HttpHealthCheck) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck_HttpHealthCheck) ProtoMessage 

func (*HealthCheck_HttpHealthCheck) ProtoMessage()

func (*HealthCheck_HttpHealthCheck) Reset 

func (m *HealthCheck_HttpHealthCheck) Reset()

func (*HealthCheck_HttpHealthCheck) Size 

func (m *HealthCheck_HttpHealthCheck) Size() (n int)

func (*HealthCheck_HttpHealthCheck) String 

func (m *HealthCheck_HttpHealthCheck) String() string

func (*HealthCheck_HttpHealthCheck) Unmarshal 

func (m *HealthCheck_HttpHealthCheck) Unmarshal(dAtA []byte) error

func (*HealthCheck_HttpHealthCheck) Validate 

func (m *HealthCheck_HttpHealthCheck) Validate() error

Validate checks the field values on HealthCheck_HttpHealthCheck with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type HealthCheck_HttpHealthCheckValidationError 

type HealthCheck_HttpHealthCheckValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

HealthCheck_HttpHealthCheckValidationError is the validation error returned by HealthCheck_HttpHealthCheck.Validate if the designated constraints aren't met.

func (HealthCheck_HttpHealthCheckValidationError) Error 

func (e HealthCheck_HttpHealthCheckValidationError) Error() string

Error satisfies the builtin error interface

type HealthCheck_HttpHealthCheck_ 

type HealthCheck_HttpHealthCheck_ struct {
	HttpHealthCheck *HealthCheck_HttpHealthCheck `protobuf:"bytes,8,opt,name=http_health_check,json=httpHealthCheck,oneof"`
}

func (*HealthCheck_HttpHealthCheck_) Equal 

func (this *HealthCheck_HttpHealthCheck_) Equal(that interface{}) bool

func (*HealthCheck_HttpHealthCheck_) MarshalTo 

func (m *HealthCheck_HttpHealthCheck_) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck_HttpHealthCheck_) Size 

func (m *HealthCheck_HttpHealthCheck_) Size() (n int)

type HealthCheck_Payload 

type HealthCheck_Payload struct {
	// Types that are valid to be assigned to Payload:
	//	*HealthCheck_Payload_Text
	//	*HealthCheck_Payload_Binary
	Payload isHealthCheck_Payload_Payload `protobuf_oneof:"payload"`
}

Describes the encoding of the payload bytes in the payload.

func (*HealthCheck_Payload) Descriptor 

func (*HealthCheck_Payload) Descriptor() ([]byte, []int)

func (*HealthCheck_Payload) Equal 

func (this *HealthCheck_Payload) Equal(that interface{}) bool

func (*HealthCheck_Payload) GetBinary 

func (m *HealthCheck_Payload) GetBinary() []byte

func (*HealthCheck_Payload) GetPayload 

func (m *HealthCheck_Payload) GetPayload() isHealthCheck_Payload_Payload

func (*HealthCheck_Payload) GetText 

func (m *HealthCheck_Payload) GetText() string

func (*HealthCheck_Payload) Marshal 

func (m *HealthCheck_Payload) Marshal() (dAtA []byte, err error)

func (*HealthCheck_Payload) MarshalTo 

func (m *HealthCheck_Payload) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck_Payload) ProtoMessage 

func (*HealthCheck_Payload) ProtoMessage()

func (*HealthCheck_Payload) Reset 

func (m *HealthCheck_Payload) Reset()

func (*HealthCheck_Payload) Size 

func (m *HealthCheck_Payload) Size() (n int)

func (*HealthCheck_Payload) String 

func (m *HealthCheck_Payload) String() string

func (*HealthCheck_Payload) Unmarshal 

func (m *HealthCheck_Payload) Unmarshal(dAtA []byte) error

func (*HealthCheck_Payload) Validate 

func (m *HealthCheck_Payload) Validate() error

Validate checks the field values on HealthCheck_Payload with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

func (*HealthCheck_Payload) XXX_OneofFuncs 

func (*HealthCheck_Payload) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type HealthCheck_PayloadValidationError 

type HealthCheck_PayloadValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

HealthCheck_PayloadValidationError is the validation error returned by HealthCheck_Payload.Validate if the designated constraints aren't met.

func (HealthCheck_PayloadValidationError) Error 

func (e HealthCheck_PayloadValidationError) Error() string

Error satisfies the builtin error interface

type HealthCheck_Payload_Binary 

type HealthCheck_Payload_Binary struct {
	Binary []byte `protobuf:"bytes,2,opt,name=binary,proto3,oneof"`
}

func (*HealthCheck_Payload_Binary) Equal 

func (this *HealthCheck_Payload_Binary) Equal(that interface{}) bool

func (*HealthCheck_Payload_Binary) MarshalTo 

func (m *HealthCheck_Payload_Binary) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck_Payload_Binary) Size 

func (m *HealthCheck_Payload_Binary) Size() (n int)

type HealthCheck_Payload_Text 

type HealthCheck_Payload_Text struct {
	Text string `protobuf:"bytes,1,opt,name=text,proto3,oneof"`
}

func (*HealthCheck_Payload_Text) Equal 

func (this *HealthCheck_Payload_Text) Equal(that interface{}) bool

func (*HealthCheck_Payload_Text) MarshalTo 

func (m *HealthCheck_Payload_Text) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck_Payload_Text) Size 

func (m *HealthCheck_Payload_Text) Size() (n int)

type HealthCheck_RedisHealthCheck 

type HealthCheck_RedisHealthCheck struct {
	// If set, optionally perform “EXISTS <key>“ instead of “PING“. A return value
	// from Redis of 0 (does not exist) is considered a passing healthcheck. A return value other
	// than 0 is considered a failure. This allows the user to mark a Redis instance for maintenance
	// by setting the specified key to any value and waiting for traffic to drain.
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
}

func (*HealthCheck_RedisHealthCheck) Descriptor 

func (*HealthCheck_RedisHealthCheck) Descriptor() ([]byte, []int)

func (*HealthCheck_RedisHealthCheck) Equal 

func (this *HealthCheck_RedisHealthCheck) Equal(that interface{}) bool

func (*HealthCheck_RedisHealthCheck) GetKey 

func (m *HealthCheck_RedisHealthCheck) GetKey() string

func (*HealthCheck_RedisHealthCheck) Marshal 

func (m *HealthCheck_RedisHealthCheck) Marshal() (dAtA []byte, err error)

func (*HealthCheck_RedisHealthCheck) MarshalTo 

func (m *HealthCheck_RedisHealthCheck) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck_RedisHealthCheck) ProtoMessage 

func (*HealthCheck_RedisHealthCheck) ProtoMessage()

func (*HealthCheck_RedisHealthCheck) Reset 

func (m *HealthCheck_RedisHealthCheck) Reset()

func (*HealthCheck_RedisHealthCheck) Size 

func (m *HealthCheck_RedisHealthCheck) Size() (n int)

func (*HealthCheck_RedisHealthCheck) String 

func (m *HealthCheck_RedisHealthCheck) String() string

func (*HealthCheck_RedisHealthCheck) Unmarshal 

func (m *HealthCheck_RedisHealthCheck) Unmarshal(dAtA []byte) error

func (*HealthCheck_RedisHealthCheck) Validate 

func (m *HealthCheck_RedisHealthCheck) Validate() error

Validate checks the field values on HealthCheck_RedisHealthCheck with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type HealthCheck_RedisHealthCheckValidationError 

type HealthCheck_RedisHealthCheckValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

HealthCheck_RedisHealthCheckValidationError is the validation error returned by HealthCheck_RedisHealthCheck.Validate if the designated constraints aren't met.

func (HealthCheck_RedisHealthCheckValidationError) Error 

func (e HealthCheck_RedisHealthCheckValidationError) Error() string

Error satisfies the builtin error interface

type HealthCheck_TcpHealthCheck 

type HealthCheck_TcpHealthCheck struct {
	// Empty payloads imply a connect-only health check.
	Send *HealthCheck_Payload `protobuf:"bytes,1,opt,name=send" json:"send,omitempty"`
	// When checking the response, “fuzzy” matching is performed such that each
	// binary block must be found, and in the order specified, but not
	// necessarily contiguous.
	Receive []*HealthCheck_Payload `protobuf:"bytes,2,rep,name=receive" json:"receive,omitempty"`
}

func (*HealthCheck_TcpHealthCheck) Descriptor 

func (*HealthCheck_TcpHealthCheck) Descriptor() ([]byte, []int)

func (*HealthCheck_TcpHealthCheck) Equal 

func (this *HealthCheck_TcpHealthCheck) Equal(that interface{}) bool

func (*HealthCheck_TcpHealthCheck) GetReceive 

func (m *HealthCheck_TcpHealthCheck) GetReceive() []*HealthCheck_Payload

func (*HealthCheck_TcpHealthCheck) GetSend 

func (m *HealthCheck_TcpHealthCheck) GetSend() *HealthCheck_Payload

func (*HealthCheck_TcpHealthCheck) Marshal 

func (m *HealthCheck_TcpHealthCheck) Marshal() (dAtA []byte, err error)

func (*HealthCheck_TcpHealthCheck) MarshalTo 

func (m *HealthCheck_TcpHealthCheck) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck_TcpHealthCheck) ProtoMessage 

func (*HealthCheck_TcpHealthCheck) ProtoMessage()

func (*HealthCheck_TcpHealthCheck) Reset 

func (m *HealthCheck_TcpHealthCheck) Reset()

func (*HealthCheck_TcpHealthCheck) Size 

func (m *HealthCheck_TcpHealthCheck) Size() (n int)

func (*HealthCheck_TcpHealthCheck) String 

func (m *HealthCheck_TcpHealthCheck) String() string

func (*HealthCheck_TcpHealthCheck) Unmarshal 

func (m *HealthCheck_TcpHealthCheck) Unmarshal(dAtA []byte) error

func (*HealthCheck_TcpHealthCheck) Validate 

func (m *HealthCheck_TcpHealthCheck) Validate() error

Validate checks the field values on HealthCheck_TcpHealthCheck with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type HealthCheck_TcpHealthCheckValidationError 

type HealthCheck_TcpHealthCheckValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

HealthCheck_TcpHealthCheckValidationError is the validation error returned by HealthCheck_TcpHealthCheck.Validate if the designated constraints aren't met.

func (HealthCheck_TcpHealthCheckValidationError) Error 

func (e HealthCheck_TcpHealthCheckValidationError) Error() string

Error satisfies the builtin error interface

type HealthCheck_TcpHealthCheck_ 

type HealthCheck_TcpHealthCheck_ struct {
	TcpHealthCheck *HealthCheck_TcpHealthCheck `protobuf:"bytes,9,opt,name=tcp_health_check,json=tcpHealthCheck,oneof"`
}

func (*HealthCheck_TcpHealthCheck_) Equal 

func (this *HealthCheck_TcpHealthCheck_) Equal(that interface{}) bool

func (*HealthCheck_TcpHealthCheck_) MarshalTo 

func (m *HealthCheck_TcpHealthCheck_) MarshalTo(dAtA []byte) (int, error)

func (*HealthCheck_TcpHealthCheck_) Size 

func (m *HealthCheck_TcpHealthCheck_) Size() (n int)

type HealthStatus 

type HealthStatus int32

Endpoint health status. 

const (
	// The health status is not known. This is interpreted by Envoy as *HEALTHY*.
	HealthStatus_UNKNOWN HealthStatus = 0
	// Healthy.
	HealthStatus_HEALTHY HealthStatus = 1
	// Unhealthy.
	HealthStatus_UNHEALTHY HealthStatus = 2
	// Connection draining in progress. E.g.,
	// `<https://aws.amazon.com/blogs/aws/elb-connection-draining-remove-instances-from-service-with-care/>`_
	// or
	// `<https://cloud.google.com/compute/docs/load-balancing/enabling-connection-draining>`_.
	// This is interpreted by Envoy as *UNHEALTHY*.
	HealthStatus_DRAINING HealthStatus = 3
	// Health check timed out. This is part of HDS and is interpreted by Envoy as
	// *UNHEALTHY*.
	HealthStatus_TIMEOUT HealthStatus = 4
)

func (HealthStatus) EnumDescriptor 

func (HealthStatus) EnumDescriptor() ([]byte, []int)

func (HealthStatus) String 

func (x HealthStatus) String() string

type Http1ProtocolOptions 

type Http1ProtocolOptions struct {
	// Handle HTTP requests with absolute URLs in the requests. These requests
	// are generally sent by clients to forward/explicit proxies. This allows clients to configure
	// envoy as their HTTP proxy. In Unix, for example, this is typically done by setting the
	// *http_proxy* environment variable.
	AllowAbsoluteUrl *google_protobuf1.BoolValue `protobuf:"bytes,1,opt,name=allow_absolute_url,json=allowAbsoluteUrl" json:"allow_absolute_url,omitempty"`
	// Handle incoming HTTP/1.0 and HTTP 0.9 requests.
	// This is off by default, and not fully standards compliant. There is support for pre-HTTP/1.1
	// style connect logic, dechunking, and handling lack of client host iff
	// *default_host_for_http_10* is configured.
	AcceptHttp_10 bool `protobuf:"varint,2,opt,name=accept_http_10,json=acceptHttp10,proto3" json:"accept_http_10,omitempty"`
	// A default host for HTTP/1.0 requests. This is highly suggested if *accept_http_10* is true as
	// Envoy does not otherwise support HTTP/1.0 without a Host header.
	// This is a no-op if *accept_http_10* is not true.
	DefaultHostForHttp_10 string `` /* 127-byte string literal not displayed */
}

func (*Http1ProtocolOptions) Descriptor 

func (*Http1ProtocolOptions) Descriptor() ([]byte, []int)

func (*Http1ProtocolOptions) Equal 

func (this *Http1ProtocolOptions) Equal(that interface{}) bool

func (*Http1ProtocolOptions) GetAcceptHttp_10 

func (m *Http1ProtocolOptions) GetAcceptHttp_10() bool

func (*Http1ProtocolOptions) GetAllowAbsoluteUrl 

func (m *Http1ProtocolOptions) GetAllowAbsoluteUrl() *google_protobuf1.BoolValue

func (*Http1ProtocolOptions) GetDefaultHostForHttp_10 

func (m *Http1ProtocolOptions) GetDefaultHostForHttp_10() string

func (*Http1ProtocolOptions) Marshal 

func (m *Http1ProtocolOptions) Marshal() (dAtA []byte, err error)

func (*Http1ProtocolOptions) MarshalTo 

func (m *Http1ProtocolOptions) MarshalTo(dAtA []byte) (int, error)

func (*Http1ProtocolOptions) ProtoMessage 

func (*Http1ProtocolOptions) ProtoMessage()

func (*Http1ProtocolOptions) Reset 

func (m *Http1ProtocolOptions) Reset()

func (*Http1ProtocolOptions) Size 

func (m *Http1ProtocolOptions) Size() (n int)

func (*Http1ProtocolOptions) String 

func (m *Http1ProtocolOptions) String() string

func (*Http1ProtocolOptions) Unmarshal 

func (m *Http1ProtocolOptions) Unmarshal(dAtA []byte) error

func (*Http1ProtocolOptions) Validate 

func (m *Http1ProtocolOptions) Validate() error

Validate checks the field values on Http1ProtocolOptions with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type Http1ProtocolOptionsValidationError 

type Http1ProtocolOptionsValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

Http1ProtocolOptionsValidationError is the validation error returned by Http1ProtocolOptions.Validate if the designated constraints aren't met.

func (Http1ProtocolOptionsValidationError) Error 

func (e Http1ProtocolOptionsValidationError) Error() string

Error satisfies the builtin error interface

type Http2ProtocolOptions 

type Http2ProtocolOptions struct {
	// `Maximum table size <http://httpwg.org/specs/rfc7541.html#rfc.section.4.2>`_
	// (in octets) that the encoder is permitted to use for the dynamic HPACK table. Valid values
	// range from 0 to 4294967295 (2^32 - 1) and defaults to 4096. 0 effectively disables header
	// compression.
	HpackTableSize *google_protobuf1.UInt32Value `protobuf:"bytes,1,opt,name=hpack_table_size,json=hpackTableSize" json:"hpack_table_size,omitempty"`
	// `Maximum concurrent streams <http://httpwg.org/specs/rfc7540.html#rfc.section.5.1.2>`_
	// allowed for peer on one HTTP/2 connection. Valid values range from 1 to 2147483647 (2^31 - 1)
	// and defaults to 2147483647.
	MaxConcurrentStreams *google_protobuf1.UInt32Value `protobuf:"bytes,2,opt,name=max_concurrent_streams,json=maxConcurrentStreams" json:"max_concurrent_streams,omitempty"`
	// This field also acts as a soft limit on the number of bytes Envoy will buffer per-stream in the
	// HTTP/2 codec buffers. Once the buffer reaches this pointer, watermark callbacks will fire to
	// stop the flow of data to the codec buffers.
	InitialStreamWindowSize *google_protobuf1.UInt32Value `` /* 127-byte string literal not displayed */
	// Similar to *initial_stream_window_size*, but for connection-level flow-control
	// window. Currently, this has the same minimum/maximum/default as *initial_stream_window_size*.
	InitialConnectionWindowSize *google_protobuf1.UInt32Value `` /* 139-byte string literal not displayed */
}

func (*Http2ProtocolOptions) Descriptor 

func (*Http2ProtocolOptions) Descriptor() ([]byte, []int)

func (*Http2ProtocolOptions) Equal 

func (this *Http2ProtocolOptions) Equal(that interface{}) bool

func (*Http2ProtocolOptions) GetHpackTableSize 

func (m *Http2ProtocolOptions) GetHpackTableSize() *google_protobuf1.UInt32Value

func (*Http2ProtocolOptions) GetInitialConnectionWindowSize 

func (m *Http2ProtocolOptions) GetInitialConnectionWindowSize() *google_protobuf1.UInt32Value

func (*Http2ProtocolOptions) GetInitialStreamWindowSize 

func (m *Http2ProtocolOptions) GetInitialStreamWindowSize() *google_protobuf1.UInt32Value

func (*Http2ProtocolOptions) GetMaxConcurrentStreams 

func (m *Http2ProtocolOptions) GetMaxConcurrentStreams() *google_protobuf1.UInt32Value

func (*Http2ProtocolOptions) Marshal 

func (m *Http2ProtocolOptions) Marshal() (dAtA []byte, err error)

func (*Http2ProtocolOptions) MarshalTo 

func (m *Http2ProtocolOptions) MarshalTo(dAtA []byte) (int, error)

func (*Http2ProtocolOptions) ProtoMessage 

func (*Http2ProtocolOptions) ProtoMessage()

func (*Http2ProtocolOptions) Reset 

func (m *Http2ProtocolOptions) Reset()

func (*Http2ProtocolOptions) Size 

func (m *Http2ProtocolOptions) Size() (n int)

func (*Http2ProtocolOptions) String 

func (m *Http2ProtocolOptions) String() string

func (*Http2ProtocolOptions) Unmarshal 

func (m *Http2ProtocolOptions) Unmarshal(dAtA []byte) error

func (*Http2ProtocolOptions) Validate 

func (m *Http2ProtocolOptions) Validate() error

Validate checks the field values on Http2ProtocolOptions with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type Http2ProtocolOptionsValidationError 

type Http2ProtocolOptionsValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

Http2ProtocolOptionsValidationError is the validation error returned by Http2ProtocolOptions.Validate if the designated constraints aren't met.

func (Http2ProtocolOptionsValidationError) Error 

func (e Http2ProtocolOptionsValidationError) Error() string

Error satisfies the builtin error interface

type HttpProtocolOptions 

type HttpProtocolOptions struct {
	// The idle timeout for upstream connection pool connections. The idle timeout is defined as the
	// period in which there are no active requests. If not set, there is no idle timeout. When the
	// idle timeout is reached the connection will be closed. Note that request based timeouts mean
	// that HTTP/2 PINGs will not keep the connection alive.
	IdleTimeout *time.Duration `protobuf:"bytes,1,opt,name=idle_timeout,json=idleTimeout,stdduration" json:"idle_timeout,omitempty"`
}

func (*HttpProtocolOptions) Descriptor 

func (*HttpProtocolOptions) Descriptor() ([]byte, []int)

func (*HttpProtocolOptions) Equal 

func (this *HttpProtocolOptions) Equal(that interface{}) bool

func (*HttpProtocolOptions) GetIdleTimeout 

func (m *HttpProtocolOptions) GetIdleTimeout() *time.Duration

func (*HttpProtocolOptions) Marshal 

func (m *HttpProtocolOptions) Marshal() (dAtA []byte, err error)

func (*HttpProtocolOptions) MarshalTo 

func (m *HttpProtocolOptions) MarshalTo(dAtA []byte) (int, error)

func (*HttpProtocolOptions) ProtoMessage 

func (*HttpProtocolOptions) ProtoMessage()

func (*HttpProtocolOptions) Reset 

func (m *HttpProtocolOptions) Reset()

func (*HttpProtocolOptions) Size 

func (m *HttpProtocolOptions) Size() (n int)

func (*HttpProtocolOptions) String 

func (m *HttpProtocolOptions) String() string

func (*HttpProtocolOptions) Unmarshal 

func (m *HttpProtocolOptions) Unmarshal(dAtA []byte) error

func (*HttpProtocolOptions) Validate 

func (m *HttpProtocolOptions) Validate() error

Validate checks the field values on HttpProtocolOptions with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type HttpProtocolOptionsValidationError 

type HttpProtocolOptionsValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

HttpProtocolOptionsValidationError is the validation error returned by HttpProtocolOptions.Validate if the designated constraints aren't met.

func (HttpProtocolOptionsValidationError) Error 

func (e HttpProtocolOptionsValidationError) Error() string

Error satisfies the builtin error interface

type HttpUri 

type HttpUri struct {
	// The HTTP server URI. It should be a full FQDN with protocol, host and path.
	//
	// Example:
	//
	// .. code-block:: yaml
	//
	//    uri: https://www.googleapis.com/oauth2/v1/certs
	//
	Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"`
	// Specify how `uri` is to be fetched. Today, this requires an explicit
	// cluster, but in the future we may support dynamic cluster creation or
	// inline DNS resolution. See `issue
	// <https://github.com/envoyproxy/envoy/issues/1606>`_.
	//
	// Types that are valid to be assigned to HttpUpstreamType:
	//	*HttpUri_Cluster
	HttpUpstreamType isHttpUri_HttpUpstreamType `protobuf_oneof:"http_upstream_type"`
	// Sets the maximum duration in milliseconds that a response can take to arrive upon request.
	Timeout *time.Duration `protobuf:"bytes,3,opt,name=timeout,stdduration" json:"timeout,omitempty"`
}

Envoy external URI descriptor

func (*HttpUri) Descriptor 

func (*HttpUri) Descriptor() ([]byte, []int)

func (*HttpUri) GetCluster 

func (m *HttpUri) GetCluster() string

func (*HttpUri) GetHttpUpstreamType 

func (m *HttpUri) GetHttpUpstreamType() isHttpUri_HttpUpstreamType

func (*HttpUri) GetTimeout 

func (m *HttpUri) GetTimeout() *time.Duration

func (*HttpUri) GetUri 

func (m *HttpUri) GetUri() string

func (*HttpUri) Marshal 

func (m *HttpUri) Marshal() (dAtA []byte, err error)

func (*HttpUri) MarshalTo 

func (m *HttpUri) MarshalTo(dAtA []byte) (int, error)

func (*HttpUri) ProtoMessage 

func (*HttpUri) ProtoMessage()

func (*HttpUri) Reset 

func (m *HttpUri) Reset()

func (*HttpUri) Size 

func (m *HttpUri) Size() (n int)

func (*HttpUri) String 

func (m *HttpUri) String() string

func (*HttpUri) Unmarshal 

func (m *HttpUri) Unmarshal(dAtA []byte) error

func (*HttpUri) Validate 

func (m *HttpUri) Validate() error

Validate checks the field values on HttpUri with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

func (*HttpUri) XXX_OneofFuncs 

func (*HttpUri) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type HttpUriValidationError 

type HttpUriValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

HttpUriValidationError is the validation error returned by HttpUri.Validate if the designated constraints aren't met.

func (HttpUriValidationError) Error 

func (e HttpUriValidationError) Error() string

Error satisfies the builtin error interface

type HttpUri_Cluster 

type HttpUri_Cluster struct {
	Cluster string `protobuf:"bytes,2,opt,name=cluster,proto3,oneof"`
}

func (*HttpUri_Cluster) MarshalTo 

func (m *HttpUri_Cluster) MarshalTo(dAtA []byte) (int, error)

func (*HttpUri_Cluster) Size 

func (m *HttpUri_Cluster) Size() (n int)

type Locality 

type Locality struct {
	// Region this :ref:`zone <envoy_api_field_core.Locality.zone>` belongs to.
	Region string `protobuf:"bytes,1,opt,name=region,proto3" json:"region,omitempty"`
	// Defines the local service zone where Envoy is running. Though optional, it
	// should be set if discovery service routing is used and the discovery
	// service exposes :ref:`zone data <config_cluster_manager_sds_api_host_az>`,
	// either in this message or via :option:`--service-zone`. The meaning of zone
	// is context dependent, e.g. `Availability Zone (AZ)
	// <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html>`_
	// on AWS, `Zone <https://cloud.google.com/compute/docs/regions-zones/>`_ on
	// GCP, etc.
	Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"`
	// When used for locality of upstream hosts, this field further splits zone
	// into smaller chunks of sub-zones so they can be load balanced
	// independently.
	SubZone string `protobuf:"bytes,3,opt,name=sub_zone,json=subZone,proto3" json:"sub_zone,omitempty"`
}

Identifies location of where either Envoy runs or where upstream hosts run.

func (*Locality) Descriptor 

func (*Locality) Descriptor() ([]byte, []int)

func (*Locality) Equal 

func (this *Locality) Equal(that interface{}) bool

func (*Locality) GetRegion 

func (m *Locality) GetRegion() string

func (*Locality) GetSubZone 

func (m *Locality) GetSubZone() string

func (*Locality) GetZone 

func (m *Locality) GetZone() string

func (*Locality) Marshal 

func (m *Locality) Marshal() (dAtA []byte, err error)

func (*Locality) MarshalTo 

func (m *Locality) MarshalTo(dAtA []byte) (int, error)

func (*Locality) ProtoMessage 

func (*Locality) ProtoMessage()

func (*Locality) Reset 

func (m *Locality) Reset()

func (*Locality) Size 

func (m *Locality) Size() (n int)

func (*Locality) String 

func (m *Locality) String() string

func (*Locality) Unmarshal 

func (m *Locality) Unmarshal(dAtA []byte) error

func (*Locality) Validate 

func (m *Locality) Validate() error

Validate checks the field values on Locality with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type LocalityValidationError 

type LocalityValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

LocalityValidationError is the validation error returned by Locality.Validate if the designated constraints aren't met.

func (LocalityValidationError) Error 

func (e LocalityValidationError) Error() string

Error satisfies the builtin error interface

type Metadata 

type Metadata struct {
	// Key is the reverse DNS filter name, e.g. com.acme.widget. The envoy.*
	// namespace is reserved for Envoy's built-in filters.
	FilterMetadata map[string]*google_protobuf.Struct `` /* 177-byte string literal not displayed */
}

Metadata provides additional inputs to filters based on matched listeners, filter chains, routes and endpoints. It is structured as a map from filter name (in reverse DNS format) to metadata specific to the filter. Metadata key-values for a filter are merged as connection and request handling occurs, with later values for the same key overriding earlier values.

An example use of metadata is providing additional values to http_connection_manager in the envoy.http_connection_manager.access_log namespace.

For load balancing, Metadata provides a means to subset cluster endpoints. Endpoints have a Metadata object associated and routes contain a Metadata object to match against. There are some well defined metadata used today for this purpose:

  • “{"envoy.lb": {"canary": <bool> }}“ This indicates the canary status of an endpoint and is also used during header processing (x-envoy-upstream-canary) and for stats purposes.

func (*Metadata) Descriptor 

func (*Metadata) Descriptor() ([]byte, []int)

func (*Metadata) Equal 

func (this *Metadata) Equal(that interface{}) bool

func (*Metadata) GetFilterMetadata 

func (m *Metadata) GetFilterMetadata() map[string]*google_protobuf.Struct

func (*Metadata) Marshal 

func (m *Metadata) Marshal() (dAtA []byte, err error)

func (*Metadata) MarshalTo 

func (m *Metadata) MarshalTo(dAtA []byte) (int, error)

func (*Metadata) ProtoMessage 

func (*Metadata) ProtoMessage()

func (*Metadata) Reset 

func (m *Metadata) Reset()

func (*Metadata) Size 

func (m *Metadata) Size() (n int)

func (*Metadata) String 

func (m *Metadata) String() string

func (*Metadata) Unmarshal 

func (m *Metadata) Unmarshal(dAtA []byte) error

func (*Metadata) Validate 

func (m *Metadata) Validate() error

Validate checks the field values on Metadata with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type MetadataValidationError 

type MetadataValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

MetadataValidationError is the validation error returned by Metadata.Validate if the designated constraints aren't met.

func (MetadataValidationError) Error 

func (e MetadataValidationError) Error() string

Error satisfies the builtin error interface

type Node 

type Node struct {
	// An opaque node identifier for the Envoy node. This also provides the local
	// service node name. It should be set if any of the following features are
	// used: :ref:`statsd <arch_overview_statistics>`, :ref:`CDS
	// <config_cluster_manager_cds>`, and :ref:`HTTP tracing
	// <arch_overview_tracing>`, either in this message or via
	// :option:`--service-node`.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Defines the local service cluster name where Envoy is running. Though
	// optional, it should be set if any of the following features are used:
	// :ref:`statsd <arch_overview_statistics>`, :ref:`health check cluster
	// verification <config_cluster_manager_cluster_hc_service_name>`,
	// :ref:`runtime override directory <config_runtime_override_subdirectory>`,
	// :ref:`user agent addition <config_http_conn_man_add_user_agent>`,
	// :ref:`HTTP global rate limiting <config_http_filters_rate_limit>`,
	// :ref:`CDS <config_cluster_manager_cds>`, and :ref:`HTTP tracing
	// <arch_overview_tracing>`, either in this message or via
	// :option:`--service-cluster`.
	Cluster string `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// Opaque metadata extending the node identifier. Envoy will pass this
	// directly to the management server.
	Metadata *google_protobuf.Struct `protobuf:"bytes,3,opt,name=metadata" json:"metadata,omitempty"`
	// Locality specifying where the Envoy instance is running.
	Locality *Locality `protobuf:"bytes,4,opt,name=locality" json:"locality,omitempty"`
	// This is motivated by informing a management server during canary which
	// version of Envoy is being tested in a heterogeneous fleet. This will be set
	// by Envoy in management server RPCs.
	BuildVersion string `protobuf:"bytes,5,opt,name=build_version,json=buildVersion,proto3" json:"build_version,omitempty"`
}

Identifies a specific Envoy instance. The node identifier is presented to the management server, which may use this identifier to distinguish per Envoy configuration for serving.

func (*Node) Descriptor 

func (*Node) Descriptor() ([]byte, []int)

func (*Node) Equal 

func (this *Node) Equal(that interface{}) bool

func (*Node) GetBuildVersion 

func (m *Node) GetBuildVersion() string

func (*Node) GetCluster 

func (m *Node) GetCluster() string

func (*Node) GetId 

func (m *Node) GetId() string

func (*Node) GetLocality 

func (m *Node) GetLocality() *Locality

func (*Node) GetMetadata 

func (m *Node) GetMetadata() *google_protobuf.Struct

func (*Node) Marshal 

func (m *Node) Marshal() (dAtA []byte, err error)

func (*Node) MarshalTo 

func (m *Node) MarshalTo(dAtA []byte) (int, error)

func (*Node) ProtoMessage 

func (*Node) ProtoMessage()

func (*Node) Reset 

func (m *Node) Reset()

func (*Node) Size 

func (m *Node) Size() (n int)

func (*Node) String 

func (m *Node) String() string

func (*Node) Unmarshal 

func (m *Node) Unmarshal(dAtA []byte) error

func (*Node) Validate 

func (m *Node) Validate() error

Validate checks the field values on Node with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type NodeValidationError 

type NodeValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

NodeValidationError is the validation error returned by Node.Validate if the designated constraints aren't met.

func (NodeValidationError) Error 

func (e NodeValidationError) Error() string

Error satisfies the builtin error interface

type Pipe 

type Pipe struct {
	// Unix Domain Socket path. On Linux, paths starting with '@' will use the
	// abstract namespace. The starting '@' is replaced by a null byte by Envoy.
	// Paths starting with '@' will result in an error in environments other than
	// Linux.
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
}

func (*Pipe) Descriptor 

func (*Pipe) Descriptor() ([]byte, []int)

func (*Pipe) Equal 

func (this *Pipe) Equal(that interface{}) bool

func (*Pipe) GetPath 

func (m *Pipe) GetPath() string

func (*Pipe) Marshal 

func (m *Pipe) Marshal() (dAtA []byte, err error)

func (*Pipe) MarshalTo 

func (m *Pipe) MarshalTo(dAtA []byte) (int, error)

func (*Pipe) ProtoMessage 

func (*Pipe) ProtoMessage()

func (*Pipe) Reset 

func (m *Pipe) Reset()

func (*Pipe) Size 

func (m *Pipe) Size() (n int)

func (*Pipe) String 

func (m *Pipe) String() string

func (*Pipe) Unmarshal 

func (m *Pipe) Unmarshal(dAtA []byte) error

func (*Pipe) Validate 

func (m *Pipe) Validate() error

Validate checks the field values on Pipe with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type PipeValidationError 

type PipeValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

PipeValidationError is the validation error returned by Pipe.Validate if the designated constraints aren't met.

func (PipeValidationError) Error 

func (e PipeValidationError) Error() string

Error satisfies the builtin error interface

type RequestMethod 

type RequestMethod int32

HTTP request method. 

const (
	METHOD_UNSPECIFIED RequestMethod = 0
	GET                RequestMethod = 1
	HEAD               RequestMethod = 2
	POST               RequestMethod = 3
	PUT                RequestMethod = 4
	DELETE             RequestMethod = 5
	CONNECT            RequestMethod = 6
	OPTIONS            RequestMethod = 7
	TRACE              RequestMethod = 8
)

func (RequestMethod) EnumDescriptor 

func (RequestMethod) EnumDescriptor() ([]byte, []int)

func (RequestMethod) String 

func (x RequestMethod) String() string

type RoutingPriority 

type RoutingPriority int32

Envoy supports :ref:`upstream priority routing <arch_overview_http_routing_priority>` both at the route and the virtual cluster level. The current priority implementation uses different connection pool and circuit breaking settings for each priority level. This means that even for HTTP/2 requests, two physical connections will be used to an upstream host. In the future Envoy will likely support true HTTP/2 priority over a single upstream connection. 

const (
	RoutingPriority_DEFAULT RoutingPriority = 0
	RoutingPriority_HIGH    RoutingPriority = 1
)

func (RoutingPriority) EnumDescriptor 

func (RoutingPriority) EnumDescriptor() ([]byte, []int)

func (RoutingPriority) String 

func (x RoutingPriority) String() string

type RuntimeUInt32 

type RuntimeUInt32 struct {
	// Default value if runtime value is not available.
	DefaultValue uint32 `protobuf:"varint,2,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
	// Runtime key to get value for comparison. This value is used if defined.
	RuntimeKey string `protobuf:"bytes,3,opt,name=runtime_key,json=runtimeKey,proto3" json:"runtime_key,omitempty"`
}

Runtime derived uint32 with a default when not specified.

func (*RuntimeUInt32) Descriptor 

func (*RuntimeUInt32) Descriptor() ([]byte, []int)

func (*RuntimeUInt32) Equal 

func (this *RuntimeUInt32) Equal(that interface{}) bool

func (*RuntimeUInt32) GetDefaultValue 

func (m *RuntimeUInt32) GetDefaultValue() uint32

func (*RuntimeUInt32) GetRuntimeKey 

func (m *RuntimeUInt32) GetRuntimeKey() string

func (*RuntimeUInt32) Marshal 

func (m *RuntimeUInt32) Marshal() (dAtA []byte, err error)

func (*RuntimeUInt32) MarshalTo 

func (m *RuntimeUInt32) MarshalTo(dAtA []byte) (int, error)

func (*RuntimeUInt32) ProtoMessage 

func (*RuntimeUInt32) ProtoMessage()

func (*RuntimeUInt32) Reset 

func (m *RuntimeUInt32) Reset()

func (*RuntimeUInt32) Size 

func (m *RuntimeUInt32) Size() (n int)

func (*RuntimeUInt32) String 

func (m *RuntimeUInt32) String() string

func (*RuntimeUInt32) Unmarshal 

func (m *RuntimeUInt32) Unmarshal(dAtA []byte) error

func (*RuntimeUInt32) Validate 

func (m *RuntimeUInt32) Validate() error

Validate checks the field values on RuntimeUInt32 with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type RuntimeUInt32ValidationError 

type RuntimeUInt32ValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

RuntimeUInt32ValidationError is the validation error returned by RuntimeUInt32.Validate if the designated constraints aren't met.

func (RuntimeUInt32ValidationError) Error 

func (e RuntimeUInt32ValidationError) Error() string

Error satisfies the builtin error interface

type SocketAddress 

type SocketAddress struct {
	Protocol SocketAddress_Protocol `protobuf:"varint,1,opt,name=protocol,proto3,enum=envoy.api.v2.core.SocketAddress_Protocol" json:"protocol,omitempty"`
	// The address for this socket. :ref:`Listeners <config_listeners>` will bind
	// to the address. An empty address is not allowed. Specify “0.0.0.0“ or “::“
	// to bind to any address. [#comment:TODO(zuercher) reinstate when implemented:
	// It is possible to distinguish a Listener address via the prefix/suffix matching
	// in :ref:`FilterChainMatch <envoy_api_msg_listener.FilterChainMatch>`.] When used
	// within an upstream :ref:`BindConfig <envoy_api_msg_core.BindConfig>`, the address
	// controls the source address of outbound connections. For :ref:`clusters
	// <config_cluster_manager_cluster>`, the cluster type determines whether the
	// address must be an IP (*STATIC* or *EDS* clusters) or a hostname resolved by DNS
	// (*STRICT_DNS* or *LOGICAL_DNS* clusters). Address resolution can be customized
	// via :ref:`resolver_name <envoy_api_field_core.SocketAddress.resolver_name>`.
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	// Types that are valid to be assigned to PortSpecifier:
	//	*SocketAddress_PortValue
	//	*SocketAddress_NamedPort
	PortSpecifier isSocketAddress_PortSpecifier `protobuf_oneof:"port_specifier"`
	// The name of the resolver. This must have been registered with Envoy. If this is
	// empty, a context dependent default applies. If address is a hostname this
	// should be set for resolution other than DNS. If the address is a concrete
	// IP address, no resolution will occur.
	ResolverName string `protobuf:"bytes,5,opt,name=resolver_name,json=resolverName,proto3" json:"resolver_name,omitempty"`
	// When binding to an IPv6 address above, this enables `IPv4 compatibity
	// <https://tools.ietf.org/html/rfc3493#page-11>`_. Binding to “::“ will
	// allow both IPv4 and IPv6 connections, with peer IPv4 addresses mapped into
	// IPv6 space as “::FFFF:<IPv4-address>“.
	Ipv4Compat bool `protobuf:"varint,6,opt,name=ipv4_compat,json=ipv4Compat,proto3" json:"ipv4_compat,omitempty"`
}

func (*SocketAddress) Descriptor 

func (*SocketAddress) Descriptor() ([]byte, []int)

func (*SocketAddress) Equal 

func (this *SocketAddress) Equal(that interface{}) bool

func (*SocketAddress) GetAddress 

func (m *SocketAddress) GetAddress() string

func (*SocketAddress) GetIpv4Compat 

func (m *SocketAddress) GetIpv4Compat() bool

func (*SocketAddress) GetNamedPort 

func (m *SocketAddress) GetNamedPort() string

func (*SocketAddress) GetPortSpecifier 

func (m *SocketAddress) GetPortSpecifier() isSocketAddress_PortSpecifier

func (*SocketAddress) GetPortValue 

func (m *SocketAddress) GetPortValue() uint32

func (*SocketAddress) GetProtocol 

func (m *SocketAddress) GetProtocol() SocketAddress_Protocol

func (*SocketAddress) GetResolverName 

func (m *SocketAddress) GetResolverName() string

func (*SocketAddress) Marshal 

func (m *SocketAddress) Marshal() (dAtA []byte, err error)

func (*SocketAddress) MarshalTo 

func (m *SocketAddress) MarshalTo(dAtA []byte) (int, error)

func (*SocketAddress) ProtoMessage 

func (*SocketAddress) ProtoMessage()

func (*SocketAddress) Reset 

func (m *SocketAddress) Reset()

func (*SocketAddress) Size 

func (m *SocketAddress) Size() (n int)

func (*SocketAddress) String 

func (m *SocketAddress) String() string

func (*SocketAddress) Unmarshal 

func (m *SocketAddress) Unmarshal(dAtA []byte) error

func (*SocketAddress) Validate 

func (m *SocketAddress) Validate() error

Validate checks the field values on SocketAddress with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

func (*SocketAddress) XXX_OneofFuncs 

func (*SocketAddress) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type SocketAddressValidationError 

type SocketAddressValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

SocketAddressValidationError is the validation error returned by SocketAddress.Validate if the designated constraints aren't met.

func (SocketAddressValidationError) Error 

func (e SocketAddressValidationError) Error() string

Error satisfies the builtin error interface

type SocketAddress_NamedPort 

type SocketAddress_NamedPort struct {
	NamedPort string `protobuf:"bytes,4,opt,name=named_port,json=namedPort,proto3,oneof"`
}

func (*SocketAddress_NamedPort) Equal 

func (this *SocketAddress_NamedPort) Equal(that interface{}) bool

func (*SocketAddress_NamedPort) MarshalTo 

func (m *SocketAddress_NamedPort) MarshalTo(dAtA []byte) (int, error)

func (*SocketAddress_NamedPort) Size 

func (m *SocketAddress_NamedPort) Size() (n int)

type SocketAddress_PortValue 

type SocketAddress_PortValue struct {
	PortValue uint32 `protobuf:"varint,3,opt,name=port_value,json=portValue,proto3,oneof"`
}

func (*SocketAddress_PortValue) Equal 

func (this *SocketAddress_PortValue) Equal(that interface{}) bool

func (*SocketAddress_PortValue) MarshalTo 

func (m *SocketAddress_PortValue) MarshalTo(dAtA []byte) (int, error)

func (*SocketAddress_PortValue) Size 

func (m *SocketAddress_PortValue) Size() (n int)

type SocketAddress_Protocol 

type SocketAddress_Protocol int32
const (
	TCP SocketAddress_Protocol = 0
	// [#not-implemented-hide:]
	UDP SocketAddress_Protocol = 1
)

func (SocketAddress_Protocol) EnumDescriptor 

func (SocketAddress_Protocol) EnumDescriptor() ([]byte, []int)

func (SocketAddress_Protocol) String 

func (x SocketAddress_Protocol) String() string

type SocketOption 

type SocketOption struct {
	// An optional name to give this socket option for debugging, etc.
	// Uniqueness is not required and no special meaning is assumed.
	Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
	// Corresponding to the level value passed to setsockopt, such as IPPROTO_TCP
	Level int64 `protobuf:"varint,2,opt,name=level,proto3" json:"level,omitempty"`
	// The numeric name as passed to setsockopt
	Name int64 `protobuf:"varint,3,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are valid to be assigned to Value:
	//	*SocketOption_IntValue
	//	*SocketOption_BufValue
	Value isSocketOption_Value `protobuf_oneof:"value"`
	// The state in which the option will be applied. When used in BindConfig
	// STATE_PREBIND is currently the only valid value.
	State SocketOption_SocketState `protobuf:"varint,6,opt,name=state,proto3,enum=envoy.api.v2.core.SocketOption_SocketState" json:"state,omitempty"`
}

Generic socket option message. This would be used to set socket options that might not exist in upstream kernels or precompiled Envoy binaries.

func (*SocketOption) Descriptor 

func (*SocketOption) Descriptor() ([]byte, []int)

func (*SocketOption) Equal 

func (this *SocketOption) Equal(that interface{}) bool

func (*SocketOption) GetBufValue 

func (m *SocketOption) GetBufValue() []byte

func (*SocketOption) GetDescription 

func (m *SocketOption) GetDescription() string

func (*SocketOption) GetIntValue 

func (m *SocketOption) GetIntValue() int64

func (*SocketOption) GetLevel 

func (m *SocketOption) GetLevel() int64

func (*SocketOption) GetName 

func (m *SocketOption) GetName() int64

func (*SocketOption) GetState 

func (m *SocketOption) GetState() SocketOption_SocketState

func (*SocketOption) GetValue 

func (m *SocketOption) GetValue() isSocketOption_Value

func (*SocketOption) Marshal 

func (m *SocketOption) Marshal() (dAtA []byte, err error)

func (*SocketOption) MarshalTo 

func (m *SocketOption) MarshalTo(dAtA []byte) (int, error)

func (*SocketOption) ProtoMessage 

func (*SocketOption) ProtoMessage()

func (*SocketOption) Reset 

func (m *SocketOption) Reset()

func (*SocketOption) Size 

func (m *SocketOption) Size() (n int)

func (*SocketOption) String 

func (m *SocketOption) String() string

func (*SocketOption) Unmarshal 

func (m *SocketOption) Unmarshal(dAtA []byte) error

func (*SocketOption) Validate 

func (m *SocketOption) Validate() error

Validate checks the field values on SocketOption with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

func (*SocketOption) XXX_OneofFuncs 

func (*SocketOption) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type SocketOptionValidationError 

type SocketOptionValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

SocketOptionValidationError is the validation error returned by SocketOption.Validate if the designated constraints aren't met.

func (SocketOptionValidationError) Error 

func (e SocketOptionValidationError) Error() string

Error satisfies the builtin error interface

type SocketOption_BufValue 

type SocketOption_BufValue struct {
	BufValue []byte `protobuf:"bytes,5,opt,name=buf_value,json=bufValue,proto3,oneof"`
}

func (*SocketOption_BufValue) Equal 

func (this *SocketOption_BufValue) Equal(that interface{}) bool

func (*SocketOption_BufValue) MarshalTo 

func (m *SocketOption_BufValue) MarshalTo(dAtA []byte) (int, error)

func (*SocketOption_BufValue) Size 

func (m *SocketOption_BufValue) Size() (n int)

type SocketOption_IntValue 

type SocketOption_IntValue struct {
	IntValue int64 `protobuf:"varint,4,opt,name=int_value,json=intValue,proto3,oneof"`
}

func (*SocketOption_IntValue) Equal 

func (this *SocketOption_IntValue) Equal(that interface{}) bool

func (*SocketOption_IntValue) MarshalTo 

func (m *SocketOption_IntValue) MarshalTo(dAtA []byte) (int, error)

func (*SocketOption_IntValue) Size 

func (m *SocketOption_IntValue) Size() (n int)

type SocketOption_SocketState 

type SocketOption_SocketState int32
const (
	// Socket options are applied after socket creation but before binding the socket to a port
	STATE_PREBIND SocketOption_SocketState = 0
	// Socket options are applied after binding the socket to a port but before calling listen()
	STATE_BOUND SocketOption_SocketState = 1
	// Socket options are applied after calling listen()
	STATE_LISTENING SocketOption_SocketState = 2
)

func (SocketOption_SocketState) EnumDescriptor 

func (SocketOption_SocketState) EnumDescriptor() ([]byte, []int)

func (SocketOption_SocketState) String 

func (x SocketOption_SocketState) String() string

type TcpKeepalive 

type TcpKeepalive struct {
	// Maximum number of keepalive probes to send without response before deciding
	// the connection is dead. Default is to use the OS level configuration (unless
	// overridden, Linux defaults to 9.)
	KeepaliveProbes *google_protobuf1.UInt32Value `protobuf:"bytes,1,opt,name=keepalive_probes,json=keepaliveProbes" json:"keepalive_probes,omitempty"`
	// The number of seconds a connection needs to be idle before keep-alive probes
	// start being sent. Default is to use the OS level configuration (unless
	// overridden, Linux defaults to 7200s (ie 2 hours.)
	KeepaliveTime *google_protobuf1.UInt32Value `protobuf:"bytes,2,opt,name=keepalive_time,json=keepaliveTime" json:"keepalive_time,omitempty"`
	// The number of seconds between keep-alive probes. Default is to use the OS
	// level configuration (unless overridden, Linux defaults to 75s.)
	KeepaliveInterval *google_protobuf1.UInt32Value `protobuf:"bytes,3,opt,name=keepalive_interval,json=keepaliveInterval" json:"keepalive_interval,omitempty"`
}

func (*TcpKeepalive) Descriptor 

func (*TcpKeepalive) Descriptor() ([]byte, []int)

func (*TcpKeepalive) Equal 

func (this *TcpKeepalive) Equal(that interface{}) bool

func (*TcpKeepalive) GetKeepaliveInterval 

func (m *TcpKeepalive) GetKeepaliveInterval() *google_protobuf1.UInt32Value

func (*TcpKeepalive) GetKeepaliveProbes 

func (m *TcpKeepalive) GetKeepaliveProbes() *google_protobuf1.UInt32Value

func (*TcpKeepalive) GetKeepaliveTime 

func (m *TcpKeepalive) GetKeepaliveTime() *google_protobuf1.UInt32Value

func (*TcpKeepalive) Marshal 

func (m *TcpKeepalive) Marshal() (dAtA []byte, err error)

func (*TcpKeepalive) MarshalTo 

func (m *TcpKeepalive) MarshalTo(dAtA []byte) (int, error)

func (*TcpKeepalive) ProtoMessage 

func (*TcpKeepalive) ProtoMessage()

func (*TcpKeepalive) Reset 

func (m *TcpKeepalive) Reset()

func (*TcpKeepalive) Size 

func (m *TcpKeepalive) Size() (n int)

func (*TcpKeepalive) String 

func (m *TcpKeepalive) String() string

func (*TcpKeepalive) Unmarshal 

func (m *TcpKeepalive) Unmarshal(dAtA []byte) error

func (*TcpKeepalive) Validate 

func (m *TcpKeepalive) Validate() error

Validate checks the field values on TcpKeepalive with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type TcpKeepaliveValidationError 

type TcpKeepaliveValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

TcpKeepaliveValidationError is the validation error returned by TcpKeepalive.Validate if the designated constraints aren't met.

func (TcpKeepaliveValidationError) Error 

func (e TcpKeepaliveValidationError) Error() string

Error satisfies the builtin error interface

type TcpProtocolOptions 

type TcpProtocolOptions struct {
}

[#not-implemented-hide:]

func (*TcpProtocolOptions) Descriptor 

func (*TcpProtocolOptions) Descriptor() ([]byte, []int)

func (*TcpProtocolOptions) Equal 

func (this *TcpProtocolOptions) Equal(that interface{}) bool

func (*TcpProtocolOptions) Marshal 

func (m *TcpProtocolOptions) Marshal() (dAtA []byte, err error)

func (*TcpProtocolOptions) MarshalTo 

func (m *TcpProtocolOptions) MarshalTo(dAtA []byte) (int, error)

func (*TcpProtocolOptions) ProtoMessage 

func (*TcpProtocolOptions) ProtoMessage()

func (*TcpProtocolOptions) Reset 

func (m *TcpProtocolOptions) Reset()

func (*TcpProtocolOptions) Size 

func (m *TcpProtocolOptions) Size() (n int)

func (*TcpProtocolOptions) String 

func (m *TcpProtocolOptions) String() string

func (*TcpProtocolOptions) Unmarshal 

func (m *TcpProtocolOptions) Unmarshal(dAtA []byte) error

func (*TcpProtocolOptions) Validate 

func (m *TcpProtocolOptions) Validate() error

Validate checks the field values on TcpProtocolOptions with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type TcpProtocolOptionsValidationError 

type TcpProtocolOptionsValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

TcpProtocolOptionsValidationError is the validation error returned by TcpProtocolOptions.Validate if the designated constraints aren't met.

func (TcpProtocolOptionsValidationError) Error 

func (e TcpProtocolOptionsValidationError) Error() string

Error satisfies the builtin error interface

type TransportSocket 

type TransportSocket struct {
	// The name of the transport socket to instantiate. The name must match a supported transport
	// socket implementation.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Implementation specific configuration which depends on the implementation being instantiated.
	// See the supported transport socket implementations for further documentation.
	Config *google_protobuf.Struct `protobuf:"bytes,2,opt,name=config" json:"config,omitempty"`
}

Configuration for transport socket in :ref:`listeners <config_listeners>` and :ref:`clusters <config_cluster_manager_cluster>`. If the configuration is empty, a default transport socket implementation and configuration will be chosen based on the platform and existence of tls_context.

func (*TransportSocket) Descriptor 

func (*TransportSocket) Descriptor() ([]byte, []int)

func (*TransportSocket) Equal 

func (this *TransportSocket) Equal(that interface{}) bool

func (*TransportSocket) GetConfig 

func (m *TransportSocket) GetConfig() *google_protobuf.Struct

func (*TransportSocket) GetName 

func (m *TransportSocket) GetName() string

func (*TransportSocket) Marshal 

func (m *TransportSocket) Marshal() (dAtA []byte, err error)

func (*TransportSocket) MarshalTo 

func (m *TransportSocket) MarshalTo(dAtA []byte) (int, error)

func (*TransportSocket) ProtoMessage 

func (*TransportSocket) ProtoMessage()

func (*TransportSocket) Reset 

func (m *TransportSocket) Reset()

func (*TransportSocket) Size 

func (m *TransportSocket) Size() (n int)

func (*TransportSocket) String 

func (m *TransportSocket) String() string

func (*TransportSocket) Unmarshal 

func (m *TransportSocket) Unmarshal(dAtA []byte) error

func (*TransportSocket) Validate 

func (m *TransportSocket) Validate() error

Validate checks the field values on TransportSocket with the rules defined in the proto definition for this message. If any rules are violated, an error is returned.

type TransportSocketValidationError 

type TransportSocketValidationError struct {
	Field  string
	Reason string
	Cause  error
	Key    bool
}

TransportSocketValidationError is the validation error returned by TransportSocket.Validate if the designated constraints aren't met.

func (TransportSocketValidationError) Error 

func (e TransportSocketValidationError) Error() string

Error satisfies the builtin error interface

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.