https://github.com/hashicorp/yamux

Golang connection multiplexing library
https://github.com/hashicorp/yamux

Last synced: 11 days ago
JSON representation

Golang connection multiplexing library

• Host: GitHub
• URL: https://github.com/hashicorp/yamux
• Owner: hashicorp
• License: mpl-2.0
• Created: 2014-05-22T19:08:46.000Z (over 10 years ago)
• Default Branch: master
• Last Pushed: 2024-10-07T16:04:25.000Z (about 1 month ago)
• Last Synced: 2024-10-19T16:54:46.725Z (20 days ago)
• Language: Go
• Size: 188 KB
• Stars: 2,219
• Watchers: 327
• Forks: 234
• Open Issues: 25
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

• go-awesome - yamux - multiplexers (Open source library / The Internet)
• my-awesome - hashicorp/yamux - 10 star:2.2k fork:0.2k Golang connection multiplexing library (Go)

README

        
# Yamux

Yamux (Yet another Multiplexer) is a multiplexing library for Golang.

It relies on an underlying connection to provide reliability

and ordering, such as TCP or Unix domain sockets, and provides

stream-oriented multiplexing. It is inspired by SPDY but is not

interoperable with it.

Yamux features include:

* Bi-directional streams

  * Streams can be opened by either client or server

  * Useful for NAT traversal

  * Server-side push support

* Flow control

  * Avoid starvation

  * Back-pressure to prevent overwhelming a receiver

* Keep Alives

  * Enables persistent connections over a load balancer

* Efficient

  * Enables thousands of logical streams with low overhead

## Documentation

For complete documentation, see the associated [Godoc](http://godoc.org/github.com/hashicorp/yamux).

## Specification

The full specification for Yamux is provided in the `spec.md` file.

It can be used as a guide to implementors of interoperable libraries.

## Usage

Using Yamux is remarkably simple:

```go

func client() {

    // Get a TCP connection

    conn, err := net.Dial(...)

    if err != nil {

        panic(err)

    }

    // Setup client side of yamux

    session, err := yamux.Client(conn, nil)

    if err != nil {

        panic(err)

    }

    // Open a new stream

    stream, err := session.Open()

    if err != nil {

        panic(err)

    }

    // Stream implements net.Conn

    stream.Write([]byte("ping"))

}

func server() {

    // Accept a TCP connection

    conn, err := listener.Accept()

    if err != nil {

        panic(err)

    }

    // Setup server side of yamux

    session, err := yamux.Server(conn, nil)

    if err != nil {

        panic(err)

    }

    // Accept a stream

    stream, err := session.Accept()

    if err != nil {

        panic(err)

    }

    // Listen for a message

    buf := make([]byte, 4)

    stream.Read(buf)

}

```