“Hai mai perso un ramo il cui codice sorgente non era ancora unito al ramo ‘release’ o al ramo ‘principale’? Cosa succede se si desidera rigenerare un ramo eliminato anche se il suo lavoro è già stato unito al ramo principale?” . Bene, l’unica soluzione a tali scenari è Git Reflog .
Attraverso questo articolo su Git Reflog, ti aiuterò a capire gli scenari in cui il tuo lavoro su un ramo potrebbe andare perso e come recuperare il ramo. Inoltre, questo articolo evidenzierà l’approccio che potresti adottare per prevenire la perdita involontaria di un ramo mentre lavori in un progetto di grandi dimensioni.
Quindi, iniziamo con questo articolo.
Considera uno scenario, un inserviente deve unire molti rami di funzionalità di diversi collaboratori e quindi eliminarli alla fine; ma il ramo viene cancellato accidentalmente prima che il lavoro possa essere unito?
Bene, prima di passare a questo articolo, lascia che ti dica che non è possibile in Git. I comandi Git sono sicuri e fungono da posto di controllo; non ti permetterebbe di farlo. Quindi, è qui che entra in gioco Git Reflog.
Cos’è Git Reflog?
Il comando ‘reflog’ tiene traccia di ogni singola modifica apportata ai riferimenti (rami o tag) di un repository e tiene una cronologia dei registri dei rami e dei tag che sono stati creati localmente o estratti. I log di riferimento come lo snapshot del commit di quando il ramo è stato creato o clonato, ritirato, rinominato o qualsiasi commit effettuato sul ramo sono gestiti da Git ed elencati dal comando ‘reflog’.
Nota: il ramo sarà recuperabile dalla tua directory di lavoro solo se il ramo è mai esistito nel tuo repository locale, ovvero il ramo è stato creato localmente o estratto da un repository remoto nel tuo repository locale affinché Git memorizzi i suoi registri della cronologia di riferimento.
Questo comando deve essere eseguito nel repository che aveva il ramo perso. Se consideri la situazione del repository remoto, devi eseguire il comando reflog sulla macchina dello sviluppatore che aveva il ramo.
comando: git reflog
Ora che sai cos’è Git Reflog, proviamo a eliminare sia un ramo unito che uno non unito e vediamo come Git lo gestisce?
Passaggio 1: elenca i rami che vengono uniti nel master
Per prima cosa, controlla nel ramo ‘ master ‘ se sei su qualche altro ramo usando il comando:
|
1
|
$git checkout master |
Produzione
Ora, per ottenere un elenco di rami uniti, menziona il seguente comando:
|
1
|
$git branch --merged |
Produzione:
Passaggio 1.1: quindi, elimina il ramo unito:
|
1
|
$git branch -d issue#902 |
Produzione:
Il ramo ‘issue#902’ è stato eliminato con successo poiché è già unito al ramo ‘master’.
Passaggio 2: ora elenchiamo i rami che non sono stati uniti nel master.
|
1
|
$git branch --no-merged |
Produzione
Passaggio 2.2: Infine, eliminiamo un ramo non unito con il seguente comando:
|
1
|
$git branch -d prepod |
Se provi a eliminare uno dei rami con un lavoro incompiuto, dì ramo “preprod”, git visualizza un messaggio di avviso.
Produzione
Ora, prima di dirti come recuperare i dati in questo articolo su Git Reflog, lascia che ti dica cosa succede esattamente quando un ramo viene eliminato e in quali circostanze può essere ripristinato il ramo.
Come e quando viene eliminato un ramo?
Poiché sappiamo che Git è un sistema di controllo della versione distribuito (DVCS), ogni macchina con il clone o una copia del repository funge sia da nodo che da hub . Ciò implica che ogni macchina avrà la propria copia dell’intero codice e cronologia del repository. Inutile dire; condividerai il tuo lavoro con gli altri e pubblicherai lo stesso.
Pertanto, in tali scenari, potrebbero verificarsi 3 casi in cui un ramo viene eliminato in uno scenario reale con molti contributori che lavorano su un progetto di grandi dimensioni. I seguenti potrebbero essere i casi:
Caso 1: uno sviluppatore può unire o eliminare il ramo
Si consideri uno scenario in cui uno sviluppatore unisce localmente il ramo di funzionalità nel ramo principale e quindi elimina il ramo di funzionalità utilizzando il comando ‘ git branch ‘ con il flag “ -d ” come mostrato nelle schermate precedenti.
Comando: ‘git branch -d branch_name’
Potrebbe anche capitare che lo sviluppatore decida di cestinare le modifiche sul ramo e decida di eliminare il ramo senza unirlo a nessun altro ramo utilizzando il seguente comando:
Comando: ‘git branch -D branch_name’
Con il comando precedente, lo sviluppatore elimina forzatamente il ramo sovrascrivendo l’avviso git
|
1
|
$git branch -D preprod |
Produzione
Nota : il ramo ‘preprod’ non sarà più elencato quando esegui il comando ‘git branch’. Quindi, il nostro lavoro salvato su questo ramo andrà perso.
Caso 2: uno sviluppatore elimina un ramo in un repository condiviso
Si consideri uno scenario in cui uno sviluppatore con accesso in lettura/scrittura tenta di eliminare il ramo remoto con forza utilizzando il comando ‘git push’ con il flag ‘–delete’.
|
1
|
$git push origin --delete quickfix |
Produzione
Oltre a questo, potrebbe esserci anche un caso in cui un utente non autorizzato o malintenzionato forza un push per eliminare il ramo remoto. In tal caso, il manutentore sarà in grado di recuperare il ramo ‘quickfix’ eliminato solo se lo sviluppatore aveva precedentemente verificato questo ramo. In questo scenario, il suo repository locale ne conterrà ancora i log di riferimento.
Se il responsabile della manutenzione non è in grado di recuperare il ramo, il proprietario del ramo che lo ha eliminato deve eseguire il ripristino dai suoi reflog locali.
Caso 3 – Uno script hook con super privilegi elimina il ramo
Questo potrebbe essere uno scenario raro ma, un possibile scenario in cui uno script hook viene attivato in un determinato evento dell’operazione git e la forza elimina i rami che non sono ancora uniti. Puoi considerare uno dei comandi sopra menzionati essere script in uno script hook con privilegi sudo.
Ora, che sai cosa succede, quando elimini il ramo, andiamo avanti con questo articolo su Git Reflog e vediamo come recuperare un ramo perso.
Recupera un ramo eliminato usando Git Reflog
Passaggio 1 : registri della cronologia di tutti i riferimenti
Ottieni un elenco di tutti i registri cronologici registrati locali per tutti i riferimenti (“master”, “uat” e “prepod”) in questo repository.
|
1
|
git reflog |
Passaggio 2 : identificare il timbro della cronologia
Come puoi fare riferimento dall’istantanea sopra, l’ ID commit evidenziato: e2225bb insieme al puntatore HEAD index:4 è quello in cui è stato creato il ramo ‘ preprod ‘ dal puntatore HEAD corrente che punta al tuo ultimo lavoro.
Passaggio 3 : recuperare
Per ripristinare il ramo ‘preprod ‘ utilizzare il comando ‘git checkout’ passando il riferimento del puntatore HEAD con l’id dell’indice – 4. Questo è il riferimento del puntatore quando è stato creato il ramo ‘preprod’ con l’ID del commit lungo evidenziato nella schermata di output.
|
1
|
git checkout -b preprod HEAD@{4} |
E voilà! Il ramo ‘ preprod ‘ viene ripristinato con tutto il codice sorgente.
NOTA : Fammi recuperare il comando ‘git checkout’ usato sopra e aiutarti a capire meglioIl comando ‘git checkout’ è un comando sovraccaricato (proprio come qualsiasi funzione Java sovraccaricata). Questa è la parte in cui viene recuperato il ramo effettivo.
Questo comando singolo esegue prima il check-out del timestamp della cronologia precedente indicato dal puntatore HEAD@{4} e quindi crea un ramo con il nome ‘preprod’ utilizzando l’opzione “-b”; così come cambia la tua directory di lavoro nel ramo appena creato.
Ciò implica che il ramo commutato sarà da ‘master’ a ‘preprod’ come indicato nella schermata di output. Ora puoi unirlo con il ramo “master” o “release” secondo il tuo modello di ramificazione.
Ora che sai come ripristinare un ramo, lascia che ti dica quale lavoro viene ripristinato quando viene ripristinato un ramo eliminato.
Quale lavoro viene ripristinato quando viene ripristinato il ramo eliminato?
I file che sono stati nascosti e salvati nell’elenco dell’indice di stash verranno ripristinati. Tutti i file non tracciati andranno persi. Inoltre, è una buona idea mettere sempre in scena e impegnare il tuo lavoro o metterlo da parte.
Per recuperare i riferimenti di log di un particolare ramo o tag, eseguire il comando – “git reflog <ref_name>”.
Esempio: per controllare i riferimenti di log del solo ramo ‘uat’ utilizzare il comando – “git reflog uat”.
Sottocomandi Git Reflog
git reflog
Comando per aprire la pagina di manuale
|
1
|
$git reflog --help |
Produzione
git reflog mostra
Mostra i log del riferimento fornito nella riga di comando.
|
1
|
git reflog show master@{0} |
git reflog scade
|
1
|
git reflog expire |
git reflog elimina
Questo comando cancella le singole voci dalla cronologia dei reflog.
|
1
|
git reflog delete |
git reflog esiste
Questo comando controlla se un ref (ramo o tag) ha un reflog – registra le voci della cronologia.
|
1
|
git reflog exists |
Oltre ai comandi sopra menzionati, il comando “Git Reflog” accetta vari sottocomandi e diverse opzioni a seconda dei sottocomandi sopra menzionati. Per ulteriori letture, esegui ” git reflog –help ” dalla finestra del terminale.