plugin

type BaseCommit ¶

type BaseCommit func(http.ResponseWriter, *base.ResponseState)

type Binding ¶

type Binding struct {
	Plugin     Plugin
	Scope      Scope
	Stage      RequestStage
	Provenance ResourceProvenance
	// contains filtered or unexported fields
}

Binding is the immutable executor input for one materialized plugin. factoryName is intentionally private: callers must provide the exact registry/config key through BindPlugin rather than deriving it from GetName.

func BindPlugin(
	factoryName string,
	p Plugin,
	scope Scope,
	provenance ResourceProvenance,
) Binding

func BindPluginChecked(
	factoryName string,
	p Plugin,
	scope Scope,
	provenance ResourceProvenance,
) (Binding, error)

type BufferedResponseExecutor ¶

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

func NewBufferedResponseExecutor(
	static []Binding,
	terminal TerminalDescriptor,
	config base.BufferedResponseConfig,
) (*BufferedResponseExecutor, error)

func (e *BufferedResponseExecutor) PostResolutionHook(
	r *http.Request,
	effective EffectiveBindingSet,
) (*http.Request, error)

func (e *BufferedResponseExecutor) WithFinalResponseCommitter(
	committer FinalResponseCommitter,
) *BufferedResponseExecutor

func (e *BufferedResponseExecutor) WithStreamingResponseExecutor(
	streaming *StreamingResponseExecutor,
) *BufferedResponseExecutor

type Capability ¶

type Capability uint32

const (
	CapabilitySystem Capability = 1 << iota
	CapabilityRequestRewrite
	CapabilityConsumerRewrite
	CapabilityRequestAccess
	CapabilityBeforeProxy
	CapabilityConditionalTerminal
	CapabilityHeaderFilter
	CapabilityBufferedBodyFilter
	CapabilityFinalResponseStore
	CapabilityStreamingBodyFilter
	CapabilityCompressionOffer
	CapabilityStreamingResponseOwner
	CapabilityExclusiveProtocolOwner
	CapabilityProtocolOwner
	CapabilityLog
	CapabilityFinalizer
	CapabilityGenerationOwner
	CapabilitySeparateSubsystem
	CapabilityLogSanitizer
)

type CapabilitySpec ¶

type CapabilitySpec struct {
	Identity           string
	ImplementationName string
	Capabilities       Capability
	RequestOwners      []RequestOwnerKind
	ResponseOwners     []ResponseOwnerKind
	Finalizer          FinalizerKind
	GenerationOwner    GenerationOwnerKind
	PrimaryPlan        string
}

func CapabilitySpecForFactory(factory string) (CapabilitySpec, bool)

func CapabilitySpecForIdentity(identity string) (CapabilitySpec, bool)

type CompressionOfferPlugin ¶

type CompressionOfferPlugin interface {
	RegisterCompressionOffers(*http.Request, *compression.State) []compression.Offer
	WrapCompression(
		http.ResponseWriter,
		*http.Request,
		*compression.State,
		compression.Decision,
	) (http.ResponseWriter, error)
}

CompressionOfferPlugin is the root-owned structural contract. It keeps the complete Offer/State/Decision values from shared negotiation.

type CompressionSet ¶

type CompressionSet uint8

CompressionSet records structural content-coding offers without coupling the capability registry to a request-local compression.State.

const (
	CompressionOfferGzip CompressionSet = 1 << iota
	CompressionOfferDeflate
	CompressionOfferBrotli
)

type ConsumerBindingResolver ¶

type ConsumerBindingResolver func(*http.Request) (ConsumerResolution, error)

type ConsumerCacheKey ¶

type ConsumerCacheKey struct {
	ConsumerID     string
	ConsumerDigest [32]byte
	GroupID        string
	GroupDigest    [32]byte
	RouteID        string
	ServiceID      string
}

type ConsumerIdentity ¶

type ConsumerIdentity struct {
	Username   string
	GroupID    string
	AuthSource string
}

type ConsumerResolution ¶

type ConsumerResolution struct {
	Bindings []Binding
	Request  *http.Request
	CacheKey ConsumerCacheKey
	Identity ConsumerIdentity
	Resolved bool
}

type EffectiveBindingSet ¶

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

EffectiveBindingSet keeps the two Plan 14 partitions separate so response materialization can execute global/system winners before route/consumer winners without reconstructing them after the terminal returns.

type EnabledSet ¶

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

EnabledSet is the immutable membership snapshot used by a route build.

func NewEnabledSet(names []string) EnabledSet

func (s EnabledSet) Contains(name string) bool

type Executor ¶

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

Executor owns an immutable snapshot of either a legacy plugin list or scoped bindings, plus the response transform count captured at build time.

func NewExecutor(plugins ...Plugin) Executor

func NewScopedExecutor(bindings ...Binding) Executor

func (e Executor) Then(terminal http.Handler) http.Handler

type FinalResponseCommitter ¶

type FinalResponseCommitter interface {
	CommitFinalResponse(http.ResponseWriter, *http.Request, *base.ResponseState, BaseCommit)
}

type FinalizerKind ¶

type FinalizerKind uint8

const (
	FinalizerNone FinalizerKind = iota
	FinalizerSnapshot
	FinalizerDynamic
)

type GenerationOwnerKind ¶

type GenerationOwnerKind uint8

const (
	GenerationOwnerNone GenerationOwnerKind = iota
	GenerationOwnerProcess
	GenerationOwnerRoute
)

type LogBinding ¶

type LogBinding struct {
	Plugin     Plugin
	Scope      Scope
	Provenance ResourceProvenance
	Policy     base.LogCapturePolicy
}

type LogExecutor ¶

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

func NewLogExecutor(bindings []LogBinding) (LogExecutor, error)

func NewLogExecutorFromBindings(bindings []Binding) (LogExecutor, error)

func (e LogExecutor) Bindings() []LogBinding

func (e LogExecutor) Prepare(r *http.Request) (*http.Request, error)

func (e LogExecutor) RegisterComposite(r *http.Request) bool

func (e LogExecutor) SealAndRegister(r *http.Request) error

func (e LogExecutor) SealFinalRequest(r *http.Request) error

func (e LogExecutor) WithBindings(bindings []LogBinding) (LogExecutor, error)

type LogRequestState ¶

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

type Plugin ¶

type Plugin interface {
	Init() error
	PostInit() error
	Handler(next http.Handler) http.Handler
	Config() any
	GetSchema() string
	GetMetadataSchema() string
	GetPriority() int
	GetName() string
}

func New(name string) Plugin

type PostResolutionHook ¶

type PostResolutionHook func(*http.Request, EffectiveBindingSet) (*http.Request, error)

type ProtocolKind ¶

type ProtocolKind string

const (
	ProtocolNone      ProtocolKind = ""
	ProtocolAI        ProtocolKind = "ai"
	ProtocolGRPCWeb   ProtocolKind = "grpc-web"
	ProtocolKafka     ProtocolKind = "kafka"
	ProtocolDubbo     ProtocolKind = "dubbo"
	ProtocolHTTPDubbo ProtocolKind = "http-dubbo"
	ProtocolMQTT      ProtocolKind = "mqtt"
)

type RequestOwnerKind ¶

type RequestOwnerKind uint8

const (
	RequestOwnerNone RequestOwnerKind = iota
	RequestOwnerInheritedStage
	RequestOwnerBeforeProxyConsumer
	RequestOwnerBeforeProxyHookRegistration
	RequestOwnerRouteOwned
	RequestOwnerSeparateSubsystem
	RequestOwnerLegacyAdapter
)

func ResolveBeforeProxyOwner(factory string, config any) (RequestOwnerKind, bool, error)

type RequestPipeline ¶

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

RequestPipeline owns the explicit Plan 14 request order. Static bindings are cloned at construction; resolution data is merged per request so no mutable request, auth, or override state can leak between requests.

func NewRequestPipeline(bindings []Binding, resolve ConsumerBindingResolver) RequestPipeline

func (p RequestPipeline) Then(terminal http.Handler) http.Handler

func (p RequestPipeline) ThenWithPostResolutionHook(
	terminal http.Handler,
	hook PostResolutionHook,
) http.Handler

func (p RequestPipeline) WithBufferedResponseExecutor(
	executor *BufferedResponseExecutor,
) RequestPipeline

func (p RequestPipeline) WithLogExecutor(executor *LogExecutor) RequestPipeline

func (p RequestPipeline) WithStreamingResponseExecutor(
	executor *StreamingResponseExecutor,
) RequestPipeline

type RequestStage ¶

type RequestStage uint8

RequestStage identifies the request-stage owner for a plugin binding.

const (
	RequestStageLegacy RequestStage = iota
	RequestStageRewrite
	RequestStageConsumerRewrite
	RequestStageAccess
	RequestStageBeforeProxy
	RequestStageNone
)

type RequestStageSpec ¶

type RequestStageSpec struct {
	Stage                 RequestStage
	AuthenticatesConsumer bool
	ConsumerConfigOnly    bool
	AdaptLegacyHandler    bool
	ConfigAware           bool
}

RequestStageSpec describes the audited request-stage owner for one exact plugin factory key. AdaptLegacyHandler is set only for handlers audited for request-stage adaptation with no post-next work, response-writer wrapper, flush/hijack, logging, or deferred cleanup behavior.

func RequestStageFor(name string) (RequestStageSpec, bool)

func ResolveRequestStage(factoryKey string, config any) (RequestStageSpec, bool, error)

type ResolvedResponsePhases ¶

type ResolvedResponsePhases struct {
	Owners            []ResponseOwnerKind
	CompressionOffers CompressionSet
	ExclusiveProtocol ProtocolKind
}

func ResolveResponsePhases(factory string, config any) (ResolvedResponsePhases, error)

type ResourceKind ¶

type ResourceKind string

ResourceKind identifies the source resource that materialized a binding.

const (
	ResourceSystem        ResourceKind = "system"
	ResourceGlobalRule    ResourceKind = "global_rule"
	ResourceRoute         ResourceKind = "route"
	ResourceService       ResourceKind = "service"
	ResourcePluginConfig  ResourceKind = "plugin_config"
	ResourceConsumer      ResourceKind = "consumer"
	ResourceConsumerGroup ResourceKind = "consumer_group"
)

const ResourceUpstream ResourceKind = "upstream"

type ResourceProvenance ¶

type ResourceProvenance struct {
	Kind ResourceKind
	ID   string
}

ResourceProvenance is kept by value so diagnostics cannot lose the source identity while route/plugin configuration maps are merged.

type ResponseBinding ¶

type ResponseBinding struct {
	Plugin     Plugin
	Scope      Scope
	Provenance ResourceProvenance
	Phases     ResponsePhaseMask
	// contains filtered or unexported fields
}

func MaterializeResponseBindings(effective EffectiveBindingSet) ([]ResponseBinding, error)

type ResponseCapability ¶

type ResponseCapability struct {
	HeaderFilter           bool
	BufferedBodyFilter     bool
	StreamingBodyFilter    bool
	StreamingResponseOwner bool
	CompressionOffer       bool
	ExclusiveProtocol      ProtocolKind
	SeparateSubsystem      bool
}

ResponseCapability is the build-time declaration for response ownership. Request-stage ownership remains in RequestStageSpec; keeping these tables separate prevents a Handler type assertion from accidentally becoming a response phase declaration.

func ResponseCapabilityFor(factory string) (ResponseCapability, bool)

type ResponseCapabilityDescriber ¶

type ResponseCapabilityDescriber interface {
	DescribeResponseCapability() (ResponseCapability, error)
}

type ResponseCapabilityPlugin ¶

type ResponseCapabilityPlugin interface {
	ResponseCapability() ResponseCapability
}

type ResponseOwnerKind ¶

type ResponseOwnerKind uint8

const (
	ResponseOwnerNone ResponseOwnerKind = iota
	ResponseOwnerHeaderFilter
	ResponseOwnerBufferedBodyFilter
	ResponseOwnerFinalStore
	ResponseOwnerStreamingHeaderFilter
	ResponseOwnerStreamingBodyFilter
	ResponseOwnerCompressionOffer
	ResponseOwnerStreamingProducer
	ResponseOwnerExclusiveProtocol
	ResponseOwnerSeparateSubsystemProtocol
)

type ResponsePhaseMask ¶

type ResponsePhaseMask uint8

const (
	ResponsePhaseHeader ResponsePhaseMask = 1 << iota
	ResponsePhaseBufferedBody
	ResponsePhaseFinalStore
)

type ResponsePlan ¶

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

ResponsePlan is an immutable generation recipe. Slices are private and every accessor returns a copy; request-local dynamic materialization never mutates the published generation.

func BuildResponsePlan(input any) (ResponsePlan, error)

func (p ResponsePlan) BufferedBindings() []ResponseBinding

func (p ResponsePlan) BufferedConfig() base.BufferedResponseConfig

func (p ResponsePlan) Install(pipeline RequestPipeline, terminal http.Handler) http.Handler

func (p ResponsePlan) Materialize(effective EffectiveBindingSet) (ResponsePlan, error)

func (p ResponsePlan) PostResolutionHook(r *http.Request, effective EffectiveBindingSet) (*http.Request, error)

func (p ResponsePlan) RouteTerminals() []RouteTerminalCandidate

func (p ResponsePlan) StaticBindings() []Binding

func (p ResponsePlan) StreamingBindings() []Binding

type ResponsePlanInput ¶

type ResponsePlanInput struct {
	StaticBindings []Binding
	RouteTerminals []RouteTerminalCandidate
	BufferedConfig base.BufferedResponseConfig
}

type RouteTerminalCandidate ¶

type RouteTerminalCandidate struct {
	Identity   string
	Scope      Scope
	Priority   int
	Provenance ResourceProvenance
	Protocol   ProtocolKind
	Terminal   base.ExclusiveProtocolTerminal
}

type Scope ¶

type Scope uint8

Scope identifies the materialized source scope of a plugin binding.

const (
	ScopeSystem Scope = iota
	ScopeGlobal
	ScopeRoute
	ScopeConsumer
)

type SecretMaterializer ¶

type SecretMaterializer = base.SecretMaterializer

SecretMaterializer resolves generation-owned credentials after schema decoding and before PostInit. Implementations must retain only redacted descriptors in their public config.

type StreamingResponseExecutor ¶

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

StreamingResponseExecutor owns streaming header filters, body wrappers and the optional exclusive protocol owner for one generation. It is immutable; all per-request state lives in the returned handler/writer chain.

func NewStreamingResponseExecutor(bindings []Binding) (*StreamingResponseExecutor, error)

func (e *StreamingResponseExecutor) Bindings() []Binding

func (e *StreamingResponseExecutor) CommitResponse(
	w http.ResponseWriter,
	r *http.Request,
	state *base.ResponseState,
	commit BaseCommit,
) error

func (e *StreamingResponseExecutor) PostResolutionHook(
	r *http.Request,
	effective EffectiveBindingSet,
) (*http.Request, error)

func (e *StreamingResponseExecutor) RunExclusiveProtocol(
	w http.ResponseWriter,
	r *http.Request,
	next http.Handler,
) (*http.Request, base.ProtocolDisposition, error)

func (e *StreamingResponseExecutor) Then(next http.Handler) http.Handler

func (e *StreamingResponseExecutor) WithRouteTerminals(
	terminals []RouteTerminalCandidate,
) (*StreamingResponseExecutor, error)

type TerminalDescriptor ¶

type TerminalDescriptor struct {
	Owner      TerminalOwner
	Provenance ResourceProvenance
}

type TerminalOwner ¶

type TerminalOwner uint8

const (
	TerminalOwnerOrdinaryProxy TerminalOwner = iota
	TerminalOwnerGlobalNotFound
	TerminalOwnerAIRuntime
	TerminalOwnerKafka
	TerminalOwnerDubbo
	TerminalOwnerHTTPDubbo
)