TUN-528: Move cloudflared into a separate repo

tunnelrpc/go.capnp

@@ -0,0 +1,15 @@
+# Generate go.capnp.out with:
+# capnp compile -o- go.capnp > go.capnp.out
+# Must run inside this directory to preserve paths.
+
+@0xd12a1c51fedd6c88;
+
+annotation package(file) :Text;
+annotation import(file) :Text;
+annotation doc(struct, field, enum) :Text;
+annotation tag(enumerant) :Text;
+annotation notag(enumerant) :Void;
+annotation customtype(field) :Text;
+annotation name(struct, field, union, enum, enumerant, interface, method, param, annotation, const, group) :Text;
+
+$package("capnp");

tunnelrpc/log.go

@@ -0,0 +1,42 @@
+package tunnelrpc
+
+import (
+	log "github.com/sirupsen/logrus"
+	"golang.org/x/net/context"
+	"golang.org/x/net/trace"
+	"zombiezen.com/go/capnproto2/rpc"
+)
+
+// ConnLogger wraps a logrus *log.Entry for a connection.
+type ConnLogger struct {
+	Entry *log.Entry
+}
+
+func (c ConnLogger) Infof(ctx context.Context, format string, args ...interface{}) {
+	c.Entry.Infof(format, args...)
+}
+
+func (c ConnLogger) Errorf(ctx context.Context, format string, args ...interface{}) {
+	c.Entry.Errorf(format, args...)
+}
+
+func ConnLog(log *log.Entry) rpc.ConnOption {
+	return rpc.ConnLog(ConnLogger{log})
+}
+
+// ConnTracer wraps a trace.EventLog for a connection.
+type ConnTracer struct {
+	Events trace.EventLog
+}
+
+func (c ConnTracer) Infof(ctx context.Context, format string, args ...interface{}) {
+	c.Events.Printf(format, args...)
+}
+
+func (c ConnTracer) Errorf(ctx context.Context, format string, args ...interface{}) {
+	c.Events.Errorf(format, args...)
+}
+
+func ConnTrace(events trace.EventLog) rpc.ConnOption {
+	return rpc.ConnLog(ConnTracer{events})
+}

tunnelrpc/logtransport.go

@@ -0,0 +1,45 @@
+// Package logtransport provides a transport that logs all of its messages.
+package tunnelrpc
+
+import (
+	"bytes"
+
+	log "github.com/sirupsen/logrus"
+	"golang.org/x/net/context"
+	"zombiezen.com/go/capnproto2/encoding/text"
+	"zombiezen.com/go/capnproto2/rpc"
+	rpccapnp "zombiezen.com/go/capnproto2/std/capnp/rpc"
+)
+
+type transport struct {
+	rpc.Transport
+	l *log.Entry
+}
+
+// New creates a new logger that proxies messages to and from t and
+// logs them to l.  If l is nil, then the log package's default
+// logger is used.
+func NewTransportLogger(l *log.Entry, t rpc.Transport) rpc.Transport {
+	return &transport{Transport: t, l: l}
+}
+
+func (t *transport) SendMessage(ctx context.Context, msg rpccapnp.Message) error {
+	t.l.Debugf("tx %s", formatMsg(msg))
+	return t.Transport.SendMessage(ctx, msg)
+}
+
+func (t *transport) RecvMessage(ctx context.Context) (rpccapnp.Message, error) {
+	msg, err := t.Transport.RecvMessage(ctx)
+	if err != nil {
+		t.l.WithError(err).Debug("rx error")
+		return msg, err
+	}
+	t.l.Debugf("rx %s", formatMsg(msg))
+	return msg, nil
+}
+
+func formatMsg(m rpccapnp.Message) string {
+	var buf bytes.Buffer
+	text.NewEncoder(&buf).Encode(0x91b79f1f808db032, m.Struct)
+	return buf.String()
+}

tunnelrpc/pogs/tunnelrpc.go

@@ -0,0 +1,211 @@
+package pogs
+
+import (
+	"github.com/cloudflare/cloudflared/tunnelrpc"
+	log "github.com/sirupsen/logrus"
+	"golang.org/x/net/context"
+	"zombiezen.com/go/capnproto2"
+	"zombiezen.com/go/capnproto2/pogs"
+	"zombiezen.com/go/capnproto2/rpc"
+	"zombiezen.com/go/capnproto2/server"
+)
+
+type Authentication struct {
+	Key         string
+	Email       string
+	OriginCAKey string
+}
+
+func MarshalAuthentication(s tunnelrpc.Authentication, p *Authentication) error {
+	return pogs.Insert(tunnelrpc.Authentication_TypeID, s.Struct, p)
+}
+
+func UnmarshalAuthentication(s tunnelrpc.Authentication) (*Authentication, error) {
+	p := new(Authentication)
+	err := pogs.Extract(p, tunnelrpc.Authentication_TypeID, s.Struct)
+	return p, err
+}
+
+type TunnelRegistration struct {
+	Err              string
+	Url              string
+	LogLines         []string
+	PermanentFailure bool
+	TunnelID         string `capnp:"tunnelID"`
+}
+
+func MarshalTunnelRegistration(s tunnelrpc.TunnelRegistration, p *TunnelRegistration) error {
+	return pogs.Insert(tunnelrpc.TunnelRegistration_TypeID, s.Struct, p)
+}
+
+func UnmarshalTunnelRegistration(s tunnelrpc.TunnelRegistration) (*TunnelRegistration, error) {
+	p := new(TunnelRegistration)
+	err := pogs.Extract(p, tunnelrpc.TunnelRegistration_TypeID, s.Struct)
+	return p, err
+}
+
+type RegistrationOptions struct {
+	ClientID             string `capnp:"clientId"`
+	Version              string
+	OS                   string `capnp:"os"`
+	ExistingTunnelPolicy tunnelrpc.ExistingTunnelPolicy
+	PoolName             string `capnp:"poolName"`
+	Tags                 []Tag
+	ConnectionID         uint8  `capnp:"connectionId"`
+	OriginLocalIP        string `capnp:"originLocalIp"`
+	IsAutoupdated        bool   `capnp:"isAutoupdated"`
+	RunFromTerminal      bool   `capnp:"runFromTerminal"`
+	CompressionQuality   uint64 `capnp:"compressionQuality"`
+}
+
+func MarshalRegistrationOptions(s tunnelrpc.RegistrationOptions, p *RegistrationOptions) error {
+	return pogs.Insert(tunnelrpc.RegistrationOptions_TypeID, s.Struct, p)
+}
+
+func UnmarshalRegistrationOptions(s tunnelrpc.RegistrationOptions) (*RegistrationOptions, error) {
+	p := new(RegistrationOptions)
+	err := pogs.Extract(p, tunnelrpc.RegistrationOptions_TypeID, s.Struct)
+	return p, err
+}
+
+type Tag struct {
+	Name  string `json:"name"`
+	Value string `json:"value"`
+}
+
+type ServerInfo struct {
+	LocationName string
+}
+
+func MarshalServerInfo(s tunnelrpc.ServerInfo, p *ServerInfo) error {
+	return pogs.Insert(tunnelrpc.ServerInfo_TypeID, s.Struct, p)
+}
+
+func UnmarshalServerInfo(s tunnelrpc.ServerInfo) (*ServerInfo, error) {
+	p := new(ServerInfo)
+	err := pogs.Extract(p, tunnelrpc.ServerInfo_TypeID, s.Struct)
+	return p, err
+}
+
+type TunnelServer interface {
+	RegisterTunnel(ctx context.Context, originCert []byte, hostname string, options *RegistrationOptions) (*TunnelRegistration, error)
+	GetServerInfo(ctx context.Context) (*ServerInfo, error)
+	UnregisterTunnel(ctx context.Context, gracePeriodNanoSec int64) error
+}
+
+func TunnelServer_ServerToClient(s TunnelServer) tunnelrpc.TunnelServer {
+	return tunnelrpc.TunnelServer_ServerToClient(TunnelServer_PogsImpl{s})
+}
+
+type TunnelServer_PogsImpl struct {
+	impl TunnelServer
+}
+
+func (i TunnelServer_PogsImpl) RegisterTunnel(p tunnelrpc.TunnelServer_registerTunnel) error {
+	originCert, err := p.Params.OriginCert()
+	if err != nil {
+		return err
+	}
+	hostname, err := p.Params.Hostname()
+	if err != nil {
+		return err
+	}
+	options, err := p.Params.Options()
+	if err != nil {
+		return err
+	}
+	pogsOptions, err := UnmarshalRegistrationOptions(options)
+	if err != nil {
+		return err
+	}
+	server.Ack(p.Options)
+	registration, err := i.impl.RegisterTunnel(p.Ctx, originCert, hostname, pogsOptions)
+	if err != nil {
+		return err
+	}
+	result, err := p.Results.NewResult()
+	if err != nil {
+		return err
+	}
+	log.Info(registration.TunnelID)
+	return MarshalTunnelRegistration(result, registration)
+}
+
+func (i TunnelServer_PogsImpl) GetServerInfo(p tunnelrpc.TunnelServer_getServerInfo) error {
+	server.Ack(p.Options)
+	serverInfo, err := i.impl.GetServerInfo(p.Ctx)
+	if err != nil {
+		return err
+	}
+	result, err := p.Results.NewResult()
+	if err != nil {
+		return err
+	}
+	return MarshalServerInfo(result, serverInfo)
+}
+
+func (i TunnelServer_PogsImpl) UnregisterTunnel(p tunnelrpc.TunnelServer_unregisterTunnel) error {
+	gracePeriodNanoSec := p.Params.GracePeriodNanoSec()
+	server.Ack(p.Options)
+	return i.impl.UnregisterTunnel(p.Ctx, gracePeriodNanoSec)
+
+}
+
+type TunnelServer_PogsClient struct {
+	Client capnp.Client
+	Conn   *rpc.Conn
+}
+
+func (c TunnelServer_PogsClient) Close() error {
+	return c.Conn.Close()
+}
+
+func (c TunnelServer_PogsClient) RegisterTunnel(ctx context.Context, originCert []byte, hostname string, options *RegistrationOptions) (*TunnelRegistration, error) {
+	client := tunnelrpc.TunnelServer{Client: c.Client}
+	promise := client.RegisterTunnel(ctx, func(p tunnelrpc.TunnelServer_registerTunnel_Params) error {
+		err := p.SetOriginCert(originCert)
+		if err != nil {
+			return err
+		}
+		err = p.SetHostname(hostname)
+		if err != nil {
+			return err
+		}
+		registrationOptions, err := p.NewOptions()
+		if err != nil {
+			return err
+		}
+		err = MarshalRegistrationOptions(registrationOptions, options)
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+	retval, err := promise.Result().Struct()
+	if err != nil {
+		return nil, err
+	}
+	return UnmarshalTunnelRegistration(retval)
+}
+
+func (c TunnelServer_PogsClient) GetServerInfo(ctx context.Context) (*ServerInfo, error) {
+	client := tunnelrpc.TunnelServer{Client: c.Client}
+	promise := client.GetServerInfo(ctx, func(p tunnelrpc.TunnelServer_getServerInfo_Params) error {
+		return nil
+	})
+	retval, err := promise.Result().Struct()
+	if err != nil {
+		return nil, err
+	}
+	return UnmarshalServerInfo(retval)
+}
+
+func (c TunnelServer_PogsClient) UnregisterTunnel(ctx context.Context, gracePeriodNanoSec int64) error {
+	client := tunnelrpc.TunnelServer{Client: c.Client}
+	promise := client.UnregisterTunnel(ctx, func(p tunnelrpc.TunnelServer_unregisterTunnel_Params) error {
+		p.SetGracePeriodNanoSec(gracePeriodNanoSec)
+		return nil
+	})
+	_, err := promise.Struct()
+	return err
+}

tunnelrpc/tunnelrpc.capnp

@@ -0,0 +1,67 @@
+using Go = import "go.capnp";
+@0xdb8274f9144abc7e;
+$Go.package("tunnelrpc");
+$Go.import("github.com/cloudflare/cloudflared/tunnelrpc");
+
+struct Authentication {
+    key @0 :Text;
+    email @1 :Text;
+    originCAKey @2 :Text;
+}
+
+struct TunnelRegistration {
+    err @0 :Text;
+    # the url to access the tunnel
+    url @1 :Text;
+    # Used to inform the client of actions taken.
+    logLines @2 :List(Text);
+    # In case of error, whether the client should attempt to reconnect.
+    permanentFailure @3 :Bool;
+    # Displayed to user
+    tunnelID @4 :Text;
+}
+
+struct RegistrationOptions {
+    # The tunnel client's unique identifier, used to verify a reconnection.
+    clientId @0 :Text;
+    # Information about the running binary.
+    version @1 :Text;
+    os @2 :Text;
+    # What to do with existing tunnels for the given hostname.
+    existingTunnelPolicy @3 :ExistingTunnelPolicy;
+    # If using the balancing policy, identifies the LB pool to use.
+    poolName @4 :Text;
+    # Client-defined tags to associate with the tunnel
+    tags @5 :List(Tag);
+    # A unique identifier for a high-availability connection made by a single client.
+    connectionId @6 :UInt8;
+    # origin LAN IP
+    originLocalIp @7 :Text;
+    # whether Argo Tunnel client has been autoupdated
+    isAutoupdated @8 :Bool;
+    # whether Argo Tunnel client is run from a terminal
+    runFromTerminal @9 :Bool;
+    # cross stream compression setting, 0 - off, 3 - high
+    compressionQuality @10 :UInt64;
+}
+
+struct Tag {
+    name @0 :Text;
+    value @1 :Text;
+}
+
+enum ExistingTunnelPolicy {
+    ignore @0;
+    disconnect @1;
+    balance @2;
+}
+
+struct ServerInfo {
+    locationName @0 :Text;
+}
+
+interface TunnelServer {
+    registerTunnel @0 (originCert :Data, hostname :Text, options :RegistrationOptions) -> (result :TunnelRegistration);
+    getServerInfo @1 () -> (result :ServerInfo);
+    unregisterTunnel @2 (gracePeriodNanoSec :Int64) -> ();
+}