yamux: github.com/hashicorp/yamux Index | Files

package yamux

import "github.com/hashicorp/yamux"

Index

Package Files

addr.go const.go mux.go session.go stream.go util.go

Variables

var (
    // ErrInvalidVersion means we received a frame with an
    // invalid version
    ErrInvalidVersion = fmt.Errorf("invalid protocol version")

    // ErrInvalidMsgType means we received a frame with an
    // invalid message type
    ErrInvalidMsgType = fmt.Errorf("invalid msg type")

    // ErrSessionShutdown is used if there is a shutdown during
    // an operation
    ErrSessionShutdown = fmt.Errorf("session shutdown")

    // ErrStreamsExhausted is returned if we have no more
    // stream ids to issue
    ErrStreamsExhausted = fmt.Errorf("streams exhausted")

    // ErrDuplicateStream is used if a duplicate stream is
    // opened inbound
    ErrDuplicateStream = fmt.Errorf("duplicate stream initiated")

    // ErrReceiveWindowExceeded indicates the window was exceeded
    ErrRecvWindowExceeded = fmt.Errorf("recv window exceeded")

    // ErrTimeout is used when we reach an IO deadline
    ErrTimeout = fmt.Errorf("i/o deadline reached")

    // ErrStreamClosed is returned when using a closed stream
    ErrStreamClosed = fmt.Errorf("stream closed")

    // ErrUnexpectedFlag is set when we get an unexpected flag
    ErrUnexpectedFlag = fmt.Errorf("unexpected flag")

    // ErrRemoteGoAway is used when we get a go away from the other side
    ErrRemoteGoAway = fmt.Errorf("remote end is not accepting connections")

    // ErrConnectionReset is sent if a stream is reset. This can happen
    // if the backlog is exceeded, or if there was a remote GoAway.
    ErrConnectionReset = fmt.Errorf("connection reset")

    // ErrConnectionWriteTimeout indicates that we hit the "safety valve"
    // timeout writing to the underlying stream connection.
    ErrConnectionWriteTimeout = fmt.Errorf("connection write timeout")

    // ErrKeepAliveTimeout is sent if a missed keepalive caused the stream close
    ErrKeepAliveTimeout = fmt.Errorf("keepalive timeout")
)

func VerifyConfig Uses

func VerifyConfig(config *Config) error

VerifyConfig is used to verify the sanity of configuration

type Config Uses

type Config struct {
    // AcceptBacklog is used to limit how many streams may be
    // waiting an accept.
    AcceptBacklog int

    // EnableKeepalive is used to do a period keep alive
    // messages using a ping.
    EnableKeepAlive bool

    // KeepAliveInterval is how often to perform the keep alive
    KeepAliveInterval time.Duration

    // ConnectionWriteTimeout is meant to be a "safety valve" timeout after
    // we which will suspect a problem with the underlying connection and
    // close it. This is only applied to writes, where's there's generally
    // an expectation that things will move along quickly.
    ConnectionWriteTimeout time.Duration

    // MaxStreamWindowSize is used to control the maximum
    // window size that we allow for a stream.
    MaxStreamWindowSize uint32

    // LogOutput is used to control the log destination
    LogOutput io.Writer
}

Config is used to tune the Yamux session

func DefaultConfig Uses

func DefaultConfig() *Config

DefaultConfig is used to return a default configuration

type Session Uses

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

Session is used to wrap a reliable ordered connection and to multiplex it into multiple streams.

func Client Uses

func Client(conn io.ReadWriteCloser, config *Config) (*Session, error)

Client is used to initialize a new client-side connection. There must be at most one client-side connection.

func Server Uses

func Server(conn io.ReadWriteCloser, config *Config) (*Session, error)

Server is used to initialize a new server-side connection. There must be at most one server-side connection. If a nil config is provided, the DefaultConfiguration will be used.

func (*Session) Accept Uses

func (s *Session) Accept() (net.Conn, error)

Accept is used to block until the next available stream is ready to be accepted.

func (*Session) AcceptStream Uses

func (s *Session) AcceptStream() (*Stream, error)

AcceptStream is used to block until the next available stream is ready to be accepted.

func (*Session) Addr Uses

func (s *Session) Addr() net.Addr

Addr is used to get the address of the listener.

func (*Session) Close Uses

func (s *Session) Close() error

Close is used to close the session and all streams. Attempts to send a GoAway before closing the connection.

func (*Session) GoAway Uses

func (s *Session) GoAway() error

GoAway can be used to prevent accepting further connections. It does not close the underlying conn.

func (*Session) IsClosed Uses

func (s *Session) IsClosed() bool

IsClosed does a safe check to see if we have shutdown

func (*Session) LocalAddr Uses

func (s *Session) LocalAddr() net.Addr

LocalAddr is used to get the local address of the underlying connection.

func (*Session) NumStreams Uses

func (s *Session) NumStreams() int

NumStreams returns the number of currently open streams

func (*Session) Open Uses

func (s *Session) Open() (net.Conn, error)

Open is used to create a new stream as a net.Conn

func (*Session) OpenStream Uses

func (s *Session) OpenStream() (*Stream, error)

OpenStream is used to create a new stream

func (*Session) Ping Uses

func (s *Session) Ping() (time.Duration, error)

Ping is used to measure the RTT response time

func (*Session) RemoteAddr Uses

func (s *Session) RemoteAddr() net.Addr

RemoteAddr is used to get the address of remote end of the underlying connection

type Stream Uses

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

Stream is used to represent a logical stream within a session.

func (*Stream) Close Uses

func (s *Stream) Close() error

Close is used to close the stream

func (*Stream) LocalAddr Uses

func (s *Stream) LocalAddr() net.Addr

LocalAddr returns the local address

func (*Stream) Read Uses

func (s *Stream) Read(b []byte) (n int, err error)

Read is used to read from the stream

func (*Stream) RemoteAddr Uses

func (s *Stream) RemoteAddr() net.Addr

LocalAddr returns the remote address

func (*Stream) Session Uses

func (s *Stream) Session() *Session

Session returns the associated stream session

func (*Stream) SetDeadline Uses

func (s *Stream) SetDeadline(t time.Time) error

SetDeadline sets the read and write deadlines

func (*Stream) SetReadDeadline Uses

func (s *Stream) SetReadDeadline(t time.Time) error

SetReadDeadline sets the deadline for future Read calls.

func (*Stream) SetWriteDeadline Uses

func (s *Stream) SetWriteDeadline(t time.Time) error

SetWriteDeadline sets the deadline for future Write calls

func (*Stream) Shrink Uses

func (s *Stream) Shrink()

Shrink is used to compact the amount of buffers utilized This is useful when using Yamux in a connection pool to reduce the idle memory utilization.

func (*Stream) StreamID Uses

func (s *Stream) StreamID() uint32

StreamID returns the ID of this stream

func (*Stream) Write Uses

func (s *Stream) Write(b []byte) (n int, err error)

Write is used to write to the stream

Package yamux imports 14 packages (graph) and is imported by 142 packages. Updated 2017-11-16. Refresh now. Tools for package owners.