Rami di venditori in Git

Un progetto Git ha al suo interno un secondo progetto il cui contenuto viene lavorato indipendentemente.

I sottomoduli non possono essere utilizzati per i più piccoli, in quanto anche il sottoprogetto deve essere incluso quando gli utenti tentano di clonare o scaricare il ‘genitore’.

Non è ansible utilizzare la fusione di sottostrutture, poiché il sottoprogetto viene triggersmente sviluppato e la fusione di sottostrutture rende molto difficile unire tali aggiornamenti nel progetto originale.

Sono stato informato che la soluzione è nota nel mondo SVN come “Rami di venditori” e che è stata fatta semplicemente in Git in modo da non aver nemmeno bisogno dell’indirizzamento. Tutorial infornati abbondano sulla rete.

Tuttavia, non riesco a farlo funzionare.

Qualcuno può (per favore, per favore?) Spiegare come posso creare una struttura in cui un progetto esiste all’interno di un altro ed entrambi possono essere sviluppati e aggiornati dalla stessa directory di lavoro. Idealmente [o meglio: è piuttosto importante, se non è supportato] che quando un cliente tenta di scaricare il progetto “genitore”, gli venga automaticamente assegnata l’ ultima versione del sottoprogetto.

Per favore non spiegarmi come usare i sottomoduli o le sottocolgi-unione o anche SVN: esterni. Questo thread è la conseguenza del seguente thread SO , e se qualcosa è mancato lì, si prega di postarlo . Questo thread sta cercando di capire come i rami del venditore, e più lungo, più chiaro e più dummied una spiegazione che riceverò più felice sarò.

Penso che i sottomoduli siano la via da seguire quando si parla di “branca dei venditori”.
Ecco come dovresti usare submod … hmmm, sto scherzando.

Solo un pensiero; tu vuoi:

  • sviluppare sia il progetto principale che il sotto-progetto all’interno della stessa directory (che è chiamato un ” approccio di sistema “: sviluppate, taggate e unite tutto il sistema)
  • o per visualizzare il sottoprogetto come un “ramo del fornitore” (che è un ramo che consente di accedere a una versione ben definita di un componente esterno del fornitore – o “set di file” – e che viene aggiornato solo con il nuovo versione ogni versione di quel componente esterno: si chiama ” approccio-componente “, tutto il sistema è visto come una raccolta di componenti separati sviluppati autonomamente)

I due approcci non sono compatibili:

  • La prima strategia è compatibile con una sottostruttura-unione: si sta lavorando sia sul progetto che sul sotto-progetto.
  • Il secondo è usato con i sottomoduli, ma i sottomoduli sono usati per definire una configurazione (elenco di tag che devi lavorare): ogni sottomodulo git, a differenza di svn: esterni, è appuntato su un particolare ID di commit, e questo è ciò che ti permette di definire una configurazione (come in S C M: “gestione della configurazione del software”)

Mi piace il secondo approccio perché la maggior parte delle volte, quando si ha un progetto e un sotto-progetto, il loro ciclo di vita è diverso (non sono sviluppati allo stesso ritmo, non sono etichettati insieme allo stesso tempo, né con lo stesso nome) .

Ciò che realmente impedisce questo approccio (“componente-basato”) nella tua domanda è la parte “entrambi possono essere sviluppati e aggiornati dalla stessa directory di lavoro”.
Vi esorto davvero a riconsiderare tale requisito, dal momento che la maggior parte degli IDE sono perfettamente in grado di trattare con più directory “fonti” e lo sviluppo del sotto-progetto può essere fatto nel proprio ambiente dedicato.


samgoody aggiunge:

Immagina un plugin eMap per Joomla e ModX. Sia il plugin che il codice specifico di Joomla (che è parte di Joomla, non di eMap) sono sviluppati mentre il plugin è all’interno di Joomla. Tutti i percorsi sono relativi, la struttura è rigida e devono essere distribuiti insieme, anche se ogni progetto ha il proprio ciclo di vita.

Se capisco correttamente, ci si trova in una configurazione in cui l’ambiente di sviluppo (il set di file su cui si sta lavorando) è esattamente la stessa dell’ambiente di distribuzione (lo stesso insieme di file viene copiato sulla piattaforma di rilascio)

Tutto viene fatto per un problema di granularità:

  • se entrambi i gruppi di file non possono esistere l’uno senza l’altro, devono essere visualizzati come un unico grande progetto (e unito a un sottoalbero), ma che li costringono a essere taggati e uniti come uno. -se l’una dipende dall’altra (che può essere sviluppata da solo), quindi dovrebbero essere nel proprio repository e progetto Git, il primo a seconda di uno specifico commit del secondo come sottomodulo: se il sottomodulo è definito nella sottostruttura di destra del primo componente, tutti i percorsi relativi sono rispettati.

samgoody aggiunge:

Il thread originale elencava problemi con i sottomoduli – principalmente il download di GitHub non li includeva (fondamentale per me) e che si bloccavano su un particolare commit.

Non sono sicuro che il download di GitHub sia di recente un problema: l’articolo ” Guide: Developing with Submodules ” menziona:

Meglio di tutti: le persone che clonano la tua fork my-awesome-framework non avranno problemi a tirare giù il tuo sottomodulo my-fantastic-plugin , dato che hai registrato l’URL clone pubblico per il sottomodulo. I comandi

 $ gh submodule init $ gh submodule update 

Tirerà i sottomoduli nel repository attuale.

Per quanto riguarda “si bloccano su un commit particolare”: questo è il punto di un sottomodulo, che consente di lavorare con una configurazione (elenco di versioni con tag di componenti) anziché un set di file potenzialmente instabile più recente.

samgoody menziona:

Devo evitare sia sottotesti che sottomoduli (vedi domanda), e preferirei affrontare questo bisogno senza discutere troppo se l’approccio è giustificato

Il tuo requisito è perfettamente legittimo e non voglio giudicare la sua giustificazione: le mie risposte precedenti sono qui solo per fornire un contesto più ampio e cercare di illustrare le opzioni solitamente disponibili con uno strumento SCM generico.

La sottostruttura di unione dovrebbe essere la risposta qui, ma implicherebbe di fondere solo i commit fatti per i file per il progetto principale, e non i commit fatti per i sottoprogetti. Se riesci a gestire quel tipo di unione parziale, direi che è la strada giusta da seguire.

Non vedo però un modo Git nativo per fare ciò che vuoi che non usi l’unione secondaria o il sottomodulo.
Spero che un vero guru del Git pubblichi qui una risposta più adeguata.

Finalmente ho qualche ora di accesso alla rete prima di tornare in montagna. Vedremo se ho qualcosa per contribuire alla chiarezza della tua situazione.

La mia comprensione (probabilmente semplificata) è che i fornitori (fuori sede) sviluppano plug-in (s) per il progetto in cui il team (in-house) sta sviluppando il codice per il progetto principale utilizzando un framework esternalizzato. Il fornitore non apporta modifiche al tuo codice e probabilmente non ha bisogno del tuo sviluppo all’avanguardia, ma ha bisogno del tuo codice stabile per sviluppare e testare il loro lavoro. Il tuo team non apporta modifiche al framework, ma a volte apporta modifiche al plug-in.

  1. Come VonC (che di solito pensa molto le cose), non credo che Git si adatti perfettamente alle tue esigenze. E come lui, penso che l’uso del modello di unione secondaria sia la soluzione più adatta. Non sono un guru del Git, ma ho avuto successo nel piegare Git a una vasta gamma di bisogni. Forse Git non soddisfa le tue esigenze:

    • SVN ti consente di avere più repository all’interno di uno, il che sembra importante per te. Penso che ciò significherebbe utilizzare esternamente o il pattern del ramo del fornitore per avvicinarsi a ciò che si desidera.

    • Mercurial ha un’estensione, Forest, per l’utilizzo di repository nidificati, che sembra adattarsi meglio al tuo modello mentale. Ho scelto Git over Mercurial 15 mesi fa, ma HG era stabile e per molti usi penso che sia paragonabile a Git. Non so quanto sia stabile l’estensione.

  2. Se fossi nella tua situazione, userei due repository Git: uno per il plugin e uno per il MainProject. Il fornitore farebbe lo sviluppo nel repository dei plug-in e avrebbe un ramo di rilascio che estraggono le versioni correnti del plug-in senza il resto dell’ambiente di sviluppo. Tale ramo verrebbe inserito nel repository MainProject come ramo di un fornitore e quindi integrato nel ramo di sviluppo principale. Quando il tuo team lavora su una modifica al plug-in, lo sviluppano in un ramo di funzionalità fuori dal tuo ramo di sviluppo principale e lo inviano al repository del fornitore come patch. Questo ti dà un stream di lavoro molto pulito, relativamente facile da configurare e imparare, mantenendo la storia dello sviluppo segregata.

    Non sto cercando di essere polemico, ma semplicemente per dire che questo è il modo migliore di Git per capire la tua situazione. Il modo più semplice per configurarlo sarebbe utilizzare l’unione secondaria, ma ciò non comporta cambiamenti in entrambe le direzioni, il che era la mia obiezione all’utilizzo di tale modello.

  3. Se il tuo team è realmente coinvolto nello sviluppo di plug-in o vuoi veramente avere la cronologia di sviluppo di entrambi i progetti e plug-in integrati in un repository Git, usa solo un repository Git. È ansible estrarre il plug-in e la sua cronologia per i record del proprio fornitore, come spiegato qui di volta in volta. Questo potrebbe darti meno incapsulamenti di quanto tu intenda, ma Git non è progettato per l’incapsulamento: la struttura dei dati di Git si basa sul monitoraggio delle modifiche all’interno di un intero progetto.

Forse ho frainteso la tua situazione e nulla di tutto questo si applica. Se è così, mi scuso. Grazie per i dettagli che tu e VonC avete elaborato, che hanno riempito molti buchi che avevo originariamente provato a capire la vostra domanda.

Se cerchi solo il titolo della domanda originale:

è attivo un buon modello per il modello di ramo fornitore con git

https://www.roe.ch/Git_Reference

sezione Modello di ramo del fornitore