zip and upload artefact

Author: motatoes

dgctl/cmd/exec.go

@@ -8,6 +8,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"github.com/diggerhq/digger/dgctl/utils"
 	orchestrator_scheduler "github.com/diggerhq/digger/libs/scheduler"
 	"github.com/diggerhq/digger/libs/spec"
 	"github.com/google/go-github/v61/github"
@@ -273,6 +274,23 @@ var execCmd = &cobra.Command{
 		var spec spec.Spec
 		err = json.Unmarshal(specBytes, &spec)
 
+		// attatch zip archive to backend
+		backendToken := spec.Job.BackendJobToken
+		zipLocation, err := utils.ArchiveGitRepo("./")
+		statusCode, respBody, err := utils.SendZipAsJobArtefact(diggerHostname, zipLocation, backendToken)
+		if err != nil {
+			log.Printf("could not attach zip artefact: %v", err)
+			os.Exit(1)
+		}
+		if *statusCode != 200 {
+			log.Printf("unexpected status code from backend: %v", *statusCode)
+			log.Printf("server response: %v", *respBody)
+			os.Exit(1)
+		}
+
+		log.Printf("exiting early ...")
+		os.Exit(0)
+
 		token := os.Getenv("GITHUB_PAT_TOKEN")
 		if token == "" {
 			log.Printf("missing variable: GITHUB_PAT_TOKEN")

dgctl/utils/backendutils.go

@@ -0,0 +1,77 @@
+package utils
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+)
+
+func SendZipAsJobArtefact(backendUrl string, zipLocation string, jobToken string) (*int, *string, error) {
+	url := fmt.Sprintf("%v/job_artefacts/", backendUrl)
+	filePath := zipLocation
+
+	// Open the file
+	file, err := os.Open(filePath)
+	if err != nil {
+		fmt.Println("Error opening file:", err)
+		return nil, nil, fmt.Errorf("Error opening file:", err)
+	}
+	defer file.Close()
+
+	// Create a buffer to store our request body as bytes
+	var requestBody bytes.Buffer
+
+	// Create a multipart writer
+	multipartWriter := multipart.NewWriter(&requestBody)
+
+	// Create a form file writer for our file field
+	fileWriter, err := multipartWriter.CreateFormFile("file", filepath.Base(filePath))
+	if err != nil {
+		fmt.Println("Error creating form file:", err)
+		return nil, nil, fmt.Errorf("Error creating form file:", err)
+	}
+
+	// Copy the file content to the form file writer
+	_, err = io.Copy(fileWriter, file)
+	if err != nil {
+		fmt.Println("Error copying file content:", err)
+		return nil, nil, fmt.Errorf("Error copying file content:", err)
+	}
+
+	// Close the multipart writer to finalize the request body
+	multipartWriter.Close()
+
+	// Create a new HTTP request
+	req, err := http.NewRequest("PUT", url, &requestBody)
+	if err != nil {
+		fmt.Println("Error creating request:", err)
+		return nil, nil, fmt.Errorf("Error creating request:", err)
+	}
+
+	// Set the content type header
+	req.Header.Set("Content-Type", multipartWriter.FormDataContentType())
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %v", jobToken))
+
+	// Send the request
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		fmt.Println("Error sending request:", err)
+		return nil, nil, fmt.Errorf("Error sending request:", err)
+	}
+	defer resp.Body.Close()
+
+	// Read and print the response
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		fmt.Println("Error reading response:", err)
+		return nil, nil, fmt.Errorf("Error reading response: %v", err)
+	}
+
+	b := string(body)
+	return &resp.StatusCode, &b, nil
+}

dgctl/utils/gitio.go

@@ -0,0 +1,99 @@
+package utils
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"time"
+)
+
+func ArchiveGitRepo(sourcePath string) (string, error) {
+	// Generate a unique ID for the temp directory
+	tempID := fmt.Sprintf("%d", time.Now().UnixNano())
+	tempDir := filepath.Join(os.TempDir(), fmt.Sprintf("temp_%s", tempID))
+
+	// Create the temp directory
+	if err := os.MkdirAll(tempDir, 0755); err != nil {
+		return "", fmt.Errorf("failed to create temp directory: %w", err)
+	}
+
+	// Copy the source directory to the temp location
+	if err := copyDir(sourcePath, tempDir); err != nil {
+		return "", fmt.Errorf("failed to copy directory: %w", err)
+	}
+
+	// Initialize a new git repo in the copied location
+	cmd := exec.Command("git", "init")
+	cmd.Dir = tempDir
+	if err := cmd.Run(); err != nil {
+		return "", fmt.Errorf("failed to initialize git repo: %w", err)
+	}
+
+	// Add all files to the git repo
+	cmd = exec.Command("git", "add", ".")
+	cmd.Dir = tempDir
+	if err := cmd.Run(); err != nil {
+		return "", fmt.Errorf("failed to add files to git repo: %w", err)
+	}
+
+	// Commit the files
+	cmd = exec.Command("git", "commit", "-m", "Initial commit")
+	cmd.Dir = tempDir
+	if err := cmd.Run(); err != nil {
+		return "", fmt.Errorf("failed to commit files: %w", err)
+	}
+
+	// Create a zip file using git archive
+	zipFile := filepath.Join(os.TempDir(), fmt.Sprintf("archive_%s.zip", tempID))
+	cmd = exec.Command("git", "archive", "--format=zip", "-o", zipFile, "HEAD")
+	cmd.Dir = tempDir
+	if err := cmd.Run(); err != nil {
+		return "", fmt.Errorf("failed to create zip archive: %w", err)
+	}
+
+	return zipFile, nil
+}
+
+func copyDir(src, dst string) error {
+	return filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Skip .git directory
+		if info.IsDir() && info.Name() == ".git" {
+			return filepath.SkipDir
+		}
+
+		relPath, err := filepath.Rel(src, path)
+		if err != nil {
+			return err
+		}
+		dstPath := filepath.Join(dst, relPath)
+
+		if info.IsDir() {
+			return os.MkdirAll(dstPath, info.Mode())
+		}
+
+		return copyFile(path, dstPath)
+	})
+}
+
+func copyFile(src, dst string) error {
+	srcFile, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer srcFile.Close()
+
+	dstFile, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer dstFile.Close()
+
+	_, err = io.Copy(dstFile, srcFile)
+	return err
+}