Gestione fork delle gerarchie multi-livello Git

4

Abbiamo la seguente struttura di gerarchia Git in atto, in cui ogni bambino è biforcuto dal genitore. Se creiamo qualcosa in Client1 che sarà utile nell'intera gerarchia, qual è il modo migliore per spingere i cambiamenti ai genitori (sia che si tratti di un solo livello o fino alla radice), dato che non desideriamo per spingere tutte le personalizzazioni specifiche del cliente lungo la catena.

Ora, mentre la soluzione ideale potrebbe essere quella di eseguire lo sviluppo al livello più alto richiesto, i moduli possono solo essere realmente testati lungo la catena in cui tutte le personalizzazioni vengono istanziate.

es. Se sviluppiamo un nuovo repository Module-New in Client1 e abbiamo bisogno di inviarlo a Core, quale sarebbe il modo migliore per farlo, dato che non vogliamo le personalizzazioni di Client1 nel core? D'altra parte, se avessimo originariamente sviluppato ModuleA direttamente in CORE, avremmo dovuto trasferire le modifiche a valle fino a Client1 per testare Module-New (e iterare per ogni modifica).

Ci sono Git Flussi di lavoro o altri strumenti che possono aiutare a stabilire queste regole. Al momento utilizziamo GitFlows per gestire i nostri master, sviluppare e creare filiali per tutti i repository. Inoltre, c'è un modo per disabilitare i push diretti in un repository remoto?

                            CORE
                              |
                ------------------------
            Product 1               Product 2
                |                       |
            ----------              ----------
        Client1     Client2     Client3     Client4
           |-v1.0   
           |-v1.1
           ...
    
posta Manish Jain 26.12.2015 - 23:43
fonte

2 risposte

1

Puoi disabilitare i repository push diretti in base alle tecnologie che stai utilizzando. Prevenire push può essere fatto in qualche modo usando git git, ma se stai usando gitlab / github / bitbucket ... dovrebbe esserci un modo per proteggere i rami.

Se tutti i rami sono protetti e il dev non può creare un nuovo ramo, allora non c'è modo di spingere al repository. In questo modo, dovrai gestire l'app utilizzando "unisci richieste / richieste push" o come viene chiamato.

Non è chiaro che cosa stai effettivamente gestendo in modo che quanto segue potrebbe non essere d'aiuto. Nel mio caso, abbiamo un prodotto principale che viene installato su ogni client, il prodotto principale potrebbe essere installato con versioni diverse. E moduli aggiuntivi possono essere installati sul lato. In entrambi i casi, solitamente la personalizzazione del client viene eseguita installando moduli specifici per i client che estendono i moduli esistenti (inclusi i moduli principali). Nel mio caso, le personalizzazioni per i clienti non si riflettono mai o raramente nel prodotto principale. Se fosse necessario, potremmo semplicemente spostare il modulo nel prodotto principale.

Se un modulo personalizzato è condiviso su più client, potremmo utilizzare rami speciali che vengono uniti nel master di ciascun repository di moduli.

Alla fine, può diventare piuttosto complicato se il codice non è in bolla al ramo principale del repository di ciascun modulo. Nel nostro caso, gran parte del lavoro è realizzato utilizzando buildout per gestire repository, fusioni e dipendenze.

La mia opinione

Gestire le dipendenze usando i repository git dovrebbe essere limitato allo sviluppo anche se sembra più semplice recuperare i repository. Il repository Git può diventare abbastanza grande e talvolta il recupero potrebbe fallire se il repository è grande e la connessione Internet è instabile ... Git non consente il recupero parziale quindi se fallisce al 99%, dovresti comunque riavviare dallo 0% .

Per la distribuzione, penso che abbia più senso che i gestori di pacchetti lo facciano. Esistono e di solito fanno bene il loro lavoro. Il vantaggio dell'utilizzo di un gestore di pacchetti è che non è necessario scaricare l'intera cronologia delle modifiche che potrebbero venire con il modulo. Solitamente i gestori dei pacchetti consentono il download parziale tramite http, quindi è possibile sospendere un aggiornamento in un secondo momento se Internet non funziona. Con un buon gestore di pacchetti, puoi anche ospitare i tuoi server di pacchetti privati per ogni cliente. Qualsiasi modulo simile per ogni cliente può essere inserito su un server centrale e ogni pacchetto personalizzato può essere trasferito su un server di pacchetti per client.

Tutto questo va bene se hai un modo per automatizzare il processo di costruzione del pacchetto e la distribuzione del pacchetto sui loro rispettivi server.

In questo modo se un client fa qualcosa come "aggiornamento del pacchetto", potrebbe controllare sul server client un pacchetto e poi sul server centrale e prendere la versione corretta da questo. Il vecchio pacchetto non deve essere cancellato e il client può eseguire il downgrade della sua configurazione come preferisce.

La mia ipotesi è che è la cosa più bella che qualcuno possa implementare, ma per quanto ne so non esiste un modo standard per farlo. Ho sentito persone farlo con le uova di Python, altre con pacchetti di Debian e così via. Ma ogni implementazione ha i propri problemi ... Come i pacchetti debian non funzioneranno su Windows e distro non debian ... le uova pythong sono piuttosto limitate ai pacchetti python .. npm su javascript e così via. Se avessimo un gestore di pacchetti universale sarebbe semplicemente un gioco da implementare.

    
risposta data 27.12.2015 - 14:14
fonte
1

La gestione della personalizzazione del codice client con il controllo del codice sorgente non è una buona idea. Non è ciò che il controllo del codice sorgente è progettato per fare.

Nel tuo caso, ad esempio, non c'è modo di determinare se il "nuovo modulo" dipende dalla personalizzazione nel ramo. quindi non puoi semplicemente fonderlo e aspettarti che funzioni.

L'approccio corretto consiste nel suddividere il progetto in componenti e creare un nuovo componente personalizzato per i clienti. Quando si distribuisce un'istanza client, si utilizza DI e la configurazione per specificare che viene utilizzato il componente personalizzato anziché standard.

Tutti i componenti sono repository separati e pubblicati tramite un gestore di pacchetti in modo che possano essere inseriti in altri progetti

Se vengono utilizzate funzionalità comuni tra componenti personalizzati, questi vengono nuovamente suddivisi in modo che il codice comune si trovi nel proprio modulo e che i componenti personalizzati lo facciano riferimento. Quindi, nel tuo scenario di voler spostare il codice 'su un livello', dovresti modificare il componente comune per aggiungere la funzione, e modificare il componente personalizzato per rimuovere la funzionalità dal suo codice, ma fare riferimento alla nuova versione del componente comune che include la funzione

    
risposta data 25.08.2016 - 10:31
fonte

Leggi altre domande sui tag