Package tunnel provides gre network tunnelling



    This section is empty.


    View Source
    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
    View Source
    var (
    	// DefaultAddress is default tunnel bind address
    	DefaultAddress = ":0"
    	// The shared default token
    	DefaultToken = "go.micro.tunnel"
    View Source
    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")
    View Source
    var (
    	ErrLinkConnectTimeout = errors.New("link connect timeout")


    func Decrypt

    func Decrypt(gcm cipher.AEAD, data []byte) ([]byte, error)

    func Encrypt

    func Encrypt(gcm cipher.AEAD, data []byte) ([]byte, error)

      Encrypt encrypts data and returns the encrypted data


      type DialOption

      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

        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

            func DialWait

            func DialWait(b bool) DialOption

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

              type DialOptions

              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

                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
                        	// send to all links

                        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

                                        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


                                            Path Synopsis
                                            Package broker is a tunnel broker
                                            Package broker is a tunnel broker
                                            Package transport provides a tunnel transport
                                            Package transport provides a tunnel transport