WIP

Signed-off-by: Francesco Romani <fromani@redhat.com>

Author: ffromani

Makefile.kni

@@ -90,3 +90,7 @@ verify-crdgen: update-vendor
 .PHONY: clean
 clean:
 	rm -rf ./bin
+
+.PHONY: build-tools
+build-tools:
+	go build -o bin/verify-commit-message hack-kni/tools/verify-commit-message.go

hack-kni/tools/verify-commit-message.go

@@ -0,0 +1,102 @@
+package main
+
+import (
+	"bufio"
+	"errors"
+	"log"
+	"os"
+	"strings"
+)
+
+const (
+	exitCodeSuccess                 = 0
+	exitCodeErrorWrongArguments     = 1
+	exitCodeErrorVerificationFailed = 2
+)
+
+const (
+	tagKNI = "[KNI]"
+
+	cherryPickLinePrefix = "(cherry picked from commit "
+	cherryPickLineSuffix = ")" // yes that simple
+)
+
+var (
+	errEmptyCommitMessage = errors.New("empty commit message")
+	errMissingTagKNI      = errors.New("missing tag: " + tagKNI)
+)
+
+type commitMessage struct {
+	lines []string
+}
+
+func newCommitMessageFromString(text string) commitMessage {
+	var cm commitMessage
+	scanner := bufio.NewScanner(strings.NewReader(text))
+	for scanner.Scan() {
+		cm.lines = append(cm.lines, scanner.Text())
+	}
+	log.Printf("commit message has %d lines", cm.NumLines())
+	return cm
+}
+
+func (cm commitMessage) NumLines() int {
+	return len(cm.lines)
+}
+
+func (cm commitMessage) IsEmpty() bool {
+	return cm.NumLines() == 0
+}
+
+func (cm commitMessage) Summary() string {
+	return cm.lines[0]
+}
+
+func (cm commitMessage) IsKNISpecific() bool {
+	return strings.Contains(cm.Summary(), tagKNI)
+}
+
+// CherryPickOrigin returns the commit hash this commit was cherry-picked
+// from if this commit has cherry-pick reference; otherwise returns empty string.
+func (cm commitMessage) CherryPickOrigin() string {
+	for idx := cm.NumLines() - 1; idx > 0; idx-- {
+		line := cm.lines[idx] // shortcut
+		cmHash, ok := strings.CutPrefix(line, cherryPickLinePrefix)
+		if !ok { // we don't have the prefix, so we don't care
+			continue
+		}
+		cmHash, ok = strings.CutSuffix(chHash, cherryPickLineSuffix)
+		if !ok { // we don't have the suffix, so we don't care
+			continue
+		}
+		return chMash
+	}
+	return "" // nothing found
+}
+
+func verifyCommitMessage(commitMessage string) error {
+	cm := newCommitMessageFromString(commitMessage)
+	if cm.IsEmpty() {
+		return errEmptyCommitMessage
+	}
+	if !cm.IsKNISpecific() {
+		return errMissingTagKNI
+	}
+	return nil
+}
+
+func main() {
+	if len(os.Args) != 2 {
+		programName := os.Args[0]
+		log.Printf("usage: %s wrong number of arguments expects: %s <commit-message>", programName, programName)
+		os.Exit(1)
+	}
+
+	err := verifyCommitMessage(os.Args[1])
+	if err != nil {
+		log.Printf("verification failed: %v", err)
+		os.Exit(2)
+	}
+
+	os.Exit(0) // all good! redundant but let's be explicit about our success
+}

hack-kni/tools/verify-commit-message_test.go

@@ -0,0 +1,102 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	goruntime "runtime"
+	"testing"
+)
+
+const (
+	binariesDir = "bin"
+	programName = "verify-commit-message"
+)
+
+func TestRunWithOnlyNewlines(t *testing.T) {
+	commitMessage := `
+
+
+
+
+
+`
+	_, errBuf, err := runCommand(t, commitMessage)
+	// run with empty commit message is unsupported and should fail
+	if err == nil {
+		t.Fatalf("Unexpectedly succeeded: %v (stderr=%s)\n", err, errBuf)
+	}
+	exitErr, ok := err.(*exec.ExitError)
+	if !ok {
+		t.Fatalf("Received unexpected error %T %v", err, err)
+	}
+	errCode := exitErr.ExitCode()
+	if errCode != exitCodeErrorVerificationFailed {
+		t.Fatalf("Received unexpected exit code %d", errCode)
+	}
+}
+
+func TestRunWithEmptyArgument(t *testing.T) {
+	_, errBuf, err := runCommand(t, "")
+	// run with empty commit message is unsupported and should fail
+	if err == nil {
+		t.Fatalf("Unexpectedly succeeded: %v (stderr=%s)\n", err, errBuf)
+	}
+	exitErr, ok := err.(*exec.ExitError)
+	if !ok {
+		t.Fatalf("Received unexpected error %T %v", err, err)
+	}
+	errCode := exitErr.ExitCode()
+	if errCode != exitCodeErrorVerificationFailed {
+		t.Fatalf("Received unexpected exit code %d", errCode)
+	}
+}
+
+func TestRunWithoutArguments(t *testing.T) {
+	_, errBuf, err := runCommand(t) // note no arguments intentionally
+	// run without arguments should fail
+	if err == nil {
+		t.Fatalf("Unexpectedly succeeded: %v (stderr=%s)\n", err, errBuf)
+	}
+	exitErr, ok := err.(*exec.ExitError)
+	if !ok {
+		t.Fatalf("Received unexpected error %T %v", err, err)
+	}
+	errCode := exitErr.ExitCode()
+	if errCode != exitCodeErrorWrongArguments {
+		t.Fatalf("Received unexpected exit code %d", errCode)
+	}
+}
+
+// runCommand returns stdout as string, stderr as string, error code
+func runCommand(t *testing.T, args ...string) (string, string, error) {
+	bin, err := getBinPath()
+	if err != nil {
+		t.Fatalf("failed to find the binary path: %v", err)
+	}
+	fmt.Printf("going to use %q\n", bin)
+	var errBuf bytes.Buffer
+	cmd := exec.Command(bin, args...)
+	cmd.Stderr = &errBuf
+	out, err := cmd.Output()
+	fmt.Printf("tool returned <%s>\n", out)
+	return string(out), errBuf.String(), err
+}
+
+func getBinPath() (string, error) {
+	rootDir, err := getRootPath()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(rootDir, binariesDir, programName), nil
+}
+
+func getRootPath() (string, error) {
+	_, file, _, ok := goruntime.Caller(0)
+	if !ok {
+		return "", fmt.Errorf("cannot retrieve tests directory")
+	}
+	basedir := filepath.Dir(file)
+	return filepath.Abs(filepath.Join(basedir, "..", ".."))
+}