fix: gitter falls back to reclone too often

go/cmd/gitter/errors.go

@@ -0,0 +1,170 @@
+package main
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// regex to extract HTTP status code from git error output.
+var httpStatusRegex = regexp.MustCompile(`(?:The requested URL returned error:\s*|HTTP\s+|http_code\s*=\s*|remote:\s*)(\d{3}\b)`)
+
+// extractHTTPStatusCode extracts a 3-digit HTTP status code from git or libcurl stderr output if present.
+func extractHTTPStatusCode(err error) int {
+	if err == nil {
+		return 0
+	}
+	m := httpStatusRegex.FindStringSubmatch(err.Error())
+	if len(m) >= 2 {
+		code, _ := strconv.Atoi(m[1])
+		if code >= 100 && code <= 599 {
+			return code
+		}
+	}
+
+	return 0
+}
+
+// errContainsAny returns true if err's lowercase error message contains any of the given substrings (case-insensitively).
+func errContainsAny(err error, substrs ...string) bool {
+	if err == nil {
+		return false
+	}
+	s := strings.ToLower(err.Error())
+	for _, sub := range substrs {
+		if strings.Contains(s, strings.ToLower(sub)) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// errContainsAll returns true if err's lowercase error message contains all of the given substrings (case-insensitively).
+func errContainsAll(err error, substrs ...string) bool {
+	if err == nil || len(substrs) == 0 {
+		return false
+	}
+	s := strings.ToLower(err.Error())
+	for _, sub := range substrs {
+		if !strings.Contains(s, strings.ToLower(sub)) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// isIndexLockError checks if an error indicates a stale index.lock file left behind by an interrupted git process.
+func isIndexLockError(err error) bool {
+	return errContainsAll(err, "index.lock", "file exists")
+}
+
+// isRefConflictError checks if an error was caused by conflicting local and remote branch or tag references.
+func isRefConflictError(err error) bool {
+	// conflicting ref names (e.g. branch vs directory name)
+	return errContainsAny(err, "refname conflict") ||
+		// stale local tracking branches that conflict with remote
+		errContainsAll(err, "some local refs could not be updated", "try running 'git remote prune origin'")
+}
+
+// isRateLimitError checks if an error indicates rate limiting (HTTP 429) or upstream load shedding by the git host.
+func isRateLimitError(err error) bool {
+	if extractHTTPStatusCode(err) == 429 {
+		return true
+	}
+
+	return errContainsAny(err,
+		// gitlab rate limit message
+		"unable to handle this request due to load",
+		// generic rate limiting
+		"too many requests",
+		// github secondary rate limits
+		"secondary rate limit",
+	)
+}
+
+// isRemoteHostError checks if an error indicates an upstream server error (HTTP 5xx), transport failure,
+// network timeout, TLS error, or remote server resource exhaustion (e.g. OOM during pack generation).
+func isRemoteHostError(err error) bool {
+	code := extractHTTPStatusCode(err)
+	if code >= 500 {
+		return true
+	}
+
+	return errContainsAny(err,
+		// connection failures, drops, resets
+		"could not connect to server",
+		"failed to connect to",
+		"connection reset by peer",
+		"recv failure",
+		// network timeouts
+		"connection timed out",
+		// server closed connection prematurely
+		"empty reply from server",
+		// tls / ssl negotiation failures
+		"tls connect error",
+		"ssl routines",
+		// git smart http rpc failures
+		"rpc failed",
+		// interrupted or truncated pack transfers (e.g. remote OOM)
+		"early eof",
+		"fetch-pack: invalid index-pack output",
+		// remote host unreachable
+		"is not responding",
+		// dns failures
+		"could not resolve host",
+		"temporary failure in name resolution",
+	)
+}
+
+// isAuthError checks if an error is due to missing git credentials or authentication failure.
+func isAuthError(err error) bool {
+	if extractHTTPStatusCode(err) == 401 {
+		return true
+	}
+
+	return errContainsAny(err,
+		"could not read username",
+		"authentication failed",
+	)
+}
+
+// isForbiddenError checks if access to the remote repository was denied (HTTP 403).
+func isForbiddenError(err error) bool {
+	if extractHTTPStatusCode(err) == 403 {
+		return true
+	}
+
+	return errContainsAny(err,
+		"forbidden",
+	)
+}
+
+// isNotFoundError returns true if the requested repository does not exist (HTTP 404 or repository not found).
+func isNotFoundError(err error) bool {
+	if extractHTTPStatusCode(err) == 404 {
+		return true
+	}
+
+	return errContainsAll(err, "repository", "not found")
+}
+
+// isRefNotFoundError returns true if the requested branch, tag, or commit hash cannot be resolved.
+func isRefNotFoundError(err error) bool {
+	return errContainsAny(err,
+		"not found or invalid",
+		"failed to resolve target ref",
+		"failed to run git rev-parse",
+		"ref cannot be empty",
+	)
+}
+
+// isFileNotFoundError returns true if a file path does not exist at the requested commit.
+func isFileNotFoundError(err error) bool {
+	return errContainsAny(err,
+		"git cat-file failed",
+		"invalid object name",
+		"does not exist in",
+	)
+}

go/cmd/gitter/errors_test.go

@@ -0,0 +1,193 @@
+package main
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestIsIndexLockError(t *testing.T) {
+	tests := []struct {
+		err      error
+		expected bool
+	}{
+		{errors.New("fatal: Unable to create '/path/to/repo.git/index.lock': File exists"), true},
+		{errors.New("some other error"), false},
+		{nil, false},
+	}
+
+	for _, tt := range tests {
+		if result := isIndexLockError(tt.err); result != tt.expected {
+			t.Errorf("isIndexLockError(%v) = %v, expected %v", tt.err, result, tt.expected)
+		}
+	}
+}
+
+func TestIsRefConflictError(t *testing.T) {
+	tests := []struct {
+		err      error
+		expected bool
+	}{
+		{errors.New("error: some local refs could not be updated; try running 'git remote prune origin' to remove any old, conflicting branches"), true},
+		{errors.New("error: fetching ref refs/remotes/some-ref-name failed: refname conflict"), true},
+		{errors.New("some other error"), false},
+		{nil, false},
+	}
+
+	for _, tt := range tests {
+		if result := isRefConflictError(tt.err); result != tt.expected {
+			t.Errorf("isRefConflictError(%v) = %v, expected %v", tt.err, result, tt.expected)
+		}
+	}
+}
+
+func TestExtractHTTPStatusCode(t *testing.T) {
+	tests := []struct {
+		err      error
+		expected int
+	}{
+		{errors.New("fatal: unable to access 'https://gitlab.example.com/repo': The requested URL returned error: 429"), 429},
+		{errors.New("fatal: unable to access 'https://github.com/repo': The requested URL returned error: 403"), 403},
+		{errors.New("fatal: unable to access 'https://github.com/repo': The requested URL returned error: 404"), 404},
+		{errors.New("error: RPC failed; HTTP 500 curl 22 The requested URL returned error: 500"), 500},
+		{errors.New("fatal: unable to access 'https://gitlab.example.com/repo': The requested URL returned error: 502"), 502},
+		{errors.New("fatal: repository not found"), 0},
+		{nil, 0},
+	}
+
+	for _, tt := range tests {
+		if result := extractHTTPStatusCode(tt.err); result != tt.expected {
+			t.Errorf("extractHTTPStatusCode(%v) = %v, expected %v", tt.err, result, tt.expected)
+		}
+	}
+}
+
+func TestIsRateLimitError(t *testing.T) {
+	tests := []struct {
+		err      error
+		expected bool
+	}{
+		{errors.New("fatal: unable to access 'https://gitlab.example.com/repo': The requested URL returned error: 429"), true},
+		{errors.New("fatal: remote error: GitLab is currently unable to handle this request due to load (ID a2b5c730282383b9-ORD)."), true}, //nolint:revive // Testing exact error message from remote git host
+		{errors.New("fatal: You have exceeded a secondary rate limit"), true},
+		{errors.New("fatal: unable to access 'https://github.com/repo': The requested URL returned error: 403"), false},
+		{nil, false},
+	}
+
+	for _, tt := range tests {
+		if result := isRateLimitError(tt.err); result != tt.expected {
+			t.Errorf("isRateLimitError(%v) = %v, expected %v", tt.err, result, tt.expected)
+		}
+	}
+}
+
+func TestIsRemoteHostError(t *testing.T) {
+	tests := []struct {
+		err      error
+		expected bool
+	}{
+		{errors.New("fatal: unable to access 'https://git.example.com/repo': The requested URL returned error: 500"), true},
+		{errors.New("fatal: unable to access 'https://gitlab.example.com/repo': The requested URL returned error: 502"), true},
+		{errors.New("fatal: unable to access 'https://git.example.com/repo/': Could not connect to server"), true},
+		{errors.New("fatal: unable to access 'https://git.example.com/repo/': Connection reset by peer"), true},
+		{errors.New("fatal: early EOF\nfatal: fetch-pack: invalid index-pack output"), true},
+		{errors.New("fatal: unable to access 'https://github.com/repo': The requested URL returned error: 403"), false},
+		{nil, false},
+	}
+
+	for _, tt := range tests {
+		if result := isRemoteHostError(tt.err); result != tt.expected {
+			t.Errorf("isRemoteHostError(%v) = %v, expected %v", tt.err, result, tt.expected)
+		}
+	}
+}
+
+func TestIsAuthError(t *testing.T) {
+	tests := []struct {
+		err      error
+		expected bool
+	}{
+		{errors.New("fatal: could not read Username for 'https://github.com': terminal prompts disabled"), true},
+		{errors.New("fatal: Authentication failed for 'https://github.com/example/repo.git/'"), true},
+		{errors.New("fatal: unable to access 'https://github.com/example/repo/': The requested URL returned error: 403"), false},
+		{nil, false},
+	}
+
+	for _, tt := range tests {
+		if result := isAuthError(tt.err); result != tt.expected {
+			t.Errorf("isAuthError(%v) = %v, expected %v", tt.err, result, tt.expected)
+		}
+	}
+}
+
+func TestIsForbiddenError(t *testing.T) {
+	tests := []struct {
+		err      error
+		expected bool
+	}{
+		{errors.New("fatal: unable to access 'https://github.com/example/repo/': The requested URL returned error: 403"), true},
+		{errors.New("remote: 403 Forbidden"), true},
+		{errors.New("fatal: unable to access 'https://gitlab.example.com/repo': The requested URL returned error: 429"), false},
+		{nil, false},
+	}
+
+	for _, tt := range tests {
+		if result := isForbiddenError(tt.err); result != tt.expected {
+			t.Errorf("isForbiddenError(%v) = %v, expected %v", tt.err, result, tt.expected)
+		}
+	}
+}
+
+func TestIsNotFoundError(t *testing.T) {
+	tests := []struct {
+		err      error
+		expected bool
+	}{
+		{errors.New("remote: Repository not found"), true},
+		{errors.New("fatal: unable to access 'https://github.com/example/repo/': The requested URL returned error: 404"), true},
+		{errors.New("fatal: unable to access 'https://github.com/example/repo/': The requested URL returned error: 403"), false},
+		{nil, false},
+	}
+
+	for _, tt := range tests {
+		if result := isNotFoundError(tt.err); result != tt.expected {
+			t.Errorf("isNotFoundError(%v) = %v, expected %v", tt.err, result, tt.expected)
+		}
+	}
+}
+
+func TestIsRefNotFoundError(t *testing.T) {
+	tests := []struct {
+		err      error
+		expected bool
+	}{
+		{errors.New("ref cannot be empty"), true},
+		{errors.New("failed to resolve target ref 'non-existent-branch'"), true},
+		{errors.New("git cat-file failed: fatal: not found or invalid"), true},
+		{errors.New("fatal: Authentication failed"), false},
+		{nil, false},
+	}
+
+	for _, tt := range tests {
+		if result := isRefNotFoundError(tt.err); result != tt.expected {
+			t.Errorf("isRefNotFoundError(%v) = %v, expected %v", tt.err, result, tt.expected)
+		}
+	}
+}
+
+func TestIsFileNotFoundError(t *testing.T) {
+	tests := []struct {
+		err      error
+		expected bool
+	}{
+		{errors.New("git cat-file failed: fatal: Not a valid object name 1234abcd"), true},
+		{errors.New("file does not exist in commit"), true},
+		{errors.New("fatal: Authentication failed"), false},
+		{nil, false},
+	}
+
+	for _, tt := range tests {
+		if result := isFileNotFoundError(tt.err); result != tt.expected {
+			t.Errorf("isFileNotFoundError(%v) = %v, expected %v", tt.err, result, tt.expected)
+		}
+	}
+}