tcp

type DeniedError ¶ added in v0.2.31

type DeniedError struct {
	Status int
	Reason string
}

DeniedError is the admission gate refusing one event (a suspended tenant, a rate limit). The handler says so in its protocol's words and closes.

func (e *DeniedError) Error() string

type Event ¶ added in v0.2.31

type Event struct {
	// Body is the raw protocol unit (a line, a frame) → `@client.body`,
	// base64. nil leaves the field off.
	Body []byte
	// Facts are the handler's parsed view of it → `@<src>.<key>`. A key may
	// be a dotted path. The line handler has none: `@tcp.*` is the head's.
	Facts map[string]any
}

Event is what a handler contributes to one run. The envelope's source is the handler's own name (`@src == "irc"` for a handler registered as "irc"; "tcp" for the line handler), its facts land under that name, and the connection's `@tcp.*` facts, `@client.ip` and the route ride along, chassis-stamped. A handler cannot write anywhere else in `_txc`.

type Handler ¶ added in v0.2.31

type Handler interface {
	ServeConn(ctx context.Context, rc RoutedConn) error
}

Handler speaks one protocol on a connection the head has already accepted. Everything before the first protocol byte is the head's: the accept gate and caps, the TLS handshake or the edge's PROXY header, the connect run that routes the connection and lets the stack refuse it, the per-tenant slot, drain. ServeConn gets the byte stream and the routing outcome, and turns protocol traffic into events with RoutedConn.Emit.

One Handler serves every connection on its listener, concurrently. ServeConn returns when the connection is finished — nil for an ordinary end (the peer hung up, the protocol said goodbye), an error naming why otherwise; the head logs it and closes the socket either way. ctx is cancelled at chassis shutdown, and the head closes the socket then too, so a blocked Read returns.

type HandlerFactory ¶ added in v0.2.31

type HandlerFactory func(pu *processor.Unit) Handler

HandlerFactory builds a listener's Handler at bind time.

type RouteResolver ¶ added in v0.2.31

type RouteResolver interface {
	ResolveErr(key ingress.RouteKey) (ingress.RouteTarget, bool, error)
}

RouteResolver is the data-plane resolver detect-tenant uses (ingress.DBResolver.ResolveErr); the head asks it whether a pinned connection's route still stands.

type RouteStamp ¶ added in v0.2.31

type RouteStamp struct {
	Tenant, Stack, Ingress string
	HostnameVerified       bool
}

RouteStamp is a connection's pinned route: what `_txc.route.*` carries on each of its events.

type RoutedConn ¶ added in v0.2.31

type RoutedConn struct {
	// Conn is the application byte stream: decrypted on a `;tls` listener,
	// past the PROXY header on a `;proxy=` one. The head closes it when
	// ServeConn returns.
	Conn net.Conn

	RID      string
	Listener string

	Tenant, Stack string // where the connect run routed the connection
	Host          string // @tcp.host — canonical; "" when routed by listener

	TLS              bool
	ALPN, TLSVersion string

	ClientIP              string
	RemotePort, LocalPort int

	// Route is the whole route the connect run promoted; Emit stamps it on
	// every later event.
	Route RouteStamp

	// Emit runs one event for this connection through the pipeline and
	// waits for the outcome. The event enters the stack the connection is
	// pinned to — the route is pre-stamped, not re-decided per event —
	// after the head has checked that route still stands; admission still
	// runs on every event. Any error means the connection is over:
	// ErrRerouted, a *DeniedError, a timeout, a failed run, shutdown.
	Emit func(ctx context.Context, ev Event) (event.DispatchResult, error)

	// AddFuel charges the connection for work the handler does itself,
	// outside any run — answering a keepalive, parsing, fan-out. The head
	// already charges the connect and every byte through Conn; all of it
	// is billed on the connection's next event (see meter). Costs follow
	// docs/advanced/fuel.md: 1 fuel ≈ 100µs of chassis work.
	AddFuel func(fuel int64)
}

RoutedConn is one accepted connection as a Handler sees it. Every field is the head's own observation or the bus loop's trusted routing outcome (event.DispatchResult) — a handler never parses identity out of an envelope, and never out of what the client sent.

type TCPController ¶

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

TCPController is the raw socket head. It owns every accepted net.Conn end to end: the accept loop admits it, the connect run through _sys/boot decides whether it stays open (and which tenant and stack it belongs to), and the listener's protocol Handler — by default the line handler, one bounded event per newline-terminated line — serves it until the stack hangs up, the peer goes quiet, or the chassis shuts down.

A `;tls` listener terminates TLS here and stamps the SNI hostname as `@tcp.host`, the connection's routing fact. A `;proxy=` listener sits behind an edge that already terminated TLS and fills the same fields from the edge's PROXY v2 header (chassis/edgeproxy), so a stack never sees which side did the handshake. Routing itself stays in `_sys/boot`: detect-tenant reads `@tcp.host`, route promotes it, and the head only learns the outcome (event.DispatchResult).

func NewController(ctx context.Context, pu *processor.Unit) *TCPController

func (tcp *TCPController) Addrs() []net.Addr

func (tcp *TCPController) SetResolver(r RouteResolver)

func (tcp *TCPController) SetTLSConfig(t *tls.Config)

func (tcp *TCPController) Start()

func (tcp *TCPController) Stop()

func (tcp *TCPController) WantsManagedTLS() bool