signaling: use BackendConfig passing more options to backend factory

Signed-off-by: Steffen Vogel <post@steffenvogel.de>

pkg/daemon.go

@@ -45,9 +45,11 @@ func NewDaemon(cfg *config.Config) (*Daemon, error) {
 	// Create backend
 	var backend signaling.Backend
 	if len(cfg.Backends) == 1 {
-		backend, err = signaling.NewBackend(cfg.Backends[0], events)
+		backend, err = signaling.NewBackend(&signaling.BackendConfig{
+			URI: cfg.Backends[0],
+		}, events)
 	} else {
-		backend, err = signaling.NewMultiBackend(cfg.Backends, events)
+		backend, err = signaling.NewMultiBackend(cfg.Backends, &signaling.BackendConfig{}, events)
 	}
 	if err != nil {
 		return nil, fmt.Errorf("failed to initialize signaling backend: %w", err)

pkg/signaling/backend.go

@@ -16,13 +16,18 @@ var (
 
 type BackendType string // URL schemes
 
-type BackendFactory func(*url.URL, chan *pb.Event) (Backend, error)
+type BackendFactory func(*BackendConfig, chan *pb.Event) (Backend, error)
 
 type BackendPlugin struct {
 	New         BackendFactory
 	Description string
 }
 
+type BackendConfig struct {
+	URI       *url.URL
+	Community *crypto.Key
+}
+
 type Backend interface {
 	io.Closer
 
@@ -30,8 +35,8 @@ type Backend interface {
 	Subscribe(kp *crypto.KeyPair) (chan *pb.SignalingMessage, error)
 }
 
-func NewBackend(uri *url.URL, events chan *pb.Event) (Backend, error) {
+func NewBackend(cfg *BackendConfig, events chan *pb.Event) (Backend, error) {
-	typs := strings.SplitN(uri.Scheme, "+", 2)
+	typs := strings.SplitN(cfg.URI.Scheme, "+", 2)
 	typ := BackendType(typs[0])
 
 	p, ok := Backends[typ]
@@ -40,10 +45,10 @@ func NewBackend(uri *url.URL, events chan *pb.Event) (Backend, error) {
 	}
 
 	if len(typs) > 1 {
-		uri.Scheme = typs[1]
+		cfg.URI.Scheme = typs[1]
 	}
 
-	be, err := p.New(uri, events)
+	be, err := p.New(cfg, events)
 	if err != nil {
 		return nil, err
 	}

pkg/signaling/backend_test.go

@@ -17,7 +17,11 @@ func TestNewBackend(t *testing.T) {
 
 	events := make(chan *pb.Event, 100)
 
-	b, err := signaling.NewBackend(uri, events)
+	cfg := &signaling.BackendConfig{
+		URI: uri,
+	}
+
+	b, err := signaling.NewBackend(cfg, events)
 	if err != nil {
 		t.Fatalf("Failed to create new backend: %s", err)
 	}

pkg/signaling/grpc/backend.go

@@ -3,7 +3,6 @@ package grpc
 import (
 	"context"
 	"fmt"
-	"net/url"
 
 	"go.uber.org/zap"
 	"google.golang.org/grpc"
@@ -28,14 +27,14 @@ type Backend struct {
 	logger *zap.Logger
 }
 
-func NewBackend(uri *url.URL, events chan *pb.Event) (signaling.Backend, error) {
+func NewBackend(cfg *signaling.BackendConfig, events chan *pb.Event) (signaling.Backend, error) {
 	var err error
 
 	b := &Backend{
 		logger: zap.L().Named("grpc"),
 	}
 
-	if err := b.config.Parse(uri); err != nil {
+	if err := b.config.Parse(cfg); err != nil {
 		return nil, fmt.Errorf("failed to parse backend configuration: %w", err)
 	}
 

pkg/signaling/grpc/config.go

@@ -2,24 +2,25 @@ package grpc
 
 import (
 	"errors"
-	"net/url"
 	"strconv"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
+	"riasc.eu/wice/pkg/signaling"
 )
 
 type BackendConfig struct {
-	URI *url.URL
+	signaling.BackendConfig
 
 	Target string
 
 	Options []grpc.DialOption
 }
 
-func (c *BackendConfig) Parse(uri *url.URL) error {
+func (c *BackendConfig) Parse(cfg *signaling.BackendConfig) error {
-	options := uri.Query()
+	c.BackendConfig = *cfg
 
+	options := c.URI.Query()
 	if str := options.Get("insecure"); str != "" {
 		if b, err := strconv.ParseBool(str); err == nil && b {
 			c.Options = append(c.Options, grpc.WithTransportCredentials(
@@ -28,13 +29,11 @@ func (c *BackendConfig) Parse(uri *url.URL) error {
 		}
 	}
 
-	c.URI = uri
+	if c.URI.Host == "" {
-
-	if uri.Host == "" {
 		return errors.New("missing gRPC server url")
 	}
 
-	c.Target = uri.Host
+	c.Target = c.URI.Host
 
 	return nil
 }

pkg/signaling/k8s/backend.go

@@ -2,9 +2,7 @@ package k8s
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
-	"net/url"
 
 	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
@@ -50,7 +48,7 @@ func init() {
 	}
 }
 
-func NewBackend(uri *url.URL, events chan *pb.Event) (signaling.Backend, error) {
+func NewBackend(cfg *signaling.BackendConfig, events chan *pb.Event) (signaling.Backend, error) {
 	var config *rest.Config
 	var err error
 
@@ -63,12 +61,11 @@ func NewBackend(uri *url.URL, events chan *pb.Event) (signaling.Backend, error)
 		events:  events,
 	}
 
-	if err := b.config.Parse(uri); err != nil {
+	if err := b.config.Parse(cfg); err != nil {
 		return nil, fmt.Errorf("failed to parse configuration: %w", err)
 	}
 
-	kubeconfig := uri.Path
+	if b.config.Kubeconfig == "" {
-	if kubeconfig == "" {
 		loadingRules := clientcmd.NewDefaultClientConfigLoadingRules()
 		// if you want to change the loading rules (which files in which order), you can do so here
 
@@ -80,14 +77,12 @@ func NewBackend(uri *url.URL, events chan *pb.Event) (signaling.Backend, error)
 		if config, err = kubeConfig.ClientConfig(); err != nil {
 			return nil, fmt.Errorf("failed to load config: %w", err)
 		}
-	} else if kubeconfig == "incluster" {
+	} else if b.config.Kubeconfig == "incluster" {
-
 		if config, err = rest.InClusterConfig(); err != nil {
 			return nil, fmt.Errorf("failed to get incluster configuration: %w", err)
 		}
 	} else {
-		config, err = clientcmd.BuildConfigFromFlags("", kubeconfig)
+		if config, err = clientcmd.BuildConfigFromFlags("", b.config.Kubeconfig); err != nil {
-		if err != nil {
 			return nil, fmt.Errorf("failed to get configuration from flags: %w", err)
 		}
 	}

pkg/signaling/k8s/config.go

@@ -6,8 +6,9 @@ import (
 )
 
 type BackendConfig struct {
-	URI *url.URL
+	signaling.BackendConfig
 
+	Kubeconfig   string
 	NodeName            string
 	AnnotationOffers    string
 	AnnotationPublicKey string
@@ -18,7 +19,9 @@ var defaultConfig = BackendConfig{
 	AnnotationPublicKey: defaultAnnotationPublicKey,
 }
 
-func (c *BackendConfig) Parse(uri *url.URL) error {
+func (c *BackendConfig) Parse(cfg *signaling.BackendConfig) error {
+	c.BackendConfig = *cfg
+
 	options := uri.Query()
 
 	if str := options.Get("node"); str == "" {
@@ -33,8 +36,7 @@ func (c *BackendConfig) Parse(uri *url.URL) error {
 		c.AnnotationPublicKey = str
 	}
 
-	uri.RawQuery = ""
+	c.Kubeconfig = c.URI.Path
-	c.URI = uri
 
 	return nil
 }

pkg/signaling/multi.go

@@ -11,18 +11,19 @@ type MultiBackend struct {
 	backends []Backend
 }
 
-func NewMultiBackend(uris []*url.URL, events chan *pb.Event) (Backend, error) {
+func NewMultiBackend(uris []*url.URL, cfg *BackendConfig, events chan *pb.Event) (Backend, error) {
 	mb := &MultiBackend{
 		backends: []Backend{},
 	}
 
 	for _, u := range uris {
-		b, err := NewBackend(u, events)
+		cfg.URI = u
-		if err != nil {
+
+		if b, err := NewBackend(cfg, events); err == nil {
+			mb.backends = append(mb.backends, b)
+		} else {
 			return nil, err
 		}
-
-		mb.backends = append(mb.backends, b)
 	}
 
 	return mb, nil

pkg/signaling/p2p/backend.go

@@ -3,7 +3,6 @@ package p2p
 import (
 	"context"
 	"fmt"
-	"net/url"
 	"sync"
 
 	p2p "github.com/libp2p/go-libp2p"
@@ -54,7 +53,7 @@ type Backend struct {
 	events chan *pb.Event
 }
 
-func NewBackend(uri *url.URL, events chan *pb.Event) (signaling.Backend, error) {
+func NewBackend(cfg *signaling.BackendConfig, events chan *pb.Event) (signaling.Backend, error) {
 	var err error
 
 	b := &Backend{
@@ -64,7 +63,7 @@ func NewBackend(uri *url.URL, events chan *pb.Event) (signaling.Backend, error)
 		events: events,
 	}
 
-	if err := b.config.Parse(uri); err != nil {
+	if err := b.config.Parse(cfg); err != nil {
 		return nil, fmt.Errorf("failed to parse backend options: %w", err)
 	}
 

pkg/signaling/p2p/config.go

@@ -2,7 +2,6 @@ package p2p
 
 import (
 	"fmt"
-	"net/url"
 	"strconv"
 
 	"github.com/libp2p/go-libp2p-core/crypto"
@@ -11,6 +10,7 @@ import (
 	dht "github.com/libp2p/go-libp2p-kad-dht"
 	"github.com/libp2p/go-libp2p/p2p/host/autorelay"
 	maddr "github.com/multiformats/go-multiaddr"
+	"riasc.eu/wice/pkg/signaling"
 )
 
 const (
@@ -31,7 +31,7 @@ type peerAddressList []peer.AddrInfo
 type multiAddressList []maddr.Multiaddr
 
 type BackendConfig struct {
-	URI *url.URL
+	signaling.BackendConfig
 
 	// Load some options
 	ListenAddresses multiAddressList
@@ -98,12 +98,12 @@ func (al *peerAddressList) Set(as []string) error {
 	return nil
 }
 
-func (c *BackendConfig) Parse(uri *url.URL) error {
+func (c *BackendConfig) Parse(cfg *signaling.BackendConfig) error {
 	var err error
 
-	c.RendezvousString = uri.Opaque
+	options := cfg.URI.Query()
 
-	options := uri.Query()
+	c.BackendConfig = *cfg
 
 	if pkStr := options.Get("private-key"); pkStr != "" {
 		pk, err := crypto.ConfigDecodeKey(pkStr)