comm

package
v0.0.0-...-65b1d8a Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 8, 2014 License: BSD-3-Clause Imports: 18 Imported by: 0

Documentation

Index

Constants

View Source
const (
	DefaultTransportBufferSize = 16
)

Variables

View Source
var (
	MemoryTransportReadTimeout error = errors.New(
		"timeout on memory transport read")
	MemoryTransportWriteTimeout error = errors.New(
		"timeout on memory transport write")
)
View Source
var (
	RPCErrorInvalidRequest        error = errors.New("invalid rpc request")
	RPCErrorInvalidResponse             = errors.New("invalid rpc response")
	RPCErrorNoConnectionForTarget       = errors.New("no connection for this target")
)

Functions

func BytesCopy

func BytesCopy(dest []byte, src []byte) int

func FirstAddr

func FirstAddr(multiAddr ps.MultiAddr) ps.Addr

func MultiAddrToRPCMap

func MultiAddrToRPCMap(addr ps.MultiAddr) map[string]string

func ReadN

func ReadN(reader io.Reader, b []byte) (int, error)

func ReadRequest

func ReadRequest(
	reader *bufio.Reader,
	decoder Decoder) (ev.RequestEvent, error)

func ReadResponse

func ReadResponse(
	reader *bufio.Reader,
	decoder Decoder) (ev.Event, error)

func WriteEvent

func WriteEvent(
	writer *bufio.Writer,
	encoder Encoder,
	event ev.Event) error

func WriteN

func WriteN(writer io.Writer, b []byte) (int, error)

Types

type BufferedTransport

type BufferedTransport struct{}

TODO to impl Transport

type Client

type Client interface {
	CallRPCTo(
		target ps.MultiAddr, request ev.Event) (response ev.Event, err error)
	io.Closer
}

type Connection

type Connection interface {
	Open() error
	io.Closer

	PeerAddr() ps.MultiAddr
	CallRPC(request ev.Event) (response ev.Event, err error)
}

type Decoder

type Decoder interface {
	Decode(e interface{}) error
}

type Encoder

type Encoder interface {
	Encode(e interface{}) error
}

type EventHandler

type EventHandler func(ev.Event)

type FileTransport

type FileTransport struct{}

TODO to impl Transport

type FramedTransport

type FramedTransport struct{}

TODO to impl Transport

type HTTPTransport

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

func NewHTTPTransport

func NewHTTPTransport(url string) *HTTPTransport

func (*HTTPTransport) Close

func (self *HTTPTransport) Close() error

func (*HTTPTransport) Open

func (self *HTTPTransport) Open() error

func (*HTTPTransport) Read

func (self *HTTPTransport) Read(b []byte) (int, error)

func (*HTTPTransport) Write

func (self *HTTPTransport) Write(b []byte) (int, error)

type MemoryClient

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

func NewMemoryClient

func NewMemoryClient(
	poolSize int,
	timeout time.Duration,
	register *MemoryTransportRegister) *MemoryClient

func (*MemoryClient) CallRPCTo

func (self *MemoryClient) CallRPCTo(
	target ps.MultiAddr, request ev.Event) (response ev.Event, err error)

func (*MemoryClient) Close

func (self *MemoryClient) Close() error

type MemoryConnection

type MemoryConnection struct {
	*MemoryTransport
	// contains filtered or unexported fields
}

func NewMemoryConnection

func NewMemoryConnection(
	addr ps.MultiAddr,
	timeout time.Duration,
	register *MemoryTransportRegister) *MemoryConnection

func (*MemoryConnection) CallRPC

func (self *MemoryConnection) CallRPC(
	request ev.Event) (response ev.Event, err error)

type MemoryServer

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

func NewMemoryServer

func NewMemoryServer(
	bindAddr ps.MultiAddr,
	timeout time.Duration,
	eventHandler RequestEventHandler,
	register *MemoryTransportRegister,
	logger logging.Logger) *MemoryServer

func (*MemoryServer) Close

func (self *MemoryServer) Close() error

func (*MemoryServer) Serve

func (self *MemoryServer) Serve()

type MemoryServerTransport

type MemoryServerTransport struct {
	ConsumeCh  chan *TransportChunk
	ResponseCh chan []byte
	// contains filtered or unexported fields
}

func NewMemoryServerTransport

func NewMemoryServerTransport(
	addr ps.MultiAddr,
	timeout time.Duration,
	register *MemoryTransportRegister) *MemoryServerTransport

func (*MemoryServerTransport) Addr

func (self *MemoryServerTransport) Addr() ps.MultiAddr

func (*MemoryServerTransport) Close

func (self *MemoryServerTransport) Close() error

func (*MemoryServerTransport) Open

func (self *MemoryServerTransport) Open() error

func (*MemoryServerTransport) Read

func (self *MemoryServerTransport) Read(p []byte) (int, error)

func (*MemoryServerTransport) ReadChunk

func (self *MemoryServerTransport) ReadChunk() (*TransportChunk, error)

func (*MemoryServerTransport) ReadNextMessage

func (self *MemoryServerTransport) ReadNextMessage() *TransportChunk

func (*MemoryServerTransport) Write

func (self *MemoryServerTransport) Write(p []byte) (int, error)

func (*MemoryServerTransport) WriteChunk

func (self *MemoryServerTransport) WriteChunk(chunk *TransportChunk) error

type MemoryTransport

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

func NewMemoryTransport

func NewMemoryTransport(
	addr ps.MultiAddr,
	timeout time.Duration,
	register *MemoryTransportRegister) *MemoryTransport

func (*MemoryTransport) Close

func (self *MemoryTransport) Close() error

func (*MemoryTransport) Open

func (self *MemoryTransport) Open() error

func (*MemoryTransport) PeerAddr

func (self *MemoryTransport) PeerAddr() ps.MultiAddr

func (*MemoryTransport) Read

func (self *MemoryTransport) Read(b []byte) (int, error)

func (*MemoryTransport) Write

func (self *MemoryTransport) Write(b []byte) (int, error)

type MemoryTransportRegister

type MemoryTransportRegister struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewMemoryTransportRegister

func NewMemoryTransportRegister() *MemoryTransportRegister

func (*MemoryTransportRegister) Get

func (self *MemoryTransportRegister) Get(
	id string) (transport *MemoryServerTransport, ok bool)

func (*MemoryTransportRegister) Register

func (self *MemoryTransportRegister) Register(
	id string, transport *MemoryServerTransport)

func (*MemoryTransportRegister) Reset

func (self *MemoryTransportRegister) Reset() error

func (*MemoryTransportRegister) String

func (self *MemoryTransportRegister) String() string

func (*MemoryTransportRegister) Unregister

func (self *MemoryTransportRegister) Unregister(id string) error

type RPCAppendEntriesRequest

type RPCAppendEntriesRequest ev.AppendEntriesRequest

type RPCAppendEntriesResponse

type RPCAppendEntriesResponse struct {
	Response *ev.AppendEntriesResponse
}

type RPCAuth

type RPCAuth struct {
	User     string
	Password string
}

type RPCClient

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

func NewRPCClient

func NewRPCClient(timeout time.Duration, auth *RPCAuth) *RPCClient

func (*RPCClient) CallRPCTo

func (self *RPCClient) CallRPCTo(
	target ps.MultiAddr, request ev.Event) (response ev.Event, err error)

func (*RPCClient) Close

func (self *RPCClient) Close() error

type RPCClientAppendRequest

type RPCClientAppendRequest ev.ClientAppendRequest

type RPCClientChangeConfigRequest

type RPCClientChangeConfigRequest ev.ClientChangeConfigRequest

type RPCClientGetConfigRequest

type RPCClientGetConfigRequest ev.ClientGetConfigRequest

type RPCClientReadOnlyRequest

type RPCClientReadOnlyRequest ev.ClientReadOnlyRequest

type RPCClientResponse

type RPCClientResponse struct {
	Result RPCResultType
	Data   []byte
	Conf   *ps.Config
	Leader *ps.ServerAddress
	Error  string
}

type RPCClientService

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

func NewRPCClientService

func NewRPCClientService(eventHandler RequestEventHandler) *RPCClientService

func (*RPCClientService) Append

func (self *RPCClientService) Append(
	args *RPCClientAppendRequest, reply *RPCClientResponse) error

func (*RPCClientService) ChangeConfig

func (self *RPCClientService) ChangeConfig(
	args *RPCClientChangeConfigRequest, reply *RPCClientResponse) error

func (*RPCClientService) GetConfig

func (self *RPCClientService) GetConfig(
	args *RPCClientGetConfigRequest, reply *RPCClientResponse) error

func (*RPCClientService) ReadOnly

func (self *RPCClientService) ReadOnly(
	args *RPCClientReadOnlyRequest, reply *RPCClientResponse) error

type RPCConnection

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

func NewRPCConnection

func NewRPCConnection(
	addr ps.MultiAddr, timeout time.Duration, auth *RPCAuth) *RPCConnection

func (*RPCConnection) CallRPC

func (self *RPCConnection) CallRPC(
	request ev.Event) (response ev.Event, err error)

func (*RPCConnection) Close

func (self *RPCConnection) Close() error

func (*RPCConnection) Open

func (self *RPCConnection) Open() error

func (*RPCConnection) PeerAddr

func (self *RPCConnection) PeerAddr() ps.MultiAddr

type RPCInstallSnapshotRequest

type RPCInstallSnapshotRequest ev.InstallSnapshotRequest

type RPCInstallSnapshotResponse

type RPCInstallSnapshotResponse struct {
	Response *ev.InstallSnapshotResponse
}

type RPCRaftService

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

func NewRPCRaftService

func NewRPCRaftService(eventHandler RequestEventHandler) *RPCRaftService

func (*RPCRaftService) AppendEntries

func (self *RPCRaftService) AppendEntries(
	args *RPCAppendEntriesRequest, reply *RPCAppendEntriesResponse) error

func (*RPCRaftService) InstallStapshot

func (self *RPCRaftService) InstallStapshot(
	args *RPCInstallSnapshotRequest, reply *RPCInstallSnapshotResponse) error

func (*RPCRaftService) RequestVote

func (self *RPCRaftService) RequestVote(
	args *RPCRequestVoteRequest, reply *RPCRequestVoteResponse) error

type RPCRequestVoteRequest

type RPCRequestVoteRequest ev.RequestVoteRequest

type RPCRequestVoteResponse

type RPCRequestVoteResponse struct {
	Response *ev.RequestVoteResponse
}

type RPCResultType

type RPCResultType int
const (
	RPCResultUnknown RPCResultType = iota
	RPCResultSuccess
	RPCResultFail
	RPCResultLeaderUnknown
	RPCResultLeaderUnsync
	RPCResultLeaderRedirect
	RPCResultLeaderInMemberChange
	RPCResultPersistError
	RPCResultGetConfig
)

type RPCServer

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

func NewRPCServer

func NewRPCServer(
	bindAddr ps.MultiAddr,
	timeout time.Duration,
	rpcAuth *RPCAuth,
	eventHandler RequestEventHandler,
	logger logging.Logger) (*RPCServer, error)

func (*RPCServer) Close

func (self *RPCServer) Close() error

func (*RPCServer) Serve

func (self *RPCServer) Serve()

func (*RPCServer) SetReadTimeout

func (self *RPCServer) SetReadTimeout(timeout time.Duration)

func (*RPCServer) SetWriteTimeout

func (self *RPCServer) SetWriteTimeout(timeout time.Duration)

type RequestEventHandler

type RequestEventHandler func(ev.RequestEvent)

type Server

type Server interface {
	Serve()
	io.Closer
}

type SocketClient

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

func NewSocketClient

func NewSocketClient(poolSize int, timeout time.Duration) *SocketClient

func (*SocketClient) CallRPCTo

func (self *SocketClient) CallRPCTo(
	target1 ps.MultiAddr, request ev.Event) (response ev.Event, err error)

func (*SocketClient) Close

func (self *SocketClient) Close() error

type SocketConnection

type SocketConnection struct {
	*SocketTransport
	// contains filtered or unexported fields
}

func NewSocketConnection

func NewSocketConnection(
	addr net.Addr, timeout time.Duration) *SocketConnection

func (*SocketConnection) CallRPC

func (self *SocketConnection) CallRPC(
	request ev.Event) (response ev.Event, err error)

type SocketNetworkLayer

type SocketNetworkLayer struct {
	*SocketClient
	*SocketServer
}

func NewSocketNetworkLayer

func NewSocketNetworkLayer(
	client *SocketClient,
	server *SocketServer) *SocketNetworkLayer

type SocketServer

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

func NewSocketServer

func NewSocketServer(
	bindAddr net.Addr,
	timeout time.Duration,
	eventHandler RequestEventHandler,
	logger logging.Logger) (*SocketServer, error)

func (*SocketServer) Close

func (self *SocketServer) Close() error

func (*SocketServer) Serve

func (self *SocketServer) Serve()

func (*SocketServer) SetReadTimeout

func (self *SocketServer) SetReadTimeout(timeout time.Duration)

func (*SocketServer) SetWriteTimeout

func (self *SocketServer) SetWriteTimeout(timeout time.Duration)

type SocketTransport

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

func NewSocketTransport

func NewSocketTransport(addr net.Addr, timeout time.Duration) *SocketTransport

func (*SocketTransport) Close

func (self *SocketTransport) Close() error

func (*SocketTransport) Open

func (self *SocketTransport) Open() error

func (*SocketTransport) PeerAddr

func (self *SocketTransport) PeerAddr() net.Addr

func (*SocketTransport) Read

func (self *SocketTransport) Read(b []byte) (int, error)

func (*SocketTransport) SetReadTimeout

func (self *SocketTransport) SetReadTimeout(timeout time.Duration)

func (*SocketTransport) SetWriteTimeout

func (self *SocketTransport) SetWriteTimeout(timeout time.Duration)

func (*SocketTransport) Write

func (self *SocketTransport) Write(b []byte) (int, error)

type TcpKeepAliveListener

type TcpKeepAliveListener struct {
	*net.TCPListener
}
Copied from net.http.server.go

tcpKeepAliveListener sets TCP keep-alive timeouts on accepted connections. It's used by ListenAndServe and ListenAndServeTLS so dead TCP connections (e.g. closing laptop mid-download) eventually go away.

func (TcpKeepAliveListener) Accept

func (ln TcpKeepAliveListener) Accept() (c net.Conn, err error)

type Transport

type Transport interface {
	Open() error
	io.Closer

	io.Reader
	io.Writer
}

type TransportChunk

type TransportChunk struct {
	Data     []byte
	SourceCh chan []byte
}

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL