Controllo della versione: backup e pubblicazione

1

La situazione: il nostro team di sviluppatori e tester sta passando da ClearCase a Git, in modo pionieristico. Mentre l'esperienza con git è limitata, c'è una certa familiarità con Linux, cygwin e msys; nessuno ha paura della linea di comando, e le persone non erano generalmente molto contente di ClearCase (anche se, naturalmente, c'era un flusso di lavoro funzionante). Abbiamo l'installazione non così rara di un repository centrale remoto che i membri del team usano per scambiare i loro contributi.

Una delle maggiori differenze tra git e Clearcase è che git memorizza le versioni dell'intero albero dei sorgenti, mentre ClearCase (di base) si concentra sui singoli file e directory. In ClearCase una cronologia dell'intero albero dei sorgenti (la sequenza delle operazioni di check-in) è praticamente impossibile da ottenere, mentre è un semplice e spesso emesso git log in git.

Come indicato nel titolo, uno dei ruoli per un sistema di controllo versione è backup. Non voglio perdere più di un giorno o più di lavoro in un crash del disco (1) , quindi controllo / spingo circa il lavoro quotidiano, anche incompleto. Con ClearCase il secondo ruolo, "pubblicazione" , è nel nostro flusso di lavoro realizzato dall'etichettatura. La "etichetta di qualità più bassa" è un'etichetta mobile che uno sviluppatore inserisce nelle versioni dei file che, come un set, sono in alcune condizioni di lavoro. Gli altri membri del team vedono solo le versioni etichettate (eccetto per quello su cui lavorano). Il check-in spesso non era un problema con questo flusso di lavoro ClearCase. Altri sviluppatori avrebbero dovuto affrontarlo solo quando hanno esaminato la cronologia dei file o l'albero delle versioni dei file. Non influenzerebbe il loro lavoro.

Con git, frequenti commit, specialmente di codice immaturo, sono un fastidio che di solito viene evitato dalla ridefinizione locale prima di premere o unire. Sfortunatamente questo rimedio non è disponibile dopo una spinta: non riesco a rebase la cronologia pubblicata (il server non consente nemmeno i push di forza). Ma devo spingere spesso per il backup. Questo enigma esiste anche se lavoro su un ramo di funzionalità, perché spingere a un repository condiviso equivale a una sorta di "pubblicazione" ancor prima che il ramo della funzione sia ufficialmente "pubblicato" unendolo nuovamente al master. Dopo l'unione, tutta la cronologia dei commit "sporca" è master inquinante.

Quindi il mio desiderio, e il requisito del team, di produrre una storia editoriale leggibile e significativa collide con la necessità di eseguire regolarmente il backup del mio lavoro. Questo è stato meno un problema in ClearCase perché i passaggi della cronologia sono per lo più nascosti e non esiste una cronologia generale dell'archivio che viene incrementata da ogni singolo commit su un file (che in realtà è un problema, ovviamente).

Come gestiscono le altre persone? Probabilmente potrei avere un secondo repo remoto privato da qualche parte su una condivisione di rete (che consentirebbe anche i push forzati) solo a scopo di backup, e quindi pubblicare sul repository del team solo dopo la reimpostazione e la lucidatura. Ma non ho mai sentito parlare di un tale flusso di lavoro, e sembra ingombrante.

È semplicemente che la maggior parte delle persone non esegue il backup spesso (ad esempio, solo ogni settimana o così)? È accettabile?

(1) E naturalmente il mio repo locale risiede sullo stesso disco dell'albero di lavoro.     
posta Peter A. Schneider 20.09.2017 - 16:52
fonte

3 risposte

3

Git incoraggia la creazione di filiali, anche per lavori di breve durata.

Il flusso di lavoro che preferisco fa uso di rami di sviluppo, che possono avere il numero di commit come preferisci, ma sono poi riuniti a squash nel ramo principale dello sviluppo per produrre commit singoli e una bella storia. Una volta che hai finito con il tuo ramo di sviluppo personale, cancellalo; i rami sono economici.

Utilizzando questo approccio, non ho quasi mai rebase, se non per coalesce commit che voglio apparire esplicitamente nella cronologia ( rebase -i ).

Sono passati circa 20 anni dall'ultima volta che ho usato ClearCase, ma in realtà è molto vicino a come l'ho usato: ogni sviluppatore aveva una visione personale (la parte superiore delle sue specifiche di visualizzazione era unica) e il lavoro completato era fuso in un ramo di sviluppo comune.

Il grosso problema che penso troveresti nel passaggio da ClearCase a Git è che dovrai unire costantemente il ramo di sviluppo comune nel tuo ramo di sviluppo personale. Una specifica di visualizzazione correttamente configurata farebbe solo apparire gli aggiornamenti con ClearCase.

    
risposta data 20.09.2017 - 20:42
fonte
2

Con git puoi avere molti repository remoti che vuoi. Quindi imposta un repository remoto "privato".

  • Il modo più semplice (ma non il migliore) per farlo è quello di stabilire una condivisione di rete su cui viene eseguito il backup del tuo IT in cui è possibile creare un repository remoto "basato su file".

  • Il modo migliore sarebbe avere il proprio gerrit-server o persino il proprio repository github (privato)

Quindi puoi sempre spingere il tuo ramo di funzione ribaltabile al tuo repository privato. In questo modo hai il tuo backup sul tuo repository remoto privato e puoi posticipare la funzionalità della funzione sul "telecomando comune" fino a quando la tua funzione non è pronta.

    
risposta data 20.09.2017 - 17:43
fonte
0

Il vantaggio dei moderni sistemi di controllo delle versioni distribuite è - come suggerisce il nome - che sono distribuiti . Quindi tutti potrebbero avere tanti repository che gli piacciono e potresti sviluppare una rete distribuita di relazioni come vuoi.

Esistono diversi approcci all'hosting:

Per citarne alcuni.

Poiché sono uno sviluppatore Open Source, è per la nostra azienda naturale ospitare il nostro codice in archivi pubblici accessibili (siamo in un processo di migrazione da un on premise soluzione a un servizio) e parte del nostro software è ospitata su Github / Bitbucket.

Il nostro tipico flusso di lavoro richiede che ogni sviluppatore abbia biforcato repository dei progetti su cui stiamo lavorando attualmente. Lì sei il padrone di te stesso e potresti adattare il tuo flusso di lavoro alle tue esigenze; e anche push --force se devi. Sono un frequente committer e sviluppo in un branch di funzionalità dal mio master fork . Appena ho finito, I squash (rebase) i miei commit a un'unità semantica e offro unire ( pull-request in github-lingo ). Quindi il mio codice viene sottoposto a revisione e dopo l'approvazione è stato unito.

Questo aiuta a mantenere una cronologia pulita. Le versioni locali di check-out sono di per sé in un backup, in modo che tutto sia sicuro e sano .

In opposizione a questo flusso di lavoro, ho votato per lavorare su un repository solo nel ramo principale. Sembra un po ' nuts dopo averlo ascoltato per la prima volta, ma l'ovvio lato positivo è:

Ognuno ha a che fare con la versione corrente del prodotto. E tutti devono codificare, che a) la versione corrente non è influenzata dalla tua funzione (principalmente fatta tramite feature toggles ) eb) nulla è "nascosto" in un ramo o persino dimenticato (in genere "l'unica vera migrazione" che rovina la tua versione).

Ci sono diverse possibilità tra cui scegliere.

because pushing to a shared repo amounts to a sort of "publishing" even before the feature branch is officially "published" by merging it back into master

Non vedo alcun problema qui. L'unico codice interessante è codice distribuito , non quello in tutti i rami.

    
risposta data 20.09.2017 - 21:00
fonte

Leggi altre domande sui tag