Support package version update on any release branch (elastic#4843)

After we create release branches we still need to maintain the right
package and test versions using the Github action on demand.

Author: rdner

magefile.go

@@ -2049,8 +2049,13 @@ func (Integration) UpdateVersions(ctx context.Context) error {
 func (Integration) UpdatePackageVersion(ctx context.Context) error {
 	const packageVersionFilename = ".package-version"
 
+	currentReleaseBranch, err := git.GetCurrentReleaseBranch(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to identify the current release branch: %w", err)
+	}
+
 	sc := snapshots.NewSnapshotsClient()
-	versions, err := sc.FindLatestSnapshots(ctx, []string{"master"})
+	versions, err := sc.FindLatestSnapshots(ctx, []string{currentReleaseBranch})
 	if err != nil {
 		return fmt.Errorf("failed to fetch a manifest for the latest snapshot: %w", err)
 	}

pkg/testing/tools/git/git.go

@@ -6,65 +6,126 @@ package git
 
 import (
 	"bufio"
+	"bytes"
 	"context"
+	"errors"
 	"fmt"
+	"io"
 	"os/exec"
 	"regexp"
 )
 
 var (
+	ErrNotReleaseBranch = errors.New("this is not a release branch")
 	releaseBranchRegexp = regexp.MustCompile(`.*(\d+\.\d+)$`)
 )
 
+type outputReader func(io.Reader) error
+
 // GetReleaseBranches returns a list of release branches of the
 // current repository ordered descending by creation date.
 // e.g. 8.13, 8.12, etc.
 func GetReleaseBranches(ctx context.Context) ([]string, error) {
-	var seen = map[string]struct{}{}
-	branchList := []string{}
-
 	c := exec.CommandContext(ctx, "git", "branch", "-r", "--list", "*/[0-9]*.*[0-9]", "--sort=-creatordate")
 
-	r, err := c.StdoutPipe()
+	branchList := []string{}
+	err := runCommand(c, releaseBranchReader(&branchList))
 	if err != nil {
-		return nil, fmt.Errorf("failed to create the stdout pipe: %w", err)
+		return nil, err
 	}
-	defer r.Close()
 
-	err = c.Start()
+	return branchList, nil
+}
+
+// GetCurrentReleaseBranch returns the current branch of the repository
+func GetCurrentReleaseBranch(ctx context.Context) (string, error) {
+	c := exec.CommandContext(ctx, "git", "symbolic-ref", "--short", "HEAD")
+
+	var branch string
+	err := runCommand(c, fullOutputReader(&branch))
 	if err != nil {
-		return nil, fmt.Errorf("failed to start git command: %w", err)
+		return "", err
 	}
 
-	scanner := bufio.NewScanner(r)
-	for scanner.Scan() {
-		branch := scanner.Text()
-		if !releaseBranchRegexp.MatchString(branch) {
-			continue
+	// in the APIs the release branch is still called `master`
+	if branch == "main" {
+		return "master", nil
+	}
+
+	return extractReleaseBranch(branch)
+}
+
+func fullOutputReader(out *string) outputReader {
+	return func(r io.Reader) error {
+		b, err := io.ReadAll(r)
+		if err != nil {
+			return fmt.Errorf("failed to read the entire output: %w", err)
 		}
+		*out = string(bytes.TrimSpace(b))
+		return nil
+	}
+}
 
-		matches := releaseBranchRegexp.FindStringSubmatch(branch)
-		if len(matches) != 2 {
-			continue
+func releaseBranchReader(out *[]string) outputReader {
+	return func(r io.Reader) error {
+		var seen = map[string]struct{}{}
+		scanner := bufio.NewScanner(r)
+		for scanner.Scan() {
+			branch := scanner.Text()
+			branch, err := extractReleaseBranch(branch)
+			if err != nil {
+				continue
+			}
+			_, exists := seen[branch]
+			if exists {
+				continue
+			}
+			seen[branch] = struct{}{}
+			// appending to the list right away instead of
+			// collecting from the map later preserves the order
+			*out = append(*out, branch)
 		}
-		branch = matches[1]
-		_, exists := seen[branch]
-		if exists {
-			continue
+		if scanner.Err() != nil {
+			return fmt.Errorf("failed to scan the output: %w", scanner.Err())
 		}
-		seen[branch] = struct{}{}
-		// appending to the list right away instead of
-		// collecting from the map later preserves the order
-		branchList = append(branchList, branch)
+
+		return nil
 	}
-	if scanner.Err() != nil {
-		return nil, fmt.Errorf("failed to scan the output: %w", err)
+}
+
+func extractReleaseBranch(branch string) (string, error) {
+	if !releaseBranchRegexp.MatchString(branch) {
+		return "", fmt.Errorf("failed to process branch %q: %w", branch, ErrNotReleaseBranch)
+	}
+
+	matches := releaseBranchRegexp.FindStringSubmatch(branch)
+	if len(matches) != 2 {
+		return "", fmt.Errorf("failed to process branch %q: expected 2 matches, got %d", branch, len(matches))
+	}
+	return matches[1], nil
+}
+
+func runCommand(c *exec.Cmd, or outputReader) error {
+	r, err := c.StdoutPipe()
+	if err != nil {
+		return fmt.Errorf("failed to create the stdout pipe: %w", err)
+	}
+	defer r.Close()
+
+	err = c.Start()
+	if err != nil {
+		return fmt.Errorf("failed to start git command: %w", err)
+	}
+
+	err = or(r)
+	if err != nil {
+		return fmt.Errorf("failed to process the git command output: %w", err)
 	}
 
 	err = c.Wait()
 	if err != nil {
-		return nil, fmt.Errorf("failed to wait for the git command to finish: %w", err)
+		return fmt.Errorf("failed to wait for the git command to finish: %w", err)
 	}
 
-	return branchList, nil
+	return nil
 }