transport

type Discard ¶

type Discard struct{}

Discard provides a client transport which discards all data and always reports success. This is useful for tests and benchmarks, when we do not want to send network messages for real.

func (d *Discard) Send(address encoding.Address, buffer []byte) error

type Error ¶

type Error struct{}

Error provides a client transport which always returns an error. This is useful for tests and benchmarks, when we do not want to send network messages for real.

func (d *Error) Send(address encoding.Address, buffer []byte) error

type Memory ¶

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

Memory provides a transport implementation which moves network messages through memory between members. This is helpful for tests where you want to simulate the interaction between multiple members without having any real network involved. This transport can guarantee that network messages were delivered through its Flush calls. A normal network stack cannot provide such guarantees.

func NewMemory() *Memory

func (m *Memory) AddPendingSend(address encoding.Address, buffer []byte)

func (m *Memory) AddTarget(address encoding.Address, target Target)

func (m *Memory) Addresses() []encoding.Address

func (m *Memory) Client() *MemoryClient

func (m *Memory) FlushAllPendingSends() error

func (m *Memory) FlushPendingSends(address encoding.Address) (bool, error)

type MemoryClient ¶

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

MemoryClient is a client which used to communicate with other targets through the memory transport.

func (m *MemoryClient) Send(address encoding.Address, buffer []byte) error

type Store ¶

type Store struct {
	Addresses []encoding.Address
	Buffers   [][]byte
}

Store provides a client transport which stores all data and always reports success. This is useful for tests, when we need to check if some specific data was transmitted.

func (s *Store) Clear()

func (s *Store) Send(address encoding.Address, buffer []byte) error

type TCPClient ¶

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

TCPClient provides reliable transport for sending data to a member.

TCPClient is not safe for concurrent use by multiple goroutines. Callers must serialize access to all methods. As this client is always called under the lock of the membership.List we have that serialization there.

func NewTCPClient(key encryption.Key) (*TCPClient, error)

func (c *TCPClient) Send(address encoding.Address, buffer []byte) error

type TCPServer ¶

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

TCPServer provides reliable transport for receiving data from members.

TCPServer is safe for concurrent use by multiple goroutines. Access to shared state is internally synchronized.

func NewTCPServer(logger logr.Logger, target Target, bindAddress string, keys []encryption.Key) (*TCPServer, error)

func (t *TCPServer) Addr() (encoding.Address, error)

func (t *TCPServer) Shutdown() error

func (t *TCPServer) Startup() error

type Target ¶

type Target interface {
	DispatchDatagram(buffer []byte) error
}

Target is the interface which the target needs to implement for processing incoming network messages.

type Transport ¶

type Transport interface {
	Send(address encoding.Address, buffer []byte) error
}

Transport is the interface the transport needs to implement for transmitting data between members.

type UDPClient ¶

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

UDPClient provides unreliable transport for sending data to a member.

UDPClient is not safe for concurrent use by multiple goroutines. Callers must serialize access to all methods. As this client is always called under the lock of the membership.List we have that serialization there.

func NewUDPClient(maxDatagramLength int, key encryption.Key) (*UDPClient, error)

func (c *UDPClient) Send(address encoding.Address, buffer []byte) error

type UDPServer ¶

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

UDPServer provides unreliable transport for receiving data from members.

UDPServer is safe for concurrent use by multiple goroutines. As the background task is reading and processing one udp message after the other, there is no special need for serialization.

func NewUDPServer(logger logr.Logger, target Target, bindAddress string, receiveBufferLength int, keys []encryption.Key) (*UDPServer, error)

func (t *UDPServer) Addr() (encoding.Address, error)

func (t *UDPServer) Shutdown() error

func (t *UDPServer) Startup() error

type Unreliable ¶

type Unreliable struct {
	// Transport is the transport to forward calls to.
	Transport Transport

	// Reliability is how often a send request is forwarded to the transport. Value is 0.0 to 1.0 with 0.0 meaning that
	// sends are never forwarded, 0.5 means that sends are forwarded 50% of the time and 1.0 means that sends are always
	// forwarded.
	Reliability float64
}

Unreliable provides a client transport which forwards the call to some other transport only some time. The other time the transmission is silently dropped. This helps in simulating a lossy network.

func (u *Unreliable) Send(address encoding.Address, buffer []byte) error