GIT-Branches/Tags entmüllen

Bei der Softwareentwicklung mit git und Pull-Requests passiert es, dass sich peu-a-peu immer mehr Branches ansammeln. Man verwendet sie, um den Pull-Request zu stellen und wenn man vergisst, den Zweig am Ende zu löschen (oft gibt es eine Checkbox, um den PR-Zweig zu löschen), dann entstehen so langsam Abfallbranches. Also Zweige, die keiner mehr braucht, aber dennoch da sind. Eigentlich sind die Änderungen darin schon längst auf den Hauptast gelangt, aber sie sind eben noch da.

Da muss man halt dann ab und zu mal aufräumen

Wie auch immer: Ran an die Arbeit.

Wie man es macht

Wenn man also mal die Refs (so heißen Tags und Branches zusammen) ausdünnen will, sollte man da nicht manuell durch die Liste durchgehen und Klickorgien zelebrieren. Nein, man sollte ein Skript ausführen, das das Ganze recht automatisch macht. Ich habe dazu mal ein Powershell (PS)-Skript geschrieben, dass die Refs auf dem Remote-Git-Server löscht.

Probleme

Wie immer, so ist auch diese Aufgabe nicht ganz trivial. Da es sich hier um ein Windows-Skript handelt und git eh nicht so ganz Windows-native ist, kommen als erstes Kodierungsprobleme.

Zweige, Tags und Refs werden durchaus mit Umlauten bzw. generell Unicode-Zeichen benutzt und dann haben sie auch noch manchmal „/“ Schrägstriche. Und zu allem Überfluss ist der Unicode-Support auf der Windows-Console eher Mist. Aus diesem Grund enthält dieses Skript selbst aber Unicode und muss daher als UTF-8 mit BOM gespeichert werden und auch die Parameter (Branchnamen) müssen unicodefähig übergeben werden. Das erledigt ein Schalter in Powershell.

Ein zweiter Aspekt sind die Mitmenschen. Zweige veralten und man kann mit 4 Wochen schon mal ein gutes Maß anlegen, ob es ein Löschkandidat ist. Allerdings gibt es auch Entwicklungen (auf Zweigen), die mehrere Wochen benötigen und Entwickler wollen die vielleicht aufheben. Daher sollte der Prozess des Löschens so sein, dass man zunächst eine Liste von Refs ermittelt, die man löschen würde, alle Mitentwickler fragt, und dann erst zur Löschung schreitet. Daher ist das Skript so gestaltet, dass es selbst ein Skript erstellt. Und zwar eine Liste von git-Befehlen „Löschen einer Ref“.

Ausführen

Lass uns zur Sache gehen. Das Skript nehmen und in einem git-VZ ausführen:

cd GitVZ
# Skript ist herkopiert und wird im Repo-VZ ausgeführt. Ausgabe wird in ‚deletescript.ps1‘ umgeleitet
search_branches2delete.ps1 > deletescript.ps1
# Nun das ‚deletescript.ps1‘ in Notepad++ anschauen und im Zweifelsfall nachbearbeiten
npp ./deletescript.ps1
# wenn alles klar ist ausführen:
./deletescript.ps1

Ergebnis ist, dass alle ermittelten Refs gelöscht werden.

Was passiert

Das Skript ermittelt alle Refs und wählt veraltete Branches aus und schreibt auf standard-out die Befehle zum Löschen der betreffenden Branches. Daher wird die Ausgabe mit dem Shelloperator ‚>‘ in eine *.ps1 – Datei umgeleitet. Fehlermeldungen landen auf standard-err und sind somit weiterhin sichtbar.

Das Ergebnis in der umgeleiteten Datei:

 git push :orign/remotes/BlaBranch
 git push :orign/remotes/Foobar_Für_mich 

Wir sehen hier „git push :“-Befehle. Damit werden genau diese Branches auf dem betreffenden remote (hier „origin“) gelöscht. Es ist die Kurzform von erst lokal im remote löschen mit -D (delete) und dann ein push -f (force). Also mit ausreichenden Berechtigungen ausgeführt, macht dieses Skript sauber.

Beachte: Es nutzt „origin“ als fixen remote. Das muss allenfalls angepasst werden. Außerdem ist das Alter (in Tagen), die „Commits behind“ fix kodiert auf 80Tg und 444 commits behind fix eingestellt.

Das Skript:


# Sucht nach stale git branches. d.h. älter als TTL Tage oder mehr als $MaxBehind hinter $RefBranch, was meist master ist.
# Ausführen in einem Git-Repo, wo Kommandos wie `git refs` etc. verfügbar sind. Ausgabe umleiten
# Es wird also nichts gefährliches gemacht in diesem Skript. Es wird auf Konsole
# eine Reihe git push :$branch -Befehle generiert, die in eine Datei umgeleitet und dann ausgeführt werden müssen
# Benutzung
# ..\$0 > kille_sie.ps1
# > .\kille_sie.ps2
# Diese datei als UTF-8 BOM speichern, Ausgabedatei ist es ebenfalls, weil Zeile 13. Damit funzen auch Branches wie "für dich"

#$PSDefaultParameterValues['*:Encoding'] = 'utf8'
[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)
#$OutputEncoding='utf8'
$TTL = 80 #days
$MaxBehind = 444 #behind to $RefBranch
$RefBranch = "remotes/origin/master"
$borderTime = (Get-Date).AddDays(-$TTL)
git fetch origin
$branches = git branch -a --format '%(refname:lstrip=1)' 

$remoteBranches = $branches | Where-Object {$_ -like '*remotes/origin/*'} 

$remoteBranches = $remoteBranches | Where-Object { ($_ -notlike 'remotes/origin/HEAD*') `
                                              -and ($_ -ne $RefBranch) `
											  -and ($_ -notlike 'remotes/origin/keep/*') `
											  -and ($_ -notlike 'remotes/origin/release/*') `
											  -and ($_ -notlike 'remotes/origin/releases/*') `
											  } 
											
foreach($branch in $remoteBranches)
{
    $branchName = ($branch.Split('/', 3))[2]
    $branchSHA = git rev-parse $branch
    $branchLastUpdate = [DateTime]::Parse($(git show -s --format=%ci $branchSHA))
	$branchBehindAhead = $(git rev-list --left-right --count $RefBranch...$branch)
	$branchBehind = [int]::Parse($branchBehindAhead.Split(9)[0])   # 9 is a tab

	# Bedingung
    if($branchLastUpdate -lt $borderTime -or $branchBehind -gt $MaxBehind)
    {
		Write-Host "Stale Branch:  $branchLastUpdate <<$branchBehind - '$branchName'"
        Write-Output "git push origin "":$branchName"""
    }
}

Bash version

Da die Zeit weitergeht und man dasselbe Skript auch auf Linux braucht (ich entwickle eh nirgends wo anders mehr) Hier eine Bash-Version:

#!/usr/bin/env bash
# Sucht nach stale git branches. d.h. älter als TTL Tage oder mehr als $MaxBehind hinter $RefBranch, was meist master ist.
# Ausführen in einem Git-Repo, wo Kommandos wie `git refs` etc. verfügbar sind. Ausgabe umleiten
# Es wird also nichts gefährliches gemacht in diesem Skript. Es wird auf Konsole
# eine Reihe git push :$branch -Befehle generiert, die in eine Datei umgeleitet und dann ausgeführt werden müssen
# Benutzung
# ./search_branches2delete.sh > kille_sie.sh
# > bash kille_sie.sh
# Die Datei ist UTF-8, damit funzen auch Branches wie "für dich".

set -euo pipefail

TTL=80        # days
MaxBehind=444 # behind to $RefBranch
RefBranch="remotes/origin/master"
borderTime=$(date -d "-${TTL} days" +%s)

git fetch origin

# Entspricht: git branch -a --format '%(refname:lstrip=1)'
branches=$(git branch -a --format '%(refname:lstrip=1)')

while IFS= read -r branch; do
   # Nur Remote-Branches von origin, ohne HEAD und geschützte Bereiche
   [[ $branch == remotes/origin/* ]] || continue
   [[ $branch == remotes/origin/HEAD* ]] && continue
   [[ $branch == "$RefBranch" ]] && continue
   [[ $branch == remotes/origin/keep/* ]] && continue
   [[ $branch == remotes/origin/release/* ]] && continue
   [[ $branch == remotes/origin/releases/* ]] && continue

   branchName=${branch#remotes/origin/}

   branchSHA=$(git rev-parse "$branch")
   branchLastUpdate=$(git show -s --format=%ct "$branchSHA")
   read -r branchBehind branchAhead <<< "$(git rev-list --left-right --count "$RefBranch...$branch")"

   # Bedingung
   if (( branchLastUpdate < borderTime || branchBehind > MaxBehind )); then
       printf "Stale Branch:  %s <<%s - '%s'\n" \
           "$(date -d "@$branchLastUpdate")" "$branchBehind" "$branchName"
       printf 'git push origin ":%s"\n' "$branchName"
   fi
done <<< "$branches"