Fixes for SHA vs branch vs HEAD checkout of templates

Signed-off-by: Alex Ellis (OpenFaaS Ltd) <[email protected]>

Author: alexellis

commands/fetch_templates.go

@@ -37,25 +37,28 @@ func fetchTemplates(templateURL, refName, templateName string, overwriteTemplate
 
 	log.Printf("Fetching templates from %s%s", templateURL, refMsg)
 
-	targetDir, err := os.MkdirTemp("", "openfaas-templates-*")
+	extractedPath, err := os.MkdirTemp("", "openfaas-templates-*")
 	if err != nil {
 		return fmt.Errorf("unable to create temporary directory: %s", err)
 	}
 
 	if !pullDebug {
-		defer os.RemoveAll(targetDir)
+		defer os.RemoveAll(extractedPath)
 	}
 
-	pullDebugPrint(fmt.Sprintf("Temp files in %s", targetDir))
+	pullDebugPrint(fmt.Sprintf("Temp files in %s", extractedPath))
 
-	args := map[string]string{"dir": targetDir, "repo": templateURL}
+	args := map[string]string{"dir": extractedPath, "repo": templateURL}
 	cmd := versioncontrol.GitCloneDefault
 
 	if len(refName) > 0 {
 		if strings.HasPrefix(refName, "sha-") {
 			cmd = versioncontrol.GitCloneFullDepth
 		} else {
 			args["refname"] = refName
+
+			cmd = versioncontrol.GitCloneBranch
+			args["refname"] = refName
 		}
 	}
 
@@ -64,12 +67,12 @@ func fetchTemplates(templateURL, refName, templateName string, overwriteTemplate
 	}
 
 	if len(refName) > 0 && strings.HasPrefix(refName, "sha-") {
+
 		targetCommit := strings.TrimPrefix(refName, "sha-")
-		checkoutArgs := []string{"-C", targetDir, "checkout", targetCommit}
 
 		t := execute.ExecTask{
 			Command: "git",
-			Args:    checkoutArgs,
+			Args:    []string{"-C", extractedPath, "checkout", targetCommit},
 		}
 		res, err := t.Execute(context.Background())
 		if err != nil {
@@ -79,16 +82,35 @@ func fetchTemplates(templateURL, refName, templateName string, overwriteTemplate
 			out := res.Stdout + " " + res.Stderr
 			return fmt.Errorf("error checking out ref %s: %s", targetCommit, out)
 		}
-
 	}
 
+	task := execute.ExecTask{
+		Command: "git",
+		Args:    []string{"-C", extractedPath, "log", "-1"},
+	}
+	res, err := task.Execute(context.Background())
+	if err != nil {
+		return fmt.Errorf("error getting git log: %w", err)
+	}
+	log.Printf("Git log: %s", res.Stdout)
 	// Get the long SHA digest from the clone repository.
-	sha, err := versioncontrol.GetGitSHAFor(targetDir, false)
+	sha, err := versioncontrol.GetGitSHAFor(extractedPath, false)
 	if err != nil {
 		return err
 	}
 
-	protectedLanguages, fetchedLanguages, err := moveTemplates(targetDir, templateName, overwriteTemplates, templateURL, refName, sha)
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("can't get current working directory: %s", err)
+	}
+	localTemplatesDir := filepath.Join(cwd, TemplateDirectory)
+	if _, err := os.Stat(localTemplatesDir); err != nil && os.IsNotExist(err) {
+		if err := os.MkdirAll(localTemplatesDir, 0755); err != nil {
+			return fmt.Errorf("can't create template directory: %s", err)
+		}
+	}
+
+	protectedLanguages, fetchedLanguages, err := moveTemplates(localTemplatesDir, extractedPath, templateName, overwriteTemplates, templateURL, refName, sha)
 	if err != nil {
 		return err
 	}
@@ -116,7 +138,7 @@ func canWriteLanguage(existingLanguages []string, language string, overwriteTemp
 // moveTemplates moves the templates from the repository to the template directory
 // It returns the existing languages and the fetched languages
 // It also returns an error if the templates cannot be read
-func moveTemplates(repoPath, templateName string, overwriteTemplate bool, repository string, refName string, sha string) ([]string, []string, error) {
+func moveTemplates(localTemplatesDir, extractedPath, templateName string, overwriteTemplate bool, repository string, refName string, sha string) ([]string, []string, error) {
 
 	var (
 		existingLanguages  []string
@@ -125,21 +147,9 @@ func moveTemplates(repoPath, templateName string, overwriteTemplate bool, reposi
 		err                error
 	)
 
-	cwd, err := os.Getwd()
-	if err != nil {
-		return nil, nil, fmt.Errorf("can't get current working directory: %s", err)
-	}
-
-	destTemplatePath := filepath.Join(cwd, TemplateDirectory)
-	if _, err := os.Stat(destTemplatePath); err != nil && os.IsNotExist(err) {
-		if err := os.MkdirAll(destTemplatePath, 0755); err != nil {
-			return nil, nil, fmt.Errorf("can't create template directory: %s", err)
-		}
-	}
-
-	templateEntries, err := os.ReadDir(destTemplatePath)
+	templateEntries, err := os.ReadDir(localTemplatesDir)
 	if err != nil {
-		return nil, nil, fmt.Errorf("unable to read directory: %s", destTemplatePath)
+		return nil, nil, fmt.Errorf("unable to read directory: %s", localTemplatesDir)
 	}
 
 	// OK if nothing exists yet
@@ -148,17 +158,17 @@ func moveTemplates(repoPath, templateName string, overwriteTemplate bool, reposi
 			continue
 		}
 
-		templateFile := filepath.Join(destTemplatePath, entry.Name(), "template.yml")
+		templateFile := filepath.Join(localTemplatesDir, entry.Name(), "template.yml")
 		if _, err := os.Stat(templateFile); err != nil && !os.IsNotExist(err) {
 			return nil, nil, fmt.Errorf("can't find template.yml in: %s", templateFile)
 		}
 
 		existingLanguages = append(existingLanguages, entry.Name())
 	}
 
-	extractedTemplates, err := os.ReadDir(filepath.Join(repoPath, TemplateDirectory))
+	extractedTemplates, err := os.ReadDir(filepath.Join(extractedPath, TemplateDirectory))
 	if err != nil {
-		return nil, nil, fmt.Errorf("can't find templates in: %s", filepath.Join(repoPath, TemplateDirectory))
+		return nil, nil, fmt.Errorf("can't find templates in: %s", filepath.Join(extractedPath, TemplateDirectory))
 	}
 
 	for _, entry := range extractedTemplates {
@@ -173,8 +183,8 @@ func moveTemplates(repoPath, templateName string, overwriteTemplate bool, reposi
 
 		if canWriteLanguage(existingLanguages, language, overwriteTemplate) {
 			// Do cp here
-			languageSrc := filepath.Join(repoPath, TemplateDirectory, language)
-			languageDest := filepath.Join(destTemplatePath, language)
+			languageSrc := filepath.Join(extractedPath, TemplateDirectory, language)
+			languageDest := filepath.Join(localTemplatesDir, language)
 			langName := language
 			if refName != "" {
 				languageDest += "@" + refName

commands/template_store_pull.go

@@ -72,6 +72,7 @@ func runTemplateStorePull(cmd *cobra.Command, args []string) error {
 			break
 		}
 	}
+
 	if !found {
 		return fmt.Errorf("template with name: `%s` does not exist in the repo", templateName)
 	}

versioncontrol/core.go

@@ -5,6 +5,7 @@ package versioncontrol
 import (
 	"bytes"
 	"fmt"
+	"log"
 	"os"
 	"os/exec"
 	"strings"
@@ -48,6 +49,7 @@ func (v *vcsCmd) run(dir string, cmdline string, keyval map[string]string, verbo
 		return nil, err
 	}
 
+	log.Printf("[git] Running command: %s %s", v.cmd, strings.Join(args, " "))
 	cmd := exec.Command(v.cmd, args...)
 	cmd.Dir = dir
 	cmd.Env = envWithPWD(cmd.Dir)

versioncontrol/git.go

@@ -7,31 +7,32 @@ import (
 	"github.com/openfaas/faas-cli/exec"
 )
 
-// GitClone defines the command to clone a repo into a directory
-var GitClone = &vcsCmd{
+// GitCloneBranch clones a specific branch of a repo into a directory
+var GitCloneBranch = &vcsCmd{
 	name:   "Git",
 	cmd:    "git",
 	cmds:   []string{"clone {repo} {dir} --depth=1 --config core.autocrlf=false -b {refname}"},
 	scheme: []string{"git", "https", "http", "git+ssh", "ssh"},
 }
 
-// GitCloneFullDepth defines the command to clone a repo into a directory with full depth
+// GitCloneFullDepth clones a repo into a directory with full depth so that a
+// SHA can be checked out after
 var GitCloneFullDepth = &vcsCmd{
 	name:   "Git",
 	cmd:    "git",
 	cmds:   []string{"clone {repo} {dir} --config core.autocrlf=false"},
 	scheme: []string{"git", "https", "http", "git+ssh", "ssh"},
 }
 
-// GitClone defines the command to clone the default branch of a repo into a directory
+// GitCloneDefault clones the default branch of a repo into a directory
 var GitCloneDefault = &vcsCmd{
 	name:   "Git",
 	cmd:    "git",
 	cmds:   []string{"clone {repo} {dir} --depth=1 --config core.autocrlf=false"},
 	scheme: []string{"git", "https", "http", "git+ssh", "ssh"},
 }
 
-// GitCheckout defines the command to clone a specific REF of repo into a directory
+// GitCheckout checks out a specific REF of a repo into a directory
 var GitCheckout = &vcsCmd{
 	name:   "Git",
 	cmd:    "git",