git-bundle - En ligne dans le Cloud

PROGRAMME:

Nom

git-bundle - Déplacer des objets et des références par archive

SYNOPSIS

jet pack créer
jet pack Vérifier
jet pack têtes de liste [ ...]
jet pack dégrouper [ ...]

DESCRIPTION

Certains workflows nécessitent qu'une ou plusieurs branches de développement sur une machine soient
répliqué sur une autre machine, mais les deux machines ne peuvent pas être directement connectées, et
par conséquent, les protocoles Git interactifs (git, ssh, rsync, http) ne peuvent pas être utilisés. Cette
La commande prend en charge jet rapporter et jet tirer opérer en emballant des objets et
références dans une archive sur la machine d'origine, puis les importer dans une autre
référentiel utilisant jet rapporter et jet tirer après avoir déplacé l'archive d'une manière ou d'une autre (par exemple, en
sneakernet). Comme il n'existe aucun lien direct entre les référentiels, l'utilisateur doit
spécifier une base pour le bundle qui est détenu par le référentiel de destination : le bundle
suppose que tous les objets de la base sont déjà dans le référentiel de destination.

OPTIONS

créer
Utilisé pour créer un bundle nommé filet. Cela nécessite le git-rev-list-args arguments à
définir le contenu du paquet.

Vérifier
Utilisé pour vérifier qu'un fichier bundle est valide et s'appliquera proprement au
dépôt. Cela inclut des vérifications sur le format du paquet lui-même ainsi que la vérification que
les commits prérequis existent et sont entièrement liés dans le référentiel actuel. jet
pack affiche une liste des commits manquants, le cas échéant, et se termine avec un statut différent de zéro.

têtes de liste
Répertorie les références définies dans le bundle. Si elle est suivie d'une liste de références, seule
les références correspondant à celles données sont imprimées.

dégrouper
Passe les objets du lot à jet pack d'index pour le stockage dans le référentiel, puis
imprime les noms de toutes les références définies. Si une liste de références est fournie, seule
les références correspondant à celles de la liste sont imprimées. Cette commande est vraiment de la plomberie,
destiné à être appelé uniquement par jet rapporter.


Une liste d'arguments, acceptable pour jet parse-rév et jet liste des reves (et contenant un
ref nommé, voir SPÉCIFICATION DES RÉFÉRENCES ci-dessous), qui spécifie les objets spécifiques et
références aux transports. Par exemple, master~10..master provoque le master actuel
référence à emballer avec tous les objets ajoutés depuis son 10ème commit d'ancêtre.
Il n'y a pas de limite explicite au nombre de références et d'objets pouvant être
emballé.

[ ...]
Une liste de références utilisée pour limiter les références signalées comme disponibles. C'est
principalement utilisé pour jet rapporter, qui s'attend à ne recevoir que les références demandées
pour et pas nécessairement tout dans le pack (dans ce cas, jet pack Agit comme jet
chercher-pack).

EN PRÉCISANT Références

jet pack n'empaquetera que les références qui sont affichées par jet show-réf: Ceci comprend
têtes, balises et têtes distantes. Les références telles que master~1 ne peuvent pas être empaquetées, mais sont
parfaitement adapté pour définir la base. Plusieurs références peuvent être emballées, et
plusieurs bases peuvent être spécifiées. Les objets conditionnés sont ceux qui ne figurent pas dans le
union des bases données. Chaque base peut être spécifiée explicitement (par exemple ^master~10), ou
implicitement (par exemple master~10..master, --since=10.days.ago master).

Il est très important que la base utilisée soit détenue par la destination. C'est bien de se tromper
le côté de la prudence, ce qui fait que le fichier bundle contient des objets déjà dans le
destination, car ils sont ignorés lors du déballage à destination.

EXEMPLE

Supposons que vous souhaitiez transférer l'historique d'un référentiel R1 sur la machine A vers un autre
référentiel R2 sur la machine B. Pour une raison quelconque, la connexion directe entre A et B n'est pas
autorisé, mais nous pouvons déplacer les données de A vers B via un mécanisme (CD, e-mail, etc.). Nous voulons
mise à jour R2 avec développement fait sur le branch master en R1.

Pour amorcer le processus, vous pouvez d'abord créer un bundle qui n'a aucune base. Tu
peut utiliser une balise pour se souvenir du dernier commit que vous avez traité, afin de faciliter les choses
pour mettre à jour ultérieurement l'autre référentiel avec un bundle incrémentiel :

machineA$ cd R1
machineA$ git bundle créer file.bundle master
machineA$ balise git -f maître lastR2bundle

Ensuite, vous transférez file.bundle vers la machine cible B. Parce que ce bundle ne
nécessitent l'extraction de tout objet existant, vous pouvez créer un nouveau référentiel sur la machine B
en le clonant :

machineB$ git clone -b master /home/me/tmp/file.bundle R2

Cela définira une télécommande appelée "origine" dans le référentiel résultant qui vous permettra de récupérer
et tirez du paquet. Le fichier $GIT_DIR/config dans R2 aura une entrée comme celle-ci :

[à distance "origine"]
url = /home/moi/tmp/fichier.bundle
récupérer = refs/heads/*:refs/remotes/origin/*

Pour mettre à jour le référentiel mine.git résultant, vous pouvez récupérer ou extraire après avoir remplacé le
bundle stocké dans /home/me/tmp/file.bundle avec des mises à jour incrémentielles.

Après avoir travaillé un peu plus dans le référentiel d'origine, vous pouvez créer un bundle incrémentiel
pour mettre à jour l'autre référentiel :

machineA$ cd R1
machineA $ git bundle créer file.bundle lastR2bundle..master
machineA$ balise git -f maître lastR2bundle

Vous transférez ensuite le bundle sur l'autre machine pour remplacer /home/me/tmp/file.bundle, et
en tirer.

machineB$ cd R2
machineB$ git pull

Si vous savez jusqu'à quel commit le référentiel destinataire prévu devrait avoir les
objets, vous pouvez utiliser cette connaissance pour spécifier la base, en donnant un point de coupure pour limiter
les révisions et les objets qui vont dans le bundle résultant. L'exemple précédent utilisait le
tag lastR2bundle à cet effet, mais vous pouvez utiliser toutes les autres options que vous donneriez
à la journal git(1) commande. Voici d'autres exemples :

Vous pouvez utiliser une balise présente dans les deux :

$ git bundle créer monbundle v1.0.0..master

Vous pouvez utiliser une base basée sur le temps :

$ git bundle créer monbundle --since=10.days maître

Vous pouvez utiliser le nombre de commits :

$ git bundle créer monbundle -10 maître

Vous pouvez exécuter git-bundle verify pour voir si vous pouvez extraire d'un bundle qui a été créé
avec une base :

$ git bundle vérifier mybundle

Cela listera les commits que vous devez avoir pour extraire du bundle et
erreur si vous ne les avez pas.

Un bundle du point de vue d'un référentiel destinataire est comme un référentiel ordinaire
duquel il récupère ou tire. Vous pouvez, par exemple, mapper des références lors de la récupération :

$ git fetch mybundle master:localRef

Vous pouvez également voir quelles références il propose :

$ git ls-remote monbundle

GIT

Une partie de l' jet(1) Suite

Utilisez git-bundle en ligne en utilisant les services onworks.net