xds

type Attachment ¶ added in v1.8.1

type Attachment struct {
	Type AttachmentType
	Name string
	// Service indicates service for the attachments.
	// For Dataplane AttachmentType it's empty since we are not matching to a specific service.
	Service string
}

type AttachmentList ¶ added in v1.8.1

type AttachmentList []Attachment

func (a AttachmentList) Len() int

func (a AttachmentList) Less(i, j int) bool

func (a AttachmentList) Swap(i, j int)

type AttachmentMap ¶ added in v1.8.1

type AttachmentMap map[Attachment]PoliciesByResourceType

func GroupByAttachment(matchedPolicies *MatchedPolicies, networking *mesh_proto.Dataplane_Networking) AttachmentMap

type AttachmentType ¶ added in v1.8.1

type AttachmentType int64

const (
	Inbound AttachmentType = iota
	Outbound
	Service
	Dataplane
)

func (s AttachmentType) String() string

type Attachments ¶ added in v1.8.1

type Attachments map[Attachment][]core_model.Resource

func BuildAttachments(matchedPolicies *MatchedPolicies, networking *mesh_proto.Dataplane_Networking) Attachments

type AttachmentsByPolicy ¶ added in v1.8.1

type AttachmentsByPolicy map[PolicyKey]AttachmentList

func GroupByPolicy(matchedPolicies *MatchedPolicies, networking *mesh_proto.Dataplane_Networking) AttachmentsByPolicy

func (abp AttachmentsByPolicy) Merge(other AttachmentsByPolicy)

type CLACache ¶

type CLACache interface {
	GetCLA(ctx context.Context, meshName, meshHash string, cluster envoy_common.Cluster, apiVersion envoy_common.APIVersion, endpointMap EndpointMap) (proto.Message, error)
}

type CaRequest ¶ added in v1.8.1

type CaRequest interface {
	MeshName() []string
	Name() string
}

type CaSecret ¶

type CaSecret struct {
	PemCerts [][]byte
}

type CircuitBreakerMap ¶

type CircuitBreakerMap map[ServiceName]*core_mesh.CircuitBreakerResource

CircuitBreakerMap holds the most specific CircuitBreaker for each reachable service.

type DataplaneMetadata ¶

type DataplaneMetadata struct {
	Resource        model.Resource
	AdminPort       uint32
	DNSPort         uint32
	EmptyDNSPort    uint32
	DynamicMetadata map[string]string
	ProxyType       mesh_proto.ProxyType
	Version         *mesh_proto.Version
	Features        Features
}

DataplaneMetadata represents environment-specific part of a dataplane configuration.

This information might change from one dataplane run to another, and therefore it cannot be a part of Dataplane resource.

On start-up, a dataplane captures its effective configuration (that might come from a file, environment variables and command line options) and includes it into request for a bootstrap config. Control Plane can use this information to fill in node metadata in the bootstrap config. Envoy will include node metadata from the bootstrap config at least into the very first discovery request on every xDS stream. This way, xDS server will be able to use Envoy node metadata to generate xDS resources that depend on environment-specific configuration.

func DataplaneMetadataFromXdsMetadata(xdsMetadata *structpb.Struct) *DataplaneMetadata

func (m *DataplaneMetadata) GetAdminPort() uint32

func (m *DataplaneMetadata) GetDNSPort() uint32

func (m *DataplaneMetadata) GetDataplaneResource() *core_mesh.DataplaneResource

func (m *DataplaneMetadata) GetDynamicMetadata(key string) string

func (m *DataplaneMetadata) GetEmptyDNSPort() uint32

func (m *DataplaneMetadata) GetProxyType() mesh_proto.ProxyType

func (m *DataplaneMetadata) GetVersion() *mesh_proto.Version

func (m *DataplaneMetadata) GetZoneEgressResource() *core_mesh.ZoneEgressResource

func (m *DataplaneMetadata) GetZoneIngressResource() *core_mesh.ZoneIngressResource

type DestinationMap ¶

type DestinationMap map[ServiceName]TagSelectorSet

DestinationMap holds a set of selectors for all reachable Dataplanes grouped by service name. DestinationMap is based on ServiceName and not on the OutboundInterface because TrafficRoute can introduce new service destinations that were not included in a outbound section. Policies that match on outbound connections also match by service destination name and not outbound interface for the same reason.

type Endpoint ¶

type Endpoint struct {
	Target          string
	UnixDomainPath  string
	Port            uint32
	Tags            map[string]string
	Weight          uint32
	Locality        *Locality
	ExternalService *ExternalService
}

Endpoint holds routing-related information about a single endpoint.

func (e Endpoint) ContainsTags(tags map[string]string) bool

func (e Endpoint) HasLocality() bool

func (e Endpoint) IsExternalService() bool

func (e Endpoint) IsReachableFromZone(localZone string) bool

func (e Endpoint) LocalityString() string

type EndpointList ¶

type EndpointList []Endpoint

EndpointList is a list of Endpoints with convenience methods.

func (l EndpointList) Filter(selector mesh_proto.TagSelector) EndpointList

type EndpointMap ¶

type EndpointMap map[ServiceName][]Endpoint

EndpointMap holds routing-related information about a set of endpoints grouped by service name.

type ExternalService ¶

type ExternalService struct {
	TLSEnabled         bool
	CaCert             []byte
	ClientCert         []byte
	ClientKey          []byte
	AllowRenegotiation bool
	ServerName         string
}

type ExternalServiceFaultInjectionMap ¶ added in v1.8.1

type ExternalServiceFaultInjectionMap map[ServiceName][]*core_mesh.FaultInjectionResource

type ExternalServicePermissionMap ¶ added in v1.8.1

type ExternalServicePermissionMap map[ServiceName]*core_mesh.TrafficPermissionResource

type ExternalServiceRateLimitMap ¶ added in v1.8.1

type ExternalServiceRateLimitMap map[ServiceName][]*core_mesh.RateLimitResource

type FaultInjectionMap ¶

type FaultInjectionMap map[mesh_proto.InboundInterface][]*core_mesh.FaultInjectionResource

FaultInjectionMap holds all matched FaultInjectionResources for each InboundInterface

type Features ¶ added in v1.8.1

type Features map[string]bool

Features is a set of features which a data plane has enabled.

func (f Features) HasFeature(feature string) bool

type HealthCheckMap ¶

type HealthCheckMap map[ServiceName]*core_mesh.HealthCheckResource

HealthCheckMap holds the most specific HealthCheck for each reachable service.

type IdentityCertRequest ¶ added in v1.8.1

type IdentityCertRequest interface {
	Name() string
}

type IdentitySecret ¶

type IdentitySecret struct {
	PemCerts [][]byte
	PemKey   []byte
}

type InboundRateLimitsMap ¶ added in v1.8.1

type InboundRateLimitsMap map[mesh_proto.InboundInterface][]*core_mesh.RateLimitResource

InboundRateLimitsMap holds all RateLimitResources for each InboundInterface

type Locality ¶

type Locality struct {
	Zone     string
	Priority uint32
}

type MatchedPolicies ¶

type MatchedPolicies struct {
	// Inbound(Listener) -> Policy
	TrafficPermissions    TrafficPermissionMap
	FaultInjections       FaultInjectionMap
	RateLimitsInbound     InboundRateLimitsMap
	CustomInboundPolicies []map[mesh_proto.InboundInterface]core_model.Resource

	// Service(Cluster) -> Policy
	TrafficLogs     TrafficLogMap
	HealthChecks    HealthCheckMap
	CircuitBreakers CircuitBreakerMap
	Retries         RetryMap

	// Outbound(Listener) -> Policy
	Timeouts           TimeoutMap
	RateLimitsOutbound OutboundRateLimitsMap
	// Actual Envoy Configuration is generated without taking this TrafficRoutes into account
	TrafficRoutes RouteMap

	// Dataplane -> Policy
	TrafficTrace *core_mesh.TrafficTraceResource
	// Actual Envoy Configuration is generated without taking this ProxyTemplate into account
	ProxyTemplate *core_mesh.ProxyTemplateResource
}

type MeshName ¶ added in v1.8.1

type MeshName = string

type MeshResources ¶ added in v1.8.1

type MeshResources struct {
	Mesh                           *core_mesh.MeshResource
	TrafficRoutes                  []*core_mesh.TrafficRouteResource
	ExternalServices               []*core_mesh.ExternalServiceResource
	ExternalServicePermissionMap   ExternalServicePermissionMap
	EndpointMap                    EndpointMap
	ExternalServiceFaultInjections ExternalServiceFaultInjectionMap
	ExternalServiceRateLimits      ExternalServiceRateLimitMap
}

type OutboundRateLimitsMap ¶ added in v1.8.1

type OutboundRateLimitsMap map[mesh_proto.OutboundInterface]*core_mesh.RateLimitResource

OutboundRateLimitsMap holds the RateLimitResource for each OutboundInterface

type PoliciesByResourceType ¶ added in v1.8.1

type PoliciesByResourceType map[core_model.ResourceType][]core_model.Resource

type PolicyKey ¶ added in v1.8.1

type PolicyKey struct {
	Type core_model.ResourceType
	Key  core_model.ResourceKey
}

type Proxy ¶

type Proxy struct {
	Id                  ProxyId
	APIVersion          envoy_common.APIVersion // todo(jakubdyszkiewicz) consider moving APIVersion here. pkg/core should not depend on pkg/xds. It should be other way around.
	Dataplane           *core_mesh.DataplaneResource
	ZoneIngress         *core_mesh.ZoneIngressResource
	Metadata            *DataplaneMetadata
	Routing             Routing
	Policies            MatchedPolicies
	EnvoyAdminMTLSCerts ServerSideMTLSCerts

	// SecretsTracker allows us to track when a generator references a secret so
	// we can be sure to include only those secrets later on.
	SecretsTracker SecretsTracker

	// ZoneEgressProxy is available only when XDS is generated for ZoneEgress data plane proxy.
	ZoneEgressProxy *ZoneEgressProxy
	// ZoneIngressProxy is available only when XDS is generated for ZoneIngress data plane proxy.
	ZoneIngressProxy *ZoneIngressProxy
}

Proxy contains required data for generating XDS config that is specific to a data plane proxy. The data that is specific for the whole mesh should go into MeshContext.

type ProxyId ¶

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

func BuildProxyId(mesh, name string) *ProxyId

func FromResourceKey(key core_model.ResourceKey) ProxyId

func ParseProxyIdFromString(id string) (*ProxyId, error)

func (id *ProxyId) String() string

func (id *ProxyId) ToResourceKey() core_model.ResourceKey

type RateLimitsMap ¶

type RateLimitsMap struct {
	Inbound  InboundRateLimitsMap
	Outbound OutboundRateLimitsMap
}

type Resource ¶

type Resource struct {
	Name     string
	Origin   string
	Resource ResourcePayload
}

Resource represents a generic xDS resource with name and version.

type ResourceList ¶

type ResourceList []*Resource

ResourceList represents a list of generic xDS resources.

func (rs ResourceList) Len() int

func (rs ResourceList) Less(i, j int) bool

func (rs ResourceList) Payloads() []ResourcePayload

func (rs ResourceList) Swap(i, j int)

func (rs ResourceList) ToDeltaDiscoveryResponse() (*envoy_sd.DeltaDiscoveryResponse, error)

func (rs ResourceList) ToIndex() map[string]ResourcePayload

type ResourcePayload ¶

type ResourcePayload = envoy_types.Resource

ResourcePayload is a convenience type alias.

type ResourceSet ¶

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

ResourceSet represents a set of generic xDS resources.

func NewResourceSet() *ResourceSet

func (s *ResourceSet) Add(resources ...*Resource) *ResourceSet

func (s *ResourceSet) AddSet(set *ResourceSet) *ResourceSet

func (s *ResourceSet) Contains(name string, resource ResourcePayload) bool

func (s *ResourceSet) Empty() bool

func (s *ResourceSet) List() ResourceList

func (s *ResourceSet) ListOf(typ string) ResourceList

func (s *ResourceSet) Remove(typ string, name string)

func (s *ResourceSet) ResourceTypes() []string

func (s *ResourceSet) Resources(typ string) map[string]*Resource

type RetryMap ¶

type RetryMap map[ServiceName]*core_mesh.RetryResource

RetryMap holds the most specific Retry for each reachable service.

type RouteMap ¶

type RouteMap map[mesh_proto.OutboundInterface]*core_mesh.TrafficRouteResource

RouteMap holds the most specific TrafficRoute for each outbound interface of a Dataplane.

type Routing ¶

type Routing struct {
	TrafficRoutes   RouteMap
	OutboundTargets EndpointMap
}

type SecretsTracker ¶ added in v1.8.1

type SecretsTracker interface {
	RequestIdentityCert() IdentityCertRequest
	RequestCa(mesh string) CaRequest
	RequestAllInOneCa() CaRequest

	UsedIdentity() bool
	UsedCas() map[string]struct{}
	UsedAllInOne() bool
}

SecretsTracker provides a way to ask for a secret and keeps track of which are used, so that they can later be generated and included in the resources.

func NewSecretsTracker(ownMesh string, allMeshes []string) SecretsTracker

type ServerSideMTLSCerts ¶ added in v1.8.1

type ServerSideMTLSCerts struct {
	CaPEM      []byte
	ServerPair util_tls.KeyPair
}

type ServiceName ¶

type ServiceName = string

ServiceName is a convenience type alias to clarify the meaning of string value.

type SocketAddressProtocol ¶

type SocketAddressProtocol int32

SocketAddressProtocol is the L4 protocol the listener should bind to

const (
	SocketAddressProtocolTCP SocketAddressProtocol = 0
	SocketAddressProtocolUDP SocketAddressProtocol = 1
)

type StreamID ¶

type StreamID = int64

StreamID represents a stream opened by XDS

type TagSelectorSet ¶

type TagSelectorSet []mesh_proto.TagSelector

TagSelectorSet is a set of unique TagSelectors.

func (s TagSelectorSet) Add(new mesh_proto.TagSelector) TagSelectorSet

func (s TagSelectorSet) Matches(tags map[string]string) bool

type TimeoutMap ¶

type TimeoutMap map[mesh_proto.OutboundInterface]*core_mesh.TimeoutResource

TimeoutMap holds the most specific TimeoutResource for each OutboundInterface

type TrafficLogMap ¶ added in v1.8.1

type TrafficLogMap map[ServiceName]*core_mesh.TrafficLogResource

TrafficLogMap holds the most specific TrafficLog for each outbound interface of a Dataplane.

type TrafficPermissionMap ¶

type TrafficPermissionMap map[mesh_proto.InboundInterface]*core_mesh.TrafficPermissionResource

TrafficPermissionMap holds the most specific TrafficPermissionResource for each InboundInterface

type VIPDomains ¶ added in v1.8.1

type VIPDomains struct {
	Address string
	Domains []string
}

type ZoneEgressProxy ¶ added in v1.8.1

type ZoneEgressProxy struct {
	ZoneEgressResource *core_mesh.ZoneEgressResource
	ZoneIngresses      []*core_mesh.ZoneIngressResource
	MeshResourcesList  []*MeshResources
}

type ZoneIngressProxy ¶ added in v1.8.1

type ZoneIngressProxy struct {
	TrafficRouteList *core_mesh.TrafficRouteResourceList
	GatewayRoutes    *core_mesh.MeshGatewayRouteResourceList
	MeshGateways     *core_mesh.MeshGatewayResourceList
}