Integrated Buildkit and improved entrypoint

Author: Bharadwajshivam28

action.yml

@@ -18,7 +18,7 @@ inputs:
 
 runs:
   using: "docker"
-  image: 'Dockerfile'
+  image: 'docker://ghcr.io/clouddrove/smurf:v1.0.4'
   args:
     - ${{ inputs.tool }}
     - ${{ inputs.command }}

cmd/sdkr/build.go

@@ -83,6 +83,7 @@ var buildCmd = &cobra.Command{
 			return fmt.Errorf(color.RedString("Dockerfile not found at %s", configs.DockerfilePath))
 		}
 
+		// In the RunE function, when creating the opts
 		opts := docker.BuildOptions{
 			ContextDir:     configs.ContextDir,
 			DockerfilePath: configs.DockerfilePath,
@@ -91,6 +92,7 @@ var buildCmd = &cobra.Command{
 			Target:         configs.Target,
 			Platform:       configs.Platform,
 			Timeout:        time.Duration(configs.BuildTimeout) * time.Second,
+			BuildKit:       configs.BuildKit,
 		}
 
 		err := docker.Build(imageName, tag, opts)
@@ -108,13 +110,14 @@ smurf sdkr build
 }
 
 func init() {
-	buildCmd.Flags().StringVarP(&configs.DockerfilePath, "file", "f", "", "Path to Dockerfile relative to context directory")
-	buildCmd.Flags().StringVar(&configs.ContextDir, "context", "", "Build context directory (default: current directory)")
-	buildCmd.Flags().BoolVar(&configs.NoCache, "no-cache", false, "Do not use cache when building the image")
-	buildCmd.Flags().StringArrayVar(&configs.BuildArgs, "build-arg", []string{}, "Set build-time variables")
-	buildCmd.Flags().StringVar(&configs.Target, "target", "", "Set the target build stage to build")
-	buildCmd.Flags().StringVar(&configs.Platform, "platform", "", "Set the platform for the build (e.g., linux/amd64, linux/arm64)")
-	buildCmd.Flags().IntVar(&configs.BuildTimeout, "timeout", 1500, "Set the build timeout")
+    buildCmd.Flags().StringVarP(&configs.DockerfilePath, "file", "f", "", "Path to Dockerfile relative to context directory")
+    buildCmd.Flags().StringVar(&configs.ContextDir, "context", "", "Build context directory (default: current directory)")
+    buildCmd.Flags().BoolVar(&configs.NoCache, "no-cache", false, "Do not use cache when building the image")
+    buildCmd.Flags().StringArrayVar(&configs.BuildArgs, "build-arg", []string{}, "Set build-time variables")
+    buildCmd.Flags().StringVar(&configs.Target, "target", "", "Set the target build stage to build")
+    buildCmd.Flags().StringVar(&configs.Platform, "platform", "", "Set the platform for the build (e.g., linux/amd64, linux/arm64)")
+    buildCmd.Flags().IntVar(&configs.BuildTimeout, "timeout", 1500, "Set the build timeout")
+    buildCmd.Flags().BoolVar(&configs.BuildKit, "buildkit", false, "Enable BuildKit for advanced Dockerfile features")
 
-	sdkrCmd.AddCommand(buildCmd)
-}
+    sdkrCmd.AddCommand(buildCmd)
+}

configs/configs.go

@@ -8,6 +8,8 @@ import (
 	"gopkg.in/yaml.v2"
 )
 
+var BuildKit bool
+
 // Config represents the structure of the configuration file
 func LoadConfig(filePath string) (*Config, error) {
 	data, err := ioutil.ReadFile(filePath)
@@ -38,4 +40,4 @@ func ExportEnvironmentVariables(vars map[string]string) error {
 		}
 	}
 	return nil
-}
+}

entrypoint.sh

@@ -1,74 +1,78 @@
 #!/bin/bash
 set -e
 
-# Debugging info
-echo "Starting entrypoint script..."
-echo "Current User: $(whoami)"
-echo "Working Directory: $(pwd)"
-echo "AWS Region: ${AWS_REGION:-not set}"
-echo "EKS Cluster: ${EKS_CLUSTER_NAME:-not set}"
-
-# Function to check file existence and non-emptiness
 check_file_exists() {
     if [ ! -s "$1" ]; then
-        echo "Error: $1 is either missing or empty."
+        echo "❌ Error: $1 is either missing or empty."
         exit 1
     fi
 }
 
 aws_eks_login() {
+    if [[ "$PROVIDER" != "aws" || "$TOOL" != "helm" ]]; then
+        return 0
+    fi
+
     if [[ -z "$AWS_ACCESS_KEY_ID" || -z "$AWS_SECRET_ACCESS_KEY" || -z "$AWS_DEFAULT_REGION" || -z "$EKS_CLUSTER_NAME" ]]; then
-        echo "⚠️ Warning: Required environment variables not set. Please ensure the following are set:"
-        echo "  - AWS_ACCESS_KEY_ID"
-        echo "  - AWS_SECRET_ACCESS_KEY"
-        echo "  - AWS_DEFAULT_REGION"
-        echo "  - EKS_CLUSTER_NAME"
-        echo "Skipping AWS and EKS login."
+        echo "❌ AWS credentials or EKS cluster name missing!"
         return 1
     fi
 
-    echo "🔹 Configuring AWS credentials..."
     aws configure set aws_access_key_id "$AWS_ACCESS_KEY_ID"
     aws configure set aws_secret_access_key "$AWS_SECRET_ACCESS_KEY"
-    aws configure set default.region "$AWS_DEFAULT_REGION"
-    echo "✅ AWS credentials configured successfully."
+    aws configure set region "$AWS_DEFAULT_REGION"
 
-    # EKS Cluster Login
-    echo "🔹 Getting EKS token for cluster: $EKS_CLUSTER_NAME..."
-    aws eks update-kubeconfig --region "$AWS_DEFAULT_REGION" --name "$EKS_CLUSTER_NAME"
-    if [ $? -eq 0 ]; then
-        echo "✅ Successfully configured EKS cluster access."
+    if aws eks update-kubeconfig --region "$AWS_DEFAULT_REGION" --name "$EKS_CLUSTER_NAME"; then
+        echo "✅ Successfully updated kubeconfig for EKS."
+        return 0
     else
-        echo "❌ Failed to configure EKS cluster access."
+        echo "❌ Failed to update kubeconfig for EKS."
+        return 1
+    fi
+}
+
+aws_login() {
+    if [[ "$PROVIDER" != "aws" || "$TOOL" != "terraform" ]]; then
+        return 0
+    fi
+
+    if [[ -z "$AWS_ACCESS_KEY_ID" || -z "$AWS_SECRET_ACCESS_KEY" || -z "$AWS_DEFAULT_REGION" ]]; then
+        echo "❌ AWS credentials missing!"
         return 1
     fi
+    
+    aws configure set aws_access_key_id "$AWS_ACCESS_KEY_ID"
+    aws configure set aws_secret_access_key "$AWS_SECRET_ACCESS_KEY"
+    aws configure set region "$AWS_DEFAULT_REGION"
 }
 
-# Docker login if credentials are provided
+# AWS Login for EKS if needed
+if [[ "$PROVIDER" == "aws" && "$TOOL" == "helm" ]]; then
+    aws_eks_login
+fi
+
+# AWS Login for Terraform if needed
+if [[ "$PROVIDER" == "aws" && "$TOOL" == "terraform" ]]; then
+    aws_login
+fi
+
+# Docker Login
 if [[ -n "$DOCKER_USERNAME" && -n "$DOCKER_PASSWORD" ]]; then
-    echo "$DOCKER_PASSWORD" | docker login --username "$DOCKER_USERNAME" --password-stdin
+    echo "$DOCKER_PASSWORD" | docker login --username "$DOCKER_USERNAME" --password-stdin -q
     echo "✅ Successfully logged into Docker Hub."
 fi
 
-# Perform AWS and EKS login
-aws_eks_login
-
-# Initialize command with base command
+# Executing Smurf Command
 SMURF_CMD="/usr/local/bin/smurf"
 
-# Add tool as first argument if provided
 if [[ $# -gt 0 ]]; then
     SMURF_CMD="$SMURF_CMD $1"
     shift
 fi
 
-# Add remaining arguments
 if [[ $# -gt 0 ]]; then
     SMURF_CMD="$SMURF_CMD $*"
 fi
 
-# Debug output
 echo "🔹 Executing command: $SMURF_CMD"
-
-# Execute the final command
-exec $SMURF_CMD
+exec $SMURF_CMD

internal/docker/build.go

@@ -1,10 +1,13 @@
 package docker
 
 import (
+	"bufio"
 	"context"
 	"encoding/json"
 	"fmt"
 	"io"
+	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"time"
@@ -65,6 +68,7 @@ func Build(imageName, tag string, opts BuildOptions) error {
 	}
 
 	fullImageName := fmt.Sprintf("%s:%s", imageName, tag)
+	// In the Build function, modify the buildOptions
 	buildOptions := types.ImageBuildOptions{
 		Tags:        []string{fullImageName},
 		Dockerfile:  relDockerfilePath,
@@ -79,6 +83,128 @@ func Build(imageName, tag string, opts BuildOptions) error {
 		NetworkMode: "default",
 	}
 
+	// Add this before the ImageBuild call
+	if opts.BuildKit {
+		// Enable BuildKit
+		os.Setenv("DOCKER_BUILDKIT", "1")
+	}
+
+	if opts.BuildKit {
+		buildOptions.Version = types.BuilderBuildKit
+	}
+
+	// Build function modification
+
+// Modify this part in your docker.Build function
+if opts.BuildKit {
+    spinner.UpdateText("Running build with BuildKit enabled...")
+    
+    // Construct docker command arguments
+    args := []string{"build"}
+    
+    // Add the tag
+    args = append(args, "--tag", fullImageName)
+    
+    // Add other build options
+    if opts.NoCache {
+        args = append(args, "--no-cache")
+    }
+    if relDockerfilePath != "" {
+        args = append(args, "--file", relDockerfilePath)
+    }
+    for k, v := range opts.BuildArgs {
+        args = append(args, "--build-arg", fmt.Sprintf("%s=%s", k, v))
+    }
+    if opts.Target != "" {
+        args = append(args, "--target", opts.Target)
+    }
+    if platform != "" {
+        args = append(args, "--platform", platform)
+    }
+    
+    // Add the context directory as the last argument
+    args = append(args, opts.ContextDir)
+    
+    // Create and configure the command
+    cmd := exec.Command("docker", args...)
+    
+    // Set environment with BuildKit enabled
+    cmd.Env = append(os.Environ(), "DOCKER_BUILDKIT=1")
+    
+    // Create pipes for stdout and stderr
+    stdoutPipe, err := cmd.StdoutPipe()
+    if err != nil {
+        return fmt.Errorf(color.RedString("failed to create stdout pipe: %v", err))
+    }
+    stderrPipe, err := cmd.StderrPipe()
+    if err != nil {
+        return fmt.Errorf(color.RedString("failed to create stderr pipe: %v", err))
+    }
+    
+    // Start the command
+    if err := cmd.Start(); err != nil {
+        return fmt.Errorf(color.RedString("failed to start build: %v", err))
+    }
+    
+    spinner.Success()
+    progressBar, _ := pterm.DefaultProgressbar.WithTotal(100).WithTitle("Building").Start()
+    
+    // Process stdout
+    go func() {
+        scanner := bufio.NewScanner(stdoutPipe)
+        for scanner.Scan() {
+            line := scanner.Text()
+            if strings.HasPrefix(line, "Step ") {
+                pterm.Info.Println(color.CyanString(line))
+                progressBar.Add(5)
+            } else {
+                trimmed := strings.TrimSpace(line)
+                if trimmed != "" {
+                    pterm.Debug.Println(trimmed)
+                }
+            }
+        }
+    }()
+    
+    // Process stderr
+    go func() {
+        scanner := bufio.NewScanner(stderrPipe)
+        for scanner.Scan() {
+            line := scanner.Text()
+            pterm.Debug.Println(color.YellowString(line))
+        }
+    }()
+    
+    // Wait for the command to complete
+    if err := cmd.Wait(); err != nil {
+        progressBar.Stop()
+        return fmt.Errorf(color.RedString("BuildKit build failed: %v", err))
+    }
+    
+    progressBar.Add(100 - progressBar.Current)
+    
+    time.Sleep(2 * time.Second)
+    
+    inspect, _, err := cli.ImageInspectWithRaw(ctx, fullImageName)
+    if err != nil {
+        return fmt.Errorf(color.RedString("failed to get image info: %v", err))
+    }
+    
+    panel := pterm.DefaultBox.WithTitle("Build Complete").Sprintf(` %s %s %s %s %s %s %s `,
+        color.GreenString("✓ Image Built Successfully"),
+        color.CyanString("Image: %s", fullImageName),
+        color.CyanString("ID: %s", inspect.ID[:12]),
+        color.CyanString("Size: %.2f MB", float64(inspect.Size)/1024/1024),
+        color.CyanString("Platform: %s/%s", inspect.Os, inspect.Architecture),
+        color.CyanString("Created: %s", inspect.Created[:19]),
+        color.CyanString("Layers: %d", len(inspect.RootFS.Layers)),
+    )
+    
+    fmt.Println(panel)
+    return nil
+}
+
+// The rest of your original Build function continues below for non-BuildKit builds
 	resp, err := cli.ImageBuild(ctx, buildCtx, buildOptions)
 	if err != nil {
 		spinner.Fail()
@@ -150,4 +276,4 @@ func Build(imageName, tag string, opts BuildOptions) error {
 
 	fmt.Println(panel)
 	return nil
-}
+}

internal/docker/types.go

@@ -11,6 +11,7 @@ type BuildOptions struct {
 	Target         string
 	Platform       string
 	Timeout        time.Duration
+	BuildKit       bool
 }
 
 // ImageInfo struct to hold information about a Docker image
@@ -40,4 +41,4 @@ type jsonMessage struct {
 	Status   string `json:"status"`
 	Error    string `json:"error"`
 	Progress string `json:"progress"`
-}
+}