inet256

Documentation

Index

• Constants
• Variables
• func HasPrefix(x []byte, prefix []byte, nbits int) bool
• func IsErrClosed(err error) bool
• func IsPublicKeyNotFound(err error) bool
• func IsUnreachable(err error) bool
• func MarshalPublicKey(pubKey PublicKey) []byte
• func NewPacketConn(n Node) net.PacketConn
• func Receive(ctx context.Context, n Node, msg *Message) error
• type Addr
  • func AddrFromBytes(x []byte) Addr
  • func NewAddr(pubKey PublicKey) Addr
  • func ParseAddrB64(data []byte) (Addr, error)
  • func (a Addr) GetPeerID() p2p.PeerID
  • func (a Addr) IsZero() bool
  • func (a Addr) MarshalText() ([]byte, error)
  • func (a Addr) Network() string
  • func (a Addr) String() string
  • func (a *Addr) UnmarshalText(x []byte) error
• type ErrAddrUnreachable
  • func (e ErrAddrUnreachable) Error() string
• type ID
• type Logger
• type Message
• type Network
• type NetworkFactory
• type NetworkParams
• type Node
• type PeerSet
• type PeerStore
• type PrivateKey
• type PublicKey
  • func ParsePublicKey(data []byte) (PublicKey, error)
• type ReceiveFunc
• type Service
• type Swarm

Constants

const (
	// MinMTU is the minimum MTU a network can provide to any address.
	// Applications should be designed to operate correctly if they can only send messages up to this size.
	MinMTU = 1 << 15
	// MaxMTU is the size of largest message that a network will ever receive from any address.
	// Applications should be prepared to receieve this much data at a time or they may encounter io.ErrShortBuffer
	MaxMTU = 1 << 16
)

const (
	// TransportMTU is the guaranteed MTU presented to networks.
	TransportMTU = (1 << 16) - 1
)

Variables

var (
	ErrPublicKeyNotFound = p2p.ErrPublicKeyNotFound
	ErrNoAddrWithPrefix  = errors.New("no address with prefix")
	ErrClosed            = net.ErrClosed
)

Functions

func HasPrefix

func HasPrefix(x []byte, prefix []byte, nbits int) bool

func IsErrClosed

func IsErrClosed(err error) bool

func IsPublicKeyNotFound

func IsPublicKeyNotFound(err error) bool

func IsUnreachable

func IsUnreachable(err error) bool

func MarshalPublicKey

func MarshalPublicKey(pubKey PublicKey) []byte

func NewPacketConn

func NewPacketConn(n Node) net.PacketConn

NewPacketConn wraps a node with the net.PacketConn interface

func Receive

func Receive(ctx context.Context, n Node, msg *Message) error

Receive is a utility function for copying a message from the Node n into msg

Types

type Addr

type Addr [32]byte

Addr is an address in an INET256 Network. It uniquely identifies a Node.

func AddrFromBytes

func AddrFromBytes(x []byte) Addr

AddrFromBytes creates a new address by reading up to 32 bytes from x Note that these bytes are not interpretted as a public key, they are interpretted as the raw address. To derive an address from a PublicKey use NewAddr

func NewAddr

func NewAddr(pubKey PublicKey) Addr

NewAddr creates a new Addr from a PublicKey

func ParseAddrB64

func ParseAddrB64(data []byte) (Addr, error)

ParseAddrB64 attempts to parse a base64 encoded INET256 address from data

func (Addr) GetPeerID

func (a Addr) GetPeerID() p2p.PeerID

GetPeerID implements p2p.HasPeerID

func (Addr) IsZero

func (a Addr) IsZero() bool

func (Addr) MarshalText

func (a Addr) MarshalText() ([]byte, error)

func (Addr) Network

func (a Addr) Network() string

Network implements net.Addr.Network

func (Addr) String

func (a Addr) String() string

String implements net.Addr.String

func (*Addr) UnmarshalText

func (a *Addr) UnmarshalText(x []byte) error

type ErrAddrUnreachable

type ErrAddrUnreachable struct {
	Addr Addr
}

func (ErrAddrUnreachable) Error

func (e ErrAddrUnreachable) Error() string

type ID

type ID = Addr

ID is an alias for Addr

type Logger

type Logger = logrus.Logger

type Message

type Message struct {
	Src     Addr
	Dst     Addr
	Payload []byte
}

Message is the essential information carried by Tell and Receive provided as a struct for use in queues or other APIs

type Network

type Network interface {
	Tell(ctx context.Context, addr Addr, data []byte) error
	Receive(ctx context.Context, fn ReceiveFunc) error

	MTU(ctx context.Context, addr Addr) int
	LookupPublicKey(ctx context.Context, addr Addr) (PublicKey, error)
	FindAddr(ctx context.Context, prefix []byte, nbits int) (Addr, error)

	LocalAddr() Addr
	PublicKey() PublicKey

	Bootstrap(ctx context.Context) error
	Close() error
}

Network is an instantiated network routing algorithm

This interface is not described in the spec, and is incidental to the implementation.

type NetworkFactory

type NetworkFactory func(NetworkParams) Network

NetworkFactory is a constructor for a network

type NetworkParams

type NetworkParams struct {
	PrivateKey PrivateKey
	Swarm      Swarm
	Peers      PeerSet

	Logger *Logger
}

NetworkParams are passed to a NetworkFactory to create a Network. This type really defines the problem domain quite well. Essentially it is a set of one-hop peers and a means to send messages to them.

type Node

type Node interface {
	// Tell sends a message containing data to the node at addr.
	// The message will be delivered at most once.
	Tell(ctx context.Context, addr Addr, data []byte) error
	// Receive calls fn with a message sent to this node.
	// The message fields, and payload must not be accessed outside fn.
	Receive(ctx context.Context, fn ReceiveFunc) error

	// MTU finds the maximum message size that can be sent to addr.
	// If the context expires, a reasonable default (normally a significant underestimate) will be returned.
	MTU(ctx context.Context, addr Addr) int
	// LookupPublicKey attempts to find the public key corresponding to addr.
	// If it can't find it, ErrPublicKeyNotFound is returned.
	LookupPublicKey(ctx context.Context, addr Addr) (PublicKey, error)
	// FindAddr looks for an address with nbits leading bits in common with prefix.
	FindAddr(ctx context.Context, prefix []byte, nbits int) (Addr, error)

	// LocalAddr returns this Node's address
	LocalAddr() Addr
	// PublicKey returns this Node's public key
	PublicKey() PublicKey

	// Close indicates no more messages should be sent or received from this node
	// and releases any resources allocated for this node.
	Close() error
}

Node is a single host in an INET256 network. Nodes send and receive messages to and from other nodes in the network. Nodes are usually created and managed by a Service. Nodes have an single ID or address corresponding to their public key.

This interface is compatible with the INET256 specification.

type PeerSet

type PeerSet interface {
	ListPeers() []Addr
	Contains(Addr) bool
}

PeerSet represents a set of peers

type PeerStore

type PeerStore interface {
	Add(x Addr)
	Remove(x Addr)
	SetAddrs(x Addr, addrs []p2p.Addr)
	ListAddrs(x Addr) []p2p.Addr

	PeerSet
}

PeerStore stores information about peers

type PrivateKey

type PrivateKey = p2p.PrivateKey

type PublicKey

type PublicKey = p2p.PublicKey

func ParsePublicKey

func ParsePublicKey(data []byte) (PublicKey, error)

type ReceiveFunc

type ReceiveFunc = func(Message)

ReceiveFunc is passed as a callback to Node.Receive

type Service

type Service interface {
	CreateNode(ctx context.Context, privKey p2p.PrivateKey) (Node, error)
	DeleteNode(ctx context.Context, privKey p2p.PrivateKey) error

	LookupPublicKey(ctx context.Context, addr Addr) (p2p.PublicKey, error)
	FindAddr(ctx context.Context, prefix []byte, nbits int) (Addr, error)
	MTU(ctx context.Context, addr Addr) int
}

Service is the top level INET256 object. It manages a set of nodes which can be created and deleted.

This interface is compatible with the INET256 specification.

type Swarm

type Swarm interface {
	Tell(ctx context.Context, dst Addr, m p2p.IOVec) error
	Receive(ctx context.Context, th ReceiveFunc) error

	Close() error
	LookupPublicKey(ctx context.Context, addr Addr) (PublicKey, error)
	PublicKey() PublicKey
	LocalAddr() Addr
}

Swarm is similar to a p2p.Swarm, but uses inet256.Addrs instead of p2p.Addrs

This interface is not described in the spec, and is incidental to the implementation.