Diciamo che ho un PC desktop e un laptop, a volte lavoro sul desktop ea volte sul laptop.

Qual è il modo più semplice per spostare avanti e indietro un repository git?

Voglio che i repository git siano identici, in modo da poter continuare da dove avevo lasciato sull'altro computer.

Vorrei assicurarmi di avere gli stessi rami e tag su entrambi i computer.

Grazie Johan

Nota: so come farlo con SubVersion, ma sono curioso di sapere come funzionerebbe con git. Se è più facile, posso usare un terzo PC come server classico con cui i due PC possono sincronizzarsi.

Nota: entrambi i computer eseguono Linux.

Aggiornamento :

Quindi proviamo l'idea di XANI con un semplice repository git su un server e la sintassi del comando push di KingCrunch. In questo esempio sono presenti due client e un server.

Quindi creiamo prima la parte server.

ssh user@server
mkdir -p ~/git_test/workspace
cd ~/git_test/workspace
git --bare init

Quindi da uno degli altri computer provo a ottenere una copia del repository con clone:

git clone user@server:~/git_test/workspace/
Initialized empty Git repository in /home/user/git_test/repo1/workspace/.git/
warning: You appear to have cloned an empty repository.

Quindi vai in quel repository e aggiungi un file:

cd workspace/
echo "test1" > testfile1.txt
git add testfile1.txt
git commit testfile1.txt -m "Added file testfile1.txt"
git push origin master

Ora il server viene aggiornato con testfile1.txt.

Comunque, vediamo se riusciamo a ottenere questo file dall'altro computer.

mkdir -p ~/git_test/repo2
cd ~/git_test/repo2
git clone user@server:~/git_test/workspace/
cd workspace/
git pull

E ora possiamo vedere il file di prova.

A questo punto possiamo modificarlo con qualche contenuto in più e aggiornare nuovamente il server.

echo "test2" >> testfile1.txt
git add testfile1.txt
git commit -m "Test2"
git push origin master

Quindi torniamo al primo client e facciamo un git pull per vedere il file aggiornato. E ora posso spostarmi avanti e indietro tra i due computer e aggiungerne un terzo se lo desidero.

Penso che ci siano più approcci. Descriverò solo come gestisco questo

Ho un netbook come server 24 ore su 24, 7 giorni su 7, che contiene più repository git. Da / a lì spingo e tiro le modifiche tramite SSH. Per l'accesso dall'esterno utilizzo dyndns.org. Funziona bene, soprattutto perché ho più di due sistemi, che richiedono l'accesso ad alcuni dei repository.

Aggiornamento: un piccolo esempio. Diciamo che il mio netbook si chiama "netbook". Creo un repository lì

$ ssh username@netbook.local
$ cd ~/git
$ mkdir newThing
$ cd newThing
$ git init --bare

Sul mio desktop ne creerò quindi un clone. Forse aggiungerò anche alcuni file

$ git clone username@netbook.local:/home/username/git/newThing
$ git add .
$ git commit -m "Initial"
$ git push origin master

Sui miei portatili farò (prima) lo stesso, ma per l'accesso remoto (dall'esterno della mia LAN), aggiungerò anche l'indirizzo esterno.

$ git clone username@netbook.local:/home/username/git/newThing
$ git remote add externalName username@mydyndns.home-ip.org:/home/username/git/newThing
$ git pull externalName master

È solo il modo in cui funziona git (/ git workflows). Puoi aggiungere tutti i repository remoti che desideri. Non importa se due o più si riferiscono agli stessi repository "fisici". Non hai bisogno di un proprio "server" locale, puoi usare qualsiasi server pubblico, a cui hai accesso ssh. E ovviamente non hai bisogno di un server pubblico, se non hai bisogno dell'accesso dall'esterno. Il repository nudo può anche essere sul sistema desktop ed è quindi possibile creare un repository di copia di lavoro all'interno del filesystem locale.

$ mkdir myRepo; cd myRepo
$ git init --bare
$ cd /path/to/myProject
$ git remote add origin /path/to/myRepo
$ git add .; git commit -m "Initial"; git push origin master

Questo è il modo, come lo gestisco, e per me funziona abbastanza bene (se non perfetto;))

Qualcosa da leggere: http://progit.org/ Libro davvero buono. -

Vorrei clonare il repository da una casella all'altra, quindi impostare i due repository in modo che io possa solo git fetchdall'altra casella.

Rinominare il telecomando da original nome dell'altra casella rende i rami remoti più facili da leggere.

Nota che usando semplicemente git fetch(e non git push), funziona bene con i repository non nudi:

[user@foo repo]$ git fetch -v bar

[user@bar repo]$ git fetch -v foo

Il modo più semplice: repository centrale creato con --bare(quindi nessun file estratto, solo roba .git) o ​​github

"Distribuito" avrà questo aspetto:

Impostare:

1. Sul laptop: git remote add desktop ssh://user@desktop/home/user/repo/path
2. Sul desktop: git remote add laptop ssh://user@laptop/home/user/repo/path

Sincronizzazione:

git pull laptop/desktop (push non funzionerà molto bene su repository non nudi perché git non modificherà i file estratti quando si spinge al repository remoto)

Oppure crea un repo su pendrive;)

Che ne dici di usare semplicemente rsync?

Non potresti semplicemente creare un repository remoto su GitHub, BitBucket o GitLab? (Le ultime due società offrono repository privati ​​gratuiti illimitati). Quando finisci la giornata di lavoro, usa semplicemente git pushper inviare le modifiche al repository remoto. Quando torni a casa, basta git pulltrasferire le modifiche dal lavoro sulla macchina di casa. Allo stesso modo, quando finisci a casa, fallo git pushe poi quando torni al lavoro, fallo git pull.

Qual è il modo più semplice per spostare un repository git avanti e indietro [tra 2 computer]?

Scenario 1: Lavoro (modifica codice e file) esclusivamente su PC1 ma voglio avere una copia duplicata dei file (es: per costruire l'intero codice base) anche su PC2.

Sincronizza da PC1 a PC2 in <1 minuto su un hotspot Wi-Fi utilizzando <25 MB di dati:

Lavoro su un computer debole con cui viaggio (un laptop), ma costruisco su un computer più potente situato altrove. Uso sempre git per sincronizzare dal mio laptop all'altro computer utilizzando uno script. Ho appena digitato questo comando per eseguirlo:

sync_git_repo_from_pc1_to_pc2

Questo è tutto! Di solito ci vogliono circa 25 MB di dati e da ~ 30 secondi a 1 minuto, anche quando si utilizza un hotspot Wi-Fi del telefono cellulare e si lavora su un repository di dozzine di gigabyte . Sono collegato a PC2, quindi lo faccio git log -1su PC2 per verificare che la sincronizzazione abbia funzionato, quindi eseguo il comando build. Funziona perfettamente. Dagli Un colpo. Vedere i collegamenti seguenti per i dettagli.

Nota: il repository clonato su PC2 sarà su un ramo git denominato somename_SYNC. Modifica lo script in modo appropriato se desideri che abbia lo stesso nome di ramo invece di utilizzare sempre un "ramo SYNC". È possibile modificare lo script per ottenere un effetto più simile allo Scenario 2 di seguito, se lo si desidera. Tuttavia, eseguire lo Scenario 2 manualmente non è difficile, quindi potresti voler continuare a eseguire lo Scenario 2 manualmente. È lo scenario 1 in cui lo script automatizzato è il più vantaggioso e fa risparmiare tempo, poiché consente un flusso di lavoro di "modifica, sincronizzazione, creazione" facile e rapido in cui la "modifica" avviene su PC1, la "sincronizzazione" viene eseguita da PC1 ma influisce anche PC2, e la "build" avviene su PC2.

Collegamenti:

1. Istruzioni complete per la configurazione e l'installazione qui:
   lavora su un progetto remoto con Eclipse tramite SSH
2. Leggimi, documentazione e repo qui: https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles/blob/master/useful_scripts/README_git-sync_repo_from_pc1_to_pc2.md .
3. Lo script esatto in questione è qui:
   https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles/blob/master/useful_scripts/sync_git_repo_from_pc1_to_pc2.sh

Scenario 2: lavoro (modifica codice e file) su più computer e desidero essere in grado di modificare lo stesso repository di codice da qualsiasi computer nel mondo:

Voglio che i repository git siano identici, in modo da poter continuare da dove avevo lasciato sull'altro computer. Vorrei assicurarmi di avere gli stessi rami e tag su entrambi i computer.

1. Vai su https://github.com e crea un account e facoltativamente (consigliato) configura le chiavi ssh .

2. Ora usa la loro interfaccia web per creare un nuovo repository.

   1. A partire dall'anno 2020 o prima, GitHub consente anche repository privati ​​gratuiti , quindi funziona bene anche per progetti privati ​​closed-source.

3. Trova il nuovo URL del repository ssh o https clone. Es: git@github.com: ElectricRCAircraftGuy / eRCaGuy_dotfiles.git o https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles.git .

4. Clona il progetto su PC1. Ex:

    git@github.com:ElectricRCAircraftGuy/eRCaGuy_dotfiles.git
    cd eRCaGuy_dotfiles
   

5. E ripeti lo stesso identico comando clone su PC2.

6. Ora su PC1, apporta alcune modifiche, eseguine il commit e inviali al tuo repository "remoto" su GitHub:

    # edit some files, then do the following
    git add -A  # stage ("add") all changed files to be committed 
    git commit  # commit them
    git push    # push them to your remote github repo
   

7. Ora su PC2, inserisci le tue modifiche:

    # pull all changes from github (which includes the changes
    # you just pushed from PC1) to PC2
    git pull  
   

8. Ora puoi modificare i file su PC2, eseguirne il commit e inviarli a GitHub utilizzando i comandi mostrati solo 2 passaggi sopra, quindi da PC1 puoi eseguire git pullper inserire tali modifiche da PC2.

9. Continua a fare questo processo, come richiesto, lavorando su PC1 O PC2 e condividendo facilmente i file e suddividendo il tuo lavoro tra i due computer. Ricorda solo che tutte le tue modifiche devono essere salvate e inviate a GitHub su un PC prima di poterle controllare (estrarle) e continuare a lavorare sull'altro PC.

10. Se ti capita di trovarti in una situazione in cui i file sono un po 'fuori sincronia tra i due PC, dovrai forse usare alcuni rami extra, fare alcune unioni, risolvere conflitti, ecc. con un piccolo team in cui lavorate tutti sullo stesso repo. Google è tuo amico. Git è molto molto molto potente e ha un comando, un set di comandi o un flusso di lavoro per quasi tutto.

Bene, puoi spingere e tirare (tramite Git) al server che potresti potenzialmente configurare. Oppure puoi archiviare i tuoi repository su GitHub e usarli come bridge di sincronizzazione.

Potresti creare il repository su uno qualsiasi dei tuoi computer, probabilmente quello desktop e spingerlo / trascinarlo sia dal laptop che da se stesso.