sigs.k8s.io/release-sdk@v0.11.1-0.20240417074027-8061fb5e4952/git/git.go

/*
Copyright 2019 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package git

import (
	"bufio"
	"bytes"
	"errors"
	"fmt"
	"io"
	"math"
	"net/url"
	"os"
	"path/filepath"
	"regexp"
	"sort"
	"strings"
	"time"

	"github.com/blang/semver/v4"
	"github.com/go-git/go-git/v5"
	"github.com/go-git/go-git/v5/config"
	"github.com/go-git/go-git/v5/plumbing"
	"github.com/go-git/go-git/v5/plumbing/object"
	"github.com/go-git/go-git/v5/plumbing/storer"
	"github.com/sirupsen/logrus"

	"sigs.k8s.io/release-sdk/regex"
	"sigs.k8s.io/release-utils/command"
	"sigs.k8s.io/release-utils/util"
)

const (
	// DefaultGithubOrg is the default GitHub org used for Kubernetes project
	// repos
	DefaultGithubOrg = "kubernetes"

	// DefaultGithubRepo is the default git repository
	DefaultGithubRepo = "kubernetes"

	// DefaultGithubReleaseRepo is the default git repository used for
	// SIG Release
	DefaultGithubReleaseRepo = "sig-release"

	// DefaultRemote is the default git remote name
	DefaultRemote = "origin"

	// DefaultRef is the default git reference name
	DefaultRef = "HEAD"

	// DefaultBranch is the default branch name
	DefaultBranch = "master"

	// DefaultGitUser is the default user name used for commits.
	DefaultGitUser = "Kubernetes Release Robot"

	// DefaultGitEmail is the default email used for commits.
	DefaultGitEmail = "k8s-release-robot@users.noreply.github.com"

	defaultGithubAuthRoot = "git@github.com:"
	gitExecutable         = "git"
	releaseBranchPrefix   = "release-"
)

// setVerboseTrace enables maximum verbosity output.
func setVerboseTrace() error {
	if err := setVerbose(5, 2, 2, 2, 2, 2, 2, 2); err != nil {
		return fmt.Errorf("set verbose: %w", err)
	}
	return nil
}

// setVerboseDebug enables a higher verbosity output for git.
func setVerboseDebug() error {
	if err := setVerbose(2, 2, 2, 0, 0, 0, 2, 0); err != nil {
		return fmt.Errorf("set verbose: %w", err)
	}
	return nil
}

// setVerbose changes the git verbosity output.
func setVerbose(
	merge,
	curl,
	trace,
	tracePackAccess,
	tracePacket,
	tracePerformance,
	traceSetup,
	traceShallow uint,
) error {
	// Possible values taken from:
	// https://git-scm.com/book/en/v2/Git-Internals-Environment-Variables#Debugging
	for key, value := range map[string]string{
		// Controls the output for the recursive merge strategy. The allowed
		// values are as follows:
		// 0 outputs nothing, except possibly a single error message.
		// 1 shows only conflicts.
		// 2 also shows file changes.
		// 3 shows when files are skipped because they haven’t changed.
		// 4 shows all paths as they are processed.
		// 5 and above show detailed debugging information.
		// The default value is 2.
		"GIT_MERGE_VERBOSITY": fmt.Sprint(merge),

		// Git uses the curl library to do network operations over HTTP, so
		// GIT_CURL_VERBOSE tells Git to emit all the messages generated by
		// that library. This is similar to doing curl -v on the command line.
		"GIT_CURL_VERBOSE": fmt.Sprint(curl),

		// Controls general traces, which don’t fit into any specific category.
		// This includes the expansion of aliases, and delegation to other
		// sub-programs.
		"GIT_TRACE": fmt.Sprint(trace),

		// Controls tracing of packfile access. The first field is the packfile
		// being accessed, the second is the offset within that file.
		"GIT_TRACE_PACK_ACCESS": fmt.Sprint(tracePackAccess),

		// Enables packet-level tracing for network operations.
		"GIT_TRACE_PACKET": fmt.Sprint(tracePacket),

		// Controls logging of performance data. The output shows how long each
		// particular git invocation takes.
		"GIT_TRACE_PERFORMANCE": fmt.Sprint(tracePerformance),

		// Shows information about what Git is discovering about the repository
		// and environment it’s interacting with.
		"GIT_TRACE_SETUP": fmt.Sprint(traceSetup),

		// Debugging fetching/cloning of shallow repositories.
		"GIT_TRACE_SHALLOW": fmt.Sprint(traceShallow),
	} {
		if err := os.Setenv(key, value); err != nil {
			return fmt.Errorf("unable to set %s=%s: %w", key, value, err)
		}
	}
	return nil
}

// GetDefaultKubernetesRepoURL returns the default HTTPS repo URL for Kubernetes.
// Expected: https://github.com/kubernetes/kubernetes
func GetDefaultKubernetesRepoURL() string {
	return GetKubernetesRepoURL(DefaultGithubOrg, false)
}

// GetKubernetesRepoURL takes a GitHub org and repo, and useSSH as a boolean and
// returns a repo URL for Kubernetes.
// Expected result is one of the following:
// - https://github.com/<org>/kubernetes
// - git@github.com:<org>/kubernetes
func GetKubernetesRepoURL(org string, useSSH bool) string {
	if org == "" {
		org = DefaultGithubOrg
	}

	return GetRepoURL(org, DefaultGithubRepo, useSSH)
}

// GetRepoURL takes a GitHub org and repo, and useSSH as a boolean and
// returns a repo URL for the specified repo.
// Expected result is one of the following:
// - https://github.com/<org>/<repo>
// - git@github.com:<org>/<repo>
func GetRepoURL(org, repo string, useSSH bool) (repoURL string) {
	slug := filepath.Join(org, repo)

	if useSSH {
		repoURL = fmt.Sprintf("%s%s", defaultGithubAuthRoot, slug)
	} else {
		repoURL = (&url.URL{
			Scheme: "https",
			Host:   "github.com",
			Path:   slug,
		}).String()
	}

	return repoURL
}

// ConfigureGlobalDefaultUserAndEmail globally configures the default git
// user and email.
func ConfigureGlobalDefaultUserAndEmail() error {
	if err := filterCommand(
		"", "config", "--global", "user.name", DefaultGitUser,
	).RunSuccess(); err != nil {
		return fmt.Errorf("configure user name: %w", err)
	}

	if err := filterCommand(
		"", "config", "--global", "user.email", DefaultGitEmail,
	).RunSuccess(); err != nil {
		return fmt.Errorf("configure user email: %w", err)
	}

	return nil
}

// ConfigureGlobalCustomUserAndEmail globally configures a custom git
// user and email.
func ConfigureGlobalCustomUserAndEmail(gitUser, gitEmail string) error {
	if err := filterCommand(
		"", "config", "--global", "user.name", gitUser,
	).RunSuccess(); err != nil {
		return fmt.Errorf("configure user name: %w", err)
	}

	if err := filterCommand(
		"", "config", "--global", "user.email", gitEmail,
	).RunSuccess(); err != nil {
		return fmt.Errorf("configure user email: %w", err)
	}

	return nil
}

// filterCommand returns a command which automatically filters sensitive information.
func filterCommand(workdir string, args ...string) *command.Command {
	// Filter GitHub API keys
	c, err := command.NewWithWorkDir(
		workdir, gitExecutable, args...,
	).Filter(`(?m)git:[0-9a-zA-Z]{35,40}`, "[REDACTED]")
	if err != nil {
		// should never happen
		logrus.Fatalf("git command creation failed: %v", err)
	}

	return c
}

// DiscoverResult is the result of a revision discovery
type DiscoverResult struct {
	startSHA, startRev, endSHA, endRev string
}

// StartSHA returns the start SHA for the DiscoverResult
func (d *DiscoverResult) StartSHA() string {
	return d.startSHA
}

// StartRev returns the start revision for the DiscoverResult
func (d *DiscoverResult) StartRev() string {
	return d.startRev
}

// EndSHA returns the end SHA for the DiscoverResult
func (d *DiscoverResult) EndSHA() string {
	return d.endSHA
}

// EndRev returns the end revision for the DiscoverResult
func (d *DiscoverResult) EndRev() string {
	return d.endRev
}

// Remote is a representation of a git remote location
type Remote struct {
	name string
	urls []string
}

// NewRemote creates a new remote for the provided name and URLs
func NewRemote(name string, urls []string) *Remote {
	return &Remote{name, urls}
}

// Name returns the name of the remote
func (r *Remote) Name() string {
	return r.name
}

// URLs returns all available URLs of the remote
func (r *Remote) URLs() []string {
	return r.urls
}

// Repo is a wrapper for a Kubernetes repository instance
type Repo struct {
	inner      Repository
	worktree   Worktree
	dir        string
	dryRun     bool
	maxRetries int
}

//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate
//go:generate /usr/bin/env bash -c "cat ../scripts/boilerplate/boilerplate.generatego.txt gitfakes/fake_repository.go > gitfakes/_fake_repository.go && mv gitfakes/_fake_repository.go gitfakes/fake_repository.go"
//go:generate /usr/bin/env bash -c "cat ../scripts/boilerplate/boilerplate.generatego.txt gitfakes/fake_worktree.go > gitfakes/_fake_worktree.go && mv gitfakes/_fake_worktree.go gitfakes/fake_worktree.go"

// Repository is the main interface to the git.Repository functionality
//
//counterfeiter:generate . Repository
type Repository interface {
	CreateTag(string, plumbing.Hash, *git.CreateTagOptions) (*plumbing.Reference, error)
	Branches() (storer.ReferenceIter, error)
	CommitObject(plumbing.Hash) (*object.Commit, error)
	CreateRemote(*config.RemoteConfig) (*git.Remote, error)
	DeleteRemote(name string) error
	Push(o *git.PushOptions) error
	Head() (*plumbing.Reference, error)
	Remote(string) (*git.Remote, error)
	Remotes() ([]*git.Remote, error)
	ResolveRevision(plumbing.Revision) (*plumbing.Hash, error)
	Tags() (storer.ReferenceIter, error)
}

// Worktree is the main interface to the git.Worktree functionality
//
//counterfeiter:generate . Worktree
type Worktree interface {
	Add(string) (plumbing.Hash, error)
	Commit(string, *git.CommitOptions) (plumbing.Hash, error)
	Checkout(*git.CheckoutOptions) error
	Status() (git.Status, error)
}

// Dir returns the directory where the repository is stored on disk
func (r *Repo) Dir() string {
	return r.dir
}

// SetDry sets the repo to dry-run mode, which does not modify any remote locations
// at all.
func (r *Repo) SetDry() {
	r.dryRun = true
}

// SetWorktree can be used to manually set the repository worktree
func (r *Repo) SetWorktree(worktree Worktree) {
	r.worktree = worktree
}

// SetInnerRepo can be used to manually set the inner repository
func (r *Repo) SetInnerRepo(repo Repository) {
	r.inner = repo
}

// SetMaxRetries defines the number of times, the git client will retry
// some operations when timing out or network failures. Setting it to
// 0 disables retrying
func (r *Repo) SetMaxRetries(numRetries int) {
	r.maxRetries = numRetries
}

func LSRemoteExec(repoURL string, args ...string) (string, error) {
	cmdArgs := append([]string{"ls-remote", "--", repoURL}, args...)
	cmdStatus, err := filterCommand("", cmdArgs...).
		RunSilentSuccessOutput()
	if err != nil {
		return "", fmt.Errorf("failed to execute the ls-remote command: %w", err)
	}

	return strings.TrimSpace(cmdStatus.Output()), nil
}

// CloneOrOpenDefaultGitHubRepoSSH clones the default Kubernetes GitHub
// repository via SSH if the repoPath is empty, otherwise updates it at the
// expected repoPath.
func CloneOrOpenDefaultGitHubRepoSSH(repoPath string) (*Repo, error) {
	return CloneOrOpenGitHubRepo(
		repoPath, DefaultGithubOrg, DefaultGithubRepo, true,
	)
}

// CleanCloneGitHubRepo creates a guaranteed fresh checkout of a given repository. The returned *Repo has a Cleanup()
// method that should be used to delete the repository on-disk afterwards.
func CleanCloneGitHubRepo(owner, repo string, useSSH, updateRepo bool, opts *git.CloneOptions) (*Repo, error) {
	repoURL := GetRepoURL(owner, repo, useSSH)
	// The use of a blank string for the repo path triggers special behaviour in CloneOrOpenRepo that causes a true
	// temporary directory with a random name to be created.
	return CloneOrOpenRepo("", repoURL, useSSH, updateRepo, opts)
}

// CloneOrOpenGitHubRepo works with a repository in the given directory, or creates one if the directory is empty. The
// repo uses the provided GitHub repository via the owner and repo. If useSSH is true, then it will clone the
// repository using the defaultGithubAuthRoot.
func CloneOrOpenGitHubRepo(repoPath, owner, repo string, useSSH bool) (*Repo, error) {
	repoURL := GetRepoURL(owner, repo, useSSH)
	return CloneOrOpenRepo(repoPath, repoURL, useSSH, true, nil)
}

// ShallowCleanCloneGitHubRepo creates a guaranteed fresh checkout of a GitHub
// repository. The returned *Repo has a Cleanup() method that should be used to
// delete the repository on-disk after it is no longer needed.
func ShallowCleanCloneGitHubRepo(owner, repo string, useSSH bool) (*Repo, error) {
	repoURL := GetRepoURL(owner, repo, useSSH)
	// Pass a blank string to ensure a temp directory gets created
	return ShallowCloneOrOpenRepo("", repoURL, useSSH)
}

// ShallowCloneOrOpenGitHubRepo this is the *GitHub* counterpart of
// ShallowCloneOrOpenRepo. It works exactly the same but it takes a
// GitHub org and repo instead of a URL
func ShallowCloneOrOpenGitHubRepo(owner, repoPath string, useSSH bool) (*Repo, error) {
	repoURL := GetRepoURL(owner, repoPath, useSSH)
	return ShallowCloneOrOpenRepo(repoPath, repoURL, useSSH)
}

// ShallowCloneOrOpenRepo clones performs a shallow clone of a repository (a
// clone of depth 1). It is almost identical to CloneOrOpenRepo. If a
// repository already exists in repoPath, then no clone is done and the function
// returns the existing repository.
func ShallowCloneOrOpenRepo(repoPath, repoURL string, useSSH bool) (*Repo, error) { //nolint: revive
	return cloneOrOpenRepo(repoPath, repoURL, true, &git.CloneOptions{Depth: 1})
}

// CloneOrOpenRepo creates a temp directory containing the provided
// GitHub repository via the url.
//
// If a repoPath is given, then the function tries to update the repository.
//
// The function returns the repository if cloning or updating of the repository
// was successful, otherwise an error.
func CloneOrOpenRepo(repoPath, repoURL string, useSSH, updateRepo bool, opts *git.CloneOptions) (*Repo, error) { //nolint: revive
	return cloneOrOpenRepo(repoPath, repoURL, updateRepo, opts)
}

// cloneOrOpenRepo checks that the repoPath exists or creates it before running the
// clone operation and connects the clone progress writer to our logging system
// if needed. This function is the core of the *CloneOrOpenRepo functions.
func cloneOrOpenRepo(repoPath, repoURL string, updateRepository bool, opts *git.CloneOptions) (*Repo, error) {
	// Ensure we have a directory path
	targetDir, preexisting, err := ensureRepoPath(repoPath)
	if err != nil {
		return nil, fmt.Errorf("ensuring repository path: %w", err)
	}

	// If the repo already exists, just update it
	if preexisting {
		return updateRepo(targetDir, true)
	}

	if opts == nil {
		opts = &git.CloneOptions{}
	}

	progressBuffer := &bytes.Buffer{}
	progressWriters := []io.Writer{progressBuffer}

	// Preserve any progresswriters already defined
	if opts.Progress != nil {
		progressWriters = append(progressWriters, opts.Progress)
	}

	// Only output the clone progress on debug or trace level,
	// otherwise it's too boring.
	logLevel := logrus.StandardLogger().Level
	if logLevel >= logrus.DebugLevel {
		progressWriters = append(progressWriters, os.Stderr)
	}

	opts.Progress = io.MultiWriter(progressWriters...)

	if err := cloneRepository(repoURL, targetDir, opts); err != nil {
		if logLevel < logrus.DebugLevel {
			logrus.Errorf(
				"Clone repository failed. Tracked progress:\n%s",
				progressBuffer.String(),
			)
		}
		return nil, err
	}

	return updateRepo(targetDir, updateRepository)
}

// cloneRepository is a utility function that exposes the bare git clone
// operation internally.
func cloneRepository(repoURL, repoPath string, opts *git.CloneOptions) error {
	// We always clone to the repo defined in the arguments
	if opts == nil {
		opts = &git.CloneOptions{}
	}
	opts.URL = repoURL
	if _, err := git.PlainClone(repoPath, false, opts); err != nil {
		return fmt.Errorf("unable to clone repo: %w", err)
	}
	return nil
}

// ensureRepoPath makes sure the repository path points to a valid directory. If
// the path is an empty string, it will create a temporary directory. If it already
// exists it will return exisitingDir set to true, a bool to let other functions
// know its ok not to clone it again.
func ensureRepoPath(repoPath string) (targetDir string, exisitingDir bool, err error) {
	if repoPath != "" {
		logrus.Debugf("Using existing repository path %q", repoPath)
		_, err := os.Stat(repoPath)

		switch {
		case err == nil:
			// The file or directory exists, just try to update the repo
			return repoPath, true, nil
		case os.IsNotExist(err):
			// The directory does not exists, we still have to clone it
			targetDir = repoPath
		default:
			// Something else bad happened
			return "", false, fmt.Errorf("reading existing directory: %w", err)
		}
	} else {
		// No repoPath given, use a random temp dir instead
		t, err := os.MkdirTemp("", "k8s-")
		if err != nil {
			return "", false, fmt.Errorf("unable to create temp dir: %w", err)
		}
		targetDir = t
		logrus.Debugf("Cloning to temporary directory %q", t)
	}
	return targetDir, false, nil
}

// updateRepo tries to open the provided repoPath and fetches the latest
// changes from the configured remote location
func updateRepo(repoPath string, updateRepository bool) (*Repo, error) {
	r, err := OpenRepo(repoPath)
	if err != nil {
		return nil, err
	}

	if updateRepository {
		// Update the repo
		if err := filterCommand(
			r.Dir(), "pull", "--rebase",
		).RunSilentSuccess(); err != nil {
			return nil, fmt.Errorf("unable to pull from remote: %w", err)
		}
	}

	return r, nil
}

// OpenRepo tries to open the provided repoPath
func OpenRepo(repoPath string) (*Repo, error) {
	if !command.Available(gitExecutable) {
		return nil, fmt.Errorf(
			"%s executable is not available in $PATH", gitExecutable,
		)
	}
	logLevel := logrus.StandardLogger().Level
	if logLevel == logrus.DebugLevel {
		logrus.Info("Setting verbose git output (debug)")
		if err := setVerboseDebug(); err != nil {
			return nil, fmt.Errorf("set debug output: %w", err)
		}
	} else if logLevel == logrus.TraceLevel {
		logrus.Info("Setting verbose git output (trace)")
		if err := setVerboseTrace(); err != nil {
			return nil, fmt.Errorf("set trace output: %w", err)
		}
	}

	if strings.HasPrefix(repoPath, "~/") {
		repoPath = os.Getenv("HOME") + repoPath[1:]
		logrus.Warnf("Normalizing repository to: %s", repoPath)
	}

	r, err := git.PlainOpenWithOptions(
		repoPath, &git.PlainOpenOptions{DetectDotGit: true},
	)
	if err != nil {
		return nil, fmt.Errorf("opening repo: %w", err)
	}

	worktree, err := r.Worktree()
	if err != nil {
		return nil, fmt.Errorf("getting repository worktree: %w", err)
	}

	return &Repo{
		inner:    r,
		worktree: worktree,
		dir:      worktree.Filesystem.Root(),
	}, nil
}

func (r *Repo) Cleanup() error {
	logrus.Debugf("Deleting %s", r.dir)
	return os.RemoveAll(r.dir)
}

// RevParseTag parses a git revision and returns a SHA1 on success, otherwise an
// error.
// If the revision does not match a tag add the remote origin in the revision.
func (r *Repo) RevParseTag(rev string) (string, error) {
	matched, err := regexp.MatchString(`v\d+\.\d+\.\d+.*`, rev)
	if err != nil {
		return "", err
	}
	if !matched {
		// Prefix all non-tags the default remote "origin"
		rev = Remotify(rev)
	}

	// Try to resolve the rev
	ref, err := r.inner.ResolveRevision(plumbing.Revision(rev))
	if err != nil {
		return "", err
	}

	return ref.String(), nil
}

// RevParse parses a git revision and returns a SHA1 on success, otherwise an
// error.
func (r *Repo) RevParse(rev string) (string, error) {
	// Try to resolve the rev
	ref, err := r.inner.ResolveRevision(plumbing.Revision(rev))
	if err != nil {
		return "", err
	}

	return ref.String(), nil
}

// RevParseTagShort parses a git revision and returns a SHA1 trimmed to the length
// 10 on success, otherwise an error.
// If the revision does not match a tag add the remote origin in the revision.
func (r *Repo) RevParseTagShort(rev string) (string, error) {
	fullRev, err := r.RevParseTag(rev)
	if err != nil {
		return "", err
	}

	return fullRev[:10], nil
}

// RevParseShort parses a git revision and returns a SHA1 trimmed to the length
// 10 on success, otherwise an error.
func (r *Repo) RevParseShort(rev string) (string, error) {
	fullRev, err := r.RevParse(rev)
	if err != nil {
		return "", err
	}

	return fullRev[:10], nil
}

// LatestReleaseBranchMergeBaseToLatest tries to discover the start (latest
// v1.x.0 merge base) and end (release-1.(x+1) or DefaultBranch) revision inside the
// repository.
func (r *Repo) LatestReleaseBranchMergeBaseToLatest() (DiscoverResult, error) {
	// Find the last non patch version tag, then resolve its revision
	versions, err := r.latestNonPatchFinalVersions()
	if err != nil {
		return DiscoverResult{}, err
	}
	version := versions[0]
	versionTag := util.SemverToTagString(version)
	logrus.Debugf("Latest non patch version %s", versionTag)

	base, err := r.MergeBase(
		DefaultBranch,
		semverToReleaseBranch(version),
	)
	if err != nil {
		return DiscoverResult{}, err
	}

	// If a release branch exists for the next version, we use it. Otherwise we
	// fallback to the DefaultBranch.
	end, branch, err := r.releaseBranchOrMainRef(version.Major, version.Minor+1)
	if err != nil {
		return DiscoverResult{}, err
	}

	return DiscoverResult{
		startSHA: base,
		startRev: versionTag,
		endSHA:   end,
		endRev:   branch,
	}, nil
}

func (r *Repo) LatestNonPatchFinalToMinor() (DiscoverResult, error) {
	// Find the last non patch version tag, then resolve its revision
	versions, err := r.latestNonPatchFinalVersions()
	if err != nil {
		return DiscoverResult{}, err
	}
	if len(versions) < 2 {
		return DiscoverResult{}, errors.New("unable to find two latest non patch versions")
	}

	latestVersion := versions[0]
	latestVersionTag := util.SemverToTagString(latestVersion)
	logrus.Debugf("Latest non patch version %s", latestVersionTag)
	end, err := r.RevParseTag(latestVersionTag)
	if err != nil {
		return DiscoverResult{}, err
	}

	previousVersion := versions[1]
	previousVersionTag := util.SemverToTagString(previousVersion)
	logrus.Debugf("Previous non patch version %s", previousVersionTag)
	start, err := r.RevParseTag(previousVersionTag)
	if err != nil {
		return DiscoverResult{}, err
	}

	return DiscoverResult{
		startSHA: start,
		startRev: previousVersionTag,
		endSHA:   end,
		endRev:   latestVersionTag,
	}, nil
}

func (r *Repo) latestNonPatchFinalVersions() ([]semver.Version, error) {
	latestVersions := []semver.Version{}

	tags, err := r.inner.Tags()
	if err != nil {
		return nil, err
	}

	_ = tags.ForEach(func(t *plumbing.Reference) error { //nolint: errcheck
		ver, err := util.TagStringToSemver(t.Name().Short())

		if err == nil {
			// We're searching for the latest, non patch final tag
			if ver.Patch == 0 && len(ver.Pre) == 0 {
				if len(latestVersions) == 0 || ver.GT(latestVersions[0]) {
					latestVersions = append([]semver.Version{ver}, latestVersions...)
				}
			}
		}
		return nil
	})
	if len(latestVersions) == 0 {
		return nil, fmt.Errorf("unable to find latest non patch release")
	}
	return latestVersions, nil
}

func (r *Repo) releaseBranchOrMainRef(major, minor uint64) (sha, rev string, err error) {
	relBranch := fmt.Sprintf("%s%d.%d", releaseBranchPrefix, major, minor)
	sha, err = r.RevParseTag(relBranch)
	if err == nil {
		logrus.Debugf("Found release branch %s", relBranch)
		return sha, relBranch, nil
	}

	sha, err = r.RevParseTag(DefaultBranch)
	if err == nil {
		logrus.Debugf("No release branch found, using %s", DefaultBranch)
		return sha, DefaultBranch, nil
	}

	return "", "", err
}

// HasBranch checks if a branch exists in the repo
func (r *Repo) HasBranch(branch string) (branchExists bool, err error) {
	logrus.Infof("Verifying %s branch exists in the repo", branch)

	branches, err := r.inner.Branches()
	if err != nil {
		return branchExists, fmt.Errorf("getting branches from repository: %w", err)
	}

	branchExists = false
	if err := branches.ForEach(func(ref *plumbing.Reference) error {
		if ref.Name().Short() == branch {
			logrus.Infof("Branch %s found in the repository", branch)
			branchExists = true
		}
		return nil
	}); err != nil {
		return branchExists, fmt.Errorf("iterating branches to check for existence: %w", err)
	}
	return branchExists, nil
}

// HasRemoteBranch takes a branch string and verifies that it exists
// on the default remote
func (r *Repo) HasRemoteBranch(branch string) (branchExists bool, err error) {
	logrus.Infof("Verifying %s branch exists on the remote", branch)

	branches, err := r.RemoteBranches()
	if err != nil {
		return false, fmt.Errorf("get remote branches: %w", err)
	}

	for _, remoteBranch := range branches {
		if remoteBranch == branch {
			logrus.Infof("Found branch %s", branch)
			return true, nil
		}
	}
	logrus.Infof("Branch %s not found", branch)
	return false, nil
}

// RemoteBranches returns a list of all remotely available branches.
func (r *Repo) RemoteBranches() (branches []string, err error) {
	remote, err := r.inner.Remote(DefaultRemote)
	if err != nil {
		return nil, NewNetworkError(err)
	}
	var refs []*plumbing.Reference
	for i := r.maxRetries + 1; i > 0; i-- {
		// We can then use every Remote functions to retrieve wanted information
		refs, err = remote.List(&git.ListOptions{})
		if err == nil {
			break
		}
		logrus.Warn("Could not list references on the remote repository.")
		// Convert to network error to see if we can retry the push
		err = NewNetworkError(err)
		if !err.(NetworkError).CanRetry() || r.maxRetries == 0 || i == 1 {
			return nil, err
		}
		waitTime := math.Pow(2, float64(r.maxRetries-i))
		logrus.Errorf(
			"Error listing remote references (will retry %d more times in %.0f secs): %s",
			i-1, waitTime, err.Error(),
		)
		time.Sleep(time.Duration(waitTime) * time.Second)
	}

	for _, ref := range refs {
		if ref.Name().IsBranch() {
			branches = append(branches, ref.Name().Short())
		}
	}
	return branches, nil
}

// Checkout can be used to checkout any revision inside the repository
func (r *Repo) Checkout(rev string, args ...string) error {
	cmdArgs := append([]string{"checkout", rev}, args...)
	return command.
		NewWithWorkDir(r.Dir(), gitExecutable, cmdArgs...).
		RunSilentSuccess()
}

// IsReleaseBranch returns true if the provided branch is a Kubernetes release
// branch
func IsReleaseBranch(branch string) bool {
	if !regex.BranchRegex.MatchString(branch) {
		logrus.Warnf("%s is not a release branch", branch)
		return false
	}

	return true
}

func (r *Repo) MergeBase(from, to string) (string, error) {
	mainRef := Remotify(from)
	releaseRef := Remotify(to)

	logrus.Debugf("MainRef: %s, releaseRef: %s", mainRef, releaseRef)

	commitRevs := []string{mainRef, releaseRef}
	var res []*object.Commit

	hashes := []*plumbing.Hash{}
	for _, rev := range commitRevs {
		hash, err := r.inner.ResolveRevision(plumbing.Revision(rev))
		if err != nil {
			return "", err
		}
		hashes = append(hashes, hash)
	}

	commits := []*object.Commit{}
	for _, hash := range hashes {
		commit, err := r.inner.CommitObject(*hash)
		if err != nil {
			return "", err
		}
		commits = append(commits, commit)
	}

	res, err := commits[0].MergeBase(commits[1])
	if err != nil {
		return "", err
	}

	if len(res) == 0 {
		return "", fmt.Errorf("could not find a merge base between %s and %s", from, to)
	}

	mergeBase := res[0].Hash.String()
	logrus.Infof("Merge base is %s", mergeBase)

	return mergeBase, nil
}

// Remotify returns the name prepended with the default remote
func Remotify(name string) string {
	split := strings.Split(name, "/")
	if len(split) > 1 {
		return name
	}
	return fmt.Sprintf("%s/%s", DefaultRemote, name)
}

// Merge does a git merge into the current branch from the provided one
func (r *Repo) Merge(from string) error {
	if err := filterCommand(
		r.Dir(), "merge", "-X", "ours", from,
	).RunSilentSuccess(); err != nil {
		return fmt.Errorf("run git merge: %w", err)
	}
	return nil
}

// Push does push the specified branch to the default remote, but only if the
// repository is not in dry run mode
func (r *Repo) Push(remoteBranch string) (err error) {
	args := []string{"push"}
	if r.dryRun {
		logrus.Infof("Won't push due to dry run repository")
		args = append(args, "--dry-run")
	}
	args = append(args, DefaultRemote, remoteBranch)

	for i := r.maxRetries + 1; i > 0; i-- {
		if err = filterCommand(r.Dir(), args...).RunSilentSuccess(); err == nil {
			return nil
		}
		// Convert to network error to see if we can retry the push
		err = NewNetworkError(err)
		if !err.(NetworkError).CanRetry() || r.maxRetries == 0 {
			return err
		}
		waitTime := math.Pow(2, float64(r.maxRetries-i))
		logrus.Errorf(
			"Error pushing %s (will retry %d more times in %.0f secs): %s",
			remoteBranch, i-1, waitTime, err.Error(),
		)
		time.Sleep(time.Duration(waitTime) * time.Second)
	}
	return fmt.Errorf("trying to push %s %d times: %w", remoteBranch, r.maxRetries, err)
}

// Head retrieves the current repository HEAD as a string
func (r *Repo) Head() (string, error) {
	ref, err := r.inner.Head()
	if err != nil {
		return "", err
	}
	return ref.Hash().String(), nil
}

// LatestPatchToPatch tries to discover the start (latest v1.x.[x-1]) and
// end (latest v1.x.x) revision inside the repository for the specified release
// branch.
func (r *Repo) LatestPatchToPatch(branch string) (DiscoverResult, error) {
	latestTag, err := r.LatestTagForBranch(branch)
	if err != nil {
		return DiscoverResult{}, err
	}

	if len(latestTag.Pre) > 0 && latestTag.Patch > 0 {
		latestTag.Patch--
		latestTag.Pre = nil
	}

	if latestTag.Patch == 0 {
		return DiscoverResult{}, fmt.Errorf(
			"found non-patch version %v as latest tag on branch %s",
			latestTag, branch,
		)
	}

	prevTag := semver.Version{
		Major: latestTag.Major,
		Minor: latestTag.Minor,
		Patch: latestTag.Patch - 1,
	}

	logrus.Debugf("Parsing latest tag %s%v", util.TagPrefix, latestTag)
	latestVersionTag := util.SemverToTagString(latestTag)
	end, err := r.RevParseTag(latestVersionTag)
	if err != nil {
		return DiscoverResult{}, fmt.Errorf("parsing version %v: %w", latestTag, err)
	}

	logrus.Debugf("Parsing previous tag %s%v", util.TagPrefix, prevTag)
	previousVersionTag := util.SemverToTagString(prevTag)
	start, err := r.RevParseTag(previousVersionTag)
	if err != nil {
		return DiscoverResult{}, fmt.Errorf("parsing previous version %v: %w", prevTag, err)
	}

	return DiscoverResult{
		startSHA: start,
		startRev: previousVersionTag,
		endSHA:   end,
		endRev:   latestVersionTag,
	}, nil
}

// LatestPatchToLatest tries to discover the start (latest v1.x.x]) and
// end (release-1.x or DefaultBranch) revision inside the repository for the specified release
// branch.
func (r *Repo) LatestPatchToLatest(branch string) (DiscoverResult, error) {
	latestTag, err := r.LatestTagForBranch(branch)
	if err != nil {
		return DiscoverResult{}, err
	}

	if len(latestTag.Pre) > 0 && latestTag.Patch > 0 {
		latestTag.Patch--
		latestTag.Pre = nil
	}

	logrus.Debugf("Parsing latest tag %s%v", util.TagPrefix, latestTag)
	latestVersionTag := util.SemverToTagString(latestTag)
	start, err := r.RevParseTag(latestVersionTag)
	if err != nil {
		return DiscoverResult{}, fmt.Errorf("parsing version %v: %w", latestTag, err)
	}

	// If a release branch exists for the latest version, we use it. Otherwise we
	// fallback to the DefaultBranch.
	end, branch, err := r.releaseBranchOrMainRef(latestTag.Major, latestTag.Minor)
	if err != nil {
		return DiscoverResult{}, fmt.Errorf("getting release branch for %v: %w", latestTag, err)
	}

	return DiscoverResult{
		startSHA: start,
		startRev: latestVersionTag,
		endSHA:   end,
		endRev:   branch,
	}, nil
}

// LatestTagForBranch returns the latest available semver tag for a given branch
func (r *Repo) LatestTagForBranch(branch string) (tag semver.Version, err error) {
	tags, err := r.TagsForBranch(branch)
	if err != nil {
		return tag, err
	}
	if len(tags) == 0 {
		return tag, errors.New("no tags found on branch")
	}

	tag, err = util.TagStringToSemver(tags[0])
	if err != nil {
		return tag, err
	}

	return tag, nil
}

// PreviousTag tries to find the previous tag for a provided branch and errors
// on any failure
func (r *Repo) PreviousTag(tag, branch string) (string, error) {
	tags, err := r.TagsForBranch(branch)
	if err != nil {
		return "", err
	}

	idx := -1
	for i, t := range tags {
		if t == tag {
			idx = i
			break
		}
	}
	if idx == -1 {
		return "", errors.New("could not find specified tag in branch")
	}
	if len(tags) < idx+1 {
		return "", errors.New("unable to find previous tag")
	}

	return tags[idx+1], nil
}

// TagsForBranch returns a list of tags for the provided branch sorted by
// creation date
func (r *Repo) TagsForBranch(branch string) (res []string, err error) {
	previousBranch, err := r.CurrentBranch()
	if err != nil {
		return nil, fmt.Errorf("retrieving current branch: %w", err)
	}
	if err := r.Checkout(branch); err != nil {
		return nil, fmt.Errorf("checking out %s: %w", branch, err)
	}
	defer func() { err = r.Checkout(previousBranch) }()

	status, err := filterCommand(
		r.Dir(), "tag", "--sort=creatordate", "--merged",
	).RunSilentSuccessOutput()
	if err != nil {
		return nil, fmt.Errorf("retrieving merged tags for branch %s: %w", branch, err)
	}

	tags := strings.Fields(status.Output())
	sort.Sort(sort.Reverse(sort.StringSlice(tags)))

	return tags, nil
}

// Tags returns a list of tags for the repository.
func (r *Repo) Tags() (res []string, err error) {
	tags, err := r.inner.Tags()
	if err != nil {
		return nil, fmt.Errorf("get tags: %w", err)
	}
	_ = tags.ForEach(func(t *plumbing.Reference) error { //nolint: errcheck
		res = append(res, t.Name().Short())
		return nil
	})
	return res, nil
}

// Add adds a file to the staging area of the repo
func (r *Repo) Add(filename string) error {
	if err := filterCommand(
		r.Dir(), "add", filename,
	).RunSilentSuccess(); err != nil {
		return fmt.Errorf("adding file %s to repository: %w", filename, err)
	}
	return nil
}

// GetUserName Reads the local user's name from the git configuration
func GetUserName() (string, error) {
	// Retrieve username from git
	userName, err := filterCommand(
		"", "config", "--get", "user.name",
	).RunSilentSuccessOutput()
	if err != nil {
		return "", fmt.Errorf("reading the user name from git: %w", err)
	}
	return userName.OutputTrimNL(), nil
}

// GetUserEmail reads the user's name from git
func GetUserEmail() (string, error) {
	userEmail, err := filterCommand(
		"", "config", "--get", "user.email",
	).RunSilentSuccessOutput()
	if err != nil {
		return "", fmt.Errorf("reading the user's email from git: %w", err)
	}
	return userEmail.OutputTrimNL(), nil
}

// UserCommit makes a commit using the local user's config as well as adding
// the Signed-off-by line to the commit message
func (r *Repo) UserCommit(msg string) error {
	// Retrieve username and mail
	userName, err := GetUserName()
	if err != nil {
		return fmt.Errorf("getting the user's name: %w", err)
	}

	userEmail, err := GetUserEmail()
	if err != nil {
		return fmt.Errorf("getting the user's email: %w", err)
	}

	// Add signed-off-by line
	msg += fmt.Sprintf("\n\nSigned-off-by: %s <%s>", userName, userEmail)

	if err := r.CommitWithOptions(msg, &git.CommitOptions{
		Author: &object.Signature{
			Name:  userName,
			Email: userEmail,
			When:  time.Now(),
		},
	}); err != nil {
		return fmt.Errorf("commit changes: %w", err)
	}

	return nil
}

// Commit commits the current repository state
func (r *Repo) Commit(msg string) error {
	return r.CommitWithOptions(
		msg,
		&git.CommitOptions{
			Author: &object.Signature{
				Name:  DefaultGitUser,
				Email: DefaultGitEmail,
				When:  time.Now(),
			},
		},
	)
}

// CommitWithOptions commits the current repository state
func (r *Repo) CommitWithOptions(msg string, options *git.CommitOptions) error {
	if _, err := r.worktree.Commit(msg, options); err != nil {
		return err
	}
	return nil
}

// CommitEmpty commits an empty commit into the repository
func (r *Repo) CommitEmpty(msg string) error {
	return command.
		NewWithWorkDir(r.Dir(), gitExecutable,
			"commit", "--allow-empty", "-m", msg,
		).
		RunSilentSuccess()
}

// Tag creates a new annotated tag for the provided `name` and `message`.
func (r *Repo) Tag(name, message string) error {
	head, err := r.inner.Head()
	if err != nil {
		return err
	}
	if _, err := r.inner.CreateTag(
		name,
		head.Hash(),
		&git.CreateTagOptions{
			Tagger: &object.Signature{
				Name:  DefaultGitUser,
				Email: DefaultGitEmail,
				When:  time.Now(),
			},
			Message: message,
		}); err != nil {
		return err
	}
	return nil
}

// CurrentBranch returns the current branch of the repository or an error in
// case of any failure
func (r *Repo) CurrentBranch() (branch string, err error) {
	branches, err := r.inner.Branches()
	if err != nil {
		return "", err
	}

	head, err := r.inner.Head()
	if err != nil {
		return "", err
	}

	if err := branches.ForEach(func(ref *plumbing.Reference) error {
		if ref.Hash() == head.Hash() {
			branch = ref.Name().Short()
			return nil
		}

		return nil
	}); err != nil {
		return "", err
	}

	return branch, nil
}

// Rm removes files from the repository
func (r *Repo) Rm(force bool, files ...string) error {
	args := []string{"rm"}
	if force {
		args = append(args, "-f")
	}
	args = append(args, files...)

	return command.
		NewWithWorkDir(r.Dir(), gitExecutable, args...).
		RunSilentSuccess()
}

// Remotes lists the currently available remotes for the repository
func (r *Repo) Remotes() (res []*Remote, err error) {
	remotes, err := r.inner.Remotes()
	if err != nil {
		return nil, fmt.Errorf("unable to list remotes: %w", err)
	}

	// Sort the remotes by their name which is not always the case
	sort.Slice(remotes, func(i, j int) bool {
		return remotes[i].Config().Name < remotes[j].Config().Name
	})

	for _, remote := range remotes {
		cfg := remote.Config()
		res = append(res, &Remote{name: cfg.Name, urls: cfg.URLs})
	}

	return res, nil
}

// HasRemote checks if the provided remote `name` is available and matches the
// expected `url`
func (r *Repo) HasRemote(name, expectedURL string) bool {
	remotes, err := r.Remotes()
	if err != nil {
		logrus.Warnf("Unable to get repository remotes: %v", err)
		return false
	}

	for _, remote := range remotes {
		if remote.Name() == name {
			for _, url := range remote.URLs() {
				if url == expectedURL {
					return true
				}
			}
		}
	}

	return false
}

// AddRemote adds a new remote to the current working tree
func (r *Repo) AddRemote(name, owner, repo string, useSSH bool) error {
	repoURL := GetRepoURL(owner, repo, useSSH)
	args := []string{"remote", "add", name, repoURL}
	return command.
		NewWithWorkDir(r.Dir(), gitExecutable, args...).
		RunSilentSuccess()
}

// PushToRemote push the current branch to a specified remote, but only if the
// repository is not in dry run mode
func (r *Repo) PushToRemote(remote, remoteBranch string) error {
	args := []string{"push", "--set-upstream"}
	if r.dryRun {
		logrus.Infof("Won't push due to dry run repository")
		args = append(args, "--dry-run")
	}
	args = append(args, remote, remoteBranch)

	return filterCommand(r.Dir(), args...).RunSuccess()
}

// PushToRemote push the current branch to a specified remote, but only if the
// repository is not in dry run mode
func (r *Repo) PushToRemoteWithOptions(pushOptions *git.PushOptions) error {
	return r.inner.Push(pushOptions)
}

// LsRemote can be used to run `git ls-remote` with the provided args on the
// repository
func (r *Repo) LsRemote(args ...string) (output string, err error) {
	for i := r.maxRetries + 1; i > 0; i-- {
		params := []string{}
		params = append(params, "--")
		params = append(params, args...)
		output, err = r.runGitCmd("ls-remote", params...)
		if err == nil {
			return output, nil
		}
		err = NewNetworkError(err)
		if !err.(NetworkError).CanRetry() || r.maxRetries == 0 || i == 1 {
			return "", err
		}

		waitTime := math.Pow(2, float64(r.maxRetries-i))
		logrus.Errorf(
			"Executing ls-remote (will retry %d more times in %.0f secs): %s",
			i-1, waitTime, err.Error(),
		)
		time.Sleep(time.Duration(waitTime) * time.Second)
	}
	return "", err
}

// Branch can be used to run `git branch` with the provided args on the
// repository
func (r *Repo) Branch(args ...string) (string, error) {
	return r.runGitCmd("branch", args...)
}

// runGitCmd runs the provided command in the repository root and appends the
// args. The command will run silently and return the captured output or an
// error in case of any failure.
func (r *Repo) runGitCmd(cmd string, args ...string) (string, error) {
	cmdArgs := append([]string{cmd}, args...)
	res, err := filterCommand(r.Dir(), cmdArgs...).RunSilentSuccessOutput()
	if err != nil {
		return "", fmt.Errorf("running git %s: %w", cmd, err)
	}
	return res.OutputTrimNL(), nil
}

// IsDirty returns true if the worktree status is not clean. It can also error
// if the worktree status is not retrievable.
func (r *Repo) IsDirty() (bool, error) {
	status, err := r.Status()
	if err != nil {
		return false, fmt.Errorf("retrieving worktree status: %w", err)
	}
	return !status.IsClean(), nil
}

// RemoteTags return the tags that currently exist in the
func (r *Repo) RemoteTags() (tags []string, err error) {
	logrus.Debug("Listing remote tags with ls-remote")
	output, err := r.LsRemote(DefaultRemote)
	if err != nil {
		return tags, fmt.Errorf("while listing tags using ls-remote: %w", err)
	}
	const gitTagPreRef = "refs/tags/"
	tags = make([]string, 0)
	scanner := bufio.NewScanner(strings.NewReader(output))
	scanner.Split(bufio.ScanWords)
	for scanner.Scan() {
		if strings.HasPrefix(scanner.Text(), gitTagPreRef) {
			tags = append(tags, strings.TrimPrefix(scanner.Text(), gitTagPreRef))
		}
	}
	logrus.Debugf("Remote repository contains %d tags", len(tags))
	return tags, nil
}

// HasRemoteTag Checks if the default remote already has a tag
func (r *Repo) HasRemoteTag(tag string) (hasTag bool, err error) {
	remoteTags, err := r.RemoteTags()
	if err != nil {
		return hasTag, fmt.Errorf("getting tags to check if tag exists: %w", err)
	}
	for _, remoteTag := range remoteTags {
		if tag == remoteTag {
			logrus.Infof("Tag %s found in default remote", tag)
			return true, nil
		}
	}
	return false, nil
}

// SetURL can be used to overwrite the URL for a remote
func (r *Repo) SetURL(remote, newURL string) error {
	if err := r.inner.DeleteRemote(remote); err != nil {
		return fmt.Errorf("delete remote: %w", err)
	}
	if _, err := r.inner.CreateRemote(&config.RemoteConfig{
		Name: remote,
		URLs: []string{newURL},
	}); err != nil {
		return fmt.Errorf("create remote: %w", err)
	}
	return nil
}

// Status reads and returns the Status object from the repository
func (r *Repo) Status() (*git.Status, error) {
	status, err := r.worktree.Status()
	if err != nil {
		return nil, fmt.Errorf("getting the repository status: %w", err)
	}
	return &status, nil
}

// ShowLastCommit is a simple function that runs git show and returns the
// last commit in the log
func (r *Repo) ShowLastCommit() (logData string, err error) {
	logData, err = r.runGitCmd("show")
	if err != nil {
		return logData, fmt.Errorf("getting last commit log: %w", err)
	}
	return logData, nil
}

// LastCommitSha returns the sha of the last commit in the repository
func (r *Repo) LastCommitSha() (string, error) {
	shaval, err := r.runGitCmd("log", "--pretty=format:'%H'", "-n1")
	if err != nil {
		return "", fmt.Errorf("trying to retrieve the last commit sha: %w", err)
	}
	return shaval, nil
}

// FetchRemote gets the objects from the specified remote. It returns true as
// first argument if something has been fetched remotely.
func (r *Repo) FetchRemote(remoteName string) (bool, error) {
	if remoteName == "" {
		return false, errors.New("error fetching, remote repository name is empty")
	}
	// Verify the remote exists
	remotes, err := r.Remotes()
	if err != nil {
		return false, fmt.Errorf("getting repository remotes: %w", err)
	}

	remoteExists := false
	for _, remote := range remotes {
		if remote.Name() == remoteName {
			remoteExists = true
			break
		}
	}
	if !remoteExists {
		return false, errors.New("cannot fetch repository, the specified remote does not exist")
	}

	res, err := filterCommand(r.Dir(), "fetch", remoteName).RunSilentSuccessOutput()
	if err != nil {
		return false, fmt.Errorf("fetching objects from %s: %w", remoteName, err)
	}
	// git fetch outputs on stderr
	output := strings.TrimSpace(res.Error())
	logrus.Debugf("Fetch result: %s", output)
	return output != "", nil
}

// Rebase calls rebase on the current repo to the specified branch
func (r *Repo) Rebase(branch string) error {
	if branch == "" {
		return errors.New("cannot rebase repository, branch is empty")
	}
	logrus.Infof("Rebasing repository to %s", branch)
	_, err := r.runGitCmd("rebase", branch)
	// If we get an error, try to interpret it to make more sense
	if err != nil {
		return fmt.Errorf("rebasing repository: %w", err)
	}
	return nil
}

// ParseRepoSlug parses a repository string and return the organization and repository name/
func ParseRepoSlug(repoSlug string) (org, repo string, err error) {
	match, err := regexp.MatchString(`(?i)^[a-z0-9-/]+$`, repoSlug)
	if err != nil {
		return "", "", fmt.Errorf("checking repository slug: %w", err)
	}
	if !match {
		return "", "", errors.New("repository slug contains invalid characters")
	}

	parts := strings.Split(repoSlug, "/")
	if len(parts) > 2 {
		return "", "", errors.New("string is not a well formed org/repo slug")
	}
	org = parts[0]
	if len(parts) > 1 {
		repo = parts[1]
	}
	return org, repo, nil
}

// NewNetworkError creates a new NetworkError
func NewNetworkError(err error) NetworkError {
	gerror := NetworkError{
		error: err,
	}
	return gerror
}

// NetworkError is a wrapper for the error class
type NetworkError struct {
	error
}

// CanRetry tells if an error can be retried
func (e NetworkError) CanRetry() bool {
	// We consider these strings as part of errors we can retry
	retryMessages := []string{
		"dial tcp", "read udp", "connection refused",
		"ssh: connect to host", "Could not read from remote",
	}

	// If any of them are in the error message, we consider it temporary
	for _, message := range retryMessages {
		if strings.Contains(e.Error(), message) {
			return true
		}
	}

	// Otherwise permanent
	return false
}

// LatestReleaseBranch determines the latest release-x.y branch of the repo.
func (r *Repo) LatestReleaseBranch() (string, error) {
	branches, err := r.RemoteBranches()
	if err != nil {
		return "", fmt.Errorf("get remote branches: %w", err)
	}

	var latest semver.Version
	for _, branch := range branches {
		if strings.HasPrefix(branch, releaseBranchPrefix) {
			version := strings.TrimPrefix(branch, releaseBranchPrefix) + ".0"

			parsed, err := semver.Parse(version)
			if err != nil {
				logrus.Debugf("Unable to parse semver for %s: %v", version, err)
				continue
			}

			if parsed.GT(latest) {
				latest = parsed
			}
		}
	}

	if latest.EQ(semver.Version{}) {
		return "", errors.New("no latest release branch found")
	}

	return semverToReleaseBranch(latest), nil
}

func semverToReleaseBranch(v semver.Version) string {
	return fmt.Sprintf("%s%d.%d", releaseBranchPrefix, v.Major, v.Minor)
}