我们可以通过QUIC/HTTP3将请求从服务器发送到客户端，并获取响应。

huangapple
go评论65阅读模式
英文:

Can we send request form server to client and get response through quic/http3?

问题

我正在使用quic-go来实现我的想法，我需要服务器主动向客户端发送请求并获取响应，就像客户端通常发送请求到Web服务器一样。但是使用quic-go，在建立连接之后，服务器可以初始化流以向客户端发送请求并获取响应吗？我尝试过，但还没有成功。下面的代码是来自示例目录中的echo.go，两个注释行之间的部分是我添加的。

package main

import (
	"context"
	"crypto/rand"
	"crypto/rsa"
	"crypto/tls"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"io"
	"log"
	"math/big"

	"github.com/lucas-clemente/quic-go"
)

const addr = "localhost:4242"

const message = "foobar"

// 我们启动一个服务器，在客户端打开的第一个流上回显数据，
// 然后与客户端建立连接，发送消息，并等待接收。
func main() {
	go func() { log.Fatal(echoServer()) }()

	err := clientMain()
	if err != nil {
		panic(err)
	}
}

// 启动一个服务器，在客户端打开的第一个流上回显所有数据
func echoServer() error {
	listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
	if err != nil {
		return err
	}
	conn, err := listener.Accept(context.Background())
	if err != nil {
		return err
	}
	stream, err := conn.AcceptStream(context.Background())
	if err != nil {
		panic(err)
	}
	// 通过loggingWriter回显
	_, err = io.Copy(loggingWriter{stream}, stream)
	if err != nil {
		panic(err)
	}

	//------------------------------
	stream1, err := conn.OpenStream()
	if err != nil {
		panic(err)
	}

	message := "aaaaa"

	fmt.Printf("2-Server: Sending '%s'\n", message)

	_, err = stream1.Write([]byte(message))
	//------------------------------
	return err
}

func clientMain() error {
	tlsConf := &tls.Config{
		InsecureSkipVerify: true,
		NextProtos:         []string{"quic-echo-example"},
	}
	conn, err := quic.DialAddr(addr, tlsConf, nil)
	if err != nil {
		return err
	}

	stream, err := conn.OpenStreamSync(context.Background())
	if err != nil {
		return err
	}

	fmt.Printf("Client: Sending '%s'\n", message)
	_, err = stream.Write([]byte(message))
	if err != nil {
		return err
	}

	buf := make([]byte, len(message))
	_, err = io.ReadFull(stream, buf)
	if err != nil {
		return err
	}
	fmt.Printf("Client: Got '%s'\n", buf)
	err = stream.Close()
	if err != nil {
		return err
	}

	//-------------------------------
	for {
		stream1, err := conn.AcceptStream(context.Background())
		if err != nil {
			panic(err)
		}

		buf1 := make([]byte, len(message))
		_, err = io.ReadFull(stream1, buf1)
		if err != nil {
			panic(err)
		}
		fmt.Printf("2-Client: Got '%s'\n", buf1)

		err = stream1.Close()
		if err != nil {
			panic(err)
		}
	}
	//-------------------------------

	return nil
}

// 一个同时记录消息的io.Writer包装器。
type loggingWriter struct{ io.Writer }

func (w loggingWriter) Write(b []byte) (int, error) {
	fmt.Printf("Server: Got '%s'\n", string(b))
	return w.Writer.Write(b)
}

// 为服务器设置一个简单的TLS配置
func generateTLSConfig() *tls.Config {
	key, err := rsa.GenerateKey(rand.Reader, 1024)
	if err != nil {
		panic(err)
	}
	template := x509.Certificate{SerialNumber: big.NewInt(1)}
	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
	if err != nil {
		panic(err)
	}
	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})

	tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
	if err != nil {
		panic(err)
	}
	return &tls.Config{
		Certificates: []tls.Certificate{tlsCert},
		NextProtos:   []string{"quic-echo-example"},
	}
}
英文:

I'm using quic-go to implement my thought, I need the server to forwardly send request to client to get response, just like we do that client sends request to web server commonly. But with quic-go, after connection is setup, can server initialize streams to send request to client and get responses? I did a trying but haven't made it work. The code below is from the echo.go of example dir, the two parts between comment lines are added by me.

package main

import (
	"context"
	"crypto/rand"
	"crypto/rsa"
	"crypto/tls"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"io"
	"log"
	"math/big"

	"github.com/lucas-clemente/quic-go"
)

const addr = "localhost:4242"

const message = "foobar"

// We start a server echoing data on the first stream the client opens,
// then connect with a client, send the message, and wait for its receipt.
func main() {
	go func() { log.Fatal(echoServer()) }()

	err := clientMain()
	if err != nil {
		panic(err)
	}
}

// Start a server that echos all data on the first stream opened by the client
func echoServer() error {
	listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
	if err != nil {
		return err
	}
	conn, err := listener.Accept(context.Background())
	if err != nil {
		return err
	}
	stream, err := conn.AcceptStream(context.Background())
	if err != nil {
		panic(err)
	}
	// Echo through the loggingWriter
	_, err = io.Copy(loggingWriter{stream}, stream)
	if err != nil {
		panic(err)
	}

	//------------------------------
	stream1, err := conn.OpenStream()
	if err != nil {
		panic(err)
	}

	message := "aaaaa"

	fmt.Printf("2-Server: Sending '%s'\n", message)

	_, err = stream1.Write([]byte(message))
	//------------------------------
	return err
}

func clientMain() error {
	tlsConf := &tls.Config{
		InsecureSkipVerify: true,
		NextProtos:         []string{"quic-echo-example"},
	}
	conn, err := quic.DialAddr(addr, tlsConf, nil)
	if err != nil {
		return err
	}

	stream, err := conn.OpenStreamSync(context.Background())
	if err != nil {
		return err
	}

	fmt.Printf("Client: Sending '%s'\n", message)
	_, err = stream.Write([]byte(message))
	if err != nil {
		return err
	}

	buf := make([]byte, len(message))
	_, err = io.ReadFull(stream, buf)
	if err != nil {
		return err
	}
	fmt.Printf("Client: Got '%s'\n", buf)
	err = stream.Close()
	if err != nil {
		return err
	}

	//-------------------------------
	for {
		stream1, err := conn.AcceptStream(context.Background())
		if err != nil {
			panic(err)
		}

		buf1 := make([]byte, len(message))
		_, err = io.ReadFull(stream1, buf1)
		if err != nil {
			panic(err)
		}
		fmt.Printf("2-Client: Got '%s'\n", buf1)

		err = stream1.Close()
		if err != nil {
			panic(err)
		}
	}
	//-------------------------------

	return nil
}

// A wrapper for io.Writer that also logs the message.
type loggingWriter struct{ io.Writer }

func (w loggingWriter) Write(b []byte) (int, error) {
	fmt.Printf("Server: Got '%s'\n", string(b))
	return w.Writer.Write(b)
}

// Setup a bare-bones TLS config for the server
func generateTLSConfig() *tls.Config {
	key, err := rsa.GenerateKey(rand.Reader, 1024)
	if err != nil {
		panic(err)
	}
	template := x509.Certificate{SerialNumber: big.NewInt(1)}
	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
	if err != nil {
		panic(err)
	}
	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})

	tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
	if err != nil {
		panic(err)
	}
	return &tls.Config{
		Certificates: []tls.Certificate{tlsCert},
		NextProtos:   []string{"quic-echo-example"},
	}
}

答案1

得分: 2

你离答案很近。

注意服务器在写入并返回数据之后，会在客户端有机会读取和处理数据之前调用log.Fatal。

请注意message变量，一个长度为6，另一个长度只有5。

请正确关闭流，服务器在交接之前没有结束它。

package main

import (
	"context"
	"crypto/rand"
	"crypto/rsa"
	"crypto/tls"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"io"
	"log"
	"math/big"

	"github.com/lucas-clemente/quic-go"
)

const addr = "localhost:4242"

const message = "foobar"

// 我们启动一个服务器，在客户端打开的第一个流上回显数据，
// 然后与客户端建立连接，发送消息，并等待接收。
func main() {
	go func() {
		err := echoServer()
		if err != nil {
			log.Println(err)
		}
	}()

	err := clientMain()
	if err != nil {
		panic(err)
	}
}

// 启动一个服务器，在客户端打开的第一个流上回显所有数据
func echoServer() error {
	listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
	if err != nil {
		return err
	}
	conn, err := listener.Accept(context.Background())
	if err != nil {
		return err
	}
	stream, err := conn.AcceptStream(context.Background())
	if err != nil {
		panic(err)
	}
	// 通过loggingWriter回显
	_, err = io.Copy(loggingWriter{stream}, stream)
	if err != nil {
		log.Println(err)
		return err
	}

	//------------------------------
	fmt.Printf("Server: 打开流\n")
	stream1, err := conn.OpenStream()
	if err != nil {
		return err
	}

	fmt.Printf("2-Server: 发送 '%s'\n", message)

	var n int
	n, err = stream1.Write([]byte(message))
	fmt.Printf("Server: 写入 %v %v\n", n, err)
	stream1.Close()
	//------------------------------
	return err
}

func clientMain() error {
	tlsConf := &tls.Config{
		InsecureSkipVerify: true,
		NextProtos:         []string{"quic-echo-example"},
	}
	conn, err := quic.DialAddr(addr, tlsConf, nil)
	if err != nil {
		return err
	}

	stream, err := conn.OpenStreamSync(context.Background())
	if err != nil {
		return err
	}

	fmt.Printf("Client: 发送 '%s'\n", message)
	_, err = stream.Write([]byte(message))
	if err != nil {
		return err
	}

	buf := make([]byte, len(message))
	_, err = io.ReadFull(stream, buf)
	if err != nil {
		return err
	}
	fmt.Printf("Client: 收到 '%s'\n", buf)
	err = stream.Close()
	if err != nil {
		return err
	}

	//-------------------------------
	for {
		fmt.Printf("Client: 接受流\n")
		stream1, err := conn.AcceptStream(context.Background())
		if err != nil {
			return err
		}

		fmt.Printf("Client: 收到流 %v\n", err)
		buf1 := make([]byte, len(message))
		_, err = io.ReadFull(stream1, buf1)
		if err != nil {
			return err
		}
		fmt.Printf("2-Client: 收到 '%s'\n", buf1)

		err = stream1.Close()
		if err != nil {
			return err
		}
		break
	}
	//-------------------------------

	return nil
}

// 一个同时记录消息的io.Writer包装器。
type loggingWriter struct{ io.Writer }

func (w loggingWriter) Write(b []byte) (int, error) {
	fmt.Printf("Server: 收到 '%s'\n", string(b))
	return w.Writer.Write(b)
}

// 为服务器设置一个基本的TLS配置
func generateTLSConfig() *tls.Config {
	key, err := rsa.GenerateKey(rand.Reader, 1024)
	if err != nil {
		panic(err)
	}
	template := x509.Certificate{SerialNumber: big.NewInt(1)}
	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
	if err != nil {
		panic(err)
	}
	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})

	tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
	if err != nil {
		panic(err)
	}
	return &tls.Config{
		Certificates: []tls.Certificate{tlsCert},
		NextProtos:   []string{"quic-echo-example"},
	}
}
英文:

You are close.

Notice how the server writes, then returns, it reaches out to log.Fatal before the client had a chance to read and handle the data.

Take care to the message variable, one is 6 length long, the other one is only 5 length long.

Properly close your stream, the server was not ending it ending before handing over;

package main

import (
	"context"
	"crypto/rand"
	"crypto/rsa"
	"crypto/tls"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"io"
	"log"
	"math/big"

	"github.com/lucas-clemente/quic-go"
)

const addr = "localhost:4242"

const message = "foobar"

// We start a server echoing data on the first stream the client opens,
// then connect with a client, send the message, and wait for its receipt.
func main() {
	go func() {
		err := echoServer()
		if err != nil {
			log.Println(err)
		}
	}()

	err := clientMain()
	if err != nil {
		panic(err)
	}
}

// Start a server that echos all data on the first stream opened by the client
func echoServer() error {
	listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
	if err != nil {
		return err
	}
	conn, err := listener.Accept(context.Background())
	if err != nil {
		return err
	}
	stream, err := conn.AcceptStream(context.Background())
	if err != nil {
		panic(err)
	}
	// Echo through the loggingWriter
	_, err = io.Copy(loggingWriter{stream}, stream)
	if err != nil {
		log.Println(err)
		return err
	}

	//------------------------------
	fmt.Printf("Server: open stream\n")
	stream1, err := conn.OpenStream()
	if err != nil {
		return err
	}

	fmt.Printf("2-Server: Sending '%s'\n", message)

	var n int
	n, err = stream1.Write([]byte(message))
	fmt.Printf("Server: write %v %v\n", n, err)
	stream1.Close()
	//------------------------------
	return err
}

func clientMain() error {
	tlsConf := &tls.Config{
		InsecureSkipVerify: true,
		NextProtos:         []string{"quic-echo-example"},
	}
	conn, err := quic.DialAddr(addr, tlsConf, nil)
	if err != nil {
		return err
	}

	stream, err := conn.OpenStreamSync(context.Background())
	if err != nil {
		return err
	}

	fmt.Printf("Client: Sending '%s'\n", message)
	_, err = stream.Write([]byte(message))
	if err != nil {
		return err
	}

	buf := make([]byte, len(message))
	_, err = io.ReadFull(stream, buf)
	if err != nil {
		return err
	}
	fmt.Printf("Client: Got '%s'\n", buf)
	err = stream.Close()
	if err != nil {
		return err
	}

	//-------------------------------
	for {
		fmt.Printf("Client: accept stream\n")
		stream1, err := conn.AcceptStream(context.Background())
		if err != nil {
			return err
		}

		fmt.Printf("Client: got stream %v\n", err)
		buf1 := make([]byte, len(message))
		_, err = io.ReadFull(stream1, buf1)
		if err != nil {
			return err
		}
		fmt.Printf("2-Client: Got '%s'\n", buf1)

		err = stream1.Close()
		if err != nil {
			return err
		}
		break
	}
	//-------------------------------

	return nil
}

// A wrapper for io.Writer that also logs the message.
type loggingWriter struct{ io.Writer }

func (w loggingWriter) Write(b []byte) (int, error) {
	fmt.Printf("Server: Got '%s'\n", string(b))
	return w.Writer.Write(b)
}

// Setup a bare-bones TLS config for the server
func generateTLSConfig() *tls.Config {
	key, err := rsa.GenerateKey(rand.Reader, 1024)
	if err != nil {
		panic(err)
	}
	template := x509.Certificate{SerialNumber: big.NewInt(1)}
	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
	if err != nil {
		panic(err)
	}
	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})

	tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
	if err != nil {
		panic(err)
	}
	return &tls.Config{
		Certificates: []tls.Certificate{tlsCert},
		NextProtos:   []string{"quic-echo-example"},
	}
}

huangapple
  • 本文由 发表于 2022年5月26日 20:24:01
  • 转载请务必保留本文链接：https://go.coder-hub.com/72391766.html
  • go
  • http3
  • quic
  • quic-go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定