Method Run

cmd/litestream/main.go:120–234

Run executes the program.

(ctx context.Context, args []string)

// Run executes the program.
func (m *Main) Run(ctx context.Context, args []string) (err error) {
	// Execute replication command if running as a Windows service.
	if isService, err := isWindowsService(); err != nil {
		return err
	} else if isService {
		return runWindowsService(ctx)
	}

	// Copy "LITESTEAM" environment credentials.
	applyLitestreamEnv()

	// Extract command name.
	var cmd string
	if len(args) > 0 {
		cmd, args = args[0], args[1:]
	}

	switch cmd {
	case "databases":
		return (&DatabasesCommand{}).Run(ctx, args)
	case "replicate":
		c := NewReplicateCommand()
		if err := c.ParseFlags(ctx, args); err != nil {
			return err
		}

		// Setup signal handler.
		signalCh := signalChan()

		// Create done channel for interrupt during shutdown. It will be
		// closed when a second signal arrives, allowing each database's
		// retry loop to observe the interrupt.
		done := make(chan struct{})
		c.SetDone(done)

		if err := c.Run(ctx); err != nil {
			return err
		}

		// Wait for signal to stop program.
		select {
		case err = <-c.execCh:
			if c.cmd != nil {
				slog.Info("subprocess exited, litestream shutting down")
			} else {
				slog.Info("replication complete, litestream shutting down")
			}
		case sig := <-signalCh:
			slog.Info("signal received, litestream shutting down", "signal", sig)

			if c.cmd != nil {
				slog.Info("sending signal to exec process")
				if err := c.cmd.Process.Signal(sig); err != nil {
					return fmt.Errorf("cannot signal exec process: %w", err)
				}

				slog.Info("waiting for exec process to close")
				if err := <-c.execCh; err != nil && !strings.HasPrefix(err.Error(), "signal:") {