Merge pull request #85 from oasisprotocol/ptrus/feature/rofl-cli-split-stdout

rofl: Split stdout and stderr for CLI commands

Author: ptrus

e2e/e2e_test.go

@@ -135,13 +135,13 @@ func TestE2E(t *testing.T) {
 			if result.Err != "" {
 				// XXX: CI seems to slow to push the image to registry, so the build timeouts, don't fail the test in that case.
 				// Remove this in future, if the timeotus get adjusted.
-				if strings.Contains(result.Logs, "response status code 524") {
+				if strings.Contains(result.Stdout, "response status code 524") {
 					t.Log("build timed out, not failing the test")
 					return
 				}
 				require.FailNow(result.Err, "build failed", result.Err)
 			}
-			require.NotEmpty(result.Logs, "no logs in response body")
+			require.NotEmpty(result.Stdout, "no logs in response body")
 			require.NotEmpty(result.Manifest, "no manifest in response body")
 			require.NotEmpty(result.ManifestHash, "no manifest hash in response body")
 			require.NotEmpty(result.OciReference, "no OCI reference in response body")
@@ -280,7 +280,7 @@ func TestE2E(t *testing.T) {
 				require.NoError(json.Unmarshal(body, &validateRes), "failed to unmarshal response body")
 				require.False(validateRes.Valid, "validation should fail for %s", tc.description)
 				require.NotEmpty(validateRes.Err, "error should be present for %s", tc.description)
-				require.NotEmpty(validateRes.Logs, "logs should be present for %s", tc.description)
+				require.NotEmpty(validateRes.Stderr, "stderr should be present for %s", tc.description)
 
 				t.Logf("Test case '%s' failed as expected with error: %s", tc.description, validateRes.Err)
 			})

tasks/roflbuild.go

@@ -55,7 +55,8 @@ type RoflBuildResult struct {
 	OciReference string `json:"oci_reference"`
 	ManifestHash string `json:"manifest_hash"`
 
-	Logs string `json:"logs"`
+	Stdout string `json:"stdout"`
+	Stderr string `json:"stderr"`
 
 	Err string `json:"err"`
 }

tasks/roflvalidate.go

@@ -46,9 +46,10 @@ type RoflValidatePayload struct {
 
 // RoflValidateResult are the results of the rofl validate task.
 type RoflValidateResult struct {
-	Valid bool   `json:"valid"`
-	Logs  string `json:"logs"`
-	Err   string `json:"err"`
+	Valid  bool   `json:"valid"`
+	Stdout string `json:"stdout"`
+	Stderr string `json:"stderr"`
+	Err    string `json:"err"`
 }
 
 // RoflValidateResultsKey is the redis key for the results of the rofl validate task.

worker/oasiscli/oasiscli.go

@@ -6,7 +6,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io"
 	"log/slog"
 	"math/rand"
 	"os"
@@ -45,8 +44,10 @@ type CommandResult struct {
 	// Validate is the result of the validate command.
 	Validate *CommandValidateResult `json:"validate,omitempty"`
 
-	// Logs are the outputted logs by the command.
-	Logs []byte `json:"logs"`
+	// Stdout is the standard output from the command.
+	Stdout []byte `json:"stdout"`
+	// Stderr is the error output from the command.
+	Stderr []byte `json:"stderr"`
 	// Err contains the error during execution of the command.
 	Err error `json:"err,omitempty"`
 }
@@ -122,10 +123,10 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (*CommandResult, error
 	}
 	c.SysProcAttr = getSysProcAttr()
 
-	var outputBuf bytes.Buffer
 	var stdoutBuf bytes.Buffer
-	c.Stdout = io.MultiWriter(&outputBuf, &stdoutBuf)
-	c.Stderr = &outputBuf
+	var stderrBuf bytes.Buffer
+	c.Stdout = &stdoutBuf
+	c.Stderr = &stderrBuf
 
 	results := &CommandResult{}
 	if err := c.Start(); err != nil {
@@ -142,10 +143,11 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (*CommandResult, error
 			_ = syscall.Kill(-c.Process.Pid, syscall.SIGKILL)
 		}
 		<-done
-		slog.Error("command timed out", "command", c.String(), "logs", outputBuf.String(), "error", ctx.Err())
+		slog.Error("command timed out", "command", c.String(), "stdout", stdoutBuf.String(), "stderr", stderrBuf.String(), "error", ctx.Err())
 		return nil, ctx.Err()
 	case err := <-done:
-		results.Logs = outputBuf.Bytes()
+		results.Stdout = stdoutBuf.Bytes()
+		results.Stderr = stderrBuf.Bytes()
 		if err != nil {
 			results.Err = fmt.Errorf("command '%s' failed: %w", c.String(), err)
 			return results, nil
@@ -166,8 +168,8 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (*CommandResult, error
 	case CommandPush:
 		// The output should be a JSON object with the OCI digest and manifest hash.
 		var parsed map[string]string
-		if err := json.Unmarshal(stdoutBuf.Bytes(), &parsed); err != nil {
-			slog.Error("failed to parse push output", "error", err, "stdout", stdoutBuf.Bytes(), "logs", results.Logs)
+		if err := json.Unmarshal(results.Stdout, &parsed); err != nil {
+			slog.Error("failed to parse push output", "error", err, "stdout", results.Stdout, "stderr", results.Stderr)
 			return nil, fmt.Errorf("failed to parse push output: %w", err)
 		}
 		if parsed["oci_reference"] == "" {

worker/worker.go

@@ -227,17 +227,18 @@ func (p *roflProcessor) processBuildTask(ctx context.Context, taskID string, pay
 		result.Err = ErrInternalError.Error()
 		return result
 	}
-	result.Logs = string(buildResult.Logs)
+	result.Stdout = string(buildResult.Stdout)
+	result.Stderr = string(buildResult.Stderr)
 
 	// Propagate the build command error if it failed.
 	if buildResult.Err != nil {
-		p.logger.Error("build command failed", "error", buildResult.Err, "logs", buildResult.Logs)
+		p.logger.Error("build command failed", "error", buildResult.Err, "stdout", buildResult.Stdout, "stderr", buildResult.Stderr)
 		result.Err = buildResult.Err.Error()
 		return result
 	}
 
 	if buildResult.Build == nil {
-		p.logger.Error("build result is nil, but no error was returned", "logs", buildResult.Logs)
+		p.logger.Error("build result is nil, but no error was returned", "stdout", buildResult.Stdout, "stderr", buildResult.Stderr)
 		result.Err = ErrInternalError.Error()
 		return result
 	}
@@ -252,17 +253,18 @@ func (p *roflProcessor) processBuildTask(ctx context.Context, taskID string, pay
 		result.Err = ErrInternalError.Error()
 		return result
 	}
-	result.Logs += "\n" + string(pushResult.Logs)
+	result.Stdout += "\n" + string(pushResult.Stdout)
+	result.Stderr += "\n" + string(pushResult.Stderr)
 
 	// Propagate the push command error if it failed.
 	if pushResult.Err != nil {
-		p.logger.Error("push command failed", "error", pushResult.Err, "logs", pushResult.Logs)
+		p.logger.Error("push command failed", "error", pushResult.Err, "stdout", pushResult.Stdout, "stderr", pushResult.Stderr)
 		result.Err = pushResult.Err.Error()
 		return result
 	}
 
 	if pushResult.Push == nil {
-		p.logger.Error("push result is nil, but no error was returned", "logs", pushResult.Logs)
+		p.logger.Error("push result is nil, but no error was returned", "stdout", pushResult.Stdout, "stderr", pushResult.Stderr)
 		result.Err = ErrInternalError.Error()
 		return result
 	}
@@ -325,11 +327,12 @@ func (p *roflProcessor) processValidateTask(ctx context.Context, taskID string,
 		result.Err = ErrInternalError.Error()
 		return result
 	}
-	result.Logs = string(validateResult.Logs)
+	result.Stdout = string(validateResult.Stdout)
+	result.Stderr = string(validateResult.Stderr)
 
 	// Check if validation succeeded.
 	if validateResult.Err != nil {
-		p.logger.Debug("validate command failed", "error", validateResult.Err, "logs", validateResult.Logs)
+		p.logger.Debug("validate command failed", "error", validateResult.Err, "stdout", validateResult.Stdout, "stderr", validateResult.Stderr)
 		result.Valid = false
 		result.Err = validateResult.Err.Error()
 	} else {