node

type Client ¶

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

Client is the client for the RPC API of a node.

func NewClient(secret string, clientCert *tls.Certificate) *Client

func (c *Client) Peers() ([]string, []string)

func (c *Client) RegisterPeer(node string, rpc string, fingerprint string) error

func (c *Client) RemovePeer(node string)

func (c *Client) SSLFingerprint() string

func (c *Client) SendData(node string, ctrl map[string]string, data []byte) ([]byte, error)

func (c *Client) SendPing(node string, rpc string) ([]string, string, error)

func (c *Client) SendRequest(node string, remoteCall RPCFunction,
	args map[RequestArgument]interface{}) (interface{}, error)

func (c *Client) Shutdown()

type Error ¶

type Error struct {
	Type       error  // Error type (to be used for equal checks)
	Detail     string // Details of this error
	IsNotExist bool   // Error is file or directory does not exist
}

Error is a network related error

func (ge *Error) Error() string

type Logger ¶

type Logger func(v ...interface{})

Logger is a function which processes log messages

type RPCFunction ¶

type RPCFunction string

RPCFunction is used to identify the called function in a RPC call

const (
	RPCPing RPCFunction = "Ping"
	RPCData RPCFunction = "Data"
)

type RequestArgument ¶

type RequestArgument int

RequestArgument is used to identify arguments in a RPC call

const (
	RequestTARGET RequestArgument = iota // Required argument which identifies the target node
	RequestTOKEN                         // Client token which is used for authorization checks
	RequestCTRL                          // Control object (i.e. what to do with the data)
	RequestDATA                          // Data object
)

type RequestHandler ¶

type RequestHandler func(ctrl map[string]string, data []byte) ([]byte, error)

RequestHandler is a function to handle incoming requests. A request has a control object which contains information on what the data is and how it should be used and the data itself. The request handler should return the result or an error.

type RufsNode ¶

type RufsNode struct {
	Client *Client // RPC client object

	DataHandler RequestHandler // Handler function for data requests
	// contains filtered or unexported fields
}

RufsNode is the management object for a node in the Rufs network.

A RufsNode registers itself to the rpc server which is the global server object. Each node needs to have a unique name. Communication between nodes is secured by using a secret string which is never exchanged over the network and a hash generated token which identifies a member.

Each RufsNode object contains a Client object which can be used to communicate with other nodes. This object should be used by pure clients - code which should communicate with the cluster without running an actual member.

func NewNode(rpcInterface string, name string, secret string, clientCert *tls.Certificate,
	dataHandler RequestHandler) *RufsNode

func (rn *RufsNode) LogInfo(v ...interface{})

func (rn *RufsNode) Name() string

func (rn *RufsNode) SSLFingerprint() string

func (rn *RufsNode) Shutdown() error

func (rn *RufsNode) Start(serverCert *tls.Certificate) error

type RufsNodeToken ¶

type RufsNodeToken struct {
	NodeName string
	NodeAuth string
}

RufsNodeToken is used to authenticate a node in the network to other nodes

type RufsServer ¶

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

RufsServer is the RPC exposed Rufs API of a machine. Server is a singleton and will route incoming (authenticated) requests to registered RufsNodes. The calling node is referred to as source node and the called node is referred to as target node.

func (s *RufsServer) Data(request map[RequestArgument]interface{},
	response *interface{}) error

func (s *RufsServer) Ping(request map[RequestArgument]interface{},
	response *interface{}) error