Decoupled the creation of servers so we can hide dbus behind a build flag and move on to simpler implementations without abandoning dbus completely

Author: dereulenspiegel

cmd/main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"io"
 	"os"
 	"os/signal"
 	"syscall"
@@ -12,7 +11,7 @@ import (
 
 	"github.com/dereulenspiegel/raucgithub"
 	"github.com/dereulenspiegel/raucgithub/repository/github"
-	"github.com/dereulenspiegel/raucgithub/server/dbus"
+	"github.com/dereulenspiegel/raucgithub/server"
 )
 
 func setDefaults() {
@@ -46,12 +45,12 @@ func main() {
 	logger.Info("Starting raucgithub")
 
 	var contextCancels []context.CancelFunc
-	var closers []io.Closer
+	var servers []server.Server
 	defer func() {
 		for _, cancelFunc := range contextCancels {
 			cancelFunc()
 		}
-		for _, closer := range closers {
+		for _, closer := range servers {
 			closer.Close()
 		}
 	}()
@@ -73,15 +72,25 @@ func main() {
 			logger.WithError(err).Fatal("failed to create update manager")
 		}
 
-		dbusConfig := viper.Sub("dbus")
-		dbusCtx, dbusCancel := context.WithCancel(ctx)
-		contextCancels = append(contextCancels, dbusCancel)
-		dbusServer, err := dbus.StartWithConfig(dbusCtx, manager, dbusConfig)
-		if err != nil {
-			logger.WithError(err).Error("failed to start dbus server")
-		} else {
-			closers = append(closers, dbusServer)
+		serverBuilders := server.Builders()
+
+		for _, builder := range serverBuilders {
+			logger := logger.WithField("server", builder.Name())
+			logger.Info("configuring server")
+			serverConfig := viper.Sub(builder.ConfigKey())
+			serverCtx, serverCancel := context.WithCancel(ctx)
+			contextCancels = append(contextCancels, serverCancel)
+			server, err := builder.New(manager, serverConfig)
+			if err != nil {
+				logger.WithError(err).Error("failed to configure server")
+			}
+			servers = append(servers, server)
+			logger.Info("starting server")
+			if err := server.Start(serverCtx); err != nil {
+				logger.WithError(err).Error("failed to start server")
+			}
 		}
+
 		logger.Info("Started successfully, waiting...")
 	}()
 

server/dbus.go

@@ -0,0 +1,27 @@
+//go:build dbus
+
+package server
+
+import (
+	"github.com/dereulenspiegel/raucgithub"
+	"github.com/dereulenspiegel/raucgithub/server/dbus"
+	"github.com/spf13/viper"
+)
+
+func init() {
+	RegisterBuilder("dbus", DBusBuilder{})
+}
+
+type DBusBuilder struct{}
+
+func (b DBusBuilder) Name() string {
+	return "DBus"
+}
+
+func (b DBusBuilder) ConfigKey() string {
+	return "dbus"
+}
+
+func (b DBusBuilder) New(manager *raucgithub.UpdateManager, conf *viper.Viper) (Server, error) {
+	return dbus.NewWithConfig(manager, conf)
+}

server/dbus/server.go

@@ -1,3 +1,5 @@
+//go:build dbus
+
 package dbus
 
 import (
@@ -46,21 +48,27 @@ type Server struct {
 
 type Option func(*Server) *Server
 
-func StartWithConfig(ctx context.Context, manager *raucgithub.UpdateManager, conf *viper.Viper) (*Server, error) {
+func NewWithConfig(manager *raucgithub.UpdateManager, conf *viper.Viper) (*Server, error) {
 	enabled := viper.GetBool("enabled")
 	if !enabled {
 		return nil, errors.New("dbus server not enabled")
 	}
-	return Start(ctx, manager)
+	return New(manager)
 }
 
-func Start(ctx context.Context, manager *raucgithub.UpdateManager, opts ...Option) (s *Server, err error) {
+func New(manager *raucgithub.UpdateManager, opts ...Option) (s *Server, err error) {
 	s = &Server{
-		logger: logrus.WithField("component", "dbusServer"),
+		logger:  logrus.WithField("component", "dbusServer"),
+		manager: manager,
 	}
 	for _, opt := range opts {
 		s = opt(s)
 	}
+
+	return s, nil
+}
+
+func (s *Server) Start(ctx context.Context) (err error) {
 	dbusContext, dbusCancel := context.WithCancel(ctx)
 	s.dbusCancel = dbusCancel
 
@@ -71,32 +79,30 @@ func Start(ctx context.Context, manager *raucgithub.UpdateManager, opts ...Optio
 		conn, err = dbus.ConnectSystemBus(dbus.WithContext(dbusContext))
 	}
 	if err != nil {
-		return nil, fmt.Errorf("failed to connect to DBus: %w", err)
+		return fmt.Errorf("failed to connect to DBus: %w", err)
 	}
 
 	s.conn = conn
-	s.manager = manager
 	s.ctx = ctx
 	if err := conn.Export(s, "/com/github/dereulenspiegel/rauc", "com.github.dereulenspiegel.rauc"); err != nil {
-		return nil, fmt.Errorf("failed to register DBus service: %w", err)
+		return fmt.Errorf("failed to register DBus service: %w", err)
 	}
 	if err := conn.Export(introspect.Introspectable(intro), "/com/github/dereulenspiegel/rauc",
 		"org.freedesktop.DBus.Introspectable"); err != nil {
-		return nil, fmt.Errorf("failed to register DBus introspection: %w", err)
+		return fmt.Errorf("failed to register DBus introspection: %w", err)
 	}
 
 	reply, err := conn.RequestName("com.github.dereulenspiegel.rauc",
 		dbus.NameFlagDoNotQueue)
 	if err != nil {
-		return nil, fmt.Errorf("failed to request name on system DBus: %w", err)
+		return fmt.Errorf("failed to request name on system DBus: %w", err)
 	}
 	if reply != dbus.RequestNameReplyPrimaryOwner {
-		return nil, errors.New("name on system DBus already taken")
+		return errors.New("name on system DBus already taken")
 	}
 
 	s.manager.RegisterUpdateAvailableCallback(s.updateAvailable)
-
-	return s, nil
+	return nil
 }
 
 func (s *Server) Close() error {

server/dbus/server_test.go

@@ -1,5 +1,4 @@
-//go:build dbus_test
-// +build dbus_test
+//go:build dbus && dbus_test
 
 package dbus
 
@@ -31,11 +30,13 @@ func useSessionBus() Option {
 func TestCreateDBusServer(t *testing.T) {
 	// Creste simple update manager without functionality to get DBus server to startup
 	manager := &raucgithub.UpdateManager{}
-	dbusServer, err := Start(context.Background(), manager)
+	dbusServer, err := New(manager)
+	require.NoError(t, err)
+	err = dbusServer.Start(context.Background())
+	require.NoError(t, err)
 	t.Cleanup(func() {
 		dbusServer.Close()
 	})
-	require.NoError(t, err)
 	assert.NotNil(t, dbusServer)
 }
 
@@ -93,12 +94,14 @@ func TestRunningDBusServerIntegration(t *testing.T) {
 	raucClient.EXPECT().GetProgress().Return(75, "installing", 1, nil)
 	raucClient.EXPECT().GetOperation().Return("installing", nil)
 
-	dbusServer, err := Start(context.Background(), updater, useSessionBus())
+	dbusServer, err := New(updater, useSessionBus())
+	require.NoError(t, err)
+	require.NotNil(t, dbusServer)
+	err = dbusServer.Start(context.Background())
+	require.NoError(t, err)
 	t.Cleanup(func() {
 		dbusServer.Close()
 	})
-	require.NoError(t, err)
-	assert.NotNil(t, dbusServer)
 
 	cmd := exec.Command("./test_run_update.py")
 	stdoutStderr, err := cmd.CombinedOutput()
@@ -156,12 +159,14 @@ func TestNewUpdateSignal(t *testing.T) {
 		},
 	}, nil)
 
-	dbusServer, err := Start(context.Background(), updater, useSessionBus())
+	dbusServer, err := New(updater, useSessionBus())
+	require.NoError(t, err)
+	require.NotNil(t, dbusServer)
+	err = dbusServer.Start(context.Background())
+	require.NoError(t, err)
 	t.Cleanup(func() {
 		dbusServer.Close()
 	})
-	require.NoError(t, err)
-	assert.NotNil(t, dbusServer)
 
 	cmd := exec.Command("./test_update_signal.py")
 	stdoutStderr, err := cmd.CombinedOutput()

server/server.go

@@ -0,0 +1,40 @@
+package server
+
+import (
+	"context"
+	"io"
+	"sync"
+
+	"github.com/dereulenspiegel/raucgithub"
+	"github.com/spf13/viper"
+)
+
+var (
+	registryLock = &sync.Mutex{}
+	registry     = make(map[string]Builder)
+)
+
+func RegisterBuilder(name string, b Builder) {
+	registryLock.Lock()
+	defer registryLock.Unlock()
+	registry[name] = b
+}
+
+func Builders() (builders []Builder) {
+	registryLock.Lock()
+	defer registryLock.Unlock()
+	for _, b := range registry {
+		builders = append(builders, b)
+	}
+	return
+}
+
+type Server interface {
+	io.Closer
+	Start(context.Context) error
+}
+type Builder interface {
+	ConfigKey() string
+	Name() string
+	New(*raucgithub.UpdateManager, *viper.Viper) (Server, error)
+}