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

Avvertimenti e output del linter

Avvertimenti non fatali che il compilatore emette durante la compilazione. Gli avvertimenti non arrestano il build — fanno emergere segnali sospetti nell’authoring, criteri di spareggio deterministici scelti dal compilatore e risorse che i template dello sviluppatore non hanno mai consumato. Ogni rilievo raggiunge stderr preceduto da un prefisso che ne nomina il tipo — warning:, lint: o notice:, a seconda del passaggio che lo ha sollevato — così le pipeline di CI possono catturarli e riproporli; gli artifact renderizzati vengono prodotti comunque.

Per gli arresti fatali della compilazione (le diagnostiche che fermano un build), vedi fatal-halts.md.

Ogni avviso, per codice breve

Parte di ciò che il compilatore segnala senza arrestarsi è una condizione a sé: porta un codice breve, lo stesso identificatore di quattro cifre che stampa una diagnostica di arresto, e una frase fissa con cui si apre il suo messaggio. La tabella seguente esegue la ricerca dall’uno all’altro, così un codice che hai in mano si risolve in ciò di cui tratta il rilievo anche quando la riga che stai leggendo è un avvertimento anziché un arresto.

Ciò che si guadagna un posto qui è una dichiarazione, non una descrizione. Ogni regola che il compilatore valuta dichiara che cosa fa una violazione — arrestare il build, oppure segnalare il rilievo e lasciare che il build finisca — e le righe seguenti sono del secondo tipo. Così un avviso aggiunto al compilatore compare qui senza che una riga venga scritta a mano, e uno che diventa una condizione di arresto ne esce.

Due limiti a ciò che la tabella copre, ed entrambi meritano di essere conosciuti prima di concludere che un codice manca:

  • Non tutto ciò che è su questa pagina è uno di questi. Diversi rilievi descritti di seguito sono sollevati da un passaggio a sé anziché da una regola dichiarata, e alcuni non portano alcuna condizione — le righe che stampano sono comunque esattamente come descritte nelle loro sezioni, ma non c’è alcun codice da risolvere e quindi nessuna riga. Il codice di classe unsupported-field è la forma da aspettarsi lì: nomina una classe di rilievi anziché una condizione.
  • Una riga qui non promette una sezione più sotto. Un avviso sollevato tardi nel rendering è catalogato anziché descritto, quindi un codice può risolversi qui in una frase e avere la sua trattazione più completa in fatal-halts.md sotto «Condizioni che non arrestano una build», che cataloga ogni condizione che porta un codice senza arrestare un build.

sentinels.md risolve qualsiasi codice breve stampato da un build, di avviso o di arresto, ed è il punto da cui partire quando non sai ancora di quale tipo è quello che hai in mano.

Codice breveSi apre con
E0004annotation contribution overridden by an explicit value
E0037cross-boundary link between endpoints rendered by different providers is not supported
E0149attachment name is a near miss for a declared slot
E0167Recipe publishes a provides key its Component does not declare
E0173declared parameter is read by no reference in the Aggregate
E0174uses socket name is a near miss for a declared socket
E0256annotation binding declares one path in both pillar lists
E0297inherited boundary directory carries no template variable, so it resolves to the path the extended Release writes to

Schema-pillar-overlap lint (Lint di sovrapposizione dei pilastri dello schema)

Scatta quando un Component o una Feature dichiara lo stesso nome di proprietà sia nel pilastro values: sia nel pilastro infra: del suo blocco spec.schema: alla stessa profondità di annidamento. Gli autori di schemi che mettono lo stesso nome di campo in entrambi i pilastri di solito intendono metterlo nell’uno o nell’altro; il lint segnala la duplicazione così che l’autore possa stabilire quale pilastro possiede il campo.

Posizione nella pipeline. Il lint viene eseguito nel passaggio di validazione dopo l’unificazione degli schemi, prima della costruzione della topologia. Percorre lo schema dopo l’espansione della forma compatta, senza seguire un $ref: (vedi la disciplina del salto silenzioso più sotto), e segnala ogni proprietà sovrapposta come avvertimento separato.

Forma emessa:

notice: LINT: Component "core/compute/web-server:1.0.0" at ./catalog/component/core/compute/web-server/1.0.0/component.yaml declares property "storage_size" in both values: and infra: pillars (path: storage_size)

Per le proprietà annidate, il percorso è il percorso in notazione puntata verso la proprietà a partire dalla radice del pilastro:

notice: LINT: Feature "core/db-pool:1.0.0" at ./catalog/feature/core/db-pool/1.0.0/feature.yaml declares property "timeout" in both values: and infra: pillars (path: connection.timeout)

Un caricamento dell’intero catalogo — aggrega validate senza argomenti — nomina ogni entità per nome e versione e per il file da cui è stata letta, come sopra. Un build, o la validazione di una sola Release, legge solo le entità che quella Release raggiunge e nomina ciascuna per nome e versione — at core/db-pool:1.0.0 — una volta per entità, per quanti riferimenti nella Release la raggiungano: un Aggregate che nomina una Feature con il suo nome semplice e un Manifest che la mappa per nome e versione raggiungono una sola Feature, che viene segnalata una volta.

Visibilità nell’editor. Il rilievo raggiunge la diagnostica dell’editor attraverso il language server, con severità di avvertimento, in testa al file anziché su una chiave — nomina un’entità del catalogo anziché una posizione all’interno del documento che stai modificando, quindi non c’è alcuna chiave di authoring su cui possa posarsi un marcatore. Viene sollevato prima della fase di rendering degli artifact, quindi non richiede alcuna regolazione: una sessione dell’editor lo mostra che serve.build_on_inspect sia attivo o no.

Disciplina del salto silenzioso. L’attraversamento termina senza avvertimento quando un ramo dello schema porta una delle vie d’uscita di JSON Schema 2020-12 che impediscono insiemi di proprietà derivabili staticamente: $ref (riferimenti tra documenti o interni al documento), patternProperties (dichiarazioni di proprietà basate sulla forma della chiave), additionalProperties impostato a true o a uno schema (proprietà che il ramo ammette senza nominarle) e gli operatori di composizione oneOf / anyOf / allOf (disgiunzioni e congiunzioni i cui rami possono dichiarare insiemi di proprietà divergenti). Percorrere questi rami richiederebbe di valutare lo schema referenziato o composto al momento del lint (un tipo di lavoro che il lint non svolge) oppure produrrebbe falsi positivi quando il nome di una proprietà values: di un ramo coincide per caso con il nome di una proprietà infra: di un altro ramo. Il lint non emette alcun avvertimento per la profondità di annidamento interessata; i livelli più profondi dello stesso schema vengono comunque percorsi e sono soggetti al lint.

Nota per l’autore. Il compilatore non rifiuta le sovrapposizioni di nomi tra pilastri — il lint è un avviso. Un Component con storage_size in entrambi i pilastri viene compilato; il values.storage_size lato sviluppatore e l’infra.storage_size lato operatore vengono validati in modo indipendente dagli schemi dei rispettivi pilastri, e il template valuesMapping: della Recipe sceglie da quale pilastro proviene il valore che confluisce nell’output renderizzato. Il lint esiste perché questo modello di authoring è quasi sempre un errore; la duplicazione consapevole tra pilastri è abbastanza rara che gli autori che la vogliono davvero possono ignorare l’avvertimento. Per la meccanica tra pilastri in generale — compresi i rari casi in cui un passaggio deliberato di valori tra pilastri è giustificato — vedi vocabulary/data-pillars.md «Meccanica tra pilastri».

Binding-map-overlap lint (Lint di sovrapposizione delle mappe del binding)

Scatta quando un binding di annotazione del Manifest dichiara lo stesso percorso in notazione puntata sia nel suo elenco maps.infra sia nel suo elenco maps.values. Il percorso verrebbe instradato attraverso entrambi i pilastri; il criterio di spareggio deterministico del compilatore lo invia attraverso infra:, il che rende il lato values: irraggiungibile dall’Aggregate. Il lint lo fa emergere così che l’autore possa restringere il binding a un solo pilastro oppure accettare consapevolmente l’instradamento solo sul lato infra.

Posizione nella pipeline. Il lint viene eseguito dopo la risoluzione del Manifest e prima che scatti qualsiasi espansione delle annotazioni, quindi un build segnala un binding sovrapposto che un’annotazione dell’Aggregate raggiunga mai quel binding o no. Percorre i binding sotto mappings.features.annotations nell’ordine in cui sono stati scritti, interseca gli elenchi maps.infra e maps.values di ciascun binding e segnala un rilievo per ogni percorso sovrapposto. All’interno di un binding, i percorsi sovrapposti vengono segnalati nell’ordine in cui li dichiara l’elenco maps.values di quel binding — l’ordine in cui li hai scritti — così esecuzioni ripetute su input identico segnalano una sequenza identica.

Forma emessa:

lint: annotation binding declares one path in both pillar lists (Manifest, at .spec.mappings.features.annotations, "compliance.aggrega.ai/data-class", on Feature "core/pii-redaction", at path "classifier_endpoint", which the routing tie-break sends through the pillar "infra", declare a second binding under another annotation key to route it through "values")
lint: annotation binding declares one path in both pillar lists (Manifest, at .spec.mappings.features.annotations.audit-scope, "audit-scope", on Feature "core/pii-redaction", at path "retention_endpoint", which the routing tie-break sends through the pillar "infra", declare a second binding under another annotation key to route it through "values")

Quelle due righe provengono da un solo build su un solo Manifest, e ciò che differisce tra i loro localizzatori è la forma della chiave di annotazione. Un localizzatore indirizza un documento per percorso in notazione puntata, quindi si ferma al primo segmento che contiene un punto proprio: audit-scope non ne contiene e il localizzatore raggiunge il binding, mentre compliance.aggrega.ai/data-class sì, e il localizzatore nomina invece il blocco annotations che la contiene. Ecco perché la chiave incriminata è anche il primo valore tra virgolette di ogni rilievo — è l’unica parte che il localizzatore non può sempre portare.

Visibilità nell’editor. Il rilievo raggiunge anche la diagnostica dell’editor attraverso il language server, con severità di avvertimento, posizionato dovunque arrivi il suo localizzatore — sul binding stesso per una chiave semplice, e sul blocco annotations che lo racchiude per una chiave che contiene un punto. Un autore che non legge mai l’output del terminale lo vede comunque. Viene sollevato prima della fase di rendering degli artifact, quindi non richiede alcuna regolazione: una sessione dell’editor lo mostra che serve.build_on_inspect sia attivo o no.

Trovare la corrispondenza da codice. Il rilievo porta ErrAnnotationBindingPillarOverlap da pkg/resolver, così un consumatore riconosce la classe con errors.Is anziché confrontando il testo del messaggio. Come ogni sentinella di avviso, non raggiunge mai il verdetto di un build — vedi sentinels.md per la funzione di accesso e i codici della condizione.

Criterio di spareggio deterministico. Il runtime risolve la collisione instradando il percorso esclusivamente attraverso il pilastro infra:. La scelta è coerente da un build all’altro; l’autore può farci affidamento. Il lato values: viene eliminato dall’instradamento effettivo del binding — le annotazioni lato Aggregate che tentano di raggiungere il percorso non ricevono alcuna destinazione di instradamento e il build si arresta sul lato Aggregate al momento dell’espansione, con l’arresto descritto in fatal-halts.md «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)». Il lint è la superficie di avviso anticipato; quell’arresto è la superficie che fa rispettare la regola.

Nota per l’autore. Come il lint di sovrapposizione dei pilastri dello schema, questo lint è un avviso — il binding viene compilato e il criterio di spareggio a runtime produce un output deterministico. Il lint scatta perché questo modello di authoring è quasi sempre involontario; un autore di binding che volesse davvero che entrambi i pilastri instradassero lo stesso percorso scriverebbe due binding separati con chiavi di annotazione diverse.

Attachment-slot near-miss lint (Lint di quasi corrispondenza degli slot di associazione)

Scatta quando un’istanza di componente associa una Feature sotto un nome che non è uno degli slot featuresSchema dichiarati dal suo tipo di Component, ma si trova a una modifica da uno di essi — un solo carattere inserito, eliminato o sostituito, oppure due caratteri adiacenti scambiati — il cui selector la Feature associata non soddisfa. È la forma che assume un refuso nel nome di uno slot, e il lint nomina entrambe le grafie così che l’autore possa vedere la coppia.

Perché esiste. Dichiarare uno slot non chiude la superficie delle associazioni: un’associazione sotto un nome che nessuno slot dichiara è legittima, perché è proprio questa apertura a permettere a una stessa entità del catalogo di servire sia un’associazione che riempie uno slot sia una credenziale condivisa a livello di un ambito più ampio. Il costo è che un nome di slot scritto male diventa silenziosamente un’associazione libera anziché il riempimento dello slot che l’autore intendeva — il build riesce e lo slot resta semplicemente vuoto. Il lint è la mitigazione dichiarata proprio per quel caso.

Posizione nella pipeline. Il lint viene eseguito alla risoluzione, nello stesso passaggio delle salvaguardie semantiche che tengono conto del catalogo, sull’Aggregate risolto. Confronta i nomi delle associazioni di ogni istanza di componente con i nomi degli slot dichiarati dal tipo di Component di quell’istanza, ed emette un avvertimento per ogni coppia di quasi corrispondenza.

Forma emessa:

lint: attachment name is a near miss for a declared slot (Aggregate nearmiss, at .spec.components.db.features.app_user_passwrod, "app_user_passwrod", on component type "core/datastore/postgres", near the declared slot "app_user_password")

Il primo valore tra virgolette è il nome sotto cui è stata scritta l’associazione, ed è ciò di cui tratta la frase iniziale dell’avvertimento. I due che seguono sono introdotti dalle parole che dicono che cosa sono: il tipo di Component su cui si trova l’associazione e lo slot dichiarato da cui dista una modifica.

Visibilità nell’editor. L’avvertimento raggiunge anche la diagnostica dell’editor attraverso il language server, con severità di avvertimento, posizionato sulla chiave dell’associazione incriminata. Un autore che non legge mai l’output del terminale vede comunque la coppia. Viene sollevato prima della fase di rendering degli artifact, quindi non richiede alcuna regolazione: una sessione dell’editor lo mostra che serve.build_on_inspect sia attivo o no.

Soglia e relativo compromesso. Il lint abbina i nomi solo a una distanza di una modifica, e solo quando entrambi i nomi sono lunghi almeno quattro caratteri. Al di sotto di quella lunghezza quasi ogni nome breve si trova a una modifica da ogni altro, quindi abbinarli produrrebbe rumore anziché segnale; oltre una modifica le coppie smettono di somigliare a refusi. Una trasposizione conta come una modifica anziché due, perché una coppia di caratteri scambiati è la svista più comune e un conteggio più severo la perderebbe.

Nota per l’autore. Il lint è un avviso e non cambia mai il verdetto del build — il compilatore non sorveglia come un autore chiama un’associazione. Un autore che associa deliberatamente una Feature sotto un nome che somiglia a uno slot può ignorare l’avvertimento; l’associazione si comporta esattamente come è stata scritta.

Non dove la Feature si adatta allo slot. Un nome a una modifica da uno slot il cui selector è soddisfatto dalla Feature associata non provoca alcun avvertimento. Quell’abbinamento non è un’associazione libera scritta male ma un riempimento scritto sotto un altro nome, e se abbia importanza dipende dal fatto che lo slot resti vuoto, cosa che si sa solo una volta combinati tutti gli ambiti. Dove lo slot resta vuoto il build si arresta e nomina l’associazione e lo slot — vedi «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)» in fatal-halts.md — quindi l’arresto è l’unico rilievo segnalato, mai un avvertimento accanto a esso. Dove qualcos’altro lega lo slot, l’associazione è un’associazione aggiuntiva ordinaria e non viene segnalato nulla. A uno slot che non dichiara alcun selector non si adatta nessuna Feature, quindi un nome vicino a uno slot del genere provoca sempre l’avvertimento.

Non su una connessione. Il lint legge il blocco features: proprio di un componente, che è aperto. Le associazioni che una connessione porta sono indicizzate dagli slot che il suo socket dichiara e da nient’altro, quindi un nome a una modifica da uno di quegli slot non è legittimo lì: il build si arresta invece, e l’arresto nomina nella stessa frase lo slot vicino al quale si trova il nome. Non viene sollevato alcun avvertimento accanto a esso. 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)» in fatal-halts.md.

Uses-socket near-miss lint (Lint di quasi corrispondenza dei socket uses)

Scatta quando il blocco uses: proprio di un componente nomina un socket che non è uno dei socket usesSchema dichiarati dal suo tipo di Component, ma si trova a una modifica da uno di essi — un solo carattere inserito, eliminato o sostituito, oppure due caratteri adiacenti scambiati. È la forma che assume un refuso nel nome di un socket, e il lint nomina entrambe le grafie così che l’autore possa vedere la coppia.

Perché esiste. Dichiarare un socket non chiude la superficie uses: sul componente proprio di uno sviluppatore: un nome di socket che nessuna voce usesSchema dichiara è legittimo, perché il silenzio del catalogo su un socket significa che la connessione non era stata prevista, non che è vietata, e lo sviluppatore possiede la topologia dell’Aggregate. Il costo è che un nome di socket scritto male diventa una propria connessione ad hoc anziché cablare il socket che l’autore intendeva — il build riesce, il socket previsto resta semplicemente non cablato e l’arco ad hoc non porta né selettore né contratto per arco. Il lint è la mitigazione dichiarata proprio per quel caso. Per ciò a cui un socket ad hoc rinuncia e ciò che conserva, vedi entities/component.md «Socket di topologia: usesSchema».

Quale superficie copre. Solo il blocco uses: proprio del componente — l’unica superficie in cui un nome di socket non dichiarato è accettato. Il uses: di un’associazione di Feature può nominare solo un socket che la Feature associata dichiara, e il uses: per arco di una Release può nominare solo un socket che il Component consumatore dichiara; un nome sbagliato su una di queste due arresta già il build, quindi un avvertimento non avrebbe nulla da aggiungere.

Posizione nella pipeline. Il lint viene eseguito alla risoluzione, nello stesso passaggio delle salvaguardie semantiche che tengono conto del catalogo, sull’Aggregate risolto. Confronta i nomi di socket propri di ogni istanza di componente con i nomi di socket dichiarati dal tipo di Component di quell’istanza, ed emette un avvertimento per ogni coppia di quasi corrispondenza. Un componente che arriva da un sotto-aggregato non è coperto: i suoi componenti interni vengono incorporati nel grafo dopo l’esecuzione di questo passaggio.

Forma emessa:

lint: uses socket name is a near miss for a declared socket (Aggregate aggregate, at .spec.components.web, "databses", on component type "core/devtool/adminer", near the declared socket "databases")

Il primo valore tra virgolette è il nome di socket che l’autore ha scritto, ed è ciò di cui tratta la frase iniziale dell’avvertimento. I due che seguono sono introdotti dalle parole che dicono che cosa sono: il tipo di Component su cui è stato nominato il socket e il socket dichiarato da cui dista una modifica. La conseguenza che l’avvertimento non esplicita è quella descritta sopra: il nome scritto male è una connessione ad hoc, quindi non porta né selettore né contratto per arco, e il socket che l’autore intendeva resta non cablato.

Visibilità nell’editor. L’avvertimento raggiunge anche la diagnostica dell’editor attraverso il language server, con severità di avvertimento, posizionato sul componente il cui blocco uses: contiene il nome incriminato. Un autore che non legge mai l’output del terminale vede comunque la coppia. Viene sollevato prima della fase di rendering degli artifact, quindi non richiede alcuna regolazione: una sessione dell’editor lo mostra che serve.build_on_inspect sia attivo o no.

Soglia e relativo compromesso. Il lint abbina i nomi solo a una distanza di una modifica, e solo quando entrambi i nomi sono lunghi almeno quattro caratteri — lo stesso limite usato dal lint di quasi corrispondenza degli slot di associazione, per lo stesso motivo. Al di sotto di quella lunghezza quasi ogni nome breve si trova a una modifica da ogni altro, quindi abbinarli produrrebbe rumore anziché segnale; oltre una modifica le coppie smettono di somigliare a refusi. Una trasposizione conta come una modifica anziché due, perché una coppia di caratteri scambiati è la svista più comune e un conteggio più severo la perderebbe.

Nota per l’autore. Il lint è un avviso e non cambia mai il verdetto del build — il compilatore non sorveglia come un autore chiama un socket. Un autore che traccia deliberatamente una connessione ad hoc sotto un nome che somiglia a un socket dichiarato (una connessione cache accanto a un socket dichiarato caches, pensata per qualcos’altro) può ignorare l’avvertimento; l’arco si comporta esattamente come è stato scritto. Non esiste alcun flag per sopprimerlo, e non ne serve uno: non ha alcun peso sul verdetto.

Undeclared-provides-key lint (Lint delle chiavi provides non dichiarate)

Scatta quando la Recipe legata a un’istanza di componente pubblica sotto il suo provides: una chiave che il tipo di Component dell’istanza non dichiara nel suo contratto spec.schema.provides:.

Perché esiste. Pubblicare più di quanto il Component dichiari è legittimo e resta legittimo: il contratto provides richiede il sottoinsieme e consente il soprainsieme, quindi una Recipe che copre il contratto del suo Component ed emette in più altre chiavi è una Recipe che lo soddisfa. Ciò che il lint nomina è una conseguenza altrimenti invisibile da entrambi i lati. Un consumatore che legge attraverso un arco uses: vede il contratto dichiarato della destinazione anziché qualunque cosa la Recipe della destinazione emetta — è questo che mantiene le Recipes intercambiabili, perché due Recipes che realizzano uno stesso Component presentano allora la stessa superficie a un consumatore, e scambiarle non può ritirare silenziosamente una chiave da cui un consumatore era arrivato a dipendere. Quindi una chiave non dichiarata non viene consegnata attraverso l’arco, e un template consumatore che la legge produce un valore vuoto anziché fallire.

Il rilievo viene indicato nella sua causa — sulla Recipe che ha pubblicato la chiave — perché è lì che può essere nominato. Presso il consumatore la chiave è un riferimento di template che il compilatore non può attribuire a una destinazione particolare, e una diagnostica che tirasse a indovinare sarebbe peggiore di nessuna. Perciò i due, deliberatamente, non si trovano nello stesso punto: il valore vuoto compare presso il consumatore, la spiegazione qui, ed entrambi compaiono nello stesso output del build.

Quale abbinamento viene confrontato. Le chiavi provides: scritte nella Recipe legata, confrontate con le chiavi spec.schema.provides: dichiarate dal tipo di Component. Quell’insieme dichiarato è lo stesso con cui viene verificata una chiave from: all’interno di un blocco inject:, quindi i due concordano su ciò che un Component dichiara. Il confronto è esatto anziché un test di somiglianza, quindi, a differenza dei due lint di quasi corrispondenza descritti sopra, non ha alcuna soglia e non abbina nomi.

La Recipe confrontata è quella a cui l’istanza è effettivamente legata, individuata in base allo stesso nome di istanza e allo stesso tipo di catalogo con cui la lega il rendering, quindi una sostituzione della Recipe per singola istanza nel Manifest viene rispettata anziché perdersi in una media. Un’istanza di componente il cui tipo non si risolve in alcun Component del catalogo viene saltata: non è stata letta alcuna dichiarazione, il che non equivale a una dichiarazione di nulla.

Posizione nella pipeline. Il lint viene eseguito alla risoluzione, nello stesso passaggio delle salvaguardie semantiche che tengono conto del catalogo, sull’Aggregate risolto — prima del rendering, quindi emerge da aggrega validate --release così come da aggrega build. Sono coperti sia i Components dichiarati alla radice dell’Aggregate sia i componenti annidati nei sottosistemi. Un componente che arriva da un sotto-aggregato non è coperto: i suoi componenti interni vengono incorporati nel grafo dopo l’esecuzione di questo passaggio, quindi la chiave non dichiarata di un tale componente continua a non essere consegnata ai consumatori, ma nessun avviso la nomina.

Forma emessa. Una riga per ogni istanza di componente e chiave, che nomina la Recipe che ha pubblicato la chiave e il Component che non la dichiara:

lint: Recipe publishes a provides key its Component does not declare (Recipe broker-with-region, at .spec.provides.region, "region", on component type "core/ai-model/openai-compatible", bound to component instance "gateway")

Il rilievo appartiene all’istanza che lo porta, quindi dieci istanze di uno stesso tipo di Component che pubblicano la stessa chiave non dichiarata sollevano dieci righe anziché una, ciascuna con il nome della propria istanza. Ogni riga è attribuita alla Recipe che ha pubblicato la chiave, perché è quello il documento che modifichi per risolverlo. Il percorso è deterministico, quindi lo stesso input produce la stessa sequenza di avvisi a ogni esecuzione.

Visibilità nell’editor. L’avviso raggiunge anche la diagnostica dell’editor attraverso il language server, con severità di avvertimento, posizionato sull’istanza di componente il cui type: lega la Recipe. Un autore che non legge mai l’output del terminale lo vede comunque. Viene sollevato prima della fase di rendering degli artifact, quindi non richiede alcuna regolazione: una sessione dell’editor lo mostra che serve.build_on_inspect sia attivo o no.

Nota per l’autore. Il lint è un avviso e non cambia mai il verdetto del build — con una Recipe che pubblica più di quanto il suo Component dichiari, il build riesce comunque. La correzione è una di due, e quale sia quella giusta lo decide l’autore: dichiarare la chiave sul Component quando i consumatori devono leggerla, oppure lasciarla non dichiarata quando è lo stato di lavoro proprio della Recipe, nel qual caso è in locals: che tale stato va collocato. Il caso opposto non è un avviso: un Component che dichiara una chiave che la sua Recipe non pubblica lascia il contratto non soddisfatto e arresta il build.

Ghost Infrastructure Tracker warnings (Avvertimenti del tracker di Ghost Infrastructure)

Scatta quando una chiave dichiarata da un autore raggiunge un nodo e nessun template dichiarato dalla Recipe legata vi fa mai riferimento. Le chiavi non lette diventano infrastruttura silenziosa: configurazione richiesta dallo sviluppatore o dall’operatore che la Recipe non cabla mai nell’output renderizzato. Il tracker le fa emergere così che la discrepanza tra ciò che è stato scritto e ciò che l’output contiene sia visibile anziché silenziosa.

Quali chiavi scritte vengono confrontate. Tre gruppi, per nodo:

  • .values — il pilastro proprio del nodo, lato sviluppatore.
  • .infra — il pilastro proprio del nodo, lato operatore.
  • .context.uses.<alias>.values — i valori per connessione portati da ogni arco uses: attraverso cui il nodo consuma. Questo gruppo è limitato al consumatore senza alcuno sforzo: la mappa uses di un nodo contiene solo gli archi di cui esso è la sorgente, quindi un valore per connessione non letto viene sempre attribuito al nodo che lo ha scritto e mai alla destinazione dell’arco.

Quali riferimenti vengono raccolti. Ogni template dichiarato dalla Recipe legata. L’avvertimento dice che una chiave non è letta da nulla, il che è un’affermazione sull’intera Recipe, quindi qualsiasi cosa più ristretta dell’intera Recipe la renderebbe falsa anziché approssimata — una chiave consumata da una coordinata source: verrebbe segnalata come non letta proprio dall’esecuzione che ha scaricato la versione da essa indicata. I blocchi letti sono:

  • valuesMapping:, l’overlay di values passato al provider.
  • source: — l’intero campo dove è scritto come una singola stringa, e ogni suo campo con valore stringa dove è scritto come oggetto. Una coordinata di sorgente è un template valutato per ogni istanza consumatrice, quindi una versione, un nome di chart, un riferimento git o una sottodirectory di modulo scelti da .values o .infra leggono quelle chiavi.
  • locals: e provides:, ogni voce.
  • assertions:, ogni voce.
  • workload:, il corpo del Workload sintetizzato.
  • artifacts:, il contenuto di ogni voce.
  • pipeline:, l’input with: di ogni passo e il suo gate when:.

Ne seguono tre limiti, e tutti e tre sono limiti a ciò che si può affermare onestamente anziché scelte. Ciascuno di essi mette a tacere la lettura anziché ampliarla, che è la direzione che costa meno: una chiave non segnalata costa a un lettore un avviso che può comunque trovare leggendo la Recipe, mentre una segnalata a torto gli dice che un’impostazione funzionante è stata ignorata.

  • Una Recipe senza un valuesMapping: inline non viene letta affatto. Le sue chiavi vengono saltate anziché segnalate, qualunque cosa facciano i suoi altri template.
  • Un blocco che la Recipe importa da un file o da un riferimento a una libreria non è disponibile a questo punto, quindi i suoi riferimenti non possono essere raccolti. Le chiavi del nodo vengono saltate per intero anziché segnalate — ciò vale allo stesso modo per un valuesMapping: importato, un workload: importato e una voce artifacts: importata.
  • Un template che non supera l’analisi sintattica non produce alcun insieme di riferimenti. Segnalare ogni chiave come non letta seppellirebbe la diagnostica di analisi che la valutazione solleva sullo stesso template, quindi invece non viene segnalato nulla. Una voce artifacts: viene letta con i delimitatori standard {{ }}, che non sono la coppia che ogni provider dichiara per quel campo; letto con la coppia sbagliata, un corpo del genere produce riferimenti che il suo autore non ha mai scritto, oppure non supera l’analisi, ed entrambi gli esiti possono solo mettere a tacere un avvertimento.

Il valueSchema di un socket non viene mai segnalato. usesSchema.<socket>.valueSchema dichiara il contratto che un valore per connessione deve soddisfare. È uno schema, non un’istanza scritta, e non è tra gli input confrontati — quindi non può mai essere segnalato. Ciò che il valore predefinito dichiarato di un socket produce è un’istanza come qualsiasi altra, letta o non letta in base ai propri meriti.

Un riferimento che nomina un intero pilastro conta come lette tutte le chiavi sottostanti. {{ .infra.port }} segna port come letta e lascia le altre chiavi del pilastro soggette a un avvertimento. {{ optional .infra `port` 8080 }} passa l’intera mappa .infra a una funzione, quindi il riferimento raccolto nomina il pilastro anziché una chiave sottostante, ogni chiave di quel pilastro conta come letta e il pilastro non solleva nulla. Lo stesso vale per l’iterazione con range su un pilastro e per il raggiungimento di una voce uses tramite index. Un autore di Recipe che vuole una copertura per singola chiave scrive riferimenti per singola chiave.

Ciò riguarda ogni blocco elencato sopra, ed è bene saperlo prima che un pilastro silenzioso venga scambiato per un avvertimento mancato: una Recipe la cui versione source: è scritta come {{ optional .infra `source_version` "1.2.3" }} ha passato l’intera mappa .infra a una funzione, quindi quella Recipe non segnala nulla su alcuna chiave .infra di nessun nodo che renderizza. Il pilastro .values non ne è interessato — i due vengono conteggiati separatamente.

Posizione nella pipeline. Il tracker viene eseguito al rendering di base, accanto alla valutazione dei template. Ciascuno dei template della Recipe viene analizzato e percorso per raccogliere i percorsi di campo qualificati con il punto a cui fa riferimento (.values.port, .infra.replicas, .context.uses.<alias>.values.retry_budget); l’insieme di chiavi risolto di ogni gruppo viene confrontato con l’unione di quei riferimenti, e la differenza è l’insieme non letto. Ciò che viene percorso è la Recipe così come è scritta: una coordinata source: viene letta come il testo del suo template, non come il valore che quel template ha prodotto per questa istanza.

Forma emessa. Una riga per chiave non letta, che nomina il nodo, il percorso del gruppo, la chiave e la Recipe di cui nessun template la legge:

warning: node "data.main-db": .values key "database_name" is read by no template in recipe "helm-postgres-sourced-with-artifacts" — correct the spelling, or remove the key
warning: node "data.main-db": .infra key "storage_class" is read by no template in recipe "helm-postgres-sourced-with-artifacts" — correct the spelling, or remove the key
warning: node "frontend": .context.uses.my-api.values key "retry_budget" is read by no template in recipe "helm-web-ui-sourced-with-artifacts" — correct the spelling, or remove the key

La riga non nomina alcun campo della Recipe, ed è voluto: chi ha scritto la chiave è lo sviluppatore, l’operatore o l’autore dell’arco uses: su cui viaggia, e nessuno di loro modifica la Recipe. Nominare il blocco in cui è stato cercato il riferimento consegnerebbe a quel lettore una coordinata in un documento che non apre. I due rimedi che la riga offre sono i due su cui può agire — una chiave scritta male è la causa comune, e una chiave che non sarebbe mai stata letta merita di essere eliminata.

L’ordine è fisso: prima il .values del nodo, poi il suo .infra, poi ogni alias uses nell’ordine in cui gli archi sono stati emessi, con le chiavi ordinate all’interno di ogni gruppo. Lo stesso input produce quindi la stessa sequenza di avvertimenti a ogni esecuzione.

Visibilità nell’editor. L’avvertimento raggiunge la diagnostica dell’editor solo dove il language server esegue la fase di rendering degli artifact durante l’ispezione di un grafo IR — aggrega serve --build-on-inspect, oppure la chiave di configurazione serve.build_on_inspect che il flag sovrascrive, disattivata per impostazione predefinita. Quella regolazione aggiunge gli avvisi che un build solleva durante il rendering, e nessuno dei controlli su cui un build si arresta. La voce nomina un nodo anziché una chiave di authoring, quindi viene disegnata sulla chiave kind: dell’Aggregate.

Perché un avvertimento e non un arresto fatale. Gli sviluppatori possono legittimamente consumare sottoinsiemi diversi di .values in una logica di template condizionale — una Recipe il cui template si dirama su .values.mode legge mode ma legge .values.replication_password in modo condizionale, solo quando mode == "replication". L’attraversamento statico non può stabilire se una chiave non referenziata sia irrilevante o un bug. Lo scopo del tracker è rendere visibile la discrepanza anziché sorvegliarla; l’omissione silenziosa è il modo di fallimento che il tracker previene.

Risposta dell’autore della Recipe. Quando un autore di Recipe vede un avvertimento di Ghost Infrastructure per una chiave che si aspettava venisse consumata dalla Recipe, la soluzione è cablare la chiave nel template. Quando la chiave non letta è un’omissione deliberata (una funzionalità che il chart non supporta, una possibilità di authoring che la Recipe ignora deliberatamente), l’autore può documentare l’omissione nel commento di intestazione della Recipe così che i lettori futuri sappiano che la discrepanza è intenzionale.

Unread declared-parameter warnings (Avvertimenti sui parametri dichiarati non letti)

Scatta quando un Aggregate dichiara una voce sotto spec.parameters: e nessun riferimento {{ .parameters.<key> }} nel testo proprio di quell’Aggregate la legge.

Un parametro dichiarato è la superficie di authoring per far variare un valore per ogni Release: la Release soddisfa la dichiarazione, e un riferimento porta il valore fornito nei valori del componente a cui appartiene. Una dichiarazione che nulla legge lascia quella variazione senza un posto in cui arrivare — qualunque cosa una Release fornisca per essa, l’output renderizzato è lo stesso. È la forma, a livello di parametro, dello stesso segnale sospetto che porta una chiave di values scritta che nulla consuma.

Un valore predefinito non è un’esenzione. Un valore predefinito che nessun riferimento legge non raggiunge l’output più di quanto lo raggiunga un valore fornito da una Release, quindi una dichiarazione con valore predefinito viene segnalata esattamente come una dichiarazione nuda.

Quali riferimenti vengono raccolti. Il testo proprio dell’Aggregate, e nient’altro. Ne seguono tre conseguenze:

  • Un parametro raggiunto solo dal predicato validate: dello schema di un Component non è visibile qui. Un predicato del genere nomina il parametro attraverso la mappa dei parametri risolta anziché attraverso un riferimento puntato nell’Aggregate, quindi la dichiarazione viene segnalata come non letta anche se il predicato la legge.
  • Un testo che non si analizza come template non produce alcun insieme di riferimenti. Segnalare ogni dichiarazione come non letta seppellirebbe la diagnostica che l’interpolazione solleva sullo stesso testo, quindi invece non viene segnalato nulla.
  • Un riferimento che nomina l’intera mappa parameters — iterandola, o raggiungendo una voce tramite index — conta ogni dichiarazione come letta, perché il riferimento raccolto nomina allora la mappa anziché una chiave sottostante e non è possibile alcuna affermazione per singola chiave.

Posizione nella pipeline. La lettura viene eseguita alla risoluzione, sul testo grezzo dell’Aggregate e sul suo contratto di parametri dichiarato — prima del rendering. Perciò emerge da aggrega validate così come da aggrega build.

Forma emessa. Una riga per dichiarazione non letta, che nomina l’Aggregate e il localizzatore della dichiarazione:

lint: declared parameter is read by no reference in the Aggregate (Aggregate fullstack-app, at .spec.parameters.unread_probe, "unread_probe")

I rilievi arrivano nell’ordine in cui l’Aggregate dichiara i suoi parametri, quindi lo stesso Aggregate produce la stessa sequenza a ogni esecuzione. Ciascuno porta il localizzatore della dichiarazione, che nomina la chiave incriminata. Anche il messaggio nomina la chiave, ed è per questo che essa compare due volte su una riga del terminale che stampa anche il localizzatore: un editor mostra il messaggio nella posizione in cui lo ha collocato e mai il testo del localizzatore, quindi un messaggio che omettesse la chiave si leggerebbe in modo identico per ogni dichiarazione non letta.

Visibilità nell’editor. L’avviso raggiunge anche la diagnostica dell’editor attraverso il language server, con severità di avvertimento, posizionato sulla dichiarazione nominata dal suo localizzatore anziché sull’Aggregate nel suo insieme. Viene sollevato prima della fase di rendering degli artifact, quindi non richiede alcuna regolazione: una sessione dell’editor lo mostra che serve.build_on_inspect sia attivo o no.

Perché un avvertimento e non un arresto fatale. Un parametro può essere dichiarato prima del riferimento che lo leggerà, e un attraversamento statico non può distinguere questo caso da un errore — lo stesso motivo per cui la lettura delle chiavi scritte si limita sempre ad avvisare. Il compilatore non sorveglia quali regolazioni un autore espone.

Provider-binding unserved-capability warning (Avvertimento di capacità non servita del binding di provider)

Scatta quando una voce sotto plugins.providers nella configurazione del workspace nomina una capability e nessun uri, e nessuno dei plugin provider letti dal build serve quella capacità. I plugin che un build legge sono quelli nelle sue directory di catalogo, i provider all’interno del compilatore e i plugin che il suo lockfile registra.

Perché esiste. Un binding viene letto solo quando il capability: di una Recipe chiede la sua capacità, e una voce che non nomina alcun plugin non seleziona nulla che la risoluzione della capacità non selezionerebbe senza di essa. Così una voce la cui capacità è scritta male — hlem per helm — non è consultata da nulla e non cambia nulla, e senza questo avvertimento nulla lo direbbe.

Perché un avvertimento e non un arresto fatale. I binding vengono scritti una sola volta per l’intero workspace, mentre un build riguarda una sola Release. Il plugin che serve la capacità può essere uno che solo un’altra Release del workspace legge, e questo build non può vederlo, quindi un arresto qui rifiuterebbe un workspace legittimo sulla base di un’ipotesi. Una voce che nomina anche un plugin è un caso diverso: un pull risolve ogni voce del genere che una Recipe la usi o no, quindi il build possiede il plugin e sa che cosa serve, e una capacità che quel plugin non serve provoca un arresto — vedi fatal-halts.md «A plugins.providers binding names a plugin that does not serve the capability (Un binding nomina un plugin che non serve la capacità)». Una voce per una capacità che qualche plugin letto dal build serve effettivamente non viene segnalata in alcun modo, che una Recipe di questa Release la usi o no.

Posizione nella pipeline. Ogni build e ogni validazione di una Release legge ogni voce della configurazione composta del workspace — i livelli e i rispettivi complementi providers_append insieme — prima che il grafo della Release venga analizzato, quindi l’avvertimento emerge da aggrega validate --release così come da aggrega build, e da aggrega pull, che renderizza la Release una volta, sul lockfile che sta per scrivere, per scoprire gli input esterni che un suo build scarica. Il giudizio non cambia nulla su quale plugin renderizza una Recipe; questo viene letto dal lockfile.

Forma emessa. Una riga per voce, nell’ordine in cui la lista composta le riporta, che nomina la capacità e una capacità servita a una modifica di distanza, dove ce n’è una:

warning: plugins.providers entry names a capability no provider-rendering plugin the build reads serves: capability "hlem", which is one edit from "helm"; the entry names no plugin, so it selects nothing a Recipe would not resolve without it, and none of the plugins this build reads — in the catalog directories, inside the compiler, or among those the lockfile records — serves the capability: correct its spelling, or keep it where the plugin serving it is one only another Release reads

Soglia. Una grafia viene proposta solo a una distanza di una modifica e solo quando entrambi i nomi sono lunghi almeno quattro caratteri, lo stesso limite usato dai lint di quasi corrispondenza descritti sopra e per lo stesso motivo.

Visibilità nell’editor. L’avvertimento raggiunge la diagnostica dell’editor attraverso il language server con severità di avvertimento. La voce si trova nel file di configurazione anziché nel documento che si sta modificando, quindi viene posizionata in testa a quel documento anziché su una chiave.

Copertura dei metadati per entità

Quali involucri di entità portano metadata.labels e metadata.annotations varia a seconda del tipo. Component, Feature e i tipi di libreria portano entrambe le chiavi; Aggregate porta solo le etichette; Recipe, FeatureRecipe, Manifest, Release e Plugin non accettano nessuna delle due chiavi a livello di involucro. Stato del linguaggio riporta la situazione di ciascuna entità ed è la superficie da consultare.

Visibilità nell’editor. Nessun avviso copre questo caso, con nessuna impostazione: non c’è nulla da segnalare, perché un’entità o porta queste chiavi o non le accetta, e una chiave che un tipo non accetta è una questione a cui risponde il suo schema quando il documento viene caricato, non qualcosa che la fase di rendering segnali in seguito. Un autore consulta la pagina di stato anziché aspettare un avvertimento.

Unsupported-field warnings (Avvertimenti di campo non supportato)

Una sola classe copre tutto ciò che hai scritto e che la destinazione non può rispettare. Ha due membri — un campo del Workload che la destinazione non può esprimere, e un’annotazione aggrega.ai/ su cui la destinazione non agisce — e condividono un solo codice di classe e un solo flag di soppressione, perché un autore che vuole mettere a tacere «le cose che questa destinazione ignora» vuole che tacciano insieme anziché un interruttore alla volta.

A Workload field the target cannot express (Un campo del Workload che la destinazione non può esprimere)

Le destinazioni differiscono per fedeltà. Un campo del Workload che una destinazione esprime nativamente può non avere equivalenti in un’altra — Docker Compose non ha alcuna nozione di vincolo di scheduling, di service account o di classe di priorità, per esempio. Quando un Workload dichiara un campo del genere e la destinazione non può esprimerlo, il campo viene omesso con un avvertimento, un avvertimento per ogni campo scritto. Non viene né scartato in silenzio né trattato come errore fatale.

La differenza rispetto a un arresto fatale è la granularità. Una forma non supportata arresta il build in modo vistoso — la destinazione non può produrre affatto quella forma di carico di lavoro. Una forma supportata che porta un campo non esprimibile viene renderizzata, senza quel campo, e lo dice.

Sulla destinazione compose la classe copre attualmente scheduling, serviceAccount, replicas, runtimeClassName, priorityClassName, imagePullSecrets, dnsPolicy, dnsConfig.options, il runAsNonRoot del container, e ogni chiave di risorsa estesa tranne nvidia.com/gpu — amd.com/gpu, per esempio — poiché quella è riservata alle GPU NVIDIA. I casi seguenti emettono una variante parziale della stessa classe, in cui il campo viene ridotto anziché rimosso:

  • persistentTemplate — il templating dei volumi per replica non è disponibile, quindi il volume si riduce a un unico volume persistente condiviso anziché scomparire.
  • Una voce attachments di un container con as: env — compose non può ricavare una variabile d’ambiente da un’associazione, quindi la variabile viene emessa con un valore vuoto. L’avvertimento nomina la voce alla sua coordinata scritta (containers.<name>.attachments.<KEY>, oppure initContainers[<i>].attachments.<KEY> per una voce init posizionale), così è chiaro quale variabile arriva vuota e a quale container appartiene. Una voce con as: file viene montata normalmente tramite bind mount e non solleva nulla.
  • Una voce volumes che nessun container monta — l’avvertimento nomina il volume alla sua coordinata scritta (volumes.<name>). Ciò che raggiunge l’output dipende dalla variante: un volume persistent o persistentTemplate viene comunque dichiarato come volume con nome, che viene quindi creato e lasciato inutilizzato, mentre un volume configmap, secret o ephemeral raggiunge l’output solo attraverso il punto di montaggio di un container, quindi se nulla lo monta la dichiarazione non produce alcun output. In ogni caso il volume che hai scritto non serve a nulla: montalo da un container, oppure rimuovilo. Ogni container del carico di lavoro conta come montatore, container di init compresi, quindi un volume montato solo da un container di init non solleva nulla.
  • Un blocco health che dichiara più di uno slot di probe — un servizio compose porta un solo healthcheck, quindi l’ordine di priorità live > ready > startup mantiene uno slot e ogni altro slot dichiarato non raggiunge alcuna parte dell’output. L’avvertimento nomina il blocco alla sua coordinata scritta (containers.<name>.health, oppure initContainers[<i>].health per una voce init posizionale) e nomina sia lo slot che è stato tradotto sia gli slot che sono stati scartati, così è chiaro quale probe è attiva nell’output e quale intento scritto è inerte. Un blocco che dichiara un solo slot viene tradotto senza perdite e non solleva nulla.
  • hostNetwork su un carico di lavoro che dichiara anche initContainers — il servizio proprio del carico di lavoro gira sulla rete del nodo, ma ogni container di init diventa un servizio a sé che si unisce alla rete del confine per conto proprio, perché condividere il namespace del servizio principale renderebbe circolare l’attesa del servizio principale su di esso. Ciò è più ristretto della forma di pod che viene modellata, in cui ogni container condivide un solo namespace, quindi la differenza viene nominata anziché lasciata da scoprire a runtime. Un carico di lavoro che dichiara hostNetwork senza container di init viene tradotto senza perdite e non solleva nulla.

An annotation the target does not act on (Un’annotazione su cui la destinazione non agisce)

Le annotazioni aggrega.ai/ sono direttive di piattaforma che un provider legge e applica a ciò che renderizza — un namespace, un prefisso di registry, un service account. Quali di esse un provider legge è una dichiarazione propria di quel provider, fatta per tipo di input, perché un provider che possiede ogni campo di un’unità di deploy che sintetizza da sé spesso non ha dove mettere lo stesso valore quando renderizza un artifact vendorizzato. Annotazioni ben note è la matrice.

La Recipe propria di un nodo e ogni funzionalità associata a quel nodo vengono renderizzate separatamente, ciascuna attraverso la destinazione indicata dal proprio capability: e ai tipi di input dichiarati dai propri source:, workload: e artifacts:. Quando un’annotazione del genere raggiunge uno di quei rendering e la dichiarazione della destinazione risolta non copre la chiave su nessuno dei tipi di input che quel rendering dichiara, la destinazione non applica nulla per quella chiave, e il build lo segnala con un avvertimento che nomina la chiave, la destinazione e ogni tipo di input dichiarato da quel rendering:

warning: node "frontend" (provider "helm-chart"): target "helm-chart" does not support annotation aggrega.ai/namespace on sourced input and ignored it

Queste conseguenze derivano dal modo in cui le annotazioni raggiungono un rendering, e ciascuna di esse è voluta:

  • Una sola riga scritta può produrre più avvertimenti. Un’annotazione di confine si propaga a cascata a ogni componente sotto di esso, e quei componenti possono essere renderizzati attraverso destinazioni diverse e tipi di input diversi. Ogni avvertimento è un’affermazione vera su un solo rendering, quindi ne ricevi uno per ogni rendering che non può agire sulla chiave — ed è anche ciò che ti dice quali parti del tuo output sono interessate.
  • Una funzionalità associata a un nodo viene giudicata sulla propria FeatureRecipe, non sulla Recipe del nodo. Un’associazione che genera risorse proprie le renderizza attraverso la destinazione indicata dalla sua FeatureRecipe, ai tipi di input che quella FeatureRecipe dichiara — quindi un’annotazione che la destinazione propria del nodo applica può non raggiungere nulla nei file dell’associazione, e vale anche il contrario. Vieni informato di ciascuna in modo indipendente, perché sono file diversi. Lo stesso vale per una funzionalità associata a un confine anziché a un componente con nome. Un’associazione la cui FeatureRecipe non dichiara nessuno tra source:, workload: e artifacts: non renderizza file propri — contribuisce iniettando valori, tramite l’arco uses che la sua Feature porta, o tramite una pipeline su documenti emessi da qualcos’altro — quindi non c’è alcun output proprio da cui un’annotazione possa mancare, e per essa non viene segnalato nulla.
  • Un rendering che dichiara più di un tipo di input viene giudicato su tutti. I suoi tipi dichiarati si compongono per addizione e i loro output vengono sommati, quindi una destinazione che legge la chiave su uno qualsiasi di essi la applica e il valore compare nell’output renderizzato. In quel caso non viene segnalato nulla, perché non c’è nulla da riportare. Un avvertimento compare solo quando ogni tipo dichiarato manca la chiave, e li nomina tutti — on sourced or synthesized input.
  • Vengono controllate solo le chiavi aggrega.ai/ nude. Una chiave con un sotto-prefisso — compliance.aggrega.ai/data-class, o la tua acme.aggrega.ai/team — è il tuo vocabolario, che il compilatore trasporta senza interpretarlo. Nulla avverte mai su una chiave del genere.
  • Una destinazione che non dichiara alcuna affermazione di supporto non solleva nulla. L’avvertimento confronta ciò che hai scritto con ciò che il provider ha detto di leggere; un provider che non ha detto nulla non gli dà nulla con cui confrontarlo, e dedurre un rifiuto dal silenzio riporterebbe un’affermazione che l’autore del provider non ha mai fatto. Un provider che non legge nessuna delle chiavi lo dice con readsNoWellKnownAnnotations: true, come fa terraform, e ogni chiave nuda che raggiunge uno dei suoi rendering viene allora segnalata con un avvertimento.

Perché un avvertimento e non un arresto. Un confine che legittimamente comprende componenti su destinazioni eterogenee avrà sempre qualche nodo che non può agire su una data chave — è la forma normale di una Release che si estende su più destinazioni, non un errore — quindi rifiutare il build respingerebbe Releases corrette. Il valore passa intatto, e l’avvertimento te lo dice.

Il codice di classe e la garanzia fuori banda

Ogni avvertimento porta il codice di classe stabile e confrontabile automaticamente unsupported-field, così gli strumenti possono fare la corrispondenza con la classe anziché analizzare il testo del messaggio. Ogni membro della classe — il campo omesso del tutto, il campo in forma ridotta e l’annotazione su cui non si agisce — porta quell’unico codice, ed è ciò che permette a un solo filtro di sopprimere l’intera classe. Gli avvertimenti viaggiano fuori banda rispetto agli artifact renderizzati, il che significa che i byte renderizzati sono identici byte per byte che gli avvertimenti emergano o no — sopprimerli non può cambiare il tuo output.

Visibilità nell’editor. Ogni membro della classe raggiunge la diagnostica dell’editor solo dove il language server esegue la fase di rendering degli artifact durante l’ispezione di un grafo IR — aggrega serve --build-on-inspect, oppure la chiave di configurazione serve.build_on_inspect che il flag sovrascrive, disattivata per impostazione predefinita. Quella regolazione aggiunge gli avvisi che un build solleva durante il rendering, e nessuno dei controlli su cui un build si arresta. Il codice di classe di cui sopra viaggia sulla diagnostica pubblicata così come sulla riga del terminale, quindi un client dell’editor riconosce la stessa classe che legge un autore. Ogni voce nomina un nodo e una destinazione anziché una chiave di authoring, quindi viene disegnata sulla chiave kind: dell’Aggregate.

Soppressione della classe

Entrambi i comandi che renderizzano accettano --no-unsupported-field-warnings, che silenzia solo questa classe mentre ogni altro avvertimento di rendering continua a emergere:

Terminal window
aggrega build --release release.yaml --no-unsupported-field-warnings
aggrega validate ./catalog/recipe/compose/mariadb/1.0.0/recipe.yaml --no-unsupported-field-warnings

Il flag riguarda solo la visualizzazione e non cambia l’output renderizzato. aggrega lint non ha un flag equivalente perché non esegue alcun passaggio di rendering — controlla solo le convenzioni di pubblicazione, quindi lì non può sorgere alcun avvertimento di rendering.

Ricorri al flag quando hai accettato deliberatamente la fedeltà ridotta — una destinazione compose usata per lo sviluppo locale, dove ci si aspetta che i campi di scheduling e di service account del Workload di produzione siano inerti. Altrimenti lascialo disattivato: l’avvertimento è il modo in cui scopri che un campo che hai scritto non sta raggiungendo la destinazione.

A declared-sensitive value travels as a literal (Un valore dichiarato sensibile viaggia come letterale)

Scatta quando un’associazione riempie uno slot consegnando un dato che il suo schema dichiara sensibile in una chiave di consegna come valore letterale, anziché come riferimento che la destinazione risolve quando esegue il deploy.

Forma emessa. Una riga per chiave di consegna, che nomina l’istanza dell’associazione, il meccanismo di consegna in cui la chiave finisce e la chiave stessa, attribuita al nodo e alla destinazione che l’hanno renderizzata:

warning: node "db" (provider "compose"): attachment "user_password" delivers a value declared sensitive to env delivery key "MARIADB_PASSWORD" as a literal; where the target supports it, fill the slot with an attachment that delivers a reference instead

Il codice di classe. L’avviso porta il codice di classe stabile e confrontabile automaticamente sensitive-by-value, così gli strumenti fanno la corrispondenza con la classe anziché analizzare il testo del messaggio. Il codice viaggia sulla riga del terminale e sulla diagnostica strutturata che il language server pubblica, quindi un autore e un client dell’editor leggono la stessa classe — alla condizione di visibilità nell’editor descritta sotto, che stabilisce se il language server pubblichi affatto questo avviso.

Visibilità nell’editor. L’avviso raggiunge la diagnostica dell’editor solo dove il language server esegue la fase di rendering degli artifact durante l’ispezione di un grafo IR — aggrega serve --build-on-inspect, oppure la chiave di configurazione serve.build_on_inspect che il flag sovrascrive, disattivata per impostazione predefinita. Quella regolazione aggiunge gli avvisi che un build solleva durante il rendering, e nessuno dei controlli su cui un build si arresta. La voce nomina un nodo e una destinazione anziché una chiave di authoring, quindi viene disegnata sulla chiave kind: dell’Aggregate.

È una classe a sé, e --no-unsupported-field-warnings non la copre. Quel flag silenzia la classe di campo non supportato descritta sopra; questo avviso continua a emergere accanto a essa. Non esiste alcun flag che silenzi questo.

Il build riesce e i byte renderizzati restano invariati. L’avviso viaggia fuori banda rispetto agli artifact renderizzati, come fa la classe di campo non supportato, quindi ciò che raggiunge il tuo output è lo stesso che la riga emerga o no.

A declared-sensitive value reaches the target through a values mapping (Un valore dichiarato sensibile raggiunge la destinazione attraverso una mappatura di values)

Scatta quando un rendering da un source: consegna alla sua destinazione l’output di un valuesMapping: mentre l’entità i cui values quella mappatura legge dichiara sensibile una foglia values: la mappatura di una Recipe su una foglia dichiarata dal suo Component, oppure la mappatura della FeatureRecipe di una Feature associata a un componente su una foglia dichiarata da quella Feature. Una mappatura è un unico template le cui chiavi di output sono una sua invenzione, quindi nessuna dichiarazione ne nomina alcuna, e la destinazione non riceve alcuna marcatura di sensibilità per chiave per la foglia. È l’unica forma di rendering in cui una dichiarazione non raggiunge alcuna chiave renderizzata mentre l’autore ha ancora una leva su di essa.

Forma emessa. Una riga per foglia dichiarata, che nomina la foglia alla sua coordinata scritta e la Recipe o FeatureRecipe la cui mappatura condiziona il collegamento, attribuita al nodo e alla destinazione che l’hanno renderizzata. La riga per una Feature associata inizia con il nome sotto cui è associata, perché un componente può portare più associazioni di una stessa Feature e le loro righe sarebbero altrimenti identiche — la seconda riga qui sotto è una Feature associata al componente api come token:

warning: node "api" (provider "terraform"): "values.token" is declared sensitive, but recipe "terraform/api" maps its values through a valuesMapping whose output keys no declaration names, so the target receives no per-key sensitivity marking for it; where the mapping reads it, the mapping's whole output is marked as carrying a value declared sensitive instead; a recipe declaring no valuesMapping renders the declared leaf paths as its own keys, and the per-key marking travels with them
warning: node "api" (provider "terraform"): attachment "token": "values.token" is declared sensitive, but FeatureRecipe "terraform/api-token" maps its values through a valuesMapping whose output keys no declaration names, so the target receives no per-key sensitivity marking for it; where the mapping reads it, the mapping's whole output is marked as carrying a value declared sensitive instead; a FeatureRecipe declaring no valuesMapping renders the declared leaf paths as its own keys, and the per-key marking travels with them

Qual è la leva. Senza una mappatura, i valori che un rendering da sorgente riceve sono indicizzati dagli stessi percorsi delle foglie dichiarate, quindi la dichiarazione si collega esattamente alla sua chiave renderizzata e la marcatura viaggia con essa — sulla destinazione Terraform è il file di override generato descritto in Input di modulo dichiarati sensibili. Con una mappatura, la marcatura che arriva copre l’output della mappatura nel suo insieme, e solo dove la mappatura legge il valore dichiarato: governa il testo che un plugin compone quando rifiuta o avverte, e non cambia alcun byte renderizzato.

Tre forme restano silenziose, e deliberatamente. Un rendering di soli artifact e un rendering di solo carico di lavoro non consegnano alla loro destinazione alcuna mappa di valori, quindi una foglia values non ha lì alcuna chiave renderizzata da marcare, comunque sia scritta. Nemmeno una Feature associata a un confine solleva un avvertimento, qualunque cosa la sua FeatureRecipe mappi: un confine non porta alcun blocco values:, quindi un’associazione del genere viene renderizzata su un pilastro values vuoto, nessuna delle foglie values della sua Feature può portarvi un dato, e rimuovere la mappatura non marcherebbe nulla. Ciascuna è una proprietà permanente della forma anziché qualcosa che un autore può cambiare, quindi un avvertimento al riguardo scatterebbe a ogni build e non indicherebbe nulla da fare; il limite viene invece insegnato in Dichiarare sensibile una foglia. Anche un rendering da un source: senza valuesMapping: è silenzioso, perché lì la marcatura arriva.

Il codice di classe. L’avviso porta il codice di classe stabile e confrontabile automaticamente sensitivity-not-conveyed, così gli strumenti fanno la corrispondenza con la classe anziché analizzare il testo del messaggio: lo strumento build dell’assistente elenca ogni rilievo sotto advisories con esso. Nomina una classe di rilievo anziché una condizione registrata, quindi non ha una riga nella tabella in cima a questa pagina.

Visibilità nell’editor. L’avviso raggiunge la diagnostica dell’editor, con severità di avvertimento e con la stessa riga che stampa un build da terminale, ogni volta che il language server renderizza la Release — un build o un’anteprima di build che gli viene richiesta, oppure un’ispezione del grafo IR con aggrega serve --build-on-inspect, o la chiave di configurazione serve.build_on_inspect che il flag sovrascrive, disattivata per impostazione predefinita. La voce nomina un nodo e una destinazione anziché una chiave di authoring, quindi viene disegnata sulla chiave kind: dell’Aggregate.

È una classe a sé, e --no-unsupported-field-warnings non la copre. Quel flag silenzia gli avvisi di fedeltà di una destinazione, un giudizio diverso dato per ragioni diverse; questo avviso continua a emergere accanto a esso. Non esiste alcun flag che silenzi questo.

Il build riesce e i byte renderizzati restano invariati. L’avviso riporta un’assenza — nessuna chiave renderizzata porta la marcatura — e una mappatura è una forma ordinaria e supportata, quindi non c’è nulla per cui arrestarsi e nulla nel tuo output si sposta, che la riga emerga o no.

A Terraform module call the engine fetches when it initialises (Una chiamata di modulo Terraform che il motore scarica durante l’inizializzazione)

Scatta quando un modulo Terraform che il build vendorizza, o il corpo Terraform scritto di una Recipe, dichiara un blocco module il cui source Terraform scarica quando la configurazione viene inizializzata anziché leggerlo dai file che il build ha collocato: un indirizzo di registry, un URL git, Mercurial o di archivio HTTP, un bucket S3 o GCS, o un percorso assoluto — oppure un percorso locale che risale fuori dal modulo vendorizzato, e che nomina file che il build non ha vendorizzato. Il lock fissa il commit e il digest dell’archivio del modulo vendorizzato, e il file di lock delle dipendenze di Terraform registra solo i provider, quindi il modulo nominato da una tale chiamata viene scaricato alla versione che il motore seleziona in quel momento e nulla di ciò che questo build registra lo copre.

Che cosa legge. I file di configurazione che il motore carica quando il modulo viene chiamato — quelli direttamente nella directory propria del modulo e in ogni directory che un source locale raggiunge da lì — e nulla in una directory che nulla chiama, quindi una chiamata scritta nella directory examples/ o tests/ di un modulo non viene segnalata. Legge ciò che dice un source e mai il modulo che quella sorgente nomina. Un file sotto spec.boundary.artifacts di una Recipe viene valutato e scritto dal compilatore stesso e non viene consegnato ad alcun provider, quindi un blocco module scritto in esso non viene letto e non provoca alcun avvertimento. Validazione strutturale dell’input nella pagina del provider enuncia la regola per intero.

Forma emessa. Una riga per chiamata, che nomina il nodo e il provider, poi il blocco, il file e la riga in cui si trova, e la sorgente così come è scritta; una sorgente che risale fuori dal modulo lo dice anziché nominare un download:

warning: node "app" (provider "terraform"): module "vpc" (main.tf, line 2) has the source "terraform-aws-modules/vpc/aws", which Terraform downloads when the configuration is initialised, at whatever version it then selects, so no commit or digest this build records covers that module
warning: node "app" (provider "terraform"): module "shared" (main.tf, line 2) has the local source "../shared", which resolves outside the module this build placed, so Terraform reads whatever sits at that path when the configuration is initialised rather than files this build vendored

Le chiamate arrivano nell’ordine in cui il motore le raggiunge — prima la directory propria del modulo, poi ogni directory nell’ordine in cui una sorgente locale la raggiunge per la prima volta, e all’interno di un file nell’ordine in cui i suoi blocchi sono scritti — quindi lo stesso input produce la stessa sequenza a ogni esecuzione. Ogni esecuzione che renderizza le solleva: aggrega build; aggrega pull, che renderizza la Release una volta per scoprire che cosa scarica un suo build; e aggrega validate su una Recipe il cui modulo è contenuto nel workspace, che renderizza quella Recipe da sola.

Il codice di classe. Ogni avvertimento porta il codice di classe stabile e confrontabile automaticamente module-fetched-at-init, così gli strumenti fanno la corrispondenza con la classe anziché analizzare il testo del messaggio. Il codice viaggia sulla diagnostica strutturata: lo strumento build dell’assistente elenca ogni rilievo sotto advisories con esso, e il language server lo pubblica su ogni voce. Nomina una classe di rilievo anziché una condizione registrata, quindi non ha una riga nella tabella in cima a questa pagina.

Visibilità nell’editor. L’avvertimento raggiunge la diagnostica dell’editor sul livello aggrega-build, con severità di avvertimento, ogni volta che il language server renderizza la Release — un build o un’anteprima di build che gli viene richiesta, oppure un’ispezione del grafo IR con aggrega serve --build-on-inspect, o la chiave di configurazione serve.build_on_inspect che il flag sovrascrive, disattivata per impostazione predefinita. La voce nomina un nodo anziché una chiave di authoring, quindi viene disegnata sulla chiave kind: dell’Aggregate.

È una classe a sé, e nessun flag la silenzia. --no-unsupported-field-warnings silenzia la classe di campo non supportato e non copre questa.

Il build riesce e i byte renderizzati restano invariati. L’avvertimento viaggia fuori banda rispetto agli artifact renderizzati, quindi il modulo vendorizzato, il corpo scritto e la configurazione radice sono identici byte per byte che esso emerga o no.

Perché un avvertimento e non un arresto. Un modulo che chiama un altro modulo è un input legittimo: Terraform scarica il modulo chiamato e la configurazione funziona. Ciò a cui l’autore rinuncia è il vincolo di versione che il build mantiene su quel modulo, che è un fatto da riportare anziché un difetto da rifiutare, e se lo scaricamento sia accettabile lo decide l’autore.

A plugin ran with no recorded digest to check it against (Un plugin è stato eseguito senza alcun digest registrato con cui verificarlo)

Scatta quando il compilatore sta per eseguire un plugin, un digest registrato dovrebbe governare i byte di quel plugin e il workspace non ne registra alcuno per esso. Il plugin viene eseguito; l’avvertimento è il modo in cui vieni a sapere che nulla ha confrontato i byte eseguiti con i byte che qualcuno ha esaminato.

aggrega pull scrive il digest di ogni plugin che acquisisce nel lockfile della Release, e ogni risoluzione successiva confronta i byte che trova con quel digest. Un workspace su cui non è ancora stato eseguito un pull, o il cui lockfile è precedente a un plugin che la configurazione ha associato nel frattempo, non ha alcun digest per quel plugin — quindi il confronto non ha nulla con cui confrontare, e senza questa riga passerebbe in silenzio.

Nemmeno un passo della pipeline, un provider o un plugin associato in un ruolo di verdetto la cui entità Plugin è scritta in una delle tue directory di catalogo ha un digest, e un pull non gliene dà uno: il pull non fissa mai un’entità del genere, e un build legge il suo .wasm da capo ogni volta — accanto all’entità, nel caso ordinario — anziché confrontarlo con qualcosa che un pull abbia registrato. Un plugin associato in un ruolo di trasformazione e scritto lì è l’eccezione: i suoi byte danno forma all’output renderizzato, quindi un pull registra il digest del .wasm che trova per esso, e una volta che lo ha fatto, un build verifica quel plugin rispetto al digest e questa riga non viene sollevata per esso.

warning: plugin "governance/label-injector:1.0.0" resolved from cache with no recorded digest to check it against, so it runs unverified; run `aggrega pull --release <release>` to record it
warning: plugin "pipeline-step/patch" resolved from local with no recorded digest to check it against, so it runs unverified; it is read from beside its Plugin entity in a catalog directory on every build, and a pull records its digest only for a plugin attached at a transform role; otherwise publish the plugin and reference the published entity to have its digest recorded

Questa è la riga che un build, un pull o una validazione mostra tra i suoi altri avvertimenti. Un comando che risolve un plugin al di fuori di un’esecuzione del genere — installando, elencando o eseguendo i plugin da riga di comando propri del workspace, oppure aggrega lint che risolve i plugin con cui esegue il lint — stampa la stessa frase su una riga a sé, senza rientro.

La riga nomina la sorgente da cui provengono i byte — la stessa parola che usano per essa aggrega pull e aggrega plugin list — e termina con ciò che vale per quella sorgente. Per i byte provenienti dalla cache dei contenuti, il rimedio è eseguire il pull della Release, che registra il digest e rende verificata ogni successiva esecuzione di quel plugin. Per i byte letti accanto a un’entità Plugin in una directory di catalogo, un pull registra il digest solo per un plugin associato in un ruolo di trasformazione, e la riga lo dice: per qualsiasi altro plugin scritto lì nessun pull cambia la situazione, e il modo per portarlo sotto un digest registrato è pubblicarlo e fare riferimento all’entità pubblicata.

Viene mostrato una volta per plugin per ogni comando, per quante volte il comando risolva quel plugin. Un rendering risolve il suo provider una volta per nodo, e un build che riempie il proprio lockfile può renderizzare la Release più di una volta; ripetere la riga ogni volta la seppellirebbe. Il servizio dell’editor la mostra sul proprio flusso di errore una sola volta per tutto il tempo in cui resta in esecuzione, mentre ogni richiesta a cui risponde la segnala all’editor da capo — così qualunque risposta da cui l’editor attinga ti informa dei plugin che quell’esecuzione ha usato senza verifica.

Visibilità nell’editor. L’avvertimento raggiunge la diagnostica dell’editor insieme agli altri avvisi dell’esecuzione, con severità di avvertimento: una validazione di una Release lo pubblica sull’Aggregate della Release, e un build o un’anteprima di build richiesti dall’editor lo pubblicano sul livello aggrega-build. Nomina un plugin anziché una chiave che hai scritto, quindi viene posizionato in testa al file. Poiché ogni esecuzione segnala ciò che ha risolto, la voce resta finché un’esecuzione risolve il plugin senza verifica e scompare con la prima esecuzione che non lo fa. Non cambia alcun verdetto e non fa fallire alcuna risoluzione, quindi ciò che una sessione risponde è lo stesso che venga mostrato o no.

Due risoluzioni non sollevano nulla, e nessuna delle due è una svista:

  • Un plugin che il compilatore porta al proprio interno. aggrega pull registra ciò che ha scaricato, e non c’è nulla da scaricare per byte che vengono distribuiti nel binario — quindi per essi non viene mai registrato alcun digest, e non ci sarebbe nulla che tu possa eseguire per cambiarlo. Il binario è l’identità di quei byte. I plugin propri del compilatore e le loro versioni sono elencati da aggrega plugin list e impressi nella sezione toolchain del lockfile.
  • Una risoluzione a cui nessun digest è mai stato destinato. aggrega validate --plugin ./some.wasm punta a un file che hai nominato sulla riga di comando, e aggrega lint ispeziona proprio l’artifact che sta verificando; in entrambi i casi il plugin è l’oggetto dell’esame anziché uno strumento a cui si accorda fiducia, quindi non c’è alcun registro a cui possa essere vincolato.

Perché un avvertimento e non un arresto. Leggere un documento ha senso anche su un workspace che nessuno ha ancora preparato — rifiutarsi di validare o di eseguire il lint finché qualcuno non esegue aggrega pull renderebbe inutilizzabili i comandi di segnalazione proprio nel momento in cui sono più utili. aggrega build non produce artifact senza alcun lockfile, quindi il build incontra questo avvertimento solo per un plugin per cui il suo lockfile non registra alcun digest — il caso ordinario è quello di un plugin letto accanto alla sua entità in una directory di catalogo.

Dove invece un lockfile mancante provoca un rifiuto. Quando un editor chiede al servizio del compilatore il grafo di una Release e il workspace non ha alcun lockfile, il servizio si ferma e ne chiede uno anziché disegnare un grafo. Un lockfile che esiste e semplicemente non registra alcun digest per un plugin rientra invece nel caso precedente: il plugin viene eseguito, e questo avvertimento è il modo in cui lo vieni a sapere. Un grafo disegnato è ciò su cui un lettore poi ragiona, e uno costruito da byte non verificati apparirebbe esattamente come uno verificato. Vedi aggrega serve.

A published archive carries an entry Windows cannot use (Un archivio pubblicato porta una voce che Windows non può usare)

Scatta quando aggrega push — o il suo --dry-run — pubblica un archivio una delle cui voci contiene una parte che Windows non può contenere così come è scritta: un nome che Windows riserva a un dispositivo, come CON, PRN, AUX, NUL, COM1 o LPT1, in qualsiasi combinazione di maiuscole e minuscole e qualunque estensione segua, oppure una parte che termina con un punto o con uno spazio. aux/x.yaml ne contiene una nella sua directory; report. e COM1.yaml ne contengono una nel nome del file. Su Windows, aggrega rifiuta di estrarre una voce del genere, quindi un workspace Windows non può usare affatto la versione. L’avvertimento scatta su ogni piattaforma, perché una pubblicazione è per chiunque ne esegua il pull, ed è il modo in cui il suo autore lo viene a sapere prima che lo scopra qualcuno su Windows.

Che cosa legge. I nomi che l’archivio conterrà: il nome del file del documento dell’entità stesso, poi ogni file che l’entità nomina accanto a sé — i file elencati in Raggruppamento. Così un documento chiamato con.yaml che importa un file di schema provoca l’avvertimento per il proprio nome. Un’entità che non nomina nulla viene pubblicata come il solo documento, che un consumatore dispone sotto un nome scelto dal prodotto anziché quello che hai scritto, quindi non viene mai segnalata, comunque si chiami il suo file. Un Plugin non pubblica alcun archivio e nemmeno esso viene mai segnalato.

Forma emessa. Una riga per voce, su standard error, nell’ordine in cui i nomi vengono composti — prima il documento, poi i file che porta in ordine lessicale — prima del resoconto proprio del dry run o della pubblicazione su standard output:

warning: an entry this publication carries cannot be used on Windows (the entry "aux/x.yaml", its segment "aux"). 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, so a workspace on Windows refuses to unpack the entry. This warning does not stop the publication; rename that segment to publish a version Windows can use

Il primo valore tra virgolette è la voce come la nomina l’archivio. Il secondo è il primo dei suoi segmenti — le parti separate dalle sue barre — che Windows non può contenere, ed è la parte da rinominare. La riga si apre con la frase fissa della condizione. Viene sollevata dalla pubblicazione anziché da una regola valutata da un build, quindi non ha alcuna riga nella tabella in cima a questa pagina; la tabella di ogni condizione la elenca sotto E0344.

Non rifiuta nulla. Il push, o il suo dry run, procede o viene rifiutato esattamente come avverrebbe senza l’avvertimento, ed esce come sarebbe uscito.

Dove altro arriva. Lo strumento publish-entity dell’assistente risponde con le stesse voci come windows_unusable_entries, e aggrega serve risponde ad aggrega/publishEntity con esse come windowsUnusableEntries; ciascuno è assente dove non ce n’è alcuna. Vedi aggrega mcp e aggrega serve. Il servizio passa anche la riga di avvertimento stessa a una richiesta che ha chiesto di ricevere le segnalazioni, insieme al resto del resoconto della pubblicazione.

Visibilità nell’editor. Nessuna come diagnostica: la pubblicazione non è un build, quindi nulla qui raggiunge un elenco di problemi. Un editor che pubblica attraverso il servizio legge windowsUnusableEntries nella risposta.

Perché un avvertimento e non un arresto. Un nome del genere è legale, e Linux e macOS usano il file così come è nominato, quindi rifiutare la pubblicazione significherebbe rifiutare un’entità funzionante sulla base di un’ipotesi su chi ne eseguirà il pull. Se rinominare è una decisione che spetta all’autore.