2010-01-31 23 views
23

Abbiamo un progetto (applicazione PHP), ma l'installazione per ogni client varia, a volte molto poco, a volte di più. Tuttavia, gran parte del codice sorgente è comune. Gestiamo installazioni specifiche come rami paralleli per il master branch e dobbiamo trasferire le modifiche dal master ad altri rami. Stessa situazione è stata risolta nel Git: how maintain (mostly) parallel branches with only a few difference? La soluzione più votato è stato quello di trasferire le modifiche tra rami in questo modo:Git: come mantenere i rami paralleli permanenti

git pull 
git checkout local 
git rebase master 

Come accennato nella soluzione crea non-fast-forward spinge dopo rebasing che trovo molto sgradevole complicazione. La mia domanda è - perché non fare, invece:

git pull 
git checkout local 
git merge master 
+0

o forse volevi dire questo? http://stackoverflow.com/questions/2850369/why-does-git-use-fast-forward-merging-de-default – cregox

risposta

5

Dipende davvero da cosa si vuole fare con il ramo. Sì, se esegui il rebase locale, verrà creato un push non-forward dopo la ridefinizione. D'altra parte, manterrai una serie di modifiche distinte in corso e quello che è nel tuo ramo sarà un insieme di modifiche COME SE FOSSE STATO FATTO AL PIÙ NUOVO CAPO DI MAESTRO.

Unire il master a locale, invece, manterrà la marcia locale in avanti nel tempo con il master e registrerà la cronologia come avvenne. Se è necessario essere in grado di ricostruire lo stato del locale nel passato, allora vorrai farlo. La storia non cambierà mai. Ma avrai una storia più complicata da affrontare.

+0

Nel mio team, abbiamo (quasi sempre) rebase qualsiasi ramo che verrà unificato di nuovo. Come spesso possibile, per semplificare il rebase. Questo semplifica la comprensione della storia dei cambiamenti quando torni. Quando dobbiamo mantenere due rami in parallelo e stiamo rilasciando entrambi (versioni di manutenzione e sviluppo, come) - quindi non possiamo più ribasare, è troppo confuso. Iniziamo invece a fondere. –

2

Greg's answer alla tua altra domanda sembra per visualizzare diversi rami come rimanendo locale per installazioni particolari, non ha spinto ad altri pronti contro termine (enfasi aggiunta):

Se è locale su un sistema, esegui il commit su del ramo "locale" del sistema, altrimenti esegui il commit su "master" e spingilo su un repository comune.

Quasi sempre si desidera passare rapidamente alle diramazioni in un repository condiviso. Il git rebase documentation spiega come ripristinare da un rebase upstream (, ad esempio, git rebase quindi git push -f), e non è divertente per chiunque sia coinvolto.

Per un altro approccio, vedere Never merging back:

Ci sono casi validi dove forcella una volta con l'intenzione di non fondersi di nuovo, ma in generale si dovrebbe cercare molto duramente per mantenere le modifiche su tale bivio a minimo.

L'autore continua a discutere la politica di ramificazione per le varie versioni dei clienti all'interno dello stesso repository.

17

L'idea è di utilizzare un ramo comune e due (o come molti come si necessità) dei clienti specifici rami. Tutte le modifiche più comuni passano al master e ciascun ramo cliente riceve le modifiche che riguardano solo il cliente . Periodicamente (quando il master è considerato in un punto stabile ), unirai le modifiche dal master al ramo del cliente (git checkout custA; git merge master). Questo introduce il nuovo codice "comune" nel ramo del cliente. Non fonderai mai l'altro modo - che inquinerebbe il master con il codice specifico del cliente.

Quando si effettua una consegna al cliente A, si checkout il "LD" ramo e inviare tale. E ovviamente allo stesso modo per gli altri clienti.

Ora diciamo che acquisisci un nuovo cliente, "C", e un po 'più tardi trovi una funzione che i clienti A e C vogliono, ma B no. È possibile creare (alias "fork") una diramazione fuori dal master (git checkout -b AC_feature master), codice/testarlo, effettuare il commit mentre si va e quindi unirlo in A e C (git checkout A; git merge AC_feature and similarly for customer C). Non codificare in A e poi contare sulla fusione A in C, perché che ottenere tutti A in C.

Se, qualche tempo dopo, si trova un bug minore in quella funzione, a fare la cambiare nello stesso ramo (git checkout AC_feature; edit/test/commit), e poi lo unisci in custA e custC come sopra.

Fonte: Questi articoli rinfrescante chiare e utili da parte dello sviluppatore di Gitolite - Sitaram Chamarty, scritto in parte con ingresso diretto da Junio ​​Hamano (partner Linus Torvalds' nel mantenere Git).

Mantenere sportelli clienti paralleli:

http://gitolite.com/archived/special-branches.html

Followup Articolo su "Fixing Up" Branches comuni e clienti:

http://gitolite.com/archived/special-branch-fixups.html