Function runCommandWithProgress

pkg/restic/restic.go:272–316

(ctx context.Context, r *Repo, args []string, callback func(T), failureErr error, opts ...GenericOption)

}

func runCommandWithProgress[T ProgressEntryValidator](ctx context.Context, r *Repo, args []string, callback func(T), failureErr error, opts ...GenericOption) (T, error) {
	logger := LoggerFromContext(ctx)
	cmdCtx, cancel := context.WithCancel(ctx)
	defer cancel()
	cmdCtx = ContextWithLogger(cmdCtx, nil) // ensure no logger is used
	cmd := r.commandWithContext(cmdCtx, args, opts...)

	// Ensure the command is logged since we're overriding the logger
	if logger != nil {
		fmt.Fprintf(logger, "command: %q\n", cmd)
	} else {
		logger = io.Discard
	}

	buf := buffer.New(8 * 1024) // 8KB IO buffer for the realtime event parsing
	reader, writer := nio.Pipe(buf)
	r.handleOutput(cmd, withAllTo(writer))

	var readErr error
	var summary T
	var wg sync.WaitGroup

	wg.Add(1)
	go func() {
		defer wg.Done()
		result, err := processProgressOutput[T](reader, logger, callback)
		summary = result
		if err != nil {
			readErr = fmt.Errorf("output processing: %w", err)
		}
	}()

	cmdErr := cmd.Run()
	writer.Close()
	wg.Wait()

	if cmdErr != nil || readErr != nil {
		if cmdErr != nil {
			cmdErr = handleResticExitError(cmdErr, failureErr)
		}
		return summary, newCmdError(cmd, errors.Join(cmdErr, readErr))
	}

	return summary, nil
}

func (r *Repo) Backup(ctx context.Context, paths []string, progressCallback func(*BackupProgressEntry), opts ...GenericOption) (*BackupProgressEntry, error) {
	for _, p := range paths {