net

package
v0.0.0-...-8585e13 Latest Latest
Warning

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

 Go to latest Published: Apr 10, 2025 License: MIT Imports: 15 Imported by: 0

Documentation

Overview

Package net implements different transports to communicate between Babble nodes.

This package contains various implementations of the Transport interface, which is used by Babble nodes to send and receive RPC requests (SyncRequest, EagerSyncRequest, JoinRequest, etc.). There are three implementations:

- Inmem: in-memory transport used only for testing

- TCP: communicating over plain TCP

- WebRTC: using WebRTC

TCP

The TCP transport is suitable when nodes are in the same local network, or when users are able to configure their connections appropriately to avoid NAT issues.

To use a TCP transport, set the following configuration options in the Babble Config object (cf config package):

- BinAdddr: the IP:PORT of the TCP socket that Babble binds to.

- AdvertiseAddr: (optional) The address that is advertised to other nodes. If BindAddr is a local address not reachable by other peers, it is usefull to set AdvertiseAddr to the reachable public address.

WebRTC

Because Babble is a peer-to-peer application, it can run into issues with NATs and firewalls. The WebRTC transport addresses the NAT traversal issue, but it requires centralised servers for peers to exchange connection information and to provide STUN/TURN services.

To use a WebRTC transport, use the following properties in the Config object:

- WebRTC: tells Babble to use a WebRTC transport

- SignalAddr: address of the WebRTC signaling server

- SignalRealm: routing domain within the signaling server

WebRTC requires a signaling mechanism for peers to exchange connection information. Usually, this would be implemented in a centralized server. So when the WebRTC transport is used, Babble is not fully p2p anymore. That being said, all the computation and data at the application layer remains p2p; the signaling server is only used as a sort of peer-discovery mechanism.

The WebRTCTransport ignores the BindAddr and AdvertiseAddr configuration values, but it requires the address of the signaling server. This address is specified by the SignalAddr configuration value. The SignalRealm defines a domain within the signaling server, such that signaling messages are only routed withing this domain.

Index

Constants

This section is empty.

Variables

View Source 
var (
	// ErrTransportShutdown is returned when operations on a transport are
	// invoked after it's been terminated.
	ErrTransportShutdown = errors.New("transport shutdown")
)

Functions

func NewInmemAddr 

func NewInmemAddr() string

NewInmemAddr returns a new in-memory addr with a randomly generate UUID as the ID.

Types

type EagerSyncRequest 

type EagerSyncRequest struct {
	FromID uint32
	Events []hashgraph.WireEvent
}

EagerSyncRequest ...

type EagerSyncResponse 

type EagerSyncResponse struct {
	FromID  uint32
	Success bool
}

EagerSyncResponse ...

type FastForwardRequest 

type FastForwardRequest struct {
	FromID uint32
}

FastForwardRequest ...

type FastForwardResponse 

type FastForwardResponse struct {
	FromID   uint32
	Block    hashgraph.Block
	Frame    hashgraph.Frame
	Snapshot []byte
}

FastForwardResponse ...

type InmemTransport 

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

InmemTransport Implements the Transport interface, to allow babble to be tested in-memory without going over a network.

func NewInmemTransport 

func NewInmemTransport(addr string) (string, *InmemTransport)

NewInmemTransport is used to initialize a new transport and generates a random local address if none is specified

func (*InmemTransport) AdvertiseAddr 

func (i *InmemTransport) AdvertiseAddr() string

AdvertiseAddr implements the Transport interface.

func (*InmemTransport) Close 

func (i *InmemTransport) Close() error

Close is used to permanently disable the transport

func (*InmemTransport) Connect 

func (i *InmemTransport) Connect(peer string, t Transport)

Connect is used to connect this transport to another transport for a given peer name. This allows for local routing.

func (*InmemTransport) Consumer 

func (i *InmemTransport) Consumer() <-chan RPC

Consumer implements the Transport interface.

func (*InmemTransport) Disconnect 

func (i *InmemTransport) Disconnect(peer string)

Disconnect is used to remove the ability to route to a given peer.

func (*InmemTransport) DisconnectAll 

func (i *InmemTransport) DisconnectAll()

DisconnectAll is used to remove all routes to peers.

func (*InmemTransport) EagerSync 

func (i *InmemTransport) EagerSync(target string, args *EagerSyncRequest, resp *EagerSyncResponse) error

EagerSync implements the Transport interface.

func (*InmemTransport) FastForward 

func (i *InmemTransport) FastForward(target string, args *FastForwardRequest, resp *FastForwardResponse) error

FastForward implements the Transport interface.

func (*InmemTransport) Join 

func (i *InmemTransport) Join(target string, args *JoinRequest, resp *JoinResponse) error

Join implements the Transport interface

func (*InmemTransport) Listen 

func (i *InmemTransport) Listen()

Listen is an empty function as there is no need to defer initialisation of the InMem service

func (*InmemTransport) LocalAddr 

func (i *InmemTransport) LocalAddr() string

LocalAddr implements the Transport interface.

func (*InmemTransport) Sync 

func (i *InmemTransport) Sync(target string, args *SyncRequest, resp *SyncResponse) error

Sync implements the Transport interface.

type JoinRequest 

type JoinRequest struct {
	InternalTransaction hashgraph.InternalTransaction
}

JoinRequest ...

type JoinResponse 

type JoinResponse struct {
	FromID        uint32
	Accepted      bool
	AcceptedRound int
	Peers         []*peers.Peer
}

JoinResponse ...

type NetworkTransport 

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

NetworkTransport provides a network based transport that can be used to communicate with babble on remote machines. It requires an underlying stream layer to provide a stream abstraction, which can be simple TCP, TLS, etc.

This transport is very simple and lightweight. Each RPC request is framed by sending a byte that indicates the message type, followed by the json encoded request.

The response is an error string followed by the response object, both are encoded using msgpack

func NewNetworkTransport 

func NewNetworkTransport(
	stream StreamLayer,
	maxPool int,
	timeout time.Duration,
	joinTimeout time.Duration,
	logger *logrus.Entry,
) *NetworkTransport

NewNetworkTransport creates a new network transport with the given dialer and listener. The maxPool controls how many connections we will pool (per target). The timeout is used to apply I/O deadlines.

func NewTCPTransport 

func NewTCPTransport(
	bindAddr string,
	advertise string,
	maxPool int,
	timeout time.Duration,
	joinTimeout time.Duration,
	logger *logrus.Entry,
) (*NetworkTransport, error)

NewTCPTransport returns a NetworkTransport that is built on top of a TCP streaming transport layer, with log output going to the supplied Logger

func NewWebRTCTransport 

func NewWebRTCTransport(
	signal signal.Signal,
	iceServers []webrtc.ICEServer,
	maxPool int,
	timeout time.Duration,
	joinTimeout time.Duration,
	logger *logrus.Entry,
) (*NetworkTransport, error)

NewWebRTCTransport returns a NetworkTransport that is built on top of a WebRTC StreamLayer. The signal is a mechanism for peers to exchange connection information prior to establishing a direct p2p link.

func (*NetworkTransport) AdvertiseAddr 

func (n *NetworkTransport) AdvertiseAddr() string

AdvertiseAddr implements the Transport interface.

func (*NetworkTransport) Close 

func (n *NetworkTransport) Close() error

Close is used to stop the network transport.

func (*NetworkTransport) Consumer 

func (n *NetworkTransport) Consumer() <-chan RPC

Consumer implements the Transport interface.

func (*NetworkTransport) EagerSync 

func (n *NetworkTransport) EagerSync(target string, args *EagerSyncRequest, resp *EagerSyncResponse) error

EagerSync implements the Transport interface.

func (*NetworkTransport) FastForward 

func (n *NetworkTransport) FastForward(target string, args *FastForwardRequest, resp *FastForwardResponse) error

FastForward implements the Transport interface.

func (*NetworkTransport) IsShutdown 

func (n *NetworkTransport) IsShutdown() bool

IsShutdown is used to check if the transport is shutdown.

func (*NetworkTransport) Join 

func (n *NetworkTransport) Join(target string, args *JoinRequest, resp *JoinResponse) error

Join implements the Transport interface.

func (*NetworkTransport) Listen 

func (n *NetworkTransport) Listen()

Listen opens the stream and handles incoming connections.

func (*NetworkTransport) LocalAddr 

func (n *NetworkTransport) LocalAddr() string

LocalAddr implements the Transport interface.

func (*NetworkTransport) Sync 

func (n *NetworkTransport) Sync(target string, args *SyncRequest, resp *SyncResponse) error

Sync implements the Transport interface.

type RPC 

type RPC struct {
	Command  interface{}
	Reader   io.Reader
	RespChan chan<- RPCResponse
}

RPC has a command, and provides a response mechanism.

func (*RPC) Respond 

func (r *RPC) Respond(resp interface{}, err error)

Respond is used to respond with a response, error or both

type RPCResponse 

type RPCResponse struct {
	Response interface{}
	Error    error
}

RPCResponse captures both a response and a potential error.

type StreamLayer 

type StreamLayer interface {
	net.Listener

	// Dial is used to create a new outgoing connection
	Dial(address string, timeout time.Duration) (net.Conn, error)

	// AdvertiseAddr returns the publicly-reachable address of the stream
	AdvertiseAddr() string
}

StreamLayer is used with the NetworkTransport to provide the low level stream abstraction.

type SyncRequest 

type SyncRequest struct {
	FromID    uint32
	Known     map[uint32]int
	SyncLimit int
}

SyncRequest ...

type SyncResponse 

type SyncResponse struct {
	FromID uint32
	Events []hashgraph.WireEvent
	Known  map[uint32]int
}

SyncResponse ...

type TCPStreamLayer 

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

TCPStreamLayer implements StreamLayer interface for plain TCP.

func (*TCPStreamLayer) Accept 

func (t *TCPStreamLayer) Accept() (c net.Conn, err error)

Accept implements the net.Listener interface.

func (*TCPStreamLayer) Addr 

func (t *TCPStreamLayer) Addr() net.Addr

Addr implements the net.Listener interface.

func (*TCPStreamLayer) AdvertiseAddr 

func (t *TCPStreamLayer) AdvertiseAddr() string

AdvertiseAddr implements the SteamLayer interface.

func (*TCPStreamLayer) Close 

func (t *TCPStreamLayer) Close() (err error)

Close implements the net.Listener interface.

func (*TCPStreamLayer) Dial 

func (t *TCPStreamLayer) Dial(address string, timeout time.Duration) (net.Conn, error)

Dial implements the StreamLayer interface.

type Transport 

type Transport interface {

	// Starts the transport listening
	Listen()

	// Consumer returns a channel that can be used to
	// consume and respond to RPC requests.
	Consumer() <-chan RPC

	// LocalAddr is used to return our local address
	LocalAddr() string

	// AdvertiseAddr is used to return our advertise address where other peers
	// can reach us
	AdvertiseAddr() string

	Sync(target string, args *SyncRequest, resp *SyncResponse) error

	EagerSync(target string, args *EagerSyncRequest, resp *EagerSyncResponse) error

	FastForward(target string, args *FastForwardRequest, resp *FastForwardResponse) error

	Join(target string, args *JoinRequest, resp *JoinResponse) error

	// Close permanently closes a transport, stopping
	// any associated goroutines and freeing other resources.
	Close() error
}

Transport provides an interface for network transports to allow a node to communicate with other nodes.

Source Files

View all Source files

Directories

Path Synopsis
Package signal defines an interface for WebRTC signaling mechanisms used by the WebRTCTransport.
 Package signal defines an interface for WebRTC signaling mechanisms used by the WebRTCTransport.
wamp
Package wamp implements a WebRTC signaling system using RPC over WebSockets.
 Package wamp implements a WebRTC signaling system using RPC over WebSockets.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.