Composer.lock dovrebbe essere impegnato nel controllo della versione?


529

Sono un po 'confuso con composer.lock usato in un'applicazione con un repository.

Ho visto molte persone dire che non dovremmo .gitignore composer.lockdal repository.

Se aggiorno le mie librerie nel mio ambiente di sviluppo, ne avrò una nuova composer.lockma non sarò in grado di aggiornarle in produzione, vero?

Non genererà conflitti su questo file?


1
Quel link è ora morto @markus
Kyrre il

Risposte:


674

Se aggiorni le tue librerie, vuoi impegnare anche il file di blocco. In pratica afferma che il tuo progetto è bloccato su quelle versioni specifiche delle librerie che stai usando.

Se si esegue il commit delle modifiche e qualcuno estrae il codice e aggiorna le dipendenze, il file di blocco dovrebbe essere non modificato. Se viene modificato, significa che hai una nuova versione di qualcosa.

Avendolo nel repository ti assicura che ogni sviluppatore sta usando le stesse versioni.


5
Ok, ma immagina che se aggiorno le librerie dall'ambiente di produzione, composer.lock verrà sovrascritto, quindi un prossimo pull dalla produzione mi chiederà di unire questo file ...
Pierre de LESPINAY,

7
Se composer.lock viene modificato, è necessario riportare le modifiche nel repository. Se vuoi legare il software a determinate versioni delle librerie, fallo esplicitamente nella configurazione. In questo modo il lucchetto non cambierà mai. Pensa al file di blocco come un indicatore di un problema di gestione delle dipendenze che deve essere risolto in un modo o nell'altro.
Meza,

361
In produzione non dovresti aggiornare le tue dipendenze, dovresti eseguire composer installche leggerà dal file di blocco e non cambi nulla.
Seldaek,

112
"In produzione non dovresti aggiornare le tue dipendenze" dovrebbe essere scritto in maiuscolo
Joaquín L. Robles il

75
@ JoaquínL.Robles IN PRODUZIONE NON DOVREI AGGIORNARE LE TUE DIPENDENZE! :)
Елин Й.

201

Per applicazioni / progetti : sicuramente sì.

Il documentazione del compositore afferma su questo (con enfasi):

Conferma il composit.lock della tua applicazione (insieme a composer.json) nel controllo della versione.

Come ha detto @meza: dovresti eseguire il commit del file di blocco in modo che tu e i tuoi collaboratori stiate lavorando sullo stesso set di versioni e vi impediate di dire "Ma ha funzionato sul mio computer". ;-)

Per le biblioteche : probabilmente no.

Le note sulla documentazione del compositore in materia:

Nota: per le librerie non è necessariamente consigliabile eseguire il commit del file di blocco (...)

E afferma qui :

Per la tua libreria puoi eseguire il commit del file composer.lock se lo desideri. Questo può aiutare il tuo team a testare sempre con le stesse versioni di dipendenza. Tuttavia, questo file di blocco non avrà alcun effetto su altri progetti che dipendono da esso. Ha solo un effetto sul progetto principale.

Per le biblioteche concordo con la risposta di @Josh Johnson.


Perché trattare i progetti al lavoro in modo diverso dalle "biblioteche"?
Josh Johnson,

4
Forse l'uso della parola "colleghi" qui era confuso, l'ho cambiato in collaboratori. La differenza principale è "progetto principale" vs libreria, in cui un progetto principale è costituito da una o più librerie e codice per integrarli. Quando esegue il compositore dal progetto principale, non utilizza il file composer.lock di una libreria, quindi installa le sue dipendenze all'ultima versione. Penso che questo dovrebbe essere simile durante il test della tua libreria.
Jeroen Fiege,

2
Il commit del file di blocco con una libreria è probabilmente una buona cosa: i file di blocco documentano quali versioni di dipendenze sono state installate quando è stata eseguita la suite di test. Ciò è particolarmente importante in un team, e specialmente in ambienti di integrazione continua.
mindplay.dk,

Conflitti non banali possono sorgere quando si reintegrano nei rami trunk 2 che hanno entrambi nuovi pacchetti installati tramite compositore. È successo in questo momento :)
g4b0,

2
@tonix, posso rispondere con una certa autorità! Il motivo per cui non commetto composer.lock per le mie librerie è che il mio CI costruisce master ogni notte, qualunque cosa accada. Garantisce che se una delle dipendenze della libreria presenta problemi di aggiornamento che avrebbe un utente della libreria, l'IC non funziona. Funziona bene!
Theodore R. Smith,

86

Dopo averlo fatto in entrambi i modi per alcuni progetti, la mia posizione è quella di composer.locknon impegnarsi come parte del progetto.

composer.locksono metadati di build che non fanno parte del progetto. Lo stato delle dipendenze dovrebbe essere controllato attraverso il modo in cui le stai controllando (manualmente o come parte del tuo processo di compilazione automatizzato) e non arbitrariamente dall'ultimo sviluppatore per aggiornarle e eseguire il commit del file di blocco.

Se sei preoccupato che le tue dipendenze cambino tra gli aggiornamenti del compositore, allora hai una mancanza di fiducia nel tuo schema di controllo delle versioni. Le versioni (1.0, 1.1, 1.2, ecc.) Dovrebbero essere immutabili e dovresti evitare i caratteri jolly "dev-" e "X. *" al di fuori dello sviluppo iniziale delle funzionalità.

Il commit del file di blocco è una regressione per il sistema di gestione delle dipendenze poiché la versione delle dipendenze è tornata ad essere definita in modo implicito.

Inoltre, il tuo progetto non dovrebbe mai essere ricostruito o avere le sue dipendenze riacquistate in ogni ambiente, in particolare prod. Il tuo deliverable (tar, zip, phar, una directory, ecc.) Dovrebbe essere immutabile e promosso attraverso gli ambienti senza cambiare.


19
Concordato. Sento che ha più senso specificare le versioni di dipendenza in composer.jsoncui le versioni richieste sono dichiarate in modo più esplicito. Ma se non imposti versioni specifiche, è meglio impegnare il composer.lock. È confuso se le versioni specificate in composer.jsonsono diverse da quelle installate come da a composer.lock. Inoltre dipende dall'app (versione interna o generale) e dal suo ciclo di sviluppo. Ovviamente, i documenti del compositore dicono , in grassetto, "Metti il ​​composit.lock della tua applicazione (insieme a composer.json) nel controllo della versione" . Scegli saggiamente =)
Quinn Comendant il

10
Dopo molta ricerca dell'anima ho deciso, su questo punto, che i documenti del compositore sono sbagliati :) Ho una regola che non aggiungo materiale generato al VCS; Consento al processo di compilazione di gestirlo.
Josh Johnson,

10
Il codice creato con i vostri pressori a chiave biomeccanici non è "materiale generato"? Non sono sicuro che si tratti di criteri solidi su cui basare una politica. =)
Quinn Comendant

5
@borfast So che sono un po 'in ritardo per la conversazione, quindi potresti averlo visto a questo punto, ma puoi specificare un hash in composer.json. Nella requiresezione, è possibile mettere: "repo": "dev-master#2633721877cae79ad461f3ca06f3f77fb4fce02e". Questo 1) andrà al ramo, 2) verifica quell'hash, 3) se l'hash non viene trovato sul ramo, tuttavia, verificherà l'intestazione del ramo specificato (master in questo caso).
CEPA

5
@CEPA - Strano. Mi sarei aspettato che fallisse se non fosse stato possibile trovare l'hash. Sembra pericoloso
Nathan JB,

31
  1. Non dovresti aggiornare le tue dipendenze direttamente dalla produzione.
  2. Dovresti controllare la versione del tuo file composer.lock .
  3. Non dovresti controllare la versione delle dipendenze effettive.

1. Non dovresti aggiornare le tue dipendenze direttamente dalla produzione , perché non sai come ciò influirà sulla stabilità del tuo codice. Potrebbero esserci dei bug introdotti con le nuove dipendenze, potrebbe cambiare il modo in cui il codice si comporta influenzando il tuo, potrebbe essere incompatibile con altre dipendenze, ecc. Dovresti farlo in un ambiente di sviluppo, seguito da un adeguato controllo di qualità e test di regressione, ecc. .

2. Dovresti controllare la versione del tuo file composer.lock , perché questo memorizza informazioni sulle tue dipendenze e sulle dipendenze delle tue dipendenze che ti permetteranno di replicare lo stato corrente del codice. Questo è importante perché tutti i test e lo sviluppo sono stati eseguiti su codice specifico. Non preoccuparti della versione effettiva del codice che hai è simile al caricamento delle modifiche al codice nella tua applicazione e al loro test. Se stai aggiornando le versioni delle tue dipendenze, questo dovrebbe essere un atto volontario e dovresti prenderti le cure necessarie per assicurarti che tutto funzioni ancora. Perdere una o due ore di tempo ripristinando una versione precedente potrebbe costare un sacco di soldi.

Uno degli argomenti che vedrai di non aver bisogno di composer.lock è che puoi impostare la versione esatta di cui hai bisogno nel tuo file composer.json e che in questo modo, ogni volta che qualcuno esegue composer install, li installerà allo stesso modo codice. Questo non è vero, perché le tue dipendenze hanno le loro dipendenze e la loro configurazione potrebbe essere specificata in un formato che consenta di aggiornare le sovversioni, o forse anche intere versioni.

Ciò significa che anche quando specifichi di voler Laravel 4.1.31 nel tuo compositore.JSON , Laravel nel suo compositore.json file potrebbe avere le sue dipendenze richieste come dispatcher di eventi di Symfony: 2. *. Con questo tipo di configurazione, potresti finire con Laravel 4.1.31 con Symfony Event-Dispatcher 2.4.1 e qualcun altro nella tua squadra potrebbe avere Laravel 4.1.31 con Event-Dispatcher 2.6.5, tutto dipenderà da quando è stata l'ultima volta che hai eseguito l'installazione del compositore.

Quindi, avere il tuo file composer.lock nel sistema di versioni memorizzerà la versione esatta di queste dipendenze secondarie, quindi, quando tu e il tuo compagno di squadra fate l'installazione di un compositore (questo è il modo in cui installerete le vostre dipendenze basate su un compositore. blocco ) entrambi otterrete le stesse versioni.

Cosa succede se si desidera aggiornare? Quindi, nel tuo ambiente di sviluppo, esegui:, composer updatequesto genererà un nuovo file composer.lock (se c'è qualcosa di nuovo) e dopo averlo testato, test QA e regressione testarlo e altro. Puoi spingerlo per tutti gli altri a scaricare il nuovo composer.lock , poiché è sicuro aggiornarlo.

3. Non dovresti controllare la versione delle tue effettive dipendenze , perché non ha senso. Con il compositore.lock puoi installare la versione esatta delle dipendenze e non dovrai impegnarle. Perché dovresti aggiungere al tuo repo 10000 file di dipendenze, quando non dovresti aggiornarli. Se è necessario modificarne uno, è necessario forkarlo e apportare le modifiche lì. E se sei preoccupato di dover recuperare le dipendenze effettive ogni volta di una build o di un rilascio, il compositore ha diversi modi per alleviare questo problema, cache, file zip, ecc.


1
Grazie, penso che questa risposta spieghi perché dovresti avere la versione composer.lock e, in caso contrario, quali sono le conseguenze e se puoi vivere con loro.
José Lozano Hernandez,

8

Quindi esegui il commit del composer.jsonprogetto e tutti gli altri membri del tuo team possono eseguire l'installazione di Composer per installare le dipendenze del progetto.

Il punto del file di blocco è registrare le versioni esatte installate in modo che possano essere reinstallate. Ciò significa che se si dispone di una versione specifica di 1. * e il proprio collega esegue l'aggiornamento del compositore che installa 1.2.4 e quindi esegue il commit del file composer.lock, quando si installa il compositore, si otterrà anche la 1.2.4, anche se 1.3.0 è stato rilasciato. Questo assicura che tutti coloro che lavorano al progetto abbiano la stessa versione esatta.

Ciò significa che se è stato eseguito il commit di qualcosa dall'ultima volta in cui è stata eseguita l'installazione di un compositore, quindi, senza un file di blocco, verrà rimosso il nuovo codice di terze parti .

Ancora una volta, questo è un problema se sei preoccupato per la tua violazione del codice. Ed è uno dei motivi per cui è importante pensare a Composer come centrato sul file composer.lock.

Fonte: Compositore: è tutto sul file di blocco .


Conferma il composit.lock della tua applicazione (insieme a composer.json) nel controllo della versione. Questo è importante perché il comando install verifica se è presente un file di blocco e, in tal caso, scarica le versioni specificate lì (indipendentemente da ciò che dice composer.json). Ciò significa che chiunque imposta il progetto scaricherà la stessa identica versione delle dipendenze. Il tuo server CI, macchine di produzione, altri sviluppatori nel tuo team, tutto e tutti funzionano con le stesse dipendenze, il che mitiga il potenziale di bug che interessano solo alcune parti delle distribuzioni. Anche se si sviluppa da solo, in sei mesi quando si reinstalla il progetto si può avere la certezza che le dipendenze installate continueranno a funzionare anche se le dipendenze hanno rilasciato molte nuove versioni da allora.

Fonte: Compositore - Uso di base .


1

Se sei preoccupato per la tua violazione del codice, dovresti impegnarti nel composer.locktuo sistema di controllo della versione per assicurarti che tutti i tuoi collaboratori del progetto stiano usando la stessa versione del codice. Senza un file di blocco, otterrai sempre il nuovo codice di terze parti.

L'eccezione è quando usi una meta app, librerie in cui le dipendenze dovrebbero essere aggiornate al momento dell'installazione (come l' app Zend Framework 2 Skeleton ). Quindi l'obiettivo è quello di afferrare le ultime dipendenze ogni volta che vuoi iniziare a sviluppare.

Fonte: Compositore: è tutto sul file di blocco

Vedi anche: Quali sono le differenze tra l'aggiornamento del compositore e l'installazione del compositore?


1

Non c'è una risposta esatta a questo.

In generale, il compositore non dovrebbe fare ciò che dovrebbe fare il sistema di compilazione e non dovresti inserire composer.lock in VCS. Il compositore potrebbe stranamente averlo al contrario. Gli utenti finali anziché i produttori non dovrebbero utilizzare i file di blocco. Di solito il tuo sistema di generazione mantiene ogni volta istantanee, directory riutilizzabili, ecc. Anziché una directory vuota. Le persone che effettuano il checkout di una libreria dal compositore potrebbero volere che la libreria utilizzi un blocco in modo che le dipendenze che la libreria carica sono state testate.

D'altro canto, ciò aumenta in modo significativo l'onere della gestione delle versioni, dove quasi sicuramente vorresti più versioni di ogni libreria poiché le dipendenze saranno rigorosamente bloccate. Se è probabile che ogni libreria abbia una versione leggermente diversa, allora hai bisogno di un supporto per più versioni della libreria e puoi anche vedere rapidamente le dimensioni delle dipendenze necessarie, quindi ti consigliamo di tenerlo sulla foglia.

Tenendo conto di ciò, non trovo davvero che i file di blocco siano utili né per le librerie né per i tuoi workdir. Per me è utile solo nella mia piattaforma di build / testing che persiste qualsiasi risorsa acquisita esternamente aggiornandola solo quando richiesto, fornendo build ripetibili per test, build e distribuzione. Sebbene ciò possa essere mantenuto in VCS non sempre con l'albero di origine, gli alberi di build saranno o altrove nella struttura VCS o gestiti da un altro sistema altrove. Se è memorizzato in un VCS, è discutibile se tenerlo o meno nello stesso repository degli alberi dei sorgenti perché altrimenti ogni pull può portare a una massa di asset di build. Mi piace piuttosto avere tutto in un repository ben organizzato, ad eccezione della produzione / credenziali sensibili e gonfia.

SVN può farlo meglio di git in quanto non ti obbliga ad acquisire l'intero repository (anche se sospetto che non sia nemmeno strettamente necessario per git ma il supporto per questo è limitato e non è comunemente usato). I repository di build semplici sono in genere solo un ramo di overlay in cui unisci / esporta l'albero di build. Alcune persone combinano risorse esterne nel loro albero di origine o separano ulteriormente, esterni, costruiscono e alberi di fonte. Di solito serve due scopi, costruire cache e build ripetibili, ma a volte tenerlo separato almeno su un certo livello consente anche build fresche / vuote e build multiple.

Esistono diverse strategie per questo e nessuna di esse funziona particolarmente bene con il persistere dell'elenco delle fonti a meno che tu non stia mantenendo una fonte esterna nella tua struttura di fonti.

Hanno anche cose come gli hash nel file, come si fondono quando due persone aggiornano i pacchetti? Solo questo dovrebbe farti pensare che forse questo è frainteso.

Gli argomenti che le persone avanzano per i file di blocco sono casi in cui hanno preso una visione molto specifica e restrittiva del problema. Desideri build ripetibili e build coerenti? Includi la cartella del fornitore in VCS. Quindi acceleri anche il recupero delle risorse e non devi dipendere da risorse esterne potenzialmente rotte durante la compilazione. Nessuna delle pipeline di creazione e distribuzione che creo richiede accesso esterno a meno che non sia assolutamente necessario. Se devi aggiornare una risorsa esterna è una e una sola volta. Ciò che il compositore sta cercando di ottenere ha senso per un sistema distribuito ad eccezione di quanto menzionato prima, non ha senso perché finirebbe con l'inferno della dipendenza dalla libreria per gli aggiornamenti della libreria con scontri comuni e gli aggiornamenti sono lenti come il pacchetto più lento da aggiornare.

Inoltre aggiorno ferocemente. Ogni volta che sviluppo aggiorno e collaudo tutto. C'è una finestra molto piccola in cui si può insinuare una significativa deriva della versione. Anche realisticamente, quando viene sostenuto il versioning semantico, che tende ad essere per il compositore, non si suppone che ci siano così tanti problemi di compatibilità o rotture.

In composer.json inserisci i pacchetti richiesti e le loro versioni. È possibile bloccare le versioni lì. Comunque quei pacchetti hanno anche dipendenze con versioni dinamiche che non saranno bloccate da composer.json (anche se non vedo perché non potresti metterli lì anche tu se vuoi che siano bloccati versione) quindi qualcun altro che esegue l'installazione di Composer ottiene qualcosa di diverso senza il lucchetto. Potrebbe non interessarti molto di questo o ti potrebbe interessare, dipende. Dovrebbe interessarti? Probabilmente almeno un po ', abbastanza per assicurarti di esserne consapevole in ogni situazione e potenziale impatto, ma potrebbe non essere un problema se hai sempre il tempo di eseguire solo DRY per primo e riparare tutto ciò che è stato aggiornato.

Il compositore delle seccature sta cercando di evitare a volte semplicemente non c'è e la seccatura che i file di blocco del compositore possono fare è significativa. Non hanno assolutamente alcun diritto di dire agli utenti cosa dovrebbero o non dovrebbero fare in merito alla costruzione rispetto alle risorse di origine (se aderire separatamente a VCS) in quanto non sono affari loro, non sono il capo di te o di me. "Il compositore dice" non è un'autorità, non sono il tuo ufficiale superiore né danno a nessuno alcuna superiorità su questo argomento. Solo tu conosci la tua situazione reale e cosa è meglio per quello. Tuttavia, potrebbero consigliare un corso di azione predefinito per gli utenti che non capiscono come funzionano le cose nel qual caso potresti voler seguirlo, ma personalmente non penso che " un vero sostituto per sapere come funzionano le cose e per essere in grado di allenare correttamente le tue esigenze. Alla fine, la loro risposta a questa domanda è la migliore ipotesi. Le persone che fanno il compositore non sanno dove dovresti tenere il tuo compositore, né dovrebbero. La loro unica responsabilità è dirti di cosa si tratta e cosa fa. A parte questo, devi decidere cosa è meglio per te.

Mantenere il file lock dentro è problematico per usabilità perché il compositore è molto riservato se usa lock o JSON e non sempre è bene usarli entrambi insieme. Se esegui install, usa solo il file di blocco che apparirebbe, quindi se aggiungi qualcosa a composer.json non verrà installato perché non è nel tuo blocco. Non è affatto intuitivo ciò che le operazioni realmente fanno e ciò che stanno facendo in relazione al file json / lock e a volte non sembrano nemmeno avere un senso (aiuto dice che install prende il nome di un pacchetto ma nel provare a usarlo dice no ).

Per aggiornare il blocco o fondamentalmente applicare le modifiche dal json devi usare update e potresti non voler aggiornare tutto. Il blocco ha la precedenza per la scelta di cosa deve essere installato. Se c'è un file di blocco, è quello che viene utilizzato. È possibile limitare l'aggiornamento in qualche modo, ma il sistema è ancora solo un casino.

L'aggiornamento richiede un'età, concerti di RAM. Ho anche il sospetto che se raccogli un progetto che non è stato toccato per un po 'che è sembrato dalle versioni che ha, che ci sarà più nel tempo e probabilmente non lo fa in modo efficiente che lo strangola.

Sono molto subdoli quando si tratta di avere comandi compositi segreti che non puoi aspettarti di essere compositi. Per impostazione predefinita, il comando di rimozione del compositore appare sulle mappe per l'aggiornamento del compositore e la rimozione del compositore, ad esempio.

La domanda che devi davvero porre non è se dovresti tenere il lucchetto nel tuo albero dei sorgenti o in alternativa se dovresti persistere da qualche parte in qualche modo o no, ma piuttosto dovresti chiederti cosa fa effettivamente, quindi puoi decidere da solo quando è necessario persistere e dove.

Sottolineerò che avere la possibilità di avere il blocco è una grande comodità quando si dispone di una solida strategia di persistenza delle dipendenze esterne poiché tiene traccia di te delle informazioni utili per rintracciarle (le origini) e aggiornarle ma se non lo fai allora non è né qui né lì. Non è utile quando ti viene forzato in gola come opzione obbligatoria per inquinare i tuoi alberi di origine. È una cosa molto comune trovare in basi di codice legacy in cui le persone hanno apportato molte modifiche a composer.json che non sono state realmente applicate e si rompono quando le persone cercano di usare compositore. Nessun compositore.lock, nessun problema di desincronizzazione.


0

Sì ovviamente.

Questo perché un compositore installato localmente darà la prima preferenza al file composer.lock rispetto a composer.json.

Se il file lock non è disponibile in vcs, il compositore punterà al file composer.json per installare le dipendenze o le versioni più recenti.

Il file composer.lock mantiene la dipendenza in modo più approfondito, ovvero indica il commit effettivo della versione del pacchetto che includiamo nel nostro software, quindi questo è uno dei file più importanti che gestisce la dipendenza in modo più fine.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.