peer

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

type BackendConfig struct {
	ReceiveTimeout time.Duration
	ProcessTimeout time.Duration
	IdleTimeout    time.Duration
}

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

type ClientProducer interface {
	Pop(target string) (SyncClient, error)
	Push(target string, client SyncClient)
	Close()
}

type CreateListenerFunc func(network, address string) (net.Listener, error)

type CreateNetConnFunc func(network,
	address string, timeout time.Duration) (net.Conn, error)

type CreateSyncClientFunc func(target string,
	timeout time.Duration) (SyncClient, error)

type FastForwardRequest struct {
	FromID uint64
}

type FastForwardResponse struct {
	FromID   uint64
	Block    poset.Block
	Frame    poset.Frame
	Snapshot []byte
}

type ForceSyncRequest struct {
	FromID uint64
	Events []poset.WireEvent
}

type ForceSyncResponse struct {
	FromID  uint64
	Success bool
}

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

type NewSyncClientFunc func(target string) (SyncClient, error)

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

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

type RPC struct {
	Command  interface{}
	RespChan chan<- *RPCResponse
}

type RPCClient interface {
	Go(serviceMethod string, args interface{},
		reply interface{}, done chan *rpc.Call) *rpc.Call
	Close() error
}

type RPCResponse struct {
	Response interface{}
	Error    error
}

type SyncClient interface {
	Sync(ctx context.Context,
		req *SyncRequest, resp *SyncResponse) error
	ForceSync(ctx context.Context,
		req *ForceSyncRequest, resp *ForceSyncResponse) error
	FastForward(ctx context.Context,
		req *FastForwardRequest, resp *FastForwardResponse) error
	Close() error
}

type SyncPeer interface {
	Sync(ctx context.Context, target string,
		req *SyncRequest, resp *SyncResponse) error
	ForceSync(ctx context.Context, target string,
		req *ForceSyncRequest, resp *ForceSyncResponse) error
	FastForward(ctx context.Context, target string,
		req *FastForwardRequest, resp *FastForwardResponse) error
	ReceiverChannel() <-chan *RPC
	Close() error
}

type SyncRequest struct {
	FromID uint64
	Known  map[uint64]int64
}

type SyncResponse struct {
	FromID    uint64
	SyncLimit bool
	Events    []poset.WireEvent
	Known     map[uint64]int64
}

type SyncServer interface {
	ReceiverChannel() <-chan *RPC
	ListenAndServe(network, address string) error
	Close() error
}