drop QUIC support

lucas-clement/quic-go is unstable and often break the build.
lugu · Oct 17, 2020 · 68fc7c9 · 68fc7c9
1 parent 4a4dd25
commit 68fc7c9
Show file tree

Hide file tree

Showing 6 changed files with 0 additions and 494 deletions.
diff --git a/bus/net/endpoint.go b/bus/net/endpoint.go
@@ -2,7 +2,6 @@ package net
 
 import (
 	"bytes"
-	"context"
 	"crypto/tls"
 	"errors"
 	"fmt"
@@ -16,7 +15,6 @@ import (
 	"github.com/lugu/qiloop/type/value"
 
 	"github.com/ftrvxmtrx/fd"
-	quic "github.com/lucas-clemente/quic-go"
 )
 
 // Filter returns true if given message shall be processed by a
@@ -205,25 +203,6 @@ const (
 	ListenAddress
 )
 
-// dialQUIC connects regardless of the certificate.
-// TOOD: does not multiplex sessions
-func dialQUIC(addr string) (EndPoint, error) {
-	conf := &tls.Config{
-		InsecureSkipVerify: true,
-		NextProtos:         []string{"qi-messaging"},
-	}
-	session, err := quic.DialAddr(addr, conf, nil)
-	if err != nil {
-		return nil, err
-	}
-	ctx := context.WithValue(context.TODO(), DialAddress, addr)
-	stream, err := session.OpenStreamSync(ctx)
-	if err != nil {
-		return nil, err
-	}
-	return NewEndPoint(newQuicStream(stream)), nil
-}
-
 // DialEndPoint construct an endpoint by contacting a given address.
 func DialEndPoint(addr string) (EndPoint, error) {
 	u, err := url.Parse(addr)
@@ -235,8 +214,6 @@ func DialEndPoint(addr string) (EndPoint, error) {
 		return dialTCP(u.Host)
 	case "tcps":
 		return dialTLS(u.Host)
-	case "quic":
-		return dialQUIC(u.Host)
 	case "unix":
 		return dialUNIX(strings.TrimPrefix(addr, "unix://"))
 	case "pipe":

diff --git a/bus/net/endpoint_test.go b/bus/net/endpoint_test.go
@@ -1,7 +1,6 @@
 package net_test
 
 import (
-	"io"
 	"io/ioutil"
 	gonet "net"
 	"os"
@@ -301,76 +300,6 @@ func TestEndPoint_DialTLS(t *testing.T) {
 	}
 }
 
-func TestEndPoint_DialQUIC(t *testing.T) {
-	addr := "quic://localhost:54322"
-	listener, err := net.Listen(addr)
-	if err != nil {
-		panic(err)
-	}
-	defer listener.Close()
-	go func() {
-		conn, err := listener.Accept()
-		if err == io.EOF {
-			panic("unexpected closed listener")
-		}
-		if err != nil {
-			panic(err)
-		}
-
-		finalizer := func(e net.EndPoint) {
-			filter := func(hrd *net.Header) (bool, bool) {
-				return true, false
-			}
-			consumer := func(msg *net.Message) error {
-				err = e.Send(*msg)
-				if err != nil {
-					panic(err)
-				}
-				return nil
-			}
-			closer := func(err error) {
-			}
-			e.AddHandler(filter, consumer, closer)
-		}
-
-		net.EndPointFinalizer(conn, finalizer)
-
-	}()
-	endpoint, err := net.DialEndPoint(addr)
-	if err != nil {
-		panic(err)
-	}
-	defer endpoint.Close()
-
-	response, err := endpoint.ReceiveAny()
-	if err != nil {
-		panic(err)
-	}
-
-	msg := net.NewMessage(net.NewHeader(net.Call, 1, 1, 1, 1), make([]byte, 0))
-	endpoint.Send(msg)
-
-	msg2, ok := <-response
-	if !ok {
-		panic("receive message")
-	}
-
-	if msg.Header != msg2.Header {
-		panic("different messages")
-	}
-
-	addr = "quic://localhost"
-	_, err = net.Listen(addr)
-	if err == nil {
-		panic("shall fail")
-	}
-
-	_, err = net.DialEndPoint(addr)
-	if err == nil {
-		panic("shall fail")
-	}
-}
-
 func TestEndPoint_DialUnix(t *testing.T) {
 	addr := util.NewUnixAddr()
 	listener, err := net.Listen(addr)

diff --git a/bus/net/listen.go b/bus/net/listen.go
@@ -132,8 +132,6 @@ func Listen(addr string) (Listener, error) {
 		return listenTCP(u.Host)
 	case "tcps":
 		return listenTLS(u.Host)
-	case "quic":
-		return listenQUIC(u.Host)
 	case "unix":
 		return listenUNIX(strings.TrimPrefix(addr, "unix://"))
 	case "pipe":

diff --git a/bus/net/stream.go b/bus/net/stream.go
@@ -2,17 +2,10 @@ package net
 
 import (
 	"context"
-	"crypto/tls"
 	"fmt"
 	"io"
-	"log"
-	"net"
 	gonet "net"
 	"os"
-	"sync"
-
-	quic "github.com/lucas-clemente/quic-go"
-	"github.com/lugu/qiloop/bus/net/cert"
 )
 
 // Stream represents a network connection. Stream abstracts
@@ -84,145 +77,3 @@ func PipeStream(r, w *os.File) Stream {
 	}
 }
 
-type quicStream struct {
-	quic.Stream
-	// quic.Stream does not permit to call Close while Writing.
-	// Refer to go-quic documentation.
-	sync.RWMutex
-}
-
-func newQuicStream(s quic.Stream) Stream {
-	return &quicStream{
-		s,
-		sync.RWMutex{},
-	}
-}
-
-func (s *quicStream) Close() error {
-	s.Lock()
-	defer s.Unlock()
-	return s.Stream.Close()
-}
-
-func (s *quicStream) Read(p []byte) (int, error) {
-	return s.Stream.Read(p)
-}
-
-func (s *quicStream) Write(p []byte) (int, error) {
-	s.RLock()
-	defer s.RUnlock()
-	return s.Stream.Write(p)
-}
-
-func (s *quicStream) String() string {
-	return fmt.Sprintf("StreamID %d", s.StreamID())
-}
-
-type quicListener struct {
-	l       quic.Listener
-	streams chan Stream
-	closer  chan struct{}
-	errors  chan error
-}
-
-func newQuicListener(ctx context.Context, l quic.Listener) (Listener, error) {
-	q := &quicListener{
-		l:       l,
-		streams: make(chan Stream),
-		closer:  make(chan struct{}),
-		errors:  make(chan error),
-	}
-	go q.bg(ctx)
-	return q, nil
-}
-
-func (q quicListener) Accept() (Stream, error) {
-	select {
-	case <-q.closer:
-		return nil, io.EOF
-	case err := <-q.errors:
-		return nil, err
-	case stream := <-q.streams:
-		return stream, nil
-	}
-}
-
-func (q quicListener) Close() error {
-	err := q.l.Close()
-	close(q.closer)
-	return err
-}
-
-func (q quicListener) bg(ctx context.Context) {
-	for {
-		sess, err := q.l.Accept(ctx)
-		if err != nil {
-			q.errors <- err
-			return
-		}
-		q.handleSession(ctx, sess)
-	}
-}
-
-func (q quicListener) handleSession(ctx context.Context, sess quic.Session) {
-	cancel := make(chan struct{})
-	go func() {
-		select {
-		case <-q.closer: // close the sesion on demand
-		case <-cancel: // close the sesion on error
-		}
-		sess.CloseWithError(0, "")
-	}()
-	// send stream of streams into streams
-	go func() {
-		for {
-			stream, err := sess.AcceptStream(ctx)
-			if err != nil {
-				if err.Error() == "NO_ERROR" {
-					continue
-				}
-				netErr := err.(net.Error)
-				if netErr.Timeout() == true {
-					continue
-				}
-				log.Printf("Session error: %s <-> %s : %#v",
-					sess.LocalAddr().String(),
-					sess.RemoteAddr().String(),
-					err)
-				close(cancel)
-				return
-			}
-			select {
-			case <-q.closer:
-				return
-			case q.streams <- newQuicStream(stream):
-			}
-		}
-	}()
-}
-
-func listenQUIC(addr string) (Listener, error) {
-	var err1, err2 error
-	cer, err1 := cert.Certificate()
-	if err1 != nil {
-		log.Printf("Failed to read x509 certificate: %s", err1)
-		cer, err2 = cert.GenerateCertificate()
-		if err2 != nil {
-			log.Printf("Failed to create x509 certificate: %s", err2)
-			return nil, fmt.Errorf("no certificate available (%s, %s)",
-				err1, err2)
-		}
-	}
-
-	conf := &tls.Config{
-		Certificates: []tls.Certificate{cer},
-		NextProtos:   []string{"qi-messaging"},
-	}
-
-	listener, err := quic.ListenAddr(addr, conf, nil)
-	if err != nil {
-		return nil, err
-	}
-	ctx := context.WithValue(context.Background(), ListenAddress, addr)
-	return newQuicListener(ctx, listener)
-}
diff --git a/go.mod b/go.mod
@@ -5,17 +5,11 @@ require (
 	github.com/dave/jennifer v1.4.0
 	github.com/denisbrodbeck/machineid v1.0.1
 	github.com/ftrvxmtrx/fd v0.0.0-20150925145434-c6d800382fff
-	github.com/golang/protobuf v1.4.0 // indirect
 	github.com/integrii/flaggy v1.3.0
-	github.com/lucas-clemente/quic-go v0.15.4
-	github.com/marten-seemann/qtls v0.9.1 // indirect
 	github.com/mattes/go-asciibot v0.0.0-20190603170252-3fa6d766c482
 	github.com/prataprc/goparsec v0.0.0-20180806094145-2600a2a4a410
 	golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5
-	golang.org/x/net v0.0.0-20190628185345-da137c7871d7 // indirect
 	golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f // indirect
-	golang.org/x/text v0.3.2 // indirect
-	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 )
 
 go 1.13