Introduzione

In questa pagina vengono mostrati gli strumenti di Git che rendono possibile il lavoro di più persone ad un progetto. Per fare questo verrà simulata in locale una situazione analoga a quella in cui si utilizzi un repository remoto.

Per poter seguire la seguente guida si presuppone:

• di aver creato il progetto gitproject come indicato;

• di aver elaborato il progetto come mostrato nelle pagine sul Commit e sul Branching.

Verranno creati nuovi repository (gitproject_2, gitproject_3, ecc..) che simuleranno repositori locali, mentre gitproject simulerà il repository remoto. Saranno quindi passati in rassegna i metodi di sincronizzazione.

Clonazione repository

In questo esempio verrà creato il progetto locale gitproject_2 sul quale verrà clonato il repository "remoto" gitproject.

1. Creare una nuova cartella in cui vogliamo creare il nuovo repository e spostarsi all'interno, digitare i seguenti comandi:

    mkdir ~/gitproject_2
    cd ~/gitproject_2

2. Clonare il repository gitproject nella cartella corrente ".":

    git clone ~/gitproject .

   Il comando sarebbe stato del tutto analogo anche se gitproject si fosse trovato su di un server esterno al proprio pc.

3. Consultare il log con git lg. Restituirà:

     *   b92d7ff (HEAD -> master, origin/master, origin/HEAD) - Mario Rossi : Merge branch 'gp-1' (18 minuti fa)
     |\  
     | * 05b43f8 (origin/gp-1) - Mario Rossi : Modificato codice per issue gp-1. (29 minuti fa)
     * | 158633d - Mario Rossi : Aggiunta cartella documentazione. (22 minuti fa)
     |/  
     * 5b235ad - Mario Rossi : Aggiunta data in stampa. (52 minuti fa)
     * b7c1ae2 - Mario Rossi : Aggiunti sorgenti e Makefile (59 minuti fa)
     * ba12845 - Mario Rossi : README aggiunto (85 minuti fa)

   Il log è quasi uguale a quello originale. Si nota la presenza di altri branch:

   • origin/master

   • origin/HEAD

   • origin/gp-1

   Questi sono i branch del repository remoto, che sono materialmente quelli creati nel repository originale. origin è il nome di default che Git da a un repository remoto.

4. Attraverso il comando remote elencare i repository remoti:

    git remote

   che restituirà:

    origin

   Allo stato attuale ne risulta uno solo, quello clonato.

   • Git puo avere più repository remoti associati al repository locale. Questo permette molta flessibilità, ma al momento verrà ignorato questo aspetto.

5. Attraverso il comando branch elencare i branch:

    git branch

   che risulterà:

     * master

   solamente un branch locale, master, sincronizzato con il master remoto (più precisamente nel punto in cui punta HEAD remoto).

Sincronizzazione manuale

In questo esempio verrà creato il progetto "locale" gitproject_3 nel quale verrà inizializzato il repository e in un secondo momento sarà sincronizzato manualmente con il repository "remoto" gitproject.

1. Creare una nuova cartella in cui vogliamo creare il nuovo repository e spostarsi all'interno, digitare nel terminale i seguenti comandi:

    mkdir ~/gitproject_3
    cd ~/gitproject_3

2. Inizializzare il repository:

    git init

   Verrà creata la cartella nascosta .git contenente l'intera cronologia e i dati di controllo e restituito un messaggio simile al seguente:

    Inizializzato repository Git vuoto in /home/mario/gitproject/.git/

3. Tramite il comando remote add aggiungere il repository remoto:

    git remote add origin ~/gitproject

4. Attraverso il comando remote elencare i repository remoti:

    git remote

   che restituirà:

    origin

5. Consultare il log con git lg, il cui output sarà

    fatal: bad default revision 'HEAD'

   Il repository è vuoto! Questo perché è stato aggiunto il repository remoto, ma non è ancora stata fatta la sincronizzazione. Il comando:

    ls -altr

   mostra la seguente situazione dei file nella cartella:

    totale 12
    drwxr-x--- 29 mario mario 4096 feb 17 02:29 ..
    drwxrwxr-x  3 mario mario 4096 feb 17 02:28 .
    drwxrwxr-x  7 mario mario 4096 feb 17 02:28 .git

Per poter sincronizzare il repository locale con quello remoto, occorre scaricare le modifiche. Questo viene fatto in due modi.

Primo metodo - Fetch + Merge

Si vuole prendere il contenuto del repository remoto e sincronizzare quello locale, in maniera da poter prendere le modifiche remote. Il comando fetch permette di scaricare in locale le modifiche remote, ma NON di applicarle.

1. Scaricare localmente le modifiche remote:

    git fetch origin

   Il comando restituirà:

    remote: Enumerazione degli oggetti in corso: 23, fatto.
    remote: Conteggio degli oggetti in corso: 100% (23/23), fatto.
    remote: Compressione oggetti in corso: 100% (15/15), fatto.
    remote: 23 oggetti totali (7 delta), 0 riutilizzati (0 delta), 0 riutilizzati nel file pack
    Decompressione degli oggetti in corso: 100% (23/23), 1.91 KiB | 325.00 KiB/s, fatto.
    Da /home/mario/gitproject
     * [nuovo branch]    gp-1       -> origin/gp-1
     * [nuovo branch]    master     -> origin/master

2. Il controllo dei file:

    ls -altr

   il cui output sarà:

    totale 12
    drwxrwxr-x  3 mario mario 4096 feb 17 02:28 .
    drwxr-x--- 29 mario mario 4096 feb 17 02:29 ..
    drwxrwxr-x  8 mario mario 4096 feb 17 02:32 .git

   ci conferma che nonostante siano state scaricate le modifiche remote, la cartella risulta essere ancora vuota. Questo perchè le modifiche scaricate sono interne alla directory .git ma non è ancora stata eseguita la sincronizzazione del tutto.

3. Consultare il log con git lg. Il cui output è:

     *   b92d7ff (origin/master) - Mario Rossi : Merge branch 'gp-1' (31 minuti fa)
     |\  
     | * 05b43f8 (origin/gp-1) - Mario Rossi : Modificato codice per issue gp-1. (42 minuti fa)
     * | 158633d - Mario Rossi : Aggiunta cartella documentazione. (35 minuti fa)
     |/  
     * 5b235ad - Mario Rossi : Aggiunta data in stampa. (65 minuti fa)
     * b7c1ae2 - Mario Rossi : Aggiunti sorgenti e Makefile (71 minuti fa)
     * ba12845 - Mario Rossi : README aggiunto (2 ore fa)

   Ci sono i repository remoti, ma non quello locale su cui ci troviamo. E dato che in quello locale non è stato ancora fatto niente, la nostra directory e' vuota.

4. Effetuare il merge del branch locale con quello remoto:

    git merge origin/master

5. Ricontrollare il log con git lg, il cui output ora sarà:

     *   b92d7ff (HEAD -> master, origin/master) - Mario Rossi : Merge branch 'gp-1' (32 minuti fa)
     |\  
     | * 05b43f8 (origin/gp-1) - Mario Rossi : Modificato codice per issue gp-1. (44 minuti fa)
     * | 158633d - Mario Rossi : Aggiunta cartella documentazione. (36 minuti fa)
     |/  
     * 5b235ad - Mario Rossi : Aggiunta data in stampa. (66 minuti fa)
     * b7c1ae2 - Mario Rossi : Aggiunti sorgenti e Makefile (73 minuti fa)
     * ba12845 - Mario Rossi : README aggiunto (2 ore fa)

   Adesso i due branch sono allineati (puntano allo stesso commit). Se vediamo il contenuto della cartella:

    ls -altr

   possiamo vedere che e' aggiornato:

    totale 32
    drwxr-x--- 29 mario mario 4096 feb 17 02:36 ..
    drwxrwxr-x  2 mario mario 4096 feb 17 02:36 src
    -rw-rw-r--  1 mario mario   16 feb 17 02:36 README
    -rw-rw-r--  1 mario mario  258 feb 17 02:36 Makefile
    drwxrwxr-x  2 mario mario 4096 feb 17 02:36 doc
    -rw-rw-r--  1 mario mario   10 feb 17 02:36 .gitignore
    drwxrwxr-x  5 mario mario 4096 feb 17 02:36 .
    drwxrwxr-x  8 mario mario 4096 feb 17 02:36 .git

Secondo metodo - Pull

Più rapido risulta l'utilizzo del comando pull che racchiude in se il fetch e il merge ed è il comando solitamente utilizzato in questi casi. Verrà creato un nuovo repository gitproject_4 che funga da progetto locale.

1. Creare una nuova cartella per ospitare il repository gitproject_4 e spostarsi all'interno, digitare nel terminale i seguenti comandi:

    mkdir ~/gitproject_4
    cd ~/gitproject_4

2. Inizializzare il repository, digitare nel terminale il seguente comando:

    git init

3. Aggiungere il repository remoto:

    git remote add origin ~/gitproject

4. Quindi eseguire il pull:

    git pull origin master

   che restituirà il seguente output:

    remote: Enumerazione degli oggetti in corso: 23, fatto.
    remote: Conteggio degli oggetti in corso: 100% (23/23), fatto.
    remote: Compressione oggetti in corso: 100% (15/15), fatto.
    remote: 23 oggetti totali (7 delta), 0 riutilizzati (0 delta), 0 riutilizzati nel file pack
    Decompressione degli oggetti in corso: 100% (23/23), 1.91 KiB | 325.00 KiB/s, fatto.
    Da /home/mario/gitproject
     * branch            master     -> FETCH_HEAD
     * [nuovo branch]    master     -> origin/master

5. Verificare il log con git lg che risulta essere:

     *   b92d7ff (HEAD -> master, origin/master) - Mario Rossi : Merge branch 'gp-1' (38 minuti fa)
     |\  
     | * 05b43f8 - Mario Rossi : Modificato codice per issue gp-1. (49 minuti fa)
     * | 158633d - Mario Rossi : Aggiunta cartella documentazione. (42 minuti fa)
     |/  
     * 5b235ad - Mario Rossi : Aggiunta data in stampa. (72 minuti fa)
     * b7c1ae2 - Mario Rossi : Aggiunti sorgenti e Makefile (79 minuti fa)
     * ba12845 - Mario Rossi : README aggiunto (2 ore fa)

È stato quindi creato un repository e sincronizzato il suo contenuto con un repository remoto.

Pubblicazione modifiche locali

Verranno qui effettuate delle modifiche nel repository locale gitproject_4.

1. Modificare il file ~/gitproject_4/src/main.cpp, digitando:

    sed -i '4 a \\tstd::cout << "Modifica da un altro repository" << std::endl;' src/main.cpp

2. Verificare il contenuto del file:

    cat src/main.cpp

   che risulterà essere:

    #include <iostream>
    int main() {
            std::cout << "sab 17 feb 2024, 01:26:54, CET: Benvenuti su Git!" << std::endl;
            std::cout << "Issue gp-1 implementata" << std::endl;
            std::cout << "Modifica da un altro repository" << std::endl;
            return 0;
    }

3. Applicare la modifica effettuando il commit:

    git commit -a -m "Aggiunta riga di output."

4. Consultare il log con git lg, il cui output ora sarà:

    * c1648d4 (HEAD -> master) - Mario Rossi : Aggiunta riga di output. (11 secondi fa)
    *   b92d7ff (origin/master) - Mario Rossi : Merge branch 'gp-1' (41 minuti fa)
    |\  
    | * 05b43f8 - Mario Rossi : Modificato codice per issue gp-1. (52 minuti fa)
    * | 158633d - Mario Rossi : Aggiunta cartella documentazione. (45 minuti fa)
    |/  
    * 5b235ad - Mario Rossi : Aggiunta data in stampa. (75 minuti fa)
    * b7c1ae2 - Mario Rossi : Aggiunti sorgenti e Makefile (82 minuti fa)
    * ba12845 - Mario Rossi : README aggiunto (2 ore fa)

   È stato creato un nuovo commit e dal log possiamo vedere che i due branch master, quello locale e quello remoto, non sono più (ovviamente) allineati.

Push

Per inviare le modifiche al repository remoto occorre utilizzare il comando push, specificando sempre il repository remoto e i branch da voler sincronizzare. In questo modo verranno mandate le modifiche nel repository in modo tale che gli altri utenti, una volta sincronizzati con quello remoto, possano percepire le modifiche avvenute.

1. Effettuare il push, digitare nel terminale il seguente comando:

    git push origin master

   questo sarà l'output visualizzato:

    Enumerazione degli oggetti in corso: 7, fatto.
    Conteggio degli oggetti in corso: 100% (7/7), fatto.
    Compressione delta in corso, uso fino a 8 thread
    Compressione oggetti in corso: 100% (3/3), fatto.
    Scrittura degli oggetti in corso: 100% (4/4), 395 byte | 395.00 KiB/s, fatto.
    4 oggetti totali (2 delta), 0 riutilizzati (0 delta), 0 riutilizzati nel file pack
    To /home/mario/gitproject
       f61b2e2..0ed9a58  master -> master

   Tuttavia si potrebbero visualizzare i seguenti messaggi di errore:

    remote: error: refusing to update checked out branch: refs/heads/master
    remote: error: Per impostazione predefinita, l'aggiornamento del branch corrente
    remote: in un repository non spoglio è negato, perché renderebbe l'indice
    remote: e l'albero di lavoro inconsistenti con i dati di cui si è eseguito
    remote: il push e richiederebbe 'git reset --hard' per ripristinare la
    remote: corrispondenza dell'albero di lavoro con HEAD.
    remote: 
    remote: Puoi impostare la variabile di configurazione
    remote: 'receive.denyCurrentBranch' a 'ignore' o 'warn' nel repository
    remote: remoto per consentire il push nel branch corrente; ciò nonostante,
    remote: questo non è raccomandato a meno che tu non provveda ad aggiornare
    remote: il suo albero di lavoro in modo che corrisponda a ciò di cui hai
    remote: eseguito il push in qualche altro modo.
    remote: 
    remote: Per non visualizzare più questo messaggio e mantenere comunque
    remote: il comportamento predefinito, imposta la variabile di
    remote: configurazione 'receive.denyCurrentBranch' a 'refuse'.
    To /home/mario/gitproject
     ! [remote rejected] master -> master (branch is currently checked out)
    error: push di alcuni riferimenti su '/home/mario/gitproject' non riuscito

   Questo perche' il nostro repository remoto non e' di tipo bare. Al momento verrà ignorato questo avviso.

2. Per poter ovviare al problema digitare il seguente comando:

    git config --global receive.denyCurrentBranch ignore

3. Effettuare nuovamente il push:

    git push origin master

4. Quando non è piu' necessario settare lo stesso valore a refuse:

    git config --global receive.denyCurrentBranch refuse

   per ripristinare lo stato originale.

Verifica

Verificare che tutto sia avvenuto nel modo corretto utilizzando un repository creato in precedenza.

1. Spostarsi nella directory del repository gitproject_3:

    cd ~/gitproject_3

2. Effettuare il pull per risincronizzarsi col server remoto, sul quale sono state apportate le modifche sviluppate sul gitproject_4:

    git pull origin master

   Verrà visualizzato il seguente output:

    remote: Enumerazione degli oggetti in corso: 7, fatto.
    remote: Conteggio degli oggetti in corso: 100% (7/7), fatto.
    remote: Compressione oggetti in corso: 100% (3/3), fatto.
    remote: 4 oggetti totali (2 delta), 0 riutilizzati (0 delta), 0 riutilizzati nel file pack
    Decompressione degli oggetti in corso: 100% (4/4), 375 byte | 375.00 KiB/s, fatto.
    Da /home/mario/gitproject
     * branch            master     -> FETCH_HEAD
       b92d7ff..c1648d4  master     -> origin/master
    Aggiornamento di b92d7ff..c1648d4
    Fast-forward
     src/main.cpp | 1 +
     1 file changed, 1 insertion(+)

3. Controllare il log con git lg che risulta essere:

    * c1648d4 (HEAD -> master, origin/master) - Mario Rossi : Aggiunta riga di output. (9 minuti fa)
    *   b92d7ff - Mario Rossi : Merge branch 'gp-1' (50 minuti fa)
    |\  
    | * 05b43f8 (origin/gp-1) - Mario Rossi : Modificato codice per issue gp-1. (61 minuti fa)
    * | 158633d - Mario Rossi : Aggiunta cartella documentazione. (54 minuti fa)
    |/  
    * 5b235ad - Mario Rossi : Aggiunta data in stampa. (84 minuti fa)
    * b7c1ae2 - Mario Rossi : Aggiunti sorgenti e Makefile (2 ore fa)
    * ba12845 - Mario Rossi : README aggiunto (2 ore fa)

   I repository risultano allineati.

Ulteriori risorse

• Guida a Git

CategoryProgrammazione