netrpc

type Client ¶

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

func (c *Client) Close() error

func (c *Client) Connect(addr string) error

type ClientWriteArgs ¶

type ClientWriteArgs struct {
	Key   string
	Value []byte
}

---------------------------------------------------------------------------- net/rpc argument and reply structs

type CommitArgs ¶

type CommitArgs struct {
	Key     string
	Version uint64
}

---------------------------------------------------------------------------- net/rpc argument and reply structs

type CoordinatorBinding ¶

type CoordinatorBinding struct {
	Svc transport.CoordinatorService
}

CoordinatorBinding provides a layer of translation between the CoordinatorService which is transport agnostic and the net/rpc package. This allows using the net/rpc package to invoke CoordinatorService methods.

func (c *CoordinatorBinding) AddNode(addr *string, r *transport.NodeMeta) error

func (c *CoordinatorBinding) RemoveNode(addr *string, r *EmptyReply) error

func (c *CoordinatorBinding) Write(args *ClientWriteArgs, r *EmptyReply) error

type CoordinatorClient ¶

type CoordinatorClient struct {
	*Client
}

CoordinatorClient is for invoking net/rpc methods on a Coordinator.

func (cc *CoordinatorClient) AddNode(addr string) (*transport.NodeMeta, error)

func (cc *CoordinatorClient) RemoveNode(addr string) error

func (cc *CoordinatorClient) Write(k string, v []byte) error

type EmptyArgs ¶

type EmptyArgs struct{}

---------------------------------------------------------------------------- net/rpc argument and reply structs

type EmptyReply ¶

type EmptyReply struct{}

---------------------------------------------------------------------------- net/rpc argument and reply structs

type NodeBinding ¶

type NodeBinding struct {
	Svc transport.NodeService
}

NodeBinding provides a layer of translation between the NodeService which is transport agnostic and the net/rpc package. This allows using the net/rpc package to invoke NodeService methods.

func (n *NodeBinding) BackPropagate(
	args *transport.PropagateRequest,
	reply *transport.PropagateResponse,
) error

func (n *NodeBinding) ClientWrite(args *ClientWriteArgs, _ *EmptyReply) error

func (n *NodeBinding) Commit(args *CommitArgs, _ *EmptyReply) error

func (n *NodeBinding) FwdPropagate(
	args *transport.PropagateRequest,
	reply *transport.PropagateResponse,
) error

func (n *NodeBinding) LatestVersion(key string, reply *VersionResponse) error

func (n *NodeBinding) Ping(_ *EmptyArgs, _ *EmptyReply) error

func (n *NodeBinding) Read(key string, reply *transport.Item) error

func (n *NodeBinding) ReadAll(_ *EmptyArgs, reply *[]transport.Item) error

func (n *NodeBinding) Update(args *transport.NodeMeta, _ *EmptyReply) error

func (n *NodeBinding) Write(args *WriteArgs, _ *EmptyReply) error

type NodeClient ¶

type NodeClient struct {
	*Client
}

func (nc *NodeClient) BackPropagate(
	vByK *transport.PropagateRequest,
) (*transport.PropagateResponse, error)

func (nc *NodeClient) ClientWrite(key string, value []byte) error

func (nc *NodeClient) Commit(key string, version uint64) error

func (nc *NodeClient) FwdPropagate(
	vByK *transport.PropagateRequest,
) (*transport.PropagateResponse, error)

func (nc *NodeClient) LatestVersion(key string) (string, uint64, error)

func (nc *NodeClient) Ping() error

func (nc *NodeClient) Read(key string) (string, []byte, error)

func (nc *NodeClient) ReadAll() (*[]transport.Item, error)

func (nc *NodeClient) Update(meta *transport.NodeMeta) error

func (nc *NodeClient) Write(key string, value []byte, version uint64) error

type VersionResponse ¶

type VersionResponse struct {
	Key     string
	Version uint64
}

---------------------------------------------------------------------------- net/rpc argument and reply structs

type WriteArgs ¶

type WriteArgs struct {
	Key     string
	Value   []byte
	Version uint64
}

---------------------------------------------------------------------------- net/rpc argument and reply structs