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

Arresti fatali

Un arresto fatale è un errore in fase di compilazione che ferma la build prima che venga prodotto qualsiasi output. Ogni arresto nomina il file, l’entità e il campo in errore, spiega cosa il compilatore non è riuscito a risolvere e indica la modifica concreta di authoring che lo corregge. Il compilatore non ripara né riscrive mai silenziosamente il tuo input — se qualcosa non va, la build si ferma e ti dice dove.

Questo catalogo è organizzato in base alla fase della compilazione in cui scatta ciascun arresto.

Ogni voce qui sotto cita il messaggio che una build stampa per la condizione che documenta: la frase fissa che enuncia la condizione, poi ciò che quell’occorrenza ha fornito. In un terminale quel messaggio compare all’interno di un frame — un’intestazione tra parentesi quadre che porta la categoria e il codice breve della condizione, un puntatore al file e alla chiave in errore seguito dall’istanza a cui si riferisce il fallimento come (instance <name>) — oppure quella sola istanza, come instance <name>, dove non si applica alcun file — e il messaggio sulla riga sottostante — quindi una riga intera incollata da una build non corrisponderà a una voce di questa pagina, mentre il messaggio al suo interno sì; error-translation.md descrive il frame per intero.

Se arrivi da una build con un codice breve in mano — la lettera E e quattro cifre, nell’intestazione tra parentesi quadre della diagnostica — parti da Trovare un arresto dal codice breve stampato dalla build in fondo a questa pagina, che elenca ogni condizione catalogata qui accanto al codice breve che una build stampa per essa.

Durante il caricamento dei tuoi file

Il compilatore legge ogni Aggregate, Manifest, Component, Feature, Recipe, FeatureRecipe, Plugin e Release a cui la tua build fa riferimento, convalida ciascuno rispetto al proprio schema e interpola i parametri tipizzati dalla Release nell’Aggregate.

YAML anchor aliased inside its own content (Ancora YAML richiamata tramite alias all’interno del proprio contenuto)

Un documento definisce un’ancora su un nodo con &name e poi la richiama tramite alias con *name in qualche punto all’interno del contenuto che quell’ancora copre. Espandere l’alias riproduce l’ancora, il cui contenuto contiene di nuovo l’alias, quindi il documento descrive una struttura senza fine. Non c’è nulla di finito da leggere, figuriamoci da convalidare, e la build si ferma invece di avviare un attraversamento che non può terminare.

La lettura di YAML in un albero non espande gli alias, quindi un documento con questa forma viene letto senza obiezioni e fallisce solo quando qualcosa lo attraversa. Il rifiuto si colloca quindi tra la lettura e l’attraversamento — e una build legge lo YAML scritto dall’autore in più di un punto, quindi la stessa condizione può presentarsi in più di uno. Quattro punti la segnalano, ciascuno inquadrando la stessa spiegazione con ciò che individua il documento su quella superficie:

  • Un file di entità, mentre viene letto. La build si ferma prima che quell’entità venga verificata rispetto al suo schema, quindi questo arresto nomina un’ancora anziché un campo e non riporta riga e colonna: a quel punto il documento non ha alcuna posizione a cui una diagnostica possa utilmente puntare.
  • Un corpo di schema, mentre viene compilato. Un pilastro spec.schema: viene compilato dalla forma compatta in un documento JSON Schema dopo che il suo file è stato letto, quindi questo arresto scatta durante quella compilazione anziché prima di essa, e riporta una riga. La forma che una lettura precedente non può cogliere è un corpo di escape $jsonschema:: un corpo di escape è uno scalare a blocco — testo semplice, privo di ancore — mentre il file circostante viene letto, e le sue ancore diventano ancore solo quando quel testo viene a sua volta analizzato, un livello più in basso. Quando il ciclo si trovava all’interno di un tale blocco, l’arresto nomina anche $jsonschema come la parola chiave il cui corpo lo conteneva.
  • Lo schema del carico di lavoro di un Plugin provider, mentre il Plugin viene caricato. spec.provider.workloadSchema è scritto come scalare a blocco: testo semplice mentre viene letto il file del Plugin stesso, privo di ancore in quel momento, e le sue ancore diventano ancore solo quando quel testo viene analizzato come documento a sé, un livello più in basso. Quell’analisi e la compilazione che segue avvengono entrambe mentre il Plugin viene caricato, quindi questo arresto scatta lì anziché quando il file viene letto, e riporta una riga. Quando il ciclo si trovava all’interno di un escape $jsonschema: nel corpo dello schema, l’arresto nomina anche $jsonschema come la parola chiave il cui corpo lo conteneva. Vedi ../entities/plugin.md per la superficie di authoring del campo.
  • Un frammento CloudFormation renderizzato, mentre il provider lo legge. Una Recipe cloudformation definisce un frammento, e un corpo artifacts: è un template — quindi ciò che il provider legge è il testo in cui quel template è stato renderizzato, contenuto che non esisteva mentre i tuoi file venivano letti. Questo arresto scatta quindi durante il rendering dell’output, dopo che ogni controllo di schema è già stato superato. Vedi ../providers/cloudformation.md per la superficie di authoring dei frammenti.

Il rifiuto riguarda la ricorsione, mai il riutilizzo o la profondità. Definire un’ancora su contenuto condiviso e farvi riferimento da molti punti è un pattern di authoring supportato — vedi ../entities/aggregate.md «Pattern di ancore YAML (blocco defs:)» e ../entities/manifest.md «Ancore YAML per manifest DRY» — e un riferimento che si espande e termina viene caricato normalmente, per quante volte compaia e per quanto profondamente il documento sia annidato; la profondità da sola non è mai un motivo per questo arresto. Ciò che arresta la build è un’ancora raggiunta mentre la build si trova ancora al suo interno, anche quando viene raggiunta indirettamente, tramite una seconda ancora dichiarata sotto di essa. Il messaggio nomina l’ancora su cui il ciclo si richiude, che non è necessariamente l’ancora più esterna del documento.

Messaggi emessi. Tutti e quattro riportano la stessa spiegazione, ed è voluto: si tratta di un’unica condizione incontrata in quattro punti, e un autore che ha imparato a leggerla una volta non dovrebbe doverla imparare di nuovo. Cambia solo il frame che individua il documento.

anchor &<anchor> is aliased by *<anchor> inside its own content, so the document expands without end; point that alias at content declared outside &<anchor>, or write the content out in full (l’ancora è richiamata tramite alias all’interno del proprio contenuto, quindi il documento si espande senza fine; punta quell’alias a contenuto dichiarato al di fuori dell’ancora, oppure scrivi il contenuto per intero)

Un file di entità è inquadrato dal controllo dell’involucro che lo stava leggendo e dal percorso da cui è stato letto:

document envelope validation failed: envelope: parse <path>: <the explanation above> (convalida dell’involucro del documento non riuscita: involucro: analisi)

Un corpo di schema è inquadrato dalla sua posizione all’interno dello schema, e dalla parola chiave di escape quando il ciclo si trovava all’interno di un blocco $jsonschema:. La build lo segnala sotto un tag CATALOG_ERROR, che nomina anche il file, l’entità e il pilastro il cui corpo non è stato compilato:

compactform at <schema-path>:<line> (keyword "$jsonschema"): <the explanation above> (compactform alla posizione, parola chiave)

Lo schema del carico di lavoro di un Plugin provider porta lo stesso frame in forma compatta; ciò che cambia è il tag CATALOG_ERROR che lo circonda, che nomina il Plugin e spec.provider.workloadSchema al posto dell’entità e del suo pilastro.

Un frammento renderizzato è inquadrato dal provider che lo ha letto:

cloudformation-provider: parse fragment: <the explanation above> (cloudformation-provider: analisi del frammento)

Come correggere: punta l’alias a contenuto dichiarato al di fuori dell’ancora in cui si trova attualmente, oppure scrivi per intero il contenuto ripetuto nel punto d’uso. In un Aggregate o in un Manifest, il blocco defs: di primo livello è la sede naturale per le ancore condivise — si trova al di fuori di ogni blocco che vi fa riferimento, quindi un’ancora dichiarata lì non può essere raggiunta dall’interno di sé stessa. Negli altri tipi di entità, che non hanno un blocco defs:, definisci l’ancora sul contenuto condiviso in un punto di cui il blocco che vi fa riferimento non sia discendente. A un’ancora si può fare riferimento da un numero qualsiasi di punti e da qualsiasi profondità; l’unica forma che non può assumere è un riferimento che ricade all’interno del contenuto coperto dall’ancora.

Lo stesso rimedio si applica ovunque l’arresto sia stato incontrato, e il frame ti dice quale documento aprire: il file di entità stesso, il blocco $jsonschema: all’interno di un pilastro di schema, il corpo workloadSchema all’interno di un Plugin provider, oppure il corpo artifacts: il cui output renderizzato è stato letto dal provider. In quest’ultimo caso l’ancora si trova nel template che hai scritto, non nel testo renderizzato — il rendering l’ha riprodotta fedelmente.

Parameter type mismatch / contract violation (Tipo di parametro non corrispondente / violazione del contratto)

La Release ha fornito un valore il cui tipo o la cui forma non corrisponde a quanto l’Aggregate ha dichiarato per quel parametro. Il validatore del contratto dei parametri intercetta tipi non corrispondenti, violazioni di enum, violazioni di intervallo, violazioni di pattern, stringhe che non sono istanze valide del format dichiarato, predicati validate: non soddisfatti e parametri obbligatori mancanti, prima che venga eseguita qualsiasi interpolazione di template. I nomi che un format può assumere, e ciò che ciascuno verifica, sono elencati in Formati con nome.

Messaggio emesso — la frase che enuncia la condizione, poi l’entità in errore, il percorso del campo e il dettaglio del vincolo:

parameter contract violated (Aggregate, at .spec.parameters.<parameter>, parameter "<parameter>" expected type <declared type>; got <received type>) (contratto del parametro violato: il parametro si aspettava il tipo dichiarato e ne ha ricevuto un altro)

Per un parametro dichiarato required: true senza default: e senza un valore fornito dalla Release, il report riporta una condizione diversa e un codice breve diverso:

required parameter not supplied (Aggregate, at .spec.parameters.<parameter>, parameter "<parameter>" is required but not supplied by Release) (parametro obbligatorio non fornito: il parametro è obbligatorio ma la Release non lo fornisce)

Solo il dettaglio dopo il percorso del campo cambia in base al vincolo non rispettato. La frase e la cornice tra parentesi che la circonda sono sempre le stesse, il che rende la frase la parte su cui fare il confronto e il dettaglio la parte da leggere. I dettagli che una build stampa, uno per tipo di vincolo:

parameter "<parameter>" value <value> not in enum [<members>] (valore del parametro non presente nell’enum) parameter "<parameter>" value "<value>" does not match pattern "<pattern>" (il valore del parametro non corrisponde al pattern) parameter "<parameter>" value "<value>" is not a valid <format>: <reason> (il valore del parametro non è valido per il formato) parameter "<parameter>" value <value> above max <max> (valore del parametro superiore al massimo) parameter "<parameter>" failed validate predicate (il predicato validate del parametro non è soddisfatto) parameter "<parameter>" validate predicate error: <detail> (errore del predicato validate del parametro)

Il <reason> di un errore di formato indica che cosa non va nel valore nei termini propri di quel formato. Un valore all’interno di un contratto annidato è indicato dal suo percorso, quindi un format dichiarato da un contratto items: viene verificato su ogni elemento e il report indica quello che non ha superato la verifica: il secondo elemento di un parametro hosts viene segnalato in .spec.parameters.hosts.1, e il suo dettaglio nomina "hosts.1".

Un parametro che dichiara un validateMessage: sostituisce l’intero dettaglio con il proprio testo, quindi il report riporta parameter contract violated (Aggregate, at .spec.parameters.<parameter>, <the validateMessage you wrote>) — la cornice resta invariata e la tua frase si trova dove sarebbe il dettaglio del vincolo.

La stessa condizione copre un contratto che, così come è scritto, non può vincolare nulla. Un pattern: che non è un’espressione regolare valida viene rifiutato quando si legge il contratto dei parametri dell’Aggregate, prima che venga verificato qualsiasi valore della Release, quindi interrompe la build indipendentemente dal fatto che una Release fornisca o meno il parametro. Il report punta alla chiave — .spec.parameters.<parameter>.pattern, o il percorso attraverso un contratto annidato come .spec.parameters.<parameter>.items.pattern — e il suo dettaglio nomina la dichiarazione, il pattern e il motivo:

parameter "<parameter>" pattern "<pattern>" does not compile: <reason> (il pattern del parametro non si compila)

Anche un format: che nomina un formato esterno all’insieme supportato non può vincolare nulla, e viene rifiutato nello stesso punto, prima che venga verificato qualsiasi valore della Release, quindi anch’esso interrompe la build indipendentemente dal fatto che una Release fornisca o meno il parametro. All’interno di un contratto annidato — sotto items:, properties: o valuesType: — è questa condizione a rifiutarlo: il report punta alla chiave, ad esempio .spec.parameters.<parameter>.items.format, e il suo dettaglio nomina la dichiarazione, il formato così come è scritto e ogni nome supportato:

parameter "<parameter>.items": format "<format>" is not supported; the supported formats are email, uri, hostname, ipv4, ipv6, uuid, date-time, date (formato del parametro non supportato; i formati supportati sono email, uri, hostname, ipv4, ipv6, uuid, date-time, date)

Sulla dichiarazione del parametro stesso, lo stesso nome viene rifiutato un passo prima, dallo schema dell’Aggregate, il cui format ammette solo i nomi supportati. Quel rifiuto è il documento che non rispetta lo schema del suo tipo — una condizione diversa, con un proprio codice breve, E0215 — e aggrega pull e aggrega validate --release lo elencano dopo aver segnalato come non risolvibile il riferimento aggregate: della Release (E0170), poiché l’Aggregate che contiene il nome non è stato caricato:

document envelope validation failed (Aggregate, at <path>); <line>:<column>: spec.parameters.<parameter>.format: enum: <format> does not equal any of: [email uri hostname ipv4 ipv6 uuid date-time date]. correct the document to match its kind’s schema (validazione dell’envelope del documento non riuscita: il formato non è tra i valori ammessi; correggi il documento perché corrisponda allo schema del suo tipo)

Il dettaglio dell’errore di predicato copre entrambi i modi in cui un predicato validate: può non produrre un verdetto: una funzione che la superficie non registra e un riferimento a qualcosa di diverso da .value. Ciascuno viene segnalato rispetto al predicato anziché rispetto al valore, e ciascuno nomina ciò che non è riuscito a risolvere.

Un predicato validate: legge il valore sottoposto a validazione come .value, ed è l’unico nome che definisce. Un predicato che nomina qualsiasi altra cosa viene rifiutato prima dell’esecuzione, quindi un riferimento digitato male viene segnalato come l’errore di denominazione che è, anziché risolversi nel nulla e manifestarsi come un valore che non ha superato la validazione.

Come correggere: modifica il valore della Release in modo che rispetti i vincoli type / enum / min / max / pattern / format dichiarati per il parametro, fornisci un parametro obbligatorio mancante, correggi un pattern: che non si compila, sostituisci un format: che nomina un formato non supportato con uno dei formati con nome oppure rimuovilo, correggi un predicato validate: che nomina qualcosa di diverso da .value o che produce qualcosa di diverso da true o false, oppure amplia la dichiarazione dell’Aggregate perché accetti la forma di cui hai effettivamente bisogno.

Regole sulla forma della Recipe

Una Recipe compone il proprio output a partire da tre tipi di input — da sorgente, sintetizzato e artefatti — descritti in ../../architecture/16-recipe-input-composition.md. La forma di una Recipe valida è vincolata dalle regole di composizione riportate di seguito. Differiscono per il momento in cui vengono verificate — quando la Recipe viene caricata, quando un nodo esegue il rendering o quando l’output viene emesso — quindi leggi ogni voce per conoscere il punto in cui viene verificata la sua condizione.

Ogni regola prende il nome da ciò che vincola. Non c’è numerazione, e nessun numero è riservato: un nome dice quale parte della Recipe aprire, e continua a dirlo comunque l’elenco seguente cresca o venga riordinato. Quando devi registrare una condizione in modo duraturo — in un gate di CI, una issue, un runbook — usa il suo codice, l’identificatore che sentinels.md elenca per la condizione e che resta fisso mentre i pacchetti che lo circondano evolvono.

Un arresto dovuto alla forma della Recipe è composto allo stesso modo. Si apre con la frase che enuncia la regola, poi nomina ciò che questa particolare Recipe ha fornito, quindi il dettaglio che le è specifico:

<the rule's sentence> (Recipe <name>:<version>, rule <rule-name>, at <position>). <rule-specific detail> (la frase della regola, poi la Recipe con nome e versione, il nome della regola e la posizione; quindi il dettaglio specifico della regola)

La frase iniziale è fissa per ciascuna regola — lo stesso testo ogni volta che quella regola interrompe la build, qualunque fase l’abbia rilevata — quindi è la parte dell’output su cui fare il confronto, ed è il testo che sentinels.md elenca per la condizione della regola. Tutto ciò che segue varia con la Recipe in errore: i valori tra parentesi dicono quale documento, quale regola per nome e dove, e la frase di chiusura è il consiglio per quell’occorrenza. La posizione è il file da cui è stata caricata la Recipe quando la regola riguarda il documento nel suo insieme, e un percorso puntato verso la chiave che hai scritto — .spec.outputComponentLabels.hosting — quando la regola riguarda una singola cosa al suo interno; una chiave che contiene punti propri non può essere scritta come un ulteriore segmento senza poter essere letta anche come due, quindi il percorso si ferma al blocco che la contiene e il consiglio cita invece la chiave.

La build stampa l’intera riga sotto un tag CATALOG_ERROR, che segnala che l’errore è attribuibile all’entità del catalogo (la Recipe, o il provider a cui si lega), non all’Aggregate o alla Release. Il file da cui è stata caricata la Recipe viene stampato accanto al tag, quindi una regola posizionata su una chiave ti dice comunque quale file aprire.

valuesMapping requires source (la mappatura dei valori richiede una sorgente)

Una Recipe dichiara valuesMapping ma non source. Senza una sorgente su cui sovrapporli, non c’è nulla che riceva i valori mappati. Questa regola viene verificata quando la Recipe viene caricata.

Messaggio emesso:

Recipe: valuesMapping requires source (Recipe <name>:<version>, rule values-mapping, at <path>). declare a source: pointer alongside valuesMapping (or remove the valuesMapping if no overlay is intended) (Recipe: valuesMapping richiede source; dichiara un puntatore source: accanto a valuesMapping, oppure rimuovi valuesMapping se non è previsto alcun overlay)

Come correggere: aggiungi un puntatore source: (un riferimento a un chart, a un modulo o a un file compose) accanto a valuesMapping, oppure rimuovi valuesMapping e adotta un tipo di input diverso (workload: per l’output sintetizzato, artifacts: per l’emissione diretta di manifest).

workload: requires a provider that can synthesize (richiede un provider in grado di eseguire la sintesi)

Una Recipe dichiara workload: (modalità sintetizzata) per un provider che non implementa la sintesi di Workload. Il supporto della modalità sintetizzata è una proprietà del provider — il catalogo della libreria standard dichiara workloadSchema sui provider capaci di sintesi per convenzione, ma la verifica si basa sulla capacità del provider, non sulla presenza di quel campo.

Due superfici lo segnalano, e solo una di esse decide la build. L’arresto viene sollevato in fase di rendering, dopo che il provider del nodo è stato associato e una volta letti i tipi di input che la sua Recipe dichiara, quindi quel report nomina il nodo. aggrega validate segnala la stessa rilevazione in anticipo, prima che qualsiasi nodo sia associato, leggendo la Recipe da sola — quindi quel report nomina invece la Recipe e la sua versione. I due non leggono lo stesso insieme di Recipes: il report anticipato viene sollevato per qualsiasi Recipe che dichiari workload:, mentre l’arresto viene sollevato per ogni tipo di input dichiarato dal nodo che il suo provider non può onorare. Quindi una Recipe che abbina un workload: a un source: si arresta comunque, e si arresta per il carico di lavoro — dichiarare un tipo di input che il provider è in grado di renderizzare non porta oltre il controllo uno non supportato.

L’unico limite a questo: artifacts: viene verificato rispetto al supporto degli artefatti autonomi solo quando è l’unico tipo dichiarato del nodo. Accanto a un source: o a un workload:, i suoi file passano come output composto, che quella capacità non governa.

Messaggio emesso in fase di rendering. La categoria a cui è attribuito l’errore ti arriva nell’intestazione tra parentesi quadre della diagnostica anziché all’interno del messaggio. Il messaggio si apre con la frase fissa che enuncia la condizione, poi nomina il nodo, il provider, il tipo dichiarato che è stato rifiutato e i tipi che quel provider supporta. Quando un nodo dichiara due tipi che il suo provider non può onorare, viene segnalato il primo nell’ordine source → workload → artifacts, così la rilevazione riguarda una sola riga della tua Recipe:

provider does not support the node’s input kind (node "<node-id>"). provider "<provider-name>" does not support <mode> recipes (this provider supports: <kinds>); declare one of the supported input kinds, or target a provider that supports <mode> (il provider non supporta il tipo di input del nodo; dichiara uno dei tipi di input supportati, oppure punta a un provider che supporta la modalità)

L’intestazione riporta la categoria e il codice breve di questa condizione, E0265, che è l’identificatore da registrare quando devi nominare questo arresto in modo duraturo — in un gate di integrazione continua, una issue o un runbook. Un numero viene assegnato una volta e poi resta fisso, quindi rimane lo stesso comunque migliori la formulazione intorno; la tabella di ogni condizione lo risolve, e la frase iniziale qui sopra è ciò su cui fare il confronto quando lavori a partire dal testo anziché da un identificatore.

aggrega validate segnala la stessa clausola sotto la Recipe che contiene il blocco, preceduta dalla superficie che l’ha letta e con in testa il codice breve di questa condizione, perché il report anticipato è la stessa condizione:

input-kind: [E0265] Recipe "<name>:<version>": provider "<provider-name>" does not support synthesized recipes (this provider supports: <kinds>); declare one of the supported input kinds, or target a provider that supports synthesized (il provider non supporta la modalità sintetizzata; dichiara uno dei tipi di input supportati, oppure punta a un provider che supporta la modalità sintetizzata)

Sull’intero catalogo è una sola riga; con --release l’intestazione si trova su una riga propria sopra la clausola. La diagnostica dell’editor per la stessa rilevazione riporta E0265 come codice.

Come correggere: associa la Recipe a un provider che esegue la sintesi (più comunemente helm o compose), oppure migra la Recipe a un tipo di input diverso (artifacts: per l’emissione diretta di manifest, oppure source: + valuesMapping: se esiste un chart/modulo).

Validazione del contenuto del Workload per singolo provider. Oggi il workloadSchema del provider è solo documentazione e non valida il corpo del Workload; i corpi vengono validati rispetto allo schema Workload incorporato di proprietà della piattaforma. Quando sarà rilasciato il sintetizzatore di Workload basato su Wasm, workloadSchema diventerà il contratto per singolo provider rispetto al quale il sintetizzatore valida il corpo del Workload (un arresto distinto, a livello di contenuto).

The provider does not support omits (Il provider non supporta omits)

Una Recipe o una FeatureRecipe dichiara omits: e il provider che la renderizza non dichiara di escludere documenti renderizzati. Escludere un documento da ciò che una sorgente renderizza è qualcosa che solo il provider può fare — solo il provider sa quali documenti la sorgente renderizza e come si chiama ciascuno — quindi un provider che non lo fa renderizzerebbe ogni documento indicato dalle voci e segnalerebbe un successo. La build invece rifiuta prima che venga renderizzato qualsiasi cosa, così la chiave non resta mai silenziosamente senza effetto.

Se un provider esclude documenti si legge dalla dichiarazione del provider stesso su ciò che supporta, non da un elenco di provider tenuto dal compilatore. Ogni voce conta, qualunque cosa renderizzi il suo when:, perché la capacità del provider di onorare la chiave non dipende da quali voci una build mantiene. I provider helm, compose e cloudformation onorano la chiave. helm-chart e terraform passano oltre la propria sorgente perché venga renderizzata al momento della distribuzione, quindi in fase di build non esiste alcun documento renderizzato da escludere, ed entrambi vengono rifiutati.

Il rifiuto viene deciso una volta che la Recipe di ogni componente e la FeatureRecipe di ogni associazione sono vincolate e ogni provider ha descritto sé stesso — prima che il primo componente venga renderizzato e prima che qualsiasi voce venga valutata, quindi una build rifiutata qui non renderizza nulla. La verifica riguarda ogni documento che renderizza una sorgente: la Recipe di un componente; la FeatureRecipe che un’associazione vincola su un componente, una volta per ogni componente che porta l’associazione; e una FeatureRecipe che genera una sola volta per un confine, una volta, nel confine che la dichiara. Ogni documento in errore viene segnalato in un’unica build; dove ce n’è più di uno, i rilievi sono raggruppati sotto documents declaring omits whose provider does not honour them. Un documento vincolato a un provider che la build non riesce a risolvere non viene segnalato qui: quella build si arresta nel punto in cui il provider viene selezionato, indicando il vincolo.

Messaggio emesso, posizionato sulla chiave del componente stesso sotto components: per le voci di una Recipe (un componente scritto all’interno di un sottosistema viene posizionato prima sotto la chiave di quel sottosistema), sulla chiave dell’associazione nel blocco features: che l’ha scritta per quelle di una FeatureRecipe su un componente, e su .spec.boundaries.<boundary>.features.<attachment> nella Release per una FeatureRecipe che genera una sola volta per il proprio confine. La categoria ti arriva nell’intestazione tra parentesi quadre; il messaggio indica prima il provider, poi il componente per cui il documento viene renderizzato:

provider does not support omits ("<provider-name>", node "<node-id>"). this provider’s contract does not declare that it leaves rendered documents out; remove the omits key, or render the source through a provider whose contract declares it (il provider non supporta omits: il contratto di questo provider non dichiara di escludere documenti renderizzati; rimuovi la chiave omits, oppure renderizza la sorgente tramite un provider il cui contratto lo dichiari)

Il rilievo di una FeatureRecipe indica l’associazione dopo il componente — node "<node-id>", attachment "<attachment>" — e quello di una FeatureRecipe che genera una sola volta per il proprio confine indica il confine e l’associazione al posto di un componente: boundary "<boundary>", attachment "<attachment>".

L’intestazione riporta il codice breve di questa condizione, E0335.

Come correggere: rimuovi la chiave omits:, oppure renderizza la sorgente tramite un provider che la onori. Dove una Recipe helm-chart o terraform usa come sorgente un chart o un modulo locale, una riga nel .aggregaignore accanto alla Recipe esclude invece un file di quella sorgente, a partire dalla prossima volta in cui la Recipe viene fissata — vedi aggrega pin.

The provider does not support boundary artifacts (Il provider non supporta gli artefatti del confine)

Una Recipe dichiara spec.boundary.artifacts — file per l’output condiviso del confine in cui viene renderizzata — e il provider che la renderizza non dichiara di accettare tali file. Il compilatore scrive quei file da sé, accanto a ciò che il provider assembla per il confine, e non ne passa nessuno al provider, quindi se un file collocato lì abbia un significato è una proprietà del target del provider. Un target che non lo legge lo consegnerebbe e lo ignorerebbe, e la configurazione che contiene non avrebbe mai effetto; la build invece rifiuta prima che venga renderizzato qualsiasi cosa.

Se un provider accetta i file si legge dalla dichiarazione del provider stesso su ciò che supporta, non da un elenco di provider tenuto dal compilatore. Qualsiasi voce conta, qualunque sia il risultato del suo rendering. Il provider terraform li accetta, scrivendo ciascuno accanto alla configurazione radice del confine; helm, compose, helm-chart e cloudformation no, e vengono rifiutati.

Il rifiuto viene deciso una volta che la Recipe di ogni componente è vincolata e ogni provider ha descritto sé stesso — prima che il primo componente venga renderizzato e prima che qualsiasi voce venga valutata, quindi una build rifiutata qui non renderizza nulla. Ogni Recipe in errore viene segnalata in un’unica build, una volta per ogni componente che renderizza; dove i rilievi sono più di uno, sono raggruppati sotto Recipes declaring boundary artifacts whose provider does not accept them. Una Recipe vincolata a un provider che la build non riesce a risolvere non viene segnalata qui: quella build si arresta nel punto in cui il provider viene selezionato, indicando il vincolo.

Messaggio emesso, posizionato su .spec.boundary nella Recipe, dove va fatta la modifica. La categoria ti arriva nell’intestazione tra parentesi quadre; il messaggio indica prima il provider, poi il componente per cui la Recipe viene renderizzata:

provider does not support boundary artifacts ("<provider-name>", node "<node-id>"). this provider’s contract does not declare that it accepts files written to a boundary’s shared output; remove the boundary block, or render the Recipe through a provider whose contract declares it (il provider non supporta gli artefatti del confine: il contratto di questo provider non dichiara di accettare file scritti nell’output condiviso di un confine; rimuovi il blocco boundary, oppure renderizza la Recipe tramite un provider il cui contratto lo dichiari)

L’intestazione riporta il codice breve di questa condizione, E0351.

Come correggere: rimuovi il blocco boundary:, oppure renderizza la Recipe tramite un provider che lo accetti. Un file che appartiene al componente anziché al confine è invece una voce artifacts:.

At least one input kind must be present (Deve essere presente almeno un tipo di input)

Una Recipe non dichiara alcun tipo di input: nessuna source abbinata a valuesMapping, nessun workload:, nessun artifacts:. Una Recipe del genere non produce output e non ha alcuna superficie di rendering. Questa regola viene verificata quando la Recipe viene caricata.

Un file di Recipe con quella forma incontra prima lo schema della Recipe: lo schema richiede, su ogni provider, uno tra source, valuesMapping, workload o artifacts, quindi il controllo dell’involucro del documento rifiuta il file con E0215 prima che questa regola venga eseguita, con un ramo per ciascuna chiave:

document envelope validation failed (Recipe, at <path>); <line>:<column>: spec: no anyOf branch matched: branch[0]: validation: required: missing properties: [“source”]; branch[1]: validation: required: missing properties: [“valuesMapping”]; branch[2]: validation: required: missing properties: [“workload”]; branch[3]: validation: required: missing properties: [“artifacts”]. correct the document to match its kind’s schema (convalida dell’involucro del documento non riuscita (Recipe): spec: nessun ramo anyOf corrisponde: ramo[0]: convalida: obbligatorie: proprietà mancanti: [“source”]; ramo[1]: convalida: obbligatorie: proprietà mancanti: [“valuesMapping”]; ramo[2]: convalida: obbligatorie: proprietà mancanti: [“workload”]; ramo[3]: convalida: obbligatorie: proprietà mancanti: [“artifacts”]. correggi il documento in modo che corrisponda allo schema del suo tipo)

Messaggio emesso:

Recipe: at least one input kind required (Recipe <name>:<version>, rule input-kinds, at <path>). declare one of: source (with valuesMapping), workload, artifacts (Recipe: è richiesto almeno un tipo di input (Recipe, regola input-kinds). dichiara uno tra: source (con valuesMapping), workload, artifacts)

Come correggere: aggiungi il tipo di input che corrisponde all’intento con cui la Recipe è stata scritta. Una Recipe per un servizio che la build non predispone — un database o un’API già in esecuzione altrove — dichiara un workload: con form: reference e il relativo endpoint (e facoltativamente port), e pubblica i propri valori di connessione sotto provides: come fa qualsiasi Recipe: helm la renderizza come un ExternalName Service, compose non renderizza nulla per essa, e con entrambi i suoi consumatori leggono i valori pubblicati.

artifacts: entry keys must be unique (Le chiavi delle voci degli artefatti devono essere univoche)

Una Recipe dichiara due o più voci sotto artifacts: con la stessa chiave. La chiave determina il nome del file emesso (che il corpo della voce sia scritto inline o caricato tramite un $import: per singola voce); chiavi duplicate emetterebbero un file con lo stesso nome nella stessa directory del confine.

La build rifiuta la Recipe durante la decodifica del documento nella sua forma tipizzata, indicando la chiave ripetuta e la riga in cui ricorre. Quel passaggio viene eseguito dopo il controllo dello schema dell’involucro e prima delle regole di forma, quindi una Recipe con una chiave artifacts: duplicata riporta uno schema valido e poi questo arresto, e le restanti regole di forma non la segnalano.

Come correggere: rinomina una delle chiavi di voce in collisione in modo che ogni voce di artifacts: abbia un nome di file univoco.

Emission-time filename collision across input kinds (Collisione di nomi di file in fase di emissione tra tipi di input)

Una Recipe e una FeatureRecipe dichiarano ciascuna tipi di input che producono file: una source: che il provider renderizza, un workload: che il provider sintetizza, voci di artifacts: e una pipeline: i cui step possono emettere. Ciascuno sceglie i propri nomi di output indipendentemente dagli altri, e nulla dichiara che quei nomi siano distinti — quindi due di essi possono produrre un file con lo stesso nome, e solo uno dei due sopravvivrebbe. La build si arresta e indica il nome di output insieme a ogni blocco che lo ha prodotto.

Il controllo viene eseguito una volta per ogni documento che emette, non appena l’emissione di quel documento è completa e prima che il suo output entri in qualsiasi assemblaggio. Tre documenti emettono, e ciascuno viene controllato a sé: la Recipe del componente stesso, la FeatureRecipe che un’associazione vincola su un componente, e la FeatureRecipe che vincola un’associazione con ambito di confine. Tenerli separati è ciò che fa sì che la diagnostica indichi il documento giusto — i file di un’associazione vengono renderizzati sotto l’identità del componente che la ospita, quindi una collisione nella FeatureRecipe dell’associazione viene segnalata a carico di quella FeatureRecipe anziché del componente ospite.

Ogni nome in collisione viene segnalato separatamente, quindi un documento i cui blocchi si sono scontrati su due nomi li segnala entrambi. Un rilievo è posizionato sul documento che modifichi per correggerlo: l’istanza del componente per una Recipe, e la FeatureRecipe stessa per un’associazione, il cui rilievo indica anche l’associazione — un componente o un confine possono vincolarne diverse.

Un blocco che emette più file con lo stesso nome non è questo arresto. Si tratta di un solo contributore anziché di due blocchi che si scontrano, e le chiavi artifacts: duplicate all’interno di un blocco vengono rifiutate durante la decodifica del documento.

Messaggio emesso:

filename collision across input kinds: two input-kind blocks produced a file under one output name (output name <filename>, produced by <origin1>, <origin2>) (collisione di nomi di file tra tipi di input: due blocchi di tipi di input hanno prodotto un file con lo stesso nome di output)

Una collisione in una FeatureRecipe riporta anche l’associazione:

filename collision across input kinds: two input-kind blocks produced a file under one output name (output name <filename>, produced by <origin1>, <origin2>, attachment <instance>) (collisione di nomi di file tra tipi di input: due blocchi di tipi di input hanno prodotto un file con lo stesso nome di output)

Come correggere: rinomina il file in collisione in qualunque tipo di input tu controlli. Se la collisione coinvolge un nome di file tradotto dal Workload e una voce di artifacts:, i nomi tradotti dal Workload seguono le convenzioni di traduzione del provider (ad es. <release-name>-deployment.yaml per helm, dove il nome della release è {{ .context.rendered_name }}) — adatta il nome di file di artifacts: a un nome che il provider non sintetizza.

An output-label key uses a reserved namespace (Una chiave di etichetta di output usa un namespace riservato)

Una Recipe indica una chiave di etichetta sotto aggrega.ai/ o app.kubernetes.io/ — in outputLabels:, il blocco che applica etichette letterali all’output renderizzato, oppure in outputComponentLabels:, il blocco che indica le chiavi di etichetta del componente i cui valori vengono promossi su di esso. Entrambi i prefissi appartengono allo spazio di chiavi di provenienza della piattaforma stessa: sono le chiavi che la build applica da sé, quindi una Recipe che ne applicasse una scriverebbe nello spazio che dice da dove proviene una risorsa. Riservarli è anche ciò che mantiene l’insieme di etichette di una Recipe disgiunto dall’insieme di provenienza, così i due non devono mai essere riconciliati quando vengono uniti. Questa regola viene verificata quando la Recipe viene caricata.

La riserva riguarda solo la radice nuda. Una chiave che si limita a contenere una radice riservata più in profondità, all’interno di un namespace proprio — ad esempio component.aggrega.ai/hosting — è uno spazio di chiavi diverso che non appartiene alla piattaforma, e resta utilizzabile.

Messaggio emesso. Un’unica condizione copre entrambi i blocchi, quindi la sua frase non può dire quale dei due sia stato scritto; il suggerimento che la segue indica il blocco citando la chiave che hai digitato e il blocco in cui l’hai digitata:

recipe output-labels constraint: key uses a reserved namespace (Recipe <name>:<version>, rule output-labels, at .spec.outputLabels). key "<key>" in outputLabels uses a reserved namespace ("aggrega.ai/" and "app.kubernetes.io/" are reserved for platform provenance) (vincolo output-labels della ricetta: la chiave usa un namespace riservato (Recipe, regola output-labels). la chiave in outputLabels usa un namespace riservato (i due prefissi sono riservati alla provenienza della piattaforma))

Una chiave scritta nel blocco promosso viene segnalata con il nome di regola di quel blocco, che il suggerimento indica:

recipe output-labels constraint: key uses a reserved namespace (Recipe <name>:<version>, rule output-component-labels, at .spec.outputComponentLabels). key "<key>" in outputComponentLabels uses a reserved namespace ("aggrega.ai/" and "app.kubernetes.io/" are reserved for platform provenance) (vincolo output-labels della ricetta: la chiave usa un namespace riservato (Recipe, regola output-component-labels). la chiave in outputComponentLabels usa un namespace riservato (i due prefissi sono riservati alla provenienza della piattaforma))

Le chiavi del blocco letterale vengono controllate dopo essere state ordinate e quelle del blocco promosso nell’ordine in cui le hai scritte, quindi una Recipe che viola la regola in più punti segnala sempre per prima la stessa chiave.

Come correggere: sposta la chiave in un namespace di tua proprietà — il tuo dominio, oppure uno con sotto-prefisso come component.aggrega.ai/… — oppure eliminala se il valore che volevi è uno che la build applica già. Le chiavi di provenienza che una risorsa renderizzata porta sono elencate in ../providers/well-known-annotations.md; rileggerne una non richiede alcuna dichiarazione nella Recipe.

A promoted component label is also declared literally (Un’etichetta di componente promossa è dichiarata anche letteralmente)

Una Recipe indica una stessa chiave sia in outputComponentLabels: sia in outputLabels:. I due blocchi applicano valori sulla stessa superficie di etichette da fonti diverse — il primo promuove il valore che il componente porta, il secondo scrive il valore digitato dall’autore della Recipe — quindi una chiave indicata in entrambi arriverebbe con due valori candidati e nulla che dica quale prevale. Questa regola viene verificata quando la Recipe viene caricata, dopo la regola del namespace riservato vista sopra, quindi una Recipe che le viola entrambe segnala per primo il namespace riservato: la correzione di quell’errore non dipende da ciò che contiene l’altro blocco.

Messaggio emesso:

recipe output-component-labels constraint: key is also declared in outputLabels (Recipe <name>:<version>, rule output-component-labels, at .spec.outputComponentLabels.<key>). key "<key>" is promoted through outputComponentLabels and also declared literally in outputLabels; keep whichever source the label should come from and drop the other (vincolo output-component-labels della ricetta: la chiave è dichiarata anche in outputLabels (Recipe, regola output-component-labels). la chiave è promossa tramite outputComponentLabels e dichiarata anche letteralmente in outputLabels; mantieni la fonte da cui l’etichetta deve provenire ed elimina l’altra)

Come correggere: decidi da dove proviene il valore dell’etichetta ed elimina l’altra dichiarazione. Mantieni la voce di outputComponentLabels: quando il valore deve seguire ciò che il componente porta, così due componenti vincolati a una stessa Recipe applicano ciascuno i propri valori; mantieni la voce di outputLabels: quando il valore è proprio della Recipe ed è lo stesso ovunque la Recipe sia vincolata.

Regole di forma della FeatureRecipe

Una FeatureRecipe compone il proprio output dagli stessi tipi di input di una Recipe, e la regola di composizione qui sotto la vincola come vincola una Recipe. Viene verificata quando la FeatureRecipe viene caricata, e segnala nella forma che assume un arresto di forma della Recipe — la frase della regola, poi il documento in errore, il nome della regola e il suggerimento per quell’occorrenza — sotto un tag CATALOG_ERROR.

Qui, deliberatamente, non esiste alcuna regola di almeno un tipo di input, ed è questa la differenza rispetto a una Recipe. Una FeatureRecipe che dichiara solo un provider e ciò che implementa è un’associazione legittima di solo cablaggio: non renderizza nulla, e il suo effetto è il collegamento che porta la Feature che implementa. Una FeatureRecipe che dichiara solo injectMapping: è legittima allo stesso modo.

A FeatureRecipe’s valuesMapping requires source (La mappatura dei valori di una FeatureRecipe richiede una sorgente)

Una FeatureRecipe dichiara valuesMapping ma non source. Una mappatura dei valori è una sovrapposizione: senza un chart, un modulo o un file su cui sovrapporla, i valori mappati non hanno nulla da raggiungere.

Messaggio emesso:

FeatureRecipe: valuesMapping requires source (FeatureRecipe <name>:<version>, rule values-mapping, at <path>). declare a source: pointer alongside valuesMapping (or remove the valuesMapping if no overlay is intended) (FeatureRecipe: valuesMapping richiede source (FeatureRecipe, regola values-mapping). dichiara un puntatore source: accanto a valuesMapping (oppure rimuovi valuesMapping se non si intende alcuna sovrapposizione))

Come correggere: aggiungi il puntatore source: per cui è stata scritta la sovrapposizione, oppure rimuovi valuesMapping e lascia che l’associazione svolga il suo lavoro in un altro modo — artifacts: per emettere file propri, injectMapping: per rimodellare ciò che consegna, oppure nessuno dei due, per un’associazione di solo cablaggio.

A pipeline declares one step id twice (Una pipeline dichiara due volte lo stesso id di step)

Una Recipe o una FeatureRecipe dichiara lo stesso id su due step della propria spec.pipeline. Uno step pubblica gli output che restituisce sotto il proprio id, e uno step successivo della stessa pipeline li legge come .steps.<id>.outputs, quindi due step con lo stesso id porterebbero quello step successivo a leggere gli output di quello dei due che ha pubblicato per ultimo anziché di quello che intendevi.

La regola riguarda la pipeline propria di un singolo documento. La Recipe di un componente e le FeatureRecipes associate a esso eseguono ciascuna la propria pipeline separatamente, e ogni pipeline parte senza output di step, quindi uno step di una Recipe e uno step di una FeatureRecipe associata possono avere lo stesso id.

Nessuno schema può esprimere questa regola — JSON Schema non ha alcuna keyword per un elenco le cui voci siano univoche rispetto a uno dei loro campi — quindi un editor che conosce lo schema accetta un documento del genere, e il controllo viene eseguito mentre il documento viene letto, subito dopo il controllo dello schema. Ogni superficie che legge una Recipe o una FeatureRecipe lo segnala: aggrega validate sul file o sull’intero catalogo, una build che carica il catalogo, un pull che ammette un’entità scaricata, la diagnostica dell’editor e una modifica di documento, che viene rifiutata anziché scritta. Un documento che non supera anche il proprio schema segnala prima i rilievi dello schema, e questo rifiuto una volta corretti quelli.

Ogni ripetizione è un rilievo a sé, posizionato sull’id ripetuto e con il nome dello step che ha dichiarato l’id per primo, con la sua riga e la sua colonna. Dove un id compare tre volte, entrambi gli step successivi nominano il primo.

Messaggio emesso, per una FeatureRecipe il cui secondo step ripete l’id del primo. La categoria e il codice breve di questa condizione, E0370, ti arrivano nell’intestazione tra parentesi quadre:

a pipeline declares one step id twice (FeatureRecipe, at <path>); <line>:<column>: spec.pipeline[1].id: step id "<id>" is already declared at spec.pipeline[0].id (line <line>, column <column>). give each step of the pipeline its own id, and point every .steps.<id> reference a later step makes at the step it means (una pipeline dichiara due volte lo stesso id di step (FeatureRecipe); spec.pipeline[1].id: l’id di step è già dichiarato in spec.pipeline[0].id. assegna a ogni step della pipeline un id proprio, e fai puntare ogni riferimento che uno step successivo fa allo step che intende)

Come correggere: rinomina uno dei due step, in modo che ogni id sia dichiarato una sola volta. Poi leggi i template with: e when: di ogni step successivo cercando i riferimenti .steps.<id> all’id che hai mantenuto, e fai puntare ciascuno allo step di cui intende gli output — è la ridenominazione a rendere raggiungibili separatamente gli output dei due step.

A document declares an API version this compiler no longer reads (Un documento dichiara una versione dell’API che questo compilatore non legge più)

La riga apiVersion di un documento dichiara aggrega.ai/v1alpha1. Ogni tipo di documento che contiene una riga apiVersion dichiara aggrega.ai/v1beta1, l’unica versione che questo compilatore legge, e non avviene alcuna conversione dalla versione precedente: il documento viene rifiutato mentre viene letto, prima che venga controllato qualsiasi altro aspetto, perché ogni altra segnalazione riguarderebbe una versione del documento che il compilatore non legge.

Ogni superficie che legge un documento lo segnala: aggrega validate, una build, un pull che accetta un’entità recuperata, la diagnostica dell’editor e una modifica del documento. Un documento che dichiara una versione che il compilatore non ha mai letto viene invece rifiutato dallo schema del suo tipo, con E0215.

Messaggio emesso, per un Component. La categoria e il codice breve di questa condizione, E0373, ti arrivano nell’intestazione tra parentesi quadre:

a document declares an API version this compiler no longer reads (Component, at <path>); 1:1: apiVersion: the document declares aggrega.ai/v1alpha1, and this compiler reads aggrega.ai/v1beta1. change the apiVersion line to apiVersion: aggrega.ai/v1beta1 (un documento dichiara una versione dell’API che questo compilatore non legge più (Component); 1:1: apiVersion: il documento dichiara aggrega.ai/v1alpha1 e questo compilatore legge aggrega.ai/v1beta1. imposta la riga apiVersion su aggrega.ai/v1beta1)

Come correggere: cambia la riga apiVersion del documento in apiVersion: aggrega.ai/v1beta1. I campi di ciascun tipo non cambiano tra le due versioni, quindi quella riga è l’unica modifica.

A plugin declares a plugin ABI version this compiler no longer speaks (Un plugin dichiara una versione dell’ABI dei plugin che questo compilatore non supporta più)

Un plugin dichiara l’ABI dei plugin v1alpha1. Questo compilatore supporta l’ABI dei plugin v1beta1 e nessun’altra, quindi un plugin compilato per quella precedente viene rifiutato anziché eseguito. Un plugin dichiara la propria ABI in due punti, e ciascuno viene rifiutato con questa stessa condizione: il report describe() che il suo guest restituisce quando viene caricato, e il campo spec.abiVersion della sua entità Plugin, rifiutato mentre l’entità viene letta, prima che venga controllato qualsiasi altro aspetto. Viene rifiutato anche un plugin che dichiara una versione dell’ABI che questo compilatore non ha mai supportato, dal controllo del descrittore (E0085) o dallo schema Plugin (E0215).

Messaggio emesso, per un guest al caricamento. La categoria e il codice breve di questa condizione, E0374, ti arrivano nell’intestazione tra parentesi quadre:

plugin "<plugin>" declares abi_version “v1alpha1”, and this compiler speaks “v1beta1”; rebuild the plugin against the current plugin kit and publish it again: a plugin declares a plugin ABI version this compiler no longer speaks (il plugin dichiara abi_version “v1alpha1” e questo compilatore supporta “v1beta1”; ricompila il plugin con il kit per plugin attuale e pubblicalo di nuovo: un plugin dichiara una versione dell’ABI dei plugin che questo compilatore non supporta più)

Messaggio emesso, per un’entità Plugin:

a plugin declares a plugin ABI version this compiler no longer speaks (Plugin, at <path>); <line>:<column>: spec.abiVersion: the Plugin declares abiVersion v1alpha1, and this compiler speaks v1beta1. rebuild the plugin against the current plugin kit and publish it again; its Plugin entity then declares abiVersion: v1beta1 (un plugin dichiara una versione dell’ABI dei plugin che questo compilatore non supporta più (Plugin); spec.abiVersion: il Plugin dichiara abiVersion v1alpha1 e questo compilatore supporta v1beta1. ricompila il plugin con il kit per plugin attuale e pubblicalo di nuovo; la sua entità Plugin dichiarerà allora abiVersion v1beta1)

Come correggere: ricompila il plugin con la versione attuale del suo kit per plugin, che imprime v1beta1 nel report describe() del guest, e pubblicalo di nuovo, così che anche l’entità generata accanto a esso dichiari abiVersion: v1beta1. Modificare solo la riga dell’entità non basta: il guest stesso continua a riportare l’ABI precedente e viene rifiutato quando viene caricato.

An artifact carries a media type this compiler no longer reads (Un artefatto riporta un tipo di media che questo compilatore non legge più)

Un artefatto recuperato da un registro riporta un tipo di media con cui pubblicava una versione precedente — application/vnd.aggrega.<kind>.v1alpha1 con il suo suffisso, nel tipo di artefatto del manifesto, nella sua configurazione o in uno dei suoi livelli. Questo compilatore pubblica e legge i tipi di media v1beta1, quindi l’artefatto viene rifiutato per nome mentre ne viene letto il manifesto, prima che venga acquisita qualsiasi parte del suo contenuto: che si tratti di un’entità di catalogo, di un plugin e del suo eseguibile o di un pacchetto di documentazione. L’indicizzazione di un registro salta un artefatto di questo tipo, indicandone il motivo. Un tipo di media al di fuori del namespace application/vnd.aggrega. proprio di Aggrega non rientra mai in questa condizione.

Messaggio emesso, per un Component pubblicato da una versione precedente. La categoria e il codice breve di questa condizione, E0375, ti arrivano nell’intestazione tra parentesi quadre:

"<reference>" carries media type “application/vnd.aggrega.component.v1alpha1+yaml”, and this compiler reads “application/vnd.aggrega.component.v1beta1+yaml”; publish the artifact again with the current release: oci: artifact carries a media type this compiler no longer reads (riporta il tipo di media “application/vnd.aggrega.component.v1alpha1+yaml” e questo compilatore legge “application/vnd.aggrega.component.v1beta1+yaml”; pubblica di nuovo l’artefatto con la versione attuale: oci: l’artefatto riporta un tipo di media che questo compilatore non legge più)

Come correggere: pubblica di nuovo l’artefatto con la versione attuale di aggrega, che scrive i tipi di media v1beta1. Un artefatto pubblicato da qualcun altro spetta a chi lo pubblica ripubblicarlo; finché non lo fa, non può essere letto.

A file cannot be read, or its bytes do not parse (Un file non può essere letto, oppure i suoi byte non superano l’analisi sintattica)

Un file che una build doveva leggere, o un documento Aggrega che un controllo dell’intero catalogo ha letto nelle directory del catalogo, non ha prodotto nulla che la superficie che lo nominava o lo leggeva potesse usare. O non è stato possibile leggerlo dal disco, oppure i suoi byte sono stati analizzati e l’analisi non è riuscita in modo pulito. Nulla a valle viene eseguito su di esso, perché non c’è alcun contenuto da verificare rispetto a uno schema, nessun componente da collocare e nessun template da renderizzare.

La condizione non nomina alcun formato, ed è voluto. La maggior parte dei file che copre viene letta come YAML; i corpi workload, values-mapping e artifact di una Recipe vengono letti come sorgente di template Go e non vengono mai analizzati. Una frase che promettesse YAML aprirebbe una diagnostica su un file template con un’affermazione sul formato di quel file. Quale dei due errori si è verificato, e per quale tipo di file, è ciò che dice la clausola che segue la frase.

I documenti da cui parte una build — l’Aggregate, la Release e il Manifest — sono i soggetti più comuni, e l’arresto viene sollevato in ogni punto in cui uno dei tre viene letto. La diagnostica indica quale documento veniva letto e il percorso da cui è stato letto. È il percorso a distinguere un file mancante da uno malformato: un errore di lettura cita il motivo indicato dal sistema operativo stesso, e un errore di analisi cita quello del parser YAML, che riporta la riga su cui il parser si è arreso.

Messaggio emesso, quando non è stato possibile leggere il file:

file load failed: the file could not be read, or its bytes did not parse (Aggregate, at <path>, failed to read file: <underlying reason>) (caricamento del file non riuscito: non è stato possibile leggere il file, oppure i suoi byte non hanno superato l’analisi (Aggregate, lettura del file non riuscita))

e quando il suo testo non ha superato l’analisi:

file load failed: the file could not be read, or its bytes did not parse (Aggregate, at <path>, failed to unmarshal YAML: <underlying reason>) (caricamento del file non riuscito: non è stato possibile leggere il file, oppure i suoi byte non hanno superato l’analisi (Aggregate, decodifica dello YAML non riuscita))

Release e Manifest compaiono al posto di Aggregate quando il documento letto è uno di questi. La stessa condizione copre anche il contratto dei parametri letto dal blocco parameters: dichiarato da un Aggregate, che viene letto dal testo stesso dell’Aggregate prima che vi venga interpolato qualsiasi valore.

Anche un parameters: { $import: … } di una Release che nomina un file che la build non riesce a ottenere viene segnalato qui, e in entrambi i casi: il percorso non nomina alcun file che la build possa leggere, oppure il file viene letto e i suoi byte non superano l’analisi. Il soggetto è la Release, e la clausola nomina la chiave che puntava al file:

file load failed: the file could not be read, or its bytes did not parse (Release, at .spec.parameters.$import: <path>, failed to read file: <underlying reason>) (caricamento del file non riuscito: non è stato possibile leggere il file, oppure i suoi byte non hanno superato l’analisi (Release, lettura del file non riuscita)) file load failed: the file could not be read, or its bytes did not parse (Release, at .spec.parameters.$import: <path>, failed to unmarshal YAML: <underlying reason>) (caricamento del file non riuscito: non è stato possibile leggere il file, oppure i suoi byte non hanno superato l’analisi (Release, decodifica dello YAML non riuscita))

Un percorso relativo viene risolto a partire dalla directory che contiene la Release che lo scrive — la Release nominata da un comando, o un anello della sua catena extends: — da qualunque posizione venga eseguito il comando, così la riga di comando e l’editor leggono lo stesso file; un percorso assoluto nomina il proprio posto. Verifica che il checkout su cui gira la build contenga il file in quel punto: un file di parametri presente sulla tua macchina ed escluso dal controllo di versione è assente durante un’esecuzione di integrazione continua, che è il modo comune in cui si incontra questo errore. Un percorso che esce dal workspace — oppure, per una Release nominata fuori dal workspace, dalla directory della Release stessa — non viene letto affatto, e viene segnalato sotto «A reference to another file leads out of the directory it must stay inside» (Un riferimento a un altro file esce dalla directory in cui deve restare) più avanti.

Anche un $import: di schema che nomina un file che la build non riesce a ottenere viene segnalato qui, perché l’errore è lo stesso: la direttiva è ben formata e il file che nomina non ha prodotto un documento. In questo caso il soggetto è un’entità di catalogo anziché uno dei tre documenti, quindi la clausola nomina la superficie di schema per cui stava risolvendo — spec.schema, un suo pilastro come spec.schema.values, o il valueSchema di un socket usesSchema — e il puntatore alla sorgente è la riga su cui la direttiva è stata scritta:

file load failed: the file could not be read, or its bytes did not parse. <surface>: read imported schema <value>: <the operating system's reason> (caricamento del file non riuscito: non è stato possibile leggere il file, oppure i suoi byte non hanno superato l’analisi. lettura dello schema importato)

con resolve imported schema path al posto di read per il caso più raro in cui non è stato possibile stabilire affatto la directory dell’entità stessa, e parse imported schema quando il file è stato letto e il suo testo non è YAML ben formato. Un errore nella direttiva che hai scritto — una chiave sorella accanto a essa, un valore che non è un percorso, o un contenuto importato che ha superato l’analisi e non è una mappa — è una condizione diversa e viene segnalato sotto «A schema $import: cannot be applied» (Un’importazione di schema non può essere applicata) più avanti.

Anche un import valuesMapping:, workload: o artifacts.<name>: di una Recipe o di una FeatureRecipe viene segnalato qui, per lo stesso motivo e con lo stesso rimedio: la direttiva è ben formata e il file che nomina non ha prodotto contenuto. Questi tre corpi sono sorgente di template Go anziché documenti, quindi può fallire solo la lettura — a questo punto nulla li analizza. L’entità e la chiave che ha nominato il percorso viaggiano nella clausola, e il puntatore alla sorgente è il percorso del file importato stesso:

file load failed: the file could not be read, or its bytes did not parse (Recipe <name> valuesMapping file import, <the operating system's reason>). if you meant a library entry rather than a file, the reference needs its fragment — an $import: carrying none is read as a file path, and an unquoted value ends where a space before # starts a comment, so quote the whole reference (caricamento del file non riuscito: non è stato possibile leggere il file, oppure i suoi byte non hanno superato l’analisi (Recipe, import di file valuesMapping). se intendevi una voce di libreria anziché un file, il riferimento ha bisogno del suo frammento — un $import: che non ne ha viene letto come percorso di file, e un valore senza virgolette termina dove uno spazio prima di # avvia un commento, quindi metti tra virgolette l’intero riferimento) file load failed: the file could not be read, or its bytes did not parse (Recipe <name> workload file import, <the operating system's reason>). if you meant a library entry rather than a file, the reference needs its fragment — an $import: carrying none is read as a file path, and an unquoted value ends where a space before # starts a comment, so quote the whole reference (caricamento del file non riuscito: non è stato possibile leggere il file, oppure i suoi byte non hanno superato l’analisi (Recipe, import di file workload). se intendevi una voce di libreria anziché un file, il riferimento ha bisogno del suo frammento — un $import: che non ne ha viene letto come percorso di file, e un valore senza virgolette termina dove uno spazio prima di # avvia un commento, quindi metti tra virgolette l’intero riferimento) file load failed: the file could not be read, or its bytes did not parse (Recipe <name> artifact <key> file import, <the operating system's reason>). if you meant a library entry rather than a file, the reference needs its fragment — an $import: carrying none is read as a file path, and an unquoted value ends where a space before # starts a comment, so quote the whole reference (caricamento del file non riuscito: non è stato possibile leggere il file, oppure i suoi byte non hanno superato l’analisi (Recipe, import di file dell’artifact). se intendevi una voce di libreria anziché un file, il riferimento ha bisogno del suo frammento — un $import: che non ne ha viene letto come percorso di file, e un valore senza virgolette termina dove uno spazio prima di # avvia un commento, quindi metti tra virgolette l’intero riferimento)

Il frammento è ciò che distingue un riferimento di libreria da un percorso: <Library>#/mappings/<entry> viene risolto rispetto alle librerie, e lo stesso testo senza il frammento è un normale percorso relativo. È facile perderlo senza accorgersene, perché un valore YAML semplice termina dove uno spazio prima di # apre un commento — così $import: LibBeta:1.0.0 #/workloads/Web arriva alla build come LibBeta:1.0.0, e la build cerca allora un file con quel nome accanto alla Recipe. Metti tra virgolette l’intero riferimento per conservare il frammento.

Le stesse tre chiavi su una FeatureRecipe segnalano la stessa condizione e si leggono allo stesso modo. Un import di artifacts viene letto due volte nel corso della vita di una Release — una volta quando aggrega pull congela il pin del suo contenuto, e di nuovo quando la voce viene renderizzata — quindi lo stesso file mancante segnala questa condizione in quello dei due momenti che raggiungi per primo. Un errore di forma nella direttiva stessa, come una chiave sorella accanto a $import: o un riferimento oci:// che include un host, è una condizione diversa e viene segnalato sotto la propria voce.

Anche aggrega lint e aggrega validate sull’intero catalogo segnalano qui, per un documento nelle directory del catalogo che dichiara una apiVersion Aggrega — una riga che inizia, senza rientro, con apiVersion: e un valore che comincia con aggrega.ai/ — e non può essere letto, non viene analizzato, o non si decodifica nell’envelope che il controllo legge, come un metadata scritto come elenco. Nessun autore ha scritto un percorso verso di esso: il controllo lo ha letto perché si trova in una directory di catalogo. Ogni controllo legge tutti i file prima di arrestarsi, quindi una sola esecuzione nomina ogni documento di questo tipo, e non verifica nient’altro né stampa alcun riepilogo. Lo YAML che non dichiara alcuna apiVersion Aggrega — tra cui i template di un chart Helm — viene ignorato. L’intestazione conta i documenti e ne nomina i file, e ciascuno è elencato sotto di essa con il motivo indicato dalla lettura o dal parser:

<n> documents under the catalog directories declare an Aggrega apiVersion and could not be loaded, so nothing was checked: <path>, <path> (documenti nelle directory del catalogo dichiarano una apiVersion Aggrega e non è stato possibile caricarli, quindi non è stato verificato nulla) file load failed: the file could not be read, or its bytes did not parse (catalog document, failed to unmarshal YAML: <the parser's reason>) (caricamento del file non riuscito: non è stato possibile leggere il file, oppure i suoi byte non hanno superato l’analisi (documento di catalogo, decodifica dello YAML non riuscita))

con failed to decode the envelope: e la riga e ciò che il decoder vi ha trovato — line 4 (metadata): a list is written where a map is expected per un metadata scritto come elenco — per un documento che supera l’analisi e non si decodifica, e failed to read file: e il motivo del sistema operativo per un file che non è stato possibile leggere. Un documento che viene caricato e dichiara un tipo che nessun catalogo contiene è nominato dallo stesso arresto, contato nella stessa intestazione ed elencato sotto la propria condizione — vedi «A catalog document declares a kind a catalog does not hold» (Un documento di catalogo dichiara un tipo che un catalogo non contiene) più avanti.

Come correggere: leggi il percorso nel messaggio anziché il nome del documento — i due differiscono ogni volta che un riferimento si è risolto in un punto inatteso. Per un errore di lettura, verifica che il file esista in quel percorso, che il percorso sia scritto come lo scrive il documento che vi fa riferimento, e che la build abbia il permesso di leggerlo; un file presente in locale e assente dal checkout di un agente di build è il caso comune. Per un errore di analisi, apri il file alla riga indicata dal parser — un valore senza virgolette che contiene i due punti, una tabulazione usata per l’indentazione e un elemento di elenco indentato sotto la chiave sbagliata sono i tre casi che ne spiegano la maggior parte.

A catalog document declares a kind a catalog does not hold (Un documento di catalogo dichiara un tipo che un catalogo non contiene)

Un documento nelle directory del catalogo dichiara una apiVersion Aggrega — una riga che inizia, senza rientro, con apiVersion: e un valore che comincia con aggrega.ai/ — e un kind che nessun catalogo contiene: un errore di battitura come Componnent, un tipo con le maiuscole sbagliate come component, o nessun kind. Un catalogo archivia ogni documento sotto il tipo che dichiara, quindi un documento del genere non entra in alcun catalogo: una build, inspect e ogni altro comando che carica il catalogo lo ignorano, e un riferimento all’entità che doveva dichiarare non si risolve in nulla.

Un catalogo contiene documenti Component, Feature, Recipe, FeatureRecipe, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary, Aggregate e Plugin. Altri tre tipi si trovano legittimamente nelle sue directory e non vengono mai segnalati qui: un Manifest e una Release tenuti accanto alle entità, e un Workload nella directory della Recipe o della FeatureRecipe che lo importa.

Lo segnalano aggrega validate e aggrega lint sull’intero catalogo, e il lint circoscritto a una release, che percorre le stesse directory. Ciascuno legge tutti i file prima di arrestarsi, quindi una sola esecuzione nomina ogni documento di questo tipo insieme a qualsiasi documento che non può essere caricato affatto, sotto un’unica intestazione che li conta e ne nomina i file; non viene verificato nulla e non viene stampato alcun riepilogo. Ogni documento è elencato con il tipo che dichiara, e la riga si chiude con i tipi che un catalogo contiene:

<n> documents under the catalog directories declare an Aggrega apiVersion and could not be loaded, so nothing was checked: <path>, <path> (documenti nelle directory del catalogo dichiarano una apiVersion Aggrega e non è stato possibile caricarli, quindi non è stato verificato nulla) catalog document declares a kind a catalog does not hold (kind “Componnent”). a catalog holds Component, Feature, Recipe, FeatureRecipe, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary, Aggregate and Plugin documents, and passes over a Workload, a Manifest or a Release; correct the kind, or move the file out of the catalog directories (un documento di catalogo dichiara un tipo che un catalogo non contiene (kind “Componnent”). un catalogo contiene documenti Component, Feature, Recipe, FeatureRecipe, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary, Aggregate e Plugin, e ignora un Workload, un Manifest o una Release; correggi il kind, oppure sposta il file fuori dalle directory del catalogo)

con no kind al posto di kind "<kind>" per un documento che non ne dichiara alcuno.

Una build non si ferma su un documento del genere: lo ignora come fa ogni caricamento, e un documento che nessuna Release raggiunge non fa mai fallire una build. Dove una Release raggiunge l’entità, la build si ferma al riferimento, sotto «A reference names no entity the catalog holds» (Un riferimento non nomina alcuna entità contenuta nel catalogo) più avanti, e la nota sotto quell’errore nomina il file quando questo dichiara il nome richiesto dal riferimento — vedi quella voce.

Come correggere: apri il file nominato dal messaggio e correggi il suo kind con il tipo del documento — contano sia l’ortografia sia le maiuscole. Un file che non è affatto un’entità di catalogo non deve stare nelle directory del catalogo; spostalo fuori, oppure assegnagli una apiVersion che non sia quella di Aggrega se è il documento di un altro strumento.

A path names content outside the entity’s own directory (Un percorso indica contenuti esterni alla directory dell’entità)

Il contenuto di un’entità risiede nella directory dell’entità stessa, perché ogni file che una pubblicazione dell’entità porta con sé viene preso da lì. Un percorso che ne esce punta a un file che non viaggerebbe con l’entità, quindi il file non è presente per chi riceve l’entità, e un pin registrato su di esso garantisce byte che quei destinatari non possono ottenere.

Per questo ogni percorso che un’entità scrive per i contenuti che porta con sé viene letto rispetto alla directory che contiene il file dell’entità e deve restare al suo interno. Ciò riguarda la source: di una Recipe e di una FeatureRecipe — un percorso semplice, oppure l’url: della forma strutturata — il file che ogni voce di valuesMapping:, workload: e artifacts: importa con $import:, e ogni schema che un Component o una Feature importa, per intero, per pilastro o, per un socket usesSchema, per il suo valueSchema e il suo infraSchema. Tre forme escono dalla directory: un percorso che risale al di sopra di essa, un percorso assoluto, che indica un luogo sulla macchina su cui è stato scritto, e un percorso scritto all’interno della directory che un collegamento simbolico lungo il cammino porta fuori di essa — una directory lungo il percorso, così come il file alla sua fine, che sia un collegamento diretto all’esterno della directory dell’entità. Un percorso che risale e rientra — ./charts/../values.tmpl — è un normale percorso all’interno della directory, e lo è anche uno che passa per un collegamento che porta altrove al suo interno. Una risalita che rientra nella directory attraverso il suo stesso nome — ../1.0.0/values.tmpl scritto in una directory chiamata 1.0.0 — viene rifiutata, perché il nome della directory non fa parte di ciò che viaggia: un’entità pubblicata viene letta da una directory a cui dà il nome la cache del destinatario, dove quel nome non trova nulla. Un percorso che passa per un collegamento diretto all’esterno viene rifiutato perché altrimenti una pubblicazione porterebbe i byte a cui punta il collegamento, ovunque punti, sotto un nome interno all’entità.

Viene rifiutato ovunque l’entità venga letta. Un aggrega validate sull’intero catalogo, aggrega validate sul file dell’entità stessa, aggrega pull e aggrega build lo rifiutano mentre il file dell’entità viene letto, e così fanno aggrega pin di una Recipe o di una FeatureRecipe e aggrega push di uno qualsiasi dei quattro tipi, prima che qualcosa venga scaricato, scritto o pubblicato. Una source: scritta come template non indica nulla finché la build non la valuta, quindi un template che produce un percorso esterno alla directory viene rifiutato dalla build, nel momento in cui il valore esiste.

Una Release è diversa, e lo è anche un riferimento a un’entità. Una Release punta ad altre entità — il suo Aggregate, il suo Manifest, la Release che estende — e non viene mai pubblicata, quindi nulla di ciò che legge viaggia da nessuna parte: quei percorsi, e il file che i parameters: di una Release importano, vengono letti così come sono scritti. Il type di un Aggregate indica un’altra entità tramite la sua identità anziché tramite contenuti che l’Aggregate porta con sé, e anch’esso viene risolto secondo regole proprie: attraverso le directory del catalogo, la cache e il registry, mai come percorso di file.

Messaggio emesso, che indica il percorso così come è scritto:

a path names content outside the entity’s own directory ("<path>"). remediation: move the file into the directory holding the entity, or a directory beneath it, and name it with a path relative to that directory. An entity’s content lives in the entity’s own directory because every file a publication of it carries is taken from there; a path that leaves it points at a file that would not travel with the entity (un percorso indica contenuti esterni alla directory dell’entità. rimedio: sposta il file nella directory che contiene l’entità, o in una directory sottostante, e indicalo con un percorso relativo a quella directory. Il contenuto di un’entità risiede nella directory dell’entità stessa perché ogni file che una sua pubblicazione porta con sé viene preso da lì; un percorso che ne esce punta a un file che non viaggerebbe con l’entità)

e, per un percorso che un collegamento porta fuori dalla directory, indicando il collegamento e dove conduce:

a path names content outside the entity’s own directory ("./frag/fragment.yaml", the link <entity-directory>/frag leads to <elsewhere>/frag). remediation: replace the link with a copy of what it leads to, placed inside the directory holding the entity. An entity’s content lives in the entity’s own directory because every file a publication of it carries is taken from there; a link leading out of it would carry the bytes it points at under a name inside the entity (un percorso indica contenuti esterni alla directory dell’entità. rimedio: sostituisci il collegamento con una copia di ciò a cui conduce, collocata all’interno della directory che contiene l’entità. Il contenuto di un’entità risiede nella directory dell’entità stessa perché ogni file che una sua pubblicazione porta con sé viene preso da lì; un collegamento che ne esce porterebbe i byte a cui punta sotto un nome interno all’entità)

Il campo da cui è stato letto è indicato sulla riga sopra il messaggio: resolve Recipe source …, resolve Recipe artifact "<key>" $import target …, spec.schema.values: imported schema … oppure, per una sorgente basata su template, node "<name>" source.

Come risolvere: sposta il file nella directory dell’entità, o in una directory sottostante, e scrivi il suo percorso relativo a quella directory. Dove un collegamento porta il percorso all’esterno, sostituisci il collegamento con una copia di ciò a cui conduce, all’interno della directory dell’entità. Un chart condiviso da più Recipes viene copiato nella directory di ciascuna Recipe, poiché ognuna viene pubblicata per conto proprio; uno schema condiviso da più Components va in una SchemaLibrary, a cui ciascun Component fa poi riferimento tramite la sua identità, e un corpo di mapping, di carico di lavoro o di artefatto condiviso da più Recipes va nel tipo di libreria corrispondente.

A Recipe’s source: names a kind nothing knows how to acquire (La sorgente di una Recipe indica un tipo che nulla sa come acquisire)

La source: di una Recipe dice a che tipo di cosa punta — un chart, un modulo, un progetto compose — e ogni tipo viene acquisito dall’adattatore di sorgente che serve quel tipo. Questa condizione segnala un tipo che nessun adattatore di sorgente serve, quindi nulla di ciò che questo programma include può scaricare la sorgente. La source: di una FeatureRecipe è soggetta alla stessa regola.

Viene rifiutato durante la lettura del documento, prima che qualcosa venga scaricato: la verifica della sola Recipe lo rifiuta, e così fa ogni Release che la raggiunge. Non è stato tentato nulla, perché nulla poteva tentarlo — ed è questo che lo distingue da un’acquisizione che è stata eseguita ed è fallita.

Messaggio emesso, che indica il documento, il tipo così come è scritto e i tipi serviti:

no source adapter serves the source kind (Recipe <name>:<version>, rule source-kind, at <file>). the source names kind "<kind>"; name a kind a source adapter serves (<the served kinds>), or write the source as a single URI whose shape names its kind (nessun adattatore di sorgente serve il tipo di sorgente (Recipe, regola source-kind). la sorgente indica un tipo; indica un tipo servito da un adattatore di sorgente, oppure scrivi la sorgente come un unico URI la cui forma indica il suo tipo)

Come risolvere: correggi il tipo nella source: in uno che la toolchain serve — un errore di ortografia e un tipo che davvero non ha alcun adattatore producono lo stesso messaggio, e il messaggio cita il tipo come lo hai scritto accanto ai tipi serviti, quindi la prima cosa da verificare è l’ortografia rispetto a quell’elenco, che descrive anche la pagina della Recipe. Se il tipo è scritto come intendevi, quel tipo non è uno che questa build può acquisire, e nessuna modifica alla Recipe lo renderà tale; fai invece puntare la source: a una forma servita, oppure scrivila come un unico URI la cui forma indica il suo tipo.

No source adapter is registered in this program for a source kind (Nessun adattatore di sorgente è registrato in questo programma per un tipo di sorgente)

Una sorgente viene scaricata dall’adattatore registrato per il suo tipo. Questa condizione segnala uno scaricamento avviato per un tipo per cui non è registrato alcun adattatore. Un tipo scritto dall’autore che nessun adattatore serve viene rifiutato durante la lettura della sua Recipe (sotto «A Recipe’s source: names a kind nothing knows how to acquire (La sorgente di una Recipe indica un tipo che nulla sa come acquisire)» più sopra), quindi nulla di ciò che un autore scrive arriva fin qui: segnala un programma assemblato senza l’adattatore per un tipo che serve, oppure un programma costruito sui pacchetti Go di Aggrega che avvia uno scaricamento per un tipo che ha assemblato esso stesso.

Messaggio emesso, che indica il tipo:

kind "<kind>": no source adapter is registered in this program for the source kind (tipo: nessun adattatore di sorgente è registrato in questo programma per il tipo di sorgente)

Come risolvere: nulla nei tuoi file di entità ne è la causa. Segnalalo a chi ha compilato il binario che stai eseguendo.

A source URL carries a credential (Un URL di sorgente contiene una credenziale)

L’url di una sorgente viene registrato così come lo hai scritto — nel lockfile della Release, nell’entity.lock accanto alla Recipe e nella cache delle sorgenti — e la Recipe stessa è un file di cui fai il commit e che puoi pubblicare. Quindi una credenziale scritta nell’URL viaggerebbe ovunque viaggi l’URL. Questa condizione segnala una source: di una Recipe il cui url scrive un utente prima dell’host: https://user:token@host/…, oppure un token scritto da solo come https://token@host/…, poiché un servizio raggiunto tramite HTTP accetta comunemente un token al posto dell’utente. Su http e https conta qualsiasi utente scritto lì; su un altro schema conta solo una password, perché un utente scritto da solo lì indica un account — ssh://git@github.com/… è accettato, e l’agente SSH fornisce la sua chiave. La source: di una FeatureRecipe è soggetta alla stessa regola.

Viene rifiutato durante la lettura del documento, prima che qualcosa venga scaricato: la verifica della sola Recipe lo rifiuta, e così fa ogni Release che la raggiunge, in una convalida, in un pull, in un pin o in una build. Il messaggio indica l’host e mai la credenziale. La verifica legge la parte dell’URL scritta prima dell’host e nient’altro, quindi un token contenuto in una query string o in un percorso non viene rilevato — e viene registrato così come è scritto, come il resto dell’URL.

Messaggio emesso su http o https, che indica il documento, la chiave e l’host, poi dove va scritta la credenziale:

the source URL carries a credential (Recipe <name>:<version>, rule source-url, at <file>). spec.source.url names a user or password for host <host>; remove it from the URL and write the credential in the netrc file instead, as an entry “machine <host> login <user> password <secret>” (the file NETRC names, else .netrc in your home directory, or _netrc in %USERPROFILE% on Windows) (l’URL della sorgente contiene una credenziale (Recipe, regola source-url). spec.source.url indica un utente o una password per l’host; rimuovili dall’URL e scrivi invece la credenziale nel file netrc, come voce «machine … login … password …» (il file indicato da NETRC, altrimenti .netrc nella tua home directory, oppure _netrc in %USERPROFILE% su Windows))

e su un altro schema, dove il rimedio è rimuovere la password:

the source URL carries a credential (Recipe <name>:<version>, rule source-url, at <file>). spec.source.url names a password for host <host>; remove it from the URL, which is written into the lockfile and the cache as authored (l’URL della sorgente contiene una credenziale (Recipe, regola source-url). spec.source.url indica una password per l’host; rimuovila dall’URL, che viene scritto nel lockfile e nella cache così come è stato scritto)

Come risolvere: rimuovi l’utente e la password dall’url, lasciando l’URL che indica l’host. Per una sorgente scaricata tramite http o https, inserisci la credenziale in una voce machine per quell’host nel tuo file netrc, che legge ogni scaricamento di un repository classico di chart Helm, di un frammento compose o di un repository Git tramite HTTP o HTTPS — Autenticazione descrive quale file e quale voce. Per un repository Git tramite SSH, l’agente SSH fornisce la chiave, e l’utente può restare. Se la Recipe è già stata sottoposta a commit o pubblicata con la credenziale al suo interno, la credenziale si trova in quella cronologia: cambiala anche sul server.

A {{ .parameters.* }} reference cannot be interpolated (Un riferimento ai parametri non può essere interpolato)

Il testo dell’Aggregate viene valutato come template prima di essere letto come documento, in modo che un riferimento {{ .parameters.<key> }} venga sostituito dal valore che la Release ha fornito per esso. Questo arresto scatta quando tale valutazione non può essere completata: il testo non viene analizzato come template, oppure viene analizzato e fallisce durante l’esecuzione.

L’interpolazione avviene prima che l’Aggregate venga analizzato come YAML, ed è per questo che un errore qui viene segnalato sull’Aggregate nel suo insieme anziché su una chiave al suo interno — a quel punto il documento non ha ancora chiavi. È anche il motivo per cui il riferimento può essere lasciato senza virgolette: la sostituzione avviene sui byte grezzi, e la regola di quoting propria di YAML decide poi il tipo del valore, quindi un riferimento senza virgolette produce il tipo naturale del valore e uno tra virgolette produce una stringa.

Un riferimento che indica una chiave che la Release non ha fornito non è questo arresto. Una chiave assente qui si risolve in un valore vuoto e viene intercettata, con il suo tipo e il suo contratto, dai controlli sui parametri descritti sotto «Parameter type mismatch / contract violation (Tipo di parametro non corrispondente / violazione del contratto)» più sopra. Ciò che questo arresto segnala è un testo che il motore di template non è riuscito affatto a elaborare — un {{ non chiuso, un nome di funzione scritto male, una pipeline i cui stadi non si combinano tra loro. Leggere un parametro tramite index — {{ index .parameters "db_size" }} — quando la Release non ha fornito tale parametro è un fallimento durante l’esecuzione, e questo arresto lo riporta, indicando la chiave: index si arresta su una chiave che la mappa non contiene su ogni superficie di template, come descrive più sotto «A template indexes a map with a key the map does not hold (Un template indicizza una mappa con una chiave che la mappa non contiene)».

Un testo che non viene affatto analizzato viene rifiutato indicando il percorso dell’Aggregate stesso, perché quel file è disponibile prima che qualcosa lo legga. Un modulo che la composizione importa viene valutato allo stesso modo un livello più in profondità, dove il suo testo viene letto dal catalogo anziché essere consegnato alla build. L’arresto è questa stessa condizione e porta questo codice in entrambi i casi; per un modulo indica anche l’import che stava seguendo e il file da cui è stato letto il testo del modulo, e il messaggio che porta indica solo il tipo — quindi la posizione che quel messaggio fornisce è una posizione nel testo del modulo stesso, non nell’Aggregate da cui sei partito.

Messaggi emessi, per un template che non viene analizzato, per lo stesso errore in un modulo che la composizione importa, e per un template che fallisce durante l’esecuzione:

invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate <path>, “template parse error: <underlying reason>”) (riferimento a parametro non valido: verifica che l’espressione {{ .parameters.* }} indichi un parametro dichiarato e venga analizzata come template Go (Aggregate, «errore di analisi del template»)) invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate, template parse error: <underlying reason>) (riferimento a parametro non valido: verifica che l’espressione {{ .parameters.* }} indichi un parametro dichiarato e venga analizzata come template Go (Aggregate, errore di analisi del template)) invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate, template execution error: <underlying reason>) (riferimento a parametro non valido: verifica che l’espressione {{ .parameters.* }} indichi un parametro dichiarato e venga analizzata come template Go (Aggregate, errore di esecuzione del template))

Il testo di un Aggregate ha una sola radice, .parameters, quindi un riferimento attraverso qualsiasi altra — {{ .values.app_token }} oppure {{ $.values.app_token }} — non legge nulla e fallisce durante l’esecuzione. Il motivo si apre allora indicando il riferimento che ha letto:

invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate, the template reads <reference>, and an Aggregate’s text defines no root but .parameters; template execution error: <underlying reason>) (riferimento a parametro non valido: verifica che l’espressione {{ .parameters.* }} indichi un parametro dichiarato e venga analizzata come template Go (Aggregate, il template legge un riferimento, e il testo di un Aggregate non definisce alcuna radice oltre a .parameters; errore di esecuzione del template))

Come risolvere: apri l’Aggregate e leggi il motivo sottostante, che indica la posizione nel testo e il costrutto che ha fallito. Verifica che ogni {{ abbia il suo }}, che una funzione che hai chiamato sia tra quelle che la superficie offre — l’interpolazione dei parametri offre le funzioni di Sprig e nient’altro, quindi l’helper optional non è disponibile qui — e che gli stadi di una pipeline accettino ciò che produce lo stadio che li precede. Se il motivo indica una chiave che index non ha trovato, leggi un parametro che potrebbe non essere impostato con un punto ({{ .parameters.db_size }}) oppure tramite get o hasKey di Sprig. Se indica un riferimento attraverso un’altra radice, dichiara il valore come parametro dell’Aggregate e leggilo come {{ .parameters.<key> }}. Se indica qualcosa che non intendevi come template — undefined variable "$json" da un’espressione n8n, o una funzione che porta il nome di un nodo Flowise — il testo contiene doppie graffe proprie, comprese quelle di un commento: scrivi ogni {{ al suo interno come {{"{{"}}, come descrive Testo che contiene le proprie doppie graffe.

The Release directory declares one Aggregate or Manifest twice (La directory della Release dichiara due volte un Aggregate o un Manifest)

Una Release il cui riferimento aggregate: o manifest: è un’identità semplice viene risolta esaminando per prima la directory della Release stessa, e quell’esame ha trovato due Aggregates — o due Manifests — con lo stesso metadata.name. Un riferimento per identità semplice nomina un’entità con quel nome, quindi un nome rivendicato due volte è un nome per cui la directory non può rispondere.

L’esame rifiuta la directory nel suo insieme, non solo il nome richiesto da un riferimento. Legge ogni Aggregate e ogni Manifest che si trova accanto alla Release, quindi anche una coppia in collisione che nessuno dei due riferimenti nomina arresta la build: la directory è ambigua indipendentemente dal fatto che fosse questa la Release in procinto di leggere quell’entità. Un riferimento scritto come percorso (./aggregate.yaml, ../shared/manifest.yaml) indirizza un file anziché un’entità e viene risolto senza l’esame, quindi una Release i cui aggregate: e manifest: sono entrambi percorsi non lo esegue mai.

Questa è la controparte, nella stessa directory, del rifiuto per identità duplicata del catalogo, e le due vengono segnalate separatamente affinché il messaggio nomini la directory in cui ti trovi anziché un livello del catalogo a cui forse non stavi pensando.

Messaggio emesso:

duplicate Aggregate/Manifest identity (metadata.name) in the Release directory: Aggregate "<name>" declared more than once in <release-directory> (identità Aggregate/Manifest duplicata (metadata.name) nella directory della Release: Aggregate dichiarato più di una volta)

con Manifest al posto di Aggregate quando a collidere sono due Manifests.

Come risolvere: assegna a una delle due entità un metadata.name diverso, oppure spostala fuori dalla directory della Release. Due Releases che distribuiscono davvero Aggregates diversi con lo stesso nome vanno in directory proprie; copiare una Release in un file accanto senza rinominare ciò che contiene è il modo in cui questo accade di solito.

A Release’s aggregate: or manifest: reference resolves to nothing (Il riferimento di una Release non si risolve in nulla)

Una Release nomina un Aggregate o un Manifest per identità semplice e non è stata trovata alcuna entità con quel nome su nessuna delle superfici in cui si cerca un’identità semplice: la directory della Release stessa, il catalogo e il registry.

Messaggio emesso, quando nulla corrisponde da nessuna parte:

aggregate/manifest reference unresolvable: no Aggregate named "<reference>" in the Release directory, catalog, or registry (riferimento aggregate/manifest non risolvibile: nessun Aggregate con questo nome nella directory della Release, nel catalogo o nel registry)

Un file nella directory della Release che non è stato possibile indicizzare cambia la segnalazione, perché cambia ciò che si può affermare onestamente. Quel file potrebbe essere stato l’entità, quindi il messaggio lo dice anziché affermare un’assenza che non può stabilire, e riporta l’errore di parsing che ne ha impedito la lettura:

aggregate/manifest reference unresolvable: Aggregate "<reference>" not found; unparseable file <path> could not be indexed and may be it: <parse failure> (riferimento aggregate/manifest non risolvibile: Aggregate non trovato; il file non analizzabile non è stato indicizzato e potrebbe essere quello cercato)

e quando un file non analizzabile è proprio quello che il riferimento nomina esplicitamente:

aggregate/manifest reference unresolvable: needed Aggregate "<reference>" is the unparseable file <path>: <parse failure> (riferimento aggregate/manifest non risolvibile: l’Aggregate richiesto è il file non analizzabile)

Come risolvere: quando il riferimento è davvero assente, correggine l’ortografia — l’identità è il metadata.name dell’entità, non il nome del suo file — oppure aggiungi l’entità alla directory della Release o al catalogo che la build legge. Quando il messaggio nomina un file non analizzabile, correggi prima quel file: il suo errore di parsing è citato nel messaggio, e ripararlo spesso risolve il riferimento con la stessa modifica. Un riferimento ./ o ../ è un percorso anziché un’identità e viene risolto come tale, quindi un punto iniziale cambia quale dei due errori stai cercando.

A component is placed in more than one boundary (Un componente è collocato in più di un confine)

L’albero dei confini di una Release colloca un componente in due confini diversi. Le due collocazioni non vengono né unite né ordinate per priorità, e non potrebbero esserlo: il confine di un componente decide dove viene scritto il suo output, in quale sottodirectory finisce, a quale sync wave si unisce e quali annotazioni e quale infra di confine eredita — mentre la sua superficie uses: per singolo arco viene letta da una visita separata. Un componente nominato due volte prenderebbe la posizione del proprio output da una collocazione e la configurazione per arco dall’altra.

Un confine colloca i componenti in tre modi, e tutti e tre contano. Nominarne uno direttamente sotto components:, con l’id che porta una volta completata la composizione, lo colloca. Nominarne uno all’interno del components: di una voce di instradamento, con il nome locale che porta all’interno di quel sottomodulo, lo colloca anch’esso. E instradare un intero sottomodulo sotto aggregates: colloca ogni componente contenuto in quel modulo. Quindi questo arresto copre anche un sottomodulo instradato in due confini, un modulo instradato in un confine con un modulo annidato al suo interno instradato in un altro, e un componente nominato in un confine mentre il modulo che lo contiene è instradato in un confine diverso.

Instradare un modulo in un confine e nominare anche uno dei suoi componenti sotto quello stesso confine non è un conflitto — entrambe le collocazioni concordano su dove appartiene il componente — e la build riesce. Uno stesso id scritto due volte sotto un solo confine è un conflitto anche lì: una voce nel components: del confine e una voce per lo stesso componente all’interno della voce di instradamento del confine sono due voci che portano la configurazione di un solo componente, senza nulla per scegliere tra loro.

Viene segnalata ogni collocazione in errore. Una Release che colloca più componenti due volte si arresta con uno di questi per ogni voce in errore in un’unica build, ciascuno alla chiave della voce a cui obietta — così più di essi insieme sono una sola build che nomina tutto ciò che ha trovato, anziché un unico errore scritto più di una volta.

La collocazione che un messaggio segnala come già in vigore non è sempre quella scritta per prima nel file. Le voci components: di un confine vengono lette prima dei componenti nominati dalle sue voci di instradamento e prima dei sottomoduli che instrada, e un confine viene letto prima dei confini annidati al suo interno; i confini scritti uno accanto all’altro vengono letti nell’ordine in cui compaiono. Quando più di una collocazione precedente è in conflitto, viene nominata la prima letta. Entrambi i punti vengono nominati in qualunque ordine si presentino, e nessuno dei due è posto al di sopra dell’altro.

Messaggio emesso. La frase enuncia la regola; ciò che segue nomina la voce in errore, il confine in cui si trova ciascuna delle due collocazioni, il blocco in cui ciascuna è stata scritta e il file che le contiene entrambe. Quando una voce sotto il components: di un confine incontra una voce precedente sotto quello di un altro confine:

component declared in more than one boundary: declare each component in exactly one boundary (Release <name>, at <field-path>, "<component>", named in the components block of boundary "<boundary-b>", while it is already named in the components block of boundary "<boundary-a>", that earlier entry naming "<component>", both declared in "<path>") (componente dichiarato in più di un confine: dichiara ogni componente in esattamente un confine (Release; nominato nel blocco components di un confine, mentre è già nominato nel blocco components di un altro confine; entrambi dichiarati nello stesso file))

Le due proposizioni che nominano i confini sono formulate in base al blocco in cui è stata scritta ciascuna voce. La voce in errore assume una delle seguenti:

  • named in the components block of boundary "<boundary>" — la mappa components: del confine stesso;
  • named inside a routing entry in boundary "<boundary>" — la mappa components: di una voce di instradamento sotto aggregates: di quel confine;
  • routed as a sub-module into boundary "<boundary>" — la voce di instradamento stessa.

La collocazione precedente, proseguendo la stessa frase, assume una delle seguenti:

  • while it is already named in the components block of boundary "<boundary>";
  • while it is already named inside a routing entry in boundary "<boundary>";
  • while it is already placed by a sub-module routed into boundary "<boundary>".

Le due proposizioni sono scelte indipendentemente, quindi può comparire qualsiasi loro combinazione, e that earlier entry naming riporta ciò a cui si riferiva quella collocazione precedente: l’id del componente, oppure il prefisso del sottomodulo quando a collocarlo è stato un sottomodulo instradato.

Quando la voce in errore è essa stessa una voce di instradamento, ciò a cui si riferisce è un sottomodulo anziché un singolo componente, e il messaggio lo dice anziché presentare un prefisso di modulo come nome di componente — qui mentre incontra un sottomodulo precedente instradato in un altro confine:

component declared in more than one boundary: declare each component in exactly one boundary (Release <name>, at <field-path>, sub-module "<module>", routed as a sub-module into boundary "<boundary-b>", while it is already placed by a sub-module routed into boundary "<boundary-a>", that earlier entry naming "<module>", both declared in "<path>") (componente dichiarato in più di un confine: dichiara ogni componente in esattamente un confine (Release; sottomodulo instradato come sottomodulo in un confine, mentre è già collocato da un sottomodulo instradato in un altro confine; entrambi dichiarati nello stesso file))

Come risolvere: elimina quella delle due collocazioni che non intendevi. Il messaggio le nomina entrambe, quindi la scelta spetta a te anziché al compilatore. Quando una dichiarazione diretta e un modulo instradato non concordano, decidi se il componente appartiene al suo modulo o sta per conto proprio: instradare il modulo lo colloca insieme a tutto il resto che il modulo contiene, mentre nominarlo direttamente lo separa da essi. Quando due voci di instradamento rivendicano un solo modulo, elimina l’instradamento che non intendevi — instradare un modulo in un confine vi colloca ogni componente che contiene, quindi due voci di questo tipo rivendicano lo stesso insieme di componenti.

A Manifest annotation binding claims the reserved aggrega.ai/ prefix (Un binding di annotazione del Manifest rivendica il prefisso riservato)

Un Manifest dichiara un binding di annotazione sotto una chiave che inizia con il semplice prefisso aggrega.ai/. Quel prefisso è dove la build applica le chiavi che emette essa stessa, quindi un binding che rivendicasse una chiave al suo interno metterebbe il tuo instradamento e l’output della piattaforma stessa in un unico spazio delle chiavi, in competizione per gli stessi nomi.

Si arresta, e non potrebbe essere un avviso. La riserva è tutto ciò che rende quello spazio delle chiavi proprio della piattaforma; ammettere il binding e menzionarlo in seguito lascerebbe la collisione nella build.

La regola riguarda lo spazio delle chiavi che un binding scritto dall’autore rivendica, quindi una chiave per cui il Manifest presentato non dichiara alcun binding viene ignorata anziché segnalata — non c’è alcun binding che possa violarla.

Messaggio emesso. La chiave in errore viene per prima, perché è ciò di cui parla la frase, e i valori che seguono sono ciascuno introdotto da ciò che sono:

manifest annotation binding uses reserved prefix (Manifest, at <field-path>, "<key>", reserved prefix "aggrega.ai/", routing to Feature "<feature-uri>", author the binding under a domain of your own such as "feature.<your-domain>/") (il binding di annotazione del manifest usa un prefisso riservato (Manifest; prefisso riservato; instradamento verso una Feature; scrivi il binding sotto un dominio tuo))

Come risolvere: rinomina la chiave del binding in un namespace che controlli. Una chiave con sottoprefisso è la forma supportata e non è riservata: feature.aggrega.ai/… per una scorciatoia della libreria standard, oppure il tuo dominio — acme.aggrega.ai/…, compliance.example.com/… — per una aziendale. Rinominare la chiave cambia ciò che un autore scrive su un componente per attivare il binding, quindi aggiorna le annotazioni che lo usano con la stessa modifica. Le chiavi proprie della piattaforma sotto il semplice prefisso sono elencate in ../providers/well-known-annotations.md.

Two Manifest annotation bindings compete for one routing slot (Due binding di annotazione del Manifest competono per un unico slot di instradamento)

Due binding di annotazione in un unico Manifest instradano verso la stessa Feature, attraverso lo stesso pilastro, allo stesso percorso. Il compito di un binding è indicare dove finisce il valore di un’annotazione, e due binding che nominano un’unica destinazione lasciano il valore con due instradamenti e nulla per scegliere tra loro al momento dell’espansione.

Un solo binding può dichiarare una data coppia percorso-pilastro per ciascuna Feature di destinazione. Due binding che puntano alla stessa Feature su percorsi diversi sono normale scrittura e la build riesce; lo stesso vale per due binding che instradano lo stesso percorso verso due Features diverse.

I binding vengono percorsi nell’ordine in cui il Manifest li dichiara, quindi il binding che un messaggio nomina per primo è sempre quello precedente nel tuo documento.

Messaggio emesso:

manifest annotation bindings collide on same Feature path+pillar (Manifest, at <path>, annotation bindings "<first-key>" and "<second-key>" both target Feature "<feature-uri>" with path "<path>" routing to pillar "<pillar>"; only one binding may declare a given (path, pillar) pair per Feature) (i binding di annotazione del manifest collidono sullo stesso percorso+pilastro della Feature (Manifest; entrambi i binding di annotazione puntano alla Feature con un percorso che instrada verso il pilastro; un solo binding può dichiarare una data coppia (percorso, pilastro) per Feature))

Come risolvere: decidi quale binding possiede la destinazione e rimuovi il percorso dall’elenco maps.infra o maps.values dell’altro, oppure elimina del tutto il secondo binding. Se i due binding esistono perché volevi che due chiavi di annotazione raggiungessero un unico campo della Feature, mantieni un binding e lascia che entrambe le chiavi di annotazione passino attraverso di esso; se esistono perché due valori diversi dovevano finire in due posti, correggi il percorso scritto per errore.

A Release reached resolution without passing through the load path (Una Release ha raggiunto la risoluzione senza passare per il percorso di caricamento)

Una Release è arrivata alla risoluzione con sia una superficie components: di primo livello non vuota sia un confine default sintetizzato. Questa combinazione non può essere prodotta da una Release caricata normalmente: il percorso di caricamento fa confluire un blocco components: di primo livello nel confine predefinito e lo svuota, e un documento che li ha scritti entrambi esplicitamente viene rifiutato dal suo schema prima di arrivare fin qui.

Quindi questo arresto non segnala nulla di ciò che hai scritto. Segnala che qualcosa ha raggiunto la risoluzione aggirando il percorso di caricamento — il più delle volte una Release costruita in memoria da un programma che incorpora il compilatore anziché letta da un file — e si ferma lì anziché lasciare che una build proceda su un documento le cui due superfici dei componenti non concordano. Leggerle in un ordine o nell’altro produrrebbe un output che omette o duplica silenziosamente dei componenti, e la visita dei confini e la visita per arco non concorderebbero nemmeno tra loro su quali.

Messaggio emesso:

release reached resolve un-normalized (non-empty root components alongside a synthesized default boundary): construct releases through the normalization core (types.NormalizeRelease via the load path), not a hand-built literal (la Release ha raggiunto la risoluzione senza essere normalizzata (componenti radice non vuoti accanto a un confine predefinito sintetizzato): costruisci le Releases attraverso il nucleo di normalizzazione (types.NormalizeRelease tramite il percorso di caricamento), non con un letterale costruito a mano)

Come risolvere: nulla, se stai scrivendo YAML — raggiungere questo arresto da aggrega build, aggrega validate o dall’editor significa che il compilatore ha un difetto che vale la pena segnalare, e la Release che stavi compilando non è in errore. Se stai incorporando il compilatore e costruisci un valore Release nel tuo codice, costruiscilo attraverso il percorso di caricamento anziché assemblare direttamente la struct, in modo che venga eseguita la normalizzazione che fa confluire i componenti radice nel confine predefinito.

A library reference expands into itself (Un riferimento a una libreria si espande in se stesso)

Una catena di riferimenti tra documenti torna a un documento che ha già raggiunto, quindi espanderla non terminerebbe mai. Due superfici di scrittura raggiungono la stessa condizione, ed entrambe sono catene tra entità di libreria anziché qualcosa all’interno di un singolo file: un $ref: da un pilastro schema verso una voce di una SchemaLibrary che, di riferimento in riferimento, torna indietro, e un $import: verso una voce di una MappingLibrary o di una WorkloadLibrary che fa lo stesso.

La catena viene confrontata su una chiave canonica — l’identità della libreria e il nome della voce, senza alcun host di registry né grafia della versione — così un ciclo non può sfuggire al controllo nominando la stessa voce in due modi diversi lungo il suo percorso. Un riferimento che si espande e termina va bene quante volte compaia e per quanto profonda sia la catena; la profondità da sola non causa mai questo arresto, e riutilizzare una voce di libreria da molti punti è lo schema per cui le librerie esistono.

Messaggio emesso, per una catena $import:, che nomina l’intero ciclo nell’ordine in cui è stato percorso, così puoi vedere quale passo lo chiude:

circular reference expansion: <Library>#/mappings/<entry> -> <Library>#/mappings/<entry> -> <Library>#/mappings/<entry> (espansione circolare dei riferimenti)

Una catena $ref: viene invece segnalata dal compilatore della forma compatta, che la inquadra con il documento e la parola chiave che stava leggendo:

compactform at <consumer-file> (keyword "$ref"): circular cross-document $ref expansion: <Library>#/schemas/<entry> -> <Library>#/schemas/<entry> -> <Library>#/schemas/<entry> (compactform, parola chiave: espansione circolare di $ref tra documenti)

Come risolvere: leggi la catena nel messaggio e interrompila al passo non voluto. Un ciclo di solito significa che due voci di libreria sono state scritte ciascuna per estendere l’altra; raccogli la parte comune in una terza voce a cui entrambe fanno riferimento, oppure incorporala in una delle due. L’ultimo passo mostrato è quello che ha chiuso il ciclo, ma non è necessariamente quello sbagliato — l’intera catena viene stampata proprio perché quale anello tagliare è una tua decisione.

La stessa condizione è alla base anche del rifiuto per ricorsione di ancore documentato sopra in «YAML anchor aliased inside its own content (Ancora YAML richiamata tramite alias all’interno del proprio contenuto)». Quello è un ciclo all’interno del testo di un singolo documento; questo è un ciclo tra documenti. La catena nel messaggio distingue i due a colpo d’occhio: un ciclo tra documenti nomina voci di libreria, e un ciclo all’interno di un documento nomina un’ancora.

A declared schema cannot be resolved (Uno schema dichiarato non può essere risolto)

Uno schema è arrivato al punto di essere usato per validare qualcosa e non è stato possibile assemblarlo in uno schema. La causa più comune è un $ref: che non nomina nulla di risolvibile; uno schema che non soddisfa il meta-schema JSON Schema arriva allo stesso arresto, così come un ramo then: o else: sotto una parola chiave condizionale che non può essere risolto da solo.

Il rifiuto avviene prima che qualcosa venga validato rispetto allo schema, e quell’ordine è il punto. Ignorare uno schema illeggibile lascerebbe non validato tutto ciò che copre mentre la build segnala successo — un controllo che ha smesso di funzionare senza nulla che dica che si è fermato.

Messaggio emesso, che nomina la posizione all’interno dello schema, la parola chiave che non è stato possibile risolvere e ciò che la risoluzione ha riportato:

validator/jsonschema: schema resolution failed (at <path-inside-the-schema>, keyword "<keyword>", <what resolution reported>) (validator/jsonschema: risoluzione dello schema non riuscita (posizione, parola chiave))

Quando l’errore è alla radice dello schema anziché a una parola chiave al suo interno, la posizione e la parola chiave vengono omesse e la frase riporta solo il motivo segnalato.

Come risolvere: apri lo schema alla posizione indicata dal messaggio. Un $ref: è il solito colpevole: verifica che la destinazione esista, che un riferimento interno al documento scriva esattamente il suo percorso #/$defs/… e che un riferimento tra documenti nomini una voce di una SchemaLibrary effettivamente contenuta nella chiusura delle dipendenze della build. Quando il messaggio nomina un ramo then: o else:, quel ramo è uno schema a pieno titolo e deve essere risolvibile di per sé.

An x-aggrega-when: or x-aggrega-validate: predicate cannot be evaluated (Un predicato non può essere valutato)

Uno schema dichiara una delle due parole chiave di estensione il cui valore è un template, e il template non è stato utilizzabile: non è una stringa, non viene analizzato come template, ha fallito durante l’esecuzione oppure ha prodotto qualcosa di diverso da true o false.

x-aggrega-when: decide se un ramo condizionale di uno schema si applica; x-aggrega-validate: decide se un valore soddisfa una regola che le parole chiave dello schema stesso non sono in grado di esprimere. Entrambe sono lette come verdetti, ed è per questo che un risultato che non lo è viene rifiutato anziché interpretato: un predicato che producesse una stringa vuota verrebbe letto come falso e ritirerebbe silenziosamente la regola che era stato scritto per far rispettare.

Messaggio emesso:

validator/jsonschema: x-aggrega extension evaluation failed (at <path-inside-the-schema>, keyword "x-aggrega-validate", <what evaluation reported>) (validator/jsonschema: valutazione dell’estensione x-aggrega non riuscita)

con "x-aggrega-when" al posto della parola chiave quando a essere in errore è il predicato del condizionale, e con il motivo riportato che indica l’errore del template — una posizione di analisi, una funzione mancante o il valore non booleano prodotto dal template.

Come risolvere: apri lo schema nella posizione indicata dal messaggio e leggi il motivo riportato. Verifica che il valore della parola chiave sia una stringa, che il template venga analizzato correttamente e che ogni percorso che attraversa esista davvero nel valore sottoposto a validazione — un predicato legge il valore come .value, e cercare qualsiasi altra cosa è l’errore più comune. Se il motivo indica una chiave che index non ha trovato, verifica invece la presenza della chiave con hasKey oppure leggila con get: index si arresta su una chiave che la mappa non contiene, come descritto più avanti in «A template indexes a map with a key the map does not hold (Un template indicizza una mappa con una chiave che la mappa non contiene)». Assicurati che il template termini producendo true o false: un confronto lo fa, mentre un template che si limita a renderizzare il valore no.

A Workload does not satisfy the Workload schema (Un Workload non soddisfa lo schema Workload)

Il blocco workload: di una Recipe o di una FeatureRecipe è stato letto e verificato rispetto allo schema Workload, e uno o più campi non lo soddisfano — una chiave scritta in modo errato, un valore del tipo sbagliato, un campo obbligatorio omesso, un valore fuori da un intervallo o da un’enumerazione dichiarati.

La segnalazione è raggruppata: un solo arresto riporta ogni campo in errore, così un Workload con quattro errori te li segnala tutti e quattro in una sola build anziché uno per build. L’intestazione indica il Workload, la Recipe che lo dichiara e il file; ogni rilievo sotto di essa indica il percorso del campo all’interno del Workload, ciò che lo schema richiedeva in quel punto e la correzione, dove è possibile indicarla.

Messaggio emesso:

workload validation failed (Workload in Recipe <name>:<version>, at <path>, schema stage): .containers.<name>.<field>: <what the schema required> — <the fix, where one can be stated> .initContainers[<i>].<field>: <what the schema required> — <the fix, where one can be stated> (validazione del carico di lavoro non riuscita (Workload nella Recipe, fase dello schema))

Un errore privo di dettaglio per campo — il blocco non è stato affatto leggibile, anziché essere letto e trovato carente — riporta invece l’intero motivo come unico rilievo.

Quando il template workload: legge un valore dichiarato sensibile, nessun rilievo cita un valore. Non è possibile stabilire quale campo del documento renderizzato provenga da quel valore, quindi ogni rilievo il cui testo potrebbe contenere un valore enuncia il vincolo dello schema con <redacted> al posto del valore, chiuso da un avviso che ne indica il motivo, e non riporta alcuna correzione derivata dal valore:

.containers.main.imagePullPolicy: against /$defs/container: enum: <redacted> does not satisfy enum ["Always","Never","IfNotPresent"] (the value is withheld because the template that rendered this document reads a value declared sensitive)

Un rilievo che non cita alcun valore — una chiave mancante, una chiave che il Workload non ammette — si legge come per qualsiasi altro template. Vedi vocabulary/compact-form-authoring.md «Che cosa dice un rifiuto su un valore dichiarato».

La build segnala l’arresto con un tag CATALOG_ERROR, perché un blocco workload: è scritto dall’autore della Recipe e non dall’Aggregate o dalla Release.

Come risolvere: apri la Recipe nei percorsi dei campi elencati e correggili uno per uno. I percorsi partono dalla radice del Workload stesso, quindi .containers.main.health.ready è il blocco ready sotto la chiave health del container main. Un container con nome si indica con la sua chiave e un init container con la sua posizione, ed è per questo che i due si leggono in modo diverso. Ciò che ogni campo accetta si trova nel riferimento per la scrittura del Workload.

Un campo che lo schema vuole come testo, rifiutato perché il valore è un numero o un booleano, indica quasi sempre un’espressione di template senza virgolette. Un blocco workload: viene renderizzato prima di essere verificato, quindi un’espressione scritta senza virgolette si espande in testo nudo e YAML legge poi quel testo per ciò che sembra. Una quantità di dimensionamento a core interi, una versione composta di sole cifre, una porta e le parole yes, no, on e off vengono tutte lette come qualcosa di diverso dal testo. Il rilievo indica quale tipo ha letto YAML, e il rimedio è mettere tra virgolette l’espressione nella Recipe — cpu: "{{ .infra.compute.cpu }}" anziché cpu: {{ .infra.compute.cpu }} — così il valore resta testo qualunque cosa fornisca l’operatore. Nota che il valore dell’operatore qui non è in errore e che metterlo tra virgolette nella Release non cambia nulla: le virgolette devono stare nella Recipe, attorno all’espressione.

A Workload attachment names a slot the entity does not declare, or a delivery the slot forbids (Un’associazione del Workload nomina uno slot che l’entità non dichiara, o una consegna che lo slot vieta)

Una voce attachments: di un container all’interno di un blocco workload: fa riferimento a uno slot di associazione, e il riferimento non corrisponde agli slot che il Component o la Feature dichiara nel proprio featuresSchema — oppure, per una voce che nomina una connessione con connection:, agli slot dichiarati dal socket di quella connessione. Una voce envFrom che nomina una connessione è soggetta alle stesse regole sulle connessioni. Il rilievo indica quale di questi casi hai davanti.

  • Lo slot non è dichiarato. Il campo from: della voce nomina uno slot che il featuresSchema dell’entità non contiene — un errore di battitura, o uno slot rinominato da una parte sola.
  • Lo slot è a scatola nera. Lo slot dichiara una allowlist inject: vuota, che riserva la consegna ai meccanismi interni della Recipe. Uno slot del genere viene riempito e consumato internamente, quindi un Workload non può accedervi.
  • La consegna è fuori dalla allowlist dello slot. Il campo as: della voce nomina un meccanismo che la lista inject: dello slot non consente.
  • La connessione non è una di quelle che il componente traccia. Il campo connection: della voce nomina un alias sotto cui non è scritta alcuna connessione del componente.
  • Il socket della connessione non dichiara lo slot. Il campo from: della voce (oppure, su envFrom, secret:) nomina uno slot che il socket attraverso cui è cablata quella connessione non dichiara.
  • Lo slot è scritto con il suo nome composto. Il campo from: (o secret:) della voce è il nome che l’associazione di una connessione assume sul componente — l’alias, un punto e lo slot — scritto senza connection:. Lo slot di una connessione si raggiunge solo nominando la connessione.

Tutte le voci in errore di tutti i container vengono segnalate insieme, così una sola build le nomina tutte. I rilievi sono raggruppati sotto un’unica intestazione che indica il Workload, la sua Recipe e il file.

Messaggio emesso:

workload featuresSchema cross-check failed (Workload in Recipe <name>:<version>, at <path>, featuresSchema stage): .containers.<name>.attachments.<KEY>.from: references slot "<slot>" which is not declared in the Component’s featuresSchema — either declare the slot in the Component (or Feature) featuresSchema, or rename the reference to an existing slot .containers.<name>.attachments.<KEY>.from: slot "<slot>" is blackbox (no inject: allowlist) and cannot be referenced from a Workload attachments entry — blackbox slots are delivered by Recipe-internal plumbing; remove the Workload-side reference, or widen the slot’s inject allowlist if Workload-side delivery is intended .containers.<name>.attachments.<KEY>.as: delivery mechanism "<as>" is not permitted by slot "<slot>" (inject allowlist: [<mechanisms>]) — use one of the allowlisted delivery mechanisms ([<mechanisms>]), or widen the slot’s inject allowlist in the Component/Feature featuresSchema .containers.<name>.attachments.<KEY>.connection: names connection "<alias>" for slot "<slot>", but the component draws no connection under that alias — name a connection the component draws (<aliases>), or remove connection to read a slot the Component declares for its own attachments .containers.<name>.attachments.<KEY>.from: names slot "<slot>" of connection "<alias>", which socket "<socket>" does not declare — name a slot socket "<socket>" declares (<slots>), or declare the slot in that socket’s featuresSchema .containers.<name>.attachments.<KEY>.from: names "<alias>.<slot>", the name the compiler composes for slot "<slot>" of connection "<alias>"; a slot a connection’s socket declares is named by naming the connection — write connection: <alias> beside from: <slot> (verifica incrociata del featuresSchema del carico di lavoro non riuscita (Workload nella Recipe, fase featuresSchema): fa riferimento a uno slot non dichiarato nel featuresSchema del Component — dichiara lo slot nel featuresSchema del Component (o della Feature), oppure rinomina il riferimento in uno slot esistente; lo slot è a scatola nera (nessuna allowlist) e non può essere referenziato da una voce attachments di un Workload — gli slot a scatola nera sono consegnati dai meccanismi interni della Recipe; rimuovi il riferimento lato Workload, oppure amplia la allowlist inject dello slot se la consegna lato Workload è voluta; il meccanismo di consegna non è consentito dallo slot (allowlist inject) — usa uno dei meccanismi di consegna consentiti, oppure amplia la allowlist inject dello slot nel featuresSchema del Component/Feature; nomina una connessione per lo slot, ma il componente non traccia alcuna connessione con quell’alias — nomina una connessione che il componente traccia, oppure rimuovi connection per leggere uno slot che il Component dichiara per le proprie associazioni; nomina uno slot di una connessione che il socket non dichiara — nomina uno slot che il socket dichiara, oppure dichiara lo slot nel featuresSchema di quel socket; nomina il nome che il compilatore compone per uno slot di una connessione; uno slot dichiarato dal socket di una connessione si nomina nominando la connessione — scrivi connection: accanto a from:)

Su una voce envFrom gli stessi rilievi si trovano in .containers.<name>.envFrom[<i>].connection e .containers.<name>.envFrom[<i>].secret.

Come risolvere: ogni rilievo nomina entrambi i lati, quindi la scelta è quale lato modificare. Per uno slot non dichiarato, correggi la grafia di from: oppure dichiara lo slot nel featuresSchema dell’entità — il suffisso .from del percorso del campo indica il riferimento. Per uno slot a scatola nera, rimuovi il riferimento lato Workload e lascia che sia la Recipe a consegnare il materiale, a meno che la consegna lato Workload non sia davvero voluta, nel qual caso assegna allo slot una allowlist inject:. Per un meccanismo rifiutato, cambia as: in uno di quelli che la allowlist nomina, oppure aggiungi il tuo alla allowlist. Per una connessione che il componente non traccia, correggi l’alias in uno di quelli elencati dal rilievo, oppure traccia la connessione nell’Aggregate o nella Release. Per uno slot che il socket non dichiara, nomina uno degli slot elencati dal rilievo, oppure dichiara lo slot nel featuresSchema del socket sul Component. Per un nome composto, scrivi la connessione e lo slot separatamente, come mostra il rilievo.

A Workload references a slot whose fill publishes no locator (Un Workload fa riferimento a uno slot il cui riempimento non pubblica alcun localizzatore)

Una voce attachments: di un container nomina uno slot per riferimento, e l’associazione che riempie quello slot non pubblica le chiavi provides che un riferimento del genere legge. Fare riferimento a uno slot per nome significa chiedere che la risorsa che esso rappresenta venga indirizzata nell’output renderizzato — tramite il nome della risorsa e tramite il campo al suo interno. Un riempimento che non pubblica né l’uno né l’altro non ha alcun localizzatore a cui puntare, quindi il riferimento non può essere trasformato in nulla.

Quali chiavi siano richieste dipende dalla voce, e il rilievo indica quali si aspettava. Una voce che nomina un proprio key: fornisce essa stessa il campo, quindi deve essere pubblicato solo il name della risorsa — ed è questo che le consente di fare riferimento a una risorsa con più chiavi. Una voce che non nomina alcun key: legge l’unico campo pubblicato dello slot, quindi devono essere presenti sia name sia key.

Il controllo verifica soltanto se le chiavi sono presenti; non ne esamina mai i valori. Tutte le voci in errore vengono segnalate insieme, sotto un’unica intestazione.

Messaggio emesso:

workload attachment slot is not referenceable (Workload in Recipe <name>:<version>, at <path>, slotReferenceability stage): .containers.<name>.attachments.<KEY>.from: slot "<slot>" is not referenceable: its resolved provides does not expose "<key>" (a workload attachment reference reads the provides keys name and key) — reference a slot filled by an attachment whose schema.provides declares the keys this reference reads, or deliver it through the slot’s inject pipe rather than a workload reference (lo slot di associazione del carico di lavoro non è referenziabile (Workload nella Recipe, fase slotReferenceability): lo slot non è referenziabile: i suoi provides risolti non espongono la chiave (un riferimento di associazione del carico di lavoro legge le chiavi provides name e key) — fai riferimento a uno slot riempito da un’associazione il cui schema.provides dichiari le chiavi lette da questo riferimento, oppure consegnalo tramite il canale inject dello slot anziché con un riferimento del carico di lavoro)

Come risolvere: due direzioni, e quale sia quella giusta dipende da ciò che intendevi. Se il riferimento è corretto, è l’associazione che riempie lo slot a dover cambiare: associa una Feature il cui schema.provides dichiari name — e key, se la voce non ne nomina uno proprio — così che esista un localizzatore a cui puntare. Se il materiale non doveva mai essere indirizzato per nome nell’output, elimina il riferimento e consegnalo invece tramite il canale inject: dello slot, che trasporta il valore anziché un puntatore al luogo in cui si trova.

A container gives one environment variable two values (Un container assegna due valori a una stessa variabile d’ambiente)

Un container di un blocco workload: nomina due volte la stessa variabile d’ambiente: una volta come chiave delle sue variables e una volta come chiave di una voce attachments consegnata as: env. Vengono controllati sia un container principale sia un init container, tanto nel Workload che la Recipe di un componente renderizza quanto nel Workload che renderizza una FeatureRecipe — quella associata a un componente come quella dichiarata in un confine — e il controllo legge il Workload così come lo ha renderizzato il suo template.

Perché si arresta invece di sceglierne uno. L’ambiente di un container viene scritto a partire da queste due raccolte in un ordine fisso — i provider helm e compose scrivono prima ogni voce letta da un’associazione e dopo di esse le semplici variables. Un nome scritto in entrambi i modi raggiungerebbe quindi il processo con il valore che quell’ordine fa prevalere, il che è una conseguenza di dove finiscono i due tipi e non di qualcosa che hai scritto tu, per cui la build rifiuta la coppia invece di renderizzarla. Il controllo viene eseguito una sola volta, qualunque provider renderizzi il Workload, dopo gli altri controlli del Workload e prima che vengano valutate le voci artifacts: o che il Workload venga passato a un qualsiasi provider, per cui una coppia rifiutata non viene mai renderizzata. Una voce attachments consegnata as: file viene montata come file invece di essere impostata nell’ambiente, per cui non forma mai una coppia.

Il controllo confronta solo i nomi; non legge mai un valore, per cui nessun rilievo ne riporta uno. Due tipi di voce d’ambiente restano fuori da ciò che confronta: una voce envFrom imposta le chiavi della ConfigMap o del Secret che nomina, che non sono note quando la build viene eseguita, e una voce che uno step della pipeline scrive in un documento renderizzato non fa parte del Workload che il controllo legge.

Ogni coppia è un rilievo a sé, posizionato sulla chiave workload: della Recipe o della FeatureRecipe che dichiara il Workload, e nomina la variabile e il container — un container principale per la sua chiave, un init container per la sua posizione nell’elenco initContainers. I rilievi arrivano prima per i container principali, nell’ordine in cui sono scritti, poi per gli init container in base alla posizione e, all’interno di un container, nell’ordine in cui sono scritte le sue voci attachments.

Messaggio emesso, per una coppia su un container principale del Workload di una Recipe. La categoria e il codice breve di questa condizione, E0345, ti arrivano nell’intestazione tra parentesi quadre, e la posizione si legge <path> at .spec.workload:

a container declares one environment variable twice ("<NAME>", container "<container>"). Rename one of the two, or write them under complementary template conditions so that only one of them renders (un container dichiara due volte una stessa variabile d’ambiente. Rinomina una delle due, oppure scrivile sotto condizioni di template complementari in modo che ne venga renderizzata una sola)

Una coppia su un init container nomina invece la sua posizione nell’elenco — init container "initContainers[<i>]" — e il rilievo di una FeatureRecipe nomina, dopo il container, l’associazione che la vincola, attachment "<attachment>", perché un componente può avere più associazioni le cui FeatureRecipes sono documenti separati.

Quando un Workload contiene più coppie, i rilievi vengono raggruppati sotto una riga che nomina il documento: containers of the Workload this Recipe renders name one environment variable twice oppure, per una FeatureRecipe, containers of the Workload rendered by the FeatureRecipe that attachment "<attachment>" binds name one environment variable twice.

La build segnala l’arresto sotto un tag CATALOG_ERROR, perché un blocco workload: è scritto dall’autore della Recipe o della FeatureRecipe e non dall’Aggregate o dalla Release.

Come risolvere: decidi quale delle due deve ricevere il container. Se le vuoi entrambe, rinominane una, così il processo vede due variabili. Se sono alternative — un semplice valore di ripiego per quando non è associata alcuna credenziale, per esempio — proteggile con condizioni complementari in modo che ne venga renderizzata esattamente una: scrivi la variabile sotto {{ if not (hasKey (default dict .features) "<slot>") }} e la voce attachments sotto {{ if hasKey (default dict .features) "<slot>" }}, oppure sotto i due rami di un unico {{ if }}/{{ else }}. Una coppia protetta in questo modo non raggiunge mai il controllo, perché nel Workload renderizzato c’è solo una delle due.

A Release’s parameters: block is written in neither of its two shapes (Il blocco dei parametri di una Release non è scritto in nessuna delle sue due forme)

Una Release soddisfa i parametri dichiarati da un Aggregate in uno di due modi, e il blocco viene letto in base alla sua forma. O è una mappa da nomi di parametri a valori scritti sul posto, oppure è una mappa con esattamente una chiave, $import:, il cui valore è il percorso di un file YAML che contiene quei valori. Un blocco che non è né l’una né l’altra cosa viene rifiutato al momento della lettura, prima che qualcosa confronti i valori con le dichiarazioni dell’Aggregate.

Vengono rifiutate tre forme. Un valore parameters: che non è affatto una mappa — uno scalare o un elenco. Una mappa che contiene $import: accanto ad altre chiavi, che chiede insieme i valori importati e quelli scritti senza dare alcuna regola per combinarli. E un $import: il cui valore non è una semplice stringa, che quindi non nomina alcun file.

Lo schema della Release dichiara le stesse due forme, per cui un file di Release che contiene una qualsiasi delle tre incontra prima il controllo dell’involucro del documento, sotto E0215, che prova entrambe le forme e dice perché ciascuna non è riuscita — qui per un elenco:

document envelope validation failed (Release, at <path>); <line>:<column>: spec.parameters: no oneOf branch matched (2 branches tried): branch[0]: type: expected object, got array; branch[1]: type: expected object, got array. correct the document to match its kind’s schema (convalida dell’involucro del documento non riuscita (Release); spec.parameters: nessun ramo oneOf corrisponde (2 rami provati): branch[0]: type: atteso object, trovato array; branch[1]: type: atteso object, trovato array. correggi il documento in modo che corrisponda allo schema del suo tipo)

Per $import: accanto a un’altra chiave il secondo ramo termina con additionalProperties: unexpected property: "<key>", e per un $import: scritto come elenco invece che come stringa termina con validation: type: array has type "array", want "string".

Messaggio emesso, quando il valore non è una mappa, che nomina ciò che vi è stato scritto — a list, per esempio:

parameters: shape must be an inline object or {$import: }: line <line>: <shape> is written where a map is expected (parameters: la forma deve essere un oggetto inline o {$import: percorso locale}: alla riga indicata il valore è scritto dove è attesa una mappa)

e quando $import: condivide la mappa con qualcos’altro, o nomina qualcosa che non è un percorso:

parameters: shape must be an inline object or {$import: }: $import: must be the only key (got <n> keys) at line <line> (parameters: la forma deve essere un oggetto inline o {$import: percorso locale}: $import deve essere l’unica chiave, trovate più chiavi alla riga indicata) parameters: shape must be an inline object or {$import: }: $import value must be a string scalar at line <line> (parameters: la forma deve essere un oggetto inline o {$import: percorso locale}: il valore di $import deve essere uno scalare stringa alla riga indicata)

Come risolvere: apri la Release alla riga indicata dal messaggio. Scrivi i valori sul posto sotto parameters:, oppure sostituisci l’intero blocco con un’unica voce $import: il cui valore è un percorso tra virgolette. Se volevi valori scritti e un file importato di valori predefiniti condivisi, sposta quelli scritti in una Release che con extends: estende quella che contiene l’importazione — sovrapporre più fonti di parametri è lo scopo di una catena extends:, e questa singola chiave viene letta da un’unica fonte per scelta progettuale.

An inline-or-import field is written in neither shape (Un campo inline o import non è scritto in nessuna delle due forme)

Tre campi che una Recipe o una FeatureRecipe scrive — una voce artifacts.<name>:, un valuesMapping: e un workload: — accettano le stesse due forme. O il corpo è scritto sul posto, come scalare stringa (un blocco | è la grafia abituale per qualsiasi cosa su più righe), oppure il valore è una mappa con esattamente una chiave, $import:, che nomina invece dove si trova il corpo. Ciò che un $import: può nominare cambia a seconda del campo: una voce di artifacts importa un percorso locale o un bundle da un’ArtifactLibrary, mentre valuesMapping: e workload: importano un percorso locale o una voce da una libreria per identità.

Un unico lettore li controlla tutti e tre, per cui i rifiuti sono gli stessi tre qualunque sia il campo in errore: una mappa che contiene più di una chiave, una mappa la cui unica chiave non è $import e un $import: il cui valore non è una semplice stringa. Un valore che non è né uno scalare né una mappa — il più delle volte un elenco — viene rifiutato per la sola forma.

Gli schemi di Recipe e FeatureRecipe dichiarano le stesse due forme per ciascuno dei tre campi, per cui un file che contiene uno qualsiasi di questi casi incontra prima il controllo dell’involucro del documento, sotto E0215, che nomina il campo e dice perché ciascuna forma non è riuscita — il primo ramo è la forma scritta sul posto, il secondo quella con $import::

document envelope validation failed (Recipe, at <path>); <line>:<column>: spec.artifacts.<name>: no oneOf branch matched (2 branches tried): branch[0]: validation: type: object has type “object”, want “string”; branch[1]: additionalProperties: unexpected property: “<key>”. correct the document to match its kind’s schema (convalida dell’involucro del documento non riuscita (Recipe); spec.artifacts: nessun ramo oneOf corrisponde (2 rami provati): branch[0]: convalida: type: object ha tipo «object», atteso «string»; branch[1]: additionalProperties: proprietà inattesa. correggi il documento in modo che corrisponda allo schema del suo tipo)

Quella è una mappa che contiene una chiave accanto a $import:. Una singola chiave che non è $import termina con required: missing required property: $import, additionalProperties: unexpected property: "<key>", un elenco termina con type: expected object, got array, e un $import: che non è una stringa nomina il tipo trovato dove era attesa una stringa, come in type: array has type "array", want "string".

Messaggi emessi. Ciascuno si apre con la frase relativa al campo in errore, poi dice che cosa ha trovato il lettore e dove:

artifacts entry: shape must be a string scalar or {$import: }: got <n> keys at line <line> (voce di artifacts: la forma deve essere uno scalare stringa o {$import: percorso locale}: trovate più chiavi alla riga indicata) valuesmapping: shape must be a string scalar or {$import: }: got key "<key>" at line <line> (valuesmapping: la forma deve essere uno scalare stringa o {$import: percorso o identità di libreria}: trovata un’altra chiave alla riga indicata) workload: shape must be a string scalar or {$import: }: $import value must be a string scalar at line <line> (workload: la forma deve essere uno scalare stringa o {$import: percorso o identità di libreria}: il valore di $import deve essere uno scalare stringa alla riga indicata)

Ciascuno dei tre campi può riportare una qualsiasi di queste chiusure; un valore che non ha nessuna delle due forme termina con line <line>: <shape> is written where text or a map is expected, nominando ciò che è stato scritto — il più delle volte a list.

Come risolvere: apri l’entità alla riga indicata dal messaggio. Scrivi il corpo sul posto come scalare a blocco, oppure sostituisci l’intero valore con un’unica voce $import:. Una mappa che contiene $import: e qualsiasi altra cosa non è una delle due forme — sposta le chiavi in più all’interno del file importato, oppure scrivi il corpo sul posto. Un $import scritto male — il più delle volte manca il $ — viene letto come una chiave ordinaria ed è segnalato come la singola chiave che non è $import.

A reference to a library entry carries whitespace (Un riferimento a una voce di libreria contiene spazi bianchi)

Un riferimento che nomina una voce all’interno di una libreria si scrive come un unico token ininterrotto: la libreria, una versione minima :<version> facoltativa, poi # e il percorso della voce — BaseWorkloads:1.0.0#/workloads/StatelessService. Nessuna sua parte ammette spazi bianchi. Sia i nomi delle librerie sia i nomi delle voci sono vincolati dagli schemi delle librerie a grafie da identificatore, e una versione è una versione, per cui uno spazio, una tabulazione o un a capo in qualsiasi punto di un riferimento non appartiene a nessuna delle tre parti.

Il rifiuto copre ogni superficie che indirizza una voce di libreria per identità: un valuesMapping:, un workload: e una voce artifacts.<name>: scritti come $import:, e un $ref: di uno schema. Un percorso locale scritto come $import: non contiene # e non è un riferimento a una voce di libreria, per cui un percorso che contiene uno spazio non viene toccato.

Ciò che rende opportuno rifiutarlo invece di sistemarlo è che la parte iniziale di un valore simile è di solito un riferimento a pieno titolo. Troncare in corrispondenza dello spazio bianco risolverebbe quel riferimento e scarterebbe silenziosamente il resto di ciò che l’autore ha scritto — e le due metà di una build non sono tenute a scartarne la stessa quantità, per cui una potrebbe registrare una dipendenza che l’altra non ha mai visto. Rifiutare fa sì che il valore significhi una sola cosa.

Il rifiuto viene segnalato alla riga del documento da cui è stato letto il riferimento:

library reference: a reference to a library entry carries no whitespace or line break: $import target "<reference>" at line <line> (riferimento di libreria: un riferimento a una voce di libreria non contiene spazi bianchi né a capo: destinazione di $import alla riga indicata)

Un riferimento raggiunge una build anche da un altro punto: il corpo di una voce di libreria che una build ha già risolto, in cui un $import: alla radice del campo, sulla prima riga, punta alla voce di un’altra libreria. Quel riferimento non è mai stato letto da un documento aperto dalla build, per cui viene segnalato senza una riga:

library reference: a reference to a library entry carries no whitespace or line break: "<reference>" (riferimento di libreria: un riferimento a una voce di libreria non contiene spazi bianchi né a capo)

Come risolvere: apri l’entità alla riga indicata dal messaggio e ricompatta il riferimento in modo che sia un unico token. La causa abituale è un a capo prima del # — un riferimento spezzato su due righe per rientrare in una colonna è per YAML un unico valore e qui un riferimento non valido, quindi scrivilo su una sola riga, per quanto lungo sia. L’altra è uno spazio finale prima della virgoletta di chiusura: finisce dentro la versione minima, dove nomina una versione che nessun artefatto pubblicato possiede. Per la seconda forma, il riferimento si trova nella libreria nominata subito prima di esso nel messaggio; correggilo dove quella libreria dichiara la voce.

A library entry’s body is not the shape that library holds (Il corpo di una voce di libreria non ha la forma che quella libreria contiene)

Una libreria pubblica corpi con nome che altre entità possono importare, e ogni tipo di libreria contiene una sola forma. Una voce di una MappingLibrary e una voce di una WorkloadLibrary contengono ciascuna un corpo di template, per cui il valore della voce è uno scalare — in pratica un blocco |. Una voce di un’ArtifactLibrary contiene un bundle: i file che stanno insieme sotto un unico nome, per cui la voce è una mappa dal nome del file di output al corpo di quel file, e ogni corpo al suo interno è uno scalare.

I corpi vengono acquisiti esattamente come sono scritti e non vengono analizzati quando la libreria viene caricata. Il template contenuto in un corpo viene analizzato nel punto in cui è importato, ed è per questo che qui si controlla solo la forma — un corpo che non è affatto un template si carica senza errori e fallisce nel punto in cui qualcosa lo renderizza.

Messaggi emessi, ciascuno dei quali nomina la riga e ciò che vi è stato scritto — a list, per esempio:

mappinglibrary: entry body must be a string scalar: line <line>: <shape> is written where text is expected (mappinglibrary: il corpo della voce deve essere uno scalare stringa: alla riga indicata il valore è scritto dove è atteso del testo) workloadlibrary: entry body must be a string scalar: line <line>: <shape> is written where text is expected (workloadlibrary: il corpo della voce deve essere uno scalare stringa: alla riga indicata il valore è scritto dove è atteso del testo) artifactlibrary: entry must be a mapping of filename to a string body: line <line>: <shape> is written where a map is expected (artifactlibrary: la voce deve essere una mappa dal nome del file a un corpo stringa: alla riga indicata il valore è scritto dove è attesa una mappa)

e, per un bundle la cui voce è una mappa ma uno dei cui file non è uno scalare, nominando il file:

artifactlibrary: entry must be a mapping of filename to a string body: file "<filename>": line <line>: <shape> is written where text is expected (artifactlibrary: la voce deve essere una mappa dal nome del file a un corpo stringa: nel file e alla riga indicati il valore è scritto dove è atteso del testo)

La build li segnala sotto un tag CATALOG_ERROR che nomina il file che stava leggendo, con la frase riportata sopra al di sotto.

Come risolvere: scrivi il corpo come scalare a blocco sotto la sua chiave. Un corpo la cui prima riga sembra una chiave YAML — come di solito accade per un template che produce YAML — viene letto come una mappa annidata se manca lo scalare a blocco, ed è questa la causa comune. Per un’ArtifactLibrary, scrivi una chiave per ogni nome di file di output, con ogni corpo come scalare a blocco a sé; un bundle scritto come un unico corpo è l’altro errore di forma comune.

A $instantiate: reference cannot be resolved (Un riferimento non può essere risolto)

Una SchemaLibrary può dichiarare strutture riutilizzabili sotto spec.templates, ciascuna con i propri $params, e una voce di schema ne istanzia poi una nominandola sotto $instantiate: e fornendone i parametri sotto $args:. La sostituzione è letterale: uno scalare $<name> nel corpo del template viene sostituito dal valore dell’argomento. Non c’è valutazione di espressioni, né condizionali né cicli, e un valore sostituito viene inserito così com’è, senza essere analizzato alla ricerca di ulteriori marcatori.

Tre errori causano il rifiuto dell’istanziazione. Il nome sotto $instantiate: non è uno di quelli che la libreria dichiara. Un parametro che il template dichiara senza un default: non ha alcuna voce sotto $args:. Oppure il valore di un argomento non è del tipo che il suo parametro dichiara — e una chiave di $args: che non nomina alcun parametro dichiarato viene segnalata allo stesso modo, anziché essere ignorata, così che un nome di argomento scritto male sia un rifiuto anziché un parametro che assume silenziosamente il valore predefinito.

Messaggi emessi:

schemalibrary: template not found: "<template-name>" not declared in spec.templates (schemalibrary: template non trovato: non dichiarato in spec.templates) schemalibrary: template parameter missing: "<parameter-name>" (template "<template-name>") (schemalibrary: parametro del template mancante) schemalibrary: template parameter type mismatch: <what the type check found> (schemalibrary: tipo del parametro del template non corrispondente) schemalibrary: template parameter type mismatch: argument "<argument-name>" is not declared in template "<template-name>"’s $params (schemalibrary: tipo del parametro del template non corrispondente: l’argomento non è dichiarato nei $params del template)

Come risolvere: per un template non trovato, correggi il nome con uno che la libreria dichiara sotto spec.templates — e verifica di importare la libreria che intendevi. Per un parametro mancante, aggiungilo a $args:, oppure assegna al parametro un default: nel template, così che i chiamanti possano ometterlo. Per una mancata corrispondenza di tipo, cambia l’argomento nel tipo dichiarato oppure amplia il type: del parametro; dove il messaggio nomina un argomento non dichiarato, correggine l’ortografia o rimuovilo.

A schema uses a JSON Schema keyword the library does not admit (Uno schema usa una parola chiave JSON Schema che la libreria non ammette)

$dynamicAnchor e $dynamicRef non sono ammessi nel contenuto di una SchemaLibrary. Rimandano la scelta dello schema a cui un riferimento si risolve fino al momento in cui il valore viene validato, il che fa dipendere il significato di una voce di libreria dal punto da cui è stata importata anziché da ciò che dice — e il compilatore risolve le strutture di una libreria prima di qualsiasi validazione, quindi non c’è nulla rispetto a cui un riferimento differito possa risolversi.

Il rifiuto viene applicato in tre punti, che insieme chiudono entrambe le vie da cui la parola chiave potrebbe arrivare. Una voce di schema viene analizzata al caricamento della libreria. Il corpo di un template viene analizzato al caricamento della libreria, così un template che contiene letteralmente la parola chiave fallisce in quel punto anziché nella prima build che lo istanzia. E il corpo sostituito viene analizzato di nuovo dopo un’istanziazione, così fornire la parola chiave come valore di un argomento non supera i primi due controlli.

Messaggio emesso:

schemalibrary: forbidden JSON Schema keyword: "$dynamicRef" at line <line> (schemalibrary: parola chiave JSON Schema vietata, alla riga indicata)

Come risolvere: sostituisci il riferimento differito con un $ref che nomini direttamente una voce di $defs. Dove la struttura varia davvero a ogni uso, esprimi la variazione come un template con $params e istanzialo per ogni uso — è la sostituzione che questa superficie offre, e si risolve prima che qualsiasi cosa venga validata rispetto al risultato.

A document nests deeper than the reader will descend (Un documento è annidato più in profondità di quanto il lettore scenda)

Ogni mappa scritta dall’autore viene letta in una struttura che conserva l’ordine in cui le sue chiavi sono state scritte, perché quell’ordine raggiunge l’output renderizzato ed è parte di ciò che rende una build identica byte per byte tra un’esecuzione e l’altra. Quel lettore scende per un numero limitato di livelli — cento — e si rifiuta di andare più a fondo, così un input che altrimenti esaurirebbe lo stack del lettore stesso viene segnalato come il rifiuto che è.

Messaggio emesso:

a document nests too many levels deep: it is read at most 100 levels deep (un documento è annidato su troppi livelli: viene letto fino a un massimo di 100 livelli di profondità)

Come risolvere: i documenti scritti realmente da un autore si annidano per pochi livelli, quindi un documento che ne raggiunge cento è generato, tradotto automaticamente o accidentalmente autoreferenziale. Cerca un valore che si è espanso in sé stesso — un’ancora YAML che fa riferimento al contenuto in cui si trova viene rifiutata dal proprio arresto più sopra, ma un generatore che emette ripetutamente la stessa struttura no. Dove la profondità è reale, sposta il ramo profondo in un’entità a sé e fai riferimento a essa per nome.

A provider declares a well-known annotation at a scope it does not render (Un provider dichiara un’annotazione well-known a un livello che non renderizza)

Un Plugin che serve un provider dice di sé due cose che devono concordare. Sotto spec.provider.wellKnownAnnotations elenca le annotazioni su cui agisce, ciascuna con i livelli a cui le legge. Sotto contract.inputKinds dice quali tipi di input renderizza in assoluto. Una chiave dichiarata a un livello il cui tipo di input la stessa entità non rivendica rappresenta quelle due affermazioni in contraddizione tra loro in un unico file, quindi l’entità viene rifiutata al caricamento.

Il controllo è un confronto dell’entità con sé stessa, ed è per questo che non richiede alcun binario del plugin e scatta ovunque l’entità venga letta — compresa una visita del catalogo su una macchina che non ha mai scaricato l’artefatto.

Due voci deliberatamente non vengono confrontate. Una voce a livello di confine non nomina alcun tipo di input, perché viene risolta una sola volta per un intero confine anziché sul percorso di rendering di un singolo nodo. Una voce che non dichiara alcun livello non fa alcuna affermazione per percorso: dice solo che il plugin legge la chiave da qualche parte.

Ciò che il rifiuto non stabilisce è che una dichiarazione lasciata in piedi sia vera. Nulla può dimostrare che il plugin che serve un provider legga una chiave che dichiara di leggere; ciò che un confronto tra due campi scritti dall’autore può fare è rifiutare la coppia di affermazioni che non possono essere entrambe vere. Una chiave dichiarata a un livello che il provider renderizza effettivamente, il cui plugin lì non legge nulla, qui passa.

Messaggio emesso:

provider "<plugin-name>" declares well-known annotation "<key>" at scope "<scope>", but its contract.inputKinds.<field> is not claimed; declare the key only at a scope the provider renders, or claim the input kind: wellKnownAnnotations: a key is declared at a scope the provider’s contract does not render (il provider dichiara un’annotazione well-known a un livello, ma il suo contract.inputKinds non è rivendicato; dichiara la chiave solo a un livello che il provider renderizza, oppure rivendica il tipo di input: wellKnownAnnotations: una chiave è dichiarata a un livello che il contratto del provider non renderizza)

Come risolvere: il messaggio nomina entrambe le metà. Rimuovi quel livello dall’elenco scope: dell’annotazione, lasciando i livelli che il provider renderizza effettivamente, oppure rivendica il tipo di input sotto contract.inputKinds se il provider lo renderizza davvero.

A compact-form schema uses a keyword the compact form does not know (Uno schema in forma compatta usa una parola chiave che la forma compatta non conosce)

Uno schema scritto in forma compatta contiene una chiave che non è né una parola chiave della forma compatta, né una delle parole chiave JSON Schema che la forma lascia passare, né uno dei tre marcatori che la forma riserva — $jsonschema:, $mode: e $ref:. Le chiavi sconosciute vengono rifiutate durante la lettura dello schema anziché scartate, perché un vincolo digitato male che viene ignorato non diventa alcun vincolo, e uno schema che sembra applicato e non applica nulla è peggio di uno che fallisce.

Il rifiuto si incontra ovunque venga compilato uno schema. Le voci di una SchemaLibrary vengono compilate al caricamento del catalogo; lo spec.schema di un Component, i suoi valueSchema e infraSchema per socket, e gli schemi che dichiarano una Feature e un Plugin provider vengono compilati alla lettura del catalogo. Lo spec.schema di un Component o di una Feature segnala questa condizione da sé, nominando l’entità e il campo; il valueSchema o l’infraSchema di un socket la segnala all’interno di «A declared schema contract cannot be read as a schema (Un contratto di schema dichiarato non può essere letto come schema)» più sotto, riportando come dettaglio la frase citata qui.

La frase del compilatore della forma compatta indica la posizione all’interno dello schema, la riga sorgente e la chiave che non ha riconosciuto:

compactform at <path-inside-the-schema>:<line> (keyword "<key>"): unknown keyword (compactform: parola chiave sconosciuta)

Una chiave scritta accanto a un $ref: tra documenti viene segnalata sotto la stessa condizione, con una frase propria, perché solo tre chiavi sorelle possono accompagnare un riferimento del genere:

compactform at <path-inside-the-schema>:<line> (keyword "<key>"): cross-document $ref sibling not allowed (allowed: properties, required, description) (compactform: chiave sorella di un $ref tra documenti non consentita (consentite: properties, required, description))

e, dove quella chiave sorella chiedeva di riaprire la struttura unita, la frase indica invece il modo per farlo:

compactform at <path-inside-the-schema>:<line> (keyword "additionalProperties"): cross-document $ref sibling not allowed (allowed: properties, required, description); use $jsonschema: to embed an open-object schema if the merged shape must accept arbitrary properties (compactform: chiave sorella di un $ref tra documenti non consentita (consentite: properties, required, description); usa $jsonschema: per incorporare uno schema a oggetto aperto se la struttura unita deve accettare proprietà arbitrarie)

La condizione sotto cui è registrata è compactform: unknown keyword, che è ciò a cui si risolve il suo codice breve.

Come risolvere: correggi la chiave nella posizione che la frase indica, confrontandola con il vocabolario delle parole chiave in compact-form-authoring.md — un errore di ortografia è la causa più comune. Dove la struttura richiede davvero una parola chiave JSON Schema che la forma compatta non contiene, scrivi quel frammento sotto $jsonschema:, che incorpora JSON Schema alla lettera. Accanto a un riferimento tra documenti, mantieni solo properties:, required: e description:; tutto il resto appartiene alla voce di libreria a cui il riferimento punta.

A compact-form schema declares a field literally named type (Uno schema in forma compatta dichiara un campo che si chiama letteralmente così)

La forma compatta decide che cosa significa una mappa dalla struttura del suo contenuto: una chiave type: indica una foglia di vincolo, le parole chiave strutturali di JSON Schema indicano un frammento da lasciar passare, e una mappa di nomi semplici indica un oggetto i cui figli sono schemi. Uno schema che dichiara un campo chiamato type è l’unica struttura che queste letture non riescono a distinguere — sembra una foglia di vincolo ed è inteso come un oggetto con un solo campo — quindi la forma chiede all’autore di dire quale delle due, con una chiave $mode: impostata a compact o jsonschema.

Questa condizione è ciò che segnala un $mode: scritto con qualsiasi altro valore. Il marcatore esiste per risolvere l’ambiguità, quindi un valore che non risolve nulla viene rifiutato anziché indovinato.

La frase del compilatore della forma compatta:

compactform at <path-inside-the-schema>:<line> (keyword "$mode"): value must be compact or jsonschema (compactform: il valore deve essere uno dei due indicati)

La condizione sotto cui è registrata è compactform: ambiguous dispatch — $mode required, che è ciò a cui si risolve il suo codice breve.

Come risolvere: imposta $mode: compact dove la mappa è un oggetto in forma compatta i cui campi includono per caso uno chiamato type, oppure $mode: jsonschema dove la mappa è un frammento JSON Schema da prendere così come è scritto. Dove nessuna delle due letture era voluta, rinominare il campo elimina l’ambiguità senza alcun marcatore.

A $jsonschema: escape carries content that is not a schema (Un escape contiene un contenuto che non è uno schema)

La chiave $jsonschema: incorpora alla lettera un frammento JSON Schema, per le strutture che la forma compatta non esprime. Ciò che incorpora viene preso così come è scritto e non viene mai tradotto, quindi deve essere uno schema: uno scalare a blocco che si analizza come YAML, oppure una mappa annidata. Un contenuto che non è né l’uno né l’altro viene rifiutato qui anziché essere trasmesso per essere usato nella validazione, dove l’errore verrebbe segnalato rispetto al consumatore dello schema anziché rispetto allo schema.

Quattro strutture vengono segnalate sotto questa condizione, e la frase dice quale hai. Il corpo di escape non si analizza come YAML. Il valore dell’escape non è né uno scalare a blocco né una mappa. Una chiave properties: contiene qualcosa che non è una mappa di nomi verso schemi. E, al livello più esterno, il documento passato al compilatore è vuoto oppure contiene un nodo per cui il lettore non ha alcuna regola.

Le frasi del compilatore della forma compatta:

compactform at <path-inside-the-schema>:<line> (keyword "$jsonschema"): escape content does not parse as YAML: <what the parse reported> (compactform: il contenuto dell’escape non si analizza come YAML) compactform at <path-inside-the-schema>:<line> (keyword "$jsonschema"): expected block-scalar string or nested mapping (compactform: attesa una stringa scalare a blocco o una mappa annidata) compactform at <path-inside-the-schema>:<line> (keyword "properties"): expected a mapping of property names to schemas (compactform: attesa una mappa di nomi di proprietà verso schemi) compactform: unsupported YAML node kind (compactform: tipo di nodo YAML non supportato)

La condizione sotto cui è registrata è compactform: $jsonschema content invalid, che è ciò a cui si risolve il suo codice breve.

Come risolvere: scrivi il corpo di escape come scalare a blocco sotto $jsonschema: — altrimenti un corpo la cui prima riga si legge come una chiave YAML viene assorbito nella mappa circostante, che è la causa comune — e verifica che ciò che contiene sia di per sé JSON Schema valido. Dove il frammento era abbastanza piccolo da essere espresso nella forma compatta, eliminare l’escape è la risposta più semplice.

A compact-form constraint does not apply to the type it was written on (Un vincolo in forma compatta non si applica al tipo su cui è stato scritto)

I vincoli in forma compatta vengono smistati in base al tipo dichiarato del campo: min: e max: diventano un limite numerico su un numero, un limite di lunghezza su una stringa e un limite di conteggio su un array. Quindi un vincolo deve trovarsi su un campo il cui tipo lo accetta, e il tipo deve essere un singolo valore perché lo smistamento abbia una risposta.

Quattro strutture vengono segnalate sotto questa condizione. Un vincolo scritto dove type: è assente o nomina un’unione, così che nulla decide quale limite si intendesse. Un vincolo scritto su un tipo che non accetta limiti di quel genere — un oggetto, o un booleano. Un type: il cui valore non è né un nome scalare né una sequenza di nomi. E un valuesType: a cui è dato qualcosa di diverso da un nome scalare.

Le frasi del compilatore della forma compatta:

compactform at <path-inside-the-schema>:<line> (keyword "<constraint>"): constraint applies to a single declared type (integer/number/string/array); type: is unresolved (union or absent) — narrow type: to a single value or remove this constraint (compactform: il vincolo si applica a un singolo tipo dichiarato (integer/number/string/array); il tipo non è risolto (unione o assente) — restringi il tipo a un singolo valore o rimuovi questo vincolo) compactform at <path-inside-the-schema>:<line> (keyword "<constraint>"): constraint applies to integer/number/string/array; declared type is <the type as written> (compactform: il vincolo si applica a integer/number/string/array; il tipo dichiarato è quello indicato) compactform at <path-inside-the-schema>:<line> (keyword "type"): expected a scalar type name or a sequence of type names (JSON Schema 2020-12 array-of-types); got unsupported node kind (compactform: atteso un nome di tipo scalare o una sequenza di nomi di tipo (array di tipi di JSON Schema 2020-12); trovato un tipo di nodo non supportato) compactform at <path-inside-the-schema>:<line> (keyword "valuesType"): expected a scalar type name (compactform: atteso un nome di tipo scalare)

La condizione sotto cui è registrata è compactform: constraint not valid for declared type, che è ciò a cui si risolve il suo codice breve.

Come risolvere: la frase nomina entrambe le metà — il vincolo e il tipo che ha incontrato. Restringi type: a un singolo nome dove contiene un’unione, aggiungilo dove manca, oppure elimina il vincolo dove il campo accetta davvero uno qualsiasi di più tipi. Un limite che deve variare con il tipo si esprime come un insieme di alternative sotto $jsonschema:, dove ogni ramo porta il proprio tipo e il proprio limite.

A $ref: is not written in a form the compiler can resolve (Un riferimento non è scritto in una forma che il compilatore sa risolvere)

Uno schema fa riferimento a un’altra struttura con $ref:, all’interno dello stesso documento oppure tra documenti diversi verso una voce di una SchemaLibrary. Due condizioni coprono i due modi in cui un riferimento fallisce, e la frase ti dice in quale ti trovi: il riferimento non è scritto in una forma che il compilatore legge, oppure è ben formato e nomina un obiettivo che non esiste.

Il riferimento non è leggibile. Il valore è vuoto, oppure la sua forma tra documenti non è <Library>#/schemas/<Entry>, oppure separa la versione con @ — caso che viene segnalato con la grafia corretta anziché con una lamentela generica, perché è l’errore che questa forma attira più spesso:

compactform at <path-inside-the-schema>:<line> (keyword "$ref"): expected a non-empty reference URL (compactform: atteso un URL di riferimento non vuoto) compactform at <consumer-document> (keyword "$ref"): cross-document $ref shape must be <LibraryName>#/schemas/<EntryName>: <the value as written> (compactform: un $ref tra documenti deve avere la forma indicata) compactform at <consumer-document> (keyword "$ref"): cross-document $ref version separator is ’:’, not ’@’ — use <the corrected value>: <the value as written> (compactform: il separatore di versione di un $ref tra documenti è ’:’, non ’@’ — usa il valore corretto)

La condizione sotto cui sono registrati è compactform: $ref unresolvable.

L’obiettivo non esiste. Il riferimento si legge correttamente e la libreria, o la voce al suo interno, è assente — oppure non è stato fornito alcun catalogo di librerie rispetto a cui risolverlo:

compactform at <consumer-document> (keyword "$ref"): SchemaLibrary <library> not found in catalog (referenced from <consumer-document>): <the value as written> (compactform: SchemaLibrary non trovata nel catalogo) compactform at <consumer-document> (keyword "$ref"): entry <entry> not found in SchemaLibrary <library>: <the value as written> (compactform: voce non trovata nella SchemaLibrary) compactform at <path-inside-the-schema>:<line> (keyword "$ref"): cross-document $ref but no SchemaLibrary catalog supplied: <the value as written> (compactform: $ref tra documenti, ma nessun catalogo di SchemaLibrary fornito)

La condizione sotto cui sono registrati è compactform: cross-document $ref target not found.

Tenere separati i due casi è ciò che rende la segnalazione utilizzabile: il primo è un valore da riscrivere nel documento che stai guardando, il secondo è una domanda su ciò che la build può vedere. Un riferimento che si espande in se stesso è ancora un’altra cosa, e viene segnalato come «A library reference expands into itself (Un riferimento a una libreria si espande in se stesso)» più sopra.

Come risolvere: per un riferimento illeggibile, riscrivi il valore — <Library>#/schemas/<Entry> per un riferimento tra documenti, #/$defs/<name> per uno interno allo stesso documento — e usa : prima di una versione minima anziché @. Per un obiettivo assente, verifica il nome della voce rispetto alla libreria che la pubblica, e verifica che la libreria sia raggiungibile dalla chiusura delle dipendenze della Release: una libreria da cui nulla dichiara di dipendere non viene caricata, quindi anche un riferimento corretto al suo interno non si risolve in nulla.

Quando la libreria si trova solo nella cache degli artefatti. La cache contiene ciò che vi è stato scaricato, e una libreria in cache conta come contenuto del catalogo solo dove una voce nel lockfile della Release ne garantisce il digest. Quando la cache contiene una SchemaLibrary che nessuna voce del lockfile fissa e che nessuna directory di catalogo fornisce, la segnalazione è seguita da una riga remediation: che nomina ciascuna di queste librerie e l’azione che funziona per il comando che l’ha segnalata:

  • aggrega build e aggrega validate --release leggono il lockfile della Release, quindi la loro riga nomina aggrega pull --release <release>, che risolve la libreria e ne registra la voce, oppure la scrittura della libreria sotto una directory di catalogo.
  • aggrega validate senza argomenti, e aggrega validate con il percorso di un’entità, che --release sia indicato o no, leggono le librerie solo dalle directory di catalogo e non leggono alcun lockfile, quindi una voce registrata non cambierebbe il loro verdetto. La loro riga lo dice, e rimanda alla scrittura della libreria sotto una directory di catalogo, oppure a aggrega pull --release <release> seguito da aggrega validate --release <release>, che verifica la Release rispetto alle librerie fissate dal suo lockfile.

Un pull che non trova una tale libreria lo segnala sotto A reference names no entity the catalog holds (Un riferimento non nomina alcuna entità contenuta nel catalogo), con una riga a sé.

A $ref: addresses a library by registry location (Un riferimento indirizza una libreria tramite la sua posizione nel registry)

Un $ref: tra documenti nomina la sua libreria per identità — il nome nudo della libreria, poi # e il percorso della voce — e mai tramite il registry su cui si trova a essere pubblicata. Attraverso quale registry si risolve un nome è una questione di configurazione del workspace, e quale versione si usa è la risposta del lockfile, quindi un riferimento che porta con sé un host fisserebbe nello schema due cose che spetta alla build decidere, e sposterebbe lo schema tra workspace come un riferimento rotto.

Dove il valore che contiene l’host si scompone comunque in una libreria e una voce, la frase riporta la grafia in forma di identità da usare al suo posto:

compactform at <consumer-document> (keyword "$ref"): cross-document $ref carries a registry host; reference the library by identity (use <Library>#/schemas/<Entry>): <the value as written> (compactform: il $ref tra documenti contiene un host di registry; fai riferimento alla libreria per identità)

e dove non lo fa, la frase termina dopo il valore:

compactform at <consumer-document> (keyword "$ref"): cross-document $ref carries a registry host; reference the library by identity: <the value as written> (compactform: il $ref tra documenti contiene un host di registry; fai riferimento alla libreria per identità)

La condizione sotto cui è registrato è compactform: cross-document $ref carries a registry host; reference the library by identity, che è ciò in cui si risolve il suo codice breve.

Come risolvere: elimina l’host e tutto ciò che precede il nome della libreria, lasciando <Library>#/schemas/<Entry>. Dove serve una versione minima, scrivila dopo il nome della libreria come :<version>. La stessa regola vale per i campi $import: di una Recipe e di una FeatureRecipe, che vengono segnalati separatamente sotto «A library $import: addresses its library by registry location (Un’importazione di libreria indirizza la sua libreria tramite la posizione nel registry)» più sotto.

A schema $import: cannot be applied (Non è possibile applicare un’importazione di schema)

Lo spec.schema di un Component o di una Feature — l’intero blocco o uno dei suoi pilastri — e il valueSchema: o l’infraSchema: di un socket usesSchema possono ciascuno essere scritti come $import: che nomina un file accanto all’entità. L’importazione viene applicata quando l’entità viene caricata, quindi ogni lettore successivo vede il contratto importato anziché il puntatore. Questa condizione è ciò che accade quando la colpa è di qualcosa che hai scritto: la direttiva stessa, o la struttura di ciò che il file da essa nominato si è rivelato contenere.

Questi errori sono un’unica condizione perché ciascuno lascia inutilizzabile la stessa superficie e ti dà la stessa cosa da fare — correggere la direttiva, o il file che nomina. La diagnostica si apre con la frase fissa e poi dice quale errore, quindi la frase è la parte su cui fare corrispondenza e la proposizione che segue è ciò su cui agire:

a schema $import: could not be applied. <surface>: <the clause for this occurrence> (non è stato possibile applicare un’importazione di schema)

La proposizione nomina la superficie che ha letto — spec.schema, uno dei suoi pilastri come spec.schema.values, oppure il valueSchema di un socket — seguita dall’errore specifico. Gli errori, e il significato di ciascuno:

  • $import: must be the only key when a schema is imported from a file. (L’importazione deve essere l’unica chiave quando uno schema viene importato da un file.) La direttiva condivide la sua mappa con contenuto di schema scritto dall’autore. $import: sostituisce un intero valore, quindi una chiave sorella non ha nulla con cui combinarsi.
  • $import: value must be a path to a file. (Il valore dell’importazione deve essere il percorso di un file.) Il valore è vuoto, oppure non è una singola stringa.
  • $import: takes a file path beside this entity, not a registry location <value>. (L’importazione accetta il percorso di un file accanto a questa entità, non una posizione in un registry.) Il valore indirizza un registry. Attraverso quale registry si risolve un nome è una questione di configurazione del workspace, quindi una superficie di schema non ne contiene mai uno; il messaggio nomina invece la forma di riferimento da usare.
  • $import: takes a file path beside this entity; reference the SchemaLibrary entry <value> with $ref: instead. (L’importazione accetta il percorso di un file accanto a questa entità; fai invece riferimento alla voce della SchemaLibrary.) Il valore indirizza una voce di libreria. A una voce di libreria si fa riferimento, non la si importa — $ref: è la parola chiave che ne risolve una.
  • imported schema <value> must be a YAML map of schema content; it is not. (lo schema importato deve essere una mappa YAML di contenuto di schema; non lo è.) Il file è stato trovato, letto e analizzato, e ciò che ne è risultato è uno scalare o una sequenza, quindi non c’è contenuto di schema da sostituire.

L’intestazione riporta la categoria e il codice breve di questa condizione, E0266, che è l’identificatore da registrare quando ti serve nominare questo arresto in modo duraturo — in un gate di integrazione continua, in una issue o in un runbook. Un numero viene assegnato una volta e poi resta fisso, quindi rimane lo stesso comunque migliori la formulazione attorno a esso; la tabella di tutte le condizioni lo risolve.

Una direttiva ben formata che nomina un file che la build non riesce a ottenere viene segnalata altrove, con un codice diverso. Un percorso che non si risolve, un file che non esiste o non può essere letto, e byte che non si analizzano come YAML non sono errori in ciò che hai scritto — non c’è alcun documento importato da giudicare — quindi vengono segnalati come il caricamento che sono, sotto «A file cannot be read, or its bytes do not parse (Un file non può essere letto, oppure i suoi byte non superano l’analisi sintattica)» più sopra, che documenta la proposizione che ciascuno di essi porta. Fai corrispondenza su quella condizione, e registrane il codice, quando ciò che stai intercettando è un file di importazione mancante o illeggibile.

Un percorso viene risolto rispetto alla directory che contiene il file dell’entità, la stessa base usata da ogni altro campo che porta un’importazione. Un’importazione il cui contenuto dichiara a sua volta un $import: viene seguita, e una catena che ritorna a un file già in elaborazione viene segnalata come «A library reference expands into itself (Un riferimento a una libreria si espande in se stesso)» più sopra anziché qui. Una direttiva scritta dentro un file portato da un’importazione viene segnalata in quel file e alla riga in esso, perché è lì che va la correzione; una direttiva scritta nell’entità viene segnalata nell’entità.

Come risolvere: rendi $import: l’unica chiave della sua mappa, e assegnagli un percorso relativo a un file YAML accanto all’entità il cui livello superiore sia una mappa di contenuto di schema. Per consumare una struttura pubblicata da una SchemaLibrary, usa invece $ref: <Library>#/schemas/<Entry> — a una voce di libreria si fa riferimento anziché importarla.

A schema block names a key that is not a data pillar (Un blocco di schema nomina una chiave che non è un pilastro dei dati)

Il blocco spec.schema di un Component o di una Feature contiene i pilastri dei dati dell’entità, e tre chiavi sono tutto ciò che ammette: values, la struttura che lo sviluppatore compila per ogni istanza; infra, il dimensionamento fisico che l’operatore fornisce; e provides, le chiavi che l’entità espone a chiunque la consumi. Questa condizione è ciò che accade quando il blocco contiene qualche altra chiave al suo livello superiore.

L’insieme è chiuso anziché aperto, per la stessa ragione per cui il contenuto di ciascun pilastro viene validato in modo chiuso: un blocco che enumera una superficie lecita rende un errore qualsiasi cosa al di fuori di essa. Una chiave che nulla riconosce porterebbe un contratto che nulla compila mai, usa per validare o consegna a un consumatore — quindi ciò che hai scritto sotto di essa sembrerebbe dichiarato e sarebbe inerte. Questo è più difficile da notare di un contratto che non hai mai scritto affatto, ed è per questo che si rifiuta il blocco anziché ignorare la chiave estranea.

La diagnostica si apre con la frase fissa, poi nomina l’entità, la regola, il punto in cui la chiave è stata scritta e cosa scrivere al suo posto:

a schema block declares a key that names no data pillar (<Kind> <name>, rule schema-pillars, at .spec.schema.<key>). rename "<key>" to one of the pillar keys, or remove it and the contract beneath it; allowed: values, infra, provides. See vocabulary/data-pillars.md for the canonical pillar set. (un blocco di schema dichiara una chiave che non nomina alcun pilastro dei dati, regola schema-pillars; rinomina la chiave in una delle chiavi dei pilastri, oppure rimuovila insieme al contratto sottostante; ammesse: values, infra, provides. Vedi vocabulary/data-pillars.md per l’insieme canonico dei pilastri.)

L’intestazione riporta la categoria e il codice breve di questa condizione, E0267, che è l’identificatore da registrare quando ti serve nominare questo arresto in modo duraturo — in un gate di integrazione continua, in una issue o in un runbook. Un numero viene assegnato una volta e poi resta fisso, quindi rimane lo stesso comunque migliori la formulazione attorno a esso; la tabella di tutte le condizioni lo risolve.

Due cose scritte in quella posizione non sono chiavi di questo insieme, e nessuna delle due viene segnalata qui. Un $import: che nomina un file accanto all’entità viene sostituito dal contenuto di quel file prima che il blocco venga letto, quindi ciò che questa condizione ispeziona è il livello superiore del documento importato stesso — una chiave estranea dentro il file importato viene segnalata qui, e la direttiva stessa mai. E un Component che dichiara extends scrive la stringa nuda inherited al posto del blocco, che è uno scalare privo di qualsiasi chiave.

Come risolvere: la frase nomina la chiave incontrata e le tre che ammette, quindi la causa più comune — un errore di battitura, o un singolare dove il nome del pilastro è plurale — è visibile dalla sola diagnostica. Dove il contenuto sotto la chiave estranea appartiene a un pilastro, spostalo sotto values:, infra: o provides: secondo la sua appartenenza; data-pillars.md indica quale pilastro possiede cosa. Dove era inteso come contenuto di schema a sé stante, appartiene a un livello più in profondità, dentro un pilastro, anziché accanto ai pilastri. Una struttura pubblicata da una SchemaLibrary si raggiunge con $ref: <Library>#/schemas/<Entry> scritto dentro un pilastro, non a livello del blocco.

A plugin asks the host to parse a source while a parse is already running for it (Un plugin chiede all’host di analizzare una sorgente mentre è già in corso un’analisi per suo conto)

Un plugin può chiedere all’host di analizzare una sorgente e restituirne il risultato, così che un plugin che ha bisogno di un documento in un certo formato non debba includere un lettore per quel formato. L’host esegue il plugin che produce l’analisi e restituisce ciò che ha prodotto. Questa condizione è ciò che accade quando il plugin raggiunto in quel modo chiede a sua volta un’analisi: la richiesta rientrerebbe nello stesso meccanismo all’interno del quale è già in esecuzione, e l’host rifiuta invece di scendere di un livello. Un solo livello è ciò che il meccanismo offre, e il rifiuto è ciò che lo mantiene a uno.

Il rifiuto raggiunge il plugin, non la build. L’host non si ferma lì per poi risalire lo stack; risponde alla chiamata con una busta di errore che contiene la frase riportata sotto e un codice che identifica il rifiuto, e il plugin che ha fatto la richiesta la riceve come risposta. Ciò che la build fa poi dipende da ciò che quel plugin fa con la risposta — un plugin che la tratta come fatale termina la build, uno che la segnala e prosegue no. Il rifiuto in sé è lo stesso in entrambi i casi.

Non è colpa di nessuno dei due plugin in particolare: la protezione copre qualunque coppia di plugin attraverso cui la richiesta è passata, anziché un singolo abbinamento specifico, quindi lo stesso rifiuto si incontra ovunque si rientri nel meccanismo.

Messaggio emesso, così come lo riceve il plugin:

aggrega_parse_source: producer-consumption re-entry denied: a producer reached through the host may not issue a further producer-consumption call (rientro nel consumo del produttore negato: un produttore raggiunto tramite l’host non può effettuare un’ulteriore chiamata di consumo del produttore)

Come risolvere: niente nei tuoi file lo causa e nessuna modifica a ciò che scrivi lo elimina — è una proprietà dei plugin con cui la build è configurata. Il plugin da correggere è quello che chiede un’analisi dall’interno di un’analisi, quindi segnala la condizione a chi lo pubblica, citando il messaggio. Se quel plugin è tuo, fagli leggere direttamente la sorgente che gli è stata passata anziché chiedere all’host di analizzarne un’altra mentre sta esso stesso servendo un’analisi.

The workspace configuration is invalid (La configurazione del workspace non è valida)

Un workspace è descritto da un .aggrega-config.yaml nella sua radice: su quale registry pubblica e da quale scarica, dove si trova la cache degli artefatti, quali plugin sono associati a quali socket e qual è la posizione di ciascun registry riguardo alla firma. Quel file viene letto e verificato rispetto al suo schema prima che venga aperto qualsiasi file di entità, perché tutto ciò che segue viene letto da esso.

Un file mancante non è un errore. Un workspace senza file di configurazione riceve i valori predefiniti documentati, quindi questo arresto non nomina mai un file assente. Nomina il file che conteneva il valore — oppure, per un’impostazione che una variabile d’ambiente sovrascrive e che lo schema non vede mai, la variabile.

Il controllo viene eseguito prima che il documento sia trasformato in impostazioni tipizzate. È questo ordine che permette al messaggio di nominare il percorso del campo a cui lo schema ha obiettato, anziché segnalare una mancata corrispondenza di tipo da un punto successivo, senza alcun campo da indicare.

Queste strutture vengono segnalate qui oltre a una semplice obiezione dello schema, ciascuna perché lo schema da solo può dire soltanto qualcosa di troppo generico per poterci agire: una chiave workspace: scritta senza nulla sotto, una chiave il cui posto è il livello superiore scritta invece sotto workspace:, un blocco cache: scritto con un nome che il file non usa, un host di registry non scritto nel modo in cui si scrive un host di registry, e tre impostazioni i cui valori lo schema ammette ma il workspace non può usare — un artifact_cache_dir assoluto o che nomina la radice stessa del workspace, una voce di signing.kinds che nomina qualcosa che non è un tipo di artefatto pubblicabile, e una voce di plugins.providers o providers_append il cui uri è una posizione di registry scritta con oci://. Un binding di provider nomina il suo plugin tramite la sua identità, provider/<name> con un :<version> facoltativo, perché è con quell’identità che il binding viene confrontato quando si risolve una capacità; una posizione di registry dice dove un plugin è pubblicato, non quale plugin sia, quindi una voce scritta in quel modo non potrebbe mai selezionare nulla. Anche una voce che nomina una funzione di ingresso con function: e nessun uri: viene segnalata qui, quando è una voce di plugins.linter o linter_append oppure una voce di plugins.governance o governance_append in un ruolo di verdetto, ir-verdict o render-verdict: queste associazioni selezionano il loro plugin tramite uri, quindi una voce del genere non associa alcun plugin e la funzione che nomina non verrebbe mai chiamata — un lint proseguirebbe come se la voce non ci fosse, e una build si fermerebbe solo più tardi, quando arrivasse a risolvere un plugin che la voce non ha mai nominato.

Anche una directory di catalogo elencata dalla configurazione — sotto workspace.catalog_dirs o catalog_dirs_append, oppure nella voce propria di una Release sotto workspace.releases, in qualsiasi file da cui la configurazione viene letta — viene segnalata qui quando non è una directory: al percorso non esiste nulla, oppure lì si trova un file o un link che non porta da nessuna parte. Viene valutata quando un catalogo sta per essere letto attraverso di essa, quindi ogni comando che legge il catalogo la rifiuta prima di leggere o scrivere qualsiasi cosa, mentre un comando che non legge alcun catalogo viene comunque eseguito. Proseguire senza di essa significherebbe compilare su meno cataloghi di quanti ne hai elencati, senza nulla che dica quali. Una directory elencata da AGGREGA_CATALOG_DIRS è soggetta alla stessa regola, e il rifiuto nomina la variabile al posto di un file.

Un host di registry — l’host di una voce di registries, oppure l’host con cui inizia default_registry quando non nomina una di quelle voci tramite il suo name:, nel qual caso sta per l’host di quella voce — si scrive come l’host stesso: in minuscolo, contenente un punto, oppure localhost, oppure un singolo nome seguito da una porta, oppure un indirizzo IP (uno IPv6 tra parentesi quadre), ciascuno con un :port facoltativo, e senza schema né credenziali. L’host di una voce di registries non porta alcun percorso; default_registry può far seguire al suo host / e un percorso di repository — segmenti in minuscolo uniti da /, senza tag, digest né / finale. Un valore che nomina un host con un’altra grafia viene rifiutato indicando la grafia da scrivere — per default_registry, l’intera posizione, percorso incluso — così che gli si applichi la policy di fiducia tenuta sotto quell’host; ciò include la porta 443 su un host raggiunto tramite HTTPS, poiché è la porta predefinita di quell’host. Un percorso che non è un percorso di repository viene rifiutato indicando l’host a cui segue, e il name: di una voce seguito da un percorso viene rifiutato indicando le due grafie da scrivere al suo posto, il solo nome oppure l’host della voce seguito dal percorso, poiché un nome sta per l’host della sua voce e non per una posizione al suo interno. Un valore che non nomina alcun host — un singolo nome senza porta che nessuna voce porta, un testo con spazi o parentesi graffe — viene rifiutato come non host, e per default_registry il rifiuto dice che andrebbe bene anche il nome di una voce. AGGREGA_DEFAULT_REGISTRY è soggetto alla stessa lettura e viene rifiutato allo stesso modo, nominando la variabile.

Messaggi emessi. Un’obiezione dello schema nomina il file, il percorso del campo e ciò che lo schema ha detto:

workspaceconfig: <path>: <field-path>: <the schema's own objection>: workspace configuration is invalid (la configurazione del workspace non è valida)

Le forme con indicazione di correzione si aprono con il file e, al posto del percorso del campo e dell’obiezione dello schema, dicono una frase sulla struttura specifica. Un artifact_cache_dir che nomina la radice del workspace:

<path>: artifact_cache_dir "<value>" names the workspace root itself; a catalog directory at the workspace root would then be stepped over as cache, leaving nothing to load — give the cache its own subdirectory (for example .aggrega/cache): workspace configuration is invalid (artifact_cache_dir nomina la radice stessa del workspace; una directory di catalogo nella radice del workspace verrebbe allora scavalcata come cache, senza lasciare nulla da caricare — assegna alla cache una sua sottodirectory: la configurazione del workspace non è valida)

una voce di signing.kinds inutilizzabile, che nomina anche il carattere jolly che copre ogni tipo:

<path>: signing.kinds entry "<kind>" is not a signable artifact kind; use a catalog entity or plugin kind, or "all" for every kind: workspace configuration is invalid (la voce di signing.kinds non è un tipo di artefatto firmabile; usa un tipo di entità di catalogo o di plugin, oppure il carattere jolly per ogni tipo: la configurazione del workspace non è valida)

un binding di provider scritto come posizione di registry, che nomina la voce, la capacità e la forma da scrivere:

<path>: plugins.providers[<n>] binds capability "<capability>" to "oci://<registry>/<repository>", which is where a plugin is published rather than which plugin it is; a provider binding names its plugin by its identity — write uri: provider/<name>, with an optional :<version>: workspace configuration is invalid (plugins.providers lega la capacità a una posizione, che indica dove un plugin è pubblicato anziché quale plugin sia; un binding di provider nomina il suo plugin tramite la sua identità — scrivi uri con l’identità del provider, con una versione facoltativa: la configurazione del workspace non è valida)

un’associazione di linter o di governance in ruolo di verdetto che nomina una funzione di ingresso e nessun plugin, il cui messaggio nomina l’elenco, la voce e la funzione, qui su plugins.linter:

<path>: plugins.linter[<n>] names the entry function "<function>" but no plugin uri; an attachment on this list selects its plugin by uri, so this one attaches no plugin and "<function>" is never called — add the uri of the plugin that exports it: workspace configuration is invalid (plugins.linter nomina la funzione di ingresso ma nessun uri di plugin; un’associazione in questo elenco seleziona il suo plugin tramite uri, quindi questa non associa alcun plugin e la funzione non viene mai chiamata — aggiungi l’uri del plugin che la esporta: la configurazione del workspace non è valida)

un host di registry scritto con un’altra grafia, qui HUB.AGGREGA.AI:

<path>: default_registry "HUB.AGGREGA.AI" is not written as the registry host it names; write "hub.aggrega.ai" — lowercase, with no scheme, path, credentials or default port — which is the spelling that host’s trust policy is kept under: workspace configuration is invalid (default_registry non è scritto come l’host di registry che nomina; scrivilo — in minuscolo, senza schema, percorso, credenziali né porta predefinita — che è la grafia sotto cui è tenuta la policy di fiducia di quell’host: la configurazione del workspace non è valida)

un registry predefinito il cui host è scritto con un’altra grafia prima del suo percorso di repository, qui GHCR.io/acme, il cui messaggio nomina l’intera posizione da scrivere:

<path>: default_registry "GHCR.io/acme" is not written as the registry location it names; write "ghcr.io/acme" — the registry host lowercase, with no scheme, credentials or default port, followed by the repository path — which keeps that host’s trust policy applying to it: workspace configuration is invalid (default_registry non è scritto come la posizione di registry che nomina; scrivila — l’host del registry in minuscolo, senza schema, credenziali né porta predefinita, seguito dal percorso di repository — il che fa sì che la policy di fiducia di quell’host continui ad applicarsi: la configurazione del workspace non è valida)

il nome di una voce seguito da un percorso, qui local/acme dove la voce chiamata local è per 127.0.0.1:5000:

<path>: default_registry "local/acme" is the name of the registries entry "local" followed by a path, and an entry’s name stands for that entry’s host alone; write "local" to use the entry, or its host followed by the path, "127.0.0.1:5000/acme": workspace configuration is invalid (default_registry è il nome della voce di registries seguito da un percorso, e il nome di una voce sta solo per l’host di quella voce; scrivi il solo nome per usare la voce, oppure il suo host seguito dal percorso: la configurazione del workspace non è valida)

un valore che non nomina alcun host, la cui frase elenca le forme che un host assume:

<path>: registries[<n>].host "<value>" is not a registry host; write a lowercase host name containing a dot (registry.example.com), localhost, a single name followed by a port (registry:5000), or an IP address, an IPv6 one in brackets — each with an optional :port and nothing else: workspace configuration is invalid (l’host della voce di registries non è un host di registry; scrivi un nome host in minuscolo contenente un punto (registry.example.com), localhost, un singolo nome seguito da una porta (registry:5000), oppure un indirizzo IP, uno IPv6 tra parentesi quadre — ciascuno con un :port facoltativo e nient’altro: la configurazione del workspace non è valida)

una directory di catalogo elencata in cui non esiste nulla, il cui messaggio nomina il file e la riga, l’elenco, la voce così come è scritta e il percorso a cui è stata risolta — l’elenco è workspace.catalog_dirs, workspace.catalog_dirs_append, oppure l’elenco di una voce di Release come `catalog_dirs` of the `workspace.releases` entry "release.yaml":

<path>:<line>: the `workspace.catalog_dirs` entry "<entry>" names <directory>, which does not exist; create that directory, or remove the entry: workspace configuration is invalid (la voce di workspace.catalog_dirs nomina una directory che non esiste; crea quella directory, oppure rimuovi la voce: la configurazione del workspace non è valida)

e un marcatore workspace: vuoto:

workspaceconfig: <path>: workspace must be a mapping; write workspace: {} to mark a workspace root with no catalog directories: workspace configuration is invalid (workspace deve essere una mappa; scrivi una mappa vuota per contrassegnare una radice di workspace senza directory di catalogo: la configurazione del workspace non è valida)

Altri due nominano una chiave scritta nel posto sbagliato — default_registry, offline, auto_pull e artifact_cache_dir stanno tutte al livello superiore anziché sotto workspace:, e il blocco della cache delle analisi è parse_cache:. Ciascuno dice quale chiave intende e dove quella chiave va collocata.

Come risolvere: apri il file che il messaggio nomina e vai al percorso del campo che cita. Se il messaggio contiene una frase di correzione, nomina direttamente la grafia o la collocazione corretta e non serve leggere altro. Se invece contiene un’obiezione dello schema, il percorso del campo è la chiave in errore e l’obiezione dice che cosa lo schema si aspettava lì — le pagine delle entità non regolano questo file, quindi leggi l’obiezione anziché cercare un contratto di entità. Un artifact_cache_dir si scrive relativo alla radice del workspace e richiede una propria sottodirectory, così che una directory di catalogo nella radice del workspace non venga scambiata per cache e saltata. Un binding di provider scritto come posizione di registry si riscrive a mano con l’identità del plugin — oci://hub.aggrega.ai/plugin/provider/compose diventa provider/compose — perché ogni comando che legge il file lo rifiuta finché non viene riscritto, aggrega plugin remove compreso; aggrega plugin add provider scrive da sé la forma con l’identità. Una voce di linter o di governance in ruolo di verdetto che nomina una funzione e nessun plugin riceve l’uri del plugin che esporta quella funzione; se nessun plugin la esporta, rimuovi la voce — nell’elenco dei linter, il linter standard viene allora eseguito come quando non è configurato alcun linter. Una directory di catalogo elencata che non è una directory si crea al percorso che il rifiuto nomina, oppure la sua voce si rimuove dalla riga che il rifiuto nomina; una copia di un progetto presa senza un checkout affiancato che essa elenca rimuove quella voce.

A plugin binding sets a key the socket it attaches to does not read (Un binding di plugin imposta una chiave che il socket a cui si associa non legge)

I socket nella configurazione del workspace associano i plugin in due modi diversi, e una chiave che appartiene a un modo non significa nulla nell’altro. Invece di accettare la chiave e ignorarla in silenzio, la configurazione viene rifiutata, così un operatore apprende che l’impostazione è inerte invece di chiedersi più tardi perché non abbia avuto effetto.

Le due discrepanze sono l’una l’immagine speculare dell’altra.

  • Un socket trasversale legato per capacità. I socket di governance, di linter e di importer associano un plugin direttamente tramite uri:. Un plugin di governance o di linter non serve alcuna capacità, quindi un binding capability: in quel punto verrebbe cercato rispetto al nulla e non corrisponderebbe a nulla — un’associazione che non può mai risolversi. Un importer pubblicizza effettivamente i formati che gestisce, ma quale formato si desidera spetta all’importazione dirlo, non all’associazione: un’associazione di importer nomina il proprio importer tramite uri:, ed è questo a sceglierlo tra gli importer che pubblicizzano il formato richiesto da un’importazione.
  • Un socket del provider che imposta una chiave senza referente. Un binding del provider nomina una capacità e il plugin che la serve, e il plugin pilota un insieme fisso di export anziché un’unica voce selezionabile, quindi function: non vi nomina nulla. with: viene rifiutato per un motivo diverso: la configurazione di rendering per un provider si scrive nella Recipe, quindi metterla sul binding del workspace la colloca sul lato sbagliato della separazione tra sviluppatore e operatore.

Messaggi emessi. Una capacità su un socket trasversale:

workspaceconfig: the <socket> socket is bound by capability "<capability>", but the cross-cutting sockets attach by uri: their plugin serves no capability, so a capability lookup matches nothing; attach it with uri: instead: a cross-cutting socket is bound by capability but attaches by uri (il socket è legato per capacità, ma i socket trasversali si associano tramite uri: il loro plugin non serve alcuna capacità, quindi una ricerca per capacità non trova nulla; associalo invece tramite uri: un socket trasversale è legato per capacità ma si associa tramite uri)

un function: inerte su un binding del provider:

workspaceconfig: the provider socket binding for capability "<capability>" sets function:, but a provider drives a fixed set of phase-keyed exports rather than one selectable entry, so function: names nothing there; remove it: a provider socket binding sets a field with no referent on that socket (il binding del socket del provider per la capacità imposta questo campo, ma un provider pilota un insieme fisso di export legati alle fasi anziché un’unica voce selezionabile, quindi il campo non vi nomina nulla; rimuovilo: un binding del socket del provider imposta un campo senza referente su quel socket)

e un with: inerte, che viene segnalato con la stessa struttura e indica invece dove va la configurazione:

workspaceconfig: the provider socket binding for capability "<capability>" sets with:, but provider render configuration belongs in the Recipe, not the workspace provider binding; remove it: a provider socket binding sets a field with no referent on that socket (il binding del socket del provider per la capacità imposta questo campo, ma la configurazione di rendering del provider va nella Recipe, non nel binding del provider del workspace; rimuovilo: un binding del socket del provider imposta un campo senza referente su quel socket)

Un function: scritto in .aggrega-config.yaml non arriva alla frase riportata sopra: lo schema della configurazione del workspace non dichiara tale chiave su un binding del provider, quindi il file viene rifiutato prima, con E0224, e il rimedio è lo stesso — rimuovere la chiave:

workspaceconfig: <file>: plugins.providers[<index>].function: against /$defs/FixedEntryPluginRef: unexpected property: “function”: workspace configuration is invalid (plugins.providers[].function: rispetto a /$defs/FixedEntryPluginRef: proprietà inattesa: “function”: la configurazione del workspace non è valida)

Come risolvere: la correzione va fatta in .aggrega-config.yaml e ogni messaggio indica la modifica esatta. Su un’associazione di governance, linter o importer, sostituisci capability: con l’uri: del plugin che intendevi associare. Su un binding del provider, rimuovi la chiave indicata — e, se era with:, sposta quella configurazione nella Recipe che esegue il rendering tramite il provider, che è la superficie che la legge.

A capability is bound to more than one provider plugin (Una capacità è legata a più di un plugin provider)

Una capacità nomina un modo di trasformare un carico di lavoro in artefatti, ed esattamente un plugin la serve in un workspace risolto. Due binding per una stessa capacità non lasciano alcuna risposta su quale dei due esegua il rendering, e una configurazione del workspace è assemblata da più livelli — un file condiviso, un file del workspace e i file complementari di aggiunta che ciascuno può fornire — quindi il secondo binding è spesso fornito da un livello il cui autore non poteva vedere il primo.

Il rifiuto è ciò che lo rende visibile. Lasciare che un binding prevalga in silenzio farebbe dipendere l’output renderizzato da quale livello sia stato letto per ultimo.

Messaggio emesso, che nomina la capacità e la regola:

workspaceconfig: capability "<capability>" is bound to more than one provider plugin; keep exactly one plugins.providers entry per capability: capability is bound to more than one provider plugin (la capacità è legata a più di un plugin provider; mantieni esattamente una voce plugins.providers per capacità: la capacità è legata a più di un plugin provider)

Come risolvere: mantieni una sola voce plugins.providers per la capacità indicata dal messaggio e rimuovi l’altra. Se le due provengono da livelli di configurazione diversi, il livello da modificare è quello che controlli — rimuovere la tua voce adotta quella fornita dal livello condiviso, e mantenere la tua significa che deve sparire invece la voce del livello condiviso. Due plugin che servono davvero entrambi il workspace servono due capacità diverse, quindi, se li vuoi entrambi, assegna a ciascuno la propria capacità invece di legarne una due volte.

An importer is attached by more than one plugins.importer entry (Un importer è associato da più di una voce)

Una voce plugins.importer associa l’importer nominato dal suo uri: dove quell’importer pubblicizza il formato richiesto da un’importazione, la voce decide quale sua versione viene eseguita e gli passa i with.sources e i with.settings della voce. Una voce fa questo per un importer, quindi una seconda voce che nomina lo stesso importer — la stessa identità, alla stessa versione o a un’altra — non verrebbe letta da nulla, e il suo with non raggiungerebbe alcun importer senza che venga detta una parola. La configurazione viene invece rifiutata al caricamento, qualunque comando la legga.

Una configurazione del workspace è assemblata da più file — il file globale, ogni .aggrega-config.yaml dalla radice del progetto fino alla directory in cui viene eseguito un comando, il file complementare importer_append che ciascuno può avere e il .aggrega-config-append-ci.yaml di una pipeline — quindi la seconda voce è spesso scritta in un file diverso dalla prima. Il messaggio nomina l’importer ed entrambe le voci, prima la precedente, ciascuna con la chiave e la posizione sotto cui è scritta, il file in cui è stata scritta e il suo uri così come vi è scritto.

Viene giudicato solo l’elenco degli importer: gli elenchi di governance e di linter accettano un plugin associato più di una volta, con ciascuna associazione che porta il proprio with. Una voce il cui uri è un percorso del filesystem non nomina alcun importer, quindi non viene confrontata.

Messaggio emesso:

importer "<identity>" is attached by <key>[<position>] in <file> (uri "<uri>") and again by <key>[<position>] in <file> (uri "<uri>"); keep exactly one plugins.importer entry per importer, its uri naming the version you want: importer is attached by more than one plugins.importer entry (l’importer è associato da una voce in un file e di nuovo da una voce in un file; mantieni esattamente una voce plugins.importer per importer, con il suo uri che nomina la versione desiderata: l’importer è associato da più di una voce plugins.importer)

Come risolvere: mantieni una sola voce per l’importer indicato dal messaggio — quella il cui uri nomina la versione desiderata, con il with che vuoi passare a quell’importer — e rimuovi l’altra. Se le due si trovano in file diversi, il file da modificare è quello che controlli: rimuovere la tua voce adotta quella dell’altro file, e mantenere la tua significa che deve sparire invece la voce dell’altro file.

A provider binding names a capability containing a colon (Un binding del provider nomina una capacità che contiene i due punti)

Il capability: di una Recipe viene letto come il nome della capacità fino agli ultimi due punti e un vincolo di versione dopo di essi — helm:1.0.0 richiede la capacità helm alla versione 1.0.0. Una voce plugins.providers viene cercata con quel nome, quindi la capacità nominata da un binding non contiene mai i due punti, e una voce la cui capacità li contiene è una voce che nessuna Recipe può mai raggiungere. Invece di lasciarla nella configurazione senza che venga letta, la configurazione viene rifiutata al caricamento, qualunque comando l’abbia letta.

Viene giudicato solo l’elenco dei provider. L’elenco degli importer condivide la struttura delle voci, ma i suoi plugin sono associati tramite uri: e nominano i propri formati import:<format>, dove i due punti fanno parte del nome. L’uri: di un binding può comunque terminare con :<version>; non è la parte che questa regola legge.

Messaggio emesso, che nomina la capacità:

the provider socket binding for capability "<capability>": a Recipe’s capability reference is read as the capability up to its last colon and a version pin after it, so the capability a binding names carries no colon; bind the capability name alone and let each Recipe pin the version it needs: a provider socket binding names a capability containing a colon, which no Recipe can select (il binding del socket del provider per la capacità: il riferimento alla capacità di una Recipe viene letto come la capacità fino agli ultimi due punti e un vincolo di versione dopo di essi, quindi la capacità nominata da un binding non contiene i due punti; lega solo il nome della capacità e lascia che ogni Recipe vincoli la versione di cui ha bisogno: un binding del socket del provider nomina una capacità che contiene i due punti, che nessuna Recipe può selezionare)

Come risolvere: scrivi solo il nome della capacità nella voce — capability: helm — e vincola le versioni dove devono stare: una Recipe vincola la versione del provider di cui ha bisogno nel proprio capability:, e un binding che deve selezionare una particolare versione del proprio plugin la scrive sull’identità del plugin, uri: provider/helm:1.0.0.

A governance attachment declares no role, or one that is not a known role (Un’associazione di governance non dichiara alcun ruolo, o ne dichiara uno che non è un ruolo noto)

Un’associazione di governance porta un ruolo, ed è il ruolo — non il tipo dichiarato dal plugin stesso — a stabilire dove viene eseguita l’associazione e che cosa può fare: se accetta o rifiuta una build, e se legge il grafo o gli artefatti renderizzati. Le associazioni vengono smistate leggendo quel ruolo, quindi un’associazione che non ne porta alcuno, o ne porta uno che nessuno riconosce, non si associerebbe a nulla e verrebbe ignorata in silenzio.

Quel silenzio è ciò che il rifiuto previene. Un plugin di governance configurato e mai consultato produce esattamente l’output di una build mai sottoposta a governance, e nulla nel risultato dice quale delle due hai in mano.

Messaggi emessi, entrambi nominano l’associazione ed elencano i ruoli esistenti. Un ruolo mancante:

workspaceconfig: governance attachment "<uri>" declares no role; set role: to one of <the known roles>: a governance attachment declares no role or an unknown role (l’associazione di governance non dichiara alcun ruolo; imposta il ruolo su uno di quelli noti: un’associazione di governance non dichiara alcun ruolo o dichiara un ruolo sconosciuto)

e uno non riconosciuto:

workspaceconfig: governance attachment "<uri>" declares unknown role "<role>"; use one of <the known roles>: a governance attachment declares no role or an unknown role (l’associazione di governance dichiara un ruolo sconosciuto; usa uno dei ruoli noti: un’associazione di governance non dichiara alcun ruolo o dichiara un ruolo sconosciuto)

Come risolvere: imposta role: sull’associazione sotto plugins.governance su uno dei ruoli elencati dal messaggio. Quale scegliere è una decisione su che cosa vuoi che faccia il plugin, non sul plugin: un ruolo che accetta o rifiuta legge la build e restituisce un verdetto, e un ruolo che trasforma è un’istruzione esplicita a lasciare che il plugin modifichi ciò che riceve. Il messaggio elenca l’insieme completo, quindi la grafia da usare si trova nel messaggio stesso.

A registry alias matches more than one host (Un alias di registry corrisponde a più di un host)

A un registry si può assegnare un alias breve nella configurazione del workspace, così che comandi e riferimenti possano nominarlo senza scriverne per intero l’host. Un alias seleziona esattamente un host. Questa condizione è ciò che segnala un token che corrisponde all’alias di due voci di registry: non c’è risposta su quale host fosse inteso, e sceglierne uno invierebbe in silenzio gli artefatti a un registry che l’autore non ha nominato, o li scaricherebbe da esso.

Messaggio emesso, che nomina l’alias, quante voci lo hanno rivendicato e quali host sono:

registry alias "<alias>" matches <count> hosts (<hosts>); address the registry by host or remove the duplicate alias: registry alias matches more than one host (l’alias di registry corrisponde a più host; indirizza il registry tramite host o rimuovi l’alias duplicato: l’alias di registry corrisponde a più di un host)

Come risolvere: apri .aggrega-config.yaml e assegna l’alias a uno degli host elencati dal messaggio, oppure indirizza il registry tramite il suo host ed elimina l’alias dal riferimento. Il messaggio nomina ogni host che detiene l’alias, quindi quali voci esaminare si trova nel messaggio. Se le voci provengono da livelli di configurazione diversi, modifica il livello di tua proprietà.

The lockfile does not satisfy its schema (Il lockfile non soddisfa il proprio schema)

Il lockfile di una release registra ciò in cui si è risolta la build: per ogni entità, libreria e plugin che raggiunge, la versione selezionata e il digest dei byte a quella versione. Viene letto e verificato rispetto al proprio schema prima di essere trasformato in vincoli tipizzati, così un documento che non è conforme viene rifiutato con il percorso del campo in cui ha fallito, invece di produrre in silenzio vincoli con delle lacune.

Il lockfile è scritto dalla macchina. Viene prodotto dal pull che risolve una release, e viene sottoposto a commit così che la stessa build si risolva allo stesso modo in seguito. Per questo un errore di schema è quasi sempre una modifica a mano, un merge che ha lasciato il documento risolto a metà, o un lockfile scritto per una forma precedente del file — ad esempio uno le cui entities non portano alcun kind — anziché qualcosa scritto deliberatamente.

Un lockfile mancante è una condizione diversa e viene segnalato in modo diverso — il lockfile è obbligatorio, quindi la sua assenza viene segnalata dove la build lo cerca, con l’istruzione di eseguire il pull che lo crea.

Messaggio emesso, che nomina il file, il percorso del campo e l’obiezione dello schema stesso:

lockfile: <path>: <field-path>: <the schema's own objection>: lockfile: file failed schema validation (lockfile: lockfile: il file non ha superato la validazione dello schema)

Una build, e aggrega pull --verify, aggiungono il comando che riscrive il lockfile:

…: lockfile: file failed schema validation; run aggrega pull --release <release> to write it again from the Release (lockfile: il file non ha superato la convalida dello schema; esegui il comando per riscriverlo a partire dalla Release)

Un documento interamente vuoto viene segnalato a parte, poiché non c’è alcun campo da nominare:

lockfile: <path>: document is empty (lockfile: il documento è vuoto)

Come risolvere: non riparare il lockfile a mano. Esegui di nuovo il pull per la release, che riscrive il documento a partire dalla risoluzione che esegue, e sottoponi a commit il risultato — è la nuova risoluzione a produrre un documento i cui vincoli concordano con ciò che la release raggiunge effettivamente. Se l’errore è seguito a un merge, risolvere il conflitto ripetendo il pull invece di modificare a mano è ciò che evita un documento che viene analizzato correttamente ma vincola le versioni sbagliate. Vale la pena leggere per primo il percorso del campo nel messaggio: ti dice se il danno riguarda una sola voce o la struttura complessiva del documento.

Durante la risoluzione del catalogo

Dopo il caricamento, il compilatore percorre i due livelli del Manifest (mappa dei tipi, poi mappa dei nomi) per scegliere la Recipe di ogni Component, e percorre tutte le catene extends su Manifests, Components o Features. La catena extends propria di una Release è seguita dalla stessa visita, un passo prima: viene seguita mentre la Release viene risolta, prima che si cerchi il Manifest o l’Aggregate che essa nomina, così le condizioni seguenti vengono segnalate rispetto alla Release anziché rispetto a un puntatore fratello che la catena avrebbe dovuto fornire.

Cyclic extends chain (Catena extends ciclica)

Una catena di puntatori extends torna su sé stessa. Ogni tipo che dichiara extends — Component, Feature, Manifest e Release — viene percorso da un’unica visita della catena, quindi un ciclo viene segnalato con le stesse parole ovunque venga trovato.

Messaggio emesso. Si apre con la frase che nomina la condizione, poi l’entità da cui è partita la risoluzione e la regola che l’ha rifiutata, e poi l’arco che chiude il ciclo — l’entità che porta l’extends: incriminato e il riferimento che dichiara:

cyclic extends chain (<kind> <name>, rule extends). <entity> extends <reference>, which is already in the chain; remove the extends on <entity>, or point it at an entity outside the chain (catena extends ciclica (tipo e nome, regola extends). L’entità estende il riferimento, che è già nella catena; rimuovi l’extends sull’entità, o puntalo a un’entità fuori dalla catena)

L’entità nominata per prima e l’entità nominata nell’arco sono di solito diverse, ed è proprio questo il punto: un ciclo viene segnalato rispetto a ogni entità che vi appartiene, mentre la riga extends: da modificare è quella che l’arco nomina. Segui l’arco, non l’intestazione.

Per un Manifest, <kind> vale Manifest, ogni entità è nominata dal suo metadata.name, e <reference> è il valore di extends: esattamente come scritto — un percorso relativo come ./base.yaml, o il semplice metadata.name di un Manifest accanto alla Release. Quale delle due forme hai scritto non cambia ciò che viene segnalato: un anello di Manifest è il file in cui si risolve, quindi due file di Manifest che dichiarano per caso lo stesso metadata.name sono due anelli e una catena che passa per entrambi non è un ciclo.

Una Release si legge allo stesso modo, e lì il punto sull’identità del file conta di più perché la struttura che protegge è comune: <kind> vale Release, <reference> è il percorso relativo che extends: nomina, e un anello di Release è il file in cui si risolve. Due file di Release che nominano il sistema distribuito anziché l’ambiente — entrambi metadata.name: shared-release, uno che estende l’altro — sono due anelli, e una catena che passa per entrambi non è un ciclo.

Un ciclo viene segnalato come ciclo per quanto lungo sia. La visita della catena applica il suo limite di profondità solo a una catena che termina, quindi un ciclo che si estende su più entità di quante il limite ne consenta viene comunque segnalato qui anziché come catena troppo profonda — il rimedio per un ciclo non è mai accorciarlo.

Come risolvere: apri l’entità che l’arco nomina, e rimuovi il suo extends: oppure puntalo a un’entità che non sia già nella catena. Dove più livelli dovevano condividere contenuto, raccogliere il contenuto duplicato in un’unica entità di base rimuove insieme il ciclo e la duplicazione.

Recipe implements does not match the mapped component type (La dichiarazione di implementazione della Recipe non corrisponde al tipo di componente mappato)

La voce di mappatura del Manifest punta a una Recipe la cui dichiarazione spec.implements: non corrisponde alla chiave di tipo di componente di quella voce di mappatura. spec.implements è un’ancora di coerenza anziché un meccanismo di dispatch: il valore della mappatura nomina direttamente la Recipe, e questo controllo conferma che la Recipe nominata dall’autore sia una che dichiara il tipo che ha mappato.

Il controllo legge il Manifest composto prima che qualsiasi Recipe venga risolta, quindi segnala la voce di mappatura scritta dall’autore anziché un suo sintomo a valle.

Messaggio emesso:

manifest mapping entry’s recipe spec.implements does not match the mapped component-type / feature-type key (manifest mapping "<component-type>" -> "<recipe-uri>", recipe spec.implements is "<recipe-implements>", expected "<component-type>", or a type "<component-type>" extends) (la spec.implements della ricetta della voce di mappatura del manifesto non corrisponde alla chiave di tipo di componente / tipo di funzionalità mappata (mappatura del manifesto dal tipo di componente all’URI della ricetta, la spec.implements della ricetta è il valore dichiarato, previsto il tipo di componente o un tipo che esso estende))

Ogni comando che legge le dipendenze di una Release esegue questo controllo; ciò che cambia è ciò che ciascuno fa con il risultato. aggrega build e aggrega pull si arrestano, perché entrambi producono qualcosa che poi useresti — artefatti renderizzati e un lockfile. aggrega validate e aggrega lint segnalano il rilievo insieme a ogni altra diagnostica trovata e poi escono con un codice diverso da zero: il loro compito è dirti tutto ciò che non va nel workspace, quindi un singolo errore non interrompe il resoconto. Nell’editor il rilievo viene pubblicato come diagnostica accanto alle altre, e qualunque altra cosa quel documento dovesse segnalare non ne è influenzata. Nota dove compare: l’editor pubblica il rilievo sul Manifest in cui è scritta la mappatura, sulla chiave della voce di mappatura che il rilievo nomina, e non sull’Aggregate — sulla prima riga del Manifest dove il suo testo aperto non contiene quella voce, come per una voce che eredita tramite extends. Gli altri rilievi a livello di dipendenze della Release, che non nominano alcun documento del tuo workspace, restano sull’Aggregate. Eseguire aggrega validate lo segnala qualunque documento tu abbia aperto.

Una voce di mappatura che nomina una Recipe che il catalogo non contiene non è questa condizione: il controllo non ha nulla con cui confrontarla e salta la voce, e la Recipe non risolvibile viene segnalata quando vengono risolte le ricette.

Le voci di FeatureRecipe seguono la stessa struttura; il controllo della mappatura features.type emette manifest feature mapping ... featurerecipe spec.implements is ... (expected ...), e il ramo delle funzionalità confronta la chiave di mappatura stessa, quindi non nomina alcuna alternativa extends.

Una chiave components.type viene giudicata anche per istanza ogni volta che raggiunge un’istanza di un’altra versione. Una chiave che non nomina il tipo esatto di un’istanza la raggiunge tramite la base del tipo, quando nessuna chiave nomina quel tipo esatto e nessun’altra chiave è scritta per la stessa base — quindi una chiave scritta senza versione, o una che nomina un’altra versione, può raggiungerla. La voce da sola non può quindi dire se la sua Recipe sia adatta, perciò la build giudica di nuovo la Recipe per ogni istanza di componente che la chiave raggiunge in quel modo, con il tipo proprio dell’istanza, alla versione con cui la build la compila, al posto della chiave: la versione che l’istanza nomina oppure, per un’istanza che non ne nomina alcuna, la versione più alta di quel Component che il catalogo contiene. Un’istanza la cui versione non è soddisfatta dalla spec.implements: della Recipe — esattamente, tramite intervallo caret, per il fatto di non avere versione, o attraverso una base che il tipo dell’istanza estende con extends — solleva questa condizione, segnalata al percorso .spec.components.<instance> dell’istanza anziché al file del Manifest:

manifest mapping entry’s recipe spec.implements does not match the mapped component-type / feature-type key (Manifest, at .spec.components.<instance>, "<instance>", of type "<component-type>", compiled as "<component-type>:<version>", reached through manifest mapping key "<key>", mapped to recipe "<recipe-uri>", whose spec.implements is "<recipe-implements>"). map this type at this version to a recipe that implements it, with a mapping key naming the version (la spec.implements della ricetta della voce di mappatura del manifesto non corrisponde alla chiave di tipo di componente / tipo di funzionalità mappata (Manifest, al percorso dell’istanza, istanza del tipo di componente, compilata come tipo e versione, raggiunta tramite la chiave di mappatura del manifesto, mappata alla ricetta, la cui spec.implements è il valore dichiarato). mappa questo tipo a questa versione su una ricetta che lo implementa, con una chiave di mappatura che nomina la versione)

Il valore compiled as compare solo per un’istanza il cui tipo non nomina una versione; un’istanza che ne nomina una mostra la sua versione in of type. Una chiave che nomina la versione propria dell’istanza non richiede un secondo giudizio, poiché il controllo sulla voce ha già posto quella domanda, e una voce già rifiutata per la sua chiave viene segnalata una volta, come sopra, anziché un’altra volta per ogni istanza. aggrega build e aggrega pull si arrestano su di essa, e aggrega validate --release la segnala ed esce con un codice diverso da zero. aggrega lint giudica le voci di mappatura di un Manifest e non le istanze che raggiungono, quindi non la segnala.

Come risolvere: correggi la dichiarazione spec.implements: della Recipe in modo che corrisponda alla chiave di tipo di componente del Manifest, oppure cambia la voce del Manifest perché punti a una Recipe la cui spec.implements: corrisponda alla chiave di tipo di componente. Per un’istanza che una chiave raggiunge a un’altra versione, aggiungi una chiave di mappatura che nomini la versione dell’istanza, mappata a una Recipe che la implementa, oppure fai puntare la chiave che la raggiunge a una tale Recipe.

Manifest mapping value is not a shape a recipe reference accepts (Il valore di mappatura del Manifest non ha una struttura accettata da un riferimento a ricetta)

Un valore di mappatura del Manifest nomina una Recipe o una FeatureRecipe in una struttura che la grammatica dei riferimenti non può esprimere. Un riferimento a ricetta accetta un nome semplice, un nome con una versione, un nome qualificato dalla capacità, o un nome qualificato dalla capacità con una versione — al massimo un /. Un valore che contiene di più (un percorso in stile tipo di componente come core/helm/eso-aws-fetcher:1.0.0) non può mai nominare un’entità del catalogo, qualunque cosa il catalogo contenga.

La struttura viene giudicata mentre il Manifest viene composto, prima che si cerchi qualsiasi cosa — il verdetto deriva dal conteggio dei separatori in una stringa, quindi non richiede alcun catalogo. Giudicarla lì è ciò che rende onesta la diagnostica: la ricetta che il valore intendeva è spesso presente e nominata correttamente, e sentirsi dire che manca ti porta a cercare la cosa sbagliata. Ogni comando che risolve le dipendenze di una Release la segnala allo stesso modo, quindi non dipende da quale tu esegua.

Messaggio emesso:

malformed recipe reference in a Manifest mapping value: spec.mappings.components.type.<key> maps to <value>, which carries <n> slash-separated segments; a recipe reference accepts "name", "name:version", "capability/name" or "capability/name:version"; correct the mapping value in the Manifest (riferimento a ricetta malformato in un valore di mappatura del Manifest: la chiave è mappata a un valore che contiene più segmenti separati da barre; un riferimento a ricetta accetta nome, nome:versione, capacità/nome o capacità/nome:versione; correggi il valore di mappatura nel Manifest)

La sezione features produce lo stesso messaggio rispetto alla propria coordinata, e un riferimento a ricetta di funzionalità viene nominato come tale.

Un valore il cui segmento di capacità contiene un vincolo di versione — compose:1.2.3/svc:1.0.0 — viene rifiutato allo stesso modo, prima che si cerchi qualsiasi cosa, quindi nulla viene scaricato da un registry. Un vincolo appartiene alla capability che la Recipe dichiara, dove seleziona quale versione del plugin che serve quella capacità la renderizza; un riferimento nomina la Recipe con la sua capacità semplice (compose/svc:1.0.0).

malformed recipe reference in a Manifest mapping value: spec.mappings.components.type.<key> maps to <value>, which carries a version pin in its capability segment <segment>; a pin belongs on the capability the recipe declares, and a recipe reference names the recipe by its bare capability, as "name", "name:version", "capability/name" or "capability/name:version"; correct the mapping value in the Manifest (riferimento a ricetta malformato in un valore di mappatura del Manifest: la chiave è mappata a un valore che contiene un vincolo di versione nel suo segmento di capacità; un vincolo appartiene alla capacità che la ricetta dichiara, e un riferimento a ricetta nomina la ricetta con la sua capacità semplice, come nome, nome:versione, capacità/nome o capacità/nome:versione; correggi il valore di mappatura nel Manifest)

Come risolvere: accorcia il valore di mappatura a una struttura che la grammatica accetta. Una ricetta è identificata dal proprio metadata.name — facoltativamente preceduto dalla sua spec.capability e seguito dalla sua versione — mai dal percorso del tipo di componente che implementa. La chiave della mappatura è il tipo di componente; il valore della mappatura è la ricetta.

Da non confondere con un valore ben strutturato che nomina una ricetta che il catalogo non contiene: quella è un’entità davvero assente e viene comunque segnalata come tale, nominando l’URI e la voce di mappatura che vi faceva riferimento.

Several Recipes implement one Component type (Più Recipes implementano un unico tipo di Component)

Due o più Recipes dichiarano lo stesso tipo di Component in spec.implements: — due Recipes a versione esatta per un unico tipo, oppure una Recipe senza versione accanto a una con versione vincolata.

Questo non solleva alcun arresto proprio, e non è un’ambiguità che la build debba risolvere. La selezione della Recipe avviene solo tramite mappatura: nulla legge spec.implements: e sceglie tra i candidati, quindi per quante Recipes implementino un tipo, quella che renderizza un’istanza è quella a cui il Manifest la mappa. spec.implements: viene letto come ancora di coerenza — per confermare che la Recipe mappata da un autore sia una che dichiara il tipo sotto cui l’ha mappata — e come fonte dei candidati di vincolo che un arresto suggerisce. Non seleziona mai.

Ciò che incontri invece è l’arresto per un’istanza che il Manifest non mappa su nulla, e quell’arresto elenca ogni Recipe che implementa il tipo così che tu possa vincolarne una — vedi «No Recipe is mapped for a component or feature instance (Nessuna Recipe è mappata per un’istanza di componente o di funzionalità)» più avanti. Viene segnalato allo stesso modo sia che il tipo sia implementato da una Recipe sia da cinque, ed è per questo che non esiste una condizione di ambiguità separata da cercare.

Come risolvere: aggiungi la mappatura. Una voce con chiave di tipo instrada ogni istanza del tipo; una voce con chiave di nome instrada un’istanza nominata e viene letta per prima, quindi è anche il modo per dare a un’istanza una Recipe diversa da quella delle sue sorelle.

Divergent Release (extends + aggregate pointer) (Release divergente (extends + puntatore aggregate))

Una Release usa extends: per ereditare da una Release di base ma dichiara anche un proprio puntatore aggregate:. Il JSON Schema della Release rifiuta questa struttura alla validazione dello schema (Livello 1, il controllo dell’involucro) tramite un vincolo allOf: quando extends: è presente, aggregate: è vietato; quando extends: è assente, sono obbligatori sia aggregate: sia manifest:.

Si arresta come una normale violazione dell’involucro, quindi la diagnostica assume la struttura di quella classe — vedi «La classe di errori dell’involucro del documento» in error-translation.md — e il rilievo punta alla chiave che qui non è consentita:

document envelope validation failed (Release, at <path>); <line>:<column>: spec.aggregate: value matches a shape that is not allowed here. correct the document to match its kind’s schema (validazione dell’involucro del documento non riuscita (Release, al percorso); riga e colonna: spec.aggregate: il valore corrisponde a una struttura che qui non è consentita. correggi il documento perché corrisponda allo schema del suo tipo)

Come risolvere: rimuovi il campo aggregate: dalla Release figlia. L’ereditarietà obbliga intenzionalmente la figlia a distribuire lo stesso intento dello sviluppatore della Release genitore; se devi distribuire un Aggregate diverso, scrivi una nuova Release senza extends:.

A feature attached by both the Aggregate and the Release cannot be merged (Una funzionalità associata sia dall’Aggregate sia dalla Release non può essere unita)

Quando un Manifest locale estende un Manifest di base con extends, i due livelli (mappa type:, mappa name:) si uniscono in modo indipendente. All’interno di ciascun livello, le chiavi del figlio sovrascrivono quelle del genitore al primo livello — si tratta di una sostituzione superficiale, non di un’unione profonda. Una voce del figlio per una data chiave sostituisce completamente la voce del genitore per quella chiave.

Quando lo stesso nome di istanza di funzionalità compare sia sul lato Aggregate sia sul lato Release con uno stato in conflitto non unibile (oltre la stratificazione infra consentita), il compilatore si arresta e posiziona la diagnostica sull’associazione che non è riuscito a conciliare. Le due dichiarazioni in conflitto seguono in un ordine fisso — prima il tipo dichiarato dall’Aggregate, poi il tipo dichiarato dalla Release — così puoi capire quale documento ha detto cosa senza aprirli entrambi.

Messaggio emesso:

feature merge conflict: reconcile the Aggregate and Release declarations for the feature (Aggregate <name>, at .spec.components.<component>.features.<attachment>, "<aggregate-declared-type>", "<release-declared-type>") (conflitto di unione delle funzionalità: concilia le dichiarazioni dell’Aggregate e della Release per la funzionalità (Aggregate, al percorso dell’associazione, tipo dichiarato dall’Aggregate, tipo dichiarato dalla Release))

Lo stesso vale per un’associazione che una connessione porta. Quando la voce di connessione dell’Aggregate e la voce della Release per la stessa connessione scrivono entrambe un’associazione sotto uno stesso slot e nominano Features diverse, la build si arresta alla voce della Release — dove è stato scritto il secondo tipo — una volta appiattita la composizione, nominando entrambi i tipi, lo slot, la connessione, il socket e il componente:

feature merge conflict: reconcile the Aggregate and Release declarations for the feature (Release <release-name>, at .spec.boundaries.<boundary>.components.<component>.uses.<socket>.<alias>, the Aggregate names "<aggregate-declared-type>", the Release names "<release-declared-type>", for the slot "<slot>", on the connection "<alias>", through socket "<socket>", of component "<component>"). Drop the type from the Release’s entry so it sizes the attachment the Aggregate declares, or name the same Feature in both documents. (conflitto di unione delle funzionalità: concilia le dichiarazioni dell’Aggregate e della Release per la funzionalità (Release, al percorso della connessione, l’Aggregate nomina un tipo, la Release ne nomina un altro, per lo slot, sulla connessione, attraverso il socket, del componente). Togli il tipo dalla voce della Release in modo che dimensioni l’associazione che l’Aggregate dichiara, oppure nomina la stessa Feature in entrambi i documenti.)

Come risolvere: concilia le due dichiarazioni. Le dichiarazioni lato Aggregate e lato Release della stessa istanza di funzionalità si combinano per pilastro — l’Aggregate contribuisce values, la Release contribuisce infra. Se entrambi i lati specificano lo stesso campo non di pilastro (come type:), i valori devono coincidere; correggi un lato perché corrisponda all’altro, oppure elimina la dichiarazione ridondante.

Annotation binding does not resolve against its target Feature (Il binding dell’annotazione non si risolve rispetto alla sua Feature di destinazione)

Il campo feature: di un binding di annotazione del Manifest nomina una Feature che il catalogo non carica, oppure gli elenchi maps.infra / maps.values del binding dichiarano percorsi in notazione puntata che lo spec.schema della Feature nominata in realtà non contiene. Entrambe le condizioni arrestano il caricamento del workspace — il binding sintetizzerebbe associazioni di Feature che instradano valori verso percorsi che il runtime non può risolvere.

Un’unica condizione copre i tre modi in cui l’instradamento di un binding non si risolve, e la diagnostica indica quale dei tre si è verificato:

  • Feature non trovata. Il valore feature: fa riferimento a un URI di Feature assente dal catalogo caricato.
  • Lo schema della Feature non si risolve. La Feature nominata viene caricata, ma il suo spec.schema: non si risolve in una rappresentazione JSON Schema 2020-12 — il contenuto è malformato, oppure nomina un riferimento tra documenti che non può essere seguito. Questa variante riporta dietro di sé la diagnostica propria dell’errore di risoluzione, così il motivo per cui lo schema non si è risolto si legge nello stesso arresto.
  • Percorso del binding assente dallo schema di destinazione. La voce maps.infra o maps.values del binding nomina un percorso in notazione puntata che lo spec.schema.<pillar>.<path> della Feature non dichiara.

Messaggio emesso (variante Feature non trovata):

annotation binding does not resolve against its target Feature (Manifest, at .spec.mappings.features.annotations.<key>, "<key>", routes to Feature "<feature-uri>", which this build’s catalog does not hold; correct or publish the Feature named under "feature") (il binding dell’annotazione non si risolve rispetto alla sua Feature di destinazione (Manifest: instrada verso una Feature che il catalogo di questa build non contiene; correggere o pubblicare la Feature nominata nel binding))

Messaggio emesso (variante in cui lo schema non si risolve):

annotation binding does not resolve against its target Feature (Manifest, annotation binding routes to Feature "<feature-uri>", whose declared schema does not resolve: <resolution failure>) (il binding dell’annotazione non si risolve rispetto alla sua Feature di destinazione (Manifest: il binding dell’annotazione instrada verso una Feature il cui schema dichiarato non si risolve))

Questa variante nomina la Feature e l’errore di risoluzione, e non riporta né la chiave del binding né una posizione nel sorgente — l’errore sta nello spec.schema: della Feature stessa, che il binding si limita a nominare. Il binding responsabile si trova cercando in mappings.features.annotations l’URI della Feature che il messaggio cita.

Messaggio emesso (variante percorso non trovato):

annotation binding does not resolve against its target Feature (Manifest, at .spec.mappings.features.annotations.<key>, "<key>", routes to Feature "<feature-uri>", at pillar "<pillar>", and path "<path>", which that Feature does not declare a property for under "schema") (il binding dell’annotazione non si risolve rispetto alla sua Feature di destinazione (Manifest: instrada verso una Feature, un pilastro e un percorso per cui quella Feature non dichiara alcuna proprietà nel proprio schema))

Come risolvere: verifica che l’URI feature: del binding esista nel catalogo e corrisponda all’URI, sensibile alle maiuscole, che una Recipe dichiara in implements:. Se la variante percorso non trovato scatta su un percorso che lo schema della Feature dichiara davvero, verifica la grafia del percorso in notazione puntata (sensibile alle maiuscole) e il nome del pilastro (infra o values).

A bound annotation value does not conform to the target Feature’s schema (Un valore di annotazione legato non è conforme allo schema della Feature di destinazione)

Un’annotazione che hai scritto instrada un valore, attraverso un binding, verso un percorso della Feature di destinazione — e il valore non soddisfa il sotto-schema che la Feature dichiara in quel percorso, oppure la Feature non vi dichiara alcuna proprietà. La condizione si valuta sul valore anziché sul binding, ed è per questo che è distinta dall’arresto sulla destinazione del binding descritto sopra: quello rifiuta ciò che il Manifest dichiara, questo rifiuta ciò che vi è stato scritto attraverso.

Validazione completa nel percorso individuato; salto non bloccante solo quando il percorso non può essere individuato. Una volta individuato il sotto-schema della sottochiave legata, il valore viene validato rispetto all’insieme completo dei vincoli di JSON Schema 2020-12 in quel percorso (tipo, enum, pattern, intervallo numerico, struttura annidata di oggetti e array) — un $ref / allOf / oneOf terminale viene risolto rispetto alle definizioni dello schema e validato, non saltato. La disciplina del salto non bloccante si applica solo alla navigazione: quando la visita incontra una via d’uscita ($ref, patternProperties, oneOf/anyOf/allOf, oppure additionalProperties con un corpo di schema) su un segmento intermedio — prima di raggiungere la foglia legata — il percorso non è risolvibile staticamente, quindi il validatore prosegue senza sollevare l’errore anziché rischiare un falso arresto; il runtime resta la superficie di validazione per quel binding.

Messaggio emesso (variante sulla conformità del valore):

annotation subkey does not conform to the target Feature’s schema at the routed pillar: annotation subkey <subkey> value <value> does not conform to Feature <feature-uri> spec.schema.<pillar>.<subkey>: <constraint failure> (la sottochiave dell’annotazione non è conforme allo schema della Feature di destinazione nel pilastro instradato: il valore della sottochiave dell’annotazione non è conforme allo schema della Feature)

Messaggio emesso (variante sulla sottochiave non dichiarata):

annotation subkey does not conform to the target Feature’s schema at the routed pillar: annotation subkey <subkey> is not declared at Feature <feature-uri> spec.schema.<pillar>.<subkey> (la sottochiave dell’annotazione non è conforme allo schema della Feature di destinazione nel pilastro instradato: la sottochiave dell’annotazione non è dichiarata nello schema della Feature)

L’arresto viene sollevato sull’annotazione così come è scritta, prima che venga espansa in un’associazione di Feature, quindi la diagnostica nomina il documento e il livello in cui il valore è stato scritto — il confine e il componente per un’annotazione lato Release, il percorso del componente per una lato Aggregate — e la chiave di annotazione da cui proviene.

Un’annotazione iniettata da un plugin di governance viene giudicata allo stesso modo, e la diagnostica dice chi l’ha scritta. Un plugin associato per iniettare annotazioni imposta il proprio valore su un componente della Release, quindi il valore viene verificato esattamente come uno che un operatore vi avesse scritto — ma la riga della Release a cui punta la diagnostica è una che nessuno ha scritto. La diagnostica aggiunge quindi quale plugin ha iniettato il valore e il ruolo di governance a cui è associato, e la correzione sta nella decisione di quel plugin anziché nella Release.

Come risolvere: correggi il valore legato perché soddisfi il sotto-schema dichiarato, oppure amplia lo schema di quella proprietà se il valore è legittimo. La variante sulla sottochiave non dichiarata viene di solito anticipata dall’arresto sulla destinazione del binding descritto sopra; raggiungerla significa che il binding dichiara il percorso e lo schema della Feature non lo contiene, quindi correggi quello dei due che è sbagliato. Quando un operatore di composizione intermedio rende un percorso non risolvibile e il runtime in seguito lo rifiuta, restringi lo schema in modo da esporre la proprietà direttamente nel percorso del binding.

An annotation subkey is not routed by its binding (Una sottochiave di annotazione non è instradata dal suo binding)

Un’annotazione che hai scritto contiene sottochiavi sotto una chiave rivendicata da un binding di annotazione del Manifest, e una di quelle sottochiavi è un nome che il binding non instrada: non compare né in maps.infra né in maps.values. Ogni sottochiave viene instradata per conto proprio, verso il percorso della Feature che il binding dichiara per essa, quindi una sottochiave che il binding non nomina non ha dove andare. Espandere l’annotazione senza di essa lascerebbe fuori dalla build un valore che hai scritto senza che nulla venga segnalato, e la causa abituale è una sottochiave scritta male — perciò la build si arresta, nominando la sottochiave, la chiave di annotazione sotto cui è stata scritta e ogni sottochiave che il binding instrada.

L’arresto viene sollevato sull’annotazione così come è scritta, prima che venga espansa in un’associazione di Feature, come accade per le due condizioni accanto: «A bound annotation value does not conform to the target Feature’s schema (Un valore di annotazione legato non è conforme allo schema della Feature di destinazione)», sopra, rifiuta una sottochiave che il binding instrada quando la Feature ne rifiuta il valore, e «An annotation routes through a pillar its authoring side may not use (Un’annotazione è instradata attraverso un pilastro che il suo lato di redazione non può usare)», sotto, rifiuta una sottochiave instradata attraverso il pilastro sbagliato. Una chiave che nessun binding rivendica non rientra in questa condizione: nulla la instrada, e la build la tralascia.

Messaggio emesso, che nomina il documento e il punto in cui l’annotazione è stata scritta, la sottochiave, la chiave di annotazione e le sottochiavi che il binding instrada:

annotation subkey is not routed by the annotation’s binding (Release <release-name>, at .spec.boundaries.<boundary>.annotations, "<subkey>", written under annotation "<key>", whose binding routes only "<subkey>, <subkey>") (la sottochiave dell’annotazione non è instradata dal binding dell’annotazione (Release: la sottochiave, scritta sotto l’annotazione, il cui binding instrada solo le sottochiavi elencate))

Un’annotazione scritta in un Aggregate viene nominata allo stesso modo, nel punto in cui è stata scritta lì — (Aggregate <name>, at .spec.subsystems.<subsystem>.annotations, …) per una scritta su un sottosistema. La build segnala un’annotazione lato Release sotto un tag OPS_ERROR e una lato Aggregate sotto un tag DEVELOPER_ERROR, secondo il documento che l’ha scritta.

Come risolvere: confronta la sottochiave con quelle elencate dal messaggio. Se si tratta di un errore di grafia, correggila con la sottochiave che il binding instrada. Se il valore deve raggiungere la Feature, il binding deve instradarlo: aggiungi il percorso a maps.infra o maps.values del binding nel Manifest — un percorso che lo schema della Feature dichiara — oppure rimuovi la sottochiave dall’annotazione.

A bare annotation value does not route to exactly one path of its binding (Un valore di annotazione semplice non viene instradato verso esattamente un percorso del suo binding)

Un’annotazione che hai scritto come valore semplice — feature.aggrega.ai/monitoring: "30s" anziché una mappa di sottochiavi — non nomina alcuna sottochiave, quindi nulla in essa dice quale percorso della Feature riempie. Viene collocata nell’unico percorso che il binding dichiara, contando insieme maps.infra e maps.values. Un binding che dichiara più di un percorso lascia al valore più destinazioni possibili e nulla per scegliere tra esse, quindi la build si arresta anziché sceglierne una. Il conteggio si fa su entrambi gli elenchi, quindi un binding che instrada un percorso attraverso infra e un altro attraverso values rifiuta un valore semplice in qualunque documento sia scritto.

L’arresto viene sollevato sull’annotazione così come è scritta, prima che venga espansa in un’associazione di Feature, come accade per le condizioni accanto, quindi la diagnostica nomina il documento e il punto in cui il valore è stato scritto. La verifica avviene una volta per ogni annotazione che hai scritto: un valore scritto su un confine o su un sottosistema viene rifiutato lì, una volta sola, che un componente al suo interno lo raccolga o meno. Ogni valore di questo tipo nella build viene segnalato, non solo il primo. La build segnala un’annotazione lato Release sotto un tag OPS_ERROR e una lato Aggregate sotto un tag DEVELOPER_ERROR, secondo il documento che l’ha scritta. La condizione è a scalar annotation value does not route to exactly one path of its binding, che è ciò che aggrega explain stampa per il suo codice.

Messaggio emesso, che nomina il documento e il punto in cui l’annotazione è stata scritta, la chiave di annotazione, il valore e i percorsi che il binding instrada:

a scalar annotation value does not route to exactly one path of its binding (Release <release-name>, at .spec.boundaries.<boundary>.annotations, "<key>", carrying the bare value "<value>", whose binding routes "<path>, <path>, <path>") (un valore di annotazione scalare non viene instradato verso esattamente un percorso del suo binding (Release: la chiave porta un valore semplice, il cui binding instrada i percorsi elencati))

Un valore vuoto non scrive nulla, quindi viene collocato ovunque uno dei due elenchi contenga un solo percorso, e viene rifiutato solo dove nessuno dei due lo contiene. Un binding che non dichiara alcun percorso viene rifiutato al caricamento del Manifest, perché lo schema del Manifest ne richiede uno, quindi una build non raggiunge questa condizione per quella via.

Un’annotazione iniettata da un plugin di governance viene giudicata allo stesso modo, e la sua diagnostica aggiunge quale plugin ha iniettato il valore e il ruolo di governance a cui è associato, come fanno le condizioni accanto.

Come risolvere: scrivi l’annotazione come una mappa che nomina la sottochiave a cui è destinato ciascun valore — feature.aggrega.ai/monitoring: {interval: 30s} — così che ogni valore venga instradato in base al proprio nome; oppure dai al singolo valore un binding tutto suo, sotto un’altra chiave di annotazione, che dichiari solo il percorso che riempie.

An annotation routes through a pillar its authoring side may not use (Un’annotazione è instradata attraverso un pilastro che il suo lato di redazione non può usare)

Le annotazioni sono ripartite per lato di redazione, e la ripartizione è la stessa che governa ogni altro pilastro scritto: un’annotazione lato Aggregate può essere instradata solo attraverso un percorso del binding che punta a values, e un’annotazione lato Release solo attraverso un percorso che punta a infra. Qualsiasi altro abbinamento provoca un arresto.

La ripartizione è ciò che impedisce alla scorciatoia delle annotazioni di diventare un modo per scrivere il pilastro dell’altro lato. L’annotazione di uno sviluppatore contribuisce values; quella di un operatore contribuisce il dimensionamento infra. Un binding che dichiara percorsi in entrambi i pilastri non è di per sé un errore — ciascun lato instrada il sottoinsieme che gli è consentito, e i percorsi dell’altro lato semplicemente non sono raggiungibili da esso.

Un binding che dichiara lo stesso percorso in entrambi gli elenchi dei pilastri è il caso che porta più spesso a questo arresto. Il criterio di spareggio dell’instradamento invia un percorso del genere attraverso infra, il che lo rende irraggiungibile dal lato Aggregate, e un’annotazione lato Aggregate instradata verso di esso si arresta qui. L’avviso che segnala quella struttura di binding prima che una build raggiunga questo arresto è descritto in warnings.md.

Messaggio emesso:

annotation routes through a pillar its authoring side may not use: annotation <key> at <source> routes through pillar <pillar> at path <path>, but <side>-side annotations may only route through pillar <permitted-pillar> (l’annotazione è instradata attraverso un pilastro che il suo lato di redazione non può usare: l’annotazione è instradata attraverso un pilastro in un percorso, ma le annotazioni di quel lato possono essere instradate solo attraverso il pilastro consentito)

Un’annotazione iniettata da un plugin di governance si trova su un componente della Release, quindi è un’annotazione lato Release e le si applica la stessa ripartizione. La sua diagnostica aggiunge quale plugin l’ha iniettata e il ruolo di governance a cui è associato, perché la chiave della Release a cui punta è una che nessuno ha scritto.

Come risolvere: instrada l’annotazione dal lato il cui pilastro è la destinazione del binding, oppure aggiungi un binding — sotto una propria chiave di annotazione — i cui percorsi puntano al pilastro consentito al lato che scrive. Dove un binding dichiara lo stesso percorso in entrambi gli elenchi dei pilastri, dividilo in due binding così che ogni lato abbia un percorso raggiungibile. Dove la diagnostica nomina un plugin che inietta, l’annotazione proviene dalla decisione di quel plugin: correggi il plugin, o il binding sotto cui inietta.

Authored values or infra do not conform to the declared schema (I values o gli infra scritti non sono conformi allo schema dichiarato)

I values: o gli infra: risolti di un’istanza di componente — o di una Feature associata — non sono conformi allo schema di catalogo dichiarato. La build valida ogni pilastro rispetto al suo schema dichiarato prima del rendering, quindi una chiave scritta male, un valore di tipo sbagliato, un numero fuori intervallo o un campo obbligatorio mancante viene intercettato alla fonte anziché produrre un manifesto non valido al momento della distribuzione.

Il controllo copre i vincoli di schema standard: un valore del tipo sbagliato (una stringa dove lo schema dichiara un intero), un valore fuori da un intervallo dichiarato o da un enum, un valore che non soddisfa un pattern dichiarato, una stringa che non è un’istanza valida del suo format dichiarato — uno dei formati con nome — e un campo obbligatorio che non è stato fornito. Un errore di formato nomina la parola chiave e riporta il valore, il formato e ciò che non va — così come lo stampano aggrega pull e aggrega validate --release per un campo uri a cui è dato ::::, "format", "value \"::::\" is not a valid uri: a URI begins with a scheme followed by a colon, such as https:". È consapevole dei default: un campo a cui lo schema assegna un default: è considerato fornito anche quando è omesso, quindi un campo obbligatorio con default non fa mai scattare il controllo «mancante».

Il pilastro values è la superficie di authoring dello sviluppatore. È validato in modo chiuso — una proprietà che lo schema non dichiara viene rifiutata come probabile refuso. Uno schema values che si compone all’interno del proprio documento (un #/$defs $ref locale o un allOf) viene risolto e validato rispetto a quel contesto di definizioni.

Il pilastro infra è la superficie di dimensionamento dell’operatore, e viene controllato solo quando il Component dichiara un pilastro schema.infra — quella dichiarazione è il contratto a cui il componente aderisce. È validato in modo chiuso rispetto a quella dichiarazione e a nient’altro, esattamente come il pilastro values è validato rispetto a schema.values: una chiave che il Component non dichiara viene rifiutata come refuso, e di una chiave che dichiara vengono imposti il tipo e l’intervallo. Un componente che vuole far validare una chiave stratificata dal provider come replicas dichiara quella chiave nel proprio schema.infra; il vocabolario accettato da un provider si raggiunge tramite il valuesMapping della sua Recipe, anziché essere stratificato sulla superficie infra scritta dall’autore.

Il controllo misura il dimensionamento di ogni componente che la Release ha collocato, e viene misurata anche una voce che non scrive alcun blocco infra:: un blocco assente è un blocco vuoto, quindi una chiave required: priva di default: viene segnalata come mancante — che è proprio il caso per intercettare il quale esiste una chiave del genere. Contano entrambi i modi di collocare un componente. Nominarlo sotto i components di un confine lo colloca, e lo stesso fa instradare sotto aggregates il sottomodulo che lo contribuisce; una voce di instradamento colloca i componenti senza dire nulla su nessuno di essi, quindi un componente collocato in quel modo parte da un blocco di dimensionamento vuoto e una chiave required: senza default sul suo tipo viene segnalata come mancante. Un componente che la Release non colloca per nessuna delle due vie non viene affatto misurato rispetto a questo contratto. Ha un errore diverso, e il build segnala invece quello: un componente non collocato in alcun confine, con i due modi per collocarlo nominati.

Il contratto vincola un componente ovunque sia stato scritto: un componente contribuito da un sottomodulo viene misurato esattamente come uno dichiarato dall’Aggregate della Release stessa. Quanto profondamente un componente è annidato non cambia quali vincoli del suo tipo si applicano.

Le associazioni di Feature sono validate allo stesso modo, rispetto a schema.values / schema.infra dichiarati dalla Feature associata. Le associazioni condividono un’unica superficie, quindi una Feature per credenziali — una con l’etichetta feature.aggrega.ai/kind: secret — viene misurata rispetto al proprio schema dichiarato esattamente come qualsiasi altra associazione. Il valore controllato è il risultato effettivo dell’unione dopo che i valori delle associazioni si propagano a cascata tra i livelli (componente, sottosistema, confine e specifico del componente) — quindi un valore introdotto legittimamente a un livello ma sovrascritto con un valore non valido a un livello più specifico viene intercettato sul risultato dell’unione, non sul frammento. Un’associazione il cui tipo non dichiara alcuno schema non viene validata; l’infra di un’associazione è validato rispetto al schema.infra dell’associazione stessa (un’associazione è una sovrapposizione e non porta alcuna unione di provider).

Il rilievo di un’associazione viene segnalato nel documento che ha scritto il pilastro non conforme, sotto il nome di quel documento, e attribuito al suo autore. I suoi values vengono segnalati nel blocco dell’Aggregate che li ha scritti — la voce features: del componente stesso, .spec.components.<component>.features.<attachment>.values.<field>, prima del blocco di un sottosistema che raggiunge il componente — come errore dello sviluppatore. Il suo infra viene segnalato nel blocco della Release che lo ha scritto — la voce della Release per il componente, sotto il confine che lo nomina, prima del blocco features: del confine stesso — come errore dell’operatore. Un pilastro che il documento a cui appartiene non ha scritto viene segnalato dove è stata scritta l’associazione stessa, cioè dove è nominato il suo type. Così un’associazione che solo la Release crea, che non porta alcun values, segnala un campo richiesto dai values della sua Feature nella voce della Release e come errore dell’operatore, in un percorso che la Release contiene — la voce del componente, oppure il blocco features: del confine per un’associazione che il confine crea per ogni componente al suo interno:

[OPS_ERROR E0168] .spec.boundaries.main.components.app.features.check.values.schema
authored pillar does not conform to its declared schema (Release probe, at .spec.boundaries.main.components.app.features.check.values.schema, values pillar does not conform to the Feature schema: missing required property: schema (required))

La stessa associazione scritta sul componente nell’Aggregate segnala [DEVELOPER_ERROR E0168] in .spec.components.app.features.check.values.schema, sotto il nome dell’Aggregate. Un editor mostra ciascuno sul documento che lo ha scritto, sulla chiave più profonda di quel percorso che il documento contiene.

Un’associazione portata da una connessione viene misurata allo stesso modo, e segnalata nella voce di connessione del documento che ha scritto il pilastro non conforme anziché nel blocco features: del componente stesso, che non la contiene. I suoi values vengono segnalati nella voce di connessione dell’Aggregate, .spec.components.<component>.uses.<socket>.<alias>.features.<slot>.values.<field> — nel documento del sottomodulo stesso, per un componente contribuito da un sottomodulo — e il suo infra nella voce della Release per quella connessione, sotto il confine che nomina il componente quando la Release nomina dei confini. Un’associazione che solo la Release crea viene segnalata nella voce della Release per entrambi i pilastri: un’associazione del genere non porta values, quindi una Feature i cui values richiedono un campo lo segnala come mancante lì, nella voce scritta dall’operatore.

La configurazione di connessione per arco viene validata allo stesso modo rispetto al contratto per arco del socket: i values di un arco scritti dallo sviluppatore rispetto al valueSchema del socket, e l’infra di un arco scritto dall’operatore (da una Release) rispetto all’infraSchema del socket. Un socket che non dichiara alcuno schema per arco per un pilastro non accetta per esso alcuna configurazione validata (omissione = nessun contratto, niente da controllare). La diagnostica nomina l’arco tramite consumatore, socket e alias. Su un componente dichiarato dall’Aggregate della Release stessa, l’infra dell’operatore viene misurato per ogni voce che la Release scrive per una delle sue connessioni — compresa una voce che non porta alcun infra, ed è così che una chiave required: senza default viene segnalata come mancante — e segnalato in quella voce nella Release, sotto il confine che nomina il componente quando la Release nomina dei confini, che è dove l’operatore lo modifica; i values dello sviluppatore vengono segnalati nella voce di connessione nell’Aggregate.

Una foglia dichiarata sensitive: true ha la propria violazione di vincolo nascosta. Il testo dell’errore cita il valore incriminato, e una diagnostica di build è letta da chiunque osservi il build, quindi su una foglia dichiarata sensibile — o in qualunque punto all’interno di un oggetto dichiarato sensibile — il <constraint failure> qui sotto riporta invece <redacted>. Lo stesso vale in una posizione che contiene sotto di sé una foglia dichiarata sensibile, compreso il pilastro stesso: un $ref scritto accanto ad altre parole chiave viene controllato per intero dove è scritto, quindi un errore all’interno della definizione che nomina viene segnalato in quella posizione e altrimenti citerebbe il valore della foglia. L’entità, il percorso del campo, il pilastro e il nome del contratto sono comunque tutti nominati, quindi la diagnostica ti dice ancora dove si trova l’errore; viene omesso solo il testo che riprodurrebbe il valore. La sensibilità si legge per pilastro, quindi una foglia con lo stesso nome in values e infra viene nascosta solo nel pilastro che la dichiara.

Messaggio emesso:

authored pillar does not conform to its declared schema (Aggregate <name>, at .spec.components.<component>.values.<field>, “values.<field>”, “<keyword>”, “<constraint failure>”) (il pilastro scritto non è conforme al proprio schema dichiarato) authored pillar does not conform to its declared schema (Release <release-name>, at .spec.components.<component>.infra.<field>, “infra.<field>”, “<keyword>”, “<constraint failure>”) (il pilastro scritto non è conforme al proprio schema dichiarato) authored pillar does not conform to its declared schema (Aggregate <name>, at .spec.components.<component>.features.<attachment>.values.<field>, values pillar does not conform to the Feature schema: <constraint failure>) (il pilastro scritto non è conforme al proprio schema dichiarato: il pilastro values non è conforme allo schema della Feature) authored pillar does not conform to its declared schema (Release <release-name>, at .spec.boundaries.<boundary>.components.<component>.features.<attachment>.infra.<field>, infra pillar does not conform to the Feature schema: <constraint failure>) (il pilastro scritto non è conforme al proprio schema dichiarato: il pilastro infra non è conforme allo schema della Feature) authored pillar does not conform to its declared schema (Release <release-name>, at .spec.boundaries.<boundary>.features.<attachment>.values.<field>, values pillar does not conform to the Feature schema: <constraint failure>) (il pilastro scritto non è conforme al proprio schema dichiarato: il pilastro values non è conforme allo schema della Feature) authored pillar does not conform to its declared schema (Aggregate <name>, at .spec.components.<component>.uses.<socket>.<alias>.values.<field>, “values.<field>”, “<keyword>”, “<constraint failure>”) (il pilastro scritto non è conforme al proprio schema dichiarato) authored pillar does not conform to its declared schema (Aggregate <name>, at .spec.components.<component>.uses.<socket>.<alias>.features.<slot>.values.<field>, values pillar does not conform to the Feature schema: <constraint failure>) (il pilastro scritto non è conforme al proprio schema dichiarato: il pilastro values non è conforme allo schema della Feature) authored pillar does not conform to its declared schema (Release <release-name>, at .spec.components.<component>.uses.<socket>.<alias>.features.<slot>.values.<field>, values pillar does not conform to the Feature schema: <constraint failure>) (il pilastro scritto non è conforme al proprio schema dichiarato: il pilastro values non è conforme allo schema della Feature) authored pillar does not conform to its declared schema (Release <release-name>, at .spec.boundaries.<boundary>.components.<component>.uses.<socket>.<alias>.infra.<field>, “infra.<field>”, “<keyword>”, “<constraint failure>”) (il pilastro scritto non è conforme al proprio schema dichiarato)

Come risolvere: correggi il valore incriminato in modo che soddisfi lo schema dichiarato, oppure — se il valore è legittimo — amplia lo schema che lo dichiara (schema.values/schema.infra del Component, o quello della Feature associata) perché lo dichiari. Ispeziona lo schema dichiarato di un Component con aggrega inspect <component-type> per vedere i tipi esatti, gli intervalli, i default e i campi obbligatori che ogni pilastro si aspetta.

A declared schema contract cannot be read as a schema (Un contratto di schema dichiarato non può essere letto come schema)

Un Component o una Feature dichiara un contratto di schema che non fornisce nulla rispetto a cui validare, quindi la configurazione che copre viene misurata rispetto a nulla. Tre contratti possono portare l’errore, ciascuno scritto nel proprio campo: lo spec.schema dell’entità stessa e i due contratti per arco che un socket di dipendenza dichiara — valueSchema per il lato dello sviluppatore di una connessione e infraSchema per quello dell’operatore. Anche una voce di SchemaLibrary, a cui quei contratti possono fare riferimento, può portare il terzo degli errori descritti sotto; come viene segnalato quel caso è spiegato più avanti.

Tre errori portano a questo arresto, e due di essi sono facili da non notare perché il contratto sembra a posto. Un contratto di socket può non compilare affatto in JSON Schema 2020-12 — una parola chiave scritta male è la causa più comune; uno spec.schema proprio di un’entità che non compila viene invece segnalato sotto la condizione di forma compatta incontrata dalla sua compilazione (E0120 per una parola chiave sconosciuta, E0116 per un vincolo che il suo tipo non accetta). Oppure può compilare senza problemi e tuttavia non costruire alcun validatore: il corpo è leggibile come forma compatta e non è uno schema rispetto a cui si possa validare qualcosa, come uno scalare semplice dove va lo schema di una proprietà (items: nonsense). Oppure può essere ben formato sotto ogni altro aspetto e nominare un formato fuori dall’insieme supportato — format: password, o un errore di grafia come format: emial — che viene rifiutato anziché letto come un vincolo che non controlla nulla, che un valore raggiunga o meno il campo; i nomi che un format può assumere sono elencati sotto Formati con nome. Tutti e tre sono un’unica condizione, perché il rimedio è lo stesso e lasciarne passare uno qualsiasi ha la stessa conseguenza.

Non dichiarare alcun contratto e dichiararne uno che non può essere letto sono situazioni diverse, e il build le tratta in modo diverso. Un campo che non dichiara nulla viene saltato: la conformità per pilastro e per arco è facoltativa, quindi un socket che non vincola nessuno dei due pilastri è un normale caso di authoring e non produce alcuna diagnostica. Un campo che dichiara qualcosa di illeggibile viene rifiutato. Lasciarlo passare lascerebbe non validato ogni payload che copre mentre il build riporta un successo — un controllo che ha smesso di funzionare senza nulla che dica che ha smesso. Quindi è il rifiuto a tenere distinti i due casi: il silenzio significa che non c’era nulla da controllare, e un arresto significa che c’era qualcosa e non è stato possibile leggerlo.

Il rifiuto nomina l’entità che ha dichiarato il contratto anziché il documento che ha scritto la configurazione, perché è lì che va la correzione. L’autore di un Aggregate a cui viene dato un tipo di componente il cui contratto non può essere letto non ha nulla da cambiare nel proprio file. Il rifiuto arriva mentre il catalogo viene letto, dove l’entità dichiarante, il pilastro, il campo scritto e la riga del sorgente sono tutti noti — quindi lo stesso errore viene segnalato in modo identico sia che tu lo raggiunga da un build, da aggrega validate o dallo strumento di build esposto da aggrega mcp. Un contratto che l’entità legge tramite $import: — il suo intero spec.schema, un suo pilastro o il contratto di un socket — viene segnalato nel file importato: la posizione nomina quel file e la riga in esso in cui è scritto il frammento, mentre il messaggio nomina comunque l’entità e il campo che ha dichiarato il contratto. Gli arresti di forma compatta che incontra lo spec.schema proprio di un’entità sono localizzati allo stesso modo.

Una voce di SchemaLibrary che nomina un formato fuori dall’insieme supportato porta a questo arresto quando la sua libreria viene letta, e il rifiuto nomina la libreria e la voce e punta alla voce nel file della libreria. aggrega validate sull’intero catalogo legge ogni libreria, quindi segnala la voce indipendentemente dal fatto che uno schema vi faccia riferimento, mentre una Release la cui risoluzione delle dipendenze non raggiunge mai la libreria non la legge. Anche una Release i cui schemi raggiungono la voce tramite un $ref: viene rifiutata, ma il rifiuto non nomina il formato: aggrega pull segnala la libreria come non trovata nel catalogo (E0114), e aggrega validate --release segnala la destinazione del riferimento come non trovata (E0121). Esegui aggrega validate sul catalogo per vedere la voce e il nome in errore.

Il messaggio riporta l’errore così come lo ha segnalato lo strumento che lo ha incontrato: per un errore di compilazione, la chiave all’interno del contratto, la riga del sorgente e la parola chiave incriminata; per un corpo che non costruisce alcun validatore, la posizione che il validatore ha rifiutato; per un nome di formato fuori dall’insieme supportato, il campo, la parola chiave format, il nome come è scritto e ogni nome supportato. Un $ref: tra documenti in un contratto di socket la cui voce di SchemaLibrary non è nella chiusura caricata porta allo stesso arresto quando aggrega validate controlla l’entità o la Release; nello spec.schema proprio di un’entità viene segnalato come descrive «A $ref: is not written in a form the compiler can resolve (Un riferimento non è scritto in una forma che il compilatore sa risolvere)» più sopra. aggrega pull legge entrambi i punti per le librerie di cui una Release ha bisogno, quindi una libreria assente dal catalogo ferma il pull prima, come descrive «A reference names no entity the catalog holds (Un riferimento non nomina alcuna entità contenuta nel catalogo)» (E0114), qualunque dei due vi faccia riferimento — e una libreria contenuta nel catalogo viene vincolata nel lockfile per entrambi.

Un vincolo ben formato accanto a uno illeggibile non viene applicato. Un contratto viene letto come un unico documento, quindi un solo frammento illeggibile disattiva ogni vincolo dichiarato insieme a esso. Ecco perché l’arresto vale più dei vincoli che costa: l’alternativa è un contratto che sembra applicato, si legge come applicato e non applica nulla.

Messaggio emesso, che nomina l’entità con la sua versione e il campo che dichiara il contratto, poi il pilastro vincolato da quel contratto, poi l’errore — qui un contratto di socket che contiene una parola chiave scritta male:

declared schema contract could not be compiled into a usable schema, so nothing was validated against it: correct the contract where it is declared, or remove it if the configuration it covers needs no validation. Component "<type>:<version>": spec.usesSchema.<socket>.valueSchema declares a schema no validator can be built from, so the values it constrains would go unmeasured: compactform at <key>:<line> (keyword "<keyword>"): unknown keyword (non è stato possibile compilare il contratto di schema dichiarato in uno schema utilizzabile, quindi nulla è stato validato rispetto a esso: correggi il contratto dove è dichiarato, oppure rimuovilo se la configurazione che copre non richiede validazione. Component: spec.usesSchema.valueSchema del socket dichiara uno schema da cui non si può costruire alcun validatore, quindi i valori che vincola resterebbero non misurati: compactform alla chiave e alla riga indicate: parola chiave sconosciuta)

e un nome di formato al di fuori dell’insieme supportato nel pilastro values di un Component:

declared schema contract could not be compiled into a usable schema, so nothing was validated against it: correct the contract where it is declared, or remove it if the configuration it covers needs no validation. Component "<type>:<version>": spec.schema.values declares a schema no validator can be built from, so the values it constrains would go unmeasured: validator/jsonschema: schema resolution failed (at values.<field>, keyword "format", format "<format>" is not supported; the supported formats are email, uri, hostname, ipv4, ipv6, uuid, date-time, date) (non è stato possibile compilare il contratto di schema dichiarato in uno schema utilizzabile, quindi nulla è stato validato rispetto a esso: correggi il contratto dove è dichiarato, oppure rimuovilo se la configurazione che copre non richiede validazione. Component: spec.schema.values dichiara uno schema da cui non si può costruire alcun validatore, quindi i valori che vincola resterebbero non misurati: validator/jsonschema: risoluzione dello schema non riuscita (nel campo sotto values, parola chiave format: il formato non è supportato; i formati supportati sono email, uri, hostname, ipv4, ipv6, uuid, date-time, date))

Una Feature è indicata come Feature "<name>:<version>", il contratto di un socket con il suo stesso campo, ad esempio spec.usesSchema.<socket>.infraSchema, e il pilastro con quello che il contratto vincola — values, infra o provides. aggrega validate, quando riceve il file dell’entità stessa, nomina l’entità senza la sua versione. Una voce di SchemaLibrary è indicata con la sua libreria e la sua voce:

declared schema contract could not be compiled into a usable schema, so nothing was validated against it: correct the contract where it is declared, or remove it if the configuration it covers needs no validation. SchemaLibrary "<library>": schema "<entry>" names a format no validator can check, so the values it constrains would go unmeasured: validator/jsonschema: schema resolution failed (at <field>, keyword "format", format "<format>" is not supported; the supported formats are email, uri, hostname, ipv4, ipv6, uuid, date-time, date) (non è stato possibile compilare il contratto di schema dichiarato in uno schema utilizzabile, quindi nulla è stato validato rispetto a esso: correggi il contratto dove è dichiarato, oppure rimuovilo se la configurazione che copre non richiede validazione. SchemaLibrary: lo schema nomina un formato che nessun validatore può verificare, quindi i valori che vincola resterebbero non misurati: validator/jsonschema: risoluzione dello schema non riuscita (nel campo indicato, parola chiave format: il formato non è supportato; i formati supportati sono email, uri, hostname, ipv4, ipv6, uuid, date-time, date))

Come risolvere: apri il campo indicato dalla diagnostica e correggi il frammento alla chiave e alla riga riportate — il più delle volte una parola chiave scritta male, da verificare rispetto al vocabolario delle parole chiave in vocabulary/compact-form-authoring.md, oppure un valore scritto dove va uno schema annidato. Se l’errore indica un formato non supportato, scrivi uno dei formati con nome oppure rimuovi il format:; un campo che contiene materiale segreto dichiara invece sensitive: true, perché password non è un formato. Per una voce di SchemaLibrary, la correzione va nel file di libreria indicato dalla diagnostica. Se l’errore indica un riferimento tra documenti, verifica che la voce di SchemaLibrary esista e che la libreria sia raggiungibile dalla chiusura delle dipendenze della Release. Se la configurazione coperta da quel campo davvero non richiede validazione, rimuovi il campo invece di lasciare un contratto che nulla può leggere.

Recipe source: is an empty string (Il campo source della Recipe è una stringa vuota)

Una Recipe dichiara source: "" — una stringa vuota. Il source: di una Recipe sceglie tra due modalità di scrittura: la modalità sourceless, in cui non c’è alcun artefatto esterno e l’output è prodotto interamente dagli altri tipi di input della Recipe, e la modalità sourced, in cui source: nomina un chart, un modulo o un file esterno da cui eseguire il rendering. Omettere il campo seleziona la prima, un valore non vuoto seleziona la seconda e una stringa vuota non seleziona nessuna delle due — quindi è un’ambiguità e non un valore con un significato. Un source: scritto come null equivale a ometterlo.

La Recipe viene rifiutata invece di lasciare che il compilatore scelga al posto tuo una delle due letture. Il modo più comune di scrivere un source: vuoto è eliminare un URI e lasciare la chiave: si intendeva la modalità sourced, e accettare la stringa vuota come sourceless consegnerebbe il componente privo dell’artefatto senza mai dire quale delle due letture ha adottato.

Questa regola viene verificata quando la Recipe viene caricata, leggendo il valore esattamente come l’hai scritto, quindi ogni comando che carica la Recipe nomina questa condizione prima che qualcosa tenti di usare il valore vuoto. aggrega validate sul file della Recipe la rifiuta; aggrega pull, una build, aggrega validate --release e lo strumento di build esposto da aggrega mcp la segnalano per una Release che raggiunge la Recipe, prima del riferimento alla Recipe che a causa sua non è più stato possibile risolvere. Un pull nomina quindi questa condizione invece di segnalare il riferimento vuoto come uno di cui non sa stabilire il tipo di source. Viene verificata prima delle regole che leggono se un source è dichiarato, quindi a una Recipe il cui source: è vuoto viene segnalato il source: anziché un valuesMapping senza nulla da sovrapporre o un tipo di input mancante.

Messaggio emesso, posizionato sul file della Recipe in cui è stato scritto il source: vuoto e sulla chiave al suo interno — .spec.source — anziché su un componente che lega la Recipe, perché la voce è condivisa da ogni componente che lo fa:

recipe source is an empty string, which names neither sourceless mode nor sourced mode (Recipe <name>:<version>, at .spec.source). omit the source field for sourceless mode, or name a non-empty path or URI for sourced mode (il source della ricetta è una stringa vuota, che non nomina né la modalità sourceless né la modalità sourced. ometti il campo source per la modalità sourceless, oppure indica un percorso o un URI non vuoto per la modalità sourced)

La build stampa la riga sotto un tag CATALOG_ERROR con il codice breve di questa condizione, E0251, e accanto il file della Recipe.

Come risolvere: ometti del tutto il campo source: (o impostalo a null) se la Recipe è sourceless, oppure fornisci un percorso / URI / oggetto source strutturato non vuoto se la Recipe è sourced.

No Recipe is mapped for a component or feature instance (Nessuna Recipe è mappata per un’istanza di componente o di funzionalità)

Il tipo di un’istanza non ha alcuna mappatura nel Manifest che si risolva in una Recipe presente nel catalogo. La selezione della Recipe avviene solo tramite mappatura: il compilatore non sceglie mai una Recipe leggendo spec.implements: e scegliendo tra i candidati, quindi un tipo non mappato provoca un arresto, indipendentemente da quante Recipes lo implementino. implements orienta la scelta; l’autore la compie; il Manifest la registra.

La stessa condizione copre una mappatura che esiste ma non porta da nessuna parte — un valore in una struttura di riferimento accettata che nomina una Recipe che il catalogo non contiene, inclusa una presente con una versione diversa da quella vincolata dal valore, e una il cui nome semplice è offerto da due capacità insieme. Nessuna delle due si risolve in una Recipe che si possa dire scelta dall’autore. Un valore di mappatura la cui struttura nessun riferimento può esprimere viene segnalato a parte, sotto «Manifest mapping value is not a shape a recipe reference accepts (Il valore di mappatura del Manifest non ha una struttura accettata da un riferimento a ricetta)» più sopra, così l’affermazione che un’entità è assente viene fatta solo riguardo a un riferimento che avrebbe potuto risolversi.

Messaggi emessi, per un’istanza di componente. Dove una mappatura esiste e nomina qualcosa di assente:

no recipe resolved for component/feature instance: add an explicit Manifest mapping for its type (Manifest, at .spec.components.<instance>, "<instance>", of type "<type>", mapped to recipe "<uri>"). correct the mapping value in the Manifest, or publish the recipe it names (nessuna ricetta risolta per l’istanza di componente/funzionalità: aggiungi una mappatura esplicita nel Manifest per il suo tipo (Manifest, con l’istanza, il suo tipo e la ricetta a cui è mappata). correggi il valore della mappatura nel Manifest, oppure pubblica la ricetta che nomina)

Dove non esiste alcuna mappatura e sono presenti Recipes che implementano il tipo, queste sono elencate come candidati da fissare:

no recipe resolved for component/feature instance: add an explicit Manifest mapping for its type (Manifest, at .spec.components.<instance>, "<instance>", of type "<type>", recipes implementing it "<recipe-uris>"). pin one of them in the Manifest (nessuna ricetta risolta per l’istanza di componente/funzionalità: aggiungi una mappatura esplicita nel Manifest per il suo tipo (Manifest, con l’istanza, il suo tipo e le ricette che lo implementano). fissane una nel Manifest)

E dove nulla implementa il tipo, non c’è nulla da elencare:

no recipe resolved for component/feature instance: add an explicit Manifest mapping for its type (Manifest, at .spec.components.<instance>, "<instance>", of type "<type>"). no recipe in the catalog implements this type; write one, then map the type to it (nessuna ricetta risolta per l’istanza di componente/funzionalità: aggiungi una mappatura esplicita nel Manifest per il suo tipo (Manifest, con l’istanza e il suo tipo). nessuna ricetta nel catalogo implementa questo tipo; scrivine una, poi mappa il tipo su di essa)

In un workspace che non nomina alcuna directory di catalogo, le Recipes cercate sono solo quelle fissate dal lockfile: quelle di un registry non vengono elencate, e un Manifest che non ne mappa nessuna per il tipo non ne fissa nessuna. In quel caso, quando nessuna Recipe fissata implementa il tipo, l’assenza viene affermata riguardo a ciò che è fissato anziché riguardo al catalogo, e il messaggio lo dice:

no recipe resolved for component/feature instance: add an explicit Manifest mapping for its type (Manifest, at .spec.components.<instance>, "<instance>", of type "<type>"). no recipe the lockfile pins implements this type; with no catalog directory, the recipes searched are only those the lockfile pins, not a registry’s; pin one a registry publishes in the Manifest, or write one, then map the type to it (nessuna ricetta risolta per l’istanza di componente/funzionalità: aggiungi nel Manifest una mappatura esplicita per il suo tipo (Manifest, nella posizione, per l’istanza e del tipo indicati). nessuna ricetta fissata dal lockfile implementa questo tipo; senza una directory di catalogo, le ricette cercate sono solo quelle fissate dal lockfile, non quelle di un registry; fissa nel Manifest una ricetta pubblicata da un registry, oppure scrivine una, poi mappa il tipo su di essa)

A un tipo che l’Aggregate scrive senza versione vengono proposte le Recipes che implementano la versione con cui la build lo compila — la versione più alta di quel Component presente nel catalogo. A un’istanza di core/datastore/postgres, con il catalogo che contiene quel Component alla versione 1.0.0, viene proposta ogni Recipe che dichiara spec.implements: core/datastore/postgres:1.0.0, oltre a quelle che dichiarano il tipo senza versione o un intervallo caret che ammette 1.0.0. A un tipo di cui il catalogo non contiene alcun Component vengono proposte solo le Recipes che dichiarano quel tipo stesso senza versione.

Un’istanza di feature segnala questi casi in una forma propria, ciascuno dopo la frase della condizione. Un tipo di feature che l’Aggregate scrive senza versione viene abbinato come un tipo di componente, alla versione a cui la build lo compila — la versione più alta di quella Feature presente nel catalogo — e un messaggio che nomina <type>:<version> nomina il tipo a quella versione, che è ciò che è stato cercato nel catalogo. Quando la Recipe a cui è mappato il componente di un’associazione è nota, le FeatureRecipes si distinguono in base alla capacità a cui quella Recipe si lega: quelle che si legano alla capacità del componente vengono proposte per prime, e una FeatureRecipe che si lega a un’altra capacità viene comunque renderizzata, come output proprio accanto a quello del componente anziché al suo interno, quindi, quando nessuna si lega alla capacità del componente, vengono proposte invece quelle. Una mappatura che non porta da nessuna parte si legge feature "<instance>" (type "<type>"): the Manifest maps it to feature recipe "<uri>", which is not in the catalog. Quando delle FeatureRecipes implementano il tipo per la capacità del componente, vengono elencate solo quelle: feature "<instance>" (type "<type>"); feature recipes implementing it for capability "<capability>", the capability its component's Recipe binds to: [<recipe-uris>]; pin one in the Manifest. Quando lo implementano solo per altre capacità: feature "<instance>" (type "<type>"); no feature recipe in the catalog implements <type>:<version> for capability "<capability>", the capability its component's Recipe binds to; feature recipes implementing it for other capabilities: [<recipe-uris>]; pin one of those in the Manifest, and it renders as its own output beside the component's, or write one for "<capability>", then map the type to it. Quando nessuna implementa affatto il tipo: feature "<instance>" (type "<type>"); no feature recipe in the catalog implements <type>:<version>; write one, then map the type to it. E quando la capacità non è nota — la mappatura del componente stesso non si risolve in alcuna Recipe, cosa che viene segnalata a parte, oppure l’associazione è scritta su un confine, i cui componenti possono essere renderizzati tramite diverse capacità — viene elencato ogni implementatore: feature "<instance>" (type "<type>"); feature recipes implementing it: [<recipe-uris>]; pin one in the Manifest. In un workspace che non nomina alcuna directory di catalogo, le FeatureRecipes cercate sono solo quelle fissate dal lockfile: quelle di un registry non vengono elencate, e un Manifest che non ne mappa nessuna per il tipo non ne fissa nessuna. In quel caso le affermazioni di assenza riguardano ciò che è fissato anziché il catalogo, e lo dicono. Quando nessuna implementa il tipo: feature "<instance>" (type "<type>"); no feature recipe the lockfile pins implements <type>:<version> for capability "<capability>", the capability its component's Recipe binds to; with no catalog directory, the feature recipes searched are only those the lockfile pins, not a registry's; pin one a registry publishes in the Manifest, where one for another capability renders as its own output beside the component's, or write one for "<capability>", then map the type to it — e quando la capacità non è nota, il messaggio non ne nomina nessuna e termina con pin one a registry publishes in the Manifest, or write one, then map the type to it. Quando delle FeatureRecipes fissate lo implementano solo per altre capacità, il messaggio per quel caso riporta no feature recipe the lockfile pins implements al posto di no feature recipe in the catalog implements, con la stessa proposizione dopo la capacità.

Come risolvere: aggiungi la mappatura richiesta dal messaggio, sotto spec.mappings.components.type nel Manifest, con il tipo di componente come chiave e la Recipe come valore. Dove il messaggio elenca dei candidati, scegline uno — quell’elenco è esattamente l’insieme delle Recipes che dichiarano di implementare il tipo alla versione in cui la build lo risolve. Dove nomina una Recipe non presente nel catalogo, correggi il valore oppure aggiungi la Recipe a una directory di catalogo letta dalla build; una versione nel valore deve corrispondere a una versione presente nel catalogo. Dove nulla implementa il tipo, il pezzo mancante è la Recipe stessa. Dove il messaggio dice che le ricette o le ricette di funzionalità cercate sono solo quelle fissate dal lockfile, il workspace non legge alcuna directory di catalogo, quindi un registry potrebbe comunque pubblicare una Recipe o una FeatureRecipe che implementa il tipo: mappare il tipo su di essa nel Manifest è ciò che fa sì che il pull la scarichi e la fissi.

A Manifest name mapping names nothing in the build (Una mappatura per nome del Manifest non nomina nulla nella build)

Una chiave sotto spec.mappings.components.name o spec.mappings.features.name non nomina alcuna istanza di componente, né alcuna associazione, presente nella build. Il livello name viene confrontato con il nome esatto della cosa che viene realizzata: una chiave components.name con il nome di un’istanza di componente così come lo scrive l’Aggregate, e una chiave features.name con il nome proprio di un’associazione — la chiave sotto cui è scritta nei features: di un componente, oppure <alias>.<slot> per un’associazione scritta su una connessione — mai con il nome del componente su cui si trova l’associazione. Una chiave che non nomina nulla non verrebbe mai consultata: ogni istanza a cui era destinata si risolverebbe tramite il livello type, e la build terminerebbe senza una parola sulla voce che ha ignorato. Perciò la build si arresta, prima di qualsiasi rendering.

Il messaggio nomina il Manifest, la chiave e la sezione in cui è scritta, i nomi di quel genere che la build contiene effettivamente — ristretti al tipo implementato dalla Recipe o dalla FeatureRecipe della voce, dove quel tipo è noto e la build ne contiene uno — e, dove può stabilirlo, il nome che probabilmente intendevi: per una chiave features.name che è il nome di un componente, le associazioni di quel tipo che il componente porta; per una chiave components.name che è il nome di un’associazione, il componente che la porta; e altrimenti un nome a una modifica di distanza.

Messaggio emesso, per una chiave features.name scritta come nome del componente su cui si trova l’associazione:

a Manifest name mapping’s key names no component instance or attachment in this build, so the entry binds nothing: Manifest "<manifest>", key "<component>" under mappings.features.name: no attachment in this build is named "<component>"; a features.name key names an attachment by its own name — the key it is written under in a component’s features, or <alias>.<slot> for one written on a connection — never the component it is attached to; attachments of type "<feature-type>" in this build: "<attachments>"; "<component>" is a component, and a features.name key names the attachment rather than the component it is attached to — did you mean "<attachment>"? (la chiave di una mappatura per nome del Manifest non nomina alcuna istanza di componente né alcuna associazione in questa build, quindi la voce non lega nulla: Manifest, chiave sotto mappings.features.name: nessuna associazione in questa build ha quel nome; una chiave features.name nomina un’associazione con il suo nome proprio — la chiave sotto cui è scritta nei features di un componente, oppure alias e slot per una scritta su una connessione — mai il componente a cui è associata; associazioni del tipo indicato in questa build: elencate; quel nome è un componente, e una chiave features.name nomina l’associazione anziché il componente a cui è associata — intendevi l’associazione suggerita?)

E per una chiave components.name a una modifica di distanza dal nome di un’istanza:

a Manifest name mapping’s key names no component instance or attachment in this build, so the entry binds nothing: Manifest "<manifest>", key "<key>" under mappings.components.name: no component instance in this build is named "<key>"; a components.name key names a component instance exactly as the Aggregate writes it; component instances of type "<component-type>" in this build: "<instances>"; did you mean "<instance>"? (la chiave di una mappatura per nome del Manifest non nomina alcuna istanza di componente né alcuna associazione in questa build, quindi la voce non lega nulla: Manifest, chiave sotto mappings.components.name: nessuna istanza di componente in questa build ha quel nome; una chiave components.name nomina un’istanza di componente esattamente come la scrive l’Aggregate; istanze di componente del tipo indicato in questa build: elencate; intendevi l’istanza suggerita?)

Ogni chiave che non nomina nulla viene segnalata in una sola build, nell’ordine in cui il Manifest le scrive.

Come risolvere: rinomina la chiave con il nome suggerito dal messaggio, o con uno dei nomi che elenca — per un’associazione, il nome sotto cui è scritta, non quello del suo componente. Se la voce non serve più, rimuovila; le istanze di quel tipo si risolvono allora tramite il livello type.

A Manifest maps two version-distinct keys onto one type (Un Manifest mappa due chiavi distinte per versione su un unico tipo)

Una ricerca per tipo ha trovato corrispondenza con più di una chiave di mapping del Manifest. Le chiavi di tipo vengono confrontate tollerando la versione, quindi core/api-server, core/api-server:1.0.0 e core/api-server:2.0.0, scritte come chiavi di mapping separate, rispondono tutte per lo stesso tipo di base — e una ricerca che ne raggiunge due ha due Recipes tra cui scegliere e nessuna regola per preferirne una.

Il build si arresta anziché risolvere la chiave che gli è capitato di leggere per prima. Sceglierne una renderebbe l’output renderizzato dipendente dall’ordine in cui il mapping è stato percorso, che è esattamente ciò che l’output identico byte per byte esclude.

Messaggio emesso:

manifest maps multiple version-distinct keys to the same base type; the type-to-recipe lookup is ambiguous: type "<type>" matches version-distinct keys [<keys>] — pin the authored type’s version or remove the duplicate mapping keys (il Manifest mappa più chiavi distinte per versione sullo stesso tipo di base; la ricerca da tipo a Recipe è ambigua: il tipo corrisponde a chiavi distinte per versione — fissa la versione del tipo scritto oppure rimuovi le chiavi di mapping duplicate)

Come risolvere: due direzioni, e il messaggio le indica entrambe. Rimuovi le chiavi di mapping duplicate, mantenendo quella che deve rispondere per il tipo — è la scelta giusta quando le chiavi in più sono residui di un aumento di versione. Oppure fissa la versione dal lato di chi scrive il tipo, in modo che il tipo dichiarato dal componente indichi esattamente la chiave che intendevi, il che è giusto quando le diverse chiavi sono deliberate e componenti diversi vogliono davvero Recipes diverse.

Two catalog entities in one directory share an identity (Due entità del catalogo in una stessa directory condividono un’identità)

Due entità dello stesso tipo, caricate dalla stessa directory di catalogo, hanno la stessa identità. Un’identità è ciò che un riferimento nomina, quindi due file che rivendicano una sola identità lasciano a ogni riferimento verso di essa due risposte.

All’interno di una directory questo arresta il build; tra directory diverse no. La stessa identità presente in due diverse directory di catalogo viene risolta come un oscuramento in cui vince la prima — vince la directory elencata prima — ed è ciò che permette a una directory locale di sovrascrivere deliberatamente un’entità pubblicata. Solo una collisione all’interno di una stessa directory è un errore di scrittura che nessuna lettura può rendere intenzionale.

La regola è la stessa per ogni tipo di entità indicizzato: Component, Feature, Recipe, FeatureRecipe, Plugin, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary e Aggregate. L’arresto è posizionato sul secondo file e indica il tipo e l’identità che sono entrati in collisione.

Messaggio emesso:

duplicate entity identity within a single catalog directory (Component identity "<identity>") (identità di entità duplicata all’interno di un’unica directory di catalogo (identità di Component))

con la parola propria del tipo al posto di Component — recipe identity, feature recipe identity, Plugin identity, SchemaLibrary identity e così via.

Come risolvere: rinomina una delle due entità, oppure spostala in una directory propria. Per una Recipe o una FeatureRecipe l’identità include l’ambito del provider e la versione, quindi due file che differiscono solo per la versione non entrano in collisione — una vera collisione in quel caso significa che la stessa versione è stata pubblicata due volte. La causa abituale è copiare il file di un’entità per iniziarne una nuova e dimenticare di cambiare metadata.name.

Due luoghi vengono letti per intero anziché un file alla volta: una directory di catalogo, da ogni documento sotto la quale una ricerca per nome può trarre la risposta, e la directory che contiene una Release, rispetto ai cui Aggregates e Manifests viene risolta una Release che li nomina per identità. Un link simbolico tra quei file può portare ovunque sulla macchina, quindi ognuna di queste directory ha una directory entro cui le sue letture devono restare, e un link che ne esce non viene letto. Il confine del workspace enuncia la regola che qui si applica e gli altri percorsi che vincola.

Quale directory sia dipende da dove si trova la directory che viene letta:

  • Il workspace, per una directory di catalogo o la directory di una Release al suo interno. Questo vale per la directory convenzionale catalog del workspace ogni volta che nessuno l’ha nominata — quando viene letta solo perché esiste: in quel caso appartiene al workspace stesso, quindi una catalog che è essa stessa un link che porta fuori dal workspace non viene letta.
  • Una directory che hai nominato e che si trova fuori dal workspace, per ciò che si trova al di sotto: una directory di catalogo che passi con --catalog, o che la configurazione del workspace elenca sotto catalog_dirs — per il workspace o per una singola Release — e la directory di una Release che nomini, o che la configurazione nomina, che si trova fuori dal workspace. La directory stessa viene usata come l’hai nominata — una che è un link viene letta dove punta — e ciò che viene letto al di sotto resta al suo interno. Questo include la directory convenzionale catalog una volta che la nomini: elencata sotto catalog_dirs, o passata con --catalog, una catalog che è un link che porta fuori dal workspace viene letta dove punta, come qualsiasi altra directory che nomini. Nominare invece il luogo a cui punta, in qualsiasi grafia, o una directory al di sopra di quel luogo, la nomina anch’esso: la directory che hai nominato legge già ciò che si trova lì, quindi viene letta una sola volta, attraverso quella directory. Nominare una directory nella configurazione è il modo in cui un workspace legge entità conservate al di fuori di esso.

Ciò che viene giudicato è ogni voce da cui la lettura prenderebbe qualcosa: un link a un file con il nome di un documento YAML, e un link a una directory, che può contenere documenti propri. Un link che porta in un punto all’interno della directory entro cui la lettura deve restare viene letto dove l’attraversamento lo incontra. Un link a un file da cui nessuna lettura del catalogo prende nulla — un file di note, un archivio di chart — non viene giudicato qui, e un link che non porta da nessuna parte non ha nulla dietro di sé da leggere.

Una ricerca da cui dipende una compilazione si ferma su un link del genere anziché scavalcarlo. L’entità dietro il link potrebbe essere quella che un riferimento nomina, e scavalcarla in silenzio permetterebbe a un’altra entità con lo stesso nome, proveniente da una directory di catalogo successiva, di risolversi al suo posto. Quindi aggrega build, aggrega pull, aggrega validate, aggrega inspect ovunque legga il catalogo, un lint di una singola Release, e le richieste dell’editor e di un assistente che eseguono il build, l’anteprima, il grafo, la validazione o la descrizione di una Release si fermano tutti prima che venga risolto qualsiasi cosa, indicando il link. Un lint dell’intero catalogo si ferma allo stesso modo: il suo verdetto risponde per ogni documento contenuto nelle directory di catalogo, quindi non riporta un catalogo pulito mentre uno di essi non ha potuto essere letto. La directory della Release è soggetta alla stessa regola ovunque una Release nomini il proprio Aggregate o il proprio Manifest per identità, o un Manifest nomini in quel modo il Manifest che estende, e la scansione si ferma su un link tra i documenti accanto alla Release anche quando il link non è quello che un riferimento nomina, per la stessa ragione per cui lì la ferma un duplicato: la directory non può rispondere per un nome mentre uno dei suoi documenti non può essere letto. La Release su cui è stata invocata l’operazione — o un Manifest che ispezioni da solo — non è uno di quei documenti: è stata letta dove è stata nominata, quindi una Release che è essa stessa un link che porta fuori viene letta dove punta, e ciò che nomina viene cercato accanto al link, nella directory in cui l’hai nominata (Una Release o un Manifest nominati attraverso un link).

Un elenco invece scavalca un link del genere, e non elenca nulla di ciò che sta dietro. L’indice delle entità dell’editor, i suoi completamenti e i candidati che propone non elencano un’entità rappresentata da un link che porta fuori, e l’indice delle entità indica un link del genere all’interno del workspace tra i link che non ha letto.

I file di configurazione del workspace sono vincolati al workspace allo stesso modo. Ogni .aggrega-config.yaml dalla radice del workspace fino alla directory in cui viene eseguito un comando, e il .aggrega-config-append-ci.yaml che una pipeline tiene accanto a uno qualsiasi di essi, è contenuto proprio del workspace. Uno che è un link che porta fuori dal workspace — o che viene raggiunto attraverso un link di directory che porta fuori — non viene letto, e poiché ogni comando, il server di linguaggio dell’editor e gli strumenti di un assistente leggono la configurazione prima di qualsiasi altra cosa, ciascuno si ferma lì, indicando il link, anziché funzionare con una configurazione composta da ciò che è rimasto. Il server di linguaggio, e il server di un assistente che comunica sui propri stream, si avviano comunque su un workspace del genere: gli elenchi delle sue Releases e delle sue entità rispondono, letti senza nulla di configurato, e indicano il file tra i link che non hanno letto, mentre ogni altra richiesta che la configurazione determina viene rifiutata con questa condizione, indicando il link. Il rimedio indicato da questo messaggio è quello proprio della configurazione: il file di configurazione globale è l’unica configurazione letta ovunque sia conservata, indicata con --config o AGGREGA_CONFIG.

Il lockfile di una Release è vincolato allo stesso modo, sia dove viene letto sia dove viene scritto. Il lockfile accanto a una Release viene letto per i pin rispetto ai quali risolvono un build, un pull, una validazione, un lint, un’ispezione, aggrega cache prune e le richieste dell’editor e di un assistente, ed è vincolato alla directory a cui è vincolata la sua scrittura: il workspace, oppure la directory propria della Release per una Release nominata al di fuori di esso. Uno che è un link che porta fuori non viene letto, e ciascuna di queste operazioni si ferma indicando il link anziché risolvere rispetto a pin conservati altrove sulla macchina, o senza di essi. Il rimedio indicato da questo messaggio è quello proprio del lockfile: ha un solo posto, accanto alla Release, dove un pull lo scrive.

Un file letto accanto a un’entità è vincolato allo stesso modo. Due operazioni leggono un file che si trova accanto al documento proprio di un’entità anziché uno nominato da un riferimento. Fissare un’entità, o pubblicarla, legge ogni altro documento YAML nella directory dell’entità per stabilire se un’altra entità la condivide. Il caricamento di un’entità Plugin scritta in una directory di catalogo legge il .wasm compilato posto accanto a essa. Ciascuno è vincolato alla directory sotto cui è stato letto il documento proprio dell’entità — il workspace, una directory di catalogo che hai nominato al di fuori di esso oppure, per un’entità che fissi o pubblichi nominandone il documento al di fuori del workspace, la directory propria di quel documento — e uno che è un link che ne porta fuori non viene letto. aggrega pin, aggrega push con o senza --dry-run, un pull che fissa, e le operazioni di pin e di pubblicazione dell’editor e di un assistente si fermano indicando il link, perché un documento rimasto non letto potrebbe essere l’entità che si mette di mezzo. Anche un build o un pull che carica il plugin si ferma indicando il link, anziché eseguire byte conservati altrove sulla macchina o cercare il plugin da un’altra parte. Il rimedio indicato da questo messaggio è quello proprio di un file accanto a un’entità: conserva lì il file stesso.

La cache degli artifact del workspace è vincolata allo stesso modo, sia dove viene letta sia dove viene scritta. Tutto ciò che viene letto dalla cache sotto artifact_cache_dir — un’entità, un plugin o una libreria in cache e il manifest accanto, un archivio sorgente e i suoi metadati, un input esterno fissato, un bundle di firma, l’indice di ricerca locale di un registry — e ogni voce del workspace elencata da aggrega cache status, aggrega cache prune e aggrega cache clear, è vincolato alla directory a cui è vincolata una scrittura nella cache: la directory della cache stessa, tanto quella predefinita .aggrega/cache quanto una che la configurazione nomina risalendo oltre la radice del workspace. Qualsiasi cosa al suo interno che sia un link che porta fuori dalla directory della cache — altrove all’interno del workspace come in qualsiasi altro luogo — non viene letta, e nemmeno nulla dietro una directory della cache scritta all’interno della radice del workspace che sia essa stessa un link che porta fuori dal workspace: un build, un pull, una validazione, una ricerca, i tre comandi della cache e le richieste dell’editor e di un assistente che leggono la cache si fermano indicando il link — compreso il contenuto che la cache conserva sotto un digest registrato, poiché un digest dice che cosa sono i byte, non da dove possono essere letti. Una directory della cache scritta all’interno della radice del workspace che è un link verso un altro punto del workspace viene letta dove porta. L’avviso di deprecazione stampato da aggrega inspect, che non decide nulla, è escluso. Un prune o un clear incontra una delle directory proprie della cache che sia un link che porta fuori dalla directory della cache, o una directory della cache che sia essa stessa un link che porta fuori dal workspace, come la rimozione che sarebbe, sotto «A path the operation writes leads through a link out of the directory it must stay inside (Un percorso che l’operazione scrive porta, attraverso un link, fuori dalla directory entro cui deve restare)», prima di elencare qualsiasi cosa. Il rimedio indicato da questo messaggio è quello proprio della cache: una volta rimosso il link, un pull riempie di nuovo la cache, e una cache conservata altrove si indica con artifact_cache_dir, relativa alla radice del workspace, anziché raggiungerla attraverso un link.

Un repository recuperato da una sorgente è vincolato al proprio checkout. Quando un pull — aggrega pull, oppure un build o una richiesta dell’editor o di un assistente che risolve le dipendenze di una Release — recupera una sorgente git-repository, esegue il checkout del repository e archivia la directory indicata dalla sorgente, e il checkout è una directory a sé: ogni link che il repository contiene, compreso module_subdir stesso, è vincolato a esso. Un link a un file o a una directory all’interno del repository viene archiviato come ciò a cui punta, con il nome del link. Un link che porta fuori dal repository — che potrebbe puntare a qualsiasi file sulla macchina che esegue il pull — non viene letto: il pull si ferma indicando il link e dove porta, e nulla viene messo in cache. Il checkout è una directory temporanea rimossa quando il pull si ferma, quindi il messaggio indica il link con la sua posizione nel repository — chart/secret.txt, come nella prima riga dell’output della riga di comando e nella frase — e la directory entro cui deve restare come il repository e la revisione indicati dalla sorgente: which must stay inside the repository <url> at <ref> (commit <commit>), oppure at commit <commit> dove la sorgente non indica alcun ref o indica il commit stesso. Il luogo a cui porta il link è indicato come il percorso che ha sulla tua macchina. Il rimedio indicato da questo messaggio è quello proprio del repository: il link è committato lì, quindi va cambiato lì — facendolo puntare all’interno del repository, o sostituendolo con il file stesso — e la sorgente nomina poi una revisione che contiene la modifica. Anche un link di directory che riconduce a una directory che l’archiviazione sta già leggendo attraverso di esso ferma il pull, perché l’albero che rappresenta non ha fine; quel rifiuto è un errore semplice anziché questa condizione.

Le sovrapposizioni lette da una generazione del catalogo sono vincolate allo stesso modo. aggrega plugin gen-catalog --from-embedded legge ogni sovrapposizione al di sotto della directory delle sovrapposizioni che riceve — digitata con --overlay, scelta nell’editor o indicata da un assistente — e vincola ciascuna alla directory sotto cui viene letta quella directory delle sovrapposizioni: il workspace, per una directory delle sovrapposizioni al suo interno, e la directory delle sovrapposizioni stessa per una indicata al di fuori del workspace. La directory delle sovrapposizioni viene usata come l’hai nominata — una che è un link viene letta dove punta. Una sovrapposizione al di sotto di essa che è un link che porta fuori dalla directory a cui è vincolata non viene letta, e nemmeno un link di directory che ne porta fuori, che può contenere sovrapposizioni proprie: la generazione si ferma indicando il link, senza scrivere nulla, anziché generare senza la sovrapposizione. Una sovrapposizione che è un link che porta altrove all’interno della directory a cui è vincolata viene letta dove punta; un link di directory che porta al suo interno non viene percorso. Il rimedio indicato da questo messaggio è quello proprio di una sovrapposizione: conserva la sovrapposizione stessa al di sotto della directory delle sovrapposizioni, oppure indica come directory delle sovrapposizioni una directory che contenga tutte le sovrapposizioni.

Una directory che importi è vincolata a sé stessa. aggrega import con una directory, lo strumento di importazione dell’assistente e il metodo aggrega/import della sessione consegnano all’importatore i file della directory selezionati dai suoi pattern di file, ciascuno nella propria posizione all’interno della directory, quindi la directory è quella entro cui restano queste letture, ovunque si trovi — all’interno del workspace come al di fuori. Viene valutata ogni voce da cui l’importazione prenderebbe qualcosa: un link a un file selezionato da uno dei pattern pertinenti — i pattern dell’importatore che serve il formato indicato o, dove il formato viene riconosciuto, quelli di ogni importatore tra cui l’importazione sceglie, compresi gli importatori core del compilatore — e un link a una directory, in cui non si entra mai. Un link che esce dalla directory, verso un altro punto del workspace o altrove, non viene letto: l’importazione si arresta indicando il link prima che venga aperto qualsiasi file della directory, senza scrivere nulla. Un link selezionato a un file in un altro punto all’interno della directory viene letto dove punta, con il nome del link stesso, e un link a un file che nessun pattern seleziona non viene né valutato né letto. La directory stessa viene usata come l’hai indicata — una directory che è un link viene letta dove punta. Raggiunto tramite un listener, lo strumento dell’assistente indica il link con la sua posizione nel workspace e non dice nulla di dove porta. Il rimedio indicato da questo messaggio è quello proprio di una directory importata: tieni il file stesso nella directory anziché un link a esso, oppure importa la directory a cui porta il link.

Messaggio emesso. Si apre con la frase propria della condizione, poi il percorso raggiunto dalla lettura, la directory entro cui deve restare, il link che incontra lungo il percorso e il luogo a cui porta quel link, poi il rimedio:

a file this operation reads leads through a link out of the directory it must stay inside (reading <workspace>/catalog-local/component/app/1.0.0/component.yaml, which must stay inside <workspace>, the link <workspace>/catalog-local/component/app/1.0.0/component.yaml leads to <elsewhere>/component.yaml). nothing was read through that link. Remove the link, or make it lead to a place inside <workspace>. To read what is kept outside, list the directory holding it as a catalog directory in the workspace configuration, rather than reaching it through a link beneath one: a listed directory is read where it leads, even when it is itself a link (un file letto da questa operazione esce, attraverso un link, dalla directory entro cui deve restare (leggendo un file che deve restare all’interno del workspace, il link porta altrove). nulla è stato letto attraverso quel link. Rimuovi il link, o fallo portare a un luogo all’interno del workspace. Per leggere ciò che è tenuto all’esterno, elenca la directory che lo contiene come directory di catalogo nella configurazione del workspace, anziché raggiungerla tramite un link sotto una di esse: una directory elencata viene letta dove porta, anche quando è essa stessa un link)

La diagnostica non porta alcuna categoria: a essere in errore è la disposizione su disco, non un documento che hai scritto.

Come risolvere: sostituisci il link con una copia di ciò a cui porta, oppure rimuovilo; oppure, dove l’entità deve restare al di fuori del workspace, elenca la directory che la contiene sotto catalog_dirs nella configurazione del workspace, o passala con --catalog, così che la directory venga letta come una directory di catalogo a sé stante. Elenca la directory a cui porta il link, non quella in cui si trova: un link incontrato sotto una directory viene valutato allo stesso modo comunque quella directory sia stata letta, quindi elencarla non cambia nulla. Dove il link è la directory catalog convenzionale del workspace stessa, basta elencare catalog — o la directory a cui punta — sotto catalog_dirs, o passare l’una o l’altra con --catalog, poiché una directory che indichi viene letta dove punta. Dove il link è il lockfile di una Release, rimuovilo ed esegui di nuovo il pull della Release, che scrive un nuovo lockfile accanto a essa. Un Manifest non ha un livello di catalogo, quindi un Manifest letto dalla Release si tiene accanto alla Release stessa. Dove il link è un file di configurazione, sostituiscilo con una copia tenuta nel workspace; una configurazione che intendi condividere tra workspace si legge indicandola come file di configurazione globale, con --config o AGGREGA_CONFIG, al di sotto dei file propri di ciascun workspace. Dove il link si trova accanto a un’entità che viene fissata o pubblicata, sostituiscilo con il file stesso, oppure sposta un documento che è un’entità in una directory a sé; dove è il .wasm accanto a un’entità Plugin, colloca lì il .wasm compilato stesso. Dove il link è la directory della cache degli artefatti o qualcosa al suo interno, rimuovilo — un pull riempie di nuovo la cache — oppure, per tenere la cache altrove, imposta artifact_cache_dir su quella directory, scritta relativamente alla radice del workspace (../shared-cache). Dove il link è committato in un repository che una sorgente git-repository recupera, modificalo in quel repository — fallo puntare all’interno del repository, oppure committa il file stesso — e indica la revisione che contiene la modifica. Dove il link è una sovrapposizione sotto la directory delle sovrapposizioni di una generazione del catalogo, sostituiscilo con la sovrapposizione stessa, oppure indica come directory delle sovrapposizioni una directory che contiene ogni sovrapposizione. Dove il link si trova in una directory che importi, tieni il file stesso nella directory anziché un link a esso, oppure importa la directory a cui porta il link.

A reference to another file leads out of the directory it must stay inside (Un riferimento a un altro file esce dalla directory entro cui deve restare)

Una Release e un Manifest possono indicare un altro file tramite un percorso: aggregate: e manifest: di una Release scritti come ./… o ../…, il suo extends:, l’extends: di un Manifest scritto come percorso e i parameters: { $import: … } di una Release. Un documento nel workspace raggiunge in questo modo solo file all’interno del workspace. Una Release che si trova al di fuori del workspace — una che indichi sulla riga di comando, o una indicata dalla configurazione del workspace — e un Manifest che indichi da solo sulla riga di comando al di fuori del workspace raggiungono solo file all’interno della propria directory: quella directory è una radice a sé stante, come lo è una directory che indichi al di fuori del workspace, e ogni Release a cui porta la sua catena extends: è vincolata alla stessa directory. Un percorso che, così come è scritto, risale fuori da quella directory e un percorso che, così come è scritto, resta all’interno ma lungo il cammino incontra un link simbolico che porta fuori vengono entrambi rifiutati, e nulla viene letto dal file che indicano. Un percorso che porta a un file non ancora presente sotto la directory non viene rifiutato qui; viene segnalato come file che non è stato possibile leggere. Il confine del workspace spiega perché viene vincolato un riferimento oltre al percorso che indichi.

Il punto da cui un percorso viene risolto segue la stessa regola che il riferimento del linguaggio insegna per ciascuna chiave: aggregate: e manifest: di una Release, e l’extends: di un Manifest, accanto alla Release indicata da un comando o da una richiesta — oppure, per un Manifest che indichi da solo, accanto a quel Manifest; l’extends: di una Release e un $import: dei parametri, accanto alla Release che lo scrive, così ogni anello di una catena extends: indica il proprio genitore accanto a sé. La diagnostica indica la directory da cui è stato risolto.

Un nome anziché un percorso non viene valutato qui — aggregate: payments, extends: base-manifest. Viene cercato tra i documenti accanto alla Release e, per un Aggregate, nelle directory di catalogo, che sono vincolate dalla regola in «A file the operation reads leads through a link out of the directory it must stay inside (Un file che l’operazione legge porta, attraverso un link, fuori dalla directory entro cui deve restare)» più sopra.

Ogni superficie che risolve ciò che una Release indica si arresta su di esso, prima che il file venga letto: aggrega pull, aggrega build, aggrega validate, aggrega inspect di una Release o di un Manifest, un lint di una singola Release e le richieste dell’editor e di un assistente che compilano, visualizzano in anteprima, rappresentano come grafo, validano o descrivono una Release. Nell’editor la diagnostica viene posta sulla chiave della Release che ha portato al file.

Messaggio emesso. Si apre con la frase propria della condizione, poi il riferimento così come è scritto, il documento in cui è scritto per un extends: e un $import: dei parametri, la directory da cui viene risolto, il luogo a cui porta, la directory entro cui deve restare e il link, dove uno lo porta fuori; poi il rimedio. Per un documento nel workspace:

a reference a document makes to another file leads out of the directory it must stay inside (.spec.aggregate: ../shared/app.yaml, resolved from <workspace>, which leads to <elsewhere>/shared/app.yaml, outside the workspace <workspace>). nothing was read from that file. A document in the workspace reaches only files inside <workspace>: move the file there — or, where a link carries the reference out, make the link lead there — or open the workspace at a directory holding both documents. An Aggregate kept outside that directory is reached by its name rather than a path, from a catalog directory the workspace configuration lists (un riferimento che un documento fa a un altro file esce dalla directory entro cui deve restare: il riferimento, risolto dal workspace, porta al di fuori del workspace. nulla è stato letto da quel file. Un documento nel workspace raggiunge solo file all’interno del workspace: sposta lì il file — oppure, dove un link porta fuori il riferimento, fai in modo che il link porti lì — oppure apri il workspace in una directory che contenga entrambi i documenti. Un Aggregate tenuto al di fuori di quella directory si raggiunge con il suo nome anziché con un percorso, da una directory di catalogo elencata nella configurazione del workspace)

e per una Release o un Manifest indicati al di fuori del workspace, la cui directory propria è quella entro cui deve restare:

a reference a document makes to another file leads out of the directory it must stay inside (.spec.aggregate: ../aggregates/app.yaml, resolved from <directory>, which leads to <parent>/aggregates/app.yaml, outside <directory>, the directory of a document named outside the workspace <workspace>). nothing was read from that file. A Release or a Manifest named outside the workspace — on the command line, or by the workspace configuration — reaches only files inside its own directory <directory>: move the file there — or, where a link carries the reference out, make the link lead there — or name the document from a workspace holding both documents. An Aggregate kept outside that directory is reached by its name rather than a path, from a catalog directory the workspace configuration lists (un riferimento che un documento fa a un altro file esce dalla directory entro cui deve restare: il riferimento, risolto dalla directory, porta al di fuori della directory di un documento indicato al di fuori del workspace. nulla è stato letto da quel file. Una Release o un Manifest indicati al di fuori del workspace — sulla riga di comando, o dalla configurazione del workspace — raggiungono solo file all’interno della propria directory: sposta lì il file — oppure, dove un link porta fuori il riferimento, fai in modo che il link porti lì — oppure indica il documento da un workspace che contenga entrambi i documenti. Un Aggregate tenuto al di fuori di quella directory si raggiunge con il suo nome anziché con un percorso, da una directory di catalogo elencata nella configurazione del workspace)

con written in <document> dopo il riferimento per un extends: o un $import: dei parametri, e the link <link> leads to <place> alla fine, dove un link porta fuori il percorso. Un riferimento aggregate: o manifest: non indica alcun documento: una Release che ne estende un’altra può averlo ereditato da una Release più in alto nella catena, e viene comunque risolto accanto alla Release indicata dal comando.

La categoria della diagnostica è [OPS_ERROR]: il riferimento è scritto in una Release o in un Manifest.

Come risolvere: per un Aggregate tenuto al di fuori del workspace, scrivi il suo metadata.name anziché un percorso ed elenca la directory che lo contiene sotto catalog_dirs nella configurazione del workspace, o passala con --catalog — una directory di catalogo è il modo in cui un workspace raggiunge entità tenute al di fuori di esso. Un Manifest, una Release indicata da un extends: e un file di parametri vengono letti accanto alla Release e mai cercati per nome, quindi tienili all’interno del workspace, oppure apri il workspace in una directory che contenga sia la Release sia il file. Per una Release o un Manifest che hai indicato da fuori del workspace, tieni ciò che indica nella sua directory, oppure compilalo nel workspace che contiene sia il documento sia ciò che indica. Dove un link porta fuori il percorso, sostituisci il link con una copia di ciò a cui porta, oppure fallo portare all’interno della directory.

No catalog version satisfies a version constraint (Nessuna versione del catalogo soddisfa un vincolo di versione)

Un riferimento indica un’entità presente nel catalogo e fissa una versione che il catalogo non contiene: una versione esatta assente, oppure un intervallo caret a cui non corrisponde nulla di disponibile. È distinto da un semplice mancato riscontro, in cui il nome stesso è sconosciuto — qui l’entità esiste e solo la versione non può essere soddisfatta, ed è per questo che il messaggio lo dice anziché segnalare l’entità come mancante e mandarti a cercare un errore di battitura nel nome.

Ogni tipo di entità arriva qui attraverso un’unica selezione, quindi un pin non soddisfacibile si comporta allo stesso modo ovunque sia scritto: un errore di battitura nella versione nella mappatura di una Recipe di un Manifest viene rifiutato esattamente come lo stesso errore sul tipo di un componente.

La condizione è recuperabile, ed è ciò che permette all’editor di mostrarla come diagnostica mentre continui a scrivere anziché abbandonare il documento. Sulla riga di comando viene unita in un arresto.

Messaggio emesso, per un riferimento raggiunto dalle dipendenze di una Release — il tipo di un componente, un valore di mappatura di un Manifest — che indica dove è stato raccolto:

no catalog version satisfies the referenced version constraint: entity "<reference>" (referenced from <referring paths>) (nessuna versione del catalogo soddisfa il vincolo di versione referenziato)

Messaggio emesso, per un pin su un puntatore extends::

no catalog version satisfies the referenced version constraint (Component <name>, at .extends, no catalog version satisfies extends parent "<reference>") (nessuna versione del catalogo soddisfa il vincolo di versione referenziato: nessuna versione del catalogo soddisfa il genitore di extends)

con Feature al posto di Component dove è la catena di una Feature a portare il pin.

Come risolvere: cambia il pin in una versione presente nel catalogo, oppure aggiungi quella versione al catalogo. aggrega inspect elenca le versioni in cui un’entità è disponibile. Un intervallo caret a cui non corrisponde nulla di solito significa che le versioni disponibili sono tutte al di sotto del minimo che indica — amplia l’intervallo, oppure pubblica la versione che il riferimento attende.

Un pin che non ha nessuna delle forme che un pin assume è una condizione diversa, descritta più sotto in «A version pin is none of the forms a pin takes (Un pin di versione non ha nessuna delle forme che un pin assume)».

A version pin is none of the forms a pin takes (Un pin di versione non ha nessuna delle forme che un pin assume)

Un riferimento nomina un’altra entità e può fissare la versione che vuole dopo i due punti, in una di due forme: un pin esatto, cioè una versione semantica come 1.0.0 — la forma che assume il metadata.version di ogni entità — oppure un pin caret, ^ seguito da una versione come ^1.0.0, che seleziona la versione più alta compatibile con essa. Un pin che non è né l’uno né l’altro — un caret il cui testo non si legge come un intervallo di versioni, come ^garbage, oppure un pin esatto che non è una versione semantica, come 1.x, 1.0 o v1.0.0 — non nomina alcuna versione, quindi nessun catalogo potrebbe contenere ciò che chiede.

Un pin di questo tipo viene segnalato come malformato anziché come un’entità o una versione che il catalogo non contiene, così la diagnostica ti rimanda al testo che hai digitato invece di farti cercare qualcosa che non esiste. È la stessa condizione ovunque sia scritto il pin: il type di un componente o di una funzionalità, l’extends: di un Component o di una Feature, una chiave o un valore di mappatura di un Manifest, lo spec.aggregate di una Release, l’implements: di una Recipe o di una FeatureRecipe, la versione che il capability: di una Recipe fissa quando viene selezionato il plugin che la serve, e il plugin: di un passo di pipeline.

Viene segnalato dove viene segnalato un riferimento che non è stato possibile risolvere, quindi un pin malformato non cambia mai quali riferimenti si risolvono — cambia ciò che dice l’errore. Un pin ben formato ma che nessuna versione disponibile soddisfa mantiene la condizione che quella superficie segnala per esso: «No catalog version satisfies a version constraint (Nessuna versione del catalogo soddisfa un vincolo di versione)» più sopra, oppure la condizione di elemento non trovato della superficie su cui è scritto.

Solo il testo dopo gli ultimi due punti è un pin, e solo quando non contiene /. Un riferimento a un host di registry con una porta, come localhost:5000/core/api-server, quindi non contiene alcun pin — il testo dopo i due punti della porta continua il riferimento — e non viene mai segnalato come pin malformato.

Messaggio emesso, per un pin caret su un tipo di componente:

reference carries a malformed version pin (reference "<reference>", pin "<pin>", the text after ^ is not a version range, referenced from <authored location>). write the reference as , as : with a semantic version such as 1.0.0, or as :^ for the highest version compatible with it (il riferimento contiene un pin di versione malformato (riferimento, pin, il testo dopo ^ non è un intervallo di versioni, referenziato dalla posizione in cui è scritto). scrivi il riferimento come nome, come nome:versione con una versione semantica come 1.0.0, oppure come nome:^versione per la versione più alta compatibile con essa)

Un pin esatto riporta an exact pin must be a semantic version al posto della clausola sul caret. Il valore che segue indica dove è stato scritto il riferimento, con le parole della superficie che lo segnala — referenced from e la posizione in cui è scritto, in the Release's spec.aggregate oppure in the recipe's spec.implements. Dove una mappatura di un Manifest viene valutata rispetto all’implements: della sua Recipe, la voce della mappatura e il lato di essa che porta il pin — in the mapping key oppure in the recipe's spec.implements — vengono invece prima del riferimento, e l’extends: di un Component o di una Feature nomina l’entità che estende e il campo prima di esso.

Come risolvere: riscrivi il pin in una delle due forme, oppure rimuovilo per selezionare la versione più alta disponibile. Un carattere jolly come 1.x si scrive come pin caret, ^1.0.0; una versione con una v iniziale o con meno di tre numeri si scrive per intero, 1.0.0.

Every version a reference could select has been withdrawn (Ogni versione che un riferimento potrebbe selezionare è stata ritirata)

Un riferimento si risolve in un repository che il registry contiene, e ogni versione tra cui il rilevamento delle versioni avrebbe potuto scegliere è stata contrassegnata come ritirata. Non resta nulla di idoneo da selezionare.

Volutamente, questo non viene segnalato come un’entità mancante. Il repository esiste e contiene ancora quelle versioni; definirlo assente nominerebbe il problema sbagliato, ti farebbe cercare un errore di battitura e sembrerebbe un ripiego silenzioso anziché il rifiuto che è. Il messaggio nomina ogni versione ritirata con il motivo registrato per essa, così ciò che ti viene detto è ciò che ha registrato chi la pubblica.

Nominare una versione ritirata esplicitamente non è questo arresto. Una versione esatta salta completamente il rilevamento delle versioni, quindi fissarne una è il modo per continuare deliberatamente a usarla; la build segnala il ritiro e prosegue.

Messaggio emesso:

every published version this reference could select has been withdrawn: <reference>: withdrawn: <version> (<recorded reason>), <version> (<recorded reason>) (ogni versione pubblicata che questo riferimento potrebbe selezionare è stata ritirata: ritirate, ciascuna con il motivo registrato)

Come risolvere: leggi i motivi registrati, che di solito indicano verso cosa spostarsi. Migra a ciò che sostituisce l’entità ritirata — è l’esito che un ritiro chiede. Dove per ora devi mantenere quella vecchia, fissa una versione esatta nel riferimento: nominare la versione è ciò che dice che la accetti, e la build allora segnala il ritiro ogni volta anziché rifiutare.

A plugins.providers binding names a plugin that does not serve the capability (Un binding nomina un plugin che non serve la capacità)

Il blocco plugins.providers del workspace seleziona un’identità di plugin per una capacità, e nessun Plugin di rendering dei provider che serve quella capacità porta quell’identità. Il binding è una scelta esplicita che il catalogo non può onorare, quindi provoca un arresto anziché ripiegare silenziosamente su un altro plugin — un ripiego renderizzerebbe il tuo output tramite un plugin che avevi detto di non usare, senza dire nulla.

Un binding seleziona in base all’identità di coordinata del plugin — il tipo di plugin e il nome del plugin, che è anche ciò che il lockfile fissa — e può portare una versione dopo di essa.

Viene valutato indipendentemente dal fatto che una Recipe chieda la capacità. Altrimenti un binding viene letto solo quando il capability: di una Recipe lo nomina, quindi un binding con una capacità scritta male non verrebbe consultato da nulla né segnalato da nulla. Ogni build e ogni aggrega validate --release controllano quindi ogni binding che nomina un plugin: un pull risolve un binding di questo tipo che una Recipe lo usi o meno, così la build contiene il plugin e sa cosa serve, e una capacità che quel plugin non serve è sicuramente sbagliata. Il controllo legge i binding nella configurazione del workspace, non il lockfile, e non cambia nulla riguardo a quale plugin renderizza una Recipe — quello resta compito del lockfile. Un binding che nomina un plugin che la build non contiene — un plugin di registry che nessun pull ha ancora scaricato — non viene valutato finché un pull non lo ha scaricato. Un binding che non nomina alcun plugin viene valutato diversamente, come avviso: vedi «A provider binding names a capability no plugin the build reads serves (Un binding di provider nomina una capacità che nessun plugin letto dalla build serve)» in «Condizioni che non arrestano una build» più sotto.

Messaggio emesso, che aggiunge ciò che il plugin nominato serve effettivamente, e una grafia a una modifica di distanza quando la capacità del binding lo è:

plugins.providers entry names a plugin no provider-rendering plugin serving the capability matches: capability "<capability>" is bound to plugin "<plugin-identity>", but no provider-rendering plugin serving "<capability>" matches that identity; "<plugin-identity>" serves "<served capability>", and "<capability>" is one edit from "<served capability>" (la voce plugins.providers nomina un plugin a cui non corrisponde alcun plugin di rendering dei provider che serve la capacità: la capacità è legata al plugin, ma nessun plugin di rendering dei provider che la serve corrisponde a quell’identità; il plugin serve un’altra capacità, e la capacità è a una modifica di distanza da essa)

Dove il plugin nominato dal binding non è nel catalogo letto dalla build, il messaggio termina dopo «matches that identity (corrisponde a quell’identità)», perché non c’è nulla da dire su ciò che serve.

Come risolvere: controlla prima la grafia del binding rispetto alla coordinata del plugin stesso — un binding che nomina la capacità dove dovrebbe nominare il plugin è la svista più comune. Dove il messaggio nomina una capacità a una modifica di distanza da quella che hai scritto, l’errore di battitura è nel capability: del binding. Poi verifica che il plugin sia nel catalogo letto dalla build e che elenchi questa capacità sotto spec.provider.capabilities; un plugin che un tempo serviva la capacità e non la dichiara più produce esattamente questo messaggio. Rimuovere il binding è la correzione giusta dove un solo plugin serve la capacità, poiché a quel punto il binding non ha nulla da disambiguare.

No provider plugin version satisfies a Recipe’s provider pin (Nessuna versione di plugin provider soddisfa il pin del provider di una Recipe)

Una Recipe lega un provider con versione vincolata — helm:1.0.0 oppure helm:^1.0.0 — e nessuna versione di Plugin di rendering dei provider soddisfa il pin. Il pin è una richiesta esplicita, quindi la build si arresta anziché ignorarlo e renderizzare tramite qualunque versione serva il provider in quel momento; sovrascrivere silenziosamente un pin produrrebbe un output che la dichiarazione stessa dell’autore dice non dovrebbe esistere.

Ci si arriva da due situazioni, e il messaggio le distingue: nulla serve la capacità, oppure qualcosa la serve e nessuna delle sue versioni soddisfa il vincolo.

Questo è distinto da una versione di entità non soddisfacibile vista più sopra. Quella riguarda un’entità del catalogo nominata a una versione che il catalogo non contiene; questa riguarda la selezione del plugin che renderizza una capacità.

Messaggi emessi:

no provider-rendering plugin version satisfies the recipe’s provider version pin: capability "<capability>" pins "<version>" but no provider-rendering plugin serves it (nessuna versione di plugin di rendering dei provider soddisfa il pin di versione del provider della Recipe: la capacità fissa una versione, ma nessun plugin di rendering dei provider la serve) no provider-rendering plugin version satisfies the recipe’s provider version pin: capability "<capability>" pins "<version>" but no serving plugin version satisfies it (nessuna versione di plugin di rendering dei provider soddisfa il pin di versione del provider della Recipe: la capacità fissa una versione, ma nessuna versione del plugin che la serve la soddisfa)

Come risolvere: amplia o correggi il pin nel campo capability: della Recipe, oppure aggiungi al catalogo la versione del plugin che chiede. Un pin caret corrisponde alle versioni pari o superiori alla soglia all’interno della stessa versione major, quindi un pin ^2.0.0 non è soddisfatto da un plugin 1.x per quanto recente. Dove il messaggio dice che nulla serve la capacità, il problema non è il pin: il plugin manca del tutto, e togliere il pin non aiuterà.

No plugin advertises a requested parse or import format (Nessun plugin annuncia un formato di parsing o di importazione richiesto)

È stato richiesto un formato e nessun plugin lo annuncia. I due socket che instradano in base al formato hanno ciascuno la propria condizione, e differiscono solo per il lavoro richiesto: un plugin parser legge un formato sorgente esterno, e un plugin importatore porta contenuti esterni dentro Aggrega come entità.

Lo spazio dei formati è aperto e appartiene interamente ai plugin. Nessuno dei due socket contiene un elenco di formati noti al compilatore: un plugin dichiara come capacità i formati che gestisce, e un nuovo formato arriva come un nuovo plugin senza alcuna modifica al compilatore. Così questo arresto riporta l’insieme annunciato così com’è anziché un’enumerazione fissa, e ogni mancanza viene segnalata in modo esplicito: la richiesta o ha un plugin che la annuncia o non può essere onorata. Nulla sostituisce un plugin mancante, con l’unica eccezione dei parser che il compilatore porta con sé, descritta più sotto.

Messaggi emessi:

no parser plugin advertises the requested format: no parser plugin advertises "parse:<format>" (nessun plugin parser annuncia il formato richiesto) no importer plugin advertises the requested format: no importer plugin advertises "import:<format>" (nessun plugin importatore annuncia il formato richiesto)

Un singolo plugin parser che annuncia il formato ma porta una struttura di versione che non può essere risolta viene trattato come se nessun plugin annunciasse il formato, anziché essere lasciato passare in silenzio, e lo dice:

no parser plugin advertises the requested format: no parser plugin version resolves for "parse:<format>" (nessun plugin parser annuncia il formato richiesto: nessuna versione di plugin parser si risolve per il formato)

Un parsing ripiega sui parser che il compilatore porta con sé. Una build analizza ogni file che consegna a una policy render-verdict in un formato che la policy non legge nativamente, un importatore legge la sua sorgente tramite il parser della sintassi che nomina, e un’importazione che non nomina alcun formato analizza la sorgente nella sintassi che nomina ciascuna firma applicabile. Per ogni sintassi si usa il parser servito dal catalogo del workspace e, dove il catalogo non ne serve alcuno, il parser che il compilatore stesso porta con sé per essa — tra questi il parser HCL tramite cui una build legge l’output di Terraform e il parser JSON tramite cui leggono gli importatori core del compilatore, così né una policy sull’output di Terraform né un’importazione tramite un importatore core richiedono un parser nel catalogo. Dove il catalogo serve un parser per una sintassi, quello del compilatore non ha alcun ruolo, e due parser con nomi diversi nel catalogo vengono rifiutati come descrive A parse or import format is advertised by more than one plugin (Un formato di parsing o di importazione è annunciato da più di un plugin). Quindi questo arresto nomina una sintassi per cui né il catalogo né il compilatore servono un parser.

Come risolvere: verifica che il formato sia scritto come il plugin lo annuncia — la capacità è il prefisso del socket più il nome del formato, quindi un plugin che annuncia parse:hcl serve il formato hcl e nient’altro. Poi verifica che il plugin sia presente nel catalogo letto dalla build. Dove non esiste alcun plugin per il formato, quel plugin è il pezzo mancante; il compilatore non può leggere un formato che nulla annuncia.

A parse or import format is advertised by more than one plugin (Un formato di parsing o di importazione è annunciato da più di un plugin)

Due o più plugin distinti annunciano lo stesso formato, e la richiesta non può essere instradata senza indovinare quale usare.

Un catalogo che li contiene entrambi è legittimo e si carica senza obiezioni. Due editori possono ciascuno distribuire un parser o un importatore per uno stesso formato, e federare i loro cataloghi è un’operazione supportata. L’ambiguità è una condizione al punto d’uso: provoca un arresto quando il formato conteso viene effettivamente richiesto, così una coppia in concorrenza che si trova fuori dalla portata di una build non la blocca mai.

Ogni candidato viene nominato, in ordine, così il messaggio è lo stesso a ogni esecuzione.

Messaggi emessi:

format is advertised by more than one parser plugin: format "<format>" is advertised by parser plugins [<plugin-names>] (il formato è annunciato da più di un plugin parser) format is advertised by more than one importer plugin: format "<format>" is advertised by importer plugins [<plugin-names>] (il formato è annunciato da più di un plugin importatore)

Per un importatore l’arresto viene sollevato in un’ulteriore struttura: le voci plugins.importer del workspace associano più di uno degli importatori che annunciano il formato, e gli importatori che nomina sono allora quelli associati.

Gli importatori tra cui sceglie un’importazione sono quelli nel catalogo del workspace e gli importatori core del compilatore, che annunciano i loro formati in ogni workspace. Così un catalogo che contiene un proprio importatore con un altro nome per un formato servito da un importatore core — import:langflow o import:flowise — incontra questo arresto in un’importazione che non associa nessuno dei due, e il messaggio nomina l’importatore core accanto a quello del catalogo. Un importatore che il catalogo contiene con il nome stesso di un importatore core non è un secondo plugin che annuncia il formato: all’interno di uno stesso nome viene scelta la versione più alta, e uno alla versione propria dell’importatore core, con il suo modulo accanto, viene eseguito al suo posto. Uno senza modulo accanto non è candidato dove un importatore con quel nome che può essere eseguito annuncia il formato, come descrive Quale viene eseguito accanto ai tuoi importatori.

Come risolvere: per un importatore, mantienili entrambi nel catalogo — oppure mantieni il tuo accanto all’importatore core — e associa quello che vuoi — una voce plugins.importer il cui uri lo nomina con la sua identità e versione, uri: importer/<name>:<version>, come lo scrive aggrega plugin add importer. L’importatore associato viene scelto tra quelli che annunciano il formato, così come una voce plugins.providers sceglie tra i plugin che servono una capacità sul socket provider, descritto in «A capability is served by more than one provider plugin (Una capacità è servita da più di un plugin provider)» più sotto. Dove gli importatori nominati sono quelli che le tue voci associano, mantieni la voce per quello che vuoi e rimuovi l’altra. Il socket di parsing non ha una selezione di questo tipo, quindi per un parser il rimedio è restringere il catalogo letto dalla build in modo che contenga solo il plugin che vuoi — puntare --catalog sulla directory che contiene la tua scelta è il modo diretto.

A plugins.importer entry pins a version of its importer the catalog does not hold (Una voce fissa una versione del proprio importatore che il catalogo non contiene)

Una voce plugins.importer associa un importatore tramite la sua identità e una versione — una esatta, uri: importer/<name>:1.2.0, o un intervallo, uri: importer/<name>:^1.2.0 — e quell’importatore annuncia il formato richiesto dall’importazione, ma nessuna sua versione tra quelle fra cui l’importazione sceglie soddisfa il pin — le versioni contenute nel catalogo del workspace e, per un importatore core, anche la versione propria del compilatore: la versione esatta non c’è, oppure nessuna delle sue versioni ricade nell’intervallo. La versione è una scelta esplicita, quindi l’importazione viene rifiutata prima che venga eseguito qualsiasi importatore, anziché eseguire al suo posto un’altra versione dell’importatore.

Questo caso è distinto da quello in cui nessun importatore annuncia il formato, descritto sopra: qui l’importatore è uno di quelli fra cui l’importazione sceglie e annuncia il formato, e manca solo la versione indicata dalla voce. Un pin che non ha nessuna delle forme di un pin di versione, come :latest, viene invece segnalato come malformato, come descrive «A version pin is none of the forms a pin takes (Un pin di versione non ha nessuna delle forme che un pin assume)».

Messaggio emesso, che indica la capacità del formato e la versione fissata dalla voce:

no importer plugin version satisfies the plugins.importer entry’s version pin: capability "import:<format>" pins "<version>" but no serving plugin version satisfies it (nessuna versione del plugin importatore soddisfa il pin di versione della voce plugins.importer: la capacità fissa una versione, ma nessuna versione del plugin che la serve la soddisfa)

Come risolvere: cambia la versione nell’uri della voce con una che il catalogo contiene — per un importatore core lo è anche la versione propria del compilatore — oppure allarga l’intervallo, oppure aggiungi al catalogo la versione indicata dalla voce. Un intervallo caret corrisponde alle versioni pari o superiori al suo minimo all’interno della stessa major, quindi ^2.0.0 non è soddisfatto da un importatore 1.x, per quanto recente.

A plugin reference carries a registry host or an artifact path (Un riferimento a un plugin contiene un host di registry o un percorso di artefatto)

Un riferimento a un Plugin inizia con un segmento a forma di host di registry — uno che contiene un punto o i due punti, come un nome DNS o una coppia host e porta — oppure con un percorso di artefatto. Un Plugin si indica tramite la sua identità di coordinata: il suo tipo di plugin, una barra, il suo nome e, facoltativamente, una versione. Il pull lega quell’identità a una posizione fisica anteponendo il registry configurato e il percorso del plugin stesso, quindi un riferimento che ne contiene già uno riceverebbe il prefisso due volte e si legherebbe a una posizione che non può essere scaricata.

Viene rifiutato nel punto in cui si forma la posizione anziché al momento dello scaricamento, così il messaggio indica ciò che hai scritto invece di emergere più tardi come un errore di tag illeggibile.

Messaggio emesso, inquadrato dal pull che stava formando la posizione, con il rimedio sulla riga sottostante:

catalog: tier-3 pull <uri>: wasm plugin reference must be the plugin coordinate identity (<pluginType>/<name>:<version>), not a registry-qualified or artifact path: "<identity>" (catalogo: pull di livello 3: il riferimento al plugin wasm deve essere l’identità di coordinata del plugin, non un percorso qualificato dal registry o un percorso di artefatto) remediation: remove the registry host and the artifact path, leaving the coordinate alone — <pluginType>/<name>:<version>, for example provider/helm:1.0.0; the pull prefixes the configured registry itself, so a reference that already carries one is prefixed twice (rimedio: rimuovi l’host del registry e il percorso dell’artefatto, lasciando solo la coordinata; il pull antepone da sé il registry configurato, quindi un riferimento che ne contiene già uno riceve il prefisso due volte)

Come risolvere: elimina tutto ciò che precede il tipo di plugin, lasciando la coordinata da sola — provider/helm:1.0.0, non hub.example.com/plugin/provider/helm:1.0.0. Il registry da cui una build esegue il pull è configurazione del workspace e non parte di un’identità, ed è questo che permette di servire un catalogo da più di un registry senza modificare le entità che contiene.

A plugin or recipe reference carries no scope (Un riferimento a un plugin o a una ricetta non ha un ambito)

Un riferimento a un Plugin o a una Recipe non ha un segmento di ambito iniziale — nessuna barra, oppure un segmento vuoto prima della barra, come in /name. Entrambi i tipi sono identificati da due parti, e la prima è ciò che tiene distinte due entità con lo stesso nome: un Plugin tramite il suo tipo di plugin e il suo nome, una Recipe tramite il suo provider e il suo nome. Due socket possono contenere ciascuno un plugin chiamato redact, e due provider possono distribuire ciascuno una ricetta chiamata postgres, quindi l’ambito fa parte dell’identità anziché esserne una decorazione.

Una posizione costruita da un ambito vuoto contiene un segmento di percorso vuoto — una doppia barra — che non può essere risolto, quindi il riferimento viene rifiutato nel punto in cui si forma la posizione anziché lasciarlo fallire più tardi come uno scaricamento illeggibile.

I due rimedi sono l’opposto del caso del plugin qualificato visto sopra e l’uno dell’altro, ed è per questo che ciascuno è formulato a sé: qui a un riferimento manca un segmento e lo aggiungi, mentre un riferimento qualificato ne ha uno in più e lo rimuovi.

Messaggi emessi, ciascuno inquadrato dal pull e con il proprio rimedio sotto:

catalog: tier-3 pull <uri>: wasm plugin reference must carry a pluginType scope (<pluginType>/<name>); an empty scope cannot bind to an OCI location: "<identity>" (catalogo: pull di livello 3: il riferimento al plugin wasm deve avere un ambito pluginType; un ambito vuoto non può legarsi a una posizione OCI) remediation: add the missing pluginType segment — write the reference as <pluginType>/<name>, for example provider/helm or governance/redact, using the pluginType the plugin entity declares under metadata.pluginType (rimedio: aggiungi il segmento pluginType mancante — scrivi il riferimento come tipo di plugin, barra e nome — usando il pluginType che l’entità del plugin dichiara)

catalog: tier-3 pull <uri>: recipe reference must be provider-scoped (<provider>/<name>); an empty provider cannot bind to an OCI location: "<identity>" (catalogo: pull di livello 3: il riferimento alla ricetta deve avere come ambito un provider; un provider vuoto non può legarsi a una posizione OCI) remediation: no local catalog directory held this reference, so it was looked for in the registry, where a provider segment is required; re-run as aggrega pull --release <release> --catalog <dir> so the directory that holds it is searched first (--catalog is repeatable) (rimedio: nessuna directory di catalogo locale conteneva questo riferimento, quindi è stato cercato nel registry, dove è richiesto un segmento provider; riesegui il pull indicando con l’opzione del catalogo la directory che lo contiene, così che venga cercata per prima; l’opzione è ripetibile)

Come risolvere: per un plugin, anteponi il tipo di plugin che l’entità Plugin dichiara sotto metadata.pluginType. Per una ricetta, anteponi il provider che la Recipe dichiara sotto spec.capability. Il rimedio per la ricetta indica una seconda possibilità che vale la pena leggere: se si raggiunge il registry, significa che le directory di catalogo locali sono state cercate per prime e nessuna conteneva il riferimento, quindi, se la ricetta deve provenire da una directory locale, indirizza la build verso quella directory anziché aggiungere un ambito.

The build consumes an artifact its publisher has deprecated (La build consuma un artefatto che il suo editore ha deprecato)

Un riferimento risolto da questa build porta un marcatore di deprecazione registrato dal suo editore, e la gravità di quel marcatore è pari o superiore alla gravità che il workspace ha configurato come soglia di arresto. Un marcatore viene associato a un artefatto pubblicato a posteriori, quindi un artefatto che ieri veniva compilato senza problemi può portarne uno oggi senza che nulla cambi nei tuoi file.

Segnalazione e arresto sono separati, e solo l’arresto è configurabile. Ogni marcatore registrato viene segnalato, a ogni gravità, e nessuna configurazione lo silenzia. Se un marcatore ferma anche la build lo decide halt_on_deprecated_severity, confrontando la gravità registrata con la soglia configurata nell’ordine warning < error < retracted. Senza soglia configurata, nulla si arresta e ogni marcatore è un avviso. Una gravità al di fuori delle tre, o una soglia al di fuori di esse, non dà mai corrispondenza: un valore malformato non può né causare un arresto né sopprimerne uno.

Ogni notifica viene stampata prima che la build si fermi, non solo quella che ne ha causato l’arresto, quindi alzare la soglia non ti fa mai perdere un rilievo — l’arresto stesso indica il singolo riferimento su cui si è fermato. I rilievi sono ordinati per riferimento, quindi lo stesso lockfile riporta la stessa sequenza a ogni esecuzione e quello che provoca l’arresto è sempre lo stesso.

Vengono controllati due archivi, ed entrambi segnalano allo stesso modo: i riferimenti fissati dal lockfile e i plugin registrati come attendibili per un verdetto di accettazione o rifiuto. Nessuno dei due controlli raggiunge un registry — entrambi leggono ciò che era già stato registrato — quindi la build resta ahead-of-time.

Messaggio emesso. Ogni rilievo viene stampato man mano che viene esaminato, poi l’arresto ripete quello che ha raggiunto la soglia e indica l’impostazione che ha fermato la build:

deprecation: <reference> is retracted: <the publisher's recorded message> (recorded in the lockfile at pull, as of <when>; re-run `aggrega pull` to refresh it)

deprecation: build consumes a deprecated entity: <reference> is retracted: <the publisher's recorded message> (recorded in the lockfile at pull, as of <when>; re-run aggrega pull to refresh it): halt_on_deprecated_severity is "error" (deprecazione: la build consuma un’entità deprecata: il riferimento è ritirato, con il messaggio registrato dall’editore (registrato nel lockfile al momento del pull; riesegui il pull per aggiornarlo): halt_on_deprecated_severity ha il valore indicato)

Un marcatore a una delle due gravità consultive è indicato come deprecated (warning) o deprecated (error) al posto di retracted. La distinzione viene mantenuta perché i due significano cose diverse — sconsigliato ma ancora selezionabile, contro escluso dalla selezione — e segnalare il più forte come il più debole sminuirebbe ciò che è accaduto.

Come risolvere: leggi il messaggio registrato, che è la spiegazione dell’editore stesso su cosa adottare al suo posto, ed esegui la migrazione. Dove non puoi ancora migrare, alzare halt_on_deprecated_severity — o rimuoverne l’impostazione — trasforma di nuovo l’arresto in un avviso che continui a vedere; si tratta di un’accettazione deliberata e non di un espediente, e la notifica continua a essere stampata. Un marcatore registrato su una versione che non usi più scompare quando il lockfile viene aggiornato con aggrega pull.

A trusted plugin’s recorded digest disagrees with the cached artifact (Il digest registrato di un plugin attendibile non concorda con l’artefatto in cache)

Un plugin associato in un ruolo che accetta o rifiuta una build ha un digest registrato come attendibile, e il manifesto in cache del plugin ne riporta uno diverso. I due vengono confrontati prima che l’eseguibile del plugin sia letto, e un disaccordo interrompe lì la risoluzione.

Il confronto è ciò che rende il digest registrato un’autorità anziché una ripetizione. Senza di esso, i byte di un plugin vengono controllati solo rispetto a un pin derivato proprio dal manifesto i cui byte poi convalida — coerente con sé stesso per costruzione, e incapace di accorgersi che l’intero artefatto è stato sostituito. Confrontare ciò che è stato registrato con ciò che il manifesto riporta ora è ciò che dà a quel controllo un parere esterno.

Questo caso è distinto da una discrepanza del digest del contenuto, che segnala byte risolti in disaccordo con il digest dichiarato per essi. Qui non è stato letto nulla, e i byte potrebbero benissimo concordare con il manifesto; ciò che non concorda è quale artefatto venga risolto. Tenere distinti i due casi è importante perché i rimedi sono opposti — uno è un artefatto corrotto o manomesso, l’altro un plugin cambiato legittimamente la cui nuova identità non è ancora stata esaminata.

Messaggio emesso:

resolve cached plugin "<plugin-identity>": the digest recorded as trusted for it is <recorded-digest>, but the plugin manifest in the content cache reports <cached-digest>; review what changed and re-record the trusted digest, or restore the recorded artifact: the digest recorded as trusted for this plugin does not match the digest its cached manifest reports (risoluzione del plugin in cache: il digest registrato come attendibile per esso è diverso da quello riportato dal manifesto del plugin nella cache dei contenuti; esamina cosa è cambiato e registra di nuovo il digest attendibile, oppure ripristina l’artefatto registrato: il digest registrato come attendibile per questo plugin non corrisponde al digest riportato dal suo manifesto in cache)

Come risolvere: scopri cosa è cambiato prima di registrare di nuovo qualsiasi cosa — questo è un plugin che può rifiutare le tue build, e il digest registrato è l’attestazione che qualcuno lo ha esaminato. Dove il cambiamento è atteso, perché hai aggiornato il plugin deliberatamente, esamina il nuovo artefatto e registra di nuovo il digest attendibile per esso. Dove non è atteso, ripristina l’artefatto indicato dalla registrazione; il disaccordo ti sta dicendo che l’identità si è spostata senza che nessuno lo decidesse.

An extends: chain cannot be assembled (Una catena di estensione non può essere assemblata)

La catena extends: di un Component, di una Feature, di un Manifest o di una Release indica un genitore che non può essere risolto, quindi la catena non può essere trasformata in un’unica entità risolta.

È distinto da un ciclo, che ha una propria condizione e un proprio rimedio — vedi «Cyclic extends chain (Catena extends ciclica)» sopra; da una catena oltre il limite di profondità, che ha una propria condizione più sotto; e da un pin di versione insoddisfacibile, in cui il genitore esiste e manca solo la versione.

Messaggio emesso, che indica l’entità che contiene l’extends: irrisolvibile e il riferimento che dichiara:

inheritance merge failed (Component <name>, at .spec.extends, <entity> extends <reference>, which no catalog entity provides). Verify the extends reference names an entity present in the catalog (unione dell’ereditarietà non riuscita: l’entità estende un riferimento che nessuna entità del catalogo fornisce. Verifica che il riferimento extends indichi un’entità presente nel catalogo)

Quando il controllo che lo segnala legge un genitore dalla cache degli artefatti in base al pin di un lockfile — il controllo extends di una build e di aggrega validate --release, aggrega validate sull’intero catalogo e aggrega inspect, oltre agli stessi controlli eseguiti dall’editor e dallo strumento validate dell’assistente — il suggerimento prosegue indicando il pull: «a base published to a registry is fetched by aggrega pull --release <release>» (una base pubblicata in un registry viene recuperata con il comando indicato). La validazione di un singolo file di entità non legge alcun lockfile, quindi un pull non cambierebbe nulla di ciò che legge, e il suo messaggio si ferma al catalogo.

Feature compare al posto di Component quando a fallire è la catena di una Feature. Come per un ciclo, l’entità nominata per prima è quella da cui è partita la risoluzione e l’entità nominata nell’arco è quella di cui aprire la riga extends:; lungo una catena a più livelli le due sono diverse.

L’extends: di un Manifest viene risolto rispetto a un luogo diverso, quindi riceve un consiglio diverso. Un Manifest è configurazione dell’operatore scritta accanto alla Release anziché contenuto del catalogo, e il suo extends: indica un file con percorso relativo o il metadata.name di un Manifest nella directory della Release stessa — mai un’entità del catalogo. Il suo messaggio si chiude quindi con ciò in cui il riferimento non è riuscito a risolversi e con dove cercare invece:

inheritance merge failed (Manifest <name>, at .spec.extends, <entity> extends <reference>, which could not be resolved: <what looking produced>). Verify the extends reference is a relative path or the name of a Manifest in the Release’s directory (unione dell’ereditarietà non riuscita: l’entità estende un riferimento che non è stato possibile risolvere. Verifica che il riferimento extends sia un percorso relativo o il nome di un Manifest nella directory della Release)

Quel dettaglio finale è l’errore riportato dalla ricerca stessa — il file che non è stato possibile leggere, o la scansione che non ha indicizzato alcun Manifest con quel nome — quindi di solito dice quale delle due forme è stata tentata e perché non ha dato risultati.

L’extends: di una Release viene risolto rispetto a una directory, e accetta una sola forma. Una Release indica il proprio genitore come percorso relativo — ./base-release.yaml, oppure ../shared/base-release.yaml. La directory rispetto a cui viene risolto è quella che contiene la Release che scrive il riferimento, e ogni anello di una catena viene risolto rispetto alla propria directory — così una Release a metà catena tenuta in una sottodirectory indica il proprio genitore accanto a sé, ovunque si trovi la Release indicata da un comando. Un token semplice non è un percorso e non indica una Release che il compilatore cercherà, quindi viene segnalato qui anziché cercato in un posto in cui non può essere trovato:

inheritance merge failed (Release <name>, at .spec.extends, <entity> extends <reference>, which could not be resolved: <what looking produced>). Verify the extends reference is a relative path to a Release file, such as ./base-release.yaml, resolved from the directory holding this Release (unione dell’ereditarietà non riuscita: l’entità estende un riferimento che non è stato possibile risolvere. Verifica che il riferimento extends sia un percorso relativo a un file di Release, come ./base-release.yaml, risolto a partire dalla directory che contiene questa Release)

Come risolvere: per un Component o una Feature, verifica che il valore di extends: indichi un’entità contenuta nel catalogo, scritta come il metadata.name di quell’entità — maiuscole e minuscole comprese. Una base pubblicata in un registry viene letta dalla cache degli artefatti in base al pin che il lockfile della Release registra per essa, quindi, quando la base si trova in un registry, esegui aggrega pull --release <release>: il pull segue la catena, recupera la base e ne registra il pin. Per un Manifest, verifica che il file si trovi dove punta il percorso relativo, oppure che un Manifest con quel metadata.name si trovi nella directory della Release e venga analizzato correttamente. Per una Release, verifica che il valore inizi con ./ o ../ e che il file a cui punta sia presente e venga analizzato come una Release.

An extends: chain runs past the depth bound (Una catena di estensione supera il limite di profondità)

La catena extends: di un Component, di una Feature, di un Manifest o di una Release termina correttamente ma attraversa più entità di quante ne consenta il limite di dieci.

Ha una condizione propria anziché condividere quella sopra, perché i due rimedi non hanno nulla in comune: un genitore assente è un riferimento da correggere, e una catena troppo profonda è una struttura da appiattire. Il limite è una protezione contro un incidente di scrittura anziché un limite strutturale — gli architetti in genere estendono una base di uno o due livelli, e una catena profonda dieci livelli è di solito un albero di base cresciuto nel tempo piuttosto che un design deliberato.

Solo una catena che TERMINA lo raggiunge. Una catena che torna su sé stessa viene segnalata come ciclo, qualunque sia la sua lunghezza, quindi questa condizione non sostituisce mai un ciclo e il suo consiglio — accorciare la catena — non viene mai dato per uno.

Messaggio emesso, che indica il limite e la lunghezza raggiunta dalla catena:

extends chain exceeds maximum depth (Component <name>, rule extends). the bound is 10 and this chain reaches <length>; shorten the chain, or extend a base that sits closer to its root (la catena extends supera la profondità massima. il limite è 10 e questa catena va oltre; accorcia la catena, oppure estendi una base più vicina alla sua radice)

Feature, Manifest o Release compare al posto di Component quando a fallire è una di quelle catene. Il limite è lo stesso dieci per ogni tipo che dichiara extends, e conta le entità sulla catena anziché gli anelli tra di esse: una catena di esattamente dieci entità viene compilata, ed è l’undicesima entità ciò che questo segnala. Così un’entità che estende una base che estende una base — tre entità, due anelli — è arrivata a tre.

Come risolvere: comprimi la parte centrale della catena. Una catena così profonda di solito significa che ogni livello aggiunge poco, e accorpare più livelli in un’unica entità di base è sia la correzione sia la struttura più chiara. Dove i livelli sono davvero distinti, un’entità più in basso nella catena può estendere direttamente una base più vicina alla radice invece di ereditare attraverso ogni livello intermedio. Una catena di Manifest così profonda è di solito una pila di sovrapposizioni per ambiente — accorpa i livelli che nessuno varia nella base a cui si sovrappongono.

An assertion name is declared twice along an extends: chain (Il nome di un’asserzione è dichiarato due volte lungo una catena di estensione)

Un’entità e qualcosa che essa estende dichiarano entrambi un’asserzione con lo stesso nome, e i due dichiarano regole diverse. Le asserzioni di un’entità che estende si aggiungono a quelle della sua base; non ne sostituiscono mai una. Quindi un nome dichiarato due volte con due regole diverse ritirerebbe silenziosamente l’invariante della base, che è l’opposto di ciò a cui serve estendere un’entità.

Dichiarare lo stesso nome con la regola identica non è una collisione e viene compilato. È ciò che mantiene il controllo idempotente lungo una catena: senza questo, una catena a tre livelli entrerebbe ogni volta in collisione con il proprio livello intermedio.

L’ordine fa parte del contratto e non è casuale. Le asserzioni vengono valutate nell’ordine unito e la prima che fallisce provoca l’arresto, quindi l’invariante di una base viene controllata prima di quella di un discendente, e lungo una catena l’insieme si accumula dalla radice verso il basso.

Messaggio emesso:

assertion name declared twice across the extends chain (Component <name>:<version>, rule assertions, at .spec.assertions.<key>). assertion "<key>" is already declared by the base Component "<base>", carrying a different rule; rename the extending entity’s assertion; an extending entity’s assertions add to the base’s and never replace one (nome di asserzione dichiarato due volte lungo la catena extends. l’asserzione è già dichiarata dal Component di base, con una regola diversa; rinomina l’asserzione dell’entità che estende; le asserzioni di un’entità che estende si aggiungono a quelle della base e non ne sostituiscono mai una)

Come risolvere: rinomina l’asserzione dell’entità che estende, che il messaggio indica insieme alla base che la dichiara già. Dove intendevi sostituire la regola della base, non è qualcosa che l’estensione supporta — restringi l’asserzione della base in modo che valga per ogni entità che la estende, oppure sposta la regola più in basso, sulle entità che ne hanno davvero bisogno. Dove le due regole devono essere uguali, rendile testualmente identiche e la collisione scompare.

Una Release instrada i componenti del suo Aggregate in uno di due modi: confini con nome sotto boundaries:, oppure componenti di primo livello sotto components:. Le due strutture si escludono a vicenda, e un singolo documento che le dichiara entrambe viene rifiutato già in lettura. Questa condizione è la stessa regola applicata lungo una catena extends:: una base che dichiara confini con nome e un figlio che dichiara componenti di primo livello sono ciascuno ben formati per conto proprio, ed è solo fondendoli insieme che le due scelte finiscono in un’unica Release risolta.

Nessuno dei due documenti è sbagliato di per sé, ed è per questo che il messaggio li nomina entrambi, insieme a entrambe le chiavi. Una diagnostica che nominasse solo la Release a cui è stato indirizzato il build ti manderebbe al file che non contiene nulla di sbagliato.

Una catena i cui anelli concordano non viene toccata. Ogni anello che dichiara confini con nome si compone normalmente, e così ogni anello che dichiara componenti di primo livello. È la combinazione delle due strutture a fermarsi.

Messaggio emesso, che nomina i due file e la chiave dichiarata da ciascuno:

release extends chain composes both named boundaries and top-level components: declare one routing shape across the chain, never both (Release <release-file>, boundaries declared by "<file>", components declared by "<file>") (la catena di estensione della Release compone sia confini con nome sia componenti di primo livello: dichiara una sola struttura di instradamento lungo la catena, mai entrambe — Release, file che dichiara i confini, file che dichiara i componenti)

Come risolvere: scegli la struttura di instradamento che la catena deve usare e scrivila lungo tutta la catena. Dove la base dichiara confini con nome, un figlio che vuole configurare dei componenti li indirizza all’interno del confine che li contiene anziché alla radice della Release — ed è anche questo che gli permette di cambiare il dimensionamento di un componente senza ridichiarare la topologia. Dove la base dichiara componenti di primo livello, un figlio che ha bisogno di confini con nome sta descrivendo una struttura di instradamento diversa da quella della sua base, ed è meglio scriverlo come una Release a sé che come figlio di quella.

An external input’s URL uses a scheme that is not allowed (L’URL di un input esterno usa uno schema non consentito)

Un URL a cui un’entità punta usa uno schema al di fuori dell’insieme consentito. Ne sono consentiti tre: https; http, ma solo verso un host di loopback, così che il traffico in chiaro possa raggiungere soltanto la macchina locale; e oci, per i contenuti scaricati da un registry.

Messaggi emessi, per un URL http non di loopback e per qualsiasi altro schema:

externalinputs: "<url>": plain http is allowed for loopback hosts only (allowed schemes: https, http to a loopback host, oci): externalinputs: URL scheme is not allowed (externalinputs: http in chiaro è consentito solo per host di loopback (schemi consentiti: https, http verso un host di loopback, oci): externalinputs: lo schema dell’URL non è consentito) externalinputs: "<url>": scheme "<scheme>" is not allowed (allowed schemes: https, http to a loopback host, oci): externalinputs: URL scheme is not allowed (externalinputs: lo schema non è consentito (schemi consentiti: https, http verso un host di loopback, oci): externalinputs: lo schema dell’URL non è consentito)

Come risolvere: passa l’URL a https, oppure a oci dove il contenuto è pubblicato in un registry. Un URL http in chiaro verso un host remoto viene rifiutato anziché declassato, quindi la correzione è puntarlo allo schema sicuro; un server di sviluppo locale continua a funzionare su http perché un host di loopback è consentito.

A render requests an external input the lockfile does not pin (Un rendering richiede un input esterno che il lockfile non fissa)

Qualcosa di cui un build ha bisogno viene scaricato da un URL che il lockfile non fissa. Un build esegue il rendering della chiusura registrata nel suo lockfile e non scarica nulla, quindi non esiste alcuna impostazione che permetta a questa esecuzione di acquisire invece l’URL: la chiusura congelata è ciò che rende un build riproducibile, e ampliare silenziosamente l’insieme degli input è l’unica cosa che non deve fare.

Raggiungere questo arresto è quindi informativo, non un errore di configurazione. I pin erano completi quando la Release è stata risolta, quindi un URL non fissato significa ora che da allora è cambiato qualcosa — un valore che orienta quali riferimenti un rendering richiede, un chart che ha iniziato a puntare altrove, o un lockfile risolto rispetto a una Release diversa.

Messaggio emesso:

"<url>" is not pinned in the lockfile; run aggrega pull --release <release> to pin every external input this Release’s render consumes, then build again: externalinputs: acquisition is disabled for unpinned inputs (non è fissato nel lockfile; esegui il comando per fissare ogni input esterno consumato dal rendering di questa Release, poi ripeti il build: externalinputs: l’acquisizione è disabilitata per gli input non fissati)

Come risolvere: fissa l’input. aggrega pull --release <path> esegue il rendering della Release per scoprire quali input esterni consuma, scarica ciascuno di essi e ne registra il digest nel lockfile accanto ai pin delle dipendenze — dopodiché ogni build successivo lo serve dal record fissato e non ha bisogno di alcuna rete. Dove l’URL è nuovo perché qualcosa che hai scritto ha iniziato a puntarvi, il passo saltato è risolvere di nuovo la Release; dove è inatteso, vale la pena trovare il riferimento che lo ha introdotto prima di fissarlo.

Fetched bytes do not match a pinned digest (I byte scaricati non corrispondono a un digest fissato)

Un URL fissato è stato scaricato di nuovo — perché la sua copia archiviata mancava — e ciò che è tornato non è ciò che il lockfile ha fissato. Il digest registrato prevale sempre: nell’archivio non viene scritto nulla e non viene restituito alcun byte.

Un ricaricamento viene scaricato tramite il digest registrato anziché tramite il tag dell’URL, quindi un tag spostato per puntare a un contenuto diverso non può cambiare ciò che una voce fissata serve. Raggiungere questo arresto significa quindi che è il contenuto dietro il digest stesso a non essere tornato integro.

Messaggi emessi, per i contenuti scaricati da un registry e per i contenuti scaricati tramite HTTPS:

externalinputs: "<url>": refilled manifest digest is <digest>, pinned digest is <digest>: externalinputs: fetched bytes mismatch the pinned digest (externalinputs: il digest del manifesto ricaricato è diverso dal digest fissato: externalinputs: i byte scaricati non corrispondono al digest fissato) externalinputs: "<url>": refetched bytes hash to <digest>, pinned digest is <digest>: externalinputs: fetched bytes mismatch the pinned digest (externalinputs: l’hash dei byte scaricati di nuovo è diverso dal digest fissato: externalinputs: i byte scaricati non corrispondono al digest fissato)

Come risolvere: trattalo prima di tutto come una questione di supply chain, non come un lockfile da aggiornare — il pin è l’affermazione che questi byte esatti sono quelli rispetto a cui hai eseguito il build, e il rifiuto è quell’affermazione che regge. Verifica che la sorgente pubblichi ancora il contenuto indicato dal digest e controlla se qualcosa tra te e la sorgente stia riscrivendo le risposte; un proxy o un mirror che serve un sostituto è una causa comune. Solo quando sai che cosa è cambiato e lo accetti dovresti fissarlo di nuovo con aggrega pull, che registra il nuovo digest.

A stored external input no longer matches its record (Un input esterno archiviato non corrisponde più al suo record)

Un input fissato è stato riletto dall’archivio locale e non corrisponde al record fissato per esso. Il controllo viene eseguito a ogni lettura, prima che i byte vengano serviti, quindi un archivio corrotto o manomesso emerge nel punto d’uso anziché alimentare silenziosamente un build.

Ciò che viene confrontato dipende da come l’input è fissato. Il contenuto scaricato tramite HTTPS è fissato calcolando l’hash del payload, quindi a ogni lettura l’hash viene ricalcolato ed entrambi i digest vengono riportati. Il contenuto scaricato da un registry è fissato tramite il digest del suo manifesto, che vincola il payload attraverso il manifesto del registry stesso anziché calcolarne direttamente l’hash, quindi una copia archiviata viene confrontata con la dimensione registrata — la verifica completa del digest si ancora invece all’acquisizione e a ogni ricaricamento indirizzato tramite digest.

Messaggi emessi:

externalinputs: "<url>": store blob sha256 is <digest>, pinned digest is <digest>: externalinputs: store blob mismatches its pinned record (externalinputs: lo sha256 del blob nell’archivio è diverso dal digest fissato: externalinputs: il blob nell’archivio non corrisponde al suo record fissato) externalinputs: "<url>": store blob sha256/<digest> is <n> bytes but the pinned record says <n>: externalinputs: store blob mismatches its pinned record (externalinputs: la dimensione in byte del blob sha256 nell’archivio è diversa da quella indicata dal record fissato: externalinputs: il blob nell’archivio non corrisponde al suo record fissato)

Come risolvere: elimina dall’archivio il blob in questione e lascia che l’esecuzione successiva lo ricarichi dalla sorgente, cosa che viene verificata rispetto al digest registrato prima che venga scritto qualsiasi cosa. Se poi anche un ricaricamento segnala una mancata corrispondenza del digest, la discrepanza è a monte anziché locale e la voce precedente è quella da leggere. Un archivio condiviso tra più macchine, o uno ripristinato da un backup eseguito durante una scrittura, è la causa locale abituale.

A guard needs a catalog entity the build resolved and cannot see (Una guardia ha bisogno di un’entità del catalogo che il build ha risolto e che non riesce a vedere)

Una guardia semantica ha cercato l’entità del catalogo dietro il tipo di un componente, e l’entità manca dalla vista fornita alla guardia — anche se la risoluzione ha risolto quel tipo come riferimento al catalogo. Un riferimento davvero irrisolvibile si arresta prima, alla risoluzione, quindi raggiungere una guardia con l’entità mancante significa che l’insieme risolto del build e la vista della guardia si sono separati.

Il build si ferma anziché saltare la guardia. Saltarla ritirerebbe un controllo senza nulla che segnali che è venuto meno, e i componenti di cui la guardia si occupava passerebbero senza esame mentre il build riporta un successo.

Un tipo scritto come percorso relativo — che inizia con ./ o ../ — non viene giudicato qui: un tipo non viene mai letto come file, quindi un valore del genere non nomina alcuna entità del catalogo ed è rifiutato prima, quando vengono risolte le dipendenze della Release, come riferimento che nessun catalogo contiene. Solo un riferimento al catalogo in forma di token semplice raggiunge questo arresto.

Ovunque la condizione si verifichi, viene segnalata con le stesse parole, quindi il testo nomina il tipo e l’errore anziché il controllo che lo ha sollevato.

Non nomina inoltre alcun documento né alcuna chiave al suo interno, il che è voluto ed è l’unico punto in cui questo arresto si legge diversamente da tutti gli altri. Ogni altro arresto si posiziona sul file e sul campo che modificheresti per eliminarlo; qui non esiste un file del genere, quindi una posizione ti manderebbe a una chiave che non è in difetto. Viene invece riportato il tipo su cui le due viste non concordano, perché è ciò che rende la divergenza riproducibile per chi la indaga.

Messaggio emesso:

the compiler’s own views of the catalog disagree (internal error: this build resolved a component type that the catalog it reads then held no entry for. This is a fault in the compiler rather than in an authored document, so there is nothing to correct in the Aggregate, the Release or the catalog. Please report it, naming the command that produced this build and the type the views disagree on: "<type>") (le viste del catalogo interne al compilatore non concordano (errore interno: questo build ha risolto un tipo di componente per il quale il catalogo che legge non conteneva poi alcuna voce. Si tratta di un errore del compilatore e non di un documento scritto dall’autore, quindi non c’è nulla da correggere nell’Aggregate, nella Release o nel catalogo. Segnalalo, indicando il comando che ha prodotto questo build e il tipo su cui le viste non concordano))

Come risolvere: nulla nei tuoi file — questo segnala un’incoerenza interna al compilatore anziché un errore in ciò che hai scritto, e vale la pena segnalarlo come difetto indicando il tipo nominato dal messaggio. Il tipo del componente è quasi certamente corretto.

A reference names no entity the catalog holds (Un riferimento non nomina alcuna entità contenuta nel catalogo)

Prima che un build esegua il rendering di qualsiasi cosa, l’intero insieme delle entità da cui una Release dipende viene visitato e ciascuna viene fissata, così che il lockfile registri esattamente ciò che il build leggerà. Un riferimento a cui il catalogo non sa rispondere interrompe quella visita: per esso non si può fissare nulla, e proseguire scriverebbe un lockfile privo di una voce di cui il build avrà bisogno in seguito, senza nulla che lo segnali.

Il rifiuto nomina il riferimento e il punto in cui è stato raccolto, perché un’entità viene raggiunta da molti punti e il punto che la nomina è quello in cui va la correzione. Un riferimento a libreria viene riportato da solo, senza percorso di raccolta — una libreria viene raggiunta dalle entità che la richiamano con $ref o $import, e il nome che fallisce è l’intero errore.

Messaggio emesso, per un’entità del catalogo — la parte finale elenca i punti che la referenziano:

resolve: no entity in the catalog matches this URI: entity "<reference>" (referenced from <referring paths>) (resolve: nessuna entità del catalogo corrisponde a questo URI: entità, con i percorsi da cui è referenziata)

per una libreria:

resolve: no entity in the catalog matches this URI: library "<reference>" (resolve: nessuna entità del catalogo corrisponde a questo URI: libreria)

e per un plugin legato a un socket provider, che viene nominato tramite la chiave di configurazione del workspace che lo conteneva anziché tramite un documento del catalogo:

resolve: no entity in the catalog matches this URI: entity "<reference>" (referenced from .aggrega-config.yaml.plugins.providers) (resolve: nessuna entità del catalogo corrisponde a questo URI: entità, referenziata da .aggrega-config.yaml.plugins.providers)

Dove un file sotto le directory di catalogo dichiara il nome richiesto dal riferimento con un tipo di entità che nessun catalogo contiene — un kind scritto male, ad esempio — la nota sotto questo errore nomina quel file, il tipo che dichiara e i tipi che un catalogo contiene, e omette il consiglio su dove vengono lette le entità locali, sia in un build che compila il proprio lockfile sia in uno che lo legge, e su ogni altra superficie che segnala questo errore; vedi Un file del catalogo rifiutato e l’errore che spiega.

Come risolvere: leggi il riferimento esattamente come lo cita il messaggio. Un nome che non esiste, una versione mai pubblicata e un nome semplice il cui registry non è configurato nel workspace arrivano tutti qui in modo identico, quindi verifica le tre cose in quest’ordine: correggi l’ortografia; conferma che la versione esista; conferma che il registry che la contiene sia configurato e raggiungibile. Dove l’entità è una che scrivi in locale, conferma che il file si trovi all’interno del catalogo che il build visita.

Dove aggrega pull, o aggrega build --auto-pull, si ferma su un riferimento a libreria mentre la cache degli artifact contiene una SchemaLibrary che nessuna voce del lockfile fissa e nessuna directory di catalogo fornisce, al messaggio segue una riga remediation: che nomina ciascuna di queste librerie. Una libreria nella cache conta come contenuto del catalogo solo dove una voce del lockfile ne garantisce il digest, e il pull registra quella voce dal registry che serve la libreria. In modalità offline il pull non può né scaricare la libreria né registrare una voce per essa, quindi la riga dice di eseguire aggrega pull --release <release> dove può raggiungere un registry, oppure di scrivere la libreria sotto una directory di catalogo. Con la connessione, nessuna directory di catalogo né alcun registry letto dal pull serve la libreria, quindi non c’è alcuna voce da registrare, e la riga indica di scrivere la libreria sotto una directory di catalogo.

A library reference is not written in the identity form (Un riferimento a libreria non è scritto nella forma di identità)

Un $ref: o $import: tra librerie nomina la libreria per identità e poi la voce al suo interno: il nome semplice della libreria, facoltativamente un : e una versione minima, poi # e il percorso della voce sulla superficie letta dal campo. In questa forma non c’è alcun host di registry. Il registry attraverso cui un nome viene risolto è configurazione del workspace, e la versione usata da un build è la risposta del lockfile, quindi un riferimento che contenesse l’uno o l’altra fisserebbe nel documento qualcosa che dovrebbe decidere il build.

Rifiutati qui: un valore che contiene un host di registry; un’ancora interna al documento scritta dove era atteso un riferimento tra librerie; un nome di libreria vuoto; e @ scritto come separatore di versione, che viene segnalato con la grafia corretta anziché come generico reclamo sulla struttura, perché è l’errore che questa forma attira di più.

Messaggio emesso:

resolve: invalid library reference URI: "<the value as written>" (resolve: URI di riferimento a libreria non valido)

e dove è stato usato @ come separatore, citando ciò che il valore dovrebbe riportare invece:

resolve: invalid library reference URI: version separator is ’:’, not ’@’ — use "<the corrected value>" (resolve: URI di riferimento a libreria non valido: il separatore di versione è ’:’, non ’@’ — usa il valore corretto)

Come risolvere: riscrivi il valore come <Library>#<entry-path>, aggiungendo :<version> dopo il nome della libreria solo dove ti serve una versione minima che limiti quale versione può essere selezionata. Elimina qualsiasi host di registry. Dove il riferimento doveva puntare all’interno dello stesso documento, un’ancora interna al documento è una cosa diversa da un riferimento a libreria, e il campo su cui l’hai scritto si aspetta la forma di libreria.

Two consumers of one library require incompatible versions (Due consumatori di una libreria richiedono versioni incompatibili)

Più entità possono fare riferimento a una stessa libreria, ciascuna indicando una versione minima o nessuna, e la versione che il build seleziona è la più alta tra le versioni minime indicate. È ciò che permette a un consumatore che chiede meno di ricevere comunque una versione che lo soddisfa, ed è il motivo per cui aggiungere un consumatore con una versione minima più alta sposta tutti verso l’alto anziché dividere il build tra due copie.

La regola vale solo finché le versioni minime concordano sul numero di versione iniziale. Due consumatori che indicano versioni major diverse chiedono due librerie che hanno per caso lo stesso nome, e nessuna singola selezione le soddisfa entrambe — così, anziché sceglierne una e lasciare che l’altro consumatore legga una struttura per cui non è stato scritto, il build si ferma e indica il disaccordo. Un consumatore che non indica alcuna versione minima non prende parte a nulla di tutto questo: la selezione è decisa dai consumatori che hanno fissato una versione.

Messaggio emesso. I consumatori vengono confrontati dopo essere stati ordinati: il primo che indica una versione minima stabilisce la major, e il messaggio elenca ogni consumatore confrontato, fino al primo, incluso, la cui versione minima indica una major diversa, insieme alla versione che ha richiesto — così gli stessi documenti indicano sempre gli stessi consumatori:

resolve: minimal version selection conflict — incompatible library version requirements: library "<library>" has consumers requiring incompatible majors: <consumer> wants <version>; <consumer> wants <version> (risoluzione: conflitto nella selezione della versione minima — requisiti di versione della libreria incompatibili: la libreria ha consumatori che richiedono versioni major incompatibili: il consumatore richiede la versione; il consumatore richiede la versione)

Come risolvere: alza la versione minima del consumatore più basso alla stessa major, che è la risposta ordinaria quando la struttura più recente è quella che tutti vogliono. Dove servono davvero entrambe le major contemporaneamente, si tratta di due librerie: pubblica la struttura più vecchia con un nome proprio e fai puntare lì il consumatore che ne ha bisogno, così ogni riferimento indica ciò per cui è stato scritto.

The chain of module imports is deeper than the pin walk descends (La catena di importazioni di moduli è più profonda di quanto scenda la visita del pinning)

Il pinning visita ogni modulo che un Aggregate importa, poi ogni modulo che questi importano, così l’intero insieme raggiunge il lockfile anziché solo il primo livello. Un modulo già registrato non viene visitato una seconda volta, ed è ciò che pone fine a un ciclo ordinario — un Aggregate che importa un modulo che a sua volta lo importa termina senza errori, dopo aver registrato ciascuno una sola volta.

Un limite di profondità pari a dieci fa da rete di sicurezza per la catena che il rilevamento delle ripetizioni non può vedere: una che presenta un’identità nuova a ogni livello, come fa un modulo ripubblicato con una nuova versione a ogni passo. Il limite è lo stesso che applica il costruttore del grafo, quindi una composizione su cui il pinning riesce è anche una composizione che si costruisce.

Messaggio emesso:

resolve: sub-aggregate inclusion depth exceeded: "<module>" at depth <depth> (risoluzione: profondità di inclusione dei sub-aggregati superata: alla profondità)

Come risolvere: accorcia la catena. Una catena così profonda di solito rispecchia il modo in cui è organizzata un’azienda anziché il modo in cui è organizzata la Release, quindi cerca i livelli che non contribuiscono con componenti propri e accorpali nel loro genitore. Dove ogni livello esiste solo per ripubblicare il livello sottostante con una nuova versione, la catena sono le versioni: importa direttamente il modulo che vuoi davvero, alla versione che vuoi.

Questo è il limite della visita del pinning. Il costruttore del grafo applica il proprio, segnalato più sotto come «Sub-aggregate nesting depth exceeded (Profondità di annidamento dei sub-aggregati superata)», e i due sono segnalazioni distinte dello stesso limite raggiunto in due punti — la prima mentre si compila il lockfile, la seconda mentre si costruisce il grafo.

The catalog view a build was given cannot load the bodies pinning needs (La vista del catalogo fornita a un build non può caricare i corpi di cui il pinning ha bisogno)

Due degli assi che il pinning visita richiedono al catalogo più di una risposta sulla versione: richiedono i documenti stessi. I moduli che un Aggregate importa devono essere letti per trovare ciò che essi importano a loro volta. Le Recipes, le FeatureRecipes e i Plugins che un build lega devono essere letti per trovare gli artefatti e le librerie che essi indicano. Una vista del catalogo che sa risolvere una versione ma non sa restituire quei corpi lascia entrambi gli assi senza nulla da leggere.

Entrambi i casi vengono rifiutati subito anziché saltati, e il motivo è ciò che un salto produrrebbe: un lockfile privo di un’intera classe di voci, scritto senza errori, che un build successivo ricostruisce fedelmente e trova incompleto. Nessuno dei due messaggi contiene valori propri, perché nessuno dei due riguarda un documento che hai scritto — ciascuno indica quale asse non può essere calcolato:

resolve: catalog lookup cannot load resolved sub-aggregate bodies (risoluzione: la ricerca nel catalogo non può caricare i corpi dei sub-aggregati risolti) resolve: catalog lookup cannot load resolved recipe and plugin bodies (risoluzione: la ricerca nel catalogo non può caricare i corpi di Recipe e plugin risolti)

Come risolvere: nulla nei tuoi file produce l’uno o l’altro, e non esiste alcuna modifica a ciò che hai scritto che ne elimini uno — l’errore sta nel modo in cui il build è stato predisposto, non in ciò che gli è stato chiesto di costruire. Segnalalo indicando il comando che hai eseguito e la configurazione del workspace su cui è stato eseguito.

An annotation-transform plugin names a component it was not given, or injects a value no annotation takes (Un plugin annotation-transform indica un componente che non gli è stato fornito, o inietta un valore che nessuna annotazione accetta)

Un operatore può associare un plugin di governance in un ruolo che aggiunge annotazioni, e quell’associazione è una dichiarazione: l’operatore ha chiesto la trasformazione, quindi ciò che il plugin aggiunge è esplicito anziché iniettato alle spalle di qualcuno. Il ruolo è limitato di conseguenza. Il plugin riceve le coordinate dei componenti che i tuoi documenti dichiarano e può aggiungere annotazioni su quelle, ciascuna con un valore che avresti potuto scrivere tu stesso su quell’annotazione: una stringa o un oggetto di sottochiavi. La struttura che restituisce non ammette altri campi, quindi ciò che resta da verificare quando il suo output viene applicato è se ogni iniezione ha indicato una coordinata che gli è stata fornita e se ogni valore è uno di quelli che un’annotazione accetta.

Un’iniezione che indica una coppia confine-componente al di fuori di quell’insieme ferma il build. Un plugin che raggiungesse un componente che i tuoi documenti non hanno mai esposto configurerebbe un’infrastruttura che nessuno ha dichiarato, e le annotazioni che aggiunge vengono espanse in associazioni di Feature esattamente come quelle scritte dall’autore, quindi l’effetto sarebbe la comparsa di risorse da un componente che l’operatore non gli ha messo davanti.

Anche un’iniezione il cui valore è null, una lista, un numero, un booleano o un oggetto senza sottochiavi ferma il build. Null e un oggetto vuoto si leggono come il valore che scrivi per escludere un componente da un’annotazione che erediterebbe, e il ruolo aggiunge annotazioni anziché rimuoverle; le altre strutture non sono valori che un’annotazione accetta. L’intero output viene verificato prima che ne venga applicata una qualsiasi parte, quindi un output rifiutato non cambia nulla.

Ogni iniezione accettata porta anche un’annotazione di accompagnamento, aggrega.ai/injected-by, che indica il plugin che l’ha effettuata. È l’host a scrivere quell’annotazione; un plugin non può fornirne una, quindi ciò che essa dice sulla provenienza di un’annotazione iniettata non spetta al plugin stabilirlo.

Messaggio emesso, per una coordinata che non è stata fornita al plugin e per un valore che nessuna annotazione accetta:

annotation-transform plugin output was rejected: an injection targets a component coordinate the host did not supply, or carries a value that is not a string or an object of subkeys: injection targets boundary "<boundary>" component "<component>" (annotation "<key>") (l’output del plugin annotation-transform è stato rifiutato: un’iniezione punta a una coordinata di componente che l’host non ha fornito, o contiene un valore che non è una stringa né un oggetto di sottochiavi: l’iniezione punta al confine, componente (annotazione)) annotation-transform plugin output was rejected: an injection targets a component coordinate the host did not supply, or carries a value that is not a string or an object of subkeys: injection for boundary "<boundary>" component "<component>" (annotation "<key>") carries a list; an injected annotation value is a string or an object of subkeys (l’output del plugin annotation-transform è stato rifiutato: un’iniezione punta a una coordinata di componente che l’host non ha fornito, o contiene un valore che non è una stringa né un oggetto di sottochiavi: l’iniezione per il confine, componente (annotazione) contiene una lista; un valore di annotazione iniettato è una stringa o un oggetto di sottochiavi)

Come risolvere: l’errore è del plugin, non dei tuoi documenti — correggilo in modo che inietti solo sulle coordinate che riceve, ciascuna delle quali arriva nel suo input, e solo una stringa o un oggetto di sottochiavi come valore. Se il componente nel messaggio è uno che ti aspettavi il plugin vedesse, verifica che la Release lo dichiari all’interno di un confine: vengono passate solo le coordinate dei componenti dichiarati. Rimuovere l’associazione da plugins.governance è il modo immediato per sbloccare un build mentre il plugin viene corretto.

A plugin reference is not a Plugin entity (Un riferimento a un plugin non è un’entità Plugin)

Un plugin viene referenziato tramite la sua entità Plugin, sempre con l’ambito del tipo di socket del plugin stesso: <pluginType>/<name>, facoltativamente con una versione, come in parser/yaml o parser/yaml:1.0.0. L’ambito è obbligatorio, non una forma tra le tante — un name:version senza ambito viene rifiutato, perché due socket possono contenere un plugin con lo stesso nome ed è l’ambito a rendere l’entità risolvibile. Il binario a cui l’entità punta si raggiunge attraverso l’entità e non viene mai indicato direttamente, quindi è l’entità a portare la dichiarazione di capacità, i limiti di runtime e l’insieme di comandi registrato rispetto a cui il caricamento verifica il binario. Un riferimento che non indica alcuna entità Plugin non ha quindi nulla con cui verificare il binario, e il build si ferma anziché caricare byte su un riferimento non verificato.

Due strutture vengono segnalate qui, e sono verificate in momenti diversi. Un riferimento la cui forma non può essere un’entità — un percorso del filesystem, o un riferimento ad artefatto come un URL oci://, un .wasm semplice o un digest @sha256: — viene rifiutato subito sulle superfici che accettano solo riferimenti a entità. Un riferimento che non indica alcuna entità contenuta da qualcosa viene rifiutato dopo la ricerca, e ciò che dice il messaggio dipende da come è scritto: un URI di entità Plugin — <pluginType>/<name>, facoltativamente con versione — viene segnalato come un’entità che nessuna directory di catalogo contiene, che il binario non include e che nessun pull ha scaricato, e a qualsiasi altro riferimento viene detto di assumere quella forma. Entrambe le strutture segnalano la stessa condizione, quindi la risposta di un build all’una o all’altra è la stessa.

Un pull rifiuta la seconda struttura prima che un build la incontri. Ogni Plugin indicato dalla pipeline di una Recipe o di una FeatureRecipe viene risolto insieme al resto delle dipendenze della Release — da una directory di catalogo, dalla copia interna al binario del compilatore, dalla cache dei contenuti o da un registry — e uno che nessuno di essi contiene ferma aggrega pull prima che scriva il lockfile, con questa condizione e lo stesso messaggio, indicando la Recipe o la FeatureRecipe la cui pipeline lo indica.

Non tutte le superfici rifiutano una forma che non è un’entità. La superficie dei plugin di pipeline accetta solo riferimenti a entità; le superfici a cui un operatore associa direttamente un plugin accettano qualsiasi forma e passano un riferimento che non è un’entità perché venga risolto come artefatto. Così lo stesso riferimento può essere accettato in un punto di associazione e rifiutato in un altro, e quella differenza dipende dalla superficie, non dal riferimento.

Messaggi emessi. Un percorso del filesystem:

plugin reference is not a Plugin entity: "<reference>" is a filesystem path, but a pipeline plugin must be a plugin-type-scoped Plugin entity URI (<pluginType>/<name>, optionally versioned, as in parser/yaml or parser/yaml:1.0.0) (il riferimento al plugin non è un’entità Plugin: è un percorso del filesystem, ma un plugin di pipeline deve essere un URI di entità Plugin con ambito di tipo di plugin (facoltativamente con versione))

un riferimento ad artefatto:

plugin reference is not a Plugin entity: "<reference>" is an artifact reference (an oci:// scheme, a bare .wasm, or an @sha256: digest), but a pipeline plugin must be a plugin-type-scoped Plugin entity URI (<pluginType>/<name>, optionally versioned, as in parser/yaml or parser/yaml:1.0.0) (il riferimento al plugin non è un’entità Plugin: è un riferimento ad artefatto (uno schema URL, un file Wasm semplice o un digest), ma un plugin di pipeline deve essere un URI di entità Plugin con ambito di tipo di plugin (facoltativamente con versione))

un URI di entità Plugin che nessuna fonte contiene:

plugin reference is not a Plugin entity: "<reference>" is a Plugin entity URI, but no catalog directory holds the entity it names, the binary does not carry it, and no pull has fetched it into the content cache; place the Plugin entity in a catalog directory, or publish it to a registry and run aggrega pull (il riferimento al plugin non è un’entità Plugin: è un URI di entità Plugin, ma nessuna directory di catalogo contiene l’entità che indica, il binario non la include e nessun pull l’ha scaricata nella cache dei contenuti; colloca l’entità Plugin in una directory di catalogo, oppure pubblicala in un registry ed esegui il pull)

e qualsiasi altro riferimento che non indica alcuna entità — uno senza ambito di tipo di plugin, con più di un / prima della versione, o che contiene un host di registry:

plugin reference is not a Plugin entity: "<reference>" must be a plugin-type-scoped Plugin entity URI (<pluginType>/<name>, optionally versioned, as in parser/yaml or parser/yaml:1.0.0); a bare .wasm reference or an artifact reference names no Plugin entity (il riferimento al plugin non è un’entità Plugin: deve essere un URI di entità Plugin con ambito di tipo di plugin (facoltativamente con versione); un riferimento a un file Wasm semplice o un riferimento ad artefatto non indica alcuna entità Plugin)

Come risolvere: scrivi il riferimento come identità dell’entità Plugin con ambito di tipo di socket, facoltativamente con la sua versione — <pluginType>/<name> o <pluginType>/<name>:<version>. Se puntavi direttamente a un file o a un artefatto, pubblica o scrivi un’entità Plugin per esso e fai riferimento a quella — l’entità è il luogo in cui risiedono le dichiarazioni che il caricamento verifica, quindi non esiste una forma equivalente che la salti. Se il messaggio dice che il riferimento è un URI di entità Plugin, la sua forma è corretta e ciò che manca è l’entità: colloca l’entità Plugin in una directory di catalogo elencata dal workspace, con il suo .wasm compilato accanto, oppure pubblica il plugin in un registry letto dal workspace ed esegui aggrega pull, che lo scarica nella cache dei contenuti — e verifica che la versione che indichi esista.

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)

Un artifact la cui firma è stata verificata quando è stato scaricato porta con sé questo fatto nella sua voce del lockfile — oppure, per un plugin associato a un ruolo di verdetto, nella sua voce in plugins-trust.yaml — come digest registrato del materiale di firma, messo in cache accanto all’artifact. Prima che venga eseguito qualsiasi rendering, il build rilegge quel materiale in cache per ogni voce che legge e che ne registra uno — un’entità di catalogo di qualsiasi tipo, una libreria, un plugin — e ne ricalcola l’hash, e l’hash deve essere quello registrato. Un plugin che il lockfile vincola, e un plugin associato a un ruolo di verdetto, ha il proprio materiale verificato di nuovo quando i suoi byte vengono caricati, ed è questo che raggiunge i comandi che caricano un plugin al di fuori di un build — tra cui aggrega lint --release e aggrega validate --release. Un bundle mancante, illeggibile o con un hash diverso significa che il materiale esaminato non è quello che si trova ora sul disco, e l’esecuzione si arresta anziché usare un artifact le cui prove di firma sono cambiate rispetto a quanto registrato.

La nuova verifica è un confronto di hash e nient’altro. Non verifica di nuovo alcuna firma, non contatta la rete e non consulta alcun materiale di fiducia, quindi vale anche in un build senza alcun accesso alla rete — ed è questo che permette a un artifact verificato una volta di restare verificato nei build offline successivi.

Il pull successivo lo ripara. Un pull sottopone allo stesso controllo ogni voce servita dalla cache dei contenuti e, dove il controllo rifiuta una voce, interroga di nuovo il registry dell’artifact sulla firma — qualunque cosa dica il requisito di firma, attraverso la stessa verifica che riceve un artifact che scarica —, registra nella voce ciò che questa verifica e mette in cache il bundle che essa indica, riscrivendo una copia in cache che non corrisponde più al suo digest. Un plugin associato a un ruolo di verdetto viene verificato di nuovo a ogni pull, qualunque cosa registri la sua voce, e il suo bundle viene messo in cache allo stesso modo. Per questo il messaggio per una voce servita dalla cache dei contenuti indica quel pull. Una voce letta da una directory di catalogo, dalla copia contenuta nel binario del compilatore o da accanto alla Release non viene mai interrogata presso un registry, quindi un pull lascia com’è una firma registrata su di essa, e il suo messaggio non indica alcun pull.

Messaggi emessi, che indicano l’artifact, il file in cache e — per una voce servita dalla cache dei contenuti — il pull che la ripara, il file in cui registra la firma e la Release di cui esegue il pull. Dal controllo del build, illeggibile o assente:

artifact "<reference>": cached signature bundle <path> is unreadable: cached signature bundle does not match its recorded digest. remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (artifact: il bundle di firma in cache è illeggibile: il bundle di firma in cache non corrisponde al suo digest registrato. rimedio: esegui il pull per verificare di nuovo la firma dell’artifact presso il suo registry, registrarla nel file e mettere in cache il bundle che indica)

e divergente:

artifact "<reference>": cached signature bundle <path> has digest <actual>, recorded digest is <recorded>: cached signature bundle does not match its recorded digest. remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (artifact: il bundle di firma in cache ha un digest diverso da quello registrato: il bundle di firma in cache non corrisponde al suo digest registrato. rimedio: esegui il pull per verificare di nuovo la firma dell’artifact presso il suo registry, registrarla nel file e mettere in cache il bundle che indica)

e, dove i byte di un plugin vengono caricati dalla cache dei contenuti, indicando anche da dove provengono:

plugin "<reference>" resolved from <source>: cached signature bundle <path> is unreadable: cached signature bundle does not match its recorded digest. remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (plugin risolto dalla sua sorgente: il bundle di firma in cache è illeggibile: il bundle di firma in cache non corrisponde al suo digest registrato. rimedio: esegui il pull per verificare di nuovo la firma dell’artifact presso il suo registry, registrarla nel file e mettere in cache il bundle che indica)

plugin "<reference>" resolved from <source>: cached signature bundle <path> has digest <actual>, recorded digest is <recorded>: cached signature bundle does not match its recorded digest. remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (plugin risolto dalla sua sorgente: il bundle di firma in cache ha un digest diverso da quello registrato: il bundle di firma in cache non corrisponde al suo digest registrato. rimedio: esegui il pull per verificare di nuovo la firma dell’artifact presso il suo registry, registrarla nel file e mettere in cache il bundle che indica)

<file> è il lockfile della Release, oppure plugins-trust.yaml nella directory della Release. Per una voce su cui nessun pull interroga un registry, il messaggio termina prima di remediation:.

Un pull che non ha alcun registry da interrogare si arresta invece. Un’entità di catalogo o una libreria viene indicata senza registry ed è legata a uno tramite il default_registry del workspace. Dove il workspace non ne indica alcuno — lo faceva quando la firma è stata registrata, e non lo fa più — non è configurato alcun registry a cui chiedere di nuovo della voce, quindi il pull si arresta con questa condizione anziché scrivere un lockfile che il build successivo rifiuta, e lascia il lockfile com’era. Il suo messaggio riporta, dopo lo step che il pull stava eseguendo:

verify: "<reference>" records a signature a build does not accept, and no registry is configured to ask about it again: cached signature bundle <path> is unreadable: cached signature bundle does not match its recorded digest (verify: registra una firma che un build non accetta, e non è configurato alcun registry a cui chiedere di nuovo al riguardo: il bundle di firma in cache è illeggibile: il bundle di firma in cache non corrisponde al suo digest registrato)

Come risolvere: nulla nei tuoi file di entità causa questo problema — la cache è del build, non tua. Esegui aggrega pull --release <release>, il comando che il messaggio indica: verifica di nuovo la firma dell’artifact e scrive insieme la firma e il suo bundle, il che ripara un bundle rimosso o alterato dopo il pull che lo ha messo in cache. In modalità offline quel pull si arresta — con il rifiuto offline, perché riparare significa interrogare il registry, oppure, per un plugin associato a un ruolo di verdetto, prima ancora, indicando il .wasm del plugin come uno che non è riuscito a risolvere, perché un pull risolve quel .wasm dal registry del plugin; consentire la rete per quella sola esecuzione lo ripara. Dove il pull si arresta dicendo che non è configurato alcun registry a cui chiedere della voce, imposta default_registry sul registry da cui l’artifact è stato prelevato con il pull, ed esegui di nuovo il pull. Dove il workspace salta la verifica della firma per l’artifact, il pull non registra invece alcuna firma nella voce, cosa che il build ammette con quella stessa impostazione. Dove la firma servita dal registry non supera la verifica, il pull si arresta con il rifiuto proprio di quella verifica: la firma registrata e il materiale servito dall’editore sono effettivamente in disaccordo, e questa è una questione per chi pubblica l’artifact. Per una voce il cui messaggio non indica alcun pull — una letta da una directory di catalogo, dalla copia contenuta nel binario del compilatore o da accanto alla Release — rimuovi la signature dalla sua voce: una voce di questo tipo non è mai soggetta a un requisito di firma, quindi il build procede.

A recorded signature was made for a different artifact (Una firma registrata è stata creata per un artifact diverso)

Una firma dice per quale artifact è stata creata. Quando un pull verifica la firma di un artifact, registra il fatto nella voce del lockfile dell’artifact — oppure, per un plugin associato a un ruolo di verdetto, nella sua voce in plugins-trust.yaml — e mette in cache la firma che ha verificato. Prima che venga eseguito qualsiasi rendering, il build legge, dalla firma in cache di ogni voce servita dalla cache dei contenuti, per quale artifact è stata creata, e questo deve essere l’artifact che il build stesso ha letto per la voce: quello il cui manifesto è conservato accanto ai suoi byte nella cache dei contenuti, mai qualcosa che la voce registra. Una firma creata per un artifact diverso arresta il build. È l’aspetto che ha una signature copiata da una voce a un’altra: la firma in cache che essa indica è intatta — corrisponde ancora al digest registrato per essa — ed è stata creata per l’artifact dell’altra voce.

Non dipende da un requisito di firma. Una firma registrata viene confrontata con ciò che dichiara, che una firma sia richiesta o meno, così come avviene per il controllo che la firma in cache corrisponda al suo digest registrato.

Un plugin è soggetto allo stesso controllo ovunque venga caricato. Un plugin che il lockfile vincola, e un plugin associato a un ruolo di verdetto, ha la propria firma registrata confrontata con l’artifact da cui sono stati letti i suoi byte quando quei byte vengono caricati dalla cache dei contenuti, il che raggiunge i comandi che caricano un plugin al di fuori di un build — tra cui aggrega lint --release e aggrega validate --release, e le stesse operazioni raggiunte tramite aggrega serve e aggrega mcp.

Che cosa legge il controllo, e che cosa non può distinguere. Legge la firma in cache e il manifesto accanto all’artifact, e confronta gli hash: non verifica alcuna firma, non contatta la rete e non consulta alcun materiale di fiducia, quindi vale anche in un build senza alcun accesso alla rete. Legge per quale artifact è stata creata una firma in entrambe le forme che un pull accetta — una firma creata sull’artifact stesso, che è ciò che producono i firmatari della toolchain stessa, e una dichiarazione firmata che indica l’artifact — quindi una firma copiata da una voce a un’altra viene rifiutata in entrambe le forme. È la stessa lettura che un pull applica a ogni firma che accetta: un pull rifiuta una firma che supera la verifica ma che la lettura non trova creata per l’artifact, o dalla quale non riesce affatto a leggere l’artifact, quindi nessuna firma registrata da un pull è una che il controllo non riesce a leggere. Una voce letta da una directory di catalogo, dalla copia contenuta nel binario del compilatore o da accanto alla Release non ha alcun manifesto, quindi la sua firma registrata viene confrontata solo con il suo digest registrato; lo stesso vale per una firma messa a mano nella cache in una forma che non è nessuna di quelle due. E poiché non viene verificata alcuna firma, una firma scritta a mano nella cache, intestata all’artifact della voce stessa, non viene distinta da una che un pull ha verificato.

Il pull successivo lo ripara. Un pull sottopone allo stesso controllo ogni voce servita dalla cache dei contenuti e, dove il controllo rifiuta una voce, interroga di nuovo il registry dell’artifact sulla firma — qualunque cosa dica il requisito di firma — e registra nella voce ciò che questa verifica al posto della firma copiata. Un plugin associato a un ruolo di verdetto viene verificato di nuovo a ogni pull, qualunque cosa registri la sua voce. Solo per una voce servita dalla cache dei contenuti si controlla per quale artifact è stata creata la sua firma, quindi ogni rifiuto di questa condizione da parte di un build o del caricamento di un plugin indica quel pull.

Messaggi emessi, che indicano la voce, il file che registra la firma, la firma in cache, il manifesto che il build ha letto per la voce e il pull che la ripara. Dal controllo del build:

artifact "<reference>": signing: the recorded signature was made for a different artifact (<file> records it, cached signature bundle <path>, the artifact read has manifest <manifest-digest>). remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (artifact: signing: la firma registrata è stata creata per un artifact diverso, con il file che la registra, il bundle di firma in cache e il manifesto dell’artifact letto. rimedio: esegui il pull per verificare di nuovo la firma dell’artifact presso il suo registry, registrarla nel file e mettere in cache il bundle che indica)

e, dove vengono caricati i byte di un plugin, indicando anche da dove provengono:

plugin "<reference>" resolved from <source>: signing: the recorded signature was made for a different artifact (<file> records it, cached signature bundle <path>, the artifact read has manifest <manifest-digest>). remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (plugin risolto dalla sua sorgente: signing: la firma registrata è stata creata per un artifact diverso, con il file che la registra, il bundle di firma in cache e il manifesto dell’artifact letto. rimedio: esegui il pull per verificare di nuovo la firma dell’artifact presso il suo registry, registrarla nel file e mettere in cache il bundle che indica)

<file> è il lockfile della Release, oppure plugins-trust.yaml nella directory della Release.

Un pull che non ha alcun registry da interrogare si arresta invece, come fa per un bundle di firma in cache che non corrisponde più al suo digest: dove un’entità di catalogo o una libreria porta una firma copiata e il workspace non indica più un default_registry a cui legarla, il pull si arresta con questa condizione e lascia il lockfile com’era. Il suo messaggio riporta, dopo lo step che il pull stava eseguendo:

verify: "<reference>" records a signature a build does not accept, and no registry is configured to ask about it again: signing: the recorded signature was made for a different artifact (cached signature bundle <path>, the artifact read has manifest <manifest-digest>) (verify: registra una firma che un build non accetta, e non è configurato alcun registry a cui chiedere di nuovo al riguardo: signing: la firma registrata è stata creata per un artifact diverso, con il bundle di firma in cache e il manifesto dell’artifact letto)

Come risolvere: nulla nei tuoi file di entità causa questo problema — la firma registrata dalla voce appartiene a un altro artifact. Esegui aggrega pull --release <release>, il comando che il messaggio indica: verifica la firma propria della voce presso il suo registry e la registra al posto di quella copiata, sia per una voce del lockfile sia per un plugin associato a un ruolo di verdetto. Funziona anche ripristinare dal controllo di versione la firma registrata propria della voce, dove il file è sottoposto a commit. In modalità offline il pull si arresta — con il rifiuto offline, perché riparare significa interrogare il registry, oppure, per un plugin associato a un ruolo di verdetto, prima ancora, indicando il .wasm del plugin come uno che non è riuscito a risolvere, perché un pull risolve quel .wasm dal registry del plugin; consentire la rete per quella sola esecuzione lo ripara. Dove il pull si arresta dicendo che non è configurato alcun registry a cui chiedere della voce, imposta default_registry sul registry da cui l’artifact è stato prelevato con il pull, ed esegui di nuovo il pull. Dove il workspace salta la verifica della firma per l’artifact, il pull non registra invece alcuna firma nella voce, cosa che il build ammette con quella stessa impostazione.

No verified signature is recorded for an artifact that requires one (Nessuna firma verificata è registrata per un artifact che la richiede)

Un pull che scarica un artifact da un registry ne verifica la firma rispetto alla policy di fiducia di quel registry e registra il fatto verificato sulla voce del lockfile dell’artifact. Un build non raggiunge alcun registry, quindi legge il fatto registrato invece di verificare di nuovo — e, prima di qualsiasi rendering, sottopone ogni voce che legge al requisito che il pull ha applicato quando ha scaricato l’artifact. Una voce servita dalla cache dei contenuti, per un artifact per cui è richiesta una firma, che non registra alcuna firma verificata arresta il build: nulla di ciò che il build possiede dice che l’artifact da cui sta per eseguire il rendering sia mai stato verificato.

Il requisito è quello del pull, impostazione per impostazione. Una firma è richiesta dove la policy di firma valida per l’intero workspace copre il tipo dell’artifact, o dove la voce propria del registry in .aggrega-config.yaml — oppure, per hub.aggrega.ai senza una voce propria, la policy integrata dell’hub ufficiale — ne richiede una; un artifact il cui tipo non è stato possibile determinare conta come richiesto sotto una policy attiva. Ciò che consente a un pull di ammettere un artifact senza firma consente anche al build di ammetterne la voce: skip_signature_verification al livello superiore, lo stesso interruttore sulla voce propria del registry tranne che per un tipo richiesto dalla policy valida per l’intero workspace, e un registry contrassegnato come advisory.

La provenienza di una voce si legge dal build, mai dal lockfile. Ogni voce servita dalla cache dei contenuti è sottoposta al requisito, qualunque altra cosa la voce registri, quindi rimuovere il digest del manifesto di una voce insieme alla sua firma non la esenta. Una voce letta da una directory di catalogo, dalla copia interna al binario del compilatore o da accanto alla Release non vi è mai sottoposta, perché non esiste alcuna firma di registry per byte che non provengono da un registry. Le voci di ogni sezione sono controllate allo stesso modo — entità del catalogo, librerie e artifact dei plugin — e ogni voce che il controllo rifiuta viene nominata nella stessa esecuzione.

Un plugin associato in un ruolo di verdetto è sottoposto allo stesso controllo, tramite plugins-trust.yaml. Un’associazione plugins.governance in un ruolo ir-verdict o render-verdict, e ogni associazione plugins.linter, non dà forma ad alcun byte renderizzato, quindi non ha una voce nel lockfile; il record accanto al lockfile ne porta invece la firma verificata. Ogni plugin di questo tipo che il build legge dalla cache dei contenuti è sottoposto allo stesso requisito, tramite le stesse impostazioni: una voce in quel record che non registra alcuna firma arresta il build, e così anche l’assenza di qualsiasi voce per il plugin — eliminare il record non lo esenta. Un plugin servito da una directory di catalogo o dalla copia interna al binario del compilatore non vi è sottoposto. Il requisito vale per un plugin di questo tipo ovunque venga caricato per una Release, non solo in un build: aggrega lint --release e aggrega validate --release, e le stesse operazioni raggiunte tramite aggrega serve e aggrega mcp, falliscono per questa condizione quando lo caricano.

Messaggi emessi, che nominano la voce, il file che non registra alcuna firma per essa, le impostazioni che ne richiedono la firma e il comando che la registra in quel file. Per una voce del lockfile, con il nome del lockfile:

signing: no verified signature is recorded for an artifact that requires one ("<reference>", <lockfile-path> records no signature for it, required by <the settings that require it>). remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry and record it in <lockfile-path> (signing: nessuna firma verificata è registrata per un artifact che la richiede: il lockfile non registra alcuna firma per esso, richiesta dalle impostazioni indicate. rimedio: esegui il pull per verificare la firma dell’artifact nel suo registry e registrarla nel lockfile)

e per un plugin associato in un ruolo di verdetto, con il nome del suo record:

signing: no verified signature is recorded for an artifact that requires one ("<plugin>", <record-path> records no signature for it, required by <the settings that require it>). remediation: run aggrega pull --release <release> to verify the plugin’s signature at its registry and record it in <record-path> (signing: nessuna firma verificata è registrata per un artifact che la richiede: il record non registra alcuna firma per il plugin, richiesta dalle impostazioni indicate. rimedio: esegui il pull per verificare la firma del plugin nel suo registry e registrarla nel record)

Entrambi i file sono indicati con il loro percorso accanto alla Release data al comando: <lockfile-path> è il lockfile della Release, e <record-path> è plugins-trust.yaml nella directory della Release.

Le impostazioni sono nominate con le parole stesse del file di configurazione: `signing.required` at the top level of the workspace configuration, `signing.required` on the `registries` entry for "<host>" oppure the official hub's built-in signature requirement for "hub.aggrega.ai", unite dove se ne applica più di una.

Come risolvere: esegui il pull indicato dal messaggio. Per una voce servita dalla cache dei contenuti che non registra alcuna firma dove ne è richiesta una, il pull chiede al registry dell’artifact la sua firma, tramite il digest del manifesto registrato dalla voce, esattamente come fa per un artifact che scarica, e registra la firma verificata sulla voce — così il build successivo la legge. Per un plugin associato in un ruolo di verdetto la domanda viene posta a ogni pull in ogni caso, e il pull registra ciò che ha verificato sulla voce del plugin in plugins-trust.yaml, creando la voce dove non ce n’è una. Un registry che non associa alcuna firma, o una firma che la configurazione di fiducia non accetta, arresta invece quel pull, nominando l’artifact, e questa è una questione per chi lo pubblica. In modalità offline il pull non può chiedere: su una voce del lockfile rifiuta indicando come consentire la rete per un’esecuzione, e su un plugin associato in un ruolo di verdetto si arresta prima di chiedere, nominando il .wasm del plugin come uno che non ha potuto risolvere, perché un pull risolve quel .wasm dal registry del plugin. Ripristinare la firma registrata della voce dal controllo di versione la sistema senza la rete, dove la cache contiene ancora il materiale di firma che quel record nomina. Dove l’artifact non è destinato a essere firmato, è il requisito a dover cambiare, e il messaggio indica quale impostazione sia — ma allentarlo significa che gli artifact di quel registry non vengono più controllati nemmeno a un pull, quindi è preferibile restringere i tipi della policy valida per l’intero workspace piuttosto che disattivare un requisito.

A recorded signature is not the one a pull would record (Una firma registrata non è quella che registrerebbe un pull)

aggrega pull --verify segnala se eseguire aggrega pull adesso cambierebbe i file che un pull scrive, e la firma che un pull ha verificato per un artifact fa parte di ciò che scrive: la signature su una voce del lockfile, e su una voce di plugins-trust.yaml per un plugin associato in un ruolo di verdetto. Questa condizione è ciò che una verifica segnala per ogni firma registrata che un semplice pull scriverebbe in modo diverso — una che registrerebbe dove non ne è registrata nessuna, una che sostituirebbe o una che cancellerebbe. La verifica non scrive nessuno dei due file e nomina ogni voce di questo tipo, in entrambi i file, nella stessa esecuzione.

Due voci del lockfile vengono segnalate senza chiedere a un registry, perché un pull le riscrive qualunque cosa risponda il registry, quindi vengono segnalate anche in modalità offline: una voce servita dalla cache dei contenuti che non registra alcuna firma dove la configurazione di fiducia ne richiede una — il pull registra la firma dell’artifact, o si arresta dove non riesce a stabilirne una — e una voce la cui firma registrata è stata fatta per un altro artifact, che il pull sostituisce con quella propria dell’artifact.

Per ogni altra voce che un pull cercherebbe di nuovo viene posta la domanda, perché solo la risposta del registry dice se il pull la cambierebbe: una voce i cui byte la verifica ha scaricato perché la cache dei contenuti non li conteneva, e una voce il cui bundle di firma in cache è stato rimosso, è illeggibile o è stato alterato. La verifica chiede al registry come farebbe il pull, segnala la voce dove la risposta registra, sostituisce o cancella la sua firma, e mette in cache il bundle che ha verificato come lo mette in cache un pull. In modalità offline per una voce di questo tipo non viene posta la domanda né essa viene segnalata: la verifica stampa una riga che la nomina e dice che la sua firma non è stata controllata.

Per il record di fiducia dei plugin, ogni pull verifica la firma di ciascun plugin associato in un ruolo di verdetto nel suo registry, e così fa una verifica: viene segnalata una voce la cui firma quella verifica registrerebbe, sostituirebbe o cancellerebbe, e così un plugin per cui il record non contiene alcuna voce dove un build lo rifiuta perché non registra alcuna firma, perché un pull scrive una voce che ne porta la firma e il build rifiuta il plugin fino ad allora. Ogni altro plugin che il record non contiene ancora è una prima comparsa e non viene segnalato. In modalità offline una verifica non chiede ad alcun registry di questi plugin: legge ciascuno dalla cache dei contenuti, come lo legge un build, e ne controlla l’identità e le funzioni host come fa una verifica connessa. Segnala senza chiedere un plugin che un build rifiuta perché non registra alcuna firma — la sua voce non ne registra nessuna, o il record non contiene alcuna voce per esso — e uno che un build rifiuta perché la firma registrata dalla sua voce è stata fatta per un altro artifact, perché un pull riscrive quella voce qualunque cosa risponda il registry; stampa una riga che nomina ogni altra voce e dice che la sua firma non è stata controllata.

I marcatori di deprecazione non vengono confrontati. Un marcatore associato a un artifact dopo il pull è lo stato del registry e cambia senza che nulla nel workspace cambi, quindi una verifica che fallisse su di esso farebbe fallire un controllo su file che nessuno ha toccato — il motivo per cui un marcatore registrato avvisa un build invece di arrestarlo.

Messaggi emessi, uno per voce, che nominano la voce, il file e ciò che registra, ciò che un pull registrerebbe invece, e il pull che aggiorna il file. Dove la risposta del registry, o la verifica propria del record, fornisce la firma che un pull registrerebbe:

signing: a recorded signature is not the one a pull would record ("<reference>", <file> records <signature>, a pull would record <signature>). remediation: run aggrega pull --release <release> to bring <file> up to date (signing: una firma registrata non è quella che registrerebbe un pull: il file registra una firma, un pull ne registrerebbe un’altra. rimedio: esegui il pull per aggiornare il file)

per una voce che non registra alcuna firma dove ne è richiesta una — una voce del lockfile o, in modalità offline, una voce del record di fiducia dei plugin:

signing: a recorded signature is not the one a pull would record ("<reference>", <file> records no signature, a pull would ask its registry for the signature a requirement asks for and record it). remediation: run aggrega pull --release <release> to bring <file> up to date (signing: una firma registrata non è quella che registrerebbe un pull: il file non registra alcuna firma, un pull chiederebbe al suo registry la firma richiesta da un requisito e la registrerebbe. rimedio: esegui il pull per aggiornare il file)

per una voce la cui firma registrata è stata fatta per un altro artifact — una voce del lockfile o, in modalità offline, una voce del record di fiducia dei plugin:

signing: a recorded signature is not the one a pull would record ("<reference>", <file> records <signature>, made for another artifact, a pull would ask its registry for this artifact’s own signature and record it). remediation: run aggrega pull --release <release> to bring <file> up to date (signing: una firma registrata non è quella che registrerebbe un pull: il file registra una firma fatta per un altro artifact, un pull chiederebbe al suo registry la firma propria di questo artifact e la registrerebbe. rimedio: esegui il pull per aggiornare il file)

e per un plugin per cui il record non contiene alcuna voce, dove un build lo rifiuta perché non registra alcuna firma — la seconda forma in modalità offline, dove la verifica non chiede ad alcun registry:

signing: a recorded signature is not the one a pull would record ("<plugin>", <record-path> records no entry for it and a signature is required for it, a pull would record <signature>). remediation: run aggrega pull --release <release> to bring <record-path> up to date (signing: una firma registrata non è quella che registrerebbe un pull: il record non contiene alcuna voce per il plugin e per esso è richiesta una firma, un pull registrerebbe una firma. rimedio: esegui il pull per aggiornare il record)

signing: a recorded signature is not the one a pull would record ("<plugin>", <record-path> records no entry for it and a signature is required for it, a pull would ask its registry for the signature a requirement asks for and record it). remediation: run aggrega pull --release <release> to bring <record-path> up to date (signing: una firma registrata non è quella che registrerebbe un pull: il record non contiene alcuna voce per il plugin e per esso è richiesta una firma, un pull chiederebbe al suo registry la firma richiesta da un requisito e la registrerebbe. rimedio: esegui il pull per aggiornare il record)

<signature> indica una firma tramite la sua modalità, il suo firmatario e il digest del suo bundle — a keyed signature by keyed:sha256:<fingerprint> with bundle digest sha256:<digest>, con issued by <issuer> dopo il firmatario per una firma senza chiave — oppure è no signature. <file> è il lockfile della Release, <lockfile-path>, oppure plugins-trust.yaml nella directory della Release, <record-path>.

Come risolvere: esegui il pull indicato dal messaggio. Scrive nel file indicato la firma che il messaggio dice che scriverebbe, e ne mette in cache il bundle, così la verifica successiva va a buon fine. Dove il messaggio dice che un pull chiederebbe al registry, il pull registra ciò che il registry verifica — e invece si arresta, nominando l’artifact, dove il registry associa una firma che la configurazione di fiducia non accetta, o nessuna dove ne è richiesta una, il che è una questione per chi lo pubblica. In modalità offline quel pull si arresta: su una voce del lockfile con il rifiuto offline, perché deve chiedere al registry, e su un plugin associato in un ruolo di verdetto prima ancora, nominando il .wasm del plugin come uno che non ha potuto risolvere, perché un pull risolve quel .wasm dal registry del plugin. Consentire la rete per quella singola esecuzione aggiorna il file. Dove il messaggio dice che un pull non registrerebbe alcuna firma, il registry non ne associa più una e nulla la richiede: il pull cancella la firma della voce, che un build ammette con le stesse impostazioni — se non ti aspettavi che il registry smettesse di firmare l’artifact, anche questa è una questione per il suo editore.

A plugin’s .wasm is not on this machine (Il file Wasm di un plugin non è su questa macchina)

Il .wasm di un plugin viene letto da uno di quattro luoghi, in quest’ordine: i plugin integrati nel binario del compilatore, un file accanto all’entità Plugin del plugin in una directory di catalogo, un percorso esplicito del filesystem indicato dal riferimento e la cache dei contenuti del workspace che aggrega pull riempie. La risoluzione di un plugin legge solo ciò che è già sulla macchina e non scarica nulla, quindi questa condizione segnala che nessuno dei quattro contiene i byte — non che un download non è riuscito. Un plugin fa eccezione: un importatore core di cui un’importazione ha bisogno. Il suo modulo viene letto solo dal binario o dalla cache dei contenuti, mai da accanto a un’entità di catalogo, e dove nessuno dei due lo contiene l’importazione lo scarica una volta dal registry predefinito del workspace; la condizione segnala allora anche che lo scaricamento non è stato possibile — il workspace è offline, il suo registry non è raggiungibile o non contiene il modulo, oppure il workspace non indica alcun registry predefinito. Un modulo che è stato scaricato e non supera la verifica viene invece rifiutato con la propria condizione, una mancata corrispondenza del digest o un rifiuto della firma, e non viene conservato nulla.

Il file accanto all’entità prende il nome dal tipo di plugin e dal nome dell’entità, e il rifiuto del pull riportato sotto indica il nome: per pipeline-step/patch è pipeline-step--patch.wasm, nella directory in cui si trova il documento dell’entità.

Un’entità Plugin scritta in una delle tue directory di catalogo viene rifiutata quando il pull la risolve. Un pull non scarica mai il .wasm di un’entità di questo tipo: cerca nei quattro luoghi indicati sopra, esattamente dove cerca un build. Uno step di pipeline, un provider o un plugin associato a un ruolo di verdetto non è fissato affatto, e un build legge la sua entità dalla directory di catalogo ogni volta. Un plugin associato a un ruolo di trasformazione è fissato, perché i suoi byte determinano l’output renderizzato: il pull registra la sua entità e il digest del contenuto del .wasm che vi ha trovato, e un build rifiuta un .wasm che non corrisponde più. Così un pull che non trova l’artifact in nessuno dei quattro luoghi si arresta lì, prima di scrivere il lockfile o qualsiasi entity.lock, invece di lasciare che un build fallisca più tardi, nello step che carica il plugin. Un .wasm che il binario contiene, o uno già presente nella cache dei contenuti, soddisfa il pull esattamente come soddisfa il build, quindi un’entità per un plugin distribuito all’interno del compilatore non ha bisogno di alcun file accanto.

Messaggi emessi. Il rifiuto del pull, che indica la directory in cui si aspettava il file, con sotto la risoluzione su cui ha interrogato:

plugin artifact not found on this machine (Plugin entity "<reference>" is authored in a catalog directory, expected <file> in <directory>). Place the built .wasm beside the entity under that name, or publish the plugin and reference the published Plugin entity instead of the one in the catalog directory (artifact del plugin non trovato su questa macchina: l’entità Plugin è scritta in una directory di catalogo e il file indicato era atteso nella directory indicata. Colloca il .wasm compilato accanto all’entità con quel nome, oppure pubblica il plugin e fai riferimento all’entità Plugin pubblicata invece che a quella nella directory di catalogo)

un plugin che un build o un’importazione carica senza che alcuna fonte ne contenga i byte — e un plugin associato a un ruolo di verdetto che aggrega pull --verify in modalità offline legge dalla cache dei contenuti come fa un build. Dove l’entità Plugin del plugin si trova in una cartella di catalogo, indicando la versione in cui si trova e dove va il suo modulo:

plugin "<reference>" at version <version> is not on this machine; place its module, named <file>, beside its Plugin entity in <directory>: plugin artifact not found on this machine (il plugin, alla versione indicata, non è su questa macchina; colloca il suo modulo, con il nome indicato, accanto alla sua entità Plugin nella directory indicata: artifact del plugin non trovato su questa macchina)

e altrimenti, indicando ogni luogo in cui il modulo è stato cercato:

plugin "<reference>" is not on this machine: the binary does not carry its module, no catalog folder holds its Plugin entity and the content cache a pull fetches into does not hold it: plugin artifact not found on this machine (il plugin non è su questa macchina: il binario non contiene il suo modulo, nessuna cartella di catalogo contiene la sua entità Plugin e la cache dei contenuti in cui un pull scarica non lo contiene: artifact del plugin non trovato su questa macchina)

Un lint, che cerca solo nel binario, indica soltanto il primo di quei luoghi.

e lo stesso per un riferimento scritto come posizione in un registry:

plugin "<reference>" not resolvable: an OCI plugin URI requires a prior aggrega pull --release <release> (so its bytes are cached) or an explicit local path; plugin resolution does not fetch from a registry: plugin artifact not found on this machine (plugin non risolvibile: un URI di plugin OCI richiede un pull precedente, così che i suoi byte siano in cache, o un percorso locale esplicito; la risoluzione dei plugin non scarica da un registry: artifact del plugin non trovato su questa macchina)

un importatore core che un’importazione non ha potuto né leggere né scaricare, indicando l’importatore, la sua versione e il motivo — qui il workspace offline — e poi ciò che mette il suo modulo sulla macchina:

core importer "<importer>" at version <version> is not on this machine, and the workspace is offline, so its registry <host> is not asked for it; run the import once with the network available, which fetches it from the workspace’s default registry, verifies it and keeps it in the content cache for every later import, or place its module, named <file>, beside a Plugin entity of <importer> at <version> in a catalog folder: plugin artifact not found on this machine (l’importatore core, alla versione indicata, non è su questa macchina e il workspace è offline, quindi il suo registry non viene interpellato; esegui l’importazione una volta con la rete disponibile, il che lo scarica dal registry predefinito del workspace, lo verifica e lo conserva nella cache dei contenuti per ogni importazione successiva, oppure colloca il suo modulo, con il nome indicato, accanto a un’entità Plugin di quell’importatore a quella versione in una cartella di catalogo: artifact del plugin non trovato su questa macchina)

Gli altri motivi si leggono its registry <host> could not be reached (<cause>), its registry <host> holds no <location>:<version> e the workspace names no default registry to fetch it from; gli ultimi due indicano solo il secondo rimedio, perché un’esecuzione con la rete disponibile non li cambierebbe.

Come risolvere: dove l’entità è una che scrivi tu, compila il plugin e colloca il suo .wasm accanto all’entità con il nome che il messaggio indica — oppure pubblica il plugin con aggrega push e fai riferimento all’entità pubblicata al posto della copia nel catalogo, poiché né un pull né un build scarica il .wasm di un’entità nel tuo catalogo. Dove il plugin è uno che consumi da un registry, esegui aggrega pull per la Release, che lo mette in cache. Dove ti aspettavi che il compilatore contenesse il plugin stesso, verifica che il binario che esegui lo contenga: aggrega plugin list elenca i plugin integrati. Dove si tratta di un importatore core, esegui l’importazione una volta dove il workspace può raggiungere il suo registry predefinito — quell’esecuzione lo scarica, lo verifica e lo mette in cache, e ogni importazione successiva è offline — oppure, dove quel registry non lo contiene, colloca il suo modulo accanto a un’entità Plugin di quell’importatore a quella versione in una cartella di catalogo, con il nome che il messaggio indica; quell’entità viene allora eseguita al posto dell’importatore core.

A plugin recorded as a trusted gate is no longer attached (Un plugin registrato come controllo attendibile non è più associato)

Un plugin che restituisce un verdetto di accettazione o rifiuto su un build viene registrato una volta risolto, così che il workspace conservi un record dei controlli che sono stati esaminati. Questa condizione è ciò che segnala un controllo registrato che nulla associa più. Il motivo per cui arresta il build invece di lasciarlo passare in silenzio è che altrimenti il suo output sarebbe indistinguibile da un output approvato dal controllo: un build con il controllo silenziosamente assente e un build che il controllo ha lasciato passare producono gli stessi file, e nessuno che esamini il risultato potrebbe dire quale dei due ha in mano.

È una questione diversa da quella di un plugin i cui byte sono cambiati. Quella rifiuta di eseguire un plugin che non è quello esaminato — una questione di identità. Questa rifiuta di eseguire il build con un controllo esaminato del tutto mancante — una questione di presenza. I rimedi differiscono di conseguenza: ripristinare l’artifact, contro ripristinare l’associazione.

Che cosa stabilisce e che cosa no. Mantenere la configurazione allineata al record stabilisce che ogni controllo registrato è ancora associato e che l’artifact di ciascuno è quello registrato. Non stabilisce nulla sul fatto che un controllo associato restituisca effettivamente un verdetto: un’associazione la cui funzione di ingresso indica un export dichiarato che non restituisce alcun verdetto viene eseguita, non segnala nulla e lascia passare il build, e nessun confronto con il record se ne accorge — il plugin eseguito è esattamente quello registrato e semplicemente non ha eseguito nulla. Due casi vicini arrestano invece il build, e sono indicati perché questo limite non venga letto come più ampio di quanto sia: una funzione di ingresso che indica un export che il plugin non dichiara viene rifiutata quando il plugin viene caricato, e un output che contiene una chiave che la struttura del verdetto non dichiara viene rifiutato invece di essere letto come un elenco vuoto di verdetti.

Messaggio emesso, che indica il record, i controlli rimossi ed entrambi i rimedi:

a plugin recorded as trusted for an accept-or-reject verdict is no longer attached at any verdict role: <record-path> records <plugin> as trusted, but no verdict attachment in the workspace configuration names it; a gate that was reviewed and is now absent leaves output indistinguishable from output that gate approved. Attach the plugin again under plugins.governance at an ir-verdict or render-verdict role, or under plugins.linter; or, if it was meant to go, run aggrega pull --upgrade --release <release> <plugin> to drop it from the record — an ordinary aggrega pull leaves the record as it is, so only an explicit upgrade removes an entry (un plugin registrato come attendibile per un verdetto di accettazione o rifiuto non è più associato ad alcun ruolo di verdetto: il record registra il plugin come attendibile, ma nessuna associazione di verdetto nella configurazione del workspace lo indica; un controllo che è stato esaminato e ora è assente lascia un output indistinguibile da un output approvato da quel controllo. Associa di nuovo il plugin nella sezione governance dei plugin a un ruolo di verdetto IR o di verdetto di rendering, oppure nella sezione linter; oppure, se doveva essere rimosso, esegui l’aggiornamento mirato per toglierlo dal record — un pull ordinario lascia il record com’è, quindi solo un aggiornamento esplicito rimuove una voce)

Dove è stato rimosso più di un controllo, vengono indicati insieme in un unico comando di aggiornamento invece che con un comando ciascuno: un aggiornamento mirato accetta più destinazioni e lascia intatto ogni pin che non ha indicato, quindi indicarli insieme è sia più breve sia più ristretto dell’aggiornamento completo che l’alternativa richiederebbe.

Come risolvere: il messaggio offre due rimedi perché solo tu sai quale si applica. Se il controllo è stato rimosso per errore, associa di nuovo il plugin sotto plugins.governance a un ruolo di verdetto, oppure sotto plugins.linter. Se doveva essere rimosso, dillo esplicitamente con l’aggiornamento mirato che il messaggio riporta, che è ciò che rimuove la sua voce. Non modificare né eliminare il record per far sparire questa condizione — è un record sottoposto a commit di ciò che è stato esaminato, e un pull ordinario lo lascia deliberatamente com’è, perché adottare una rimozione in silenzio è esattamente ciò che questo rifiuto esiste per impedire.

A gate recorded as trusted resolves to a different identity (Un controllo registrato come attendibile si risolve in un’identità diversa)

Un plugin che restituisce un verdetto di accettazione o rifiuto su un build viene registrato una volta risolto, insieme alla versione e al digest dell’artifact in cui si è risolto. Questa condizione è ciò che segnala una risoluzione successiva quando raggiunge una versione diversa o byte diversi per un controllo che il record contiene già, e l’esecuzione non ha mai chiesto di adottare quell’identità.

Un’unica condizione copre sia una versione spostata sia byte spostati, perché il record è indirizzato dall’identità del plugin e contiene la versione e il digest come campi di un’unica voce: confrontare una risoluzione con esso è un unico confronto con un unico esito. Una ripubblicazione che non ha cambiato alcun byte e un nuovo push alla stessa versione sono lo stesso evento per chi esamina — l’identità non è più quella che è stata esaminata.

È una questione diversa da quella di un controllo registrato che nulla associa più, che è una questione di presenza anziché di identità. È diversa anche da quella di un plugin i cui byte in cache non concordano con il digest registrato: quella rifiuta di eseguire un plugin che non è quello esaminato, e il suo rimedio è ripristinare o registrare di nuovo l’artifact, mentre questa rifiuta di adottare una nuova identità senza che sia stato chiesto, e il suo rimedio è indicare il plugin in un aggiornamento. Due rimedi, due condizioni.

Chiedere la nuova identità è ciò che un pull offre già, e ci sono due modi per chiederla. Un aggiornamento completo risolve di nuovo tutto, e un aggiornamento mirato risolve di nuovo i plugin che indica; entrambi vengono letti come richiesta della nuova identità, e il record viene aggiornato. Qualsiasi altro pull mantiene l’identità registrata e si arresta, che è lo scopo di registrarla — un record che adottasse qualunque cosa si risolva dopo seguirebbe la risoluzione invece di governarla. Una prima comparsa non è un disaccordo: un’identità che il record non contiene ancora viene semplicemente compilata.

Il confronto viene eseguito anche su un pull che si limita a verificare, che non scrive né il record né il lockfile. Una verifica che saltasse il record mentre controlla il lockfile accanto a esso segnalerebbe una concordanza che non ha mai cercato.

Messaggio emesso, che indica il plugin, entrambe le identità ed entrambi i rimedi:

plugin "<plugin-identity>": <record-path> records version <recorded-version> with digest <recorded-digest> as trusted for it, but this resolution reports version <resolved-version> with digest <resolved-digest>; review what changed and adopt it with aggrega pull --upgrade --release <release> <plugin>, or restore the recorded identity: the plugin identity recorded as trusted no longer matches what this resolution reports (plugin: il record registra per esso come attendibili una versione e un digest, ma questa risoluzione riporta un’altra versione e un altro digest; esamina ciò che è cambiato e adottalo con l’aggiornamento mirato, oppure ripristina l’identità registrata: l’identità del plugin registrata come attendibile non corrisponde più a ciò che questa risoluzione riporta)

Come risolvere: decidi quale delle due identità è quella che intendi, perché solo tu puoi farlo. Se lo spostamento è uno che intendi — il controllo è stato ripubblicato e hai esaminato ciò che è cambiato — adottalo con l’aggiornamento mirato che il messaggio riporta, che risolve di nuovo quel plugin e riscrive la sua voce. Se non te lo aspettavi, l’identità registrata è quella che è stata esaminata: ripristina la versione o l’artifact che il record indica, e indaga sul perché il riferimento ora si risolve altrove. Non modificare il record per far sparire questa condizione — è una dichiarazione sottoposta a commit di ciò che è stato esaminato, e un pull ordinario lo lascia deliberatamente com’è, perché adottare in silenzio un controllo cambiato è esattamente ciò che questo rifiuto esiste per impedire.

A Plugin entity’s claims disagree with the plugin’s own self-report (Le affermazioni di un’entità Plugin non concordano con l’autodescrizione del plugin stesso)

Un’entità Plugin indica ciò che offre il plugin a cui punta: quali export ha, su cosa opera ciascuno di essi e con quale ambito e — per un plugin che serve un provider — come si comporta durante il rendering. Il plugin riporta le stesse cose su sé stesso quando viene caricato. Questa condizione è ciò che segnala un disaccordo tra le due.

Il confronto avviene per export, indicizzato per nome, e procede in una sola direzione: tutto ciò che l’entità afferma deve corrispondere, e il plugin può offrire di più. Un’entità che descrive parte della superficie del plugin non è tenuta a elencare il resto, quindi un export che il plugin dichiara e che l’entità omette non è un disaccordo. Un disaccordo è invece un export affermato che il plugin non dichiara, oppure un export affermato il cui operates o scope differisce da ciò che il plugin riporta. Il selettore in forma libera non viene confrontato.

Quando l’entità definisce anche un blocco di comportamento di rendering, i suoi campi vengono confrontati uno per uno — i tipi di input, la modalità di assemblaggio, la coppia di delimitatori dei template degli artifact, l’annotazione del nome di assemblaggio, l’affermazione di istanza riutilizzabile, l’affermazione di collegamento tra confini, l’affermazione sulle voci omesse e la directory di annidamento — e viene indicato il primo in disaccordo. Un’entità che non definisce un blocco del genere salta del tutto quel confronto.

Lo stesso controllo viene eseguito alla pubblicazione, quindi una discrepanza di norma emerge prima che l’entità venga pubblicata, anziché quando un build la carica.

Messaggi emessi. Un export affermato che il plugin non ha:

entity "<entity>" claims export "<export>", which the plugin’s describe() does not declare: wasm: entity contract claim does not match plugin describe() (l’entità afferma un export che il describe() del plugin non dichiara: wasm: l’affermazione del contratto dell’entità non corrisponde al describe() del plugin)

un campo di un export affermato:

entity "<entity>" export "<export>" declares operates "<claimed>" but the plugin’s describe() reports "<reported>": wasm: entity contract claim does not match plugin describe() (l’export dell’entità dichiara un valore di operates, ma il describe() del plugin ne riporta un altro: wasm: l’affermazione del contratto dell’entità non corrisponde al describe() del plugin)

e un campo del comportamento di rendering, che viene segnalato con la stessa struttura nominando il campo in disaccordo:

entity "<entity>" declares boundary_assembly "<claimed>" but the plugin’s describe() reports "<reported>": wasm: entity contract claim does not match plugin describe() (l’entità dichiara un valore di boundary_assembly, ma il describe() del plugin ne riporta un altro: wasm: l’affermazione del contratto dell’entità non corrisponde al describe() del plugin)

Come risolvere: è l’affermazione dell’entità Plugin a dover essere corretta, non il tuo Aggregate o la tua Release. Allinea l’affermazione a ciò che riporta il plugin — il messaggio nomina entrambi i valori, quindi in quale direzione deve cambiare si vede nel messaggio stesso. Se l’entità è una che pubblichi tu, rigenerarla dal binario è il modo affidabile per far concordare le due; se consumi un’entità pubblicata, seleziona una versione la cui affermazione corrisponda al binario a cui punta e segnala il disaccordo a chi l’ha pubblicata.

A Plugin entity’s recorded command set does not match the plugin (L’insieme di comandi registrato di un’entità Plugin non corrisponde al plugin)

Un plugin che fornisce comandi da terminale ha quei comandi registrati nella sua entità Plugin. Quel record è scritto automaticamente anziché redatto da un autore: viene letto dal plugin e trascritto, quindi rispecchia esattamente il binario. Questa condizione è ciò che segnala un record che ha smesso di rispecchiarlo — una differenza nel nome di un comando, nel suo breve testo di aiuto o nell’ordine in cui i comandi sono dichiarati.

Il confronto è di uguaglianza completa, ed è voluto. Le affermazioni sulle capacità e sugli export presenti altrove nell’entità sono curate: un autore può legittimamente descrivere parte della superficie e tralasciare il resto, quindi vengono verificate come sottoinsieme. Il record dei comandi non è curato, quindi qualsiasi cosa che non sia un accordo esatto significa che il record si è discostato da ciò che il plugin offre davvero, e un elenco di comandi vicino ma non corretto è ciò che instraderebbe male un’invocazione.

Un plugin caricato senza un’entità non viene verificato qui. Il record risiede nell’entità, quindi i byte caricati direttamente non ne portano alcuno e il confronto non ha nulla con cui essere eseguito.

Messaggio emesso, che nomina entrambi gli insiemi e come registrarli di nuovo:

wasm: plugin "<plugin>": recorded command mirror <recorded set> does not match the plugin describe() commands <reported set>; re-run aggrega plugin sync and commit the result: wasm: recorded command mirror does not match plugin describe() (wasm: per il plugin indicato, il mirror dei comandi registrato non corrisponde ai comandi del describe() del plugin; esegui di nuovo la sincronizzazione dei plugin e fai il commit del risultato: wasm: il mirror dei comandi registrato non corrisponde al describe() del plugin)

Lo stesso confronto alla pubblicazione segnala gli insiemi senza l’istruzione per registrarli di nuovo:

plugin "<plugin>": recorded command mirror <recorded set> does not match the plugin describe() commands <reported set>: wasm: recorded command mirror does not match plugin describe() (per il plugin indicato, il mirror dei comandi registrato non corrisponde ai comandi del describe() del plugin: wasm: il mirror dei comandi registrato non corrisponde al describe() del plugin)

Come risolvere: registra di nuovo l’insieme dal binario e fai il commit del risultato — il messaggio nomina il comando che lo fa. Non modificare a mano il record per farlo corrispondere: è gestito automaticamente, e una modifica a mano che oggi concorda viene ricavata di nuovo e sovrascritta la volta successiva in cui viene registrato. Se consumi un’entità pubblicata anziché pubblicarla, l’entità è stata pubblicata con un record che il suo stesso binario non supporta, e questa è una questione per chi l’ha pubblicata.

A Plugin entity’s recorded version does not match the plugin (La versione registrata di un’entità Plugin non corrisponde al plugin)

Un plugin riporta la versione che il suo build vi ha registrato, e anche la sua entità Plugin registra una versione; le due devono essere la stessa stringa. Le ricette di build con cui vengono costruiti i plugin di Aggrega prendono quella versione dal tag che rilascia il plugin — il tag del compilatore stesso per un plugin distribuito con il compilatore, un tag proprio del plugin per uno distribuito al di fuori di esso — quindi un build del commit indicato dal tag riporta la versione di rilascio, e un build di qualsiasi altro commit riporta una versione di sviluppo come 1.0.0-3-g1a2b3c4. Questa condizione è ciò che segnala una coppia che si è separata, e viene verificata prima che venga pubblicato qualsiasi byte, così che una coppia divergente non raggiunga un catalogo.

Il confronto è una corrispondenza esatta di stringhe. Un plugin costruito senza una versione di build registrata ne riporta una vuota, e quel valore vuoto è allora ciò a cui deve essere uguale la versione dell’entità — il controllo non tratta «nessuna versione riportata» come «qualsiasi versione accettata», perché il suo scopo è che la versione di un’entità pubblicata dica sempre ciò che il suo binario riporta davvero.

Messaggio emesso:

plugin "<plugin>": recorded metadata.version "<recorded>" does not match the plugin describe() version "<reported>": wasm: entity metadata.version does not match plugin describe() (per il plugin indicato, il metadata.version registrato non corrisponde alla versione del describe() del plugin: wasm: il metadata.version dell’entità non corrisponde al describe() del plugin)

Alla pubblicazione il rifiuto nomina anche il file dell’entità, il .wasm e la correzione:

Plugin <plugin>: metadata.version in <entity-path> does not match the .wasm describe() version at <path> — set metadata.version to the release you are publishing and build the plugin from a clean checkout of the commit that release’s tag names, so it reports that version itself; for a new release, commit the entity with the source it releases and tag that commit first: plugin "<plugin>": recorded metadata.version "<recorded>" does not match the plugin describe() version "<reported>": wasm: entity metadata.version does not match plugin describe() (per il Plugin indicato, il metadata.version nel file dell’entità non corrisponde alla versione del describe() del .wasm nel percorso indicato — imposta metadata.version sul rilascio che stai pubblicando e costruisci il plugin da un checkout pulito del commit indicato dal tag di quel rilascio, così che riporti da sé quella versione; per un nuovo rilascio, fai il commit dell’entità con il sorgente che rilascia e applica prima il tag a quel commit: per il plugin indicato, il metadata.version registrato non corrisponde alla versione del describe() del plugin: wasm: il metadata.version dell’entità non corrisponde al describe() del plugin)

Come risolvere: imposta il metadata.version dell’entità sul rilascio che stai pubblicando e costruisci il plugin da un checkout pulito del commit indicato dal tag di quel rilascio, così che riporti da sé quella versione. Per un nuovo rilascio, fai il commit dell’entità con il sorgente che rilascia e applica prima il tag a quel commit — il tag deve indicare un commit che contiene già l’entità. Non copiare nell’entità la versione che il plugin riporta: un build di qualsiasi altro commit riporta una versione di sviluppo, e copiarla pubblicherebbe quel build con una versione che nessun tag di rilascio indica. Se il plugin non riporta alcuna versione, è stato costruito senza la sua versione registrata; costruiscilo con la sua versione registrata.

A plugin was built from a working tree with uncommitted changes (Un plugin è stato costruito da un albero di lavoro con modifiche non sottoposte a commit)

Il build di un plugin registra la sua versione dal commit da cui è stato costruito, e un build fatto da un albero di lavoro con modifiche non sottoposte a commit porta il marcatore -dirty alla fine di quella versione — 1.0.0-dirty su un tag, 1.0.0-3-g1a2b3c4-dirty oltre un tag. Una versione del genere è una versione semantica valida, ma indica un commit che non contiene i byte costruiti, quindi nessuno può ricostruire ciò che verrebbe pubblicato a partire dalla versione con cui verrebbe pubblicato. La pubblicazione di un Plugin rifiuta un plugin la cui versione porta il marcatore, prima che venga pubblicato qualsiasi byte e prima di contattare il registry; anche un’esecuzione di prova lo rifiuta.

Viene rifiutato solo il marcatore. Una versione di sviluppo costruita da un commit, come 1.0.0-3-g1a2b3c4, indica un commit che contiene davvero ciò che è stato costruito, e viene pubblicata; lo stesso vale per una versione preliminare come 1.0.0-rc.1. La convalida di un plugin rispetto alla sua entità al di fuori di una pubblicazione non solleva questa condizione, poiché un build in fase di sviluppo viene abitualmente fatto da un albero modificato.

Il controllo legge la versione che il plugin riporta sul proprio build, e viene eseguito prima del confronto con il metadata.version dell’entità — quindi un plugin costruito con modifiche non sottoposte a commit sotto un’entità che registra la versione pulita viene segnalato qui, anziché come una versione registrata che non corrisponde al plugin.

Messaggio emesso, che nomina il plugin, la versione che riporta e il rimedio:

Plugin <plugin>: the .wasm at <path> was built from a working tree with uncommitted changes — set metadata.version in <entity-path> to the release you are publishing and build the plugin from a clean checkout of the commit that release’s tag names, so it reports that version itself; for a new release, commit the entity with the source it releases and tag that commit first: plugin was built from a working tree with uncommitted changes, so no commit reproduces the version it reports (plugin "<plugin>", describe() version "<version>", which ends with "-dirty") (per il Plugin indicato, il .wasm nel percorso indicato è stato costruito da un albero di lavoro con modifiche non sottoposte a commit — imposta metadata.version nel file dell’entità sul rilascio che stai pubblicando e costruisci il plugin da un checkout pulito del commit indicato dal tag di quel rilascio, così che riporti da sé quella versione; per un nuovo rilascio, fai il commit dell’entità con il sorgente che rilascia e applica prima il tag a quel commit: il plugin è stato costruito da un albero di lavoro con modifiche non sottoposte a commit, quindi nessun commit riproduce la versione che riporta (con il plugin e la sua versione del describe(), che termina con il marcatore dirty))

Come risolvere: costruisci il plugin da un checkout pulito del commit indicato dal tag del rilascio, così che riporti la versione di rilascio registrata dall’entità. Per rilasciare la modifica stessa, imposta il metadata.version dell’entità sul nuovo rilascio, fai il commit dell’entità insieme alla modifica, applica il tag a quel commit e costruisci lì. Fare il commit della modifica e ricostruire non basta da solo ad aprire la strada a un rilascio: il plugin ricostruito riporta una versione di sviluppo, e copiarla nell’entità pubblicherebbe il build con una versione che nessun tag di rilascio indica.

A Plugin entity’s recorded host functions do not match the binary (Le funzioni host registrate di un’entità Plugin non corrispondono al binario)

Un plugin dichiara quali chiamate proprie dell’host utilizza, e quell’insieme viene registrato nella sua entità Plugin quando il plugin viene pubblicato — letto dal binario stesso anziché redatto da un autore. Quando il plugin viene scaricato, l’insieme viene ricavato di nuovo dai byte il cui contenuto è appena stato verificato, e confrontato con il record. Una differenza in una qualsiasi delle due direzioni arresta lo scaricamento.

Questo si aggiunge al pin del contenuto anziché ripeterlo, e intercetta due cose che il pin da solo non intercetta: un binario pubblicato da qualcosa di diverso dal normale percorso di pubblicazione, che non porta alcun record o ne porta uno che non descrive i propri byte; e un errore nello step di registrazione stesso. Il pin stabilisce che i byte sono quelli fissati; questo stabilisce che ciò che è stato scritto su di essi è vero per essi.

Un’entità che non porta alcun record viene confrontata con un insieme vuoto, che corrisponde a un plugin che non usa nessuna delle chiamate dell’host — lo stesso accordo innocuo in entrambi i versi, quindi un’entità senza record non viene rifiutata per il fatto di esserne priva.

Messaggio emesso, che nomina il plugin, entrambi gli insiemi e l’artifact da cui provengono i byte:

plugin "<plugin>": stamped spec.runtime.hostFunctions <recorded set> does not match <derived set> derived from the verified .wasm <artifact>: wasm: stamped host-function record does not match .wasm imports (per il plugin indicato, lo spec.runtime.hostFunctions timbrato non corrisponde all’insieme ricavato dal .wasm verificato: wasm: il record timbrato delle funzioni host non corrisponde agli import del .wasm)

Lo stesso confronto eseguito durante la convalida di un plugin segnala i due insiemi senza l’artifact:

plugin "<plugin>": recorded host-function record <recorded set> does not match the .wasm imports <derived set>: wasm: stamped host-function record does not match .wasm imports (per il plugin indicato, il record delle funzioni host registrato non corrisponde agli import del .wasm: wasm: il record timbrato delle funzioni host non corrisponde agli import del .wasm)

Come risolvere: nulla nei tuoi file di entità causa questa condizione e nessuna modifica a ciò che scrivi la risolve. Ripubblica il plugin attraverso il normale percorso di pubblicazione, che ricava il record dal binario e scrive i due insieme. Se consumi un plugin pubblicato, l’entità e il binario a cui punta sono stati pubblicati non allineati, quindi segnala la discrepanza a chi lo pubblica, citando entrambi gli insiemi dal messaggio — e non modificare a mano il record per farlo concordare, poiché è ricavato anziché redatto e la derivazione successiva scarta la modifica.

The lockfile no longer matches what the release resolves to (Il lockfile non corrisponde più a ciò in cui si risolve la Release)

Il lockfile di una Release fissa ogni entità, libreria e plugin che la Release raggiunge, ciascuno con la versione selezionata e un digest, e registra i file di Release stessi — la Release e ogni Release che essa estende — tramite il digest del loro contenuto. Il digest di un’entità copre ciò che una sua pubblicazione trasporta: il suo documento e ogni file che essa nomina accanto a sé, ciascuno tramite il suo percorso e i suoi byte. Quello di una libreria e quello di un plugin coprono i loro byte. Risolvere di nuovo la Release produce lo stesso insieme, e i due vengono confrontati. Questa condizione è ciò che segnala un disaccordo.

Ogni disaccordo viene raccolto prima che uno qualsiasi di essi venga segnalato, su tutto ciò che il lockfile fissa, così che una sola esecuzione ti mostri il quadro completo anziché una voce alla volta.

Vengono segnalate queste strutture di disaccordo, ed è utile distinguerle perché i rimedi differiscono:

  • Un riferimento che il lockfile non fissa. La Release ora raggiunge qualcosa per cui il lockfile non ha alcuna voce — una dipendenza aggiunta dopo il pull che lo ha scritto. La voce indica dove la Release lo richiede, quindi una Recipe o FeatureRecipe che il Manifest lega viene segnalata con la voce di mapping che la lega, e una che il livello name lega indica l’istanza o l’associazione per cui è stata scelta.
  • Un riferimento fissato la cui coppia si è spostata. Il lockfile fissa una coppia di versione e digest e la risoluzione ne ha prodotta un’altra. Si tratta di contenuto vendorizzato i cui byte sono cambiati, oppure di qualcosa nel workspace che è cambiato: il documento di un’entità o di una libreria modificato, un file che un’entità nomina — un chart sotto la sua sorgente, un file che importa, l’entity.lock accanto a essa — modificato, aggiunto o rimosso, oppure il .wasm accanto all’entità di un plugin sostituito. La voce nomina l’entità anziché il file; un semplice aggrega pull --release <release> nomina un file che si è spostato sotto il lock di una Recipe o di una FeatureRecipe, come descrive 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 fissaggio). Un registry che serve altri byte sotto una versione fissata non viene segnalato qui: il pull che li scarica li rifiuta, come descrive Fetched or cached bytes do not match the digest committed for them (I byte scaricati o in cache non corrispondono al digest dichiarato per essi).
  • Un riferimento fissato che la Release non raggiunge più. Il lockfile fissa ancora qualcosa da cui niente nella Release dipende più.
  • Un file di Release modificato dopo il pull. La Release, o una Release che essa estende, non contiene più i byte che il lockfile ha registrato per essa. Tutto ciò che la Release richiede — quale versione della sorgente scaricare, quali componenti collocare dove — viene risolto da ciò che il file contiene, quindi i pin registrati potrebbero non descrivere più ciò che ora richiede. Viene segnalato qui, prima che qualsiasi cosa venga renderizzata, anziché come qualunque errore su cui il rendering sarebbe fallito: una versione della sorgente modificata emergerebbe altrimenti più tardi come uno scaricamento che non trova alcun pin. Un lockfile che non registra alcun file di Release segnala la Release come non registrata, e un file di Release che la Release non estende più viene segnalato come non più letto.
  • Un riferimento di sorgente che si è spostato nel suo remoto. Una sorgente scritta a un ref: git viene registrata al commit in cui il ref si è risolto. Ogni pull che non è un aggiornamento chiede al remoto dove punta ora il ref, e così fa aggrega pull --verify dove la rete è raggiungibile; un ref che si risolve in un commit diverso viene segnalato qui anziché adottato. Solo questi due lo segnalano: un build legge il commit registrato e non chiede.

Il confronto riguarda il contenuto, quindi un contenuto identico raggiunto per un’altra via non deriva: ciò che deve differire perché questa condizione scatti sono i byte. Per un file di Release questo include un commento o una modifica degli spazi, esattamente come avviene per l’Aggregate e il Manifest che la Release nomina. Per un’entità è il contenuto di ciò che trasporta, quindi la stessa entità letta da una directory di catalogo e scaricata da un registry non deriva, e nemmeno un checkout i cui file differiscono solo nei bit di permesso, compreso il bit di esecuzione, né una pubblicazione il cui archivio è stato compresso in modo diverso.

Messaggio emesso. Si apre con la frase propria della condizione, e seguono tutte le discrepanze raccolte, ciascuna con il proprio asse — e, per un’entità, il proprio tipo, perché un’entità è identificata dal tipo e dall’URI insieme, quindi una Release il cui Aggregate e il cui Manifest condividono un nome ha due voci, e la modifica di uno dei due viene segnalata su quello modificato:

lockfile: out of date; it no longer matches what its Release resolves to: entity "<uri>" (<kind>) not in lockfile (referenced from <site>) (lockfile: non aggiornato; non corrisponde più a ciò in cui si risolve la sua Release: entità, con il suo tipo, non presente nel lockfile, con il punto da cui è referenziata) <axis> "<uri>" changed: lockfile=(<version>,<digest>) current=(<version>,<digest>) (il riferimento indicato è cambiato sull’asse indicato: versione e digest nel lockfile differiscono da quelli attuali) entity "<uri>" (<kind>) changed: lockfile=(<version>,<digest>) current=(<version>,<digest>) (l’entità indicata, del tipo indicato, è cambiata: versione e digest nel lockfile differiscono da quelli attuali) <axis> "<uri>" no longer used by the release (il riferimento indicato sull’asse indicato non è più usato dalla Release) release document "<file>" was edited after the lockfile was written: its content no longer matches the recorded digest (lockfile=<digest> current=<digest>), so the pins may no longer describe what it asks for; re-resolving the Release records the files it reads as they now stand (il documento di Release indicato è stato modificato dopo la scrittura del lockfile: il suo contenuto non corrisponde più al digest registrato, quindi i pin potrebbero non descrivere più ciò che richiede; risolvere di nuovo la Release registra i file che legge così come sono ora)

<site> è il punto in cui la Release richiede il riferimento, scritto come il percorso della voce che lo nomina — manifest.spec.mappings.components.name.db-primary, per esempio — con al massimo tre di questi punti elencati in ordine e ... dopo di essi quando ce ne sono di più. Un riferimento la cui risoluzione non registra alcun punto di questo tipo viene segnalato senza la parentesi.

Un pull che segnala un riferimento di sorgente spostato nomina l’artifact come lo ha scritto il suo autore, con chart= e module_subdir= dove la sorgente li nomina:

source-artifact kind=<kind> url=<url>: reference "<ref>" moved — the lockfile pins <commit>, and it now resolves to <commit>; adopt where it now points with aggrega pull --upgrade --release <release> (source-artifact: il riferimento indicato si è spostato — il lockfile fissa un commit, e ora si risolve in un altro; adotta il punto a cui ora punta con un pull di aggiornamento)

Un build stampa il rimedio dopo le voci:

run aggrega pull --release <release> to re-resolve the Release and rewrite its lockfile (esegui il pull per risolvere di nuovo la Release e riscriverne il lockfile)

Quali comandi vincolano una release al suo lockfile. aggrega build confronta prima di renderizzare e si arresta. aggrega validate --release, e ogni selezione di aggrega inspect che risolve una release — la vista predefinita, --resolved, --ir-graph e --closure — eseguono lo stesso confronto non appena le dipendenze della release vengono risolte, e si arrestano con lo stesso messaggio e lo stesso rimedio, senza scrivere nulla sullo standard output; quindi nessuno dei due lascia passare un lockfile che una build rifiuta perché non più allineato. Gli strumenti dell’assistente build, validate con release e describe con release rifiutano alle stesse condizioni. aggrega pull lo esegue rispetto al lockfile che sta per scrivere, e aggrega pull --verify rispetto a quello su disco. Un comando che non risolve alcuna release — aggrega validate senza argomenti, che legge i pin del lockfile solo per trovare un genitore extends, o con il percorso di un’entità, e aggrega inspect --raw o --output yaml senza --ir-graph — non è vincolato a un lockfile, e non lo è nemmeno una release senza lockfile accanto. Il language server dell’editor arresta le sue build su di esso, e lo segnala su una richiesta di grafo come avviso sul lockfile, continuando comunque a disegnare il grafo.

Come risolvere: risolvi di nuovo la Release ed esegui il commit del lockfile riscritto. Per tutto ciò che un build segnala, un semplice aggrega pull --release <release> — il comando che il build stampa — è l’intera correzione: risolve la Release così com’è ora, riscrive i pin che si sono spostati e mantiene tutti gli altri, così che non si sposti nulla che tu non abbia toccato. Dove ciò che si è spostato è un file sotto la sorgente locale di una Recipe o di una FeatureRecipe, quel pull si arresta prima indicando aggrega pin per l’entità, perché registrare il nuovo pin accanto a essa è lo step dell’autore; eseguilo, oppure passa --pin-sources al pull, e il pull elimina la deriva. L’unica voce che un semplice pull non elimina è un riferimento di sorgente che si è spostato nel suo remoto, perché eliminarla significa adottare il commit che il riferimento nomina ora: aggrega pull --upgrade --release <release> fa questo, e la voce lo dice — dove l’entity.lock della Recipe registra quella sorgente, l’aggiornamento si arresta allo stesso modo finché il nuovo commit non viene fissato accanto a essa. Leggi le voci prima di farlo, perché la terza struttura è quella su cui vale la pena fermarsi: un riferimento che la Release non raggiunge più è di solito una dipendenza che hai rimosso di proposito, ma dove non l’hai rimossa tu, qualcos’altro è cambiato rendendola irraggiungibile. Una coppia che si è spostata su un riferimento che non hai toccato significa che il contenuto a quella versione non è il contenuto che è stato esaminato, il che è una questione per chi lo fornisce anziché qualcosa da adottare senza guardare.

Un pull esegue questo stesso confronto sul lockfile che sta per scrivere e non ne scrive uno che il confronto rifiuta, quindi un lockfile appena scritto da un pull lo supera per un build a cui vengono dati gli stessi input. Dove questa condizione ricompare subito dopo un pull completato, le due esecuzioni hanno ricevuto input diversi: una directory di catalogo passata a una e non all’altra, oppure una configurazione del workspace modificata tra le due. Esegui il pull e il build sugli stessi input.

An artifact is not at the source the build was told to find it (Un artifact non si trova nella sorgente in cui al build è stato detto di trovarlo)

Un riferimento di catalogo nomina un artifact e una versione. Questa condizione segnala che nulla risponde a quella coppia — né nel registry in cui il riferimento si risolve, né nella cache locale degli artifact da cui il build legge.

Un build legge la cache; non si collega all’esterno di propria iniziativa. L’acquisizione è uno step separato: il pull che risolve una Release scarica ciò di cui la Release ha bisogno e lo scrive nella cache, e il build poi legge ciò che vi si trova. Così questa condizione raggiunge un build come un mancato riscontro nella cache, e raggiunge un pull come un registry che non ha un tale artifact. Dove un build è configurato per riempire il proprio lockfile all’avvio, l’acquisizione che esegue è quello stesso pull.

Messaggi emessi. Un registry senza un tale tag, e uno scaricamento che ha risolto un manifesto il cui blob di contenuto è assente:

oci: "<reference>:<version>": oci: artifact not found at remote source (oci: per il riferimento e la versione indicati: oci: artifact non trovato nella sorgente remota)

oci: content for "<reference>:<version>": oci: artifact not found at remote source (oci: contenuto per il riferimento e la versione indicati: oci: artifact non trovato nella sorgente remota)

una lettura della cache che non ha trovato alcuna voce, che è la struttura che incontra un build:

oci: cache miss for <reference>@<version>: oci: artifact not found at remote source (oci: nessuna voce nella cache per il riferimento e la versione indicati: oci: artifact non trovato nella sorgente remota)

e lo stesso per un artifact in cache il cui manifesto manca accanto a esso:

oci: manifest cache miss for <reference>@<version>: oci: artifact not found at remote source (oci: manifesto assente nella cache per il riferimento e la versione indicati: oci: artifact non trovato nella sorgente remota)

Come risolvere: controlla prima il riferimento e la versione — una versione che non esiste più e un nome con un errore di battitura producono la stessa risposta, e il messaggio li riporta entrambi così che possano essere confrontati con il catalogo. Dove il riferimento è corretto, l’artifact non è stato acquisito: esegui il pull per la Release, che scarica ciò che la Release raggiunge e popola la cache. Dove il workspace è offline, quel pull deve essere eseguito da un luogo con accesso alla rete; un build offline legge solo ciò che è già in cache, e questo è ciò che dice quando la cache non lo contiene.

The registry will not serve an artifact without credentials it accepts (Il registry non fornisce un artifact senza credenziali che accetti)

Il registry ha risposto, e ha rifiutato: o non sono state presentate credenziali, oppure quelle presentate non sono state accettate. È distinto da un registry che non è stato affatto raggiungibile — qui la conversazione è avvenuta e la risposta è stata no.

Quattro momenti la segnalano, tutti mentre gli artifact vengono acquisiti o pubblicati: la risoluzione di un riferimento, il pull del suo contenuto, l’elenco delle versioni che un repository contiene, e la verifica di una credenziale nel momento in cui viene memorizzata.

Messaggi emessi, ciascuno con ciò che veniva richiesto e con la risposta del registry:

oci: resolve "<reference>:<version>": <what the registry replied>: oci: authentication required or failed (oci: risoluzione del riferimento indicato, con la risposta del registry: oci: autenticazione richiesta o non riuscita)

l’elenco delle versioni di un repository, che indica invece lo stato:

oci: tags/list "<repository>": status <code>: oci: authentication required or failed (oci: tags/list del repository indicato, con il codice di stato: oci: autenticazione richiesta o non riuscita)

e la verifica di una credenziale mentre viene memorizzata:

oci: verify credential for "<host>": <what the registry replied>: oci: authentication required or failed (oci: verifica della credenziale per l’host indicato, con la risposta del registry: oci: autenticazione richiesta o non riuscita)

Dove l’errore emerge da uno step che fornisce un rimedio, la riga termina con il login da eseguire sull’host che ha ricavato:

remediation: aggrega login <host> (or docker login <host>) before re-running aggrega pull —release <release> (rimedio: esegui aggrega login, o docker login, sull’host indicato prima di rieseguire aggrega pull —release per la Release indicata)

e, dove un’importazione stava recuperando uno degli importer core del compilatore, lo stesso login prima di eseguire di nuovo l’importazione:

remediation: aggrega login <host> (or docker login <host>) before re-running the import (rimedio: aggrega login (o docker login) prima di eseguire di nuovo l’importazione)

Anche un repository classico di chart Helm o un archivio di chart, un frammento compose e un repository Git scaricati tramite http o https segnalano questa condizione quando il server rifiuta la richiesta come non autorizzata, e il loro rimedio nomina la voce netrc da aggiungere anziché un login, poiché è da quel file che questi download leggono la loro credenziale:

remediation: add an entry for <host> (machine <host> login <user> password <secret>) to the netrc file <path>, then run the command again (rimedio: aggiungi al file netrc una voce per l’host (con machine, login e password), poi esegui di nuovo il comando)

Come risolvere: questo spetta all’operatore anziché all’autore dell’entità — nulla in un Aggregate, Component o Recipe lo causa. L’hub ufficiale, hub.aggrega.ai, serve a chiunque ciò che pubblica, quindi leggere da esso non richiede alcuna credenziale, mentre pubblicarvi sì; un altro registry può richiedere una credenziale anche per la lettura. Accedi all’host che il messaggio nomina — oppure, per una sorgente scaricata tramite http o https, aggiungi la voce netrc che il rimedio nomina — ed esegui di nuovo l’acquisizione. Dove hai già effettuato l’accesso, la credenziale nell’archivio non è una che quell’host accetta per quel repository: accedi di nuovo per aggiornarla, e verifica che l’account abbia accesso in lettura al repository in cui il riferimento si risolve, poiché un repository privato risponde esattamente così a un account che non può vederlo. Dove il riferimento si risolve in un host che non ti aspettavi, l’alias del registry o il registry predefinito in .aggrega-config.yaml punta altrove.

The netrc file cannot be read (Il file netrc non può essere letto)

Un repository di chart Helm classico o un archivio di chart, un frammento compose e un repository Git scaricato tramite http o https prendono la propria credenziale dal file netrc, che viene letto quando una tale sorgente viene scaricata — da un pull, da un pin o da un build che riempie il proprio lockfile. Quale file viene letto, e quale voce risponde a una richiesta, è spiegato in Autenticazione. Questa condizione segnala un file netrc che esiste e che non è stato possibile usare: non è stato possibile leggerlo — è una directory, per esempio, oppure non hai il permesso di leggerlo — oppure non segue il formato netrc. Il formato viene letto in modo rigoroso, perché una parola letta nel posto sbagliato sposta ogni parola successiva: una parola chiave scritta in modo errato trasformerebbe altrimenti la password successiva nella parola chiave seguente, e la richiesta partirebbe senza credenziale, o con quella sbagliata, mentre il file sembrava corretto.

Un file che non esiste non è questa condizione: non contiene credenziali, e a una richiesta che ne ha bisogno risponde il rifiuto del server. Nemmeno un file che altri utenti della macchina possono leggere è questa condizione: su Linux e macOS produce un avviso che nomina il file, e viene comunque letto.

Il messaggio nomina il file e, per un errore di formato, la riga, e dice cosa non va solo in termini di formato — mai una parola che il file contiene, poiché una parola fuori posto può essere una password. La diagnostica non ha alcuna categoria: il file netrc è il tuo file di credenziali anziché un documento che il build legge.

Messaggio emesso per un errore di formato, che è uno tra: una parola che si trova dove è attesa una parola chiave, una parola chiave non seguita dal suo valore, un login, password o account che si trova prima di qualsiasi voce machine o default, e una parola tra virgolette non chiusa sulla riga in cui si apre:

the netrc file could not be read (file <path>, line <line>, a word stands where a keyword is expected (machine, default, login, password, account or macdef)). Correct the file, or set NETRC to the path of another netrc file to read instead (impossibile leggere il file netrc: nel file e nella riga indicati una parola si trova dove è attesa una parola chiave (machine, default, login, password, account o macdef). Correggi il file, oppure imposta NETRC sul percorso di un altro file netrc da leggere al suo posto)

e per un file che non è stato possibile leggere, riportando il motivo:

the netrc file could not be read (file <path>, <why it could not be read>). Correct the file, or set NETRC to the path of another netrc file to read instead (impossibile leggere il file netrc: il file indicato, con il motivo per cui non è stato possibile leggerlo. Correggi il file, oppure imposta NETRC sul percorso di un altro file netrc da leggere al suo posto)

Come risolvere: apri il file che il messaggio nomina. Per un errore di formato, vai alla riga che nomina: ogni voce è machine <host> — o default — seguita da login <user> e password <secret>, e una parola chiave scritta in modo errato o lasciata senza il suo valore è la causa abituale. Per un file che non è stato possibile leggere, rendilo un file che puoi leggere, leggibile solo da te (chmod 600). Dove il file non è quello che intendevi far leggere, imposta NETRC sul percorso di quello che intendevi.

The registry could not be reached (Il registry non è raggiungibile)

La conversazione con il registry non è mai avvenuta: la risoluzione dei nomi, la connessione o l’handshake sicuro non sono riusciti. È il corrispettivo di un registry che ha risposto e ha rifiutato — qui non è stato accertato nulla, in un senso o nell’altro, quindi lo stato dell’artifact all’altra estremità è sconosciuto anziché noto come mancante.

È anche ciò che segnala un errore di trasporto senza una causa più specifica mentre si acquisisce la sorgente di una Recipe, quindi su quel percorso è la risposta generica «l’altra estremità non è raggiungibile» anziché un’affermazione su quale livello abbia fallito.

Messaggio emesso, che nomina la sorgente in acquisizione e riporta l’errore di trasporto sottostante, con il rimedio che la condizione porta con sé:

sourceresolver: kind=<kind> url=<url> version=<version>: oci: network unreachable (cause: <the transport failure>); remediation: check network connectivity to <host>; corporate proxies typically need HTTPS_PROXY exported (sourceresolver: con il tipo, l’URL e la versione indicati: oci: rete non raggiungibile (causa: l’errore di trasporto); rimedio: verifica la connettività di rete verso l’host indicato; i proxy aziendali richiedono in genere che HTTPS_PROXY sia esportata)

Come risolvere: la correzione spetta all’operatore ed è esterna al tuo catalogo. Verifica che l’host indicato nel messaggio sia raggiungibile dal punto in cui viene eseguito il comando. Dove l’ambiente raggiunge la rete tramite un proxy, il proxy deve essere esportato nell’ambiente, come indica il rimedio — un proxy configurato solo per un browser o per un gestore di pacchetti non verrà rilevato. Dove l’host è raggiungibile a mano ma non da qui, la differenza sta di solito nelle credenziali presso un proxy o in un certificato di intercettazione che l’handshake non ha accettato. Una volta che gli artifact sono in cache, i build successivi leggono la cache e non hanno affatto bisogno della rete.

A server did not answer in time (Un server non ha risposto in tempo)

Una richiesta è rimasta in attesa del server a cui era indirizzata — un registry, o qualsiasi altro server raggiunto da un comando, come il log di trasparenza in cui viene registrata una firma — ed è stata ritirata. Una richiesta attende al massimo 30 secondi che il server inizi la sua risposta, una volta che la richiesta è stata inviata per intero, e al massimo 30 secondi la parte successiva di una risposta già in arrivo; oltre l’uno o l’altro limite viene rifiutata con questa condizione, che nomina il server e l’attesa. È ciò che produce un server che accetta una connessione e non risponde mai, e ciò che produce anche un indirizzo che non ne accetta mai una, invece di un comando che attende senza fine. Una scansione dell’intero elenco dei repository di un registry attende invece su ogni pagina per tutto il tempo in cui la scansione può durare, ed è limitata da una condizione propria, E0377.

Solo l’attesa è limitata. Un download o un upload che continua a procedere richiede tutto il tempo che serve, perché l’attesa viene misurata solo mentre non arriva nulla. Un chart Helm che il source: di una Recipe scarica tramite HTTPS è soggetto solo all’attesa dell’inizio della sua risposta, e quella scadenza viene segnalata con le parole della libreria di rete anziché con questa condizione. Una richiesta che un comando ripete già quando va in timeout — una lettura durante aggrega registry update, una scrittura durante una pubblicazione — viene prima ripetuta, quindi il rifiuto è ciò che resta dopo il suo ultimo tentativo.

Messaggio emesso, per un elenco delle versioni a cui il registry non ha risposto:

aggrega plugin add: 127.0.0.1:18471: list versions for plugin/cli/mo: oci: list tags: Get “http://127.0.0.1:18471/v2/plugin/cli/mo/tags/list”: 127.0.0.1:18471 did not answer within 30s: egress: the server did not answer in time (aggrega plugin add: 127.0.0.1:18471: elenco delle versioni per plugin/cli/mo: oci: elenco dei tag: Get: 127.0.0.1:18471 non ha risposto entro 30s: egress: il server non ha risposto in tempo)

e per una risposta che si è interrotta a metà:

<host> stopped answering: nothing more of its answer arrived for 30s: egress: the server did not answer in time (ha smesso di rispondere: per 30s non è arrivato nient’altro della sua risposta: egress: il server non ha risposto in tempo)

Come risolvere: la correzione spetta all’operatore ed è al di fuori del tuo catalogo. Verifica che il server indicato dal messaggio sia attivo e raggiungibile dal punto in cui viene eseguito il comando; un registry sotto carico o in manutenzione risponde di nuovo più tardi, e basta eseguire di nuovo il comando. Se l’ambiente raggiunge la rete tramite un proxy, verifica che il proxy inoltri la richiesta anziché trattenerla. L’attesa è fissa; non esiste alcuna impostazione che la allunghi.

A registry’s repository listing did not end in time (L’elenco dei repository di un registry non è terminato in tempo)

Una scansione dell’intero elenco dei repository di un registry è durata cinque minuti senza raggiungere la fine dell’elenco, ed è stata interrotta. Due comandi scansionano l’elenco: aggrega plugin add, solo quando nessun plugin porta esattamente il nome ricevuto e il comando ne cerca uno il cui nome lo contenga, e aggrega registry update, che elenca i repository di un registry prima di leggerli uno per uno. Un elenco che continua a nominare nuovi repository senza fine e uno che un registry serve troppo lentamente per essere completato terminano entrambi qui anziché bloccare il comando; la scansione non produce alcun repository, quindi nulla viene scelto o indicizzato da un elenco che è stato troncato. Il messaggio indica quanti repository l’elenco aveva nominato al momento dell’interruzione.

Messaggio emesso, per l’aggiunta di un plugin la cui query è parte di un nome:

aggrega plugin add: 127.0.0.1:18472: no cli plugin is named “mo”, and searching every repository for a name containing it did not finish; name the plugin exactly, as aggrega plugin add cli <name>: the walk was stopped after 5m0s, before the listing ended (repositories named so far: 146): registry: the repository listing did not end in time (aggrega plugin add: 127.0.0.1:18472: nessun plugin cli si chiama «mo», e la ricerca in ogni repository di un nome che lo contenga non è terminata; indica il plugin con il nome esatto, come aggrega plugin add cli seguito dal nome: la scansione è stata interrotta dopo 5m0s, prima della fine dell’elenco (repository nominati finora: 146): registry: l’elenco dei repository non è terminato in tempo)

Come risolvere: per aggrega plugin add, indica il plugin con il nome esatto — aggrega plugin add cli moo anziché aggrega plugin add cli mo — così il plugin viene cercato con quel nome con una sola richiesta e l’elenco non viene mai scansionato. Per aggrega registry update, la causa è l’elenco del registry: verifica con chi gestisce il registry che il suo elenco termini, ed esegui di nuovo l’aggiornamento una volta che termina. Il limite di cinque minuti è fisso; non esiste alcuna impostazione che lo allunghi.

A registry kept asking to slow down (Un registry ha continuato a chiedere di rallentare)

Un registry troppo occupato risponde 429 Too Many Requests, oppure 503 Service Unavailable con un header Retry-After che indica quanto attendere. Ogni richiesta che un comando rivolge a un registry attende quanto il registry chiede — dieci secondi dove non lo dice — e viene ripetuta; ogni richiesta rivolta a quel registry attende con essa, e gliene vengono inviate meno contemporaneamente finché non risponde di nuovo. Un registry che per cinque minuti non risponde altro che «rallenta» viene rifiutato con questa condizione, indicando il registry, la sua ultima risposta e da quanto tempo non rispondeva altro, e lo stesso vale per una richiesta il cui limite di tempo scade mentre attende. aggrega registry update segnala quindi quel registry come non indicizzato, e il registry mantiene l’indice che aveva prima dell’esecuzione.

Messaggio emesso, per un registry che ha chiesto di rallentare per cinque minuti:

<host> kept asking to slow down: its last answer was 429 Too Many Requests, and it had answered nothing else for 5m0s: oci: the registry kept asking to slow down (ha continuato a chiedere di rallentare: la sua ultima risposta è stata 429 Too Many Requests, e non aveva risposto nient’altro per 5m0s: oci: il registry ha continuato a chiedere di rallentare)

e per una richiesta il cui limite di tempo ha posto fine all’attesa:

<host> kept asking to slow down: its last answer was 429 Too Many Requests, and it had answered nothing else for <how long> when the request’s own time ran out: oci: the registry kept asking to slow down (ha continuato a chiedere di rallentare: la sua ultima risposta è stata 429 Too Many Requests, e non aveva risposto nient’altro quando è scaduto il tempo della richiesta: oci: il registry ha continuato a chiedere di rallentare)

Come risolvere: la causa è il limite di frequenza del registry, non qualcosa che hai scritto tu. Un registry che limita la frequenza con cui un client può fare richieste di solito limita tutto ciò che proviene dallo stesso indirizzo, quindi verifica se altri comandi o altre macchine dietro quell’indirizzo gli stanno facendo richieste nello stesso momento, ed esegui di nuovo il comando una volta che hanno terminato. Se il registry è gestito da te, controlla il suo limite di frequenza. Il limite di cinque minuti è fisso; non esiste alcuna impostazione che lo allunghi.

Fetched or cached bytes do not match the digest committed for them (I byte scaricati o in cache non corrispondono al digest dichiarato per essi)

Ogni artifact porta con sé un manifesto che dichiara il digest del suo contenuto, e il lockfile fissa in modo indipendente il digest di quel manifesto. Entrambe le dichiarazioni vengono verificate ricalcolando l’hash dei byte disponibili e confrontandolo. Questo è ciò che segnala un confronto non riuscito, e scatta allo stesso modo sui byte appena scaricati e sui byte riletti dalla cache.

Due condizioni, e quale scatta indica quale livello era in disaccordo. Una nomina un contenuto che non corrisponde al digest dichiarato dal suo stesso manifesto. L’altra nomina un manifesto in cache che non corrisponde al digest che il lockfile ha fissato per esso — il controllo che impedisce a un manifesto manomesso di diventare l’autorità di cui si fida un successivo controllo del contenuto. È il pin a dare significato a quel secondo controllo: proviene dal lockfile anziché dal ricavare di nuovo il manifesto dai byte in cache, quindi i due sono davvero indipendenti.

Un’entità è poi tenuta alla propria riga, al di sopra di ciò che portano i byte. Una volta che i byte di un’entità in cache concordano con il loro manifesto, vengono confrontati con il digest che il lockfile registra per l’entità, che copre i file trasportati dalla sua pubblicazione — ciascuno per percorso e byte — anziché i byte compressi. Così gli stessi file pubblicati con una compressione diversa concordano comunque, mentre file diversi sotto la stessa versione no, e un disaccordo viene segnalato sotto la condizione del contenuto. Un pull che rispetta un pin esegue lo stesso confronto su ciò che un registry serve sotto la versione fissata.

Nessuno di questi controlli ha bisogno della rete. Ognuno è un confronto di hash su byte già disponibili, ed è ciò che permette a un build completamente offline di stabilire comunque che ciò che sta leggendo è ciò che è stato fissato.

Messaggi emessi. Il contenuto rispetto al suo manifesto:

oci: content digest <computed> != manifest layer <committed>: oci: content digest mismatch (oci: il digest del contenuto calcolato è diverso da quello dichiarato dal layer del manifesto: oci: mancata corrispondenza del digest del contenuto)

un’entità plugin, che un manifesto dichiara in una posizione diversa:

oci: config digest <computed> != manifest config <committed>: oci: content digest mismatch (oci: il digest della configurazione calcolato è diverso da quello della configurazione del manifesto: oci: mancata corrispondenza del digest del contenuto)

un manifesto in cache rispetto al digest fissato:

oci: cached manifest digest <computed> != pinned <pinned>: oci: cached manifest digest mismatch (oci: il digest calcolato del manifesto in cache è diverso da quello fissato: oci: mancata corrispondenza del digest del manifesto in cache)

un’entità in cache rispetto alla sua riga, e un registry che serve un altro contenuto sotto una versione fissata:

catalog: cached <uri> content digest <computed> does not match lockfile pin <pinned>: oci: content digest mismatch (catalog: il digest del contenuto dell’entità in cache indicata non corrisponde al pin del lockfile: oci: mancata corrispondenza del digest del contenuto)

oci: content digest mismatch: pinned entity "<uri>": registry now serves digest <computed> for the pinned version, not the pinned digest <pinned>; run aggrega pull --upgrade --release <release> to update the pin (oci: mancata corrispondenza del digest del contenuto: entità fissata indicata: il registry ora serve per la versione fissata un digest diverso da quello fissato; esegui il pull di aggiornamento per aggiornare il pin)

Entrambi vengono inquadrati da ciò che si stava leggendo. Un’entità fissata che nessuna sorgente contiene al suo pin, con la condizione del manifesto dove il manifesto della voce di cache era in disaccordo e quella del contenuto altrimenti:

pinned entity <uri>: no source holds the pinned bytes <pinned> (<what each source it read held>); with a registry reachable, aggrega pull --release <release> fetches the pinned version again: <the message above> (entità fissata indicata: nessuna sorgente contiene i byte fissati, con ciò che conteneva ogni sorgente letta; con un registry raggiungibile, il pull scarica di nuovo la versione fissata: il messaggio precedente)

Anche una voce di archivio che nomina un percorso che esce dall’archivio viene segnalata sotto la condizione del contenuto, poiché un bundle che ci prova non è il bundle che era stato dichiarato:

path traversal entry "<name>": oci: content digest mismatch (voce con attraversamento di percorso indicata: oci: mancata corrispondenza del digest del contenuto)

Entrambe portano lo stesso rimedio dove lo step che le fa emergere ne fornisce uno:

remediation: run aggrega pull —upgrade —release <release> to refresh the lockfile and cache (rimedio: esegui aggrega pull —upgrade —release sulla Release indicata, per aggiornare il lockfile e la cache)

Come risolvere: niente nei tuoi file di entità causa questo errore e nessuna modifica di authoring lo elimina. Aggiorna insieme la cache e il lockfile con aggrega pull --upgrade --release <release>, che scarica di nuovo dalla sorgente e riscrive entrambi. Se questo lo elimina, la copia in cache era stata alterata o troncata dopo essere stata scritta. Se la mancata corrispondenza sopravvive a un aggiornamento, i byte serviti dall’editore differiscono davvero da ciò che era stato fissato — una versione ripubblicata, che è una domanda per chi la pubblica, e che vale la pena porre prima di adottare il nuovo digest anziché dopo.

A manifest carries no layer of the expected kind, or more than one (Un manifesto non contiene alcun layer del tipo atteso, oppure ne contiene più di uno)

Il manifesto di un artifact elenca i suoi layer, e quello che porta il contenuto viene selezionato in base al suo tipo di media anziché alla sua posizione. È ciò che permette a un artifact di raggruppare più di un layer — un chart con accanto un layer di provenienza separato, per esempio — e di avere comunque il contenuto individuato in modo affidabile.

Due strutture non lasciano nulla da selezionare. Nessun layer del tipo atteso significa che il manifesto descrive qualcosa di diverso da ciò che si è assunto che il riferimento indicasse. Più di uno significa che la scelta non ha risposta, e prendere il primo sarebbe a volte giusto e a volte sbagliato in silenzio.

Messaggi emessi, ciascuno dei quali nomina il tipo di media atteso. Nessuno:

oci: manifest has no layer of media type "<media-type>": oci: manifest has no layer of the expected content media type (oci: il manifesto non ha alcun layer del tipo di media indicato: oci: il manifesto non ha alcun layer del tipo di media del contenuto atteso)

e più di uno, che nomina anche quanti:

oci: manifest has <count> layers of media type "<media-type>"; expected exactly one: oci: manifest has multiple layers of the expected content media type (oci: il manifesto ha più layer del tipo di media indicato; ne era atteso esattamente uno: oci: il manifesto ha più layer del tipo di media del contenuto atteso)

Come risolvere: la correzione spetta all’editore anziché a te — il manifesto non è qualcosa che scrive un autore di catalogo. Verifica prima che il riferimento punti dove intendevi: un riferimento che si risolve in un tipo di artifact diverso produce la prima struttura, perché il manifesto è un vero manifesto di qualcos’altro. Se il riferimento è corretto, l’artifact è stato pubblicato con un manifesto che non lo descrive come il tipo che dichiara di essere, quindi riporta il tipo di media del messaggio a chi lo pubblica. La pubblicazione tramite il normale percorso di pubblicazione produce un manifesto con esattamente un layer di contenuto, quindi un artifact in una delle due strutture è stato assemblato in un altro modo.

A published bundle holds no entity, or holds two (Un bundle pubblicato non contiene alcuna entità, oppure ne contiene due)

Un’entità che dichiara file accanto al proprio documento — il chart locale di una Recipe o il suo lock, lo schema importato di un Component — viene pubblicata come .tar.gz che raggruppa l’entità insieme a quei file. Rileggerne uno significa ritrovare l’entità tra di essi — e il file in cui è stata scritta può chiamarsi in qualsiasi modo, quindi ciò che la identifica è il preambolo di entità che porta, non il suo nome. Il documento alla radice del bundle il cui kind: è un tipo di entità pubblicabile è l’entità; un frammento compose, un template di chart o un manifesto Kubernetes accanto a esso non lo sono, e non lo è nemmeno un documento di entità più in profondità dentro un albero source/, che è contenuto che l’entità distribuisce anziché l’entità stessa.

Due strutture non lasciano nulla da selezionare, ed entrambe sono proprietà del modo in cui l’artifact è stato pubblicato.

Nessun documento di entità alla radice del bundle. Il bundle è stato impacchettato senza l’entità alla sua radice — il suo documento omesso, o posto in una sottodirectory anziché accanto ai file che porta. Il messaggio elenca ciò che la radice del bundle contiene, il che di solito basta a capire quale dei due casi si è verificato.

Due documenti di entità alla radice del bundle. Il bundle è stato impacchettato da un’intera directory in cui erano state scritte due entità — cosa che aggrega push non fa mai, poiché ogni entità porta solo i file che dichiara, ma che un altro client può fare. Impacchettate in quel modo, ciascuna delle loro coordinate pubblicate porta gli stessi byte — quindi rispondere con una qualsiasi delle due restituirebbe l’altra entità sotto il nome richiesto, senza che nulla a valle possa accorgersene. Non c’è una scelta sicura da fare, quindi non se ne fa nessuna.

Messaggi emessi, che elencano ciò che è stato trovato. Nessuno, dove il bundle porta altri file:

bundle root carries no entity document among <file>, <file>: oci: published bundle carries no entity document (la radice del bundle non contiene alcun documento di entità tra i file indicati: oci: il bundle pubblicato non contiene alcun documento di entità)

nessuno, dove non porta nulla:

bundle root carries no files at all: oci: published bundle carries no entity document (la radice del bundle non contiene alcun file: oci: il bundle pubblicato non contiene alcun documento di entità)

e più di uno, che nomina sia il numero sia i documenti in collisione:

bundle root carries <count> entity documents (<file>, <file>): oci: published bundle carries more than one entity document (la radice del bundle contiene più documenti di entità, nei file indicati: oci: il bundle pubblicato contiene più di un documento di entità)

Come risolvere: entrambi spettano all’editore anziché a te, e la correzione sta nella directory di versione da cui l’entità è stata pubblicata. Dai a ogni entità una directory di versione propria, in modo che quella directory contenga un’entità e i file che le appartengono — la struttura che ogni entità pubblicata già segue, in cui la directory prende il nome dal metadata.version dell’entità e si trova sotto il nome dell’entità stessa. Poi pubblica di nuovo con una nuova versione: i byte pubblicati sono immutabili, quindi ripubblicare sulla versione esistente viene rifiutato anziché corretto. Se stai consumando anziché pubblicando, riporta il messaggio a chi pubblica l’artifact; i nomi di file in esso identificano la directory da dividere.

A published artifact cannot be read as an entity (Un artifact pubblicato non può essere letto come entità)

La lettura di un’entità dalla coordinata in cui è pubblicata parte dai byte che il registry serve lì — aggrega inspect oci://… li legge perché tu possa esaminarli, e un pull delle dipendenze legge allo stesso modo quelli di un archivio per trovare la versione che fissa. Due strutture di quei byte non contengono alcuna entità da leggere.

Un archivio che non si decomprime. Un’entità pubblicata con i file che dichiara viene pubblicata come .tar.gz, e i byte iniziano come tale, ma il flusso di compressione o l’archivio al suo interno non è ben formato — il più delle volte perché è stato troncato. I byte corrispondono comunque al digest che il manifesto dell’artifact registra per essi, quindi sono esattamente ciò che è stato pubblicato: il danno è avvenuto prima o durante la pubblicazione anziché lungo il percorso fino a te.

Un documento che non è un’entità. La coordinata porta un singolo documento, e questo non viene analizzato, non dichiara alcun kind: oppure dichiara un tipo che non viene mai pubblicato, come una Release o un Manifest. Il riferimento allora nomina qualcosa pubblicato accanto al catalogo anziché un’entità — per esempio un artifact di dati pubblicato con aggrega push-artifact.

Messaggi emessi. Un archivio il cui flusso di compressione non è ben formato, con l’errore che lo ha fermato:

oci: unbundle gzip: <archive error>: oci: published bundle cannot be unpacked (oci: estrazione gzip del bundle: l’errore dell’archivio: oci: il bundle pubblicato non può essere decompresso)

uno che si interrompe a metà di un file:

read <file> from the published bundle: <archive error>: oci: published bundle cannot be unpacked (lettura del file indicato dal bundle pubblicato: l’errore dell’archivio: oci: il bundle pubblicato non può essere decompresso)

un documento che dichiara un tipo che non viene mai pubblicato:

the published document declares kind <kind>, which a registry does not publish: oci: published artifact is not an entity document (il documento pubblicato dichiara un tipo che un registry non pubblica: oci: l’artifact pubblicato non è un documento di entità)

e byte che non sono affatto un documento:

the published bytes do not parse as a document (<parse error>): oci: published artifact is not an entity document (i byte pubblicati non vengono analizzati come documento, con l’errore di analisi: oci: l’artifact pubblicato non è un documento di entità)

Come risolvere: un archivio che non si decomprime deve essere sostituito dall’editore. I byte pubblicati sono immutabili, quindi il rimedio è pubblicare di nuovo l’entità con una nuova versione; se la stai consumando, riporta il messaggio a chi la pubblica. Un documento che non è un’entità significa quasi sempre che il riferimento non è quello che intendevi: verifica che nomini la coordinata in cui è pubblicata un’entità, cioè il riferimento che aggrega push stampa quando ne pubblica una.

The registry could not answer what is attached to an artifact (Il registry non ha potuto rispondere su ciò che è associato a un artifact)

Le firme e le altre associazioni sono agganciate a un artifact anziché stare al suo interno, e trovarle è una domanda posta al registry. Questa condizione dice che la domanda è rimasta senza risposta — il registry non serve quella ricerca, l’artifact a cui sono agganciate le associazioni non è stato individuato, oppure la richiesta stessa non è riuscita.

Non è la stessa cosa di una risposta «non è associato nulla», e confondere le due è esattamente ciò che questa condizione esiste per impedire. Un artifact che davvero non porta alcuna firma si risolve normalmente e produce un elenco vuoto. Questa dice che l’elenco non è mai stato ottenuto, quindi non si sa nulla di ciò che è associato.

Che il build si arresti dipende dal fatto che sia richiesta una firma, ed entrambe le direzioni sono intenzionali:

  • È richiesta una firma. Il build si ferma. Un controllo richiesto che non è stato possibile eseguire non è stato superato, e ammettere l’artifact si baserebbe su una domanda che nessuno è riuscito a porre.
  • Non è richiesta alcuna firma. Il build prosegue e lo dice ad alta voce, anziché in silenzio. La ricerca non ha prodotto nulla da verificare in un senso o nell’altro, quindi rifiutare respingerebbe un artifact sulla base di una domanda senza risposta — ma il silenzio verrebbe letto come un pull pulito di un artifact non firmato, cosa che non è.

Messaggi emessi. Un registry che non serve la ricerca:

oci: target does not support referrer discovery: <target kind>: oci: referrer discovery could not be completed (oci: la destinazione non supporta la scoperta dei referrer, con il tipo di destinazione indicato: oci: non è stato possibile completare la scoperta dei referrer)

l’artifact stesso non individuabile:

oci: resolve subject "<reference>": <the underlying failure>: oci: referrer discovery could not be completed (oci: risoluzione del soggetto indicato: l’errore sottostante: oci: non è stato possibile completare la scoperta dei referrer)

e la ricerca che non riesce:

oci: list referrers of "<reference>": <the underlying failure>: oci: referrer discovery could not be completed (oci: elenco dei referrer del riferimento indicato: l’errore sottostante: oci: non è stato possibile completare la scoperta dei referrer)

Dove non è richiesta alcuna firma, lo stesso testo compare invece come avviso:

signature verification could not run for <uri> (the registry could not answer the signature lookup and no signature is required; continuing): <the message above> (non è stato possibile eseguire la verifica della firma per l’artifact indicato (il registry non ha potuto rispondere alla ricerca della firma e non è richiesta alcuna firma; si prosegue): il messaggio precedente)

Come risolvere: la correzione spetta all’operatore e riguarda il registry anziché il tuo catalogo. Dove il registry non serve affatto le ricerche delle associazioni, non può portare firme, quindi esegui il mirror dell’artifact su uno che possa farlo oppure smetti di richiedere firme da quell’host in .aggrega-config.yaml — e prendi nota di quale delle due stai scegliendo, perché la seconda significa che le firme da quell’host non vengono più controllate. Dove la ricerca non è riuscita per un registry che la serve, si tratta di un problema di trasporto o di permessi specifico dell’endpoint delle associazioni, e rieseguire una volta che il registry è raggiungibile è l’intero rimedio.

An artifact that must be signed carries no signature (Un artifact che deve essere firmato non porta alcuna firma)

Una firma è richiesta per un artifact quando la policy di firma del workspace stesso copre il suo tipo oppure il registry da cui proviene è configurato per richiederne una. Questa condizione segnala che il registry ha risposto alla ricerca delle associazioni, che non era associato nulla e che era richiesta una firma.

I due requisiti sono un’unica posizione letta a due ambiti. La policy a livello di workspace impone una firma su un tipo che rientra nel suo ambito anche da un host la cui voce non ne richiede alcuna, quindi un host che non richiede nulla non esenta un artifact coperto dalla policy a livello di workspace.

Dove non è richiesta alcuna firma, questo non è affatto un errore. L’artifact viene verificato se è presente una firma e passa senza segnalazioni se non ce n’è nessuna, ed è questo che rende utilizzabile senza formalità un host privo di una posizione configurata.

Un artifact il cui tipo non è stato possibile determinare mentre è attiva una policy a livello di workspace viene trattato come se richiedesse una firma anziché come esente, così un artifact non classificabile non può sfuggire a una policy attivata.

Messaggio emesso, inquadrato dal riferimento che stava controllando:

verifying the signature of <uri>: signing: no signature found for an artifact that requires one (verifica della firma dell’artifact indicato: signing: nessuna firma trovata per un artifact che ne richiede una)

Come risolvere: la correzione spetta all’operatore o all’editore, non all’autore dell’entità. Dove ti aspettavi che l’artifact fosse firmato, è stato pubblicato senza firma — riporta il riferimento a chi lo pubblica, poiché solo chi lo pubblica può associarne una. Dove l’artifact non è pensato per essere firmato, è il requisito la cosa da cambiare: proviene dalla voce del registry in .aggrega-config.yaml oppure dalla policy di firma a livello di workspace, e il riferimento del messaggio ti dice quale host esaminare. Disattivare un requisito significa che gli artifact da quell’host non vengono più controllati, quindi preferisci restringere l’ambito della policy a un tipo anziché disattivarla del tutto.

A signature does not verify (Una firma non supera la verifica)

È stata trovata e controllata una firma, e il controllo non è riuscito. È l’esito negativo generale di quel controllo, e copre una catena di certificati che non ha radice nel materiale di fiducia, una firma senza voce nel log di trasparenza dove ne è richiesta una, una firma su un artifact diverso da quello disponibile, un bundle che è stato alterato e un bundle controllato rispetto a una chiave fissata con cui non supera la verifica.

È volutamente distinta da una firma il cui firmatario non è attendibile. Quella è strutturalmente valida e creata dal firmatario sbagliato; questa non ha superato affatto il controllo. Tenerle separate è ciò che ti permette di distinguere «l’artifact non è ciò che è stato firmato» da «l’artifact è stato firmato da qualcuno che non hai accettato».

Per quale artifact è stata creata una firma viene controllato due volte. Una volta superato il controllo crittografico della firma, la toolchain legge dalla firma stessa per quale artifact è stata creata — la stessa lettura a cui ogni build successivo sottopone la firma registrata, ed è ciò che permette a un build di rifiutare una firma copiata da un artifact a un altro senza verificare nulla — e rifiuta la firma dove quella lettura non nomina l’artifact disponibile, o dove la firma è in una forma da cui la lettura non riesce a ricavare l’artifact. Vengono lette entrambe le forme che un pull accetta: una firma creata sull’artifact stesso e una dichiarazione firmata che lo nomina. La lettura segue le regole proprie del controllo crittografico, quindi su una firma che quel controllo accetta le due concordano; un rifiuto di questo tipo significa che non concordavano, e vale la pena segnalarlo con il riferimento e il messaggio anziché aggirarlo con la configurazione.

Dove la voce di un registry contrassegna la verifica come consultiva, lo stesso testo viene segnalato come avviso e l’esecuzione prosegue.

Messaggi emessi. Dal controllo stesso, che riporta ciò che ha segnalato il verificatore:

signing: signature bundle does not verify: <what the verifier reported> (signing: il bundle di firma non supera la verifica: ciò che ha segnalato il verificatore)

e, dove il controllo crittografico è superato e la lettura dell’artifact per cui è stata creata la firma non concorda:

signing: signature bundle does not verify: its cryptographic check holds, but it does not name <manifest-digest> as the artifact it was made for (signing: il bundle di firma non supera la verifica: il suo controllo crittografico è superato, ma non nomina il digest del manifesto indicato come l’artifact per cui è stato creato)

signing: signature bundle does not verify: its cryptographic check holds, but it is in a form from which the artifact it was made for cannot be read (signing: il bundle di firma non supera la verifica: il suo controllo crittografico è superato, ma è in una forma da cui non si può leggere l’artifact per cui è stato creato)

ciascuno inquadrato dal riferimento in verifica:

verifying the signature of <uri>: <the message above> (verifica della firma dell’artifact indicato: il messaggio precedente)

e, dove la voce del registry rende la verifica consultiva, come avviso anziché come arresto:

signature verification failed for <uri> (advisory; continuing): <the message above> (la verifica della firma non è riuscita per l’artifact indicato (consultiva; si prosegue): il messaggio precedente)

Come risolvere: niente nei tuoi file di entità causa questo errore e nessuna modifica di authoring lo elimina. Trattalo come un’affermazione sull’artifact anziché sulla tua configurazione: i byte disponibili non sono i byte che sono stati firmati, oppure la firma non è una che il materiale di fiducia configurato può controllare. Per prima cosa acquisisci di nuovo l’artifact, poiché una copia in cache troncata o alterata fallisce esattamente in questo modo e un nuovo download lo elimina. Dove sopravvive a un nuovo download, riporta il riferimento e le parole stesse del verificatore a chi pubblica l’artifact. Non ricorrere all’impostazione consultiva per superarlo — quell’impostazione mantiene il controllo in esecuzione e gli impedisce di arrestare il build, il che è una scelta deliberata di accettare artifact non verificati da quell’host anziché un modo per correggerne uno.

A signature verifies but its signer is not one the registry trusts (Una firma supera la verifica, ma il suo firmatario non è uno di cui il registry si fida)

La firma ha superato il controllo — la catena di certificati ha radice nel materiale di fiducia e la voce di trasparenza è presente — e l’identità in quel certificato non corrisponde a nessuna delle identità configurate come accettabili per il registry. L’artifact è stato firmato da un firmatario reale che non è stato accettato.

Vengono confrontate entrambe le metà di un’identità, il soggetto e l’emittente che lo ha garantito, e a non corrispondere può essere l’una o l’altra. Il messaggio nomina entrambe dove si possono leggere dal certificato, perché un firmatario che presenta un soggetto atteso sotto un emittente che nessuno ha accettato appare identico a un soggetto sbagliato, a meno che non vengano mostrate entrambe.

Messaggi emessi. Con entrambe le metà leggibili:

signing: signature identity is not trusted for this registry: <what the verifier reported>; signer presented issuer "<issuer>" with identity "<subject>", but no trusted identity permits that issuer (signing: l’identità della firma non è attendibile per questo registry: ciò che ha segnalato il verificatore; il firmatario ha presentato l’emittente indicato con l’identità indicata, ma nessuna identità attendibile ammette quell’emittente)

e dove non si possono leggere, ripiegando sul resoconto del verificatore stesso:

signing: signature identity is not trusted for this registry: <what the verifier reported> (signing: l’identità della firma non è attendibile per questo registry: ciò che ha segnalato il verificatore)

Come risolvere: questa è una decisione dell’operatore, ed è una decisione reale anziché una formalità. Confronta l’emittente e l’identità nel messaggio con le identità attendibili configurate per quel registry in .aggrega-config.yaml. Dove il firmatario è uno che intendi accettare, aggiungilo — una voce nomina un’identità, o un pattern che vi corrisponde, insieme all’emittente, ed entrambi devono essere corretti. Dove non lo è, l’artifact è stato firmato da qualcuno che non hai accettato, e aggiungere l’identità per far passare il build è l’unica risposta da evitare. I registry che pubblicizzano la propria policy di fiducia possono averla fissata quando il registry viene aggiunto, ed è questo il modo di inserire le identità previste senza trascriverle.

A keyless trust policy names no acceptable signer (Una policy di fiducia senza chiave non nomina alcun firmatario accettabile)

La verifica senza chiave decide se accettare un artifact confrontando l’identità nel suo certificato di firma con un insieme di identità configurate come accettabili. Un insieme vuoto viene rifiutato anziché essere trattato come una policy: un confronto con il nulla accetterebbe ogni firmatario oppure li rifiuterebbe tutti, e nessuna delle due cose è ciò che intendeva un operatore che ha configurato la verifica.

Messaggio emesso, che è la frase propria della condizione:

signing: keyless verification requires at least one trusted identity (signing: la verifica senza chiave richiede almeno un’identità attendibile)

Come risolvere: configura almeno un’identità attendibile per il registry in .aggrega-config.yaml. Una voce nomina l’identità — come soggetto esatto o come pattern che vi corrisponde — insieme all’emittente che la garantisce, ed entrambi sono obbligatori. Dove il registry pubblicizza la propria policy di fiducia, fissare quella policy quando il registry viene aggiunto riempie l’insieme con ciò che il registry pubblica. Dove non intendi affatto verificare le firme da questo registry, si tratta di un’impostazione diversa da un insieme di identità vuoto, e impostarla esplicitamente è ciò che lo dichiara.

The pinned trust root cannot be read (La radice di fiducia fissata non può essere letta)

Una radice di fiducia fissata nel workspace è ciò che permette a un controllo senza chiave di verificare senza accesso alla rete ovunque venga eseguito: un file il cui contenuto è il materiale rispetto al quale viene controllata ogni firma. Questa condizione segnala che il file nel percorso configurato non è stato trasformato in materiale di fiducia utilizzabile — è assente, non è leggibile, oppure il suo contenuto non è una radice di fiducia.

Si arresta anziché ripiegare. Una radice fissata è una scelta deliberata di controllare le firme rispetto a materiale che controlli tu, quindi scaricarne una in silenzio al suo posto sostituirebbe quella scelta con un’altra e produrrebbe un risultato di verifica che nessuno ha chiesto.

Messaggio emesso, che nomina il percorso e riporta ciò che ha segnalato la lettura:

signing: cannot load pinned trust root: <path>: <what the read reported> (signing: impossibile caricare la radice di fiducia fissata: il percorso indicato: ciò che ha segnalato la lettura)

Come risolvere: questo spetta all’operatore. Verifica che il percorso configurato per la radice di fiducia esista e sia leggibile da chi esegue il comando — un percorso relativo a una directory di lavoro diversa e un file presente ma non leggibile vengono entrambi segnalati qui. Dove il file esiste ed è leggibile, il suo contenuto non è una radice di fiducia, quindi sostituiscilo con un bundle aggiornato dalla fonte da cui lo hai ottenuto anziché modificarlo. Dove una radice fissata non era voluta, è la configurazione la cosa da cambiare: rimuovi il pin e la verifica usa il materiale che le verrebbe fornito altrimenti.

A pinned verification key is not the key profile the verifier accepts (Una chiave di verifica fissata non è del profilo di chiave che il verificatore accetta)

La firma e la verifica con una chiave detenuta usano un unico profilo di chiave, e una chiave di qualsiasi altro tipo viene rifiutata anziché tentata. È un’affermazione sul tipo della chiave, non sul fatto che verifichi qualcosa.

I due momenti in cui viene segnalata sono compiti diversi. Uno è il caricamento di una chiave con cui firmare, che avviene dove un artifact viene pubblicato; l’altro è il controllo di una firma rispetto a una chiave fissata per un registry, che avviene dove un artifact viene verificato. Il rifiuto è lo stesso in entrambi.

Messaggi emessi, ciascuno dei quali nomina l’algoritmo della chiave effettivamente fornita — an RSA key o an Ed25519 key. Una chiave di verifica fissata:

signing: unsupported held-key type: pinned key is <the key's algorithm>, want ECDSA P-256 (signing: tipo di chiave detenuta non supportato: la chiave fissata usa l’algoritmo indicato, è richiesta ECDSA P-256)

e una chiave caricata per firmare:

signing: unsupported held-key type: held key is <the key's algorithm>, want ECDSA P-256 (signing: tipo di chiave detenuta non supportato: la chiave detenuta usa l’algoritmo indicato, è richiesta ECDSA P-256)

Come risolvere: fornisci una chiave del profilo che il messaggio nomina. Dove stai verificando, la chiave è quella fissata per il registry in .aggrega-config.yaml e deve essere la metà pubblica della chiave con cui firma l’editore — una mancata corrispondenza qui significa di solito che è stato fissato il file sbagliato, poiché una chiave del tipo giusto ma diversa da quella attesa viene invece segnalata come una firma che non supera la verifica. Dove stai firmando, genera una chiave del profilo indicato, oppure usa il percorso senza chiave, che non richiede affatto una chiave detenuta.

The workspace is offline and the step needs the network (Il workspace è offline e lo step richiede la rete)

Un workspace può essere contrassegnato come offline, e quell’impostazione è un rifiuto anziché una preferenza: ogni step che raggiungerebbe la rete viene rifiutato nel punto in cui viene costruito, prima che venga aperta qualsiasi connessione. Rifiutare presto è ciò che fa dire all’errore «questo workspace è offline» anziché farlo emergere più tardi come un timeout senza spiegazione.

Un’unica decisione, letta in un unico punto. Uno step che deve sapere in anticipo se la rete potrebbe essere raggiunta pone la stessa domanda che pone il download stesso, quindi un controllo e l’operazione che protegge non possono giungere a conclusioni diverse.

Raggiunge diversi tipi di lavoro, tutti con lo stesso rifiuto: l’acquisizione di un artifact da un registry, l’acquisizione della sorgente di una Recipe tramite la rete, il download di un input esterno, l’ottenimento di un’identità con cui firmare e il download del materiale di fiducia. Un build che legge una cache popolata non ne raggiunge nessuno, ed è questo lo scopo dell’impostazione.

Dove l’intero comando è un’andata e ritorno di rete, il rifiuto arriva per primo anziché per ultimo. push, push-artifact e registry update esistono per raggiungere un registry, quindi lo dicono prima di leggere la tua entità o di percorrere i tuoi repository, e nominano quale dei tre punti ha impostato la modalità — il flag che hai digitato, la variabile d’ambiente, oppure il file e la chiave al suo interno. Un --dry-run è l’eccezione, ed è un’eccezione per ciò che fa anziché per come si chiama: riporta ciò che pubblicherebbe e non chiama nulla, quindi è la forma di una pubblicazione sicura offline e continua a funzionare.

Messaggio emesso, che porta con sé il proprio rimedio ed è la frase propria della condizione:

egress: network access refused because the workspace is offline; remediation: pass --offline=false to allow the network for this one run, or clear the top-level offline key in the configuration file (or AGGREGA_OFFLINE) to allow it from now on; where the work is a build that needs content the machine does not have, run aggrega pull --release <release> from a connected environment first to populate the cache (egress: accesso alla rete rifiutato perché il workspace è offline; rimedio: passa il flag che consente la rete per questa sola esecuzione, oppure rimuovi la chiave di primo livello che imposta la modalità offline nel file di configurazione (o AGGREGA_OFFLINE) per consentirla da ora in poi; dove il lavoro è un build che richiede contenuto che la macchina non ha, esegui prima il pull della Release indicata da un ambiente connesso per popolare la cache)

Inquadrato da ciò che aveva bisogno della rete — l’acquisizione della sorgente di una Recipe, per esempio:

sourceresolver: kind=<kind> url=<url> version=<version>: <the message above> (sourceresolver: con il tipo, l’URL e la versione indicati: il messaggio precedente)

L’aggiunta dell’hub ufficiale in un workspace offline non viene rifiutata: l’hub viene aggiunto sulla sua base di riferimento integrata, e l’avviso dice che all’hub non è stata chiesta la sua policy di fiducia perché il workspace è offline.

Come risolvere: il messaggio nomina tre strade, e quale si applica sta a te deciderlo. Dove la modalità è impostata e vuoi superarla per questo solo comando, passa --offline=false; è a questo che serve il flag, ed è l’unica risposta disponibile per chi non ha scritto personalmente il file di configurazione. Dove il workspace deve essere offline, è il contenuto mancante la cosa da correggere: esegui il pull da un punto con accesso alla rete in modo che la cache contenga tutto ciò che la Release raggiunge, e poi il build offline non ha bisogno di nient’altro. Dove non deve essere affatto offline, rimuovi l’impostazione alla sua origine — la chiave di primo livello offline in .aggrega-config.yaml, oppure la variabile d’ambiente che il messaggio nomina, e la variabile è quella che coglie di sorpresa le persone perché non si trova in alcun file. Tieni presente che un workspace offline non può affatto firmare con il percorso senza chiave, poiché emettere un certificato e registrarlo sono operazioni di rete senza una forma offline.

Durante la costruzione della topologia

Una volta che ogni Component ha una Recipe risolta, il compilatore unisce i Components nel grafo IR leggendo il blocco uses: di ogni Component e incrociando le destinazioni e le associazioni di funzionalità.

Dangling uses target (Destinazione di arco pendente)

Un arco uses: nomina un componente di destinazione che non esiste nella topologia risolta. L’arresto è agnostico rispetto all’origine — un arco dell’Aggregate scritto dallo sviluppatore e un arco cablato da una Release vengono intercettati allo stesso modo. Una destinazione pendente è un arresto fatale, non un’eliminazione silenziosa: un arco verso una destinazione inesistente altrimenti sparirebbe e lascerebbe silenziosamente vuoti i valori iniettati del consumatore al momento della distribuzione. È il fratello strutturale dell’arresto per socket non dichiarato più sotto: in qualunque socket sia cablata una connessione, la sua destinazione deve risolversi in un componente esistente prima che l’arco venga sottoposto al controllo dei tipi.

Messaggio emesso. Prima viene il rifiuto, poi la destinazione che non corrisponde a nulla e il socket in cui la connessione è stata cablata — poi cosa fare al riguardo:

uses edge target does not exist ("<target>", wired into socket "<socket>"). Point the target at a component the Aggregate declares, or declare a component under that name. (la destinazione dell’arco uses non esiste: la destinazione indicata, cablata nel socket indicato. Punta la destinazione a un componente che l’Aggregate dichiara, oppure dichiara un componente con quel nome.)

Il rilievo è posizionato sulla voce scritta a cui si riferisce, nel documento in cui quella voce è stata scritta, quindi una connessione tracciata dal blocco uses: proprio di un componente, una proiettata da un’associazione e una cablata da una Release vengono ciascuna segnalate sul proprio blocco. Ogni connessione non valida viene segnalata come rilievo a sé, così un solo build le nomina tutte anziché fermarsi alla prima.

Come risolvere: dichiara il componente di destinazione mancante, oppure correggi il nome della destinazione nella voce uses: perché corrisponda a un componente esistente.

Two connections of one component under one alias (Due connessioni di un componente sotto un unico alias)

Un componente legge ciascuna delle sue connessioni tramite il suo alias — la chiave sotto cui la connessione è stata scritta oppure, per una connessione scritta come voce di elenco, il nome stesso della sua destinazione. Un template di Recipe legge le connessioni di un componente indicizzate solo per alias, e un’asserzione le legge indicizzate per socket e poi per alias, quindi due connessioni di un componente sotto un unico alias condividerebbero un solo slot in almeno una di queste viste: la successiva lo occuperebbe, e l’altra sarebbe assente da ciò che il template o l’asserzione vede. Perciò un alias nomina una sola connessione di un componente — qualunque sia il socket in cui ciascuna è cablata, qualunque cosa l’abbia tracciata (il blocco uses: proprio del componente, il blocco uses: di un’associazione a qualsiasi livello, o una voce per arco di una Release) e qualunque sia la sua destinazione. Una coppia arresta il build una volta che il grafo è definitivo, prima che venga eseguita qualsiasi asserzione e prima che venga renderizzato qualsiasi cosa.

La coppia nasce da una scrittura che è legittima su ciascuna superficie presa da sola: la voce propria di un componente e quella di un’associazione sullo stesso socket e alias; un elenco che nomina due volte la stessa destinazione (models: [llama, llama]); un alias scritto su due socket (models: { local: … } accanto a databases: { local: … }); due associazioni che cablano lo stesso alias; oppure una voce di Release che traccia una connessione su un socket che l’Aggregate ha lasciato non legato, sotto un alias che l’Aggregate ha già usato su un altro socket. Due strutture vicine non raggiungono mai questo arresto: una chiave scritta due volte in uno stesso blocco di voci con chiave fa fallire il caricamento del documento, e una voce di Release su un socket e un alias che un altro blocco ha già tracciato configura quella connessione — oppure, se nomina una destinazione diversa, si arresta come cambio di destinazione — anziché tracciarne una seconda.

Messaggio emesso. Prima viene il rifiuto, poi l’alias e il componente, poi il socket di questa connessione, la sua destinazione e il punto in cui è stata scritta la sua voce, poi lo stesso per la connessione che detiene già l’alias — poi cosa fare al riguardo:

connection alias is already used by another connection of the same component ("<alias>", on component "<component>", this connection wired into socket "<socket>", with target "<target>", written in "<file>", at "<key path>", the connection already holding the alias wired into socket "<socket>", with target "<target>", written in "<file>", at "<key path>"). Give one of the two connections an alias of its own: a component reads each connection by its alias, whatever socket it is wired into. A list entry takes its target’s name as its alias, so a target listed twice is listed once, or written as two keyed entries under two aliases. (l’alias di connessione è già usato da un’altra connessione dello stesso componente: l’alias e il componente indicati, il socket, la destinazione, il file e il percorso di chiave di questa connessione, poi gli stessi per la connessione che detiene già l’alias. Assegna a una delle due connessioni un alias proprio: un componente legge ogni connessione tramite il suo alias, qualunque sia il socket in cui è cablata. Una voce di elenco prende come alias il nome della sua destinazione, quindi una destinazione elencata due volte va elencata una sola volta, oppure scritta come due voci con chiave sotto due alias.)

Dove entrambe le connessioni sono state scritte allo stesso percorso di chiave — un elenco che nomina due volte la stessa destinazione — ciascuna viene anche nominata con la sua posizione in quell’elenco, list entry "2" accanto a list entry "1", che è l’unica cosa a distinguere le due voci.

Il rilievo è posizionato sulla voce propria della connessione successiva — quella tracciata per seconda, che è quella che altrimenti avrebbe occupato lo slot dell’alias — nel documento in cui quella voce è stata scritta. Così una voce di Release, o un’associazione che la Release scrive, viene classificata come errore operativo, e una voce nell’Aggregate come errore dello sviluppatore. Ogni connessione non valida viene segnalata come rilievo a sé, così un solo build le nomina tutte.

Alcune strutture vengono nominate in modo meno esatto. Un nome di associazione dichiarato a più di un livello — su un componente e sul sottosistema che lo contiene, per esempio — traccia una connessione da ciascun blocco che lo dichiara, e il build le registra entrambe solo sotto il nome dell’associazione. Entrambe le connessioni vengono allora nominate su uno dei blocchi dichiaranti — il blocco di associazioni proprio del componente, ovunque il nome vi sia dichiarato — e nessuna delle due porta una posizione di elenco. Lo stesso vale all’interno di un Aggregate importato, dove i blocchi dichiaranti — quello di un componente e quello di uno dei sottosistemi propri del modulo — vengono nominati nel documento proprio del modulo. In ognuna di queste strutture la coppia viene comunque rifiutata.

Come risolvere: assegna a una delle due connessioni un alias proprio. Per un elenco che nomina due volte la stessa destinazione, elenca la destinazione una sola volta, oppure scrivi le due connessioni come voci con chiave sotto due alias. Per un alias su due socket, rinomina una delle due chiavi. Un’associazione che cabla un socket sotto un alias che il componente usa già prende una chiave diversa nel proprio blocco uses:.

uses: socket not declared in the owning entity’s usesSchema (Socket non dichiarato nello schema dei socket dell’entità proprietaria)

Un blocco uses: nomina un socket che l’entità proprietaria della superficie non dichiara nel suo usesSchema, su una delle due superfici in cui si può nominare solo un socket dichiarato: il uses: di un’associazione di Feature, dove il socket deve essere dichiarato sulla Feature associata, e il uses: per arco di una Release, dove deve essere dichiarato sul Component consumatore. Una Release può cablare o configurare archi solo all’interno dei socket che lo usesSchema del Component dichiara già.

La superficie delle associazioni viene controllata a ogni livello a cui è scritta un’associazione: su un componente, su un sottosistema — dell’Aggregate o di un modulo che esso importa —, su un confine di Release e su una voce di componente della Release, compresa la voce per un componente che un modulo fornisce. Le dichiarazioni proprie di un modulo vengono controllate una volta costruita la composizione che lo importa, e il rilievo nomina l’Aggregate del modulo e la chiave all’interno del suo documento.

Il blocco uses: proprio di un componente deliberatamente non è una di quelle superfici, quindi questo arresto non scatta per esso. Uno sviluppatore possiede la topologia che l’Aggregate dichiara e può nominare un socket che il catalogo non ha dichiarato; il silenzio del catalogo su un socket significa che la connessione non era prevista, non che sia vietata. Un socket del genere è legittimo e il suo arco viene costruito — ciò a cui rinuncia sono il selettore e il contratto per arco che un socket dichiarato porta con sé. Un nome di socket scritto male in quel punto quindi non è un arresto ma una connessione ad hoc a sé stante, e viene segnalato come avvertimento che nomina entrambe le grafie — vedi warnings.md «Uses-socket near-miss lint (Lint di quasi corrispondenza dei socket uses)».

Messaggio emesso:

unknown uses socket: name a socket the entity declares in its usesSchema — only a component’s own uses block may name one the catalog did not declare (Release <release-name>, at .spec.components.<component>, "<component-type>", "<socket-name>", "<declared-sockets>") (socket uses sconosciuto: nomina un socket che l’entità dichiara nel suo usesSchema — solo il blocco uses proprio di un componente può nominarne uno che il catalogo non ha dichiarato; con la Release, la voce del componente, il tipo di componente, il nome del socket e i socket dichiarati)

Il ramo delle associazioni nomina il tipo di funzionalità al posto del tipo di componente; una Feature associata che non dichiara alcun usesSchema segnala invece che per essa le dichiarazioni uses: non sono consentite.

Come risolvere: su un’associazione, correggi il nome del socket con uno che la Feature associata dichiara, oppure dichiara quel socket nello usesSchema della Feature. Su una voce per arco di una Release, correggi il nome del socket con uno che il Component consumatore dichiara — una Release non può introdurre un socket che il Component non dichiara, e spostare la dichiarazione nell’entità di catalogo è il percorso supportato. Se l’entità di catalogo non dichiara alcun usesSchema, non accetta dichiarazioni uses: su quella superficie — rimuovi il blocco.

A connection carries an attachment under a name its socket declares no slot for (Una connessione porta un’associazione sotto un nome per cui il suo socket non dichiara alcuno slot)

Il blocco features: di una voce di connessione nomina un’associazione che nessuno slot del socket della connessione dichiara. Le associazioni che una connessione porta sono un insieme chiuso: il socket attraverso cui la connessione è cablata dichiara, in un featuresSchema sulla voce dello usesSchema del Component consumatore, ogni slot che una connessione su di esso può riempire, e un’associazione sotto qualsiasi altro nome viene rifiutata quando il build carica. Un socket che non dichiara alcun featuresSchema non ammette associazioni sulle sue connessioni, e nemmeno un socket che l’Aggregate nomina senza che il Component lo dichiari — un socket del genere non dichiara alcuno slot.

La regola vale su entrambi i documenti che scrivono le associazioni di una connessione: la voce di connessione dell’Aggregate sotto il uses: di un componente e la voce uses: per arco della Release. Per un componente che un sub-aggregato fornisce, i nomi dello sviluppatore vengono controllati una volta letto il documento proprio del sub-aggregato, e il rilievo nomina il file di quel documento e la voce del componente al suo interno. I nomi della Release vengono controllati una volta appiattita la composizione, per ogni componente rispetto a cui la Release scrive, e il rilievo nomina la voce propria della Release — all’interno del confine in cui si trova, oppure sotto la voce di instradamento che raggiunge il componente di un sub-aggregato. Una voce di Release su un socket che il Component non dichiara viene segnalata dall’arresto per socket non dichiarato più sopra, che elenca i socket che esistono davvero, anziché da questo.

Messaggio emesso. Prima viene il rifiuto, poi il documento e la voce, il nome dell’associazione, la connessione, il socket, il componente e gli slot che il socket dichiara — poi cosa fare al riguardo:

a connection carries an attachment under a name its socket declares no slot for (Aggregate <aggregate-name>, at .spec.components.<component>.uses.<socket>.<alias>, "<attachment>", on the connection "<alias>", through socket "<socket>", of component "<component>", the socket declaring the slots "<slots>"). Write the attachment under one of the slots the socket declares, or declare this slot in the socket’s featuresSchema on the Component. (una connessione porta un’associazione sotto un nome per cui il suo socket non dichiara alcuno slot: l’Aggregate, la voce, l’associazione, la connessione, il socket e il componente indicati, con gli slot che il socket dichiara. Scrivi l’associazione sotto uno degli slot che il socket dichiara, oppure dichiara questo slot nel featuresSchema del socket sul Component.)

Dove il nome è a una modifica di distanza da uno slot che il socket dichiara — un carattere trasposto, mancante, raddoppiato o errato, la struttura che assume un refuso — quello slot viene nominato subito dopo di esso, così la grafia probabilmente voluta si trova nella stessa frase:

a connection carries an attachment under a name its socket declares no slot for (Release <release-name>, at .spec.boundaries.<boundary>.components.<component>.uses.<socket>.<alias>, "credentail", near the declared slot "credential", on the connection "<alias>", …) (una connessione porta un’associazione sotto un nome per cui il suo socket non dichiara alcuno slot: la Release e la voce indicate, il nome dell’associazione vicino allo slot dichiarato, la connessione indicata, …)

Per un nome del genere non viene sollevato alcun avviso separato. Sul blocco features: proprio di un componente, un nome a una modifica di distanza da uno slot dichiarato è legittimo e genera solo l’avviso descritto in «An attachment name is one edit from a declared slot (Un nome di associazione è a una modifica di distanza da uno slot dichiarato)» più sotto; su una connessione il nome viene rifiutato, e il rifiuto porta con sé l’abbinamento stesso.

Dove il socket non dichiara alcuno slot, l’elenco è assente e l’indicazione recita «The socket declares no slots, so no connection wired through it carries an attachment: remove the attachment, or declare the slot in the socket’s featuresSchema on the Component. (Il socket non dichiara alcuno slot, quindi nessuna connessione cablata attraverso di esso porta un’associazione: rimuovi l’associazione, oppure dichiara lo slot nel featuresSchema del socket sul Component.)» Dove il Component non dichiara affatto il socket, recita «The component’s type does not declare this socket, so the socket declares no slots and no connection wired through it carries an attachment: remove the attachment, or declare the socket and its slot in the Component’s usesSchema. (Il tipo del componente non dichiara questo socket, quindi il socket non dichiara alcuno slot e nessuna connessione cablata attraverso di esso porta un’associazione: rimuovi l’associazione, oppure dichiara il socket e il suo slot nello usesSchema del Component.)»

Ogni associazione non valida viene segnalata come rilievo a sé, così un solo build le nomina tutte.

Come risolvere: scrivi l’associazione sotto uno slot che il socket dichiara; oppure, se la connessione ha bisogno di uno slot che il socket non ha, dichiaralo nel featuresSchema del socket sul Component. Su un socket che il Component non dichiara, dichiara il socket e il suo slot nello usesSchema del Component, oppure rimuovi l’associazione.

Release retargets a developer-declared edge (La Release cambia la destinazione di un arco dichiarato dallo sviluppatore)

Una voce uses: per arco di una Release nomina una destinazione diversa da quella che lo sviluppatore ha già cablato per lo stesso socket e alias. Una Release può configurare un arco dichiarato dallo sviluppatore (impostando infra per arco, nominando la stessa destinazione oppure omettendola) e può cablare un arco in un socket dichiarato ma non legato, ma non può cambiare la destinazione di un arco dichiarato dallo sviluppatore — lo sviluppatore possiede l’architettura che ha scritto.

Le due destinazioni vengono confrontate così come sono state scritte, non come si risolvono. Un target: può nominare l’alias pubblicato di un sub-aggregato anziché un id di componente, e quell’alias si risolve nel componente per cui il modulo lo pubblica — quindi una voce di Release che ripete proprio l’alias scritto dallo sviluppatore è una configurazione e viene accettata, esattamente come lo è la ripetizione di un semplice id di componente.

L’arco mantiene la destinazione che gli ha dato lo sviluppatore, che questo arresto scatti o meno, e il blocco infra: della voce di Release non gli viene applicato. Un cambio di destinazione rifiutato non viene mai applicato a metà.

Messaggio emesso. Prima viene il rifiuto, poi la destinazione che lo sviluppatore ha dichiarato, la destinazione che la Release ha nominato e il socket — poi cosa fare al riguardo:

release edge retargets a developer-declared edge (declared target "<declared-target>", target the Release names "<release-target>", wired into socket "<socket>"). Drop the target from the Release entry to configure the connection as it was declared, or change the target where the connection is declared. (l’arco della Release cambia la destinazione di un arco dichiarato dallo sviluppatore: la destinazione dichiarata, la destinazione che la Release nomina e il socket in cui è cablato, indicati. Togli la destinazione dalla voce della Release per configurare la connessione così come è stata dichiarata, oppure cambia la destinazione dove la connessione è dichiarata.)

Il rilievo è posizionato sulla voce scritta in cui la connessione è stata dichiarata, nel documento che l’ha dichiarata. Ogni voce non valida viene segnalata come rilievo a sé, così un solo build le nomina tutte anziché una per esecuzione.

Come risolvere: togli il target divergente dalla voce uses: della Release per configurare l’arco esistente (solo infra per arco), oppure, se la connessione appartiene davvero a un socket diverso, cablala attraverso un socket che lo sviluppatore ha lasciato non legato. Per cambiare la destinazione stessa, cambiala nell’Aggregate, dove la topologia viene scritta.

Release per-edge configuration has no edge to apply to (La configurazione per arco della Release non ha alcun arco a cui applicarsi)

Una voce uses: per arco di una Release imposta infra:, associazioni sotto features:, o entrambi, ma non esiste alcun arco nel consumatore, nel socket e nell’alias che nomina, una volta tracciati tutti gli archi del build.

Le due cose che una voce di Release può fare sono cablare un arco e configurarne uno, e quale delle due faccia dipende dal fatto che nomini o meno un target:. Una voce con una destinazione crea l’arco che configura. Una voce senza destinazione configura un arco che deve già esistere — dichiarato dallo sviluppatore nell’Aggregate, oppure fornito da una Feature associata. Quindi una voce che non nomina alcuna destinazione e non corrisponde ad alcun arco esistente non si applica a nulla: il blocco infra: e le associazioni sotto di esso non raggiungono mai alcun output. Il build si ferma anziché accettare una scrittura che non fa nulla, perché altrimenti un build riuscito si leggerebbe come conferma che l’infrastruttura è stata applicata e che la connessione porta ciò che la voce vi ha messo.

L’alias fa parte di ciò che una voce nomina, quindi una voce che configura un alias mai dichiarato dallo sviluppatore non raggiunge alcun arco anche quando il socket è legato sotto un alias diverso. Lo stesso vale per una voce che nomina un componente che l’Aggregate non dichiara.

Due condizioni vicine vengono segnalate dai propri arresti anziché da questo, perché ciascuna ha qualcosa in più da dirti. Un socket che lo usesSchema del Component consumatore non dichiara viene segnalato come socket non dichiarato, che può elencare i socket che esistono davvero. Un target: che non nomina alcun componente viene segnalato come destinazione pendente. Un componente disattivato da un interruttore active: si porta via i propri archi per progettazione, quindi una voce rimasta su di esso viene accettata anziché arrestata.

Ogni voce non valida viene segnalata. Una Release con diverse voci che non raggiungono alcun arco si arresta con uno di questi per ciascuna voce in un unico build, nell’ordine in cui il documento le dichiara, anziché segnalare la prima e lasciare le altre al build successivo.

Messaggio emesso, dove la voce nomina un componente che esiste. Porta il percorso della voce stessa, così viene nominata la riga da modificare anziché il componente che la contiene:

release per-edge configuration has no edge to apply to (Release <release-name>, at .spec.boundaries.<boundary>.components.<consumer>.uses.<socket>.<alias>, "<consumer>", on socket "<socket>", under alias "<alias>"). Give the entry a target to wire the edge, or remove it: an entry with no target configures an edge that must already exist. (la configurazione per arco della Release non ha alcun arco a cui applicarsi: la Release, la voce, il consumatore, il socket e l’alias indicati. Dai alla voce una destinazione per cablare l’arco, oppure rimuovila: una voce senza destinazione configura un arco che deve già esistere.)

Una Release che nomina i propri componenti al livello superiore anziché sotto i confini riporta la struttura che il suo autore ha scritto — .spec.components.<consumer>.uses.<socket>.<alias> — e un componente nominato all’interno di una voce di instradamento aggregates: viene nominato attraverso quella voce, con il nome locale che vi porta.

Dove la voce nomina un componente che l’Aggregate non dichiara, l’arresto proviene da una fase precedente del build e recita, nominando ciò che la voce imposta — infra, features oppure infra and features:

release per-edge configuration has no edge to apply to: release edge <consumer>/<socket>/<alias> sets <infra|features|infra and features> on <consumer>, which is not a component in the topology (la configurazione per arco della Release non ha alcun arco a cui applicarsi: l’arco della Release indicato imposta i blocchi indicati sul consumatore indicato, che non è un componente nella topologia)

Come risolvere: aggiungi un target: alla voce, che cabla l’arco e vi applica la configurazione; correggi l’alias con quello che l’Aggregate ha dichiarato per quella connessione, così la voce configura l’arco esistente; correggi il nome del componente con uno che l’Aggregate dichiara; oppure rimuovi la voce se la configurazione non è più desiderata.

A Release attachment takes the name of a connection’s attachment (Un’associazione della Release prende il nome dell’associazione di una connessione)

Una Release scrive un’associazione sotto il nome che prende un’associazione su una delle connessioni di un componente: l’alias della connessione, un punto e lo slot che l’associazione riempie — gpt.credential per l’associazione che riempie lo slot credential sulla connessione gpt. L’associazione di una connessione si scrive sulla sua voce di connessione — la connessione dell’Aggregate sotto il uses: del componente, oppure la voce uses: per arco della Release per la stessa connessione — e diventa un’associazione del componente consumatore sotto quel nome composto. La Release scrive associazioni ad altri due livelli le cui chiavi possono contenere un punto, quindi anche lì si può scrivere il nome composto:

  • Il blocco features: proprio di una voce di componente, che si associa a quel componente.
  • Il blocco features: proprio di un confine, che si associa a ogni componente collocato in quel confine o in un confine annidato al suo interno — compresi i componenti di un sub-aggregato che il confine instrada senza nominarli. Una chiave lì si arresta quando è uguale al nome composto su uno qualsiasi dei componenti che raggiunge, che nomini o meno un type:.

Il build si ferma anziché fondere l’una o l’altra nell’associazione della connessione, perché allora nessuno dei due documenti mostrerebbe per intero ciò che il build ne fa. Lo slot di un socket viene riempito per connessione, dalla voce propria della connessione, e mai da un’associazione che vi ricada a cascata da un livello più ampio. Una chiave con un punto che nessuna associazione di connessione dei componenti che raggiunge prende è un normale nome di associazione, e non viene rifiutata.

Il controllo copre un’associazione che l’uno o l’altro documento ha messo sulla connessione, e un componente che un sub-aggregato fornisce così come uno che l’Aggregate dichiara.

Messaggio emesso, per una chiave su una voce di componente. Prima viene il rifiuto, poi la Release e la voce di componente, la chiave che la Release ha scritto, il componente, la connessione, il socket e lo slot — poi la voce di connessione su cui scriverla:

a Release attachment takes the name of an attachment one of a component’s connections carries (Release <release-name>, at .spec.components.<component>, "<alias>.<slot>", of component "<component>", on the connection "<alias>", through socket "<socket>", in the slot "<slot>"). Write it on the connection entry, under uses.<socket>.<alias>.features.<slot>, and remove "<alias>.<slot>" from this entry’s features: an attachment a connection carries is written on that connection and nowhere else. (un’associazione della Release prende il nome di un’associazione che una delle connessioni di un componente porta: la Release, la voce del componente, la chiave, il componente, la connessione, il socket e lo slot indicati. Scrivila sulla voce di connessione, sotto il percorso indicato, e rimuovi la chiave dalle features di questa voce: un’associazione che una connessione porta si scrive su quella connessione e da nessun’altra parte.)

Messaggio emesso, per una chiave su un confine. Nomina il blocco delle associazioni del confine e il componente la cui connessione porta l’associazione:

a Release attachment takes the name of an attachment one of a component’s connections carries (Release <release-name>, at .spec.boundaries.<boundary>.features, "<alias>.<slot>", of component "<component>", on the connection "<alias>", through socket "<socket>", in the slot "<slot>"). Write it on component "<component>"’s connection entry, under uses.<socket>.<alias>.features.<slot>, and remove "<alias>.<slot>" from this boundary’s features: an attachment a connection carries is written on that connection and nowhere else. (un’associazione della Release prende il nome di un’associazione che una delle connessioni di un componente porta: la Release, il blocco delle associazioni del confine, la chiave, il componente, la connessione, il socket e lo slot indicati. Scrivila sulla voce di connessione del componente indicato, sotto il percorso indicato, e rimuovi la chiave dalle features di questo confine: un’associazione che una connessione porta si scrive su quella connessione e da nessun’altra parte.)

Una chiave su un confine che raggiunge diversi componenti le cui connessioni portano il nome composto viene segnalata una volta per ciascuno di essi, perché ogni connessione è una modifica separata.

Il rilievo è posizionato sul blocco in cui la chiave è stata scritta — la voce di componente, oppure il features: del confine — perché la chiave stessa contiene un punto e una posizione non può indirizzare una chiave del genere; la chiave viene invece nominata nel messaggio. In una Release che nomina confini, una voce di componente si legge .spec.boundaries.<boundary>.components.<component>, un componente nominato all’interno di una voce di instradamento aggregates: viene nominato attraverso quella voce, con il nome locale che vi porta, e il blocco di un confine annidato si legge .spec.boundaries.<outer>.boundaries.<inner>.features.

Come risolvere: sposta l’associazione sulla voce della Release per quella connessione — uses.<socket>.<alias>.features.<slot> sotto il componente — scrivendovi solo infra: per dimensionare un’associazione che l’Aggregate dichiara, oppure type: e infra: per una che solo la Release crea; poi rimuovi la chiave con il punto dal features: del componente o del confine. Una chiave valida per tutto il confine e destinata alle connessioni di diversi componenti si scrive una volta su ciascuna di quelle connessioni.

A Release connection attachment names no Feature type (Un’associazione di connessione della Release non nomina alcun tipo di Feature)

Una voce uses: per arco di una Release mette un’associazione su una connessione, sotto uno slot per cui l’Aggregate non dichiara alcuna associazione su quella connessione, e non nomina alcun type:. Un’associazione che una Release scrive su una connessione è una di due cose. O dimensiona un’associazione che l’Aggregate dichiara già sulla stessa connessione, e non nomina alcun tipo perché lo nomina la dichiarazione dell’Aggregate; oppure è un’associazione che solo la Release crea, e allora la voce della Release è l’unico posto da cui può provenire il suo tipo di Feature. Senza di esso, nulla può scegliere una FeatureRecipe per l’associazione.

Il controllo copre un componente che un sub-aggregato fornisce così come uno che l’Aggregate dichiara. Un componente che un interruttore active: ha disattivato si porta via le proprie connessioni, quindi una voce rimasta su di esso non viene controllata.

Messaggio emesso. Prima viene il rifiuto, poi la Release e la voce di connessione, lo slot, la connessione, il socket e il componente — poi cosa fare al riguardo:

a Release connection attachment names no Feature type, and the type is required for an attachment only the Release makes (Release <release-name>, at .spec.components.<component>.uses.<socket>.<alias>, "<slot>", on the connection "<alias>", through socket "<socket>", of component "<component>"). Name the Feature this attachment attaches under its type, or declare the attachment on the Aggregate’s connection entry and size it here. (un’associazione di connessione della Release non nomina alcun tipo di Feature, e il tipo è obbligatorio per un’associazione che solo la Release crea: la Release, la voce di connessione, lo slot, la connessione, il socket e il componente indicati. Nomina, con il suo tipo, la Feature che questa associazione associa, oppure dichiara l’associazione sulla voce di connessione dell’Aggregate e dimensionala qui.)

Ogni associazione non valida viene segnalata come rilievo a sé, così un solo build le nomina tutte.

Come risolvere: aggiungi un type: che nomini la Feature che l’associazione associa; oppure, dove spetta allo sviluppatore dichiarare l’associazione, dichiarala sulla voce di connessione dell’Aggregate con i suoi values: e mantieni solo infra: sulla voce della Release.

Component identity cannot be stamped on what it emits (L’identità del Component non può marcare ciò che esso emette)

L’identità di un componente non è solo una chiave nel tuo Aggregate — è un nome all’interno del cluster. Ogni risorsa che un componente emette viene marcata con essa, sotto aggrega.ai/component-id e app.kubernetes.io/name, e i sintetizzatori di carichi di lavoro danno il suo nome a ciò che emettono. Quindi l’identità deve essere un nome che la destinazione accetterà, e deve essere un nome che significa ciò che dice.

Un nome che hai scritto raggiunge il suo output esattamente come l’hai scritto, ed è questo che rende il nome nel tuo Aggregate il nome che puoi cercare nel tuo cluster. È una cosa che vale la pena avere, ed è il motivo per cui un’identità che la destinazione rifiuterebbe viene segnalata qui anziché essere riparata in silenzio in qualcosa che non hai mai scritto.

Un carattere fa eccezione, ed è uno che non puoi scrivere: il punto che unisce il nome di un modulo al nome di un componente al suo interno. È escluso da ogni nome che scrivi proprio perché quell’unione sia univoca, e viene tolto dall’identità prima della marcatura — data-layer.main-db viene marcato come data-layer-zdmain-db. Questo non costa alcun nome digitato da qualcuno, ed è ciò che rende possibile marcare un componente fornito da un Aggregate importato: il punto non è un carattere che un nome di Service accetta, e all’interno di un indirizzo del cluster separa un servizio dal suo namespace, quindi un nome con un punto passato a un consumatore come host si risolverebbe in un servizio diverso anziché fallire.

Vengono rifiutate due strutture.

Un’identità che l’alfabeto di marcatura non può contenere. L’identità viene scritta nel valore dell’etichetta che ogni risorsa emessa porta, e quell’alfabeto ammette lettere, cifre, -, _ e ., e richiede che il valore inizi e finisca con una lettera o una cifra. Le regole sui nomi scritti sono vicine a questa ma non uguali — consentono a un nome di iniziare o finire con - o _ — quindi _api e api- sono entrambi nomi che puoi scrivere e nessuno dei due può essere marcato.

Quanto possa essere lungo un nome non viene chiesto qui. Questo spetta alla destinazione in cui un componente viene distribuito, e destinazioni diverse rispondono in modo diverso: questa condizione copre le strutture che nessuna destinazione potrebbe contenere. Un nome rifiutato per la sua lunghezza viene invece segnalato dal rifiuto proprio della destinazione, che porta il motivo di quella destinazione e la lunghezza che accetterebbe.

Un’identità che inizia come inizia un’identità composta. Le risorse che una Feature emette non possono essere marcate con un nome di componente che hai scritto, quindi Aggrega compone per esse un’identità a partire dalle parti che hai scritto, dietro un prefisso fisso che dice dove la Feature è stata associata. Dove la Feature è associata a un singolo componente, l’identità è composta da quel componente e dalla chiave sotto cui la Feature è associata, e inizia con cfr--. Dove è associata a un intero confine, non si applica il nome di alcun componente, quindi l’identità è composta dal percorso del confine e dal nome sotto cui la Feature è associata, e inizia con bfr--. È il prefisso a dire a chi legge da quale dei due proviene una risorsa, anziché da un componente. Quindi bfr-- e cfr-- sono entrambi riservati all’inizio di un’identità di componente. Un componente chiamato bfr--api o cfr--api verrebbe marcato in modo identico a uno composto, e nulla nell’output emesso potrebbe distinguere i due. È riservato solo il prefisso completo: un componente chiamato bfr, cfr, bfr-api o bfrontend ha un nome ordinario e il build va a buon fine.

Il controllo legge l’identità che un componente porta effettivamente, che per un componente fornito da un Aggregate importato è quella qualificata — il nome del modulo, un punto e il nome proprio del componente. Così due nomi, ciascuno accettabile da solo, possono comunque unirsi in un’identità che non lo è: un modulo chiamato bfr--x e un componente chiamato y al suo interno si uniscono in bfr--x.y, che inizia come inizia un’identità composta. L’arresto nomina l’identità unita, indicando la chiave che hai scritto.

Messaggio emesso, per un’identità che la destinazione rifiuterebbe:

component identity cannot be the name its emitted resources are stamped with: rename the component (Aggregate, at <field-path>, "<identity>", which must "<rule>") (l’identità del componente non può essere il nome con cui vengono marcate le risorse che emette: rinomina il componente; con l’Aggregate, il percorso del campo e l’identità indicati, e la regola che l’identità deve rispettare)

e per una che inizia come inizia un’identità composta, dove <opening> è quello dei prefissi riservati a cui il nome corrisponde:

component identity cannot be the name its emitted resources are stamped with: rename the component (Aggregate, at <field-path>, "<identity>", which must not open with the reserved "<opening>") (l’identità del componente non può essere il nome con cui vengono marcate le risorse che emette: rinomina il componente; con l’Aggregate, il percorso del campo e l’identità indicati, che non deve iniziare con il prefisso riservato indicato)

Come risolvere: rinomina il componente, su ogni superficie che lo nomina — l’Aggregate che lo dichiara e la Release che lo colloca e lo configura. Dagli un nome che inizi e finisca con una lettera o una cifra e che non inizi né con bfr-- né con cfr--. Rinominare un componente cambia il nome che le sue risorse portano nel cluster, quindi su un’applicazione già distribuita trattalo come qualsiasi altra ridenominazione di risorse.

The target will not accept a name derived from an authored identity (La destinazione non accetta un nome derivato da un’identità scritta)

Ogni destinazione deriva i propri nomi dall’identità di un componente: un installatore di chart deriva un nome di release, un orchestratore di container deriva nomi di servizio. Questo arresto è quella destinazione che dichiara di non poterne usare uno.

Aggrega non contiene le regole di denominazione di alcuna destinazione. Non sa quanto possa essere lungo un nome, quali caratteri una destinazione ammetta, né che cosa la grammatica di una destinazione richieda all’inizio di un nome — e deliberatamente non lo sa, perché queste cose differiscono a seconda della destinazione, del tipo di risorsa su cui un nome finisce e talvolta di un singolo servizio all’interno di un singolo provider. Perciò, prima che un nome sia stabilito, il compilatore interroga il provider che renderizzerà il componente, e questo arresto riporta la risposta del provider. Ecco perché il messaggio porta la parola propria della destinazione per ciò che è stato rifiutato (release name, Service name) e il motivo proprio della destinazione, anziché una regola scritta nel compilatore.

Perché il nome viene rifiutato anziché accorciato. Un nome che hai scritto è il nome con cui il tuo carico di lavoro viene distribuito: accorciarlo rinominerebbe ogni risorsa in ogni output esistente, e lo farebbe per tuo conto senza che tu l’abbia chiesto. La persona che può scegliere un nome diverso è la persona che ha scritto questo, quindi l’arresto punta alla chiave spec.components che hai scritto e lascia stare il nome. I nomi che Aggrega stessa compone — l’identità di una Feature associata a un intero confine, per esempio — vengono invece accorciati, perché sono assemblati da parti scritte in più documenti e nessun singolo autore può vedere la lunghezza che raggiungono.

Due risposte che una destinazione può dare, e portano in direzioni diverse. Dove un nome più corto verrebbe accettato, l’arresto indica la lunghezza che funzionerebbe, così un nuovo nome viene scelto una volta sola anziché due. Dove nessuna lunghezza aiuterebbe — un carattere che la grammatica della destinazione rifiuta nella posizione in cui è finito — non viene indicata alcuna lunghezza, perché accorciare non può porvi rimedio. Il caso più comune del secondo tipo: una destinazione i cui nomi ammettono solo minuscole esegue l’escape di ogni carattere che non ammette, e ogni escape inizia con un trattino, quindi un nome il cui primo carattere subisce l’escape produce un nome che inizia con un trattino. Una destinazione che lì richiede una lettera minuscola o una cifra lo rifiuta per quanto corto sia il resto. Una destinazione può anche sottoporre l’inizio di un nome alla regola più rigida delle risorse che ne prendono il nome: la destinazione helm rifiuta un nome che inizia con una cifra, segnalato come Service name, perché Helm accetta un tale nome di release mentre il cluster rifiuta un Service Kubernetes che ne prende il nome.

Una terza forma compare solo per un nome composto: una destinazione può indicare una lunghezza inferiore all’identità più corta che il compilatore riesce a comporre dalle parti ricevute, poiché un’identità composta riserva spazio per un discriminatore. L’arresto lo dice e nomina il rimedio — accorciare le parti scritte — anziché segnalare il provider come difettoso.

Alcuni nomi esistono solo per il carico di lavoro che un componente renderizza. Il provider viene interpellato una volta risolto il Workload di quel componente, e la domanda porta il form del Workload e le sue chiavi Service, così che una destinazione possa giudicare anche i nomi che costruisce a partire da essi. Con la destinazione helm se ne aggiungono due: un CronJob name, al massimo 52 caratteri e giudicato solo per un Workload scheduled, perché il cluster dà al Job di ogni esecuzione il nome del CronJob con un suffisso aggiunto; e ogni Service name, <release name>-<service key>, al massimo 63 caratteri. Un nome di Service è costruito con parti di due autori — il nome del tuo componente e la chiave che il carico di lavoro dichiara, nella Recipe o in una FeatureRecipe — quindi il suo motivo nomina la chiave e il punto in cui il carico di lavoro la dichiara, spec.workload.services.<key>, accanto al campo che hai scritto. Una chiave abbastanza lunga da non lasciare spazio ad alcun nome di componente non indica alcuna lunghezza entro cui scegliere, e il motivo dice che è la chiave a dover essere più corta. Questi nomi non vengono giudicati per una Feature associata a un intero boundary: la sua identità viene stabilita prima che il suo Workload sia risolto, perché il punto in cui viene assemblato il suo output può dipenderne.

Messaggio emesso, per un’identità scritta:

the target will not accept a name derived from this component’s authored identity: rename the component (component "<identity>", written at <field-path>, which the target cannot use as a <name-kind>, <the target's reason>). choose a name of at most <n> characters that the target accepts (la destinazione non accetta un nome derivato dall’identità scritta di questo componente: rinomina il componente (il componente indicato, scritto al percorso indicato, che la destinazione non può usare come il tipo di nome indicato, con il motivo della destinazione). scegli un nome che la destinazione accetti, al massimo del numero di caratteri indicato)

Come risolvere: rinomina il componente con un nome che la destinazione accetti, su ogni superficie che lo nomina — l’Aggregate che lo dichiara e la Release che lo colloca e lo configura. Dove il messaggio indica una lunghezza, restaci dentro. Dove non la indica, leggi il motivo della destinazione: di solito è un carattere che la destinazione non ammette, e più spesso una lettera maiuscola all’inizio del nome — oppure, con la destinazione helm, una cifra in quella posizione. Preferisci lettere minuscole e cifre con trattini tra le parole; il capitolo sulla denominazione spiega che cosa costa un nome con ciascun tipo di destinazione. Dove il motivo nomina una chiave Service, la lunghezza si può recuperare anche accorciando quella chiave nel punto in cui il carico di lavoro la dichiara — e dove il motivo dice che la chiave non lascia spazio, solo questo funziona. Rinominare un componente cambia il nome che portano le sue risorse, quindi su un’applicazione già distribuita trattalo come qualsiasi altra ridenominazione di risorse.

Dove l’identità è una che il compilatore ha composto anziché una che hai scritto tu, lo stesso arresto riporta il valore composto e ti chiede di accorciare le parti da cui è stato costruito — il nome sotto cui hai associato una Feature e il percorso del confine a cui l’hai associata.

A provider never accepted a name the compiler composed (Un provider non ha mai accettato un nome composto dal compilatore)

Questo segnala un difetto in un plugin, non in qualcosa che hai scritto.

Stabilire un nome composto è uno scambio: il compilatore propone un’identità, il provider la accetta oppure dice quanto dovrebbe essere corta, il compilatore ne compone una più corta e il provider viene interpellato di nuovo. Un secondo rifiuto è normale e previsto — accorciare a una lunghezza può far finire un carattere dove la grammatica di quella destinazione non lo ammette, e il fatto che il provider lo dica è il modo in cui un compilatore che non conosce la grammatica di alcuna destinazione e un provider che la conosce raggiungono un accordo.

Ciò che non è normale è un provider che non accetta mai nulla: uno che indica una lunghezza, riceve un nome di quella lunghezza e lo rifiuta di nuovo. Lo scambio è limitato, e al raggiungimento del limite il build si ferma e nomina il provider anziché usare un nome su cui il provider non si è mai detto d’accordo. Un nome stabilito per rinuncia verrebbe apposto su risorse reali senza che nulla nell’output registri che non si è raggiunto alcun accordo, e la conseguenza emergerebbe al momento dell’applicazione anziché nel build che lo ha prodotto.

Messaggio emesso:

provider guest never accepted a component identity the compiler composed for it (provider guest "<provider>", refused <n> proposals, the last of them "<identity>"). report the defect to whoever maintains that provider plugin (il guest del provider non ha mai accettato un’identità di componente che il compilatore ha composto per esso (il guest del provider indicato ha rifiutato il numero di proposte indicato, l’ultima delle quali è l’identità indicata). segnala il difetto a chi mantiene quel plugin del provider)

Come risolvere: segnalalo a chi mantiene il plugin del provider nominato, citando l’ultima proposta dal messaggio. Non esiste alcuna modifica di authoring che lo aggiri: il compilatore ha già offerto ogni lunghezza che il provider ha chiesto. Se il provider è uno che mantieni tu, la verifica da fare è che un nome tagliato a un limite che esso indica sia un nome che poi accetta.

Required uses: socket not populated (Socket richiesto non popolato)

Un Component dichiara nel suo usesSchema un socket contrassegnato con required: true, e nulla nel build cabla una connessione su quel socket per una delle istanze di quel Component.

Tre superfici possono cablarlo, e l’arresto scatta solo quando tutte e tre sono vuote. Il blocco uses: proprio dell’istanza nell’Aggregate; una voce uses: per arco di una Release che nomina un target:, la quale crea la connessione in un socket dichiarato ma non legato; e l’insieme di connessioni che la composizione ha prodotto, che è ciò che risponde per un componente fornito da un Aggregate importato — il blocco uses: di un tale componente si trova nel documento proprio di quell’Aggregate, letto solo una volta assemblata la composizione. Poiché la terza superficie è l’ultima a essere completa, il controllo viene eseguito una volta che l’intera composizione esiste anziché mentre vengono letti i due documenti scritti, e pone la stessa domanda a ogni componente, qualunque documento lo abbia dichiarato.

Due strutture che sembrano dover popolare il socket non lo fanno. Una voce di Release che non nomina alcun target: configura una connessione che deve già esistere anziché crearne una, quindi non cabla nulla (e, dove porta infra:, viene segnalata dal proprio arresto più sopra). E il uses: di un’associazione di Feature nomina socket dichiarati sulla Feature associata, un insieme di socket separato su un’entità separata, quindi un’associazione non può mai popolare un socket proprio di un Component.

Messaggio emesso:

required uses socket not populated (Component, at .spec.components.<instance>.uses.<socket>, "<socket-name>", declared required by component type "<component-type>") (socket uses richiesto non popolato (Component, al percorso del socket, con il nome del socket, dichiarato richiesto dal tipo di componente indicato))

Il rilievo è posizionato sulla voce di socket che l’autore deve scrivere, .spec.components.<instance>.uses.<socket>. Il nome di istanza al suo interno è il nome che il componente porta nel documento che lo dichiara, quindi per un componente fornito da un Aggregate importato il localizzatore nomina una chiave contenuta nel file proprio di quell’Aggregate anziché il nome con prefisso che la composizione gli ha dato.

Ogni socket richiesto non popolato viene segnalato, su ogni componente: un solo build ti informa su tutti anziché solo sul primo.

Come risolvere: aggiungi una voce uses: per il socket richiesto, cablandola a una destinazione che il selector: del socket accetta; oppure cablalo dalla Release con una voce che nomina un target:. Se il socket non deve più essere richiesto, aggiorna lo usesSchema del Component per impostare required: false oppure rimuovi la dichiarazione required.

Sub-aggregate nesting depth exceeded (Profondità di annidamento dei sub-aggregati superata)

Una catena di importazioni di sub-aggregati supera la profondità massima di annidamento del compilatore. Il limite impedisce un appiattimento incontrollato di topologie profondamente annidate e impone una scomposizione architetturale oltre una soglia.

Messaggio emesso:

max sub-aggregate nesting depth exceeded: depth <depth> at prefix <flattened-prefix>. (profondità massima di annidamento dei sub-aggregati superata: la profondità indicata al prefisso appiattito indicato.)

Come risolvere: ristruttura la topologia dell’aggregato per ridurre l’annidamento. Una profondità di annidamento così elevata di solito indica che la struttura dell’Aggregate rispecchia la gerarchia organizzativa anziché la topologia di distribuzione — valuta di appiattire gruppi di sub-aggregati in sottosistemi paritetici all’interno di un unico Aggregate genitore.

Feature type mismatch between Aggregate and Release (Mancata corrispondenza del tipo di Feature tra Aggregate e Release)

L’Aggregate e la Release associano entrambi una funzionalità con lo stesso nome di istanza, ma ciascuno dichiara un type: diverso, e l’associazione della Release raggiunge il componente dai features: di un confine. Dove invece la Release la scrive sulla propria voce per il componente, lo stesso conflitto viene rifiutato prima e segnalato come E0153, sotto «A feature attached by both the Aggregate and the Release cannot be merged (Una funzionalità associata sia dall’Aggregate sia dalla Release non può essere unita)» più sopra.

Messaggio emesso:

feature type mismatch between Aggregate and Release (node <node-id>, attachment <instance-name>, existing type <type-in-aggregate> conflicts with <type-in-release>) (mancata corrispondenza del tipo di funzionalità tra Aggregate e Release (il nodo e l’associazione indicati, il tipo esistente nell’Aggregate è in conflitto con il tipo nella Release))

Come risolvere: togli il type: dalla Release (lo erediterà dall’Aggregate), oppure cambia uno dei due lati in modo che entrambi dichiarino lo stesso tipo. La Release può omettere type: o ripetere il tipo dell’Aggregate, ma non può sostituirne uno diverso.

Cyclic extends on Components or Features (Extends ciclico su Components o Features)

La catena extends: di un Component o la catena extends: di una Feature torna su sé stessa.

Messaggio emesso, con Feature al posto di Component quando a formare il ciclo è la catena di una Feature:

cyclic extends chain (Component <name>, rule extends). <entity> extends <reference>, which is already in the chain; remove the extends on <entity>, or point it at an entity outside the chain (catena extends ciclica (Component indicato, regola extends). L’entità estende il riferimento, che è già nella catena; rimuovi l’extends sull’entità, o puntalo a un’entità fuori dalla catena)

Come risolvere: apri l’entità che l’arco nomina — che lungo una catena di tre o più non è l’entità nominata all’inizio del messaggio — e rimuovi il suo extends: o fallo puntare altrove.

A component the composition holds is placed in no boundary (Un componente contenuto nella composizione non è collocato in alcun confine)

Una Release colloca un componente in un confine in due modi, e ciascuno dei due vale. Nomina il componente sotto i components di un confine, indirizzandolo con l’id che il componente porta una volta appiattita l’intera composizione. Oppure instrada in un confine, sotto aggregates, il modulo che fornisce il componente, il che colloca in una volta sola ogni componente che quel modulo contiene.

Un componente che non raggiunge nessuno dei due viene renderizzato al di fuori di ogni confine che la Release ha dichiarato. La sua directory di output, la sua sync wave, le sue annotazioni e il suo infra per componente non provengono allora da nessuna parte — e il build altrimenti riuscirebbe, emetterebbe gli artifact e non direbbe nulla del fatto che la configurazione dell’operatore non gli è mai stata applicata. Due componenti separati da quella linea vengono inoltre renderizzati in output diversi e perdono l’ordinamento che hanno quando sono collocati insieme.

Due strutture deliberatamente non vi incorrono. Una Release che dichiara components di primo livello anziché confini con nome colloca tutto ciò che nomina: normalizzare una tale Release le dà un confine proprio che contiene esattamente quei componenti. E un componente il cui intero modulo la Release non ha collocato da nessuna parte viene invece segnalato una sola volta rispetto al modulo, sotto la voce seguente — un errore, un rimedio, una chiave da modificare — anziché una volta per ogni componente la cui dichiarazione propria è corretta.

Messaggio emesso. Il valore alla fine è l’id che il componente porta una volta appiattita la composizione, che per un componente fornito da un modulo è il nome di quel modulo, un punto e il nome proprio del componente:

component placed in no boundary: name it under a boundary’s components, or place the sub-module that contributes it under aggregates (Release <name>, at <authored key>, "<component-id>") (componente non collocato in alcun confine: nominalo tra i componenti di un confine, oppure colloca tra gli aggregati il sottomodulo che lo fornisce (con la Release, la chiave scritta e l’id del componente indicati))

Come risolvere: nomina il componente sotto i components di un confine, usando esattamente l’id che il messaggio cita — per un componente fornito da un modulo è l’id con prefisso, non il nome scritto all’interno del file proprio del modulo. Oppure, dove l’intero modulo appartiene a un solo confine, instradalo lì sotto aggregates e lascia che ogni componente che contiene venga collocato in una volta sola.

A sub-module’s components are placed in no boundary (I componenti di un sottomodulo non sono collocati in alcun confine)

La forma su scala di modulo della regola precedente: un modulo che la composizione ha incluso ha fornito componenti, e nessun confine ne contiene alcuno. Viene segnalata una sola volta per il modulo anziché una volta per componente, perché un modulo non collocato da nessuna parte è un unico errore di authoring con un unico rimedio in un’unica chiave — e segnalarlo per componente nominerebbe componenti le cui dichiarazioni proprie sono perfettamente corrette.

La regola legge la collocazione anziché la grafia, quindi un modulo i cui componenti sono nominati ciascuno singolarmente sotto i components di un confine è collocato e passa: rifiutarlo per mancanza di una voce di instradamento respingerebbe una forma di scrittura che il linguaggio ammette. Passa anche un modulo collocato solo in parte — quali dei suoi componenti abbiano voci proprie è una questione della regola sui componenti, e quelli che ha tralasciato vengono segnalati lì, ciascuno alla propria chiave.

Un modulo che non ha fornito alcun componente non vi incorre: non c’è nulla da collocare. Né vi incorre uno rimosso da un interruttore active: falso, che non è mai stato composto affatto.

Messaggio emesso, posizionato sulla voce aggregates che ha dichiarato il modulo, sotto il nome locale che il documento importatore ha scritto:

sub-module placed in no boundary: route it into a boundary under aggregates, or name its components there under components (Release <name>, at <authored key>, "<module-path>") (sottomodulo non collocato in alcun confine: instradalo in un confine tra gli aggregati, oppure nomina lì i suoi componenti tra i componenti (con la Release, la chiave scritta e il percorso del modulo indicati))

Come risolvere: aggiungi una voce aggregates per il modulo sotto il confine a cui appartiene, il che colloca ogni componente che fornisce. Oppure, dove i suoi componenti appartengono a confini diversi, nomina ciascuno di essi sotto il confine a cui appartiene, usando gli id con prefisso che portano una volta appiattiti.

A boundary names a component the composition does not hold (Un confine nomina un componente che la composizione non contiene)

Il corrispettivo per eccesso di nomi delle due regole precedenti, e una questione separata anziché un ramo dell’una o dell’altra: quelle chiedono di un componente se qualcosa lo abbia collocato, questa chiede di una voce scritta dalla Release se qualcosa le corrisponda. Nessuna delle due implica l’altra. Una Release può nominare un componente che non esiste mentre ogni componente che esiste è collocato correttamente, e può lasciare non collocato un componente reale mentre ogni voce che ha scritto si risolve.

La voce che non nomina nulla non configura nulla: il suo directory, subDirectory, syncWave, le sue annotazioni e il suo infra per componente sono scritti per un componente che non c’è, quindi nulla viene renderizzato sotto di essi e il build altrimenti riuscirebbe con la configurazione dell’operatore silenziosamente inerte.

Un confine nomina un componente in due modi, ed entrambi vengono controllati. Sotto components, una voce indirizza il componente con l’id che porta una volta appiattita la composizione — quindi un componente fornito da un modulo si scrive con il prefisso di quel modulo davanti al proprio nome. All’interno di una voce di instradamento aggregates, una voce indirizza il componente con il nome locale che porta all’interno di quel modulo, che si risolve nello stesso id. Il messaggio cita l’id che la voce ha indirizzato, che sull’asse instradato non è il nome che il file scrive: il file porta la metà locale e il modulo fornisce il resto.

Un sottosistema non contribuisce in nulla all’id di un componente, quindi un componente dichiarato all’interno di un sottosistema si indirizza con il suo nome semplice. Una voce scritta come se il sottosistema facesse parte dell’id non indirizza nulla e incorre in questa regola.

Un componente disattivato da un interruttore active: falso non vi incorre. Disattivare un componente è un atto di authoring, e non ci si aspetta che la Release che lo configura venga riscritta nella stessa modifica — rifiutare la voce renderebbe l’interruttore inutilizzabile finché una qualsiasi Release nominasse il componente.

Messaggio emesso:

boundary names a component the composition does not hold: correct the name, or remove the entry (Release <name>, at <authored key>, "<addressed id>") (il confine nomina un componente che la composizione non contiene: correggi il nome, oppure rimuovi la voce (con la Release, la chiave scritta e l’id indirizzato indicati))

Come risolvere: confronta l’id che il messaggio cita con i componenti che la composizione contiene effettivamente. Un prefisso di modulo mancante e un nome di sottosistema scritto nell’id sono le due cause comuni; togli il sottosistema, aggiungi il prefisso del modulo o correggi la grafia. Dove la voce è rimasta da un componente che è stato poi rimosso o rinominato, eliminala.

A uses edge targets a component an active: toggle removed (Un arco ha come destinazione un componente rimosso da un interruttore)

Il fratello dell’arresto per destinazione pendente più sopra, segnalato separatamente perché all’autore venga detto perché la destinazione manca. La destinazione non è assente perché non sia mai stata dichiarata — è dichiarata, ed è stata deliberatamente rimossa da questo build perché il suo interruttore active: si è risolto in false, portando con sé i propri archi. Un componente sopravvissuto dipende ancora da essa, e lasciar sparire l’arco lascerebbe silenziosamente vuoti i valori iniettati di quel consumatore al momento della distribuzione.

Messaggio emesso. Prima viene il rifiuto, poi la destinazione che l’interruttore ha rimosso e il socket in cui la connessione è stata cablata — poi cosa fare al riguardo:

uses edge target was pruned because its active toggle resolved to false ("<target>", wired into socket "<socket>"). Keep the target’s active toggle true, or drop the dependency on it. (la destinazione dell’arco uses è stata rimossa perché il suo interruttore active si è risolto in false: la destinazione indicata, cablata nel socket indicato. Mantieni a true l’interruttore della destinazione, oppure elimina la dipendenza da essa.)

Il rilievo è posizionato sulla voce scritta a cui si riferisce, sugli stessi percorsi che nomina l’arresto per destinazione pendente più sopra, e ogni connessione non valida viene segnalata anziché solo la prima.

Come risolvere: decidi quale dei due appartiene a questo ambiente. Riattiva la destinazione — dove il suo interruttore legge un parametro, ciò significa fornire il parametro per questa Release. Oppure subordina il consumatore allo stesso interruttore, così i due escono insieme e nessun arco resta a puntare verso il nulla. Oppure, dove il consumatore davvero non ne ha più bisogno, rimuovi l’arco dal blocco uses: del consumatore.

A uses target names a module’s component the module does not export (Una destinazione di arco nomina un componente di un modulo che il modulo non esporta)

Un modulo pubblica la propria interfaccia sotto exportedComponents:, e un documento che importa il modulo raggiunge i componenti del modulo solo attraverso quei nomi: il nome del modulo, un punto e uno dei suoi alias. Una destinazione uses: che raggiunge un componente all’interno di un modulo in qualsiasi altro modo — con il nome del componente all’interno del modulo, oppure con un percorso che attraversa il modulo fino a un modulo annidato al suo interno — arresta il build, perché la connessione si legherebbe a qualcosa che l’autore del modulo non ha pubblicato ed è libero di rinominare o rimuovere. Il blocco uses: proprio di un componente, quello di un’associazione e una connessione cablata da una Release vi sono soggetti allo stesso modo. In quali moduli entri una connessione si legge dal punto in cui si trova il suo consumatore, quindi una connessione tra due componenti di uno stesso modulo — compresa una Release che li cabla l’uno all’altro — non attraversa alcuna interfaccia e non viene rifiutata. Una destinazione che non corrisponde ad alcun componente viene invece segnalata dall’arresto per destinazione pendente, così un nome digitato male viene segnalato una sola volta.

Messaggio emesso. Prima viene il rifiuto, poi la destinazione così come è scritta, il modulo in cui entra e gli alias che quel modulo esporta, e il socket — poi cosa fare al riguardo:

uses edge target names a component its module does not export ("<target>", module "<module>", which exports "<aliases>", wired into socket "<socket>"). Name the component through one of the module’s exported aliases, or list it under the module’s exportedComponents. (la destinazione dell’arco uses nomina un componente che il suo modulo non esporta: la destinazione, il modulo, gli alias che esporta e il socket in cui è cablata, indicati. Nomina il componente tramite uno degli alias esportati dal modulo, oppure elencalo tra i componenti esportati del modulo.)

Un modulo che non esporta nulla viene indicato come esportante "nothing". Il rilievo è posizionato sulla voce scritta nel documento che ha tracciato la connessione.

Come risolvere: nomina il componente tramite un alias che il modulo esporta — finance-db-subsystem.primary_db anziché finance-db-subsystem.internal-pg-primary — oppure, dove sei tu l’autore del modulo e intendi pubblicare il componente, elencalo sotto gli exportedComponents del modulo, con il suo nome proprio se è quello il nome che gli importatori devono usare.

An active: toggle does not resolve to true or false (Un interruttore non si risolve in true o false)

Un interruttore active: raggiunge il costruttore del grafo già risolto in un letterale — un booleano scritto direttamente, oppure un riferimento a parametro in cui i valori della Release sono stati sostituiti prima che il documento venisse letto. Viene poi letto in modo rigoroso: un letterale che non è un booleano ferma il build anziché ricadere su un valore predefinito qualsiasi. La regola è la stessa per l’interruttore di un componente e per quello di un modulo.

Un letterale vuoto è il caso che vale la pena nominare, perché è ciò che produce un parametro non soddisfatto. Un interruttore che legge {{ .parameters.<key> }} si risolve nel nulla finché quel parametro non ha un valore, e leggere il nulla come «presente» distribuirebbe proprio l’entità che l’autore ha subordinato al parametro. Solo un interruttore che nessuno ha scritto vale per impostazione predefinita come presente, e ciò si legge dall’assenza dell’interruttore anziché dal suo valore — ed è per questo che scrivere active: senza nulla dopo non equivale a omettere la chiave.

Messaggio emesso:

active toggle did not resolve to a boolean (node "<node>", active resolved to "<value>") (l’interruttore active non si è risolto in un booleano (il nodo indicato, con active risolto nel valore indicato))

e, dove si è risolto nel nulla, con l’indicazione che nomina la causa abituale:

active toggle did not resolve to a boolean (node "<node>", active resolved to ""). a toggle reading a parameter resolves to nothing until that parameter is fulfilled (l’interruttore active non si è risolto in un booleano (il nodo indicato, con active risolto in una stringa vuota). un interruttore che legge un parametro si risolve nel nulla finché quel parametro non viene soddisfatto)

Come risolvere: scrivi true o false. Dove l’interruttore legge un parametro, fornisci quel parametro nella Release, oppure dagli un default: dove è dichiarato nell’Aggregate, così ogni ambiente ha una risposta. Per rendere un’entità presente incondizionatamente, rimuovi la chiave active: anziché lasciarla vuota.

A module a composition imports cannot be loaded, or imports itself (Un modulo che una composizione importa non può essere caricato, oppure importa sé stesso)

Un Aggregate compone altri Aggregates nominandoli sotto aggregates:, e ciascuno viene caricato e percorso a sua volta, così i suoi componenti entrano nel grafo. Due cose qui fermano quel percorso.

Il modulo non può essere caricato affatto — il riferimento non si risolve in nulla che il catalogo possa restituire, oppure il documento dietro di esso non può essere letto. Il motivo fornito dal caricatore viene riportato sotto l’arresto anziché esservi incorporato, così ciò che è fallito viene segnalato con le parole stesse del caricatore.

Oppure il modulo nomina un tipo già presente nella catena che si sta percorrendo. Espanderlo riprodurrebbe la catena che lo contiene, senza fine. Viene segnalato nel punto in cui il riferimento chiude il ciclo, nominando sia il tipo sia la posizione che occupa nella composizione.

Messaggio emesso, per un riferimento circolare:

sub-aggregate load failed (circular sub-aggregate reference "<module-type>", at "<path in the composition>") (caricamento del sub-aggregato non riuscito (riferimento circolare a un sub-aggregato, con il tipo di modulo e il percorso nella composizione indicati))

e per un errore di caricamento, dove l’arresto si legge come la sola frase, posizionato sul percorso del modulo, con il motivo proprio del caricatore sotto di esso:

sub-aggregate load failed (caricamento del sub-aggregato non riuscito)

Come risolvere: per un errore di caricamento, leggi il motivo sotto l’arresto — un nome o una versione a cui il catalogo non sa rispondere è il caso comune, e la correzione va nella voce aggregates: che lo nomina. Per un riferimento circolare, spezza il ciclo: il percorso nel messaggio è il punto in cui la catena si chiude, e uno dei moduli lungo di essa deve smettere di importare quello che lo importa. Dove due moduli hanno davvero bisogno ciascuno dei componenti dell’altro, la parte condivisa appartiene a un terzo modulo che entrambi importano.

Two instances flatten to one identifier (Due istanze si appiattiscono in un unico identificatore)

Comporre un Aggregate appiattisce ogni componente in un unico insieme, e un componente fornito da un modulo porta il nome di quel modulo, un punto e il proprio nome. L’insieme si rifiuta di contenere due voci sotto un unico identificatore: la seconda sostituirebbe la prima, e uno dei due componenti sparirebbe dall’output senza che nulla venga detto al riguardo.

Questo arresto è quello sollevato mentre i componenti di un modulo vengono uniti, e la superficie di authoring non offre i nomi che lo produrrebbero. Ogni componente che un modulo fornisce porta il nome di quel modulo davanti al proprio; un nome di istanza si scrive con lettere, cifre, - e _, quindi non può contenere il punto con cui i due vengono uniti, e due identificatori costruiti da nomi di modulo diversi non possono coincidere. Due moduli importati sotto un unico nome sono un’unica chiave duplicata, e il documento viene rifiutato al caricamento. Quindi questo fa da rete di sicurezza per una composizione assemblata da qualcosa di diverso dal normale percorso di authoring, e imbattersi in uno merita una segnalazione anziché un aggiramento.

Due componenti di uno stesso Aggregate che raggiungono un unico identificatore sono un arresto diverso, e la normale scrittura lo produce — vedi Two subsystems declare a component under one name (Due sottosistemi dichiarano un componente con un unico nome) più sotto.

Messaggio emesso:

flattened node ID collision: rename one of the colliding instances so their flattened IDs differ (id "<identifier>", path "<path in the composition>", collides with existing entry from "<the other contributor>") (collisione di ID di nodo appiattiti: rinomina una delle istanze in collisione in modo che i loro ID appiattiti differiscano (l’identificatore e il percorso nella composizione indicati, in collisione con la voce esistente proveniente dall’altro contributore indicato))

Come risolvere: rinomina una delle due istanze che il messaggio nomina, nel documento che la dichiara e in ogni voce di Release che la indirizza.

Two subsystems declare a component under one name (Due sottosistemi dichiarano un componente con un unico nome)

I sottosistemi raggruppano i componenti di un Aggregate per chi legge e per ciò che ricade a cascata su di essi; non qualificano il nome a cui un componente risponde. Un componente dichiarato sotto subsystems.frontend si indirizza come api, non come frontend.api, e uno fornito da un modulo porta il nome di quel modulo anziché quello del sottosistema. Quindi due sottosistemi di uno stesso Aggregate possono dichiarare ciascuno un componente chiamato api, e i due rispondono allora allo stesso identificatore.

Il documento è ben formato — i due sono chiavi separate in blocchi separati, ed è esattamente per questo che nulla lo rifiuta prima — ma solo un componente può portare un identificatore. Il build si ferma anziché tenere quello letto per ultimo e renderizzare come se fosse stato dichiarato un solo componente.

Lo stesso nome due volte all’interno di uno stesso sottosistema è un errore diverso: sono due voci sotto un’unica chiave, e il documento viene rifiutato mentre viene letto.

Messaggio emesso:

components in different subsystems take the same identity: rename one of them, since a subsystem contributes nothing to a component’s identity (Aggregate, at .spec.subsystems.<second>.components.<identifier>, "<identifier>", declared under subsystems "<first>, <second>") (componenti in sottosistemi diversi assumono la stessa identità: rinominane uno, poiché un sottosistema non contribuisce in nulla all’identità di un componente (con l’Aggregate, il percorso e l’identificatore indicati, dichiarato sotto i sottosistemi indicati))

Come risolvere: rinomina uno dei due componenti, nel documento che lo dichiara e in ogni voce di Release che lo indirizza. Dove i due sono davvero lo stesso componente desiderato in due posti, dichiaralo una sola volta e dipendi da esso dall’altro sottosistema. Rinominare il sottosistema non aiuta: il sottosistema non fa parte del nome.

A re-published component alias points back at itself (Un alias di componente ripubblicato punta a sé stesso)

Un modulo pubblica una parte di sé esportando componenti sotto alias, e un Aggregate che lo importa può ripubblicare uno di quegli alias sotto un nome proprio. Risolvere un tale alias segue la catena delle ripubblicazioni fino al componente che in ultima istanza nomina, così un arco che punta al nome pubblico raggiunge un componente reale.

Una catena che torna su un alias prima di raggiungere un componente non arriva mai a destinazione. Il percorso si ferma anziché seguirla all’infinito, e nomina la catena che ha percorso, così l’anello che chiude il ciclo è visibile.

Nulla di ciò che puoi scrivere produce una catena del genere. L’albero delle importazioni è aciclico, e ogni anello nomina qualcosa annidato più in profondità dell’anello precedente, quindi una catena assemblata dalle importazioni scende e finisce. Questo fa quindi da rete di sicurezza per una tabella di alias assemblata da qualcosa di diverso dal normale percorso di authoring, anziché per una struttura che un Aggregate può dichiarare.

Messaggio emesso:

re-exported component alias forms a cycle (alias chain <first> -> <second> -> <first>) (l’alias di componente riesportato forma un ciclo (con la catena di alias indicata))

Come risolvere: nulla nei tuoi file lo produce, e non esiste alcuna modifica di authoring che lo risolva. Segnalalo con il comando che hai eseguito e la catena di alias che il messaggio nomina, che è il dettaglio che indica dove si è chiuso il ciclo.

An Aggregate reached graph building without being normalised (Un Aggregate è arrivato alla costruzione del grafo senza essere stato normalizzato)

Un Aggregate scritto con i componenti al primo livello e uno scritto con sottosistemi con nome assumono la stessa forma mentre vengono letti: i componenti di primo livello vengono incorporati in un sottosistema fornito dal compilatore, e il primo livello viene svuotato. È questa incorporazione a permettere a tutto ciò che segue di porre un’unica domanda a un’unica forma.

Un Aggregate che arriva alla costruzione del grafo con entrambi popolati non è stato prodotto da quella lettura. Le due forme si escludono a vicenda dove vengono scritte — un documento che le dichiara entrambe viene rifiutato al caricamento — e l’incorporazione è ciò che le rende un’unica forma in seguito, quindi nulla di ciò che un autore può scrivere arriva fin qui. Fa da rete di sicurezza per un Aggregate assemblato da qualcosa di diverso dal normale percorso di caricamento, e imbattersi in uno merita una segnalazione anziché un aggiramento.

Il suo messaggio inizia così:

aggregate reached topology un-normalized (non-empty root components alongside a synthesized default subsystem) (l’aggregato ha raggiunto la topologia senza essere normalizzato (componenti radice non vuoti accanto a un sottosistema predefinito sintetizzato))

e prosegue con il percorso di costruzione che il compilatore si aspetta, che è una nota per chi sta eseguendo il debug del build anziché un’istruzione di authoring.

Come risolvere: nulla nei tuoi file lo produce, e non esiste alcuna modifica di authoring che lo risolva. Segnalalo con il comando che hai eseguito.

A label-transform plugin’s patch reaches outside node labels (La patch di un plugin label-transform va oltre le etichette dei nodi)

Un plugin di governance associato in un ruolo label-transform riceve una proiezione del grafo — una voce per nodo, con le etichette di quel nodo e i valori che la sua istanza dichiara, omesso ogni valore che il suo Component dichiara sensibile — e restituisce patch sulle etichette dei nodi. L’host le applica solo alle etichette e poi verifica che ciò che è tornato sia ancora quella vista delle etichette: gli stessi nodi, ciascuno con sole etichette, ogni valore di etichetta una stringa.

Qualsiasi altra cosa viene rifiutata e il build si ferma. Aggiungere o rimuovere un nodo, o cambiare un campo di un nodo diverso dalle sue etichette, è esattamente la comparsa silenziosa di infrastruttura che nessuno ha dichiarato — quindi, anziché assorbire una modifica che il ruolo non copre, il build dice quale regola di confinamento la patch ha violato. Le etichette sono l’intera superficie del ruolo, e un operatore che ha associato il plugin ha dichiarato questo e nulla di più.

Messaggi emessi. La patch è stata rifiutata prima di essere applicata:

mutator patch rejected: patch <n> does not decode as a JSON Patch document: <what the reader could not do> (patch del mutatore rifiutata: la patch indicata non si decodifica come documento JSON Patch: ciò che il lettore non è riuscito a fare) mutator patch rejected: patch <n> does not apply to the node-label surface: <what the patch engine refused> (patch del mutatore rifiutata: la patch indicata non si applica alla superficie delle etichette dei nodi: ciò che il motore delle patch ha rifiutato)

oppure il risultato della sua applicazione non era la vista che l’host aveva consegnato:

mutator patch rejected: mutated node set changed size (a mutator may not add or remove nodes) (patch del mutatore rifiutata: l’insieme di nodi mutato ha cambiato dimensione (un mutatore non può aggiungere né rimuovere nodi)) mutator patch rejected: mutated node set introduced node "<node>" (a mutator may not add nodes) (patch del mutatore rifiutata: l’insieme di nodi mutato ha introdotto il nodo indicato (un mutatore non può aggiungere nodi)) mutator patch rejected: node "<node>" gained a field outside "labels" (a mutator may only touch labels) (patch del mutatore rifiutata: il nodo indicato ha acquisito un campo al di fuori delle etichette (un mutatore può toccare solo le etichette)) mutator patch rejected: node "<node>" lost its "labels" field (patch del mutatore rifiutata: il nodo indicato ha perso il suo campo delle etichette) mutator patch rejected: node "<node>" carries a non-string label value after patching: <what the reader found> (patch del mutatore rifiutata: il nodo indicato porta un valore di etichetta che non è una stringa dopo l’applicazione della patch: ciò che il lettore ha trovato)

Come risolvere: l’errore è del plugin, non dei tuoi documenti. Correggilo in modo che ogni operazione che restituisce indirizzi una voce sotto le labels di un nodo e imposti solo valori stringa — un valore di etichetta numerico o booleano è il caso comune, poiché la superficie accetta solo stringhe. Rimuovere l’associazione da plugins.governance è il modo immediato per sbloccare un build mentre il plugin viene corretto.

Omissione intenzionale: non è richiesto che la topologia sia aciclica

Aggrega ammette cicli nella topologia: non richiede che il grafo delle dipendenze sia un grafo aciclico orientato. Architetture agent-to-agent, pattern di callback e coppie con autenticazione reciproca producono tutti archi ciclici, e il compilatore li accetta. L’ordinamento al momento della distribuzione è compito del renderer (tramite un syncWave per confine o un equivalente), non del grafo IR.

Durante la verifica dei contratti di inject

Il compilatore percorre ogni blocco inject: — sia self-inject (un Component che inietta in sé stesso) sia uses-inject (cablaggio tra Component) — e convalida il contratto di consegna rispetto allo schema provides: del Component di destinazione, alla partizione delle etichette della Feature e all’insieme delle chiavi di consegna dichiarate. Una chiave from: su un blocco scritto dal componente proprio dell’Aggregate viene controllata non appena il catalogo è risolto, quindi fallisce sulla riga che hai scritto; una sul blocco di un componente fornito da un modulo viene controllata una volta costruita la composizione che importa il modulo, e fallisce sulla riga nel documento proprio del modulo; una chiave from: su una connessione fornita da una Feature associata viene controllata una volta che ogni superficie in grado di tracciare una connessione ha dato il proprio contributo, che è il primo momento in cui una tale connessione esiste e può essere controllata.

Inject from key is not in the target’s provides (La chiave di inject non figura tra ciò che la destinazione fornisce)

Una voce inject: fa riferimento a una chiave from: che la sorgente da cui legge non pubblica: lo schema provides: del Component di destinazione per il blocco proprio di un componente o per una connessione, e la FeatureRecipe della Feature allegata per il blocco inject: proprio di una Feature allegata.

Il controllo si applica ovunque sia stata scritta la connessione. Una connessione uses: raggiunge la topologia costruita da più di una superficie di authoring — il blocco uses: proprio di un Component e il blocco uses: di una Feature associata a esso, che quell’associazione sia scritta sul componente, su un sottosistema, su un confine di Release o sulla voce di componente di un confine di Release — e la stessa chiave scritta male viene rifiutata su ciascuna di esse. La diagnostica punta al blocco il cui autore l’ha scritta: la voce uses: propria di un’associazione, nel punto in cui l’associazione stessa è stata dichiarata, anziché il blocco uses: del componente consumatore, che per una connessione fornita non contiene nulla.

Rispetto a che cosa si risolve il riferimento dipende da dove si trova. Un from: di self-inject a livello di Component si risolve rispetto al provides: proprio di quello stesso Component. Un from: su una connessione uses: si risolve rispetto al provides: del componente a cui punta quella connessione — e dove due superfici scrivono un solo socket e un solo alias, ciascuna connessione si risolve rispetto alla destinazione che essa stessa nomina, nello stesso build che rifiuta la coppia perché condivide un alias. Un Component che non dichiara alcun provides: rifiuta ogni riferimento from: rivolto a esso.

Il blocco inject: proprio di una Feature allegata. Lì un from: si risolve rispetto alle chiavi che la FeatureRecipe della Feature pubblica nel suo provides:, così come valutate per il componente a cui la Feature è allegata, e viene verificato quando si esegue il rendering di quel componente. Una chiave che la FeatureRecipe non pubblica non metterebbe nulla nell’ambiente, nel file o nell’argomento del componente, quindi la build si arresta — a meno che la FeatureRecipe non legga essa stessa le voci della Feature allegata, in .inject, in un template che valuta rispetto al contesto di rendering proprio della Feature allegata — quello che porta .inject: la sua mappatura dei valori, il suo carico di lavoro, i suoi artefatti, le sue omissioni o il with: o il when: di un passo della pipeline, scritti inline o importati. I suoi locals:, provides:, source: e assertions: non portano .inject, e il suo injectMapping: viene valutato rispetto al contesto del componente, quindi una lettura in uno qualsiasi di essi non conta. Una FeatureRecipe di questo tipo riceve ogni voce così come è scritta e la consegna a modo suo, quindi le sue voci non vengono rifiutate, e una chiave che non pubblica non consegna nulla attraverso la consegna propria del componente e resta a disposizione della FeatureRecipe. Se una FeatureRecipe legga .inject si decide dai percorsi che i suoi template nominano: un template che trasmette l’intero proprio contesto (toJson .) o che raggiunge le voci attraverso una funzione come index . "inject" non conta come lettura delle voci, e le sue voci che nominano una chiave non pubblicata vengono rifiutate. Una Feature allegata a un confine la cui FeatureRecipe esegue il rendering una sola volta per quel confine viene verificata rispetto a quell’unica valutazione; dove nessun confine che contiene il componente ne ha prodotta una, non c’è nulla rispetto a cui verificare le sue chiavi e queste non vengono rifiutate. Un from: che nomina una chiave pubblicata consegna come prima. Il rilievo è posizionato sulla voce propria della Feature allegata, nel documento che l’ha scritta — .spec.components.<component>.features.<attachment> nell’Aggregate, per esempio — e una voce la cui chiave di consegna è già detenuta anche da un’altra sorgente inject viene segnalata anche sotto «An attachment delivers a key another inject source already claimed (Un allegato consegna una chiave già rivendicata da un’altra sorgente inject)», poiché ciascuna richiede la propria correzione.

Sul blocco inject: proprio di un componente una voce value: porta un letterale e non viene risolta rispetto a nulla, quindi un letterale che per caso somiglia a una chiave provides non viene rifiutato lì; su una connessione una voce value: viene rifiutata, come descrive più sotto «An inject: entry on a connection carries a literal (Una voce di inject su una connessione porta un letterale)». Solo from: nomina una chiave.

La superficie uses: per arco propria della Release porta target e infra e nessun inject:, quindi una connessione cablata lì non impone alcuna consegna e non ha alcuna chiave from: da controllare.

Messaggio emesso, per un from: letto sul blocco inject: proprio di un Component. Prima viene il rifiuto, poi la chiave in errore, il tipo di componente rispetto a cui è stata risolta e le chiavi dichiarate da quel tipo in ordine — le alternative tra cui scegliere:

invalid inject key: the from-key must name a provides key its source publishes (Aggregate <name>, at .spec.components.<component>.inject.<mechanism>.<delivery-key>, "<from-key>", "<component-type>", "<key-1>", "<key-2>") (chiave inject non valida: la from-key deve nominare una chiave provides pubblicata dalla sua sorgente (con l’Aggregate, il percorso, la from-key, il tipo di componente e le chiavi dichiarate indicati))

Per un from: letto su una connessione uses:, lo stesso rifiuto viene per primo, e il meccanismo e la chiave di consegna sotto cui è stata scritta la voce precedono la chiave in errore:

invalid inject key: the from-key must name a provides key its source publishes (Aggregate <name>, at .spec.components.<component>.uses.<socket>.<alias>, "<mechanism>", "<delivery-key>", "<from-key>", "<component-type>", "<key-1>") (chiave inject non valida: la from-key deve nominare una chiave provides pubblicata dalla sua sorgente (con l’Aggregate e la connessione indicati, il meccanismo, la chiave di consegna, la from-key, il tipo di componente e la chiave dichiarata))

Per un from: letto sul blocco inject: proprio di una Feature allegata, la chiave errata viene per prima, poi l’in: e il meccanismo della voce, la FeatureRecipe rispetto a cui è stata risolta e, in ordine, ogni chiave che quella FeatureRecipe pubblica:

invalid inject key: the from-key must name a provides key its source publishes (Aggregate <name>, at .spec.components.<component>.features.<attachment>, "<from-key>", in "<in>", mechanism "<mechanism>", FeatureRecipe "<feature-recipe>", publishes "<key-1>", publishes "<key-2>") (chiave inject non valida: la from-key deve nominare una chiave provides pubblicata dalla sua sorgente (con l’Aggregate, il percorso, la from-key, l’in, il meccanismo, la FeatureRecipe e le chiavi che pubblica indicati))

Quando la destinazione non dichiara alcuna chiave provides: non ci sono alternative da elencare, quindi il messaggio termina dopo il tipo di componente — oppure, sul blocco di una Feature allegata, dopo la FeatureRecipe.

Come risolvere: cambia la chiave from: in modo che corrisponda a una delle chiavi dichiarate elencate nel messaggio, oppure estendi lo schema provides: del Component di destinazione per dichiarare la chiave di cui hai bisogno. Sul blocco di una Feature allegata, cambia la chiave from: in una che la FeatureRecipe pubblica, oppure — dove la FeatureRecipe è tua — pubblica la chiave nel suo provides:, oppure falle leggere essa stessa la voce in .inject se consegna il valore a modo suo.

Required feature not attached (Funzionalità richiesta non associata)

Il Component dichiara un mandato di presenza — un’annotazione features.aggrega.ai/requiredType.<label> — che nomina un tipo di Feature non presente tra le associazioni con cui finisce questa istanza di componente, contando ogni livello: i blocchi a livello di componente e di sottosistema dell’Aggregate, i blocchi a livello di confine e di componente della Release, e l’espansione guidata dalle annotazioni.

Messaggio emesso:

missing required feature: attach a Feature of the required type to the component (<required-type>, required by component type <component-type>, under the requirement label <label>) (funzionalità richiesta mancante: associa al componente una Feature del tipo richiesto (il tipo richiesto indicato, richiesto dal tipo di componente indicato, sotto l’etichetta di requisito indicata))

I tre valori sono il tipo di Feature che il mandato esige — che la frase precedente nomina già, quindi compare senza didascalia — poi il tipo di componente che dichiara il mandato e l’etichetta che il mandato porta, ciascuno con una didascalia così che un lettore possa distinguere due riferimenti a entità. Un componente che esige due tipi diversi segnala due messaggi che differiscono, e a due componenti che dichiarano il mandato da tipi diversi viene detto quale tipo ha avanzato ciascuna richiesta. Il rilievo è posizionato sulla chiave propria del componente sotto components:, e un componente scritto all’interno di un sottosistema è posizionato prima sotto la chiave di quel sottosistema.

Il nome sotto cui è scritta un’associazione qui non conta: il mandato chiede se un’associazione del tipo nominato sia presente o meno. Legare uno slot lo soddisfa, e lo stesso fa un’associazione sotto qualsiasi altro nome.

Come risolvere: associa una Feature del tipo richiesto al componente nell’Aggregate o nella Release, oppure a un livello più ampio da cui il componente eredita. Se il Component non deve più richiederla, rimuovi l’annotazione del mandato dalla sua dichiarazione di catalogo.

Malformed attachment requirement (Requisito di associazione malformato)

La dichiarazione di un mandato di presenza non può essere valutata. Il valore di un’annotazione è una stringa opaca, quindi nulla ne convalida la forma prima che il compilatore la legga: un valore che non è un URI di tipo Feature, o una chiave che nomina la famiglia di mandati senza un’etichetta dopo il prefisso, viene segnalato come una dichiarazione difettosa anziché come un requisito non soddisfatto — un refuso non deve mai apparire come un requisito soddisfatto.

Messaggi emessi:

malformed attachment requirement (<key>, declared by component type <component-type>, which cannot be evaluated because the value must be a Feature type URI of the form <publisher>/<name> in lower-case kebab segments, as in core/prometheus-exporter). Correct that annotation on the component type’s catalog entity. (requisito di associazione malformato (la chiave indicata, dichiarata dal tipo di componente indicato, che non può essere valutata perché il valore deve essere un URI di tipo Feature nella forma editore/nome in segmenti kebab minuscoli, come nell’esempio indicato). Correggi quell’annotazione sull’entità di catalogo del tipo di componente.)

malformed attachment requirement (<key>, declared by component type <component-type>, which cannot be evaluated because the key needs a label naming the requirement, as in features.aggrega.ai/requiredType.database). Correct that annotation on the component type’s catalog entity. (requisito di associazione malformato (la chiave indicata, dichiarata dal tipo di componente indicato, che non può essere valutata perché la chiave ha bisogno di un’etichetta che nomini il requisito, come nell’esempio indicato). Correggi quell’annotazione sull’entità di catalogo del tipo di componente.)

Il messaggio inizia con la chiave dell’annotazione — la dichiarazione di cui tratta l’arresto — e dopo di essa nomina il tipo di componente la cui dichiarazione è difettosa, così nomina l’entità da correggere anche se il rilievo è posizionato sull’istanza di componente che usa quel tipo: l’istanza è dove lo vedi, e l’entità di catalogo è dove si trova il rimedio.

Questo arresto viene sollevato non appena la composizione è assemblata, cioè prima di ogni controllo che legge il grafo finito. Un build con un mandato difettoso lo segnala quindi da solo: i controlli che verrebbero eseguiti dopo non vengono raggiunti, perché ragionano su ciò che dice la dichiarazione e la dichiarazione non può essere letta. Correggilo e riesegui il build per vedere il resto.

Come risolvere: correggi l’entità di catalogo del Component. Il rimedio è nel catalogo, non nell’Aggregate — ed è per questo che questo arresto è distinto da «Required feature not attached (Funzionalità richiesta non associata)», dove sono i tuoi documenti a dover essere modificati.

Required attachment slot not bound (Slot di associazione richiesto non legato)

Un’entità di catalogo dichiara uno slot di associazione con required: true nel suo featuresSchema, e nulla lega il nome di quello slot su un’istanza dell’entità. Il controllo viene eseguito sulle associazioni con cui l’istanza finisce dopo che ogni livello è stato combinato — i blocchi features: a livello di componente e di sottosistema dell’Aggregate, i blocchi a livello di confine e di componente della Release, e le associazioni prodotte dall’espansione guidata dalle annotazioni — quindi una credenziale associata una volta a un livello da cui l’istanza eredita lega lo slot esattamente come un riempimento scritto sull’istanza.

Messaggio emesso:

required attachment slot unfilled (<slot>, declared required by component type <component-type>). Attach a Feature at that name, in the Aggregate or in the Release, on the component or at a scope above it. (slot di associazione richiesto non riempito (lo slot indicato, dichiarato richiesto dal tipo di componente indicato). Associa una Feature con quel nome, nell’Aggregate o nella Release, sul componente o a un livello superiore.)

I due valori sono il nome proprio dello slot e il tipo di componente che lo dichiara, quindi un’istanza che lascia non legati due slot segnala due messaggi che differiscono. Il rilievo è posizionato sulla chiave dello slot sotto il blocco features: del componente nell’Aggregate; poiché quella chiave è esattamente ciò che manca, un editor lo colloca sulla chiave esistente più vicina — il blocco features: dove il componente ne scrive uno, e il componente stesso dove non lo fa. Nulla ha scritto l’associazione mancante, quindi nessun autore di documento viene chiamato in causa: il rilievo resta sul componente ed è classificato come errore dello sviluppatore, e il rimedio nomina entrambi i documenti, perché l’uno o l’altro può riempire lo slot — l’Aggregate sul componente o su un sottosistema che lo contiene, la Release sulla sua voce per il componente o su un confine che lo contiene.

Uno slot dichiarato da un socket — nel featuresSchema di una voce dello usesSchema — è richiesto a ciascuna connessione cablata attraverso il socket anziché al componente: ogni connessione lo riempie per sé, sulla propria voce nell’Aggregate o nella Release, e nessun livello superiore lo raggiunge. Così un socket con due connessioni, una delle quali riempie lo slot, segnala solo l’altra, nominandola:

required attachment slot unfilled ("<slot>", declared required by socket "<socket>", of component type "<component-type>", left unfilled by the connection "<alias>"). Attach a Feature under that slot in this connection’s features, on its entry in the Aggregate or in the Release. (slot di associazione richiesto non riempito (lo slot indicato, dichiarato richiesto dal socket indicato, del tipo di componente indicato, lasciato non riempito dalla connessione indicata). Associa una Feature sotto quello slot nelle funzionalità di questa connessione, sulla sua voce nell’Aggregate o nella Release.)

Quel rilievo è posizionato sulla voce della connessione nel documento che ha tracciato la connessione — la voce uses: dell’Aggregate, o la voce per arco della Release per una connessione che la Release ha cablato. Una connessione tracciata da una Feature associata è cablata in un socket che la Feature dichiara, non in uno del componente, quindi non spetta a essa riempire gli slot dei socket del componente.

Come risolvere: associa una Feature sotto il nome dello slot, nell’Aggregate o nella Release — sul componente, o a un livello più ampio condiviso da ogni consumatore dello slot; per lo slot di un socket, sulla connessione che il rilievo nomina. Un’associazione sotto un nome diverso non lega lo slot: uno slot è un punto di legame con nome, quindi il nome è il legame. Se lo slot non deve più essere richiesto, aggiorna il featuresSchema dell’entità di catalogo — quello proprio del componente o quello del socket — per eliminare la dichiarazione required.

Two Features declared to conflict reach one component (Due Features dichiarate in conflitto raggiungono un solo componente)

Il campo interoperability.conflictsWith di una Feature nomina le Features accanto a cui non può essere associata, e un componente finisce per portare la Feature e una di quelle che essa nomina. Il controllo viene eseguito sulle associazioni con cui il componente finisce dopo che ogni livello è stato combinato — i blocchi features: a livello di componente e di sottosistema dell’Aggregate, i blocchi a livello di confine della Release (ogni confine in cui si trova il componente, compresi quelli annidati) e le sue voci a livello di componente, e le associazioni prodotte dall’espansione guidata dalle annotazioni. Così una coppia arresta il build quando entrambe sono scritte sul componente, quando una è su un confine o un sottosistema che lo contiene, o quando una si trova su un confine esterno e l’altra su un confine annidato al suo interno. Due Features associate a confini fratelli che non condividono alcun componente non si incontrano mai, e un confine che non contiene alcun componente non raggiunge nulla, quindi in nessuno dei due casi il build si arresta.

Basta una sola dichiarazione: l’arresto scatta quando l’elenco dell’una o dell’altra Feature nomina l’altra. I nomi vengono confrontati togliendo l’eventuale versione, da entrambi i lati, così una voce corrisponde a ogni versione della Feature che nomina. Il compilatore confronta i nomi dichiarati dall’autore della Feature con le Features che il componente porta e non legge nient’altro in nessuno dei due.

Messaggio emesso:

a Feature reaches a component alongside a Feature it declares a conflict with ("<feature>", attached in the Release on boundary "<boundary-path>", conflicts with "<other-feature>", attached in the Aggregate on component "<component>", on component "<component>"). Attach only one of the two where they meet: remove one attachment, or move it to a scope that does not hold this component. (una Feature raggiunge un componente insieme a una Feature con cui dichiara un conflitto (la Feature indicata, associata nella Release sul confine indicato, è in conflitto con l’altra Feature indicata, associata nell’Aggregate sul componente indicato, sul componente indicato). Associa solo una delle due dove si incontrano: rimuovi un’associazione, oppure spostala a un livello che non contiene questo componente.)

Il primo valore è la Feature il cui elenco nomina l’altra — quella che nomina la frase precedente — seguita da ogni punto in cui è stata associata; poi la Feature con cui è in conflitto, e ogni punto in cui quella è stata associata; e per ultimo il componente in cui si incontrano. Ogni punto è espresso con le parole del documento che apriresti per modificarlo: attached in the Aggregate on component, attached in the Aggregate on subsystem, attached in the Release on boundary (il percorso di un confine annidato unisce i suoi livelli con /), attached in the Release on the entry for component seguito da in boundary, oppure attached by annotation-driven expansion of seguito dall’annotazione, e da declared at con il punto in cui è stata scritta. Un’associazione scritta su una connessione è espressa come la voce di quella connessione, poiché è quella voce, anziché il blocco proprio del componente, il punto in cui viene modificata: attached in the Aggregate on the connection seguito da through socket e of component, oppure attached in the Release on the connection seguito da through socket, of the entry for component e in boundary. Una Feature associata in due punti li elenca entrambi. Il rilievo è posizionato sulla chiave propria del componente sotto components:, e una coppia che si incontra su più componenti viene segnalata una volta per ciascuno di essi, nell’ordine in cui l’Aggregate dichiara i componenti.

Come risolvere: associa solo una delle due dove si incontrano — rimuovi una delle associazioni, oppure spostane una a un livello che non contiene questo componente, come un confine fratello. Dove l’associazione deriva dall’espansione guidata dalle annotazioni, è l’annotazione la cosa da cambiare, non il blocco su cui si è espansa. Se le due Features possono in realtà essere combinate, è la dichiarazione a essere sbagliata: rimuovi l’altra Feature dall’elenco conflictsWith sull’entità di catalogo della Feature che la dichiara.

Attachment does not conform to its declared slot shape (L’associazione non è conforme alla forma dichiarata del suo slot)

Un’associazione lega uno slot dichiarato ma non corrisponde alla forma che quello slot dichiara. Il caso comune è la consegna: l’allowlist inject di uno slot nomina i meccanismi attraverso cui un riempimento può consegnare il proprio materiale, e un’allowlist vuota è blackbox — la Recipe consegna il materiale internamente e un riempimento non può imporre alcuna consegna. Un blocco inject: {} vuoto non impone alcuna consegna, quindi è conforme alla forma di ogni slot, compreso uno con allowlist vuota, e riceve lo stesso verdetto ovunque sia scritta l’associazione: su un componente dichiarato dall’Aggregate, su un componente fornito da un modulo importato o a un ambito più ampio. Un’associazione sotto un nome che nessuno slot dichiara è un’associazione libera e non porta alcun vincolo di slot.

Messaggio emesso, dove l’associazione impone una consegna che il suo slot non accetta — lo slot, poi il meccanismo, poi ciascun meccanismo che l’allowlist inject dello slot accetta, nell’ordine in cui lo slot li dichiara (per un’allowlist vuota non ne segue nessuno):

attachment does not conform to its declared slot shape (Aggregate <name>, at .spec.components.<component>.features.<attachment>, "<slot>", "<mechanism>", "<permitted-mechanism>") (l’associazione non è conforme alla forma dichiarata del suo slot (con l’Aggregate, il percorso, lo slot, il meccanismo e il meccanismo consentito indicati))

Un componente fornito da un modulo importato viene controllato una volta costruita la composizione che lo importa, e segnala in una seconda forma. Nomina l’Aggregate del modulo e la chiave, all’interno del documento del modulo, che lo slot non dichiara — un meccanismo sotto il blocco inject: dell’associazione, oppure il blocco inject: stesso quando nomina un qualsiasi meccanismo su uno slot la cui allowlist è vuota:

attachment does not conform to its declared slot shape (Aggregate <name>, at .spec.components.<component>.features.<attachment>.<key>, attachment does not conform to the declared slot shape: this key is not part of the slot’s declaration — <remedy>) (l’associazione non è conforme alla forma dichiarata del suo slot (con l’Aggregate e il percorso indicati, l’associazione non è conforme alla forma dichiarata dello slot: questa chiave non fa parte della dichiarazione dello slot — il rimedio indicato))

dove <remedy> dipende dalla chiave:

  • remove it, per un blocco inject: che nomina un meccanismo su uno slot la cui allowlist è vuota;
  • remove it, or add it to the slot's inject allowlist in the entity's featuresSchema, per un meccanismo che l’allowlist di uno slot può nominare — env, file o arg;
  • remove it: a slot's inject allowlist in the entity's featuresSchema accepts only env, file and arg, per qualsiasi altro meccanismo, che nessuno slot può dichiarare.

Un’associazione dichiarata a un livello più ampio — a livello di sottosistema, a cascata su ogni componente al di sotto — è tenuta alla stessa forma, e viene controllata rispetto allo slot su ciascun componente che raggiunge. La stessa associazione può quindi essere conforme per un componente e non conforme per un altro, perciò questa forma nomina il componente e lo slot rispetto a cui è fallita, e colloca l’associazione al livello in cui è stata dichiarata anziché su una chave all’interno del suo blocco di consegna:

attachment does not conform to its declared slot shape (Aggregate <name>, at .spec.subsystems.<scope>.features.<attachment>, this attachment is declared at a scope that reaches component <component>, whose attachment slot <slot> does not accept the delivery it carries: move the attachment down to the components that may receive it) (l’associazione non è conforme alla forma dichiarata del suo slot (con l’Aggregate e il percorso indicati, questa associazione è dichiarata a un livello che raggiunge il componente indicato, il cui slot di associazione indicato non accetta la consegna che porta: sposta l’associazione più in basso, sui componenti che possono riceverla))

Un’associazione portata da una connessione non raggiunge mai questo arresto. La sua forma è chiusa dove viene scritta: sulla voce di connessione dell’Aggregate accetta type, description e values, e su quella della Release type, description e infra, quindi non può imporre alcuna consegna — un inject: scritto lì viene rifiutato al caricamento del documento, con il nome della chiave — e la voce del Workload che la consegna è invece tenuta all’allowlist inject dello slot del socket. Nemmeno lo slot di un socket è raggiunto da alcun livello, quindi la forma valida per un intero livello descritta sopra non ha corrispettivo su una connessione.

Come risolvere: le forme richiedono due modifiche diverse, e il percorso del campo ti dice quale delle due hai. Dove nomina un’associazione su un componente, o una chiave al suo interno, l’errore è nella consegna: rimuovila, oppure sposta le sue voci sotto un meccanismo che l’allowlist inject dello slot nomina. Dove il materiale deve davvero raggiungere il carico di lavoro tramite un meccanismo che lo slot non elenca, l’allowlist nel featuresSchema dell’entità di catalogo può essere ampliata — ma solo con env, file o arg, i meccanismi che uno slot può dichiarare; un Component che vi nomina qualsiasi altro meccanismo non supera la convalida al caricamento, quindi per qualsiasi altro meccanismo rimuoverlo è l’unica soluzione. Dove nomina un’associazione a un livello, l’associazione è ben formata e l’errore è nella sua collocazione: spostala più in basso, sui componenti il cui slot accetta la consegna, lasciando fuori dalla sua portata i componenti che riservano la consegna alla loro Recipe.

Duplicate delivery key across inject sources (Chiave di consegna duplicata tra le fonti di inject)

La stessa chiave di consegna (ad esempio, lo stesso nome di variabile d’ambiente) viene rivendicata due volte tra le fonti di inject scritte dallo sviluppatore per un componente — a livello di Component e sotto una voce uses[], da due voci uses[] sullo stesso componente, oppure sotto due meccanismi di consegna del blocco inject: proprio del Component. La consegna non può provenire da due punti contemporaneamente, quindi una chiave rivendicata due volte è una contraddizione e non una questione di quale delle due prevalga.

Il build la legge in quattro punti, perché vedono insiemi diversi di fonti scritte e di connessioni di dipendenza e pongono loro domande diverse, e ciascuno segnala nella propria forma.

Il primo legge le connessioni che hai scritto nell’Aggregate, e segnala mentre i tuoi file vengono risolti. Nomina il meccanismo di consegna, la chiave, e poi il socket e l’alias della prima connessione, nell’ordine di scrittura, che rivendica anch’essa la chiave:

duplicate delivery key across inject sources (Aggregate <name>, at .spec.components.<component>.inject.<mechanism>.<key>, "<mechanism>", "<key>", "<socket>", "<alias>") (chiave di consegna duplicata tra le fonti di inject (con l’Aggregate, il percorso, il meccanismo, la chiave, il socket e l’alias indicati))

Il secondo legge lo stesso blocco scritto e gli pone una domanda diversa: se il componente rivendica una chiave sotto due dei propri meccanismi di consegna, senza alcuna connessione coinvolta. Segnala una volta per ogni meccanismo che rivendica la chiave, posizionato sulla voce propria di quel meccanismo, e nomina il meccanismo di cui tratta il rilievo, la chiave, e poi ogni altro meccanismo che la rivendica, nell’ordine di scrittura:

duplicate delivery key across inject sources (Aggregate <name>, at .spec.components.<component>.inject.<mechanism>.<key>, "<mechanism>", "<key>", "<other-mechanism>") (chiave di consegna duplicata tra le fonti di inject (con l’Aggregate, il percorso, il meccanismo, la chiave e l’altro meccanismo indicati))

Nessuno dei due meccanismi è il responsabile e spetta a te intervenire su entrambi i rilievi: rinomina la chiave sotto uno dei due, oppure elimina una delle due consegne. Quali meccanismi un componente possa usare è una questione separata, a cui risponde la sua allowlist spec.inject — vedi «Self-inject mechanism not in the component’s allowlist (Meccanismo di self-inject non presente nell’allowlist del componente)» più sotto.

Anche un componente fornito da un modulo incontra queste prime due forme, lette dal documento proprio del modulo una volta costruita la composizione che lo importa; in quel caso nominano l’Aggregate del modulo e la chiave all’interno del suo documento.

Il terzo legge le connessioni che la topologia finita porta, comprese quelle che un’associazione di Feature ha fornito per tuo conto. Viene eseguito prima che qualsiasi cosa venga renderizzata, e nomina la chiave di consegna che hai scritto insieme al socket di dipendenza che anch’esso la consegna:

duplicate delivery key across self-inject and uses-inject ("<key>", socket "<socket>") (chiave di consegna duplicata tra self-inject e uses-inject (la chiave indicata, il socket indicato))

Una chiave scritta consegnata attraverso due socket di dipendenza segnala una volta per socket, così un solo build ti informa su tutti anziché su quello raggiunto per primo.

Il quarto legge la stessa topologia finita e le pone una domanda diversa: se due delle connessioni di dipendenza proprie di un componente consegnano una stessa chiave tra loro, senza che il componente stesso rivendichi nulla. Segnala una volta su ciascuna connessione, posizionato sulla voce di consegna propria di quella connessione, e nomina il percorso della voce seguito da ogni socket che consegna la chiave:

duplicate delivery key across inject sources ("inject.<mechanism>.<key>", "<socket>", "<socket>") (chiave di consegna duplicata tra le fonti di inject (con il percorso della voce e i socket indicati))

Un socket nominato due volte è ciò che ti dice che le due connessioni si trovano su un solo socket con alias diversi — lì la posizione è l’unica cosa che le distingue, quindi leggi il percorso del campo di ciascuno dei due rilievi anziché i nomi dei socket.

Nessuna delle due connessioni è la responsabile e spetta a te intervenire su entrambe: rinomina una delle chiavi, oppure elimina una delle due consegne.

Dove la chiave è un percorso, il percorso del campo nomina invece il blocco del meccanismo. Ciò che una chiave di consegna esprime è affare del meccanismo stesso, e un meccanismo file consegna in un percorso di montaggio — quindi una tale chiave contiene punti, mentre un percorso del campo separa i propri passi proprio con i punti. Un percorso del campo si ferma all’ultimo passo che può nominare senza ambiguità anziché esprimerne uno che si leggerebbe come una discesa attraverso chiavi che il tuo documento non contiene, quindi per una chiave come /etc/app/config.yaml si legge .spec.components.<component>.inject.<mechanism> e si ferma lì. Il messaggio nomina la chiave in entrambi i casi, ed è questo a mantenere il rilievo ugualmente utilizzabile — ma il punto del messaggio in cui leggerla varia tra le quattro forme sopra, quindi leggi il percorso del campo per il blocco e poi prendi la chiave da quella delle quattro che hai: dove il dettaglio inizia con il meccanismo di consegna, la chiave è il valore tra virgolette subito dopo; dove il dettaglio inizia con la chiave da sola, è il primo valore tra virgolette; e dove il dettaglio inizia con il percorso proprio della voce di consegna, la chiave è l’ultimo passo di quel percorso.

Come risolvere: rinomina una delle chiavi in conflitto, oppure elimina la dichiarazione duplicata. Nota che l’injectMapping di una FeatureRecipe che riscrive una chiave consegnata dal blocco inject: proprio del componente o da uno dei blocchi inject: delle sue connessioni è un’intercettazione intenzionale e non viene segnalato né qui né altrove.

Una chiave rivendicata da una Feature associata al componente incontra lo stesso spazio condiviso dalla terza delle sue tre superfici di authoring, e viene segnalata sotto «An attachment delivers a key another inject source already claimed (Un’associazione consegna una chiave già rivendicata da un’altra fonte di inject)» più sotto; una chiave consegnata da due Features associate, dove la successiva delle due la consegna tramite l’injectMapping della sua FeatureRecipe, viene segnalata sotto «Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Due Features associate consegnano una stessa chiave, la successiva tramite l’injectMapping della sua FeatureRecipe)».

Self-inject on a component without an allowlist (Self-inject su un componente senza allowlist)

Lo sviluppatore ha scritto un blocco inject: a livello di componente, ma l’entità di catalogo del Component non dichiara spec.inject. I Components senza un’allowlist spec.inject sono tipi Black-Box — non ricevono alcuna iniezione scritta dallo sviluppatore.

Messaggio emesso:

self-inject on component without spec.inject allowlist (Aggregate <name>, at .spec.components.<component>.inject, "inject", "<component-type>") (self-inject su un componente senza allowlist spec.inject (con l’Aggregate, il percorso, la chiave inject e il tipo di componente indicati))

Il rilievo è posizionato sul blocco inject: stesso, che è l’elemento da rimuovere.

Come risolvere: rimuovi il blocco inject: da questa istanza di Component, oppure passa a un tipo di Component White-Box la cui dichiarazione di catalogo includa spec.inject.

Self-inject mechanism not in the component’s allowlist (Meccanismo di self-inject non presente nell’allowlist del componente)

Lo sviluppatore ha scritto un blocco inject: a livello di componente usando un meccanismo (ad esempio env o una specifica forma di montaggio di file) che non è elencato nell’allowlist spec.inject del Component.

Messaggio emesso:

self-inject on component without spec.inject allowlist (Aggregate <name>, at .spec.components.<component>.inject.<mechanism>, "<component-type>", "<mechanism>", "<allowlisted-mechanism-1>", "<allowlisted-mechanism-2>", …) (self-inject su un componente senza allowlist spec.inject (con l’Aggregate, il percorso, il tipo di componente, il meccanismo e i meccanismi consentiti indicati))

I meccanismi che il tipo consente seguono quello imposto, così il messaggio porta sia ciò che è stato scritto sia ciò che il tipo permette. Un tipo che non dichiara alcuna allowlist segnala il meccanismo imposto senza nulla dopo.

Sia questa regola sia quella precedente valgono per un componente fornito da un modulo, una volta costruita la composizione che importa il modulo; il rilievo nomina allora l’Aggregate del modulo e la chiave all’interno del suo documento.

Come risolvere: passa a un meccanismo presente nell’allowlist, oppure, se il Component deve supportare il meccanismo di cui hai bisogno, estendi la sua allowlist spec.inject nel catalogo.

uses edge dictates delivery on a socket that allowlists none (Un arco impone la consegna su un socket che non consente alcun meccanismo)

Un blocco inject: su un arco uses: si cabla in un socket la cui voce dello usesSchema non dichiara alcuna allowlist inject:, oppure ne dichiara una vuota. Un socket del genere è una connessione Black-Box: l’entità che lo ha dichiarato gestisce internamente i valori della dipendenza, quindi il consumatore prende qualunque cosa emetta la Recipe del produttore e non sceglie la forma di consegna. Una chiave inject: assente e inject: [] sono la stessa dichiarazione.

Il socket viene letto sull’entità che lo ha dichiarato, qualunque essa sia: un arco scritto su un’associazione di Feature si risolve rispetto allo usesSchema della Feature associata, e ogni altro arco rispetto a quello del Component consumatore.

Messaggio emesso. Prima viene il rifiuto, poi i meccanismi che l’arco ha imposto, il socket e l’entità la cui dichiarazione è stata letta — poi che cosa fare al riguardo:

uses-edge inject dictates a delivery mechanism the socket does not permit ("<mechanism>", on socket "<socket>", declared on the component type "<component-type>"). The socket declares no delivery allowlist, so it permits no dictation at all — the entity that declared it delivers the dependency’s values itself. Remove the inject block from this connection and read the values from the connection’s provides in the consuming Recipe, or declare the mechanisms the socket permits in its usesSchema entry. (l’inject dell’arco uses impone un meccanismo di consegna che il socket non consente (il meccanismo indicato, sul socket indicato, dichiarato sul tipo di componente indicato). Il socket non dichiara alcuna allowlist di consegna, quindi non consente alcuna imposizione — l’entità che lo ha dichiarato consegna da sé i valori della dipendenza. Rimuovi il blocco inject da questa connessione e leggi i valori dai provides della connessione nella Recipe consumatrice, oppure dichiara i meccanismi che il socket consente nella sua voce dello usesSchema.)

Il rilievo è posizionato sulla voce scritta di cui tratta, nel documento in cui quella voce è stata scritta: .spec.components.<consumer>.uses.<socket>.<alias> per un arco tracciato dal blocco uses: proprio di un componente, e .spec.components.<consumer>.features.<attachment>.uses.<socket>.<alias> per uno tracciato da un’associazione — con radice nel blocco che ha dichiarato l’associazione, che può essere quello di un sottosistema o di un confine anziché quello proprio del componente. Dove il socket è stato dichiarato sulla Feature associata, il messaggio nomina il tipo di funzionalità al posto del tipo di componente. Ogni arco in errore viene segnalato come rilievo a sé, così un solo build li nomina tutti.

Come risolvere: rimuovi il blocco inject: dall’arco e leggi invece i valori della dipendenza da .context.uses.<alias>.provides.<name> nella Recipe consumatrice; oppure, se la connessione deve essere trasparente, dichiara i meccanismi di consegna che il socket consente nell’allowlist inject: della sua voce dello usesSchema.

Un socket che l’entità dichiarante non ha mai dichiarato è un caso diverso e qui non viene rifiutato: un socket ad hoc non porta alcuna allowlist, quindi non c’è nulla al di fuori del quale l’arco possa trovarsi.

uses edge dictates a delivery mechanism outside the socket’s allowlist (Un arco impone un meccanismo di consegna al di fuori dell’allowlist del socket)

Un blocco inject: su un arco uses: nomina un meccanismo di consegna che l’allowlist inject: del socket non elenca. L’allowlist è la dichiarazione, da parte dell’entità dichiarante, delle forme di consegna da cui il suo punto di ingresso è effettivamente in grado di leggere i valori della dipendenza, quindi un meccanismo al di fuori di essa consegnerebbe valori che nulla consuma.

Ogni meccanismo nominato dal blocco viene controllato, e ciascuno al di fuori dell’allowlist viene segnalato, così un solo build li nomina tutti anziché uno per esecuzione.

Messaggio emesso. Prima viene il rifiuto, poi il meccanismo rifiutato, il socket, ciò che quel socket consente e l’entità la cui dichiarazione è stata letta:

uses-edge inject dictates a delivery mechanism the socket does not permit ("<mechanism>", on socket "<socket>", which permits "<mechanism-1>, <mechanism-2>", declared on the component type "<component-type>"). Dictate one of the mechanisms the socket permits, or widen that socket’s inject allowlist in the declaring entity’s usesSchema entry. (l’inject dell’arco uses impone un meccanismo di consegna che il socket non consente (il meccanismo indicato, sul socket indicato, che consente i meccanismi indicati, dichiarato sul tipo di componente indicato). Imponi uno dei meccanismi che il socket consente, oppure amplia l’allowlist inject di quel socket nella voce dello usesSchema dell’entità dichiarante.)

Il rilievo è posizionato sulla voce scritta di cui tratta, sugli stessi percorsi che nomina il rifiuto precedente. Dove il socket è stato dichiarato sulla Feature associata, il messaggio nomina il tipo di funzionalità al posto del tipo di componente.

Come risolvere: passa a uno dei meccanismi presenti nell’allowlist, oppure, se l’entità deve supportare il meccanismo di cui hai bisogno, amplia l’allowlist inject: di quel socket nella sua voce usesSchema di catalogo.

An inject: entry carries both a literal and a source key (Una voce di inject porta sia un letterale sia una chiave di origine)

Una voce inject: consegna una di due cose: un letterale, scritto sotto value: — sul blocco proprio di un componente, l’unico punto in cui si consegna un letterale — oppure una chiave letta dal componente a cui punta la connessione, scritta sotto from:. Una voce che li porta entrambi dice due cose contemporaneamente e non offre alcuna regola per scegliere tra di esse, quindi viene rifiutata anziché lasciare che una delle due prevalga in silenzio.

Gli schemi di authoring ammettono esattamente uno dei due, quindi un documento letto da un file viene rifiutato al caricamento. Questo è il controllo che sta dietro a quello: legge ogni blocco inject: che l’Aggregate e la Release portano mentre i due documenti vengono risolti, così un documento costruito per una via diversa da un file viene comunque rifiutato prima che da esso venga costruito qualcosa, anziché vedersi scegliere in silenzio un campo. Copre gli stessi blocchi del controllo della forma più sotto.

Ogni meccanismo di consegna che contiene una voce in errore viene segnalato come rilievo a sé, posizionato su quel meccanismo nel documento che lo ha scritto — .spec.components.<component>.inject.env per il blocco proprio di un componente — e tutti quelli presenti nel build vengono segnalati insieme. Il rilievo nomina il meccanismo e poi il campo in: di ciascuna voce in errore nell’elenco di quel meccanismo.

Messaggio emesso:

inject entry carries both value: and from:; schema requires exactly one ("<mechanism>", "<in-1>", "<in-2>") (la voce di inject porta entrambi i campi; lo schema ne richiede esattamente uno (il meccanismo e le voci indicati))

Come risolvere: apri ogni voce che il messaggio nomina ed elimina quello dei due di cui non ha bisogno. Mantieni from: dove il valore deve provenire dal componente a cui punta la connessione — nomina una chiave che il provides: di quel componente dichiara. Mantieni value: dove il valore è un letterale fornito da questo lato, sul blocco proprio di un componente; su una connessione e sul blocco proprio di una Feature allegata un letterale viene rifiutato, quindi lì mantieni from:.

An inject: entry on a connection carries a literal (Una voce di inject su una connessione porta un letterale)

Una connessione consegna al componente consumatore ciò che pubblica il componente a cui punta: ogni voce nel blocco inject: della connessione nomina sotto from: una delle chiavi provides: di quel componente. Un letterale scritto sotto value: non nomina nulla che la destinazione pubblichi, quindi non ha posto su una connessione, e la voce viene rifiutata anziché scartata. Un letterale che un componente consegna a sé stesso appartiene al blocco inject: proprio del componente, dove value: è ammesso.

Ogni connessione viene controllata, qualunque sia il documento che l’ha tracciata: una sul blocco uses: proprio di un componente, una tracciata da una Feature associata nell’Aggregate e una tracciata da un’associazione scritta nella Release. Viene rifiutata prima che qualcosa venga renderizzato, quindi aggrega validate --release la segnala così come aggrega build.

Ogni voce in errore viene segnalata come rilievo a sé, posizionato sulla voce della connessione nel documento che l’ha tracciata — .spec.components.<component>.uses.<socket>.<alias> per la connessione propria di un componente, .spec.components.<component>.features.<attachment>.uses.<socket>.<alias> per una tracciata da un’associazione e, nella Release, lo stesso percorso sotto la voce dell’associazione, come .spec.boundaries.<boundary>.components.<component>.features.<attachment>.uses.<socket>.<alias> — e tutte quelle presenti nel build vengono segnalate insieme. Un rilievo nell’Aggregate è classificato sotto DEVELOPER_ERROR, uno nella Release sotto OPS_ERROR. Il rilievo nomina il meccanismo e il campo in: della voce.

Messaggio emesso:

inject entry on a connection carries value:; a connection delivers the target’s published keys, each named with from: ("<mechanism>", "<in>") (la voce di inject su una connessione porta un letterale; una connessione consegna le chiavi pubblicate dalla destinazione, ciascuna nominata come origine (il meccanismo e la voce indicati))

Come risolvere: dove il valore è uno di quelli che la destinazione pubblica, sostituisci value: con from: che nomina quella chiave provides:. Dove è un letterale di cui il componente consumatore ha bisogno, sposta la voce nel blocco inject: proprio di quel componente, i cui meccanismi sono governati dall’allowlist spec.inject del suo tipo di Component.

An inject: entry on an attached Feature carries a literal (Una voce di iniezione su una Feature allegata contiene un letterale)

Il blocco inject: scritto su una Feature allegata consegna al componente ciò che la FeatureRecipe di quell’allegato pubblica: ogni voce nomina una delle chiavi che il provides: della FeatureRecipe pubblica, sotto from:. Un letterale scritto sotto value: non nomina nulla che l’allegato pubblichi, quindi nulla raggiungerebbe il componente sotto l’in: di quella voce; la voce viene rifiutata invece di essere costruita e scartata. Un letterale di cui il componente ha bisogno va nel blocco inject: proprio del componente, dove value: è ammesso e consegnato.

Viene verificato ogni allegato su cui un Aggregate scrive un blocco inject:: uno nel blocco features: proprio di un componente e uno nel blocco features: di un sottosistema, che raggiunge ogni componente contenuto nel sottosistema — nell’Aggregate che la Release nomina e in ogni modulo che quell’Aggregate importa sotto aggregates:, a qualsiasi profondità. Una connessione che un allegato traccia porta il proprio blocco inject:, e un letterale lì ricade nel rifiuto della connessione descritto sopra. Un allegato della Release non scrive alcun blocco inject: proprio. La voce viene rifiutata prima di qualsiasi rendering, quindi aggrega validate --release la segnala così come aggrega build.

Ogni voce errata viene segnalata come rilievo a sé, classificato come DEVELOPER_ERROR rispetto all’Aggregate il cui documento ha scritto il blocco — il documento proprio di un modulo per un allegato scritto in un modulo — e posizionato sul meccanismo di consegna all’interno del blocco dell’allegato in quel documento: .spec.components.<component>.features.<attachment>.inject.<mechanism>, oppure .spec.subsystems.<subsystem>.features.<attachment>.inject.<mechanism> per l’allegato di un sottosistema. Tutte quelle di un documento vengono segnalate insieme; quelle in un modulo importato vengono segnalate una volta che l’Aggregate importatore supera la verifica. Il rilievo nomina il meccanismo e l’in: della voce. Una voce che porta sia value: sia from: viene segnalata una sola volta, sotto «An inject: entry carries both a literal and a source key (Una voce di iniezione contiene sia un letterale sia una chiave sorgente)» sopra.

Messaggio emesso:

inject entry on an attachment carries value:; an attachment delivers the keys its FeatureRecipe publishes, each named with from:, and a literal belongs in the component’s own inject block ("<mechanism>", "<in>") (una voce inject su un allegato contiene un letterale; un allegato consegna le chiavi che la sua FeatureRecipe pubblica, ciascuna nominata come chiave sorgente, e un letterale va nel blocco inject proprio del componente)

Come risolvere: dove il valore è uno che la FeatureRecipe dell’allegato pubblica, sostituisci value: con from: che nomina quella chiave provides:. Dove è un letterale di cui il componente ha bisogno, sposta la voce nel blocco inject: proprio del componente, i cui meccanismi sono governati dall’allowlist spec.inject del suo tipo di Component:

components:
api:
type: core/api
inject:
env:
- in: LITERAL_NAME
value: a-literal # the literal, delivered by the component's own block
features:
token:
type: core/token
inject:
env:
- in: TOKEN_NAME
from: name # a key the attachment's FeatureRecipe publishes

An inject: delivery is not a list of entries (Una consegna di inject non è un elenco di voci)

Ogni meccanismo di consegna in un blocco inject: — env, file, arg o un meccanismo nominato accanto a essi — è un elenco di voci, ciascuna con in: ed esattamente uno tra from: e value:. Un meccanismo che contiene qualsiasi altra cosa, come una mappa da nomi a chiavi, non consegna nulla che il compilatore possa leggere, quindi viene rifiutato anziché scartato. Un meccanismo scritto senza alcun valore non consegna nulla e non viene rifiutato.

Gli schemi di authoring ammettono solo l’elenco, quindi un documento letto da un file viene rifiutato al caricamento, come documento che non corrisponde allo schema del suo tipo. Questo è il controllo che sta dietro a quello: legge ogni blocco inject: che l’Aggregate e la Release portano mentre i due documenti vengono risolti, così un documento costruito per una via diversa da un file viene comunque rifiutato prima che da esso venga costruito qualcosa, anziché veder svanire la consegna. Copre ogni blocco che l’uno o l’altro documento porta: nell’Aggregate, quello proprio di un componente, quello di un’associazione e quelli sulle connessioni che l’uno o l’altra traccia; nella Release, quelli sulle connessioni che le sue associazioni tracciano.

Ogni meccanismo in errore viene segnalato come rilievo a sé, posizionato su quel meccanismo nel documento che lo ha scritto e con il nome del meccanismo, e tutti quelli presenti nel build vengono segnalati insieme. I rilievi dell’Aggregate vengono segnalati prima di quelli della Release.

Messaggio emesso:

inject delivery: shape must be a list of entries, each in: with exactly one of from: or value: ("<mechanism>") (consegna inject: la forma deve essere un elenco di voci, ciascuna con una destinazione ed esattamente un’origine o un letterale (il meccanismo indicato))

La posizione è il percorso di chiavi scritto dall’autore. Nell’Aggregate, .spec.components.<component>.inject.<mechanism> per il blocco proprio di un componente, .spec.components.<component>.uses.<socket>.<alias>.inject.<mechanism> per un blocco su una delle sue connessioni e .spec.components.<component>.features.<attachment>… per quello di un’associazione, con .subsystems.<name> per ogni sottosistema in cui è dichiarato un componente o un’associazione. Nella Release, il blocco su una connessione tracciata da un’associazione, attraverso quell’associazione — .spec.boundaries.<boundary>.features.<attachment>.uses.<socket>.<alias>.inject.<mechanism> per una associata a livello dell’intero confine, .spec.boundaries.<boundary>.components.<component>.features.<attachment>… per una su un componente, con .boundaries.<name> per ogni confine annidato e .aggregates.<module> per ogni voce di instradamento attraverso cui è nominato un componente.

Come risolvere: scrivi come elenco ogni meccanismo che il messaggio nomina. Una voce DB_URL: host sotto env: diventa - in: DB_URL con from: host quando host nomina una chiave provides: — quella del componente connesso su una connessione, quella propria del componente sul suo blocco — oppure, sul blocco proprio del componente, con value: host quando è un letterale fornito da questo lato.

The Feature filling an attachment slot does not satisfy the slot’s selector (La Feature che riempie uno slot di associazione non soddisfa il selettore dello slot)

Un Component dichiara punti di legame con nome per le Features che si aspetta, e uno slot può dichiarare un selector: che vincola le etichette di qualunque cosa lo riempia. Un’associazione lega uno slot portandone il nome; quando lo fa, le etichette della Feature che nomina vengono confrontate con quel vincolo, e un riempimento che non lo soddisfa ferma il build. Uno slot che non dichiara alcun vincolo accetta qualsiasi riempimento.

Se uno slot possa essere lasciato non legato è una questione diversa con un rimedio diverso, segnalata dal proprio arresto più sopra: questo presuppone un riempimento e chiede se il riempimento sia ammissibile, quindi uno slot non legato non lo riguarda.

Due esiti vengono segnalati sotto quest’unica condizione, e il messaggio li distingue in base a ciò che dice il suo ultimo valore. Un riempimento che non ha soddisfatto il vincolo nomina la Feature le cui etichette non hanno trovato corrispondenza. Un vincolo che non è stato possibile leggere affatto nomina invece il motivo — un’espressione che il matcher delle etichette non è riuscito a valutare — che è un errore nella dichiarazione propria dello slot anziché in ciò che vi è stato associato.

Messaggio emesso, dove le etichette del riempimento non hanno soddisfatto il vincolo:

attachment slot selector unsatisfied ("<selector>", declared on slot "<slot>", not satisfied by the labels of the Feature filling it, "<feature-type>"). Add the labels the slot’s selector requires to the Feature’s labels, or fill the slot with a Feature that already carries them. (selettore dello slot di associazione non soddisfatto (il selettore indicato, dichiarato sullo slot indicato, non soddisfatto dalle etichette della Feature che lo riempie, il tipo di Feature indicato). Aggiungi alle etichette della Feature le etichette che il selettore dello slot richiede, oppure riempi lo slot con una Feature che le porta già.)

e dove non è stato possibile valutare il vincolo stesso:

attachment slot selector unsatisfied ("<selector>", declared on slot "<slot>", which could not be evaluated: "<why it could not be evaluated>"). Correct the selector on the slot’s declaration in the component’s catalog entity. (selettore dello slot di associazione non soddisfatto (il selettore indicato, dichiarato sullo slot indicato, che non è stato possibile valutare: il motivo indicato). Correggi il selettore nella dichiarazione dello slot nell’entità di catalogo del componente.)

È posizionato sulla chiave del riempimento nel documento che ha scritto il riempimento, e classificato sotto l’autore di quel documento: il blocco features: del componente nell’Aggregate è un errore dello sviluppatore, e un riempimento che solo la Release effettua — sulla sua voce per il componente, o su un confine che lo contiene — è un errore dell’operatore, segnalato sul percorso proprio della Release:

[OPS_ERROR E0008] release.yaml at .spec.boundaries.main.components.app.features.identity
attachment slot selector unsatisfied ("feature.aggrega.ai/kind!=secret", declared on slot "identity", not satisfied by the labels of the Feature filling it, "core/secret-value"). Add the labels the slot's selector requires to the Feature's labels, or fill the slot with a Feature that already carries them.

Lo stesso riempimento scritto sul componente nell’Aggregate segnala [DEVELOPER_ERROR E0008] aggregate.yaml at .spec.components.app.features.identity.

Uno slot dichiarato da un socket — nel featuresSchema di una voce dello usesSchema — sottopone allo stesso modo al suo selector: il riempimento di ciascuna connessione. L’associazione che una connessione porta nello slot viene confrontata con il vincolo, e un riempimento che esso non ammette ferma il build, nominando il socket e la connessione oltre allo slot:

attachment slot selector unsatisfied ("<selector>", declared on slot "<slot>", of socket "<socket>", filled on the connection "<alias>", not satisfied by the labels of the Feature filling it, "<feature-type>"). Add the labels the slot’s selector requires to the Feature’s labels, or fill the slot with a Feature that already carries them. (selettore dello slot di associazione non soddisfatto (il selettore indicato, dichiarato sullo slot indicato, del socket indicato, riempito sulla connessione indicata, non soddisfatto dalle etichette della Feature che lo riempie, il tipo di Feature indicato). Aggiungi alle etichette della Feature le etichette che il selettore dello slot richiede, oppure riempi lo slot con una Feature che le porta già.)

È posizionato sulla chiave dell’associazione sotto il features: di quella connessione, nel documento che ha scritto il riempimento: la voce della connessione dell’Aggregate, oppure la voce per arco della Release per un riempimento che solo la Release effettua.

Anche un selettore di slot che la grammatica non riesce a leggere viene rifiutato prima che qualcosa riempia lo slot. aggrega validate, sull’intero catalogo o su un singolo Component o Feature, legge ogni selettore di slot dichiarato dal documento dell’entità stessa — gli slot propri di un Component, gli slot dichiarati dai suoi socket e gli slot di una Feature — e rifiuta quello che la grammatica non riesce a leggere sotto questa stessa condizione, che qualcosa riempia o meno lo slot. Il messaggio è la forma «non è stato possibile valutarlo» vista sopra; uno slot dichiarato da un socket aggiunge il socket:

attachment slot selector unsatisfied ("<selector>", declared on slot "<slot>", of socket "<socket>", which could not be evaluated: "<why it could not be evaluated>"). Correct the selector on the slot’s declaration in the socket’s featuresSchema on the component’s catalog entity. (selettore dello slot di associazione non soddisfatto, dichiarato sullo slot del socket, che non è stato possibile valutare. Correggi il selettore nella dichiarazione dello slot nel featuresSchema del socket, sull’entità di catalogo del componente.)

Su uno slot di una Feature il rimedio nomina invece l’entità di catalogo della Feature. Nulla ha riempito lo slot, quindi l’errore è dell’entità di catalogo: viene classificato come CATALOG_ERROR e nomina il file dell’entità.

Come risolvere: per un riempimento che non ha soddisfatto il vincolo, associa una Feature le cui etichette lo soddisfano — il selettore nel messaggio dice quali etichette vengono richieste — oppure amplia il selector: dello slot nel Component che lo dichiara. Dove il messaggio dice che non è stato possibile valutare il vincolo, l’errore è nell’espressione del selettore: correggila nella dichiarazione dello slot del Component, o in quella del socket.

An attachment written under another name fits a slot its component leaves empty (Un’associazione scritta sotto un altro nome si adatta a uno slot che il suo componente lascia vuoto)

La superficie di associazione propria di un Component è aperta: un’associazione sotto un nome che nessuno slot dichiara è un’associazione libera, ed è legittima. Una sola struttura su quella superficie arresta il build, perché è la struttura che assume un riempimento destinato a uno slot quando viene scritto sotto il nome sbagliato. Il build si ferma quando per una stessa associazione valgono tutte queste condizioni:

  • è scritta sul componente stesso — sul blocco features: proprio del componente nell’Aggregate, oppure sulla voce della Release per quel solo componente;
  • il suo nome non è uno slot che il tipo del componente dichiara;
  • le etichette della sua Feature soddisfano il selector: di uno slot che il tipo dichiara;
  • nulla lega quello slot sul componente dopo che ogni livello è stato combinato.

Lasciata così, un’associazione del genere è un’associazione libera mentre lo slot a cui era destinata resta vuoto — e uno slot facoltativo lasciato vuoto produce un build verde e non consegna nulla. La regola vale per ogni Feature, non solo per le credenziali.

Tutto il resto sulla superficie resta libero. Un’associazione la cui Feature non si adatta ad alcuno slot dichiarato non ferma il build; lo stesso vale per un’associazione aggiuntiva accanto a uno slot che qualcosa lega già, purché nessun altro slot a cui si adatta resti vuoto. Un’associazione che il componente eredita da un sottosistema o da un confine di Release non viene mai giudicata, quindi la struttura condivisa — una credenziale associata una sola volta a un livello in cui si trovano più componenti, senza che alcun componente riempia lo slot — non ferma il build. Uno slot che non dichiara alcun selector: non dice nulla su quale Feature sia destinata a riempirlo, quindi nessuna associazione vi viene sottoposta in questo modo. Nemmeno un’associazione portata da una connessione viene giudicata qui: gli slot di un socket sono un insieme chiuso, e qualsiasi altro nome su una connessione arresta il build sotto «A connection carries an attachment under a name its socket declares no slot for (Una connessione porta un’associazione sotto un nome per cui il suo socket non dichiara alcuno slot)».

Messaggio emesso. Prima viene la frase della condizione, poi il nome sotto cui è stata scritta l’associazione, il componente, la Feature che associa e lo slot vuoto a cui si adatta — poi che cosa fare al riguardo:

attachment written under a name no slot declares fits a slot its component leaves empty ("<attachment>", on component "<component>", attaching the Feature "<feature-type>", which fits the empty slot "<slot>"). Attach it as "<slot>" to fill the slot. (un’associazione scritta sotto un nome che nessuno slot dichiara si adatta a uno slot che il suo componente lascia vuoto (l’associazione indicata, sul componente indicato, che associa la Feature indicata, la quale si adatta allo slot vuoto indicato). Associala con il nome dello slot indicato per riempire lo slot.)

Dove la Feature si adatta a più di uno slot vuoto, il messaggio li nomina tutti, nell’ordine in cui il tipo del componente li dichiara, e lascia a te la scelta:

attachment written under a name no slot declares fits a slot its component leaves empty ("<attachment>", on component "<component>", attaching the Feature "<feature-type>", which fits the empty slot "<slot>", and the empty slot "<another-slot>"). Attach it under the name of the slot it is meant to fill. (un’associazione scritta sotto un nome che nessuno slot dichiara si adatta a uno slot che il suo componente lascia vuoto (l’associazione indicata, sul componente indicato, che associa la Feature indicata, la quale si adatta allo slot vuoto indicato e all’altro slot vuoto indicato). Associala sotto il nome dello slot che deve riempire.)

È posizionato sulla chiave dell’associazione nel documento che l’ha scritta, e classificato sotto l’autore di quel documento. Un’associazione sul blocco features: proprio del componente nell’Aggregate viene segnalata su .spec.components.<component>.features.<attachment> come errore dello sviluppatore; una che solo la Release ha scritto, sulla sua voce per il componente, viene segnalata lì — sotto il confine che nomina il componente, .spec.boundaries.<boundary>.components.<component>.features.<attachment> — come errore dell’operatore:

[OPS_ERROR E0328] release.yaml at .spec.boundaries.main.components.app.features.metrics
attachment written under a name no slot declares fits a slot its component leaves empty ("metrics", on component "app", attaching the Feature "core/prometheus-exporter", which fits the empty slot "identity"). Attach it as "identity" to fill the slot.

Lo slot vuoto in sé è un rilievo separato dove è richiesto, segnalato sul componente nell’Aggregate sotto «Required attachment slot not bound (Slot di associazione richiesto non legato)».

In che cosa differisce dall’avviso di quasi corrispondenza. L’avviso descritto in «An attachment name is one edit from a declared slot (Un nome di associazione è a una modifica di distanza da uno slot dichiarato)» riguarda il modo in cui un nome è scritto: un nome a una modifica di distanza da uno slot il cui selector: la Feature dell’associazione non soddisfa, che non ferma il build e segnala un avvertimento. Questo arresto riguarda ciò a cui la Feature si adatta, qualunque sia il nome: il nome può essere qualsiasi, e lo slot a cui si adatta deve essere stato lasciato vuoto. Dove un nome è a una modifica di distanza da uno slot e la sua Feature si adatta effettivamente a quello slot, non viene sollevato alcun avviso, e se lo slot resta vuoto questo arresto è l’unico rilievo segnalato.

Come risolvere: associala sotto il nome dello slot, così che riempia lo slot — il messaggio nomina lo slot, o ogni candidato quando ce ne sono diversi. Se si tratta davvero di un’associazione separata, riempi anche lo slot, poiché un’associazione aggiuntiva è libera una volta che ogni slot a cui si adatta è legato; oppure, dove deve raggiungere più componenti, associala al sottosistema o al confine di Release in cui si trovano. Se la Feature non deve mai riempire quello slot, restringi il selector: dello slot nel Component che lo dichiara.

An attachment delivers a key another inject source already claimed (Un’associazione consegna una chiave già rivendicata da un’altra fonte di inject)

Tre superfici di authoring consegnano nel canale di iniezione di un componente attraverso un blocco inject:: il blocco inject: proprio del componente, i blocchi inject: sulle voci del suo blocco di dipendenze e il blocco su ciascuna Feature associata a esso. Condividono un unico spazio con chiave per ogni meccanismo di consegna, quindi una chiave rivendicata da due di esse è ambigua riguardo a quale valore arrivi, e il build si ferma anziché lasciare che una superficie ne sostituisca un’altra in silenzio. Una Feature associata può consegnare anche in un secondo modo, tramite l’injectMapping della sua FeatureRecipe; quella via incontra lo stesso spazio dopo che ogni blocco ha consegnato, e viene segnalata più sotto in «Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Due Features associate consegnano una stessa chiave, la successiva tramite l’injectMapping della sua FeatureRecipe)».

Questa condizione è il lato di quello spazio che riguarda il blocco dell’associazione. Viene segnalata quando il blocco inject: proprio di un’associazione rivendica una chiave che una consegna precedente detiene già — la voce più sopra, «Duplicate delivery key across inject sources (Chiave di consegna duplicata tra le fonti di inject)», è la stessa regola letta dal lato scritto dallo sviluppatore, e insieme coprono la rivendicazione di ogni blocco.

È l’ordine a decidere chi è entrato in collisione. La prima rivendicazione sotto una chiave è quella che la detiene, e le rivendicazioni successive sono quelle segnalate — così a un’associazione la cui chiave è già presa viene detto, mentre a un’associazione che ha rivendicato per prima non viene detto nulla di una successiva che non ha sostituito niente. Una rivendicazione che non ha consegnato nulla lascia libera la chiave e non partecipa a niente di tutto questo.

Il rilievo è posizionato sulla voce propria dell’associazione all’interno del blocco del componente, che è la posizione da modificare; il messaggio nomina la chiave e il meccanismo nel cui spazio con chiave si trova. Ogni chiave in collisione viene segnalata a sé, così un’associazione che duplica due chiavi ti informa su entrambe.

Messaggio emesso:

duplicate delivery key across attachment-inject and another inject source ("<key>", mechanism "<mechanism>") (chiave di consegna duplicata tra l’inject dell’associazione e un’altra fonte di inject (la chiave indicata, il meccanismo indicato))

Come risolvere: nessuno dei due lati è il responsabile e spetta a te intervenire su entrambi. Rinomina la chiave sul lato che controlli — più spesso la voce inject: propria del componente, poiché la mappatura della Feature è scritta in un documento di catalogo — oppure elimina una delle due consegne. Dove l’associazione è davvero destinata a fornire il valore, rimuovi la rivendicazione scritta dallo sviluppatore anziché quella dell’associazione. Nota che un injectMapping della FeatureRecipe di una Feature che scrive una chiave è una via diversa e non viene segnalato qui: riscrivere una chiave consegnata dal blocco inject: proprio del componente o da una delle sue connessioni è un’intercettazione e non viene segnalato affatto, e scrivere una chiave consegnata da un’altra Feature associata viene segnalato sotto la voce seguente.

Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Due Features associate consegnano una stessa chiave, la successiva tramite l’injectMapping della sua FeatureRecipe)

Una Feature associata consegna nel canale di iniezione del suo componente per due vie: il blocco inject: scritto sull’associazione e l’injectMapping della sua FeatureRecipe, il cui output nomina la chiave di consegna — spesso a partire da un valore che l’associazione porta, come la variabile d’ambiente scelta per una credenziale. Quando due Features associate arrivano a una stessa chiave sotto uno stesso meccanismo di consegna, e la successiva delle due vi arriva tramite la sua mappatura, il build si ferma. Se lo si lasciasse proseguire, il componente leggerebbe il valore scritto per ultimo, qualunque fosse, così una credenziale potrebbe essere presentata al posto di un’altra senza che nulla nell’output lo dica.

Copre ogni Feature associata, ovunque sia stata associata: il blocco features: proprio del componente, un sottosistema, un confine di Release o una voce di componente della Release, l’espansione di un’annotazione e la voce features: di una connessione. La prima delle due consegne può essere la mappatura dell’altra Feature o il suo stesso blocco inject: — il build segnala entrambi gli abbinamenti sotto quest’unica condizione.

È l’ordine a decidere chi è entrato in collisione. Ogni blocco inject: consegna prima che venga renderizzata qualsiasi mappatura, e le mappature vengono renderizzate in un unico ordine fisso — l’ordine in cui la mappatura di inject percorre le Features associate di un componente, descritto nella pipeline di compilazione — quindi la prima consegna sotto una chiave è quella che la detiene, e la Feature successiva è quella segnalata. Decide la sola presenza: i valori non vengono confrontati, quindi due Features che consegnano lo stesso valore sotto una stessa chiave vengono comunque segnalate. Una chiave che l’output di una mappatura non porta affatto non è una consegna; una chiave che porta con un valore vuoto lo è, perché il valore vuoto sostituisce ciò che c’era prima. Una stessa chiave sotto due meccanismi di consegna diversi sono due chiavi, non una collisione.

Che cosa non viene segnalato. Un injectMapping di una FeatureRecipe che riscrive una chiave consegnata dal blocco inject: proprio del componente o da uno dei blocchi inject: delle sue connessioni è un’intercettazione — una Feature di instradamento che qualifica un host, una guardia che reindirizza un upstream — e il valore della mappatura sostituisce quell’unica voce. La mappatura di una Feature che riscrive una chiave consegnata dal suo stesso blocco inject: è quella Feature che trasforma la propria consegna, e nemmeno essa viene segnalata.

Il rilievo è posizionato sulla voce propria della Feature successiva — all’interno del blocco features: del componente oppure, per una Feature portata da una connessione, sulla sua voce sotto quella connessione nel documento che l’ha scritta, come .spec.components.<component>.uses.<socket>.<alias>.features.<slot> nell’Aggregate. Il messaggio nomina la chiave, il meccanismo di consegna ed entrambe le Features con i nomi che portano sul componente; una Feature portata da una connessione è nominata con l’alias della connessione e lo slot che riempie, uniti da un punto. Ogni chiave in collisione viene segnalata a sé.

Messaggio emesso:

duplicate delivery key across two attachments: an attachment’s FeatureRecipe writes a delivery key another attachment already delivered ("<key>", mechanism "<mechanism>", attachment "<attachment>", delivered first by attachment "<other-attachment>"). Give one of the two attachments a key of its own, or attach one fewer: the key this attachment delivers under is chosen by its FeatureRecipe, which can read the attachment’s own values and infra, and the other’s is chosen the same way or by its own inject block where it delivered through one. A Release sets an attachment’s infra and never its values, so where a key is chosen by a value, attach that attachment in the Aggregate with the value, and keep giving the rest from the Release. (chiave di consegna duplicata tra due associazioni: la FeatureRecipe di un’associazione scrive una chiave di consegna che un’altra associazione ha già consegnato. Assegna a una delle due associazioni una chiave propria, oppure associane una in meno: la chiave con cui questa associazione consegna è scelta dalla sua FeatureRecipe, che può leggere i values e l’infra dell’associazione stessa, e quella dell’altra è scelta allo stesso modo oppure dal suo blocco inject, se ha consegnato tramite uno di essi. Una Release imposta l’infra di un’associazione e mai i suoi values, quindi, dove una chiave è scelta da un valore, effettua quell’associazione nell’Aggregate insieme al valore e continua a fornire il resto dalla Release.)

Come risolvere: assegna a una delle due Features una chiave propria — per una Feature di credenziali, di solito è la chiave che i suoi valori nominano — oppure rimuovi una delle due associazioni. Dove entrambe sono destinate a fornire una stessa variabile, decidi quale il componente deve leggere e associa solo quella. Due credenziali che una Release associa da sola arrivano entrambe sotto la chiave che la loro Feature nomina per impostazione predefinita, perché una Release non può scrivere i values di un’associazione: associa una delle due nell’Aggregate con il valore che ne nomina la chiave e fornisci la sua origine dalla Release nella stessa voce.

A component declares an inject mechanism the attached Feature maps nothing to (Un componente dichiara un meccanismo di inject a cui la Feature associata non mappa nulla)

L’allowlist spec.inject di un Component può nominare meccanismi di consegna oltre a quelli standard — un meccanismo che la logica interna del componente stesso comprende, e per il quale qualsiasi cosa consegni al componente deve produrre un valore. Quando una Feature è associata a un componente del genere, l’injectMapping della FeatureRecipe è ciò che dice sotto quale meccanismo viene consegnato ciascun valore che produce. Un meccanismo che il componente ha dichiarato e per cui la mappatura non produce alcuna chiave è una consegna che silenziosamente non avverrebbe mai, quindi il build si ferma.

Una mappatura che non dice nulla sui meccanismi non è una mappatura che li esclude tutti. Una FeatureRecipe la cui mappatura viene renderizzata come un dizionario piatto di consegne non afferma nulla sui meccanismi — è la forma ordinaria per una Feature che produce consegne come variabili d’ambiente — e lo stesso vale per un’associazione che lega una FeatureRecipe senza alcuna mappatura da valutare. Nessuna delle due viene segnalata qui; questa condizione riguarda solo una mappatura che nomina dei meccanismi e ne omette uno che il componente ha dichiarato.

Ogni meccanismo non mappato è un rilievo a sé, così un componente che ne dichiara due, nessuno dei quali è mappato da un’associazione, ti informa su entrambi. Il rilievo è posizionato sulla voce dell’associazione nel tuo file, e nomina anche la FeatureRecipe — perché è il documento in cui è scritta la mappatura, e si trova tutt’altrove.

Messaggio emesso:

custom inject mechanism has no matching key in injectMapping output; add the mechanism’s key to the Recipe injectMapping ("<mechanism>", recipe "<featurerecipe>") (il meccanismo di inject personalizzato non ha una chiave corrispondente nell’output dell’injectMapping; aggiungi la chiave del meccanismo all’injectMapping della Recipe (il meccanismo indicato, la FeatureRecipe indicata))

Come risolvere: il messaggio nomina entrambe le metà. Aggiungi la chiave del meccanismo all’injectMapping della FeatureRecipe in modo che la Feature produca un valore per esso, oppure elimina il meccanismo dall’allowlist spec.inject del Component dove nulla deve consegnare sotto di esso. Dove la FeatureRecipe appartiene al catalogo di qualcun altro, associare una Feature la cui mappatura copre il meccanismo è la terza soluzione.

An attached Feature’s injectMapping output cannot be read (L’output injectMapping di una Feature associata non può essere letto)

L’injectMapping di una FeatureRecipe è un template, e ciò che produce viene letto come YAML: un dizionario con chiavi per meccanismo di consegna — env, file, arg o un meccanismo proprio del componente — oppure un dizionario piatto di consegne d’ambiente. Quando l’output non si legge come nessuno dei due, nessuna delle sue chiavi può essere consegnata, quindi il build si ferma anziché renderizzare il componente come se la Feature associata non avesse consegnato nulla. Una credenziale è il caso che conta di più: un componente che si aspetta una password mai ricevuta potrebbe altrimenti funzionare senza, e nulla nell’output lo direbbe.

La causa abituale è un valore che il template ha scritto tra virgolette così com’è. Un doppio apice al suo interno chiude anticipatamente lo scalare tra virgolette, e una barra rovesciata avvia una sequenza di escape che YAML può non riconoscere, quindi una mappatura che viene renderizzata correttamente per la maggior parte dei valori si rompe per quello che contiene un carattere del genere — spesso una password. Un output vuoto, o che viene interpretato come un dizionario che non consegna nulla, non rientra in questa condizione: non consegna nulla, ed è ciò che dice.

La cornice sopra il messaggio nomina il componente in fase di rendering, poi l’associazione con il nome che porta sul componente e la FeatureRecipe in cui è scritta la mappatura, come feature "<attachment>" (recipe "<featurerecipe>") injectMapping output. Sotto il messaggio c’è il motivo per cui non è stato possibile leggere l’output — la riga e ciò che YAML vi ha trovato, come yaml: line 2: found unknown escape character. Dove il template legge un valore che un autore ha dichiarato sensibile e il motivo dipende da ciò che quel valore contiene, il motivo viene omesso e al suo posto compare una frase che lo dice, così l’arresto non cita mai il valore che ha rotto l’output. Il build segnala l’arresto sotto un tag CATALOG_ERROR, perché la mappatura è scritta dall’autore della FeatureRecipe.

Messaggio emesso:

FeatureRecipe injectMapping output could not be read as a dictionary of deliveries (non è stato possibile leggere l’output injectMapping della FeatureRecipe come dizionario di consegne)

Come risolvere: nell’injectMapping della FeatureRecipe, scrivi ogni valore tramite toJson — {{ .values.key }}: {{ .values.origin | toJson }} — che lo scrive come stringa JSON che YAML rilegge esattamente, qualunque carattere contenga. Dove la FeatureRecipe appartiene al catalogo di qualcun altro, si può anche modificare il valore in modo che non contenga doppi apici né barre rovesciate finché la mappatura non viene corretta.

An attached Feature’s injectMapping output writes deliveries under a key nothing delivers (L’output injectMapping di una Feature associata scrive consegne sotto una chiave che nulla consegna)

L’output dell’injectMapping di una FeatureRecipe viene unito al canale di iniezione del componente in base alle sue chiavi di primo livello. env, file e arg vengono consegnati come quei meccanismi, e qualsiasi altra chiave viene consegnata come meccanismo a sé con quel nome, che la Recipe del componente legge in .context.inject.<name>. La vista all è diversa: è costruita a partire dai meccanismi dopo l’unione, mai unita da un output, quindi i valori che una mappatura scrive sotto all: non raggiungono nulla. L’output si legge comunque senza errori, quindi senza questo arresto un build che legge quei valori in modo facoltativo riesce senza di essi — una credenziale scritta lì non raggiunge mai il componente, e nulla nel build nomina la mappatura che l’ha persa.

Si applica ovunque all: porti almeno una voce, da solo o accanto ad altri meccanismi; gli altri meccanismi nello stesso output non sono il problema, e un all: scritto vuoto non perde nulla e non viene segnalato. Un dizionario piatto che per caso porta una chiave chiamata all con un singolo valore è una consegna d’ambiente chiamata all, non questa condizione.

Il rilievo è posizionato sulla voce dell’associazione nel tuo file, e nomina la chiave e la FeatureRecipe in cui è scritta la mappatura — perché è quello il documento da modificare, e si trova tutt’altrove — insieme alle chiavi che un output può portare. Ogni chiave del genere è un rilievo a sé. Il build lo segnala sotto un tag CATALOG_ERROR.

Messaggio emesso:

FeatureRecipe injectMapping output writes a key no delivery mechanism of the host reads ("all", recipe "<featurerecipe>", an output may carry "env, file, arg, or a custom mechanism the host's Recipe reads under its own name") (l’output injectMapping della FeatureRecipe scrive una chiave che nessun meccanismo di consegna dell’host legge (la chiave all, la FeatureRecipe indicata e le chiavi che un output può portare))

Come risolvere: nell’injectMapping della FeatureRecipe, sposta le voci da sotto all: al meccanismo da cui il componente le legge — di solito env:, o il nome del meccanismo che la Recipe del componente legge. Dove la FeatureRecipe appartiene al catalogo di qualcun altro, associa invece una Feature la cui mappatura consegna il valore.

Durante il rendering dell’output

Dopo che ogni contratto è stato validato, il compilatore valuta i template Go sui valori dei Component, sui blocchi injectMapping delle FeatureRecipe e sui sorgenti delle Recipe e delle FeatureRecipe, quindi passa il risultato al renderer.

provides: template references a non-self-contained root (Il template di provides fa riferimento a una radice non autocontenuta)

Il template provides: di una Recipe fa riferimento a una radice al di fuori dell’insieme autocontenuto. Il blocco provides viene valutato durante la valutazione dei provides, prima che il canale di inject venga idratato e prima che vengano percorsi gli archi tra nodi, quindi può fare riferimento solo a dati che appartengono al proprio nodo: .context.instance_id, .context.rendered_name dove il provider del nodo ne riporta uno, .values, .infra, i .locals risolti del nodo e stringhe statiche. Il controllo è un’allowlist positiva, quindi qualsiasi altra radice provoca un arresto — .context.inject e .context.uses (tra nodi), .context.annotations.*, .context.labels, .context.metadata e .metadata.* (dati legati alla collocazione o alla distribuzione che la superficie dei provides non espone) e .attachment_name (il passaggio dei provides di una Recipe base non risolve alcuna associazione). Fare riferimento a una di queste radici provoca un arresto esplicito anziché il rendering silenzioso di un valore vuoto.

.locals fa parte della superficie: i locals di un nodo si risolvono nel preambolo della stessa fase, prima dei suoi provides, quindi un template provides li legge e riceve valori risolti.

Messaggio emesso:

provides block references a root outside the self-contained set ("<expression>") (il blocco provides fa riferimento a una radice al di fuori dell’insieme autocontenuto (con l’espressione indicata))

L’arresto è posizionato sulla Recipe che dichiara la voce e sulla chiave scritta al suo interno — .spec.provides.<name> — quindi nomina il blocco da modificare anziché il componente che ha legato la Recipe. Ogni voce che esce dalla superficie viene segnalata nello stesso build; dove sono più d’una, i rilievi vengono raggruppati sotto provides entries that reach outside the data they are evaluated against.

Come risolvere: riscrivi il template in modo che attinga solo dai pilastri propri della Recipe. Se il valore dipende dall’output di un altro nodo, quella dipendenza appartiene al blocco uses[].inject di un chiamante, non ai provides della destinazione. Se il valore è calcolato, metti l’espressione in una voce locals: e leggila da provides — così l’espressione vive in un solo punto. Se cercavi di raggiungere il namespace di distribuzione (o altri dati di collocazione) per costruire un host tra namespace, pubblica qui l’host nudo e qualificalo dal lato del consumatore con una funzionalità di instradamento — i provides del produttore non devono dipendere da dove è stato distribuito.

Il provides: di una FeatureRecipe segue la stessa regola dei locals: i suoi locals: si risolvono prima del suo provides:, quindi anche una voce provides di una FeatureRecipe legge .locals.

locals: entry references a sibling defined later in the same block (Una voce di locals fa riferimento a una voce sorella definita più avanti nello stesso blocco)

Un blocco locals: si risolve nell’ordine in cui sono scritte le sue voci, e una voce legge solo una voce sorella definita sopra di essa. Un riferimento diretto .locals.<key> a una voce che il blocco definisce più avanti provoca un arresto: il compilatore non ordina né riordina mai il blocco per far risolvere il riferimento, perché l’output emesso seguirebbe allora un’inferenza anziché ciò che è stato scritto. Senza l’arresto il riferimento si risolverebbe, tramite la politica delle chiavi mancanti, in una stringa vuota, quindi un hostname o un nome di secret derivato perderebbe silenziosamente il segmento da cui era stato costruito.

Entrambe le risoluzioni di un blocco locals: decidono questo errore, e una di esse è il fissaggio. Un blocco viene risolto per due scopi diversi: perché i template propri della Recipe possano leggerlo mentre viene eseguito il rendering di un artefatto, e perché una coordinata source: strutturata possa essere risolta e l’artefatto che nomina possa essere fissato. L’errore viene deciso a partire dall’ordine delle chiavi dichiarato e dal testo scritto, che è tutto ciò di cui ha bisogno, quindi entrambe le risoluzioni lo raggiungono e segnalano la stessa condizione — aggrega pull, e un build che riempie il lockfile, rifiutano il blocco esattamente come fa un rendering. Due conseguenze vale la pena conoscere durante la scrittura. Mentre viene risolta una coordinata viene letto l’intero blocco, quindi una voce fuori ordine provoca un arresto anche dove ogni campo source: è letterale e non legge alcun local. E una Recipe il cui source: è una semplice stringa, o che non dichiara alcun source:, non risolve alcuna coordinata, quindi su quella Recipe l’errore viene segnalato quando viene eseguito il rendering dell’output.

Messaggio emesso, per una voce nel blocco locals: proprio della Recipe di un componente. È posizionato sulla chiave scritta all’interno della Recipe, e ogni voce in errore viene segnalata in un solo build; dove sono più d’una, i rilievi vengono raggruppati sotto locals entries that read a sibling they cannot:

locals entry references a sibling defined later in the same block ("<expression>", the key it names is "<referenced>", resolved at this point "<the locals available here>", reached through the component "<component>"). define "<referenced>" above "<key>" in the locals block (la voce di locals fa riferimento a una voce sorella definita più avanti nello stesso blocco (con l’espressione, la chiave che nomina, i locals risolti a questo punto e il componente attraverso cui è stata raggiunta indicati). definisci la chiave nominata sopra la voce indicata nel blocco locals)

Un autoriferimento è la stessa condizione — la chiave è dichiarata e non risolta — e nessun riordinamento lo risolve, quindi il messaggio lo dice al posto dell’istruzione di spostamento:

locals entry references a sibling defined later in the same block ("<expression>", the key it names is "<key>", resolved at this point "<the locals available here>", reached through the component "<component>"). a locals entry cannot read itself; compute the value from .values and .infra directly (la voce di locals fa riferimento a una voce sorella definita più avanti nello stesso blocco (con l’espressione, la chiave che nomina, i locals risolti a questo punto e il componente attraverso cui è stata raggiunta indicati). una voce di locals non può leggere sé stessa; calcola il valore direttamente da .values e .infra)

Una Recipe è legata da molti componenti, quindi un errore in un blocco condiviso viene segnalato una volta per ciascun componente che lo lega — e reached through the component è ciò che distingue quei rilievi. Condividono una posizione, perché riguardano tutti la stessa voce scritta nello stesso documento; la posizione è dove modificare, e il nome del componente è quale dei tuoi componenti rappresenta ciascun rilievo. I rilievi non vengono uniti in uno solo, perché unirli direbbe che qualcosa non va senza dire quali componenti raggiunge, ed è proprio la parte su cui devi agire.

Lo stesso errore in un blocco locals: dichiarato dalla ricetta di una Feature viene segnalato allo stesso modo: posizionato sulla chiave scritta all’interno di quella ricetta, nominato dal componente su cui si trova l’associazione e raggruppato con eventuali voci sorelle che portano lo stesso errore. Dove la ricetta è associata in più di un punto, l’errore viene segnalato una volta per ciascuno — ogni associazione lega quel blocco in modo indipendente, quindi ciascuna è un’occorrenza a sé anziché la ripetizione di una sola.

Dove quella forma segnala un autoriferimento, la sua clausola di posizione nomina la voce che fa il riferimento stessa anziché una successiva, perché è lì che si trova la chiave.

Come risolvere: sposta la voce a cui si fa riferimento sopra chi la legge. Riordinare un blocco locals: è una modifica di comportamento ovunque una voce ne legga un’altra, quindi la correzione è esattamente il riordinamento che il messaggio nomina. Un autoriferimento — una voce che nomina la propria chiave — non può essere corretto con un riordinamento; calcola invece il valore direttamente da .values e .infra, come dice il messaggio al posto dell’istruzione di spostamento.

locals: key does not exist (La chiave di locals non esiste)

Un template legge .locals.<key> per una chiave che il blocco locals: non dichiara affatto — un errore di ortografia, o una chiave che è stata rinominata o rimossa. Ogni superficie che legge il pilastro solleva questo arresto: una voce locals:, un template provides:, un template source: di una Recipe e la risoluzione di una coordinata source: strutturata, che legge l’intero blocco per fissare l’artefatto che la coordinata nomina. Il pilastro dei locals è una mappa aperta a chiavi, quindi una chiave sconosciuta al suo interno supera il controllo della radice e altrimenti si risolverebbe in una stringa vuota; l’arresto è ciò che impedisce a quel valore vuoto di raggiungere un artefatto emesso.

Messaggio emesso, dove il riferimento in errore si trova in un template provides::

template references a key the locals block does not declare (Recipe <recipe> provides[<key>] references <expression>, the locals block declares no <referenced>, it declares <the keys it does declare>). correct the key name (il template fa riferimento a una chiave che il blocco locals non dichiara (la voce di provides indicata della Recipe indicata fa riferimento all’espressione indicata, il blocco locals non dichiara la chiave indicata, dichiara le chiavi indicate). correggi il nome della chiave)

Messaggio emesso, dove si trova in una voce locals: stessa. Porta il componente attraverso cui il blocco è stato legato, per il motivo che espone l’arresto per l’ordinamento qui sopra — un blocco condiviso viene segnalato una volta per ogni componente che lo lega, ed è questo a distinguere quei rilievi:

template references a key the locals block does not declare ("<expression>", the missing key is "<referenced>", the block declares "<the keys it does declare>", reached through the component "<component>"). correct the key name (il template fa riferimento a una chiave che il blocco locals non dichiara (con l’espressione, la chiave mancante, le chiavi che il blocco dichiara e il componente attraverso cui è stata raggiunta indicati). correggi il nome della chiave)

Come risolvere: correggi il nome della chiave con uno che il blocco dichiara; il messaggio li elenca. L’arresto è distinto dall’arresto per l’ordinamento qui sopra perché i rimedi differiscono — nessun riordinamento fa risolvere una chiave che non esiste.

Il controllo legge il percorso a cui un riferimento si risolve anziché i caratteri digitati, quindi un alias del blocco viene seguito: una chiave raggiunta tramite il punto che un corpo with .locals ricollega, o tramite una variabile legata a .locals, viene controllata esattamente negli stessi termini della scrittura diretta e provoca un arresto allo stesso modo, e lo stesso vale per una chiave letta dal blocco tra parentesi — {{ (.locals).nope }} o {{ ($.locals).nope }} — perché le parentesi producono il blocco stesso e nient’altro. Una sola scrittura sfugge al controllo: una chiave raggiunta tramite una chiamata il cui risultato il testo del template non può nominare — {{ index .locals "nope" }}, oppure {{ (default dict .locals).nope }} — perché ciò che una tale chiamata produce viene deciso quando il template viene eseguito anziché da ciò che è scritto. Una chiave assente letta come campo dal risultato di una tale chiamata — la forma (default dict .locals).nope — non provoca un arresto, e produce il testo segnaposto del motore di template <no value>. Una chiave assente raggiunta tramite index provoca un arresto, ma come «A template indexes a map with a key the map does not hold (Un template indicizza una mappa con una chiave che la mappa non contiene)» più sotto anziché come questo controllo: index provoca un arresto su qualsiasi chiave di mappa che la mappa non contiene. index resta quindi il modo per raggiungere una chiave il cui nome è esso stesso calcolato, e un nome calcolato che il blocco non dichiara viene comunque segnalato per la sua chiave.

Template references a root the render context does not define (Il template fa riferimento a una radice che il contesto di rendering non definisce)

Un template fa riferimento a una radice di primo livello — il primo segmento del percorso dopo il punto iniziale — che il suo contesto di rendering non definisce: un errore di ortografia come {{ .valeus.port }}, o una radice che non esiste sulla superficie che si sta scrivendo. Il controllo è un’allowlist positiva sui nomi delle radici, e l’insieme ammesso è derivato dalla forma stessa del contesto di rendering anziché essere mantenuto come elenco separato accanto a esso, quindi l’insieme che il build rifiuta e l’insieme che il contesto effettivamente fornisce non possono divergere. La diagnostica nomina il riferimento in errore ed elenca le radici che quel contesto definisce.

L’arresto scatta in modo identico sia che il riferimento sia nudo sia che sia racchiuso in un fallback default, if, with o range, e la forma racchiusa è quella che conta di più: un wrapper può fornire un fallback per una chiave assente sotto una radice definita, ma mai per una radice assente, quindi senza questo arresto la forma racchiusa si risolverebbe silenziosamente in un valore vuoto e lascerebbe terminare il build con successo. Una chiave assente sotto una radice definita non viene toccata e segue ancora la politica missingkey=zero per i template di valore descritta in «Missing template key — asymmetric policy (Chiave di template mancante — politica asimmetrica)» più sotto, quindi idiomi a chiave opzionale come {{ .values.optional_field | default "fallback" }} continuano a funzionare.

Lo stesso arresto copre una chiave digitata male un livello più in basso, sotto un pilastro la cui forma è dichiarata. Alcuni pilastri hanno un insieme di chiavi che il compilatore definisce: .context, .metadata, .inject, .workload e .boundary nel contesto di rendering di Recipe e FeatureRecipe, e .manifest in un template di percorso. Un riferimento a una chiave che uno di quei pilastri non definisce — {{ .context.nmae }}, {{ .metadata.typo }}, {{ .workload.containres }}, {{ .boundary.nmae }} — provoca un arresto esattamente come una radice sbagliata, e la diagnostica elenca le chiavi che quel pilastro definisce. Nei template propri dell’associazione di una Feature, .inject definisce una chiave in più per ogni meccanismo di consegna che il blocco inject: dell’associazione stessa nomina, accanto a env, file, arg e all: un’associazione che scrive un meccanismo vault_ref: si legge in {{ .inject.vault_ref.VAULT_PATH }}, e la diagnostica elenca .inject.vault_ref tra le chiavi che .inject definisce. Un meccanismo che l’associazione non nomina provoca un arresto anche dentro un if o un with, perché il riferimento viene controllato prima che il template venga eseguito. Per leggerne uno che l’associazione potrebbe non nominare, proteggilo: {{ with .inject }}{{ if hasKey . "vault_ref" }}{{ index . "vault_ref" "VAULT_PATH" }}{{ end }}{{ end }}. Con la coppia protetta il build riesce sia che l’associazione nomini il meccanismo sia che non lo nomini, e sia che scriva un blocco inject: sia che non ne scriva affatto — in quel caso .inject non contiene nulla, quindi il with salta il proprio corpo, mentre hasKey applicato direttamente a .inject provocherebbe un arresto su un valore che non è una mappa. All’interno della protezione, index provoca comunque un arresto su una chiave che il meccanismo nominato non contiene. Altri pilastri sono aperti, perché ciò che contengono sono dati a chiave anziché un insieme che il compilatore dichiara — tra questi .values, .infra, .locals, .provides, .features e .steps nel contesto di rendering, e .parameters e .parent_boundary in un template di percorso. Un pilastro aperto accetta qualsiasi chiave. Una chiave assente sotto un pilastro aperto non è questo arresto — segue la politica delle chiavi mancanti della superficie descritta in «Missing template key — asymmetric policy (Chiave di template mancante — politica asimmetrica)» più sotto, quindi {{ .values.optional_field | default "fallback" }} e ogni altro idioma a chiave opzionale continuano a funzionare.

Quali pilastri sono dichiarati e quali sono aperti è una proprietà della superficie, non qualcosa che un template possa influenzare: il compilatore lo legge dalla forma del contesto di rendering che sta per fornire. È questo che permette all’arresto per l’errore di battitura e al rendering della chiave opzionale di avvenire sullo stesso template.

Una superficie può anche restringere una chiave che il suo pilastro altrimenti definisce, e una segnalazione del genere non è un errore di ortografia. Dove una chiave porta una risposta priva di significato — o che appartiene a un nodo diverso — su una particolare superficie, quella superficie rifiuta il riferimento anziché risolverlo nella cosa sbagliata, e la diagnostica elenca le chiavi che definisce. Due casi da conoscere, entrambi {{ .context.rendered_name }}. Nei template propri di un’associazione di Feature, la chiave porta il nome del componente host così come lo riporta il provider proprio dell’host, quindi viene rifiutata sull’associazione di un host il cui provider non riporta alcun nome — un host che colloca da solo un insieme di artefatti, o uno che esegue il rendering tramite un provider che non deriva un tale nome — e ammessa su ogni altro host. {{ .context.instance_id }} è ammessa su quella superficie e nomina il componente host per cui l’associazione si sta risolvendo, che è ciò da cui prendono il nome le risorse proprie dell’host su un tale host. Nelle voci locals: di una Recipe, la chiave viene rifiutata qualunque cosa riporti il provider del nodo: un local condivide il suo contesto con il template source: della Recipe, e il fatto che il nodo fornisca o meno un sorgente è una delle cose da cui il nome dipende, quindi lì il nome non viene offerto. La diagnostica elenca .context.instance_id come l’unica chiave che .context definisce lì; leggi invece il nome renderizzato in una voce provides: o in un template inline. Vedi ../templates/rendered-resource-names.md per ciò che ciascuna delle due chiavi nomina e dove ciascuna è leggibile.

Messaggio emesso quando la radice stessa non è definita:

template references a root the render context does not define (template <template-name> references <dotted-path>, the render context defines <the roots that context defines>) (il template fa riferimento a una radice che il contesto di rendering non definisce (il template indicato fa riferimento al percorso indicato, il contesto di rendering definisce le radici indicate))

E quando la radice è corretta ma una chiave sotto un pilastro dichiarato non lo è:

template references a root the render context does not define (template <template-name> references <dotted-path>, <pillar> defines <the keys that pillar defines>) (il template fa riferimento a una radice che il contesto di rendering non definisce (il template indicato fa riferimento al percorso indicato, il pilastro indicato definisce le chiavi indicate))

Come risolvere: correggi il riferimento con uno che la diagnostica elenca — la maggior parte delle segnalazioni è un errore di ortografia di .values, .infra o .context, o di una chiave sotto .context o .metadata. Rimuovere il wrapper di fallback non elimina l’arresto, e aggiungerne uno non lo ha mai soppresso; il wrapper nascondeva soltanto quale riferimento fosse sbagliato. Se i dati appartengono davvero a un altro nodo, raggiungono questo template attraverso il canale di inject — cablali con una voce uses[].inject sul consumatore e leggili da .context.inject — anziché attraverso una radice propria.

Il controllo copre ogni superficie di template che il renderer valuta, ciascuna rispetto all’insieme di riferimenti che la propria superficie definisce: valuesMapping, injectMapping, workload di Recipe e FeatureRecipe, i corpi di artifacts:, le voci provides: e locals:, source:, i corpi when: e with: dei passi di pipeline, assertions:, i template value: di self-inject a livello di componente in un Aggregate e i template di percorso dei confini della Release (directory: / subDirectory:). Due di queste superfici nominano alcuni rifiuti con una diagnostica propria, perché l’errore che descrivono è più specifico di «questo riferimento non esiste»: un template di percorso che cerca di raggiungere una variabile che non gli viene fornita è coperto da «Path-template references a variable outside the allowlist (Il template di percorso fa riferimento a una variabile al di fuori dell’allowlist)» più sotto, e una FeatureRecipe a livello di confine che cerca di raggiungere un pilastro per componente da «FeatureRecipe template references a field outside its scope’s allowlist (Il template della FeatureRecipe fa riferimento a un campo al di fuori dell’allowlist del suo livello)». Tutto il resto che quelle due superfici rifiutano — inclusa una chiave digitata male sotto un pilastro che ammettono — segnala questo arresto, quindi nessuna diagnostica ti dice che il tuo riferimento è qualcosa che non è.

An artifacts: template reads a pillar the Recipe does not declare (Un template di artifacts legge un pilastro che la Recipe non dichiara)

Il template di una voce artifacts: legge .workload, o una chiave al di sotto di esso, in una Recipe che non dichiara alcun workload:; oppure legge .source, o una chiave al di sotto di esso, in una Recipe che non dichiara alcun source:. Entrambi i pilastri sono sempre presenti nel contesto di rendering degli artefatti — sono radici che la superficie definisce — quindi il riferimento è ben formato e l’arresto riguarda l’assenza della dichiarazione anziché un riferimento sbagliato. Una Recipe che esegue il rendering di un Deployment a partire dal proprio workload sintetizzato e una Recipe che esegue il rendering di un chart a partire da un sorgente sono forme diverse, e un corpo artifacts: scritto per una delle due cerca di raggiungere un pilastro che l’altra non riempie mai.

Il controllo viene eseguito prima che la voce sia valutata, ed è questo ordine a rendere utile la segnalazione. Un pilastro assente arriva al template come valore vuoto, quindi, lasciato alla valutazione, il build non inserirebbe nulla nel file emesso oppure fallirebbe con ciò che il motore di template dice sulla lettura di una chave dal nulla — e nessuna delle due cose nomina il pilastro o la dichiarazione mancante. Rifiutare prima permette all’arresto di nominare l’espressione esatta che ha cercato di raggiungere il pilastro, citata così come l’hai scritta.

Un source: dichiarato ma il cui rendering produce una stringa vuota viene letto come nessun sorgente, perché ciò che il controllo legge è il sorgente dopo che il suo template è stato valutato. È lo stesso valore da cui il provider esegue poi il rendering, quindi una Recipe il cui source: si è risolto nel nulla non ha neppure un sorgente da offrire a un corpo artifacts:.

Messaggio emesso, con un’unica forma ovunque sia stata scritta la voce artifacts:. Ciò che varia non è la frase ma le didascalie che la seguono, che dicono quale documento contiene la voce.

Ogni riferimento in errore nel template viene nominato, quindi un corpo che cerca di raggiungere due pilastri assenti ti segnala entrambi anziché solo quello che compare per primo. Ogni riferimento viene segnalato sul documento che dichiara la voce, citato così come l’hai scritto e con la didascalia dell’output a cui appartiene:

artifact template references a pillar the Recipe does not declare (<expression>, artifact <output-name>) (il template di artefatto fa riferimento a un pilastro che la Recipe non dichiara (con l’espressione e l’artefatto indicati))

L’espressione nomina il pilastro nel suo primo segmento, ed è questo a dirti quale dichiarazione manca: .source.chart cerca di raggiungere source:, .workload.containers cerca workload:.

Una voce dichiarata dalla Recipe propria di un componente viene segnalata sul blocco artifacts: di quella Recipe.

Una voce dichiarata da una FeatureRecipe — associata a un componente come funzionalità, o dichiarata su un confine — viene controllata rispetto ai pilastri che dichiara quella FeatureRecipe anziché a quelli del componente host, viene segnalata sul blocco artifacts: della FeatureRecipe e porta un’ulteriore didascalia che nomina l’associazione che la lega:

artifact template references a pillar the Recipe does not declare (<expression>, artifact <output-name>, attachment <attachment-name>) (il template di artefatto fa riferimento a un pilastro che la Recipe non dichiara (con l’espressione, l’artefatto e l’associazione indicati))

La didascalia dell’associazione dice ciò che la posizione da sola non può dire: un componente può portare più associazioni, e un’associazione dichiarata su un confine raggiunge ogni componente che il confine contiene. La frase stessa nomina una Recipe in entrambi i percorsi; sono la posizione e la didascalia dell’associazione insieme a dire quale documento aprire.

Dove un template nomina più riferimenti, ciascuno riceve una segnalazione propria sotto una riga che nomina la voce che condividono, e quella riga nomina anche il documento:

artifact <output-name> references pillars its Recipe does not declare (l’artefatto indicato fa riferimento a pilastri che la sua Recipe non dichiara)

artifact <output-name> references pillars the FeatureRecipe attachment <attachment-name> binds does not declare (l’artefatto indicato fa riferimento a pilastri che la FeatureRecipe legata dall’associazione indicata non dichiara)

Ognuna di queste segnalazioni porta la stessa condizione di arresto, qualunque sia il documento che riguarda, quindi tutto ciò che fa corrispondenza sulla condizione anziché sul testo non vede alcuna differenza tra loro.

Come risolvere: dichiara il pilastro che il template legge, oppure smetti di leggerlo. Dichiararlo è la correzione quando il corpo artifacts: appartiene a quella forma di Recipe — aggiungi il workload: che i riferimenti del template a container, porte o volumi si aspettano, o il source: di cui interpola il percorso del chart o del modulo. Eliminare il riferimento è la correzione quando il corpo è stato scritto per una Recipe diversa e riusa un frammento che qui non si applica; dove il valore proviene davvero da altrove, pubblicalo tramite il provides: del nodo produttore e leggilo dal canale di inject anziché cercare di raggiungere un pilastro che questa Recipe non riempie. Proteggere il riferimento con un wrapper di fallback non elimina l’arresto — manca il pilastro, non la chiave al di sotto — e non lo elimina neppure spostare il riferimento in un’altra voce della stessa Recipe, perché ogni voce di un blocco artifacts: viene valutata rispetto agli stessi pilastri.

Questo arresto è distinto da «Template references a root the render context does not define (Il template fa riferimento a una radice che il contesto di rendering non definisce)» qui sopra, e vale la pena distinguere i due perché i rimedi differiscono. Quello scatta su una radice che la superficie non definisce affatto, o su una chiave digitata male sotto un pilastro la cui forma è fissa — {{ .workload.containres }} su una Recipe che dichiara un workload. Questo scatta su un riferimento scritto correttamente a un pilastro che semplicemente non c’è.

A template reads a rendered name the node’s provider does not report (Un template legge un nome renderizzato che il provider del nodo non riporta)

Un template legge {{ .context.rendered_name }} — il nome che il provider legato dà all’output di cui esegue il rendering per il nodo, a partire da un sorgente fornito dall’autore o da un workload che sintetizza — su un nodo il cui provider non riporta alcun nome del genere. Il riferimento è ben formato e la chiave è una di quelle che il contesto di rendering definisce; ciò che manca è una risposta per questo nodo.

Il rifiuto esiste perché l’alternativa è peggiore di un arresto. Il nome raggiunge un template come semplice stringa, quindi un nodo che non ne ha alcuno farebbe sparire il riferimento nel rendering ed emetterebbe un indirizzo privo di un segmento — .svc.cluster.local dove si intendeva un hostname — con codice di uscita zero, senza nulla da leggere nel build. Quell’artefatto viene distribuito, e ciò che nomina non esiste. Rifiutare prima che qualcosa venga valutato segnala invece l’errore sul template scritto dall’autore.

Se il provider di un nodo riporti un tale nome è stabilito dal legame della Recipe, prima di ogni valutazione, quindi qui nulla viene indovinato.

Due segnalazioni, e quale ricevi dipende dal nodo anziché da dove hai scritto il riferimento. Un nodo che non fornisce alcun sorgente proprio, sotto un provider che non riporta alcun nome per esso, ha risorse che prendono il nome dalla sua identità, quindi esiste un valore corretto e la segnalazione lo nomina. Un nodo che fornisce un sorgente, sotto un provider che non deriva alcun nome per esso, non ha un sostituto — e offrire lì l’identità ti manderebbe verso un valore che non nomina nessuna delle risorse di quel nodo, quindi la segnalazione dice invece questo.

Messaggio emesso, dove il nodo non fornisce alcun sorgente proprio:

template reads the name the target gives the resources it renders for the node, and this node’s provider reports no such name; a conforming template reads a value the node’s own provider supplies (".context.rendered_name", provider "<provider>"). read {{ .context.instance_id }} instead: this node supplies no source of its own, so its resources are named after the node’s identity (il template legge il nome che la destinazione dà alle risorse di cui esegue il rendering per il nodo, e il provider di questo nodo non riporta alcun nome del genere; un template conforme legge un valore fornito dal provider proprio del nodo (con la chiave e il provider indicati). leggi invece la chiave indicata: questo nodo non fornisce alcun sorgente proprio, quindi le sue risorse prendono il nome dall’identità del nodo)

E dove fornisce un sorgente, sotto un provider che non deriva alcun nome del genere:

template reads the name the target gives the resources it renders for the node, and this node’s provider reports no such name; a conforming template reads a value the node’s own provider supplies (".context.rendered_name", provider "<provider>"). write a value that does not depend on a name this target derives: it reports none for the output it renders from supplied source, so there is nothing of that kind to read here (il template legge il nome che la destinazione dà alle risorse di cui esegue il rendering per il nodo, e il provider di questo nodo non riporta alcun nome del genere; un template conforme legge un valore fornito dal provider proprio del nodo (con la chiave e il provider indicati). scrivi un valore che non dipenda da un nome che questa destinazione deriva: non ne riporta alcuno per l’output di cui esegue il rendering a partire da un sorgente fornito, quindi qui non c’è nulla di quel tipo da leggere)

Dove il riferimento si trova in un template diverso da una voce provides:, la segnalazione nomina inoltre il campo in cui è stato scritto — field "valuesMapping", field "artifacts[probe.tf.json]" — perché la chiave di una voce artifacts: è un nome di file di output e contiene il carattere con cui la posizione separa i propri segmenti, quindi la posizione si ferma al blocco che contiene la voce.

Quali template copre: ogni template che una Recipe scrive inline — le sue voci provides:, il suo valuesMapping:, il suo corpo workload:, ogni voce artifacts: e i with: e when: di ogni passo di pipeline. Una superficie di template ne resta fuori: una voce valuesMapping:, workload: o artifacts: fornita tramite $import: — sia che l’import nomini un file locale sia una voce di libreria — non porta alcun testo nella Recipe finché il rendering non la risolve, quindi un riferimento all’interno di un tale corpo viene renderizzato come valore vuoto anziché provocare un arresto.

Come risolvere: leggi la chiave che la segnalazione nomina. Dove l’output del tuo nodo è qualcosa costruito per esso sotto un provider che non riporta alcun nome — un workload sintetizzato, un insieme di artefatti collocato — {{ .context.instance_id }} è il nome che quelle risorse portano effettivamente, ed è il valore giusto anziché un fallback. Dove il tuo nodo fornisce un chart o un modulo proprio e la segnalazione non offre alcun sostituto, il nome che cercavi di raggiungere non è uno che quel provider deriva: pubblica qualcosa che non dipenda da esso, oppure dai un nome alla risorsa nel sorgente che hai fornito e rileggi quel nome da un valore che imposti tu. ../templates/rendered-resource-names.md espone quali provider riportano un nome e, per ciascuno degli altri, perché non ne esiste alcuno da riportare.

A template reads its callers’ render facts without declaring it (Un template legge i fatti di rendering dei suoi chiamanti senza dichiararlo)

Un template in una FeatureRecipe associata a un componente legge render_facts sotto .context.used_by — ciò che i componenti che si connettono all’host dell’associazione hanno riportato sui propri rendering — e la FeatureRecipe non imposta readsCallerRenderFacts: true.

La chiave è ciò che decide quando avviene il rendering dell’associazione. Senza di essa, il rendering dell’associazione avviene subito dopo quello del componente a cui è associata, e un componente che si connette e che viene dopo nell’ordine del build a quel punto non ha ancora eseguito il rendering, quindi ciò che ha emesso non può essere lì da leggere. Rifiutare il template prima di qualsiasi rendering segnala la dichiarazione mancante sul campo che hai scritto, anziché produrre un build il cui template legge ciò che hanno emesso alcuni dei suoi chiamanti e non gli altri.

Messaggio emesso:

template reads its callers’ render facts, but the FeatureRecipe does not set readsCallerRenderFacts (<reference>, written in <field>) (il template legge i fatti di rendering dei suoi chiamanti, ma la FeatureRecipe non imposta readsCallerRenderFacts (con il riferimento e il campo in cui è scritto indicati))

Il riferimento viene citato relativamente alla connessione da cui è stato letto — .render_facts, o .render_facts.<name> — perché un template legge i chiamanti una connessione alla volta, all’interno di {{ range .context.used_by }} o da una connessione che sceglie. Il campo nomina il blocco in cui è stato scritto il template: valuesMapping, workload o artifacts[<output-name>]. Un with: o un when: di un passo di pipeline che legge gli stessi fatti viene invece segnalato dalla voce successiva, qualunque cosa imposti la FeatureRecipe, perché impostare la chiave non permetterebbe a un passo di leggerli. Dove più campi leggono i fatti, ciascuno riceve una segnalazione propria sotto una riga che nomina ciò che condividono:

attachment templates reading their callers’ render facts without declaring it (template di associazione che leggono i fatti di rendering dei propri chiamanti senza dichiararlo)

Come risolvere: imposta readsCallerRenderFacts: true nello spec della FeatureRecipe. Così il rendering delle sue associazioni avviene dopo che ogni componente ha eseguito il rendering, e non cambia nient’altro di ciò di cui eseguono il rendering — vedi la pagina dell’entità FeatureRecipe. La chiave è il contratto, e questo arresto ti aiuta solo a trovare un template che ne ha visibilmente bisogno: il controllo legge il template così come è scritto, quindi un riferimento costruito mentre il template viene eseguito, o uno scritto in contenuto importato da un file o da una libreria, non provoca un arresto — imposta comunque la chiave su una FeatureRecipe del genere. Provoca un arresto anche un template che legge un campo chiamato render_facts da qualche altro elenco accanto a .context.used_by, e lo stesso vale per uno che legge i fatti propri del suo host come .render_facts all’interno di {{ with .context }} accanto a esso — scrivi quelli propri dell’host per esteso come .context.render_facts, che non viene mai scambiato per quelli dei chiamanti; impostare la chiave elimina entrambi i casi senza altro costo che il rendering posticipato.

Una FeatureRecipe che esegue il rendering una sola volta per un confine (executionScope: boundary) non viene controllata qui: i template che producono le sue risorse non hanno alcun .context da leggere, e un riferimento a esso viene invece rifiutato come campo al di fuori dell’allowlist del suo livello.

A pipeline step reads its callers’ render facts (Un passo di pipeline legge i fatti di rendering dei suoi chiamanti)

Il with: o il when: di un passo di pipeline, in una FeatureRecipe associata a un componente, legge render_facts sotto .context.used_by — ciò che i componenti che si connettono all’host dell’associazione hanno riportato sui propri rendering.

Un passo di pipeline non vede mai quelle connessioni. Un passo può riscrivere i documenti propri del componente host, e l’output proprio di un componente resta lo stesso chiunque vi si connetta, quindi i template di un passo vengono valutati senza .context.used_by — per ogni FeatureRecipe, che imposti o meno readsCallerRenderFacts: true. Quella chiave decide quando avviene il rendering dell’associazione, mai ciò che un passo vede. Un passo che leggesse i fatti dei suoi chiamanti non leggerebbe quindi nulla, e il build si arresta prima di qualsiasi rendering anziché eseguire il rendering di quella lettura come valore vuoto.

Messaggio emesso:

pipeline step reads its callers’ render facts, but a pipeline step does not read the components connecting to its host; it reads only the host’s own render facts (<reference>, written in <field>) (il passo di pipeline legge i fatti di rendering dei suoi chiamanti, ma un passo di pipeline non legge i componenti che si connettono al suo host; legge solo i fatti di rendering propri dell’host (con il riferimento e il campo in cui è scritto indicati))

Il riferimento è citato relativamente alla connessione da cui è stato letto — .render_facts, o .render_facts.<name> — come nella voce qui sopra, e il campo nomina il passo tramite il suo id: pipeline[<step>].with o pipeline[<step>].when. Dove più passi leggono i fatti, ciascuno riceve una segnalazione propria sotto una riga che nomina ciò che hanno in comune:

pipeline steps reading their callers’ render facts (passi di pipeline che leggono i fatti di rendering dei loro chiamanti)

Come risolvere: in un passo, leggi i fatti di rendering propri dell’host in .context.render_facts, scritto per intero — provengono dal rendering proprio dell’host, quindi leggerli non fa dipendere nulla da chi vi si connette. Leggi invece i fatti dei chiamanti nei template che producono le risorse proprie dell’associazione — il suo valuesMapping:, workload: o artifacts: — con readsCallerRenderFacts: true impostato, come descrive la pagina dell’entità FeatureRecipe. Impostare solo la chiave non elimina questo arresto. Il controllo legge il template così come è scritto, con i limiti che descrive la voce qui sopra: un riferimento costruito mentre il template viene eseguito, o uno scritto in contenuto importato da un file o da una libreria, non provoca un arresto, e un passo che legge un campo chiamato render_facts da qualche altro elenco accanto a .context.used_by, o i fatti propri del suo host come .render_facts all’interno di {{ with .context }} accanto a esso, provoca anch’esso un arresto.

Una FeatureRecipe che esegue il rendering una sola volta per un confine (executionScope: boundary) non viene controllata qui, per il motivo che dà la voce qui sopra.

A template reads its targets’ render facts without declaring it (Un template legge i fatti di rendering delle sue destinazioni senza dichiararlo)

Un template in una FeatureRecipe associata a un componente legge render_facts sotto .context.uses — ciò che i componenti a cui l’host dell’associazione è cablato hanno riportato sui propri rendering — e la FeatureRecipe non imposta readsTargetRenderFacts: true.

La chiave decide due cose. Fa avvenire il rendering dell’associazione una volta che ogni componente ha eseguito il rendering: senza di essa, il rendering dell’associazione avviene subito dopo il componente a cui è associata, e una destinazione che viene più avanti nell’ordine del build non ha ancora eseguito il rendering a quel punto. Ed è ciò che mette i fatti di ciascuna destinazione sulle connessioni che l’associazione legge: senza di essa, nessuna voce di .context.uses porta affatto .render_facts. Rifiutare il template prima di qualsiasi rendering segnala la dichiarazione mancante sul campo che hai scritto, anziché un build il cui template non legge nulla dove si aspettava i fatti di una destinazione.

Messaggio emesso:

template reads the render facts of a component its host is wired to, but the FeatureRecipe does not set readsTargetRenderFacts (<reference>, written in <field>) (il template legge i fatti di rendering di un componente a cui il suo host è cablato, ma la FeatureRecipe non imposta readsTargetRenderFacts (con il riferimento e il campo in cui è scritto indicati))

Il riferimento è quello che il template ha scritto: per intero sotto l’alias di una connessione — .context.uses.<alias>.render_facts, o .context.uses.<alias>.render_facts.<name> — oppure, dove il template legge le connessioni una alla volta, all’interno di {{ range .context.uses }}, {{ with .context.uses.<alias> }} o da una connessione che sceglie, relativamente a quella connessione: .render_facts, o .render_facts.<name>. Il campo nomina il blocco in cui il template è stato scritto: valuesMapping, workload o artifacts[<output-name>]. Il with: o il when: di un passo di pipeline che legge gli stessi fatti viene invece segnalato dalla voce successiva, qualunque cosa imposti la FeatureRecipe. Dove più campi leggono i fatti, ciascuno riceve una segnalazione propria sotto una riga che nomina ciò che hanno in comune:

attachment templates reading the render facts of the components their host is wired to, without declaring it (template di associazione che leggono i fatti di rendering dei componenti a cui il loro host è cablato, senza dichiararlo)

Come risolvere: imposta readsTargetRenderFacts: true nello spec della FeatureRecipe — readsCallerRenderFacts: true non elimina questo arresto, poiché mette i fatti sui componenti che si connettono all’host anziché su quelli a cui è cablato. Questo fa avvenire il rendering delle sue associazioni dopo che ogni componente ha eseguito il rendering, mette i fatti di ciascuna destinazione sulla sua connessione e non cambia nient’altro di ciò di cui eseguono il rendering — vedi la pagina dell’entità FeatureRecipe. La chiave è il contratto, e questo arresto ti aiuta solo a trovare un template che visibilmente ne ha bisogno: il controllo legge il template così come è scritto, quindi un riferimento costruito mentre il template viene eseguito, o uno scritto in contenuto importato da un file o da una libreria, non provoca un arresto — imposta comunque la chiave su una FeatureRecipe del genere. Un template che legge .context.uses in qualsiasi modo e legge anche un campo chiamato render_facts da qualche altro valore — tra cui i fatti di un chiamante all’interno di {{ range .context.used_by }} — provoca anch’esso un arresto; imposta la chiave, e anche readsCallerRenderFacts dove il template legge i fatti dei suoi chiamanti.

Una FeatureRecipe che esegue il rendering una sola volta per un confine (executionScope: boundary) non viene controllata qui, per il motivo che dà la voce sui chiamanti qui sopra.

A pipeline step reads its targets’ render facts (Un passo di pipeline legge i fatti di rendering delle sue destinazioni)

Il with: o il when: di un passo di pipeline, in una FeatureRecipe associata a un componente, legge render_facts sotto .context.uses — ciò che i componenti a cui l’host dell’associazione è cablato hanno riportato sui propri rendering.

Un passo legge le connessioni che il suo host stabilisce, come le legge la Recipe propria dell’host, e mai i fatti di rendering delle loro destinazioni — per ogni FeatureRecipe, che imposti o meno readsTargetRenderFacts: true. Un passo può riscrivere i documenti propri del componente host, e il rendering proprio dell’host legge ciò che le sue destinazioni pubblicano, mai ciò che hanno emesso, quindi i template di un passo vengono valutati senza quei fatti. Un passo che li leggesse non leggerebbe quindi nulla, e il build si arresta prima di qualsiasi rendering anziché eseguire il rendering di quella lettura come valore vuoto.

Messaggio emesso:

pipeline step reads the render facts of a component its host is wired to, but a pipeline step reads only the host’s own render facts (<reference>, written in <field>) (il passo di pipeline legge i fatti di rendering di un componente a cui il suo host è cablato, ma un passo di pipeline legge solo i fatti di rendering propri dell’host (con il riferimento e il campo in cui è scritto indicati))

Il riferimento è citato come nella voce qui sopra, e il campo nomina il passo tramite il suo id: pipeline[<step>].with o pipeline[<step>].when. Dove più passi leggono i fatti, ciascuno riceve una segnalazione propria sotto una riga che nomina ciò che hanno in comune:

pipeline steps reading the render facts of the components their host is wired to (passi di pipeline che leggono i fatti di rendering dei componenti a cui il loro host è cablato)

Come risolvere: in un passo, leggi i fatti di rendering propri dell’host in .context.render_facts, scritto per intero. Leggi invece i fatti delle destinazioni nei template che producono le risorse proprie dell’associazione — il suo valuesMapping:, workload: o artifacts: — con readsTargetRenderFacts: true impostato, come descrive la pagina dell’entità FeatureRecipe. Impostare solo la chiave non elimina questo arresto. Il controllo legge il template così come è scritto, con i limiti che descrive la voce qui sopra.

Una FeatureRecipe che esegue il rendering una sola volta per un confine (executionScope: boundary) non viene controllata qui, per il motivo che dà la voce sui chiamanti qui sopra.

Cross-node type safety violation via selector: (Violazione della sicurezza dei tipi tra nodi tramite selector)

Un unico arresto copre le due espressioni di etichette che un autore di catalogo scrive per vincolare ciò che può essere cablato o associato, perché entrambe falliscono allo stesso modo: un insieme di etichette che non soddisfa un’espressione dichiarata da un’entità del catalogo.

Un arco uses: la cui destinazione non soddisfa il selector: del suo socket. Un socket usesSchema dichiara un campo selector: che esclude il Component di destinazione collegato all’altra estremità dell’arco. Il selettore è il modo in cui l’autore del catalogo dice «questo socket accetta solo destinazioni le cui etichette corrispondono a questa espressione»; un arco che soddisfa la ricerca per nome del socket ma non l’espressione del selettore è una violazione della sicurezza dei tipi.

Messaggio emesso:

selector violation ("", declared on socket "", not satisfied by the labels of ""). Add the labels the selector requires to the target’s component type, or wire the socket to a component that already carries them. (violazione del selettore (l’espressione indicata, dichiarata sul socket indicato, non è soddisfatta dalle etichette della destinazione indicata). Aggiungi al tipo di componente della destinazione le etichette richieste dal selettore, oppure cabla il socket a un componente che le porta già.)

Un’associazione il cui componente non soddisfa il campo appliesTo: della Feature. Una Feature dichiara a quali componenti può essere associata, su appliesTo: e su appliesToAnyOf:. I requisiti della singola espressione valgono insieme e le alternative valgono in alternativa, e ne basta una qualsiasi; entrambe le superfici devono essere soddisfatte, e una superficie che la Feature omette è soddisfatta da qualsiasi cosa. Un’associazione il cui componente porta etichette che la dichiarazione della Feature non ammette è la stessa classe di violazione del caso dell’arco qui sopra.

Messaggio emesso:

selector violation ("", declared by Feature "", not satisfied by the labels of ""). Add the labels the Feature’s appliesTo requires to this component’s type, or attach a Feature whose applicability the component already satisfies. (violazione del selettore (l’espressione appliesTo indicata, dichiarata dalla Feature indicata, non è soddisfatta dalle etichette del componente indicato). Aggiungi al tipo di questo componente le etichette richieste dall’appliesTo della Feature, oppure associa una Feature la cui applicabilità il componente soddisfa già.)

Ciascuna delle due espressioni può anche essere scritta in una forma che la grammatica delle etichette non riesce affatto a leggere. Questo viene segnalato come lo stesso arresto, il cui ultimo valore è il motivo per cui non è stato possibile leggerla anziché l’insieme di etichette che non l’ha soddisfatta — ed è questo che distingue un’espressione che non è stato possibile valutare da una che è stata valutata e si è rivelata falsa:

selector violation ("", declared by Feature "", which could not be evaluated: ""). Correct the appliesTo selector on the Feature’s catalog entity. (violazione del selettore (l’espressione appliesTo indicata, dichiarata dalla Feature indicata, che non è stato possibile valutare, per il motivo indicato). Correggi il selettore appliesTo sull’entità di catalogo della Feature.)

Anche un selettore di socket che la grammatica non riesce a leggere viene rifiutato prima che qualcosa colleghi il socket. aggrega validate, sull’intero catalogo o su un singolo Component o Feature, legge ogni selettore di socket dichiarato dal documento dell’entità stessa, e rifiuta quello che la grammatica non riesce a leggere sotto questa stessa condizione, che un arco sia collegato o meno attraverso il socket:

selector violation ("", declared on socket "", which could not be evaluated: ""). Correct the selector on the socket’s declaration in the component type’s usesSchema. (violazione del selettore, dichiarato sul socket, che non è stato possibile valutare. Correggi il selettore nella dichiarazione del socket nell’usesSchema del tipo di componente.)

Su un socket di una Feature il rimedio nomina invece l’usesSchema della Feature. Nulla ha collegato il socket, quindi l’errore è dell’entità di catalogo: viene classificato come CATALOG_ERROR e nomina il file dell’entità.

L’arresto porta la chiave scritta a cui si riferisce — la voce di socket uses:, o la voce features: che nomina l’associazione — insieme al file che la dichiara, quindi la posizione che segnala è la voce che modifichi anziché l’inizio del documento. Un Component scritto all’interno di un sottosistema è posizionato sul sottosistema sotto cui è stato scritto, livello per livello. Un’associazione è posizionata sulla voce features: che l’ha scritta, nel documento che l’ha scritta, e attribuita all’autore di quel documento: il blocco proprio del componente o il blocco di un sottosistema nell’Aggregate, un errore dello sviluppatore; e, per un’associazione che fa solo la Release, la sua voce per il componente o il blocco features: di un confine che contiene il componente, un errore dell’operatore. Dove entrambi i documenti scrivono l’associazione, essa è posizionata dove viene nominato il suo type, cosa che l’Aggregate fa sempre. Un’associazione scritta su una connessione è posizionata sulla sua chiave sotto il features: di quella connessione, nel documento che l’ha scritta — la voce di connessione dell’Aggregate, o la voce per arco della Release per un’associazione che fa solo la Release. Una Feature che la sola Release associa a un componente che la sua dichiarazione non ammette si presenta così:

[OPS_ERROR E0007] release.yaml at .spec.boundaries.main.components.app.features.metrics
selector violation ("component.aggrega.ai/type in (server, worker)", declared by Feature "core/prometheus-exporter", not satisfied by the labels of "app"). Add the labels the Feature's appliesTo requires to this component's type, or attach a Feature whose applicability the component already satisfies.

e la stessa associazione scritta sul componente nell’Aggregate si presenta come [DEVELOPER_ERROR E0007] aggregate.yaml at .spec.components.app.features.metrics. Un’associazione prodotta dall’espansione guidata dalle annotazioni non è stata scritta da alcuna voce features:, quindi è posizionata sulla chiave features: propria del componente nel documento che dichiara il componente, come errore dello sviluppatore.

Come risolvere una violazione di arco: instrada l’arco uses: verso un Component le cui etichette soddisfano il selettore, oppure modifica l’espressione del selettore nell’entità del catalogo perché accetti la classe di destinazione prevista. Esamina i metadata.labels del Component di destinazione con aggrega inspect per confermare quali etichette porta.

Come risolvere una violazione di associazione: associa la Feature a un componente le cui etichette la sua dichiarazione ammette, oppure amplia il campo appliesTo: della Feature — aggiungendo un’alternativa sotto appliesToAnyOf: dove la Feature serve davvero più di una classe di componenti. Dove il componente dovrebbe rientrare e non rientra, il pezzo mancante è di solito un’etichetta: esaminalo con aggrega inspect e aggiungi ciò che l’espressione richiede nei metadata.labels del Component.

Unknown provider (Provider sconosciuto)

Una Recipe dichiara capability: <name> dove <name> non nomina alcun provider servito dal compilatore. Il compilatore non può inoltrare il rendering a un provider di cui non ha mai sentito parlare.

Messaggio emesso:

unknown provider: <provider-name> (provider sconosciuto: il nome indicato)

Come risolvere: verifica che il nome del provider sia scritto correttamente — cloudformation, compose, helm, helm-chart e terraform sono i nomi serviti dai plugin provider incorporati. Se intendevi un provider aziendale personalizzato, assicurati che un Plugin di rendering dei provider che serve quel nome (pluginType: provider con il nome nelle sue spec.provider.capabilities) sia presente nel workspace del catalogo a cui punta il build.

A capability is served by more than one provider plugin (Una capacità è servita da più di un plugin provider)

Un build raggiunge una capacità — o un pull ne risolve una — servita da più di un Plugin di rendering dei provider (pluginType: provider, ciascuno dei quali elenca quella capacità nelle sue spec.provider.capabilities), e il workspace non ha selezionato quale ne esegua il rendering. Anziché scegliere un provider arbitrariamente, il build si arresta e nomina entrambi i candidati. Un catalogo che contiene due plugin per la stessa capacità è legittimo — due editori possono ciascuno distribuire un plugin per helm o compose, e il catalogo li accetta entrambi. L’ambiguità emerge solo nel punto d’uso: l’arresto scatta quando un build o un pull raggiunge effettivamente la capacità contesa, non al momento del caricamento.

Messaggio emesso. Prima viene la regola che ha arrestato il build, e i dettagli — quale capacità, quali candidati e il legame da scrivere — la seguono:

capability is served by more than one provider plugin; add a plugins.providers entry to select one: capability "<capability-name>" is served by more than one provider plugin (<plugin-1>, <plugin-2>); add a plugins.providers entry for "<capability-name>" selecting one (la capacità è servita da più di un plugin provider; aggiungi una voce plugins.providers per selezionarne uno: la capacità indicata è servita da più di un plugin provider (quelli indicati); aggiungi una voce plugins.providers per la capacità indicata che ne selezioni uno)

Come risolvere: aggiungi una voce plugins.providers nella configurazione del workspace, con la capacità come chiave e come valore l’identità del plugin che ne esegue il rendering. Mantieni entrambi i plugin nel catalogo federato; il legame indica a questo workspace a quale dei due inoltrare la capacità contesa.

The plugin serving a provider cannot assemble what that provider combines (Il plugin che serve un provider non può assemblare ciò che quel provider combina)

Un provider dichiara che cosa diventa l’output per nodo di un gruppo di inoltro: l’output di ciascun nodo scritto direttamente sul percorso di inoltro, i frammenti fusi in un unico documento, oppure ciascun nodo collocato in una propria posizione all’interno di un’unica struttura che li racchiude. Dove un provider dichiara che l’output è combinato — un file compose unificato, un chart ombrello — il plugin che lo serve deve offrire l’export che esegue la combinazione. Questo arresto scatta dove non lo fa: il plugin annuncia il rendering per nodo (render_node) e nessun assemble_boundary corrispondente, quindi i nodi del gruppo possono essere renderizzati ma il loro output non può essere unito.

Entrambe le metà di quel disaccordo appartengono al plugin. Che cosa diventa l’output di un gruppo di inoltro fa parte di ciò che il plugin riporta su sé stesso quando viene caricato, e l’export che eseguirebbe la combinazione è una delle voci sotto spec.exports di un’entità Plugin, verificata rispetto a quello stesso resoconto — quindi l’arresto nomina un plugin che dichiara un assemblaggio che la sua superficie di export non fornisce.

Il build si arresta anziché saltare l’assemblaggio. Saltarlo scriverebbe il frammento di ciascun nodo sul percorso in cui era atteso un unico artefatto e segnalerebbe un successo, e nulla più avanti può distinguere quei frammenti dall’output piatto per nodo che un provider che non dichiara alcun assemblaggio emette per progettazione — quindi un artefatto mancante emergerebbe ovunque l’output venga applicato anziché al momento del build.

Un gruppo di inoltro privo di percorso di inoltro viene ignorato. L’output scritto senza alcun percorso è output per nodo, quindi lì non viene assemblato nulla su cui una dichiarazione di combinazione possa avere effetto.

Messaggio emesso — un rilievo per ciascun gruppo di inoltro in errore, che nomina il provider e il percorso su cui quel gruppo si assembla:

provider expected to assemble its dispatch group provides no boundary assembler ("<provider>", dispatch path "<path>") (il provider che dovrebbe assemblare il proprio gruppo di inoltro non fornisce alcun assemblatore di confine (con il provider e il percorso di inoltro indicati))

Dove più di un gruppo di inoltro è in errore, i rilievi arrivano insieme sotto la segnalazione dispatch groups whose provider offers no boundary assembler.

Come risolvere: servi la capacità con un plugin che annunci sia render_node sia assemble_boundary — vedi ../entities/plugin.md per la superficie di scrittura spec.exports, e ../schema/plugins/wasm-provider.md per ciò che riceve l’export di assemblaggio. Se il plugin lo scrivi tu, allineare i due lati spetta a te: aggiungi l’export di assemblaggio, oppure non riportare alcuna dichiarazione di assemblaggio e lascia che l’output di ciascun nodo arrivi sul percorso di inoltro senza essere unito. Se usi un plugin pubblicato, seleziona una versione che offra entrambi gli export, oppure seleziona un plugin il cui provider non dichiari alcun assemblaggio per quella capacità.

A boundary-level Feature’s output reaches no assembled file (L’output di una Feature a livello di confine non raggiunge alcun file assemblato)

Una Feature associata sotto il features: di un confine, la cui FeatureRecipe dichiara executionScope: boundary, esegue il rendering una sola volta per l’intero confine, e il suo output va nella directory a cui si valutano per essa il directory: e il subDirectory: propri del confine. Un provider che fonde il proprio output in un unico documento — compose, in un unico docker-compose.yaml; cloudformation, in un unico stack — scrive il contributo di una tale Feature solo come parte del file che lì assembla a partire dai componenti del confine. Quel file esiste solo dove l’output di almeno un componente arriva nella stessa directory sotto lo stesso provider.

Quel file non esiste dove i componenti del confine arrivano altrove: quando si trovano in confini annidati il cui subDirectory: li manda altrove — "{{ .component_id }}", per esempio, così che ogni componente abbia un file proprio — o sotto una directory che l’output della Feature non condivide. Nella directory della Feature non viene assemblato nulla, quindi il suo output non verrebbe scritto da nessuna parte — per il bridge compose, un servizio gateway che nessun file contiene — e il build segnalerebbe un successo. Il build invece si arresta.

Una Feature il cui provider scrive ciascun contributo come file propri — helm, helm-chart e terraform — non è interessata: quei file vengono scritti indipendentemente dal fatto che accanto a essi venga assemblato qualcosa.

Messaggio emesso — un rilievo per ciascuna Feature in errore, posizionato sulla sua voce sotto il features: del confine, che nomina il confine, la Feature, il percorso di inoltro verso cui è stato instradato il suo output e il provider:

boundary-level Feature’s output is routed to a dispatch path nothing assembles (boundary "<boundary>", feature "<instance>", dispatch path "<path>", provider "<provider>"). attach the Feature at a boundary whose output path also receives its components, or give the boundary’s components the directory the Feature’s output is routed to (l’output della Feature a livello di confine è instradato verso un percorso di inoltro che nulla assembla (con il confine, l’istanza della Feature, il percorso di inoltro e il provider indicati). associa la Feature a un confine il cui percorso di output riceve anche i suoi componenti, oppure dai ai componenti del confine la directory verso cui è instradato l’output della Feature)

Un bridge compose associato a un confine padre bridge, il cui unico confine figlio colloca ciascun componente sotto subDirectory: "{{ .component_id }}", stampa:

[OPS_ERROR E0365] release-compose.yaml at .spec.boundaries.bridge.features.gateway
boundary-level Feature's output is routed to a dispatch path nothing assembles (boundary "bridge", feature "gateway", dispatch path "bridge/compose", provider "compose"). attach the Feature at a boundary whose output path also receives its components, or give the boundary's components the directory the Feature's output is routed to

Dove più di una Feature è in errore, i rilievi arrivano insieme sotto la segnalazione boundary-level Features whose output is routed to a dispatch path nothing assembles.

Come risolvere: fai in modo che la directory della Feature sia una in cui arrivano anche i componenti del suo confine. Associa la Feature a un confine il cui percorso di output riceva quei componenti, oppure dai ai componenti la directory verso cui è instradato l’output della Feature — per i confini figli, directory: "{{ .parent_boundary.directory }}" senza un subDirectory: proprio, così che condividano il file del padre. Il messaggio nomina la directory verso cui è stato instradato l’output della Feature, che è quella da condividere.

Path-template references a variable outside the allowlist (Il template di percorso fa riferimento a una variabile al di fuori dell’allowlist)

Un template directory: o subDirectory: fa riferimento a un nome di variabile che l’allowlist delle variabili dei template di percorso non include — per esempio un errore di ortografia come {{ .parmaeters.region }}, o un campo che esiste nel contesto di rendering della Recipe ma non è esposto ai template di percorso (come .context.inject o .values). Lo stesso arresto copre {{ .component_id }} in un template directory:: la variabile esiste, e i template subDirectory: possono leggerla, ma il directory: di un confine viene valutato una sola volta per l’intero confine anziché una volta per componente, quindi lì una variabile per componente farebbe dipendere il percorso emesso da quale componente è stato valutato per primo.

I template di percorso vengono validati al momento del parsing, prima che inizi qualsiasi lavoro di rendering, rispetto alle variabili che il contesto dei template di percorso definisce, meno quelle che la particolare superficie rifiuta. Il compilatore valuta inoltre i template di percorso con la semantica missingkey=error, quindi un riferimento presente nell’allowlist ma non definito al momento della valutazione produce un errore esplicito anziché il rendering silenzioso di una stringa vuota in un percorso di directory.

Questo arresto riguarda la variabile. Una chiave digitata male sotto una variabile ammessa — {{ .manifest.recipe_nmae }} — segnala invece «Template references a root the render context does not define (Il template fa riferimento a una radice che il contesto di rendering non definisce)» più sopra, nominando le chiavi che .manifest definisce, perché la variabile stessa è stata ammessa e solo la chiave era sbagliata.

Messaggio emesso:

path template references a field not in the documented allowlist ("<dotted-path>", written in "<directory|subDirectory>", the render context defines "<the variables that field may read>") (il template di percorso fa riferimento a un campo che non è nell’allowlist documentata (con il percorso indicato, scritto nel campo indicato; il contesto di rendering definisce le variabili indicate))

Come risolvere: correggi il nome del campo con uno presente nell’allowlist dei template di percorso, oppure rimuovi il riferimento. L’allowlist per directory: è {{ .capability }}, {{ .boundary_name }}, {{ .parameters.X }}, {{ .manifest.recipe_name }} e {{ .parent_boundary.* }}; subDirectory: aggiunge {{ .component_id }}. Altre superfici (valuesMapping della Recipe, injectMapping della FeatureRecipe, ecc.) usano una forma di contesto diversa; i riferimenti a .context.*, .values, .infra o .locals non sono deliberatamente esposti ai template di percorso, perché l’emissione dei percorsi è una questione strutturale, non una questione di rendering dei valori.

Path collision: two contributors emit at incompatible paths (Collisione di percorsi: due contributori emettono su percorsi incompatibili)

Due confini le cui dichiarazioni di percorso si valutano allo stesso percorso di assemblaggio passano per provider diversi. Entrambi assemblano lì, e ciascuno scrive file di cui l’altro non sa nulla, quindi uno sostituisce silenziosamente l’altro sul disco — e il build che ha prodotto l’output sostituito sembra essere riuscito.

Il subDirectory: predefinito dà a ciascun provider un sottopercorso proprio, quindi due provider raggiungono un unico percorso solo dove le dichiarazioni sono state scritte in modo da valutarsi allo stesso modo: due confini che condividono un directory: ed entrambi fissano subDirectory: allo stesso letterale, per esempio.

Messaggi emessi. Viene segnalato un rilievo per ciascun confine contributore, quindi ogni confine il cui output ha raggiunto il percorso viene nominato a sé anziché raccolto in un elenco all’interno di un unico messaggio. L’errore è che due provider si incontrano su un unico percorso, quindi ci sono sempre almeno due rilievi, e arrivano insieme sotto una segnalazione che indica che cosa hanno in comune:

assembly paths reached by more than one provider (percorsi di assemblaggio raggiunti da più di un provider)

Ogni rilievo nomina il percorso, il confine il cui output lo ha raggiunto e il provider attraverso cui passa quel confine:

dispatch path produced multiple provider outputs ("<path>", boundary "<boundary>", provider "<provider>") (il percorso di inoltro ha prodotto più output di provider (con il percorso, il confine e il provider indicati))

Un build i cui confini api-net e db-net dichiarano entrambi directory: ./dist/shared e subDirectory: merged, uno instradato attraverso helm e l’altro attraverso compose, stampa:

[OPS_ERROR E0048]
assembly paths reached by more than one provider
caused by (2):
[OPS_ERROR]
dispatch path produced multiple provider outputs ("dist/shared/merged", boundary "db-net", provider "compose")
---
[OPS_ERROR]
dispatch path produced multiple provider outputs ("dist/shared/merged", boundary "api-net", provider "helm")

La segnalazione porta il codice breve e ogni rilievo sotto di essa porta soltanto la propria categoria, che è la forma usata da ogni segnalazione di errori raccolti — vedi error-translation.md per quella grammatica.

Come risolvere: dai a ciascun confine un directory: distinto (così che si assemblino su percorsi separati), oppure lascia subDirectory: al suo valore predefinito, così che l’output di ciascun provider arrivi su un sottopercorso proprio. Il pattern del bridge compose fa confluire intenzionalmente due sotto-confini in un unico percorso di assemblaggio; quel pattern richiede che entrambi i confini puntino allo stesso provider e portino annotazioni risolte a cascata compatibili.

A boundary’s output directory is not a directory beneath the output root (La directory di output di un confine non è una directory sotto la radice di output)

Il directory: e il subDirectory: di un confine vengono valutati e uniti nella directory sotto cui viene scritto il suo output, e quel percorso viene normalizzato una volta: out/a, out//a, ./out/a e out/a/ sono un’unica directory. Dove il percorso normalizzato non è una directory sotto la radice di output, il build si ferma prima che venga scritto qualsiasi cosa. Si tratta di un percorso che risale fuori dalla radice di output (.., ../escape, a/../..), di uno assoluto (/srv/out), o di uno che non nomina affatto una directory: un valore vuoto, o uno che si normalizza nella radice di output stessa, come directory: "." con la sottodirectory disabilitata.

Il percorso viene controllato così come è stato valutato, quindi viene giudicato il risultato di un template, non il testo scritto. Il messaggio nomina il campo da cui proviene l’errore — directory: dove la sola directory esce già dalla radice di output o dove non vi viene unita alcuna sottodirectory, altrimenti subDirectory: — insieme al valore a cui quel campo si è valutato e al percorso che ha prodotto.

Messaggio emesso:

boundary output directory does not name a directory beneath the output root (Release "<release>", boundary "<boundary>", directory: "<value>", output path "<path>"). write a directory beneath the output root, such as “deploy/prod” — no leading ”/”, no ”..” climbing above it, and not the output root itself (la directory di output del confine non nomina una directory sotto la radice di output (con la Release, il confine, il valore di directory e il percorso di output indicati). scrivi una directory sotto la radice di output, come «deploy/prod» — senza «/» iniziale, senza «..» che risalga sopra di essa, e non la radice di output stessa)

Dove l’errore è nella sottodirectory, il terzo valore riporta invece subDirectory: "<value>".

Come risolvere: scrivi il campo che il messaggio nomina come una directory sotto la radice di output. Una directory pensata per stare accanto alla radice di output va invece al suo interno. Per scrivere l’output di un confine direttamente nel suo directory:, imposta subDirectory: "." — la directory stessa deve comunque nominare una directory propria.

A boundary-level Feature is named . or .. (Una Feature a livello di confine si chiama . o ..)

Un provider che dà a ciascun contributore una directory propria — terraform, sotto modules/, e helm-chart, sotto charts/ — colloca una Feature associata a un confine in una directory che prende il nome dalla sola istanza, accanto ai componenti del confine. La chiave features: di un confine ammette . e .., e nessuno dei due è un nome di directory: . metterebbe i file della Feature nella directory che contiene tutti i contributori, e .. in quella sopra di essa, quindi i file finirebbero al di fuori della posizione che il provider ha dato alla Feature. Il build invece si ferma. Qualsiasi altro nome non viene toccato, compreso uno con punti come audit.v2.

Messaggio emesso:

boundary-level Feature instance name is not a directory name (Release "<release>", boundary "<boundary>", feature "<instance>"). rename the Feature instance under the boundary’s features to an ordinary name, such as “audit” (il nome dell’istanza della Feature a livello di confine non è un nome di directory (con la Release, il confine e l’istanza della Feature indicati). rinomina l’istanza della Feature sotto i features del confine con un nome ordinario, come «audit»)

Come risolvere: rinomina l’istanza sotto il features: del confine con un nome ordinario.

Instance-ID collision across boundaries assembling to the same path (Collisione di ID di istanza tra confini che si assemblano sullo stesso percorso)

Due confini che si assemblano sulla stessa tupla (percorso, provider) contribuiscono componenti con ID di istanza identici. L’assemblaggio unificato non può distinguere i due frammenti di componente — un singolo chart Helm non può contenere due Deployments chiamati web-server, e un singolo file docker-compose non può contenere due servizi chiamati api.

Messaggio emesso:

multiple contributors share an instance ID at the same dispatch path: dispatch path "<path>" provider "<provider>" already contains node "<instance-id>" (contributing boundaries: [<boundaries>]); component instance IDs must be unique within an assembly group (più contributori condividono un ID di istanza sullo stesso percorso di inoltro: il percorso di inoltro e il provider indicati contengono già il nodo indicato (con i confini contributori indicati); gli ID di istanza dei componenti devono essere unici all’interno di un gruppo di assemblaggio)

Come risolvere: rinomina uno dei componenti in collisione nell’Aggregate, oppure separa i due confini su percorsi directory: distinti, così che ogni istanza di componente arrivi nel proprio assemblaggio.

Two contributors write the same output path (Due contributori scrivono lo stesso percorso di output)

Due contributori di un unico assemblaggio producono un file allo stesso percorso di output. Questo è distinto dalla collisione di ID di istanza qui sopra: i componenti hanno nomi diversi e l’assemblaggio è in grado di distinguerli — sono i file che emettono a finire su un unico percorso. Accade più spesso dove un provider scrive l’output di ciascun contributore fianco a fianco anziché sotto una posizione per componente, così due componenti le cui Recipes emettono lo stesso nome di file (due voci artifacts: entrambe chiamate main.tf, ad esempio) si incontrano su un unico percorso. L’output proprio dell’assemblatore può entrare in collisione con il file di un contributore allo stesso modo.

Che due contributori che emettono un unico nome di file entrino in collisione dipende da dove il loro provider li colloca. Un provider che annida ciascun contributore sotto la propria posizione nell’assemblaggio tiene separati due file con lo stesso nome; un provider che scrive i contributori fianco a fianco no. Il confronto avviene sul percorso finale in cui un file verrebbe scritto, non sul nome che il contributore ha emesso, quindi il caso annidato non viene segnalato.

Il build si arresta anziché scrivere uno dei due file e scartare l’altro. Non esiste una risoluzione silenziosa corretta: rinominare uno dei file o aggiungervi un suffisso inventerebbe un nome che nessuno ha scritto, e unirne i contenuti inventerebbe un documento che nessuno ha redatto. Ogni percorso in collisione viene segnalato, e ogni contributore che lo scrive viene nominato, così un solo build ti dà il quadro completo anziché una collisione alla volta.

Messaggi emessi. Viene segnalato un rilievo per ogni percorso in collisione — una sola volta, per quanti confini abbiano alimentato l’assemblaggio in cui si è verificata — quindi un build i cui contributori si sono incontrati su due percorsi ti informa di entrambi e nessuna collisione viene segnalata due volte:

assembled output collision: two contributors write the same output path (output path "<output-path>", written by "<contributor-1> and <contributor-2>", assembled within "<boundary-1> and <boundary-2>") (collisione nell’output assemblato: due contributori scrivono lo stesso percorso di output (con il percorso di output, i contributori che lo scrivono e i confini in cui è stato assemblato indicati))

Ogni contributore è nominato per ciò che è, ed è questo a dire dove è scritto il suo nome: component <name> per un’istanza di componente, feature <name> per una funzionalità associata a un confine, e the <provider> assembly per l’output unito proprio dell’assemblaggio. I contributori sono elencati in ordine di nome, quindi la frase è la stessa in ogni build dello stesso input.

Anche un file che una Recipe fornisce all’output condiviso del confine è soggetto a questa regola. Il blocco boundary: di una Recipe scrive i suoi file accanto all’output assemblato proprio del provider, una volta per nome di file. Più componenti che dichiarano un nome con byte identici sono un unico file e non entrano mai in collisione; dichiararlo con byte diversi provoca qui una collisione, che nomina il file e ogni componente che lo ha dichiarato, e lo stesso vale per un nome che l’assemblaggio del provider scrive da sé — aggrega.modules.tf per terraform, ad esempio, che nomina the terraform assembly tra i contributori. Un file che più componenti hanno dichiarato in modo identico e che incontra il file proprio dell’assemblaggio viene nominato con tutti loro, come component <name-1> and component <name-2>.

Vengono nominati anche i confini da cui l’assemblaggio è stato alimentato, e sono elencati anziché individuati singolarmente. I confini le cui dichiarazioni directory: vengono valutate allo stesso modo si assemblano come uno solo, e nulla in una collisione dice in quale di essi siano stati dichiarati i contributori che si sono incontrati — quindi il rilievo ti dà ogni confine la cui dichiarazione potrebbe separarli e non afferma di nessuno di essi che sia quello in errore. Il rilievo viene segnalato sul documento della Release nel suo insieme per lo stesso motivo: nominare un confine al suo interno ti manderebbe a un documento che potrebbe non aver contribuito in nulla al percorso.

Dove entrano in collisione più percorsi, i rilievi arrivano insieme sotto una segnalazione che indica ciò che hanno in comune:

assembled output paths written by more than one contributor (percorsi dell’output assemblato scritti da più di un contributore)

Come risolvere: rinomina il file emesso in qualunque Recipe tu controlli — una chiave di artifacts:, la chiave di un blocco boundary:, o il nome di file che deriva una traduzione del Workload — così che i due non si incontrino più. Dove due Recipes dichiarano un unico file condiviso e intendono la stessa configurazione, rendi le loro dichiarazioni identiche byte per byte. Dove i due contributori appartengono davvero a output separati, assegna ai loro confini percorsi directory: distinti così che ciascuno si assembli per conto proprio.

The same name is derived more than once inside the output (Lo stesso nome viene derivato più di una volta all’interno dell’output)

Un assemblaggio finisce per usare lo stesso nome due volte per qualcosa all’interno dei file che emette, in un punto dove c’è spazio per uno solo. Accade in due modi: due contributori derivano lo stesso nome, oppure l’output proprio di un singolo contributore porta quel nome due volte. Questo è distinto dalle due collisioni qui sopra: dove sono coinvolti due contributori, i componenti hanno nomi diversi e i loro file finiscono su percorsi diversi, quindi nulla nella struttura dell’assemblaggio è sbagliato — è un nome nel contenuto, come l’identificatore che una destinazione usa per indirizzare una risorsa, o il nome con cui un output viene pubblicato perché un altro vi faccia riferimento.

Quali nomi vengono confrontati dipende da ciò che il provider fa con l’output di un assemblaggio. Dove il provider unisce quell’output in un unico documento — un template di stack, un file compose — i nomi all’interno di quel documento vengono confrontati tra loro, e un contributore il cui output è scritto come file separati propri ne resta fuori. I suoi nomi non incontrano quelli di nessun altro, quindi tra di essi nulla si arresta, e nulla che tu possa rinominare lo cambierebbe. Dove invece il provider scrive l’output di ciascun contributore come file propri — un rendering di chart, un insieme di manifesti — ogni contributore dell’assemblaggio viene confrontato con ogni altro, perché un nome in un output del genere è unico rispetto a qualunque cosa legga quei file come insieme anziché all’interno di un singolo file.

Le risorse proprie di una FeatureRecipe seguono la stessa strada di quelle del suo componente host, perché un’associazione contribuisce all’assemblaggio a cui appartiene il suo host. Quindi, dove il provider unisce, i nomi di un’associazione vengono confrontati con quelli del suo componente host e con quelli di ogni altra associazione, esattamente come i nomi di due componenti: finiscono tutti all’interno dell’unico documento, e di due nomi uguali uno sostituisce l’altro lì. Dove il provider non unisce, le risorse dell’associazione vengono scritte sotto una directory che nomina il componente a cui è associata, e i suoi nomi vengono comunque confrontati con ogni contributore dell’assemblaggio — ed è lì che viene intercettata un’identità di risorsa che deve essere unica in tutto un cluster. Il confronto è quindi lo stesso in entrambi i casi, e ciò che differisce è solo dove finisce il nome che verrebbe sostituito.

Una metà dell’arresto non è toccata da nulla di tutto ciò: l’output proprio di un singolo contributore che porta un nome due volte. Si tratta di un nome usato due volte all’interno di un output scritto da un solo contributore, quindi provoca un arresto ovunque quell’output sia stato scritto, e le due cose da separare si trovano sempre al suo interno.

La maggior parte di questi nomi appartiene al provider, derivata dall’istanza di componente e dalla risorsa, quindi due componenti possono arrivare a un unico nome ogni volta che le parti da cui è derivato coincidono — e un componente può arrivare due volte a un unico nome allo stesso modo, quando due delle sue risorse sono costruite a partire da parti che coincidono. Poiché il nome vive nei byte stessi del file, l’assemblaggio non può vederlo: il provider segnala i nomi che ha derivato, e il build li confronta.

Un tipo di nome appartiene al build anziché a un provider, e viene segnalato allo stesso modo: l’identità con cui è etichettata ogni risorsa emessa da una FeatureRecipe, che raggiunge il tuo output come etichetta aggrega.ai/component-id. Viene segnalata sotto il tipo di nome component-id, così puoi trovare la stessa stringa nel tuo output emesso. Dove una FeatureRecipe sintetizza le proprie risorse, quell’identità è anche ciò da cui prendono il nome; dove esegue il rendering di un chart o di un frammento fornito dal suo autore, i nomi all’interno di quel rendering restano quelli del componente host e solo le etichette portano l’identità.

Per una funzionalità associata a un componente è composta dal componente a cui la funzionalità è associata e dalla chiave che hai scritto sotto features:, dietro un prefisso fisso. Il componente host fa parte del valore perché un solo nome di funzionalità associato a più componenti emette un insieme separato di risorse su ciascuno, e ogni insieme ha bisogno di un’identità propria.

Per una funzionalità associata a un confine è composta dal nome della funzionalità e da ogni segmento del percorso del confine, dietro un prefisso proprio. Entrambi i casi compongono anziché sostituire: un carattere che l’alfabeto delle etichette rifiuta viene trascritto anziché sostituito, e le parti sono unite da una sequenza che nessuna parte scritta può contenere, quindi due associazioni che sai distinguere raggiungono sempre due identità. L’unico residuo è la lunghezza: un’identità composta troppo lunga per il valore di un’etichetta viene accorciata attorno a un digest della sua interezza, e due identità accorciate possono in linea di principio incontrarsi. Questo arresto segnala un tale incontro tra due contributori i cui nomi vengono confrontati, e due associazioni su un componente sono due contributori di questo tipo ovunque il provider del loro host le assembli insieme. Vedi ../providers/well-known-annotations.md per come viene costruita ciascuna.

Un rendering Kubernetes segnala un tipo di nome proprio: il nome che porta nel suo metadata.name ogni risorsa prodotta dal suo rendering. Un nome del genere deve essere unico all’interno del suo kind — e, per un tipo che il cluster tiene nei namespace, all’interno del suo namespace — anziché in tutto l’output, quindi il tipo di nome dice a quale di questi ambiti è circoscritto. Inizia con resource-names e poi porta il kind della risorsa e il namespace in cui la risorsa finisce, che è quello che la risorsa nomina per sé o, dove non ne nomina alcuno, quello con cui è annotato il confine. Quindi resource-names:Service--default sono i nomi dei Service che finiscono in default. Un tipo che l’API di Kubernetes tiene fuori da ogni namespace — un ClusterRole, una StorageClass, una CustomResourceDefinition — e un tipo personalizzato che una CustomResourceDefinition nello stesso rendering dichiara con l’ambito Cluster portano solo il loro kind, qualunque namespace scriva il loro documento: resource-names:ClusterRole sono i nomi di ogni ClusterRole che l’output porta. Qualunque cosa al di fuori di lettere e cifre viene trascritta anziché sostituita e le due parti sono unite da una sequenza che nessuna parte scritta può contenere, quindi due coppie diverse non raggiungono mai un unico tipo di nome, e un tipo da solo non raggiunge mai il tipo di nome di un tipo e di un namespace. Un Service e un Deployment possono condividere un nome, e due namespace contengono un nome di un tipo con namespace in modo indipendente, quindi nessuno dei due casi provoca un arresto. Il nome stesso viene segnalato esattamente come lo ha scritto il tuo chart, il che lo rende la stringa da cercare nei tuoi template.

Quindi due contributori di un unico output che scrivono ciascuno un unico oggetto a livello di cluster con un unico nome provocano un arresto anche dove la Release li colloca in due namespace, perché applicarli entrambi scrive quell’unico oggetto due volte; e un chart che scrive un oggetto del genere sotto due namespace diversi, che il rendering emette come due file, provoca un arresto come singolo contributore che porta il nome due volte. Un tipo che nulla nel rendering classifica — un tipo personalizzato la cui CustomResourceDefinition il rendering non emette, o un documento che non nomina alcun apiVersion — viene confrontato all’interno del suo namespace, come un tipo con namespace, perché nulla nel rendering dice che il cluster lo tiene fuori da un namespace; due contributori che scrivono un oggetto del genere in due namespace quindi non si incontrano.

I nomi vengono confrontati tra i contributori di un unico output, e mai tra due output. Due confini sono due output quando ciascuno ha una directory propria — una che nomina, o quella assegnata a ogni confine che non nomina alcun directory: — e nulla in un build dice se due output vengono applicati a un unico cluster o a due: la CustomResourceDefinition di un unico operatore distribuita in ciascuno di due cluster è lo stesso nome in due output, ed è corretto. Quindi due confini che scrivono ciascuno un unico oggetto a livello di cluster con un unico nome non fermano il build anche dove entrambi sono applicati a un unico cluster; dove lo sono, emetti l’oggetto da uno solo dei due.

La disposizione che raggiunge più spesso questo arresto è quella di due Features associate a un unico componente, ciascuna delle quali consegna un chart fornito dal suo autore. Entrambi i chart eseguono il rendering con lo stesso nome di release — quello del componente host, così che associare un chart non rinomini risorse che il suo autore ha già dichiarato e distribuito — e dare a una risorsa il nome della release è tra le cose più comuni che un chart fa. Nulla nella struttura dell’output è sbagliato: le due risorse portano semplicemente un unico nome. Dove il provider del componente scrive documenti distinti, ciascuna associazione scrive sotto una directory propria e applicarle entrambe lascia quella applicata per ultima; dove raccoglie il suo gruppo in un unico documento, entrambe le associazioni contribuiscono a quel documento e di due nomi uno sostituisce l’altro al suo interno. Rinomina la risorsa nel chart che controlli, o dalle un nome che porti qualcosa che distingua le due associazioni — ed è l’associazione che deve raggiungere il template, perché entrambi i chart eseguono il rendering con il nome di release dell’host, quindi rinominare l’associazione da sola non sposta nulla. Passa .attachment_name nel chart tramite il valuesMapping: della FeatureRecipe, e impostalo su quello dei valori propri del chart da cui sono costruiti i nomi delle sue risorse.

Una seconda disposizione raggiunge lo stesso arresto con una sola Feature anziché due: un chart il cui template scrive un nome di risorsa come letterale, associato a due componenti. Ciascun host ne esegue il rendering con un nome di release proprio, quindi il letterale è l’unico motivo per cui le due copie portano un unico nome — dai alla risorsa il nome di .Release.Name e l’host vi rientra, che è ciò che fa già un chart che costruisce i nomi delle sue risorse dalla propria identità di release.

Una terza disposizione ha la stessa struttura, una superficie di scrittura più all’interno: una FeatureRecipe che consegna le sue risorse tramite artifacts: anziché tramite un chart, associata con un unico nome a due componenti, il cui corpo scrive un nome di risorsa come letterale. L’output di ciascuna associazione finisce sotto una directory che nomina il suo host, quindi i percorsi emessi differiscono e nulla nella struttura dell’output è sbagliato — ma entrambi i corpi portano lo stesso nome, e applicarli entrambi lascia quello applicato per ultimo. Un nome in un corpo di artifacts viene confrontato esattamente come un nome di cui un chart ha eseguito il rendering: i due descrivono la stessa risorsa nello stesso cluster, quindi da dove provenga il nome non fa alcuna differenza per ciò che accade quando vengono applicati entrambi. Questa lettura si basa sul fatto che i due nomi vengano letti insieme, cosa che avviene dove un provider scrive l’output di ciascun contributore come file che una destinazione legge come un unico insieme. Dove invece il provider unisce l’output di un assemblaggio in un unico documento, i file di ciascuna associazione restano fuori da quel documento e un nome all’interno di uno di essi è circoscritto a quel file, quindi due associazioni del genere non si incontrano mai e il build procede.

Non tutti i nomi vengono segnalati, quindi un build che non si arresta non ha stabilito che ogni nome che il suo output finirà per portare sia stato confrontato. Una risorsa lasciata da nominare al cluster — una che dichiara generateName anziché name — non porta ancora alcun nome, quindi non ce n’è nessuno da segnalare. E un nome scritto in qualche altro campo perché un controller lo legga in seguito non è un nome di risorsa, quindi nulla lo confronta. Entrambi i limiti sono proprietà della lettura del documento emesso, quindi entrambi si applicano a un corpo di artifacts esattamente come si applicano a un template di chart renderizzato.

Un corpo di artifacts: è un template, quindi un nome al suo interno che deve essere distinto per ogni host viene composto anziché scritto come letterale. .context.rendered_name è il nome che gli assegna il provider proprio del componente host — con helm, il suo nome di release, scritto nei caratteri ammessi da un nome Kubernetes — e .attachment_name è la chiave con cui lo hai associato, quindi {{ .context.rendered_name }}-{{ .attachment_name }} dà a una risorsa un nome proprio su ogni host e sotto ogni associazione. Su un host il cui provider non segnala un nome del genere, componilo invece da .context.instance_id, l’identità dell’host. Un unico corpo scritto raggiunge ogni host a cui è associato portando con sé i nomi che contiene, e un letterale è lo stesso su tutti — quindi dai quella struttura a un nome che deve essere unico nel cluster.

Nulla del significato di un nome viene interpretato — due nomi segnalati sono o lo stesso testo o non lo sono — ed è per questo che la stessa segnalazione copre ogni tipo di nome, chiunque lo abbia derivato.

Un nome può comparire in più di una segnalazione per un unico componente, perché ogni parte di un componente viene segnalata man mano che ne viene eseguito il rendering. Si tratta di un’unica risorsa nominata in ogni segnalazione a cui appartiene, non di un nome usato due volte, e non provoca un arresto. Ciò che provoca un arresto è una singola segnalazione che porta un nome due volte, perché quella segnalazione descrive un output in cui il nome è davvero usato due volte.

Questa lettura dipende da ciò che conta come un unico contributore, e per il tipo component-id la risposta è l’associazione anziché il componente o il confine su cui si trova. Un’associazione è identificata da entrambe le coordinate che hai scritto per essa — il componente a cui è associata insieme alla chiave sotto features:, oppure il percorso del confine insieme al nome in quel confine — quindi due associazioni su un solo componente sono due contributori, esattamente come lo sono due su componenti diversi, e un nome di funzionalità scritto in due confini è due contributori anche se il nome è lo stesso in ciascuno. Essere due contributori è ciò che rende confrontabili le loro identità in ciascuna di queste disposizioni; se due di essi vengano confrontati del tutto segue la stessa regola di ogni altro nome qui, quindi dove il provider unisce, un’associazione il cui output è scritto come file separati propri resta fuori dal documento unito e viene confrontata solo con sé stessa. Due associazioni che raggiungono un’unica identità provocano quindi un arresto ovunque il loro output possa raggiungere quello dell’altra, e ogni rilievo nomina entrambe le sue coordinate così puoi capire quali due cose separare. Poiché entrambe le coordinate fanno parte del valore composto, due associazioni che sai distinguere raggiungono due identità a qualunque lunghezza che rientri nella destinazione — quindi la disposizione che raggiunge questo arresto è quella in cui un valore troppo lungo per la sua destinazione è stato accorciato e due valori accorciati si sono incontrati. Dove due identità accorciate si incontrano e il loro output non può raggiungere quello dell’altra — due associazioni su un componente, con un provider che unisce, ciascuna scritta come file separati propri — nulla le confronta, e i due insiemi di risorse portano un unico aggrega.ai/component-id in comune.

Una disposizione merita di essere esplicitata perché sembra che debba provocare un arresto e invece non lo fa: associare una funzionalità con lo stesso nome su due componenti è pienamente supportato, e non richiede alcuna ridenominazione. Il componente fa parte del valore composto, quindi metrics su api e metrics su web raggiungono due identità e le risorse di ciascun componente ricevono un’identità propria — il che conta perché una cascata che per progettazione conia un unico nome di associazione su molti componenti non lascia a un autore nessun altro nome da scrivere. Ogni modo in cui una FeatureRecipe consegna risorse mette la sua identità su ciò che emette, compreso quello che si limita a incorporare una sorgente e ne esegue il rendering così com’è, quindi ognuno di essi viene confrontato; una funzionalità la cui FeatureRecipe non emette nulla non ha nulla da confrontare.

Il build si arresta anziché tenerne uno e scartare l’altro. Non esiste una risoluzione silenziosa corretta: tenere il primo eliminerebbe del tutto dall’output una risorsa che hai dichiarato e lascerebbe il build a segnalare un successo, e qualunque cosa facesse riferimento a quella eliminata si risolverebbe silenziosamente su quella rimasta. Ogni nome in collisione viene segnalato, ciascuno con il tipo di nome che è e con ogni contributore che lo ha derivato nominato — così un solo build ti dà il quadro completo anziché una collisione alla volta. Un contributore il cui output proprio porta il nome due volte viene nominato come contributore che ha derivato il nome più di una volta, ed è questo che ti dice che le due cose da separare si trovano all’interno di quell’unico componente anziché tra due componenti.

Messaggi emessi. Viene segnalato un rilievo per ogni contributore e per ogni nome in collisione, così ogni contributore che ha derivato il nome viene nominato a sé anziché essere raccolto in un elenco all’interno di un unico messaggio. Dove due contributori hanno derivato il nome ci sono almeno due rilievi, e arrivano insieme sotto una segnalazione che indica ciò che hanno in comune:

dispatch groups whose contributors derive one name more than once in one key space (gruppi di inoltro i cui contributori derivano un unico nome più di una volta in un unico spazio delle chiavi)

Ogni rilievo nomina il nome, il tipo di nome che è, il contributore che lo ha derivato, e il provider e il percorso dell’assemblaggio in cui si unisce il loro output:

derived name collision: one name is derived more than once in one key space ("<name>", key space "<kind-of-name>", derived by component "<contributor>", provider "<provider>", dispatch path "<path>") (collisione di nomi derivati: un unico nome viene derivato più di una volta in un unico spazio delle chiavi (con il nome, lo spazio delle chiavi, il componente che lo ha derivato, il provider e il percorso di inoltro indicati))

Il contributore è nominato per ciò che è, ed è questo a dire dove è scritto il suo nome: derived by component per un’istanza di componente, e derived by feature per una funzionalità associata a un confine.

Dove il nome proprio del contributore non basta da solo a identificarlo, segue una seconda coordinata, e quale sia dipende dal tipo. Una funzionalità associata a un confine porta il percorso del confine, perché un unico nome di funzionalità può essere scritto in più di un confine:

derived name collision: one name is derived more than once in one key space ("<name>", key space "<kind-of-name>", derived by feature "<feature-name>", attached at boundary "<boundary-path>", provider "<provider>", dispatch path "<path>") (collisione di nomi derivati: un unico nome viene derivato più di una volta in un unico spazio delle chiavi (con il nome, lo spazio delle chiavi, la funzionalità che lo ha derivato, il confine a cui è associata, il provider e il percorso di inoltro indicati))

Un componente porta la chiave dell’associazione il cui rendering ha derivato il nome, perché un componente porta un’associazione per ogni chiave che hai scritto:

derived name collision: one name is derived more than once in one key space ("<name>", key space "<kind-of-name>", derived by component "<component>", carrying attachment "<attachment-key>", provider "<provider>", dispatch path "<path>") (collisione di nomi derivati: un unico nome viene derivato più di una volta in un unico spazio delle chiavi (con il nome, lo spazio delle chiavi, il componente che lo ha derivato, l’associazione che porta, il provider e il percorso di inoltro indicati))

Il rendering proprio di un componente — un nome che il suo provider ha derivato per il componente stesso anziché per una delle sue associazioni — non porta alcuna seconda coordinata, quindi il rilievo termina con il nome del componente.

Dove l’output proprio di un singolo contributore porta il nome due volte, quell’unico contributore è l’unico rilievo, quindi arriva da solo senza alcuna segnalazione sopra di esso — e viene nominato come contributore che ha derivato il nome più di una volta, anziché come contributore che ne ha incontrato un altro:

derived name collision: one name is derived more than once in one key space ("<name>", key space "<kind-of-name>", derived more than once by component "<contributor>", provider "<provider>", dispatch path "<path>") (collisione di nomi derivati: un unico nome viene derivato più di una volta in un unico spazio delle chiavi (con il nome, lo spazio delle chiavi, il componente che lo ha derivato più di una volta, il provider e il percorso di inoltro indicati))

La seconda coordinata segue qui il contributore alle stesse condizioni di sopra, quindi una ripetizione all’interno dell’output proprio di un’associazione nomina quell’associazione anziché soltanto il componente che la porta.

Come risolvere: dove sono nominati due contributori, rinominane uno nell’Aggregate, così che i nomi derivati da esso non coincidano più con quelli dell’altro. Dove il tipo di nome è component-id, ogni rilievo nomina già la cosa da rinominare: carrying attachment "…" è la chiave sotto il blocco features: di quel componente, e un feature "…" attached at boundary "…" è il nome sotto il blocco features: di quel confine. Dove i due rilievi differiscono solo per il confine che nominano, le due associazioni portano un unico nome in due confini — rinominane una, oppure assegna ai due confini percorsi directory: distinti così che il loro output non venga più unito. Dove i due nomi sono stati composti dal build, possono essersi incontrati solo dopo essere stati accorciati per rientrare nella destinazione, quindi accorcia tu stesso le parti da cui sono composti anziché lasciarlo fare al build. Dove entrambi i nomi derivano da qualcosa che hai impostato esplicitamente — un valore che la Recipe fornisce al provider, o un’annotazione che il provider legge — modifica invece quello, su quello dei due che controlli. Dove i due contributori appartengono davvero a output separati, assegna ai loro confini percorsi directory: distinti così che ciascuno si assembli per conto proprio e i due nomi non si incontrino mai. Dove un singolo contributore è nominato come contributore che ha derivato il nome più di una volta, le due cose in collisione si trovano entrambe all’interno di quell’unico componente: trova le due risorse prodotte dalla sua Recipe i cui nomi coincidono, e cambia ciò da cui prende il nome una delle due — la chiave sotto cui è dichiarata, o un valore da cui è costruita — così che il provider derivi un nome distinto per ciascuna. Dove il tipo di nome è costituito solo da un tipo con ambito di cluster, come resource-names:ClusterRole, i documenti nominati descrivono un unico oggetto nel cluster, in qualunque namespace siano stati collocati: emettilo da un solo contributore — tramite un valore che il suo chart offre, come un interruttore per installare le sue definizioni — oppure, dove i due devono essere due oggetti, dai a uno dei due un nome proprio nel chart o nel corpo che controlli; un singolo contributore nominato due volte per esso lo scrive sotto due namespace, e uno dei due documenti è quello da eliminare.

An authored export name is one the build derives for a cross-stack reference (Un nome di esportazione scritto è uno che il build deriva per un riferimento tra stack)

Il blocco Outputs: di una Recipe cloudformation è CloudFormation scritto dall’autore, e una sua voce può portare un proprio Export: con un Name:; quel nome raggiunge lo stack assemblato esattamente come è scritto. Separatamente, quando un arco uses passa da un confine a un altro, il provider pubblica il valore consumato come Output dello stack con un Export sotto un nome che deriva dalla release, dal confine, dal componente e dalla chiave fornita. Questo arresto scatta dove i due si incontrano: il nome che hai scritto è il nome che la derivazione ha prodotto per lo stesso build, quindi lo stack dichiarerebbe un unico nome di esportazione due volte da due punti, e un nome di esportazione deve essere unico.

Solo la coincidenza provoca un arresto. Dichiarare un nome di esportazione su una voce Outputs è supportato, e uno che non coincide con alcun nome derivato viene pubblicato accanto a quelli derivati senza commenti — su ogni voce tranne l’output dello stack su cui un riferimento tra stack pubblica la propria esportazione, per una chiave che consuma. Un Export: lì provoca un arresto a meno che non porti esattamente il nome derivato; quel caso è The output a cross-stack reference publishes on already carries an Export (L’output su cui un riferimento tra stack pubblica porta già un Export).

L’arresto riporta il nome di esportazione derivato insieme alle quattro parti da cui è stato costruito, così puoi vedere quale riferimento tra confini lo ha prodotto, e nomina l’output dello stack sotto cui si trova la tua dichiarazione — contrassegnato come un nome che il provider assembla anziché uno scritto da una Recipe, perché il provider costruisce quel nome codificando il componente e la voce nelle lettere e cifre ammesse da un ID logico, quindi non è la stringa con cui è stato scritto nessuno dei due. Il nome di esportazione è la parte da cercare. La tua voce lo scrive esattamente come l’arresto, ed è questo che rende i due una collisione, quindi è l’unica stringa che compare sia nel messaggio sia nei tuoi file.

Il confronto è circoscritto a un unico stack: i nomi di esportazione che quello stack dichiara, rispetto ai nomi derivati per i riferimenti tra confini che vi pubblicano. Due stack non vengono confrontati tra loro, e un nome di esportazione scritto come funzione intrinseca di CloudFormation si risolve al momento della distribuzione, quindi non c’è alcun nome da confrontare. Ciò che un nome incontra tra le esportazioni già distribuite in un account e in una regione è una proprietà della distribuzione, che un build non osserva.

Messaggio emesso. La condizione nomina il tipo di errore e la frase propria del provider dice cosa è successo; la segnalazione circostante nomina anche l’arco uses che viene cablato:

two things a plugin produced occupy one name in its output (due cose prodotte da un plugin occupano un unico nome nel suo output) cloudformation-provider: an export name a cross-boundary link derives is already declared by another Outputs entry in the same stack: the link derives the export name <export-name> for provides key <provides-key> of component <component> in boundary <boundary> of Release <release>, and another Outputs entry of the same stack already declares that same export name — that declaration sits under the stack output <stack-output>, a name this provider assembles rather than one a Recipe wrote; each shadowing Outputs entry spells its export name exactly as the halt does, so searching your Recipes for that name reaches the entry — rename the export name the entry declares, or remove that entry’s Export block and let the link publish the export (un nome di esportazione che un collegamento tra confini deriva è già dichiarato da un’altra voce Outputs nello stesso stack: il collegamento deriva il nome di esportazione indicato per la chiave provides indicata del componente indicato nel confine indicato della Release indicata, e un’altra voce Outputs dello stesso stack dichiara già quello stesso nome di esportazione — quella dichiarazione si trova sotto l’output dello stack indicato, un nome che questo provider assembla anziché uno scritto da una Recipe; ogni voce Outputs che fa ombra scrive il suo nome di esportazione esattamente come l’arresto, quindi cercare quel nome nelle tue Recipes porta alla voce — rinomina il nome di esportazione che la voce dichiara, oppure rimuovi il blocco Export di quella voce e lascia che il collegamento pubblichi l’esportazione)

Come risolvere: cerca nelle tue Recipes il nome di esportazione che l’arresto nomina — la voce Outputs che lo dichiara lo scrive in modo identico — quindi rinomina quel nome di esportazione così che non coincida più, oppure rimuovi il blocco Export: di quella voce e lascia che sia il cablaggio tra stack stesso a pubblicare l’esportazione. Rimuoverlo è di solito la scelta giusta dove la voce esisteva per esportare lo stesso valore che l’arco consuma: il provider pubblica comunque un Export per quel valore, quindi quello scritto non aggiunge nulla. Mantieni invece l’Export: scritto e rinominalo dove la voce esporta il valore per un consumatore diverso che lo importa con un nome scelto da te.

The output a cross-stack reference publishes on already carries an Export (L’output su cui un riferimento tra stack pubblica porta già un Export)

Quando un arco uses passa da un confine a un altro, il provider pubblica l’Export del valore consumato sull’output dello stack che assembla per il componente produttore e la chiave fornita — lo stesso output che una Recipe cloudformation raggiunge quando il suo blocco Outputs: scrive una voce sotto quella chiave. Un Export: già presente su quell’output viene mantenuto solo quando il suo Name: è esattamente il nome che il provider deriva: è l’esportazione che un precedente riferimento tra stack allo stesso valore ha già pubblicato, così ogni consumatore importa quell’unico nome. Qualsiasi altro Export: in quel punto provoca un arresto, perché scrivere l’esportazione del provider sovrascriverebbe ciò che hai scritto tu, e mantenere il tuo lascerebbe ogni consumatore a importare un nome che il riferimento non ha mai pubblicato.

L’arresto scatta su quattro forme di Export: su quell’output:

  • un Name: che è una stringa diversa;
  • un Name: scritto come funzione intrinseca di CloudFormation, che si risolve al momento della distribuzione, quindi il provider non può leggere ciò che esprime;
  • un blocco Export: che non nomina nulla;
  • un Export: scritto come valore semplice anziché come blocco.

Un nome di esportazione che dichiari su qualsiasi altra voce Outputs viene confrontato separatamente, in An authored export name is one the build derives for a cross-stack reference (Un nome di esportazione scritto è uno che il build deriva per un riferimento tra stack).

Messaggio emesso. La condizione nomina il tipo di errore e la frase propria del provider dice cosa è successo; la segnalazione circostante nomina anche l’arco uses che viene cablato:

two things a plugin produced occupy one name in its output (due cose prodotte da un plugin occupano un unico nome nel suo output) cloudformation-provider: the stack output a cross-boundary link publishes its export on already carries an Export the link did not write: the link derives the export name <export-name> for provides key <provides-key> of component <component> in boundary <boundary> of Release <release>, and the stack output this provider assembles for that key and component <what-it-found>; remove that entry’s Export block and let the link publish the export every consumer imports (l’output dello stack su cui un collegamento tra confini pubblica la propria esportazione porta già un Export che il collegamento non ha scritto: il collegamento deriva il nome di esportazione indicato per la chiave provides indicata del componente indicato nel confine indicato della Release indicata, e l’output dello stack che questo provider assembla per quella chiave e quel componente presenta quanto indicato; rimuovi il blocco Export di quella voce e lascia che il collegamento pubblichi l’esportazione che ogni consumatore importa)

<what-it-found> è uno dei seguenti, nell’ordine delle forme qui sopra:

already declares the export name <name> (dichiara già il nome di esportazione indicato) already declares an export name that is not a string — one given as an intrinsic, which resolves at deploy time, so this provider cannot read what it spells (dichiara già un nome di esportazione che non è una stringa — uno fornito come funzione intrinseca, che si risolve al momento della distribuzione, quindi questo provider non può leggere ciò che esprime) already carries an Export block declaring no export name (porta già un blocco Export che non dichiara alcun nome di esportazione) already carries an Export that is not a block, where CloudFormation expects one carrying a Name (porta già un Export che non è un blocco, dove CloudFormation se ne aspetta uno che porti un Name)

Come risolvere: nella Recipe del componente che l’arresto nomina, trova la voce Outputs scritta sotto la chiave fornita che nomina, e rimuovi il blocco Export: di quella voce — il cablaggio tra stack pubblica allora l’esportazione che ogni consumatore importa. Dove ti serve che il valore venga esportato anche con un nome tuo, per un consumatore al di fuori di questo build, scrivi quell’Export: su una voce Outputs sotto una chiave diversa: lì un nome di esportazione è supportato, purché non sia uno che il build deriva.

Chart-name mismatch on a merged helm-chart umbrella (Nome di chart non corrispondente in un chart ombrello helm-chart unito)

Due o più confini contribuiscono allo stesso percorso di assemblaggio del provider helm-chart, ma le loro annotazioni aggrega.ai/chart-name effettive (risolte attraverso la cascata delle annotazioni dei confini) non concordano. Un chart ombrello Helm ha esattamente un nome di chart; il renderer non può scegliere uno dei candidati in conflitto.

Messaggi emessi. Viene segnalato un rilievo per ciascun confine contributore, ognuno con il valore a cui quel confine si è risolto, così i nomi discordanti arrivano uno per rilievo anziché come un’unica raccolta stampata. La segnalazione sotto cui arrivano indica ciò che hanno in comune:

merged dispatch groups whose boundaries disagree on the assembly name (gruppi di inoltro uniti i cui confini non concordano sul nome di assemblaggio)

Ogni rilievo nomina il valore a cui quel confine si è risolto, l’annotazione da cui è stato letto, il confine, il provider e il percorso su cui confluiscono:

merged-path assembly has conflicting assembly-name annotation values ("<value>", annotation "<annotation>", boundary "<boundary>", provider "<provider>", dispatch path "<path>") (l’assemblaggio a percorso unito ha valori in conflitto per l’annotazione del nome di assemblaggio (con il valore, l’annotazione, il confine, il provider e il percorso di inoltro indicati))

Come risolvere: dichiara un’annotazione aggrega.ai/chart-name corrispondente su ogni confine contributore (il meccanismo a cascata lo rende DRY quando i contributori condividono un confine padre — dichiarala una volta sul padre), oppure separa i confini su percorsi directory: distinti, così che ciascuno abbia un chart ombrello proprio.

FeatureRecipe template references a field outside its scope’s allowlist (Il template della FeatureRecipe fa riferimento a un campo al di fuori dell’allowlist del suo livello)

Una FeatureRecipe con executionScope: boundary fa riferimento a un campo esclusivamente per componente come .context.instance_id, .context.inject o .context.uses — campi che non hanno un valore significativo a livello di confine — in un template che viene eseguito una sola volta per il confine: i suoi locals:, provides:, valuesMapping:, artifacts: o il with: o il when: di un passo di pipeline. Vale la condizione speculare: una FeatureRecipe a livello di componente (il valore predefinito) che fa riferimento a campi .boundary.* non supera lo stesso validatore. La validazione viene eseguita al momento del parsing rispetto all’allowlist dei campi del livello pertinente, prima che inizi qualsiasi lavoro di rendering. L’injectMapping di una FeatureRecipe a livello di confine non viene controllato qui: viene eseguito una volta per ciascun componente raggiunto dall’associazione, nel contesto di quel componente, quindi legge .context.*, e un riferimento a .boundary al suo interno viene segnalato da «Template references a root the render context does not define (Il template fa riferimento a una radice che il contesto di rendering non definisce)» più sopra.

Messaggio emesso:

FeatureRecipe template references a per-component-only field with executionScope: boundary ("<dotted-path>", written in "<field>", the render context defines "<the roots the boundary-scope context defines>") (il template della FeatureRecipe fa riferimento a un campo esclusivamente per componente con executionScope: boundary (con il percorso indicato, scritto nel campo indicato; il contesto di rendering definisce le radici indicate))

Una FeatureRecipe a livello di confine il cui valuesMapping legge .context.instance_id stampa:

[CATALOG_ERROR E0039] scope-probe-fr at .spec.valuesMapping
FeatureRecipe template references a per-component-only field with executionScope: boundary (".context.instance_id", written in "valuesMapping", the render context defines ".values, .infra, .locals, .provides, .features, .metadata, .steps, .source, .boundary")

Come risolvere: riscrivi il template in base ai campi disponibili nel livello, oppure cambia l’executionScope della FeatureRecipe. Le FeatureRecipes a livello di confine fanno riferimento a .boundary.path, .boundary.boundary_name, .boundary.components, alle raccolte .boundary.*_uses_edges, a .boundary.labels, .boundary.annotations e .boundary.feature_attachments. Le FeatureRecipes a livello di Component fanno riferimento a .context.instance_id, .context.inject, .context.uses, .context.labels, .context.annotations. Entrambi i livelli condividono .values, .infra, .locals, .provides, .steps e .metadata. Un parametro della Release non è un pilastro a sé su questa superficie — raggiunge un template di FeatureRecipe tramite una voce values o infra che vi fa riferimento.

Self-inject value template references cross-node data (Il template del valore di self-inject fa riferimento a dati tra nodi)

Un template inject: value: a livello di componente attinge da .context.inject o .context.uses. Il canale di inject è proprio ciò che questa fase sta costruendo — un template all’interno del valore di self-inject proprio di un componente non può leggere da esso.

È il .context della superficie a determinarlo: porta instance_id, labels e annotations, e nient’altro. .context.inject e .context.uses sono quindi chiavi che il contesto di questa superficie non definisce, e il riferimento provoca un arresto come «Template references a root the render context does not define (Il template fa riferimento a una radice che il contesto di rendering non definisce)» più sopra, al momento del parsing, prima che venga eseguito il rendering di qualsiasi cosa. La diagnostica nomina il meccanismo e la chiave di consegna a cui appartiene il template, ed elenca le chiavi che .context definisce qui — così la stessa segnalazione copre sia un vero tentativo di raggiungere dati tra nodi sia un semplice errore di ortografia come {{ .context.nmae }}, che è l’errore più comune e che altrimenti sarebbe stato renderizzato come niente.

Messaggio emesso — il dettaglio a livello di riferimento; la segnalazione circostante nomina anche il nodo, il meccanismo e la chiave di consegna:

template references a root the render context does not define (template self-inject.<mechanism>[<key>] references .context.inject, .context defines .context.instance_id, .context.labels, .context.annotations) (il template fa riferimento a una radice che il contesto di rendering non definisce (il template di self-inject indicato fa riferimento al percorso indicato, il contesto definisce le chiavi indicate))

Ogni frame della segnalazione è nel dominio dello sviluppatore, perché un blocco inject: a livello di componente viene scritto nell’Aggregate.

Come risolvere: sposta il cablaggio tra componenti in una voce uses[].inject — è lì che il contesto tra nodi è disponibile. Mantieni i template value: di self-inject a livello di componente chiusi sui values e sull’infra propri del componente, sui suoi .context.instance_id / .context.labels / .context.annotations e su .metadata.

Missing template key — asymmetric policy (Chiave di template mancante — politica asimmetrica)

La gestione delle chiavi mancanti dipende dalla superficie del template. Dove un rendering vuoto finisce in un punto circoscritto — un campo del manifesto che l’autore può rileggere — la mancanza è tollerata e la lettura non produce nulla. Dove invece un rendering vuoto produrrebbe una struttura sbagliata o un verdetto sbagliato, la superficie rifiuta il riferimento anziché risolverlo in nulla.

  • L’interpolazione dei parametri in un Aggregate — i riferimenti {{ .parameters.<key> }} che porta il testo proprio dell’Aggregate — è la prima di queste superfici: viene eseguita sul documento grezzo prima che il catalogo si risolva, quindi la sua politica si applica a testo che nessun’altra superficie ha ancora visto. Un riferimento a un parametro che la Release non ha mai valorizzato viene renderizzato come niente, e una pipe default o una guardia if su una lettura del genere si comporta esattamente come farebbe sul parametro non valorizzato. Un riferimento che il template itera continua a essere iterato come niente, ed è ciò che serve a un range su una lista opzionale — a meno che il testo non lo stampi anche, nel qual caso provoca un arresto come descrive «A template reads and iterates a path that holds nothing (Un template legge e itera un percorso che non contiene nulla)» più sotto. Un riferimento il cui padre è assente — .parameters.db.host dove non è stato valorizzato alcun parametro db — provoca comunque un arresto, perché non c’è nulla in cui scendere e fornire un padre scambierebbe l’arresto con un artefatto silenziosamente sbagliato. Un limite merita di essere enunciato come limite anziché come politica: un riferimento ancorato a una radice che la superficie non definisce viene lasciato com’è anziché renderizzato come niente, quindi sopravvive nel documento interpolato come il testo segnaposto proprio del motore di template, <no value>. Nulla su questa superficie provoca un arresto per questo, quindi ancora ogni riferimento a un parametro a .parameters, e leggi un <no value> isolato come una radice scritta male.
  • I template di percorso (directory: / subDirectory: dei confini della Release) vengono valutati con missingkey=error. Un riferimento a una variabile che la superficie non fornisce loro provoca un arresto al momento del parsing — vedi «Path-template references a variable outside the allowlist (Il template di percorso fa riferimento a una variabile al di fuori dell’allowlist)» più sopra — e lo stesso vale per una chiave digitata male sotto .manifest, le cui chiavi sono dichiarate. Un riferimento ammesso ma non definito al momento della valutazione, come una chiave di .parameters che la Release non fornisce, produce un errore esplicito anziché il rendering silenzioso di una stringa vuota in un percorso di directory.
  • assertions (su un Component, una Feature, una Recipe o una FeatureRecipe) vengono valutate con missingkey=error. Un riferimento a una chiave non definita provoca un arresto con una diagnostica di chiave inesistente che nomina l’entità, l’istanza e l’asserzione. La rigidità è ciò che rende affidabile un’asserzione: un predicato il cui riferimento fosse renderizzato come valore vuoto confronterebbe con niente e passerebbe, quindi un singolo errore di battitura ritirerebbe silenziosamente la regola che l’asserzione era stata scritta per far rispettare. Poiché il riferimento nudo provoca un arresto prima che qualsiasi fallback possa essere eseguito, un semplice default non fornisce un fallback per un campo opzionale su questa superficie — proteggi il riferimento con hasKey, oppure usa l’helper optional, che esegue direttamente il controllo di presenza. Nemmeno leggere la chiave tramite index ne fornisce uno: index provoca un arresto su una chiave di mappa che la mappa non contiene, nominando la chiave.
  • I template di valore (valuesMapping della Recipe, voci locals: e provides:, corpi di artifacts:, corpi di Workload, injectMapping e pipeline.with della FeatureRecipe, e template value: di self-inject a livello di componente) vengono valutati con missingkey=zero, quindi un riferimento a una chiave non definita non arresta il build — la lettura non produce nulla, ed è il nulla a raggiungere l’artefatto. Ciò che invece provoca ancora un arresto su questa superficie è un riferimento che scende attraverso un contenitore che l’autore non ha mai fornito — .values.tls.ca dove non è stato scritto alcun tls — perché non c’è nulla in cui scendere. Solo la chiave finale di un riferimento i cui contenitori sono tutti presenti viene renderizzata come niente. Un campo di primo livello che il contesto definisce ma per cui non contiene nulla — .workload su una Recipe che non ne sintetizza alcuno, .features su un componente senza associazioni — viene renderizzato come niente allo stesso modo quando viene letto per intero. Un riferimento è un solo riferimento comunque sia scritto: .values.list, $.values.list e (.values).list nominano la stessa chiave, quindi iterarla con range in una scrittura equivale a iterarla in tutte, e una chiave letta da un pilastro tra parentesi viene renderizzata, o provoca un arresto, esattamente come la scrittura diretta. Una chiave su cui il template esegue range continua a essere iterata come niente quando non è impostata, e una chiave che il template sia stampa sia itera provoca un arresto quando non è impostata — vedi «A template reads and iterates a path that holds nothing (Un template legge e itera un percorso che non contiene nulla)» più sotto. Le protezioni funzionano come previsto: {{ .values.optional_field | default "fallback" }} fornisce effettivamente il fallback, perché un valore non impostato conta come vuoto per default e come falso per if. Chi scrive e ha bisogno del discriminante tra assente e zero — distinguere «chiave assente» da «chiave presente e vuota» — usa l’helper optional documentato in templates/sprig-functions.md, e legge una data chiave in un solo modo per template: una chiave che lo stesso template legge anche come .values.<key> conta come presente, quindi optional riporta il suo valore vuoto anziché il fallback. Ciò che questa politica non copre è una lettura tramite index: indicizzare una mappa con una chiave che non contiene provoca un arresto che nomina la chiave, qui come su ogni superficie — vedi «A template indexes a map with a key the map does not hold (Un template indicizza una mappa con una chiave che la mappa non contiene)» più sotto.
  • Una coordinata source: — i campi con template di un blocco source: strutturato su una Recipe o una FeatureRecipe (version, ref, chart, module_subdir) — viene valutata con missingkey=error. Un riferimento a una chiave che nulla fornisce provoca un arresto che nomina il campo della sorgente, anziché risolversi in niente: una versione o un ref vuoti fisserebbero un artefatto diverso da quello che l’autore ha nominato, e il fissaggio è ciò che ogni build successivo riproduce. Questa superficie è anche quella in cui l’insieme di funzioni disponibili differisce, e in cui un riferimento locals: che l’ordine di scrittura del blocco stesso rifiuta provoca un arresto prima che venga valutato qualsiasi cosa — vedi più sotto.
  • I contratti di parametro tipizzati intercettano i casi di parametro obbligatorio mancante e di violazione del contratto nello strato del contratto dei parametri, prima che venga eseguita l’interpolazione — vedi «Parameter type mismatch / contract violation (Tipo di parametro non corrispondente / violazione del contratto)» più sopra.

L’insieme di helper è lo stesso per template di valore, template di percorso e asserzioni: le funzioni di Sprig più quelle proprie di Aggrega (optional e capitalizedWords). Il fail di Sprig è tra queste, quindi un template di valore può fermare il build con un messaggio proprio, come descrive «A value template failed while it ran (Un template di valore non è riuscito durante l’esecuzione)» più sotto; un’asserzione è la superficie scritta per questo, dato che arrestare il build è il suo unico scopo. Tra queste tre ciò che differisce è la politica delle chiavi mancanti — optional è disponibile anche in un template di percorso, dove legge una chiave da .parameters senza che la politica rigida scatti prima. La risoluzione di una coordinata source: differisce nell’insieme di funzioni stesso, e ha una sottosezione propria più sotto. L’interpolazione dei parametri in un Aggregate offre solo le funzioni di Sprig, quindi lì nessuno dei due helper di Aggrega è disponibile. Una funzione legge allo stesso modo su ognuna di queste superfici, la coordinata e l’interpolazione incluse: index, che provoca un arresto nominando la chiave quando la mappa che legge non la contiene.

Il messaggio che stampa una mancanza in un template di percorso è citato sotto la voce che documenta quella condizione, «Path-template references a variable outside the allowlist (Il template di percorso fa riferimento a una variabile al di fuori dell’allowlist)» più sopra, quindi è scritto una volta sola anziché ripetuto qui.

Come risolvere: per le mancanze nei template di percorso, correggi il nome del campo con uno presente nell’allowlist documentata in path-template-variables.md. Per una mancanza in un’asserzione, correggi il riferimento — la maggior parte delle segnalazioni è una chiave scritta male — oppure, dove il campo è davvero opzionale, proteggilo con hasKey o usa l’helper optional; racchiudere il riferimento nudo in un default non elimina l’arresto, perché il riferimento si risolve prima che venga eseguito il fallback, e nemmeno leggerlo tramite index, perché index provoca un arresto su una chiave che la mappa non contiene. Per le mancanze nei template di valore dove il rendering vuoto non è desiderato, usa l’helper optional oppure fornisci la chiave mancante come dichiarazione parameters.* tipizzata sull’Aggregate con un valore della Release, come voce provides: di un Component a monte cablata tramite uses[].inject, o come voce locals: sulla stessa entità.

Resolving a source: coordinate registers a narrower function set (La risoluzione di una coordinata source registra un insieme di funzioni più ristretto)

Un blocco source: strutturato viene risolto perché l’artefatto che nomina possa essere fissato, e quella risoluzione registra gli helper propri di Aggrega e nient’altro — optional e capitalizedWords sono disponibili, e index provoca un arresto su una chiave di mappa che la mappa non contiene esattamente come quando la Recipe esegue il rendering; le funzioni di Sprig no. Tra le superfici su cui una Recipe o una FeatureRecipe scrive template, questa è quella il cui insieme di funzioni differisce, quindi un’espressione che viene renderizzata correttamente altrove nella stessa Recipe può essere rifiutata qui. L’insieme più ristretto è voluto: ciò che viene fissato è deciso dai values e dall’infra che l’autore fornisce, e tra le funzioni di Sprig ce ne sono alcune che leggono l’orologio, l’ambiente, una sorgente casuale o la rete.

Chiamare una funzione di Sprig in un campo source:, o in una voce locals: che quel campo legge, provoca un arresto al momento del parsing. La diagnostica ha come intestazione E0111 e nomina la voce, il campo source: che la legge, la funzione che non è riuscita a risolvere e gli helper che questa superficie registra:

resolve: parse template at <name>:<version>.spec.locals.<key>, read by <name>:<version>.spec.source.<field>: resolve: source-template parse error (cause: template: <name>:<version>.spec.locals.<key>:1: function "<function>" not defined); a source field, and every locals entry it reads, is evaluated when the source is resolved with Aggrega’s own helpers only (optional, capitalizedWords and index), not the Sprig functions a render adds; write the value without that function, or move the value into a locals entry no source field reads (risoluzione: parsing del template alla voce di locals indicata, letta dal campo source indicato: risoluzione: errore di parsing del template della sorgente (causa: la funzione indicata non è definita); un campo source, e ogni voce di locals che legge, viene valutato quando la sorgente viene risolta solo con gli helper propri di Aggrega (optional, capitalizedWords e index), non con le funzioni di Sprig che un rendering aggiunge; scrivi il valore senza quella funzione, oppure sposta il valore in una voce di locals che nessun campo source legge)

Un campo source: che chiama direttamente la funzione viene segnalato allo stesso modo, nominando solo il campo.

La portata sono le voci che la coordinata legge. La risoluzione di una coordinata valuta ogni voce locals: che un campo source: legge, e ogni voce che una tale voce legge a sua volta — e nessun’altra. Una voce che nessun campo source: raggiunge non viene valutata, analizzata né controllata mentre la sorgente viene risolta, quindi una voce di locals di cui il rendering ha bisogno — una che fa aritmetica con le funzioni di Sprig, o che nomina una risorsa in base a .context.instance_id — non ha alcun effetto sul fissaggio dell’artefatto; viene valutata, e ogni suo difetto segnalato, quando la Recipe esegue il rendering. Quali voci legge un campo è deciso dal suo testo, quindi un campo che legge .locals in un modo che non nomina alcuna singola voce — {{ index .locals "version" }}, l’intero blocco passato a optional o assegnato a una variabile — fa invece valutare ogni voce, e la diagnostica per una voce che raggiunge in quel modo lo dice: al posto di read by <field> riporta evaluated for <field>, which reads the locals block as a whole rather than by entry, so every entry is evaluated.

Due forme stanno al di fuori di questa superficie, e sapere in quale si trova una Recipe spiega perché la stessa espressione è accettata in una Recipe e rifiutata in un’altra:

  • Un source: scritto come stringa semplice — un URI o un percorso locale anziché una mappa — viene preso così com’è, quindi non ha campi da valutare e il blocco locals: qui non viene risolto affatto.
  • Un’entità che non dichiara alcun source: non risolve alcuna coordinata, quindi il suo blocco locals: viene risolto solo per il rendering proprio di quell’entità, dove si applica l’insieme completo di funzioni.

Il contratto sull’ordine dei riferimenti è lo stesso qui per ogni voce che la coordinata legge. La risoluzione di una coordinata rifiuta gli stessi riferimenti che un rendering rifiuta in ogni voce che valuta: una voce che legge una voce sorella che il blocco dichiara più sotto, e qualsiasi template che legge una chiave che il blocco non dichiara. Entrambi segnalano le condizioni documentate più sopra sotto «locals: entry references a sibling defined later in the same block (Una voce di locals fa riferimento a una voce sorella definita più avanti nello stesso blocco)» e «locals: key does not exist (La chiave di locals non esiste)» — la stessa condizione, con lo stesso rimedio, qualunque risoluzione l’abbia raggiunta per prima — e la segnalazione nomina il campo source: per cui la voce è stata valutata. Un difetto in una voce che nessun campo source: legge viene rifiutato quando la Recipe esegue il rendering, sotto la stessa condizione.

Ciò che questa superficie invece tralascia è una voce che una coordinata davvero non può risolvere: una che legge dati che esistono solo mentre un artefatto viene renderizzato, e .context.instance_id è il caso per cui esiste. Una voce del genere viene saltata, quindi una Recipe la cui coordinata ne raggiunge una su un ramo che non percorre viene comunque fissata. Dove la coordinata stessa aveva bisogno di quella voce, la risoluzione provoca un arresto nominando il campo source: — la segnalazione di chiave mancante descritta più sopra per questa superficie, con intestazione E0110 — e cita, accanto alla chiave che non è riuscita a leggere, perché quella voce qui non contiene alcun valore:

resolve: evaluate template at <name>:<version>.spec.source.<field>: resolve: source-template evaluation failure at lock time (cause: template: … map has no entry for key "<key>"); it reads <name>:<version>.spec.locals.<key>, which could not be evaluated here (cause: template: … map has no entry for key "context") (risoluzione: valutazione del template al campo source indicato: risoluzione: errore di valutazione del template della sorgente al momento del lock (causa: la mappa non ha alcuna voce per la chiave indicata); legge la voce di locals indicata, che qui non è stato possibile valutare (causa: la mappa non ha alcuna voce per la chiave context))

Né un campo source: né una voce locals: che esso legge possono leggere .provides. Un blocco locals: alimenta un blocco provides: e mai il contrario, quindi un template su questa superficie che legge .provides viene rifiutato come il riferimento inverso che è, anziché risolversi in niente. Il rifiuto non è un’assenza al momento del lock che una fase successiva soddisferebbe — nessun ordinamento rende valido il riferimento — quindi viene segnalato allo stesso modo ovunque la coordinata venga risolta. La diagnostica ha come intestazione E0112; nomina il campo, oppure la voce e il campo che la legge, dice che cosa c’è di sbagliato nel riferimento e indica la superficie che l’espressione può leggere invece:

source-version template at <name>:<version>.spec.source.<field> references .provides, which is an invalid reverse reference (locals feed provides, never the reverse) — refactor to read only .values and .infra (and .locals over the same): resolve: source-template references .provides (invalid reverse reference) (il template della versione della sorgente al campo source indicato fa riferimento a .provides, che è un riferimento inverso non valido (locals alimenta provides, mai il contrario) — rifattorizza per leggere solo .values e .infra (e .locals sugli stessi): risoluzione: il template della sorgente fa riferimento a .provides (riferimento inverso non valido))

Dove emerge l’arresto: mentre il lockfile viene popolato o aggiornato — aggrega pull, o un build che lo popola (--auto-pull, --upgrade o l’impostazione auto_pull del workspace). Ogni errore viene segnalato come una sola diagnostica, con come intestazione il codice di ciò che è andato storto — E0111 per un template che non supera il parsing, E0112 per un riferimento a .provides, E0110 per un template che ha superato il parsing ma non è stato possibile valutare — nel terminale come in un editor collegato ad aggrega serve. Una chiave mancante su un campo source:, a differenza di una funzione non disponibile, viene segnalata al momento dell’esecuzione anziché del parsing, nominando il campo e la chiave che non è riuscita a leggere.

Come risolvere: optional è registrato su questa superficie e su ogni template di valore, template di percorso e asserzione, il che lo rende la scelta portabile — {{ optional .values "chart_version" "25.0.8" }} al posto di {{ default "25.0.8" .values.chart_version }}. Leggi la differenza semantica prima di sostituire: optional scatta quando la chiave è assente, mentre default scatta quando il valore è vuoto, quindi una chiave scritta come stringa vuota o come zero mantiene il valore scritto con optional e viene sostituita con default. Dove l’espressione ha davvero bisogno di una funzione di Sprig — rimodellare una stringa anziché fornire un fallback — tienila fuori da ciò che la coordinata legge: in una voce locals: che nessun campo source: legge, o sulla superficie che la consuma (valuesMapping, un corpo di Workload, una voce artifacts:).

A template indexes a map with a key the map does not hold (Un template indicizza una mappa con una chiave che la mappa non contiene)

Un template legge una mappa tramite index — {{ index .values "replicas" }}, oppure {{ index .context.inject.env $apiKeyVar }} con un nome di chiave che il template ha calcolato — e la mappa non contiene la chiave richiesta. index provoca lì un arresto e nomina la chiave, su ogni superficie che valuta un template: template di valore, voci locals: e provides:, template di percorso, asserzioni, una coordinata source: strutturata, l’interpolazione dei parametri in un Aggregate e i predicati validate: dei suoi parametri, e i predicati x-aggrega-when: e x-aggrega-validate: di uno schema.

Questa è una proprietà del solo index, e la politica delle chiavi mancanti di nessuna superficie la modifica. Una lettura con il punto di una chiave non impostata sotto un pilastro aperto continua a non produrre nulla su un template di valore, come descrive «Missing template key — asymmetric policy (Chiave di template mancante — politica asimmetrica)» più sopra, e un template che verifica se l’autore ha fornito una tale chiave non ne è toccato. Ciò che provoca un arresto è chiedere a index una chiave che la mappa non contiene. index è il modo in cui un template raggiunge una chiave il cui nome calcola — una credenziale letta sotto il nome di variabile scelto dalla Recipe consumatrice, per esempio — e senza l’arresto quella lettura metterebbe nell’artefatto il testo segnaposto del motore di template <no value> mentre il build riesce: un server avviato con quel testo come chiave. Ogni altra risposta che index dà è quella propria del motore di template: una posizione in una lista o in una stringa, una posizione fuori intervallo, una chiave che la mappa contiene — compresa una il cui valore è null, che stampa <no value>.

Messaggio emesso, come ultima riga della segnalazione — i frame sopra di esso nominano il nodo e il campo in cui si trova il template, e su un template di valore di una Recipe o di una FeatureRecipe l’intestazione porta il codice di questa condizione:

template: <template>:<line>:<column>: executing "<template>" at <index <map> <key>>: error calling index: template indexes a map with a key the map does not hold (key "<key>"). read a key that may be absent through a function that tests for it first, such as optional, get or hasKey (template: esecuzione del template indicato, alla riga e alla colonna indicate, nell’espressione index indicata: errore nella chiamata di index: il template indicizza una mappa con una chiave che la mappa non contiene (con la chiave indicata). leggi una chiave che può essere assente tramite una funzione che ne verifica prima la presenza, come optional, get o hasKey)

Su una superficie che segnala un errore di template sotto una condizione propria — una voce provides: («A provides: template could not be evaluated (Un template di provides non può essere valutato)»), l’interpolazione dei parametri («A {{ .parameters.* }} reference cannot be interpolated (Un riferimento ai parametri non può essere interpolato)»), un predicato di schema («An x-aggrega-when: or x-aggrega-validate: predicate cannot be evaluated (Un predicato non può essere valutato)»), una coordinata source: («Resolving a source: coordinate registers a narrower function set (La risoluzione di una coordinata source registra un insieme di funzioni più ristretto)») — l’intestazione porta il codice di quella condizione e la riga sopra è il motivo che porta, chiave inclusa.

Come risolvere: decidi se la chiave può legittimamente essere assente.

  • Può esserlo. Leggila tramite una funzione che ne verifica prima la presenza: {{ optional .values "replicas" 1 }} restituisce il fallback quando la chiave è assente e il valore, qualunque esso sia, quando è presente; il get di Sprig restituisce una stringa vuota per una chiave assente; hasKey verifica senza leggere. optional è registrato su ogni superficie tranne l’interpolazione dei parametri e i predicati di un parametro o di uno schema, che offrono get e hasKey di Sprig; una coordinata source: registra optional e non Sprig.
  • Non deve esserlo. Forniscila. La chiave che il messaggio nomina è quella che il template ha richiesto, quindi le cause abituali sono una chiave pubblicata sotto un altro nome — una credenziale la cui key non è il nome di variabile che la Recipe legge — una chiave scritta male nel template o nei valori scritti, e una connessione che consegnerebbe la chiave e non è cablata.

A template reads and iterates a path that holds nothing (Un template legge e itera un percorso che non contiene nulla)

Un template stampa un percorso così com’è e itera anche sullo stesso percorso — "user": "{{ .values.user }}" e "users": "{{ range .values.user }}…{{ end }}" in un unico valuesMapping, per esempio — e i dati non contengono nulla lì: la chiave non è impostata, contiene null, oppure è un campo di primo livello che il contesto definisce e per cui non contiene nulla, come .workload su una Recipe che non ne sintetizza alcuno. Il build si arresta prima che il template venga eseguito e nomina il percorso, su ogni superficie che renderizza un valore non impostato come niente: i template di valore che elenca «Missing template key — asymmetric policy (Chiave di template mancante — politica asimmetrica)» più sopra, e l’interpolazione dei parametri in un Aggregate.

Ciascuna lettura presa da sola ha una risposta. Un valore non impostato che viene stampato non produce nulla, e uno su cui si esegue range non itera nulla. Un percorso letto in entrambi i modi non può avere né l’una né l’altra: renderizzarlo come niente farebbe fallire il range su del testo, e lasciarlo non impostato stamperebbe nell’artefatto il testo segnaposto del motore di template <no value> mentre il build riesce. Quindi non viene data nessuna delle due risposte e il build invece si ferma.

Ciò che conta come stampare il percorso è circoscritto, e la linea è tracciata dove il template lo stampa di sicuro:

  • Viene stampato quando un’azione consiste nel percorso e in nient’altro — {{ .values.user }}, {{ $.values.user }}, {{ (.values).user }}, o una variabile legata al percorso, {{ $u }} dopo {{ $u := .values.user }} — in un punto che il template raggiunge ogni volta che viene eseguito.
  • Non viene stampato quando la lettura si trova dentro un corpo if, with o range o un ramo else, perché se quella lettura venga eseguita dipende da una condizione, e la condizione può essere proprio il test che le impedisce di incontrare il nulla — quindi {{ if .values.user }}{{ .values.user }}{{ end }} accanto a un range .values.user viene renderizzato come ha sempre fatto. Né viene stampato quando è il test stesso di una guardia, l’assegnazione di una variabile o un argomento di una funzione — {{ .values.user | quote }}, {{ toYaml .values.user }} — il cui output è la risposta della funzione anziché il segnaposto.

Una stampa dentro un corpo che viene effettivamente eseguito su un percorso che non contiene nulla scrive comunque <no value>, cosa che questo controllo non raggiunge. Una scrittura di un percorso è lo stesso percorso di ogni altra, quindi una stampa in una scrittura e un range in un’altra vengono giudicati insieme, e il messaggio cita la scrittura che il template ha usato per prima. Un percorso che contiene un valore viene stampato e iterato come ha sempre fatto, e un percorso il cui padre non contiene nulla è lasciato all’arresto che lo scendere attraverso il nulla già provoca.

Messaggio emesso, come ultima riga della segnalazione — i frame sopra di esso nominano il nodo e il template, e l’intestazione porta il codice di questa condizione:

template reads a path as a value and iterates it, and the data holds nothing at that path (path <path>). supply a value at the path, guard the printed read with an if or with over the path, or read it one way only (il template legge un percorso come valore e lo itera, e i dati non contengono nulla in quel percorso (con il percorso indicato). fornisci un valore nel percorso, proteggi la lettura stampata con un if o un with sul percorso, oppure leggilo in un solo modo)

Anche l’interpolazione dei parametri in un Aggregate segnala la stessa riga sotto il codice di questa condizione. Una voce provides: segnala un errore di template sotto «A provides: template could not be evaluated (Un template di provides non può essere valutato)», quindi lì l’intestazione porta il codice di quella condizione e la riga sopra è il motivo che porta, percorso incluso.

Come risolvere: decidi quale delle due letture intende il template.

  • Il percorso deve esserci. Forniscilo — nei values: dell’Aggregate, nell’infra: della Release o nel parametro che la Release valorizza — oppure dichiaralo obbligatorio nello schema che lo governa, così che la sua assenza venga segnalata dove viene scritto.
  • Il percorso può essere assente. Proteggi la lettura stampata: {{ with .values.user }}{{ . }}{{ end }} o {{ if .values.user }}{{ .values.user }}{{ end }} non stampa nulla quando non è impostato, e il range accanto continua a iterare come niente.
  • Una sola lettura basta. Leggi il percorso in un solo modo — un range che scrive anche ciò di cui ha bisogno, oppure una stampa tramite una funzione come toYaml o join che risponde da sé per un valore non impostato.

A value template failed while it ran (Un template di valore non è riuscito durante l’esecuzione)

Il template di valore di una Recipe o di una FeatureRecipe — uno dei template che «Missing template key — asymmetric policy (Chiave di template mancante — politica asimmetrica)» più sopra elenca, tra cui un corpo di Workload, un corpo di artifacts: o una voce locals: — è stato analizzato, ha iniziato l’esecuzione e si è fermato prima di produrre il proprio testo. Ciò che lo ha fermato è il motivo proprio del motore di template, che l’arresto riporta sotto di sé: un riferimento che scende attraverso un contenitore che nulla ha fornito, come {{ .values.tls.ca }} dove non è stato scritto alcun tls; un confronto tra valori di due tipi, come {{ if eq .context.instance_id 1 }}, che confronta un testo con un numero e provoca un arresto con cannot compare text with a number; oppure una chiamata al fail di Sprig, che un template di valore può effettuare per rifiutare un input con un messaggio proprio.

Quattro errori su questi template vengono invece segnalati sotto condizioni proprie. Una voce provides: viene segnalata sotto «A provides: template could not be evaluated (Un template di provides non può essere valutato)» più sotto, con questa frase e il motivo del motore all’interno del suo messaggio. Una lettura tramite index di una chiave che la mappa non contiene viene segnalata sotto «A template indexes a map with a key the map does not hold (Un template indicizza una mappa con una chiave che la mappa non contiene)» più sopra. Un template che stampa e itera con range uno stesso percorso che non contiene nulla viene rifiutato prima di essere eseguito, sotto «A template reads and iterates a path that holds nothing (Un template legge e itera un percorso che non contiene nulla)» più sopra. E un template che non supera il parsing si ferma prima di essere eseguito, quindi non rientra in questa condizione.

Messaggio emesso — i frame sopra di esso nominano l’istanza del componente e il template, come recipe "<recipe>" workload template o Recipe "<recipe>" locals["<key>"], e sotto di esso segue la riga propria del motore di template:

a value template failed while it ran (un template di valore non è riuscito durante l’esecuzione)

La riga del motore recita template: <template>:<line>:<column>: executing "<template>" at <<expression>>: <reason> — per una chiamata a fail, error calling fail: <the message the template wrote>. Il build segnala l’arresto sotto un tag CATALOG_ERROR, perché il template è scritto dall’autore della Recipe o della FeatureRecipe. aggrega pull incontra lo stesso errore quando esegue il rendering della Release per scoprire gli input esterni che legge: segnala l’errore, scrive comunque i fissaggi delle dipendenze del lockfile e avverte che i fissaggi degli input esterni potrebbero essere incompleti; il build invece si arresta.

Come risolvere: leggi il motivo del motore alla fine della segnalazione — nomina il template, la riga e la colonna, e l’espressione su cui si è fermato. Per un contenitore che nulla ha fornito, forniscilo, oppure proteggi la lettura in modo che non scenda mai in qualcosa di assente: {{ with .values.tls }}{{ .ca }}{{ end }}, oppure l’helper optional. Per due tipi confrontati, confronta elementi omogenei — un numero con un numero scritto senza virgolette, un testo con un testo scritto tra virgolette — oppure trasforma uno dei due lati in testo con toString. Per una chiamata a fail, il messaggio è dell’autore del template e dice ciò di cui la Recipe ha bisogno: forniscilo, oppure mappa il componente su una Recipe che accetti ciò che hai scritto.

A governance plugin rejected the build (Un plugin di governance ha rifiutato il build)

Un operatore può associare un plugin di governance in un ruolo di verdetto, sul grafo che il compilatore ha costruito o sugli artefatti di cui ha eseguito il rendering. Un plugin del genere legge e restituisce un verdetto. L’host non ha alcun percorso che applicherebbe una modifica proveniente da esso, quindi un ruolo di verdetto può rifiutare un build e non può riscriverlo per renderlo conforme — il rifiuto è tutto ciò che può fare, e cosa cambiare è lasciato a chi lo legge.

Solo un verdetto di arresto ferma il build. I verdetti di avviso e informativi vengono segnalati e il build prosegue. Ogni verdetto di arresto restituito da un plugin viene segnalato, nell’ordine in cui il plugin li ha emessi, così un’unica esecuzione ti informa su tutti.

Il messaggio che un build stampa è quello proprio del plugin, riportato esattamente come è stato restituito e inquadrato solo dal plugin che lo ha restituito — quindi quanto sia specifico, e quanto sia utile per agire, spetta al plugin deciderlo anziché al compilatore. Qualsiasi dettaglio opzionale portato dal verdetto segue tra parentesi quadre, con ogni parte nominata: un codice, un identificatore di regola, una classificazione, un riferimento alla sorgente, una posizione, un suggerimento. La condizione sotto cui viene registrato è policy violation, che è ciò a cui si risolve un codice breve nell’intestazione della diagnostica.

Il rifiuto è attribuito all’associazione di governance anziché a uno dei tuoi documenti, quindi non porta alcuna posizione nel file: non c’è alcuna chiave che lo abbia prodotto, e la risposta è soddisfare la policy oppure riconsiderare l’associazione.

Messaggio emesso:

policy plugin "<plugin>" rejected the build: <the plugin's own message> [code=<code>; rule_id=<rule>; classification=<class>; source_ref=<reference>; location=<where>; suggest=<suggestion>] (il plugin di policy indicato ha rifiutato il build: con il messaggio proprio del plugin e, tra parentesi quadre, il codice, l’identificatore della regola, la classificazione, il riferimento alla sorgente, la posizione e il suggerimento indicati)

La parte tra parentesi quadre è presente solo dove il verdetto portava un dettaglio, e ciascuna parte al suo interno solo dove il plugin l’ha impostata.

Come risolvere: leggi il messaggio del plugin e il suggerimento, dove ne ha fornito uno. Dove il rilievo è corretto, modifica ciò a cui si oppone. Dove la policy non dovrebbe applicarsi a questa Release, si tratta di una questione relativa all’associazione: le associazioni di governance si configurano sotto plugins.governance nella configurazione del workspace, e quale plugin viene eseguito in quale ruolo è una decisione dell’operatore anziché qualcosa che un documento possa sovrascrivere.

A governance attachment’s settings do not match the plugin’s declared schema (Le impostazioni di un’associazione di governance non corrispondono allo schema dichiarato dal plugin)

Un plugin di governance può dichiarare uno schema per le impostazioni che la sua associazione gli passa. Le impostazioni scritte sotto with.settings dell’associazione vengono controllate rispetto a quello schema prima che il plugin venga invocato, così un’associazione configurata male viene segnalata come l’errore di configurazione che è, anziché raggiungere il plugin come input malformato e tornare indietro come qualunque cosa il plugin ne ricavi.

Quest’ordine è lo scopo stesso del controllo. Rende inoltre questa condizione nettamente distinta da un rifiuto: il plugin non è stato eseguito, non è stato raggiunto alcun verdetto e nulla del build è stato giudicato. Un plugin che non dichiara alcuno schema per le impostazioni accetta qualsiasi impostazione, quindi un’associazione con uno di questi plugin non incontra mai questa condizione.

Il controllo copre ogni ruolo di governance. Un’associazione scritta in ir-verdict, render-verdict, label-transform o annotation-transform ha le proprie impostazioni controllate rispetto allo schema prima che il plugin venga invocato — with.settings è la stessa chiave scritta in ogni ruolo, e ogni ruolo la legge prima rispetto allo schema. Un ruolo di trasformazione viene eseguito dove il build lo applica, il che, in un build che esegue prima un pull, avviene durante quel pull, quindi lì il messaggio si apre con il passo che lo ha invocato, come in auto-pull: label-transform:.

Messaggio emesso — il ruolo in cui l’associazione è stata scritta e il plugin che nomina, poi la frase fissa, poi ciò che il controllo dello schema ha trovato:

ir-verdict: plugin "<the attachment's uri>": with.settings does not satisfy the plugin’s declared settings schema: <what the schema check found>: policy attachment settings do not satisfy the plugin’s declared settings schema (ir-verdict: il plugin indicato: with.settings non soddisfa lo schema delle impostazioni dichiarato dal plugin: con l’esito del controllo dello schema indicato: le impostazioni dell’associazione di policy non soddisfano lo schema delle impostazioni dichiarato dal plugin)

La clausola iniziale riporta render-verdict per un’associazione scritta in quel ruolo. Ciò che il controllo dello schema ha trovato è la segnalazione propria del validatore dello schema e occupa più di una riga.

Come risolvere: correggi le impostazioni sotto with.settings di quell’associazione in plugins.governance. Il dettaglio a metà del messaggio nomina la chiave errata e ciò che lo schema si aspettava lì; il riferimento proprio del plugin documenta le impostazioni che dichiara.

A pipeline step failed (Un passo di pipeline non è riuscito)

Una FeatureRecipe può dichiarare una pipeline: una sequenza di passi, ciascuno dei quali invoca un export di plugin sui documenti che il nodo ha emesso, così che una Feature possa dare forma all’output prodotto dalla Recipe propria del componente. Questa è la condizione sotto cui un passo segnala quando non riesce per qualsiasi motivo diverso da una patch che indirizza qualcosa che l’insieme di documenti non contiene, che ha una segnalazione propria più sotto.

Ciò che non è riuscito viene nominato con l’ID del passo e il suo indice, e la clausola che segue dice quale parte ha ceduto: il rendering dell’input with del passo, la chiamata stessa, un output che l’host non ha potuto leggere, un errore restituito dal plugin, una diagnostica con severità di errore emessa dal plugin, una patch rifiutata dal motore di patch, oppure una patch che nomina un ambito che la scansione non ha.

Un passo non riuscito viene annullato per intero. I documenti vengono ripristinati allo stato in cui erano prima dell’esecuzione del passo, e gli output propri del passo vengono scartati con essi, così il when o il with di un passo successivo non può leggere un risultato parziale. Un passo dichiarato optional: true viene allora segnalato come avviso e la scansione prosegue; un passo che non è opzionale ferma il build. Ciò che optional: non tollera è un contratto dichiarato violato — vedi la voce più sotto.

Messaggi emessi:

pipeline step failed: step "<id>" (index <n>) with: <what the render could not do> (passo di pipeline non riuscito: nell’input del passo indicato, con l’indice indicato, il rendering non ha potuto fare quanto indicato) pipeline step failed: step "<id>" (index <n>) invoke: <what the call could not do> (passo di pipeline non riuscito: nell’invocazione del passo indicato, con l’indice indicato, la chiamata non ha potuto fare quanto indicato) pipeline step failed: step "<id>" (index <n>) error diagnostic: <the plugin's message> (passo di pipeline non riuscito: il passo indicato, con l’indice indicato, ha emesso una diagnostica di errore con il messaggio del plugin indicato) pipeline step failed: scope "<scope>" key "<key>": <what the patch engine refused> (passo di pipeline non riuscito: nell’ambito e nella chiave indicati, il motore di patch ha rifiutato quanto indicato) pipeline step failed: unknown patch scope "<scope>" (passo di pipeline non riuscito: ambito di patch sconosciuto, quello indicato)

Come risolvere: leggi l’ID del passo, poi la clausola dopo l’indice — dice quale metà del passo esaminare. Un errore di with è un template nel blocco with: proprio del passo, e spetta a te correggerlo. Una diagnostica di errore è il giudizio del plugin, con parole sue, sul tuo input. Una patch rifiutata e un ambito sconosciuto sono l’output del plugin rispetto a ciò che il nodo ha emesso, e spettano all’autore del plugin. Dove a un passo è davvero consentito non riuscire — un arricchimento opzionale anziché una trasformazione obbligatoria — dichiaralo optional: true, ricordando che questo tollera un errore e non un contratto violato.

A pipeline step’s typed input or output does not satisfy its declared contract (L’input o l’output tipizzato di un passo di pipeline non soddisfa il contratto dichiarato)

Un export di plugin può dichiarare uno schema per l’input che riceve e per gli output che restituisce. Entrambi vengono controllati: il valore with renderizzato prima della chiamata, e gli output restituiti dopo di essa. Una diagnostica la cui severità non è dichiarata dal contratto condiviso viene rifiutata allo stesso modo.

Questo provoca un arresto anche per un passo dichiarato optional: true, e la distinzione è l’intera ragione per cui la condizione è separata da un errore del passo. Opzionale tollera un passo che non è riuscito a fare il proprio lavoro — una chiamata non riuscita, un plugin che ha sollevato un’obiezione. Non tollera un output che l’host non può instradare, né un input che non ha mai avuto la struttura che l’export dichiarava di ricevere: un contratto dichiarato è un impegno, e un build che saltasse silenziosamente un passo il cui contratto è stato violato segnalerebbe un successo per una Feature che non ha fatto nulla.

Messaggi emessi:

pipeline step "<id>" with input does not satisfy the declared input contract: <what the schema check found>: pipeline step typed-I/O contract violation (l’input del passo di pipeline indicato non soddisfa il contratto di input dichiarato: con l’esito del controllo dello schema indicato: violazione del contratto di I/O tipizzato del passo di pipeline) pipeline step "<id>" returned outputs that do not satisfy the declared output contract: <what the schema check found>: pipeline step typed-I/O contract violation (il passo di pipeline indicato ha restituito output che non soddisfano il contratto di output dichiarato: con l’esito del controllo dello schema indicato: violazione del contratto di I/O tipizzato del passo di pipeline)

e, per una severità di diagnostica che il contratto non dichiara, che arriva all’interno del frame dell’errore del passo:

pipeline step failed: step "<id>" (index <n>): <the severity the host could not route>: pipeline step typed-I/O contract violation (passo di pipeline non riuscito: il passo indicato, con l’indice indicato: con la severità che l’host non ha potuto instradare indicata: violazione del contratto di I/O tipizzato del passo di pipeline)

Dove il template with del passo legge un valore dichiarato sensibile, una violazione dell’input non nomina alcun valore. Ciò che il controllo dello schema ha trovato viene sostituito da ciascuna posizione non valida e dalla parola chiave che l’ha rifiutata, chiusi da un avviso che nomina il motivo — at '/origin': pattern (the value is withheld because the template that rendered this input reads a value declared sensitive) — così il campo da correggere viene comunque nominato. Vedi vocabulary/compact-form-authoring.md «Cosa dice un rifiuto su un valore dichiarato».

Come risolvere: per una violazione dell’input, correggi il blocco with: del passo rispetto allo schema dichiarato dal suo export — il dettaglio nomina il campo e ciò che era atteso. Una violazione dell’output e una severità non dichiarata spettano al plugin correggerle; la dichiarazione del passo non è ciò che è sbagliato, quindi contrassegnarlo come opzionale non eliminerà né l’una né l’altra.

A pipeline patch addresses a document the set does not hold, or one with no tree to address (Una patch di pipeline indirizza un documento che l’insieme non contiene, o uno senza un albero da indirizzare)

Un passo di pipeline indirizza un documento tramite un ambito e una chiave, e due forme di indirizzo vengono rifiutate.

L’insieme non lo contiene. Il passo ha applicato una patch a una coppia di ambito e chiave che non è tra i documenti che ha ricevuto. Non verrebbe modificato nulla, quindi, anziché applicare una patch al nulla e segnalare un successo, la scansione si ferma:

pipeline patch targets a document not present in the set: scope "<scope>" key "<key>" (la patch di pipeline punta a un documento non presente nell’insieme: con l’ambito e la chiave indicati)

Non porta alcun albero da indirizzare. Alcune unità non hanno una struttura in cui una patch possa puntare — un corpo binario, testo libero, una regione che il provider non può percorrere in sicurezza. Un’unità del genere viene comunque passata al passo, contrassegnata con il suo media type e i suoi byte, così può essere selezionata ed emessa per intero; ciò che non può subire è una patch, perché non c’è nulla rispetto a cui un percorso possa risolversi. Una patch su un’unità del genere si ferma anziché essere saltata silenziosamente:

pipeline patch targets an opaque (non-structured) unit: scope "<scope>" key "<key>" (la patch di pipeline punta a un’unità opaca, non strutturata: con l’ambito e la chiave indicati)

Ciò che conta come strutturato è la lettura propria che il provider fa dell’unità anziché un test fisso, quindi lo stesso contenuto può essere indirizzabile con un provider e opaco con un altro.

Entrambi sono rifiuti propri della scansione, e un build li segnala sul nodo la cui pipeline ha applicato la patch, quindi il messaggio qui sopra arriva sotto un arresto che nomina quel nodo. Quell’arresto è la forma che ferma il build degli stessi due errori di indirizzamento, documentata sotto «A pipeline step addresses documents the node does not have (Un passo di pipeline indirizza documenti che il nodo non ha)» più sotto — che copre anche il terzo indirizzo con cui un passo può non raggiungere nulla, una richiesta dei documenti di un componente host in un punto in cui non ce n’è alcuno.

Come risolvere: entrambi spettano all’autore del plugin anziché a te. Un passo riceve l’insieme di documenti su cui viene eseguito e può leggere quali chiavi contiene, quindi un obiettivo assente è un passo che indirizza un documento che questo nodo non ha emesso — applica la patch a un documento presente, oppure emetti prima quello che intendevi e applicagli la patch in un passo successivo. Per un’unità opaca, sostituisci la patch con un’emissione dell’intera unità: un corpo opaco viene sostituito anziché modificato.

A patch’s test operation did not match the document (L’operazione di test di una patch non corrispondeva al documento)

Una patch può contenere un’operazione test, che asserisce cosa si trova in un percorso prima che vengano applicate le operazioni successive. Il motore rifiuta l’intera patch quando l’asserzione non è soddisfatta, ed è questo che rende una patch condizionale davvero condizionale anziché ottimistica: un plugin che verifica prima di modificare sta dicendo che non toccherà un documento che non riconosce.

Due forme vengono segnalate sotto questa condizione. Nel percorso non c’è proprio nulla, e il messaggio lo dice. Oppure c’è un valore e non è quello asserito, il che viene segnalato come semplice rifiuto — non viene citato né il valore asserito né quello trovato.

Messaggi emessi:

jsonpatch: test operation failed: no value at path (jsonpatch: operazione di test non riuscita: nessun valore nel percorso) jsonpatch: test operation failed (jsonpatch: operazione di test non riuscita)

Dove la patch era portata dall’output di un passo di pipeline, il rifiuto arriva sotto l’errore di quel passo, nominando il passo. Dove era portata dalla patch di un plugin label-transform, arriva sotto il rifiuto della patch di label.

Come risolvere: l’errore è del plugin anziché dei tuoi documenti. Un test che si aspettava un valore che il documento non ha di solito significa che il plugin viene eseguito su una struttura per cui non è stato scritto — l’output di un altro provider, oppure un documento che un passo precedente della stessa pipeline ha già modificato. Dove spetta a te correggere la patch, allenta il test a ciò che il documento contiene davvero, oppure fai in modo che la condizione when del passo escluda il caso anziché verificarlo all’interno della patch.

A workload: form and the fields beside it do not agree (La forma di un carico di lavoro e i campi accanto a essa non concordano)

Un workload: dichiara una form: — la struttura di ciò che viene eseguito, espressa in termini che ogni destinazione comprende anziché nel vocabolario di una singola destinazione. Alcuni campi hanno senso solo su una forma, e una forma dichiarata senza il campo di cui ha bisogno non ha nulla di coerente da renderizzare. Entrambe le direzioni vengono controllate, prima che qualsiasi destinazione traduca il carico di lavoro, così il disaccordo viene segnalato una sola volta rispetto a ciò che hai scritto anziché una volta per destinazione, con le parole che ciascuna destinazione usa per descriverlo.

Vengono applicati cinque abbinamenti, e ciascuno segnala una propria frase che nomina entrambe le metà e cosa scrivere:

workload declares a persistentTemplate volume but is not form: stateful; declare form: stateful (il carico di lavoro dichiara un volume persistentTemplate ma non è form: stateful; dichiara form: stateful) workload is form: reference but declares no endpoint; set endpoint to the external host or URL the reference points at (il carico di lavoro è form: reference ma non dichiara alcun endpoint; imposta endpoint sull’host esterno o sull’URL a cui punta il riferimento) workload declares an endpoint but is not form: reference; declare form: reference or remove the endpoint (il carico di lavoro dichiara un endpoint ma non è form: reference; dichiara form: reference oppure rimuovi l’endpoint) workload is form: scheduled but declares no schedule; set schedule to a 5-field cron expression or an @-macro (e.g. @daily) (il carico di lavoro è form: scheduled ma non dichiara alcuna pianificazione; imposta schedule su un’espressione cron a 5 campi o su una macro @, ad es. @daily) workload declares a schedule but is not form: scheduled; declare form: scheduled or remove the schedule (il carico di lavoro dichiara una pianificazione ma non è form: scheduled; dichiara form: scheduled oppure rimuovi la pianificazione)

Ciascuna è posizionata sull’istanza del componente il cui carico di lavoro veniva letto, e segnalata come errore di traduzione, perché il disaccordo è tra due campi di un unico blocco scritto dall’autore.

Le condizioni sotto cui sono registrate, che sono ciò in cui si risolvono i loro codici brevi, sono persistentTemplate volume requires form: stateful, form: reference requires an endpoint, endpoint requires form: reference, form: scheduled requires a schedule e schedule requires form: scheduled.

Un abbinamento vale in una sola direzione. Un carico di lavoro form: stateful senza template di claim per replica è normale e non provoca nulla — la regola è che un template di claim ha bisogno dell’identità stabile per replica che solo quella forma fornisce, non che la forma abbia bisogno di un template di claim. Gli altri due abbinamenti valgono in entrambe le direzioni, perché un endpoint e una pianificazione hanno ciascuno esattamente una forma su cui significano qualcosa.

I due abbinamenti di endpoint sono anche nello schema del Workload, quindi un carico di lavoro che viola uno dei due viene rifiutato nella fase dello schema, sotto E0214, prima che si arrivi alla sua frase qui sopra. Un endpoint: su qualsiasi forma diversa da reference — compresa una form: omessa, poiché si legge come stateless — viene rifiutato come

workload validation failed (Workload in Recipe <name>:<version>, at <path>, schema stage): .endpoint: value matches a shape that is not allowed here (validazione del carico di lavoro non riuscita, nel Workload della Recipe e al percorso indicati, fase dello schema: .endpoint: il valore corrisponde a una forma che qui non è consentita)

e form: reference senza endpoint: termina invece con .endpoint: missing required property: endpoint. Il rimedio è quello indicato dalla frase dell’abbinamento.

Come risolvere: ogni frase nomina i due campi e dà entrambe le risposte. Aggiungi il campo di cui la forma ha bisogno, oppure cambia la forma in quella a cui il campo appartiene, oppure rimuovi il campo dove è rimasto dopo una modifica — eliminare un valore schedule: lasciando la chiave è la forma che questo errore assume più spesso.

A workload schedule: is not an expression the check accepts (La pianificazione di un carico di lavoro non è un’espressione che il controllo accetta)

Un carico di lavoro form: scheduled contiene uno schedule: che dice quando viene eseguito, e la struttura del valore viene controllata prima che qualsiasi destinazione lo legga. Sono accettate due scritture: una delle cinque macro @hourly, @daily, @weekly, @monthly e @yearly, oppure un’espressione crontab a cinque campi i cui campi usano solo cifre e i caratteri *, ,, - e /.

Cosa il controllo legge e cosa no. Conta i campi ed esamina i caratteri al loro interno. Non valuta intervalli, aritmetica dei passi né nomi dei giorni della settimana, quindi un’espressione a cinque campi i cui numeri sono fuori intervallo passa qui e spetta alla destinazione rifiutarla. Un’espressione a sei campi con un campo iniziale dei secondi viene rifiutata: cinque campi è ciò che questa superficie accetta, e una destinazione che vuole i secondi li riceve in un altro modo.

Messaggio emesso:

workload schedule is not a valid cron expression; use a 5-field crontab expression (e.g. “0 0 * * *”) or one of @hourly, @daily, @weekly, @monthly, @yearly (la pianificazione del carico di lavoro non è un’espressione cron valida; usa un’espressione crontab a 5 campi, come quella dell’esempio, oppure una tra @hourly, @daily, @weekly, @monthly, @yearly)

La condizione sotto cui è registrato è schedule is not a valid cron expression, che è ciò in cui si risolve il suo codice breve.

Come risolvere: conta prima i campi — una pianificazione con quattro o sei campi è la causa più comune, e uno spazio di troppo dentro un campo lo divide in due. Sostituisci il nome di un giorno o di un mese con il suo numero, e ricorri a una macro dove una di esse dice ciò che intendevi.

A workload suspend: is set on a form other than scheduled (La sospensione di un carico di lavoro è impostata su una forma diversa da quella pianificata)

suspend: true sospende la pianificazione ricorrente di un carico di lavoro form: scheduled: la risorsa pianificata viene renderizzata, e nessuna esecuzione parte dalla sua pianificazione finché non viene ripresa. Nessun’altra forma porta una pianificazione, quindi su qualsiasi altra forma il campo non ha nulla da sospendere, e il build si arresta anziché renderizzare un carico di lavoro che lo scarta silenziosamente. Il controllo viene eseguito insieme agli altri abbinamenti di forma, prima che qualsiasi destinazione traduca il carico di lavoro, e anche qui una form: omessa si legge come stateless.

Messaggio emesso:

workload declares suspend but is not form: scheduled; declare form: scheduled with a schedule or remove suspend (il carico di lavoro dichiara suspend ma non è form: scheduled; dichiara form: scheduled con una pianificazione oppure rimuovi suspend)

È posizionata sull’istanza del componente il cui carico di lavoro veniva letto, e segnalata come errore di traduzione. La condizione sotto cui è registrata è suspend requires form: scheduled, che è ciò in cui si risolve il suo codice breve.

La regola vale in una sola direzione, e solo su true. Un carico di lavoro form: scheduled senza suspend: è normale e viene eseguito secondo la sua pianificazione, e suspend: false, il valore predefinito, non provoca nulla su nessuna forma.

Come risolvere: dove il carico di lavoro doveva essere eseguito solo quando qualcuno lo avvia, rendilo form: scheduled con uno schedule: e mantieni suspend: true; altrimenti mantieni la forma così come è scritta e rimuovi suspend:, che nessun’altra forma legge.

A library $import: is not written in the bare-name form (Un’importazione di libreria non è scritta nella forma a nome nudo)

Tre campi di una Recipe e di una FeatureRecipe possono prendere il proprio corpo da una libreria anziché scriverlo sul posto: una voce artifacts.<name>:, un valuesMapping: e un workload:. Ciascuno scrive $import: con il nome nudo della libreria, poi #, poi il percorso della voce sulla superficie che quel campo legge — rispettivamente #/artifacts/, #/mappings/ e #/workloads/. Un valore che non ha questa forma non nomina nulla che il build possa risolvere, e viene rifiutato quando il campo viene risolto.

I tre campi sono deliberatamente speculari l’uno all’altro, quindi l’errore si legge allo stesso modo su tutti e tre e cambia solo la superficie:

artifacts $import: is not a bare-name artifact-library reference (#/artifacts/): "<the value as written>" (l’importazione di artifacts non è un riferimento a una libreria di artefatti in forma a nome nudo: con il valore indicato, così come è stato scritto) valuesMapping $import: is not a bare-name mapping-library reference (#/mappings/): "<the value as written>" (l’importazione di valuesMapping non è un riferimento a una libreria di mapping in forma a nome nudo: con il valore indicato, così come è stato scritto) workload $import: is not a bare-name workload-library reference (#/workloads/): "<the value as written>" (l’importazione di workload non è un riferimento a una libreria di workload in forma a nome nudo: con il valore indicato, così come è stato scritto)

Una versione scritta con @ viene segnalata con la grafia da usare al suo posto, anziché ricadere in una lamentela per una libreria non trovata, perché è l’errore che questa forma attira più spesso:

artifacts $import: is not a bare-name artifact-library reference (#/artifacts/): version separator is ’:’, not ’@’ — use "<the corrected value>" (l’importazione di artifacts non è un riferimento a una libreria di artefatti in forma a nome nudo: il separatore di versione è ’:’, non ’@’ — usa il valore corretto indicato)

Un’ulteriore forma viene segnalata qui, e non è un errore di scrittura. Il corpo proprio di un file di un bundle di un’ArtifactLibrary non può essere a sua volta un $import: di un altro bundle: uno slot di file non può espandersi in molti file, quindi un’importazione annidata viene rifiutata anziché risolta in qualcosa che l’autore non ha scritto. Componi invece i bundle nel punto in cui vengono consumati.

Una voce artifacts: scritta dalla Recipe propria di un componente viene decisa prima che qualsiasi cosa venga renderizzata, quindi la segnalazione è posizionata sul blocco artifacts: di quella Recipe e nomina il riferimento, il bundle, il file il cui corpo contiene l’importazione annidata, e la voce in cui l’importazione è stata scritta. Ogni file del bundle con quella forma viene segnalato in un unico build; dove ce n’è più di uno, i rilievi sono raggruppati sotto artifacts entries whose library import the compiler cannot resolve:

artifacts $import: is not a bare-name artifact-library reference (#/artifacts/) ("<the value as written>", bundle "<bundle>", bundle file "<filename>", artifacts entry "<key>"). a bundle file body cannot import another bundle — compose the two at the artifacts entry that consumes them (l’importazione di artifacts non è un riferimento a una libreria di artefatti in forma a nome nudo, con il valore così come è stato scritto, il bundle, il file del bundle e la voce di artifacts indicati. Il corpo di un file di bundle non può importare un altro bundle — componi i due nella voce di artifacts che li consuma)

Una voce artifacts: scritta da una FeatureRecipe segnala la stessa condizione quando il bundle viene risolto, nominando il primo file con quella forma:

artifacts $import: is not a bare-name artifact-library reference (#/artifacts/): bundle "<bundle>" file "<filename>" body is a field-root $import: (nested library import inside a bundle file is not supported; compose at the consumption site) (l’importazione di artifacts non è un riferimento a una libreria di artefatti in forma a nome nudo: il corpo del file indicato del bundle indicato è un’importazione alla radice del campo; un’importazione di libreria annidata dentro un file di bundle non è supportata; componi nel punto di consumo)

Un valuesMapping: scritto dalla Recipe propria di un componente viene deciso prima che qualsiasi cosa venga renderizzata, quindi la segnalazione è posizionata sulla chiave valuesMapping: di quella Recipe e riporta la grafia da usare:

valuesMapping $import: is not a bare-name mapping-library reference (#/mappings/) ("<the value as written>"). name the library and the entry either side of the fragment — write #/mappings/ (l’importazione di valuesMapping non è un riferimento a una libreria di mapping in forma a nome nudo, con il valore indicato, così come è stato scritto. Nomina la libreria e la voce ai due lati del frammento — scrivi la forma indicata)

Un valuesMapping: scritto da una FeatureRecipe viene segnalato quando il riferimento viene risolto, nella forma riportata dall’elenco qui sopra.

Un workload: scritto dalla Recipe propria di un componente viene deciso prima che qualsiasi cosa venga renderizzata, quindi la segnalazione è posizionata sulla chiave workload: di quella Recipe e riporta la grafia da usare:

workload $import: is not a bare-name workload-library reference (#/workloads/) ("<the value as written>"). name the library and the entry either side of the fragment — write #/workloads/ (l’importazione di workload non è un riferimento a una libreria di workload in forma a nome nudo, con il valore indicato, così come è stato scritto. Nomina la libreria e la voce ai due lati del frammento — scrivi la forma indicata)

Un workload: scritto da una FeatureRecipe viene segnalato quando il riferimento viene risolto, nella forma riportata dall’elenco qui sopra.

Come risolvere: riscrivi il valore come <Library>#<entry-path>, aggiungendo :<version> dopo il nome della libreria solo dove ti serve un limite minimo sulla versione che può essere selezionata. Verifica che il frammento corrisponda al campo — un percorso di voce #/mappings/… su un workload: nomina una superficie che quel campo non legge, e viene segnalato qui anziché come voce mancante. La stessa forma di identità regola il $ref: di uno schema, i cui rifiuti sono documentati sotto «A $ref: is not written in a form the compiler can resolve (Un riferimento non è scritto in una forma che il compilatore sa risolvere)» più sopra.

A library $import: names a library or an entry the catalog does not hold (Un’importazione di libreria nomina una libreria o una voce che il catalogo non contiene)

Un $import: è scritto correttamente e ciò a cui punta non c’è. Sei condizioni coprono le due metà di un riferimento nei tre tipi di libreria, e quella che ottieni dice quale metà esaminare: la libreria stessa è assente da ciò che il build può vedere, oppure la libreria c’è e non pubblica la voce.

L’insieme rispetto a cui si risolve un riferimento è il catalogo proprio del workspace più le librerie che il lockfile ha fissato e introdotto durante il caricamento del build. Quindi una libreria da cui nulla nella chiusura delle dipendenze della Release dichiara di dipendere non fa parte di quell’insieme, per quanto corretto appaia il riferimento al suo interno.

La libreria non c’è:

artifact-library import references an ArtifactLibrary not present in the catalog: ArtifactLibrary "<library>" (bundle "<entry>") (un’importazione di libreria di artefatti fa riferimento a un’ArtifactLibrary non presente nel catalogo: con l’ArtifactLibrary e il bundle indicati) mapping-library import references a MappingLibrary not present in the catalog: MappingLibrary "<library>" (entry "<entry>") (un’importazione di libreria di mapping fa riferimento a una MappingLibrary non presente nel catalogo: con la MappingLibrary e la voce indicate) workload-library import references a WorkloadLibrary not present in the catalog: WorkloadLibrary "<library>" (entry "<entry>") (un’importazione di libreria di workload fa riferimento a una WorkloadLibrary non presente nel catalogo: con la WorkloadLibrary e la voce indicate)

La voce non c’è:

artifact-library import references a bundle not present in the ArtifactLibrary: bundle "<entry>" in ArtifactLibrary "<library>" (un’importazione di libreria di artefatti fa riferimento a un bundle non presente nell’ArtifactLibrary: con il bundle e l’ArtifactLibrary indicati) mapping-library import references an entry not present in the MappingLibrary: entry "<entry>" in MappingLibrary "<library>" (un’importazione di libreria di mapping fa riferimento a una voce non presente nella MappingLibrary: con la voce e la MappingLibrary indicate) workload-library import references an entry not present in the WorkloadLibrary: entry "<entry>" in WorkloadLibrary "<library>" (un’importazione di libreria di workload fa riferimento a una voce non presente nella WorkloadLibrary: con la voce e la WorkloadLibrary indicate)

Una voce artifacts: scritta dalla Recipe propria di un componente segnala un bundle mancante in una forma propria. Quella voce viene decisa prima che venga eseguito il rendering di qualsiasi cosa, quindi la segnalazione è posizionata sul blocco artifacts: in quella Recipe e nomina la voce in cui è stata scritta l’importazione insieme a entrambe le metà del riferimento:

artifact-library import references a bundle not present in the ArtifactLibrary ("<entry>", ArtifactLibrary "<library>", artifacts entry "<key>") (un’importazione di libreria di artefatti fa riferimento a un bundle non presente nell’ArtifactLibrary: con il bundle, l’ArtifactLibrary e la voce di artifacts indicati)

Un valuesMapping: scritto dalla Recipe propria di un componente segnala una voce mancante in una forma propria, per la stessa ragione: anch’esso viene deciso prima che venga eseguito il rendering di qualsiasi cosa, quindi la segnalazione è posizionata sulla chiave valuesMapping: in quella Recipe e nomina entrambe le metà del riferimento:

mapping-library import references an entry not present in the MappingLibrary ("<entry>", MappingLibrary "<library>") (un’importazione di libreria di mapping fa riferimento a una voce non presente nella MappingLibrary: con la voce e la MappingLibrary indicate)

Un workload: scritto dalla Recipe propria di un componente segnala una voce mancante in una forma propria, per la stessa ragione: anch’esso viene deciso prima che venga eseguito il rendering di qualsiasi cosa, quindi la segnalazione è posizionata sulla chiave workload: in quella Recipe e nomina entrambe le metà del riferimento:

workload-library import references an entry not present in the WorkloadLibrary ("<entry>", WorkloadLibrary "<library>") (un’importazione di libreria di workload fa riferimento a una voce non presente nella WorkloadLibrary: con la voce e la WorkloadLibrary indicate)

Una voce artifacts: scritta da una FeatureRecipe, un valuesMapping: o un workload: scritti da una FeatureRecipe, e ogni riferimento a una libreria che il build non può vedere, vengono segnalati mentre il riferimento viene risolto, nelle forme riportate dai due elenchi qui sopra.

Ciascuna nomina sia la libreria sia la voce, qualunque metà sia fallita, così una sola segnalazione basta a distinguere una libreria mancante da una voce mancante senza aprire nulla.

Come risolvere: per una voce mancante, verifica il nome rispetto a ciò che la libreria pubblica — il nome di una voce è una chiave nella mappa propria di quella libreria, e distingue tra maiuscole e minuscole. Per una libreria mancante, il riferimento di solito è corretto ed è la chiusura a essere incompleta: dichiara la dipendenza da quella libreria in modo che venga caricata, e aggiorna il lockfile in modo che venga fissata. Una libreria raggiungibile in un workspace e non in un altro è lo stesso errore visto dall’altro lato.

A library $import: addresses its library by registry location (Un’importazione di libreria indirizza la sua libreria tramite la posizione nel registry)

Un $import: di libreria nomina la sua libreria per identità, mai tramite il registry su cui si trova a essere pubblicata. Attraverso quale registry si risolve un nome è una questione di configurazione del workspace, e quale versione si usa è la risposta del lockfile, quindi un riferimento che porta con sé un host fissa in un documento di catalogo due cose che spetta al build decidere — e il documento smette allora di funzionare in qualsiasi workspace configurato diversamente.

I casi in cui un riferimento del genere può ancora raggiungere questo arresto sono più ristretti di quanto sembri. I campi $import: propri di una Recipe e di una FeatureRecipe vengono rifiutati prima, dal loro schema, che non ammette alcun prefisso di registry in nessuna delle tre posizioni. Ciò che rimane è il riferimento che nessuno schema descrive: uno letto dal corpo stesso di una voce di libreria, che l’entità che lo consuma non ha scritto e non può vedere finché il corpo non viene risolto.

Messaggio emesso, dalle superfici valuesMapping: e workload:, dove il risolutore riporta solo il valore:

library $import: carries a registry host; reference the library by bare-name identity: "<the value as written>" (l’importazione di libreria contiene un host di registry; fai riferimento alla libreria per identità tramite il nome nudo: con il valore indicato, così come è stato scritto)

Una voce artifacts: non raggiunge questo arresto, e vale la pena conoscerne la ragione se lo stai cercando lì. Il suo riferimento proprio viene rifiutato insieme al resto del documento, come ogni altra posizione; e, a differenza delle altre due superfici, un file di bundle il cui corpo è a sua volta un’importazione viene rifiutato anziché seguito — quindi non esiste alcun corpo da cui potrebbe arrivare un riferimento che porta un host.

Come risolvere: elimina l’host e tutto ciò che precede il nome della libreria, lasciando <Library>#<entry-path>. Dove il valore problematico si trova all’interno di una libreria che consumi anziché in una che pubblichi, la correzione spetta all’autore di quella libreria; finché non arriva, importare una voce diversa o scrivere il corpo sul posto sblocca il build.

Two artifact outputs of one Recipe carry the same filename (Due output di artefatti di una stessa Recipe portano lo stesso nome di file)

Il blocco artifacts: di una Recipe nomina un output per chiave, e un bundle importato in una chiave fornisce i suoi file al di sotto di essa. Due output che arrivassero allo stesso nome di file significherebbero che uno sovrascrive l’altro, quindi il build si arresta anziché scegliere quale sopravvive.

Questa è una protezione residuale, e dirlo fa parte di ciò che è. Un output prende il nome dalla chave sotto cui è stato scritto, le chiavi di una mappa sono uniche all’interno di un documento, e la superficie di scrittura limita una chiave a un singolo nome di file — quindi due voci scritte dall’autore non possono entrare in collisione, e una chiave non può nemmeno comporre il nome annidato prodotto dal bundle di un’altra chiave. Ciò che la protezione copre ancora è il contenuto che ha raggiunto la proiezione senza passare per il rifiuto delle chiavi duplicate proprio di un documento scritto dall’autore: stato assemblato durante l’esecuzione del build anziché letto da un file. Una collisione segnalata qui indica quindi il modo in cui il build è stato assemblato anziché una riga che puoi vedere.

Viene sollevata per Recipe, sugli output propri di quella Recipe, ed è questo che la distingue da due contributori diversi che finiscono su un unico percorso in un assemblaggio — quello è «Two contributors write the same output path (Due contributori scrivono lo stesso percorso di output)» più sopra, con un rimedio diverso.

Messaggio emesso:

artifacts output filename collision: two artifact outputs carry the same filename (Recipe "<recipe>", artifact output "<filename>" emitted more than once) (collisione del nome di file di un output di artifacts: due output di artefatti portano lo stesso nome di file, con la Recipe e l’output di artefatto indicati, emesso più di una volta)

Come risolvere: apri la Recipe nominata dal messaggio e confronta le sue chiavi artifacts: con i file forniti da qualsiasi bundle che importa. Dove le chiavi sono davvero distinte e la collisione persiste, nulla nel documento è in errore e vale la pena di sottoporre la segnalazione a chi mantiene il build.

An ArtifactLibrary bundle file names no file of its own under the key it was imported at (Un file di bundle di un’ArtifactLibrary non nomina alcun file proprio sotto la chiave in cui è stato importato)

Una voce artifacts: che importa un bundle si espande in un output per ciascun file di quel bundle, ognuno annidato sotto la chiave in cui è stata scritta l’importazione. Quindi la chiave nomina una directory e ogni file fornito dal bundle appartiene al di sotto di essa, con un nome proprio. Un nome di file che risale fuori da quella directory, nomina una posizione assoluta o non nomina nulla non vi appartiene, e il build si arresta anziché collocare il file in un punto che la Recipe che lo consuma non ha mai scelto.

Non nominare nulla copre ogni nome che non sia l’unica scrittura di un singolo file al di sotto della chiave. . e ./, e un nome che ricade sulla chiave come x/.., nominano la chiave stessa, quindi il file verrebbe scritto dove deve stare la directory della chiave. Un nome con una / finale o doppia, o con una parte . o .. — x/, a//b, ./a, a/./b, a/../b — è una seconda scrittura di un file che un altro nome può portare: a//b accanto a a/b sono due nomi per un unico file, e uno verrebbe scritto sopra l’altro senza che venga segnalata alcuna collisione. Anche il nome vuoto viene rifiutato.

Ciò che impedisce è una ridisposizione silenziosa anziché una scrittura al di fuori della directory di output. Il punto in cui vengono scritti i file è protetto di nuovo, quindi un nome che risale abbastanza viene comunque rifiutato lì. Il nome che supera quella protezione è quello che risale di esattamente un livello: ricade all’interno della directory di output, in una posizione che nessuno ha scelto. Questo è peggio di una scrittura rifiutata, perché ogni protezione dalle collisioni su questo percorso legge un nome così come è stato composto anziché come si risolve — quindi due file del genere possono risolversi su un unico output senza che nulla segnali una collisione, e quale dei due sopravvive non è deciso da nulla che qualcuno abbia scritto.

Una struttura annidata scritta in modo semplice all’interno della chiave non viene toccata. Un bundle è libero di portare le proprie sottodirectory, come rbac/role.yaml, e annidarle sotto la chiave di consumo è lo scopo stesso della chiave. Un nome che contiene semplicemente dei punti all’interno di una parte, come ..config o role.v1.yaml, è un nome ordinario.

La Recipe che consuma e il bundle pubblicato sono di solito scritti da autori diversi, quindi il messaggio nomina entrambe le metà insieme al rimedio.

Una voce artifacts: scritta dalla Recipe propria di un componente viene decisa prima che venga eseguito il rendering di qualsiasi cosa, quindi la segnalazione è posizionata sul blocco artifacts: in quella Recipe e nomina prima il file, poi la libreria da cui proviene e la voce in cui viene consumato. Ogni file del bundle il cui nome viene rifiutato è segnalato in un unico build; dove ce n’è più di uno, i rilievi sono raggruppati sotto artifacts entries whose library import the compiler cannot resolve:

artifact-library bundle file name does not name a file of its own beneath the artifacts key its output is nested under ("<filename>", ArtifactLibrary "<library>", artifacts entry "<key>"). rename the file inside the ArtifactLibrary bundle to an ordinary file name beneath the artifacts key it is consumed at, such as “config.yaml” or “rbac/role.yaml” — no ”.” or ”..” part, and no leading, trailing or doubled ”/” (il nome di un file nel bundle di una libreria di artefatti non nomina un file proprio al di sotto della chiave di artifacts sotto cui è annidato il suo output, con il file, l’ArtifactLibrary e la voce di artifacts indicati. rinomina il file all’interno del bundle dell’ArtifactLibrary con un nome di file ordinario al di sotto della chiave di artifacts in cui viene consumato, come «config.yaml» o «rbac/role.yaml» — nessuna parte «.» o «..», e nessuna «/» iniziale, finale o doppia)

Una voce artifacts: scritta da una FeatureRecipe segnala la stessa condizione mentre il bundle viene risolto, nominando la ricetta in cui è stata scritta e il primo di questi file:

artifact-library bundle file name does not name a file of its own beneath the artifacts key its output is nested under (Recipe "<recipe>", artifact "<key>", bundle file "<filename>"). rename the file inside the ArtifactLibrary bundle to an ordinary file name beneath the artifacts key it is consumed at, such as “config.yaml” or “rbac/role.yaml” — no ”.” or ”..” part, and no leading, trailing or doubled ”/” (il nome di un file nel bundle di una libreria di artefatti non nomina un file proprio al di sotto della chiave di artifacts sotto cui è annidato il suo output, con la Recipe, l’artefatto e il file del bundle indicati. rinomina il file all’interno del bundle dell’ArtifactLibrary con un nome di file ordinario al di sotto della chiave di artifacts in cui viene consumato, come «config.yaml» o «rbac/role.yaml» — nessuna parte «.» o «..», e nessuna «/» iniziale, finale o doppia)

Come risolvere: rinomina il file all’interno dell’ArtifactLibrary con un nome di file ordinario al di sotto della chiave. Dove la libreria non è tua, importare un bundle diverso o scrivere la voce sul posto sblocca il build mentre la correzione viene fatta a monte. Un file destinato a finire del tutto altrove è una seconda voce artifacts: nella chiave sotto cui appartiene, non un nome che ci arriva risalendo.

An imported artifact no longer matches the digest recorded beside its Recipe (Un artefatto importato non corrisponde più al digest registrato accanto alla sua Recipe)

Una voce artifacts: che importa un file locale ha il proprio contenuto fissato quando la Recipe viene fissata — da aggrega pin, oppure da un pull o da un push a cui è chiesto di eseguire lo stesso passo: il digest dei byte del file viene registrato in entity.lock accanto alla Recipe. Una voce del boundary.artifacts: di una Recipe viene fissata e confrontata allo stesso modo, registrata sotto boundary/<key>, che è il nome che le dà il messaggio. Ogni build rilegge il file, ne ricalcola il digest e rifiuta la discrepanza — così un file modificato dopo essere stato fissato non viene mai renderizzato come se fosse stato verificato. aggrega pull --verify esegue lo stesso confronto e segnala una discrepanza con lo stesso messaggio.

Ciò che viene confrontato è il contenuto della voce, non ciò che il suo rendering ha prodotto. Il corpo di un artefatto è un template, e valutarlo sostituisce valori che differiscono per ogni istanza di componente, quindi un digest sull’output non corrisponderebbe per ogni istanza i cui valori differiscono. Il contenuto registrato è lo stesso testo per ogni istanza che si lega alla Recipe, ed è questo che rende un unico digest registrato la cosa giusta con cui confrontare.

Una Recipe che nessuno ha fissato non ha alcun fissaggio accanto a sé, e un build non la confronta. L’assenza di un fissaggio non è una discrepanza per un build; significa che non c’è nulla da confrontare. Un pull su una Recipe del genere invece si arresta, come descrive 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 fissaggio). Un lockfile scritto prima che il file fosse modificato segnala per primo, perché la riga dell’entità copre anche il file importato, come spiega A local source no longer matches the pins recorded beside its Recipe (Una sorgente locale non corrisponde più ai fissaggi registrati accanto alla sua Recipe), dove la stessa sezione dice quando questo confronto è quello che un build incontra.

Tre superfici portano lo stesso controllo su documenti diversi — la Recipe propria di un componente, una Feature associata a un componente e una Feature associata a un confine — quindi il contenuto della FeatureRecipe viene misurato rispetto al digest registrato accanto alla FeatureRecipe anziché accanto alla Recipe del componente host. Sulle due superfici di associazione il messaggio nomina anche l’associazione, ed è questo che dice quale documento aprire.

Messaggi emessi:

imported artifact content does not match the digest recorded for it in entity.lock ("<artifact>", imported file "<path>", its content digests to "<digest>", the recorded pin is "<digest>"). If the file was changed on purpose, run aggrega pin on the entity that imports it to record its new digest; otherwise restore the file (il contenuto dell’artefatto importato non corrisponde al digest registrato per esso in entity.lock, con l’artefatto, il file importato, il digest del suo contenuto e il fissaggio registrato indicati. Se il file è stato modificato intenzionalmente, esegui aggrega pin sull’entità che lo importa per registrarne il nuovo digest; altrimenti ripristina il file) imported artifact content does not match the digest recorded for it in entity.lock ("<artifact>", imported file "<path>", its content digests to "<digest>", the recorded pin is "<digest>", attachment "<attachment>"). If the file was changed on purpose, run aggrega pin on the entity that imports it to record its new digest; otherwise restore the file (il contenuto dell’artefatto importato non corrisponde al digest registrato per esso in entity.lock, con l’artefatto, il file importato, il digest del suo contenuto, il fissaggio registrato e l’associazione indicati. Se il file è stato modificato intenzionalmente, esegui aggrega pin sull’entità che lo importa per registrarne il nuovo digest; altrimenti ripristina il file)

Come risolvere: due risposte, e quale sia giusta dipende dal fatto che la modifica fosse voluta o no. Se lo era, esegui aggrega pin sulla Recipe in modo che il fissaggio venga ripreso dai byte attuali del file, e fai il commit dell’entity.lock che riscrive. Se non lo era, ripristina il file — il digest registrato è la registrazione dei byte che sono stati fissati, e un build che eseguisse il rendering del file modificato distribuirebbe contenuto che nulla ha verificato.

A local source no longer matches the pins recorded beside its Recipe (Una sorgente locale non corrisponde più ai fissaggi registrati accanto alla sua Recipe)

Una Recipe o una FeatureRecipe il cui source: nomina una directory o un file accanto a essa ha quella sorgente fissata quando l’entità viene fissata — da aggrega pin, oppure da un pull o da un push a cui è chiesto di eseguire lo stesso passo. L’entity.lock accanto all’entità registra un digest per ciascun file che la sorgente fornisce a ciò che una pubblicazione dell’entità porta con sé, indicizzato in base al percorso del file. Una volta che il lock li registra, ogni build confronta la sorgente così com’è con quei fissaggi prima che il provider la legga, e rifiuta una discrepanza — così un chart o un modulo modificato dopo essere stato fissato non viene mai renderizzato come se fosse stato verificato. aggrega pull --verify esegue lo stesso confronto e segnala una discrepanza con lo stesso messaggio. Un build nomina l’istanza di componente di cui stava risolvendo la sorgente e, sotto di essa, il documento della Recipe.

La sorgente viene confrontata come un unico insieme di file. Un file il cui contenuto è cambiato, un file aggiunto alla sorgente e un file rimosso da essa cambiano ciascuno ciò a partire da cui l’entità esegue il rendering, quindi ciascuno viene segnalato, con il digest che il file ha ora e il digest registrato per esso. Un file accanto all’entità che la sorgente non fornisce — una nota o un README vicino alla Recipe — non viene confrontato. Una sorgente scritta come template, come ./charts/{{ .values.flavour }}, fornisce ogni file della directory dell’entità, perché quale directory nomini è deciso da ciascuna Release; per quella forma viene segnalata una modifica a qualsiasi file della directory.

Una Recipe il cui lock non registra alcun fissaggio per la sua sorgente non ha nulla che un build possa confrontare. Un build non la rifiuta; la rifiuta un pull o un push che non esegue il fissaggio, come descrive 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 fissaggio). I fissaggi che un lock registra ancora per una sorgente locale che la Recipe non dichiara più non fissano nulla di ciò che essa legge, quindi non vengono confrontati con nulla. Una Recipe che un pull ha risolto da un registry è coperta invece dal digest che il lockfile registra per ciò che porta con sé la sua pubblicazione.

Un lockfile scritto prima della modifica segnala per primo. Il lockfile registra l’entità in base a ciò che porta con sé, e i file della sorgente ne fanno parte, quindi un build o aggrega pull --verify con un lockfile scritto prima che un file cambiasse si arresta prima che questo confronto venga eseguito, con The lockfile no longer matches what the release resolves to (Il lockfile non corrisponde più a ciò in cui si risolve la Release) che nomina l’entità ed entrambi i digest. Un semplice aggrega pull nomina il file che è cambiato, con 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 fissaggio). Lo stesso vale per un file importato. Dove il lockfile non ha una voce propria dell’entità, è questo confronto che incontrano un build e un pull di verifica: una Recipe o una FeatureRecipe che il Manifest nomina con un riferimento che è anche il nome di un Component o di una Feature che la Release raggiunge viene registrata sotto quel riferimento come Component o Feature, quindi nulla nel lockfile cambia quando cambiano i file della Recipe.

Messaggi emessi:

the files of the entity’s local source do not match the pins recorded for them in entity.lock (file <path> digests to <digest> and its recorded pin is <digest>). If the source was changed on purpose, run aggrega pin on the entity to record its files again; otherwise restore the files (i file della sorgente locale dell’entità non corrispondono ai fissaggi registrati per essi in entity.lock, con il file, il suo digest e il fissaggio registrato indicati. Se la sorgente è stata modificata intenzionalmente, esegui aggrega pin sull’entità per registrarne di nuovo i file; altrimenti ripristina i file) the files of the entity’s local source do not match the pins recorded for them in entity.lock (file <path> digests to <digest> and no pin is recorded for it). If the source was changed on purpose, run aggrega pin on the entity to record its files again; otherwise restore the files (i file della sorgente locale dell’entità non corrispondono ai fissaggi registrati per essi in entity.lock, con il file e il suo digest indicati, per il quale non è registrato alcun fissaggio. Se la sorgente è stata modificata intenzionalmente, esegui aggrega pin sull’entità per registrarne di nuovo i file; altrimenti ripristina i file) the files of the entity’s local source do not match the pins recorded for them in entity.lock (file <path> is no longer in the source and its recorded pin is <digest>). If the source was changed on purpose, run aggrega pin on the entity to record its files again; otherwise restore the files (i file della sorgente locale dell’entità non corrispondono ai fissaggi registrati per essi in entity.lock, con il file indicato, che non fa più parte della sorgente, e il suo fissaggio registrato. Se la sorgente è stata modificata intenzionalmente, esegui aggrega pin sull’entità per registrarne di nuovo i file; altrimenti ripristina i file)

Come risolvere: come per un file importato, due risposte, e quale sia giusta dipende dal fatto che la modifica fosse voluta o no. Se lo era, esegui aggrega pin sulla Recipe in modo che i file della sua sorgente vengano fissati di nuovo, e fai il commit dell’entity.lock che riscrive. Se non lo era, ripristina i file nominati dal messaggio.

Ogni file che una pubblicazione di un’entità porta con sé viene letto dalla directory propria dell’entità, e un collegamento simbolico lì presente viene rifiutato anziché seguito. Seguirlo pubblicherebbe i byte a cui punta sotto il nome del collegamento stesso — da qualunque punto punti, anche fuori dalla directory dell’entità — in un artefatto di cui viene poi calcolato il digest e che, dove si applica la firma, viene firmato. Saltarlo invece pubblicherebbe un artefatto il cui contenuto differisce silenziosamente dalla tua directory. Quindi ogni forma di collegamento viene rifiutata allo stesso modo: un collegamento a un file, un collegamento a una directory, un collegamento che non punta da nessuna parte, un collegamento che punta a se stesso e due collegamenti che puntano l’uno all’altro.

Il rifiuto avviene ovunque vengano letti i file dell’entità: da aggrega pin, da una pubblicazione prima che impacchetti qualsiasi cosa (esecuzione di prova inclusa), da un pull e da un pull di verifica che confrontano l’entity.lock con i file dell’entità, da un build che confronta una sorgente locale con i suoi fissaggi, e da un rendering che legge una directory di sorgente locale prima che qualsiasi parte di essa venga consegnata a un provider. Il messaggio nomina il collegamento tramite il suo percorso accanto al documento dell’entità, e la diagnostica è posizionata sul collegamento stesso.

Un collegamento che le tue regole di esclusione lasciano fuori non è un file che l’entità porta con sé, quindi viene saltato come qualsiasi altro file che quelle regole lasciano fuori, e non viene mai seguito. Quelle regole sono quelle registrate nell’entity.lock quando l’entità è stata fissata, quindi una riga che aggiungi a .aggregaignore ha effetto quando fissi di nuovo l’entità.

Messaggio emesso:

a symbolic link sits among the files an entity carries (<path>). remediation: replace the link with a copy of what it points to, placed inside the entity’s own directory. A link met inside a source directory can instead be left out with a line in the .aggregaignore beside the entity, which takes effect when the entity is pinned again. A link is refused rather than followed because the bytes it points to would travel under the link’s name, from wherever it points (un collegamento simbolico si trova tra i file che un’entità porta con sé, con il percorso indicato. rimedio: sostituisci il collegamento con una copia di ciò a cui punta, collocata all’interno della directory propria dell’entità. Un collegamento incontrato all’interno di una directory di sorgente può invece essere lasciato fuori con una riga nel .aggregaignore accanto all’entità, che ha effetto quando l’entità viene fissata di nuovo. Un collegamento viene rifiutato anziché seguito perché i byte a cui punta viaggerebbero sotto il nome del collegamento, da qualunque punto punti)

Come risolvere: dove l’entità ha bisogno di ciò a cui punta il collegamento, sostituisci il collegamento con una copia della sua destinazione all’interno della directory dell’entità, e fissa di nuovo l’entità. Dove il collegamento è lì per tua comodità e l’entità non lo legge, aggiungi il suo percorso al .aggregaignore accanto al documento dell’entità e fissa di nuovo. Quali file vengono distribuiti con un’entità descrive le regole che decidono che cosa porta con sé un’entità.

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 fissaggio)

Una Recipe o una FeatureRecipe può dipendere da byte esterni al proprio documento: un source: remoto le cui coordinate sono scritte per intero, un file che una voce artifacts importa con $import, e i file di un source: che nomina una directory o un file accanto a essa. Il fissaggio di ciascuno viene registrato nell’entity.lock accanto all’entità, e registrarlo è il passo dell’autore dell’entità, aggrega pin. Quindi un pull non registra quei fissaggi di sua iniziativa: su un’entità in una delle tue directory di catalogo che la Release costruisce, confronta ciò che il passo registrerebbe con ciò che il lock contiene, e si arresta quando al lock manca un fissaggio — o ne contiene uno a cui l’input non corrisponde più — anziché scrivere nella directory dell’autore senza che gli sia stato chiesto. Un build che popola il proprio lockfile è un pull e si arresta allo stesso modo.

Un push si arresta sullo stesso confronto, sull’unica entità che sta per pubblicare. Prima che il bundle venga costruito, e prima che venga contattato qualsiasi registry, confronta ciò che il passo registrerebbe per l’entità con il lock accanto a essa, e rifiuta allo stesso modo — esecuzione di prova inclusa — a meno che al push non sia stato chiesto di eseguire il passo esso stesso. Ciò che il messaggio suggerisce alla fine differisce tra i due, perché ciascun comando ha i propri modi per far registrare i fissaggi; ciò che segnala no.

Una sorgente locale è vincolata ai suoi fissaggi come un unico insieme di file. Dove il lock non ne registra nessuno, ogni file che la sorgente fornisce viene segnalato qui come mancante. Dove li registra, un file aggiunto dopo il fissaggio viene segnalato come mancante e un file modificato o rimosso come un fissaggio a cui l’input non corrisponde più, e un build segnala la stessa modifica come A local source no longer matches the pins recorded beside its Recipe (Una sorgente locale non corrisponde più ai fissaggi registrati accanto alla sua Recipe). I fissaggi che un lock registra ancora per una sorgente locale che la Recipe non dichiara più — il suo source: rimosso, o che ora nomina un artefatto remoto — non fissano nulla di ciò che la Recipe legge, quindi non arrestano né un pull, né un push, né un pull di verifica, né un build; il successivo aggrega pin li elimina.

Il messaggio nomina ogni input che manca, per classe. Ciascuno è un remote source, indicato dal suo url e dalla versione in cui si è risolto, un imported file, indicato dalla chiave artifacts che lo consuma, oppure un local source file, indicato dal suo percorso accanto all’entità — così sai se è una sorgente o un file a richiedere il fissaggio. Ogni entità del genere nella Release viene segnalata in un’unica esecuzione.

Un’entità risolta da un registry non viene mai vincolata a questo da un pull, perché la sua pubblicazione lo è già stata. Si trova nella cache dei contenuti anziché in una directory di cui sei autore, quindi un pull non legge né scrive alcun lock accanto a essa, e le sue sorgenti sono vincolate al lockfile della Release. Un’entità pubblicata con aggrega push è stata rifiutata alla pubblicazione a meno che il suo lock non registrasse ogni fissaggio che il passo avrebbe registrato per essa in quel momento, e quel lock viaggia all’interno del bundle pubblicato.

Messaggi emessi, da un pull e da un push:

an input the entity reads has no pin recorded for it in the entity.lock beside it (Recipe "<name>", remote source <url>@<version>: no pin recorded, imported file <key>: the recorded pin no longer matches it). remediation: run aggrega pin <entity-path> and commit the entity.lock it writes beside the entity; to have every pull in this workspace record the pins itself instead, set pin_sources_at_pull: true in the workspace configuration (un input che l’entità legge non ha alcun fissaggio registrato per esso nell’entity.lock accanto a essa, con la Recipe indicata, una sorgente remota indicata con la sua versione per cui non è registrato alcun fissaggio, e un file importato indicato a cui il fissaggio registrato non corrisponde più. rimedio: esegui aggrega pin sul percorso dell’entità indicato e fai il commit dell’entity.lock che scrive accanto all’entità; per fare invece in modo che ogni pull in questo workspace registri i fissaggi da sé, imposta pin_sources_at_pull: true nella configurazione del workspace) an input the entity reads has no pin recorded for it in the entity.lock beside it (Recipe "<name>", remote source <url>@<version>: no pin recorded). remediation: run aggrega pin <entity-path> and commit the entity.lock it writes beside the entity; to have this publication record the pins itself instead, re-run it with --pin-sources; to have every publication in this workspace record them, set pin_sources_at_push: true in the workspace configuration (un input che l’entità legge non ha alcun fissaggio registrato per esso nell’entity.lock accanto a essa, con la Recipe indicata e una sorgente remota indicata con la sua versione per cui non è registrato alcun fissaggio. rimedio: esegui aggrega pin sul percorso dell’entità indicato e fai il commit dell’entity.lock che scrive accanto all’entità; per fare invece in modo che questa pubblicazione registri i fissaggi da sé, eseguila di nuovo con —pin-sources; per fare in modo che ogni pubblicazione in questo workspace li registri, imposta pin_sources_at_push: true nella configurazione del workspace)

La clausola centrale del messaggio della pubblicazione nomina ciò che accetta la superficie da cui hai pubblicato: --pin-sources in un terminale, il campo pinSources sul daemon e l’argomento pin_sources dello strumento dell’assistente.

Come risolvere: dove l’entità è tua, esegui aggrega pin su di essa e fai il commit dell’entity.lock che scrive, poi esegui di nuovo il pull o il push — oppure esegui il push con --pin-sources, che esegue il passo prima che il bundle venga costruito. Dove è di qualcun altro — un catalogo che consumi da una directory propria — chi la pubblica non l’ha ancora fissata; imposta pin_sources_at_pull: true nella configurazione del tuo workspace in modo che ogni pull registri i fissaggi da sé, oppure passa --pin-sources a un singolo pull. aggrega pin descrive il passo per intero.

A provides: template could not be evaluated (Un template di provides non può essere valutato)

Una voce provides: è un template che produce il valore che un altro componente legge attraverso una connessione di dipendenza. Questa condizione è ciò che segnala una voce che non è stato possibile valutare: un template non analizzabile, una funzione che chiama e che questa superficie non registra, un riferimento che scende attraverso qualcosa che il contesto di rendering non ha fornito, oppure una lettura con index di una chiave che la mappa non contiene.

È distinta dai due rifiuti che vengono eseguiti prima della valutazione sullo stesso blocco — un riferimento a una radice esterna all’insieme autonomo e un riferimento che l’ordine in cui l’autore ha scritto il blocco stesso rifiuta — entrambi documentati più sopra. Quelli nominano l’espressione da cambiare; questa porta con sé ciò che la valutazione stessa ha riportato, ed è per questo che la voce viene nominata accanto.

Messaggio emesso, che nomina l’istanza di componente, la voce all’interno del blocco e ciò che la valutazione ha riportato:

provides template evaluation failed (node "<instance>", provides["<key>"], <what the evaluation reported>) (la valutazione del template di provides non è riuscita, con il nodo, la chiave di provides e ciò che la valutazione ha riportato indicati)

L’intestazione porta il codice di questa condizione, E0056, qualunque cosa abbia riportato la valutazione. Dove la valutazione si è fermata su una propria condizione di arresto — una lettura con index di una chiave che la mappa non contiene è quella abituale — quella condizione viene segnalata sotto questa anziché al suo posto: sotto caused by (2):, la frase di questa condizione viene per prima e la segnalazione propria della valutazione per seconda, frase inclusa. Quindi chi confronta i codici associa ogni voce provides: fallita a E0056, e legge che cosa ha fatto fallire la valutazione dalla condizione sottostante, la cui frase rimanda al proprio codice nella tabella di tutte le condizioni — E0327 per la chiave assente.

Come risolvere: apri il blocco provides: della Recipe alla chiave che il messaggio nomina e leggi il motivo riportato — di solito nomina una posizione di parsing o una funzione. La gestione delle chiavi mancanti su questa superficie rende una chiave finale assente come niente anziché fallire, quindi un errore qui è un difetto strutturale: un template non analizzabile, un riferimento che scende attraverso un contenitore che non è mai stato fornito, oppure una lettura con index di una chiave che la mappa non contiene, che il motivo riportato nomina. Dove il valore è davvero facoltativo, leggilo attraverso l’helper optional anziché scendere in qualcosa che potrebbe non esserci.

A Recipe or FeatureRecipe does not publish a provides key its contract declares (Una Recipe o una FeatureRecipe non pubblica una chiave provides che il suo contratto dichiara)

Un Component e una Feature dichiarano ciascuno, sotto schema.provides, le chiavi che qualunque cosa li leghi pubblicherà — il contratto di output rispetto a cui un consumatore scrive le proprie connessioni. La Recipe legata a un Component e la FeatureRecipe legata a una Feature devono produrre ogni chiave che quel contratto nomina. Una che non lo fa viene rifiutata, perché altrimenti la chiave mancante non consegnerebbe assolutamente nulla: il riferimento del consumatore arriverebbe come una variabile non impostata, un argomento vuoto o un file che non c’è, senza che nulla dica perché.

Il contratto è la presenza delle chiavi, e nient’altro. Ogni chiave dichiarata deve comparire; le chiavi in più sono consentite. I valori stessi non vengono mai ispezionati — sono puntatori opachi trasmessi come stringhe, quindi i tipi che un contratto dichiara restano un’indicazione per il consumatore anziché un controllo che il build esegue.

Ogni mancanza viene segnalata. Una Recipe a cui mancano tre chiavi genera tre rilievi, ciascuno posizionato sulla propria voce nel blocco provides: di quella Recipe, così tutti e tre si correggono da un unico build. Il messaggio nomina la chiave mancante, il tipo il cui contratto la dichiara e l’istanza a cui la Recipe era legata — quest’ultima è ciò che distingue due rilievi quando una Recipe serve più istanze di uno stesso tipo.

Messaggio emesso:

Recipe or FeatureRecipe does not publish a provides key its abstract entity’s schema.provides contract declares ("<key>", declared by component type "<type>", bound to component instance "<instance>") (la Recipe o la FeatureRecipe non pubblica una chiave provides che il contratto schema.provides della sua entità astratta dichiara (con la chiave indicata, dichiarata dal tipo di componente indicato, legata all’istanza di componente indicata))

L’abbinamento tra Feature e FeatureRecipe segnala la stessa condizione attraverso la risoluzione propria dell’associazione, nominando la coppia e la chiave:

Recipe or FeatureRecipe does not publish a provides key its abstract entity’s schema.provides contract declares (<attachment context>, <the FeatureRecipe> does not publish provides key "<key>" declared by <the Feature>’s schema.provides contract) (la Recipe o la FeatureRecipe non pubblica una chiave provides che il contratto schema.provides della sua entità astratta dichiara (con il contesto dell’associazione indicato: la FeatureRecipe indicata non pubblica la chiave provides indicata, dichiarata dal contratto schema.provides della Feature indicata))

Lì segnala la prima chiave mancante in ordine alfabetico e si ferma, così quell’abbinamento nomina una chiave per build mentre l’abbinamento del Component le nomina tutte. In entrambi i casi le chiavi vengono percorse in ordine alfabetico, ed è questo che rende entrambi uguali da un’esecuzione all’altra.

Come risolvere: aggiungi la chiave mancante al blocco provides: della Recipe o della FeatureRecipe, oppure rimuovila dallo schema.provides del Component o della Feature dove nulla dovrebbe pubblicarla. Una chiave il cui template viene renderizzato come niente viene comunque pubblicata, con la stringa vuota come valore, quindi una voce presente e vuota soddisfa il contratto e non viene segnalata qui. Dove un valore vuoto deve fermare il build, rifiutalo in un’asserzione: le asserzioni di una Recipe leggono i suoi valori provides: risolti.

An assertion stopped the build (Un’asserzione ha fermato il build)

Un Component, una Feature, una Recipe o una FeatureRecipe può portare assertions: — template con un nome il cui scopo è rifiutare un input anziché produrre testo. Un’asserzione chiama fail, ed è questa chiamata a fermare il build; l’argomento è il messaggio che il suo autore ha scritto per chiunque la incontri.

Le asserzioni vengono valutate in due momenti, così una regola legge lo stato a cui si riferisce: quelle su un Component o una Feature vengono eseguite una volta risolto il catalogo e prima che qualsiasi cosa venga renderizzata, e quelle su una Recipe o una FeatureRecipe vengono eseguite una volta stabilito il legame e prima che quel legame venga renderizzato.

Anche un riferimento a una chiave che nulla fornisce viene segnalato qui. La superficie valuta con una gestione rigorosa delle chiavi mancanti, proprio perché un predicato il cui riferimento è stato renderizzato come vuoto non possa confrontarsi con il nulla e passare silenziosamente — altrimenti un solo errore di battitura renderebbe inefficace la regola che l’asserzione è stata scritta per far rispettare. Per questo un semplice default non fornisce un fallback su questa superficie: il riferimento nudo ferma la valutazione prima che il fallback possa essere eseguito. Proteggi il riferimento con hasKey, oppure usa l’helper optional; anche leggerlo tramite index provoca un arresto, nominando la chiave, come descrive «A template indexes a map with a key the map does not hold (Un template indicizza una mappa con una chiave che la mappa non contiene)».

Messaggio emesso, che nomina il genere di entità e il tipo, l’istanza e l’asserzione, e poi riporta il messaggio scritto dall’asserzione stessa:

<entity-kind> "<type>" instance "<instance>" assertion "<name>": assertion "<kind>/<type>/<instance>/<name>": template: <kind>/<type>/<instance>/<name>:<line>:<column>: executing "<kind>/<type>/<instance>/<name>" at <fail …>: error calling fail: assertion failed: <the message the assertion wrote> (asserzione indicata dell’istanza indicata, del tipo e del genere di entità indicati: asserzione indicata: template: alla riga e alla colonna indicate: esecuzione dell’asserzione indicata nell’espressione fail indicata: errore nella chiamata di fail: asserzione non riuscita: con il messaggio scritto dall’asserzione)

e, per una chiave che nulla fornisce, la frase del motore di template dopo quella propria della condizione:

<entity-kind> "<type>" instance "<instance>" assertion "<name>": assertion "<kind>/<type>/<instance>/<name>": assertion failed: template: <kind>/<type>/<instance>/<name>:<line>:<column>: executing "<kind>/<type>/<instance>/<name>" at <.reference>: map has no entry for key "<key>" (asserzione indicata dell’istanza indicata, del tipo e del genere di entità indicati: asserzione indicata: asserzione non riuscita: template: alla riga e alla colonna indicate: esecuzione dell’asserzione indicata nel riferimento indicato: la mappa non ha alcuna voce per la chiave indicata)

e dove a non riuscire è stata la valutazione anziché il predicato:

<entity-kind> "<type>" instance "<instance>" assertion "<name>": assertion "<kind>/<type>/<instance>/<name>" parse: <what the parse reported> (asserzione indicata dell’istanza indicata, del tipo e del genere di entità indicati: parsing dell’asserzione indicata: con l’esito del parsing indicato)

Un valore dichiarato sensibile non compare nel messaggio. Dove l’asserzione legge un tale valore e chiama fail con la sua frase scritta per intero come un’unica stringa tra virgolette — fail "…", senza nulla convogliato in essa e senza nulla di composto — il messaggio riporta quella frase così come è scritta, qualunque cosa contenga il valore, perché la frase non cita nulla di ciò che l’asserzione ha letto. Dove il suo messaggio cita il valore, il messaggio riporta <redacted> al posto del valore. Dove il messaggio è composto in qualsiasi altro modo e ciò che l’asserzione ha fatto dipendeva da ciò che il valore contiene, il messaggio dopo l’espressione non riuscita viene sostituito da failure text withheld: this template reads a value declared sensitive, and the failure depends on what that value holds; l’arresto e il suo codice restano invariati. Che cosa conta come dichiarato, e quali rifiuti restano fuori da tutto questo, è descritto in vocabulary/compact-form-authoring.md «Cosa dice un rifiuto su un valore dichiarato».

Controllata da sola, un’entità segnala un’asserzione non riuscita come avviso. aggrega validate a cui viene passato il file di una Recipe, il controllo di quel file da parte dell’editor tramite aggrega serve e lo strumento validate di aggrega mcp a cui viene passata una entity costruiscono la Recipe attorno a segnaposto e valori predefiniti dello schema anziché ai valori che una Release imposta, quindi non possono distinguere un’asserzione che attende una Release da una che è difettosa. Lì, un’asserzione che chiama fail — quella propria della Recipe, o una dichiarata dal Component che la Recipe implementa — viene segnalata come avviso che riporta il messaggio sopra, chiuso dalla frase A Release must satisfy this assertion before a build of it can pass., e il controllo passa. Un riferimento a una chiave che nulla fornisce e un’asserzione che non supera il parsing non sono asserzioni non riuscite: ciascuno è un difetto nel testo stesso dell’asserzione, e quel controllo lo giudica come giudica qualsiasi altro difetto. Un build ha sempre una Release, e si arresta sull’asserzione come descritto qui; vedi un’asserzione non riuscita è un avviso.

Come risolvere: il messaggio dopo gli ultimi due punti è dell’autore dell’asserzione, ed è quello che dice cosa cambiare — un’asserzione è scritta in modo che incontrarla ti dia la risposta. Dove la segnalazione è una chiave mancante anziché la frase dell’autore, il difetto è dell’asserzione stessa: correggi il riferimento, oppure proteggilo come descritto sopra. Dove la regola non dovrebbe applicarsi a questa Release, si tratta di una questione relativa all’entità che porta l’asserzione anziché al tuo file.

A pipeline step addresses documents the node does not have (Un passo di pipeline indirizza documenti che il nodo non ha)

Un passo di pipeline indirizza un documento tramite un ambito e una chiave. Tre condizioni coprono i modi in cui un indirizzo non raggiunge nulla, e ciascuna ferma il build anziché lasciare che un passo segnali un successo su una modifica mai avvenuta.

Il nodo non lo ha emesso. Una patch nomina una coppia di ambito e chiave che non è tra i documenti prodotti da questo nodo:

node "<instance>": pipeline PATCH targets a document the node did not emit (nodo indicato: la PATCH di pipeline punta a un documento che il nodo non ha emesso)

Non c’è alcun host da indirizzare. Un passo ha cercato i documenti di un componente host in un punto in cui non ce n’è alcuno — la pipeline propria di un componente, il cui unico ambito è il suo stesso output, oppure una Feature associata a un confine anziché a un singolo componente. L’ambito host è vuoto ovunque venga eseguita una pipeline del genere, quindi un indirizzo al suo interno si risolve nel nulla:

node "<instance>": pipeline /host operation from a step with no host component (nodo indicato: operazione /host di pipeline da un passo senza componente host)

Il documento non porta alcun albero da indirizzare. Alcune unità non hanno una struttura in cui un percorso possa puntare — un corpo binario, testo libero, una regione che la destinazione non può percorrere in sicurezza. Un’unità del genere viene comunque passata al passo, così può essere selezionata ed emessa per intero; ciò che non può subire è una patch:

node "<instance>": pipeline PATCH target is not parseable structured YAML/JSON (nodo indicato: la destinazione della PATCH di pipeline non è YAML/JSON strutturato analizzabile) pipeline PATCH target is not parseable structured YAML/JSON (node "<instance>", document "<key>") (la destinazione della PATCH di pipeline non è YAML/JSON strutturato analizzabile (con il nodo e il documento indicati))

Ciascuna arriva con il resoconto proprio della scansione sull’indirizzo sotto di sé, e ciascuna è posizionata sull’istanza di componente la cui pipeline lo ha prodotto.

Due delle tre vengono segnalate anche prima di qualsiasi scansione. Se un punto abbia o meno documenti host dipende da dove è stata scritta la pipeline, quindi un passo che dichiara di operare sui documenti host in un punto che non ne ha viene nominato non appena il build sa cosa dichiara ogni plugin, senza attendere che un nodo venga renderizzato — e una Feature associata a un confine viene nominata accanto al passo:

pipeline /host operation from a step with no host component (operazione /host di pipeline da un passo senza componente host) pipeline /host operation from a step with no host component ("<attachment>") (operazione /host di pipeline da un passo senza componente host (con l’associazione indicata))

Le due letture sono una suddivisione di un’unica condizione anziché lo stesso rilievo ripetuto due volte: ciò che una dichiarazione può stabilire viene stabilito dalla dichiarazione, e ciò che solo l’esecuzione può vedere resta all’esecuzione — un passo che dichiara il proprio ambito può comunque restituire un’operazione su un altro.

Queste tre sono la forma che ferma il build dei rifiuti di indirizzamento che la scansione della pipeline stessa segnala, documentati sotto «A pipeline patch addresses a document the set does not hold, or one with no tree to address (Una patch di pipeline indirizza un documento che l’insieme non contiene, o uno senza un albero da indirizzare)» più sopra.

Come risolvere: tutte e tre spettano all’autore del passo anziché a te. Per un obiettivo assente, applica la patch a un documento che il nodo emette davvero, oppure emetti quello che intendevi in un passo precedente e applicagli la patch in uno successivo — un passo può leggere quali chiavi ha ricevuto. Per un host mancante, sposta il passo in un punto in cui c’è un componente host, indirizza invece i documenti propri del punto, oppure eliminalo. Per un’unità senza albero, sostituisci la patch con un’emissione dell’intera unità: un corpo opaco viene sostituito anziché modificato.

A pipeline patch addresses output that has not been assembled yet (Una patch di pipeline indirizza un output che non è ancora stato assemblato)

Alcuni provider uniscono l’output per nodo di un gruppo di inoltro in un unico documento — un file compose unito, un chart ombrello. Finché quell’unione non avviene non ci sono documenti distinti, solo frammenti, quindi una patch che ne indirizza uno non ha nulla in cui puntare. Una pipeline su un componente del genere viene quindi differita per intero e rieseguita una volta che l’unione ha prodotto i documenti, il che è il percorso ordinario e non richiede nulla all’autore.

Questa condizione è ciò che raggiunge il build quando una patch arriva comunque a un frammento. Il caso che nomina è l’output proprio di una Feature associata. Dove il provider del componente unisce il proprio gruppo, l’intera pipeline dell’associazione viene trattenuta finché l’unione non ha prodotto i documenti — e ciò che riceve quella riesecuzione sono soltanto i documenti del componente. Un passo sull’output proprio della Feature viene offerto solo mentre il componente viene renderizzato, cioè prima che sia avvenuta qualsiasi unione, quindi non ha nulla da indirizzare. Questo vale in qualunque modo viaggi l’output proprio della Feature: che entri nell’unione o venga scritto come documenti propri, il suo ambito non è mai l’ambito che la riesecuzione porta.

L’emissione non è mai interessata. Un’emissione aggiunge un documento anziché modificarne uno, e viene eseguita per nodo con ogni provider, quindi ne è del tutto estranea.

La condizione viene segnalata prima di qualsiasi scansione, a partire da ciò che i plugin e i provider dichiarano, e di nuovo come salvaguardia mentre un nodo viene renderizzato. Messaggi emessi:

pipeline PATCH targets an assembler provider’s pre-assembly fragments ("<attachment>") (la PATCH di pipeline punta ai frammenti pre-assemblaggio di un provider assemblatore (con l’associazione indicata)) pipeline PATCH targets an assembler provider’s pre-assembly fragments (node "<instance>", <scope>-scope document "<key>" is rendered by an assembler provider). the post-assembly phase re-runs this PATCH once the documents are discrete (la PATCH di pipeline punta ai frammenti pre-assemblaggio di un provider assemblatore (con il nodo indicato; il documento indicato, nell’ambito indicato, viene renderizzato da un provider assemblatore). la fase post-assemblaggio riesegue questa PATCH una volta che i documenti sono distinti)

Come risolvere: indirizza i documenti del componente anziché quelli propri della Feature, che è la forma rieseguita dopo l’unione; oppure metti il componente su un provider che non unisce il proprio gruppo di inoltro; oppure elimina il passo. Quale dei tre sia giusto dipende da ciò che il passo doveva cambiare, e il messaggio nomina l’ambito indirizzato così puoi capirlo. Cambiare la capability: propria della FeatureRecipe non è tra queste soluzioni: non cambia quale ambito riceve la riesecuzione dopo l’unione, ed è proprio questo l’oggetto di questa condizione.

A pipeline step’s plugin does not claim the provider rendering what it addresses (Il plugin di un passo di pipeline non rivendica il provider che esegue il rendering di ciò che il passo indirizza)

Un plugin usato da un passo di pipeline può dichiarare i provider con cui è stato testato. Quell’elenco è una rivendicazione esplicita anziché un implicito «qualsiasi cosa simile»: eseguire un plugin con un provider che non nomina rischia una patch scritta per un’altra forma di output, quindi il build si ferma anziché tentare.

Il provider con cui viene confrontato un passo è quello che esegue il rendering dei documenti che quel passo indirizza — il provider proprio del componente per un passo sui documenti del componente, e il provider proprio della Feature per un passo su quelli della Feature. Su una Feature associata a un componente si presentano entrambi, e sono due valori diversi provenienti da due documenti diversi.

Un elenco di rivendicazioni vuoto o assente non corrisponde a nulla, quindi ogni passo che usa un plugin del genere viene segnalato qui. Un plugin che il build non ha potuto interrogare è un caso diverso e non viene segnalato qui: un’autodescrizione impossibile da ottenere è l’assenza di una rivendicazione anziché una rivendicazione vuota, e un passo del genere si ferma con l’errore stesso di risoluzione, caricamento o autodescrizione, che è ciò da riparare.

La condizione viene segnalata non appena il build sa cosa ogni plugin dichiara di sé, prima dell’esecuzione che invocherebbe il passo, e una volta per ogni passo scritto anziché una volta per build — così un autore vede ogni passo problematico di una pipeline da un unico build. I nomi dei Provider vengono confrontati in modo esatto.

Messaggi emessi, il primo dalla pipeline propria di un componente e il secondo da quella di una Feature, che nomina anche l’associazione:

pipeline plugin is not compatible with the rendering provider ("<provider>") (il plugin di pipeline non è compatibile con il provider di rendering, quello indicato) pipeline plugin is not compatible with the rendering provider ("<attachment>", "<provider>") (il plugin di pipeline non è compatibile con il provider di rendering (con l’associazione e il provider indicati))

Come risolvere: il rilievo è posizionato sul passo scritto, e il provider che nomina è ciò con cui la dichiarazione deve essere riconciliata. Dove il plugin è tuo, aggiungi il provider alla compatibilità che dichiara, una volta che lo hai testato con esso. Dove non lo è, seleziona una versione del plugin che rivendica il provider, esegui il rendering di quell’ambito tramite un provider che il plugin rivendica, oppure elimina il passo.

A provider refused a node’s input (Un provider ha rifiutato l’input di un nodo)

Un provider può controllare l’input che riceve per un componente prima di eseguirne il rendering, e segnalare ciò che trova. I rilievi con severità di arresto fermano il build; i rilievi con severità di avviso e di informazione vengono mostrati accanto all’output del build e non cambiano nulla dei byte emessi.

Si tratta della lettura che il provider stesso fa del tuo input anziché di quella del compilatore, quindi a cosa obietta e con quanta precisione lo dice spetta al provider deciderlo. Il compilatore nomina il componente e il provider, e riporta i messaggi del provider così come sono stati restituiti; dove un provider ne ha segnalati diversi, arrivano insieme separati da punti e virgola, così un solo build ti informa di tutti.

Lo stesso instradamento viene usato sia che l’input appartenga alla Recipe propria di un componente sia che appartenga a una Feature associata, quindi il controllo di un provider si legge in modo identico in entrambi i casi.

Messaggio emesso:

provider rejected node input: node "<instance>", provider "<provider>": <the provider's messages> (il provider ha rifiutato l’input del nodo: con il nodo, il provider e i messaggi del provider indicati)

Come risolvere: leggi i messaggi del provider — nominano ciò che nell’input risolto non ha potuto accettare. L’input è composto dai valori della Recipe e dalla configurazione propria del componente, quindi la correzione si trova di solito in uno di questi; la pagina di riferimento propria del provider dice cosa richiede. Dove il provider obietta a qualcosa che non puoi cambiare da un documento, è una questione per chi ha scritto la Recipe o il plugin.

A provider rendered the same input twice and produced different output (Un provider ha renderizzato due volte lo stesso input e ha prodotto output diversi)

A parità di input, un build produce output identico — è il contratto rispetto a cui gli strumenti di revisione e gli strumenti di distribuzione leggono il risultato di un build. Una modalità di build facoltativa lo verifica direttamente: ogni componente viene renderizzato due volte a partire dallo stesso input e i byte emessi vengono confrontati. Un provider i cui due rendering non concordano porta uno stato dall’uno all’altro, o comunque non è una funzione del proprio input, e il build si ferma.

Il build ordinario renderizza ogni componente una sola volta, quindi questa condizione si incontra solo nella modalità di verifica. Nulla di un build normale cambia per il fatto che essa sia disponibile.

Ciò che viene confrontato è l’output grezzo emesso dal provider — gli stessi byte da cui vengono ricavati gli artefatti renderizzati — quindi viene intercettata una differenza in qualsiasi punto di ciò che ha prodotto, anziché solo una differenza che sopravvive fino a un file finale.

Messaggio emesso:

rendering node "<instance>": node "<instance>" (provider "<provider>"): two renders of identical input produced different output: provider render is not deterministic (rendering del nodo indicato: nodo indicato, con il provider indicato: due rendering di un input identico hanno prodotto output diversi: il rendering del provider non è deterministico)

Come risolvere: per prima cosa trova ciò che differisce tra due build del componente nominato dal messaggio — eseguine il build due volte e confronta gli output. Dove la differenza è un valore che un chart da cui attingi genera da capo a ogni rendering — una password casuale, una chiave generata, un timestamp in un Secret o in una ConfigMap — l’errore è nell’output di quel chart anziché nel provider, e puoi eliminarlo tu stesso in uno di due modi. Fornisci il valore, tramite qualunque impostazione il chart offra per esso, dal valuesMapping: della Recipe, così che il chart smetta di generarlo. Oppure, dove il documento generato è uno che la Release non deve distribuire — un Secret che l’operatore fornisce separatamente, per esempio — lascialo fuori dal build con una voce omits: sulla Recipe; vedi Recipe → Il campo omits:. Altrimenti l’errore è del provider anziché dei tuoi documenti, e nulla che tu possa scrivere lo elimina. Segnalalo a chi pubblica il plugin che serve quel provider, nominando il componente che il messaggio identifica — le cause abituali sono un timestamp, un valore casuale o un ordinamento che segue l’iterazione di una mappa anziché l’ordine scritto dall’autore. Finché non viene corretto, la modalità di build ordinaria non è interessata, e fissare il plugin a una versione che ha superato la verifica è la risposta pratica.

An omits entry left out nothing the source rendered (Una voce omits non ha lasciato fuori nulla di ciò che la sorgente ha renderizzato)

Ogni voce della lista omits: di una Recipe o di una FeatureRecipe che si applica a un build — con il suo when: assente, vuoto o vero — deve lasciare fuori dall’output almeno una cosa che la sorgente ha renderizzato: un documento che un chart renderizza, un servizio, un volume o una config che un file compose dichiara, oppure una risorsa che un template CloudFormation dichiara. Il provider che esegue il rendering della sorgente confronta ogni voce con ciò che ha renderizzato e riporta quante unità ha lasciato fuori ciascuna; una voce che non ne ha lasciata fuori nessuna ferma il build.

Una voce che non corrisponde a nulla è un’affermazione sulla sorgente che non è più vera. La causa abituale è un aggiornamento della sorgente che ha rinominato o rimosso ciò che la voce nomina — e un documento o un servizio rinominato si trova allora nell’output con il suo nuovo nome, che è esattamente ciò che la voce era stata scritta per tenere fuori — e l’altra è un errore nella voce stessa. Ignorarla distribuirebbe ciò che la voce doveva lasciare fuori, quindi il build si ferma e nomina la voce.

Il messaggio nomina il nodo, il provider, il documento che dichiara la voce e la posizione della voce nella lista omits: di quel documento, contando da 0, e il kind, il nome e il namespace in cui la voce si è risolta, il namespace solo dove la voce ne nomina uno. Per una FeatureRecipe associata a un componente il nodo è quel componente; per una associata a un confine, la riga sopra il messaggio nomina l’associazione e il suo confine. Dove più voci non hanno corrisposto a nulla, viene nominata la prima nell’ordine in cui le hai scritte, così la stessa voce viene nominata a ogni esecuzione. Un campo il cui template ha letto un valore dichiarato sensibile viene mostrato come <redacted> anziché come ciò in cui si è risolto. Una voce scartata dal suo when: non viene mai passata al provider né verificata.

Messaggio emesso. La categoria ti arriva nell’intestazione tra parentesi quadre:

an omits entry left out nothing the source rendered (node "<node-id>", provider "<provider>", "<document>" omits[<position>], kind "<kind>", name "<name>", namespace "<namespace>"). correct the entry so it names something the source renders, or remove it; a source upgrade that renamed or removed it is the usual cause (una voce omits non ha lasciato fuori nulla di ciò che la sorgente ha renderizzato (con il nodo, il provider, la posizione nella lista omits del documento, il kind, il nome e il namespace indicati). correggi la voce in modo che nomini qualcosa che la sorgente renderizza, oppure rimuovila; la causa abituale è un aggiornamento della sorgente che ha rinominato o rimosso ciò che nominava)

L’intestazione porta il codice breve di questa condizione, E0334.

Come risolvere: confronta la voce con ciò che la sorgente renderizza ora — esegui il build con la voce rimossa e leggi ciò che il componente renderizza — poi correggi il kind, il nome o il namespace della voce, oppure rimuovi la voce dove ciò che nominava non c’è più. Per un chart, una voce nomina un documento tramite il kind e il metadata.name propri del documento e, dove la voce nomina un namespace, il namespace in cui si trova il documento; per un file compose, nomina un service, un volume o un config tramite la sua chiave; per un template CloudFormation, nomina una risorsa tramite il suo Type e il suo ID logico, in uno qualsiasi dei template della sorgente. Vedi Recipe → Il campo omits:.

A provider’s omitted counts do not match the omits entries it was handed (I conteggi delle omissioni di un provider non corrispondono alle voci omits che ha ricevuto)

Un provider che dichiara di lasciare fuori unità renderizzate riporta, per ogni voce omits: che ha ricevuto, a quante unità corrispondeva quella voce — un conteggio per voce, nell’ordine in cui le voci gli sono state passate. Un resoconto mancante, che contiene troppo pochi o troppi conteggi, o che contiene un conteggio inferiore a zero non lascia alcun modo di sapere se una voce abbia lasciato fuori qualcosa, quindi il build si ferma. Nulla di ciò che hai scritto lo causa: segnala un provider il cui output restituito non rispetta il contratto che dichiara.

Messaggio emesso. Il messaggio nomina il nodo e il provider, poi quante voci sono state passate e cosa è tornato indietro — o quanti conteggi, oppure il conteggio inferiore a zero e la voce per cui è stato dato:

a provider’s omitted counts do not match the omits entries it was handed (node "<node-id>", provider "<provider>", handed <n> omits entries, returned <m> omitted counts) (i conteggi delle omissioni di un provider non corrispondono alle voci omits che ha ricevuto (con il nodo e il provider indicati, il numero indicato di voci omits ricevute e il numero indicato di conteggi delle omissioni restituiti))

L’intestazione porta il codice breve di questa condizione, E0336.

Come risolvere: segnalalo a chi pubblica il plugin che serve quel provider, nominando il componente che il messaggio identifica. Ciò che un provider è tenuto a fare è descritto nel contratto dei plugin sotto Lasciare fuori le unità renderizzate.

Assembled output still carries a cross-boundary placeholder (L’output assemblato porta ancora un segnaposto tra confini)

Dove una connessione di dipendenza attraversa due output assemblati, il valore che porta non può essere noto mentre viene renderizzato il lato consumatore — viene pubblicato dall’altro lato e risolto una volta che entrambi sono stati assemblati. Quindi il build scrive un segnaposto nell’input del componente consumatore, e il provider lo sostituisce con la propria forma di riferimento incrociato una volta che l’assemblaggio esiste.

Questa condizione è ciò che segnala un segnaposto sopravvissuto a quella sostituzione. Sopravvivere significa che la risoluzione non lo ha mai raggiunto: il valore è finito in un punto che il provider non poteva indirizzare — il più delle volte inserito in una stringa più ampia anziché presente come valore intero — oppure un attraversamento è stato marcato senza nulla dall’altro lato a risolverlo. Un segnaposto non è mai output valido, quindi il build si ferma anziché distribuire un file che ne contiene uno.

Il messaggio nomina il provider che ha scritto il file e il percorso in cui si trova il file: un percorso è unico solo all’interno di un unico assemblaggio, quindi sono i due insieme a identificare un file. Viene segnalato ogni file problematico anziché solo il primo, e ciascuno viene segnalato una sola volta, per quanti confini abbiano alimentato l’assemblaggio in cui si trova. Viene segnalato sul documento della Release nel suo insieme anziché su un confine al suo interno — l’errore sta nel modo in cui un valore ha raggiunto il file anziché in una dichiarazione di confine, quindi nessuna dichiarazione di confine è ciò che va cambiato.

Messaggio emesso:

assembled output retains an unresolved cross-boundary link placeholder ("<provider>", "<output-path>") (l’output assemblato conserva un segnaposto di collegamento tra confini non risolto (con il provider e il percorso di output indicati))

Come risolvere: la causa più comune è un valore che il lato consumatore ha interpolato in una stringa più lunga. Un riferimento incrociato deve costituire l’intero valore come cui viene iniettato, quindi cambia la mappatura della Recipe in modo che lo consegni intero e componi invece attorno a esso nel vocabolario proprio della destinazione. Dove il valore è intero e il segnaposto sopravvive comunque, l’errore sta dal lato del provider nella risoluzione e spetta a chi pubblica quel plugin.

Un template può leggere i valori di un produttore direttamente da una connessione, in .context.uses.<alias>.provides — oppure, in una FeatureRecipe con ambito di confine, dalle connessioni del confine sotto .boundary. Dove la connessione unisce due componenti che eseguono il rendering in output diversi e il provider la collega con un riferimento proprio, ciascuno di quei valori raggiunge il template come un segnaposto che il provider sostituisce una volta assemblati entrambi gli output: con un riferimento tra stack, oppure con il valore stesso. Quindi un template può soltanto copiare un valore del genere — scriverlo intero, all’interno di una stringa più ampia, oppure attraverso una funzione che lo lascia com’è, come quote.

Un confronto, una diramazione, una lunghezza o una funzione che cambia il valore — eq, if, len, upper, trimPrefix — verrebbe decisa rispetto al segnaposto anziché al valore, silenziosamente. Il build lo verifica valutando il template due volte, una volta sui segnaposto e una volta sui valori reali, e si arresta dove i due non concordano una volta che ogni segnaposto è stato riscritto. Si applica a ogni template che legge una connessione del genere: i template propri di una Recipe, l’injectMapping: di una FeatureRecipe associata e i template di una FeatureRecipe con ambito di confine.

Il messaggio nomina il template — il campo e la Recipe a cui appartiene — e, per ogni valore provides da cui dipende la differenza, il componente consumatore, l’alias e il socket della connessione, e il componente produttore. Un valore che il template ha solo copiato non viene nominato.

Messaggio emesso:

a template does more than copy a value it reads off a cross-boundary link (template "<template>", provides key "<key>" that component "<consumer>" reads off its connection "<alias>" on socket "<socket>" to component "<producer>"). Copy the value as it stands, whole or inside a larger string, because the provider writes in its place what the value becomes in the other output, and branch on a value of the component’s own instead (un template fa più che copiare un valore che legge da un collegamento tra confini (con il template indicato e la chiave provides indicata che il componente consumatore indicato legge dalla sua connessione indicata, sul socket indicato, verso il componente produttore indicato). Copia il valore così com’è, intero o all’interno di una stringa più ampia, perché il provider scrive al suo posto ciò che il valore diventa nell’altro output, e basa invece la diramazione su un valore proprio del componente)

Come risolvere: copia il valore che il messaggio nomina anziché verificarlo o trasformarlo, e basa la decisione su un valore che il componente consumatore scrive da sé — una delle sue chiavi values o infra — anziché su ciò che legge la sua connessione. Il provider CloudFormation descrive ciò che un valore copiato diventa nell’altro stack.

A provider named a directory for a contributor that is not one directory (Un provider ha nominato per un contributore una directory che non è una singola directory)

Un provider che colloca ciascun contributore sotto la propria posizione all’interno di un unico output contenitore dichiara la directory sotto cui si trovano quelle posizioni, e il build vi compone l’identità di ciascun componente. Il valore deve nominare esattamente una directory: un valore che contiene un separatore di percorso, o che nomina la directory corrente o quella superiore, collocherebbe i file di un componente in un punto diverso da sotto la sua posizione — o del tutto fuori dall’assemblaggio, o riorganizzati silenziosamente al suo interno.

Il build si ferma anziché comporre un percorso del genere. Il messaggio nomina il provider che ha dichiarato il valore e il valore stesso, così è chiaro quale provider cambiare e cosa ha dichiarato.

Un provider che non dichiara alcuna directory del genere non è interessato. Ciascun contributore si trova allora direttamente nella directory di distribuzione sotto il proprio nome, quindi rinunciare a nominare una directory contenitore è una risposta legittima anziché un’omissione.

Messaggio emesso:

provider named a directory for each contributor’s own sub-directory that is not a single directory name: provider "<provider>" declared nest_segment "<value>"; the value must name one directory, carrying no path separator and naming neither the current nor the parent directory (il provider ha nominato, per la sottodirectory propria di ciascun contributore, una directory che non è un singolo nome di directory: il provider indicato ha dichiarato nest_segment con il valore indicato; il valore deve nominare una sola directory, senza separatori di percorso e senza nominare né la directory corrente né quella superiore)

Come risolvere: nulla in alcun documento di catalogo produce questo valore, quindi non c’è nulla da correggere nei tuoi file — proviene dal plugin che serve il provider. Segnalalo a chi pubblica quel plugin, citando il valore che il messaggio nomina. Dove il plugin è tuo, dichiara un singolo nome di directory, oppure non dichiararne alcuno e lascia che ciascun contributore si trovi nella directory di distribuzione.

A boundary-scope Feature is attached only to a component (Una Feature con ambito di confine è associata solo a un componente)

Una FeatureRecipe può dichiarare di generare una sola volta per un confine anziché una volta per ciascun componente — una risorsa condivisa per tutto ciò che il confine contiene, invece di una per componente. Il confine è quindi il punto in cui un’associazione del genere va scritta: un’associazione con quel nome scritta solo su un componente non nomina alcun ambito per cui la ricetta possa generare, quindi nulla decide su quale confine verrebbe eseguita, quali valori leggerebbe o dove verrebbe scritto il suo output.

Scriverla anche su un componente è normale e non viene segnalato. Un’associazione dichiarata su un confine raggiunge ogni componente che quel confine contiene, compresi quelli negli ambiti annidati al suo interno, quindi portarla è la forma normale. Ciò che viene controllato è se l’ambito proprio del componente, o uno che lo racchiude, dichiara il nome — la ricerca procede verso l’esterno a partire da dove si trova il componente e si ferma al primo ambito che lo dichiara. Un componente che ribadisce su sé stesso un’associazione che il suo ambito circostante dichiara già viene renderizzato esattamente come la forma dichiarata solo sull’ambito, ed è ammesso per lo stesso motivo.

Un componente collocato in nessun ambito non ha nulla da percorrere, quindi un’associazione con ambito di confine su di esso viene segnalata qui — che è la lettura onesta, poiché non esiste alcun ambito per cui una ricetta del genere possa generare.

Messaggio emesso, che nomina l’associazione e l’ambito in cui si trova il componente:

attachment binds a FeatureRecipe with executionScope: boundary and no boundary holding the component declares it ("<attachment>", on a component in boundary "<boundary>") (l’associazione lega una FeatureRecipe con executionScope: boundary e nessun confine che contiene il componente la dichiara (con l’associazione indicata, su un componente nel confine indicato))

e, per un componente in nessun ambito, che non fornisce alcun valore del genere:

attachment binds a FeatureRecipe with executionScope: boundary and no boundary holding the component declares it ("<attachment>") (l’associazione lega una FeatureRecipe con executionScope: boundary e nessun confine che contiene il componente la dichiara (con l’associazione indicata))

Come risolvere: dichiara l’associazione sotto features: sul confine per cui deve generare — l’ambito in cui si trova il componente, o uno che lo racchiude — anziché solo sul componente. Dove intendevi una generazione per componente, associa invece una Feature la cui FeatureRecipe non dichiara l’ambito di confine.

The sandbox refused a plugin (La sandbox ha rifiutato un plugin)

Ogni plugin riporta che cosa è e di che cosa ha bisogno prima che gli sia consentito svolgere qualsiasi lavoro, e la sandbox legge quel resoconto rispetto a ciò che è disposta a concedere. Questa condizione copre l’intera classe di resoconti che la sandbox non accetta, e la frase dice quale parte è stata rifiutata: una versione dell’interfaccia dei plugin che l’host non parla, un tipo di plugin per cui l’host non ha vocabolario, un plugin che chiede accesso alla rete in uscita o accesso al filesystem, un plugin che nomina una chiamata host al di fuori dell’insieme che l’host offre o che importa da un namespace al di fuori dell’insieme che ammette, un export mancante o malformato, un campo che porta un valore al di fuori dell’insieme a cui è limitato, oppure un’autodescrizione del tutto illeggibile.

Il rifiuto avviene prima che il plugin venga eseguito, e un plugin rifiutato viene chiuso prima che l’errore si propaghi, quindi nulla di ciò che ha chiesto viene concesso, nemmeno per un istante.

Parte di ciò che un plugin non può avere non viene controllata qui, perché non viene mai concessa. L’host dà a un guest un orologio congelato, nessun filesystem, nessun ambiente e nessuna destinazione per il proprio output, quindi un guest che tenta di raggiungere uno qualsiasi di essi non riesce nel tentativo anziché essere rifiutato in anticipo. Ciò che questa condizione copre è il resoconto che il plugin fa di sé stesso, controllato prima che si avvii.

Messaggi emessi. La frase della condizione chiude ciascuno di essi, e ciò che la precede nomina il plugin e la parte del suo resoconto che è stata rifiutata. Una versione dell’interfaccia che l’host non parla:

plugin "<plugin>" declares abi_version "<declared>"; host speaks "<supported>": wasm: plugin rejected by the sandbox (il plugin indicato dichiara l’abi_version indicata; l’host parla la versione supportata indicata: wasm: plugin rifiutato dalla sandbox)

un tipo di plugin per cui l’host non ha vocabolario:

plugin "<plugin>" declares unknown plugin_type "<declared>": wasm: plugin rejected by the sandbox (il plugin indicato dichiara un plugin_type sconosciuto, quello indicato: wasm: plugin rifiutato dalla sandbox)

un’autodescrizione che non può essere letta:

wasm: plugin "<plugin>" describe() output is not valid JSON: <what the read reported>: wasm: plugin rejected by the sandbox (wasm: l’output di describe() del plugin indicato non è JSON valido: con l’esito della lettura indicato: wasm: plugin rifiutato dalla sandbox)

un plugin a cui manca l’export richiesto dal suo tipo, nominato a partire dallo stesso registro da cui viene letto il tipo stesso:

<kind> plugin "<plugin>" declares no "<export>" export: wasm: plugin rejected by the sandbox (il plugin indicato, del tipo indicato, non dichiara l’export indicato: wasm: plugin rifiutato dalla sandbox)

un campo limitato a un insieme fisso che porta qualcos’altro — la stessa struttura copre la modalità di assemblaggio e i campi operates e scope di ciascun export:

plugin "<plugin>" export "<export>" declares unknown scope "<declared>" (want "own", "host", or empty): wasm: plugin rejected by the sandbox (l’export indicato del plugin indicato dichiara un ambito sconosciuto, quello indicato (atteso uno dei valori indicati, o vuoto): wasm: plugin rifiutato dalla sandbox)

una capacità abbinata dichiarata senza entrambi i suoi export, o gli export senza la rivendicazione:

plugin "<plugin>" declares the cross-boundary linking capability but does not export both "link_publish" and "link_resolve": wasm: plugin rejected by the sandbox (il plugin indicato dichiara la capacità di collegamento tra confini ma non esporta entrambi gli export indicati: wasm: plugin rifiutato dalla sandbox)

un nome di capacità che una Recipe non potrebbe mai selezionare — un provider che serve un nome contenente i due punti, o un passo di pipeline compatibile con uno di essi — perché il capability: di una Recipe viene letto come il nome fino agli ultimi due punti, seguito da un fissaggio di versione. Il parse:<format> di un parser e l’import:<format> di un importatore non vengono rifiutati: i due punti fanno parte di quei nomi, che vengono cercati per formato anziché tramite una Recipe. Lo stesso rifiuto impedisce che l’entità di un plugin del genere venga generata per la pubblicazione:

plugin "<plugin>" (plugin_type "provider") serves the capability "<name>", which contains a colon; a Recipe’s capability reference is read as the capability up to its last colon and a version pin after it, so no Recipe can name "<name>": report the capability name without a colon: wasm: plugin rejected by the sandbox (il plugin indicato (con il plugin_type indicato) serve la capacità indicata, che contiene i due punti; il riferimento alla capacità di una Recipe viene letto come la capacità fino agli ultimi due punti, seguita da un fissaggio di versione, quindi nessuna Recipe può nominare quella capacità: riporta il nome della capacità senza i due punti: wasm: plugin rifiutato dalla sandbox)

e le chiamate host che un plugin rivendica rispetto a quelle che il suo binario usa davvero, il che viene controllato in entrambe le direzioni, così un plugin non può né annunciare una superficie che non usa né nasconderne una che usa:

plugin "<plugin>" declares host function "<name>" in describe() that its wasm does not import: wasm: plugin rejected by the sandbox (il plugin indicato dichiara in describe() la funzione host indicata, che il suo wasm non importa: wasm: plugin rifiutato dalla sandbox) plugin "<plugin>" imports host function "<name>" that its describe() does not declare: wasm: plugin rejected by the sandbox (il plugin indicato importa la funzione host indicata, che il suo describe() non dichiara: wasm: plugin rifiutato dalla sandbox)

Come risolvere: nulla nei tuoi file di entità lo causa e nessuna modifica di scrittura lo elimina — il resoconto rifiutato è quello proprio del plugin. Dove usi un plugin pubblicato, segnala il messaggio a chi lo pubblica e nel frattempo seleziona una versione che l’host accetta. Dove il plugin è tuo, il messaggio nomina il campo ed entrambi i valori, quindi la correzione è quella che la frase indica: parla la versione dell’interfaccia che parla l’host, dichiara un tipo che conosce, mantieni ogni campo all’interno dell’insieme a cui è limitato, dichiara l’export che il tuo tipo richiede e dichiara esattamente le chiamate host che il tuo binario usa — né di più, né di meno.

A plugin is not the kind of plugin the socket expects (Un plugin non è del tipo di plugin che il socket si aspetta)

Ogni punto di associazione indica a quale tipo di plugin inoltra, e ogni plugin riporta il proprio tipo. Questa condizione è ciò che segnala un disaccordo tra i due: un plugin che serve un provider associato dove è atteso un linter, un parser associato dove è atteso un importatore, un plugin che non è un comando da terminale eseguito come tale. Il controllo avviene mentre il plugin viene caricato, quindi un plugin del tipo sbagliato non raggiunge mai il lavoro che gli sarebbe stato chiesto di svolgere.

Il motivo per cui si ferma anziché tentare comunque è che i tipi non condividono un’interfaccia. Un plugin di un altro tipo verrebbe chiamato tramite export che non ha, e ciò che tornasse indietro verrebbe letto rispetto a una struttura che non ha mai prodotto.

La lettura dell’autodescrizione di un plugin senza affermarne il tipo non è interessata. Una superficie che vuole solo sapere che cosa un plugin dice di sé — elencare ciò che è configurato, generare un’entità per un plugin — non esprime alcuna aspettativa, e lì questo controllo viene saltato.

Messaggio emesso, che nomina il plugin ed entrambi i tipi, con il tipo atteso indicato a parole oltre che con il suo valore dichiarato:

wasm: plugin "<plugin>": expected a <kind in words> plugin (plugin type "<expected>") but its describe() reports plugin type "<reported>": wasm: declared plugin type does not match plugin describe() (wasm: il plugin indicato: era atteso un plugin del tipo indicato a parole (con il tipo di plugin atteso indicato), ma il suo describe() riporta il tipo di plugin indicato: wasm: il tipo di plugin dichiarato non corrisponde al describe() del plugin)

Come risolvere: associa un plugin del tipo che il punto di associazione accetta — il messaggio nomina il tipo atteso. Dove il plugin è quello che intendevi, l’associazione è nel posto sbagliato: spostala sulla superficie a cui appartiene il suo tipo. Dove il plugin lo scrivi tu e dovrebbe essere del tipo atteso, sta riportando su sé stesso il tipo sbagliato, e questa è una correzione nel plugin anziché nella configurazione che lo associa.

A plugin failed while it was running (Un plugin non è riuscito durante l’esecuzione)

Un plugin a cui è stato chiesto di fare qualcosa non è tornato con un risultato. Tre condizioni coprono questo caso, e ciò che le separa è solo il modo in cui l’errore si è propagato — un plugin andato in crash, un plugin che ha fermato la propria esecuzione e un plugin che è arrivato fino in fondo e ha riportato di non poter fare ciò che gli era stato chiesto. Formano deliberatamente un’unica tassonomia, così che un build tratti allo stesso modo ogni modo in cui un plugin può non riuscire.

Un plugin andato in crash. La maggior parte dei guasti all’interno di un plugin — un’istruzione irraggiungibile, una divisione per zero, una lettura al di fuori della sua memoria — viene trasformata in errori ordinari all’uscita e non raggiunge mai questa condizione. Questa condizione è la rete di sicurezza dietro quel percorso, per un crash che gli sfugge.

Un plugin che ha fermato la propria esecuzione. Un plugin che chiede di terminare fa qualcosa di cui il modello dei plugin non ha alcun bisogno: un plugin restituisce il proprio risultato tramite la chiamata con cui è stato invocato, non terminando. La sua esecuzione si ferma; il processo del build non viene toccato.

Un plugin che ha riportato un errore. L’involucro del risultato che un plugin restituisce ha un posto in cui dire che non ha potuto completare, e un messaggio che lo dice viene trasmesso come errore anziché letto come risultato.

Messaggi emessi, ciascuno dei quali nomina il plugin o l’export e porta ciò che l’errore ha fornito. Un crash porta il valore recuperato:

wasm: guest plugin "<plugin>" panicked in <export>: <the recovered value>: wasm: guest plugin panicked during call (wasm: il plugin guest indicato è andato in panic nell’export indicato: con il valore recuperato indicato: wasm: il plugin guest è andato in panic durante la chiamata)

un plugin che si è fermato da sé porta il codice con cui si è fermato:

wasm: plugin "<plugin>" call to <export> invoked proc_exit(<code>): wasm: plugin invoked proc_exit (wasm: la chiamata del plugin indicato all’export indicato ha invocato proc_exit con il codice indicato: wasm: il plugin ha invocato proc_exit)

e un errore riportato porta il messaggio proprio del plugin:

call "<export>": wasm: guest plugin reported an error: <the plugin's message> (chiamata dell’export indicato: wasm: il plugin guest ha riportato un errore: con il messaggio del plugin indicato)

Come risolvere: nulla nei tuoi file di entità causa nessuno dei tre, e nessuna modifica di scrittura li elimina — ciascuno è un guasto all’interno del plugin. Segnala il messaggio a chi lo pubblica, nominando l’export che identifica, e fissa il plugin a una versione che funzionava mentre viene corretto. Dove il plugin è tuo: restituisci un errore sull’involucro del risultato anziché andare in crash o terminare, così il build riceve un messaggio che può mostrare; e dove l’errore riportato è la risposta ponderata del plugin stesso, il suo messaggio è ciò che un lettore vedrà, quindi vale la pena dire che cosa dell’input non ha potuto accettare.

A plugin returned something that is not the shape the socket reads (Un plugin ha restituito qualcosa che non ha la struttura che il socket legge)

Ogni punto di associazione legge il risultato che riceve rispetto alla struttura che si aspetta, e rifiuta qualsiasi altra cosa — un campo che la struttura non dichiara, un campo il cui valore non è del tipo dichiarato per esso, oppure byte che non sono affatto un risultato ben formato.

Rifiuta anziché leggere ciò che può, e il motivo è che leggere ciò che può sarebbe silenzioso. Quale export un’associazione chiama può essere scelto per ciascuna associazione, quindi un’associazione può nominare un export il cui risultato ha una struttura del tutto diversa. Saltare le parti che non corrispondono produce un risultato vuoto — e un risultato vuoto è di per sé una risposta legittima: nessun verdetto restituito, nessun rilievo sollevato. I due sarebbero allora indistinguibili, e un build proseguirebbe esattamente come se il plugin lo avesse approvato.

Messaggio emesso, che nomina l’export da cui è tornato il risultato e porta il motivo per cui la lettura non è riuscita — insieme identificano l’export che l’associazione avrebbe dovuto nominare:

call "<export>": wasm: guest plugin returned an output that is not the shape the socket reads: <what could not be read> (chiamata dell’export indicato: wasm: il plugin guest ha restituito un output che non ha la struttura che il socket legge: con ciò che non è stato possibile leggere indicato)

Come risolvere: controlla la funzione di ingresso che l’associazione nomina rispetto agli export che il plugin dichiara — un’associazione puntata sull’export sbagliato è la causa comune, e il motivo nel messaggio nomina il campo che non vi appartiene. Dove l’export è quello giusto, il plugin sta restituendo una struttura che il punto di associazione non legge, il che è una correzione nel plugin; segnalalo a chi lo pubblica, citando sia l’export sia il motivo.

A plugin returned a diagnostic at a severity that is not declared (Un plugin ha restituito una diagnostica con una severità non dichiarata)

Un plugin può restituire osservazioni insieme al proprio risultato, e ciascuna porta una severità tratta da un insieme chiuso: una che ferma il build e nomina che cosa correggere, una che viene mostrata accanto a un build che si completa comunque, e una che registra l’osservazione e non cambia nulla. Una severità al di fuori di quell’insieme è una per cui l’host non ha alcun instradamento, e il build si ferma.

Rifiuta anziché scegliere un instradamento, ed entrambe le alternative sono peggiori. Ignorare un’osservazione che non può instradare la tratterebbe come qualcosa per cui non c’è nulla da fare — il che, dove il plugin sta decidendo se accettare il build, si legge come approvazione: un’obiezione sollevata dal plugin lascerebbe passare il build senza essere mai mostrata. Trattarla come la severità che ferma il build rifiuterebbe un build sulla base di un valore che nessuno ha scelto. Entrambe sono silenziose, quindi l’host dice che il valore è sbagliato e si corregge invece il plugin.

Il controllo viene eseguito una sola volta, dove il risultato viene letto, anziché in ogni punto in cui un’osservazione viene mostrata in seguito — che è anche l’unico punto in cui l’identità del plugin è ancora a portata di mano, poiché un’osservazione confluita in una segnalazione non sa più quale plugin l’ha sollevata.

Messaggio emesso, che nomina il plugin, l’export, quale osservazione era in errore, il suo valore e i valori dichiarati:

plugin "<plugin>" call "<export>": wasm: guest plugin returned a diagnostic whose severity the contract does not declare: diagnostic <index> has severity "<value>"; the declared severities are "halt", "warn" and "info" (chiamata dell’export indicato del plugin indicato: wasm: il plugin guest ha restituito una diagnostica la cui severità il contratto non dichiara: la diagnostica con l’indice indicato ha la severità indicata; le severità dichiarate sono le tre indicate)

Come risolvere: nulla nei tuoi file di entità lo causa — il valore proviene dal plugin. Segnalalo a chi pubblica il plugin, citando il valore che il messaggio nomina. Dove il plugin è tuo, emetti una delle tre severità dichiarate; il messaggio le nomina, e l’indice ti dice quale osservazione esaminare.

A provider returned two output files under one path (Un provider ha restituito due file di output sotto un unico percorso)

Un provider restituisce il proprio output come lista di file, ciascuno dei quali nomina il percorso in cui viene scritto. L’host li raccoglie indicizzandoli per percorso e scrive i byte di ciascun file così come sono, senza eseguire alcun serializzatore proprio. Due file che nominano lo stesso percorso lasciano quella raccolta con due valori per una sola chiave.

Rifiuta anziché sceglierne uno, perché nessuna delle due scelte può essere distinta dall’altra a posteriori. Tenere l’ultimo scarta un file che il provider ha detto di scrivere; tenere il primo ne scarta uno successivo. In entrambi i casi l’output su disco è ben formato e ha un file in meno, senza che nulla registri che un file è stato scartato — e il percorso sopravvissuto è il percorso che sarebbe sopravvissuto comunque, quindi nulla nel risultato dice che si è verificata una collisione. Quale dei due fosse inteso è una domanda a cui solo il provider può rispondere.

Viene segnalato ovunque un provider restituisca file: nel rendering di un singolo nodo e nell’assemblaggio dell’output di un gruppo di inoltro in un unico artefatto. La condizione e la correzione sono le stesse in entrambi i casi, quindi entrambi la segnalano.

Messaggio emesso, che nomina il percorso restituito due volte e il nodo o il percorso di inoltro per cui è stato restituito:

provider guest returned two output files under one path; a conforming guest returns each output path at most once (path "<path>", node "<node>") (il guest provider ha restituito due file di output sotto un unico percorso; un guest conforme restituisce ciascun percorso di output al massimo una volta (con il percorso e il nodo indicati))

Come risolvere: nulla nei tuoi file di entità lo causa — i percorsi provengono dal provider. Segnalalo a chi lo pubblica, citando il percorso che il messaggio nomina. Dove il provider è tuo, restituisci ciascun percorso di output al massimo una volta: costruisci la lista dei percorsi rispetto a un insieme, così che un secondo file su un unico percorso venga intercettato dove viene prodotto, e dai al secondo file un percorso distinto se servono entrambi.

A provider reported a render fact whose value is not a list (Un provider ha riportato un fatto di rendering il cui valore non è una lista)

Un provider può riportare, accanto ai propri file, fatti sull’output di cui ha eseguito il rendering — ciascuno con un nome e un valore, nel vocabolario documentato proprio di quel provider — e le Features associate a un componente li leggono dai propri template. Il valore di ogni fatto è una lista, anche quando contiene una sola voce: un unico nome può essere riportato da più di un rendering di un componente, le chiamate al suo provider e i rendering delle Features associate a esso, e le liste vengono unite in una sola sotto quel nome per i template che lo leggono. Un provider non può sapere, al momento del rendering, se il suo resoconto sarà l’unico sotto un nome, quindi un valore che è un oggetto, una stringa, un numero, un booleano o null viene rifiutato nel punto in cui il provider lo consegna, per ogni rendering, che un template legga o meno il fatto.

Messaggio emesso, che nomina il fatto, il nodo per cui è stato riportato, il provider che lo ha riportato e che cosa era il valore:

provider guest reported a render fact whose value is not a list; a conforming guest reports every render fact’s value as a JSON array, even with one entry (fact "<fact>", node "<node>", provider "<provider>", its value is <kind>) (il guest provider ha riportato un fatto di rendering il cui valore non è una lista; un guest conforme riporta il valore di ogni fatto di rendering come array JSON, anche con una sola voce (con il fatto, il nodo e il provider indicati; il suo valore è del tipo indicato))

Come risolvere: nulla nei tuoi file di entità lo causa — il valore proviene dal provider. Segnalalo a chi lo pubblica, citando il fatto che il messaggio nomina. Dove il provider è tuo, riporta il valore di quel fatto come array JSON — un singolo oggetto diventa una lista che contiene quell’oggetto — e documentalo come lista tra i fatti che il tuo provider riporta; vedi Riportare fatti su ciò che un guest ha emesso.

Quando una connessione attraversa due gruppi di inoltro, al provider di ciascun lato viene chiesto di cablarla: l’estremità consumata pubblica un’identità, l’estremità consumatrice si risolve rispetto a essa, e ciascuna può restituire un cablaggio strutturale da applicare all’output del proprio gruppo. Ogni elemento di cablaggio nomina il file di output a cui si applica. Un passaggio successivo suddivide quel file, applica le operazioni e lo riassembla fedelmente byte per byte.

Un nome che non corrisponde ad alcun file emesso non lascia a quel passaggio nulla da suddividere, e il passaggio rifiuta anziché ignorare il cablaggio. Le operazioni che porta sono ciò che risolve la connessione, quindi scartarle lascia un output assemblato che fa riferimento a un’estremità che nulla ha cablato — il che fallisce al momento della distribuzione, lontano dal provider che lo ha causato, e sembra un errore nella connessione anziché nel cablaggio.

I file che un elemento di cablaggio può nominare sono i file restituiti dal rendering proprio di quel gruppo. Vengono passati al provider nella stessa chiamata, quindi il provider non deve mai indovinare un nome: ne seleziona uno dall’insieme che ha ricevuto.

Messaggio emesso, che nomina il file richiesto dal cablaggio e l’estremità per cui è stato restituito:

link patch names an output file the dispatch group did not emit; a conforming link patch names a file the group’s own render returned (file "<file>", node "<node>") (la patch di collegamento nomina un file di output che il gruppo di inoltro non ha emesso; una patch di collegamento conforme nomina un file restituito dal rendering proprio del gruppo (con il file e il nodo indicati))

Come risolvere: nulla nei tuoi file di entità lo causa — il nome proviene dal provider. Segnalalo a chi lo pubblica, citando il file che il messaggio nomina. Dove il provider è tuo, prendi il nome del file dai file assemblati che la chiamata ti passa anziché da un nome costruito in modo indipendente — un percorso composto a mano diventa obsoleto nel momento in cui cambia il rendering che lo produce, ed è questo l’aspetto che assume.

A pipeline step’s file emission carries no file (L’emissione di file di un passo di pipeline non porta alcun file)

Un passo di pipeline può emettere un nuovo documento accanto a quelli a cui applica una patch. Ogni emissione dichiara il proprio tipo, e un’emissione di tipo file porta il file che scrive: il percorso e il contenuto.

Qui il tipo è corretto e il file è assente, quindi il passo ha dichiarato un’intenzione che la sua risposta non attua. È questa la differenza tra questo arresto e quello per un tipo non definito qui sotto: l’host sa esattamente cosa fare con un’emissione emit_file e non ha nulla su cui farlo.

Rifiuta anziché non emettere nulla, perché un’emissione che silenziosamente non contribuisse alcun file sarebbe invisibile. Un passo che emette un documento è spesso l’intera ragione per cui si trova nella pipeline, e il suo output è un file che prima non c’era — quindi un build che lo saltasse produrrebbe un output a cui manca un documento, mentre il passo segnala di essere stato eseguito.

Messaggio emesso, che nomina il nodo e quale delle emissioni del passo era in errore:

emit_file side effect carries no file; a conforming emit_file side effect carries a file with its path and content (node "<node>", side effect <index>) (l’effetto collaterale emit_file non porta alcun file; un effetto collaterale emit_file conforme porta un file con il suo percorso e il suo contenuto (con il nodo e l’indice dell’effetto collaterale indicati))

Come risolvere: nulla nei tuoi file di entità lo causa — la risposta proviene dal plugin. Segnalalo a chi lo pubblica, citando l’indice che il messaggio nomina. Dove il plugin è tuo, compila il membro file in ogni emissione emit_file, con sia il percorso sia il contenuto; l’indice dice quale emissione della risposta di quel passo esaminare.

A pipeline step declares an emission kind the contract does not define (Un passo di pipeline dichiara un tipo di emissione che il contratto non definisce)

Ogni emissione restituita da un passo di pipeline dichiara il proprio tipo, e il contratto ne definisce due: uno scrive un file, l’altro contribuisce un documento di risorsa personalizzata. Il tipo è una stringa aperta nel formato di trasmissione, ed è ciò che permette di aggiungere un tipo successivo senza rompere i plugin esistenti.

Quell’apertura è esattamente il motivo per cui un tipo non definito viene rifiutato anziché ignorato. Un valore che l’host non definisce non può essere distinto, dalla sola struttura, da uno che una versione successiva definirà — quindi un host che lo saltasse scarterebbe silenziosamente ciò che il passo intendeva con esso, a ogni build, mentre il passo segnala un successo. Rifiutare mantiene aperto il punto di estensione senza farne una falla: un tipo che questo build non definisce viene segnalato come non definito, citando il valore inviato dal passo, anziché essere accettato e ignorato.

Messaggio emesso, che nomina il nodo, quale emissione era in errore e il tipo che ha dichiarato:

side effect declares a kind the plugin contract does not define; a conforming side effect declares emit_file or emit_crd (node "<node>", side effect <index>, kind "<value>") (l’effetto collaterale dichiara un tipo che il contratto dei plugin non definisce; un effetto collaterale conforme dichiara emit_file o emit_crd (con il nodo, l’indice dell’effetto collaterale e il tipo indicati))

Come risolvere: nulla nei tuoi file di entità lo causa — il valore proviene dal plugin. Segnalalo a chi lo pubblica, citando il tipo che il messaggio nomina. Dove il plugin è tuo, dichiara uno dei tipi che il messaggio elenca; un errore di battitura in un tipo definito è la causa comune, e il valore citato nel messaggio è ciò che hai inviato.

A provider’s reassembly is handed a unit its own carve never produced (Al riassemblaggio di un provider viene passata un’unità che la sua stessa suddivisione non ha mai prodotto)

Un provider la cui struttura di output non può essere indirizzata direttamente può suddividerla da sé: divide un file di output in unità indirizzabili, ciascuna sotto un token, e le restituisce. Un passo di pipeline indirizza quindi un’unità tramite quel token, e il riassemblaggio reinserisce le unità modificate nel file fedelmente byte per byte. Le due metà sono un unico contratto — i token sotto cui un file viene suddiviso sono i token che il suo riassemblaggio risolve.

Quando al riassemblaggio viene passato un token che la suddivisione di quello stesso file non ha prodotto, non esiste alcun intervallo di byte in cui il contenuto modificato possa tornare. Rifiuta anziché scartare l’unità, perché un’unità scartata produce un file ben formato a cui manca una modifica che un passo doveva apportare: nulla è fallito, nulla è malformato, e la modifica è semplicemente assente.

Le due metà possono essere in disaccordo solo dove sono separate — un codec che suddivide da sé e prende in prestito il riassemblaggio strutturale standard per il resto. Suddividere sotto un insieme di token e riassemblare rispetto a un altro produce allora esattamente questo. Un codec che possiede entrambe le metà non può arrivarci: il suo riassemblaggio risponde dei propri token.

Messaggio emesso, che nomina il token che non si è risolto in nulla e il file rispetto a cui è stato nominato:

reassemble names a patched unit token the carve did not produce; a conforming codec carves and reassembles a file under the same tokens (token "<token>", file "<file>") (il riassemblaggio nomina un token di unità modificata che la suddivisione non ha prodotto; un codec conforme suddivide e riassembla un file sotto gli stessi token (con il token e il file indicati))

Come risolvere: nulla nei tuoi file di entità lo causa. Dove il provider è tuo, fai in modo che i token prodotti da una metà siano i token che l’altra risolve: derivali una sola volta e trasportali, anziché derivarli in modo indipendente su ciascun lato, e dove la suddivisione riscrive un file prima di dividerlo, riassembla rispetto alla stessa forma riscritta. Dove il provider non è tuo, segnalalo a chi lo pubblica, citando il token che il messaggio nomina.

A workload declares a form compose cannot express (Un carico di lavoro dichiara una forma che compose non può esprimere)

Il provider compose esegue il rendering di servizi a lunga esecuzione. Un carico di lavoro che dichiara di eseguire una copia per macchina, di essere eseguito secondo una pianificazione o di essere eseguito una volta e terminare non ha un equivalente pulito su una singola macchina, quindi il rendering si ferma anziché emettere un semplice servizio — che lo avvierebbe, lo manterrebbe in esecuzione e travisarebbe ciò che è stato chiesto.

Messaggio emesso. La condizione nomina il tipo di errore — un provider senza alcuna espressione per qualcosa che il build dichiara — e la frase propria del provider nomina la forma che ha ricevuto:

a plugin has no expression for a construct this build declares (un plugin non ha alcuna espressione per un costrutto che questo build dichiara) compose: workload form "<form>" has no compose mapping; compose supports stateless and stateful only: compose cannot express this workload form (compose: la forma di carico di lavoro indicata non ha alcuna mappatura compose; compose supporta solo stateless e stateful: compose non può esprimere questa forma di carico di lavoro)

Come risolvere: dove la destinazione è davvero un ambiente compose su una singola macchina, esprimi il lavoro come servizio a lunga esecuzione — le forme stateless e stateful sono le due di cui esegue il rendering. Dove la forma è ciò che intendevi, esegui il rendering di quel confine tramite un provider la cui destinazione ha un equivalente: una copia per macchina, un’esecuzione pianificata e un job eseguito fino al completamento hanno tutti espressioni dirette altrove, e la scelta del provider spetta al confine anziché al carico di lavoro.

A container declares a field compose has no primitive for (Un container dichiara un campo per cui compose non ha una primitiva)

Due campi dei container non hanno un equivalente compose, ed entrambi fermano il rendering anziché essere scartati.

Hook eseguiti quando un container si avvia o sta per fermarsi. compose non ha nulla che li esegua, e un hook che silenziosamente non viene eseguito è una sorpresa di correttezza che emerge in fase di esecuzione anziché in fase di build.

Ambiente in blocco tratto da un oggetto con nome. compose può leggere variabili da un file, ma un riferimento a un oggetto non è un file — reinterpretare l’uno come l’altro cambierebbe ciò che il container riceve senza dirlo.

Entrambi vengono controllati per i container ordinari e per i container eseguiti prima di quello principale, quindi lo stesso campo provoca un arresto ovunque sia dichiarato e il messaggio nomina il container da cui proviene.

Messaggi emessi. Entrambi segnalano la stessa condizione — un provider senza alcuna espressione per qualcosa che il build dichiara — e la frase propria del provider è ciò che dice quale campo:

a plugin has no expression for a construct this build declares (un plugin non ha alcuna espressione per un costrutto che questo build dichiara) compose: node "<node>" container "<container>": compose: node "<node>" declares container lifecycle hooks; compose has no lifecycle-hook primitive: compose has no lifecycle-hook primitive; container declares lifecycle hooks (compose: nel nodo e nel container indicati: compose: il nodo indicato dichiara hook del ciclo di vita del container; compose non ha alcuna primitiva per gli hook del ciclo di vita: compose non ha alcuna primitiva per gli hook del ciclo di vita; il container dichiara hook del ciclo di vita)

a plugin has no expression for a construct this build declares (un plugin non ha alcuna espressione per un costrutto che questo build dichiara) compose: node "<node>" container "<container>": compose: node "<node>" declares container envFrom; compose has no env-from-object primitive: compose has no env-from-object primitive; container declares envFrom (compose: nel nodo e nel container indicati: compose: il nodo indicato dichiara envFrom per il container; compose non ha alcuna primitiva per l’ambiente da un oggetto: compose non ha alcuna primitiva per l’ambiente da un oggetto; il container dichiara envFrom)

Come risolvere: per una destinazione compose, rimuovi il campo e svolgi il suo lavoro in un altro modo — il lavoro di avvio appartiene a un container eseguito prima di quello principale, e il lavoro di arresto alla gestione dei segnali propria del container; l’ambiente in blocco può essere scritto come variabili esplicite, oppure fornito da un file che la destinazione compose può leggere. Dove il campo è ciò che intendevi, esegui il rendering di quel confine tramite un provider la cui destinazione ha la primitiva.

An omits entry names a kind or a namespace a compose file does not have (Una voce omits nomina un kind o un namespace che un file compose non ha)

Una voce omits: su una Recipe o su una FeatureRecipe che attinge da un file compose lascia fuori un’unità di primo livello di quel file, e un file compose ha esattamente tre kind che una voce può nominare — un service, un volume e un config, ciascuno indicato dalla propria chiave sotto services:, volumes: o configs: — e nessun namespace. Una voce che nomina qualsiasi altro kind, tra cui il Secret di un documento di chart o un network di compose, o che porta un namespace, non nomina nulla che il file possa lasciare fuori, quindi il rendering si ferma anziché trattare la voce come una che non ha corrisposto a nulla. I kind vengono confrontati esattamente, quindi Service viene rifiutato dove si intende service. Ogni voce viene controllata prima che venga lasciato fuori qualsiasi cosa, e viene nominata la prima in errore, nell’ordine in cui le voci sono state scritte.

Messaggi emessi. Entrambi riportano la condizione per un costrutto per cui un provider non ha alcuna espressione, e la frase propria del provider nomina la voce e i kind che accetta. Un campo il cui template ha letto un valore dichiarato sensibile viene mostrato come <redacted>:

a plugin has no expression for a construct this build declares (un plugin non ha alcuna espressione per un costrutto che questo build dichiara) compose: an omits entry (name "<name>") names kind "<kind>": compose leaves out a service, a volume or a config, each named by its key under services:, volumes: or configs:, and no other kind (compose: una voce omits (con il nome indicato) nomina il kind indicato: compose lascia fuori un servizio, un volume o una config, ciascuno nominato dalla propria chiave sotto services:, volumes: o configs:, e nessun altro kind)

a plugin has no expression for a construct this build declares (un plugin non ha alcuna espressione per un costrutto che questo build dichiara) compose: an omits entry (kind "<kind>", name "<name>") names namespace "<namespace>", and a compose file has no namespaces: compose leaves out a service, a volume or a config, each named by its key under services:, volumes: or configs:, and no other kind; remove the namespace from the entry (compose: una voce omits (con il kind e il nome indicati) nomina il namespace indicato, e un file compose non ha namespace: compose lascia fuori un servizio, un volume o una config, ciascuno nominato dalla propria chiave sotto services:, volumes: o configs:, e nessun altro kind; rimuovi il namespace dalla voce)

Come risolvere: nomina l’unità come fa il file compose — kind: service, volume o config, e come name: la sua chiave sotto quella sezione — ed elimina il namespace:. Vedi compose → Modalità con sorgente.

An omits entry names a namespace a CloudFormation template does not have (Una voce omits nomina un namespace che un template CloudFormation non ha)

Una voce omits: su una Recipe o su una FeatureRecipe che attinge da un template CloudFormation lascia fuori una risorsa, nominata dal suo Type come kind della voce e dal suo ID logico come name della voce. Un template non ha namespace, quindi una voce che porta un namespace non nomina nulla che un template possa lasciare fuori, e il rendering si ferma anziché trattare la voce come una che non ha corrisposto a nulla. Ogni voce viene controllata prima che venga lasciato fuori qualsiasi cosa, e viene nominata la prima che porta un namespace, nell’ordine in cui le voci sono state scritte.

Messaggio emesso. Riporta la condizione per un costrutto per cui un provider non ha alcuna espressione, e la frase propria del provider nomina la voce e ciò che questo provider lascia fuori. Un campo il cui template ha letto un valore dichiarato sensibile viene mostrato come <redacted>:

a plugin has no expression for a construct this build declares (un plugin non ha alcuna espressione per un costrutto che questo build dichiara) cloudformation-provider: an omits entry (kind "<kind>", name "<name>") names namespace "<namespace>", and a CloudFormation template has no namespaces: cloudformation leaves out a resource, named by its Type as the entry’s kind and its logical ID under Resources as the entry’s name; remove the namespace from the entry (cloudformation-provider: una voce omits (con il kind e il nome indicati) nomina il namespace indicato, e un template CloudFormation non ha namespace: cloudformation lascia fuori una risorsa, nominata dal suo Type come kind della voce e dal suo ID logico sotto Resources come nome della voce; rimuovi il namespace dalla voce)

Come risolvere: elimina il namespace: dalla voce, che nomina la risorsa solo tramite il suo Type e il suo ID logico. Vedi cloudformation → Lasciare risorse fuori da un template di origine.

A published port declares a transport compose cannot spell (Una porta pubblicata dichiara un trasporto che compose non sa scrivere)

Una porta compose pubblicata porta il proprio trasporto come suffisso sulla voce, e quel suffisso ha due grafie. Una porta che dichiara qualsiasi altro trasporto non ha alcuna grafia compose.

Il rendering si ferma anziché eliminare il suffisso, perché una porta pubblicata che ricade silenziosamente sul trasporto predefinito si avvia portando traffico che i suoi client non possono raggiungere — che è esattamente il guasto che la dichiarazione di un trasporto esiste per prevenire, reintrodotto nel momento della traduzione.

Una porta che non dichiara alcun trasporto non è interessata. Viene pubblicata senza suffisso, esattamente come una porta che non ha mai portato un trasporto.

Messaggio emesso. La condizione nomina il tipo di errore — un valore senza alcuna rappresentazione in ciò che il provider emette — e la frase propria del provider la segue:

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) compose: node "<node>" apply service ports: compose publishes a port’s transport as a tcp or udp suffix; this port declares a transport compose cannot express (compose: nel nodo indicato, applicazione delle porte del servizio: compose pubblica il trasporto di una porta come suffisso tcp o udp; questa porta dichiara un trasporto che compose non può esprimere)

Come risolvere: per una destinazione compose, dichiara il trasporto della porta come uno dei due che compose sa scrivere, oppure lascialo non dichiarato e lascia che la voce venga pubblicata senza suffisso. Dove il trasporto è quello che intendevi, esegui il rendering di quel confine tramite un provider la cui destinazione può esprimerlo.

A resources quantity cannot be converted to a compose value (Una quantità di risorse non può essere convertita in un valore compose)

Le quantità di processore e di memoria di un container, e il suo conteggio nvidia.com/gpu, sono scritte nella notazione che Kubernetes usa per le risorse, e compose le porta in unità proprie — un conteggio di GPU diventa il conteggio di una prenotazione di dispositivi NVIDIA — quindi ciascuna viene letta come quantità e convertita a partire dal suo valore. Due cose lo impediscono, e il messaggio dice quale ha incontrato: un valore che non è affatto una quantità, e una quantità per cui compose non ha una forma esatta — una quantità negativa, una quantità di memoria che non è un numero intero di byte, una quantità di processore più fine di nove cifre decimali di un core, un conteggio di GPU che non è un numero intero di dispositivi, o una quantità oltre la più grande che compose può contenere. Anche un container la cui richiesta e il cui limite nvidia.com/gpu chiedono conteggi diversi ferma il rendering, perché compose prenota un solo conteggio per un servizio. Il rendering si ferma anziché arrotondare il valore o emettere un’approssimazione, perché un limite che silenziosamente non è il limite richiesto è il tipo di differenza che nessuno cerca finché qualcosa non viene fermato per averlo superato.

Messaggi emessi. Ciascuno si apre con la condizione — un valore senza alcuna rappresentazione in ciò che il provider emette — poi nomina la risorsa, se il valore è una richiesta o un limite, il suo percorso nel Workload e il valore. Un valore che non è una quantità è seguito da ciò che gli ha impedito di esserlo e dalla forma che una quantità assume:

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) compose: node "<node>" container "<container>": compose: the <cpu|memory|nvidia.com/gpu> <request|limit> at <path>: "<value>" is not a quantity: <reason>; a quantity is a number such as 2, 0.5 or 1.5, with an optional sign and at most one of an integer exponent (1e3, 5E-2) or a unit suffix (n, u, m, k, M, G, T, P, E, Ki, Mi, Gi, Ti, Pi, Ei): resources quantity cannot be converted to a compose deploy.resources value (compose: nel nodo e nel container indicati: compose: la richiesta o il limite indicato della risorsa indicata, al percorso indicato: il valore indicato non è una quantità: con il motivo indicato; una quantità è un numero come 2, 0.5 o 1.5, con un segno facoltativo e al massimo uno tra un esponente intero (1e3, 5E-2) o un suffisso di unità (n, u, m, k, M, G, T, P, E, Ki, Mi, Gi, Ti, Pi, Ei): la quantità di resources non può essere convertita in un valore deploy.resources di compose)

Una quantità che compose non può rappresentare è seguita dall’intervallo che compose ammette per quella risorsa:

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) compose: node "<node>" container "<container>": compose: the memory <request|limit> at <path> is "<value>", a quantity compose cannot represent exactly; a compose memory value is a whole number of bytes from 0 to 9223372036854775807: resources quantity cannot be converted to a compose deploy.resources value (compose: nel nodo e nel container indicati: compose: la richiesta o il limite di memoria indicato, al percorso indicato, è il valore indicato, una quantità che compose non può rappresentare esattamente; un valore di memoria compose è un numero intero di byte da 0 a 9223372036854775807: la quantità di resources non può essere convertita in un valore deploy.resources di compose)

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) compose: node "<node>" container "<container>": compose: the cpu <request|limit> at <path> is "<value>", a quantity compose cannot represent exactly; a compose cpus value is a core count from 0 to 9223372036.854775807 with at most nine decimal places: resources quantity cannot be converted to a compose deploy.resources value (compose: nel nodo e nel container indicati: compose: la richiesta o il limite di cpu indicato, al percorso indicato, è il valore indicato, una quantità che compose non può rappresentare esattamente; un valore cpus di compose è un numero di core da 0 a 9223372036.854775807 con al massimo nove cifre decimali: la quantità di resources non può essere convertita in un valore deploy.resources di compose)

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) compose: node "<node>" container "<container>": compose: the nvidia.com/gpu <request|limit> at <path> is "<value>", a quantity compose cannot represent exactly; a compose device count is a whole number of devices from 0 to 9223372036854775807: resources quantity cannot be converted to a compose deploy.resources value (compose: nel nodo e nel container indicati: compose: la richiesta o il limite nvidia.com/gpu indicato, al percorso indicato, è il valore indicato, una quantità che compose non può rappresentare esattamente; un conteggio di dispositivi compose è un numero intero di dispositivi da 0 a 9223372036854775807: la quantità di resources non può essere convertita in un valore deploy.resources di compose)

Una richiesta e un limite di GPU che chiedono conteggi diversi nominano entrambi i percorsi ed entrambi i conteggi:

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) compose: node "<node>" container "<container>": compose: the nvidia.com/gpu request at <path> and the limit at <path> ask for different counts (<request> and <limit>); compose reserves one device count for a service, so write the same count in both or only the limit: resources quantity cannot be converted to a compose deploy.resources value (compose: nel nodo e nel container indicati: compose: la richiesta nvidia.com/gpu al percorso indicato e il limite al percorso indicato chiedono conteggi diversi (quelli indicati); compose prenota un solo conteggio di dispositivi per un servizio, quindi scrivi lo stesso conteggio in entrambi o solo il limite: la quantità di resources non può essere convertita in un valore deploy.resources di compose)

Dove il template del Workload legge un valore che un autore ha dichiarato sensibile, nessun messaggio cita il valore che ha rifiutato, e i due conteggi vengono omessi allo stesso modo.

Come risolvere: dove il valore non è una quantità, scrivilo nella forma descritta in Workload → Quantità di risorse; un suffisso isolato come m è ciò che un template lascia quando il valore che interpola è vuoto, quindi l’input da correggere è quello che il template ha letto. Dove è una quantità che compose non può rappresentare, scrivi una quantità entro l’intervallo che il messaggio indica — la memoria come numero intero di byte in qualsiasi unità (1536Mi anziché 1.5001Gi), il tempo di processore con al massimo nove cifre decimali di un core, e un conteggio di GPU come numero intero di dispositivi (1, non 0.5 o 500m). Dove una richiesta e un limite di GPU non concordano, scrivi lo stesso conteggio in entrambi, oppure scrivi solo il limite, che è il conteggio che Kubernetes pianifica per lo stesso Workload.

A resource quantity the helm provider emits is not a quantity (Una quantità di risorsa che il provider helm emette non è una quantità)

Il provider helm copia testualmente ogni quantità di risorsa nei manifesti che emette — i valori resources.requests e resources.limits di ogni container e init container, risorse estese incluse, e ephemeral.sizeLimit, persistent.size e persistentTemplate.size di ogni volume — e prima controlla ciascuna rispetto alla forma di quantità, sul Workload così come i template della Recipe lo hanno valutato. Un valore al di fuori della forma ferma il build qui, dove altrimenti verrebbe compilato senza errori e rifiutato dal cluster al momento dell’installazione del chart.

Messaggio emesso. Si apre con la condizione, poi nomina il nodo, il percorso del campo nel Workload, il valore e ciò che gli ha impedito di essere una quantità, e indica la forma che una quantità assume:

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) helm: node "<node>": <path>: "<value>" is not a quantity: <reason>; a quantity is a number such as 2, 0.5 or 1.5, with an optional sign and at most one of an integer exponent (1e3, 5E-2) or a unit suffix (n, u, m, k, M, G, T, P, E, Ki, Mi, Gi, Ti, Pi, Ei) (helm: nel nodo indicato: percorso indicato: il valore indicato non è una quantità: con il motivo indicato; una quantità è un numero come 2, 0.5 o 1.5, con un segno facoltativo e al massimo uno tra un esponente intero (1e3, 5E-2) o un suffisso di unità (n, u, m, k, M, G, T, P, E, Ki, Mi, Gi, Ti, Pi, Ei))

Come risolvere: scrivi il valore nella forma descritta in Workload → Quantità di risorse. Dove il campo è un template, il valore da correggere è quello che il template ha letto: un suffisso isolato come m o Mi è ciò che un template lascia quando il valore che interpola è vuoto, e un parametro della Release raggiunge il campo esattamente come è stato scritto.

A service type the helm provider cannot render (Un tipo di servizio che il provider helm non può renderizzare)

Il provider helm renderizza ogni voce services di un Workload come un Service Kubernetes il cui tipo è il type della voce. Una voce Loopback chiede che le sue porte siano raggiungibili dall’indirizzo di loopback dell’host stesso e da nessun altro punto, e un Service Kubernetes non ha alcun tipo che lo faccia: su quali indirizzi dei nodi ascolta un Service NodePort è un’impostazione dell’intero cluster, non di un singolo Service. Quindi il build si ferma sulla prima voce Loopback, nell’ordine in cui sono dichiarati i servizi, prima che venga scritta qualsiasi risorsa.

Il build si ferma anziché renderizzare la voce come un altro tipo, perché ciascuno dei tipi che un Service ha cambia ciò che la porta raggiunge: un Service ClusterIP perde la portata pubblicata che la voce chiede, e uno NodePort pubblica la porta su ogni indirizzo di nodo che il cluster consente — l’esposizione più ampia che la voce esiste per evitare.

Messaggio emesso. Si apre con la condizione, poi nomina il nodo, il percorso del servizio nel Workload e il tipo:

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) helm: node "<node>": services.<service>: type “Loopback” publishes the service’s ports on the host’s loopback address only, and a Kubernetes Service has no type that does; declare ClusterIP to keep the ports inside the cluster, or NodePort or LoadBalancer to publish them outside it (helm: nel nodo indicato: servizio indicato sotto services: il tipo «Loopback» pubblica le porte del servizio solo sull’indirizzo di loopback dell’host, e un Service Kubernetes non ha alcun tipo che lo faccia; dichiara ClusterIP per mantenere le porte all’interno del cluster, oppure NodePort o LoadBalancer per pubblicarle all’esterno)

Come risolvere: per una destinazione helm, dichiara il tipo che dice fin dove la porta deve arrivare nel cluster — ClusterIP per mantenerla all’interno, NodePort o LoadBalancer per pubblicarla. Una voce Loopback è per una destinazione compose, che pubblica la porta su 127.0.0.1; vedi Workload → services.

A Kubernetes version the helm provider cannot render a chart for (Una versione di Kubernetes per cui il provider helm non può renderizzare un chart)

Il provider helm renderizza un chart a partire dalla sorgente per la versione di Kubernetes che l’annotazione aggrega.ai/kubernetes-version nomina su un componente o sul suo confine, e legge il valore nel modo in cui helm template --kube-version legge il proprio flag. Un valore che quel flag rifiuterebbe — "one.two", "latest", un singolo numero come "1", un numero scritto con uno zero iniziale come "01.20" — non ha alcuna versione che il chart possa leggere come .Capabilities.KubeVersion, quindi il build si ferma prima che il chart venga renderizzato.

Il build si ferma anziché renderizzare il chart per la versione predefinita, perché un chart legge la versione per scegliere una versione di API, un campo o un intero meccanismo, e un chart renderizzato per una versione diversa da quella che hai nominato emette la forma per quell’altra versione — una che il cluster su cui viene distribuito potrebbe non eseguire.

Un valore vuoto non viene rifiutato. Viene trattato come non impostato, e il chart viene renderizzato per la versione predefinita: quella per cui renderizza il helm template standard della stessa versione di helm.

Messaggio emesso. Si apre con la condizione, poi nomina il nodo e il confine in cui è collocato, l’annotazione, il valore e ciò che gli ha impedito di essere una versione, e indica la forma da scrivere:

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) helm: node "<node>" in boundary "<boundary>": annotation aggrega.ai/kubernetes-version: "<value>" is not a Kubernetes version a chart can be rendered for: <reason>; write the version of the cluster the chart deploys to, such as “1.31” or “v1.31.2”, on the component or on its boundary (helm: nel nodo indicato, nel confine indicato: annotazione aggrega.ai/kubernetes-version: il valore indicato non è una versione di Kubernetes per cui si possa renderizzare un chart: con il motivo indicato; scrivi la versione del cluster su cui viene distribuito il chart, come «1.31» o «v1.31.2», sul componente o sul suo confine)

Il messaggio nomina sia il nodo sia il suo confine perché il provider legge insieme le annotazioni di un componente e quelle del suo confine, e prevale il valore proprio del componente, quindi il valore potrebbe essere stato scritto sull’uno o sull’altro.

Come risolvere: scrivi la versione del cluster su cui viene distribuito il chart — una versione major e minor come "1.31", oppure una completa come "v1.31.2" — sul componente o sul suo confine, oppure rimuovi l’annotazione per renderizzare per la versione predefinita. Vedi helm → La versione di Kubernetes per cui viene renderizzato un chart.

A health probe cannot be turned into a compose healthcheck (Una sonda di integrità non può essere trasformata in un healthcheck compose)

Una sonda di integrità dichiarata diventa un healthcheck compose, e due cose possono impedirlo.

Una sonda che controlla un percorso via HTTP, su un container che non pubblica alcuna porta. Il controllo viene costruito come una richiesta a una porta del container, quindi senza alcuna porta dichiarata non c’è alcun indirizzo rispetto a cui costruirlo.

Una sonda che non dichiara alcun modo di eseguire il controllo — né un percorso, né una porta a cui connettersi, né un comando da eseguire. Non c’è nulla da trasformare in un controllo. Questa è una salvaguardia dietro lo schema anziché una forma che probabilmente scriverai: prima che una sonda arrivi qui si verifica che abbia uno dei tre.

Messaggi emessi. Entrambi riportano la stessa condizione — qualcosa che il provider richiede e che non è riuscito a risolvere in esattamente un valore — e la frase propria del provider dice quale:

a plugin could not resolve something it requires to exactly one value (un plugin non è riuscito a risolvere in esattamente un valore qualcosa che richiede) compose: node "<node>" container "<container>": probe http: requires at least one container port; container declares none (compose: nel nodo e nel container indicati: sonda http: richiede almeno una porta del container; il container non ne dichiara nessuna)

a plugin could not resolve something it requires to exactly one value (un plugin non è riuscito a risolvere in esattamente un valore qualcosa che richiede) compose: node "<node>" container "<container>": probe declares no shape (http/tcp/exec) (compose: nel nodo e nel container indicati: la sonda non dichiara alcuna forma (http/tcp/exec))

Come risolvere: dichiara la porta rispetto a cui eseguire il controllo sullo stesso container della sonda — una sonda via HTTP legge la prima porta del container, quindi la porta deve esistere perché il controllo possa essere costruito. Dove il container davvero non pubblica nulla, controllalo in un altro modo: una sonda che esegue un comando non ha bisogno di alcuna porta. Per una sonda senza alcun modo di controllo dichiarato, dagliene uno dei tre.

A configmap volume has no file behind it (Un volume configmap non ha alcun file dietro di sé)

Un volume che monta configurazione viene fornito tramite il meccanismo proprio di compose per questo scopo, referenziato per nome, e la voce che contiene il contenuto proviene da un file che la Recipe emette. Questa condizione è ciò che segnala un riferimento senza alcuna voce corrispondente: il file non c’è, quindi il montaggio esisterebbe senza nulla dietro e il container si avvierebbe leggendo un percorso vuoto.

Il controllo viene eseguito sull’intero output assemblato anziché per componente, ed è voluto: il riferimento e la voce che contiene il contenuto arrivano per vie diverse e possono provenire da componenti diversi dello stesso gruppo, quindi l’output assemblato è il primo punto in cui sono presenti entrambi. Un controllo per componente rifiuterebbe un riferimento il cui contenuto è fornito da un altro componente dello stesso gruppo.

Viene segnalato ogni riferimento non risolto anziché solo il primo, in un ordine stabile, così un solo build li nomina tutti.

Messaggio emesso. La condizione viene per prima, poi ogni servizio, il riferimento che ha fatto e il punto in cui viene montato:

a plugin could not resolve something it requires to exactly one value (un plugin non è riuscito a risolvere in esattamente un valore qualcosa che richiede) compose AssembleBoundary: service "<service>" references config "<name>" mounted at "<path>"; declare each one as a top-level configs: entry from the Recipe’s artifacts: input: configmap volume requires a file emitted via the Recipe’s artifacts: input; none found (compose AssembleBoundary: il servizio indicato fa riferimento alla config indicata, montata al percorso indicato; dichiara ciascuna come voce configs: di primo livello dall’input artifacts: della Recipe: un volume configmap richiede un file emesso tramite l’input artifacts: della Recipe; nessuno trovato)

Come risolvere: emetti il file dall’input artifacts: della Recipe con il nome a cui il volume fa riferimento — i due vengono abbinati tramite quel nome, quindi una discrepanza tra ciò che il volume chiede e ciò che la Recipe emette è la causa comune. Dove il contenuto doveva provenire da altrove, il volume è il meccanismo sbagliato: un valore che appartiene all’ambiente va invece lì.

What an omits entry left out is still named by the compose file (Ciò che una voce omits ha lasciato fuori è ancora nominato dal file compose)

Una voce omits: lascia fuori un servizio, un volume o una config da un file compose di origine, e compose rifiuta un file che ne nomina uno che non dichiara. Quindi, una volta rimosse le unità delle voci, ogni riferimento che il resto del file fa ancora a una di esse ferma il rendering: un servizio nominato da depends_on, links, volumes_from, extends, un valore di build.additional_contexts o una modalità di rete, IPC, PID o UTS service:; un volume nominato come sorgente di una voce volumes:; una config nominata da una voce configs: — letti in ogni servizio, negli hook pre_start di ogni servizio e in ogni job. L’elenco completo, e i valori che sembrano soltanto riferimenti, si trovano in compose → Modalità con sorgente.

Il controllo legge il file proprio della Recipe o della FeatureRecipe che dichiara la voce, quindi ferma il rendering anche dove un altro contributore allo stesso file assemblato dichiara un’unità con il nome di quella lasciata fuori. Viene segnalato ogni riferimento anziché solo il primo — i servizi in ordine di chiave, poi i job, gli hook di ciascun servizio dopo di esso — così un solo build li nomina tutti.

Messaggio emesso. La condizione viene per prima, poi ogni voce che fa riferimento, l’unità che nomina e il campo in cui si trova il riferimento:

a plugin could not resolve something it requires to exactly one value (un plugin non è riuscito a risolvere in esattamente un valore qualcosa che richiede) compose: what an omits entry left out is still named by the file: service "<service>" names <kind> "<name>" at <field>; compose refuses a file naming a service, a volume or a config it does not declare: leave out what names it as well, change the reference through valuesMapping, or remove the entry (compose: ciò che una voce omits ha lasciato fuori è ancora nominato dal file: il servizio indicato nomina l’unità del kind e del nome indicati nel campo indicato; compose rifiuta un file che nomina un servizio, un volume o una config che non dichiara: lascia fuori anche ciò che lo nomina, cambia il riferimento tramite valuesMapping, oppure rimuovi la voce)

Un’unità il cui nome di voce è stato costruito a partire da un valore dichiarato sensibile viene mostrata come <redacted>.

Come risolvere: decidi quale delle due cose intendevi. Dove il servizio che fa riferimento ha ancora bisogno dell’unità, mantienila: rimuovi la voce. Dove non ne ha bisogno, cambia il riferimento tramite il valuesMapping: della Recipe — lì una lista sostituisce la lista del file di base, quindi depends_on: [] ne svuota una — oppure lascia fuori il servizio che fa riferimento con una voce propria.

What an omits entry left out is still named by a CloudFormation template (Ciò che una voce omits ha lasciato fuori è ancora nominato da un template CloudFormation)

Una voce omits: lascia fuori una risorsa da un template CloudFormation di origine, e CloudFormation rifiuta un template che nomina una risorsa che non dichiara. Quindi, una volta rimosse le risorse delle voci, ogni riferimento che i template rimanenti fanno ancora a una di esse ferma il rendering: un Ref, un Fn::GetAtt nella sua forma a lista o nella sua forma a stringa con punto, il DependsOn di una risorsa, o una variabile di un Fn::Sub — letti in qualsiasi punto del corpo di ogni risorsa e di ogni output. L’elenco completo, e i valori che sembrano soltanto riferimenti, si trovano in cloudformation → Lasciare risorse fuori da un template di origine.

Il controllo legge insieme i template propri della Recipe o della FeatureRecipe che dichiara la voce: un riferimento a un ID logico che un altro di quei template dichiara ancora non viene fermato, mentre uno a una risorsa lasciata fuori ferma il rendering anche dove un altro componente dichiara una risorsa con quell’ID logico. Viene segnalato ogni riferimento anziché solo il primo — template per template nell’ordine in cui la sorgente li porta, per ciascun template le sue risorse e poi i suoi output in ordine di chiave — così un solo build li nomina tutti.

Messaggio emesso. La condizione viene per prima, poi ogni riferimento: il template in cui si trova, la risorsa che nomina, il modo in cui la nomina e il punto in cui si trova come percorso dalla radice del template:

a plugin could not resolve something it requires to exactly one value (un plugin non è riuscito a risolvere in esattamente un valore qualcosa che richiede) cloudformation-provider: what an omits entry left out is still named by the source’s templates: template "<template>" names resource "<logical-id>" (type "<type>") by <Ref|Fn::GetAtt|DependsOn|Fn::Sub> at <path>; CloudFormation refuses a template naming a resource it does not declare: leave out what names it as well, or remove the entry (cloudformation-provider: ciò che una voce omits ha lasciato fuori è ancora nominato dai template della sorgente: il template indicato nomina la risorsa indicata (del tipo indicato) nel modo indicato, al percorso indicato; CloudFormation rifiuta un template che nomina una risorsa che non dichiara: lascia fuori anche ciò che la nomina, oppure rimuovi la voce)

Dove i campi di una voce sono stati costruiti a partire da un valore dichiarato sensibile, l’ID logico e il tipo della sua risorsa vengono mostrati come <redacted>, così come ogni passo del percorso che riporta quell’ID logico.

Come risolvere: decidi quale delle due cose intendevi. Dove la risorsa che fa riferimento ha ancora bisogno di quella lasciata fuori, mantienila: rimuovi la voce. Dove non ne ha bisogno, lascia fuori anche la risorsa che fa riferimento, con una voce propria — un valore legato a un parametro sostituisce solo un riferimento a quel parametro, quindi un riferimento a una risorsa non può essere cambiato in questo modo. Un output che nomina la risorsa non può essere lasciato fuori, quindi una risorsa nominata da un output resta.

A valuesMapping key names no parameter of a sourced CloudFormation template (Una chiave valuesMapping non nomina alcun parametro di un template CloudFormation di origine)

Un template CloudFormation di origine riceve valori tramite i Parameters che dichiara, e il valuesMapping della Recipe o della FeatureRecipe che lo usa come sorgente scrive una chiave per ogni parametro che riempie. Una chiave che non nomina alcun parametro dichiarato da un template della sorgente non ha dove andare, quindi il rendering si ferma anziché scartarla — l’errore che CloudFormation stesso segnalerebbe per un parametro sconosciuto, segnalato mentre sta ancora a te correggerlo. Solo un valuesMapping riempie i parametri: i valori che nulla ha mappato non vengono mai letti in questo modo, quindi i valori propri di un componente o di un’associazione scritti per i suoi altri input non incontrano mai questa condizione.

Messaggio emesso. La condizione viene per prima, poi ogni chiave che non ha nominato nulla e ciò che dichiara ciascun template della sorgente:

a plugin could not resolve something it requires to exactly one value (un plugin non è riuscito a risolvere in esattamente un valore qualcosa che richiede) cloudformation-provider: the Recipe’s or FeatureRecipe’s valuesMapping writes the key "<key>", and no template of the source declares a parameter of that name: template "<template>" declares "<parameter>", …; a sourced template takes values only through the parameters it declares, so rename the key to the parameter it is meant for, or remove it from the valuesMapping (cloudformation-provider: il valuesMapping della Recipe o della FeatureRecipe scrive la chiave indicata, e nessun template della sorgente dichiara un parametro con quel nome: il template indicato dichiara il parametro indicato, …; un template di origine riceve valori solo tramite i parametri che dichiara, quindi rinomina la chiave con il nome del parametro a cui è destinata, oppure rimuovila dal valuesMapping)

Come risolvere: confronta la chiave con i parametri che il messaggio elenca — una chiave scritta male è la causa abituale — e rinominala, oppure rimuovila dal valuesMapping. Vedi cloudformation → Valori per i parametri di un template di origine.

Another component references a CloudFormation parameter a sourced template’s binding filled (Un altro componente fa riferimento a un parametro CloudFormation che il legame di un template di origine ha riempito)

Riempire il parametro di un template di origine tramite il valuesMapping della Recipe o della FeatureRecipe della Feature associata che lo usa come sorgente sostituisce ogni riferimento a esso in ogni template di quella sorgente e ne rimuove la dichiarazione. Il contenuto proveniente da altre parti dello stesso stack assemblato — il frammento o il template di origine di un altro componente, oppure il frammento del componente a cui è associata una Feature — che nomina ancora il parametro tramite Ref, una variabile di Fn::Sub o il Fn::ValueOf di una regola nomina allora qualcosa che lo stack non dichiara più, cosa che CloudFormation rifiuta quando lo stack viene distribuito, quindi l’assemblaggio si ferma. Un nome che qualche componente dello stack dichiara ancora, come proprio parametro o come ID logico di una risorsa, è un riferimento che lo stack risolve e non viene fermato.

Messaggio emesso. La condizione viene per prima, poi ogni riferimento: il componente e il template in cui si trova, il parametro e il componente il cui valuesMapping della Recipe o della FeatureRecipe associata lo ha riempito — una Feature associata a un componente viene nominata tramite quel componente, e una associata a un confine tramite l’identità che le sue risorse portano come aggrega.ai/component-id, composta dal percorso del confine e dal nome dell’associazione, come bfr--stack--aux:

a plugin could not resolve something it requires to exactly one value (un plugin non è riuscito a risolvere in esattamente un valore qualcosa che richiede) cloudformation-provider: a parameter a sourced template’s binding filled is still referenced from elsewhere in the assembled stack: component "<component>"’s template "<template>" references parameter "<parameter>", which the valuesMapping of a Recipe or FeatureRecipe rendering for component "<component>" binds; …; binding a parameter removes its declaration from the source that declares it, and no template in the stack declares it any more, so the reference names nothing CloudFormation can resolve: reference what the binding component publishes instead, declare the parameter in the template that references it, or remove the key from the valuesMapping (cloudformation-provider: un parametro che il legame di un template di origine ha riempito è ancora referenziato da altre parti dello stack assemblato: il template indicato del componente indicato fa riferimento al parametro indicato, che il valuesMapping di una Recipe o di una FeatureRecipe che esegue il rendering per il componente indicato lega; …; legare un parametro ne rimuove la dichiarazione dalla sorgente che lo dichiara, e nessun template nello stack lo dichiara più, quindi il riferimento non nomina nulla che CloudFormation possa risolvere: fai invece riferimento a ciò che pubblica il componente che lo lega, dichiara il parametro nel template che vi fa riferimento, oppure rimuovi la chiave dal valuesMapping)

Come risolvere: dove il componente che fa riferimento ha bisogno del valore, fai in modo che il componente che lo riempie lo pubblichi tramite provides e fai riferimento a quello; oppure dichiara il parametro nel template che fa riferimento, così che riceva un proprio valore; oppure rimuovi la chiave dal valuesMapping, così che il parametro resti dichiarato e ogni componente legga il valore passato quando lo stack viene distribuito. Vedi cloudformation → Valori per i parametri di un template di origine.

A value bound to a CloudFormation parameter cannot take the parameter’s type (Un valore legato a un parametro CloudFormation non può assumere il tipo del parametro)

Un letterale legato a un parametro viene convertito nel modo in cui CloudFormation converte lo stesso valore passato per il Type di quel parametro quando lo stack viene distribuito. Dove non esiste una conversione del genere il rendering si ferma: un valore che non è un numero legato a un Number o a un List<Number>, una lista o una mappa legata a un parametro che accetta un solo valore, e qualsiasi letterale legato a un parametro AWS::SSM::Parameter::Value<…>, il cui valore CloudFormation legge da Parameter Store anziché dal template. Anche una lista legata a un parametro che il template nomina come variabile di Fn::Sub ferma il rendering, perché una variabile sostituisce una sola stringa.

Messaggio emesso. La condizione viene per prima, poi il parametro, il suo template e il suo tipo, e il motivo per cui il valore non è adatto; nessun valore viene citato:

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) cloudformation-provider: parameter "<parameter>" of template "<template>" is of type <type>, and <why the value does not fit> (cloudformation-provider: il parametro indicato del template indicato è del tipo indicato, e il valore non è adatto per il motivo indicato)

Come risolvere: lega un valore del tipo del parametro — oppure, per un tipo Parameter Store, un riferimento dinamico {{resolve:ssm:…}} o una funzione intrinseca — oppure lascia il parametro non legato per un valore passato quando lo stack viene distribuito.

A value bound to a CloudFormation parameter is one its constraints refuse (Un valore legato a un parametro CloudFormation è uno che i suoi vincoli rifiutano)

Un letterale legato a un parametro viene controllato rispetto ai vincoli che il template dichiara per esso — AllowedValues, AllowedPattern, MinLength, MaxLength, MinValue e MaxValue — lo stesso controllo che CloudFormation esegue su un valore passato quando lo stack viene distribuito, spostato al momento del build così che riempire un parametro non rimuova alcun controllo che il template ha dichiarato. Una funzione intrinseca e un riferimento dinamico vengono lasciati al controllo di CloudFormation, poiché il loro valore non esiste finché lo stack non viene distribuito.

Messaggio emesso. La condizione viene per prima, poi il parametro, il suo template e il vincolo; nessun valore viene citato:

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) cloudformation-provider: the value bound to parameter "<parameter>" of template "<template>" does not satisfy its <constraint>, which CloudFormation would refuse when the stack deploys; bind a value the parameter admits (cloudformation-provider: il valore legato al parametro indicato del template indicato non soddisfa il suo vincolo indicato, che CloudFormation rifiuterebbe quando lo stack viene distribuito; lega un valore che il parametro ammette)

Come risolvere: lega un valore che il vincolo ammette; la dichiarazione del parametro nel template stesso elenca ciò che consente.

A secret bound to a CloudFormation parameter would be written into the template (Un segreto legato a un parametro CloudFormation verrebbe scritto nel template)

Un valore legato a un parametro viene scritto nel template, dove chiunque possa leggere il template dello stack può leggerlo. Il rendering si ferma su un letterale legato a un parametro che il template dichiara NoEcho e, dove il valuesMapping della Recipe o della FeatureRecipe legge un valore che un autore ha dichiarato sensibile, su ogni letterale che quella mappatura lega, poiché nessuna parte del suo output può essere ricondotta al valore da cui proviene. Un riferimento dinamico e una funzione intrinseca vengono scritti così come sono dati — compreso il testo all’interno di una funzione intrinseca — quindi un valore sensibile che la mappatura inserisce in una stringa Fn::Sub raggiunge il template come quel testo, e solo un riferimento dinamico tiene fuori dal template il segreto stesso.

Messaggio emesso. La condizione viene per prima, poi i parametri e ciò da legare al loro posto; nessun valore viene citato. Uno tra:

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) cloudformation-provider: parameter "<parameter>" of template "<template>" is declared NoEcho, and the value bound to it would be written into the template as it stands; bind a dynamic reference ({{resolve:secretsmanager:…}} or {{resolve:ssm-secure:…}}) or an intrinsic function instead, or leave the parameter unbound for a deploy-time value (cloudformation-provider: il parametro indicato del template indicato è dichiarato NoEcho, e il valore legato a esso verrebbe scritto nel template così com’è; lega invece un riferimento dinamico ({{resolve:secretsmanager:…}} o {{resolve:ssm-secure:…}}) o una funzione intrinseca, oppure lascia il parametro non legato per un valore fornito al momento della distribuzione)

cloudformation-provider: the Recipe’s or FeatureRecipe’s valuesMapping reads a value declared sensitive, so a literal it produces is refused, and binding parameter(s) "<parameter>", … would write a literal into the template as it stands; … (cloudformation-provider: il valuesMapping della Recipe o della FeatureRecipe legge un valore dichiarato sensibile, quindi un letterale che produce viene rifiutato, e legare il parametro o i parametri indicati, … scriverebbe un letterale nel template così com’è; …)

Come risolvere: conserva il segreto in Secrets Manager o come stringa sicura di Parameter Store e lega un riferimento dinamico che punti a esso — {{resolve:secretsmanager:<secret>}} o {{resolve:ssm-secure:<name>}} — anziché inserirlo nel testo di una funzione intrinseca, oppure lascia il parametro non legato per un valore passato quando lo stack viene distribuito. Vedi cloudformation → Valori per i parametri di un template di origine.

A dynamic reference is bound where CloudFormation does not resolve it (Un riferimento dinamico è legato dove CloudFormation non lo risolve)

CloudFormation risolve un riferimento dinamico nelle proprietà di una risorsa, ma non nei dati utente EC2 né nei metadati AWS::CloudFormation::Init, e mostra gli Outputs di un template a chiunque legga lo stack. Quindi un riferimento dinamico legato a un parametro a cui un qualsiasi template della sorgente fa riferimento in una proprietà UserData, in quei metadati o nei suoi Outputs ferma il rendering anziché raggiungere un punto in cui o non può essere distribuito o viene esposto.

Messaggio emesso. La condizione viene per prima, poi il parametro, il template e il punto in cui quel template vi fa riferimento; nessun valore viene citato:

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) cloudformation-provider: the value bound to parameter "<parameter>" is a dynamic reference, and template "<template>" references the parameter in <where>, where CloudFormation does not resolve a dynamic reference or shows it to whoever reads the stack; bind an intrinsic function instead, or leave the parameter unbound for a deploy-time value (cloudformation-provider: il valore legato al parametro indicato è un riferimento dinamico, e il template indicato fa riferimento al parametro nel punto indicato, dove CloudFormation non risolve un riferimento dinamico o lo mostra a chiunque legga lo stack; lega invece una funzione intrinseca, oppure lascia il parametro non legato per un valore fornito al momento della distribuzione)

Come risolvere: lascia il parametro non legato e passa il suo valore quando lo stack viene distribuito, oppure lega una funzione intrinseca che produca ciò di cui il template ha bisogno in quel punto.

A rule reads a bound CloudFormation parameter by name (Una regola legge per nome un parametro CloudFormation legato)

Fn::ValueOf nelle Rules di un template nomina un parametro tramite il suo ID logico anziché tramite Ref, e legge il valore passato per esso quando lo stack viene distribuito. Legare il parametro rimuove la sua dichiarazione da ogni template della sorgente, il che lascerebbe la regola — in uno qualsiasi di quei template — a non nominare nulla, quindi il rendering si ferma.

Messaggio emesso. La condizione viene per prima, poi la regola, il suo template e il parametro:

a plugin has no expression for a construct this build declares (un plugin non ha alcuna espressione per un costrutto che questo build dichiara) cloudformation-provider: rule "<rule>" of template "<template>" reads parameter "<parameter>" through Fn::ValueOf, which names a declared parameter by its logical ID, and binding the parameter removes its declaration from the source; leave the parameter unbound so the rule can read it at deploy (cloudformation-provider: la regola indicata del template indicato legge il parametro indicato tramite Fn::ValueOf, che nomina un parametro dichiarato tramite il suo ID logico, e legare il parametro rimuove la sua dichiarazione dalla sorgente; lascia il parametro non legato così che la regola possa leggerlo al momento della distribuzione)

Come risolvere: rimuovi la chiave del parametro dal valuesMapping, così che il parametro resti dichiarato e la regola legga il valore passato quando lo stack viene distribuito.

The assembled CloudFormation stack cannot carry a transform (Lo stack CloudFormation assemblato non può portare una trasformazione)

Il Transform dello stack assemblato è costruito a partire da quello di ogni componente, e una trasformazione elabora l’intero template, quindi una trasformazione il cui effetto non è circoscritto al contenuto scritto per essa viene rifiutata anziché poter cambiare il modo in cui viene distribuito il contenuto di un altro componente: AWS::CodeDeployBlueGreen e AWS::Include sempre, una macro definita dal tuo account e AWS::ServiceCatalog accanto a qualsiasi altro componente, AWS::LanguageExtensions accanto al contenuto serverless di un altro componente, e AWS::Serverless-2016-10-31 dove i suoi Globals raggiungerebbero le risorse serverless di un altro componente o una delle sue sorgenti di eventi nomina una risorsa che un altro componente dichiara. La tabella completa si trova in cloudformation → Sezioni di primo livello nello stack assemblato.

Messaggio emesso. La condizione viene per prima, poi ogni componente nello stack, la trasformazione e i componenti che la dichiarano, e il motivo per cui non può essere portata:

a plugin has no expression for a construct this build declares (un plugin non ha alcuna espressione per un costrutto che questo build dichiara) cloudformation-provider: the assembled stack of component "<component>", … cannot carry the transform "<transform>", declared by component "<component>": <why> (cloudformation-provider: lo stack assemblato del componente indicato, … non può portare la trasformazione indicata, dichiarata dal componente indicato: con il motivo indicato)

Come risolvere: colloca il componente che dichiara la trasformazione in un confine proprio, così che il suo stack non contenga nulla che la trasformazione possa cambiare; oppure, dove il messaggio nomina contenuto che un altro componente dichiara, sposta quel contenuto nel componente che dichiara la trasformazione.

Two components order one pair of transforms oppositely (Due componenti ordinano in modo opposto una stessa coppia di trasformazioni)

Lo stack assemblato esegue le sue trasformazioni in un unico ordine, costruito a partire dall’ordine proprio di ciascun componente e da quello documentato da CloudFormation. Dove due ordini non possono valere entrambi — due componenti che elencano una stessa coppia di trasformazioni in senso opposto, o un componente che elenca AWS::Serverless-2016-10-31 prima di AWS::LanguageExtensions, che CloudFormation documenta nell’altro senso — non c’è un unico ordine da scrivere, quindi il rendering si ferma.

Messaggio emesso. La condizione viene per prima, poi la coppia e chi l’ha ordinata in ciascun senso:

a plugin could not resolve something it requires to exactly one value (un plugin non è riuscito a risolvere in esattamente un valore qualcosa che richiede) cloudformation-provider: the transforms "<first>" and "<second>" are ordered both ways — "<first>" before "<second>" by <who>, and "<second>" before "<first>" by <who> — and the assembled stack’s Transform runs them in one order; declare them in one order (cloudformation-provider: le trasformazioni indicate sono ordinate in entrambi i sensi — la prima anteposta alla seconda da chi è indicato, e la seconda anteposta alla prima da chi è indicato — e il Transform dello stack assemblato le esegue in un unico ordine; dichiarale in un unico ordine)

Come risolvere: dichiara la coppia in un unico ordine in ogni componente che le elenca entrambe, seguendo l’ordine proprio di CloudFormation dove ne documenta uno.

Two entries reach one stack output name (Due voci raggiungono un unico nome di output dello stack)

Un nome di output dello stack ammette solo lettere e cifre, quindi viene costruito a partire da ciò che hai scritto codificando i caratteri che quell’alfabeto non ammette anziché eliminandoli. Due voci che hai scritto distinte restano quindi distinte, e questo arresto è ciò che segnala il caso in cui due di esse raggiungono comunque un unico nome. Il rendering si ferma anziché emettere un solo output dove sono state scritte due voci, il che eliminerebbe silenziosamente una delle due.

Viene segnalato ogni nome dietro cui si sono incontrate due o più voci, e viene nominata ogni voce dietro ciascun nome, in un ordine stabile — così un solo build ti mostra l’intera collisione anziché un solo lato di essa.

Messaggio emesso, che si apre con la condizione e prosegue con il dettaglio proprio del provider:

two things a plugin produced occupy one name in its output (due cose prodotte da un plugin occupano un unico nome nel suo output) cloudformation-provider: two entries an author wrote reach one stack Output name: <the entries that met> reach the Output name "<name>"; an Output name is built by encoding the component and the entry into the letters and digits a logical id admits, rather than by dropping what it does not, so two entries an author wrote apart stay apart — renaming either end clears the build (cloudformation-provider: due voci scritte da un autore raggiungono un unico nome di Output dello stack: le voci indicate che si sono incontrate raggiungono il nome di Output indicato; un nome di Output viene costruito codificando il componente e la voce nelle lettere e cifre ammesse da un ID logico, anziché eliminando ciò che non ammette, quindi due voci che un autore ha scritto distinte restano distinte — rinominare una delle due estremità sblocca il build)

Come risolvere: rinomina una delle voci, o uno dei componenti, così che le due non raggiungano più un unico nome — il messaggio nomina entrambi i lati. Il nome porta la punteggiatura e le maiuscole e minuscole che hai scritto, codificate anziché eliminate, quindi una differenza nell’una o nelle altre sopravvive nel nome e due voci scritte in modo diverso ricevono nomi distinti.

A CloudFormation fragment writes one key twice (Un frammento CloudFormation scrive due volte una stessa chiave)

Una mappa contiene un valore per chiave, quindi un frammento che scrive due volte la stessa chiave manterrebbe il corpo venuto per ultimo e scarterebbe l’altro. Dove la mappa è il blocco che contiene le risorse o gli output, il corpo scartato è una risorsa o un output che è stato scritto e non sarebbe nel risultato. Il rendering invece si ferma.

Vengono segnalati entrambi i punti in cui la chiave è stata scritta, perché una chiave scritta due volte è di solito il frutto di due modifiche pensate come due chiavi diverse — e all’autore servono entrambi per capire quale cambiare.

Messaggio emesso, che si apre con la condizione e prosegue con il dettaglio proprio del provider:

two things a plugin produced occupy one name in its output (due cose prodotte da un plugin occupano un unico nome nel suo output) cloudformation-provider: one mapping key is written more than once: the key "<key>" is written at line <first> and again at line <second>; a mapping holds one value per key, so one of the two bodies would be dropped — remove one, or rename one so each key is written once (cloudformation-provider: una chiave di mappa è scritta più di una volta: la chiave indicata è scritta alla riga indicata e di nuovo alla seconda riga indicata; una mappa contiene un valore per chiave, quindi uno dei due corpi verrebbe eliminato — rimuovine uno, oppure rinominane uno così che ogni chiave sia scritta una volta sola)

Come risolvere: apri il frammento alle due righe che il messaggio nomina. Dove i due corpi dovevano essere una sola cosa, rimuovi quello ora ridondante; dove dovevano essere due, rinominane uno così che ciascuno abbia una chiave propria. Il frammento è un template, quindi dove una chiave viene composta anziché scritta letteralmente controlla il testo renderizzato anziché soltanto la sorgente.

A cross-boundary reference has no consuming stack to be written into (Un riferimento tra confini non ha alcuno stack consumatore in cui essere scritto)

Dove una connessione di dipendenza attraversa due output assemblati separatamente, il lato consumatore viene renderizzato con un segnaposto e il riferimento viene scritto una volta che entrambi i lati esistono. Questa condizione è ciò che accade quando l’output assemblato del lato consumatore non contiene affatto un template di stack: non c’è alcun documento in cui scrivere il riferimento, quindi il segnaposto non può essere sostituito.

Messaggio emesso. La condizione nomina il tipo di errore, e la frase propria del provider dice quale input:

a plugin could not resolve something it requires to exactly one value (un plugin non è riuscito a risolvere in esattamente un valore qualcosa che richiede) cloudformation-provider: cross-boundary link resolve received no consumer stack template (cloudformation-provider: la risoluzione del collegamento tra confini non ha ricevuto alcun template di stack consumatore)

Come risolvere: nulla di ciò che scrivi all’interno del componente consumatore produce questo — è la forma di ciò che il suo confine ha assemblato. Verifica che il lato consumatore sia renderizzato proprio dal provider CloudFormation: una connessione che attraversa verso un confine che assembla qualcos’altro non ha alcuno stack in cui il riferimento possa arrivare, e la connessione va posta tra due confini che lo stesso provider assembla. Dove entrambi i lati dovrebbero essere CloudFormation, il confine consumatore non ha prodotto alcun template di stack, il che è una questione per chi ha scritto le Recipes che vi contribuiscono.

A cross-boundary reference was spliced into a longer string (Un riferimento tra confini è stato inserito in una stringa più lunga)

Un riferimento incrociato CloudFormation è un oggetto anziché testo, quindi può solo sostituire un valore per intero. Questa condizione è ciò che segnala un segnaposto trovato all’interno di una stringa più ampia — un valore composto attorno a esso, anziché consegnato come l’intero contenuto di ciò che è stato iniettato. Non c’è nulla con cui scambiare l’oggetto, quindi il rendering si ferma anziché emettere un riferimento in una forma che la destinazione non può leggere.

Messaggio emesso. La condizione viene per prima, poi il valore e la connessione su cui è arrivato:

a plugin has no representation for a value it was given (un plugin non ha alcuna rappresentazione per un valore che ha ricevuto) cloudformation-provider: cross-boundary link value is interpolated into a larger string; only a whole-scalar injection can carry a cross-stack reference: output key "<key>" on socket "<socket>" (cloudformation-provider: il valore del collegamento tra confini è interpolato in una stringa più ampia; solo un’iniezione di uno scalare intero può portare un riferimento tra stack: con la chiave di output indicata sul socket indicato)

Come risolvere: consegna il valore per intero anziché comporre attorno a esso. Dove il lato consumatore ha bisogno del valore all’interno di una stringa più lunga — una stringa di connessione, un URL — costruisci quella composizione nel vocabolario proprio della destinazione a partire dal riferimento, anziché nel template della Recipe prima che il riferimento esista. La mappatura che inietta il valore è il punto in cui avviene l’inserimento, quindi è quella la riga da cambiare.

Two rendered resources land at one output file (Due risorse renderizzate finiscono in un unico file di output)

Ogni risorsa renderizzata viene scritta in un file il cui nome deriva da ciò che la risorsa è e da come si chiama. Due risorse che condividono questi elementi portano lo stesso nome di file, quindi una occuperebbe lo spazio dell’altra e il rendering si ferma anziché emettere un solo file dove sono state renderizzate due risorse.

Due risorse che vengono renderizzate in modo identico non sono una collisione. Dove il contenuto corrisponde byte per byte, tenerne una non fa perdere nulla e il rendering prosegue — quindi un template incluso due volte con lo stesso risultato non viene segnalato.

Messaggio emesso. La condizione viene per prima, poi entrambi i template che le hanno prodotte e il file in cui si sono incontrate:

two things a plugin produced occupy one name in its output (due cose prodotte da un plugin occupano un unico nome nel suo output) helm: node "<node>": rendered resources "<one template>" and "<the other>" both derive output "<file>" with differing content: two rendered resources derive the same output filename with differing content (helm: nel nodo indicato: le risorse renderizzate indicate, l’una e l’altra, derivano entrambe l’output indicato con contenuto diverso: due risorse renderizzate derivano lo stesso nome di file di output con contenuto diverso)

Come risolvere: dai alle due risorse identità distinte — il nome è ciò che di solito differisce, e il nome del file ne deriva. Il messaggio nomina entrambi i template, quindi aprili e controlla che cosa produce ciascuno: due template che renderizzano la stessa risorsa con un unico nome spesso significano che uno dei due è una copia più vecchia. Dove servono entrambe, sono due risorse e ciascuna ha bisogno di un nome proprio.

A synthesized StatefulSet has no single service to govern it (Uno StatefulSet sintetizzato non ha un unico servizio che lo governi)

Un carico di lavoro che dichiara uno storage per istanza viene renderizzato come StatefulSet, e uno StatefulSet nomina un servizio che lo governa — quello che dà a ciascuna istanza il suo indirizzo stabile. Quel servizio è quello dichiarato senza un proprio indirizzo di cluster. Due forme fermano il rendering: nessuno dichiarato, quindi non c’è nulla da nominare; e più di uno, quindi la domanda su quale di essi governi non ha risposta. L’una e l’altra produrrebbero uno StatefulSet che la destinazione rifiuta, quindi il rendering si ferma anziché emetterne uno.

Messaggi emessi. Entrambi riportano la stessa condizione — qualcosa che il provider richiede e che non è riuscito a risolvere in esattamente un valore — e la frase propria del provider dice quale delle due forme si è presentata. Ciascuno viene stampato sotto una cornice che nomina il nodo:

a plugin could not resolve something it requires to exactly one value (un plugin non è riuscito a risolvere in esattamente un valore qualcosa che richiede) synthesized StatefulSet requires a headless governing Service (declare a service with type: Headless); none found: synthesized StatefulSet has no headless governing Service (lo StatefulSet sintetizzato richiede un Service headless che lo governi (dichiara un servizio con type: Headless); nessuno trovato: lo StatefulSet sintetizzato non ha alcun Service headless che lo governi)

a plugin could not resolve something it requires to exactly one value (un plugin non è riuscito a risolvere in esattamente un valore qualcosa che richiede) synthesized StatefulSet declares more than one headless Service; the governing Service is ambiguous (declare exactly one type: Headless service): synthesized StatefulSet has more than one headless Service (lo StatefulSet sintetizzato dichiara più di un Service headless; il Service che lo governa è ambiguo (dichiara esattamente un servizio type: Headless): lo StatefulSet sintetizzato ha più di un Service headless)

Come risolvere: dichiara sul carico di lavoro esattamente un servizio di tipo headless. Dove non ne è dichiarato nessuno, aggiungilo — un carico di lavoro con storage per istanza ne ha bisogno, ed è ciò che dà a ciascuna istanza un indirizzo che resta suo. Dove ne è dichiarato più di uno, mantieni quello che deve governare e assegna agli altri un tipo ordinario, oppure rimuovili; un secondo servizio headless è di solito uno che non aveva bisogno di essere headless.

A plugin reported a failure it did not classify (Un plugin ha segnalato un errore che non ha classificato)

Un plugin che ferma un build riporta due cose: una frase propria che dice che cosa è successo, e quale tipo di errore quella frase nomina. I tipi sono un piccolo insieme che il compilatore dichiara — un costrutto senza alcuna espressione, un input che non è stato possibile risolvere in un solo valore, due cose prodotte che vogliono un unico nome, un valore senza alcuna rappresentazione — e questa condizione è quella che un plugin sceglie quando il suo errore non rientra in nessuno di essi.

È un ripiego anziché un approdo. Un plugin che vi ricorre dove uno degli altri tipi è adatto ti sta dicendo meno di quanto sa, e la formulazione dice chiaramente che il plugin ha rinunciato a classificare, non che qualcosa sia semplicemente andato storto — così un ripiego usato troppo è riconoscibile anziché indistinguibile da una segnalazione corretta.

Messaggio emesso. La condizione viene per prima e la frase propria del plugin la segue:

a plugin reported a failure that none of the declared kinds names (un plugin ha segnalato un errore che nessuno dei tipi dichiarati nomina) <the plugin's own sentence>

Come risolvere: leggi la frase propria del plugin, che è dove si trova tutto ciò che è specifico del tuo build. La condizione in sé ti dice soltanto che il plugin non aveva un tipo per l’errore. Dove il plugin è tuo, scegli il tipo che l’errore è davvero; dove non lo è, la frase è ciò da citare a chi lo pubblica.

A plugin named a condition the socket does not declare (Un plugin ha nominato una condizione che il socket non dichiara)

Un plugin riporta una condizione che questo compilatore dichiara anziché inventare un numero proprio, quindi l’identificatore che ti raggiunge è sempre uno per cui aggrega explain dà una risposta. Questo arresto è ciò che produce una segnalazione che nomina qualsiasi altra cosa: un numero sotto cui non è registrato nulla, un numero ritirato, un codice breve scritto diversamente dalla registrazione in cui si risolve, o una coppia di identificatori che nominano due condizioni diverse.

Si ferma anziché ritirare in silenzio la segnalazione. Eliminare gli identificatori e lasciar valere la condizione generica di errore del plugin produrrebbe un build identico in tutto e per tutto a quello di un plugin che non ha nominato alcuna condizione, così chi deve correggerlo non saprebbe mai che c’era qualcosa da correggere. Riportare invece il numero offerto ti consegnerebbe un identificatore che non si risolve in nulla.

Il tuo build riceve comunque ciò che lo ha fermato. L’arresto cita il numero in errore, dice perché non si risolve in alcuna condizione, nomina le condizioni generiche a cui un plugin ricorre quando non ha un’identità migliore, e riporta invariata la frase propria del plugin.

Messaggio emesso:

wasm: guest plugin named a condition the socket does not declare: the guest named "<offered>", and <why it resolves to no condition>; a plugin names a condition this compiler declares, and reaches for one of <the generic conditions and their codes> when it has none better: <the plugin's own sentence> (wasm: il plugin guest ha nominato una condizione che il socket non dichiara: il guest ha nominato il valore indicato, con il motivo indicato per cui non si risolve in alcuna condizione; un plugin nomina una condizione che questo compilatore dichiara, e ricorre a una delle condizioni generiche indicate, con i loro codici, quando non ne ha una migliore: seguito dalla frase propria del plugin)

Come risolvere: nulla nei tuoi file di entità causa questo — è la segnalazione del plugin a essere sbagliata, e l’errore che stava segnalando è reale. Agisci in base alla frase propria del plugin, che è l’ultima parte del messaggio. Dove il plugin è tuo, segnala una condizione che questo compilatore dichiara — uno dei tipi generici che il messaggio elenca, dove l’errore non rientra in nessuna delle condizioni più specifiche; dove il plugin non è tuo, cita il numero in errore a chi lo pubblica.

A source artifact is cached without a workspace root to anchor it (Un artifact sorgente viene messo in cache senza una radice del workspace a cui ancorarlo)

Un artifact sorgente acquisito viene conservato in uno slot sotto la cache degli artifact del workspace, e il percorso di quello slot è costruito a partire dalla radice del workspace verso l’esterno. Questa condizione segnala che la radice arriva vuota, il che lascerebbe relativo il percorso dello slot — risolto rispetto a qualunque directory in cui il processo si trovi quando i byte vengono scritti, e con la cache collocata in un punto che nessuno ha scelto.

Viene rifiutato anziché risolto, perché uno slot scritto nel posto sbagliato è peggio di nessuno slot: le letture successive guardano in quello giusto, non trovano nulla e acquisiscono di nuovo, quindi ciò che vedresti è una cache che sembra non contenere mai nulla, e nient’altro che indichi il perché.

Messaggio emesso. Si apre con la frase propria della condizione, e segue ciò che identifica l’artifact:

cacheslot: empty workspaceRoot (kind=<kind> url=<url> chart=<chart> version=<version>) (cacheslot: workspaceRoot vuoto (con kind, url, chart e version indicati))

Come risolvere: nulla nei tuoi file di entità causa questo e nessuna modifica a ciò che scrivi lo elimina — la radice del workspace è fornita da qualunque cosa stia guidando il build, non scritta in un catalogo. Esegui il build dall’interno del workspace, così che la radice venga individuata anziché passata come niente. Dove guidi il compilatore da un software tuo, passa la radice del workspace in modo esplicito; un chiamante che vuole davvero la cache relativa alla directory corrente passa un singolo punto, che viene accettato e lo dichiara deliberatamente.

A value would place a cached file outside the cache (Un valore collocherebbe un file in cache fuori dalla cache)

Un’entità in cache e un artifact sorgente in cache vivono ciascuno in uno slot che la cache nomina per esso, e quello slot è composto a partire da valori: il riferimento dell’entità e la versione in cui si è risolta, oppure il tipo, url, chart, module_subdir, la versione e il digest di una sorgente. Ogni valore nomina una posizione nella struttura. Questa condizione segnala un valore che sposterebbe ciò che viene scritto per esso in un punto diverso dalla posizione che nomina — accanto a un altro slot, o del tutto fuori dalla cache — e lo rifiuta prima che lì venga scritto o letto qualsiasi cosa.

La maggior parte di quei valori arriva da un punto che la cache non controlla: un corpo servito da un registry, un record riletto dal disco, una coordinata scritta dall’autore di una Recipe o di una FeatureRecipe. Una versione che è un percorso anziché una versione, un percorso url o un module_subdir che risale oltre la propria posizione, e un riferimento che si risolve in una directory formata da soli punti vengono ciascuno rifiutati qui. Un valore che nomina una sola directory — e un percorso url o un module_subdir che resta alla propria posizione o al di sotto — non viene toccato.

Un module_subdir che risale viene rifiutato prima che venga recuperato qualsiasi cosa. Per una sorgente git-repository lo stesso valore nomina anche la directory del repository che il pull archivia, e uno che risale oltre il repository farebbe leggere al pull i file accanto al suo checkout. Quindi il pull giudica module_subdir prima di recuperare il repository, e rifiuta un valore che risale con questa condizione, citandolo sotto la sua chiave: non viene recuperato nulla, e non viene letto nulla accanto al checkout. Una barra rovesciata al suo interno viene letta come separatore, come la legge un percorso Windows, quindi ..\shared viene rifiutato su ogni macchina anziché essere letto da accanto al checkout su una sola; un separatore all’inizio o alla fine del valore viene eliminato, quindi /charts/app nomina charts/app.

Messaggio emesso. Si apre con la frase propria della condizione, poi il valore così come è stato scritto sotto la chiave con cui è stato scritto, e il rimedio:

a value a cache location is built from would place cached files outside the place it names in the cache (version "../../../etc" for entity "demo/app/web"). a version, a name, a kind or a host names one directory of the cache, so it carries no / or \ and is neither . nor ..; a URL path or a module subdirectory may name directories beneath its place but may not climb above it. Correct the value where it was written, or, where a registry served it, ask its publisher to publish a version that carries a well-formed one (un valore a partire dal quale è costruita una posizione della cache collocherebbe i file in cache fuori dal punto che nomina nella cache (la versione indicata per l’entità indicata). una versione, un nome, un tipo o un host nomina una sola directory della cache, quindi non contiene né una barra né una barra rovesciata e non è né il punto singolo né il doppio punto; un percorso URL o una sottodirectory di modulo può nominare directory al di sotto della propria posizione ma non può risalire oltre. Correggi il valore dove è stato scritto, oppure, dove lo ha servito un registry, chiedi a chi lo pubblica di pubblicare una versione che ne porti uno ben formato)

Come risolvere: dove il valore è uno che hai scritto tu — source.version, url o module_subdir di una Recipe o di una FeatureRecipe — correggilo in modo che nomini una sola directory, o un percorso che resta all’interno della propria posizione; il messaggio cita il valore e la chiave da cui è stato letto. Dove lo ha servito un registry, l’entità pubblicata porta una versione o una coordinata che non è tale, cosa che nessuna tua modifica può correggere: il messaggio nomina ciò che è stato recuperato, e il rimedio spetta a chi la pubblica.

Diverse operazioni scrivono o rimuovono file propri, in posizioni che determinano da sé anziché in posizioni che hai nominato tu: la directory di output di un build e ogni file che vi scrive, e la directory .trace che un build tracciato sostituisce; il lockfile di una Release, e il registro di fiducia dei plugin accanto a esso, che un pull scrive; il file entity.lock accanto a un’entità, che aggrega pin scrive, e che un pull che fissa sorgenti scrive accanto a ogni entità che fissa; il file .aggrega-config.yaml del workspace, quando un comando scrive la configurazione del workspace; la cache degli artifact e ogni suo sottoalbero, che un pull riempie e che aggrega cache clear e aggrega cache prune svuotano; i bundle di firma che un pull conserva in quella cache per ogni artifact di cui ha verificato la firma; le bozze che aggrega import scrive; le entità Plugin che aggrega plugin gen-catalog scrive sotto la propria directory di output; e il marcatore .aggrega/active-release che il server di linguaggio dell’editor scrive quando viene registrata una Release predefinita, e la directory .aggrega che lo contiene. Lo stesso vale qualunque sia la superficie che ha avviato l’operazione — la riga di comando, il server di linguaggio dell’editor o gli strumenti di un assistente. Il confine del workspace enuncia la regola che qui si applica, e i percorsi che escono dal workspace di proposito.

Ciascuna di queste posizioni ha una directory entro cui deve restare, e quale sia dipende dalla directory sotto cui l’operazione la compone:

  • Il workspace, per tutto ciò che viene composto al suo interno. È il caso abituale, e vale anche per una directory che hai nominato e che si trova all’interno del workspace. dist e .trace di un build sono sempre composti qui, sotto la radice del workspace, da qualunque cartella venga eseguito il build, e così anche le bozze di un import che non nomina alcuna directory di output.
  • Una directory che hai nominato e che si trova fuori dal workspace, per tutto ciò che viene composto al di sotto: la directory di output che passi a aggrega plugin gen-catalog o a aggrega import; la directory di una Release che nomini, o che la configurazione del workspace nomina, che si trova fuori dal workspace, per il lockfile e il registro di fiducia accanto a essa; e la directory di un’entità che nomini a aggrega pin, o una directory di catalogo che nomini con --catalog o che la configurazione elenca sotto catalog_dirs, per il file entity.lock accanto a ogni entità lì presente. La directory stessa viene usata come l’hai nominata — una che è un link viene scritta attraverso il link, dove punta — e ciò che viene scritto al di sotto resta al suo interno.
  • La directory della cache degli artifact stessa, per tutto ciò che viene scritto nella cache al di sotto e per tutto ciò che aggrega cache clear e aggrega cache prune vi rimuovono — tanto la .aggrega/cache predefinita quanto un artifact_cache_dir che la configurazione scrive risalendo oltre la radice del workspace (../shared-cache). Una delle directory proprie della cache, o un file al suo interno, che sia un link che porta fuori dalla directory della cache viene rifiutato anche dove porta altrove all’interno del workspace, così che nulla di ciò che viene scritto nella cache, e nulla di ciò che un clear o un prune rimuove, finisca su un file al di fuori di essa. Dove si trovi la directory della cache stessa viene giudicato per primo: una scritta all’interno della radice del workspace viene seguita ovunque porti all’interno del workspace e rifiutata, vincolata al workspace, dove porta fuori da esso; una scritta risalendo oltre la radice del workspace viene usata come l’hai nominata, scritta attraverso il link fino a dove punta, se è un link.

Ciascuna di queste posizioni viene controllata prima che vi venga scritto o rimosso qualsiasi cosa. La parte più profonda del percorso che esiste, con ogni link simbolico lungo il cammino seguito, deve essere la directory entro cui deve restare o trovarsi al di sotto di essa. Un link in qualsiasi punto del cammino che porti fuori da quella directory — una dist collegata a una directory altrove, un lockfile collegato a un file in un altro progetto, una .aggrega/cache collegata a una directory condivisa con altro lavoro, una directory sotto una directory di output di gen-catalog collegata a un altro punto — farebbe finire la scrittura o la rimozione al di fuori, quindi l’operazione invece si ferma, e quel percorso resta esattamente com’era. Conta soprattutto per un build: svuotare e riscrivere una directory di output che è un link cancellerebbe e riscriverebbe altrimenti una directory in un altro punto della macchina.

Un link che non porta da nessuna parte viene trattato per ciò che è — non qualcosa che esiste — quindi viene controllata la directory che lo contiene. Dove un link del genere si trova proprio alla fine di un percorso che l’operazione sta per creare, il file verrebbe creato dove punta il link, quindi viene controllato anche il punto a cui punta. Un link che punta a un punto all’interno della directory entro cui il percorso deve restare viene seguito come al solito.

Messaggio emesso. Si apre con la frase propria della condizione, poi il percorso che l’operazione stava per scrivere o rimuovere — writing o removing dice quale dei due — la directory entro cui deve restare, il link che incontra lungo il cammino e il punto a cui quel link porta, poi il rimedio. Un build la cui dist è un link che porta fuori dal workspace viene fermato alla prima cosa che toccherebbe, lo svuotamento dell’output precedente:

a path this operation writes or deletes leads through a link out of the directory it must stay inside (removing <workspace>/dist/boundaries, which must stay inside <workspace>, the link <workspace>/dist leads to <elsewhere>/dist-target). nothing was written to or removed from that path. Remove the link, or make it lead to a place inside <workspace>, and run the operation again (un percorso che questa operazione scrive o elimina porta, attraverso un link, fuori dalla directory entro cui deve restare (rimozione del percorso indicato, che deve restare all’interno del workspace indicato; il link indicato porta alla destinazione indicata). nulla è stato scritto in quel percorso o rimosso da esso. Rimuovi il link, oppure fallo portare a un punto all’interno del workspace indicato, ed esegui di nuovo l’operazione)

La diagnostica non porta alcuna categoria: a essere in errore è la disposizione su disco, non un documento che hai scritto.

Come risolvere: rimuovi il link che il messaggio nomina ed esegui di nuovo l’operazione, così che crei una vera directory o un vero file in quel punto; oppure fai portare il link a un punto all’interno della directory che il messaggio nomina, dove viene seguito. Nulla nei tuoi file di entità causa questo e nessuna modifica a ciò che scrivi lo elimina.

A name the operation writes holds a part Windows cannot hold (Un nome che l’operazione scrive contiene una parte che Windows non può contenere)

Su Windows, alcuni nomi non raggiungono un file così come sono scritti. Un nome che Windows riserva a un dispositivo — CON, PRN, AUX, NUL, CONIN$, CONOUT$, da COM0 a COM9 e da LPT0 a LPT9, e i nomi COM e LPT scritti con un uno, un due o un tre in apice — nomina il dispositivo anziché un file, con qualsiasi combinazione di maiuscole e minuscole e qualunque estensione lo segua, quindi nul, Aux.yaml e com1.txt sono tutti dispositivi. E una parte di un percorso che termina con un punto o uno spazio è una parte che Windows può troncare anziché conservarla così come è scritta. Scrivere un nome del genere metterebbe i suoi byte in un punto diverso dal file che nomina.

Perciò, quando un’operazione sta per scrivere sotto una directory, su una macchina Windows, un nome che non ha scelto da sé, un nome che contiene una parte del genere viene rifiutato prima che venga scritto qualsiasi cosa: una voce dell’archivio che un artifact sorgente o un’entità del catalogo porta con sé, quando la cache dispone l’archivio per la lettura; un file che un build renderizza nella sua directory di output; una bozza che un importatore restituisce ad aggrega import, in un’esecuzione di prova come in una scrittura; e il documento che aggrega edit-document riscrive, qualunque superficie abbia chiesto la modifica. Ogni parte del nome viene giudicata, con una barra rovesciata letta come separatore, come la legge Windows — quindi aux/x.yaml viene rifiutato per la sua directory aux, report. per il suo punto finale e .. \evil.yaml per la sua prima parte, due caratteri punto e uno spazio. Un insieme rifiutato per un solo nome non scrive nessuno degli altri: un archivio non viene disposto, l’output di un build non viene svuotato né scritto, e nessuna bozza raggiunge il disco.

Su Linux e macOS gli stessi nomi vengono scritti così come sono nominati, e questa condizione non scatta mai. Un nome che risale fuori dalla directory sotto cui viene scritto è un errore diverso, rifiutato su ogni piattaforma con il messaggio proprio di quell’operazione prima che venga interpellata questa condizione.

Messaggio emesso. Si apre con la frase propria della condizione, poi il nome, la parte che Windows non può contenere e la directory sotto cui il nome doveva essere scritto, poi il rimedio:

a name this operation writes holds a path segment Windows cannot hold as written (the name "aux/x.yaml", its segment "aux", beneath <directory>). It was not written. Windows reserves device names such as CON, PRN, AUX, NUL, COM1 and LPT1, in any letter case and whatever extension follows, and does not hold a segment ending in a full stop or a space as written; rename that segment where the name is produced (un nome che questa operazione scrive contiene un segmento di percorso che Windows non può contenere così come è scritto (il nome, il suo segmento e la directory indicati). Non è stato scritto. Windows riserva nomi di dispositivo come CON, PRN, AUX, NUL, COM1 e LPT1, con qualsiasi combinazione di maiuscole e minuscole e qualunque estensione segua, e non conserva così come è scritto un segmento che termina con un punto o uno spazio; rinomina quel segmento dove il nome viene prodotto)

La diagnostica non porta alcuna categoria: il nome proviene da qualunque cosa lo abbia prodotto — chi pubblica un archivio, una Recipe o una libreria, un importatore, il percorso che una modifica nomina — anziché da un unico documento a cui il compilatore attribuisce l’errore.

Come risolvere: rinomina la parte che il messaggio nomina là dove il nome ha origine. Per una voce di archivio, si tratta dell’artifact sorgente o dell’entità pubblicati, che solo chi li pubblica può cambiare. Per un file renderizzato, è il nome di output che gli dà una Recipe o un’ArtifactLibrary; per una bozza, l’importatore che l’ha nominata; per una modifica, il percorso del documento. Nulla della macchina Windows rende il nome utilizzabile così come è scritto.

Condizioni che non arrestano una build

Ogni condizione descritta sopra arresta un build. Alcune condizioni portano un codice breve e un messaggio propri senza mai arrestarne uno, e sono catalogate qui così che un codice che hai in mano si risolva sempre in qualcosa, da qualunque pagina tu sia arrivato.

Si dividono in quattro tipi, e vale la pena conoscerne la differenza prima di andare in cerca di una correzione.

  • Un avviso. Il build lo segnala e prosegue, e l’output renderizzato è lo stesso che tu intervenga o meno. Ciascuno è descritto per intero in warnings.md — che cosa lo fa scattare, in quale punto della compilazione viene letto, che cosa stampa e che cosa fare al riguardo — e le voci seguenti indicano quale sezione, anziché ripeterlo qui.
  • Una condizione che l’editor assorbe. Riceve risposta dall’integrazione dell’editor stessa e non raggiunge né l’output di un build né una diagnostica.
  • Una salvaguardia dietro un rifiuto precedente. La regola che protegge è fatta rispettare prima di essa da una condizione che arresta davvero, quindi un build incontra prima quella precedente.
  • Un rifiuto su un comando che non è un build. È un arresto netto con un rimedio reale — termina il comando che lo ha incontrato, e nulla viene pubblicato, scritto o modificato — ma nessuna fase della compilazione lo raggiunge, quindi nessun build lo segnala. Pubblicare o firmare un artifact, fissare gli input di un’entità, aggiungere un registry, modificare un documento, trasformare la descrizione di una sorgente esterna in file di authoring in bozza e verificare un intero catalogo — per la sua correttezza o rispetto alle convenzioni di pubblicazione — sono i punti in cui li si incontra, e ogni voce dice a quale comando appartiene e chi detiene la correzione.

An annotation binding declares one path in both pillar lists (Un binding di annotazione dichiara uno stesso percorso in entrambi gli elenchi dei pilastri)

Un avviso. Un binding di annotazione del Manifest nomina lo stesso percorso in notazione puntata sia nel suo elenco maps.infra sia nel suo elenco maps.values. Dichiarare la sovrapposizione è legittimo e il compilatore non la sorveglia: il criterio di spareggio dell’instradamento invia in modo deterministico il percorso attraverso infra, il che rende il lato values di quel percorso irraggiungibile dall’Aggregate.

Il suo messaggio inizia così:

annotation binding declares one path in both pillar lists (il binding di annotazione dichiara uno stesso percorso in entrambi gli elenchi dei pilastri)

È ciò che ti avvisa prima che un build incontri l’arresto descritto sopra in «An annotation routes through a pillar its authoring side may not use (Un’annotazione è instradata attraverso un pilastro che il suo lato di redazione non può usare)» — l’avviso è la superficie che arriva prima, quell’arresto è quella che fa rispettare la regola. Il lint è descritto in «Binding-map-overlap lint (Lint di sovrapposizione delle mappe del binding)» in warnings.md.

An attachment name is one edit from a declared slot (Un nome di associazione è a una modifica di distanza da uno slot dichiarato)

Un avviso. Un componente associa una Feature sotto un nome che non è uno degli slot dichiarati dal suo tipo ma che si trova a una sola modifica di distanza da uno di essi — la struttura che assume un refuso nel nome di uno slot. Un’associazione sotto un nome che nessuno slot dichiara è legittima, quindi nulla si arresta; ciò che l’avviso nomina è la conseguenza, cioè che l’associazione è un’associazione libera anziché il riempimento dello slot che intendevi, e lo slot resta vuoto. Su una connessione lo stesso refuso non è legittimo e provoca invece un arresto, che nomina lo slot vicino; vedi «A connection carries an attachment under a name its socket declares no slot for (Una connessione porta un’associazione sotto un nome per cui il suo socket non dichiara alcuno slot)». Dove la Feature dell’associazione soddisfa il selector: dello slot vicino, l’avviso non viene sollevato: quell’abbinamento è giudicato dall’arresto descritto in «An attachment written under another name fits a slot its component leaves empty (Un’associazione scritta sotto un altro nome si adatta a uno slot che il suo componente lascia vuoto)», che lo segnala quando lo slot resta vuoto.

Il suo messaggio inizia così:

attachment name is a near miss for a declared slot (il nome dell’associazione è una quasi corrispondenza con uno slot dichiarato)

Descritto in «Attachment-slot near-miss lint (Lint di quasi corrispondenza degli slot di associazione)» in warnings.md, con la soglia di abbinamento e ciò che deliberatamente non intercetta.

A uses: socket name is one edit from a declared socket (Un nome di socket è a una modifica di distanza da un socket dichiarato)

Un avviso. Il blocco uses: proprio di un componente nomina un socket che il suo tipo non dichiara ma che si trova a una sola modifica di distanza da uno di essi. Uno sviluppatore possiede la topologia che l’Aggregate dichiara e può nominare un socket che il catalogo non aveva previsto, quindi un nome di socket che il tipo non dichiara è legittimo su quella superficie e nulla si arresta. Ciò che l’avviso nomina è la conseguenza: il nome scritto male traccia una propria connessione ad hoc, senza selettore né contratto per arco, mentre il socket che intendevi resta non cablato.

Il suo messaggio inizia così:

uses socket name is a near miss for a declared socket (il nome del socket uses è una quasi corrispondenza con un socket dichiarato)

Descritto in «Uses-socket near-miss lint (Lint di quasi corrispondenza dei socket uses)» in warnings.md. Le due superfici vicine in cui un nome di socket assente dallo usesSchema dell’entità proprietaria provoca un arresto sono trattate sopra in «uses: socket not declared in the owning entity’s usesSchema (Socket non dichiarato nello schema dei socket dell’entità proprietaria)».

A Recipe publishes a provides key its Component does not declare (Una Recipe pubblica una chiave che il suo Component non dichiara)

Un avviso. La Recipe legata a un componente pubblica sotto provides: una chiave che il tipo del componente non dichiara nel suo contratto spec.schema.provides:. Pubblicare più di quanto il Component dichiari è legittimo e resta legittimo — il contratto richiede il sottoinsieme e consente il soprainsieme. Ciò che l’avviso nomina è una conseguenza invisibile da entrambi i lati: un consumatore che legge attraverso un arco uses: vede il contratto dichiarato della destinazione, non qualunque cosa emetta la sua Recipe, quindi una chiave non dichiarata non viene consegnata e un template consumatore che la legge viene renderizzato vuoto.

Il suo messaggio inizia così:

Recipe publishes a provides key its Component does not declare (la Recipe pubblica una chiave provides che il suo Component non dichiara)

Il caso opposto non è un avviso: un Component che dichiara una chiave che la sua Recipe non pubblica lascia il contratto non soddisfatto e provoca un arresto. Descritto in «Undeclared-provides-key lint (Lint delle chiavi provides non dichiarate)» in warnings.md.

A declared parameter is read by nothing (Un parametro dichiarato non è letto da nulla)

Un avviso. Un Aggregate dichiara una voce sotto spec.parameters: e nessun riferimento {{ .parameters.<key> }} nel testo proprio di quell’Aggregate la legge, quindi, qualunque cosa una Release fornisca per essa, l’output renderizzato è lo stesso. Il compilatore non sorveglia quali regolazioni un autore espone, e un parametro può legittimamente essere dichiarato prima del riferimento che lo leggerà, quindi questo dà un avviso anziché arrestare.

Il suo messaggio inizia così:

declared parameter is read by no reference in the Aggregate (il parametro dichiarato non è letto da alcun riferimento nell’Aggregate)

Descritto in «Unread declared-parameter warnings (Avvertimenti sui parametri dichiarati non letti)» in warnings.md, incluso il motivo per cui un valore predefinito non è un’esenzione e quali riferimenti la lettura può e non può vedere.

A provider binding names a capability no plugin the build reads serves (Un binding di provider nomina una capacità che nessun plugin letto dalla build serve)

Un avviso. Una voce plugins.providers nomina una capacità e nessun plugin, e nessuno dei plugin provider letti dalla build — nelle directory di catalogo, all’interno del compilatore o tra quelli che il lockfile registra — serve quella capacità. È la struttura che assume una capacità scritta male, e una voce del genere non viene letta da nulla: un binding viene consultato solo quando una Recipe chiede la sua capacità, e uno che non nomina alcun plugin non seleziona nulla che la risoluzione della capacità non selezionerebbe senza di esso.

Dà un avviso anziché arrestare perché il build non può esserne sicuro. I binding vengono scritti una sola volta per l’intero workspace, mentre un build riguarda una sola Release, quindi il plugin che serve la capacità può essere uno che solo un’altra Release legge. La voce che nomina un plugin viene giudicata diversamente, e si arresta dove è sicuramente sbagliata — vedi sopra «A plugins.providers binding names a plugin that does not serve the capability (Un binding nomina un plugin che non serve la capacità)».

Il suo messaggio inizia così:

plugins.providers entry names a capability no provider-rendering plugin the build reads serves (la voce plugins.providers nomina una capacità che nessun plugin di rendering dei provider letto dalla build serve)

e prosegue con la capacità, e con una capacità servita a una modifica di distanza, dove ce n’è una. Descritto in «Provider-binding unserved-capability warning (Avvertimento di capacità non servita del binding di provider)» in warnings.md.

An editor position falls outside the document (Una posizione dell’editor cade fuori dal documento)

Una condizione che l’editor assorbe. Le funzionalità dell’editor che dipendono da dove si trova il cursore — vai alla definizione, hover, completamento — individuano prima il cursore all’interno della struttura analizzata del documento. Questa condizione è ciò che quel passaggio segnala quando la posizione indirizza una riga che il documento non ha, il che accade in modo transitorio mentre una modifica è in corso e la posizione inviata dall’editor è stata misurata su un testo che il documento ha già superato.

Il suo messaggio è:

position out of range (posizione fuori intervallo)

Non raggiunge alcun build né alcuna diagnostica. Ogni funzionalità che può incontrarla risponde senza alcun risultato anziché far emergere un errore, che è il comportamento richiesto dal protocollo dell’editor: una richiesta a cui non si può rispondere non restituisce nulla, e l’editor chiede di nuovo dopo il tasto successivo.

Non c’è nulla da correggere nei tuoi file, e nulla compare in un build. Una funzionalità che resta senza risposta anziché riprendersi alla modifica successiva merita di essere segnalata come difetto.

The schema-merge step’s own input guard (La protezione dell’input propria della fase di unione degli schemi)

Una protezione che un build non raggiunge. Quando un Component o una Feature ne estende un altro ed entrambi dichiarano degli schemi, quegli schemi vengono combinati in uno solo. La libreria che esegue la combinazione rifiuta un input che non può unire strutturalmente:

merger: invalid merge input (merger: input di unione non valido)

Appartiene alla fase di combinazione, che un build raggiunge davvero ogni volta che un’entità che ne estende un’altra e la sua base dichiarano entrambe degli schemi. Ciò da cui protegge è il ricevere una catena vuota, o una voce della catena il cui schema manca — e il chiamante non può passarle né l’una né l’altra: assembla la catena solo a partire da schemi che ha già trovato presenti, e combina solo quando quella catena risulta non vuota.

La protezione resta perché è il rifiuto di un input malformato da parte di una libreria esportata. Rimuoverla non eliminerebbe alcun arresto che un build possa raggiungere; trasformerebbe un rifiuto chiaro in un crash per un chiamante esterno al compilatore che passasse un input del genere, il che è strettamente peggiore.

La catena in sé non riguarda questa fase. Una catena che forma un ciclo e una catena che supera il limite di profondità vengono rifiutate dall’unica visita di extends: prima che qualsiasi schema venga combinato — vedi sopra «Cyclic extends chain (Catena extends ciclica)» e «An extends: chain runs past the depth bound (Una catena di estensione supera il limite di profondità)».

È catalogata perché è dichiarata e porta un codice proprio, così un codice che hai in mano si risolve. Nulla di ciò che puoi scrivere ne produce una, e incontrarne una significherebbe che la disposizione descritta sopra non vale più — vale la pena segnalarlo come difetto anziché aggirarlo.

An explicit value displaced one an annotation supplied (Un valore esplicito ha sostituito uno fornito da un’annotazione)

Un avviso. L’espansione guidata dalle annotazioni trasforma un’annotazione che un Aggregate o una Release porta in un’associazione di Feature con una configurazione propria. Dove la stessa associazione porta anche una configurazione scritta esplicitamente — sul componente, su un ambito al di sopra di esso o nella Release — il valore esplicito prevale in ogni chiave che entrambi coprono. È la regola voluta e l’output emesso non è sbagliato, quindi il build termina. Ciò che l’avviso nomina è la conseguenza: il contributo dell’annotazione a quella chiave non è più visibile da nessuna parte nell’output, e l’autore che ha scritto l’annotazione potrebbe non sapere che è stato soppresso.

Segnala ogni sostituzione anziché solo quelle che hanno cambiato qualcosa. L’unione sovrascrive il valore soppresso, quindi non resta alcun confronto da fare né nulla che possa dire se i due coincidevano — la registrazione del fatto che una sostituzione è avvenuta è l’intera prova. Viene letto una volta che l’intera cascata delle associazioni e l’espansione sono state combinate, che è il primo punto in cui quella registrazione esiste.

Il suo messaggio inizia così:

annotation contribution overridden by an explicit value (contributo dell’annotazione sovrascritto da un valore esplicito)

e prosegue con l’annotazione che è stata sostituita, poi le coordinate della chiave che l’ha sostituita, poi il punto in cui l’annotazione sostituita è stata scritta. La posizione che lo precede è il documento in cui si trova il rilievo e la chiave al suo interno:

<file> at <authored key>: annotation contribution overridden by an explicit value ("<annotation-key>", component "<component>", attachment "<attachment>", pillar "<pillar>", key "<the key at issue>", annotation declared at "<where the annotation was written>") (nel file e alla chiave indicati: contributo dell’annotazione sovrascritto da un valore esplicito (annotazione, componente, associazione, pilastro, chiave in questione e punto in cui l’annotazione è stata dichiarata indicati))

Due di quei valori sono facili da fraintendere. Il valore component viene indicato solo dove la voce che sostituisce ha un componente: una voce scritta per un intero ambito non ha un componente proprio, e nominarne uno che non ha mai avuto manderebbe un lettore a una chiave che nessuno ha scritto. E annotation declared at nomina il punto in cui è stata scritta l’annotazione sostituita, che è l’ambito da cui è stata ereditata ovunque non sia stata scritta sul componente che l’ha sostituita — quindi non è la chiave del componente ripetuta sotto un’altra etichetta.

Che cosa fare: nulla, dove il valore esplicito è quello che intendevi. L’avviso esiste perché la precedenza sia una scelta anziché una sorpresa. Dove non è quello che intendevi, ci sono due modi per uscirne e differiscono per portata. Elimina la voce esplicita, e il valore dell’annotazione arriva fino a quella chiave. Oppure rimuovi l’annotazione dal componente o dall’ambito che la porta, e non viene dato alcun contributo — il che riguarda anche ogni altra chiave che quell’annotazione fornisce. Dove servono entrambi i lati ma per chiavi diverse, restringi quello dei due che arriva più lontano del previsto, così che non si sovrappongano più.

A connection crosses between two different providers’ assembled outputs (Una connessione attraversa gli output assemblati di due provider diversi)

Dove le due estremità di una connessione di dipendenza vengono assemblate in output diversi, un provider che annuncia il collegamento tra confini la cabla in modo nativo — pubblicando un riferimento sul lato che produce e risolvendolo su quello che consuma. Quel cablaggio è scritto nel vocabolario proprio di un provider, e un provider non può risolvere un riferimento pubblicato da un altro. Perciò una connessione le cui due estremità vengono renderizzate tramite provider diversi non viene cablata da nessuno dei due.

Questo dà un avviso e non arresta il build. La connessione porta ancora il suo valore: il contratto di iniezione convoglia lo scalare del lato che produce fino al lato che consuma esattamente come fa altrove, quindi ciò che resta è una connessione funzionante cablata nel modo ordinario anziché una connessione interrotta. Ciò che il rilievo ti dice è che il cablaggio nativo che potevi aspettarti non è avvenuto — e l’output è invariato che tu intervenga o meno.

Basta che un provider annunci il collegamento perché venga segnalato. Non serve che lo dichiarino entrambe le estremità: una sola dichiarazione significa che il cablaggio nativo era atteso ed è impossibile, e l’autore che ha associato quel provider è colui che lo voleva. Richiedere entrambe le dichiarazioni non direbbe nulla nella consueta Release mista, in cui un provider collega e l’altro no, che è proprio il caso a cui questo serve.

Dove sono state collocate le estremità non conta. Un output assemblato è identificato dal suo percorso e dal suo provider insieme, quindi due estremità i cui provider differiscono si trovano sempre in output diversi, qualunque sia la loro collocazione. Ciò che viene letto sono i due provider e le loro due dichiarazioni.

Viene segnalato una volta per ciascuna connessione di questo tipo, posizionato sul documento e sulla chiave in cui la connessione è stata scritta.

Messaggio emesso, che inizia con l’estremità remota e poi nomina il socket e il provider di ciascuna estremità:

cross-boundary link between endpoints rendered by different providers is not supported ("<target-component>", socket "<socket>", consumer provider "<provider>", target provider "<provider>") (il collegamento tra confini fra estremità renderizzate da provider diversi non è supportato (componente di destinazione, socket, provider del consumatore e provider di destinazione indicati))

Come risolvere: dove il valore scalare che la connessione già porta è sufficiente, non serve fare nulla — si tratta di una notifica anziché di un guasto. Dove si vuole il cablaggio nativo, le due estremità devono essere renderizzate tramite un solo provider: sposta un’estremità in un confine che passa per il provider dell’altra, oppure servi entrambe le capacità con uno solo. Dove nessuna delle due cose è possibile, la forma che porta il valore è quella che la Release ha, e la connessione funziona.

A command-line plugin runner was built without a way to find plugins (Un esecutore di plugin da riga di comando è stato costruito senza un modo per trovare i plugin)

Un plugin che contribuisce un comando da terminale viene eseguito da un componente che deve prima trasformare il riferimento del plugin in byte. Questa condizione segnala che quel componente è stato costruito senza la parte che esegue la trasformazione, quindi non c’è alcun percorso dal riferimento a qualcosa da eseguire.

Riguarda un comando da terminale anziché un build, quindi nessuna fase della compilazione la raggiunge: viene sollevata dove viene smistato un comando installato, e la risposta che produce è la mancata partenza di quel comando anziché un arresto in un build.

Nessun percorso nello strumento da riga di comando distribuito può sollevarla. Ogni punto in cui lo strumento costruisce quel componente fornisce il meccanismo di ricerca, quindi la protezione scatta solo dove qualcos’altro lo costruisce e tralascia il meccanismo di ricerca.

Messaggio emesso, che è la frase propria della condizione:

cliplugin: no plugin resolver configured (cliplugin: nessun resolver di plugin configurato)

Come risolvere: nulla nei tuoi file di entità causa questa condizione, e nulla che tu possa scrivere in un catalogo o in un workspace la elimina. Dove esegui lo strumento da riga di comando pubblicato, questa non è una condizione che puoi raggiungere — un comando installato che non parte sta segnalando qualcos’altro, e il messaggio che ha stampato è quello da leggere. Dove incorpori l’esecutore di plugin in un software tuo, fornisci, quando lo costruisci, il meccanismo di ricerca che risolve un riferimento di plugin nei suoi byte.

A registry alias is already bound to another host (Un alias di registry è già legato a un altro host)

Un rifiuto all’aggiunta di un registry al workspace, non su un build. Un alias è un nome breve che seleziona una voce di registry, quindi è univoco tra le voci. Registrare un alias già detenuto da un host diverso viene rifiutato anziché consentire che oscuri il legame esistente, il che cambierebbe silenziosamente dove punta ogni riferimento che usa quell’alias.

Aggiungere di nuovo lo stesso host con il suo alias esistente non è un conflitto — aggiorna la voce sul posto, che è ciò che fa rieseguire il comando per cambiare le altre impostazioni di un host.

Messaggio emesso, che nomina l’alias e l’host che già lo detiene:

workspaceconfig: registry alias "<alias>" is already used by host "<host>"; choose a different alias or address that host directly: registry alias is already used by another host (workspaceconfig: l’alias di registry indicato è già usato dall’host indicato; scegli un alias diverso o indirizza direttamente quell’host: l’alias di registry è già usato da un altro host)

Come risolvere: la correzione spetta all’operatore, dalla riga di comando. Dai al nuovo registry un alias diverso, oppure lascialo senza alias e fai riferimento a esso tramite l’host. Dove intendevi spostare l’alias sul nuovo host, rimuovilo prima dalla voce che il messaggio nomina in .aggrega-config.yaml — il rifiuto esiste perché spostare un alias sia qualcosa che fai di proposito anziché un effetto collaterale dell’aggiunta di un registry.

A registry serves a trust document that cannot be read as one (Un registry serve un documento di fiducia che non può essere letto come tale)

Un rifiuto all’aggiunta di un registry, non su un build. Un registry può pubblicare le identità di firma con cui si aspetta che gli artifact siano firmati, così che l’aggiunta del registry possa fissarle anziché costringere un operatore a trascriverle. Questa condizione segnala un registry che ha risposto con un documento che non è utilizzabile come policy di fiducia.

È un rifiuto netto proprio perché l’endpoint ha risposto. Un registry che non pubblica nulla è un esito ordinario e previsto, che viene tollerato; uno che pubblica qualcosa di illeggibile è una configurazione errata, e non fissare nulla a partire da esso lascerebbe il registry silenziosamente non fissato pur sembrando che lo fosse stato.

Qui vengono segnalate tre strutture: un contenuto che non si decodifica affatto, incluso un documento che porta un campo che il formato non definisce; una voce di identità che non nomina né un’identità esatta né un pattern; e una voce di identità senza emittente. Le ultime due vengono rifiutate perché una voce del genere non può mai corrispondere a una firma, quindi indebolirebbe il fissaggio pur sembrando rafforzarlo.

Messaggi emessi. Contenuto che non si decodifica:

registrytrust: advertised trust config is malformed: <what the decoder reported> (registrytrust: la configurazione di fiducia annunciata è malformata, seguita da quanto segnalato dal decodificatore)

una voce di identità senza nulla su cui trovare corrispondenza:

registrytrust: advertised trust config is malformed: <list>[<index>]: an identity entry must set identity or identity_regexp (registrytrust: la configurazione di fiducia annunciata è malformata: nell’elenco e all’indice indicati, una voce di identità deve impostare identity o identity_regexp)

e una senza emittente:

registrytrust: advertised trust config is malformed: <list>[<index>]: an identity entry must set issuer (registrytrust: la configurazione di fiducia annunciata è malformata: nell’elenco e all’indice indicati, una voce di identità deve impostare issuer)

Ciascuno è racchiuso dal comando che lo ha incontrato:

aggrega registry add: <the message above> (aggrega registry add: il messaggio riportato sopra)

Come risolvere: la correzione spetta a chi gestisce il registry, non a te — riporta loro il messaggio, perché nomina la voce esatta e ciò che le manca. Per procedere nel frattempo, aggiungi il registry senza fissare la sua policy annunciata e fornisci tu stesso le identità o la chiave; il comando le accetta direttamente, che è anche ciò che fai per un registry che non pubblica alcuna policy.

A registry publishes no trust document (Un registry non pubblica alcun documento di fiducia)

Un esito ordinario e previsto anziché un guasto, e non arresta nulla. Un registry può pubblicare le identità di firma che si aspetta, e la maggior parte non lo fa. Quando gliene viene chiesto uno, un registry del genere risponde di non averne, e l’aggiunta del registry prosegue — l’esito viene segnalato come notifica e le identità vengono invece fissate manualmente.

È deliberatamente distinto da un registry che non è stato possibile raggiungere. Questo ha risposto; la risposta è stata che non pubblica alcuna policy. Tenere separati i due casi è ciò che permette di tollerare un’assenza deliberata mentre un problema di raggiungibilità resta visibile come tale.

Segnalato come notifica, che nomina il registry, ciò che ha risposto e che cosa fare invece:

Notice: <host> publishes no trust policy (HTTP 404); pin its trust by hand with —identity or —key (Notifica: l’host indicato non pubblica alcuna policy di fiducia (HTTP 404); fissa manualmente la sua fiducia con —identity o —key)

La condizione sotto cui è registrato è registrytrust: registry advertises no trust config.

L’hub ufficiale è l’eccezione: porta con sé una baseline integrata, quindi dove non pubblica alcun documento viene fissata invece quella baseline, e la notifica dice che cosa ha risposto l’hub e che la baseline viene usata al suo posto, anziché chiederti di fissare delle identità.

Come risolvere: non c’è nulla di guasto. Se vuoi che le firme di questo registry vengano verificate, fornisci l’identità o la chiave quando lo aggiungi, esattamente come dice la notifica — è il percorso normale per un registry che non pubblica alcuna policy. Se non lo fai, il registry viene aggiunto senza una posizione sulla firma e gli artifact che ne provengono vengono verificati solo quando portano una firma.

A registry is added offline with no trust policy to pin (Un registry viene aggiunto offline senza una policy di fiducia da fissare)

Un rifiuto all’aggiunta di un registry, non su un build. L’aggiunta di un registry è l’unico momento in cui la sua fiducia viene fissata: le identità di firma che annuncia vengono recuperate una sola volta e ogni pull successivo esegue la verifica rispetto a quella copia fissata. Quando il workspace è offline quel recupero non può essere effettuato, quindi al registry non viene mai chiesto nulla. Anziché scrivere una voce che non si fida di nulla — e a cui ogni pull successivo vincolerebbe il registry — l’aggiunta di un registry diverso dall’hub ufficiale viene rifiutata a meno che tu non fornisca personalmente la policy.

Tre casi non vengono rifiutati. Fornire identità o una chiave registra esattamente quelle e non effettua alcun recupero, quindi funziona allo stesso modo offline come online. L’hub ufficiale viene aggiunto sulla sua baseline integrata, che porta con sé che il recupero venga effettuato o meno. E chiedere di non effettuare alcun recupero — --fetch-trust=false — registra la voce a partire dai flag, esattamente come fa online.

Lo si incontra ovunque venga aggiunto un registry: aggrega registry add, aggrega config init --registry <host>, le richieste aggrega/registryAdd e aggrega/configInit di aggrega serve, il cui messaggio di errore riporta il codice breve prima della frase, e gli strumenti di registrazione di aggrega mcp, che eseguono quei comandi. L’inizializzazione di una configurazione non accetta né identità né chiavi, quindi offline può inizializzare solo l’hub; aggiungi invece qualsiasi altro registry con aggrega registry add.

Messaggio emesso, che è la frase propria della condizione:

a registry other than the official hub is not registered offline without a trust policy supplied by hand, because the policy it advertises cannot be fetched; register it once while online, or pin its trust by hand with aggrega registry add <host> --identity <identity>=<issuer> or --key <public-key-file> (un registry diverso dall’hub ufficiale non viene registrato offline senza una policy di fiducia fornita manualmente, perché la policy che annuncia non può essere recuperata; registralo una volta mentre sei online, oppure fissa manualmente la sua fiducia con un’identità e il suo emittente o con un file di chiave pubblica)

racchiuso dal comando che lo ha incontrato e dal registry che nomina:

aggrega registry add: <host>: <the message above> (aggrega registry add: l’host indicato, poi il messaggio riportato sopra)

Come risolvere: registra il registry una volta mentre il workspace è online — passa --offline=false per quell’unica esecuzione, oppure rimuovi l’impostazione offline — così che la sua policy annunciata venga recuperata e fissata; in seguito non c’è nulla da ripetere, poiché i pull successivi eseguono la verifica rispetto alla copia fissata. Dove non puoi andare online, fornisci la policy manualmente: una o più voci --identity <identity>=<issuer> per un registry senza chiave, oppure --key che punta al suo file di chiave pubblica per uno con chiave, ovvero ciò che avresti fissato dal suo annuncio.

A tag is already published with different content (Un tag è già pubblicato con un contenuto diverso)

Un rifiuto alla pubblicazione, non su un build. I byte pubblicati sono congelati: prima che venga caricato qualsiasi cosa, si cerca la versione di destinazione e il digest a cui punta viene confrontato con il digest che produrrebbe il contenuto che si ha in mano. Una versione che punta già a un contenuto diverso viene rifiutata.

Ripubblicare un contenuto identico byte per byte non è un conflitto. I digest corrispondono, non viene caricato nulla e il comando segnala che la versione è già pubblicata — quindi rieseguire una pubblicazione riuscita solo in parte è sicuro, e completa la pubblicazione: la data di pubblicazione che ancora manca alla versione, e la sua firma dove il push firma, vengono allegate, e una versione a cui non manca né l’una né l’altra non riceve nulla, come descrive Completare una pubblicazione lasciata parziale da un push precedente.

Non esiste alcun flag che lo scavalchi. Un contenuto modificato viene pubblicato con una nuova versione, ed è ciò che lascia ai consumatori una versione verso cui spostarsi deliberatamente anziché una versione cambiata a loro insaputa.

Messaggi emessi, che indicano la versione, il digest che contiene e il digest offerto. Pubblicando un’entità del catalogo, che nomina anche il controllo che verifica l’aumento di versione:

aggrega push: <reference>:<version> is already published as <existing digest>; refusing to overwrite with <proposed digest> — publish a new version (aggrega lint —pre-publish verifies the bump): oci: tag already published with different content (aggrega push: la versione indicata è già pubblicata con il digest esistente indicato; rifiuto di sovrascriverla con il digest proposto — pubblica una nuova versione (aggrega lint —pre-publish verifica l’aumento di versione): oci: tag già pubblicato con un contenuto diverso)

e pubblicando un artifact di dati:

aggrega push-artifact: <reference>:<version> is already published as <existing digest>; refusing to overwrite with <proposed digest> — publish a new version: oci: tag already published with different content (aggrega push-artifact: la versione indicata è già pubblicata con il digest esistente indicato; rifiuto di sovrascriverla con il digest proposto — pubblica una nuova versione: oci: tag già pubblicato con un contenuto diverso)

Come risolvere: aumenta la versione e pubblica di nuovo. Per un’entità del catalogo ciò significa metadata.version e la directory per versione in cui si trova l’entità, che si spostano insieme. Prima di farlo, verifica che la modifica sia una che intendevi: il fatto che i due digest differiscano su una versione che ritieni di non aver toccato significa che il contenuto su disco non è il contenuto che è stato pubblicato, e scoprire perché vale più che pubblicarci sopra. Il controllo di pre-pubblicazione nominato nel messaggio confronta una versione con quella precedente ed è il modo per confermare che l’aumento sia corretto.

An entity shares its directory with another entity (Un’entità condivide la propria directory con un’altra entità)

Un rifiuto quando si fissa e quando si pubblica, non su un build. Ogni tipo di entità ha una directory propria tranne i tre che una radice del workspace contiene fianco a fianco: un Aggregate, una Release e un Manifest. Un’entità pubblicata è un unico artifact a un’unica coordinata per ogni versione, e la directory in cui viene scritta lo rispecchia — la fase di pin scrive l’unico file entity.lock per cui una directory ha spazio, e una pubblicazione impacchetta l’entità dalla sua directory. Quindi un’entità di qualsiasi altro tipo con un’altra entità accanto viene rifiutata in entrambi quei momenti: da aggrega pin, da un pull o un push a cui viene chiesto di fissare per conto dell’autore, e da aggrega push, che fissi o meno. Viene rifiutata prima che venga recuperato qualsiasi cosa, e nulla viene scritto.

Una directory che contiene più entità viene comunque caricata, sottoposta al lint, convalidata e compilata. La disposizione viene giudicata solo quando qualcosa viene prodotto dalla directory, che è anche il momento in cui il messaggio può nominare l’entità che si mette di mezzo. Un pull che non fissa non scrive nulla accanto all’entità e non viene rifiutato.

Ciò che conta come entità accanto è qualsiasi altro documento YAML direttamente nella stessa directory il cui kind: è un tipo di entità. I file propri di un chart, un frammento compose, un manifest Kubernetes o un README non sono entità, e una sottodirectory — un chart locale, un albero source/ — non si trova accanto all’entità, qualunque cosa contenga. Di ogni vicino vengono letti solo il tipo e il nome, quindi nulla di ciò che un vicino dichiara può cambiare la risposta.

Il nome della directory non viene giudicato. Un’entità da sola nella sua directory viene fissata e pubblicata alla versione che dichiara ovunque si trovi quella directory; la disposizione <name>/<version>/ che usa il catalogo della libreria standard è una convenzione anziché un controllo.

Messaggio emesso, che nomina l’entità, ogni entità accanto a essa e i file da spostare:

the entity shares its directory with another entity, and an entity of its kind has a directory of its own (Recipe "<name>", beside it: Recipe "<name>" in <file>). remediation: give each entity a directory of its own — move <file> into a directory of its own, together with any file only that entity reads; only the Aggregate, Manifest and Release kinds may share a directory with other entities (l’entità condivide la propria directory con un’altra entità, e un’entità del suo tipo ha una directory propria (la Recipe indicata e, accanto a essa, la Recipe indicata nel file indicato). rimedio: dai a ogni entità una directory propria — sposta il file indicato in una directory propria, insieme a ogni file che solo quell’entità legge; solo i tipi Aggregate, Manifest e Release possono condividere una directory con altre entità)

Come risolvere: sposta ogni entità che il messaggio nomina in una directory propria, portando con sé i file che solo essa legge — un chart locale, un file importato e il file entity.lock se registra i pin di quell’entità — ed esegui aggrega pin su ciascuna che legge una sorgente remota o importa un file, così che ogni lock registri la propria entità. Disporre ciascuna come <kind>/<provider-or-publisher>/…/<name>/<version>/ la mantiene dove il catalogo della libreria standard tiene ogni entità. Una directory di catalogo viene trovata percorrendola, quindi un build sul catalogo renderizza lo stesso output dopo lo spostamento.

An entity kind has no artifact media type (Un tipo di entità non ha un tipo di media dell’artifact)

Un rifiuto alla pubblicazione, non su un build. Ogni tipo di entità pubblicabile ha un tipo di media per ciascuna delle due forme che assume il suo artifact — il solo documento, oppure un archivio del documento e dei file che dichiara — e l’impacchettamento di un’entità lo cerca in base al tipo. Questa condizione segnala un tipo privo di voce.

Nessun build lo raggiunge. L’unico altro punto in cui viene eseguita la stessa ricerca tratta una voce mancante come «questa non è una libreria» e prosegue, quindi lì la condizione non emerge mai.

Messaggio emesso, la frase propria della condizione racchiusa dal comando e dal file che stava impacchettando:

aggrega push: bundle <path>: oci: unknown entity kind for mediatype dispatch (aggrega push: bundle del percorso indicato: oci: tipo di entità sconosciuto per la selezione del tipo di media)

Come risolvere: confronta il campo kind: del file che stai pubblicando con i tipi che stampa aggrega push --list-kinds — un tipo scritto male o non supportato viene segnalato qui, e correggere il campo è l’intero rimedio. Dove il tipo è uno che quell’elenco riporta, si tratta di una lacuna nella toolchain anziché nella tua entità, e vale la pena segnalarla citando il tipo.

A published archive carries an entry Windows cannot use (Un archivio pubblicato porta una voce che Windows non può usare)

Un avviso sollevato quando un’entità viene pubblicata; non arresta mai nulla, e un build non lo solleva. Un’entità che porta con sé file accanto al suo documento viene pubblicata come archivio, e ogni nome che l’archivio contiene — il nome di file del documento dell’entità stesso, poi ogni file che porta con sé — viene giudicato con la regola che l’arresto «A name the operation writes holds a part Windows cannot hold (Un nome che l’operazione scrive contiene una parte che Windows non può contenere)» descritto sopra applica su Windows: una parte che Windows riserva a un dispositivo, con qualsiasi combinazione di maiuscole e minuscole e qualunque estensione la segua, oppure una parte che termina con un punto o uno spazio. Quindi aux/x.yaml lo provoca per la sua directory aux, report. per il suo punto finale, e un documento chiamato con.yaml che importa un file di schema per il suo stesso nome. Un’entità che non porta nulla con sé viene pubblicata come il solo documento, disposto sotto un nome scelto dal prodotto, e un Plugin non pubblica alcun archivio, quindi nessuno dei due lo provoca.

Viene sollevato su ogni piattaforma, e non rifiuta nulla. Un workspace su Windows rifiuta di disporre una voce del genere, sotto quell’arresto, quindi non può usare la versione; l’avviso è il modo in cui chi pubblica lo scopre prima che lo scopra qualcuno su Windows. La pubblicazione, o la sua esecuzione di prova, prosegue o si ferma esattamente come farebbe senza di esso.

Ogni superficie che pubblica un’entità lo solleva, ciascuna nella propria forma. aggrega push, e il suo --dry-run, stampa una riga per voce sullo standard error, ognuna che inizia con warning: . Lo strumento publish-entity dell’assistente risponde con le voci come windows_unusable_entries, e anche il testo della risposta le nomina. aggrega serve risponde ad aggrega/publishEntity con esse come windowsUnusableEntries, e passa le righe di avviso stesse a una richiesta che ha chiesto di essere informata. Ogni risposta omette il campo dove non esiste una voce del genere.

Il suo messaggio inizia così:

an entry this publication carries cannot be used on Windows (una voce che questa pubblicazione porta con sé non può essere usata su Windows)

e prosegue con la voce e la prima delle sue parti che Windows non può contenere, poi il rimedio. Descritto in «A published archive carries an entry Windows cannot use (Un archivio pubblicato porta una voce che Windows non può usare)» in warnings.md.

Come risolvere: rinomina la parte che il messaggio nomina, su disco e ovunque le dichiarazioni dell’entità nominino il file, e pubblica di nuovo. Dove la versione non è destinata a essere usata su Windows, non c’è nulla da cambiare.

Two catalog identities publish to one repository location (Due identità del catalogo pubblicano in una stessa posizione di repository)

Un rifiuto alla verifica di un intero catalogo, non su un build. La destinazione in cui un’entità viene pubblicata è derivata dalla sua identità e convertita in minuscolo, quindi due identità che differiscono solo per maiuscole e minuscole finiscono nello stesso posto. Pubblicarle entrambe lascerebbe i byte di un’entità sovrascritti da quelli dell’altra, e nulla in nessuna delle due entità lo direbbe.

Il controllo viene eseguito sull’intero catalogo in una volta, perché una collisione è una proprietà di una coppia anziché di ciascuna entità presa da sola — nessuna delle due è sbagliata di per sé, e leggere l’una o l’altra isolatamente non mostra nulla.

Messaggio emesso. Si apre con la cornice del controllo del catalogo, poi la frase propria della condizione, poi ogni gruppo in collisione, ciascuno con la posizione condivisa e le identità che la raggiungono:

catalog validation failed: oci: distinct catalog identities map to the same OCI repository location: (convalida del catalogo non riuscita: oci: identità di catalogo distinte corrispondono alla stessa posizione di repository OCI)

  • <location> <- <identity>, <identity>

Come risolvere: rinomina una delle entità che il messaggio nomina, nel suo metadata.name e nella directory che lo rispecchia. Quale rinominare spetta a te; le coppie che differiscono solo per maiuscole e minuscole sono la forma comune, e scegliere una grafia e usarla in modo coerente è ciò che impedisce alla coppia di ripresentarsi. Rinominare è un vero cambiamento dell’identità di un’entità, quindi tutto ciò che fa riferimento al vecchio nome deve spostarsi con essa — è un motivo per risolvere la collisione prima che uno dei due nomi venga pubblicato anziché dopo.

Keyless signing was asked for without the services it needs (La firma senza chiave è stata richiesta senza i servizi di cui ha bisogno)

Un rifiuto alla firma durante la pubblicazione, non su un build. La firma senza chiave non ha una forma offline: ottiene un’identità, fa emettere per essa un certificato di breve durata, registra la firma dove può essere verificata in seguito, e poi scarta la chiave. Ognuno di questi passaggi è uno scambio con un servizio in esecuzione. Questa condizione segnala che l’identità da cui parte il flusso non era disponibile, quindi il flusso viene rifiutato anziché avviato e abbandonato a metà.

La segnalano due forme: nulla di configurato per fornire un’identità, e qualcosa di configurato che non ha prodotto nulla.

Un workspace offline lo segnala diversamente, sotto il rifiuto che copre ogni passaggio di rete, perché il rifiuto avviene prima che venga mai chiesta un’identità.

Messaggi emessi. Nessuna sorgente di identità:

signing: keyless signing requires a live identity provider, Fulcio, and Rekor: an identity token source is required (signing: la firma senza chiave richiede un provider di identità attivo, Fulcio e Rekor: è richiesta una sorgente di token di identità)

e una sorgente che non ha prodotto nulla:

signing: keyless signing requires a live identity provider, Fulcio, and Rekor: an identity token is required (signing: la firma senza chiave richiede un provider di identità attivo, Fulcio e Rekor: è richiesto un token di identità)

Come risolvere: la correzione spetta all’operatore, nel modo in cui viene eseguita la pubblicazione. In una pipeline automatizzata l’identità proviene dalle credenziali proprie della pipeline, quindi questo di solito significa che al job non è stato concesso il permesso che le emette. In un’esecuzione interattiva l’identità proviene dall’accesso, che il comando ti chiederà di effettuare. Dove non vuoi affatto un’identità attiva, firma invece con una chiave in tuo possesso — quel percorso non ha bisogno di nessuno di questi servizi, ed è quello da usare da un ambiente che non può raggiungerli.

An unsigned publish targets a registry or a policy that requires a signature (Una pubblicazione non firmata è destinata a un registry o a una policy che richiede una firma)

Un rifiuto alla pubblicazione, non su un build. Dove è richiesta una firma, il contenuto non firmato non viene pubblicato. Il controllo viene eseguito prima che venga caricato qualsiasi byte, quindi nulla di parziale raggiunge il registry.

Due condizioni, perché un requisito ha due origini e i rimedi differiscono. Una è la posizione propria del registry di destinazione, che si applica a tutto ciò che vi viene pubblicato. L’altra è la policy di firma del workspace, che copre un insieme di tipi di artifact ovunque vengano pubblicati. Quando valgono entrambe, viene segnalata quella del registry, perché nominare la destinazione è la più utile delle due.

Qui non esiste alcun flag che pubblichi contenuto non firmato. Disattivare esplicitamente la firma non allenta il rifiuto — cambia solo il valore predefinito per gli artifact per cui la firma è facoltativa.

La firma viene prodotta prima del caricamento anziché dopo, quindi anche un errore di firma finisce qui e non viene pubblicato nulla.

Messaggi emessi. Il requisito proprio del registry:

aggrega push: registry "<host>" requires signatures; re-run signing the artifact (there is no flag to push unsigned content here): signing: registry requires signatures; refusing to push unsigned content (aggrega push: il registry indicato richiede firme; riesegui firmando l’artifact (qui non esiste alcun flag per eseguire il push di contenuto non firmato): signing: il registry richiede firme; rifiuto di eseguire il push di contenuto non firmato)

quello della policy del workspace, che nomina il tipo che ha fatto rientrare l’artifact nel suo ambito:

aggrega push: the signing policy requires a signature for kind "<kind>"; re-run signing the artifact (there is no flag to push unsigned content here): signing: signing policy requires a signature for this artifact kind; refusing to push unsigned content (aggrega push: la policy di firma richiede una firma per il tipo indicato; riesegui firmando l’artifact (qui non esiste alcun flag per eseguire il push di contenuto non firmato): signing: la policy di firma richiede una firma per questo tipo di artifact; rifiuto di eseguire il push di contenuto non firmato)

e una firma che non è stato possibile produrre, che viene segnalata sotto la condizione del registry e cita l’errore sottostante:

aggrega push: sign <reference>:<version>: <the underlying failure>: signing: registry requires signatures; refusing to push unsigned content (aggrega push: firma della versione indicata: l’errore sottostante indicato: signing: il registry richiede firme; rifiuto di eseguire il push di contenuto non firmato)

Una forma di errore di firma viene nominata in modo specifico, perché un rifiuto generico spinge le persone a riottenere una credenziale che non può essere d’aiuto:

aggrega push: sign <reference>:<version>: the identity token carries no verified email or subject claim — the OIDC flow/client did not return an email-scoped identity (re-exporting or re-acquiring the token will not help); configure the identity provider/client/scope to return one: <the underlying failure>: signing: registry requires signatures; refusing to push unsigned content (aggrega push: firma della versione indicata: il token di identità non contiene alcun claim email o subject verificato — il flusso/client OIDC non ha restituito un’identità con ambito email (riesportare o riottenere il token non servirà); configura il provider di identità/client/ambito perché ne restituisca una: l’errore sottostante indicato: signing: il registry richiede firme; rifiuto di eseguire il push di contenuto non firmato)

Come risolvere: la correzione spetta all’operatore. Firma l’artifact e pubblica di nuovo — con una chiave in tuo possesso oppure con il percorso senza chiave, a seconda di come è configurato il workspace. Dove non ti aspettavi che fosse richiesta una firma, il messaggio dice quale origine l’ha richiesta: la posizione propria di un registry si trova nella voce di quel registry in .aggrega-config.yaml, e il requisito limitato a un tipo si trova nella policy di firma dell’intero workspace. Allentare l’uno o l’altro è una decisione su che cosa sei disposto a pubblicare senza firma, quindi restringere l’ambito della policy è di solito meglio che disattivarla.

References signed together need different signing credentials (I riferimenti firmati insieme richiedono credenziali di firma diverse)

Un rifiuto alla firma, non su un build. aggrega sign con più riferimenti, e aggrega deprecate --from con un file batch, firmano tutto ciò che ricevono con una sola credenziale: un’unica chiave in tuo possesso, oppure un’unica identità senza chiave. Quale credenziale serva a un riferimento lo decide la configurazione del suo registry — un signing.key_path che si applica a quel registry seleziona la chiave che nomina, e dove non se ne applica nessuno il riferimento viene firmato senza chiave. Quando i riferimenti nominati insieme richiederebbero credenziali diverse — una chiave per un registry e nessuna per un altro, oppure due chiavi diverse — non viene firmato nulla, e il messaggio nomina i registry da ciascuna parte.

Il controllo viene eseguito prima che venga chiesta un’identità e prima che venga letto qualsiasi registry, quindi nulla viene firmato o allegato e a nessuno viene chiesto nulla per un’esecuzione che non andrà avanti. Una firma non può essere ritirata da chi l’ha già recuperata, ed è per questo che l’esecuzione viene rifiutata anziché firmata con la credenziale che serve a uno dei riferimenti, qualunque esso sia.

Una chiave passata con --key decide per ogni riferimento. Si applica a ogni riferimento nominato, qualunque cosa dica la configurazione per ciascun registry, quindi un’esecuzione del genere non viene mai rifiutata qui.

Lo si incontra ovunque venga firmato un batch: aggrega sign, aggrega deprecate --from, le richieste aggrega/signArtifacts e aggrega/deprecateArtifact di aggrega serve, il cui messaggio di errore riporta il codice breve prima della frase, e gli strumenti sign-artifacts e deprecate-artifact di aggrega mcp. Una chiamata a uno strumento che raggiunge un server attraverso un listener non impiega mai una chiave nominata dalla configurazione, quindi lì ogni riferimento viene firmato con l’identità che la chiamata invia e la chiamata non viene rifiutata qui.

Messaggio emesso. Si apre con la frase propria della condizione, poi segue ogni credenziale con i registry per cui firmerebbe, e il rimedio viene per ultimo:

aggrega sign: signing: the references named together need different signing credentials, so nothing was signed (<registry> signs with the held key signing.key_path names, <registry> signs keyless: no signing.key_path applies). remediation: sign them in separate runs, one per credential: the references on <registry>, then the references on <registry>; each run signs as it would on its own (aggrega sign: signing: i riferimenti nominati insieme richiedono credenziali di firma diverse, quindi non è stato firmato nulla (il registry indicato firma con la chiave in tuo possesso che signing.key_path nomina, il registry indicato firma senza chiave: non si applica alcun signing.key_path). rimedio: firmali in esecuzioni separate, una per credenziale: i riferimenti sul registry indicato, poi i riferimenti sul registry indicato; ogni esecuzione firma come farebbe da sola)

e, dove un registry del batch richiede firme, nominandolo alla fine del rimedio:

aggrega sign: signing: the references named together need different signing credentials, so nothing was signed (<registry> signs with the held key signing.key_path names, <registry> signs keyless: no signing.key_path applies). remediation: sign them in separate runs, one per credential: the references on <registry>, then the references on <registry>; each run signs as it would on its own, and <registry> requires signatures, so this refusal holds back signing that would otherwise have gone ahead rather than signing that cannot be done (aggrega sign: signing: i riferimenti nominati insieme richiedono credenziali di firma diverse, quindi non è stato firmato nulla (il registry indicato firma con la chiave in tuo possesso che signing.key_path nomina, il registry indicato firma senza chiave: non si applica alcun signing.key_path). rimedio: firmali in esecuzioni separate, una per credenziale: i riferimenti sul registry indicato, poi i riferimenti sul registry indicato; ogni esecuzione firma come farebbe da sola, e il registry indicato richiede firme, quindi questo rifiuto trattiene una firma che altrimenti sarebbe andata avanti, non una firma impossibile da eseguire)

Un secondo registry con una chiave propria viene nominato come firmante «with a different held key (con una diversa chiave in tuo possesso)». Il percorso di una chiave non viene mai stampato: il messaggio nomina l’impostazione, che è ciò che puoi cambiare.

Come risolvere: suddividi i riferimenti in base alla credenziale di cui hanno bisogno i loro registry ed esegui una volta per credenziale — un aggrega sign che nomina i riferimenti sui registry firmati con una chiave, un altro che nomina il resto; per aggrega deprecate --from, un file batch per credenziale. Ogni esecuzione firma allora come avrebbe fatto da sola. Per firmare invece ogni riferimento con una sola chiave in un’unica esecuzione, passa quella chiave con --key.

A detached signature does not verify against the key supplied (Una firma separata non supera la verifica con la chiave fornita)

L’esito negativo della verifica di una firma semplice su un payload rispetto a una chiave pubblica, interamente offline: il payload differisce da ciò che è stato firmato, la firma è stata alterata, oppure la chiave non è quella che l’ha prodotta.

Nulla nella toolchain distribuita lo raggiunge. Il controllo a cui appartiene non ha alcun chiamante al di fuori dei propri test, quindi nessun comando che un utente esegue — build, pull o pubblicazione — lo segnala. È catalogato qui perché il codice rimandi a qualcosa, non perché un build possa stamparlo. La verifica che un pull esegue davvero riguarda un bundle di firma completo e viene segnalata separatamente.

Messaggio emesso, che cita ciò che ha riportato il verificatore:

signing: signature does not verify: <what the verifier reported> (signing: la firma non supera la verifica, seguito da ciò che ha riportato il verificatore)

Come risolvere: nulla nei tuoi file di entità lo causa, e nulla che tu possa scrivere in un catalogo o in un workspace lo elimina. Se esegui lo strumento da riga di comando pubblicato, questa non è una condizione che puoi raggiungere, e un problema di firma che stai effettivamente osservando viene segnalato invece da una delle condizioni di verifica del bundle descritte sopra. Se usi il pacchetto di firma direttamente da un tuo software, il payload, la firma e la chiave devono essere i tre che vanno insieme — un payload riserializzato tra la firma e la verifica è la causa abituale, poiché i byte allora differiscono anche se il contenuto si legge allo stesso modo.

A resolved artifact is not a documentation bundle (Un artifact risolto non è un bundle di documentazione)

Un riferimento che si risolve in un artifact di qualche altro tipo — un’entità del catalogo, un plugin — viene rifiutato anziché messo in cache come documentazione, così un riferimento puntato male fallisce dove è puntato anziché più tardi come un bundle che non può essere letto.

Dove si presenta. Il bundle di documentazione viene acquisito nella cache condivisa da ogni progetto sulla macchina, dal registry configurato del workspace sotto il namespace riservato docs: dal server rivolto agli assistenti una volta, all’avvio e prima che risponda a qualsiasi cosa, da aggrega explain e dalla spiegazione di un codice in un editor la prima volta che uno dei due ne ha bisogno, e da aggrega scaffold --example — in ogni caso solo dove la macchina non contiene alcuna copia che il controllo delle firme del workspace ammetta. Questo è il controllo che ogni acquisizione esegue su ciò che è tornato indietro.

Non arresta mai una sessione. L’acquisizione riporta il proprio esito sul flusso di log del server e la connessione procede in ogni caso; ciò che costa un artifact rifiutato sono le risorse di documentazione, che per quella sessione rispondono allora «non trovato». aggrega scaffold --example non ha nulla da scrivere senza il bundle, quindi lì si tratta del rifiuto del comando, e non viene scritto nulla.

Messaggio emesso, che nomina il riferimento ed entrambi i tipi di media:

docscache: <reference>@<version> has media type "<what was found>", want "<what a documentation bundle is>": docscache: artifact is not a documentation bundle (docscache: il riferimento indicato alla versione indicata ha il tipo di media trovato, mentre è atteso quello di un bundle di documentazione: docscache: l’artifact non è un bundle di documentazione)

Come risolvere: nulla nei tuoi file di entità lo causa, e nessuna modifica di authoring lo elimina. Il riferimento usato dall’acquisizione punta a qualcosa che non è un bundle di documentazione — controlla il registry configurato del workspace, poiché il riferimento del bundle è derivato da esso, e un riferimento ben formato che punta a un altro artifact si risolve correttamente e fallisce solo qui.

A page is absent from a documentation bundle (Una pagina è assente da un bundle di documentazione)

Un bundle di documentazione è stato messo in cache e il suo contenuto verificato, e la pagina richiesta — oppure, per aggrega scaffold --example, la directory dell’esempio — non vi si trova. È diverso dal non avere alcun bundle: il bundle è presente e integro, e la voce vi manca.

Non raggiunge alcun build. La superficie che serve pagine di documentazione a un editor o a un assistente lo trasforma in una normale risposta «non trovato» per la risorsa richiesta. aggrega scaffold --example lo segnala come un rifiuto che nomina l’esempio e il bundle, seguito da un rimando a aggrega scaffold --example --list, che stampa gli esempi che il bundle contiene davvero, e non scrive nulla.

Quale delle due risposte «non trovato» ricevi vale la pena di saperlo distinguere, anche se la superficie le presenta allo stesso modo. Questa significa che il bundle è in cache e integro e che la pagina non vi si trova. L’altra — nessun bundle che il workspace possa leggere, perché nessuno è in cache o l’unica copia è una che il controllo delle firme del workspace rifiuta — significa che l’acquisizione non è stata completata, e il flusso di log del server dice perché.

Messaggio emesso, che nomina la pagina e il bundle in cui è stata cercata:

page "<page>" in <reference>@<version>: docscache: page not found in documentation bundle (la pagina indicata nel riferimento indicato alla versione indicata: docscache: pagina non trovata nel bundle di documentazione)

Come risolvere: nei tuoi file non c’è nulla di rotto. Una pagina che manca dal bundle manca perché il bundle è precedente a essa oppure perché il percorso richiesto non è quello sotto cui è pubblicata — il bundle viene acquisito alla versione che il server riporta come propria, quindi una pagina aggiunta dopo quella versione non vi si trova. Dove la pagina non è mai esistita, la richiesta ha nominato un percorso che la documentazione non usa, e la documentazione pubblicata è il posto in cui trovare quello che usa.

An edit would produce a document its schema refuses (Una modifica produrrebbe un documento che il suo schema rifiuta)

Un rifiuto su una modifica di documento, non su un build. Una modifica strutturata — aggiungere un componente, associare una Feature, cablare un arco o impostare un valore — viene composta e innestata nel documento, e il risultato viene poi verificato rispetto allo schema del tipo di documento che è. Dove quel controllo obietta, la modifica viene rifiutata e non viene scritto nulla. Appartiene ad aggrega edit-document, e alla stessa capacità raggiunta da un editor tramite aggrega serve o da un assistente, che sono punti di ingresso sottili verso un’unica implementazione.

Il tipo viene letto dal documento, mai fornito da chi chiama. Un chiamante che nominasse il tipo potrebbe nominare quello sbagliato, e il risultato verrebbe allora verificato rispetto a uno schema secondo cui il documento non è scritto — il che ammetterebbe esattamente la modifica che questo controllo esiste per rifiutare.

Il file resta byte per byte com’era, e la scrittura è atomica, quindi una modifica rifiutata è indistinguibile da una mai tentata, e una richiesta corretta può essere ritentata sul documento da cui sei partito.

Il suo oggetto è una richiesta ben formata. La richiesta nominava una modifica che questa capacità applica, e il documento che avrebbe prodotto è uno che lo schema di authoring avrebbe rifiutato se lo avessi digitato a mano — ed è per questo che per essa non viene ribadita alcuna regola di authoring: chiedere a una Release di portare un valore dello sviluppatore viene rifiutato dallo stesso schema in entrambi i casi. Una richiesta che non ha mai indirizzato una modifica — un percorso di nodo che non raggiunge nulla nel documento, un valore scritto come mapping dove è richiesto uno scalare, una voce già presente che porta qualcos’altro — viene rifiutata per motivi propri, e ogni superficie lo segnala nel proprio canale.

Anche un documento che era già non valido lo segnala. Il controllo viene eseguito anche dove la modifica non ha cambiato nulla, quindi una modifica su un documento che il prodotto rifiuterebbe di leggere lo dice anziché segnalare un successo.

Il controllo è quello che applica ogni lettura del documento, quindi rifiuta anche una Recipe o una FeatureRecipe la cui pipeline dichiara due volte lo stesso id di step, una regola che nessuno schema può enunciare; l’obiezione dopo la frase si apre allora con la frase e il consiglio propri di quella condizione, come descritto in A pipeline declares one step id twice (Una pipeline dichiara due volte lo stesso id di step).

Messaggio emesso, che porta l’obiezione propria dello schema dopo la frase — il tipo di documento e il file, poi la posizione, la chiave in errore e ciò che lo schema ha detto lì — e si chiude con il consiglio:

the edit was refused because the resulting document would not be valid, and nothing was written: document envelope validation failed (<kind>, at <path>); <line>:<column>: <field-path>: … <the schema's own objection>. correct the document to match its kind’s schema (la modifica è stata rifiutata perché il documento risultante non sarebbe valido, e non è stato scritto nulla: convalida dell’involucro del documento non riuscita (il tipo indicato, nel percorso indicato); la riga e la colonna indicate: il percorso del campo indicato: … seguito dall’obiezione propria dello schema. correggi il documento perché corrisponda allo schema del suo tipo)

Come risolvere: apri il documento nella posizione citata dal messaggio e leggi l’obiezione, che dice che cosa lo schema voleva in quella chiave. La modifica da fare riguarda di solito la richiesta anziché il documento — chiedi una voce che lo schema ammette in quel punto, e la stessa richiesta si applica senza problemi. Dove la chiave è una che il tipo di quel documento non può portare affatto, appartiene alla superficie di authoring che può farlo, e la pagina dell’entità per quel tipo nomina i campi che dichiara. Ciò che è semanticamente ammissibile non viene deciso a questo punto — se un socket di dipendenza sia uno che il produttore dichiara, per esempio — quindi questo rifiuto riguarda sempre la forma del documento, mai ciò che può essere consumato attraverso una connessione.

An annotation key uses a prefix the platform reserves (Una chiave di annotazione usa un prefisso che la piattaforma riserva)

Un rifiuto alla verifica di un’entità rispetto alle convenzioni di pubblicazione, non su un build. Il prefisso aggrega.ai/, e feature.aggrega.ai/ al di fuori di una Feature, appartengono alla piattaforma: una chiave scritta sotto uno di essi porta un significato che assegna la piattaforma, quindi un’entità tua che vi scrive rivendica uno spazio dei nomi che non detiene.

Avvisa mentre redigi e rifiuta al gate di pubblicazione, ed entrambe le letture nominano questa stessa condizione. Ciò che è stato trovato è lo stesso in entrambi i casi; cambia solo la conseguenza. Questa divisione è il modo in cui si comporta la maggior parte delle regole delle convenzioni di pubblicazione catalogate qui, quindi viene enunciata una volta e data per scontata nelle voci seguenti che non dicono altrimenti — le due che confrontano con una versione già pubblicata lo dicono nelle proprie voci, perché quelle non possono essere eseguite affatto sul contenuto locale.

Il suo messaggio inizia così:

an annotation key on the entity uses a prefix the platform reserves (una chiave di annotazione dell’entità usa un prefisso che la piattaforma riserva)

Come risolvere: sposta la chiave sotto un prefisso che appartiene alla tua organizzazione. Dove un workspace ha comunque un motivo per scrivere sotto il prefisso riservato, questa regola è tra quelle con un’opzione di esclusione descritte in «Le regole di disciplina» in aggrega-lint.md.

An entity’s name does not follow the shape its kind expects (Il nome di un’entità non segue la forma che il suo tipo prevede)

Un rifiuto alla verifica di un’entità rispetto alle convenzioni di pubblicazione, non su un build. Ogni tipo di entità porta una convenzione sulla forma del nome — il numero di segmenti per i tipi cloud-native, PascalCase per i tipi di libreria — e il nome che questa entità dichiara non corrisponde a quello che il suo tipo prevede.

Il suo messaggio inizia così:

the entity’s name does not follow the documented name shape for its kind (il nome dell’entità non segue la forma di nome documentata per il suo tipo)

Come risolvere: rinomina l’entità secondo la forma che il suo tipo prevede; le convenzioni per ciascun tipo sono elencate in «Le regole di disciplina» in aggrega-lint.md, insieme all’opzione di esclusione per un catalogo che nomina deliberatamente le entità a modo suo.

A schema uses a dynamic reference that cannot be resolved ahead of time (Uno schema usa un riferimento dinamico che non può essere risolto in anticipo)

Un rifiuto alla verifica di un’entità rispetto alle convenzioni di pubblicazione, non su un build. Uno schema che l’entità porta con sé usa un costrutto di riferimento dinamico, la cui destinazione viene scelta mentre un documento viene convalidato anziché fissata quando lo schema viene scritto. Qui i riferimenti vengono espansi in anticipo, quindi non c’è alcuna convalida in corso rispetto alla quale un costrutto del genere possa essere risolto.

Il suo messaggio inizia così:

a schema in the entity uses a dynamic reference construct that cross-document reference resolution cannot follow (uno schema nell’entità usa un costrutto di riferimento dinamico che la risoluzione dei riferimenti tra documenti non può seguire)

Come risolvere: sostituisci il costrutto dinamico con un riferimento semplice che nomini direttamente la destinazione. Dove lo schema ha davvero bisogno del costrutto e non verrà referenziato tra documenti, la regola prevede un’opzione di esclusione descritta in «Le regole di disciplina» in aggrega-lint.md.

A schema declares an identifier the platform owns (Uno schema dichiara un identificatore che appartiene alla piattaforma)

Un rifiuto alla verifica di un’entità rispetto alle convenzioni di pubblicazione, non su un build. Uno schema che l’entità porta con sé dichiara un identificatore proprio, laddove l’identificatore canonico è derivato dall’identità dell’entità. Quello dichiarato sostituisce quello derivato, quindi un riferimento scritto rispetto all’identificatore canonico smette di risolversi.

Il suo messaggio inizia così:

a schema in the entity declares an identifier of its own, where the platform owns that schema’s identity (uno schema nell’entità dichiara un identificatore proprio, laddove l’identità di quello schema appartiene alla piattaforma)

Come risolvere: rimuovi l’identificatore dichiarato e lascia che venga derivato. L’opzione di esclusione, per uno schema pubblicato deliberatamente sotto un identificatore proprio, è descritta in «Le regole di disciplina» in aggrega-lint.md.

A Component’s category label and its directory name different categories (L’etichetta di categoria di un Component e la sua directory nominano categorie diverse)

Un rifiuto alla verifica di un’entità rispetto alle convenzioni di pubblicazione, non su un build. Un Component porta un’etichetta di categoria ed è archiviato sotto una directory di categoria; la convenzione è che le due nominino la stessa categoria, così che la directory che un lettore sfoglia e l’etichetta che un selettore abbina non possano essere in disaccordo.

Il suo messaggio inizia così:

the entity’s category label does not match the category directory the entity is filed under (l’etichetta di categoria dell’entità non corrisponde alla directory di categoria sotto cui l’entità è archiviata)

Come risolvere: cambia quello dei due che è sbagliato, così che concordino — sposta il file sotto la directory che la sua etichetta nomina, oppure correggi l’etichetta con la categoria che la directory nomina. L’insieme chiuso delle categorie, e l’opzione di esclusione, sono in «Le regole di disciplina» in aggrega-lint.md.

A schema extension is written directly into schema content (Un’estensione di schema è scritta direttamente nel contenuto dello schema)

Un rifiuto alla verifica di un’entità rispetto alle convenzioni di pubblicazione, non su un build. Un Component o una Feature scrive un’estensione di schema di Aggrega direttamente nel contenuto del suo schema, laddove l’entità dispone di una superficie di prima classe per dichiarare la stessa cosa. La forma scritta direttamente funziona, e la convenzione preferisce la superficie dichiarata perché è quella che insegnano le pagine delle entità e quella che leggono gli strumenti.

Questa è l’unica regola del gruppo che segnala anche un build, come avviso che non arresta il build. La verifica dell’entità rispetto alle convenzioni di pubblicazione al gate di pubblicazione eleva lo stesso rilievo a rifiuto.

Il suo messaggio inizia così:

the entity writes an Aggrega schema extension directly into schema content instead of declaring it under usesSchema or featuresSchema (l’entità scrive un’estensione di schema di Aggrega direttamente nel contenuto dello schema invece di dichiararla nello schema dei socket o nello schema delle associazioni)

Come risolvere: sposta l’estensione sulla superficie dei socket o delle associazioni propria dell’entità, che è il punto in cui la dichiarano le pagine delle entità component.md e feature.md. L’opzione di esclusione è in «Le regole di disciplina» in aggrega-lint.md.

A Plugin pins neither runtime cap, so the platform’s own apply (Un Plugin non fissa nessuno dei due limiti di runtime, quindi si applicano quelli della piattaforma)

Un avviso sollevato quando un’entità viene verificata rispetto alle convenzioni di pubblicazione, sia mentre redigi sia al gate di pubblicazione; non arresta mai nulla, e un build non lo solleva. Un Plugin dichiara il tetto di memoria e il limite di tempo che l’host applica quando carica ed esegue il plugin. Uno che non dichiara né l’uno né l’altro viene eseguito con i valori predefiniti della piattaforma, il che è un esito supportato e non un errore — quindi ciò che questo segnala è che i valori predefiniti sono in vigore e che è possibile fissarli esplicitamente.

Il suo messaggio inizia così:

the Plugin entity declares no runtime resource cap of its own, so the platform defaults apply (l’entità Plugin non dichiara alcun limite di risorse di runtime proprio, quindi si applicano i valori predefiniti della piattaforma)

Come risolvere: fissa i limiti di cui il plugin ha effettivamente bisogno, oppure lascia deliberatamente in vigore i valori predefiniti. Non prevede alcuna impostazione di esclusione, e il motivo è che segnala un fatto sull’entità anziché un giudizio su di essa: non c’è nulla da allentare. I campi sono descritti in plugin.md.

An attachment slot admits only secret material without saying it handles it (Uno slot di associazione ammette solo materiale segreto senza dichiarare di gestirlo)

Un avviso sollevato quando un’entità viene verificata rispetto alle convenzioni di pubblicazione, sia mentre redigi sia al gate di pubblicazione; non arresta mai nulla, e un build non lo solleva. Uno slot di associazione può fissare, tramite il suo selettore, che solo una Feature portatrice di segreti possa riempirlo, e può registrare separatamente che qualunque cosa lo riempia gestisce materiale segreto. Il selettore stabilisce quali riempimenti sono ammissibili; la registrazione stabilisce la gestione. Uno slot che fissa il primo e omette la seconda lascia che la gestione venga dedotta dal selettore anziché letta dallo slot. Ogni slot che un’entità dichiara viene verificato: quelli del suo blocco di associazioni e, su un Component, quelli che un socket di dipendenza dichiara per ogni connessione cablata attraverso di esso — il rilievo sullo slot di un socket nomina il socket accanto allo slot.

Il suo messaggio inizia così:

an attachment slot admits only secret material and does not declare that it handles it (uno slot di associazione ammette solo materiale segreto e non dichiara di gestirlo)

Come risolvere: dichiara la gestione sullo slot, accanto al selettore che fissa ciò che ammette. Non prevede alcuna impostazione di esclusione, per lo stesso motivo per cui non ne prevede la regola sui limiti del Plugin: segnala un fatto sull’entità e lascia a te la decisione.

A Recipe publishes a provides key its Component does not declare, checked at publication (Una Recipe pubblica una chiave che il suo Component non dichiara, con verifica alla pubblicazione)

Un avviso sollevato quando un’entità viene verificata rispetto alle convenzioni di pubblicazione, sia mentre redigi sia al gate di pubblicazione; non arresta mai nulla, e un build non lo solleva. Una Recipe pubblica una chiave sotto provides:, e il Component che la Recipe implementa non dichiara quella chiave nel pilastro provides del suo schema. Un consumatore che cabla attraverso una connessione legge il contratto dichiarato del Component anziché qualunque cosa emetta la Recipe, quindi la chiave viene prodotta e poi rifiutata dove qualcosa tenta di consumarla.

🔴 Due condizioni descrivono questo caso, e non sono la stessa. L’avviso che segnala un build è documentato sopra in «A Recipe publishes a provides key its Component does not declare (Una Recipe pubblica una chiave che il suo Component non dichiara)»; questo viene sollevato quando l’entità viene verificata rispetto alle convenzioni di pubblicazione, e porta un codice proprio. Il rilievo è lo stesso fatto incontrato su due superfici — leggi il codice nella diagnostica per capire quale hai in mano.

Il suo messaggio inizia così:

the Recipe publishes a provides key the Component it implements does not declare, so a consumer wiring that key is refused (la Recipe pubblica una chiave provides che il Component che implementa non dichiara, quindi un consumatore che cabla quella chiave viene rifiutato)

Come risolvere: dichiara la chiave sul Component, così che il contratto che un consumatore legge includa ciò che la Recipe emette — oppure smetti di pubblicarla dalla Recipe dove nulla è destinato a consumarla. L’opzione di esclusione è in «Le regole di disciplina» in aggrega-lint.md.

A Component’s metrics annotation and its provides key disagree (L’annotazione delle metriche di un Component e la sua chiave provides sono in disaccordo)

Un avviso sollevato quando un’entità viene verificata rispetto alle convenzioni di pubblicazione, sia mentre redigi sia al gate di pubblicazione; non arresta mai nulla, e un build non lo solleva. Un Component può indicare come si autenticano le metriche del suo prodotto, nella sua annotazione observability.aggrega.ai/metrics-credential — none, target-key o separate-token — e può dichiarare la chiave provides metrics_credential_required, che ciascuna delle sue Recipes pubblica per dire se le metriche di un’istanza richiedono una credenziale. Le due sono un unico fatto sul prodotto visto da due lati, quindi un Component che afferma che le sue metriche non richiedono credenziali non dichiara alcuna chiave del genere, e uno che afferma che richiedono una credenziale la dichiara. Questa condizione segnala un Component in cui le due sono in disaccordo, nominando il Component, il valore dell’annotazione e la chiave in più o mancante.

Il suo messaggio inizia così:

a Component’s annotation stating how its metrics authenticate disagrees with whether it declares the provides key saying an instance’s metrics need a credential (l’annotazione di un Component che indica come si autenticano le sue metriche è in disaccordo con il fatto che dichiari o meno la chiave provides che dice se le metriche di un’istanza richiedono una credenziale)

Come risolvere: correggi quello dei due che è sbagliato — dichiara metrics_credential_required nel pilastro provides, e pubblicala da ciascuna Recipe, dove le metriche richiedono una credenziale; rimuovila dove non ne richiedono; oppure cambia l’annotazione nel valore che descrive il prodotto. Non prevede alcuna impostazione di esclusione, per lo stesso motivo per cui non ne prevede la regola sui limiti del Plugin; quali valori legge, e quali Components lascia non letti, sono in «Le regole di disciplina» in aggrega-lint.md.

A connection and the target it reaches do not name one key (Una connessione e la destinazione che raggiunge non nominano una stessa chiave)

Un avviso sollevato quando una Release viene verificata rispetto alle convenzioni di pubblicazione; non arresta mai nulla, e un build non lo solleva. Un server che verifica una chiave conserva la chiave che verifica in uno slot proprio, e un chiamante presenta una chiave sulla connessione attraverso cui raggiunge quel server. Nessuna delle due estremità vede quella dell’altra, quindi le due sono un’unica chiave solo perché i loro autori scrivono lo stesso localizzatore a entrambe le estremità. Questa condizione segnala una connessione la cui destinazione dichiara lo slot per la chiave che richiede ai suoi chiamanti, nei casi in cui le due non sono un’unica chiave: la connessione porta una credenziale e lo slot della chiave della destinazione non è riempito, lo slot della chiave della destinazione è riempito e la connessione non porta alcuna credenziale, oppure entrambi sono riempiti e i due scrivono i loro localizzatori in modo diverso.

A differenza delle regole che la precedono, questa legge un’intera Release anziché una singola entità, quindi la si incontra solo quando viene verificata una Release e mai al gate di pubblicazione, che verifica una singola entità da sola; ovunque venga segnalata, è un consiglio. Il rilievo nomina il componente, la connessione, la destinazione e i due slot, e non cita mai nessuno dei due localizzatori. Uno scrape — una connessione sul socket scrape_target — viene giudicato in base a ciò che la sua destinazione afferma sulle proprie metriche: per nulla dove l’annotazione observability.aggrega.ai/metrics-credential della destinazione dice none, mai rispetto alla chiave della destinazione dove dice separate-token, e come qualsiasi altra connessione negli altri casi; una connessione su qualsiasi altro socket viene giudicata qualunque cosa affermi la destinazione.

Il suo messaggio inizia così:

a connection and the target it reaches do not name one key: they write different locators for it, or only one of them names one (una connessione e la destinazione che raggiunge non nominano una stessa chiave: scrivono localizzatori diversi per essa, oppure solo una delle due ne nomina una)

Come risolvere: fai in modo che entrambe le estremità leggano un unico parametro — il campo credential della connessione e il campo api_key della destinazione — così che la chiave che il chiamante presenta e la chiave che il server verifica non possano essere scritte in modo diverso; oppure, dove una connessione non deve presentare alcuna chiave, togli la credenziale da essa. Quali slot vengono letti, che cosa viene confrontato e l’opzione di esclusione sono in «Le regole di disciplina» in aggrega-lint.md.

The change being published breaks what the evolution rubric allows (La modifica in corso di pubblicazione viola ciò che la griglia di evoluzione consente)

Un rifiuto al controllo che precede la pubblicazione, non su un build. La versione in corso di pubblicazione viene confrontata con la versione già pubblicata prima di essa, e la differenza tra le due viene classificata rispetto a una griglia documentata. Questa condizione segnala che la differenza è una a cui la griglia si oppone.

Ha bisogno di un predecessore pubblicato con cui confrontarsi, quindi essa e il controllo dell’aumento di versione descritto sotto sono le due regole di questo gruppo che non possono essere eseguite sul solo contenuto locale: senza consultare alcun registry non c’è nulla da confrontare, e il controllo viene saltato anziché superato.

Il suo messaggio inizia così:

the version being published changes the published predecessor in a way the documented evolution rubric objects to (la versione in corso di pubblicazione modifica il predecessore pubblicato in un modo a cui la griglia di evoluzione documentata si oppone)

Come risolvere: leggi la classificazione nella diagnostica, che nomina che cosa della modifica ha suscitato l’obiezione della griglia, e rendi la modifica compatibile oppure pubblicala con una versione che la ammetta. La griglia è esposta in «La griglia dell’aumento di versione» in aggrega-lint.md.

The version offered is a smaller bump than the change requires (La versione offerta è un aumento minore di quello che la modifica richiede)

Un rifiuto al controllo che precede la pubblicazione, non su un build. La modifica in corso di pubblicazione viene classificata rispetto alla griglia di evoluzione, e la versione offerta per essa è un passo più piccolo di quello che la classificazione richiede — una rimozione o un restringimento offerti come patch, per esempio. Un aumento eccessivo è sempre accettato; è un aumento insufficiente a fermarsi qui.

A differenza delle regole che la precedono, questa viene decisa qui anziché dal plugin delle convenzioni. Quale aumento sia stato offerto è noto solo al momento della pubblicazione, e in quel momento non è in corso alcuna compilazione, quindi il confronto tra la classificazione e la versione offerta viene fatto in quel punto.

Il suo messaggio inizia così:

the version bump being published is smaller than the evolution check’s classification of the change requires (l’aumento di versione in corso di pubblicazione è minore di quanto richiede la classificazione della modifica fatta dal controllo di evoluzione)

Come risolvere: pubblica con la versione che la classificazione richiede; la diagnostica nomina quale sia. Dove ritieni che la modifica sia più piccola di come è stata classificata, la griglia in «La griglia dell’aumento di versione» in aggrega-lint.md dice che cosa colloca una modifica in ciascuna classe. La prima pubblicazione di un’entità non ha un predecessore, quindi il confronto viene saltato e segnalato come non eseguito anziché superato.

An import stopped partway through translating a source (Un’importazione si è interrotta a metà della traduzione di una sorgente)

Un rifiuto alla trasformazione di una descrizione di sorgente esterna in bozze di file di authoring, non su un build. L’importer ha segnalato una diagnostica abbastanza grave da interrompere la traduzione, quindi ciò che ha prodotto è parziale: una parte della sorgente è diventata bozze di file di authoring e una parte no.

Il risultato parziale è voluto, non un relitto. Nomina l’esito e non la causa — ciò che non è stato possibile tradurre è segnalato nelle diagnostiche accanto a esso, una per ogni costrutto che l’importer non è riuscito a trasferire, con le parole dell’importer stesso. Questa condizione è ciò che permette a un chiamante di distinguere «l’importazione si è fermata e ha prodotto parte di una risposta» da «l’importazione è fallita del tutto», che sono situazioni diverse con passi successivi diversi.

Il suo messaggio inizia così:

the importer reported a diagnostic that stops the import, so the source was not fully turned into draft authoring files (l’importer ha segnalato una diagnostica che interrompe l’importazione, quindi la sorgente non è stata trasformata completamente in bozze di file di authoring)

Come risolvere: leggi le diagnostiche segnalate accanto a essa — ciascuna nomina un costrutto della sorgente che l’importer non è riuscito a tradurre. La correzione sta nella sorgente che hai fornito, oppure nel completare a mano la bozza: un’importazione produce un punto di partenza da modificare, quindi un costrutto che non è sopravvissuto alla traduzione va scritto direttamente dal lato di Aggrega. aggrega-import.md descrive ciò che il comando produce e dove scrive.

More than one importer recognises the source (Più di un importer riconosce la sorgente)

Un rifiuto alla trasformazione di una descrizione di sorgente esterna in bozze di file di authoring, non su un build. L’importazione non ha nominato alcun formato, quindi il formato è stato riconosciuto dalle firme che gli importer dichiarano — quelli nel catalogo del workspace così come gli importer di base del compilatore, ciascuno dei quali nomina la sintassi in cui viene letta una sorgente, i nomi di file a cui si applica e i percorsi che il suo albero analizzato deve o non deve contenere — e alla sorgente corrispondevano firme di importer che servono più di un formato. L’importazione non sceglie tra di essi: in quale formato sia una sorgente è un’affermazione degli importer, non del compilatore, e scegliere sarebbe un’ipotesi che consegna la sorgente a un importer a cui potrebbe non essere destinata.

Non è la stessa cosa di un unico formato annunciato da più di un importer, descritto in «A parse or import format is advertised by more than one plugin (Un formato di parsing o di importazione è annunciato da più di un plugin)» più sopra. Lì il formato è stabilito e gli importer che lo servono sono in concorrenza, quindi una voce plugins.importer sceglie tra di essi; qui sono i formati stessi a differire, quindi nessuna associazione risolve la questione, mentre la risolve nominare il formato. Un importer che riconosce una sorgente la riconosce come ogni formato che annuncia, quindi anche un importer che annuncia più di un formato, una delle cui firme corrisponde, viene rifiutato qui.

Il suo messaggio inizia così:

more than one importer recognises the source (più di un importer riconosce la sorgente)

Il resto del messaggio nomina la sorgente e ogni formato come cui è stata riconosciuta, nell’ordine delle identità e delle versioni degli importer, poi il rimedio:

more than one importer recognises the source (source "<source>", recognised as "<format>", "<format>"). Pass —format to name the one to read it as (for example —format <format> or —format <format>) (più di un importer riconosce la sorgente (sorgente indicata, riconosciuta come i formati indicati). Passa —format per nominare il formato in cui leggerla (per esempio —format seguito da uno dei formati))

Come risolvere: nomina il formato — --format su aggrega import, oppure format sullo strumento di importazione dell’assistente e sul metodo aggrega/import della sessione. Dove uno degli importer non dovrebbe mai riconoscere una sorgente del genere, la modifica riguarda le firme di quell’importer, che il suo autore dichiara nella sua autodichiarazione describe() e che la sua entità Plugin registra quando viene generata; oppure, dove si tratta di uno contenuto nel catalogo del workspace, lascialo fuori dal catalogo che il workspace legge — un importer di base è sempre tra quelli provati, quindi una sorgente che uno di essi riconosce insieme a un altro importer si risolve nominando il formato. aggrega-import.md descrive come viene riconosciuto un formato.

No importer recognises the source (Nessun importer riconosce la sorgente)

Un rifiuto alla trasformazione di una descrizione di sorgente esterna in bozze di file di authoring, non su un build. L’importazione non ha nominato alcun formato, quindi il formato è stato riconosciuto dalle firme che gli importer dichiarano — quelli nel catalogo del workspace così come gli importer di base del compilatore — e alla sorgente non corrispondevano le firme di alcun formato. L’importazione non tira a indovinare: consegnare la sorgente a un importer che non ha mai dichiarato di leggere quella forma produrrebbe una bozza a partire da una sorgente a cui potrebbe non essere destinato.

È la controparte di «More than one importer recognises the source (Più di un importer riconosce la sorgente)» più sopra. Lì diversi formati rivendicano la sorgente; qui nessuno lo fa. In entrambi i casi nominare il formato risolve la questione, e nulla viene scritto finché non viene nominato.

Il suo messaggio inizia così:

no importer recognises the source (nessun importer riconosce la sorgente)

Il resto del messaggio nomina la sorgente, poi il rimedio e ogni formato annunciato dagli importer del catalogo, nell’ordine in cui sono stati letti:

no importer recognises the source (source "<source>"). Pass —format to name it explicitly (for example —format <format> or —format <format>) (nessun importer riconosce la sorgente (sorgente indicata). Passa —format per nominarlo esplicitamente (per esempio —format seguito da uno dei formati annunciati))

Dove nessun importer annuncia alcun formato, il rimedio lo dice al posto degli esempi.

A una directory viene offerto un rimedio diverso, perché nominare un formato qualsiasi non può aiutarla. Una directory viene letta solo attraverso i pattern di file che il suo importer dichiara, e una firma che non dichiara alcun pattern di file non si applica a nessuno dei file di una directory — così una directory che contiene, per esempio, un’unica esportazione di Langflow non viene riconosciuta da alcuna firma, e nominare il formato langflow verrebbe a sua volta rifiutato secondo An importer that declares no file patterns is handed a directory (Un importer che non dichiara pattern di file riceve una directory). Il rifiuto di una directory la nomina quindi come directory e propone di importare da solo uno dei suoi file, oppure di nominare un formato il cui importer dichiara pattern di file — solo quei formati, ricavati dalle dichiarazioni degli importer stessi:

no importer recognises the source (directory "<directory>"). Import one of the directory’s files on its own, or pass —format naming a format whose importer reads a directory through the file patterns it declares (for example —format <format> or —format <format>) (nessun importer riconosce la sorgente (directory). Importa da solo uno dei file della directory, oppure passa —format nominando un formato il cui importer legge una directory attraverso i pattern di file che dichiara (per esempio —format o —format))

Dove nessun importer dichiara un pattern di file, il rifiuto propone di importare da solo uno dei file della directory e dice che nessun importer del catalogo dichiara i pattern di file attraverso cui viene letta una directory.

Come risolvere: nomina il formato — --format su aggrega import, oppure format sullo strumento di importazione dell’assistente e sul metodo aggrega/import della sessione, ciascuno dei quali formula il rifiuto attorno al campo che accetta e lo apre con il codice breve di questa condizione; la risposta della sessione porta inoltre entrambi i codici della condizione nei suoi dati. Per una directory, importa da solo l’unico file che intendevi — una firma che non nomina alcun file si applica a un file importato da solo, qualunque sia il suo nome — oppure nomina uno dei formati che il rifiuto elenca. Dove la sorgente avrebbe dovuto essere riconosciuta, la modifica riguarda le firme dell’importer che serve il suo formato, che il suo autore dichiara nella sua autodichiarazione describe() e che la sua entità Plugin registra quando viene generata. aggrega-import.md descrive come viene riconosciuto un formato.

An importer that declares no file patterns is handed a directory (A un importer che non dichiara pattern di file viene passata una directory)

Un rifiuto alla trasformazione di una descrizione di sorgente esterna in bozze di file di authoring, non su un build. La sorgente nominata è una directory, e una directory viene passata al suo importer esattamente come i file selezionati dai pattern di file dichiarati dall’importer — quindi quali file di una directory legge un importer è un’affermazione dell’importer stesso. L’importer che serve il formato della sorgente non dichiara pattern di file: legge un solo file, e non dice nulla su quali file di una directory siano suoi.

Non viene aperto nulla. L’importazione si ferma una volta risolto l’importer e prima che venga letto qualsiasi file della directory, anziché passare all’importer ogni file che la directory contiene.

Il suo messaggio inizia così:

the importer serving the source’s format declares no file patterns, so it reads one file and cannot read a directory (l’importer che serve il formato della sorgente non dichiara pattern di file, quindi legge un solo file e non può leggere una directory)

Il resto del messaggio nomina il formato, l’importer e la directory così come l’hai nominata, poi il rimedio:

the importer serving the source’s format declares no file patterns, so it reads one file and cannot read a directory (format "<format>", importer "importer/<name>", directory "<directory>"). Import one of the directory’s files on its own instead; the importer reads a directory once it declares the file patterns its files are named by (l’importer che serve il formato della sorgente non dichiara pattern di file, quindi legge un solo file e non può leggere una directory (formato, importer e directory indicati). Importa invece da solo uno dei file della directory; l’importer legge una directory una volta che dichiara i pattern di file con cui sono nominati i suoi file)

Come risolvere: importa da solo un file del formato. Perché un importer legga directory del suo formato, il suo autore dichiara i pattern con cui sono nominati i suoi file — il campo files di una firma di riconoscimento nella sua autodichiarazione describe(), che la sua entità Plugin registra quando viene generata. aggrega-import.md descrive che cosa legge un’importazione di una directory.

No file in the directory matches the importer’s file patterns (Nessun file della directory corrisponde ai pattern di file dell’importer)

Un rifiuto alla trasformazione di una descrizione di sorgente esterna in bozze di file di authoring, non su un build. La sorgente nominata è una directory, il formato è stabilito e l’importer che lo serve dichiara pattern di file — ma nessun file contenuto nella directory, a qualsiasi profondità, corrisponde a uno di essi. Non passare all’importer alcuna sorgente lo farebbe fallire su una sorgente vuota, con parole che riguardano il contenuto anziché quali file sono stati letti, quindi l’importazione si ferma qui senza aver letto nulla.

Dove il formato è stato riconosciuto anziché nominato, l’importer la cui firma ha riconosciuto la directory corrispondeva a uno dei suoi file, quindi la si incontra solo dove l’importer che viene eseguito non è quello — un altro importer dello stesso formato selezionato da una voce plugins.importer, oppure un’altra versione di esso.

Il suo messaggio inizia così:

no file in the directory matches the file patterns the importer serving the source’s format declares (nessun file della directory corrisponde ai pattern di file dichiarati dall’importer che serve il formato della sorgente)

Il resto del messaggio nomina il formato, l’importer, la directory così come l’hai nominata e ogni pattern che l’importer dichiara, poi il rimedio:

no file in the directory matches the file patterns the importer serving the source’s format declares (format "<format>", importer "importer/<name>", directory "<directory>", file patterns "<pattern>", "<pattern>"). Name a directory holding a file one of those patterns matches, or the format of an importer whose patterns match the files this directory holds (nessun file della directory corrisponde ai pattern di file dichiarati dall’importer che serve il formato della sorgente (formato, importer, directory e pattern di file indicati). Nomina una directory che contenga un file a cui corrisponde uno di quei pattern, oppure il formato di un importer i cui pattern corrispondono ai file che questa directory contiene)

Come risolvere: importa la directory che contiene i file del formato — un pattern viene confrontato con la parte finale del percorso di un file all’interno della directory, quindi conta un file a qualsiasi profondità — oppure nomina il formato in cui sono i file della directory. aggrega-import.md descrive che cosa legge un’importazione di una directory.

A file read from the directory and a file named in the importer’s with.sources have the same name (Un file letto dalla directory e un file nominato nelle sorgenti dell’importer hanno lo stesso nome)

Un rifiuto alla trasformazione di una descrizione di sorgente esterna in bozze di file di authoring, non su un build. La sorgente nominata è una directory, e i suoi file raggiungono l’importer come sorgenti con nome, ciascuno sotto il suo percorso all’interno della directory. La voce plugins.importer che associa l’importer nomina file propri sotto with.sources, che lo raggiungono anch’essi come sorgenti con nome, ciascuno sotto il suo nome di base — e un nome è portato da entrambi. Un nome è il modo in cui un importer distingue una sorgente da un’altra, quindi passargli entrambi lascerebbe che una delle due mettesse in ombra l’altra senza nulla che dica quale; l’importazione invece si ferma, senza consegnare nulla.

Il suo messaggio inizia così:

a file read from the directory and a file named in the importer’s with.sources have the same name (un file letto dalla directory e un file nominato nelle sorgenti dell’importer hanno lo stesso nome)

Il resto del messaggio nomina il nome e il file di with.sources, poi il rimedio:

a file read from the directory and a file named in the importer’s with.sources have the same name (name "<name>", the with.sources file "<path>"). Each source reaches the importer under one name, so rename one of the two files, or leave the file out of the importer’s with.sources (un file letto dalla directory e un file nominato nelle sorgenti dell’importer hanno lo stesso nome (nome e file di with.sources indicati). Ogni sorgente raggiunge l’importer sotto un unico nome, quindi rinomina uno dei due file, oppure lascia il file fuori dalle with.sources dell’importer)

Come risolvere: rinomina uno dei due file, oppure togli il file dal campo with.sources della voce dove la directory lo contiene già. Un file di with.sources mantiene il suo nome di base, quindi quello che incontra è un file con lo stesso nome al livello superiore della directory; un file in una directory sottostante porta quella directory nel suo nome. Quale importer trasforma una sorgente in bozze descrive il campo with.sources di una voce.

An import’s target names a capability no Recipe in the catalog binds to (La destinazione di un’importazione nomina una capacità a cui nessuna Recipe del catalogo si associa)

Un rifiuto alla trasformazione di una descrizione di sorgente esterna in bozze di file di authoring, non su un build. All’importazione è stata data una destinazione — --target su aggrega import, oppure target sullo strumento di importazione dell’assistente e sul metodo aggrega/import della sessione — così che produca la bozza di un Manifest che mappa ogni tipo di componente della bozza su una Recipe di quel provider. La destinazione è una capacità del provider, confrontata con lo spec.capability a cui si associa ogni Recipe nel catalogo del workspace, e nessuna Recipe lì si associa a quella data. Un Manifest redatto per essa non mapperebbe nulla, e ogni tipo di componente risulterebbe allora mancante dal catalogo quando ciò che è sbagliato è l’opzione stessa — il più delle volte un errore di battitura.

Non viene eseguito nulla e non viene scritto nulla. L’importazione si ferma una volta caricato il catalogo, prima che il formato della sorgente venga riconosciuto e prima che l’importer venga eseguito, quindi non viene prodotta alcuna bozza e non viene scritto alcun file, anche in un’esecuzione di prova.

Il suo messaggio inizia così:

no Recipe in the workspace’s catalog binds to the capability the import’s target names (nessuna Recipe nel catalogo del workspace si associa alla capacità nominata dalla destinazione dell’importazione)

Il resto del messaggio nomina la destinazione esattamente come è stata data e le capacità a cui le Recipes del catalogo si associano effettivamente, ciascuna una volta e in ordine, poi il rimedio:

no Recipe in the workspace’s catalog binds to the capability the import’s target names (target "<target>", the catalog’s Recipes bind to "<capability>", "<capability>"). Name one of those capabilities as the target, or leave the target out and no Manifest is drafted; nothing was drafted or written (nessuna Recipe nel catalogo del workspace si associa alla capacità nominata dalla destinazione dell’importazione (destinazione indicata, capacità a cui si associano le Recipes del catalogo). Nomina una di quelle capacità come destinazione, oppure ometti la destinazione e non viene redatto alcun Manifest; non è stato redatto né scritto nulla)

Dove il catalogo non contiene alcuna Recipe, il messaggio lo dice al posto dell’elenco, e il rimedio è aggiungere al catalogo una Recipe del provider.

Come risolvere: nomina una delle capacità che il messaggio elenca — compose o helm, per esempio, come le scrive lo spec.capability di una Recipe — oppure ometti la destinazione, il che non produce alcuna bozza di Manifest. Dove il provider che intendevi è uno per cui il catalogo non contiene ancora alcuna Recipe, aggiungi le sue Recipes a una cartella di catalogo che il workspace legge per prima. aggrega-import.md descrive che cosa redige un’importazione a cui è data una destinazione.

A child Release inherits a boundary directory that resolves where its parent writes (Una Release figlia eredita una directory di confine che si risolve dove scrive la sua Release genitore)

Un avviso. Una Release estende un’altra e ne eredita la directory di output di un confine, e quella directory non contiene alcuna variabile di template — quindi si risolve nello stesso percorso per entrambe, e il build della figlia scrive dove scrive il build del genitore.

Ereditare la directory è la forma supportata, non un errore. Una directory è un template, quindi un genitore la scrive una volta e una figlia che soddisfa un parametro la risolve altrove senza duplicare nulla; è proprio per questo che una figlia non deve ripetere la topologia dei confini del suo genitore. Ciò che è circoscritto e reale è il caso residuo che questo nomina: senza alcuna variabile al suo interno, non resta nulla da risolvere in modo diverso.

Non può arrestare nulla, e questa è una proprietà della regola, non una cautela nei suoi confronti. Scrivere nello stesso percorso risolto è qualcosa che un autore può legittimamente voler fare — una figlia che sostituisce solo le Recipes di rendering per confrontarne l’output, o che cambia solo il dimensionamento — quindi una regola che si arrestasse sulla base della deduzione rifiuterebbe un input legittimo sulla base di un’ipotesi.

Il suo messaggio inizia così:

inherited boundary directory carries no template variable, so it resolves to the path the extended Release writes to (la directory di confine ereditata non contiene alcuna variabile di template, quindi si risolve nel percorso in cui scrive la Release estesa)

Come risolvere: dove le due dovevano scrivere in posti diversi, inserisci un riferimento a un parametro nella directory e lascia che ciascuna Release lo soddisfi. Dove scrivere in un unico percorso è ciò che intendevi, non c’è nulla da cambiare — l’avviso ti ha detto che cosa farà, e il build produce comunque il suo output.

Trovare un arresto a partire dal codice breve stampato dal build

L’intestazione tra parentesi quadre di una diagnostica di arresto nomina la categoria a cui è attribuibile l’errore e, dove l’errore nomina una delle condizioni catalogate qui, il codice breve di quella condizione — la lettera E e quattro cifre, come in [CATALOG_ERROR E0209]. Un numero viene assegnato una volta e poi resta fisso, quindi un codice breve che incolli in una segnalazione o in una ricerca nomina ancora la condizione che nominava quando l’hai annotato. Gli altri due identificatori che una condizione porta, e quale dei tre usare e quando, sono spiegati in sentinels.md.

La riga di messaggio propria della condizione si apre con una frase fissa che enuncia la condizione. Tutto ciò che segue quella frase varia con l’occorrenza — il documento in errore, la chiave scritta, il valore incriminato e il consiglio per quell’occorrenza — e le voci sopra citano l’intera forma per la condizione che ciascuna documenta. La frase fissa è la parte che è sempre uguale, ed è questo che la rende la parte su cui cercare la corrispondenza.

La tabella seguente mette in relazione le due cose, limitatamente a questa pagina: per ogni condizione catalogata qui, il codice breve che un build stampa e la frase con cui si apre la sua riga di messaggio, accanto alla voce sopra che spiega la correzione da apportare in authoring. I titoli delle voci sono citati esattamente, così cercarne uno in questa pagina porta alla sua voce. La tabella di ogni condizione risolve un codice breve su ogni condizione che il compilatore dichiara, comprese quelle che nessuna voce qui copre.

Dove una voce compare accanto a due codici brevi, copre due condizioni distinte e ciascuna registra la propria frase; leggi le frasi anziché il titolo condiviso per capire quale delle due ha segnalato un build.

aggrega explain <code> esegue questa ricerca per te nel terminale, accettando uno qualsiasi dei codici della condizione e stampando la condizione insieme alla voce sopra che la documenta. È descritto in aggrega explain.

Codice breveSi apre conDocumentata in
E0001cliplugin: no plugin resolver configuredA command-line plugin runner was built without a way to find plugins (Un esecutore di plugin da riga di comando è stato costruito senza un modo per trovare i plugin)
E0003malformed attachment requirementMalformed attachment requirement (Requisito di associazione malformato)
E0004annotation contribution overridden by an explicit valueAn explicit value displaced one an annotation supplied (Un valore esplicito ha sostituito uno fornito da un’annotazione)
E0005policy violationA governance plugin rejected the build (Un plugin di governance ha rifiutato il build)
E0006required attachment slot unfilledRequired attachment slot not bound (Slot di associazione richiesto non legato)
E0007selector violationCross-node type safety violation via selector: (Violazione della sicurezza dei tipi tra nodi tramite selector)
E0008attachment slot selector unsatisfiedThe Feature filling an attachment slot does not satisfy the slot’s selector (La Feature che riempie uno slot di associazione non soddisfa il selettore dello slot)
E0009pipeline step typed-I/O contract violationA pipeline step’s typed input or output does not satisfy its declared contract (L’input o l’output tipizzato di un passo di pipeline non soddisfa il contratto dichiarato)
E0010pipeline step failedA pipeline step failed (Un passo di pipeline non è riuscito)
E0011pipeline patch targets a document not present in the setA pipeline patch addresses a document the set does not hold, or one with no tree to address (Una patch di pipeline indirizza un documento che l’insieme non contiene, o uno senza un albero da indirizzare)
E0012pipeline patch targets an opaque (non-structured) unitA pipeline patch addresses a document the set does not hold, or one with no tree to address (Una patch di pipeline indirizza un documento che l’insieme non contiene, o uno senza un albero da indirizzare)
E0013feature type mismatch between Aggregate and ReleaseFeature type mismatch between Aggregate and Release (Mancata corrispondenza del tipo di Feature tra Aggregate e Release)
E0014inject entry carries both `value:` and `from:`; schema requires exactly oneAn inject: entry carries both a literal and a source key (Una voce di inject porta sia un letterale sia una chiave di origine)
E0015uses-edge inject dictates a delivery mechanism the socket does not permituses edge dictates delivery on a socket that allowlists none (Un arco impone la consegna su un socket che non consente alcun meccanismo); uses edge dictates a delivery mechanism outside the socket’s allowlist (Un arco impone un meccanismo di consegna al di fuori dell’allowlist del socket)
E0016jsonpatch: test operation failedA patch’s test operation did not match the document (L’operazione di test di una patch non corrispondeva al documento)
E0017annotation-transform plugin output was rejected: an injection targets a component coordinate the host did not supply, or carries a value that is not a string or an object of subkeysAn annotation-transform plugin names a component it was not given, or injects a value no annotation takes (Un plugin annotation-transform indica un componente che non gli è stato fornito, o inietta un valore che nessuna annotazione accetta)
E0018policy attachment settings do not satisfy the plugin's declared settings schemaA governance attachment’s settings do not match the plugin’s declared schema (Le impostazioni di un’associazione di governance non corrispondono allo schema dichiarato dal plugin)
E0019endpoint requires form: referenceA workload: form and the fields beside it do not agree (La forma di un carico di lavoro e i campi accanto a essa non concordano)
E0020schedule is not a valid cron expressionA workload schedule: is not an expression the check accepts (La pianificazione di un carico di lavoro non è un’espressione che il controllo accetta)
E0021persistentTemplate volume requires form: statefulA workload: form and the fields beside it do not agree (La forma di un carico di lavoro e i campi accanto a essa non concordano)
E0022pipeline PATCH target is not parseable structured YAML/JSONA pipeline step addresses documents the node does not have (Un passo di pipeline indirizza documenti che il nodo non ha)
E0023form: reference requires an endpointA workload: form and the fields beside it do not agree (La forma di un carico di lavoro e i campi accanto a essa non concordano)
E0024schedule requires form: scheduledA workload: form and the fields beside it do not agree (La forma di un carico di lavoro e i campi accanto a essa non concordano)
E0025form: scheduled requires a scheduleA workload: form and the fields beside it do not agree (La forma di un carico di lavoro e i campi accanto a essa non concordano)
E0026imported artifact content does not match the digest recorded for it in entity.lockAn imported artifact no longer matches the digest recorded beside its Recipe (Un artefatto importato non corrisponde più al digest registrato accanto alla sua Recipe)
E0027artifacts $import: is not a bare-name artifact-library reference (<Library>#/artifacts/<entry>)A library $import: is not written in the bare-name form (Un’importazione di libreria non è scritta nella forma a nome nudo)
E0028artifacts output filename collision: two artifact outputs carry the same filenameTwo artifact outputs of one Recipe carry the same filename (Due output di artefatti di una stessa Recipe portano lo stesso nome di file)
E0029artifact template references a pillar the Recipe does not declareAn artifacts: template reads a pillar the Recipe does not declare (Un template di artifacts legge un pilastro che la Recipe non dichiara)
E0030artifact-library import references a bundle not present in the ArtifactLibraryA library $import: names a library or an entry the catalog does not hold (Un’importazione di libreria nomina una libreria o una voce che il catalogo non contiene)
E0031artifact-library import references an ArtifactLibrary not present in the catalogA library $import: names a library or an entry the catalog does not hold (Un’importazione di libreria nomina una libreria o una voce che il catalogo non contiene)
E0032assembled output collision: two contributors write the same output pathTwo contributors write the same output path (Due contributori scrivono lo stesso percorso di output)
E0033assertion failedAn assertion stopped the build (Un’asserzione ha fermato il build)
E0034duplicate delivery key across attachment-inject and another inject sourceAn attachment delivers a key another inject source already claimed (Un’associazione consegna una chiave già rivendicata da un’altra fonte di inject)
E0035provider expected to assemble its dispatch group provides no boundary assemblerThe plugin serving a provider cannot assemble what that provider combines (Il plugin che serve un provider non può assemblare ciò che quel provider combina)
E0036merged-path assembly has conflicting assembly-name annotation valuesChart-name mismatch on a merged helm-chart umbrella (Nome di chart non corrispondente in un chart ombrello helm-chart unito)
E0037cross-boundary link between endpoints rendered by different providers is not supportedA connection crosses between two different providers’ assembled outputs (Una connessione attraversa gli output assemblati di due provider diversi)
E0038derived name collision: one name is derived more than once in one key spaceThe same name is derived more than once inside the output (Lo stesso nome viene derivato più di una volta all’interno dell’output)
E0039FeatureRecipe template references a per-component-only field with executionScope: boundaryFeatureRecipe template references a field outside its scope’s allowlist (Il template della FeatureRecipe fa riferimento a un campo al di fuori dell’allowlist del suo livello)
E0040library $import: carries a registry host; reference the library by bare-name identityA library $import: addresses its library by registry location (Un’importazione di libreria indirizza la sua libreria tramite la posizione nel registry)
E0041multiple contributors share an instance ID at the same dispatch pathInstance-ID collision across boundaries assembling to the same path (Collisione di ID di istanza tra confini che si assemblano sullo stesso percorso)
E0042locals entry references a sibling defined later in the same blocklocals: entry references a sibling defined later in the same block (Una voce di locals fa riferimento a una voce sorella definita più avanti nello stesso blocco)
E0043template references a key the locals block does not declarelocals: key does not exist (La chiave di locals non esiste)
E0044mapping-library import references an entry not present in the MappingLibraryA library $import: names a library or an entry the catalog does not hold (Un’importazione di libreria nomina una libreria o una voce che il catalogo non contiene)
E0045valuesMapping $import: is not a bare-name mapping-library reference (<Library>#/mappings/<entry>)A library $import: is not written in the bare-name form (Un’importazione di libreria non è scritta nella forma a nome nudo)
E0046mapping-library import references a MappingLibrary not present in the catalogA library $import: names a library or an entry the catalog does not hold (Un’importazione di libreria nomina una libreria o una voce che il catalogo non contiene)
E0047assembled output retains an unresolved cross-boundary link placeholderAssembled output still carries a cross-boundary placeholder (L’output assemblato porta ancora un segnaposto tra confini)
E0048dispatch path produced multiple provider outputsPath collision: two contributors emit at incompatible paths (Collisione di percorsi: due contributori emettono su percorsi incompatibili)
E0049path template references a field not in the documented allowlistPath-template references a variable outside the allowlist (Il template di percorso fa riferimento a una variabile al di fuori dell’allowlist)
E0050pipeline /host operation from a step with no host componentA pipeline step addresses documents the node does not have (Un passo di pipeline indirizza documenti che il nodo non ha)
E0051pipeline PATCH targets an assembler provider's pre-assembly fragmentsA pipeline patch addresses output that has not been assembled yet (Una patch di pipeline indirizza un output che non è ancora stato assemblato)
E0052pipeline PATCH targets a document the node did not emitA pipeline step addresses documents the node does not have (Un passo di pipeline indirizza documenti che il nodo non ha)
E0053pipeline plugin is not compatible with the rendering providerA pipeline step’s plugin does not claim the provider rendering what it addresses (Il plugin di un passo di pipeline non rivendica il provider che esegue il rendering di ciò che il passo indirizza)
E0054provider rejected node inputA provider refused a node’s input (Un provider ha rifiutato l’input di un nodo)
E0055Recipe or FeatureRecipe does not publish a provides key its abstract entity's schema.provides contract declaresA Recipe or FeatureRecipe does not publish a provides key its contract declares (Una Recipe o una FeatureRecipe non pubblica una chiave provides che il suo contratto dichiara)
E0056provides template evaluation failedA provides: template could not be evaluated (Un template di provides non può essere valutato)
E0057provides block references a root outside the self-contained setprovides: template references a non-self-contained root (Il template di provides fa riferimento a una radice non autocontenuta)
E0058provider render is not deterministicA provider rendered the same input twice and produced different output (Un provider ha renderizzato due volte lo stesso input e ha prodotto output diversi)
E0059duplicate delivery key across self-inject and uses-injectDuplicate delivery key across inject sources (Chiave di consegna duplicata tra le fonti di inject)
E0060template references a root the render context does not defineTemplate references a root the render context does not define (Il template fa riferimento a una radice che il contesto di rendering non definisce); Self-inject value template references cross-node data (Il template del valore di self-inject fa riferimento a dati tra nodi)
E0061unknown providerUnknown provider (Provider sconosciuto)
E0062custom inject mechanism has no matching key in injectMapping output; add the mechanism's key to the Recipe injectMappingA component declares an inject mechanism the attached Feature maps nothing to (Un componente dichiara un meccanismo di inject a cui la Feature associata non mappa nulla)
E0063workload-library import references an entry not present in the WorkloadLibraryA library $import: names a library or an entry the catalog does not hold (Un’importazione di libreria nomina una libreria o una voce che il catalogo non contiene)
E0064workload $import: is not a bare-name workload-library reference (<Library>#/workloads/<entry>)A library $import: is not written in the bare-name form (Un’importazione di libreria non è scritta nella forma a nome nudo)
E0065workload-library import references a WorkloadLibrary not present in the catalogA library $import: names a library or an entry the catalog does not hold (Un’importazione di libreria nomina una libreria o una voce che il catalogo non contiene)
E0066uses edge target does not existDangling uses target (Destinazione di arco pendente)
E0067active toggle did not resolve to a booleanAn active: toggle does not resolve to true or false (Un interruttore non si risolve in true o false)
E0068max sub-aggregate nesting depth exceededSub-aggregate nesting depth exceeded (Profondità di annidamento dei sub-aggregati superata)
E0069mutator patch rejectedA label-transform plugin’s patch reaches outside node labels (La patch di un plugin label-transform va oltre le etichette dei nodi)
E0070re-exported component alias forms a cycleA re-published component alias points back at itself (Un alias di componente ripubblicato punta a sé stesso)
E0071release edge retargets a developer-declared edgeRelease retargets a developer-declared edge (La Release cambia la destinazione di un arco dichiarato dallo sviluppatore)
E0072sub-aggregate load failedA module a composition imports cannot be loaded, or imports itself (Un modulo che una composizione importa non può essere caricato, oppure importa sé stesso)
E0073flattened node ID collision: rename one of the colliding instances so their flattened IDs differTwo instances flatten to one identifier (Due istanze si appiattiscono in un unico identificatore)
E0074release per-edge configuration has no edge to apply toRelease per-edge configuration has no edge to apply to (La configurazione per arco della Release non ha alcun arco a cui applicarsi)
E0075aggregate reached topology un-normalized (non-empty root components alongside a synthesized default subsystem)An Aggregate reached graph building without being normalised (Un Aggregate è arrivato alla costruzione del grafo senza essere stato normalizzato)
E0076sub-module placed in no boundary: route it into a boundary under `aggregates`, or name its components there under `components`A sub-module’s components are placed in no boundary (I componenti di un sottomodulo non sono collocati in alcun confine)
E0077uses edge target was pruned because its active toggle resolved to falseA uses edge targets a component an active: toggle removed (Un arco ha come destinazione un componente rimosso da un interruttore)
E0078producer-consumption re-entry denied: a producer reached through the host may not issue a further producer-consumption callA plugin asks the host to parse a source while a parse is already running for it (Un plugin chiede all’host di analizzare una sorgente mentre è già in corso un’analisi per suo conto)
E0079wasm: recorded command mirror does not match plugin describe()A Plugin entity’s recorded command set does not match the plugin (L’insieme di comandi registrato di un’entità Plugin non corrisponde al plugin)
E0080wasm: entity contract claim does not match plugin describe()A Plugin entity’s claims disagree with the plugin’s own self-report (Le affermazioni di un’entità Plugin non concordano con l’autodescrizione del plugin stesso)
E0081wasm: guest plugin returned a diagnostic whose severity the contract does not declareA plugin returned a diagnostic at a severity that is not declared (Un plugin ha restituito una diagnostica con una severità non dichiarata)
E0082wasm: guest plugin reported an errorA plugin failed while it was running (Un plugin non è riuscito durante l’esecuzione)
E0083wasm: guest plugin panicked during callA plugin failed while it was running (Un plugin non è riuscito durante l’esecuzione)
E0084wasm: stamped host-function record does not match .wasm importsA Plugin entity’s recorded host functions do not match the binary (Le funzioni host registrate di un’entità Plugin non corrispondono al binario)
E0085wasm: plugin rejected by the sandboxThe sandbox refused a plugin (La sandbox ha rifiutato un plugin)
E0086wasm: plugin invoked proc_exitA plugin failed while it was running (Un plugin non è riuscito durante l’esecuzione)
E0087wasm: declared plugin type does not match plugin describe()A plugin is not the kind of plugin the socket expects (Un plugin non è del tipo di plugin che il socket si aspetta)
E0088wasm: entity metadata.version does not match plugin describe()A Plugin entity’s recorded version does not match the plugin (La versione registrata di un’entità Plugin non corrisponde al plugin)
E0089every published version this reference could select has been withdrawnEvery version a reference could select has been withdrawn (Ogni versione che un riferimento potrebbe selezionare è stata ritirata)
E0090format is advertised by more than one importer pluginA parse or import format is advertised by more than one plugin (Un formato di parsing o di importazione è annunciato da più di un plugin)
E0091format is advertised by more than one parser pluginA parse or import format is advertised by more than one plugin (Un formato di parsing o di importazione è annunciato da più di un plugin)
E0092capability is served by more than one provider plugin; add a plugins.providers entry to select oneA capability is served by more than one provider plugin (Una capacità è servita da più di un plugin provider)
E0093manifest maps multiple version-distinct keys to the same base type; the type-to-recipe lookup is ambiguousA Manifest maps two version-distinct keys onto one type (Un Manifest mappa due chiavi distinte per versione su un unico tipo)
E0094duplicate entity identity within a single catalog directoryTwo catalog entities in one directory share an identity (Due entità del catalogo in una stessa directory condividono un’identità)
E0095malformed recipe reference in a Manifest mapping valueManifest mapping value is not a shape a recipe reference accepts (Il valore di mappatura del Manifest non ha una struttura accettata da un riferimento a ricetta)
E0096manifest mapping entry's recipe spec.implements does not match the mapped component-type / feature-type keyRecipe implements does not match the mapped component type (La dichiarazione di implementazione della Recipe non corrisponde al tipo di componente mappato)
E0097no importer plugin advertises the requested formatNo plugin advertises a requested parse or import format (Nessun plugin annuncia un formato di parsing o di importazione richiesto)
E0098no parser plugin advertises the requested formatNo plugin advertises a requested parse or import format (Nessun plugin annuncia un formato di parsing o di importazione richiesto)
E0099no recipe resolved for component/feature instance: add an explicit Manifest mapping for its typeNo Recipe is mapped for a component or feature instance (Nessuna Recipe è mappata per un’istanza di componente o di funzionalità)
E0100plugins.providers entry names a plugin no provider-rendering plugin serving the capability matchesA plugins.providers binding names a plugin that does not serve the capability (Un binding nomina un plugin che non serve la capacità)
E0101no provider-rendering plugin version satisfies the recipe's provider version pinNo provider plugin version satisfies a Recipe’s provider pin (Nessuna versione di plugin provider soddisfa il pin del provider di una Recipe)
E0102wasm plugin reference must be the plugin coordinate identity (<pluginType>/<name>:<version>), not a registry-qualified or artifact pathA plugin reference carries a registry host or an artifact path (Un riferimento a un plugin contiene un host di registry o un percorso di artefatto)
E0103no catalog version satisfies the referenced version constraintNo catalog version satisfies a version constraint (Nessuna versione del catalogo soddisfa un vincolo di versione)
E0104wasm plugin reference must carry a pluginType scope (<pluginType>/<name>); an empty scope cannot bind to an OCI locationA plugin or recipe reference carries no scope (Un riferimento a un plugin o a una ricetta non ha un ambito)
E0105recipe reference must be provider-scoped (<provider>/<name>); an empty provider cannot bind to an OCI locationA plugin or recipe reference carries no scope (Un riferimento a un plugin o a una ricetta non ha un ambito)
E0106resolve: invalid library reference URIA library reference is not written in the identity form (Un riferimento a libreria non è scritto nella forma di identità)
E0107resolve: minimal version selection conflict — incompatible library version requirementsTwo consumers of one library require incompatible versions (Due consumatori di una libreria richiedono versioni incompatibili)
E0108resolve: catalog lookup cannot load resolved sub-aggregate bodiesThe catalog view a build was given cannot load the bodies pinning needs (La vista del catalogo fornita a un build non può caricare i corpi di cui il pinning ha bisogno)
E0109resolve: catalog lookup cannot load resolved recipe and plugin bodiesThe catalog view a build was given cannot load the bodies pinning needs (La vista del catalogo fornita a un build non può caricare i corpi di cui il pinning ha bisogno)
E0110resolve: source-template evaluation failure at lock timeResolving a source: coordinate registers a narrower function set (La risoluzione di una coordinata source registra un insieme di funzioni più ristretto)
E0111resolve: source-template parse errorResolving a source: coordinate registers a narrower function set (La risoluzione di una coordinata source registra un insieme di funzioni più ristretto)
E0112resolve: source-template references .provides (invalid reverse reference)Resolving a source: coordinate registers a narrower function set (La risoluzione di una coordinata source registra un insieme di funzioni più ristretto)
E0113resolve: sub-aggregate inclusion depth exceededThe chain of module imports is deeper than the pin walk descends (La catena di importazioni di moduli è più profonda di quanto scenda la visita del pinning)
E0114resolve: no entity in the catalog matches this URIA reference names no entity the catalog holds (Un riferimento non nomina alcuna entità contenuta nel catalogo)
E0115compactform: ambiguous dispatch — $mode requiredA compact-form schema declares a field literally named type (Uno schema in forma compatta dichiara un campo che si chiama letteralmente così)
E0116compactform: constraint not valid for declared typeA compact-form constraint does not apply to the type it was written on (Un vincolo in forma compatta non si applica al tipo su cui è stato scritto)
E0117compactform: $jsonschema content invalidA $jsonschema: escape carries content that is not a schema (Un escape contiene un contenuto che non è uno schema)
E0118compactform: cross-document $ref carries a registry host; reference the library by identityA $ref: addresses a library by registry location (Un riferimento indirizza una libreria tramite la sua posizione nel registry)
E0119compactform: $ref unresolvableA $ref: is not written in a form the compiler can resolve (Un riferimento non è scritto in una forma che il compilatore sa risolvere)
E0120compactform: unknown keywordA compact-form schema uses a keyword the compact form does not know (Uno schema in forma compatta usa una parola chiave che la forma compatta non conosce)
E0121compactform: cross-document $ref target not foundA $ref: is not written in a form the compiler can resolve (Un riferimento non è scritto in una forma che il compilatore sa risolvere)
E0122deprecation: build consumes a deprecated entityThe build consumes an artifact its publisher has deprecated (La build consuma un artefatto che il suo editore ha deprecato)
E0123docscache: artifact is not a documentation bundleA resolved artifact is not a documentation bundle (Un artifact risolto non è un bundle di documentazione)
E0124docscache: page not found in documentation bundleA page is absent from a documentation bundle (Una pagina è assente da un bundle di documentazione)
E0125egress: network access refused because the workspace is offline; remediation: pass `--offline=false` to allow the network for this one run, or clear the top-level `offline` key in the configuration file (or AGGREGA_OFFLINE) to allow it from now on; where the work is a build that needs content the machine does not have, run `aggrega pull --release <release>` from a connected environment first to populate the cacheThe workspace is offline and the step needs the network (Il workspace è offline e lo step richiede la rete)
E0126externalinputs: acquisition is disabled for unpinned inputsA render requests an external input the lockfile does not pin (Un rendering richiede un input esterno che il lockfile non fissa)
E0127externalinputs: fetched bytes mismatch the pinned digestFetched bytes do not match a pinned digest (I byte scaricati non corrispondono a un digest fissato)
E0128externalinputs: URL scheme is not allowedAn external input’s URL uses a scheme that is not allowed (L’URL di un input esterno usa uno schema non consentito)
E0129externalinputs: store blob mismatches its pinned recordA stored external input no longer matches its record (Un input esterno archiviato non corrisponde più al suo record)
E0130lockfile: out of date; it no longer matches what its Release resolves toThe lockfile no longer matches what the release resolves to (Il lockfile non corrisponde più a ciò in cui si risolve la Release)
E0131lockfile: file failed schema validationThe lockfile does not satisfy its schema (Il lockfile non soddisfa il proprio schema)
E0132oci: manifest has multiple layers of the expected content media typeA manifest carries no layer of the expected kind, or more than one (Un manifesto non contiene alcun layer del tipo atteso, oppure ne contiene più di uno)
E0133oci: cached manifest digest mismatchFetched or cached bytes do not match the digest committed for them (I byte scaricati o in cache non corrispondono al digest dichiarato per essi)
E0135oci: content digest mismatchFetched or cached bytes do not match the digest committed for them (I byte scaricati o in cache non corrispondono al digest dichiarato per essi)
E0136oci: network unreachableThe registry could not be reached (Il registry non è raggiungibile)
E0137oci: artifact not found at remote sourceAn artifact is not at the source the build was told to find it (Un artifact non si trova nella sorgente in cui al build è stato detto di trovarlo)
E0138oci: authentication required or failedThe registry will not serve an artifact without credentials it accepts (Il registry non fornisce un artifact senza credenziali che accetti)
E0139oci: tag already published with different contentA tag is already published with different content (Un tag è già pubblicato con un contenuto diverso)
E0140oci: manifest has no layer of the expected content media typeA manifest carries no layer of the expected kind, or more than one (Un manifesto non contiene alcun layer del tipo atteso, oppure ne contiene più di uno)
E0141oci: distinct catalog identities map to the same OCI repository locationTwo catalog identities publish to one repository location (Due identità del catalogo pubblicano in una stessa posizione di repository)
E0142oci: referrer discovery could not be completedThe registry could not answer what is attached to an artifact (Il registry non ha potuto rispondere su ciò che è associato a un artifact)
E0143oci: unknown entity kind for mediatype dispatchAn entity kind has no artifact media type (Un tipo di entità non ha un tipo di media dell’artifact)
E0144cached signature bundle does not match its recorded digestA cached signature bundle does not match the digest recorded for it (Un bundle di firma in cache non corrisponde al digest registrato per esso)
E0145plugin reference is not a Plugin entityA plugin reference is not a Plugin entity (Un riferimento a un plugin non è un’entità Plugin)
E0146circular reference expansionA library reference expands into itself (Un riferimento a una libreria si espande in se stesso)
E0147registrytrust: advertised trust config is malformedA registry serves a trust document that cannot be read as one (Un registry serve un documento di fiducia che non può essere letto come tale)
E0148registrytrust: registry advertises no trust configA registry publishes no trust document (Un registry non pubblica alcun documento di fiducia)
E0149attachment name is a near miss for a declared slotAn attachment name is one edit from a declared slot (Un nome di associazione è a una modifica di distanza da uno slot dichiarato)
E0150attachment does not conform to its declared slot shapeAttachment does not conform to its declared slot shape (L’associazione non è conforme alla forma dichiarata del suo slot)
E0151component declared in more than one boundary: declare each component in exactly one boundaryA component is placed in more than one boundary (Un componente è collocato in più di un confine)
E0152duplicate Aggregate/Manifest identity (metadata.name) in the Release directoryThe Release directory declares one Aggregate or Manifest twice (La directory della Release dichiara due volte un Aggregate o un Manifest)
E0153feature merge conflict: reconcile the Aggregate and Release declarations for the featureA feature attached by both the Aggregate and the Release cannot be merged (Una funzionalità associata sia dall’Aggregate sia dalla Release non può essere unita)
E0154the compiler's own views of the catalog disagreeA guard needs a catalog entity the build resolved and cannot see (Una guardia ha bisogno di un’entità del catalogo che il build ha risolto e che non riesce a vedere)
E0155duplicate delivery key across inject sourcesDuplicate delivery key across inject sources (Chiave di consegna duplicata tra le fonti di inject)
E0156invalid inject key: the from-key must name a provides key its source publishesInject from key is not in the target’s provides (La chiave di inject non figura tra ciò che la destinazione fornisce)
E0158invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go templateA {{ .parameters.* }} reference cannot be interpolated (Un riferimento ai parametri non può essere interpolato)
E0160manifest annotation bindings collide on same Feature path+pillarTwo Manifest annotation bindings compete for one routing slot (Due binding di annotazione del Manifest competono per un unico slot di instradamento)
E0161manifest annotation binding uses reserved prefixA Manifest annotation binding claims the reserved aggrega.ai/ prefix (Un binding di annotazione del Manifest rivendica il prefisso riservato)
E0162missing required feature: attach a Feature of the required type to the componentRequired feature not attached (Funzionalità richiesta non associata)
E0163required uses socket not populatedRequired uses: socket not populated (Socket richiesto non popolato)
E0164parameter contract violatedParameter type mismatch / contract violation (Tipo di parametro non corrispondente / violazione del contratto)
E0165required parameter not suppliedParameter type mismatch / contract violation (Tipo di parametro non corrispondente / violazione del contratto)
E0167Recipe publishes a provides key its Component does not declareA Recipe publishes a provides key its Component does not declare (Una Recipe pubblica una chiave che il suo Component non dichiara)
E0168authored pillar does not conform to its declared schemaAuthored values or infra do not conform to the declared schema (I values o gli infra scritti non sono conformi allo schema dichiarato)
E0169self-inject on component without spec.inject allowlistSelf-inject on a component without an allowlist (Self-inject su un componente senza allowlist); Self-inject mechanism not in the component’s allowlist (Meccanismo di self-inject non presente nell’allowlist del componente)
E0170aggregate/manifest reference unresolvableA Release’s aggregate: or manifest: reference resolves to nothing (Il riferimento di una Release non si risolve in nulla)
E0171unknown uses socket: name a socket the entity declares in its usesSchema — only a component's own uses block may name one the catalog did not declareuses: socket not declared in the owning entity’s usesSchema (Socket non dichiarato nello schema dei socket dell’entità proprietaria)
E0172release reached resolve un-normalized (non-empty root components alongside a synthesized default boundary)A Release reached resolution without passing through the load path (Una Release ha raggiunto la risoluzione senza passare per il percorso di caricamento)
E0173declared parameter is read by no reference in the AggregateA declared parameter is read by nothing (Un parametro dichiarato non è letto da nulla)
E0174uses socket name is a near miss for a declared socketA uses: socket name is one edit from a declared socket (Un nome di socket è a una modifica di distanza da un socket dichiarato)
E0175file load failed: the file could not be read, or its bytes did not parseA file cannot be read, or its bytes do not parse (Un file non può essere letto, oppure i suoi byte non superano l’analisi sintattica)
E0176signing: keyless signing requires a live identity provider, Fulcio, and RekorKeyless signing was asked for without the services it needs (La firma senza chiave è stata richiesta senza i servizi di cui ha bisogno)
E0177signing: no signature found for an artifact that requires oneAn artifact that must be signed carries no signature (Un artifact che deve essere firmato non porta alcuna firma)
E0178signing: keyless verification requires at least one trusted identityA keyless trust policy names no acceptable signer (Una policy di fiducia senza chiave non nomina alcun firmatario accettabile)
E0179signing: signature does not verifyA detached signature does not verify against the key supplied (Una firma separata non supera la verifica con la chiave fornita)
E0180signing: signature bundle does not verifyA signature does not verify (Una firma non supera la verifica)
E0181signing: signing policy requires a signature for this artifact kind; refusing to push unsigned contentAn unsigned publish targets a registry or a policy that requires a signature (Una pubblicazione non firmata è destinata a un registry o a una policy che richiede una firma)
E0182signing: cannot load pinned trust rootThe pinned trust root cannot be read (La radice di fiducia fissata non può essere letta)
E0183signing: registry requires signatures; refusing to push unsigned contentAn unsigned publish targets a registry or a policy that requires a signature (Una pubblicazione non firmata è destinata a un registry o a una policy che richiede una firma)
E0184signing: unsupported held-key typeA pinned verification key is not the key profile the verifier accepts (Una chiave di verifica fissata non è del profilo di chiave che il verificatore accetta)
E0185signing: signature identity is not trusted for this registryA signature verifies but its signer is not one the registry trusts (Una firma supera la verifica, ma il suo firmatario non è uno di cui il registry si fida)
E0186no source adapter serves the source kindA Recipe’s source: names a kind nothing knows how to acquire (La sorgente di una Recipe indica un tipo che nulla sa come acquisire)
E0187cacheslot: empty workspaceRootA source artifact is cached without a workspace root to anchor it (Un artifact sorgente viene messo in cache senza una radice del workspace a cui ancorarlo)
E0188artifacts entry: shape must be a string scalar or {$import: <local-path>}An inline-or-import field is written in neither shape (Un campo inline o import non è scritto in nessuna delle due forme)
E0189artifactlibrary: entry must be a mapping of filename to a string bodyA library entry’s body is not the shape that library holds (Il corpo di una voce di libreria non ha la forma che quella libreria contiene)
E0190schemalibrary: forbidden JSON Schema keywordA schema uses a JSON Schema keyword the library does not admit (Uno schema usa una parola chiave JSON Schema che la libreria non ammette)
E0191mappinglibrary: entry body must be a string scalarA library entry’s body is not the shape that library holds (Il corpo di una voce di libreria non ha la forma che quella libreria contiene)
E0192a document nests too many levels deepA document nests deeper than the reader will descend (Un documento è annidato più in profondità di quanto il lettore scenda)
E0193parameters: shape must be an inline object or {$import: <local-path>}A Release’s parameters: block is written in neither of its two shapes (Il blocco dei parametri di una Release non è scritto in nessuna delle sue due forme)
E0194schemalibrary: template not foundA $instantiate: reference cannot be resolved (Un riferimento non può essere risolto)
E0195schemalibrary: template parameter missingA $instantiate: reference cannot be resolved (Un riferimento non può essere risolto)
E0196schemalibrary: template parameter type mismatchA $instantiate: reference cannot be resolved (Un riferimento non può essere risolto)
E0197valuesmapping: shape must be a string scalar or {$import: <path-or-library-identity>}An inline-or-import field is written in neither shape (Un campo inline o import non è scritto in nessuna delle due forme)
E0198wellKnownAnnotations: a key is declared at a scope the provider's contract does not renderA provider declares a well-known annotation at a scope it does not render (Un provider dichiara un’annotazione well-known a un livello che non renderizza)
E0199workloadlibrary: entry body must be a string scalarA library entry’s body is not the shape that library holds (Il corpo di una voce di libreria non ha la forma che quella libreria contiene)
E0200workload: shape must be a string scalar or {$import: <path-or-library-identity>}An inline-or-import field is written in neither shape (Un campo inline o import non è scritto in nessuna delle due forme)
E0201assertion name declared twice across the extends chainAn assertion name is declared twice along an extends: chain (Il nome di un’asserzione è dichiarato due volte lungo una catena di estensione)
E0202cyclic extends chainCyclic extends chain (Catena extends ciclica); Cyclic extends on Components or Features (Extends ciclico su Components o Features)
E0204FeatureRecipe: valuesMapping requires sourceA FeatureRecipe’s valuesMapping requires source (La mappatura dei valori di una FeatureRecipe richiede una sorgente)
E0205inheritance merge failedAn extends: chain cannot be assembled (Una catena di estensione non può essere assemblata)
E0207recipe output-component-labels constraint: key is also declared in outputLabelsA promoted component label is also declared literally (Un’etichetta di componente promossa è dichiarata anche letteralmente)
E0208recipe output-labels constraint: key uses a reserved namespaceAn output-label key uses a reserved namespace (Una chiave di etichetta di output usa un namespace riservato)
E0209Recipe: valuesMapping requires sourcevaluesMapping requires source (la mappatura dei valori richiede una sorgente)
E0210Recipe: at least one input kind requiredAt least one input kind must be present (Deve essere presente almeno un tipo di input)
E0211filename collision across input kinds: two input-kind blocks produced a file under one output nameEmission-time filename collision across input kinds (Collisione di nomi di file in fase di emissione tra tipi di input)
E0212workload attachment slot is not referenceableA Workload references a slot whose fill publishes no locator (Un Workload fa riferimento a uno slot il cui riempimento non pubblica alcun localizzatore)
E0213workload featuresSchema cross-check failedA Workload attachment names a slot the entity does not declare, or a delivery the slot forbids (Un’associazione del Workload nomina uno slot che l’entità non dichiara, o una consegna che lo slot vieta)
E0214workload validation failedA Workload does not satisfy the Workload schema (Un Workload non soddisfa lo schema Workload)
E0215document envelope validation failedYAML anchor aliased inside its own content (Ancora YAML richiamata tramite alias all’interno del proprio contenuto); Divergent Release (extends + aggregate pointer) (Release divergente (extends + puntatore aggregate))
E0216validator/jsonschema: x-aggrega extension evaluation failedAn x-aggrega-when: or x-aggrega-validate: predicate cannot be evaluated (Un predicato non può essere valutato)
E0218validator/jsonschema: schema resolution failedA declared schema cannot be resolved (Uno schema dichiarato non può essere risolto)
E0220extends chain exceeds maximum depthAn extends: chain runs past the depth bound (Una catena di estensione supera il limite di profondità)
E0221merger: invalid merge inputThe schema-merge step’s own input guard (La protezione dell’input propria della fase di unione degli schemi)
E0222registry alias matches more than one hostA registry alias matches more than one host (Un alias di registry corrisponde a più di un host)
E0223a cross-cutting socket is bound by capability but attaches by uriA plugin binding sets a key the socket it attaches to does not read (Un binding di plugin imposta una chiave che il socket a cui si associa non legge)
E0224workspace configuration is invalidThe workspace configuration is invalid (La configurazione del workspace non è valida)
E0225capability is bound to more than one provider pluginA capability is bound to more than one provider plugin (Una capacità è legata a più di un plugin provider)
E0226registry alias is already used by another hostA registry alias is already bound to another host (Un alias di registry è già legato a un altro host)
E0227a governance attachment declares no role or an unknown roleA governance attachment declares no role, or one that is not a known role (Un’associazione di governance non dichiara alcun ruolo, o ne dichiara uno che non è un ruolo noto)
E0228a provider socket binding sets a field with no referent on that socketA plugin binding sets a key the socket it attaches to does not read (Un binding di plugin imposta una chiave che il socket a cui si associa non legge)
E0229position out of rangeAn editor position falls outside the document (Una posizione dell’editor cade fuori dal documento)
E0246the digest recorded as trusted for this plugin does not match the digest its cached manifest reportsA trusted plugin’s recorded digest disagrees with the cached artifact (Il digest registrato di un plugin attendibile non concorda con l’artefatto in cache)
E0247a plugin recorded as trusted for an accept-or-reject verdict is no longer attached at any verdict roleA plugin recorded as a trusted gate is no longer attached (Un plugin registrato come controllo attendibile non è più associato)
E0248wasm: guest plugin returned an output that is not the shape the socket readsA plugin returned something that is not the shape the socket reads (Un plugin ha restituito qualcosa che non ha la struttura che il socket legge)
E0250provider named a directory for each contributor's own sub-directory that is not a single directory nameA provider named a directory for a contributor that is not one directory (Un provider ha nominato per un contributore una directory che non è una singola directory)
E0251recipe source is an empty string, which names neither sourceless mode nor sourced modeRecipe source: is an empty string (Il campo source della Recipe è una stringa vuota)
E0252artifact-library bundle file name does not name a file of its own beneath the artifacts key its output is nested underAn ArtifactLibrary bundle file names no file of its own under the key it was imported at (Un file di bundle di un’ArtifactLibrary non nomina alcun file proprio sotto la chiave in cui è stato importato)
E0253annotation binding does not resolve against its target FeatureAnnotation binding does not resolve against its target Feature (Il binding dell’annotazione non si risolve rispetto alla sua Feature di destinazione)
E0254annotation subkey does not conform to the target Feature's schema at the routed pillarA bound annotation value does not conform to the target Feature’s schema (Un valore di annotazione legato non è conforme allo schema della Feature di destinazione)
E0255annotation routes through a pillar its authoring side may not useAn annotation routes through a pillar its authoring side may not use (Un’annotazione è instradata attraverso un pilastro che il suo lato di redazione non può usare)
E0256annotation binding declares one path in both pillar listsAn annotation binding declares one path in both pillar lists (Un binding di annotazione dichiara uno stesso percorso in entrambi gli elenchi dei pilastri)
E0257declared schema contract could not be compiled into a usable schema, so nothing was validated against it: correct the contract where it is declared, or remove it if the configuration it covers needs no validationA declared schema contract cannot be read as a schema (Un contratto di schema dichiarato non può essere letto come schema)
E0259attachment binds a FeatureRecipe with executionScope: boundary and no boundary holding the component declares itA boundary-scope Feature is attached only to a component (Una Feature con ambito di confine è associata solo a un componente)
E0260component placed in no boundary: name it under a boundary's `components`, or place the sub-module that contributes it under `aggregates`A component the composition holds is placed in no boundary (Un componente contenuto nella composizione non è collocato in alcun confine)
E0261boundary names a component the composition does not hold: correct the name, or remove the entryA boundary names a component the composition does not hold (Un confine nomina un componente che la composizione non contiene)
E0262component identity cannot be the name its emitted resources are stamped with: rename the componentComponent identity cannot be stamped on what it emits (L’identità del Component non può marcare ciò che esso emette)
E0263the target will not accept a name derived from this component's authored identity: rename the componentThe target will not accept a name derived from an authored identity (La destinazione non accetta un nome derivato da un’identità scritta)
E0264provider guest never accepted a component identity the compiler composed for itA provider never accepted a name the compiler composed (Un provider non ha mai accettato un nome composto dal compilatore)
E0265provider does not support the node's input kindworkload: requires a provider that can synthesize (richiede un provider in grado di eseguire la sintesi)
E0266a schema `$import:` could not be appliedA schema $import: cannot be applied (Non è possibile applicare un’importazione di schema)
E0267a schema block declares a key that names no data pillarA schema block names a key that is not a data pillar (Un blocco di schema nomina una chiave che non è un pilastro dei dati)
E0268reassemble names a patched unit token the carve did not produce; a conforming codec carves and reassembles a file under the same tokensA provider’s reassembly is handed a unit its own carve never produced (Al riassemblaggio di un provider viene passata un’unità che la sua stessa suddivisione non ha mai prodotto)
E0269provider guest returned two output files under one path; a conforming guest returns each output path at most onceA provider returned two output files under one path (Un provider ha restituito due file di output sotto un unico percorso)
E0270link patch names an output file the dispatch group did not emit; a conforming link patch names a file the group's own render returnedA provider’s link wiring names an output file that was never emitted (Il cablaggio di collegamento di un provider nomina un file di output che non è mai stato emesso)
E0271emit_file side effect carries no file; a conforming emit_file side effect carries a file with its path and contentA pipeline step’s file emission carries no file (L’emissione di file di un passo di pipeline non porta alcun file)
E0272side effect declares a kind the plugin contract does not define; a conforming side effect declares emit_file or emit_crdA pipeline step declares an emission kind the contract does not define (Un passo di pipeline dichiara un tipo di emissione che il contratto non definisce)
E0273template reads the name the target gives the resources it renders for the node, and this node's provider reports no such name; a conforming template reads a value the node's own provider suppliesA template reads a rendered name the node’s provider does not report (Un template legge un nome renderizzato che il provider del nodo non riporta)
E0274the plugin identity recorded as trusted no longer matches what this resolution reportsA gate recorded as trusted resolves to a different identity (Un controllo registrato come attendibile si risolve in un’identità diversa)
E0275the edit was refused because the resulting document would not be valid, and nothing was writtenAn edit would produce a document its schema refuses (Una modifica produrrebbe un documento che il suo schema rifiuta)
E0276the version being published changes the published predecessor in a way the documented evolution rubric objects toThe change being published breaks what the evolution rubric allows (La modifica in corso di pubblicazione viola ciò che la griglia di evoluzione consente)
E0277an annotation key on the entity uses a prefix the platform reservesAn annotation key uses a prefix the platform reserves (Una chiave di annotazione usa un prefisso che la piattaforma riserva)
E0278the entity's name does not follow the documented name shape for its kindAn entity’s name does not follow the shape its kind expects (Il nome di un’entità non segue la forma che il suo tipo prevede)
E0279a schema in the entity uses a dynamic reference construct that cross-document reference resolution cannot followA schema uses a dynamic reference that cannot be resolved ahead of time (Uno schema usa un riferimento dinamico che non può essere risolto in anticipo)
E0280a schema in the entity declares an identifier of its own, where the platform owns that schema's identityA schema declares an identifier the platform owns (Uno schema dichiara un identificatore che appartiene alla piattaforma)
E0281the entity's category label does not match the category directory the entity is filed underA Component’s category label and its directory name different categories (L’etichetta di categoria di un Component e la sua directory nominano categorie diverse)
E0282the entity writes an Aggrega schema extension directly into schema content instead of declaring it under usesSchema or featuresSchemaA schema extension is written directly into schema content (Un’estensione di schema è scritta direttamente nel contenuto dello schema)
E0283the Plugin entity declares no runtime resource cap of its own, so the platform defaults applyA Plugin pins neither runtime cap, so the platform’s own apply (Un Plugin non fissa nessuno dei due limiti di runtime, quindi si applicano quelli della piattaforma)
E0284an attachment slot admits only secret material and does not declare that it handles itAn attachment slot admits only secret material without saying it handles it (Uno slot di associazione ammette solo materiale segreto senza dichiarare di gestirlo)
E0285the Recipe publishes a provides key the Component it implements does not declare, so a consumer wiring that key is refusedA Recipe publishes a provides key its Component does not declare, checked at publication (Una Recipe pubblica una chiave che il suo Component non dichiara, con verifica alla pubblicazione)
E0286the version bump being published is smaller than the evolution check's classification of the change requiresThe version offered is a smaller bump than the change requires (La versione offerta è un aumento minore di quello che la modifica richiede)
E0287the importer reported a diagnostic that stops the import, so the source was not fully turned into draft authoring filesAn import stopped partway through translating a source (Un’importazione si è interrotta a metà della traduzione di una sorgente)
E0288a plugin has no expression for a construct this build declaresA workload declares a form compose cannot express (Un carico di lavoro dichiara una forma che compose non può esprimere); A container declares a field compose has no primitive for (Un container dichiara un campo per cui compose non ha una primitiva); An omits entry names a kind or a namespace a compose file does not have (Una voce omits nomina un kind o un namespace che un file compose non ha); An omits entry names a namespace a CloudFormation template does not have (Una voce omits nomina un namespace che un template CloudFormation non ha); A rule reads a bound CloudFormation parameter by name (Una regola legge per nome un parametro CloudFormation legato); The assembled CloudFormation stack cannot carry a transform (Lo stack CloudFormation assemblato non può portare una trasformazione)
E0289a plugin could not resolve something it requires to exactly one valueA health probe cannot be turned into a compose healthcheck (Una sonda di integrità non può essere trasformata in un healthcheck compose); A configmap volume has no file behind it (Un volume configmap non ha alcun file dietro di sé); What an omits entry left out is still named by the compose file (Ciò che una voce omits ha lasciato fuori è ancora nominato dal file compose); What an omits entry left out is still named by a CloudFormation template (Ciò che una voce omits ha lasciato fuori è ancora nominato da un template CloudFormation); A valuesMapping key names no parameter of a sourced CloudFormation template (Una chiave valuesMapping non nomina alcun parametro di un template CloudFormation di origine); Another component references a CloudFormation parameter a sourced template’s binding filled (Un altro componente fa riferimento a un parametro CloudFormation che il legame di un template di origine ha riempito); Two components order one pair of transforms oppositely (Due componenti ordinano in modo opposto una stessa coppia di trasformazioni); A cross-boundary reference has no consuming stack to be written into (Un riferimento tra confini non ha alcuno stack consumatore in cui essere scritto); A synthesized StatefulSet has no single service to govern it (Uno StatefulSet sintetizzato non ha un unico servizio che lo governi)
E0290two things a plugin produced occupy one name in its outputAn authored export name is one the build derives for a cross-stack reference (Un nome di esportazione scritto è uno che il build deriva per un riferimento tra stack); The output a cross-stack reference publishes on already carries an Export (L’output su cui un riferimento tra stack pubblica porta già un Export); Two entries reach one stack output name (Due voci raggiungono un unico nome di output dello stack); A CloudFormation fragment writes one key twice (Un frammento CloudFormation scrive due volte una stessa chiave); Two rendered resources land at one output file (Due risorse renderizzate finiscono in un unico file di output)
E0291a plugin has no representation for a value it was givenA published port declares a transport compose cannot spell (Una porta pubblicata dichiara un trasporto che compose non sa scrivere); A resources quantity cannot be converted to a compose value (Una quantità di risorse non può essere convertita in un valore compose); A resource quantity the helm provider emits is not a quantity (Una quantità di risorsa che il provider helm emette non è una quantità); A service type the helm provider cannot render (Un tipo di servizio che il provider helm non può renderizzare); A Kubernetes version the helm provider cannot render a chart for (Una versione di Kubernetes per cui il provider helm non può renderizzare un chart); A value bound to a CloudFormation parameter cannot take the parameter’s type (Un valore legato a un parametro CloudFormation non può assumere il tipo del parametro); A value bound to a CloudFormation parameter is one its constraints refuse (Un valore legato a un parametro CloudFormation è uno che i suoi vincoli rifiutano); A secret bound to a CloudFormation parameter would be written into the template (Un segreto legato a un parametro CloudFormation verrebbe scritto nel template); A dynamic reference is bound where CloudFormation does not resolve it (Un riferimento dinamico è legato dove CloudFormation non lo risolve); A cross-boundary reference was spliced into a longer string (Un riferimento tra confini è stato inserito in una stringa più lunga)
E0292a plugin reported a failure that none of the declared kinds namesA plugin reported a failure it did not classify (Un plugin ha segnalato un errore che non ha classificato)
E0293wasm: guest plugin named a condition the socket does not declareA plugin named a condition the socket does not declare (Un plugin ha nominato una condizione che il socket non dichiara)
E0294components in different subsystems take the same identity: rename one of them, since a subsystem contributes nothing to a component's identityTwo subsystems declare a component under one name (Due sottosistemi dichiarano un componente con un unico nome)
E0295library reference: a reference to a library entry carries no whitespace or line breakA reference to a library entry carries whitespace (Un riferimento a una voce di libreria contiene spazi bianchi)
E0296release extends chain composes both named boundaries and top-level components: declare one routing shape across the chain, never bothA Release chain’s links disagree about the routing shape (Gli anelli di una catena di Release non concordano sulla struttura di instradamento)
E0297inherited boundary directory carries no template variable, so it resolves to the path the extended Release writes toA child Release inherits a boundary directory that resolves where its parent writes (Una Release figlia eredita una directory di confine che si risolve dove scrive la sua Release genitore)
E0298oci: published bundle carries no entity documentA published bundle holds no entity, or holds two (Un bundle pubblicato non contiene alcuna entità, oppure ne contiene due)
E0299oci: published bundle carries more than one entity documentA published bundle holds no entity, or holds two (Un bundle pubblicato non contiene alcuna entità, oppure ne contiene due)
E0300oci: published bundle cannot be unpackedA published artifact cannot be read as an entity (Un artifact pubblicato non può essere letto come entità)
E0301oci: published artifact is not an entity documentA published artifact cannot be read as an entity (Un artifact pubblicato non può essere letto come entità)
E0302an input the entity reads has no pin recorded for it in the entity.lock beside itAn 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 fissaggio)
E0303the entity shares its directory with another entity, and an entity of its kind has a directory of its ownAn entity shares its directory with another entity (Un’entità condivide la propria directory con un’altra entità)
E0304a path names content outside the entity's own directoryA path names content outside the entity’s own directory (Un percorso indica contenuti esterni alla directory dell’entità)
E0305the files of the entity's local source do not match the pins recorded for them in entity.lockA local source no longer matches the pins recorded beside its Recipe (Una sorgente locale non corrisponde più ai fissaggi registrati accanto alla sua Recipe)
E0306plugin artifact not found on this machineA plugin’s .wasm is not on this machine (Il file Wasm di un plugin non è su questa macchina)
E0307a value a cache location is built from would place cached files outside the place it names in the cacheA value would place a cached file outside the cache (Un valore collocherebbe un file in cache fuori dalla cache)
E0308a Feature reaches a component alongside a Feature it declares a conflict withTwo Features declared to conflict reach one component (Due Features dichiarate in conflitto raggiungono un solo componente)
E0309a symbolic link sits among the files an entity carriesA symbolic link sits among the files an entity carries (Un collegamento simbolico si trova tra i file che un’entità porta con sé)
E0310a registry other than the official hub is not registered offline without a trust policy supplied by hand, because the policy it advertises cannot be fetched; register it once while online, or pin its trust by hand with `aggrega registry add <host> --identity <identity>=<issuer>` or `--key <public-key-file>`A registry is added offline with no trust policy to pin (Un registry viene aggiunto offline senza una policy di fiducia da fissare)
E0311reference carries a malformed version pinA version pin is none of the forms a pin takes (Un pin di versione non ha nessuna delle forme che un pin assume)
E0312a provider socket binding names a capability containing a colon, which no Recipe can selectA provider binding names a capability containing a colon (Un binding del provider nomina una capacità che contiene i due punti)
E0313plugins.providers entry names a capability no provider-rendering plugin the build reads servesA provider binding names a capability no plugin the build reads serves (Un binding di provider nomina una capacità che nessun plugin letto dalla build serve)
E0314plugin was built from a working tree with uncommitted changes, so no commit reproduces the version it reportsA plugin was built from a working tree with uncommitted changes (Un plugin è stato costruito da un albero di lavoro con modifiche non sottoposte a commit)
E0315a connection carries an attachment under a name its socket declares no slot forA connection carries an attachment under a name its socket declares no slot for (Una connessione porta un’associazione sotto un nome per cui il suo socket non dichiara alcuno slot)
E0316a Release attachment takes the name of an attachment one of a component's connections carriesA Release attachment takes the name of a connection’s attachment (Un’associazione della Release prende il nome dell’associazione di una connessione)
E0317a Release connection attachment names no Feature type, and the type is required for an attachment only the Release makesA Release connection attachment names no Feature type (Un’associazione di connessione della Release non nomina alcun tipo di Feature)
E0318duplicate delivery key across two attachments: an attachment's FeatureRecipe writes a delivery key another attachment already deliveredTwo attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Due Features associate consegnano una stessa chiave, la successiva tramite l’injectMapping della sua FeatureRecipe)
E0319connection alias is already used by another connection of the same componentTwo connections of one component under one alias (Due connessioni di un componente sotto un unico alias)
E0320a path this operation writes or deletes leads through a link out of the directory it must stay insideA path the operation writes leads through a link out of the directory it must stay inside (Un percorso che l’operazione scrive porta, attraverso un link, fuori dalla directory entro cui deve restare)
E0321a file this operation reads leads through a link out of the directory it must stay insideA file the operation reads leads through a link out of the directory it must stay inside (Un file che l’operazione legge porta, attraverso un link, fuori dalla directory entro cui deve restare)
E0323template reads its callers' render facts, but the FeatureRecipe does not set readsCallerRenderFactsA template reads its callers’ render facts without declaring it (Un template legge i fatti di rendering dei suoi chiamanti senza dichiararlo)
E0324a reference a document makes to another file leads out of the directory it must stay insideA reference to another file leads out of the directory it must stay inside (Un riferimento a un altro file esce dalla directory entro cui deve restare)
E0325provider guest reported a render fact whose value is not a list; a conforming guest reports every render fact's value as a JSON array, even with one entryA provider reported a render fact whose value is not a list (Un provider ha riportato un fatto di rendering il cui valore non è una lista)
E0326pipeline step reads its callers' render facts, but a pipeline step does not read the components connecting to its host; it reads only the host's own render factsA pipeline step reads its callers’ render facts (Un passo di pipeline legge i fatti di rendering dei suoi chiamanti)
E0327template indexes a map with a key the map does not holdA template indexes a map with a key the map does not hold (Un template indicizza una mappa con una chiave che la mappa non contiene)
E0328attachment written under a name no slot declares fits a slot its component leaves emptyAn attachment written under another name fits a slot its component leaves empty (Un’associazione scritta sotto un altro nome si adatta a uno slot che il suo componente lascia vuoto)
E0329a connection and the target it reaches do not name one key: they write different locators for it, or only one of them names oneA connection and the target it reaches do not name one key (Una connessione e la destinazione che raggiunge non nominano una stessa chiave)
E0330signing: the references named together need different signing credentials, so nothing was signedReferences signed together need different signing credentials (I riferimenti firmati insieme richiedono credenziali di firma diverse)
E0331signing: no verified signature is recorded for an artifact that requires oneNo verified signature is recorded for an artifact that requires one (Nessuna firma verificata è registrata per un artifact che la richiede)
E0332signing: the recorded signature was made for a different artifactA recorded signature was made for a different artifact (Una firma registrata è stata creata per un artifact diverso)
E0333signing: a recorded signature is not the one a pull would recordA recorded signature is not the one a pull would record (Una firma registrata non è quella che registrerebbe un pull)
E0334an omits entry left out nothing the source renderedAn omits entry left out nothing the source rendered (Una voce omits non ha lasciato fuori nulla di ciò che la sorgente ha renderizzato)
E0335provider does not support omitsThe provider does not support omits (Il provider non supporta omits)
E0336a provider's omitted counts do not match the omits entries it was handedA provider’s omitted counts do not match the omits entries it was handed (I conteggi delle omissioni di un provider non corrispondono alle voci omits che ha ricevuto)
E0337no importer plugin version satisfies the plugins.importer entry's version pinA plugins.importer entry pins a version of its importer the catalog does not hold (Una voce fissa una versione del proprio importatore che il catalogo non contiene)
E0338importer is attached by more than one plugins.importer entryAn importer is attached by more than one plugins.importer entry (Un importer è associato da più di una voce)
E0339more than one importer recognises the sourceMore than one importer recognises the source (Più di un importer riconosce la sorgente)
E0340a name this operation writes holds a path segment Windows cannot hold as writtenA name the operation writes holds a part Windows cannot hold (Un nome che l’operazione scrive contiene una parte che Windows non può contenere)
E0341the importer serving the source's format declares no file patterns, so it reads one file and cannot read a directoryAn importer that declares no file patterns is handed a directory (A un importer che non dichiara pattern di file viene passata una directory)
E0342no file in the directory matches the file patterns the importer serving the source's format declaresNo file in the directory matches the importer’s file patterns (Nessun file della directory corrisponde ai pattern di file dell’importer)
E0343a file read from the directory and a file named in the importer's `with.sources` have the same nameA file read from the directory and a file named in the importer’s with.sources have the same name (Un file letto dalla directory e un file nominato nelle sorgenti dell’importer hanno lo stesso nome)
E0344an entry this publication carries cannot be used on WindowsA published archive carries an entry Windows cannot use (Un archivio pubblicato porta una voce che Windows non può usare)
E0345a container declares one environment variable twiceA container gives one environment variable two values (Un container assegna due valori a una stessa variabile d’ambiente)
E0346a Component's annotation stating how its metrics authenticate disagrees with whether it declares the provides key saying an instance's metrics need a credentialA Component’s metrics annotation and its provides key disagree (L’annotazione delle metriche di un Component e la sua chiave provides sono in disaccordo)
E0347template reads the render facts of a component its host is wired to, but the FeatureRecipe does not set readsTargetRenderFactsA template reads its targets’ render facts without declaring it (Un template legge i fatti di rendering delle sue destinazioni senza dichiararlo)
E0348pipeline step reads the render facts of a component its host is wired to, but a pipeline step reads only the host's own render factsA pipeline step reads its targets’ render facts (Un passo di pipeline legge i fatti di rendering delle sue destinazioni)
E0349no Recipe in the workspace's catalog binds to the capability the import's target namesAn import’s target names a capability no Recipe in the catalog binds to (La destinazione di un’importazione nomina una capacità a cui nessuna Recipe del catalogo si associa)
E0350no importer recognises the sourceNo importer recognises the source (Nessun importer riconosce la sorgente)
E0351provider does not support boundary artifactsThe provider does not support boundary artifacts (Il provider non supporta gli artefatti del confine)
E0352boundary output directory does not name a directory beneath the output rootA boundary’s output directory is not a directory beneath the output root (La directory di output di un confine non è una directory sotto la radice di output)
E0353boundary-level Feature instance name is not a directory nameA boundary-level Feature is named . or .. (Una Feature a livello di confine si chiama . o ..)
E0354a template does more than copy a value it reads off a cross-boundary linkA template did more than copy a value it read off a cross-boundary link (Un template ha fatto più che copiare un valore letto da un collegamento tra confini)
E0355inject delivery: shape must be a list of entries, each `in:` with exactly one of `from:` or `value:`An inject: delivery is not a list of entries (Una consegna di inject non è un elenco di voci)
E0356suspend requires form: scheduledA workload suspend: is set on a form other than scheduled (La sospensione di un carico di lavoro è impostata su una forma diversa da quella pianificata)
E0357a Manifest name mapping's key names no component instance or attachment in this build, so the entry binds nothingA Manifest name mapping names nothing in the build (Una mappatura per nome del Manifest non nomina nulla nella build)
E0358uses edge target names a component its module does not exportA uses target names a module’s component the module does not export (Una destinazione di arco nomina un componente di un modulo che il modulo non esporta)
E0359no source adapter is registered in this program for the source kindNo source adapter is registered in this program for a source kind (Nessun adattatore di sorgente è registrato in questo programma per un tipo di sorgente)
E0360the netrc file could not be readThe netrc file cannot be read (Il file netrc non può essere letto)
E0361the source URL carries a credentialA source URL carries a credential (Un URL di sorgente contiene una credenziale)
E0362inject entry on a connection carries `value:`; a connection delivers the target's published keys, each named with `from:`An inject: entry on a connection carries a literal (Una voce di inject su una connessione porta un letterale)
E0363annotation subkey is not routed by the annotation's bindingAn annotation subkey is not routed by its binding (Una sottochiave di annotazione non è instradata dal suo binding)
E0364a value template failed while it ranA value template failed while it ran (Un template di valore non è riuscito durante l’esecuzione)
E0365boundary-level Feature's output is routed to a dispatch path nothing assemblesA boundary-level Feature’s output reaches no assembled file (L’output di una Feature a livello di confine non raggiunge alcun file assemblato)
E0366FeatureRecipe injectMapping output could not be read as a dictionary of deliveriesAn attached Feature’s injectMapping output cannot be read (L’output injectMapping di una Feature associata non può essere letto)
E0367a scalar annotation value does not route to exactly one path of its bindingA bare annotation value does not route to exactly one path of its binding (Un valore di annotazione semplice non viene instradato verso esattamente un percorso del suo binding)
E0368FeatureRecipe injectMapping output writes a key no delivery mechanism of the host readsAn attached Feature’s injectMapping output writes deliveries under a key nothing delivers (L’output injectMapping di una Feature associata scrive consegne sotto una chiave che nulla consegna)
E0369template reads a path as a value and iterates it, and the data holds nothing at that pathA template reads and iterates a path that holds nothing (Un template legge e itera un percorso che non contiene nulla)
E0370a pipeline declares one step id twiceA pipeline declares one step id twice (Una pipeline dichiara due volte lo stesso id di step)
E0371catalog document declares a kind a catalog does not holdA catalog document declares a kind a catalog does not hold (Un documento di catalogo dichiara un tipo che un catalogo non contiene)
E0372inject entry on an attachment carries `value:`; an attachment delivers the keys its FeatureRecipe publishes, each named with `from:`, and a literal belongs in the component's own inject blockAn inject: entry on an attached Feature carries a literal (Una voce di iniezione su una Feature allegata contiene un letterale)
E0373a document declares an API version this compiler no longer readsA document declares an API version this compiler no longer reads (Un documento dichiara una versione dell’API che questo compilatore non legge più)
E0374a plugin declares a plugin ABI version this compiler no longer speaksA plugin declares a plugin ABI version this compiler no longer speaks (Un plugin dichiara una versione dell’ABI dei plugin che questo compilatore non supporta più)
E0375oci: artifact carries a media type this compiler no longer readsAn artifact carries a media type this compiler no longer reads (Un artefatto riporta un tipo di media che questo compilatore non legge più)
E0376egress: the server did not answer in timeA server did not answer in time (Un server non ha risposto in tempo)
E0377registry: the repository listing did not end in timeA registry’s repository listing did not end in time (L’elenco dei repository di un registry non è terminato in tempo)
E0378oci: the registry kept asking to slow downA registry kept asking to slow down (Un registry ha continuato a chiedere di rallentare)

Il dominio del linter (non fatale)

Il compilatore è rigorosamente privo di opinioni riguardo all’esecuzione. Non arresta mai il build per pattern che sono soltanto sospetti — valori inutilizzati, segreti orfani, destinazioni scollegate. Al massimo un pattern del genere suscita un avviso — quello del build stesso, per i pochi catalogati sopra in «Condizioni che non arrestano una build», come un parametro dichiarato che nulla legge — e il resto appartiene al dominio del linter, dove le aziende scelgono di adottare plugin Wasm che fanno rispettare le proprie convenzioni.

Credenziali orfane

Una Feature di credenziali associata senza un contratto di consegna inject: non è un errore di compilazione. Il compilatore di base conserva la dichiarazione nel grafo IR e non emette alcun avviso. I plugin linter aziendali possono rilevare questo pattern e segnalarlo con un avviso; i renderer aziendali possono anche scegliere di montare implicitamente i segreti orfani secondo le proprie convenzioni Black-Box. Poiché entrambe le interpretazioni sono valide, il compilatore di base non prende posizione.