channel

Aug 26, 2022

Changes in this version

+ type ClosedError struct

+ func (ClosedError) Error() string

type Sender

+ TrySend func(s Sendable) (bool, error)

Aug 15, 2022

Changes in this version

+ const TypeHeader

type Channel

+ func NewChannelWithUnderlay(logicalName string, underlay Underlay, bindHandler BindHandler, ...) (Channel, error)

+ type UnderlayAcceptor interface

+ AcceptUnderlay func(u Underlay) error

+ type UnderlayDispatcher struct

+ func NewUnderlayDispatcher(config UnderlayDispatcherConfig) *UnderlayDispatcher

+ func (self *UnderlayDispatcher) Run()

+ type UnderlayDispatcherConfig struct

+ Acceptors map[string]UnderlayAcceptor

+ ConnectTimeout time.Duration

+ DefaultAcceptor UnderlayAcceptor

+ Listener UnderlayListener

+ TransportConfig transport.Configuration

Jul 15, 2022

Changes in this version

type Underlay

+ GetLocalAddr func() net.Addr

+ GetRemoteAddr func() net.Addr

May 13, 2022

Changes in this version

+ type ListenerConfig struct

+ Headers map[int32][]byte

+ PoolConfigurator func(config *goroutines.PoolConfig)

+ TransportConfig transport.Configuration

+ func DefaultListenerConfig() ListenerConfig

May 10, 2022

Changes in this version

+ func WriteUnknownVersionResponse(writer io.Writer)

May 9, 2022

Changes in this version

+ func GetRetryVersion(err error) (uint32, bool)

Apr 19, 2022

Changes in this version

+ func MarshalV2(m *Message) ([]byte, error)

type Message

+ func ReadV2(peer io.Reader) (*Message, error)

Apr 12, 2022

Changes in this version

type UnderlayFactory

+ func NewClassicDialerWithBindAddress(identity *identity.TokenId, endpoint transport.Address, localBinding string, ...) UnderlayFactory

+ func NewReconnectingDialerWithHandlerAndLocalBinding(identity *identity.TokenId, endpoint transport.Address, localBinding string, ...) UnderlayFactory

Mar 30, 2022

Changes in this version

type UnderlayFactory

+ func NewExistingConnDialer(id *identity.TokenId, peer net.Conn, headers map[int32][]byte) UnderlayFactory

+ func NewExistingConnListener(identity *identity.TokenId, peer net.Conn, headers map[int32][]byte) UnderlayFactory

Mar 3, 2022

Changes in this version

+ const AnyContentType

+ const ConnectionIdHeader

+ const ContentTypeHeartbeat

+ const ContentTypeHelloType

+ const ContentTypeLatencyResponseType

+ const ContentTypeLatencyType

+ const ContentTypePingType

+ const ContentTypeResultType

+ const DECODER

+ const DecoderFieldName

+ const DefaultConnectTimeout

+ const DefaultOutQueueSize

+ const DefaultOutstandingConnects

+ const DefaultQueuedConnects

+ const HeartbeatHeader

+ const HeartbeatResponseHeader

+ const HelloRouterAdvertisementsHeader

+ const HelloSequence

+ const HelloVersionHeader

+ const High

+ const Highest

+ const Low

+ const MaxConnectTimeout

+ const MaxOutstandingConnects

+ const MaxQueuedConnects

+ const MaxReflectedHeader

+ const MessageFieldName

+ const MinConnectTimeout

+ const MinOutstandingConnects

+ const MinQueuedConnects

+ const ReflectedHeaderBitMask

+ const ReplyForHeader

+ const ResultSuccessHeader

+ const Standard

+ var ListenerClosedError = listenerClosedError

+ var UnknownVersionError = errors.New("channel synchronization error, bad magic number")

+ func AcceptNextChannel(logicalName string, underlayFactory UnderlayFactory, bindHandler BindHandler, ...) error

+ func ConfigureHeartbeat(binding Binding, heartbeatInterval time.Duration, checkInterval time.Duration, ...)

+ func IsTimeout(err error) bool

+ func NewErrorContext(err error) context.Context

+ func NewWSListener(peer transport.Connection) *wsListener

+ func NextConnectionId() (string, error)

+ type AsyncFunctionReceiveAdapter struct

+ Handler ReceiveHandlerF

+ Type int32

+ func (adapter *AsyncFunctionReceiveAdapter) ContentType() int32

+ func (adapter *AsyncFunctionReceiveAdapter) HandleReceive(m *Message, ch Channel)

+ type BaseSendListener struct

+ func (BaseSendListener) NotifyAfterWrite()

+ func (BaseSendListener) NotifyBeforeWrite()

+ func (BaseSendListener) NotifyErr(error)

+ func (BaseSendListener) NotifyQueued()

+ type BaseSendable struct

+ func (BaseSendable) Context() context.Context

+ func (BaseSendable) Msg() *Message

+ func (BaseSendable) Priority() Priority

+ func (BaseSendable) ReplyReceiver() ReplyReceiver

+ func (BaseSendable) SendListener() SendListener

+ type BindHandler interface

+ BindChannel func(binding Binding) error

+ type BindHandlerF func(binding Binding) error

+ func (f BindHandlerF) BindChannel(binding Binding) error

+ type Binding interface

+ AddCloseHandler func(h CloseHandler)

+ AddErrorHandler func(h ErrorHandler)

+ AddPeekHandler func(h PeekHandler)

+ AddReceiveHandler func(contentType int32, h ReceiveHandler)

+ AddReceiveHandlerF func(contentType int32, h ReceiveHandlerF)

+ AddTransformHandler func(h TransformHandler)

+ AddTypedReceiveHandler func(h TypedReceiveHandler)

+ Bind func(h BindHandler) error

+ GetChannel func() Channel

+ GetUserData func() interface{}

+ SetUserData func(data interface{})

+ type Channel interface

+ GetTimeSinceLastRead func() time.Duration

+ IsClosed func() bool

+ SetLogicalName func(logicalName string)

+ StartRx func()

+ Underlay func() Underlay

+ func NewChannel(logicalName string, underlayFactory UnderlayFactory, bindHandler BindHandler, ...) (Channel, error)

+ func NewChannelWithTransportConfiguration(logicalName string, underlayFactory UnderlayFactory, bindHandler BindHandler, ...) (Channel, error)

+ type CloseHandler interface

+ HandleClose func(ch Channel)

+ type CloseHandlerF func(ch Channel)

+ func (self CloseHandlerF) HandleClose(ch Channel)

+ type ConnectOptions struct

+ ConnectTimeoutMs time.Duration

+ MaxOutstandingConnects int

+ MaxQueuedConnects int

+ func DefaultConnectOptions() ConnectOptions

+ func (co *ConnectOptions) ConnectTimeout() time.Duration

+ func (co *ConnectOptions) Validate() error

+ type ConnectionHandler interface

+ HandleConnection func(hello *Hello, certificates []*x509.Certificate) error

+ type Decoder struct

+ func (d Decoder) Decode(msg *Message) ([]byte, bool)

+ type Envelope interface

+ ReplyTo func(msg *Message) Envelope

+ Send func(ch Channel) error

+ ToSendable func() Sendable

+ WithPriority func(p Priority) Envelope

+ WithTimeout func(duration time.Duration) TimeoutEnvelope

+ func NewErrorEnvelope(err error) Envelope

+ type ErrorHandler interface

+ HandleError func(err error, ch Channel)

+ type ErrorHandlerF func(err error, ch Channel)

+ func (self ErrorHandlerF) HandleError(err error, ch Channel)

+ type Headers map[int32][]byte

+ func (self Headers) GetBoolHeader(key int32) (bool, bool)

+ func (self Headers) GetByteHeader(key int32) (byte, bool)

+ func (self Headers) GetStringHeader(key int32) (string, bool)

+ func (self Headers) GetUint16Header(key int32) (uint16, bool)

+ func (self Headers) GetUint32Header(key int32) (uint32, bool)

+ func (self Headers) GetUint64Header(key int32) (uint64, bool)

+ func (self Headers) PutBoolHeader(key int32, value bool)

+ func (self Headers) PutByteHeader(key int32, value byte)

+ func (self Headers) PutStringHeader(key int32, value string)

+ func (self Headers) PutUint16Header(key int32, value uint16)

+ func (self Headers) PutUint32Header(key int32, value uint32)

+ func (self Headers) PutUint64Header(key int32, value uint64)

+ type HeartbeatCallback interface

+ CheckHeartBeat func()

+ HeartbeatRespRx func(ts int64)

+ HeartbeatRespTx func(ts int64)

+ HeartbeatRx func(ts int64)

+ HeartbeatTx func(ts int64)

+ type Hello struct

+ Headers map[int32][]byte

+ IdToken string

+ func UnmarshalHello(message *Message) *Hello

+ type Identity interface

+ Certificates func() []*x509.Certificate

+ ConnectionId func() string

+ Id func() *identity.TokenId

+ Label func() string

+ LogicalName func() string

+ type Message struct

+ Body []byte

+ func NewHello(idToken string, attributes map[int32][]byte) *Message

+ func NewMessage(contentType int32, body []byte) *Message

+ func NewResult(success bool, message string) *Message

+ func ReadWSMessage(peer io.Reader) (*Message, error)

+ func (m *Message) Context() context.Context

+ func (m *Message) Msg() *Message

+ func (m *Message) Priority() Priority

+ func (m *Message) ReplyReceiver() ReplyReceiver

+ func (m *Message) ReplyTo(o *Message) Envelope

+ func (m *Message) Send(ch Channel) error

+ func (m *Message) SendListener() SendListener

+ func (m *Message) SetSequence(seq int32)

+ func (m *Message) String() string

+ func (m *Message) ToSendable() Sendable

+ func (m *Message) WithPriority(p Priority) Envelope

+ func (m *Message) WithTimeout(duration time.Duration) TimeoutEnvelope

+ type MessageHeader struct

+ ContentType int32

+ Headers Headers

+ func (header *MessageHeader) GetBoolHeader(key int32) (bool, bool)

+ func (header *MessageHeader) GetByteHeader(key int32) (byte, bool)

+ func (header *MessageHeader) GetStringHeader(key int32) (string, bool)

+ func (header *MessageHeader) GetUint16Header(key int32) (uint16, bool)

+ func (header *MessageHeader) GetUint32Header(key int32) (uint32, bool)

+ func (header *MessageHeader) GetUint64Header(key int32) (uint64, bool)

+ func (header *MessageHeader) IsReply() bool

+ func (header *MessageHeader) IsReplyingTo(sequence int32) bool

+ func (header *MessageHeader) PutBoolHeader(key int32, value bool)

+ func (header *MessageHeader) PutByteHeader(key int32, value byte)

+ func (header *MessageHeader) PutStringHeader(key int32, value string)

+ func (header *MessageHeader) PutUint16Header(key int32, value uint16)

+ func (header *MessageHeader) PutUint32Header(key int32, value uint32)

+ func (header *MessageHeader) PutUint64Header(key int32, value uint64)

+ func (header *MessageHeader) ReplyFor() int32

+ func (header *MessageHeader) Sequence() int32

+ type Options struct

+ DelayRxStart bool

+ OutQueueSize int

+ WriteTimeout time.Duration

+ func DefaultOptions() *Options

+ func LoadOptions(data map[interface{}]interface{}) (*Options, error)

+ func (o Options) String() string

+ type PeekHandler interface

+ Close func(ch Channel)

+ Connect func(ch Channel, remoteAddress string)

+ Rx func(m *Message, ch Channel)

+ Tx func(m *Message, ch Channel)

+ type Priority uint32

+ type ReceiveHandler interface

+ HandleReceive func(m *Message, ch Channel)

+ type ReceiveHandlerF func(m *Message, ch Channel)

+ func (self ReceiveHandlerF) HandleReceive(m *Message, ch Channel)

+ type ReplyReceiver interface

+ AcceptReply func(*Message)

+ type Result struct

+ Message string

+ Success bool

+ func UnmarshalResult(message *Message) *Result

+ type SendListener interface

+ NotifyAfterWrite func()

+ NotifyBeforeWrite func()

+ NotifyErr func(error)

+ NotifyQueued func()

+ type Sendable interface

+ Context func() context.Context

+ Msg func() *Message

+ Priority func() Priority

+ ReplyReceiver func() ReplyReceiver

+ SendListener func() SendListener

+ Sequence func() int32

+ SetSequence func(seq int32)

+ type Sender interface

+ Send func(s Sendable) error

+ type TimeoutEnvelope interface

+ SendAndWaitForWire func(ch Channel) error

+ SendForReply func(ch Channel) (*Message, error)

+ type TimeoutError struct

+ func (self TimeoutError) Unwrap() error

+ type TraceHandler struct

+ func NewTraceHandler(path string, id string) (*TraceHandler, error)

+ func (h *TraceHandler) AddDecoder(decoder TraceMessageDecoder)

+ func (h *TraceHandler) Connect(ch Channel, remoteAddress string)

+ func (h TraceHandler) Close(ch Channel)

+ func (h TraceHandler) Rx(msg *Message, ch Channel)

+ func (h TraceHandler) Tx(msg *Message, ch Channel)

+ type TraceMessageDecode map[string]interface

+ func (d TraceMessageDecode) MarshalResult() ([]byte, bool)

+ func (d TraceMessageDecode) MarshalTraceMessageDecode() ([]byte, error)

+ func NewTraceMessageDecode(decoder, message string) TraceMessageDecode

+ type TraceMessageDecoder interface

+ Decode func(msg *Message) ([]byte, bool)

+ type TransformHandler interface

+ Rx func(m *Message, ch Channel)

+ Tx func(m *Message, ch Channel)

+ type TypedReceiveHandler interface

+ ContentType func() int32

+ type Underlay interface

+ Headers func() map[int32][]byte

+ IsClosed func() bool

+ Rx func() (*Message, error)

+ SetWriteTimeout func(duration time.Duration) error

+ Tx func(m *Message) error

+ type UnderlayFactory interface

+ Create func(timeout time.Duration, tcfg transport.Configuration) (Underlay, error)

+ func NewClassicDialer(identity *identity.TokenId, endpoint transport.Address, ...) UnderlayFactory

+ func NewReconnectingDialer(identity *identity.TokenId, endpoint transport.Address, ...) UnderlayFactory

+ func NewReconnectingDialerWithHandler(identity *identity.TokenId, endpoint transport.Address, ...) UnderlayFactory

+ type UnderlayListener interface

+ Listen func(handlers ...ConnectionHandler) error

+ func NewClassicListener(identity *identity.TokenId, endpoint transport.Address, ...) UnderlayListener

+ func NewClassicListenerWithTransportConfiguration(identity *identity.TokenId, endpoint transport.Address, ...) UnderlayListener

+ type UnsupportedVersionError struct

+ func (u UnsupportedVersionError) Error() string