bind

type AcmeTLSConfig ¶

type AcmeTLSConfig struct {
	Domains  []string
	CacheDir string
}

AcmeTLSConfig acme@tls.TLS

func (m AcmeTLSConfig) MarshalJSON() ([]byte, error)

type AddRequestHeaderNetHTTPHandlerConfig ¶

type AddRequestHeaderNetHTTPHandlerConfig struct {
	Key   string
	Value string
}

AddRequestHeaderNetHTTPHandlerConfig add_request_header@net/http.Handler

func (m AddRequestHeaderNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type AddResponseHeaderNetHTTPHandlerConfig ¶

type AddResponseHeaderNetHTTPHandlerConfig struct {
	Key   string
	Value string
}

AddResponseHeaderNetHTTPHandlerConfig add_response_header@net/http.Handler

func (m AddResponseHeaderNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type Component ¶

type Component interface {
	// contains filtered or unexported methods
}

Component is basic definition of Component

type ComponentsOnceConfig ¶

type ComponentsOnceConfig struct {
	Components []Component
}

ComponentsOnceConfig components@once.Once

func (m ComponentsOnceConfig) MarshalJSON() ([]byte, error)

type CompressNetHTTPHandlerConfig ¶

type CompressNetHTTPHandlerConfig struct {
	Level   int
	Handler HTTPHandler
}

CompressNetHTTPHandlerConfig compress@net/http.Handler

func (m CompressNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type ConfigDumpNetHTTPHandlerConfig ¶

type ConfigDumpNetHTTPHandlerConfig struct {
	ReadOnly bool
}

ConfigDumpNetHTTPHandlerConfig config_dump@net/http.Handler

func (m ConfigDumpNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type DefIoReaderConfig ¶

type DefIoReaderConfig struct {
	Name string
	Def  IoReader `json:",omitempty"`
}

DefIoReaderConfig def@io.Reader

func (m DefIoReaderConfig) MarshalJSON() ([]byte, error)

type DefIoWriterConfig ¶

type DefIoWriterConfig struct {
	Name string
	Def  IoWriter `json:",omitempty"`
}

DefIoWriterConfig def@io.Writer

func (m DefIoWriterConfig) MarshalJSON() ([]byte, error)

type DefNetConnConfig ¶

type DefNetConnConfig struct {
	Name string
	Def  NetConn `json:",omitempty"`
}

DefNetConnConfig def@net.Conn

func (m DefNetConnConfig) MarshalJSON() ([]byte, error)

type DefNetHTTPHandlerConfig ¶

type DefNetHTTPHandlerConfig struct {
	Name string
	Def  HTTPHandler `json:",omitempty"`
}

DefNetHTTPHandlerConfig def@net/http.Handler

func (m DefNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type DefNetPacketConnConfig ¶

type DefNetPacketConnConfig struct {
	Name string
	Def  NetPacketConn `json:",omitempty"`
}

DefNetPacketConnConfig def@net.PacketConn

func (m DefNetPacketConnConfig) MarshalJSON() ([]byte, error)

type DefOnceConfig ¶

type DefOnceConfig struct {
	Name string
	Def  Once `json:",omitempty"`
}

DefOnceConfig def@once.Once

func (m DefOnceConfig) MarshalJSON() ([]byte, error)

type DefPacketHandlerConfig ¶

type DefPacketHandlerConfig struct {
	Name string
	Def  PacketHandler `json:",omitempty"`
}

DefPacketHandlerConfig def@packet.Handler

func (m DefPacketHandlerConfig) MarshalJSON() ([]byte, error)

type DefPacketListenConfigConfig ¶

type DefPacketListenConfigConfig struct {
	Name string
	Def  PacketListenConfig `json:",omitempty"`
}

DefPacketListenConfigConfig def@packet.ListenConfig

func (m DefPacketListenConfigConfig) MarshalJSON() ([]byte, error)

type DefProtocolHandlerConfig ¶

type DefProtocolHandlerConfig struct {
	Name string
	Def  ProtocolHandler `json:",omitempty"`
}

DefProtocolHandlerConfig def@protocol.Handler

func (m DefProtocolHandlerConfig) MarshalJSON() ([]byte, error)

type DefServiceConfig ¶

type DefServiceConfig struct {
	Name string
	Def  Service `json:",omitempty"`
}

DefServiceConfig def@service.Service

func (m DefServiceConfig) MarshalJSON() ([]byte, error)

type DefStreamDialerConfig ¶

type DefStreamDialerConfig struct {
	Name string
	Def  StreamDialer `json:",omitempty"`
}

DefStreamDialerConfig def@stream.Dialer

func (m DefStreamDialerConfig) MarshalJSON() ([]byte, error)

type DefStreamHandlerConfig ¶

type DefStreamHandlerConfig struct {
	Name string
	Def  StreamHandler `json:",omitempty"`
}

DefStreamHandlerConfig def@stream.Handler

func (m DefStreamHandlerConfig) MarshalJSON() ([]byte, error)

type DefStreamListenConfigConfig ¶

type DefStreamListenConfigConfig struct {
	Name string
	Def  StreamListenConfig `json:",omitempty"`
}

DefStreamListenConfigConfig def@stream.ListenConfig

func (m DefStreamListenConfigConfig) MarshalJSON() ([]byte, error)

type DefTLSConfig ¶

type DefTLSConfig struct {
	Name string
	Def  TLS `json:",omitempty"`
}

DefTLSConfig def@tls.TLS

func (m DefTLSConfig) MarshalJSON() ([]byte, error)

type DialerStreamDialerConfig ¶

type DialerStreamDialerConfig struct {
	Network DialerStreamDialerDialerNetworkEnum
	Address string
}

DialerStreamDialerConfig dialer@stream.Dialer

func (m DialerStreamDialerConfig) MarshalJSON() ([]byte, error)

type DialerStreamDialerDialerNetworkEnum ¶

type DialerStreamDialerDialerNetworkEnum string

const (
	DialerStreamDialerDialerNetworkEnumEnumUnix DialerStreamDialerDialerNetworkEnum = "unix"
	DialerStreamDialerDialerNetworkEnumEnumTCP6 DialerStreamDialerDialerNetworkEnum = "tcp6"
	DialerStreamDialerDialerNetworkEnumEnumTCP4 DialerStreamDialerDialerNetworkEnum = "tcp4"
	DialerStreamDialerDialerNetworkEnumEnumTCP  DialerStreamDialerDialerNetworkEnum = "tcp"
)

type DirectNetHTTPHandlerConfig ¶

type DirectNetHTTPHandlerConfig struct {
	Code int
	Body IoReader
}

DirectNetHTTPHandlerConfig direct@net/http.Handler

func (m DirectNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type EnvIoReaderConfig ¶

type EnvIoReaderConfig struct {
	Name string
}

EnvIoReaderConfig env@io.Reader

func (m EnvIoReaderConfig) MarshalJSON() ([]byte, error)

type ExpvarNetHTTPHandler ¶

type ExpvarNetHTTPHandler struct {
}

ExpvarNetHTTPHandler expvar@net/http.Handler

func (m ExpvarNetHTTPHandler) MarshalJSON() ([]byte, error)

type FileIoReaderConfig ¶

type FileIoReaderConfig struct {
	Path string
}

FileIoReaderConfig file@io.Reader

func (m FileIoReaderConfig) MarshalJSON() ([]byte, error)

type FileIoWriterConfig ¶

type FileIoWriterConfig struct {
	Path string
}

FileIoWriterConfig file@io.Writer

func (m FileIoWriterConfig) MarshalJSON() ([]byte, error)

type FileNetHTTPHandlerConfig ¶

type FileNetHTTPHandlerConfig struct {
	Root string
}

FileNetHTTPHandlerConfig file@net/http.Handler

func (m FileNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type ForwardNetHTTPHandlerConfig ¶

type ForwardNetHTTPHandlerConfig struct {
	Dialer StreamDialer `json:",omitempty"`
	URL    string
}

ForwardNetHTTPHandlerConfig forward@net/http.Handler

func (m ForwardNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type ForwardStreamHandlerConfig ¶

type ForwardStreamHandlerConfig struct {
	Dialer StreamDialer
}

ForwardStreamHandlerConfig forward@stream.Handler

func (m ForwardStreamHandlerConfig) MarshalJSON() ([]byte, error)

type FromTLSConfig ¶

type FromTLSConfig struct {
	Domain string
	Cert   IoReader
	Key    IoReader
}

FromTLSConfig from@tls.TLS

func (m FromTLSConfig) MarshalJSON() ([]byte, error)

type HTTP1StreamHandlerConfig ¶

type HTTP1StreamHandlerConfig struct {
	Handler HTTPHandler
}

HTTP1StreamHandlerConfig http1@stream.Handler

func (m HTTP1StreamHandlerConfig) MarshalJSON() ([]byte, error)

type HTTP2StreamHandlerConfig ¶

type HTTP2StreamHandlerConfig struct {
	Handler HTTPHandler
	TLS     TLS `json:",omitempty"`
}

HTTP2StreamHandlerConfig http2@stream.Handler

func (m HTTP2StreamHandlerConfig) MarshalJSON() ([]byte, error)

type HTTP3PacketHandlerConfig ¶

type HTTP3PacketHandlerConfig struct {
	Handler HTTPHandler
	TLS     TLS
}

HTTP3PacketHandlerConfig http3@packet.Handler

func (m HTTP3PacketHandlerConfig) MarshalJSON() ([]byte, error)

type HTTPHandler ¶

type HTTPHandler interface {
	Component
	// contains filtered or unexported methods
}

HTTPHandler http.Handler

type HTTPIoReaderConfig ¶

type HTTPIoReaderConfig struct {
	Dialer StreamDialer `json:",omitempty"`
	URL    string
}

HTTPIoReaderConfig http@io.Reader

func (m HTTPIoReaderConfig) MarshalJSON() ([]byte, error)

type HostsNetHTTPHandlerConfig ¶

type HostsNetHTTPHandlerConfig struct {
	Hosts    []HostsNetHTTPHandlerRoute
	NotFound HTTPHandler `json:",omitempty"`
}

HostsNetHTTPHandlerConfig hosts@net/http.Handler

func (m HostsNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type HostsNetHTTPHandlerRoute ¶

type HostsNetHTTPHandlerRoute struct {
	Domains []string
	Handler HTTPHandler
}

type InlineIoReaderConfig ¶

type InlineIoReaderConfig struct {
	Data string
}

InlineIoReaderConfig inline@io.Reader

func (m InlineIoReaderConfig) MarshalJSON() ([]byte, error)

type IoReader ¶

type IoReader interface {
	Component
	// contains filtered or unexported methods
}

IoReader io.Reader

type IoWriter ¶

type IoWriter interface {
	Component
	// contains filtered or unexported methods
}

IoWriter io.Writer

type LbNetHTTPHandlerConfig ¶

type LbNetHTTPHandlerConfig struct {
	Policy   LbNetHTTPHandlerLoadBalancePolicyEnum `json:",omitempty"`
	Handlers []LbNetHTTPHandlerWeight
}

LbNetHTTPHandlerConfig lb@net/http.Handler

func (m LbNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type LbNetHTTPHandlerLoadBalancePolicyEnum ¶

type LbNetHTTPHandlerLoadBalancePolicyEnum string

const (
	LbNetHTTPHandlerLoadBalancePolicyEnumEnumRoundRobin LbNetHTTPHandlerLoadBalancePolicyEnum = "round_robin"
	LbNetHTTPHandlerLoadBalancePolicyEnumEnumRandom     LbNetHTTPHandlerLoadBalancePolicyEnum = "random"
)

type LbNetHTTPHandlerWeight ¶

type LbNetHTTPHandlerWeight struct {
	Weight  uint `json:",omitempty"`
	Handler HTTPHandler
}

type LbStreamDialerConfig ¶

type LbStreamDialerConfig struct {
	Policy  LbStreamDialerLoadBalancePolicyEnum `json:",omitempty"`
	Dialers []LbStreamDialerWeight
}

LbStreamDialerConfig lb@stream.Dialer

func (m LbStreamDialerConfig) MarshalJSON() ([]byte, error)

type LbStreamDialerLoadBalancePolicyEnum ¶

type LbStreamDialerLoadBalancePolicyEnum string

const (
	LbStreamDialerLoadBalancePolicyEnumEnumRoundRobin LbStreamDialerLoadBalancePolicyEnum = "round_robin"
	LbStreamDialerLoadBalancePolicyEnumEnumRandom     LbStreamDialerLoadBalancePolicyEnum = "random"
)

type LbStreamDialerWeight ¶

type LbStreamDialerWeight struct {
	Weight uint `json:",omitempty"`
	Dialer StreamDialer
}

type LbStreamHandlerConfig ¶

type LbStreamHandlerConfig struct {
	Policy   LbStreamHandlerLoadBalancePolicyEnum `json:",omitempty"`
	Handlers []LbStreamHandlerWeight
}

LbStreamHandlerConfig lb@stream.Handler

func (m LbStreamHandlerConfig) MarshalJSON() ([]byte, error)

type LbStreamHandlerLoadBalancePolicyEnum ¶

type LbStreamHandlerLoadBalancePolicyEnum string

const (
	LbStreamHandlerLoadBalancePolicyEnumEnumRoundRobin LbStreamHandlerLoadBalancePolicyEnum = "round_robin"
	LbStreamHandlerLoadBalancePolicyEnumEnumRandom     LbStreamHandlerLoadBalancePolicyEnum = "random"
)

type LbStreamHandlerWeight ¶

type LbStreamHandlerWeight struct {
	Weight  uint `json:",omitempty"`
	Handler StreamHandler
}

type ListenerPacketListenConfigConfig ¶

type ListenerPacketListenConfigConfig struct {
	Network ListenerPacketListenConfigListenerNetworkEnum
	Address string
}

ListenerPacketListenConfigConfig listener@packet.ListenConfig

func (m ListenerPacketListenConfigConfig) MarshalJSON() ([]byte, error)

type ListenerPacketListenConfigListenerNetworkEnum ¶

type ListenerPacketListenConfigListenerNetworkEnum string

const (
	ListenerPacketListenConfigListenerNetworkEnumEnumUnixPacket ListenerPacketListenConfigListenerNetworkEnum = "unixpacket"
	ListenerPacketListenConfigListenerNetworkEnumEnumUDP6       ListenerPacketListenConfigListenerNetworkEnum = "udp6"
	ListenerPacketListenConfigListenerNetworkEnumEnumUDP4       ListenerPacketListenConfigListenerNetworkEnum = "udp4"
	ListenerPacketListenConfigListenerNetworkEnumEnumUDP        ListenerPacketListenConfigListenerNetworkEnum = "udp"
)

type ListenerStreamListenConfigConfig ¶

type ListenerStreamListenConfigConfig struct {
	Network ListenerStreamListenConfigListenerNetworkEnum
	Address string
}

ListenerStreamListenConfigConfig listener@stream.ListenConfig

func (m ListenerStreamListenConfigConfig) MarshalJSON() ([]byte, error)

type ListenerStreamListenConfigListenerNetworkEnum ¶

type ListenerStreamListenConfigListenerNetworkEnum string

const (
	ListenerStreamListenConfigListenerNetworkEnumEnumUnix ListenerStreamListenConfigListenerNetworkEnum = "unix"
	ListenerStreamListenConfigListenerNetworkEnumEnumTCP6 ListenerStreamListenConfigListenerNetworkEnum = "tcp6"
	ListenerStreamListenConfigListenerNetworkEnumEnumTCP4 ListenerStreamListenConfigListenerNetworkEnum = "tcp4"
	ListenerStreamListenConfigListenerNetworkEnumEnumTCP  ListenerStreamListenConfigListenerNetworkEnum = "tcp"
)

type LoadIoReaderConfig ¶

type LoadIoReaderConfig struct {
	Load IoReader
}

LoadIoReaderConfig load@io.Reader

func (m LoadIoReaderConfig) MarshalJSON() ([]byte, error)

type LoadIoWriterConfig ¶

type LoadIoWriterConfig struct {
	Load IoReader
}

LoadIoWriterConfig load@io.Writer

func (m LoadIoWriterConfig) MarshalJSON() ([]byte, error)

type LoadNetConnConfig ¶

type LoadNetConnConfig struct {
	Load IoReader
}

LoadNetConnConfig load@net.Conn

func (m LoadNetConnConfig) MarshalJSON() ([]byte, error)

type LoadNetHTTPHandlerConfig ¶

type LoadNetHTTPHandlerConfig struct {
	Load IoReader
}

LoadNetHTTPHandlerConfig load@net/http.Handler

func (m LoadNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type LoadNetPacketConnConfig ¶

type LoadNetPacketConnConfig struct {
	Load IoReader
}

LoadNetPacketConnConfig load@net.PacketConn

func (m LoadNetPacketConnConfig) MarshalJSON() ([]byte, error)

type LoadOnceConfig ¶

type LoadOnceConfig struct {
	Load IoReader
}

LoadOnceConfig load@once.Once

func (m LoadOnceConfig) MarshalJSON() ([]byte, error)

type LoadPacketHandlerConfig ¶

type LoadPacketHandlerConfig struct {
	Load IoReader
}

LoadPacketHandlerConfig load@packet.Handler

func (m LoadPacketHandlerConfig) MarshalJSON() ([]byte, error)

type LoadPacketListenConfigConfig ¶

type LoadPacketListenConfigConfig struct {
	Load IoReader
}

LoadPacketListenConfigConfig load@packet.ListenConfig

func (m LoadPacketListenConfigConfig) MarshalJSON() ([]byte, error)

type LoadProtocolHandlerConfig ¶

type LoadProtocolHandlerConfig struct {
	Load IoReader
}

LoadProtocolHandlerConfig load@protocol.Handler

func (m LoadProtocolHandlerConfig) MarshalJSON() ([]byte, error)

type LoadServiceConfig ¶

type LoadServiceConfig struct {
	Load IoReader
}

LoadServiceConfig load@service.Service

func (m LoadServiceConfig) MarshalJSON() ([]byte, error)

type LoadStreamDialerConfig ¶

type LoadStreamDialerConfig struct {
	Load IoReader
}

LoadStreamDialerConfig load@stream.Dialer

func (m LoadStreamDialerConfig) MarshalJSON() ([]byte, error)

type LoadStreamHandlerConfig ¶

type LoadStreamHandlerConfig struct {
	Load IoReader
}

LoadStreamHandlerConfig load@stream.Handler

func (m LoadStreamHandlerConfig) MarshalJSON() ([]byte, error)

type LoadStreamListenConfigConfig ¶

type LoadStreamListenConfigConfig struct {
	Load IoReader
}

LoadStreamListenConfigConfig load@stream.ListenConfig

func (m LoadStreamListenConfigConfig) MarshalJSON() ([]byte, error)

type LoadTLSConfig ¶

type LoadTLSConfig struct {
	Load IoReader
}

LoadTLSConfig load@tls.TLS

func (m LoadTLSConfig) MarshalJSON() ([]byte, error)

type LogNetHTTPHandlerConfig ¶

type LogNetHTTPHandlerConfig struct {
	Output  IoWriter
	Handler HTTPHandler
}

LogNetHTTPHandlerConfig log@net/http.Handler

func (m LogNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type MergeTLSConfig ¶

type MergeTLSConfig struct {
	Merge []TLS
}

MergeTLSConfig merge@tls.TLS

func (m MergeTLSConfig) MarshalJSON() ([]byte, error)

type MessageOnceConfig ¶

type MessageOnceConfig struct {
	Message string
}

MessageOnceConfig message@once.Once

func (m MessageOnceConfig) MarshalJSON() ([]byte, error)

type MethodNetHTTPHandlerConfig ¶

type MethodNetHTTPHandlerConfig struct {
	Methods  []MethodNetHTTPHandlerRoute
	NotFound HTTPHandler
}

MethodNetHTTPHandlerConfig method@net/http.Handler

func (m MethodNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type MethodNetHTTPHandlerMethodEnum ¶

type MethodNetHTTPHandlerMethodEnum string

const (
	MethodNetHTTPHandlerMethodEnumMethodTrace   MethodNetHTTPHandlerMethodEnum = "TRACE"
	MethodNetHTTPHandlerMethodEnumMethodPut     MethodNetHTTPHandlerMethodEnum = "PUT"
	MethodNetHTTPHandlerMethodEnumMethodPost    MethodNetHTTPHandlerMethodEnum = "POST"
	MethodNetHTTPHandlerMethodEnumMethodPatch   MethodNetHTTPHandlerMethodEnum = "PATCH"
	MethodNetHTTPHandlerMethodEnumMethodOptions MethodNetHTTPHandlerMethodEnum = "OPTIONS"
	MethodNetHTTPHandlerMethodEnumMethodHead    MethodNetHTTPHandlerMethodEnum = "HEAD"
	MethodNetHTTPHandlerMethodEnumMethodGet     MethodNetHTTPHandlerMethodEnum = "GET"
	MethodNetHTTPHandlerMethodEnumMethodDelete  MethodNetHTTPHandlerMethodEnum = "DELETE"
	MethodNetHTTPHandlerMethodEnumMethodConnect MethodNetHTTPHandlerMethodEnum = "CONNECT"
)

type MethodNetHTTPHandlerRoute ¶

type MethodNetHTTPHandlerRoute struct {
	Method  MethodNetHTTPHandlerMethodEnum
	Handler HTTPHandler
}

type MetricsNetHTTPHandler ¶

type MetricsNetHTTPHandler struct {
}

MetricsNetHTTPHandler metrics@net/http.Handler

func (m MetricsNetHTTPHandler) MarshalJSON() ([]byte, error)

type MultiNetHTTPHandlerConfig ¶

type MultiNetHTTPHandlerConfig struct {
	Multi []HTTPHandler
}

MultiNetHTTPHandlerConfig multi@net/http.Handler

func (m MultiNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type MultiOnceConfig ¶

type MultiOnceConfig struct {
	Multi []Once
}

MultiOnceConfig multi@once.Once

func (m MultiOnceConfig) MarshalJSON() ([]byte, error)

type MultiServiceConfig ¶

type MultiServiceConfig struct {
	Multi []Service
}

MultiServiceConfig multi@service.Service

func (m MultiServiceConfig) MarshalJSON() ([]byte, error)

type MultiStreamHandlerConfig ¶

type MultiStreamHandlerConfig struct {
	Multi []StreamHandler
}

MultiStreamHandlerConfig multi@stream.Handler

func (m MultiStreamHandlerConfig) MarshalJSON() ([]byte, error)

type MuxNetHTTPHandlerConfig ¶

type MuxNetHTTPHandlerConfig struct {
	Routes   []MuxNetHTTPHandlerRoute
	NotFound HTTPHandler `json:",omitempty"`
}

MuxNetHTTPHandlerConfig mux@net/http.Handler

func (m MuxNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type MuxNetHTTPHandlerRoute ¶

type MuxNetHTTPHandlerRoute struct {
	Prefix  string `json:",omitempty"`
	Path    string `json:",omitempty"`
	Regexp  string `json:",omitempty"`
	Handler HTTPHandler
}

type MuxStreamHandlerConfig ¶

type MuxStreamHandlerConfig struct {
	Routes   []MuxStreamHandlerRoute
	NotFound StreamHandler
}

MuxStreamHandlerConfig mux@stream.Handler

func (m MuxStreamHandlerConfig) MarshalJSON() ([]byte, error)

type MuxStreamHandlerRoute ¶

type MuxStreamHandlerRoute struct {
	Pattern string `json:",omitempty"`
	Regexp  string `json:",omitempty"`
	Prefix  string `json:",omitempty"`
	Handler StreamHandler
}

type NetConn ¶

type NetConn interface {
	Component
	// contains filtered or unexported methods
}

NetConn net.Conn

type NetPacketConn ¶

type NetPacketConn interface {
	Component
	// contains filtered or unexported methods
}

NetPacketConn net.PacketConn

type NoneIoReader ¶

type NoneIoReader struct {
}

NoneIoReader none@io.Reader

func (m NoneIoReader) MarshalJSON() ([]byte, error)

type NoneIoWriter ¶

type NoneIoWriter struct {
}

NoneIoWriter none@io.Writer

func (m NoneIoWriter) MarshalJSON() ([]byte, error)

type NoneNetConn ¶

type NoneNetConn struct {
}

NoneNetConn none@net.Conn

func (m NoneNetConn) MarshalJSON() ([]byte, error)

type NoneNetHTTPHandler ¶

type NoneNetHTTPHandler struct {
}

NoneNetHTTPHandler none@net/http.Handler

func (m NoneNetHTTPHandler) MarshalJSON() ([]byte, error)

type NoneNetPacketConn ¶

type NoneNetPacketConn struct {
}

NoneNetPacketConn none@net.PacketConn

func (m NoneNetPacketConn) MarshalJSON() ([]byte, error)

type NoneOnce ¶

type NoneOnce struct {
}

NoneOnce none@once.Once

func (m NoneOnce) MarshalJSON() ([]byte, error)

type NonePacketHandler ¶

type NonePacketHandler struct {
}

NonePacketHandler none@packet.Handler

func (m NonePacketHandler) MarshalJSON() ([]byte, error)

type NonePacketListenConfig ¶

type NonePacketListenConfig struct {
}

NonePacketListenConfig none@packet.ListenConfig

func (m NonePacketListenConfig) MarshalJSON() ([]byte, error)

type NoneProtocolHandler ¶

type NoneProtocolHandler struct {
}

NoneProtocolHandler none@protocol.Handler

func (m NoneProtocolHandler) MarshalJSON() ([]byte, error)

type NoneService ¶

type NoneService struct {
}

NoneService none@service.Service

func (m NoneService) MarshalJSON() ([]byte, error)

type NoneStreamDialer ¶

type NoneStreamDialer struct {
}

NoneStreamDialer none@stream.Dialer

func (m NoneStreamDialer) MarshalJSON() ([]byte, error)

type NoneStreamHandler ¶

type NoneStreamHandler struct {
}

NoneStreamHandler none@stream.Handler

func (m NoneStreamHandler) MarshalJSON() ([]byte, error)

type NoneStreamListenConfig ¶

type NoneStreamListenConfig struct {
}

NoneStreamListenConfig none@stream.ListenConfig

func (m NoneStreamListenConfig) MarshalJSON() ([]byte, error)

type NoneTLS ¶

type NoneTLS struct {
}

NoneTLS none@tls.TLS

func (m NoneTLS) MarshalJSON() ([]byte, error)

type Once ¶

type Once interface {
	Component
	// contains filtered or unexported methods
}

Once once.Once

type OriginalStreamDialer ¶

type OriginalStreamDialer struct {
}

OriginalStreamDialer original@stream.Dialer

func (m OriginalStreamDialer) MarshalJSON() ([]byte, error)

type PacketHandler ¶

type PacketHandler interface {
	Component
	// contains filtered or unexported methods
}

PacketHandler packet.Handler

type PacketListenConfig ¶

type PacketListenConfig interface {
	Component
	// contains filtered or unexported methods
}

PacketListenConfig packet.ListenConfig

type PacketServiceConfig ¶

type PacketServiceConfig struct {
	Listener PacketListenConfig
	Handler  PacketHandler
}

PacketServiceConfig packet@service.Service

func (m PacketServiceConfig) MarshalJSON() ([]byte, error)

type PprofNetHTTPHandler ¶

type PprofNetHTTPHandler struct {
}

PprofNetHTTPHandler pprof@net/http.Handler

func (m PprofNetHTTPHandler) MarshalJSON() ([]byte, error)

type ProtocolHandler ¶

type ProtocolHandler interface {
	Component
	// contains filtered or unexported methods
}

ProtocolHandler protocol.Handler

type QuicStreamListenConfigConfig ¶

type QuicStreamListenConfigConfig struct {
	Packet NetPacketConn
	TLS    TLS
}

QuicStreamListenConfigConfig quic@stream.ListenConfig

func (m QuicStreamListenConfigConfig) MarshalJSON() ([]byte, error)

type QuitNetHTTPHandler ¶

type QuitNetHTTPHandler struct {
}

QuitNetHTTPHandler quit@net/http.Handler

func (m QuitNetHTTPHandler) MarshalJSON() ([]byte, error)

type RawComponent ¶

type RawComponent []byte

RawComponent is store raw bytes of Component

func (m RawComponent) MarshalJSON() ([]byte, error)

func (m *RawComponent) UnmarshalJSON(data []byte) error

type RawHTTPHandler ¶

type RawHTTPHandler []byte

RawHTTPHandler is store raw bytes of HTTPHandler

func (m RawHTTPHandler) MarshalJSON() ([]byte, error)

func (m *RawHTTPHandler) UnmarshalJSON(data []byte) error

type RawIoReader ¶

type RawIoReader []byte

RawIoReader is store raw bytes of IoReader

func (m RawIoReader) MarshalJSON() ([]byte, error)

func (m *RawIoReader) UnmarshalJSON(data []byte) error

type RawIoWriter ¶

type RawIoWriter []byte

RawIoWriter is store raw bytes of IoWriter

func (m RawIoWriter) MarshalJSON() ([]byte, error)

func (m *RawIoWriter) UnmarshalJSON(data []byte) error

type RawNetConn ¶

type RawNetConn []byte

RawNetConn is store raw bytes of NetConn

func (m RawNetConn) MarshalJSON() ([]byte, error)

func (m *RawNetConn) UnmarshalJSON(data []byte) error

type RawNetPacketConn ¶

type RawNetPacketConn []byte

RawNetPacketConn is store raw bytes of NetPacketConn

func (m RawNetPacketConn) MarshalJSON() ([]byte, error)

func (m *RawNetPacketConn) UnmarshalJSON(data []byte) error

type RawOnce ¶

type RawOnce []byte

RawOnce is store raw bytes of Once

func (m RawOnce) MarshalJSON() ([]byte, error)

func (m *RawOnce) UnmarshalJSON(data []byte) error

type RawPacketHandler ¶

type RawPacketHandler []byte

RawPacketHandler is store raw bytes of PacketHandler

func (m RawPacketHandler) MarshalJSON() ([]byte, error)

func (m *RawPacketHandler) UnmarshalJSON(data []byte) error

type RawPacketListenConfig ¶

type RawPacketListenConfig []byte

RawPacketListenConfig is store raw bytes of PacketListenConfig

func (m RawPacketListenConfig) MarshalJSON() ([]byte, error)

func (m *RawPacketListenConfig) UnmarshalJSON(data []byte) error

type RawProtocolHandler ¶

type RawProtocolHandler []byte

RawProtocolHandler is store raw bytes of ProtocolHandler

func (m RawProtocolHandler) MarshalJSON() ([]byte, error)

func (m *RawProtocolHandler) UnmarshalJSON(data []byte) error

type RawService ¶

type RawService []byte

RawService is store raw bytes of Service

func (m RawService) MarshalJSON() ([]byte, error)

func (m *RawService) UnmarshalJSON(data []byte) error

type RawStreamDialer ¶

type RawStreamDialer []byte

RawStreamDialer is store raw bytes of StreamDialer

func (m RawStreamDialer) MarshalJSON() ([]byte, error)

func (m *RawStreamDialer) UnmarshalJSON(data []byte) error

type RawStreamHandler ¶

type RawStreamHandler []byte

RawStreamHandler is store raw bytes of StreamHandler

func (m RawStreamHandler) MarshalJSON() ([]byte, error)

func (m *RawStreamHandler) UnmarshalJSON(data []byte) error

type RawStreamListenConfig ¶

type RawStreamListenConfig []byte

RawStreamListenConfig is store raw bytes of StreamListenConfig

func (m RawStreamListenConfig) MarshalJSON() ([]byte, error)

func (m *RawStreamListenConfig) UnmarshalJSON(data []byte) error

type RawTLS ¶

type RawTLS []byte

RawTLS is store raw bytes of TLS

func (m RawTLS) MarshalJSON() ([]byte, error)

func (m *RawTLS) UnmarshalJSON(data []byte) error

type RedirectNetHTTPHandlerConfig ¶

type RedirectNetHTTPHandlerConfig struct {
	Code     int
	Location string
}

RedirectNetHTTPHandlerConfig redirect@net/http.Handler

func (m RedirectNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type RefIoReaderConfig ¶

type RefIoReaderConfig struct {
	Name string
	Def  IoReader `json:",omitempty"`
}

RefIoReaderConfig ref@io.Reader

func (m RefIoReaderConfig) MarshalJSON() ([]byte, error)

type RefIoWriterConfig ¶

type RefIoWriterConfig struct {
	Name string
	Def  IoWriter `json:",omitempty"`
}

RefIoWriterConfig ref@io.Writer

func (m RefIoWriterConfig) MarshalJSON() ([]byte, error)

type RefNetConnConfig ¶

type RefNetConnConfig struct {
	Name string
	Def  NetConn `json:",omitempty"`
}

RefNetConnConfig ref@net.Conn

func (m RefNetConnConfig) MarshalJSON() ([]byte, error)

type RefNetHTTPHandlerConfig ¶

type RefNetHTTPHandlerConfig struct {
	Name string
	Def  HTTPHandler `json:",omitempty"`
}

RefNetHTTPHandlerConfig ref@net/http.Handler

func (m RefNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type RefNetPacketConnConfig ¶

type RefNetPacketConnConfig struct {
	Name string
	Def  NetPacketConn `json:",omitempty"`
}

RefNetPacketConnConfig ref@net.PacketConn

func (m RefNetPacketConnConfig) MarshalJSON() ([]byte, error)

type RefOnceConfig ¶

type RefOnceConfig struct {
	Name string
	Def  Once `json:",omitempty"`
}

RefOnceConfig ref@once.Once

func (m RefOnceConfig) MarshalJSON() ([]byte, error)

type RefPacketHandlerConfig ¶

type RefPacketHandlerConfig struct {
	Name string
	Def  PacketHandler `json:",omitempty"`
}

RefPacketHandlerConfig ref@packet.Handler

func (m RefPacketHandlerConfig) MarshalJSON() ([]byte, error)

type RefPacketListenConfigConfig ¶

type RefPacketListenConfigConfig struct {
	Name string
	Def  PacketListenConfig `json:",omitempty"`
}

RefPacketListenConfigConfig ref@packet.ListenConfig

func (m RefPacketListenConfigConfig) MarshalJSON() ([]byte, error)

type RefProtocolHandlerConfig ¶

type RefProtocolHandlerConfig struct {
	Name string
	Def  ProtocolHandler `json:",omitempty"`
}

RefProtocolHandlerConfig ref@protocol.Handler

func (m RefProtocolHandlerConfig) MarshalJSON() ([]byte, error)

type RefServiceConfig ¶

type RefServiceConfig struct {
	Name string
	Def  Service `json:",omitempty"`
}

RefServiceConfig ref@service.Service

func (m RefServiceConfig) MarshalJSON() ([]byte, error)

type RefStreamDialerConfig ¶

type RefStreamDialerConfig struct {
	Name string
	Def  StreamDialer `json:",omitempty"`
}

RefStreamDialerConfig ref@stream.Dialer

func (m RefStreamDialerConfig) MarshalJSON() ([]byte, error)

type RefStreamHandlerConfig ¶

type RefStreamHandlerConfig struct {
	Name string
	Def  StreamHandler `json:",omitempty"`
}

RefStreamHandlerConfig ref@stream.Handler

func (m RefStreamHandlerConfig) MarshalJSON() ([]byte, error)

type RefStreamListenConfigConfig ¶

type RefStreamListenConfigConfig struct {
	Name string
	Def  StreamListenConfig `json:",omitempty"`
}

RefStreamListenConfigConfig ref@stream.ListenConfig

func (m RefStreamListenConfigConfig) MarshalJSON() ([]byte, error)

type RefTLSConfig ¶

type RefTLSConfig struct {
	Name string
	Def  TLS `json:",omitempty"`
}

RefTLSConfig ref@tls.TLS

func (m RefTLSConfig) MarshalJSON() ([]byte, error)

type RemoveRequestHeaderNetHTTPHandlerConfig ¶

type RemoveRequestHeaderNetHTTPHandlerConfig struct {
	Key string
}

RemoveRequestHeaderNetHTTPHandlerConfig remove_request_header@net/http.Handler

func (m RemoveRequestHeaderNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type RemoveResponseHeaderNetHTTPHandlerConfig ¶

type RemoveResponseHeaderNetHTTPHandlerConfig struct {
	Key string
}

RemoveResponseHeaderNetHTTPHandlerConfig remove_response_header@net/http.Handler

func (m RemoveResponseHeaderNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type SelfSignedTLS ¶

type SelfSignedTLS struct {
}

SelfSignedTLS self_signed@tls.TLS

func (m SelfSignedTLS) MarshalJSON() ([]byte, error)

type Service ¶

type Service interface {
	Component
	// contains filtered or unexported methods
}

Service service.Service

type ServiceOnceConfig ¶

type ServiceOnceConfig struct {
	Service Service
}

ServiceOnceConfig service@once.Once

func (m ServiceOnceConfig) MarshalJSON() ([]byte, error)

type StreamDialer ¶

type StreamDialer interface {
	Component
	// contains filtered or unexported methods
}

StreamDialer stream.Dialer

type StreamHandler ¶

type StreamHandler interface {
	Component
	// contains filtered or unexported methods
}

StreamHandler stream.Handler

type StreamListenConfig ¶

type StreamListenConfig interface {
	Component
	// contains filtered or unexported methods
}

StreamListenConfig stream.ListenConfig

type StreamServiceConfig ¶

type StreamServiceConfig struct {
	Listener          StreamListenConfig
	Handler           StreamHandler
	DisconnectOnClose bool `json:",omitempty"`
}

StreamServiceConfig stream@service.Service

func (m StreamServiceConfig) MarshalJSON() ([]byte, error)

type StripPrefixNetHTTPHandlerConfig ¶

type StripPrefixNetHTTPHandlerConfig struct {
	Prefix  string
	Handler HTTPHandler
}

StripPrefixNetHTTPHandlerConfig strip_prefix@net/http.Handler

func (m StripPrefixNetHTTPHandlerConfig) MarshalJSON() ([]byte, error)

type TLS ¶

type TLS interface {
	Component
	// contains filtered or unexported methods
}

TLS tls.TLS

type TLSDownStreamHandlerConfig ¶

type TLSDownStreamHandlerConfig struct {
	Handler StreamHandler
	TLS     TLS
}

TLSDownStreamHandlerConfig tls_down@stream.Handler

func (m TLSDownStreamHandlerConfig) MarshalJSON() ([]byte, error)

type TLSStreamDialerConfig ¶

type TLSStreamDialerConfig struct {
	Dialer StreamDialer
	TLS    TLS
}

TLSStreamDialerConfig tls@stream.Dialer

func (m TLSStreamDialerConfig) MarshalJSON() ([]byte, error)

type TLSStreamListenConfigConfig ¶

type TLSStreamListenConfigConfig struct {
	ListenConfig StreamListenConfig
	TLS          TLS
}

TLSStreamListenConfigConfig tls@stream.ListenConfig

func (m TLSStreamListenConfigConfig) MarshalJSON() ([]byte, error)

type TLSUpStreamHandlerConfig ¶

type TLSUpStreamHandlerConfig struct {
	Handler StreamHandler
	TLS     TLS
}

TLSUpStreamHandlerConfig tls_up@stream.Handler

func (m TLSUpStreamHandlerConfig) MarshalJSON() ([]byte, error)

type ValidationTLSConfig ¶

type ValidationTLSConfig struct {
	Ca IoReader
}

ValidationTLSConfig validation@tls.TLS

func (m ValidationTLSConfig) MarshalJSON() ([]byte, error)

type WaitService ¶

type WaitService struct {
}

WaitService wait@service.Service

func (m WaitService) MarshalJSON() ([]byte, error)