Come posso controllare la data e l'ora dell'ultimo `git pull` che è stato eseguito?

91

Come posso controllare la data e l'ora dell'ultima git pullche è stata eseguita? Ho spesso bisogno di sapere quando il codice è cambiato su un server quando qualcosa va storto.

git  git-pull 
— Chirag Patel
fonte

Risposte:

27

Il git showcomando mostra la data del commit più recente. Questa non è la data in cui è stato eseguito il pull del commit nel repository locale, ma Git non conserva tali informazioni di pull.

Potresti essere in grado di trovare l'ora dell'ultimo pull utilizzando il ctime (ora di creazione) dei file sul server. Per esempio:

ls -lct

mostra l'ora di ogni file, ordinata per prima dalla più recente.

— Greg Hewgill
fonte
18
Questo non risponde alla domanda - vedi la risposta di Smoove di seguito.
— Wilfred Hughes
1
git showmostra la data del tip commit del ramo corrente, che non è necessario il commit più recente nel repo, figuriamoci la data dell'ultimo fetch / pull. Consiglio anche di controllare la risposta di Smoove.
— Stefaan
3
Mi permetto di dissentire. Questo risponde alla domanda. Sebbene non ti dia la data dell'ultimo pull, ti dà la data del commit che era il più recente l'ultima volta che hai eseguito il pull. Per il caso d'uso nella domanda originale, questo è perfettamente adatto. Vuoi sapere quando hai aggiornato l'ultima volta il codice su un server tramite git pull, cioè quale versione del codice è attualmente sul server. git showti dice in quale commit si trova il tuo clone locale. (So ​​che questo è vecchio, ma sono finito qui tramite la ricerca.)
— Dietmar
149 
stat -c %Y .git/FETCH_HEAD

Ti darà un timestamp unix dell'ultima modifica di quel file. Git scrive il file FETCH_HEAD ogni volta che esegui il pull o il recupero, anche se non c'era nulla da estrarre.

— smoove
fonte
17
Timestamp Unix dell'ora modificata su OSX:stat -f '%m' .git/FETCH_HEAD
— jpillora
18
Git scrive FETCH_HEAD prima dell'effettivo fetch / pull ... Quindi, se il pull non è riuscito o è stato annullato, FETCH_HEAD non rappresenterebbe lo stato effettivo del repository. Ciò è particolarmente problematico quando l'URL del repository originale non funziona, poiché ogni pull fallirebbe ma FETCH_HEAD verrà aggiornato a ogni tentativo.
— rustyx
9
Data dell'ora modificata su OS X:stat -f '%Sm' $(git rev-parse --show-toplevel)/.git/FETCH_HEAD
— Colin vH
7
Puoi anche controllare .git/refs/heads/masterquale cambierà il timestamp quando si git pulltraduce in modifiche in arrivo dal masterramo remoto , ma il timestamp non cambierà quando git pullsegnala che non ci sono modifiche.
— Malvineous
6
Per chiunque utilizzi questo in uno script: se un fetch o un pull non è stato ancora eseguito, FETCH_HEAD non esiste ancora e stat restituirà il codice di uscita 1.
— MajicBob
43

Per un sospetto, ho provato "stat -c% y .git / FETCH_HEAD", e ho ottenuto una stampa leggibile dell'epoca:

> stat -c %y .git/FETCH_HEAD
2015-02-24 17:42:08.072094410 -0500

Inoltre, puoi aggiungere when = !stat -c %y .git/FETCH_HEADalla [alias]sezione nel tuo file ~ / .gitconfig (è più sicuro farlo automaticamente eseguendo la seguente riga di comando in qualsiasi repository git)

git config --global alias.when '!stat -c %y .git/FETCH_HEAD'

e poi puoi trovare queste informazioni con il tuo nuovo "comando", in qualsiasi momento:

> git when
2015-02-23 15:07:53.086254218 -0500

[Poi mi è venuto in mente di fare "man stat" e ho scoperto che ci sono molti altri parametri% disponibili per il programma 'stat'. YMMV.]

— Paul McMullin
fonte
3
Questa è la risposta più utile!
— Arun
Solo una nota. -cnon è un'opzione valida di statper Mac.
— Abel Callejo
10

In un repository non nudo (e un repository nudo non ha senso git pull), git registra tutte le modifiche ai suggerimenti del ramo e l'idea del ramo corrente in "reflogs", in .git/logs. Puoi visualizzarli usando git log -g.

Tuttavia, sebbene i file di registro abbiano timestamp, non sembra che git log -glo stamperanno. Tuttavia, se dai un'occhiata ad .git/logs/HEADesempio, vedrai che il formato è abbastanza semplice da analizzare: consiste in ciò da cui è cambiato ref (o HEAD), in cui è cambiato, chi l'ha cambiato, quando e un messaggio di attività.

— araqnid
fonte
5 
git show -1 --stat

Questo comando git mostra le ultime modifiche di data e ora di commit con il messaggio

— sachin_ur
fonte
3

Usa python: python -c "import os;print os.stat('.git/FETCH_HEAD').st_mtime"

— più ampio
fonte
ha bisogno di un po 'di formattazione, ma una risposta completamente valida per freebsd dove stat non funziona nei modi descritti sopra.
— Endre
2 
python -c "import os, datetime ;print datetime.datetime.fromtimestamp(os.stat('.git/FETCH_HEAD').st_mtime)"

o 

python3 -c "import os, datetime ;print(datetime.datetime.fromtimestamp(os.stat('.git/FETCH_HEAD').st_mtime))"
— RedEyed
fonte
1

Soluzione Bash Cross Platform (OSX / Linux)

Fortemente ispirato dalla @smoovesrisposta: https://stackoverflow.com/a/9229377/622276 e commenti.

Ma sto mantenendo la mia integrazione git prompt di bash

Con la fonte qui: https://github.com/neozenith/dotfiles/blob/master/bash-scripts/function_parse_git_prompt.sh

msys versione in Git Bash per Windows funziona in modo identico alla versione per Linux.

Sto compilando le opzioni multipiattaforma in un'istruzione case. Quindi eseguirà un processo di recupero su qualsiasi repository Git in cui navigo che è più vecchio di quindici minuti dall'ultimo recupero in modo che il resto del mio script di prompt sappia se ho cose da tirare.

Git radar era abituato a questo, ma richiedeva il salvataggio di un file con timestamp di quando è stato chiamato l'ultimo recupero. Questo non scrive file temporanei.

git rev-parse --show-toplevelsignifica solo che se sono da qualche parte in un repository git otterrà la radice del repository in modo che possiamo fare riferimento al .gitpercorso della cartella.

# No repo == no more work 
local REPO_ROOT=`git rev-parse --show-toplevel 2> /dev/null`
if [[ -n $REPO_ROOT && -e "$REPO_ROOT/.git/FETCH_HEAD" ]]; then

    case $OSTYPE in
      darwin*)
        local LAST_FETCH="$(stat -f '%m' $REPO_ROOT/.git/FETCH_HEAD)" 
        local FETCH_THRESHOLD="$(date -v-15m +%s)"  
      ;;
      *)
        local LAST_FETCH="$(stat -c %Y $REPO_ROOT/.git/FETCH_HEAD)" 
        local FETCH_THRESHOLD="$(date -d'15 minutes ago' +%s)"  
      ;;
    esac

    # Fork fetch process in background
    if [[ $LAST_FETCH -lt $FETCH_THRESHOLD ]]; then
      git fetch --all --quiet --prune 2> /dev/null &
    fi

fi
— Josh Peak
fonte
1

Ecco un piccolo involucro git. Installalo con il nome gite con i diritti chmod a+x git. Quindi aggiungi last_successful_fetcha .git/info/exclude.

Quando vuoi vedere il risultato, usa stat last_successful_fetch.

#!/bin/sh

# This script just invokes git as expected, plus one additional action:
# If there stands last_successful_fetch in .git/info/exclude, then
# this file will be touched in top dir.

"`which --all git | uniq | head -n 2 | tail -n 1`" "$@"
status=$?

if [ _"$1" = _pull -o _"$1" = _fetch ]; then
    if grep last_successful_fetch "`git rev-parse --git-dir`/info/exclude" >/dev/null 2>&1; then
        [ $status = 0 ] && touch last_successful_fetch
    fi
fi
— jifb
fonte
0 
$ # for the latest pull even if there's nothing new
$ stat -c %y .git/FETCH_HEAD
2017-12-15 11:24:25.000000000 +0100
$ 
$ # for records of updated references
$ git reflog --date=iso
db2bba84 (HEAD -> master, origin/master, origin/HEAD) HEAD@{2017-12-14 11:28:39 +0100}: pull: Fast-forward
37fe73ad HEAD@{2017-12-03 17:09:32 +0100}: pull: Fast-forward
c4107fcd HEAD@{2017-11-27 18:53:40 +0100}: clone: from https://github.com/macports/macports-base
$ 
$ # for a more detailed view of the latter
$ git log -g
commit db2bba84d5e8cd82ec94a19129deb91ef62287bb (HEAD -> master, origin/master, origin/HEAD)
Reflog: HEAD@{0} (me <me@machine.local>)
Reflog message: pull: Fast-forward
Author: Ryan Schmidt <ryandesign@macports.org>
Date:   Wed Dec 13 10:23:47 2017 -0600

    portutil.tcl: Fix renames that supply the -force option

    Treat $options as a list not as a string.

    See: https://trac.macports.org/ticket/55492

[snip]
— 1.61803
fonte
-2

Come suggerito dall'utente: https://stackoverflow.com/users/83646/smoove , puoi trovare quando git pull è stato chiamato l'ultima volta sul repository controllando il timestamp di modifica di: .git / FETCH_HEAD come: git scrive .git / FETCH_HEAD ogni volta che esegui il pull o il recupero, anche se non c'era nulla da estrarre.

Esempio: {master} vinegupt @ bhling69 (/imsgit_local/work/vinegupt/ims_18.5a/ims_common) $ stat -c% y .git / FETCH_HEAD

12-02-2018 02: 01: 50.487160386 +0530

— Vineet Gupta
fonte
Per OSX 10.9.5 avevo bisogno di farlo: stat -f %Sm .git/FETCH_HEADma sembra funzionare bene per me.
— Josh
Dovresti votare la risposta di @ smoove invece di copiarla / incollarla nella tua "risposta".
— bfontaine
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.