Disons que j'ai un ordinateur de bureau et un ordinateur portable, et parfois je travaille sur le bureau et parfois je travaille sur l'ordinateur portable.

Quelle est la manière la plus simple de déplacer un dépôt git d'avant en arrière?

Je veux que les référentiels git soient identiques, afin que je puisse continuer là où j'ai laissé sur l'autre ordinateur.

Je voudrais m'assurer que j'ai les mêmes branches et balises sur les deux ordinateurs.

Merci Johan

Remarque: je sais comment faire cela avec SubVersion, mais je suis curieux de savoir comment cela fonctionnerait avec git. Si c'est plus simple, je peux utiliser un troisième pc comme serveur classique avec lequel les deux pc: s peuvent se synchroniser.

Remarque: les deux ordinateurs exécutent Linux.

Mise à jour :

Essayons donc l'idée de XANI: s avec un dépôt git nu sur un serveur et la syntaxe de commande push de KingCrunch. Dans cet exemple, il y a deux clients et un serveur.

Créons donc d'abord la partie serveur.

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

Donc, à partir de l'un des autres ordinateurs, j'essaye d'obtenir une copie du dépôt avec 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.

Ensuite, allez dans ce dépôt et ajoutez un fichier:

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

Le serveur est maintenant mis à jour avec testfile1.txt.

Quoi qu'il en soit, voyons si nous pouvons obtenir ce fichier depuis l'autre ordinateur.

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

Et maintenant, nous pouvons voir le fichier de test.

À ce stade, nous pouvons le modifier avec un peu plus de contenu et mettre à nouveau le serveur à jour.

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

Ensuite, nous retournons au premier client et faisons un git pull pour voir le fichier mis à jour. Et maintenant, je peux aller et venir entre les deux ordinateurs, et en ajouter un troisième si je le souhaite.

Je pense qu'il existe plusieurs approches. Je vais juste décrire comment je gère ça

J'ai un netbook en tant que serveur 24/7, qui contient plusieurs référentiels git. De / Vers là, je pousse et tire les modifications via SSH. Pour accéder de l'extérieur, j'utilise dyndns.org. Cela fonctionne bien, en particulier parce que j'ai plus de deux systèmes, qui ont besoin d'accéder à certains des référentiels.

Mise à jour: un petit exemple. Disons que mon netbook s'appelle "netbook". J'y crée un référentiel

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

Sur mon bureau, je vais créer un clone de celui-ci. Peut-être que je vais aussi ajouter des fichiers

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

Sur mes portables, je ferai (d'abord) de même, mais pour l'accès à distance (depuis l'extérieur de mon LAN), j'ajouterai également l'adresse externe.

$ 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

C'est juste la façon dont git (/ git workflows) fonctionne. Vous pouvez ajouter autant de référentiels distants que vous le souhaitez. Cela n'a pas d'importance si deux ou plus font référence aux mêmes référentiels "physiques". Vous n'avez pas besoin d'un propre "serveur" local, vous pouvez utiliser n'importe quel serveur public auquel vous avez accès ssh. Et bien sûr, vous n'avez pas du tout besoin d'un serveur public, si vous n'avez pas besoin d'un accès de l'extérieur. Le référentiel nu peut également se trouver sur le système de bureau et vous pouvez ensuite créer un référentiel de copie de travail dans le système de fichiers local.

$ 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

C'est comme ça, comment je gère ça, et moi pour moi ça marche assez bien (sinon parfait;))

Quelque chose à lire: http://progit.org/ Très bon livre.

Je clonerais le dépôt d'une boîte à l'autre, puis configurerais les deux dépôts afin que je puisse simplement git fetchpartir de l'autre boîte.

Renommer la télécommande de originpar le nom de l'autre boîte facilite la lecture des branches distantes.

Notez qu'en utilisant simplement git fetch(et non git push), cela fonctionne bien avec des référentiels non nus:

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

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

Moyen le plus simple: dépôt central créé avec --bare(donc pas de fichiers extraits, uniquement des trucs .git), ou github

"Distribué" ressemblera à ça:

Installer:

1. Sur ordinateur portable: git remote add desktop ssh://user@desktop/home/user/repo/path
2. Sur le bureau: git remote add laptop ssh://user@laptop/home/user/repo/path

Synchronisation:

git pull laptop/desktop (push ne fonctionnera pas très bien sur les dépôts non nus car git ne modifiera pas les fichiers extraits lors du transfert vers le dépôt distant)

Ou, faites un repo sur clé USB;)

Que diriez-vous simplement d'utiliser rsync?

Ne pourriez-vous pas simplement créer un référentiel distant sur GitHub, BitBucket ou GitLab? (Les deux dernières sociétés offrent des référentiels privés gratuits et illimités). Lorsque vous avez terminé la journée de travail, utilisez simplement git pushpour transmettre vos modifications au référentiel distant. Lorsque vous rentrez chez vous, faites simplement git pullpour transférer vos modifications du travail sur votre ordinateur personnel. De même, lorsque vous avez terminé à la maison, faites git push, puis lorsque vous revenez au travail, faites git pull.

Quelle est la manière la plus simple de déplacer un référentiel git dans les deux sens [entre 2 ordinateurs]?

Scénario 1: Je travaille (éditer le code et les fichiers) exclusivement sur PC1 mais je souhaite avoir une copie en double des fichiers (ex: pour construire toute la base de code) également sur PC2.

Synchronisez de PC1 à PC2 en <1 minute sur un point d'accès wifi tout en utilisant <25 Mo de données:

Je travaille sur un ordinateur faible avec lequel je voyage (un ordinateur portable), mais sur un ordinateur plus puissant situé ailleurs. J'utilise git tout le temps pour synchroniser mon ordinateur portable avec l'autre ordinateur à l'aide d'un script. Je viens de taper cette commande pour l'exécuter:

sync_git_repo_from_pc1_to_pc2

C'est ça! Cela prend généralement environ 25 Mo de données et environ 30 secondes à 1 minute, même lorsque vous utilisez un point d'accès Wi-Fi pour téléphone portable et que vous travaillez sur un dépôt d'une taille de dizaines de gigaoctets . Je suis ssh'ed dans PC2, donc je fais git log -1sur PC2 pour vérifier que la synchronisation a fonctionné, puis j'exécute la commande de construction. Fonctionne parfaitement. Donner un coup de feu. Voir les liens ci-dessous pour plus de détails.

Remarque: le repo cloné sur PC2 sera sur une branche git nommée somename_SYNC. Modifiez le script de manière appropriée si vous souhaitez qu'il ait le même nom de branche au lieu de toujours utiliser une "branche SYNC". Il est possible de modifier le script pour obtenir un effet plus semblable au scénario 2 ci-dessous si vous le souhaitez. Néanmoins, faire le scénario 2 manuellement n'est pas difficile, vous voudrez peut-être simplement continuer à faire le scénario 2 manuellement. C'est le scénario 1 où le script automatisé est le plus avantageux et le plus rapide, car il permet un flux de travail simple et rapide «modifier, synchroniser, construire» où «modifier» a lieu sur PC1, «synchroniser» est exécuté à partir de PC1 mais affecte également PC2, et "build" a lieu sur PC2.

Liens:

1. Instructions complètes de configuration et d'installation ici:
   Travaillez sur un projet distant avec Eclipse via SSH
2. Lisez-moi, documentation et dépôt ici: https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles/blob/master/useful_scripts/README_git-sync_repo_from_pc1_to_pc2.md .
3. Le script exact en question est ici:
   https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles/blob/master/useful_scripts/sync_git_repo_from_pc1_to_pc2.sh

Scénario 2: Je travaille (modifier le code et les fichiers) sur plusieurs ordinateurs et je souhaite pouvoir modifier le même référentiel de code à partir de n'importe quel ordinateur dans le monde:

Je veux que les référentiels git soient identiques, afin que je puisse continuer là où j'ai laissé sur l'autre ordinateur. Je voudrais m'assurer que j'ai les mêmes branches et balises sur les deux ordinateurs.

1. Accédez à https://github.com et créez un compte et, éventuellement (recommandé), configurez les clés ssh .

2. Utilisez maintenant leur interface Web pour créer un nouveau référentiel.

   1. À partir de l'année 2020 ou avant, GitHub autorise également les dépôts privés gratuits , ce qui fonctionne bien même pour les projets privés à source fermée.

3. Recherchez la nouvelle URL de clonage ssh ou https du référentiel. Ex: git@github.com: ElectricRCAircraftGuy / eRCaGuy_dotfiles.git ou https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles.git .

4. Clonez le projet sur PC1. Ex:

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

5. Et répétez exactement la même commande de clonage sur PC2.

6. Maintenant sur PC1, apportez quelques modifications, validez-les et transférez-les dans votre référentiel "distant" sur 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. Maintenant sur PC2, intégrez vos modifications:

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

8. Vous pouvez maintenant éditer des fichiers sur PC2, les valider et les pousser vers github en utilisant les commandes indiquées juste 2 étapes ci-dessus, puis à partir de PC1, vous pouvez exécuter git pullpour extraire ces modifications de PC2.

9. Continuez à faire ce processus, si nécessaire, en travaillant sur PC1 OU PC2, et partagez facilement les fichiers et répartissez votre travail entre les deux ordinateurs. N'oubliez pas que toutes vos modifications doivent être validées et transmises à github sur un PC avant de pouvoir les extraire (les extraire) et continuer à travailler sur l'autre PC.

10. Si jamais vous vous trouvez dans une situation où les fichiers sont un peu désynchronisés entre les deux PC, vous devrez peut-être utiliser des branches supplémentaires, faire des fusions, résoudre des conflits, etc. Ensuite, cela devient plus similaire au travail avec une petite équipe où vous travaillez tous sur le même repo. Google est ton ami. Git est très très très puissant et dispose d'une commande, d'un ensemble de commandes ou d'un workflow pour à peu près tout.

Eh bien, vous pouvez pousser et tirer (via Git) vers le serveur que vous pourriez potentiellement configurer. Ou vous pouvez stocker vos dépôts sur GitHub et l'utiliser comme pont de synchronisation.

Vous pouvez créer le référentiel sur n'importe lequel de vos ordinateurs, probablement celui du bureau et y pousser / tirer à la fois depuis l'ordinateur portable et lui-même.