terraform-provider-google/vendor/github.com/hashicorp/yamux
Paddy 961c878e0d Switch to using Go modules. (#2679)
Switch to using Go modules.

This migrates our vendor.json to use Go 1.11's modules system, and
replaces the vendor folder with the output of go mod vendor.

The vendored code should remain basically the same; I believe some
tree shaking of packages and support scripts/licenses/READMEs/etc.
happened.

This also fixes Travis and our Makefile to no longer use govendor.
2018-12-20 17:22:22 -08:00
..
.gitignore Switch to using Go modules. (#2679) 2018-12-20 17:22:22 -08:00
addr.go Initial transfer of provider code 2017-06-06 11:58:56 -04:00
const.go Initial transfer of provider code 2017-06-06 11:58:56 -04:00
LICENSE Initial transfer of provider code 2017-06-06 11:58:56 -04:00
mux.go Initial transfer of provider code 2017-06-06 11:58:56 -04:00
README.md Initial transfer of provider code 2017-06-06 11:58:56 -04:00
session.go Switch to using Go modules. (#2679) 2018-12-20 17:22:22 -08:00
spec.md Initial transfer of provider code 2017-06-06 11:58:56 -04:00
stream.go Switch to using Go modules. (#2679) 2018-12-20 17:22:22 -08:00
util.go Switch to using Go modules. (#2679) 2018-12-20 17:22:22 -08:00

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.

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:


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)
}