spdystream get stuck for second or third stream

[liudanking]

I use go-stream-muxer write some simple tunnel experimental code. yamux works well, and spdystream always gets stuck for the second or third stream. The experimental code is as below:

client:

package main

import (
    "io"
    "log"
    "net"

    ymux "github.com/jbenet/go-stream-muxer/spdystream"

    smux "github.com/jbenet/go-stream-muxer"
    // ymux "github.com/jbenet/go-stream-muxer/yamux"
)

func dial() {
    nconn, _ := net.Dial("tcp", "localhost:8080")
    // sconn, _ := ymux.DefaultTransport.NewConn(nconn, false) // false == client
    sconn, err := ymux.Transport.NewConn(nconn, false)
    if err != nil {
        log.Fatalf("new stream connection error:%v", err)
    }

    go sconn.Serve(func(smux.Stream) {}) // no-op

    l, err := net.Listen("tcp", ":8079")
    if err != nil {
        panic(err)
    }

    for {
        c, err := l.Accept()
        if err != nil {
            log.Printf("accept error:%v", err)
            continue
        }
        log.Printf("accept %s", c.RemoteAddr().String())
        // Open a new stream
        stream, err := sconn.OpenStream()
        if err != nil {
            panic(err)
        }
        go handleConn(stream, c)
    }

}

func handleConn(stream smux.Stream, conn net.Conn) {
    log.Printf("data transfer")
    go io.Copy(stream, conn)
    go io.Copy(conn, stream)
    // for test only, we do not handle stream closing
}

func main() {
    dial()
}

server:

package main

import (
    "fmt"
    "io"
    "log"
    "net"

    smux "github.com/jbenet/go-stream-muxer"
    ymux "github.com/jbenet/go-stream-muxer/spdystream"
    // ymux "github.com/jbenet/go-stream-muxer/yamux"
)

func listen() {
    // tr := ymux.DefaultTransport
    tr := ymux.Transport
    l, _ := net.Listen("tcp", "localhost:8080")

    for {
        c, _ := l.Accept()

        fmt.Println("accepted connection")
        sc, _ := tr.NewConn(c, true)

        go serveTunnel(sc)
    }
}

func serveTunnel(sc smux.Conn) {
    // for {
    //  stream, err := sc.AcceptStream()
    //  if err != nil {
    //      log.Printf("accept stream error:%v", err)
    //      continue
    //  }
    //  log.Printf("accept stream")
    //  go serveStream(stream)
    // }
    sc.Serve(serveStream)
}

func serveStream(stream smux.Stream) {
    conn, err := net.Dial("tcp", "127.0.0.1:80")
    if err != nil {
        log.Printf("connect to remote error:%v", err)
        return
    }
    log.Println("data transfer")

    go io.Copy(stream, conn)
    go io.Copy(conn, stream)
}

func echoStream(s smux.Stream) {
    defer s.Close()

    fmt.Println("accepted stream")
    io.Copy(s, s) // echo everything
    fmt.Println("closing stream")
}

func main() {
    listen()
}

I am not sure whether this is a spdystream bug or there is something wring with my code.

[victorb]

Seems like spdystream is also failing in the tests provided in this repo:

➜  go-stream-muxer git:(master) ✗ make test
go get github.com/whyrusleeping/gx
go get github.com/whyrusleeping/gx-go
gx --verbose install --global
installing package: go-stream-muxer-1.1.0
successfully found all deps for go-stream-muxer
installation of dep go-stream-muxer complete!
gx-go rewrite
go test ./...
?   	github.com/jbenet/go-stream-muxer	[no test files]
--- FAIL: TestSpdystream (12.76s)
	ttest.go:352: timed out receiving streams
FAIL
FAIL	github.com/jbenet/go-stream-muxer/suite	22.887s
?   	github.com/jbenet/go-stream-muxer/test	[no test files]
make: *** [test] Error 1

[raulk]

I consider the spdystream multiplexer to be deprecated. It hasn't been actively maintained since 2017, and we now have first-class support for QUIC (spdy's successor).