Salta ai contenuti
AggregaAggrega
Seleziona lingua: Italiano
Questa pagina è stata tradotta automaticamente. Leggi l’originale in inglese.

aggrega pull

aggrega pull risolve tutte le dipendenze di una Release e scrive un lockfile che fissa ogni dipendenza a una versione e a un digest del contenuto esatti. Un aggrega build successivo usa ciò che il lockfile fissa, lo verifica e si arresta indicando qualsiasi cosa di cui ha bisogno che non vi sia fissata — così le build sono riproducibili e possono funzionare offline.

Tutto ciò che una build consuma viene fissato in questo unico momento. Le entità del catalogo, gli artefatti sorgente a cui una Recipe indirizza un provider e i documenti remoti che un provider richiede durante il rendering vengono risolti dallo stesso comando e registrati nella stessa scrittura del lockfile. aggrega pull è il passaggio che tocca la rete; la build no. Questa è tutta la regola, e il resto di questa pagina è ciò che ne consegue.

Cosa fa

aggrega pull risolve tre tipi di dipendenza in un solo passaggio:

  • Entità del catalogo — i Components, le Features, le Recipes, le FeatureRecipes, le librerie di schemi e di mapping e i plugin Wasm a cui la Release fa riferimento, risolti in modo transitivo (tramite extends:, implements:, aggregate:, gli agganci delle Feature e i punti $import: / $ref: delle librerie) e recuperati dal registry quando non sono già presenti in locale.
  • Artefatti sorgente — la source: remota verso cui una singola Recipe o FeatureRecipe indirizza un provider: un chart Helm (OCI o HTTPS classico) o un frammento Compose su HTTPS. Ciascuno viene recuperato, messo in cache e fissato con un pin.
  • Input esterni — i documenti remoti che un provider chiede all’host durante il rendering, come un $ref nel values.schema.json di un chart che punta a un URL. Ciascuno viene recuperato, archiviato sotto il proprio digest del contenuto e fissato con un pin.

Due dei tre si leggono dai documenti che hai scritto. Il terzo no: gli input esterni si trovano eseguendo il rendering della Release, ed è per questo che questo comando ne esegue uno. Per eseguire il comando non serve nulla di tutto ciò — Come la risoluzione trova gli input esterni lo spiega per intero, insieme a quanto costa il rendering, a cosa succede quando non può completarsi e a come vi si rapporta una build che compila il proprio lockfile.

Un’entità del catalogo nominata senza registry viene recuperata tramite il default_registry del workspace, e il percorso di repository che il default contiene è il luogo da cui viene recuperata. Con default_registry: ghcr.io/acme, core/api-server viene recuperato da ghcr.io/acme/component/core/api-server — dove aggrega push lo pubblica tramite lo stesso default — ed è lì che se ne cerca la firma. Il percorso indica solo la posizione: la firma che un pull richiede, le chiavi e le identità di cui si fida e la credenziale che presenta sono quelle conservate per l’host, quindi la voce registries per ghcr.io governa ogni percorso su quell’host. Il lockfile registra un’entità di questo tipo in base alla sua identità, alla versione e ai digest, così come registra un’entità recuperata da un host senza percorso. La sintassi di un percorso è descritta in come si scrive un host di registry.

Il comando scrive il risultato in <release-stem>.lock accanto alla Release. Un workspace che aggancia un plugin che restituisce un verdetto di accettazione o rifiuto ottiene anche un secondo file in quella directory — il record di fiducia dei plugin.

Un pull a cui si chiede di fissare i pin scrive un tipo di file in più. Accanto a ogni Recipe e FeatureRecipe nelle tue directory di catalogo che importa un file di artefatto, punta a una source: remota che hai scritto per intero o legge una source: accanto a sé, si trova un entity.lock che registra il digest di quel contenuto. Registrarlo è il passo dell’autore dell’entità, aggrega pin, e per impostazione predefinita un pull non lo esegue: confronta il lock di ciascuna di queste entità con ciò che il passo registrerebbe, e si arresta dove manca un pin. aggrega pull --pin-sources, o un workspace che imposta pin_sources_at_pull: true, esegue invece il passo — e allora l’effetto di un pull arriva oltre la directory in cui si trova la Release, anche se i file di entità che hai scritto non vengono mai modificati. Il lock dell’entità descrive quel file, e Anteprima di ciò che un pull scriverebbe mostra l’intero insieme per il tuo workspace prima che qualcosa cambi.

Un pull rifiutato perché un riferimento non si è risolto in nulla indica da dove vengono lette le entità locali, ovunque venga eseguito. Il rifiuto riporta il resoconto del workspace stesso sulle directory da cui ha letto le entità locali e su cosa cambiare perché l’entità venga letta — la nota che Da dove vengono lette le entità locali mostra — e lo riporta da questo comando, da una build che risolve prima le proprie dipendenze, dallo strumento di pull di aggrega mcp e allo stesso modo dalla risoluzione delle dipendenze di un editor, perché è la risoluzione eseguita da tutti loro a comporlo. Il rifiuto dello strumento di pull indica anche il codice breve e il codice descrittivo della condizione, così come un terminale stampa il codice breve in testa al rifiuto. Un file in quelle directory che dichiara una apiVersion di Aggrega — una riga che inizia, senza rientro, con apiVersion: e un valore che comincia con aggrega.ai/ — e che non è stato possibile caricare, ad esempio uno che non viene analizzato come YAML, viene nominato nello stesso rifiuto, tra i file di catalogo saltati al caricamento, con il motivo fornito dal parser stesso: un file del genere potrebbe essere quello che dichiara l’entità nominata dal riferimento, e non se ne può leggere nulla che dica quale entità dichiari. Un file YAML che dichiara un’altra apiVersion, o nessuna, non è un documento Aggrega e non viene mai nominato lì.

Il lockfile

Il lockfile fissa ogni dipendenza al suo URI, alla versione risolta e al digest del contenuto. Ha sezioni per le entità del catalogo, le librerie di schemi e di mapping (ciascuna con riferimenti inversi ai Components e alle Features che la consumano), i plugin Wasm, gli artefatti sorgente, gli input esterni (ciascuno indicizzato per URL e con i plugin che lo hanno richiesto) e i file della Release stessi. Il file è scritto in una forma canonica e deterministica.

Un’entità viene registrata in base a ciò che una sua pubblicazione contiene. Il digest nella riga di un’entità copre il suo documento e ogni file che nomina accanto a sé — la source: locale di una Recipe o di una FeatureRecipe, ogni file nominato da un $import:, l’entity.lock accanto a essa, ogni file di schema che un Component o una Feature importa — lo stesso insieme che aggrega push pubblica. Ogni file contribuisce con il proprio percorso e i propri byte, e nient’altro contribuisce: né il modo in cui un archivio è stato compresso, né un timestamp, né un bit di permesso, compreso il bit di esecuzione. Un’entità che non nomina alcun file viene registrata come quell’unico documento. Così la stessa entità registra lo stesso digest sia che sia stata letta dalla tua directory di catalogo sia che sia stata recuperata da un registry, e un lockfile committato da un checkout si verifica su un altro checkout dello stesso commit qualunque sia la sua umask, e indipendentemente dal fatto che il sistema di quel checkout registri quali file sono eseguibili. Un chart modificato sotto una Recipe, un file aggiunto a una sorgente che essa dichiara e un entity.lock modificato cambiano ciascuno il digest; uno script il cui bit di esecuzione è stato invertito, e una nota accanto all’entità che nulla nomina, no. L’Aggregate e il Manifest che la Release nomina sono registrati allo stesso modo, ciascuno come il suo unico documento. Una libreria è registrata in base al digest dei suoi byte, che sono il suo documento ovunque venga letta.

Ogni Recipe e FeatureRecipe che il Manifest associa è una riga, qualunque sia il livello che la associa. Una realizzazione che il livello name del Manifest sceglie per una singola istanza o un singolo aggancio viene acquisita e registrata esattamente come una che il suo livello type sceglie per ogni istanza di un tipo, e il campo referenced_from della sua riga nomina la voce che la associa — manifest.spec.mappings.components.name.<instance> o manifest.spec.mappings.features.name.<attachment>. Una build la confronta con quella riga, quindi un lockfile che non la registra arresta la build, nominando la realizzazione e quella voce. Vedi Mappatura URI piatta per i due livelli.

Gli agganci di una connessione sono dipendenze esattamente come quelli di un componente. La Feature che un aggancio su una connessione nomina — scritto su una voce uses: di un componente nell’Aggregate, o su una voce di connessione nella Release — viene acquisita e registrata come la Feature di un aggancio scritto sul componente stesso, e il campo referenced_from della sua riga nomina la voce di connessione scritta dall’autore, che termina con .uses.<socket>.<alias>.features.<slot>.type. Anche la realizzazione che il Manifest le associa è una riga, sia che la associ features.type sia features.name indicizzato per il nome dell’aggancio, <alias>.<slot>. Una build confronta entrambe con le loro righe: un lockfile privo di una delle due arresta la build nominando il riferimento e la voce che lo richiede, e una Feature il cui contenuto è cambiato dopo il pull la arresta nominando entrambi i digest. Vedi la voce di connessione dell’Aggregate per l’aggancio stesso.

Una base estesa da un Component o da una Feature è una riga, che qualcos’altro la nomini o no. Il pull segue ogni extends: fino alla fine della sua catena e registra ogni base sotto il proprio tipo di entità, con il referenced_from della sua riga che nomina lo spec.extends dell’entità che la estende — component(<name>:<version>).spec.extends. Una build legge la base da quella riga, quindi un Manifest mappa il tipo proprio di un wrapper e non ha bisogno di alcuna riga per la sua base. Una base che nessuna directory di catalogo, cache o registry contiene viene segnalata nel punto in cui la catena viene unita — vedi An extends: chain cannot be assembled (Non è possibile assemblare una catena).

La Release viene registrata in base al suo contenuto, non solo al suo nome. Tutto ciò che la Release richiede — a quale versione di chart si risolve una sorgente, quali componenti finiscono in quale confine — viene risolto da ciò che il file contiene, quindi release_documents registra il digest della Release e di ogni Release che essa estende, accanto a release, che la nomina. Modifica la Release dopo il pull e la build successiva si arresta prima di qualsiasi rendering, nominando il file modificato e indicandoti di eseguire di nuovo il pull; un semplice aggrega pull --release <release> registra la modifica rispettando ogni altro pin. Il digest copre i byte del file così come sono, quindi conta anche una modifica a un commento o agli spazi, esattamente come per l’Aggregate e il Manifest. Un file che la Release importa tramite parameters non viene registrato in questo modo.

Un pull cerca un marcatore di deprecazione su ogni artefatto di cui verifica la firma, e dice che cosa ha trovato. Un marcatore la cui firma si verifica rispetto a un firmatario che il pull riconosce — il firmatario dell’artefatto stesso, o un’identità in trusted_deprecation_identities del registry — viene registrato e annunciato con la sua gravità e il firmatario del marcatore. Un marcatore che il pull ha trovato e non ha potuto riconoscere — illeggibile, non firmato, firmato da qualcuno di cui la policy non si fida, o con una firma che non è stato possibile verificare — viene segnalato come marker present but not honored, con il motivo, e non viene registrato. Una ricerca che non è stato possibile completare — il pull non ha potuto aprire il registry dell’artefatto, o l’elenco di ciò che vi è allegato non ha risposto — viene segnalata come marker lookup did not complete, con il motivo, e non registra nulla, perché il pull non ha appreso nulla sull’esistenza di un marcatore. Con un registry la cui policy di fiducia richiede una firma per il tipo dell’artefatto e non è advisory, ciascuno di questi due casi arresta il pull invece di essere segnalato. Un artefatto senza marcatore non produce alcuna riga, e dove la verifica delle firme è disattivata, per il workspace o per il registry dell’artefatto, non si cerca alcun marcatore.

Committa <release-stem>.lock insieme alla Release, come committi qualsiasi manifest di dipendenze fissate. Un diff del lockfile mostra ai revisori esattamente quali versioni e digest delle dipendenze sono cambiati; una modifica al digest di una libreria nomina i consumatori su cui incide.

Ciò che un dato pull ha fatto — se ogni entità è stata recuperata ex novo da un registry (fetched-fresh), ha riutilizzato uno slot della cache (cache-reuse), è stata trovata in un catalogo locale (local), è stata servita dalla copia interna al binario del compilatore (in-binary) o era esterna (external: l’Aggregate o il Manifest della Release stessa, letti dal file o dalla voce che la Release nomina anziché risolti come una delle sue dipendenze; un Aggregate che il pull ha recuperato da un registry è invece fetched-fresh) — è una diagnostica transitoria dell’evento di pull stampata su stdout da --detail, e non viene mai scritta nel lockfile. Quale sorgente abbia servito un’entità dipende dallo stato locale della macchina che esegue il pull, quindi renderlo persistente romperebbe l’identità byte per byte del lockfile tra macchine diverse. Riporta ciò che questo pull ha fatto, che in seguito non è più ricostruibile (un’entità appena scaricata viene messa in cache dall’esecuzione successiva); per lo stato di risoluzione dopo il pull delle dipendenze di una Release, usa aggrega inspect.

Il lock dell’entità

Una Recipe o FeatureRecipe può dipendere da byte esterni al proprio documento: un chart o un frammento recuperato da una source: remota, un file che una voce artifacts — o una voce del boundary.artifacts di una Recipe — introduce con $import, oppure i file di una source: che nomina una directory o un file accanto a essa. Il digest di ciascuno di questi viene registrato in un file chiamato entity.lock, nella stessa directory del file dell’entità. Il file dell’entità che hai scritto non viene mai modificato; ciò che ne è stato derivato vive accanto a esso. Lo schema del lock dell’entità descrive il file campo per campo.

Chi lo scrive. Lo scrive un solo passo: aggrega pin, che l’autore dell’entità esegue, non richiede alcuna Release e registra ogni classe di pin che il lock contiene. aggrega pull --pin-sources e aggrega push --pin-sources eseguono lo stesso passo per conto dell’autore e scrivono gli stessi byte. Un pull a cui non si è chiesto di fissare i pin non scrive alcun lock: per ogni Recipe e FeatureRecipe che la Release costruisce dalle tue directory di catalogo, confronta ciò che il passo registrerebbe con ciò che il lock contiene, e si arresta dove un pin manca o non corrisponde più al suo input, nominando l’entità, ogni input e la sua classe, e aggrega pin. I file di una sorgente locale vengono confrontati con i loro pin come un unico insieme: un lock che non ne registra nessuno arresta il pull, e lo stesso fa un file aggiunto, modificato o rimosso dopo il pin. La chiave di workspace pin_sources_at_pull rende il pinning il comportamento predefinito di ogni pull, e --pin-sources=false ripristina l’arresto per una singola esecuzione. Il pinning è un compito dell’autore, quindi un arresto al primo pull di un consumatore significa che l’editore dell’entità non l’ha mai fissata; il rimedio del consumatore è quella chiave, non una modifica manuale della directory di qualcun altro. aggrega pin lo spiega per intero.

Cosa contiene. Tre elenchi, ciascuna riga dei quali nomina un input:

  • sourceDigests — una riga per ogni source: remota le cui coordinate hai scritto per intero, senza template in kind, url, chart, module_subdir, version o ref. La riga riporta il kind e l’url della sorgente, il suo chart o module_subdir dove ne ha uno, la versione a cui si è risolta — per una sorgente git, il commit indicato dal suo ref — e il digest del contenuto dell’archivio recuperato, più il digest del manifest per un chart recuperato tramite OCI.
  • artifactDigests — una riga per ogni voce artifacts o boundary.artifacts fornita da un file importato con $import, che nomina la voce e il digest dei byte del file. Una voce artifacts è nominata dalla sua chiave, e una voce boundary.artifacts come boundary/<key>, così una voce di ciascun blocco scritta sotto la stessa chiave riceve un pin distinto.
  • localSourceDigests — una riga per ogni file con cui una source: che nomina una directory o un file accanto all’entità contribuisce a ciò che una pubblicazione dell’entità contiene, che nomina il percorso del file accanto all’entità e il digest dei suoi byte. Per una sorgente di questo tipo non si recupera nulla; il digest dei suoi file viene calcolato così come sono. Una sorgente scritta come template contribuisce con ogni file nella directory dell’entità, quindi ciascuno di essi ha una riga.

Cosa non contiene:

  • Una sorgente remota le cui coordinate sono compilate da un template — una version letta da .infra, per esempio. Quale artefatto nomina lo decide ogni Release che usa l’entità, quindi ogni versione a cui si risolve viene fissata nel lockfile di quella Release, e nulla che la riguardi viene scritto accanto all’entità.
  • Una voce artifacts o boundary.artifacts inline, che fa parte del file dell’entità, e una voce presa da un’ArtifactLibrary, il cui contenuto è fissato dalla versione della libreria che il lockfile registra.

Un’entità senza nulla da fissare non riceve alcun entity.lock, e il passo, eseguito su un’entità che non ne ha più bisogno, lo rimuove.

Committalo accanto all’entità. Ogni Recipe e FeatureRecipe usa lo stesso nome di file, e la directory in cui si trova dice a quale entità appartiene, quindi il lock viaggia con quella directory. Non contiene alcun timestamp e le sue righe sono mantenute in un ordine fisso, quindi il passo su input invariati lo lascia identico byte per byte, e un diff su di esso nomina la sorgente, il file importato o il file della sorgente locale che è cambiato. Una directory contiene un solo lock, quindi il passo rifiuta una Recipe o FeatureRecipe con qualsiasi altra entità accanto — ogni tipo ha una directory propria tranne Aggregate, Release e Manifest — e un pull a cui si chiede di fissare i pin rifiuta un’entità di questo tipo prima che qualcosa venga risolto; Un’entità per directory espone la regola. Un pull che non fissa pin non scrive nulla accanto a un’entità e non valuta la sua directory.

aggrega build confronta i tuoi file con esso. Una build legge il lock ed esegue tre confronti:

  • Il digest di ogni file importato viene ricalcolato e confrontato con la sua riga, un file boundary.artifacts esattamente come un file artifacts. Un file modificato dopo il pin arresta la build con [CATALOG_ERROR E0026], nominando l’artefatto come lo nomina la sua riga, il file importato ed entrambi i digest.
  • Il digest dei file di una sorgente locale viene ricalcolato e confrontato con le loro righe, come un unico insieme, prima che il provider legga la sorgente. Un file modificato, aggiunto o rimosso dopo il pin arresta la build con E0305 sotto l’istanza di componente di cui è la sorgente, nominando ciascuno di questi file ed entrambi i digest; un file accanto all’entità con cui la sorgente non contribuisce non viene confrontato. Un lock che non registra alcuna riga per una sorgente locale non lascia nulla da confrontare, come descrive A local source no longer matches the pins recorded beside its Recipe (Una sorgente locale non corrisponde più ai pin registrati accanto alla sua Recipe).
  • Ogni riga di sorgente viene confrontata con il digest che il lockfile della Release registra per la stessa sorgente. Una discordanza arresta la build con [FETCH_ERROR E0135], nominando il lock ed entrambi i digest. I due file sono scritti da due risoluzioni della stessa sorgente — quella del passo di pin e quella del pull — quindi sono discordi quando quelle risoluzioni hanno ottenuto byte diversi, o quando uno dei due file è stato modificato. Byte diversi sotto una stessa versione sono l’aspetto di un upstream che ha ripubblicato una versione.

Un lockfile scritto prima della modifica provoca per primo un arresto, e un pull nomina il file. Il lockfile registra l’entità in base a ciò che contiene, e il lock e ogni file letto da questi confronti ne fanno parte, quindi una build — o aggrega pull --verify — che usa un lockfile scritto prima che cambiassero un file importato, un file di una sorgente locale o il lock stesso si arresta prima che venga eseguito uno qualsiasi dei tre confronti: The lockfile no longer matches what the release resolves to (Il lockfile non corrisponde più a ciò a cui si risolve la release), nominando l’entità ed entrambi i digest. Un semplice aggrega pull nomina quindi il file, perché confronta il lock con ciò che il passo di pin registrerebbe e rifiuta l’input il cui pin non corrisponde più: An entity reads an input the lock beside it records no pin for (Un’entità legge un input per cui il lock accanto a essa non registra alcun pin).

Dove il lockfile non ha alcun record del contenuto proprio dell’entità, sono i tre confronti che una build incontra. Una Recipe o FeatureRecipe che il Manifest nomina tramite un riferimento che è anche il nome di un Component o di una Feature raggiunti dalla Release non ha una voce propria: la voce del lockfile per quel riferimento registra il Component o la Feature, quindi nel lockfile non cambia nulla quando cambiano i file della Recipe, e una build e un pull di verifica segnalano il file cambiato con il codice sopra indicato. Il confronto delle righe di sorgente è anche ciò che una build incontra quando la voce source_artifacts del lockfile è il record che è cambiato mentre il lock accanto all’entità no.

Rispondere all’arresto. Se hai modificato il file importato di proposito, esegui aggrega pin sull’entità: il passo registra il nuovo digest del file e la build successiva lo accetta. Altrimenti, ripristina il file. Una sorgente locale cambiata ammette le stesse due risposte: fissa di nuovo l’entità, oppure ripristina i file che l’arresto nomina. Per una riga di sorgente discorde dal lockfile, ripristina entity.lock dal controllo di versione, oppure esegui aggrega pin sull’entità per riscriverlo.

Anche aggrega pull --verify lo controlla. Un pull di verifica esegue gli stessi tre confronti sui lock accanto alle Recipes e alle FeatureRecipes che la Release raggiunge nelle tue directory di catalogo, segnala ogni pin che una build rifiuterebbe con lo stesso codice e con le stesse parole, termina con un codice diverso da zero se ce n’è uno e non scrive alcun lock.

Dove nessun lock viene confrontato. Una Recipe o FeatureRecipe risolta da un registry anziché da una delle tue directory di catalogo non ha un lock che una build legga; le sue sorgenti vengono confrontate solo con il lockfile della Release. E una sorgente scritta con un ref: git viene registrata nel lock al commit a cui quel ref si è risolto, mentre una build cerca il pin della sorgente alla versione che l’entità nomina, quindi quella riga non viene mai confrontata — né da una build né da un pull di verifica. Il lockfile fissa comunque il commit, e ogni build verifica l’archivio in cache rispetto a esso.

Il registro di fiducia dei plugin

Alcuni plugin che il workspace aggancia non danno mai forma all’output renderizzato. Un aggancio plugins.governance in un ruolo ir-verdict o render-verdict, e ogni aggancio plugins.linter, restituiscono un verdetto di accettazione o rifiuto e nient’altro — nessun loro byte raggiunge un artefatto. Quindi non fanno parte di ciò che una build riproduce byte per byte, e il lockfile, che fissa esattamente quello, è il posto sbagliato per loro.

Le loro identità vanno invece in un secondo file committato: plugins-trust.yaml, accanto al lockfile. Contiene una voce per ciascuno di questi plugin, che registra la coordinata di identità del plugin, la versione selezionata per esso e il digest del contenuto dell’artefatto risolto — più la firma che il pull ha verificato per quell’artefatto, dove ne ha verificata una, e, quando l’editore ha deprecato quell’artefatto dopo averlo pubblicato, il marcatore che il pull ha trovato e verificato. Lo schema del record di fiducia dei plugin descrive il file campo per campo.

Committa plugins-trust.yaml insieme al lockfile, per lo stesso motivo per cui committi il lockfile: un record tenuto fuori dal controllo di versione è un record che nessuno può revisionare e con cui nulla può essere confrontato. Committato, è un’unica dichiarazione condivisa di quale plugin ciascuno di quegli agganci ha risolto, e un diff su di esso nomina l’identità che è cambiata.

Il file compare solo quando c’è qualcosa da registrare. Un workspace che non aggancia alcun plugin che restituisce verdetti non risolve alcuna identità di questo tipo, quindi il pull non scrive alcun file e non dice nulla al riguardo — un’assenza, non un file mancante. Quando il pull lo crea, nomina il file creato e ti dice di committarlo. Un pull successivo aggiunge un’identità che il record non contiene ancora e lascia ogni identità già registrata esattamente com’è.

Ogni modifica a questo file viene annunciata, e nient’altro lo è. Un pull che modifica il record stampa una riga per ogni voce modificata, nominando il plugin e il tipo di modifica: un’identità registrata per la prima volta, un’identità adottata al posto di quella presente (nominandole entrambe, così puoi vedere cosa è stato sostituito), una deprecazione registrata sull’artefatto che una voce già nomina, una deprecazione rimossa da una voce, una firma registrata su una voce o rimossa da essa, oppure la voce eliminata. La riga di creazione descritta sopra è separata e riguarda il file anziché una voce, quindi una prima risoluzione dice entrambe le cose: questo file è nuovo e va committato, e queste sono le identità che ora contiene.

Un pull che lascia il record esattamente com’era non dice nulla al riguardo. Quindi una riga su questo file significa che il file committato è cambiato e che vale la pena leggerne il diff — il che qui conta più che per il lockfile. Tutto ciò che il lockfile fissa fa anche parte di ciò che una build riproduce byte per byte, quindi una modifica lì ha un secondo posto in cui emergere; l’identità di un plugin di verdetto non ne ha. Questo file è l’unico posto in cui viene annotato un gate sostituito.

aggrega pull --dry-run non annuncia nulla di tutto ciò, perché non modifica nulla. Elenca invece il record tra i file che scriverebbe, come descrive Anteprima di ciò che un pull scriverebbe.

Una deprecazione viene aggiunta a una voce che il record contiene già, e questo non equivale a riscriverla. Se un editore depreca un plugin di cui ti fidi già, il successivo aggrega pull registra il marcatore sulla voce esistente di quel plugin — la coordinata, la versione e il digest restano invariati, perché l’artefatto non è cambiato e non si sta adottando nulla di nuovo. Quindi un semplice pull può aggiungere un blocco deprecation, e solo un aggiornamento esplicito cambia un’identità. Un marcatore viene registrato solo sull’artefatto che la voce già nomina, e nessun pull insegue un marcatore che ha smesso di essere pubblicato: un marcatore registrato se ne va solo con la voce che lo conteneva, cioè quando quella voce viene eliminata, oppure quando un aggiornamento esplicito risolve di nuovo il plugin e non trova alcun marcatore sui byte che la voce già registra.

La firma verificata viene registrata su una voce allo stesso modo, e ogni pull vi risponde da capo. Il pull verifica la firma di ciascuno di questi plugin rispetto alla policy di fiducia del suo registry a ogni esecuzione — un plugin servito da un registry viene recuperato ogni volta in base alla sua versione, poiché nulla lo fissa — e registra ciò che ha verificato sulla voce del plugin, sempre senza toccare l’identità: la modalità, il firmatario che ha trovato corrispondenza e il digest del bundle di firma messo in cache, la stessa signature che contiene una voce del lockfile. A differenza di un marcatore, la risposta sostituisce ciò che la voce conteneva, e dove il pull non ha verificato alcuna firma — il plugin non ne ha e nessuna è richiesta, oppure skip_signature_verification o un registry advisory lo ha ammesso — la voce non ne registra alcuna. Anche il bundle di firma verificato viene di nuovo messo in cache, e una copia in cache che non corrisponde più al suo digest viene riscritta. Così una voce che ha perso la firma, una voce con una firma copiata da quella di un altro plugin, una voce il cui bundle di firma in cache è stato rimosso o alterato, o un record eliminato o scritto prima che venisse registrata una firma, vengono riparati dal successivo semplice aggrega pull. Una build confronta ciascuno di questi plugin con quel fatto: vedi Il record di fiducia dei plugin nella pagina della build.

Un’identità risolta in disaccordo con quella registrata arresta il pull. Una voce registrata nomina sia una versione sia un digest, quindi il cambiamento dell’una o dell’altro è lo stesso evento: il plugin che verrebbe eseguito non è il plugin per cui il record è stato revisionato. La diagnostica nomina il plugin, ciò che il record contiene e ciò che questa risoluzione ha riportato, su entrambi gli assi contemporaneamente — e il pull si ferma senza toccare il record, così l’identità revisionata resta lì per il confronto. Si arresta per la sola versione (una ripubblicazione i cui byte non sono cambiati) esattamente come si arresta per il solo digest (un nuovo push alla stessa versione).

aggrega pull --verify esegue lo stesso confronto. Non scrive nessuno dei file che un pull committa, quindi non adotta nulla; segnala se quei file descrivono ancora ciò che un pull risolverebbe oggi, e il record è uno di essi. Confronta inoltre la firma di ogni voce con quella fornita dalla verifica del plugin eseguita dal pull stesso, e segnala una voce la cui firma un pull registrerebbe, sostituirebbe o rimuoverebbe — e un plugin per cui il record non contiene alcuna voce dove una build lo rifiuta perché non registra alcuna firma — come descrive Confronta le firme registrate, in entrambi i file.

Per adottare una nuova identità, richiedila per nome: aggrega pull --upgrade --release <release> <plugin>, nominando il plugin come lo nomina l’aggancio nel tuo .aggrega-config.yaml, senza alcun suffisso di versione. Questo risolve di nuovo quel solo plugin e ne riscrive la voce, lasciando invariati ogni altra dipendenza fissata e ogni altra identità registrata — e funziona anche se il plugin non ha un pin nel lockfile, perché una destinazione nominata può anche nominare uno di quegli agganci. Un aggrega pull --upgrade senza argomenti, che risolve di nuovo ogni dipendenza, risolve di nuovo e riscrive anche ogni identità registrata. Lo stesso fa aggrega build --upgrade, che esegue un pull di aggiornamento completo senza argomenti e non ha modo di nominare una singola destinazione.

Per rimuovere un’identità, richiedi anche questo per nome. Sganciare un plugin da .aggrega-config.yaml non ne cancella la voce, ed è voluto: un semplice aggrega pull non ne rimuove mai una. Esegui aggrega pull --upgrade --release <release> <plugin>, nominando il plugin come lo nomina il record — la sua coordinata di identità, che è la stringa stampata dall’arresto descritto più sotto — e la voce viene eliminata, lasciando invariati ogni altra dipendenza fissata e ogni altra identità registrata. Un aggrega pull --upgrade senza argomenti elimina ogni voce che nessun aggancio di verdetto nomina più, nello stesso passaggio che risolve di nuovo tutto il resto.

Eliminare l’ultima voce lascia il file al suo posto e vuoto anziché cancellarlo. Un record vuoto non contiene nulla, quindi non fissa nulla e non arresta nulla — come l’assenza di un record — e mantenere il file fa sì che la rimozione compaia nel suo diff come una rimozione.

Un record che non soddisfa il proprio schema arresta ogni comando che lo legge — una build, un lint con ambito di release e un pull, compreso un pull che non ha nulla di proprio da registrare. Un record svuotato e uno danneggiato sono deliberatamente diversi: lo svuotamento è il modo in cui si rimuove l’ultima voce, e un record svuotato resta silenzioso, mentre un file il cui contenuto non è più analizzabile è un guasto e non un record vuoto — leggerlo come vuoto renderebbe il troncamento del file un modo per disattivare il confronto. Ripristinalo dal controllo di versione per riavere le identità revisionate.

Un plugin servito dalla copia interna al binario del compilatore non viene registrato. Il pull registra ciò che ha acquisito — recuperato da un registry o letto dalla cache — e dal binario non si acquisisce nulla: quei byte sono identificati dalla versione del compilatore che li contiene, quindi non c’è una loro risoluzione propria da registrare. Agganciare un plugin che il binario contiene già non produce quindi alcuna voce per esso. È il record che resta limitato agli artefatti acquisiti, non una risoluzione fallita.

Una build, un lint con ambito di release e una validazione con ambito di release confrontano la configurazione del workspace con il record. Prima che venga eseguito uno qualsiasi di quegli agganci, aggrega build, aggrega lint --release e aggrega validate --release — e le stesse operazioni raggiunte tramite aggrega serve e aggrega mcp — confrontano gli agganci di verdetto che la configurazione nomina con le voci che il record contiene. Un plugin il cui digest dell’artefatto risolto non è quello registrato viene rifiutato anziché eseguito. Una voce del record di cui nessun aggancio di verdetto configurato rende conto arresta l’esecuzione: un gate che è stato revisionato e ora è assente lascia un output indistinguibile da un output approvato da quel gate, ed è proprio ciò che chi legge l’output non può vedere. L’arresto nomina il plugin e offre i due rimedi che differiscono in base a ciò che intendevi — aggancia di nuovo il plugin se la rimozione è stata un errore, oppure esegui l’aggiornamento esplicito descritto sopra se era voluta — e stampa quell’aggiornamento pronto da eseguire. La direzione inversa — un aggancio che il record non contiene ancora — è il primo avvistamento descritto sopra, e nessuno dei due confronti si arresta su di esso; il requisito di firma è l’unico vincolo a cui un aggancio senza voce non sfugge. Le stesse tre superfici confrontano ogni plugin che leggono dalla cache con la firma registrata nella sua voce, quando lo caricano, come descrive la pagina della build per una build. Gli ambiti di lint sull’intero catalogo e su una singola entità non consultano alcun record.

Una validazione viene confrontata con il record perché esegue gli stessi controlli di una build. aggrega validate --release raggiunge ogni controllo che aggrega build raggiunge, salvo la scrittura degli artefatti, plugin di gate compresi — è questo che fa sì che «questo si valida» significhi lo stesso di «questo si compila» — quindi l’identità del plugin che esegue viene confrontata con il record esattamente come quella di una build. Gli altri ambiti di aggrega validate non vi sono soggetti: validare l’intero catalogo, una singola entità o un binario di plugin non legge affatto gli agganci di plugin del workspace, quindi in essi non viene eseguito alcun plugin di verdetto e non c’è nulla che un record possa vincolare.

Confrontare una configurazione con il record ne stabilisce la presenza e l’identità, e nulla di più. Stabilisce che ogni gate che il record nomina è ancora agganciato e che ciascuno viene eseguito dall’artefatto registrato per esso. Non stabilisce che un gate eseguito abbia effettivamente restituito un verdetto, e un caso di questo tipo non viene rilevato da nessuna parte: un aggancio la cui function nomina un export che il plugin dichiara effettivamente, che non è l’export di verdetto letto dal suo socket, e il cui output non contiene alcun campo di primo livello al di fuori della forma che quel socket si aspetta — l’oggetto vuoto è il caso più semplice — viene eseguito, non restituisce nulla su cui basare un rifiuto e lascia passare la build. Il suo output è indistinguibile da quello di un gate che approva, e nessun confronto con il record può accorgersene, perché nel record non c’è nulla di sbagliato: il plugin eseguito è esattamente quello registrato, e semplicemente non ha eseguito nulla. Due casi vicini si arrestano, quindi il limite non è più ampio di quanto sembri — una function che nomina un export che il plugin non dichiara viene rifiutata al caricamento del plugin, e un output che contiene un campo di primo livello che la forma del socket non dichiara viene rifiutato anziché letto come un elenco di verdetti che risulta vuoto. Quindi un’identità registrata non è di per sé sufficiente perché un gate abbia giudicato qualcosa.

Il digest registrato governa i plugin che il workspace risolve dalla cache popolata da aggrega pull, e nulla di ciò che risolve in altro modo. È la risoluzione che un aggancio di verdetto segue normalmente — nulla lo fissa nel lockfile, quindi i suoi byte provengono dalla cache, ed è in quella lettura che il digest risolto viene confrontato con quello registrato. Un plugin di verdetto che il workspace risolve in un altro modo non raggiunge mai quella lettura, ed è governato da ciò che governa il modo in cui si è risolto anziché dal record: i byte serviti dalla copia interna al binario del compilatore sono identificati dalla versione del compilatore che li contiene, un .wasm accanto alla sua entità di catalogo è un file nella tua directory di catalogo, un percorso esplicito del file system è il percorso che hai nominato, e un plugin con un pin nel lockfile è governato da quel pin. L’altra metà del confronto di una configurazione con il record non è limitata in questo modo: ogni voce che il record contiene deve ancora essere giustificata da un aggancio configurato, comunque quel plugin si risolva. Quindi il record stabilisce che i gate che nomina sono ancora agganciati, qualunque cosa li serva, e stabilisce l’identità dell’artefatto di quelli serviti dalla cache.

Rispettare o aggiornare

Per impostazione predefinita aggrega pull rispetta un lockfile esistente: una dipendenza già fissata si risolve esattamente nella sua versione fissata (verificata rispetto al suo digest fissato), vengono risolti e aggiunti solo i riferimenti non ancora fissati, e i pin dei riferimenti che la Release non raggiunge più vengono eliminati. Così un nuovo pull di una Release invariata non fa nulla: riproduce lo stesso lockfile byte per byte (compreso generated_at). Aggiungere una nuova dipendenza, o eseguire il pull dopo che una modifica manuale ha rimosso un pin, risolve solo quella lacuna e lascia intatti tutti gli altri pin.

Una dipendenza che un nuovo pull legge dalla cache viene registrata esattamente come l’aveva registrata il pull che l’ha scaricata. La sua riga conserva la versione, il digest del contenuto e il manifest_digest — quest’ultimo preso dal manifest memorizzato accanto al contenuto nella cache — insieme alla signature e alla deprecation che quel pull ha verificato nel registry. Nulla di tutto ciò viene cercato di nuovo finché una build accetterebbe la riga, e --detail riporta tale dipendenza come cache-reuse, quindi un nuovo pull le cui dipendenze sono tutte in cache, su un lockfile che registra ogni firma richiesta dalla configurazione di fiducia e solo firme che una build accetta, scrive lo stesso lockfile che il registry sia raggiungibile o meno.

Un nuovo pull cerca di nuovo una firma esattamente dove una build rifiuterebbe la riga, e le righe di questo tipo sono due.

  • Una firma richiesta che il lockfile non registra. Dove la configurazione di fiducia richiede una firma per una dipendenza servita dalla cache e la riga del lockfile non ne registra alcuna — la riga è stata modificata, il lockfile è stato riscritto da zero su una cache riempita da un pull precedente, oppure il requisito è stato aggiunto dopo il pull che ha scritto la riga — il nuovo pull chiede la firma al registry di quella dipendenza, tramite il digest del manifest memorizzato accanto a essa nella cache, esattamente come fa per una dipendenza che scarica, e registra la firma verificata sulla riga. Quella riga è quella che una build rifiuta (No verified signature is recorded for an artifact that requires one (Nessuna firma verificata è registrata per un artefatto che ne richiede una)), quindi eseguire di nuovo il pull è ciò che elimina quel rifiuto. Un registry che non allega alcuna firma, o una firma che la configurazione di fiducia non accetta, arresta il nuovo pull come arresta un pull che ha scaricato la dipendenza. Le impostazioni che consentono a un pull di ammettere una dipendenza senza firma lasciano tale riga com’è e non chiedono nulla al riguardo: skip_signature_verification al livello superiore, lo stesso interruttore nella voce del registry stesso tranne che per un tipo richiesto dalla politica di firma dell’intero workspace, e un registry contrassegnato advisory.
  • Una firma registrata che una build non accetta. Dove la riga registra una firma il cui bundle di firma in cache è stato rimosso o alterato dopo il pull che l’ha messo in cache — o una signature copiata da un’altra riga, il cui bundle è intatto ma è stato creato per un altro artefatto — una build rifiuta la riga qualunque cosa dica il requisito di firma (A cached signature bundle does not match the digest recorded for it (Un bundle di firma in cache non corrisponde al digest registrato per esso), A recorded signature was made for a different artifact (Una firma registrata è stata creata per un artefatto diverso)). Così il nuovo pull interroga di nuovo il registry di quella dipendenza sulla sua firma, qualunque cosa dica il requisito, tramite la stessa verifica che riceve una dipendenza che scarica: ciò che quella verifica conferma sostituisce la firma della riga, e il bundle che essa indica viene rimesso in cache, riscrivendo una copia in cache che non corrisponde più al suo digest — così la riga e la cache contengono ciò che ha lasciato il pull che ha scaricato la dipendenza. Una firma che la configurazione di fiducia non accetta arresta il nuovo pull come arresta un pull che ha scaricato la dipendenza, e lo stesso fa un registry che non ne allega alcuna dove una firma è richiesta. Dove la verifica non registra alcuna firma — skip_signature_verification dove si applica, che non chiede nulla, un registry che non allega alcuna firma dove nessuna è richiesta, o un registry advisory dove nulla viene verificato — la firma della riga viene cancellata, cosa che una build ammette con le stesse impostazioni.

Una riga la cui firma registrata è accettata da una build non viene interrogata di nuovo, e nemmeno una riga che non ne registra alcuna e per cui nulla richiede una firma.

Una dipendenza indicata senza registry, in un workspace che ora non indica alcun default_registry, non può essere interrogata. La sua riga è stata legata a un registry dal pull che ne ha registrato la firma, e senza un predefinito non c’è alcun registry da interrogare. Dove tale riga registra una firma che una build non accetta, il nuovo pull si arresta con il rifiuto della build stessa, indicando che nessun registry è configurato per interrogare di nuovo la riga, e lascia il lockfile com’era. Configurare come default_registry il registry da cui proviene la dipendenza ed eseguire di nuovo il pull lo ripara.

Ciò che questo rispetto governa è ciò che serve un registry o la cache. Un’entità fornita da una directory di catalogo locale viene risolta da quella directory, nella versione dichiarata dal suo file, e la voce che il lockfile registra per essa non viene consultata lungo il percorso. Il lockfile registra comunque tale entità, quindi la vedrai lì — ma modificare a mano quella voce non mantiene l’entità alla versione che hai scritto, e la riconciliazione successiva riscrive la voce in modo che corrisponda al file. Per cambiare la versione di un’entità fornita localmente che una Release risolve, modifica il file del catalogo anziché il lockfile.

Un pin indica dei byte, non un luogo, quindi una voce di cache che non contiene più il suo pin viene scartata anziché considerata attendibile. Un’entità modificata sul posto — un nuovo corpo sotto la stessa version — lascia nella cache dei contenuti il corpo precedente sotto quel nome e quella versione. Una directory di catalogo viene letta per prima, quindi un’entità che una di esse fornisce ancora viene fissata dal suo file e la voce obsoleta non viene mai letta. Il rendering che il pull esegue per scoprire gli input esterni della Release legge ogni pin come fa una build, dalla directory di catalogo che contiene i byte fissati, e segnala la voce scartata con l’avviso che stampa aggrega build. Dove nessuna directory di catalogo fornisce l’entità e un registry è raggiungibile, il pull scarica di nuovo la versione fissata, riscrive la voce e lo segnala sullo standard error, indicando la voce ed entrambi i digest:

reuse: cache entry for <name>:<version> held <digest the entry held>, not the pinned <pinned digest>; refreshed from the registry (pin unchanged)

I byte scaricati vengono confrontati con il pin come per qualsiasi download sotto un pin, quindi un registry che serve altri byte sotto quella versione arresta il pull, come descritto più avanti. Dove nessuna sorgente contiene i byte fissati — nessuna directory di catalogo fornisce l’entità, la voce di cache contiene altri byte e nessun registry serve la versione fissata oppure l’esecuzione non ne raggiunge nessuno — il pull e aggrega pull --verify si arrestano con E0135 — o E0133 dove il manifest della voce di cache non è quello fissato dal lockfile — indicando ogni sorgente letta e ciò che conteneva; dove l’esecuzione non ha raggiunto alcun registry, l’arresto indica anche il passaggio che scarica di nuovo la versione fissata.

Per aggiornare le versioni fissate, esegui aggrega pull --upgrade --release <release> — scarta i pin esistenti e risolve di nuovo tutte le dipendenze alle versioni più recenti che soddisfano i vincoli. L’aggiornamento è l’atto esplicito; il comportamento predefinito non fa mai fluttuare una dipendenza fissata. Ciò rispecchia la convenzione di npm ci / cargo / go build (il predefinito realizza il lock; l’aggiornamento è su richiesta), ed è ciò che rende sicuro il pull automatico di aggrega build — la build risolve esattamente ciò che il lockfile fissa, senza mai spostare silenziosamente una versione.

Quella forma senza argomenti scarta ogni pin registrato, quindi chiede conferma prima di fare qualsiasi cosa. Rispondi in anticipo con --yes per l’uso non interattivo; se lo standard input non è un terminale e manca --yes, rifiuta anziché attendere una risposta che nessuno può dare. Indicare dei target (aggrega pull --upgrade --release <release> <uri>) mantiene ogni pin non indicato, quindi quella forma non chiede nulla. aggrega build --upgrade esegue la forma senza argomenti ed è soggetto alle stesse condizioni.

Se i byte di una versione fissata nel registry non corrispondono più al digest registrato dal lockfile (una violazione dell’immutabilità a monte), pull si arresta con un errore di integrità anziché adottare silenziosamente i byte modificati — esegui --upgrade per fissare di nuovo deliberatamente.

Verificare un lockfile senza scriverlo

aggrega pull --verify --release <release> risponde a una domanda: eseguire aggrega pull ora cambierebbe il lockfile, o il registro di fiducia dei plugin accanto a esso? Esegue la risoluzione che eseguirebbe un pull, confronta con essa il lockfile e il registro, e si ferma prima che venga scritto qualsiasi cosa un pull consolidi — il lockfile, il registro di fiducia dei plugin e ogni entity.lock restano come sono. Termina con un codice diverso da zero se il lockfile manca e per qualsiasi differenza, indicandole una per una. Gli indicatori di deprecazione non vengono confrontati, come descritto più avanti. Viene rifiutato insieme a --upgrade, a --dry-run e a --pin-sources, qualunque valore abbia quel flag: una verifica non registra un pin mancante in un entity.lock né si arresta per esso, quindi il flag non cambierebbe nulla.

Rispetta i pin registrati esattamente come fa un pull. Una dipendenza fissata dal lockfile si risolve nella sua versione fissata e viene controllata rispetto al suo digest fissato, e un’entità fornita da una directory di catalogo locale viene risolta da quella directory, come descritto in Rispettare o aggiornare. Quindi:

  • Un riferimento il cui registry ha pubblicato una versione più recente dopo il pull non è una deriva. Un pull manterrebbe il suo pin, quindi il lockfile è ancora quello che scriverebbe un pull; aggrega pull --upgrade è il modo in cui si adotta la versione più recente.
  • Un registry che ora serve byte diversi sotto una versione fissata arresta la verifica con l’errore di integrità che arresta un pull, anziché segnalare la modifica come deriva.
  • Una riga del lockfile modificata a mano, una Release modificata e un’entità modificata in una directory di catalogo locale vengono segnalate ciascuna, perché ciascuna è una differenza tra il lockfile e ciò che un pull risolve ora.

Legge e riempie la cache come fa un pull. Una voce che la cache contiene sotto il suo pin — un’entità di catalogo o il .wasm di un plugin — viene letta da lì senza interrogare un registry, ed è questo che permette a una verifica di essere eseguita in modalità offline su un workspace riempito da un pull connesso. Una voce che la cache non contiene viene scaricata, come la scarica un pull, e una che non corrisponde più al suo pin viene trattata esattamente come la tratta un pull. Quindi una verifica può aggiungere elementi alla cache, e non sposta mai un pin.

Confronta le firme registrate, in entrambi i file

La firma che un pull ha verificato per un artefatto fa parte di ciò che scrive: la signature su una voce del lockfile, e su una voce di plugins-trust.yaml per un plugin collegato a un ruolo di verdetto. Una volta che i pin concordano, una verifica confronta ogni firma registrata con quella che un pull registrerebbe ora, e segnala ognuna che un pull registrerebbe dove non ne è registrata alcuna, sostituirebbe o cancellerebbe, sotto A recorded signature is not the one a pull would record (Una firma registrata non è quella che un pull registrerebbe). Ogni voce di questo tipo, in entrambi i file, viene indicata nella stessa esecuzione.

Quali voci del lockfile interroga è una scelta del pull stesso. Un nuovo pull interroga un registry sulla firma di una voce esattamente dove descritto in Rispettare o aggiornare, e una verifica legge quella stessa scelta:

  • Due vengono segnalate senza interrogare un registry, perché un pull le riscrive qualunque cosa risponda il registry: una voce servita dalla cache che non registra alcuna firma dove la configurazione di fiducia ne richiede una — il pull registra la firma dell’artefatto, o si ferma dove non è possibile stabilirne alcuna — e una voce la cui firma registrata è stata creata per un altro artefatto, che il pull sostituisce con quella dell’artefatto stesso.
  • Ogni altra voce che un pull cercherebbe di nuovo viene interrogata, perché solo la risposta del registry dice se il pull la cambierebbe: una voce i cui byte sono stati scaricati da questa verifica, e una voce il cui bundle di firma in cache è stato rimosso, è illeggibile o è stato alterato. La verifica interroga il registry, come farebbe il pull, e segnala la voce dove la risposta registra, sostituisce o cancella la sua firma. Il bundle di firma verificato viene messo in cache come lo mette in cache un pull, quindi una voce il cui bundle in cache è stato rimosso, mentre il suo registry serve ancora la firma registrata, supera il controllo e lascia la cache riparata.

Una voce la cui firma registrata è accettata da una build, e una voce che non ne registra alcuna e per cui nulla richiede una firma, non vengono interrogate, né da un pull né da una verifica.

Il registro di fiducia dei plugin è confrontato con lo stesso pull. Ogni pull verifica nel suo registry la firma di ciascun plugin collegato a un ruolo di verdetto, e lo stesso fa una verifica, che segnala una voce la cui firma quella verifica registrerebbe, sostituirebbe o cancellerebbe. Un plugin per cui il registro non contiene alcuna voce viene segnalato dove una build lo rifiuta perché non registra alcuna firma, perché un pull scrive una voce che porta la sua firma e la build rifiuta il plugin fino ad allora. Qualsiasi altro è un primo avvistamento, che una verifica non segnala, così come non segnala alcuna identità che il registro non contiene ancora. In modalità offline una verifica non interroga alcun registry su questi plugin, e Offline descrive cosa segnala al loro posto.

Gli indicatori di deprecazione non vengono confrontati. Un indicatore allegato a un artefatto dopo il pull è uno stato del registry, e cambia senza che nulla nel workspace cambi; una verifica che fallisse per esso farebbe fallire un controllo su file che non hai toccato. Per lo stesso motivo un indicatore registrato avverte una build anziché fermarla. Quindi un pull può registrare un indicatore su una voce che una verifica ha superato.

Anteprima di ciò che un pull scriverebbe

aggrega pull --dry-run --release <release> risolve le dipendenze esattamente come un pull ordinario e poi, invece di scrivere, stampa ciò che avrebbe scritto: un’intestazione che indica il percorso di ciascun file, seguita dal contenuto che quel file conterrebbe.

aggrega pull --dry-run --release release.yaml

Indica ogni file, non solo il lockfile. Il lockfile, l’entity.lock accanto a ogni Recipe e FeatureRecipe i cui pin registrati si sposterebbero con --pin-sources, e il registro di fiducia dei plugin compaiono tutti nello stesso report, perché un’anteprima che mostrasse solo il lockfile ti insegnerebbe che il lockfile è l’unica cosa che cambia. Un pull che si arresterebbe su un’entità non fissata si arresta anche con --dry-run, per lo stesso motivo: ciò che mostra un’anteprima è ciò che farebbe il pull. I file che un pull lascerebbe identici byte per byte non compaiono affatto — un nome nel report significa che quel file sta per cambiare. L’ultima riga li conta, e un workspace che un pull non cambierebbe riporta un conteggio pari a zero.

Nulla su disco si sposta. Nessun lockfile viene scritto o creato, nessun lock di entità viene scritto o rimosso, e nessun registro di fiducia viene creato o modificato. Dove una capacità è servita da più di un plugin di provider e nulla ha scelto tra di essi, l’esecuzione si arresta indicando cosa fornire anziché offrirsi di scrivere la scelta nella tua configurazione — un’anteprima non modifica un file di configurazione strada facendo.

La risoluzione stessa viene comunque eseguita, quindi la cache si riempie comunque. Quali input esterni consuma una Release è un prodotto del suo rendering, e un’esecuzione che rinunciasse a risolvere non avrebbe nulla da riportare, quindi --dry-run scarica e memorizza esattamente come fa un pull. Il contenuto sotto .aggrega/cache viene letto solo tramite i pin registrati da un lockfile, quindi riempirlo non cambia nulla di ciò che una build risolve; ciò che mostra un dry run è ciò che un pull scriverebbe.

Un --upgrade senza argomenti non chiede nulla con questo flag. La conferma esiste perché un aggiornamento completo scarta ogni pin registrato, e un’anteprima non ne scarta nessuno — quindi aggrega pull --dry-run --upgrade --release <release> è la forma da usare quando ciò che vuoi sapere è quanto ti costerebbe un aggiornamento, e viene eseguita senza una risposta.

Non è accettato insieme a --verify, che già non scrive nessuno di quei file. La coppia lascerebbe il flag senza alcun effetto pur sembrando che abbia fatto qualcosa, quindi viene rifiutata anziché ignorata.

Una cosa che un’anteprima con pinning non sempre può mostrare per intero, e lo dice quando accade. Un pull a cui si chiede di fissare riscrive l’entity.lock accanto a ogni Recipe e FeatureRecipe e poi esegue il rendering della Release per scoprirne gli input esterni; un’anteprima lascia intatti quei lock, quindi dove un pin registrato lì è diventato obsoleto — per esempio, hai modificato un file importato dopo che è stato fissato — quel rendering viene confrontato con il digest obsoleto che il lock non scritto registra ancora, e si ferma. Tutto il resto del report è esattamente ciò che un pull scriverebbe; mancano solo i pin degli input esterni del lockfile riportato. L’esecuzione lo dice sia nel suo output sia nella sua diagnostica, anziché consegnarti un lockfile che sembra completo. Una prima risoluzione di un workspace non è interessata, perché non esiste ancora alcun digest registrato rispetto a cui qualcosa possa essere obsoleto.

La composizione descritta da questi pin

Un lockfile fissa ciò che una build di questa Release consumerà, quindi la risoluzione traccia la composizione che traccia quella build: risolve i documenti, applica le trasformazioni dichiarate dai collegamenti del workspace e sottopone il risultato ai controlli che una build esegue su un grafo completo. Ne derivano due cose, ed entrambe emergono nel passaggio che scrive il lockfile anziché alla prima build che lo legge.

Una composizione rifiutata da quei controlli arresta il pull. Un arco uses: il cui target non soddisfa il selector: del suo socket, una Feature collegata a un componente che il suo appliesTo: non ammette, e ogni altra violazione segnalata da quei controlli fermano questo comando, con la diagnostica che stampa una build degli stessi documenti — e l’arresto indica ogni rilievo in un’unica esecuzione anziché solo il primo, quindi un solo passaggio ti consegna l’intero elenco da correggere. Avviene prima della scrittura, quindi <release-stem>.lock e plugins-trust.yaml restano esattamente com’erano e una Release che non si compila non viene mai registrata come una che si è risolta correttamente. Ciò che non è coperto sono i collegamenti che restituiscono un verdetto: qui non viene eseguito alcun collegamento ir-verdict o render-verdict, quindi un verdetto di rifiuto ferma la build, il lint con ambito di release o la validazione con ambito di release che lo invoca, anziché questo comando.

Un collegamento in un ruolo che modella il grafo viene eseguito durante quel passaggio, quindi un plugin che non si risolve arresta il pull. Un collegamento label-transform decide le etichette dei nodi prima che qualsiasi cosa venga confrontata con esse, e un collegamento annotation-transform inietta annotazioni che si espandono in collegamenti di Feature — entrambi cambiano ciò che il grafo contiene, quindi tracciare il grafo significa invocarli, e invocarli significa disporre dei byte di ciascun plugin. Un plugin i cui byte questo passaggio non riesce a ottenere arresta l’esecuzione, indicando il plugin e ciò che non è stato trovato per esso — lo stesso rifiuto che fa una build dello stesso workspace quando non riesce a ottenerli. Ciò che invoca è l’elenco dei collegamenti che questo passaggio ha appena risolto, con le impostazioni e i file di definizione che il lockfile registra perché una build successiva li ricostruisca, così entrambi i passaggi eseguono lo stesso collegamento sullo stesso input.

Anche un Plugin indicato da un passo di pipeline che nessuno contiene arresta il pull. Ogni Plugin indicato dalla pipeline di una Recipe o di una FeatureRecipe viene risolto con le altre dipendenze della Release — da una directory di catalogo, dalla copia interna al binario del compilatore, dalla cache dei contenuti o dal registry — e uno che nessuno di essi contiene è uno che nemmeno una build potrebbe caricare. Quindi il pull si ferma prima di scrivere qualsiasi cosa, indicando il Plugin e la Recipe o FeatureRecipe la cui pipeline lo indica, con la condizione che una build solleva quando raggiunge quel passo (A plugin reference is not a Plugin entity (Un riferimento a un plugin non è un’entità Plugin)). Ciò vale per ogni Recipe e FeatureRecipe che il Manifest vincola, compresa una che nulla in questa Release collega, perché ciascuna viene risolta e fissata che venga renderizzata o no. Pubblica il Plugin, o collocalo in una directory di catalogo con il suo .wasm compilato accanto, ed esegui di nuovo il pull.

Quell’arresto e un’esecuzione degradata sono esiti diversi, deliberatamente. Un rendering che non riesce a finire — quello descritto sia in Come la risoluzione trova gli input esterni sia in Offline — lascia corretto ogni pin delle dipendenze, quindi i pin vengono scritti e la mancanza viene segnalata. Una composizione rifiutata dai controlli non è una mancanza in ciò che è stato risolto: è una Release che non si compila, quindi nulla viene fissato per essa e l’esecuzione si ferma.

La cache

Il contenuto scaricato viene memorizzato sotto .aggrega/cache, suddiviso in un sottoalbero entities/ per le entità di catalogo, un sottoalbero source-artifacts/ per gli artefatti sorgente e un sottoalbero inputs/ per gli input esterni consumati da un rendering. Lo slot di un’entità di catalogo prende il nome dal suo tipo, dalla sua coordinata e dalla sua versione — quindi un Component e una Recipe che condividono una coordinata e una versione mantengono due slot — quello di un artefatto sorgente da dove è stato scaricato, dalla sua versione e da un prefisso del digest del suo contenuto, e quello di un input esterno dal digest del suo contenuto; ciò che una build legge da ciascuno di essi viene confrontato con ciò che il lockfile registra. Pin di versione identici condividono quindi un solo slot tra più Releases. Ogni slot di artefatto sorgente contiene l’archivio autorevole, un’estrazione rigenerata e un piccolo file di metadati; l’estrazione viene rigenerata a ogni lettura, quindi l’output della build dipende dall’archivio e dal lockfile, non dallo stato dei file estratti.

Ogni nome che la cache deriva da un valore è accettato da Windows, Linux e macOS. Una coordinata, una versione, un host di registry o un digest contiene caratteri che un nome di file non può contenere: il / tra le parti di una coordinata, il : prima di una versione, dentro sha256: e prima della porta di un registry. Così ogni valore — un tipo, una coordinata, una versione, un host di registry o un digest — viene trascritto prima di diventare un nome di directory o di file — una lettera minuscola, una cifra, ., _ e - vengono scritti così come sono, e ogni altro carattere viene scritto come un escape che inizia con +. Il Component core/devtool/adminer:1.0.0 alla versione 1.0.0 è lo slot entities/+zx000043omponent/core+zsdevtool+zsadminer+zx00003a1.0.0/1.0.0/, e uno slot che prende il nome da un digest del contenuto è sha256+zx00003a<hex>. Anche una lettera maiuscola viene sottoposta a escape, quindi due coordinate che differiscono solo per maiuscole e minuscole mantengono due slot su un file system che non distingue le maiuscole; un nome che Windows riserva a un dispositivo, come con, ha la prima lettera sottoposta a escape; e nessun nome termina con un punto. Due valori diversi non condividono mai un nome, e un valore ha lo stesso nome su ogni macchina. aggrega cache status elenca ogni voce in base ai valori da cui sono stati trascritti i suoi nomi — un’entità di catalogo in base alla sua coordinata, alla sua versione e al suo tipo — anziché in base ai nomi trascritti.

Una voce di un archivio mantiene il nome che le ha dato il suo editore, quindi su Windows una voce che Windows non può contenere viene rifiutata. I file contenuti nell’archivio di un artefatto sorgente o di un’entità di catalogo vengono disposti con i nomi che l’archivio dà loro, non trascritti dalla cache. Dove l’estrazione viene eseguita su Windows, una voce che contiene una parte che Windows non può contenere così come è scritta — un nome che riserva a un dispositivo, come NUL o aux, con qualsiasi combinazione di maiuscole e minuscole e con o senza estensione, oppure una parte che termina con un punto o uno spazio — viene rifiutata con E0340, indicando la voce, e nulla di quell’archivio viene disposto. Su Linux e macOS tale voce viene disposta con il nome che ha. Una voce che risale fuori dalla directory dell’estrazione viene rifiutata su ogni macchina.

Lo slot di un’entità di catalogo è una voce solo con il suo manifest. Lo slot contiene il contenuto servito da un registry e, accanto, il manifest che descrive quel contenuto. Uno slot che contiene solo il contenuto — un download interrotto tra le due scritture, o un file collocato lì a mano — non è una voce: un pull, e un pull di verifica, lo richiedono al registry dell’entità dove è raggiungibile, mentre una build, che non scarica mai, tratta l’entità come mancante, come fa un pull quando nessun registry è raggiungibile.

Ciò che arriva nella cache è vincolato a due cose: la forma descritta dallo schema dell’entità stessa e il luogo che la cache indica per essa. Un corpo scaricato da un registry viene sottoposto allo schema del suo tipo — lo stesso controllo che lo rilegge — prima di essere messo in cache, quindi un’entità o una libreria pubblicata servita dal registry che il suo stesso schema rifiuta arresta il pull, indicando ciò che è stato scaricato, anziché essere messa in cache e incontrata più tardi come un guasto. E un valore da cui viene costruita una posizione di cache che collocherebbe un file in cache in un luogo diverso da quello indicato dal valore — una versione che è un percorso anziché una versione, un percorso url di una sorgente o un module_subdir che risale sopra il suo posto — viene rifiutato dove la posizione viene costruita, indicando il valore incriminato. Un valore scritto in una Recipe o in una FeatureRecipe di cui sei autore è vincolato allo stesso modo nel momento in cui da esso viene costruita la posizione di cache — e il module_subdir di una sorgente git prima ancora, prima che il repository venga scaricato, come descritto più avanti.

Un repository git viene archiviato dal proprio checkout. Per una sorgente git-repository il pull esegue il checkout del repository al commit che fissa e archivia la directory indicata da module_subdir, o l’intero repository. Un module_subdir che risale sopra il repository così come è scritto — ../shared o ..\shared — viene rifiutato prima che il repository venga scaricato, con E0307 che riporta il valore, quindi non viene letto nulla accanto al checkout. Un link simbolico di cui il repository ha fatto il commit viene archiviato come il file o la directory a cui punta, dove questo si trova all’interno del repository — module_subdir stesso può essere un link di questo tipo. Uno che porta fuori dal repository arresta il pull con E0321, indicando il link e dove porta, e nulla viene messo in cache, quindi un repository da cui esegui il pull non può far copiare al pull un file della tua macchina nell’artefatto. Il checkout viene rimosso una volta che il pull si ferma, quindi il messaggio indica il link in base alla sua posizione nel repository, e il repository e la revisione indicati dalla sorgente, anziché una directory che non esiste più. Spetta al repository cambiare il link. Il confine del workspace enuncia la regola che qui si applica.

La cache è ancorata al workspace anziché alla directory da cui hai eseguito il comando, quindi un workspace ha una sola cache e un pull eseguito da una sottodirectory riempie lo stesso archivio che legge una build eseguita dalla radice.

Un pull in cui non è stato trovato alcun workspace e nessuno è stato indicato viene rifiutato prima di scaricare qualsiasi cosa. Quando nulla indica una radice e il rilevamento non àncora nulla — dalla cartella in cui lo esegui o, per una Release indicata da un percorso assoluto, dalla cartella della Release stessa — quella cartella sarebbe la radice, e una cache scritta al suo interno la renderebbe un workspace. Così il pull si ferma, non scrive alcun lockfile né alcuna cache, e indica la cartella e i due modi per uscirne: indica il tuo workspace con --workspace-root o AGGREGA_WORKSPACE_ROOT, oppure dai a quella cartella un .aggrega-config.yaml con un blocco workspace:. Lo strumento di pull di aggrega mcp, chiamato senza workspace_root su un server avviato senza radice, viene rifiutato allo stesso modo; Configurazione elenca gli altri comandi per cui ciò vale.

Eseguire la build dove la rete non è raggiungibile

Poiché questo comando è l’unico passaggio che accede all’esterno, una sola esecuzione connessa basta a rendere locale ogni build successiva. Quell’esecuzione scrive il lockfile e riempie la cache del workspace con i byte indicati da quei pin, e una build non ha poi bisogno di nient’altro.

Tre cose vengono portate sulla macchina disconnessa:

  • La Release e il suo lockfile. Esegui il commit di <release-stem>.lock accanto alla Release; è ciò che dice alla build a quale versione e a quale digest si è risolta ogni dipendenza.
  • plugins-trust.yaml, dove il workspace collega un plugin che restituisce un verdetto. Una build confronta i collegamenti di verdetto indicati dalla sua configurazione con quel registro prima che uno qualsiasi di essi venga eseguito, quindi portare con sé il registro è ciò che vincola la build disconnessa alle identità che sono state revisionate e alle firme che il pull ha verificato per esse. Eseguine il commit accanto al lockfile, come descritto in Il registro di fiducia dei plugin.
  • La directory della cache. Le entità, gli artefatti sorgente e gli input fissati si trovano tutti al suo interno, e tutto ciò che una directory catalog_dirs locale non fornisce viene letto da lì.

Esegui la build sulla macchina disconnessa come di consueto. Impostare lì la modalità offline vale la pena anche se una build su un lockfile completo legge la sua chiusura dalla cache: trasforma un potenziale accesso alla rete in un rifiuto immediato che indica la modalità, anziché in un tentativo di connessione che deve prima andare in timeout. Tutto ciò che la cache non contiene, e ogni input esterno che il lockfile non fissa, arresta la build indicando ciò che manca e la risoluzione che lo fisserebbe — nulla viene scaricato silenziosamente per colmare la lacuna.

Una macchina air-gapped e un workspace offline sono affermazioni diverse, e vale la pena mantenere la differenza. Una macchina dietro un air gap può contenere una copia locale di un registry, o un catalogo catalog_dirs con tutto ciò di cui ha bisogno, nel qual caso un pull ordinario su quella macchina può essere soddisfatto senza accedere affatto all’esterno. La modalità offline descrive ciò a cui un comando può accedere, non ciò che la macchina contiene; Offline espone cosa rifiuta e cosa lascia stare.

Offline

In modalità offline — la chiave di primo livello offline in un file di configurazione, AGGREGA_OFFLINE nell’ambiente, o --offline sulla riga di comando — aggrega pull rifiuta l’accesso alla rete. Il rifiuto avviene prima che venga tentata qualsiasi connessione, anziché come un timeout a metà di un download, quindi un pull offline non raggiunge alcun registry né alcuna sorgente remota. Dove un file sottoposto a commit o una variabile esportata ha impostato la modalità e vuoi superarla per un solo comando, --offline=false consente la rete solo per quell’esecuzione.

--upgrade viene rifiutato del tutto in questa modalità, ed è l’unica opzione qui a esserlo. Un aggiornamento completo fa fluttuare ogni dipendenza alla versione più alta che un registry offre al momento, quindi deve chiedere a un registry cosa serve al momento. Un pull ordinario no: rispetta i pin che già registra, risolve solo ciò che non ne ha, ed è quindi soddisfacibile con ciò che la macchina contiene. Il rifiuto dice quale dei tre luoghi ha impostato la modalità e come consentire la rete per una sola esecuzione.

La risoluzione attinge quindi solo a ciò che la macchina contiene già: lo stack di ricerca catalog_dirs e la cache sotto .aggrega/cache. Con un catalogo e una cache che soddisfano ogni riferimento, un pull offline si completa normalmente e scrive un lockfile ordinario. Il lockfile registra l’URI, la versione risolta e il digest di ogni dipendenza, e mai quale di quei luoghi ha servito i byte — quindi un pull offline e un pull online che risolvono le stesse versioni scrivono lo stesso lockfile.

Una dipendenza che un pull offline non può soddisfare localmente lo arresta. La voce non viene mai saltata:

  • Un’entità di catalogo che non si risolve da nessuna parte arresta il pull, indicando il riferimento e da dove è stato referenziato, così vengono indicati sia la dipendenza mancante sia ciò che l’ha richiesta.
  • Una source: remota arresta il pull, indicando la sorgente e dicendoti di consentire l’accesso alla rete oppure di popolare la cache da un ambiente connesso.
  • Una dipendenza contenuta nella cache la cui firma richiesta non è registrata dal lockfile, o la cui firma registrata non è accettata da una build, arresta il pull con il rifiuto offline, indicando la dipendenza: registrare la firma significa interrogare il suo registry, come descritto in Rispettare o aggiornare. Consentire la rete per quella sola esecuzione la registra. Una firma registrata accettata da una build non viene cercata di nuovo, quindi non ferma un pull offline.

Un input esterno è l’unico che non arresta, e invece lo dice. Il rendering che li trova non può scaricare ciò che non è già memorizzato, quindi un pull offline su una Release con un input esterno non fissato si completa, scrive ogni pin di dipendenza che ha risolto e segnala tre cose: che il rendering non è terminato, cosa ha fissato, e che una build di questa Release si arresterà indicando l’URL. I pin delle dipendenze che ha scritto sono corretti — nulla in essi dipendeva dal rendering — quindi vengono mantenuti anziché scartati perché un lettore li riproduca.

Ciò è deliberato e non una lacuna, e non esiste alcun interruttore per cambiarlo. Un pull che scartasse lavoro corretto ti costerebbe la parte riuscita; un pull che restasse in silenzio ti consegnerebbe un lockfile che sembra completo e non lo è. Dirlo è l’unico esito che ti lascia in grado di agire: esegui di nuovo il pull da un ambiente connesso, o da uno la cui cache contiene già il contenuto, e lo stesso comando lo fissa.

Quindi un pull offline è un rifiuto di toccare la rete anziché un risultato ridotto per tutto ciò che un documento indica, e per gli input esterni è una risoluzione completata che ti dice cosa non ha potuto raggiungere. Un lockfile che esiste è uno la cui risoluzione delle dipendenze si è completata; se i suoi input esterni siano completi è ciò che ti dice l’output del pull stesso, e ciò a cui una build poi lo vincola.

--verify in modalità offline copre meno, e lo segnala. Chiedere dove punta oggi un ref di sorgente registrato significa raggiungere il suo remote, cosa che la modalità offline rifiuta. Quindi un --verify offline controlla le dipendenze fissate e salta quell’asse, e stampa una riga che lo dice anziché riportare una corrispondenza che non ha mai stabilito. Una firma registrata che solo il suo registry può confermare — su una voce del lockfile il cui bundle di firma in cache è stato rimosso o alterato — viene saltata allo stesso modo, su una riga che indica ciascuna di tali voci:

verify: offline, so the signature the lockfile records for "<reference>" was not checked at its registry, which alone can say whether a pull would record it again; this verify does not cover it

Una firma registrata che un pull riscriverebbe qualunque cosa rispondesse il registry viene comunque segnalata offline, perché non serve alcuna risposta per saperlo, come descritto in Confronta le firme registrate, in entrambi i file.

Un plugin collegato a un ruolo di verdetto servito da un registry è il punto in cui una verifica offline e un pull offline si separano. Un plugin di questo tipo non viene mai fissato nel lockfile, quindi ogni pull risolve il suo .wasm dal suo registry, e un pull offline su un workspace che ne collega uno si ferma lì, indicando il plugin come uno di cui non ha potuto risolvere il .wasm — anche dove la cache dei contenuti lo contiene, e indipendentemente dal fatto che quel registry sia contrassegnato advisory o salti la verifica delle firme. Una verifica offline invece non chiede nulla al registry sul plugin: legge il plugin dalla cache dei contenuti, come lo legge una build, e si ferma dove la cache non contiene il suo .wasm o ne contiene uno che non corrisponde più al digest indicato dal suo manifest pubblicato. Confronta comunque l’identità del plugin con il registro di fiducia dei plugin e ricontrolla le sue funzioni host rispetto a quel .wasm, e si arresta dove uno dei due non concorda, esattamente come fa una verifica connessa. Segnala il plugin dove un pull riscrive la sua voce qualunque cosa risponda il registry, ovvero dove una build rifiuta il plugin per la sua voce: perché non registra alcuna firma, dato che la sua voce non ne registra alcuna o il registro non contiene alcuna voce per esso, oppure perché la firma registrata dalla sua voce è stata creata per un altro artefatto, che il pull sostituisce con quella del plugin stesso. Ogni altra voce — una la cui firma è accettata da una build, e una il cui bundle di firma in cache è stato rimosso o alterato — la indica su una riga che dice che la sua firma non è stata controllata, e non segnala nulla su quella firma:

verify: offline, so the signature of "<plugin>" was not checked at its registry, which alone can say whether a pull would record the same signature on its entry in the plugin trust record; this verify does not cover it

Quindi una verifica offline passa oltre una voce la cui firma un pull connesso sostituirebbe o cancellerebbe — una il cui firmatario è stato modificato a mano, per esempio, o una che il suo registry non allega più — con quella riga come unica cosa a segnalarlo. Una verifica air-gapped resta disponibile; ciò che non ti dice è se un ref si è spostato nel frattempo, o se una firma saltata verrebbe registrata di nuovo. Un controllo che legge solo il codice di uscita copre questi casi solo quando la verifica viene eseguita connessa.

Integrazione con aggrega build

  • Verifica. aggrega build verifica ogni dipendenza risolta rispetto al lockfile e si arresta in caso di drift: un’entità, una libreria o un plugin il cui contenuto non corrisponde più al proprio pin, un riferimento che la Release ora raggiunge e che il lockfile non fissa oppure uno che fissa e che la Release non raggiunge più, e un file di Release modificato dopo il pull. Per risolverlo esegui aggrega pull --release <release>, il comando che l’arresto stampa: il pull risolve la Release così com’è ora, riscrive i pin che si sono spostati e mantiene tutti gli altri, così nulla fluttua se non l’hai cambiato tu. Dove ciò che si è spostato è un file sotto la sorgente locale di una Recipe, il pull indica prima aggrega pin per quell’entità, come descrive Il lock dell’entità. Un lockfile appena scritto da questo comando supera quel controllo, perché il comando esegue lo stesso controllo prima di scriverlo; una build che si arresta per drift subito dopo un pull ha ricevuto input diversi da quelli del pull — una directory --catalog passata a uno e non all’altro, oppure una configurazione del workspace modificata tra i due — quindi esegui entrambi sugli stessi input. aggrega validate --release e ogni selezione di aggrega inspect che risolve una Release sottopongono il lockfile allo stesso controllo e rifiutano con lo stesso arresto, così nessuno dei due lascia passare un lockfile che una build rifiuta.
  • Pull automatico. Se il lockfile manca e auto_pull è true, aggrega build esegue prima automaticamente il pull. Se auto_pull è false, che è il suo valore predefinito, la build si arresta e ti chiede di eseguire il pull. Il pull eseguito da una build segue pin_sources_at_pull, quindi su un’entità senza pin si arresta esattamente come un pull. Il passaggio di pull eseguito da una build è lo stesso descritto in questa pagina, quindi una build che completa un lockfile esistente si arresta su un ref di sorgente spostato esattamente come fa aggrega pull — vedi Determinismo e integrità.
  • Offline. In modalità offline, aggrega build usa solo ciò che la macchina contiene già e rifiuta l’accesso alla rete prima di tentare qualsiasi connessione. Un riferimento il cui contenuto non è nella cache arresta la build invece di farla fallire a metà di un fetch, e una build senza lockfile a cui non viene chiesto di completarne uno si arresta indicando il pull che lo completerebbe, esattamente come online. --auto-pull non viene rifiutato: il completamento che richiede è il pull descritto in questa pagina, quindi sulle entità di catalogo già in cache o presenti in un catalogo locale scrive il lockfile senza contattare un registry — una Recipe il cui chart viene recuperato da una sorgente remota viene risolta di nuovo, quindi offline si arresta anche dove la cache contiene quel chart — e un riferimento che nessuno dei due contiene — o uno in cache la cui firma richiesta non è registrata nel lockfile, o la cui firma registrata non è accettata da una build — lo arresta con il rifiuto proprio del pull, che indica quel riferimento. --upgrade viene rifiutato, per il motivo indicato in Offline.
  • Ricerca nel catalogo. Il pull rispetta catalog_dirs da .aggrega-config.yaml anche quando non viene fornito alcun --catalog — e le directory proprie di una Release, dove la configurazione gliene assegna sotto workspace.releases — e risolve lo stesso stack di ricerca in cui vince la prima corrispondenza usato da aggrega build, così le dipendenze che fissa corrispondono a ciò in cui cerca la build. Una directory elencata che non è una directory — perché lì non esiste nulla, ad esempio — viene rifiutata da entrambi i comandi prima che venga risolto o scritto qualcosa, nominando la voce e il file di configurazione e la riga che la elencano, come mostra Da dove vengono lette le entità locali.

Come la risoluzione trova gli input esterni

Nulla in questa sezione cambia la regola precedente — c’è ancora un solo momento in cui qualcosa viene fissato, ed è questo comando. Ciò che descrive è come il comando raggiunge il terzo dei tre tipi, il che conta quando integri la risoluzione in una pipeline, leggi un’esecuzione degradata o ragioni sul perché questo comando esegua un rendering.

Un’entità di catalogo e un artefatto sorgente sono nominati ciascuno in un documento; un input esterno no. Risolvere i primi due significa leggere ciò che hai scritto. Un input esterno è nominato da un provider, a metà di un rendering, e quali URL nomina dipende dai valori sottoposti a rendering — una voce dei valori assente lascia non compilato un intero sottoalbero dello schema di un chart e non richiesto ogni riferimento remoto in quel sottoalbero. Nessuna lettura della Release può enumerare l’insieme.

Quindi il comando fa due cose in un solo passaggio: risolve e fissa la chiusura nominata dai documenti, poi esegue il rendering di quella chiusura per vedere quali documenti remoti richiedono i provider. Gli artefatti prodotti dal rendering vengono scartati e i pin vengono mantenuti. Entrambe le cose sono interne all’unico comando, e nessuna è un secondo momento in cui qualcosa potrebbe essere fissato — c’è una sola scrittura del lockfile, e contiene ogni pin.

Due conseguenze vanno conosciute prima di integrare la risoluzione in una pipeline automatizzata come passaggio economico. Costa più di una risoluzione che legge solo documenti, perché esegue un rendering. E può fallire per un motivo per cui una risoluzione basata solo sui documenti non potrebbe: un provider che non riesce a eseguire il rendering di questa Release. Quando ciò accade i pin delle dipendenze vengono comunque scritti, perché nulla di essi dipendeva dal rendering, e la diagnostica indica la fase che si è fermata, ciò che è stato fissato e che una build si arresterà indicando l’URL senza pin. L’esecuzione non va persa, e Offline mostra lo stesso esito raggiunto per un’altra via.

Il rendering sottopone inoltre il lockfile al confronto che applica una build, prima che venga scritto qualcosa. Esegue la sequenza propria della build, quindi confronta il lockfile che questo comando sta per scrivere con ciò a cui si risolve una build della stessa Release, esattamente come una build confronta un lockfile che trova su disco. Un lockfile rifiutato da quel confronto non viene scritto — né qualsiasi altra cosa il comando avrebbe scritto dopo — e il comando si arresta dicendo che la risoluzione e la build non concordano su ciò da cui dipende la Release, seguito da ogni voce indicata dal confronto. Nulla nei tuoi file può causarlo, e risolvere di nuovo porterebbe allo stesso disaccordo, quindi segnalalo insieme alla Release invece di riprovare. È l’unico errore di rendering che blocca la scrittura, ed è il motivo per cui una build della stessa Release, sugli stessi input, non segnala drift su un lockfile scritto da questo comando.

Non esiste un’opzione per saltare il rendering. Un’opzione del genere conserverebbe, come scelta, proprio la sorpresa che un unico momento elimina: una Release che si risolve senza errori mentre un input di cui il suo rendering ha bisogno resta senza pin, scoperto solo al momento della build.

--auto-pull integra questa stessa risoluzione in una build, e la build esegue un solo rendering. Il rendering del completamento è quello che trova e fissa gli input esterni, e la build presenta quel rendering invece di eseguirne un secondo, quindi una build con un solo comando costa lo stesso rendering di una build ordinaria su un lockfile già completo. aggrega build spiega quali flag di rendering di una build lo raggiungono.

L’insieme dipende dai parametri della Release, ed è così che si comportano già i pin dei component. Modificare i parametri di una Release tra la risoluzione e la build è una modifica alla Release, quindi la build si arresta al confronto del drift indicando il file, prima che un rendering possa richiedere un URL senza pin; il rimedio è questo comando. I parametri importati da un file separato non sono registrati per contenuto, quindi modificare invece quel file raggiunge il rendering, che si arresta indicando l’URL senza pin — con un rimedio che indica anch’esso questo comando.

Determinismo e integrità

Il source: di una Recipe può definire tramite template la propria versione in base ai values e all’infra risolti della Release (e sui locals definiti sugli stessi); questi si risolvono al momento del pull e il risultato viene fissato. Il pull valuta solo le voci locals: lette dai campi source:, e le voci che queste a loro volta leggono, con i soli helper di template di Aggrega: una voce letta dalla sorgente che chiama una funzione Sprig arresta il pull indicando la voce, il campo e la funzione, mentre una voce che nessun campo source: legge viene lasciata alla build, che la valuta e la controlla quando esegue il rendering della Recipe — vedi Resolving a source: coordinate registers a narrower function set (La risoluzione di una coordinata source: registra un insieme di funzioni più ristretto). Un tag o un branch Git mutabile viene fissato al commit concreto a cui punta, e il ref che hai scritto viene registrato accanto. Al momento della build il digest dell’archivio in cache viene verificato di nuovo rispetto al lockfile, quindi una cache manomessa viene rilevata.

Un ref registrato è vincolato al commit che ha fissato. Il ref viene registrato perché le esecuzioni successive lo interrogano di nuovo, non per leggibilità — una build chiede quale artefatto nomina, e un pull chiede se punta ancora dove puntava. Un pull che non è un upgrade chiede di nuovo a ciascun ref registrato dove punta, e un ref che si è spostato nel suo remote arresta l’esecuzione — indicando l’artefatto, il ref, il commit fissato nel lockfile e il commit a cui si risolve ora — invece di adottare lo spostamento. Esegui aggrega pull --upgrade --release <release> per adottarlo. Un upgrade mirato, che nomina URI di entità, non lo fa: un riferimento a una sorgente non è un’entità che si possa nominare, quindi un’esecuzione mirata lo mantiene esattamente come fa un semplice pull.

Quel controllo è l’unica cosa che la nuova verifica del digest al momento della build non può fare per te. Un pull che adottasse un ref spostato riscriverebbe i byte recuperati e il digest registrato nello stesso atto, quindi i due valori confrontati da una build si sarebbero spostati insieme e concorderebbero — e staresti eseguendo la build di un contenuto sorgente diverso da quello su cui è stato revisionato il lockfile, senza che nulla lo segnali.

Solo un ref registrato nel lockfile viene vincolato in questo modo, e un ref viene registrato ogni volta che ne scrivi uno. Una Recipe che nomina la propria sorgente solo con version: non ha ref, quindi non c’è nulla che un’esecuzione successiva debba chiedere di nuovo — ed è la risposta giusta, perché una versione che hai scritto tu non può spostarsi a tua insaputa. Il riferimento del lockfile indica cosa viene registrato.

Scrivi il ref, non il commit. Una build trova un artefatto con sorgente git tramite il ref che hai scritto, confrontato con il ref registrato nel lockfile, quindi ref: v1.2.3 esegue la build sul commit a cui quel tag è stato fissato e il commit non deve mai comparire nella tua Recipe. Indicare invece un tag mutabile in version: non funziona e non è previsto che funzioni: version: viene confrontato così come è scritto, e per una sorgente git il lockfile fissa un commit.

Il lockfile fissa il contenuto recuperato dai registry e dalle sorgenti remote, e registra il digest di ogni entità che risolve dalle tue directory di catalogo — sul file dell’entità e su ogni file che nomina accanto a esso, come descrive Il lockfile — e di ogni file di Release letto dalla risoluzione. Anche i file di una sorgente che inizia con ./ o ../, e un file di artefatto importato da un’entità, vengono fissati uno per uno nel lock accanto a quell’entità, come descrive Il lock dell’entità, ed è questo che indica quello che si è spostato; l’integrità del resto del tuo workspace tra una build e l’altra è responsabilità del sistema di controllo del codice sorgente. Vedi output identico byte per byte per l’ambito della garanzia di determinismo.

Autenticazione

Le credenziali dei registry vengono lette solo dalla configurazione delle credenziali di Docker: config.json nella directory indicata da DOCKER_CONFIG, oppure ~/.docker/config.json quando quella variabile non è impostata, insieme a qualsiasi credential helper o portachiavi del sistema operativo a cui il file delega tramite credsStore o credHelpers. aggrega login <registry> vi scrive una credenziale, e così fa docker login <registry>; esegui l’uno o l’altro prima di aggrega pull per un catalogo OCI o un registry di chart privato. I file scritti da podman login e da helm registry login non vengono letti.

Una configurazione delle credenziali che non può essere letta viene segnalata senza il suo contenuto. Quando config.json non è JSON valido, il valore auth di una voce non è un utente e una password uniti da due punti e codificati in base64, o un credential helper indicato dal file non riesce a rispondere, il raggiungimento del registry fallisce con un messaggio che indica il registry e il file delle credenziali, mai il contenuto del file o della voce. aggrega login e aggrega logout segnalano allo stesso modo un config.json che non è JSON valido, e non vi modificano nulla. Correggi il file; una voce che non può essere letta può anche essere sostituita con aggrega login <registry>.

Un repository di chart Helm classico o un archivio di chart (helm-https-chart), un frammento compose (compose-https-fragment) e un repository Git raggiunto tramite HTTP o HTTPS (git-repository) si autenticano con il file netrc, il file di credenziali per utente che leggono anche curl e Git. È l’unico archivio di credenziali che questi tre tipi leggono: ~/.config/helm/repositories.yaml e i credential helper di Git non vengono letti. Un repository Git raggiunto tramite SSH si autentica attraverso l’agente SSH e non legge alcun file netrc.

machine charts.example.com
login deploy-bot
password <token>

Quale file viene letto. Il file indicato dalla variabile d’ambiente NETRC, quando è impostata. Altrimenti .netrc nella tua home directory; su Windows, _netrc in %USERPROFILE% quando quel file esiste, e .netrc nella stessa posizione quando non esiste. Un file mancante non contiene credenziali e non è un errore. Un file che esiste e non può essere letto, o che non segue il formato netrc, arresta il comando con E0360, nominando il file — e, per un errore di formato, la riga — ma mai ciò che il file contiene: The netrc file cannot be read (Il file netrc non può essere letto). Su Linux e macOS, un file netrc leggibile da altri utenti della macchina produce un avviso che lo nomina; rendilo leggibile solo da te (chmod 600).

Quale voce risponde a una richiesta. Ogni richiesta viene cercata in base al suo host — il nome host senza la porta, senza distinzione tra maiuscole e minuscole — e riceve risposta dalla prima voce machine che nomina quell’host, o dalla voce default quando nessuna lo nomina. Il login e la password della voce vengono inviati come credenziali HTTP basic, sia su http sia su https; una voce a cui manca l’uno o l’altra non invia nulla. Un repository il cui indice colloca i propri chart su un altro host riceve risposta richiesta per richiesta: la richiesta dell’indice prende la voce dell’host del repository, e la richiesta del chart quella dell’host del chart. Una richiesta che parte senza credenziale deve essere leggibile in modo anonimo, e un server che risponde 401 o 403 arresta il pull come download non autorizzato, il cui rimedio nomina la voce da aggiungere e il file in cui è stata cercata.

La credenziale non viene scritta da nessuna parte. Viene letta quando viene eseguito un download e inviata con la richiesta: il lockfile, l’entity.lock accanto alla Recipe, la cache delle sorgenti e ogni messaggio riportano l’URL della sorgente così come l’hai scritto.

Un URL di sorgente non contiene credenziali. Una Recipe o FeatureRecipe il cui url di sorgente scrive un utente prima del suo host — https://user:token@charts.example.com/…, oppure un token scritto da solo come https://token@charts.example.com/… — viene rifiutata con E0361 alla lettura del documento, prima che venga scaricato qualsiasi cosa: la convalida della Recipe la rifiuta, e così ogni pull, pin e build che la raggiunge. Il messaggio nomina l’host e mai la credenziale: A source URL carries a credential (Un URL di sorgente contiene una credenziale). Metti invece la credenziale in una voce machine del file netrc. Su SSH, un utente scritto da solo — ssh://git@github.com/… — nomina un account anziché un segreto ed è accettato, mentre una password scritta lì viene anch’essa rifiutata.

Il controllo legge solo la parte dell’URL che precede l’host. Un token contenuto in una query string o in un percorso — …/index.yaml?access_token=… — non viene rilevato, quindi non scriverne uno lì: l’URL viene registrato così come è scritto nel lockfile, nell’entity.lock e nella cache delle sorgenti, compresi i nomi delle directory della cache.

Variabili d’ambiente

Le impostazioni del workspace lette da pull possono essere sovrascritte tramite l’ambiente, sopra la configurazione committata e sotto qualsiasi flag: AGGREGA_OFFLINE (vedi Offline, e --offline per il flag che la sovrasta), AGGREGA_CATALOG_DIRS (separata come una lista di percorsi del sistema operativo; fornisci percorsi assoluti), AGGREGA_ARTIFACT_CACHE_DIR, AGGREGA_DEFAULT_REGISTRY e AGGREGA_SKIP_SIGNATURE_VERIFICATION (rumorosa — ovunque un pull avrebbe controllato una firma, registra un avviso che la verifica è disabilitata globalmente). Vedi environment-variables.md per l’elenco completo e il modello di precedenza.

Vedi anche

  • ./aggrega-build.md — verifica il lockfile ed esegue il pull automatico quando configurato.
  • ./aggrega-serve.md — il daemon offre questa stessa risoluzione in aggrega/resolveDependencies, e all’interno di aggrega/build per una richiesta il cui campo autoPull la chiede, così un editor può eseguirla senza lasciare la sessione; in entrambi i casi viene eseguita solo quando una richiesta la nomina, e scrive lo stesso lockfile di questo comando.
  • ./aggrega-push.md — pubblica entità di catalogo in un registry.
  • ./aggrega-lint.md — il controllo di pubblicazione che precede aggrega push.
  • ../../architecture/13-catalog-and-registry.md — il modello completo di catalogo, lockfile e cache.

Sinossi

aggrega pull [<uri>...] [flags]

Descrizione

Resolve the Release's catalog and source dependencies into the cache and write the per-Release lockfile.
By default, pull reconciles the lockfile against the current dependency resolution while honoring
the pins it already records. That pin discipline governs what a registry or the content cache
serves: such an entity is fetched at its pinned version and verified against its pinned digest,
and if the registry no longer serves the pinned bytes, pull halts rather than silently re-pinning.
An entity a local catalog directory supplies is resolved from that directory instead, at the
version its file declares, and its recorded pin is not consulted — so editing a pin by hand does
not hold a locally-supplied entity at that version, and the reconcile rewrites the entry to match
the file. A reference with no pin — newly added, or removed from the lockfile by hand — is
resolved fresh and added. Entities no longer among the resolved dependencies are pruned.
Re-running pull on an unchanged dependency set is a no-op.
Use --upgrade with no positional arguments to discard the existing lockfile and re-resolve
every entity from current registry state, floating each dependency to the highest available
version. That form drops every recorded pin, so it asks for confirmation first; --yes answers in
advance, and on a non-interactive stdin it refuses rather than waiting for an answer nobody can
give. Pass one or more entity URIs after --upgrade to upgrade only those: each named pin
is dropped and re-resolved fresh while every other pin — and the recorded external inputs —
is held unchanged. A named target may also be a plugin that returns an accept-or-reject verdict;
such a plugin carries no lockfile pin, and its identity is recorded beside the lockfile instead.
Naming one the workspace still attaches adopts the identity it resolves to. Naming one the
workspace no longer attaches drops its recorded identity — the one way to clear an entry that
outlived the attachment it was recorded for. A bare --upgrade does both for every plugin at once.
A URI given without --upgrade is a usage error.
Each Recipe and FeatureRecipe this Release builds from one of your catalog directories carries
the pins for its own inputs in the entity.lock beside it: a remote source: written out in full,
a file an artifacts entry imports, and each file of a local source:. Recording them is the
entity author's step, aggrega pin.
By default pull records none of them, and halts on an entity whose lock is missing any, naming
the entity, each input and its class, and the command that records them. A local source's files
are held to their pins as one set: a file added, changed or removed since the pin halts the pull
the same way.
Pass --pin-sources, or set pin_sources_at_pull in the workspace configuration, to have pull run
that same step instead; --pin-sources=false restores the halt for one run.
Which files of a local source directory belong to its entity was decided when the entity was
pinned, by the ignore rules of the plugin that served its capability for the author, and its
entity.lock records that decision. Where the plugin this workspace binds for that capability
declares different rules, pull prints a warning naming both plugins and the difference, and
carries on: the entity's files are the ones its recorded rules kept.

Flag

FlagPredefinitoDescrizione
--catalog[]Directory del catalogo; ripetibile. Ogni —catalog <dir> viene anteposto allo stack di ricerca del catalogo (vince la prima corrispondenza): le catalog_dirs del workspace oppure, per una Release a cui la configurazione del workspace assegna directory proprie in workspace.releases, quelle di tale Release; lo stack termina con la directory chiamata catalog alla radice del workspace, quando esiste. Un elenco catalog_dirs scritto vuoto non legge alcun catalogo locale.
--detailfalseStampa, per ogni entità risolta, cosa ha fatto questo pull — recuperata da zero da un registry, riutilizzato uno slot della cache, trovata in un catalogo locale, servita dall’interno del binario del compilatore, oppure esterna (l’Aggregate o il Manifest della Release stessa, letto dal file o dalla voce che la Release indica). Solo stdout; non scritto nel lockfile
--dry-runfalseRisolve le dipendenze e stampa ciò che questo pull scriverebbe invece di scriverlo: il percorso di ogni file e il contenuto che conterrebbe vanno su stdout, e il lockfile, l’entity.lock accanto a ogni Recipe e FeatureRecipe i cui pin registrati si sposterebbero con —pin-sources, e il record di fiducia dei plugin restano tutti intatti. Vengono indicati solo i file che cambierebbero davvero. La risoluzione stessa viene eseguita esattamente come altrimenti, quindi la cache dei contenuti si riempie comunque, un pull che si arresterebbe su un’entità senza pin si arresta anche qui, e un —upgrade senza argomenti non chiede nulla perché non elimina alcun pin — ciò che mostra un dry run è ciò che un pull scriverebbe. Non accettato con —verify, che già non ne scrive nessuno
--include-prereleasefalseNon ancora implementato: accettato e ignorato, così uno script che lo passa continua a funzionare quando inizierà ad avere effetto
--pin-sourcesfalseEsegue il passaggio di pin dell’autore dell’entità sulle Recipes e FeatureRecipes che questa Release costruisce, registrando nell’entity.lock accanto a ciascuna il pin di ogni input che legge — un source: remoto scritto per intero, un file importato da una voce artifacts e ogni file di una sorgente locale — invece di arrestarsi su un’entità il cui lock non li registra. È lo stesso passaggio di aggrega pin, che scrive gli stessi byte. Scrive accanto all’entità, quindi viene eseguito solo dove l’entità ha una posizione scrivibile: un documento in una delle tue directory di catalogo. Un’entità risolta dalla cache non ne ha e non viene mai fissata. Sovrascrive pin_sources_at_pull del workspace in entrambe le direzioni: —pin-sources fissa i pin per questa esecuzione e —pin-sources=false arresta per questa esecuzione, qualunque cosa dica l’impostazione
--progressfalseForza l’attivazione dell’indicatore di avanzamento del pull anche quando stderr non è un terminale, stampando una riga semplice per ogni passaggio man mano che si completa, con il relativo tempo. Il valore predefinito è auto: la checklist interattiva delle fasi viene mostrata solo quando stderr è un terminale che interpreta le sequenze di escape, un terminale che non le interpreta riceve le stesse righe semplici, e l’output reindirizzato o in pipe non ne riceve nessuna
--quietfalseSilenzia l’indicatore di avanzamento del pull su stderr. Non influisce su stdout. Ha la precedenza su —progress
--release—Percorso del file YAML della Release (obbligatorio). Un percorso relativo viene risolto rispetto alla directory in cui esegui il comando, non rispetto alla radice del workspace. Dove quella directory non appartiene ad alcun workspace e non viene indicata alcuna radice, un percorso assoluto trova il workspace a partire dalla cartella della Release stessa
--upgradefalseRisolve di nuovo le dipendenze dallo stato attuale dei registry, portando ciascuna alla versione più alta disponibile. Senza argomenti (nessun URI posizionale) scarta il lockfile e risolve di nuovo ogni entità, e chiede prima conferma perché elimina ogni pin registrato; con uno o più URI di entità, risolve di nuovo solo quelle, mantenendo invariati tutti gli altri pin e gli input esterni registrati, e non chiede nulla (mutuamente esclusivo con —verify)
--verifyfalseVerifica il lockfile esistente rispetto alla risoluzione delle dipendenze che un pull eseguirebbe ora, senza scrivere il lockfile, il record di fiducia dei plugin né alcun entity.lock; esce con codice diverso da zero in caso di drift o di lockfile mancante. La risoluzione rispetta i pin registrati nel lockfile esattamente come un pull: un riferimento il cui registry ha pubblicato una versione più recente dopo il pull non è drift, perché un pull ne manterrebbe il pin, e un registry che ora serve byte diversi sotto una versione fissata arresta la verifica come arresta un pull. La cache dei contenuti viene letta e riempita come la legge e la riempie un pull: una voce che la cache contiene sotto il suo pin viene letta da lì senza interrogare un registry, una che non contiene viene recuperata, e una che non corrisponde più al suo pin viene trattata esattamente come la tratta un pull. Vincola inoltre l’entity.lock accanto a ogni Recipe e FeatureRecipe nelle tue directory di catalogo raggiunta dalla Release a ciò con cui lo confronta una build, ed esce con codice diverso da zero su un pin che una build rifiuterebbe: un file importato che non corrisponde più al digest registrato, una sorgente locale i cui file non corrispondono più ai digest registrati, o un pin di sorgente in disaccordo con il lockfile. Confronta inoltre la firma che il lockfile registra per ogni artefatto, e il record di fiducia dei plugin per ogni plugin, con quella che un pull registrerebbe ora, ed esce con codice diverso da zero dove un pull ne registrerebbe, sostituirebbe o cancellerebbe una: una firma richiesta da un requisito che non è registrata, e una fatta per un altro artefatto, vengono segnalate senza interrogare un registry, perché un pull le riscrive qualunque cosa risponda; una firma che un pull cerca di nuovo e potrebbe registrare invariata — l’artefatto è stato recuperato, o il suo bundle di firma in cache è stato rimosso o alterato — viene verificata presso il suo registry, oppure in modalità offline lasciata non controllata con una riga che lo dice; e ogni plugin coperto dal record di fiducia dei plugin viene verificato presso il suo registry, come lo verifica ogni pull, tranne in modalità offline, dove viene letto dalla cache dei contenuti come lo legge una build, la sua identità e le sue funzioni host vengono comunque controllate e la sua firma viene lasciata non controllata con una riga che lo dice, a meno che una build non lo rifiuti perché non ne registra alcuna o ne registra una fatta per un altro artefatto, cosa che viene segnalata. I marcatori di deprecazione non vengono confrontati. Segnala inoltre le versioni del compilatore e dei plugin core registrate nel lockfile — segnalate a fini di audit e mai confrontate con questo binario, quindi una differenza di toolchain non è mai drift. Non accettato con —pin-sources, qualunque valore gli venga dato: una verifica non registra un pin mancante in un entity.lock né si arresta su di esso, quindi il flag non cambierebbe nulla (mutuamente esclusivo con —upgrade)
--yesfalseRisponde in anticipo alla conferma di —upgrade senza argomenti, per l’uso non interattivo. Raggiunge solo quel prompt e nient’altro: ogni altra forma di pull non chiede nulla, quindi passarlo non cambia alcun comportamento in quei casi