Documentation
¶
Overview ¶
Package proxy hosts the embedded L7/L4 proxy (tasks T-41..T-48). This file freezes the RouteSource contract between the route-table client and the proxy/DNS/VIP consumers.
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type L4 ¶
type L4 struct {
// contains filtered or unexported fields
}
L4 is the raw TCP passthrough proxy (spec F5). It reconciles one listener per L4Route.public_port to the current RouteSnapshot, and for each accepted connection picks a healthy backend (P2C) and splices bytes both ways.
type L7 ¶
type L7 struct {
// Activate is the scale-to-zero hook (T-71). Nil for now.
Activate func(envID string)
// DisableHTTPSRedirect serves plaintext requests directly instead of
// 308-redirecting them to HTTPS. Single-node/dev sets this: HTTPS runs on a
// non-standard port with a self-signed cert, so a bare https:// redirect
// would be broken (T-54).
DisableHTTPSRedirect bool
// contains filtered or unexported fields
}
L7 is the ingress HTTP reverse proxy: it matches a request to a route from the current RouteSnapshot, load-balances across the route's healthy endpoints (P2C), applies per-route middleware, and proxies. It serves both the :80 and :443 listeners (HTTPS redirect happens on the plaintext side).
type RouteClient ¶
type RouteClient struct {
// contains filtered or unexported fields
}
RouteClient keeps a WatchRoutes stream, persists each snapshot to disk, and implements proxy.RouteSource. It loads the last snapshot at startup so a node keeps serving traffic while the control plane is unreachable (spec §7).
func NewRouteClient ¶
func NewRouteClient(dialer RouteDialer, nodeID, path string, log *slog.Logger) *RouteClient
NewRouteClient constructs the client. path is where snapshots are cached.
func (*RouteClient) Current ¶
func (c *RouteClient) Current() *clusterv1.RouteSnapshot
Current returns the latest snapshot (never nil).
func (*RouteClient) Run ¶
func (c *RouteClient) Run(ctx context.Context)
Run keeps the WatchRoutes stream alive, applying each snapshot and reconnecting with backoff. It returns when ctx is canceled.
func (*RouteClient) Updates ¶
func (c *RouteClient) Updates(ctx context.Context) <-chan *clusterv1.RouteSnapshot
Updates returns a channel receiving each new snapshot until ctx is canceled.
type RouteDialer ¶
type RouteDialer interface {
WatchRoutes(ctx context.Context, haveVersion uint64) (RouteStream, error)
}
RouteDialer opens a WatchRoutes stream to a control node (over node mTLS). The daemon supplies the concrete transport; tests inject a fake.
type RouteSource ¶
type RouteSource interface {
// Current returns the latest snapshot (never nil; may be an empty
// snapshot with Version 0 before the first sync).
Current() *clusterv1.RouteSnapshot
// Updates returns a channel receiving each new snapshot. The channel is
// closed when ctx is canceled. Slow consumers may miss intermediate
// versions but always eventually receive the latest.
Updates(ctx context.Context) <-chan *clusterv1.RouteSnapshot
}
RouteSource provides the current route table and change notifications. Implementations: the RouteStream gRPC client with disk cache (T-42), a static source for tests, and a direct in-process source on control nodes.
type RouteStream ¶
type RouteStream interface {
Recv() (*clusterv1.RouteSnapshot, error)
}
RouteStream is the receive side of a WatchRoutes stream.
type StaticRouteSource ¶
type StaticRouteSource struct {
Snapshot *clusterv1.RouteSnapshot
}
StaticRouteSource serves a fixed snapshot (tests, and the bootstrap window before the first stream sync).
func (*StaticRouteSource) Current ¶
func (s *StaticRouteSource) Current() *clusterv1.RouteSnapshot
func (*StaticRouteSource) Updates ¶
func (s *StaticRouteSource) Updates(ctx context.Context) <-chan *clusterv1.RouteSnapshot
Source Files