destination

type AddrSet struct {
	Addrs []*net.TcpAddress `protobuf:"bytes,1,rep,name=addrs,proto3" json:"addrs,omitempty"`
	// contains filtered or unexported fields
}

type AuthorityOverride struct {
	AuthorityOverride string `protobuf:"bytes,1,opt,name=authority_override,json=authorityOverride,proto3" json:"authority_override,omitempty"`
	// contains filtered or unexported fields
}

type DestinationClient interface {
	// Given a destination, return all addresses in that destination as a long-
	// running stream of updates.
	Get(ctx context.Context, in *GetDestination, opts ...grpc.CallOption) (Destination_GetClient, error)
	// Given a destination, return that destination's profile and send an update
	// whenever it changes.
	GetProfile(ctx context.Context, in *GetDestination, opts ...grpc.CallOption) (Destination_GetProfileClient, error)
}

type DestinationProfile struct {

	// The fully-qualified service name, if one exists.
	//
	// When resolving (especially by IP), this field provides the fully-qualified
	// name of the resolved service, if one exists. This field does NOT include
	// any port information. E.g. a lookup for 10.2.3.4:8080 might have a name
	// like `foo.bar.svc.cluster.local`.
	//
	// Implementations MAY provide names for non-service IP-lookups (e.g., pod or
	// node dns names), but this is not required.
	//
	// If the lookup does not refer to a known named entity, this field MUST be
	// left empty.
	FullyQualifiedName string `protobuf:"bytes,5,opt,name=fully_qualified_name,json=fullyQualifiedName,proto3" json:"fully_qualified_name,omitempty"`
	// Indicates that connections on this service address should be handled as
	// opaque TCP streams. HTTP routes returned on for such services will be
	// ignored.
	OpaqueProtocol bool `protobuf:"varint,4,opt,name=opaque_protocol,json=opaqueProtocol,proto3" json:"opaque_protocol,omitempty"`
	// A list of routes, each with a RequestMatch.  If a request matches
	// more than one route, the first match wins.
	Routes []*Route `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty"`
	// The retry budget controls how much additional load the proxy can generate
	// as retries. Failured requests on retryable routes will not be retried if
	// there is no available budget.
	RetryBudget *RetryBudget `protobuf:"bytes,2,opt,name=retry_budget,json=retryBudget,proto3" json:"retry_budget,omitempty"`
	// If this list is non-empty, requests to this destination should instead be
	// split between the destinations in this list.  Each destination should
	// receive a portion of the requests proportional to its weight.  If this
	// list is empty, requests should be sent to this destination as normal.
	DstOverrides []*WeightedDst `protobuf:"bytes,3,rep,name=dst_overrides,json=dstOverrides,proto3" json:"dst_overrides,omitempty"`
	// If this field is set, it indicates that the target is a known endpoint (and
	// not a service address). The values of `fully_qualified_name` and
	// `dst_overrides` will be ignored for the purposes of service discovery--
	// traffic split and load balancing will be skipped and the single endpoint
	// are used.
	//
	// No endpoint should be set If the target is unknown.
	Endpoint *WeightedAddr `protobuf:"bytes,6,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	// contains filtered or unexported fields
}

type DestinationServer interface {
	// Given a destination, return all addresses in that destination as a long-
	// running stream of updates.
	Get(*GetDestination, Destination_GetServer) error
	// Given a destination, return that destination's profile and send an update
	// whenever it changes.
	GetProfile(*GetDestination, Destination_GetProfileServer) error
	// contains filtered or unexported methods
}

type Destination_GetClient interface {
	Recv() (*Update, error)
	grpc.ClientStream
}

type Destination_GetProfileClient interface {
	Recv() (*DestinationProfile, error)
	grpc.ClientStream
}

type Destination_GetProfileServer interface {
	Send(*DestinationProfile) error
	grpc.ServerStream
}

type Destination_GetServer interface {
	Send(*Update) error
	grpc.ServerStream
}

type GetDestination struct {
	Scheme string `protobuf:"bytes,1,opt,name=scheme,proto3" json:"scheme,omitempty"`
	Path   string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	// An opaque value that is set at injection-time and sent with destintion
	// lookups.
	//
	// If, for instance, the token encodes a namespace or some locality
	// information, the service may alter its results to take this locality into
	// account.
	ContextToken string `protobuf:"bytes,3,opt,name=context_token,json=contextToken,proto3" json:"context_token,omitempty"`
	// contains filtered or unexported fields
}

type Http2ClientParams struct {

	// Overrides the default client flow control settings.
	FlowControl *Http2ClientParams_FlowControl `protobuf:"bytes,1,opt,name=flow_control,json=flowControl,proto3" json:"flow_control,omitempty"`
	// Enables keep-alive timeouts.
	KeepAlive *Http2ClientParams_KeepAlive `protobuf:"bytes,2,opt,name=keep_alive,json=keepAlive,proto3" json:"keep_alive,omitempty"`
	// Configures Hyper internals.
	Internals *Http2ClientParams_Internals `protobuf:"bytes,3,opt,name=internals,proto3" json:"internals,omitempty"`
	// contains filtered or unexported fields
}

type Http2ClientParams_FlowControl struct {

	// Configures the maximum connection-level flow control window size.
	InitialConnectionWindowSize uint32 `` /* 147-byte string literal not displayed */
	// Configures the maximum stream-level flow control window size.
	InitialStreamWindowSize uint32 `` /* 135-byte string literal not displayed */
	// Enables Hyper's adaptive flow control, ignoring other window settings.
	AdaptiveFlowControl bool `protobuf:"varint,3,opt,name=adaptive_flow_control,json=adaptiveFlowControl,proto3" json:"adaptive_flow_control,omitempty"`
	// contains filtered or unexported fields
}

type Http2ClientParams_Internals struct {
	MaxConcurrentResetStreams uint32 `` /* 141-byte string literal not displayed */
	MaxFrameSize              uint32 `protobuf:"varint,2,opt,name=max_frame_size,json=maxFrameSize,proto3" json:"max_frame_size,omitempty"`
	MaxSendBufSize            uint32 `protobuf:"varint,3,opt,name=max_send_buf_size,json=maxSendBufSize,proto3" json:"max_send_buf_size,omitempty"`
	// contains filtered or unexported fields
}

type Http2ClientParams_KeepAlive struct {

	// The time between pings.
	Interval *duration.Duration `protobuf:"bytes,1,opt,name=interval,proto3" json:"interval,omitempty"`
	// The time to wait for a ping response before considering the connection
	// dead.
	Timeout *duration.Duration `protobuf:"bytes,2,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// Whether to send pings when there is no other traffic.
	WhileIdle bool `protobuf:"varint,3,opt,name=while_idle,json=whileIdle,proto3" json:"while_idle,omitempty"`
	// contains filtered or unexported fields
}

type HttpStatusRange struct {

	// Minimum matching http status code (inclusive), if specified.
	Min uint32 `protobuf:"varint,1,opt,name=min,proto3" json:"min,omitempty"`
	// Maximum matching http status code (inclusive), if specified.
	Max uint32 `protobuf:"varint,2,opt,name=max,proto3" json:"max,omitempty"`
	// contains filtered or unexported fields
}

type NoEndpoints struct {
	Exists bool `protobuf:"varint,1,opt,name=exists,proto3" json:"exists,omitempty"`
	// contains filtered or unexported fields
}

type PathMatch struct {

	// Match if the request path matches this regex.
	Regex string `protobuf:"bytes,1,opt,name=regex,proto3" json:"regex,omitempty"`
	// contains filtered or unexported fields
}

type ProtocolHint struct {

	// Types that are assignable to Protocol:
	//
	//	*ProtocolHint_H2_
	//	*ProtocolHint_Opaque_
	Protocol isProtocolHint_Protocol `protobuf_oneof:"protocol"`
	// When set, indicates that the target supports receiving opaque traffic
	// wrapped with the Linkerd connection header on the specified port.
	OpaqueTransport *ProtocolHint_OpaqueTransport `protobuf:"bytes,2,opt,name=opaque_transport,json=opaqueTransport,proto3" json:"opaque_transport,omitempty"`
	// contains filtered or unexported fields
}

type ProtocolHint_H2 struct {
	// contains filtered or unexported fields
}

type ProtocolHint_H2_ struct {
	// Hints that the service understands HTTP2 and the proxy's internal
	// http2-upgrade mechanism.
	H2 *ProtocolHint_H2 `protobuf:"bytes,1,opt,name=h2,proto3,oneof"`
}

type ProtocolHint_Opaque struct {
	// contains filtered or unexported fields
}

type ProtocolHint_OpaqueTransport struct {

	// The target proxy's inbound port.
	InboundPort uint32 `protobuf:"varint,1,opt,name=inbound_port,json=inboundPort,proto3" json:"inbound_port,omitempty"`
	// contains filtered or unexported fields
}

type ProtocolHint_Opaque_ struct {
	// Hints that the destination will handle this connection as an opaque TCP
	// stream, and (if `opaque_transport` is set) that the proxy should not send
	// a `SessionProtocol` as part of its transport header.
	Opaque *ProtocolHint_Opaque `protobuf:"bytes,3,opt,name=opaque,proto3,oneof"`
}

type RequestMatch struct {

	// Types that are assignable to Match:
	//
	//	*RequestMatch_All
	//	*RequestMatch_Any
	//	*RequestMatch_Not
	//	*RequestMatch_Path
	//	*RequestMatch_Method
	Match isRequestMatch_Match `protobuf_oneof:"match"`
	// contains filtered or unexported fields
}

type RequestMatch_All struct {
	All *RequestMatch_Seq `protobuf:"bytes,1,opt,name=all,proto3,oneof"`
}

type RequestMatch_Any struct {
	Any *RequestMatch_Seq `protobuf:"bytes,2,opt,name=any,proto3,oneof"`
}

type RequestMatch_Method struct {
	Method *http_types.HttpMethod `protobuf:"bytes,5,opt,name=method,proto3,oneof"` // TODO: match on arbitrary header
}

type RequestMatch_Not struct {
	Not *RequestMatch `protobuf:"bytes,3,opt,name=not,proto3,oneof"`
}

type RequestMatch_Path struct {
	Path *PathMatch `protobuf:"bytes,4,opt,name=path,proto3,oneof"`
}

type RequestMatch_Seq struct {
	Matches []*RequestMatch `protobuf:"bytes,1,rep,name=matches,proto3" json:"matches,omitempty"`
	// contains filtered or unexported fields
}

type ResponseClass struct {

	// This class contains responses which match this condition.
	Condition *ResponseMatch `protobuf:"bytes,1,opt,name=condition,proto3" json:"condition,omitempty"`
	// If responses in this class should be considered failures.  This defaults
	// to false (success).
	IsFailure bool `protobuf:"varint,2,opt,name=is_failure,json=isFailure,proto3" json:"is_failure,omitempty"`
	// contains filtered or unexported fields
}

type ResponseMatch struct {

	// Types that are assignable to Match:
	//
	//	*ResponseMatch_All
	//	*ResponseMatch_Any
	//	*ResponseMatch_Not
	//	*ResponseMatch_Status
	Match isResponseMatch_Match `protobuf_oneof:"match"`
	// contains filtered or unexported fields
}

type ResponseMatch_All struct {
	All *ResponseMatch_Seq `protobuf:"bytes,1,opt,name=all,proto3,oneof"`
}

type ResponseMatch_Any struct {
	Any *ResponseMatch_Seq `protobuf:"bytes,2,opt,name=any,proto3,oneof"`
}

type ResponseMatch_Not struct {
	Not *ResponseMatch `protobuf:"bytes,3,opt,name=not,proto3,oneof"`
}

type ResponseMatch_Seq struct {
	Matches []*ResponseMatch `protobuf:"bytes,1,rep,name=matches,proto3" json:"matches,omitempty"`
	// contains filtered or unexported fields
}

type ResponseMatch_Status struct {
	Status *HttpStatusRange `protobuf:"bytes,4,opt,name=status,proto3,oneof"` // TODO: match on arbitrary header or trailer
}

type RetryBudget struct {

	// The ratio of additional traffic that may be added by retries.  A
	// retry_ratio of 0.1 means that 1 retry may be attempted for every 10 regular
	// requests.  A retry_ratio of 1.0 means that 1 retry may be attempted for
	// every 1 regular request (in other words, total request load may be doubled
	// as a result of retries).
	RetryRatio float32 `protobuf:"fixed32,1,opt,name=retry_ratio,json=retryRatio,proto3" json:"retry_ratio,omitempty"`
	// The proxy may always attempt this number of retries per second, even if it
	// would violate the retry_ratio.  This is to allow retries to happen even
	// when the request rate is very low.
	MinRetriesPerSecond uint32 `protobuf:"varint,2,opt,name=min_retries_per_second,json=minRetriesPerSecond,proto3" json:"min_retries_per_second,omitempty"`
	// This duration indicates for how long requests should be considered for the
	// purposes of enforcing the retry_ratio.  A higher value considers a larger
	// window and therefore allows burstier retries.
	Ttl *duration.Duration `protobuf:"bytes,3,opt,name=ttl,proto3" json:"ttl,omitempty"`
	// contains filtered or unexported fields
}

type Route struct {

	// This route contains requests which match this condition.
	Condition *RequestMatch `protobuf:"bytes,1,opt,name=condition,proto3" json:"condition,omitempty"`
	// A list of response classes for this route.  If a response matches
	// more than one ResponseClass, the first match wins.  If a response does not
	// match any ResponseClasses, it is considered to be a successful response.
	ResponseClasses []*ResponseClass `protobuf:"bytes,2,rep,name=response_classes,json=responseClasses,proto3" json:"response_classes,omitempty"`
	// Metric labels to attach to requests and responses that match this route.
	MetricsLabels map[string]string `` /* 188-byte string literal not displayed */
	// If a route is retryable, any failed requests on that route may be retried
	// by the proxy.
	IsRetryable bool `protobuf:"varint,4,opt,name=is_retryable,json=isRetryable,proto3" json:"is_retryable,omitempty"`
	// After this time has elapsed since receiving the initial request, any
	// outstanding request will be cancelled, a timeout error response will be
	// returned, and no more retries will be attempted.
	Timeout *duration.Duration `protobuf:"bytes,5,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// contains filtered or unexported fields
}

type TlsIdentity struct {

	// Types that are assignable to Strategy:
	//
	//	*TlsIdentity_DnsLikeIdentity_
	//	*TlsIdentity_UriLikeIdentity_
	Strategy isTlsIdentity_Strategy `protobuf_oneof:"strategy"`
	// The server name of the endpoint. This is the value that needs to be included
	// by clients in the ClientHello SNI extension of the TLS handshake when they
	// initiate TLS connections to servers.
	ServerName *TlsIdentity_DnsLikeIdentity `protobuf:"bytes,4,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
	// contains filtered or unexported fields
}

type TlsIdentity_DnsLikeIdentity struct {

	// A DNS-like name that encodes workload coordinates.
	//
	// For example:
	//
	//	{name}.{namespace}.{type}.identity.{control-namespace}.{trust-domain...}
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

type TlsIdentity_DnsLikeIdentity_ struct {
	DnsLikeIdentity *TlsIdentity_DnsLikeIdentity `protobuf:"bytes,1,opt,name=dns_like_identity,json=dnsLikeIdentity,proto3,oneof"`
}

type TlsIdentity_UriLikeIdentity struct {

	// A URI name that encodes workload identity.
	//
	// For example:
	//
	//	spiffe://trust-domain/workload-dentifier
	Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"`
	// contains filtered or unexported fields
}

type TlsIdentity_UriLikeIdentity_ struct {
	UriLikeIdentity *TlsIdentity_UriLikeIdentity `protobuf:"bytes,3,opt,name=uri_like_identity,json=uriLikeIdentity,proto3,oneof"`
}

type UnimplementedDestinationServer struct {
}

type UnsafeDestinationServer interface {
	// contains filtered or unexported methods
}

type Update struct {

	// Types that are assignable to Update:
	//
	//	*Update_Add
	//	*Update_Remove
	//	*Update_NoEndpoints
	Update isUpdate_Update `protobuf_oneof:"update"`
	// contains filtered or unexported fields
}

type Update_Add struct {
	// A new set of endpoints are available for the service. The set might be
	// empty.
	Add *WeightedAddrSet `protobuf:"bytes,1,opt,name=add,proto3,oneof"`
}

type Update_NoEndpoints struct {
	// `no_endpoints{exists: false}` indicates that the service does not exist
	// and the client MAY try an alternate service discovery method (e.g. DNS).
	//
	// `no_endpoints(exists: true)` indicates that the service does exist and
	// the client MUST NOT fall back to an alternate service discovery method.
	NoEndpoints *NoEndpoints `protobuf:"bytes,3,opt,name=no_endpoints,json=noEndpoints,proto3,oneof"`
}

type Update_Remove struct {
	// Some endpoints have been removed from the service.
	Remove *AddrSet `protobuf:"bytes,2,opt,name=remove,proto3,oneof"`
}

type WeightedAddr struct {
	Addr              *net.TcpAddress    `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Weight            uint32             `protobuf:"varint,3,opt,name=weight,proto3" json:"weight,omitempty"`
	MetricLabels      map[string]string  `` /* 185-byte string literal not displayed */
	TlsIdentity       *TlsIdentity       `protobuf:"bytes,5,opt,name=tls_identity,json=tlsIdentity,proto3" json:"tls_identity,omitempty"`
	ProtocolHint      *ProtocolHint      `protobuf:"bytes,6,opt,name=protocol_hint,json=protocolHint,proto3" json:"protocol_hint,omitempty"`
	AuthorityOverride *AuthorityOverride `protobuf:"bytes,7,opt,name=authority_override,json=authorityOverride,proto3" json:"authority_override,omitempty"`
	// The HTTP/2 parameters to use when connecting to the destination, if HTTP/2
	// is used. These parameters are used by proxies when the application traffic
	// is HTTP/2 or when the H2 ProtocolHint is used to transport HTTP/1
	// connections over HTTP/2.
	Http2 *Http2ClientParams `protobuf:"bytes,8,opt,name=http2,proto3" json:"http2,omitempty"`
	// contains filtered or unexported fields
}

type WeightedAddrSet struct {
	Addrs        []*WeightedAddr   `protobuf:"bytes,1,rep,name=addrs,proto3" json:"addrs,omitempty"`
	MetricLabels map[string]string `` /* 185-byte string literal not displayed */
	// contains filtered or unexported fields
}

type WeightedDst struct {

	// This authority will be used as the `path` in a call to the Destination.Get
	// rpc.
	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	// The proportion of requests to send to this destination.  This value is
	// relative to other weights in the same dst_overrides list.
	Weight uint32 `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"`
	// contains filtered or unexported fields
}