dataplane

Documentation

Overview

Package dataplane translates Graph representation of the cluster state into an intermediate representation of data plane configuration. We can think of it as an intermediate state between the cluster resources and NGINX configuration files.

The package includes: - The types to hold the intermediate representation. - The functions to translate the Graph into the representation.

Index

• type Configuration
  • func BuildConfiguration(ctx context.Context, g *graph.Graph, resolver resolver.ServiceResolver) Configuration
• type Filters
• type InvalidFilter
• type MatchRule
  • func (r *MatchRule) GetMatch() v1beta1.HTTPRouteMatch
• type PathRule
• type SSL
• type Upstream
• type VirtualServer

Types

type Configuration

type Configuration struct {
	// HTTPServers holds all HTTPServers.
	// FIXME(pleshakov) We assume that all servers are HTTP and listen on port 80.
	HTTPServers []VirtualServer
	// SSLServers holds all SSLServers.
	// FIXME(kate-osborn) We assume that all SSL servers listen on port 443.
	SSLServers []VirtualServer
	// Upstreams holds all unique Upstreams.
	Upstreams []Upstream
	// BackendGroups holds all unique BackendGroups.
	// FIXME(pleshakov): Ensure Configuration doesn't include types from the graph package.
	BackendGroups []graph.BackendGroup
}

Configuration is an intermediate representation of dataplane configuration.

func BuildConfiguration

func BuildConfiguration(ctx context.Context, g *graph.Graph, resolver resolver.ServiceResolver) Configuration

BuildConfiguration builds the Configuration from the Graph. FIXME(pleshakov) For now we only handle paths with prefix matches. Handle exact and regex matches

type Filters

type Filters struct {
	InvalidFilter   *InvalidFilter
	RequestRedirect *v1beta1.HTTPRequestRedirectFilter
}

Filters hold the filters for a MatchRule.

type InvalidFilter

type InvalidFilter struct{}

InvalidFilter is a special filter for handling the case when configured filters are invalid.

type MatchRule

type MatchRule struct {
	// Filters holds the filters for the MatchRule.
	Filters Filters
	// Source is the corresponding HTTPRoute resource.
	// FIXME(pleshakov): Consider referencing only the parts needed for the config generation rather than
	// the entire resource.
	Source *v1beta1.HTTPRoute
	// BackendGroup is the group of Backends that the rule routes to.
	BackendGroup graph.BackendGroup
	// MatchIdx is the index of the rule in the Rule.Matches.
	MatchIdx int
	// RuleIdx is the index of the corresponding rule in the HTTPRoute.
	RuleIdx int
}

MatchRule represents a routing rule. It corresponds directly to a Match in the HTTPRoute resource. An HTTPRoute is guaranteed to have at least one rule with one match. If no rule or match is specified by the user, the default rule {{path:{ type: "PathPrefix", value: "/"}}} is set by the schema.

func (*MatchRule) GetMatch

func (r *MatchRule) GetMatch() v1beta1.HTTPRouteMatch

GetMatch returns the HTTPRouteMatch of the Route .

type PathRule

type PathRule struct {
	// Path is a path. For example, '/hello'.
	Path string
	// MatchRules holds routing rules.
	MatchRules []MatchRule
}

PathRule represents routing rules that share a common path.

type SSL

type SSL struct {
	// CertificatePath is the path to the certificate file.
	CertificatePath string
}

type Upstream

type Upstream struct {
	// Name is the name of the Upstream. Will be unique for each service/port combination.
	Name string
	// ErrorMsg contains the error message if the Upstream is invalid.
	ErrorMsg string
	// Endpoints are the endpoints of the Upstream.
	Endpoints []resolver.Endpoint
}

type VirtualServer

type VirtualServer struct {
	// SSL holds the SSL configuration options for the server.
	SSL *SSL
	// Hostname is the hostname of the server.
	Hostname string
	// PathRules is a collection of routing rules.
	PathRules []PathRule
	// IsDefault indicates whether the server is the default server.
	IsDefault bool
}

VirtualServer is a virtual server.