Je souhaite utiliser le contrôle de version, mais pour des raisons de sécurité, le serveur sur lequel je travaille n'a pas d'accès Internet: je ne peux déplacer des fichiers que sur une clé USB. Puis-je toujours utiliser Git avec cette configuration? Puis-je créer de petits correctifs que je peux appliquer sur un référentiel Git?

Bien sûr, rien dans Git n’exige de protocole particulier. Le client standard prend immédiatement en charge HTTP (S), SSH, le protocole Git personnalisé et, ce qui est important, le protocole local . Cela prend juste un chemin vers un .gitrépertoire local , qui peut être dans un répertoire de travail ( /path/to/project/.git) ou simplement un répertoire nu ( /path/to/project.git), bien que le nommage ne soit qu'une convention.

Cela signifie que vous pouvez bien sûr ajouter un lecteur flash comme télécommande:

git remote add origin /mnt/flashdrive/foo.git

ou sous Windows:

git remote add origin F:\foo.git

Ou même l'ajouter comme une télécommande supplémentaire avec un nom différent (si vous préférez originpointer vers un serveur Internet quelque part):

git remote add flashdrive /mnt/flashdrive/foo.git

Ensuite, vous pouvez simplement pousser / tirer vers / depuis cette télécommande comme une autre.

Si vous lisez la documentation , vous remarquerez qu'il existe également un file://protocole qui se comporte légèrement différemment. Il est recommandé d’utiliser un chemin local car cela utilisera des optimisations supplémentaires - si vous utilisez le file://protocole, alors git utilisera des composants réseau standard (pour parler au disque local), ce qui est plus lent.

Sur un seul ordinateur, rien de spécial n'est nécessaire. Exécutez git initle répertoire souhaité et travaillez avec Git comme vous le feriez normalement.

Pour synchroniser un référentiel sur plusieurs ordinateurs, il existe plusieurs méthodes.

Méthode 1a (pas de réseau du tout): vous pouvez créer un «référentiel nu» sur la clé USB, puis y appuyer et en extraire comme vous le feriez avec tout autre référentiel distant. En d'autres termes, les opérations de référentiel via des chemins locaux ne sont pas différentes des opérations via des URL SSH ou HTTPS.

1. Créez un référentiel 'distant':

   $ git init --bare /mnt/Stick/Repositories/Large_Project.git
   

2. Dans l'ordinateur 1, tout y est:

   $ cd ~/Large_Project
   $ git remote add usb /mnt/Stick/Repositories/Large_Project.git
   $ git push usb master
   

3. Dans l'ordinateur 2, bien, comme toujours.

   $ git remote add usb /mnt/Stick/Repositories/Large_Project.git
   $ git pull usb
   

(Vous pouvez également pousser / récupérer / extraire directement depuis une URL ou un chemin.)

Méthode 1b (réseau interne): Si vous avez un serveur interne avec SSH disponible et si Git est installé, vous pouvez procéder comme ci - dessus , il vous suffit de spécifier une adresse SSH à l'aide de la syntaxe [user@]host:pathou ssh://[user@]host/path.

1. Créez un référentiel 'distant' en s'exécutant git init --bare <somepath.git>sur le serveur désigné (via SSH).

2. Dans l'ordinateur 1, de la même manière que démontré précédemment.

   $ git remote add origin myserver.example.com:Gits/Large_Project.git
   

   Ou si vous préférez:

   $ git remote add origin ssh://myserver.example.com/Gits/Large_Project.git
   

3. Dans l'ordinateur 2, encore la même chose que la méthode 1a.

Méthode 2: vous pouvez créer des «ensembles de transfert» qui archivent une liste donnée de commises dans un seul fichier.

Malheureusement, les commandes de regroupement ne se souviennent pas automatiquement de ce qui était déjà groupé la dernière fois. Il est donc nécessaire de marquer manuellement ou de conserver les notes. Je prendrai juste les exemples du manuel de git-bundle.

1. Sur l’ordinateur 1, créez un ensemble de toute la branche:

   $ cd ~/Large_Project
   $ git bundle create /mnt/Stick/Project.bundle master
   $ git tag -f last-bundled master
   

2. Dans l'ordinateur 2, tirez de la liasse comme s'il s'agissait d'un référentiel:

   $ cd ~/Large_Project
   $ git pull /mnt/Stick/Project.bundle
   

Les paquets suivants ne doivent pas nécessairement être emballés master- ils peuvent uniquement emballer les commits récemment ajoutés last-bundled..master.

1. Dans l’ordinateur 1, créez un ensemble des nouveaux commits ajoutés:

   $ cd ~/Large_Project
   $ git bundle create /mnt/Stick/Project.bundle last-bundled..master
   $ git tag -f last-bundled master
   

2. Comme ci-dessus.

git bundle create

L’une des méthodes consiste à utiliser le stockage externe pour échanger des données entre des référentiels: git bundle . De cette façon, vous ne disposez que de fichiers uniques pour chaque transfert, et non de référentiels Git intermédiaires.

Chaque "git push" se transforme en création d'un fichier, "git fetch" récupère les éléments de ce fichier.

Session de démonstration

Créer le premier dépôt et faire le premier "push"

gitbundletest$ mkdir repo1

gitbundletest$ cd repo1

repo1$ git init
Initialized empty Git repository in /tmp/gitbundletest/repo1/.git/
repo1$ echo 1 > 1 && git add 1 && git commit -m 1
[master (root-commit) c8b9ff9] 1
 1 file changed, 1 insertion(+)
 create mode 100644 1

repo1$ git bundle create /tmp/1.bundle master HEAD
Enumerating objects: 3, done.
Counting objects: 100% (3/3), done.
Writing objects: 100% (3/3), 384 bytes | 384.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)

"clonage" vers le deuxième référentiel (c.-à-d. le deuxième ordinateur):

gitbundletest$ git clone /tmp/1.bundle repo2
Cloning into 'repo2'...
Receiving objects: 100% (3/3), done.

gitbundletest$ cd repo2/

repo2$ cat 1
1

Faire quelques changements et les "pousser" dans un autre fichier bundle:

repo2$ echo 2 > 1 && git add 1 && git commit -m 2
[master 250d387] 2
 1 file changed, 1 insertion(+), 1 deletion(-)

repo2$ git bundle create /tmp/2.bundle origin/master..master origin/HEAD..HEAD
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Writing objects: 100% (3/3), 415 bytes | 415.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)

"extraire" les modifications dans le premier référentiel:

repo2$ cd ../repo1

repo1$ git pull /tmp/2.bundle 
Receiving objects: 100% (3/3), done.
From /tmp/2.bundle
 * branch            HEAD       -> FETCH_HEAD
Updating c8b9ff9..250d387
Fast-forward
 1 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

repo1$ cat 1
2

Contrairement au premier paquet, le second ne contient qu'un historique partiel de Git et n'est pas directement clonable:

repo1$ cd ..

gitbundletest$ git clone /tmp/2.bundle repo3
Cloning into 'repo3'...
error: Repository lacks these prerequisite commits:
error: c8b9ff94942039469fa1937f6d38d85e0e39893a 
fatal: bad object 250d38747656401e15eca289a27024c61e63ed68
fatal: remote did not send all necessary objects

Il est désavantageux d'utiliser des ensembles dont vous avez besoin pour spécifier manuellement la plage de validations que chaque ensemble doit contenir. Contrairement à git push, git bundlene garde pas trace de ce qui était dans le paquet précédent, vous devez ajuster manuellement refs/remotes/origin/masterou les paquets seraient plus gros que ce qu’il pourrait être.

Vous devez d'abord installer Git . Ensuite, pour créer un nouveau référentiel, exécutez-le dans le dossier que vous avez copié:

git init

Vous pouvez ensuite ajouter les fichiers pour lesquels vous souhaitez contrôler la version git add(ajouter -apour tous les fichiers) et commencer à valider les modifications ( git commit).

Vous n’avez pas à appuyer sur une télécommande, vous pouvez travailler sur votre historique local ( git log).

Pour plus d'informations, consultez:

• Tutoriel Git .
• git - le guide simple

Pousser / tirer sans internet

En utilisant la git pushcommande, il est possible de pousser sur SSH (en utilisant la connexion locale, intranet):

git remote add server ssh://[user@]host.xz[:port]/path/to/dev/repo.git/
git push server

ou en poussant dans le dossier:

git push /mnt/usb/my_repo

Cela suppose que vous ayez deux copies de votre référentiel.

La même chose avec tirer, par exemple

git pull /mnt/usb/my_repo

Patcher

Pour appliquer des correctifs, vous pouvez utiliser la patchcommande ou git apply.

Voir: Créer un fichier de correctif ou un fichier diff à partir du référentiel git et l'appliquer à un autre référentiel git différent .

Vous pouvez aussi utiliser Git localement. Ensuite, vos commits ne sont stockés que localement et vous avez toujours le contrôle de version (et pouvez différer / fusionner, etc.), mais vous ne pouvez tout simplement pas accéder au référentiel à partir d’un autre ordinateur.

Vous pouvez démarrer un référentiel Git local en l'exécutant git initdans votre dossier local. Comme décrit ici .