fixup! feat: headless mode

Use a single channel per consumer, instead of one channel per
consumer/event tuple. This ensures that overall ordering of events
remains consistent, and avoids introducing subtle race conditions.

.goreleaser.yaml

@@ -40,25 +40,12 @@ brews:
       system "#{bin}/octoplex -h"
 
 release:
-  draft: true
   github:
     owner: rfwatson
     name: octoplex
 
 changelog:
   use: github
-  groups:
-    - title: New Features
-      regexp: '^.*?feat(\([[:word:]]+\))??!?:.+$'
-      order: 0
-    - title: "Bug fixes"
-      regexp: '^.*?fix(\([[:word:]]+\))??!?:.+$'
-      order: 1
-    - title: "Refactorings"
-      regexp: '^.*?refactor(\([[:word:]]+\))??!?:.+$'
-      order: 2
-    - title: Others
-      order: 999
   filters:
     exclude:
       - "^doc:"

internal/app/app.go

@@ -27,6 +27,8 @@ type App struct {
 	dispatchC     chan event.Command
 	dockerClient  container.DockerClient
 	screen        *terminal.Screen // Screen may be nil.
+	// TODO: startup check
+	// TODO: handle SIGINT
 	headless           bool
 	clipboardAvailable bool
 	configFilePath     string
@@ -107,19 +109,6 @@ func (a *App) Run(ctx context.Context) error {
 		a.eventBus.Send(event.AppStateChangedEvent{State: domain.AppState{}})
 	}
 
-	// doFatalError publishes a fatal error to the event bus, waiting for the
-	// user to acknowledge it if not in headless mode.
-	doFatalError := func(msg string) {
-		a.eventBus.Send(event.FatalErrorOccurredEvent{Message: msg})
-
-		if a.headless {
-			return
-		}
-
-		emptyUI()
-		<-a.dispatchC
-	}
-
 	containerClient, err := container.NewClient(ctx, a.dockerClient, a.logger.With("component", "container_client"))
 	if err != nil {
 		err = fmt.Errorf("create container client: %w", err)
@@ -130,7 +119,10 @@ func (a *App) Run(ctx context.Context) error {
 		} else {
 			msg = err.Error()
 		}
-		doFatalError(msg)
+		a.eventBus.Send(event.FatalErrorOccurredEvent{Message: msg})
+
+		emptyUI()
+		<-a.dispatchC
 		return err
 	}
 	defer containerClient.Close()
@@ -160,7 +152,9 @@ func (a *App) Run(ctx context.Context) error {
 	})
 	if err != nil {
 		err = fmt.Errorf("create mediaserver: %w", err)
-		doFatalError(err.Error())
+		a.eventBus.Send(event.FatalErrorOccurredEvent{Message: err.Error()})
+		emptyUI()
+		<-a.dispatchC
 		return err
 	}
 	defer srv.Close()
@@ -177,16 +171,14 @@ func (a *App) Run(ctx context.Context) error {
 	defer uiUpdateT.Stop()
 
 	startMediaServerC := make(chan struct{}, 1)
-	if a.headless { // disable startup check in headless mode for now
-		startMediaServerC <- struct{}{}
-	} else {
 	if ok, startupErr := doStartupCheck(ctx, containerClient, a.eventBus); startupErr != nil {
-			doFatalError(startupErr.Error())
+		startupErr = fmt.Errorf("startup check: %w", startupErr)
+		a.eventBus.Send(event.FatalErrorOccurredEvent{Message: startupErr.Error()})
+		<-a.dispatchC
 		return startupErr
 	} else if ok {
 		startMediaServerC <- struct{}{}
 	}
-	}
 
 	for {
 		select {
@@ -210,12 +202,6 @@ func (a *App) Run(ctx context.Context) error {
 			updateUI()
 		case serverState := <-srv.C():
 			a.logger.Debug("Server state received", "state", serverState)
-
-			if serverState.ExitReason != "" {
-				doFatalError(serverState.ExitReason)
-				return errors.New("media server exited")
-			}
-
 			applyServerState(serverState, state)
 			updateUI()
 		case replState := <-repl.C():

internal/app/integration_test.go

@@ -892,17 +892,13 @@ func TestIntegrationMediaServerError(t *testing.T) {
 			done <- struct{}{}
 		}()
 
-		require.EqualError(
+		require.NoError(t, app.New(buildAppParams(t, configService, dockerClient, screen, screenCaptureC, logger)).Run(ctx))
-			t,
-			app.New(buildAppParams(t, configService, dockerClient, screen, screenCaptureC, logger)).Run(ctx),
-			"media server exited",
-		)
 	}()
 
 	require.EventuallyWithT(
 		t,
 		func(c *assert.CollectT) {
-			assert.True(c, contentsIncludes(getContents(), "Server process exited unexpectedly."), "expected to see title")
+			assert.True(c, contentsIncludes(getContents(), "Mediaserver error: Server process exited unexpectedly."), "expected to see title")
 			assert.True(c, contentsIncludes(getContents(), "address already in use"), "expected to see message")
 		},
 		waitTime,

internal/terminal/terminal.go

@@ -486,6 +486,10 @@ func (ui *UI) captureScreen(screen tcell.Screen) {
 func (ui *UI) handleAppStateChanged(evt event.AppStateChangedEvent) {
 	state := evt.State
 
+	if state.Source.ExitReason != "" {
+		ui.handleMediaServerClosed(state.Source.ExitReason)
+	}
+
 	ui.updatePullProgress(state)
 
 	ui.mu.Lock()
@@ -680,6 +684,24 @@ func (ui *UI) hideModal(pageName string) {
 	ui.app.SetFocus(ui.destView)
 }
 
+func (ui *UI) handleMediaServerClosed(exitReason string) {
+	if ui.pages.HasPage(pageNameModalSourceError) {
+		return
+	}
+
+	modal := tview.NewModal()
+	modal.SetText("Mediaserver error: " + exitReason).
+		AddButtons([]string{"Quit"}).
+		SetBackgroundColor(tcell.ColorBlack).
+		SetTextColor(tcell.ColorWhite).
+		SetDoneFunc(func(int, string) {
+			ui.dispatch(event.CommandQuit{})
+		})
+	modal.SetBorderStyle(tcell.StyleDefault.Background(tcell.ColorBlack).Foreground(tcell.ColorWhite))
+
+	ui.pages.AddPage(pageNameModalSourceError, modal, true, true)
+}
+
 const dash = "—"
 
 const (

main.go

@@ -95,11 +95,9 @@ func run() error {
 		// When running in headless mode tview doesn't handle SIGINT for us.
 		ch := make(chan os.Signal, 1)
 		signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
-
 		go func() {
 			<-ch
 			logger.Info("Received interrupt signal, exiting")
-			signal.Stop(ch)
 			cancel(errShutdown)
 		}()
 	}
@@ -188,8 +186,8 @@ func printUsage() {
 	os.Stderr.WriteString("  help          Print this help message\n")
 	os.Stderr.WriteString("\n")
 	os.Stderr.WriteString("Additionally, Octoplex can be configured with the following environment variables:\n\n")
-	os.Stderr.WriteString("  OCTO_DEBUG    Enables debug logging if set\n")
+	os.Stderr.WriteString("  OCTO_DEBUG    Enables debug logging if set\n\n")
-	os.Stderr.WriteString("  OCTO_HEADLESS Enables headless mode if set (experimental)\n\n")
+	os.Stderr.WriteString("  OCTO_HEADLESS Enables headless mode if set (experimental)\n")
 }
 
 // buildLogger builds the logger, which may be a no-op logger.