Comment fonctionne l'intégration de commande bug tracker / version avec des flux de travail git typiques?

https://stackoverflow.com/questions/1484153

18-09-2019
|

Question

Voici des exemples de flux de git:

Disons que vous vouliez profiter de l'intégration de bug tracker avec votre système de contrôle de version. Où / comment cette forme dans ces flux de travail. Que verriez-vous réellement dans le suivi?

Je suis l'auteur de BugTracker.NET qui, comme beaucoup d'autres trackers de bugs (Trac, Redmine, FogBugz) intègre à svn. Nous le faisons tous plus ou moins de la même façon. Mais avec git, j'ai du mal à imaginer ce que l'intégration avec git ressemblerait.

EDIT: J'ai pris un coup d'œil à une tentative de github-FogBugz intégration , mais même l'auteur de ce dit: « Il est assez évident que FogBugz a été écrit pour un système plus traditionnel CVS / SVN SCM à l'esprit. en tant que tel, commit affichage de la liste n'a pas vraiment jive avec git ».

EDIT2: Une discussion sur Redmine / flux de travail git : Il semble que la configuration la plus typique est que Redmine travaille avec un clone local de tout ce qui est considéré comme le dépôt « central », il voit si des changements quand ils font à ce clone. Déclenche ou travaux programmés automatisent la poussée au clone de Redmine.

EDIT3: Semble même avec linux et Linus, il est finalement un dépôt git principal qui pourrait être considéré comme le dépôt bienveillant dictateur: Voir http://git.kernel.org/?p=linux/kernel/git/torvalds/linux-2.6.git;a = résumé

EPILOGUE: Merci tout le monde. Mon BugTracker.NET inclut désormais l'intégration git, selon les conseils que vous les gens me ont donnés.

La solution

Trac et Redmine à la fois de l'intégration de support avec Git. Il ressemble plus ou moins exactement le même que le support de Subversion. Le bug tracker suit un repo dictateur bienveillant repo, il ne faut pas se soucier de tous les autres clones autour de la place.

Une chose que je ne pense est utile de mentionner que tout bug tracker doit prendre en charge les branches git correctement. Travailler sur les branches est une partie importante de la méthodologie Git, il doit être pris en charge dans le bug tracker. Redmine peut le faire à travers un patch, mais enfin je regardé (il y a environ un mois), il n'a pas été dans l'arborescence des fichiers source (vous pouvez suivre seul maître).

D'autres caractéristiques utiles seraient une représentation graphique de la façon dont les branches sont créées et ont fusionné, semblable à la façon dont les regards gitk. Je ne connais pas de bug tracker qui fait ce genre de visualisation.

EDIT par Corey Trager. Je copier / coller @ réponse de Squelch ici (j'upvoted @Squelch aussi):

En raison de la nature distribuée de Git contre la centralisation de SVN, il est tout à fait possible pour chaque utilisateur ou une copie du référentiel d'avoir des branches différentes. Les trackers de exisitnig ont généralement une copie locale du dépôt qui est utilisé comme référence centrale ( « dictateur bienveillant ») qui peut être considéré comme la copie de travail pour tous les utilisateurs.

Il est tout à fait possible pour les utilisateurs d'avoir une structure de branche différente dans leur copie locale de celle du suivi. Ils peuvent choisir de garder un peu privé, tirer seulement les branches de la télécommande qu'ils sont intéressés, ou pousser une nouvelle branche à la télécommande (suivi). Les utilisateurs peuvent même partager entre les branches elles-mêmes que la télécommande ne peut jamais voir.

Le bug tracker peut vraiment que les dépôts de référence, il a accès. Généralement c'est local au suivi, mais il est également possible de tirer de dépôts à distance au tracker, et beaucoup plus difficile à gérer. Si elle accède à une télécommande, il ne peut suivre les branches qu'il a connaissance, et il n'y a pas vraiment une méthode d'initier cette tâche en dehors d'une tâche planifiée. Cela suppose également que les utilisateurs sont au service de leur copie locale aussi.

Comme vous l'avez déjà noté, une tâche planifiée, ou un crochet d'événement peut être utilisé pour mettre à jour le système de suivi en utilisant le journal de livraison pour plus de détails. Ces informations peuvent ensuite être comparés aux problèmes tracker pour l'affichage selon les besoins et noté ci-dessus.

En bref, le tracker généralement voir tous les changements sont faits sur les branches, il a actuellement accès. Avec un crochet ces changements sont immédiatement visibles, y compris la création d'une nouvelle branche. Il ne voit pas ou suivre les modifications apportées aux utilisateurs (hors ligne) dépôts jusqu'à ce qu'ils poussent ces changements.

FIN DE @Squelch

Autres conseils

Grande question.
Pour y répondre, vous devez regarder ce que ces deux outils ( BugTracker.NET , que vous connaissez bien, évidemment;) et Git , fait d'abord pour Linux en 2005) sont en train d'essayer de résoudre .

BugTracker.NET: suivi sur le Web, pour bug (ou à peu près tout autre que vous souhaitez suivre « article », puisque vous pouvez définir vos champs personnalisés, état et flux de travail)
Git: à sa base, il est un intégrateur de patch, fait appliquer beaucoup de patches de beaucoup de gens (pas tous connus ou avec des rôles spécifiques) à un grand nombre de fichiers. rapidement .

Vous pouvez voir ici la dissonance, entre un référentiel central et d'un outil d'agrégation de code distribué.

Le plus petit dénominateur commun entre les deux modèles restent le « flux de travail de dictateur bienveillant », qui est le flux de travail les plus distribués là-bas qui ont encore un référentiel central pour vous surveiller.

Mais si vous suivez cette voie (suivre un référentiel agissant comme le « référentiel officiel », tout en ayant un flux de travail de fusion distribué en vrac en dessous d'un repo), vous devez alors redéfinir ce qui est un utilisateur et son rôle. < br> Surtout quand il s'agit d'intégrer Git avec votre outil de suivi des bogues basé sur les rôles centralisé.

Si vous regardez présentation de Linus de Git à Google , autour de 18'35, vous arriverez au passage où vous vous rendez compte à l'aide Git signifie ne pas avoir tous les utilisateurs identifiés et rattachés à un rôle.

Voici quelques citations rapides / points qui illustrent ce fait:

« Parce que vous avez un référentiel central signifie que tout le monde qui travaille sur ce projet doit écrire au référentiel central.
Ce qui signifie que, puisque vous ne voulez pas que tout le monde à écrire au dépôt central, parce que la plupart des gens sont des crétins, vous créez cette classe de gens qui sont apparemment pas des crétins. »

Alors, pas tout le monde finira par pousser au dépôt central, et la plupart du travail là-bas réel (petites corrections, les validations, les tests, ...) sera fait par un nombre limité de personnes de toute façon.

Ce « flux de travail de dictateur bienveillant » signifie que vous travaille avec un « réseau de confiance »: un groupe choisi de personnes. Encore une fois, tous les développeurs sont directement visibles.

De la même présentation, ce que vous vous rendez compte aussi est qu'un « tout dépôt » peut faire partie du cycle de vie du code (par opposition à de l'intégration «branches, « testing », « être libéré », ou étiquettes ' release1.0' , ...):

« L'une des choses pour les sociétés commerciales: le modèle distribué contribue également au processus de libération
.   Vous pouvez avoir une équipe de vérification qui a son propre arbre. Et ils tirent des gens et ils vérifient, et ils ont vérifié, ils peuvent le pousser à l'équipe de libération et dire « Hey. Nous avons vérifié nos la version, et les gens de développement, ils peuvent continuer, jouer avec leur tête, au lieu d'avoir à créer des balises, des branches, tout ce que vous faites pour essayer de garder hors les uns des autres orteils.
  Encore une fois, vous éloigner les uns des autres orteils par chaque groupe que seul peut avoir son propre arbre, et suivre son travail et ce qu'ils veulent faire. ».

qui renforcent le point précédent: si vous surveillez un seul repo, vous ne pouvait monitory engage à partir d'un nombre limité de personnes
. Et il ajoute une touche:
Bien que vous ne pouvez pas surveiller tous les prises en pension là-bas, vous ne voulez pas de surveiller un seul repo: si le suivi des bogues se chevauchent plusieurs phases (à savoir « l'intégration contrinous », « tests fonctionnels », « validation de l'utilisateur » , « pré-production », ...), chacun d'eux ayant potentiellement leur propre arbre, et chacun d'eux étant un pola source tiel pour remplir un rapport de bogue.
À cet égard, le "soutien de la branche Git par Redmine" ( Révision 2840 ) est toujours fait avec un état d'esprit « repo centralisé », où vous utilisez une branche pour une modelisation du cycle de vie de développement (où vous faire des tâches à propos et autour développement, au lieu de faire un véritable « effort de développement » qui est ce qu'une branche devrait être tout au sujet).

D'où vient tout ce que vous laisser?

soit imposer un modèle de référentiel central strict (tout le monde doit pousser à une prise en pension), qui, dans mon expérience, n'est jamais bon quand un outil essayer de vous forcer à travailler dans un sens au lieu de vous laisser adapter l'outil la façon dont vous voulez travailler.
ou la redéfinition de la gestion du cycle de vie de bug à prendre en compte:
- arbres potentiellement multiples, chacun une étape potentielle dans une résolution de bug.
- les utilisateurs qui seront enregistrés comme travaillant sur un bug, mais sans complet l'histoire de code: à savoir le code contrôlé pourrait ne pas être directement qui leur sont associés, depuis la résolution peut être fait dans les branches privées sur les dépôts de développeurs, tandis que le code surveillé est fabriqué à partir de plusieurs fusions par un « intégrateur » sur les référentiels dédiés.
- rapports intelligents capables de dire ce que les bugs sont détectés / fixes dans une « révision officielle » du code, se bornant à indiquer l'origine de ces changements (il provient des fusions de ces branches éloignées, pour cette prise en pension à distance)

En bref, ce n'est pas une tâche triviale.

Les questions demeurent:

flux de travail de publication Git, qui est inter-repo (push / pull), ainsi que intra-repo (fusion / rebasage): ceux qui ne voulez-vous suivre
Git privé branchement: non tous l'histoire du code sera toujours visible, et ne doit pas être suivi. Seules les branches publiques (qui sont tirés / poussées, mais aussi modifiés dans leur propre prise en pension par une fusion ou rebasage) doivent être suivis
les utilisateurs de Git:. En fonction de leur place au sein du « réseau de confiance », ils ont des rôles différents que le suivi doit refléter

Pour faire écho à la réponse de MichaelM, Redmine a une bonne intégration de Git. Il suit les commits des mots clés comme références. fixe etc et un numéro de suivi du formulaire # 1234.

Il est vrai que le soutien de la branche n'est pas encore tout à fait là, mais il est entré dans le coffre sur Github

Le lien à Redmine tronc est indicative de la sortie de suiveur de dépôts Git avec les différences étant la façon dont les branches sont parcourus.

$ git log

Peut être utilisé pour analyser les messages, engager les auteurs et les révisions à utiliser dans tous les trackers, si nécessaire.

Edit: En raison de la nature distribuée de Git contre la centralisation de SVN, il est tout à fait possible pour chaque utilisateur ou une copie du référentiel d'avoir des branches différentes. Les trackers de exisitnig ont généralement une copie locale du dépôt qui est utilisé comme référence centrale ( « dictateur bienveillant ») qui peut être considéré comme la copie de travail pour tous les utilisateurs.

Il y a aussi intégration open source avec FogBugz, sur GitHub bien sûr.

Jetez un oeil à la façon dont le fait Launchpad:. Le suivi de l'état du bogue dans différents endroits

Ci-dessous je vais citer Mark Shuttleworth :

suivi des bogues vraiment distribués (où la liste des bogues suit le code   partout) est très excitant, et peut-être la solution à long terme. Dans   Entre-temps, vous pouvez vous adresser avec le suivi que l'état de la   bogue dans quelques endroits différents. Canonical a été finance des travaux sur   Bugzilla, Trac et autres trackers de bugs pour le rendre plus facile de parler   les programatically, afin que nous puissions garder les développeurs Ubuntu à jour   automatiquement.

Nous avons une « vision centralisée de l'état de bug distribué » dans Launchpad,   ce qui nous permet de suivre l'état d'un problème en amont, en   Debian, ou dans d'autres distros. Par exemple, consultez ces bugs:

https://bugs.launchpad.net/moblin-applets/+bug/ 209870
   https://bugs.launchpad.net/ubuntu/+source/ nfs-utils / + bug / 214041
   https://bugs.launchpad.net/ubuntu/+source/tuxmath/ + bug / 220319
   https://bugs.launchpad.net/ubuntu /+source/linux-source-2.6.22/+bug/123920
   https://bugs.launchpad.net/ubuntu/+source/warsow/ + bug / 131582

Dans tous les cas, vous pouvez voir comment le bug est lié à des rapports dans d'autres   suivi de bogues, puis l'état est mis à jour automatiquement. En tant que petit   Par conséquent, vous pouvez vous abonner à un rapport de bogue sur un bug tracker   (Des types pris en charge) via LP.

Une vue centralisée n'est pas la solution ultime, mais cela fonctionne pour nous   en ce moment et un bon nombre d'autres projets - amonts et distributions   -. Utilisent aussi

Redmine intègre déjà avec Git et il est opensource. Peut-être que vous pouvez jeter un oeil à leur intégration dans des idées.

Peut-être que je suis un peu naïf, mais serait vraiment suivi des bogues dans différents git que dans svn? Le référentiel utilisé par le système sera essentiellement la même structure (branches et tags) comme dans la subversion, droit?

Je peux imaginer que vous voudriez une belle représentation graphique de la façon dont les branches interagissent, mais à part ça ...

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow