rpc rewrite: control RPCs using gRPC + separate RPC for data transfer

transport/ssh: update go-netssh to new version => supports CloseWrite and Deadlines => build: require Go 1.11 (netssh requires it)
2018-12-11 22:01:50 +01:00
parent d281fb00e3
commit 796c5ad42d
100 changed files with 6460 additions and 1485 deletions
@@ -0,0 +1,181 @@
+// Package versionhandshake wraps a transport.{Connecter,AuthenticatedListener}
+// to add an exchange of protocol version information on connection establishment.
+//
+// The protocol version information (banner) is plain text, thus making it
+// easy to diagnose issues with standard tools.
+package versionhandshake
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"net"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+type HandshakeMessage struct {
+	ProtocolVersion int
+	Extensions []string
+}
+
+// A HandshakeError describes what went wrong during the handshake.
+// It implements net.Error and is always temporary.
+type HandshakeError struct {
+	msg string
+	// If not nil, the underlying IO error that caused the handshake to fail.
+	IOError error
+}
+
+var _ net.Error = &HandshakeError{}
+
+func (e HandshakeError) Error() string { return e.msg }
+
+// Always true to enable usage in a net.Listener.
+func (e HandshakeError) Temporary() bool { return true }
+
+// If the underlying IOError was net.Error.Timeout(), Timeout() returns that value.
+// Otherwise false.
+func (e HandshakeError) Timeout() bool {
+	if neterr, ok := e.IOError.(net.Error); ok {
+		return neterr.Timeout()
+	}
+	return false
+}
+
+func hsErr(format string, args... interface{}) *HandshakeError {
+	return &HandshakeError{msg: fmt.Sprintf(format, args...)}
+}
+
+func hsIOErr(err error, format string, args... interface{}) *HandshakeError {
+	return &HandshakeError{IOError: err, msg: fmt.Sprintf(format, args...)}
+}
+
+// MaxProtocolVersion is the maximum allowed protocol version.
+// This is a protocol constant, changing it may break the wire format.
+const MaxProtocolVersion = 9999
+
+// Only returns *HandshakeError as error.
+func (m *HandshakeMessage) Encode() ([]byte, error) {
+	if m.ProtocolVersion <= 0 || m.ProtocolVersion > MaxProtocolVersion {
+		return nil, hsErr(fmt.Sprintf("protocol version must be in [1, %d]", MaxProtocolVersion))
+	}
+	if len(m.Extensions) >= MaxProtocolVersion {
+		return nil, hsErr(fmt.Sprintf("protocol only supports [0, %d] extensions", MaxProtocolVersion))
+	}
+	// EXTENSIONS is a count of subsequent \n separated lines that contain protocol extensions
+	var extensions strings.Builder
+	for i, ext := range m.Extensions {
+		if strings.ContainsAny(ext, "\n") {
+			return nil, hsErr("Extension #%d contains forbidden newline character", i)
+		}
+		if !utf8.ValidString(ext) {
+			return nil, hsErr("Extension #%d is not valid UTF-8", i)
+		}
+		extensions.WriteString(ext)
+		extensions.WriteString("\n")
+	}
+	withoutLen := fmt.Sprintf("ZREPL_ZFS_REPLICATION PROTOVERSION=%04d EXTENSIONS=%04d\n%s",
+		m.ProtocolVersion, len(m.Extensions), extensions.String())
+	withLen := fmt.Sprintf("%010d %s", len(withoutLen), withoutLen)
+	return []byte(withLen), nil
+}
+
+func (m *HandshakeMessage) DecodeReader(r io.Reader, maxLen int) error {
+	var lenAndSpace [11]byte
+	if _, err := io.ReadFull(r, lenAndSpace[:]); err != nil {
+		return hsIOErr(err, "error reading protocol banner length: %s", err)
+	}
+	if !utf8.Valid(lenAndSpace[:]) {
+		return hsErr("invalid start of handshake message: not valid UTF-8")
+	}
+	var followLen int
+	n, err := fmt.Sscanf(string(lenAndSpace[:]), "%010d ", &followLen)
+	if n != 1 || err != nil {
+		return hsErr("could not parse handshake message length")
+	}
+	if followLen > maxLen {
+		return hsErr("handshake message length exceeds max length (%d vs %d)",
+			followLen, maxLen)
+	}
+
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, io.LimitReader(r, int64(followLen)))
+	if err != nil {
+		return hsIOErr(err, "error reading protocol banner body: %s", err)
+	}
+
+	var (
+		protoVersion, extensionCount int
+	)
+	n, err = fmt.Fscanf(&buf, "ZREPL_ZFS_REPLICATION PROTOVERSION=%04d EXTENSIONS=%4d\n",
+		&protoVersion, &extensionCount)
+	if n != 2 || err != nil {
+		return hsErr("could not parse handshake message: %s", err)
+	}
+	if protoVersion < 1 {
+		return hsErr("invalid protocol version %q", protoVersion)
+	}
+	m.ProtocolVersion = protoVersion
+
+	if extensionCount < 0 {
+		return hsErr("invalid extension count %q", extensionCount)
+	}
+	if extensionCount == 0 {
+		if buf.Len() != 0 {
+			return hsErr("unexpected data trailing after header")
+		}
+		m.Extensions = nil
+		return nil
+	}
+	s := buf.String()
+	if strings.Count(s, "\n") != extensionCount {
+		return hsErr("inconsistent extension count: found %d, header says %d", len(m.Extensions), extensionCount)
+	}
+	exts := strings.Split(s, "\n")
+	if exts[len(exts)-1] != "" {
+		return hsErr("unexpected data trailing after last extension newline")
+	}
+	m.Extensions = exts[0:len(exts)-1]
+
+	return nil
+}
+
+func DoHandshakeCurrentVersion(conn net.Conn, deadline time.Time) error {
+	// current protocol version is hardcoded here
+	return DoHandshakeVersion(conn, deadline, 1)
+}
+
+const HandshakeMessageMaxLen = 16 * 4096
+
+func DoHandshakeVersion(conn net.Conn, deadline time.Time, version int) error {
+	ours := HandshakeMessage{
+		ProtocolVersion: version,
+		Extensions: nil,
+	}
+	hsb, err := ours.Encode()
+	if err != nil {
+		return hsErr("could not encode protocol banner: %s", err)
+	}
+
+	defer conn.SetDeadline(time.Time{})
+	conn.SetDeadline(deadline)
+	_, err = io.Copy(conn, bytes.NewBuffer(hsb))
+	if err != nil {
+		return hsErr("could not send protocol banner: %s", err)
+	}
+
+	theirs := HandshakeMessage{}
+	if err := theirs.DecodeReader(conn, HandshakeMessageMaxLen); err != nil {
+		return hsErr("could not decode protocol banner: %s", err)
+	}
+
+	if theirs.ProtocolVersion != ours.ProtocolVersion {
+		return hsErr("protocol versions do not match: ours is %d, theirs is %d",
+			ours.ProtocolVersion, theirs.ProtocolVersion)
+	}
+	// ignore extensions, we don't use them
+
+	return nil
+}
@@ -0,0 +1,119 @@
+package versionhandshake
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zrepl/zrepl/util/socketpair"
+	"io"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestHandshakeMessage_Encode(t *testing.T) {
+
+	msg := HandshakeMessage{
+		ProtocolVersion: 2342,
+	}
+
+	encB, err := msg.Encode()
+	require.NoError(t, err)
+	enc := string(encB)
+	t.Logf("enc: %s", enc)
+
+
+
+	assert.False(t, strings.ContainsAny(enc[0:10], " "))
+	assert.True(t, enc[10] == ' ')
+
+	var (
+		headerlen, protoversion, extensionCount int
+	)
+	n, err := fmt.Sscanf(enc, "%010d ZREPL_ZFS_REPLICATION PROTOVERSION=%04d EXTENSIONS=%04d\n",
+		&headerlen, &protoversion, &extensionCount)
+	if n != 3 || (err != nil && err != io.EOF) {
+		t.Fatalf("%v %v", n, err)
+	}
+
+	assert.Equal(t, 2342, protoversion)
+	assert.Equal(t, 0, extensionCount)
+	assert.Equal(t, len(enc)-11, headerlen)
+
+}
+
+func TestHandshakeMessage_Encode_InvalidProtocolVersion(t *testing.T) {
+
+	for _, pv := range []int{-1, 0,  10000, 10001} {
+		t.Logf("testing invalid protocol version = %v", pv)
+		msg := HandshakeMessage{
+			ProtocolVersion: pv,
+		}
+		b, err := msg.Encode()
+		assert.Error(t, err)
+		assert.Nil(t, b)
+	}
+
+}
+
+func TestHandshakeMessage_DecodeReader(t *testing.T) {
+
+	in := HandshakeMessage{
+		2342,
+		[]string{"foo", "bar 2342"},
+	}
+
+	enc, err := in.Encode()
+	require.NoError(t, err)
+
+	out := HandshakeMessage{}
+	err = out.DecodeReader(bytes.NewReader([]byte(enc)), 4 * 4096)
+	assert.NoError(t, err)
+	assert.Equal(t, 2342, out.ProtocolVersion)
+	assert.Equal(t, 2, len(out.Extensions))
+	assert.Equal(t, "foo", out.Extensions[0])
+	assert.Equal(t, "bar 2342", out.Extensions[1])
+
+}
+
+func TestDoHandshakeVersion_ErrorOnDifferentVersions(t *testing.T) {
+	srv, client, err := socketpair.SocketPair()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer srv.Close()
+	defer client.Close()
+
+	srvErrCh := make(chan error)
+	go func() {
+		srvErrCh <- DoHandshakeVersion(srv, time.Now().Add(2*time.Second), 1)
+	}()
+	err = DoHandshakeVersion(client, time.Now().Add(2*time.Second), 2)
+	t.Log(err)
+	assert.Error(t, err)
+	assert.True(t, strings.Contains(err.Error(), "version"))
+
+	srvErr := <-srvErrCh
+	t.Log(srvErr)
+	assert.Error(t, srvErr)
+	assert.True(t, strings.Contains(srvErr.Error(), "version"))
+}
+
+func TestDoHandshakeCurrentVersion(t *testing.T) {
+	srv, client, err := socketpair.SocketPair()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer srv.Close()
+	defer client.Close()
+
+	srvErrCh := make(chan error)
+	go func() {
+		srvErrCh <- DoHandshakeVersion(srv, time.Now().Add(2*time.Second), 1)
+	}()
+	err = DoHandshakeVersion(client, time.Now().Add(2*time.Second), 1)
+	assert.Nil(t, err)
+	assert.Nil(t, <-srvErrCh)
+
+}
@@ -0,0 +1,66 @@
+package versionhandshake
+
+import (
+	"context"
+	"net"
+	"time"
+	"github.com/zrepl/zrepl/transport"
+)
+
+type HandshakeConnecter struct {
+	connecter transport.Connecter
+	timeout time.Duration
+}
+
+func (c HandshakeConnecter) Connect(ctx context.Context) (transport.Wire, error) {
+	conn, err := c.connecter.Connect(ctx)
+	if err != nil {
+		return nil, err
+	}
+	dl, ok := ctx.Deadline()
+	if !ok {
+		dl = time.Now().Add(c.timeout)
+	}
+	if err := DoHandshakeCurrentVersion(conn, dl); err != nil {
+		conn.Close()
+		return nil, err
+	}
+	return conn, nil
+}
+
+func Connecter(connecter transport.Connecter, timeout time.Duration) HandshakeConnecter {
+	return HandshakeConnecter{
+		connecter: connecter,
+		timeout: timeout,
+	}
+}
+
+// wrapper type that performs a a protocol version handshake before returning the connection
+type HandshakeListener struct {
+	l transport.AuthenticatedListener
+	timeout time.Duration
+}
+
+func (l HandshakeListener) Addr() (net.Addr) { return l.l.Addr() }
+
+func (l HandshakeListener) Close() error { return l.l.Close() }
+
+func (l HandshakeListener) Accept(ctx context.Context) (*transport.AuthConn, error) {
+	conn, err := l.l.Accept(ctx)
+	if err != nil {
+		return nil, err
+	}
+	dl, ok := ctx.Deadline()
+	if !ok {
+		dl = time.Now().Add(l.timeout) // shadowing
+	}
+	if err := DoHandshakeCurrentVersion(conn, dl); err != nil {
+		conn.Close()
+		return nil, err
+	}
+	return conn, nil
+}
+
+func Listener(l transport.AuthenticatedListener, timeout time.Duration) transport.AuthenticatedListener {
+	return HandshakeListener{l, timeout}
+}