Add log passthrough for lock-exec

Creates multiwriter with a single buffer (combined output) and
std IO file descriptors

Author: JoshStern

cmd/run.go

@@ -20,17 +20,17 @@ func (c *cli) newRunCmd() *cobra.Command {
 			locker := c.newLocker()
 
 			log.Info("running command")
-			out, err := locker.Run(c.cmd.Context(), args[0], args[1])
+			err := locker.Run(c.cmd.Context(), args[0], args[1])
 			if err != nil {
 				if errors.Is(err, lock.ErrLocked) {
 					log.Info("did not run command. key is locked")
 					return
 				}
 
-				log.Fatalw("command failed", "error", err, "output", out)
+				log.Fatalw("command failed", "error", err)
 			}
 
-			log.Infow("command succeeded", "output", out)
+			log.Infow("command succeeded")
 		},
 	}
 

lock/run.go

@@ -3,6 +3,7 @@ package lock
 import (
 	"context"
 	"fmt"
+	"os"
 	"os/exec"
 	"strings"
 	"time"
@@ -11,17 +12,25 @@ import (
 // Run acquires a lock under the specified key, executes the command, and then unlocks the key.
 // Returns ErrLocked if the key is already locked. Otherwise returns combined stdout and stderr
 // of the command and the command error. If the unlock step fails the lock expires after 24 hours.
-func (c *Client) Run(ctx context.Context, key, command string) (string, error) {
+func (c *Client) Run(ctx context.Context, key, command string) error {
 	// use context.Background here so that unlock runs even if the context is cancelled
 	defer c.Unlock(context.Background(), key) //nolint:errcheck
 
 	err := c.Lock(ctx, key, time.Hour*24) //nolint:gomnd
 	if err != nil {
-		return "", fmt.Errorf("lock failed: %w", err)
+		return fmt.Errorf("lock failed: %w", err)
 	}
 
+	// Build command
 	fields := strings.Fields(command)
-	cmdout, cmderr := exec.CommandContext(ctx, fields[0], fields[1:]...).CombinedOutput() //nolint:gosec
+	cmd := exec.CommandContext(ctx, fields[0], fields[1:]...) //nolint:gosec
 
-	return strings.TrimSpace(string(cmdout)), cmderr
+	// Write to std outputs
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("command failed: %w", err)
+	}
+	return nil
 }

lock/run_test.go

@@ -18,20 +18,17 @@ func TestRun(t *testing.T) {
 
 	wg.Add(1)
 	go func() {
-		out, err := tc.Run(ctx, "locktest", "sleep 1")
-		assert.Empty(t, out)
+		err := tc.Run(ctx, "locktest", "sleep 1")
 		assert.NoError(t, err)
 		wg.Done()
 	}()
 	time.Sleep(time.Millisecond * 500)
 
-	out, err := tc.Run(ctx, "locktest", "sleep 5")
-	assert.Empty(t, out)
+	err := tc.Run(ctx, "locktest", "sleep 5")
 	assert.ErrorIs(t, err, ErrLocked)
 
-	out, err = tc.Run(ctx, "locktest", "echo hello test")
+	err = tc.Run(ctx, "locktest", "echo hello test")
 	assert.NoError(t, err)
-	assert.Equal(t, "hello test", out)
 
 	wg.Wait()
 }