Come funziona l'integrazione del bug tracker/controllo della versione con i tipici flussi di lavoro git?

https://stackoverflow.com/questions/1484153

18-09-2019
|

Domanda

Ecco alcuni esempi di flussi di lavoro git:

Supponiamo che tu voglia sfruttare l'integrazione del bug tracker con il tuo sistema di controllo della versione.Dove/come si adatterebbe a questi flussi di lavoro.Cosa vedresti effettivamente nel tracker?

Sono l'autore di BugTracker.NET che come molti altri bug tracker (Trac, Redmine, FogBugz) si integra con svn.Lo facciamo tutti più o meno allo stesso modo.Ma con git, ho difficoltà a immaginare come sarebbe l'integrazione con git.

MODIFICARE:Ho dato un'occhiata a un tentativo di github-fogbugz integrazione, ma anche l'autore dice "È abbastanza ovvio che FogBugz è stato scritto pensando a un sistema SCM CVS/SVN più tradizionale.Pertanto, la visualizzazione dell'elenco dei commit non si adatta perfettamente a git".

EDIT2:Una discussione su Flusso di lavoro Redmine/git:Sembra che la configurazione più tipica sia che Redmine funzioni con un clone locale di qualunque sia considerato il repository "centrale", quindi vede i cambiamenti quando arrivano a questo clone.Trigger o processi pianificati automatizzano il push sul clone di Redmine.

EDIT3:Sembra che anche con Linux e Linus, alla fine esista un repository git principale che potrebbe essere considerato il repository del dittatore benevolo:Vedere http://git.kernel.org/?p=linux/kernel/git/torvalds/linux-2.6.git;a=summary

EPILOGO:Grazie a tutti.Mio BugTracker.NET ora include l'integrazione con Git, secondo le indicazioni che mi avete fornito.

Soluzione

Trac e Redmine sia l'integrazione con il supporto Git. Sembra più o meno esattamente come il supporto di Subversion. Il bug tracker segue un pronti contro termine come il dittatore benevolo di pronti contro termine, non deve preoccuparsi di tutti gli altri cloni attorno al luogo.

Una cosa che penso è degno di nota è che qualsiasi bug tracker deve supportare rami git correttamente. Lavorare su rami è una parte così importante della metodologia Git, ha bisogno di essere sostenuta nel bug tracker. Redmine possibile farlo attraverso una patch, ma ultima volta che ho guardato (circa un mese fa), non era nel source tree principale (si poteva solo seguire master).

Altre caratteristiche utili sarebbero una rappresentazione grafica di come vengono creati e fuse, simile a sguardi come gitk rami. Non so di alcun bug tracker che fa questo tipo di visualizzazione.

EDIT da Corey Trager. Copio / incollato @ risposta di silenziamento qui (I upvoted @Squelch troppo):

A causa della natura distribuita del Git contro la natura centralizzata di SVN, è del tutto possibile per ogni utente o copia del repository di avere diversi rami. Gli inseguitori exisitnig in genere hanno una copia locale del repository che viene utilizzato come riferimento centrale ( "dittatore benevolo") che può essere considerata come la copia di lavoro per tutti gli utenti.

E 'del tutto possibile per gli utenti di avere una struttura ramo diverso nella loro copia locale da quella del tracker. Si può cercare di mantenere un po 'privata, tirare solo i rami dal telecomando che sono interessati a, o spingere un nuovo ramo al telecomando (tracker). Gli utenti possono anche condividere i rami tra loro che il telecomando non può mai vedere.

Il bug tracker può davvero solo repository di riferimento si ha accesso. Comunemente questo è locale al tracker, ma è anche possibile tirare dal repository remoto al tracker, e molto più difficile da gestire. Se si accede a un telecomando, può seguire soltanto rami che venga a conoscenza di, e non c'è davvero una modalità di avvio questo compito a parte un'operazione pianificata. Ciò presuppone anche che gli utenti stanno scontando la loro copia locale troppo.

Come si è già notato, un'operazione pianificata, o un gancio di evento possono essere utilizzati per aggiornare il tracker utilizzando il registro di commit per i dettagli. Questi dettagli possono poi essere abbinati alle questioni Tracker per la visualizzazione come richiesto e osservato in precedenza.

In breve, il tracker in genere vedere qualunque cambiamenti sono fatti sui rami che attualmente ha accesso. Con un gancio queste modifiche sono visti immediatamente compresa la creazione di un nuovo ramo. Non sarà vedere o tenere traccia delle modifiche apportate a utenti (offline) repository fino a quando spingono tali modifiche.

FINE DI @Squelch

Altri suggerimenti

Ottima domanda.
Per rispondere, devi vedere quali sono entrambi questi strumenti (BugTracker.NET, che conosci bene, ovviamente ;) e Idiota, realizzato inizialmente per Linux nel 2005) sono effettivamente cercando di risolvere.

BugTracker.NET:tracker basato sul web, per bug (o praticamente qualsiasi altro "elemento" che desideri monitorare, poiché puoi definire i campi personalizzati, lo stato e il flusso di lavoro)
Idiota:nella sua essenza, è un integratore di patch, creato per applicare molte patch da molte persone (non tutte conosciute o con ruoli specifici) a un gran numero di file. Velocemente.

Quindi puoi vedere la dissonanza qui, tra un riferimento centrale e uno strumento di aggregazione del codice distribuito.

Il minimo comune denominatore tra questi due modelli rimane il "flusso di lavoro del dittatore benevolo", che è il flusso di lavoro più distribuito là fuori che ha ancora un archivio centrale da monitorare.

Ma se dovessi seguire questo percorso (monitorare un repository che funge da "riferimento ufficiale", pur avendo un flusso di lavoro di unione distribuito libero sotto quell'unico repository), dovrai ridefinire cos'è un utente e il suo ruolo.
Soprattutto quando si tratta di integrare Git con il tuo strumento centralizzato di tracciamento dei bug basato sui ruoli.

Se guardi La presentazione di Git da parte di Linus a Google, verso le 18'35, arriverai al passaggio in cui ti renderai conto che usare Git significa non avere Tutto gli utenti identificati e associati a un ruolo.

Ecco un paio di citazioni/punti rapidi che illustrano questo fatto:

“Poiché hai un repository centrale significa che tutti coloro che stanno lavorando su quel progetto devono scrivere nel repository centrale.
Ciò significa che, dal momento che non vuoi che tutti scrivano nel repository centrale, perché la maggior parte delle persone sono idioti, crei questa classe di persone che apparentemente non sono idioti."

Quindi, non tutti finiranno per passare al repository centrale, e la maggior parte del lavoro vero e proprio lì (piccole correzioni, convalide, test, ...) sarà comunque svolto da un numero limitato di persone.

Quel "flusso di lavoro da dittatore benevolo" significa che lavori con una "rete di fiducia":un gruppo selezionato di persone.Ancora una volta, non tutti gli sviluppatori sono direttamente visibili.

Dalla stessa presentazione, ciò che ti rendi conto è anche che un "all repository" può far parte del ciclo di vita del codice (al contrario dei rami "integrazione", "testing", "da rilasciare" o delle etichette "release1.0" ', ...):

“ Una delle cose per le aziende commerciali:il modello distribuito aiuta anche nel processo di rilascio.
Puoi avere un team di verifica che abbia il proprio albero.E prendono dalle persone e lo verificano, e lo hanno verificato, possono inviarlo al team di rilascio e dire "Ehi.Ora abbiamo verificato Nostro versione, e gli addetti allo sviluppo, possono andare avanti, giocando con la testa, invece di dover creare tag, rami, qualunque cosa tu faccia per cercare di tenerti lontani a vicenda.
Ancora una volta, vi tenete lontani a vicenda in modo che ogni singolo gruppo possa avere il proprio albero e tenere traccia del proprio lavoro e di ciò che vuole che venga fatto.”.

Ciò rafforza il punto precedente:se monitori solo un repository, puoi monitorare solo i commit di un numero limitato di persone.
E aggiunge una svolta:
Mentre non puoi monitorare Tutto i repository disponibili, potresti non voler monitorare solo un repository:se il bug tracking si sovrappone a più fasi (vale a dire 'integrazione continua', 'test funzionale', 'validazione utente', 'pre-produzione', ...), ciascuna di esse ha potenzialmente un proprio albero, e ciascuna di esse essendo un potenziale fonte per compilare una segnalazione di bug.
A questo proposito, il "supporto del ramo Git di Redmine" (Revisione 2840) è ancora realizzato con una mentalità "repo centralizzata", in cui si utilizza un ramo per una modellizzazione del ciclo di vita dello sviluppo (dove si eseguono attività su e intorno sviluppo, invece di fare un vero e proprio "sforzo di sviluppo" che è ciò di cui dovrebbe occuparsi una filiale).

Dove ti lascia tutto questo?

o imponendo un rigido modello di repository centrale (tutti devono eseguire il push su un repository), il che, secondo la mia esperienza, non è mai positivo quando uno strumento cerca di costringerti a lavorare in un modo invece di lasciarti adattare lo strumento al modo in cui vuoi lavorare .
o ridefinire la gestione del ciclo di vita dei bug per tenere conto di:
- potenzialmente più alberi, ognuno dei quali rappresenta un potenziale passo nella risoluzione del bug.
- utenti che verranno registrati come al lavoro su un bug, ma senza completare cronologia del codice:cioè.il codice monitorato potrebbe non esserlo direttamente ad essi associati, poiché la risoluzione può essere eseguita in rami privati sui repository dello sviluppatore, mentre il codice monitorato è costituito da più fusioni da parte di un "integratore" su repository dedicati.
- reporting intelligente in grado di indicare quali bug vengono rilevati/risolti in una "revisione ufficiale" del codice, limitandosi a indicare l'origine di tali modifiche (proviene dalle fusioni di tali rami remoti, per tale repository remoto)

Insomma, non si tratta di un compito banale.

Le questioni rimangono:

Flusso di lavoro di pubblicazione Git, che è inter-repo (push/pull) e intra-repo (merge/rebase):quali vuoi monitorare?
Git ramificazione privata:non Tutto la cronologia del codice sarà sempre visibile e non dovrà essere tracciata.Dovrebbero essere tracciati solo i rami pubblici (che vengono estratti/spinti, ma anche modificati all'interno del proprio repository tramite una fusione o un rebase)
Utenti Git:a seconda della loro posizione all'interno della "rete di fiducia", hanno ruoli diversi che il tracker deve riflettere.

Per la risposta di eco MichaelM, Redmine ha una buona integrazione Git. Ne consegue il commit i messaggi per parole chiave come riferimenti. correzioni ecc e un numero inseguitore della forma # 1234.

E 'vero che il sostegno ramo non è abbastanza ancora lì, ma è entrato il tronco circa un mese fa , ed è destinato per la versione 0.9. Redmine è attualmente mantenuto in SVN, ma c'è anche un specchio su Github

Il collegamento in Redmine tronco è indicativo dell'uscita inseguitore per repository Git con le differenze essendo come i rami sono navigato.

$ git log

Può essere utilizzato per analizzare messaggi di commit, autori e le revisioni per l'utilizzo in qualsiasi inseguitore, se necessario.

Modifica A causa della natura distribuita del Git contro la natura centralizzata di SVN, è del tutto possibile per ogni utente o copia del repository di avere diversi rami. Gli inseguitori exisitnig in genere hanno una copia locale del repository che viene utilizzato come riferimento centrale ( "dittatore benevolo") che può essere considerata come la copia di lavoro per tutti gli utenti.

C'è anche un open source integrazione con Fogbugz, su GitHub naturalmente.

Date un'occhiata a come Launchpad fa questo:. Il monitoraggio dello stato del bug in luoghi diversi

Di seguito citerò a Mark Shuttleworth :

bug tracking veramente distribuito (in cui la lista di bug segue il codice   in tutto il mondo) è molto emozionante, e può essere la soluzione a lungo termine. Nel   frattempo, è possibile affrontare con solo il monitoraggio dello stato della   bug in alcuni posti diversi. Canonical ha finanziato il lavoro su   Bugzilla, Trac e altri bug tracker per rendere più facile parlare con   li programmaticamente, in modo che possiamo mantenere gli sviluppatori di Ubuntu aggiornati   automaticamente.

Abbiamo una "visione centralizzata dello stato bug distribuita" in Launchpad,   che ci aiuta a tenere traccia dello stato di un problema a monte, in   Debian, o in altre distribuzioni. Ad esempio, prova anche questi bug:

https://bugs.launchpad.net/moblin-applets/+bug/ 209.870
   https://bugs.launchpad.net/ubuntu/+source/ nfs-utils / + bug / 214.041
   https://bugs.launchpad.net/ubuntu/+source/tuxmath/ + bug / 220.319
   https://bugs.launchpad.net/ubuntu /+source/linux-source-2.6.22/+bug/123920
   https://bugs.launchpad.net/ubuntu/+source/warsow/ + bug / 131582

In ogni caso, si può vedere come il bug è legato a rapporti in altri   bug tracker, e allora lo stato viene aggiornato automaticamente. Come una piccola   Di conseguenza, è possibile iscriversi a qualsiasi bug report su qualsiasi bug tracker   (Dei tipi supportati) attraverso LP.

Una visione centralizzata non è la soluzione definitiva, ma funziona per noi   in questo momento e un bel paio di altri progetti - upstreams e distribuzioni   -. Lo usano troppo

Redmine è già integrando con Git ed è opensource. Forse si può dare un'occhiata al loro integrazione per le idee.

Forse sono un po 'ingenuo, ma sarebbe bug tracking essere davvero così diverso in git che in svn? Il repository utilizzato dal sistema sarà essenzialmente la stessa struttura (rami e tag) come in eversione, giusto?

Posso immaginare che ci si vuole una rappresentazione grafica bella di come i rami interagiscono, ma a parte questo ...

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow