Merge pull request #18 from gruntwork-io/build-update

Build tools update

Author: denis256

Makefile

@@ -11,14 +11,21 @@ build: $(shell find . \( -type f -name '*.go' -print \))
 clean:
 	rm -f engine
 
+lint: SHELL:=/bin/bash
 lint:
-	golangci-lint run ./...
+	golangci-lint run -c <(curl -s https://raw.githubusercontent.com/gruntwork-io/terragrunt/main/.golangci.yml) ./...
+
+update-local-lint: SHELL:=/bin/bash
+update-local-lint:
+	curl -s https://raw.githubusercontent.com/gruntwork-io/terragrunt/main/.golangci.yml --output .golangci.yml
+	tmpfile=$$(mktemp) ;\
+	echo '# This file is generated using `make update-local-lint` to track the linting used in Terragrunt. Do not edit manually.' | cat - .golangci.yml > $${tmpfile} && mv $${tmpfile} .golangci.yml
 
 test:
 	go test -v ./...
 
 tools:
-	go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.61.0
+	go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.63.4
 
 fmt:
 	@echo "Running source files through gofmt..."

engine/engine.go

@@ -1,8 +1,10 @@
+// Package engine provides the implementation of Terragrunt IaC engine interface
 package engine
 
 import (
 	"bufio"
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -35,36 +37,41 @@ func (c *TerraformEngine) Init(req *tgengine.InitRequest, stream tgengine.Engine
 	if err != nil {
 		return err
 	}
+
 	return nil
 }
 
 func (c *TerraformEngine) Run(req *tgengine.RunRequest, stream tgengine.Engine_RunServer) error {
-	log.Infof("Run Terraform engine %v", req.WorkingDir)
-	cmd := exec.Command(iacCommand, req.Args...)
-	cmd.Dir = req.WorkingDir
-	env := make([]string, 0, len(req.EnvVars))
-	for key, value := range req.EnvVars {
+	log.Infof("Run Terraform engine %v", req.GetWorkingDir())
+	cmd := exec.Command(iacCommand, req.GetArgs()...)
+	cmd.Dir = req.GetWorkingDir()
+
+	env := make([]string, 0, len(req.GetEnvVars()))
+	for key, value := range req.GetEnvVars() {
 		env = append(env, fmt.Sprintf("%s=%s", key, value))
 	}
+
 	cmd.Env = append(cmd.Env, env...)
 
 	stdoutPipe, err := cmd.StdoutPipe()
 	if err != nil {
 		sendError(stream, err)
 		return err
 	}
+
 	stderrPipe, err := cmd.StderrPipe()
 	if err != nil {
 		sendError(stream, err)
 		return err
 	}
 
-	if req.AllocatePseudoTty {
+	if req.GetAllocatePseudoTty() {
 		ptmx, err := pty.Start(cmd)
 		if err != nil {
 			log.Errorf("Error allocating pseudo-TTY: %v", err)
 			return err
 		}
+
 		defer func() { _ = ptmx.Close() }()
 
 		go func() {
@@ -87,61 +94,81 @@ func (c *TerraformEngine) Run(req *tgengine.RunRequest, stream tgengine.Engine_R
 
 	var wg sync.WaitGroup
 
-	// 2 streams to send stdout and stderr
 	wg.Add(wgSize)
 
-	// Stream stdout
 	go func() {
+		// Ensure this goroutine signals completion when it returns
 		defer wg.Done()
+
+		// Create a reader that translates data from stdoutPipe into UTF-8 runes
 		reader := transform.NewReader(stdoutPipe, unicode.UTF8.NewDecoder())
+		// Wrap the reader in a buffered reader for efficient reading
 		bufReader := bufio.NewReader(reader)
+
 		for {
+			// Read a single rune from the buffered reader
 			char, _, err := bufReader.ReadRune()
 			if err != nil {
-				if err != io.EOF {
+				// If there's an error and it's not EOF, log it
+				if !errors.Is(err, io.EOF) {
 					log.Errorf("Error reading stdout: %v", err)
 				}
+				// Exit the loop on EOF or any other error
 				break
 			}
+
+			// Stream the read character back to the client
 			if err = stream.Send(&tgengine.RunResponse{Stdout: string(char)}); err != nil {
+				// If streaming fails, log the error and exit
 				log.Errorf("Error sending stdout: %v", err)
 				return
 			}
 		}
 	}()
 
-	// Stream stderr
+	// Starts a goroutine that captures stderr output character by character,
+	// applying UTF-8 decoding, and streams each character to the client.
+	// Handles errors appropriately and signals completion via WaitGroup.
+	// Terminates on EOF or transmission errors.
 	go func() {
 		defer wg.Done()
+
 		reader := transform.NewReader(stderrPipe, unicode.UTF8.NewDecoder())
 		bufReader := bufio.NewReader(reader)
+
 		for {
 			char, _, err := bufReader.ReadRune()
 			if err != nil {
-				if err != io.EOF {
+				if !errors.Is(err, io.EOF) {
 					log.Errorf("Error reading stderr: %v", err)
 				}
+
 				break
 			}
+
 			if err = stream.Send(&tgengine.RunResponse{Stderr: string(char)}); err != nil {
 				log.Errorf("Error sending stderr: %v", err)
 				return
 			}
 		}
 	}()
 	wg.Wait()
-	err = cmd.Wait()
+
 	resultCode := 0
-	if err != nil {
-		if exitError, ok := err.(*exec.ExitError); ok {
+
+	if err := cmd.Wait(); err != nil {
+		var exitError *exec.ExitError
+		if ok := errors.As(err, &exitError); ok {
 			resultCode = exitError.ExitCode()
 		} else {
 			resultCode = 1
 		}
 	}
+
 	if err := stream.Send(&tgengine.RunResponse{ResultCode: int32(resultCode)}); err != nil {
 		return err
 	}
+
 	return nil
 }
 
@@ -158,6 +185,7 @@ func (c *TerraformEngine) Shutdown(req *tgengine.ShutdownRequest, stream tgengin
 	if err != nil {
 		return err
 	}
+
 	return nil
 }
 

engine/engine_test.go

@@ -1,9 +1,11 @@
-package engine
+package engine_test
 
 import (
 	"context"
 	"testing"
 
+	"github.com/gruntwork-io/terragrunt-engine-terraform/engine"
+
 	"github.com/stretchr/testify/require"
 
 	"os"
@@ -118,18 +120,19 @@ func (m *MockShutdownServer) RecvMsg(msg interface{}) error {
 }
 
 func TestTerraformEngine_Init(t *testing.T) {
-	engine := &TerraformEngine{}
+	t.Parallel()
+	engine := &engine.TerraformEngine{}
 	mockStream := &MockInitServer{}
 
 	err := engine.Init(&tgengine.InitRequest{}, mockStream)
 	require.NoError(t, err)
-	assert.Equal(t, 1, len(mockStream.Responses))
-	assert.Equal(t, "Terraform Initialization completed\n", mockStream.Responses[0].Stdout)
+	assert.NotEmpty(t, mockStream.Responses)
+	assert.Equal(t, "Terraform Initialization completed\n", mockStream.Responses[0].GetStdout())
 }
 
 func TestTerraformEngine_Run(t *testing.T) {
 	t.Parallel()
-	engine := &TerraformEngine{}
+	engine := &engine.TerraformEngine{}
 	mockStream := &MockRunServer{}
 
 	cmd := "terraform"
@@ -141,20 +144,20 @@ func TestTerraformEngine_Run(t *testing.T) {
 	}
 	err := engine.Run(req, mockStream)
 	require.NoError(t, err)
-	assert.True(t, len(mockStream.Responses) > 0)
+	assert.NotEmpty(t, mockStream.Responses)
 	// merge stdout from all responses to a string
 	var output string
 	for _, response := range mockStream.Responses {
-		if response.Stdout != "" {
-			output += response.Stdout
+		if response.GetStdout() != "" {
+			output += response.GetStdout()
 		}
 	}
 	assert.Contains(t, output, "Usage: terraform [global options] <subcommand> [args]")
 }
 
 func TestTerraformEngineError(t *testing.T) {
 	t.Parallel()
-	engine := &TerraformEngine{}
+	engine := &engine.TerraformEngine{}
 	mockStream := &MockRunServer{}
 
 	cmd := "terraform"
@@ -165,30 +168,30 @@ func TestTerraformEngineError(t *testing.T) {
 	}
 	err := engine.Run(req, mockStream)
 	require.NoError(t, err)
-	assert.True(t, len(mockStream.Responses) > 0)
+	assert.NotEmpty(t, mockStream.Responses)
 	// merge stdout from all responses to a string
 	var output string
 
 	for _, response := range mockStream.Responses {
-		if response.Stderr != "" {
-			output += response.Stderr
+		if response.GetStderr() != "" {
+			output += response.GetStderr()
 		}
 	}
 	// get status code from last response
-	code := mockStream.Responses[len(mockStream.Responses)-1].ResultCode
+	code := mockStream.Responses[len(mockStream.Responses)-1].GetResultCode()
 	assert.Contains(t, output, "Terraform has no command named \"not-a-valid-command\"")
 	assert.NotEqual(t, 0, code)
 }
 
 func TestTerraformEngine_Shutdown(t *testing.T) {
 	t.Parallel()
-	engine := &TerraformEngine{}
+	engine := &engine.TerraformEngine{}
 	mockStream := &MockShutdownServer{}
 
 	err := engine.Shutdown(&tgengine.ShutdownRequest{}, mockStream)
 	require.NoError(t, err)
-	assert.Equal(t, 1, len(mockStream.Responses))
-	assert.Equal(t, "Terraform Shutdown completed\n", mockStream.Responses[0].Stdout)
+	assert.Len(t, mockStream.Responses, 1)
+	assert.Equal(t, "Terraform Shutdown completed\n", mockStream.Responses[0].GetStdout())
 }
 
 func TestHelperProcess(*testing.T) {

test/basic_test.go

@@ -1,4 +1,4 @@
-package test
+package integration_test
 
 import (
 	"context"
@@ -65,6 +65,7 @@ func bufDialer(context.Context, string) (net.Conn, error) {
 }
 
 func runTerraformCommand(t *testing.T, ctx context.Context, command string, args []string, workingDir string, envVars map[string]string) (string, string, error) {
+	t.Helper()
 	// nolint:staticcheck
 	conn, err := grpc.DialContext(ctx, "", grpc.WithContextDialer(bufDialer), grpc.WithInsecure())
 	if err != nil {
@@ -95,15 +96,15 @@ func runTerraformCommand(t *testing.T, ctx context.Context, command string, args
 			break
 		}
 
-		stdout.WriteString(resp.Stdout)
-		stderr.WriteString(resp.Stderr)
+		stdout.WriteString(resp.GetStdout())
+		stderr.WriteString(resp.GetStderr())
 
-		_, err = fmt.Fprint(os.Stdout, resp.Stdout)
+		_, err = fmt.Fprint(os.Stdout, resp.GetStdout())
 		if err != nil {
 			return "", "", err
 		}
 
-		_, err = fmt.Fprint(os.Stderr, resp.Stderr)
+		_, err = fmt.Fprint(os.Stderr, resp.GetStderr())
 		if err != nil {
 			return "", "", err
 		}