tunnel

Documentation

Overview

Package tunnel provides gre network tunnelling

Index

• Variables
• func Decrypt(data []byte, key string) ([]byte, error)
• func Encrypt(data []byte, key string) ([]byte, error)
• type DialOption
  • func DialLink(id string) DialOption
  • func DialMode(m Mode) DialOption
  • func DialTimeout(t time.Duration) DialOption
• type DialOptions
• type Link
• type ListenOption
  • func ListenMode(m Mode) ListenOption
  • func ListenTimeout(t time.Duration) ListenOption
• type ListenOptions
• type Listener
• type Mode
• type Option
  • func Address(a string) Option
  • func Id(id string) Option
  • func Nodes(n ...string) Option
  • func Token(t string) Option
  • func Transport(t transport.Transport) Option
• type Options
  • func DefaultOptions() Options
• type Session
• type Tunnel
  • func NewTunnel(opts ...Option) Tunnel

Variables

var (
	// DiscoverTime sets the time at which we fire discover messages
	DiscoverTime = 60 * time.Second
	// KeepAliveTime defines time interval we send keepalive messages to outbound links
	KeepAliveTime = 30 * time.Second
	// ReconnectTime defines time interval we periodically attempt to reconnect dead links
	ReconnectTime = 5 * time.Second
)

var (
	// DefaultAddress is default tunnel bind address
	DefaultAddress = ":0"
	// The shared default token
	DefaultToken = "go.micro.tunnel"
)

var (
	// DefaultDialTimeout is the dial timeout if none is specified
	DefaultDialTimeout = time.Second * 5
	// ErrDialTimeout is returned by a call to Dial where the timeout occurs
	ErrDialTimeout = errors.New("dial timeout")
	// ErrDiscoverChan is returned when we failed to receive the "announce" back from a discovery
	ErrDiscoverChan = errors.New("failed to discover channel")
	// ErrLinkNotFound is returned when a link is specified at dial time and does not exist
	ErrLinkNotFound = errors.New("link not found")
	// ErrReadTimeout is a timeout on session.Recv
	ErrReadTimeout = errors.New("read timeout")
)

var (
	ErrLinkConnectTimeout = errors.New("link connect timeout")
)

Functions

func Decrypt

func Decrypt(data []byte, key string) ([]byte, error)

Decrypt decrypts the payload and returns the decrypted data

func Encrypt

func Encrypt(data []byte, key string) ([]byte, error)

Encrypt encrypts data and returns the encrypted data

Types

type DialOption

type DialOption func(*DialOptions)

func DialLink

func DialLink(id string) DialOption

DialLink specifies the link to pin this connection to. This is not applicable if the multicast option is set.

func DialMode

func DialMode(m Mode) DialOption

Dial multicast sets the multicast option to send only to those mapped

func DialTimeout

func DialTimeout(t time.Duration) DialOption

DialTimeout sets the dial timeout of the connection

type DialOptions

type DialOptions struct {
	// Link specifies the link to use
	Link string
	// specify mode of the session
	Mode Mode
	// the dial timeout
	Timeout time.Duration
}

type Link

type Link interface {
	// Id returns the link unique Id
	Id() string
	// Delay is the current load on the link (lower is better)
	Delay() int64
	// Length returns the roundtrip time as nanoseconds (lower is better)
	Length() int64
	// Current transfer rate as bits per second (lower is better)
	Rate() float64
	// Is this a loopback link
	Loopback() bool
	// State of the link: connected/closed/error
	State() string
	// honours transport socket
	transport.Socket
}

Link represents internal links to the tunnel

type ListenOption

type ListenOption func(*ListenOptions)

func ListenMode

func ListenMode(m Mode) ListenOption

Listen options

func ListenTimeout

func ListenTimeout(t time.Duration) ListenOption

Timeout for reads and writes on the listener session

type ListenOptions

type ListenOptions struct {
	// specify mode of the session
	Mode Mode
	// The read timeout
	Timeout time.Duration
}

type Listener

type Listener interface {
	Accept() (Session, error)
	Channel() string
	Close() error
}

The listener provides similar constructs to the transport.Listener

type Mode

type Mode uint8

Mode of the session

const (
	// send over one link
	Unicast Mode = iota
	// send to all channel listeners
	Multicast
	// send to all links
	Broadcast
)

type Option

type Option func(*Options)

func Address

func Address(a string) Option

The tunnel address

func Id

func Id(id string) Option

The tunnel id

func Nodes

func Nodes(n ...string) Option

Nodes specify remote network nodes

func Token

func Token(t string) Option

Token sets the shared token for auth

func Transport

func Transport(t transport.Transport) Option

Transport listens for incoming connections

type Options

type Options struct {
	// Id is tunnel id
	Id string
	// Address is tunnel address
	Address string
	// Nodes are remote nodes
	Nodes []string
	// The shared auth token
	Token string
	// Transport listens to incoming connections
	Transport transport.Transport
}

Options provides network configuration options

func DefaultOptions

func DefaultOptions() Options

DefaultOptions returns router default options

type Session

type Session interface {
	// The unique session id
	Id() string
	// The channel name
	Channel() string
	// The link the session is on
	Link() string
	// a transport socket
	transport.Socket
}

Session is a unique session created when dialling or accepting connections on the tunnel

type Tunnel

type Tunnel interface {
	// Init initializes tunnel with options
	Init(opts ...Option) error
	// Address returns the address the tunnel is listening on
	Address() string
	// Connect connects the tunnel
	Connect() error
	// Close closes the tunnel
	Close() error
	// Links returns all the links the tunnel is connected to
	Links() []Link
	// Dial allows a client to connect to a channel
	Dial(channel string, opts ...DialOption) (Session, error)
	// Listen allows to accept connections on a channel
	Listen(channel string, opts ...ListenOption) (Listener, error)
	// String returns the name of the tunnel implementation
	String() string
}

Tunnel creates a gre tunnel on top of the go-micro/transport. It establishes multiple streams using the Micro-Tunnel-Channel header and Micro-Tunnel-Session header. The tunnel id is a hash of the address being requested.

func NewTunnel

func NewTunnel(opts ...Option) Tunnel

NewTunnel creates a new tunnel