go-micro: github.com/micro/go-micro/tunnel Index | Files | Directories

package tunnel

import "github.com/micro/go-micro/tunnel"

Package tunnel provides gre network tunnelling

Index

Package Files

crypto.go default.go link.go listener.go options.go session.go tunnel.go

Variables

var (
    // DiscoverTime sets the time at which we fire discover messages
    DiscoverTime = 30 * 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")
    // ErrLinkDisconnected is returned when a link we attempt to send to is disconnected
    ErrLinkDisconnected = errors.New("link not connected")
    // ErrLinkLoppback is returned when attempting to send an outbound message over loopback link
    ErrLinkLoopback = errors.New("link is loopback")
    // ErrLinkRemote is returned when attempting to send a loopback message over remote link
    ErrLinkRemote = errors.New("link is remote")
    // ErrReadTimeout is a timeout on session.Recv
    ErrReadTimeout = errors.New("read timeout")
    // ErrDecryptingData is for when theres a nonce error
    ErrDecryptingData = errors.New("error decrypting data")
)
var (
    ErrLinkConnectTimeout = errors.New("link connect timeout")
)

func Decrypt Uses

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

Decrypt decrypts the payload and returns the decrypted data

func Encrypt Uses

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

Encrypt encrypts data and returns the encrypted data

type DialOption Uses

type DialOption func(*DialOptions)
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 Uses

func DialMode(m Mode) DialOption

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

func DialTimeout Uses

func DialTimeout(t time.Duration) DialOption

DialTimeout sets the dial timeout of the connection

func DialWait Uses

func DialWait(b bool) DialOption

DialWait specifies whether to wait for the connection to be accepted before returning the session

type DialOptions Uses

type DialOptions struct {
    // Link specifies the link to use
    Link string
    // specify mode of the session
    Mode Mode
    // Wait for connection to be accepted
    Wait bool
    // the dial timeout
    Timeout time.Duration
}
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 Uses

type ListenOption func(*ListenOptions)

func ListenMode Uses

func ListenMode(m Mode) ListenOption

Listen options

func ListenTimeout Uses

func ListenTimeout(t time.Duration) ListenOption

Timeout for reads and writes on the listener session

type ListenOptions Uses

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

type Listener Uses

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

The listener provides similar constructs to the transport.Listener

type Mode Uses

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 Uses

type Option func(*Options)

func Address Uses

func Address(a string) Option

The tunnel address

func Id Uses

func Id(id string) Option

The tunnel id

func Nodes Uses

func Nodes(n ...string) Option

Nodes specify remote network nodes

func Token Uses

func Token(t string) Option

Token sets the shared token for auth

func Transport Uses

func Transport(t transport.Transport) Option

Transport listens for incoming connections

type Options Uses

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 Uses

func DefaultOptions() Options

DefaultOptions returns router default options

type Session Uses

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 Uses

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 Uses

func NewTunnel(opts ...Option) Tunnel

NewTunnel creates a new tunnel

Directories

PathSynopsis
brokerPackage broker is a tunnel broker
transportPackage transport provides a tunnel transport

Package tunnel imports 16 packages (graph) and is imported by 22 packages. Updated 2020-02-22. Refresh now. Tools for package owners.