Avertissements et sortie du linter
Avertissements non fatals que le compilateur émet pendant la compilation. Les avertissements n’arrêtent pas le build — ils font apparaître des signes de problèmes de rédaction, des critères de départage déterministes choisis par le compilateur et des ressources que les templates du développeur n’ont jamais consommées. Chaque constat atteint stderr derrière un préfixe qui nomme sa nature — warning:, lint: ou notice:, selon la passe qui l’a levé — afin que les pipelines de CI puissent les capturer et les faire réapparaître ; les artefacts rendus sont produits quoi qu’il en soit.
Pour les arrêts fatals de la compilation (les diagnostics qui arrêtent un build), voir fatal-halts.md.
Chaque avertissement, par code court
Une partie de ce que le compilateur signale sans s’arrêter est une condition à part entière : elle porte un code court, le même identifiant à quatre chiffres qu’affiche un diagnostic d’arrêt, et une phrase fixe par laquelle s’ouvre son message. Le tableau ci-dessous fait la correspondance de l’un à l’autre, de sorte qu’un code que vous avez en main renvoie à ce dont traite le constat, même lorsque la ligne que vous lisez est un avertissement plutôt qu’un arrêt.
Ce qui mérite une place ici est une déclaration, pas une description. Chaque règle que le compilateur évalue énonce ce que fait une violation — arrêter le build, ou signaler le constat et laisser le build se terminer — et les lignes ci-dessous sont du second type. Ainsi, un avertissement ajouté au compilateur apparaît ici sans qu’une ligne soit écrite à la main, et un avertissement qui devient une condition d’arrêt en disparaît.
Deux limites à ce que couvre le tableau, et toutes deux méritent d’être connues avant de conclure qu’un code manque :
- Tout ce qui figure sur cette page n’en fait pas partie. Plusieurs des constats expliqués ci-dessous sont levés par une passe qui leur est propre plutôt que par une règle déclarée, et certains ne portent aucune condition — les lignes qu’ils affichent restent exactement telles que décrites dans leurs sections, mais il n’y a aucun code à résoudre et donc aucune ligne. Le code de classe
unsupported-fieldest la forme à attendre dans ce cas : il nomme une classe de constats plutôt qu’une condition. - Une ligne ici ne promet pas une section plus bas. Un avertissement levé tard dans le rendu est catalogué plutôt qu’expliqué, de sorte qu’un code peut renvoyer ici à une phrase et avoir son traitement plus complet dans fatal-halts.md sous « Conditions qui n’arrêtent pas un build », qui catalogue chaque condition portant un code sans arrêter un build.
sentinels.md résout tout code court qu’affiche un build, d’avertissement ou d’arrêt, et c’est l’endroit par où commencer lorsque vous ne savez pas encore de quel type est celui que vous avez en main.
| Code court | S’ouvre par |
|---|---|
E0004 | annotation contribution overridden by an explicit value |
E0037 | cross-boundary link between endpoints rendered by different providers is not supported |
E0149 | attachment name is a near miss for a declared slot |
E0167 | Recipe publishes a provides key its Component does not declare |
E0173 | declared parameter is read by no reference in the Aggregate |
E0174 | uses socket name is a near miss for a declared socket |
E0256 | annotation binding declares one path in both pillar lists |
E0297 | inherited boundary directory carries no template variable, so it resolves to the path the extended Release writes to |
Schema-pillar-overlap lint (Lint de chevauchement des piliers du schéma)
Se déclenche quand un Component ou une Feature déclare le même nom de propriété à la fois dans le pilier values: et dans le pilier infra: de son bloc spec.schema: au même niveau d’imbrication. Les auteurs de schémas qui mettent le même nom de champ dans les deux piliers entendent généralement le mettre dans l’un ou dans l’autre ; le lint signale la duplication afin que l’auteur puisse déterminer quel pilier possède le champ.
Place dans le pipeline. Le lint s’exécute dans la passe de validation après l’unification des schémas, avant la construction de la topologie. Il parcourt le schéma après l’expansion de la forme compacte, sans suivre de $ref: (voir la discipline de saut silencieux ci-dessous), et signale chaque propriété en chevauchement comme un avertissement distinct.
Forme émise :
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)Pour les propriétés imbriquées, le chemin est le chemin pointé vers la propriété depuis la racine du pilier :
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 chargement du catalogue entier — aggrega validate sans argument — nomme chaque entité par son nom et sa version et par le fichier d’où elle a été lue, comme ci-dessus. Un build, ou la validation d’une seule Release, ne lit que les entités que cette Release atteint et nomme chacune par son nom et sa version — at core/db-pool:1.0.0 — une fois par entité, quel que soit le nombre de références de la Release qui l’atteignent : un Aggregate qui nomme une Feature par son nom nu et un Manifest qui la mappe par nom et version atteignent une seule Feature, qui est signalée une fois.
Visibilité dans l’éditeur. Le constat atteint les diagnostics de l’éditeur par le serveur de langage, avec la gravité avertissement, en tête du fichier plutôt que sur une clé — il nomme une entité du catalogue plutôt qu’une position dans le document que vous modifiez, il n’y a donc aucune clé de rédaction sur laquelle un marqueur pourrait se placer. Il est levé avant l’étape de rendu des artefacts, il n’a donc besoin d’aucun réglage : une session d’éditeur le fait apparaître que serve.build_on_inspect soit activé ou non.
Discipline de saut silencieux. Le parcours se termine sans avertissement lorsqu’une branche du schéma porte l’une des portes de sortie de JSON Schema 2020-12 qui empêchent des ensembles de propriétés dérivables statiquement : $ref (références entre documents ou internes au document), patternProperties (déclarations de propriétés fondées sur la forme de la clé), additionalProperties défini à true ou à un schéma (propriétés que la branche admet sans les nommer), et les opérateurs de composition oneOf / anyOf / allOf (disjonctions et conjonctions dont les branches peuvent déclarer des ensembles de propriétés divergents). Parcourir ces branches exigerait soit d’évaluer le schéma référencé ou composé au moment du lint (un type de travail que le lint n’effectue pas), soit produirait des faux positifs lorsque le nom d’une propriété values: d’une branche coïncide par hasard avec le nom d’une propriété infra: d’une autre branche. Le lint n’émet aucun avertissement pour le niveau d’imbrication concerné ; les niveaux plus profonds du même schéma sont toujours parcourus et soumis au lint.
Note de rédaction. Le compilateur ne rejette pas les chevauchements de noms entre piliers — le lint est un avertissement. Un Component avec storage_size dans les deux piliers se compile ; le values.storage_size côté développeur et le infra.storage_size côté opérateur sont validés indépendamment par les schémas de leurs piliers, et le template valuesMapping: de la Recipe choisit de quel pilier la valeur passe dans la sortie rendue. Le lint existe parce que ce modèle de rédaction est presque toujours une erreur ; la duplication consciente entre piliers est assez rare pour que les auteurs qui la veulent vraiment puissent ignorer l’avertissement. Pour la mécanique inter-piliers en général — y compris les rares cas où un acheminement délibéré entre piliers est justifié — voir vocabulary/data-pillars.md « Mécanique inter-piliers ».
Binding-map-overlap lint (Lint de chevauchement des maps de liaison)
Se déclenche quand une liaison d’annotation du Manifest déclare le même chemin pointé à la fois dans sa liste maps.infra et dans sa liste maps.values. Le chemin serait routé par les deux piliers ; le critère de départage déterministe du compilateur l’envoie par infra:, ce qui rend le côté values: inaccessible depuis l’Aggregate. Le lint le fait apparaître afin que l’auteur puisse soit restreindre la liaison à un seul pilier, soit accepter consciemment le routage par le seul côté infra.
Place dans le pipeline. Le lint s’exécute après la résolution du Manifest et avant que la moindre expansion d’annotation ne se déclenche, de sorte qu’un build signale une liaison en chevauchement, qu’une annotation d’un Aggregate atteigne jamais cette liaison ou non. Il parcourt les liaisons sous mappings.features.annotations dans l’ordre où elles ont été écrites, fait l’intersection des listes maps.infra et maps.values de chaque liaison et signale un constat par chemin en chevauchement. Au sein d’une liaison, les chemins en chevauchement sont signalés dans l’ordre où la liste maps.values de cette liaison les déclare — l’ordre dans lequel vous les avez écrits — de sorte que des exécutions répétées sur une entrée identique signalent une séquence identique.
Forme émise :
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")Ces deux lignes proviennent d’un seul build sur un seul Manifest, et ce qui diffère entre leurs localisateurs est la forme de la clé d’annotation. Un localisateur adresse un document par chemin pointé, il s’arrête donc au premier segment qui contient lui-même un point : audit-scope n’en contient aucun et le localisateur atteint la liaison, tandis que compliance.aggrega.ai/data-class en contient un, et le localisateur nomme à la place le bloc annotations qui la contient. C’est pourquoi la clé fautive est aussi la première valeur entre guillemets de chaque constat — c’est la seule partie que le localisateur ne peut pas toujours porter.
Visibilité dans l’éditeur. Le constat atteint aussi les diagnostics de l’éditeur par le serveur de langage, avec la gravité avertissement, positionné là où son localisateur parvient — sur la liaison elle-même pour une clé simple, et sur le bloc annotations englobant pour une clé contenant un point. Un auteur qui ne lit jamais la sortie du terminal le voit quand même. Il est levé avant l’étape de rendu des artefacts, il n’a donc besoin d’aucun réglage : une session d’éditeur le fait apparaître que serve.build_on_inspect soit activé ou non.
Établir la correspondance par programme. Le constat porte ErrAnnotationBindingPillarOverlap de pkg/resolver, de sorte qu’un consommateur reconnaît la classe avec errors.Is plutôt qu’en comparant le texte du message. Comme toute sentinelle d’avertissement, il n’atteint jamais le verdict d’un build — voir sentinels.md pour l’accesseur et les codes de la condition.
Critère de départage déterministe. Le runtime résout la collision en routant le chemin exclusivement par le pilier infra:. Le choix est cohérent d’un build à l’autre ; l’auteur peut s’y fier. Le côté values: est retiré du routage effectif de la liaison — les annotations côté Aggregate qui tentent d’atteindre le chemin ne reçoivent aucune cible de routage et le build s’arrête côté Aggregate au moment de l’expansion, avec l’arrêt décrit dans fatal-halts.md « An annotation routes through a pillar its authoring side may not use (Une annotation est routée par un pilier que son côté auteur ne peut pas utiliser) ». Le lint est la surface d’alerte précoce ; cet arrêt est la surface qui fait respecter la règle.
Note de rédaction. Comme le lint de chevauchement des piliers du schéma, ce lint est un avertissement — la liaison se compile et le critère de départage à l’exécution produit une sortie déterministe. Le lint se déclenche parce que ce modèle de rédaction est presque toujours involontaire ; un auteur de liaison qui voudrait réellement que les deux piliers routent le même chemin écrirait deux liaisons distinctes avec des clés d’annotation différentes.
Attachment-slot near-miss lint (Lint de quasi-correspondance des emplacements de rattachement)
Se déclenche quand une instance de composant rattache une Feature sous un nom qui n’est pas l’un des emplacements featuresSchema déclarés de son type de Component, mais qui se trouve à une modification de l’un d’eux — un seul caractère inséré, supprimé ou substitué, ou deux caractères adjacents permutés — dont la Feature rattachée ne satisfait pas le selector. C’est la forme que prend une faute de frappe dans un nom d’emplacement, et le lint nomme les deux orthographes afin que l’auteur puisse voir la paire.
Pourquoi il existe. Déclarer un emplacement ne ferme pas la surface de rattachement : un rattachement sous un nom qu’aucun emplacement ne déclare est légal, car c’est cette ouverture qui permet à une même entité du catalogue de servir à la fois un rattachement qui remplit un emplacement et des informations d’identification partagées à une portée plus large. Le coût est qu’un nom d’emplacement mal orthographié devient silencieusement un rattachement libre plutôt que le remplissage de l’emplacement que l’auteur voulait — le build réussit et l’emplacement reste simplement vide. Le lint est l’atténuation annoncée précisément pour ce cas.
Place dans le pipeline. Le lint s’exécute à la résolution, dans la même passe que les garde-fous sémantiques qui tiennent compte du catalogue, sur l’Aggregate résolu. Il compare les noms de rattachement de chaque instance de composant aux noms d’emplacements déclarés du type de Component de cette instance, et émet un avertissement par paire de quasi-correspondance.
Forme émise :
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")La première valeur entre guillemets est le nom sous lequel le rattachement a été écrit, et c’est d’elle que traite la phrase d’ouverture de l’avertissement. Les deux suivantes sont introduites par les mots qui disent ce qu’elles sont : le type de Component sur lequel se trouve le rattachement, et l’emplacement déclaré dont il est à une modification près.
Visibilité dans l’éditeur. L’avertissement atteint aussi les diagnostics de l’éditeur par le serveur de langage, avec la gravité avertissement, positionné sur la clé de rattachement fautive. Un auteur qui ne lit jamais la sortie du terminal voit quand même la paire. Il est levé avant l’étape de rendu des artefacts, il n’a donc besoin d’aucun réglage : une session d’éditeur le fait apparaître que serve.build_on_inspect soit activé ou non.
Le seuil et son compromis. Le lint n’apparie des noms qu’à une distance d’une modification, et seulement lorsque les deux noms comptent au moins quatre caractères. En dessous de cette longueur, presque chaque nom court se trouve à une modification de tous les autres, de sorte que les apparier produirait du bruit plutôt que du signal ; au-delà d’une modification, les paires cessent de ressembler à des fautes de frappe. Une transposition compte pour une modification plutôt que deux, car une paire de caractères permutés est l’erreur la plus courante et un comptage plus strict la manquerait.
Note de rédaction. Le lint est un avertissement et ne change jamais le verdict du build — le compilateur ne contrôle pas la façon dont un auteur nomme un rattachement. Un auteur qui rattache délibérément une Feature sous un nom qui ressemble à un emplacement peut ignorer l’avertissement ; le rattachement se comporte exactement comme il a été écrit.
Pas lorsque la Feature correspond à l’emplacement. Un nom à une modification d’un emplacement dont la Feature rattachée satisfait le selector ne donne lieu à aucun avertissement. Cet appariement n’est pas un rattachement libre mal tapé mais un remplissage écrit sous un autre nom, et son importance dépend de ce que l’emplacement finisse vide ou non, ce qui n’est connu qu’une fois toutes les portées fusionnées. Lorsque l’emplacement reste vide, le build s’arrête et nomme le rattachement et l’emplacement — voir « An attachment written under another name fits a slot its component leaves empty (Un rattachement écrit sous un autre nom correspond à un emplacement que son composant laisse vide) » dans fatal-halts.md — de sorte que l’arrêt est le seul constat signalé, jamais un avertissement à côté. Lorsqu’autre chose lie l’emplacement, le rattachement est un rattachement supplémentaire ordinaire et rien n’est signalé. Aucune Feature ne correspond à un emplacement qui ne déclare aucun selector, de sorte qu’un nom proche d’un tel emplacement donne toujours lieu à l’avertissement.
Pas sur une connexion. Le lint lit le propre bloc features: d’un composant, qui est ouvert. Les rattachements que porte une connexion sont indexés par les emplacements que son socket déclare et rien d’autre, de sorte qu’un nom à une modification de l’un de ces emplacements n’y est pas légal : le build s’arrête à la place, et l’arrêt nomme dans la même phrase l’emplacement près duquel se trouve le nom. Aucun avertissement n’est levé à côté. Voir « A connection carries an attachment under a name its socket declares no slot for (Une connexion porte un rattachement sous un nom pour lequel son socket ne déclare aucun emplacement) » dans fatal-halts.md.
Uses-socket near-miss lint (Lint de quasi-correspondance des sockets uses)
Se déclenche quand le propre bloc uses: d’un composant nomme un socket qui n’est pas l’un des sockets usesSchema déclarés de son type de Component, mais qui se trouve à une modification de l’un d’eux — un seul caractère inséré, supprimé ou substitué, ou deux caractères adjacents permutés. C’est la forme que prend une faute de frappe dans un nom de socket, et le lint nomme les deux orthographes afin que l’auteur puisse voir la paire.
Pourquoi il existe. Déclarer un socket ne ferme pas la surface uses: sur le propre composant d’un développeur : un nom de socket qu’aucune entrée usesSchema ne déclare est légal, car le silence du catalogue sur un socket signifie que la connexion n’a pas été anticipée et non qu’elle est interdite, et le développeur possède la topologie de l’Aggregate. Le coût est qu’un nom de socket mal orthographié devient une connexion ad hoc à part entière au lieu de câbler le socket que l’auteur voulait — le build réussit, le socket prévu reste simplement non câblé, et l’arête ad hoc ne porte ni sélecteur ni contrat par arête. Le lint est l’atténuation annoncée précisément pour ce cas. Pour ce à quoi renonce un socket ad hoc et ce qu’il conserve, voir entities/component.md « Sockets de topologie : usesSchema ».
Quelle surface il couvre. Uniquement le propre bloc uses: du composant — la seule surface où un nom de socket non déclaré est accepté. Le uses: d’un rattachement de Feature ne peut nommer qu’un socket que la Feature rattachée déclare, et le uses: par arête d’une Release ne peut nommer qu’un socket que le Component consommateur déclare ; un nom erroné sur l’une ou l’autre de ces surfaces arrête déjà le build, un avertissement n’aurait donc rien à ajouter.
Place dans le pipeline. Le lint s’exécute à la résolution, dans la même passe que les garde-fous sémantiques qui tiennent compte du catalogue, sur l’Aggregate résolu. Il compare les propres noms de socket de chaque instance de composant aux noms de socket déclarés du type de Component de cette instance, et émet un avertissement par paire de quasi-correspondance. Un composant qui provient d’un sous-agrégat n’est pas couvert : ses composants internes sont intégrés au graphe après l’exécution de cette passe.
Forme émise :
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")La première valeur entre guillemets est le nom de socket que l’auteur a écrit, et c’est d’elle que traite la phrase d’ouverture de l’avertissement. Les deux suivantes sont introduites par les mots qui disent ce qu’elles sont : le type de Component sur lequel le socket a été nommé, et le socket déclaré dont il est à une modification près. La conséquence que l’avertissement n’explicite pas est celle décrite ci-dessus : le nom mal orthographié est une connexion ad hoc, il ne porte donc ni sélecteur ni contrat par arête, et le socket que l’auteur voulait reste non câblé.
Visibilité dans l’éditeur. L’avertissement atteint aussi les diagnostics de l’éditeur par le serveur de langage, avec la gravité avertissement, positionné sur le composant dont le bloc uses: contient le nom fautif. Un auteur qui ne lit jamais la sortie du terminal voit quand même la paire. Il est levé avant l’étape de rendu des artefacts, il n’a donc besoin d’aucun réglage : une session d’éditeur le fait apparaître que serve.build_on_inspect soit activé ou non.
Le seuil et son compromis. Le lint n’apparie des noms qu’à une distance d’une modification, et seulement lorsque les deux noms comptent au moins quatre caractères — la même borne que celle qu’utilise le lint de quasi-correspondance des emplacements de rattachement, pour la même raison. En dessous de cette longueur, presque chaque nom court se trouve à une modification de tous les autres, de sorte que les apparier produirait du bruit plutôt que du signal ; au-delà d’une modification, les paires cessent de ressembler à des fautes de frappe. Une transposition compte pour une modification plutôt que deux, car une paire de caractères permutés est l’erreur la plus courante et un comptage plus strict la manquerait.
Note de rédaction. Le lint est un avertissement et ne change jamais le verdict du build — le compilateur ne contrôle pas la façon dont un auteur nomme un socket. Un auteur qui trace délibérément une connexion ad hoc sous un nom qui ressemble à un socket déclaré (une connexion cache à côté d’un socket déclaré caches, destinée à autre chose) peut ignorer l’avertissement ; l’arête se comporte exactement comme elle a été écrite. Aucune option ne permet de le supprimer, et aucune n’est nécessaire : il ne pèse en rien sur le verdict.
Undeclared-provides-key lint (Lint des clés provides non déclarées)
Se déclenche quand la Recipe liée à une instance de composant publie sous son provides: une clé que le type de Component de l’instance ne déclare pas dans son contrat spec.schema.provides:.
Pourquoi il existe. Publier davantage que ce que le Component déclare est légal et le reste : le contrat provides exige le sous-ensemble et permet le sur-ensemble, de sorte qu’une Recipe qui couvre le contrat de son Component et émet en outre des clés supplémentaires est une Recipe qui le remplit. Ce que le lint nomme, c’est une conséquence qui serait sinon invisible des deux côtés. Un consommateur qui lit à travers une arête uses: voit le contrat déclaré de la cible plutôt que ce que la Recipe de la cible se trouve émettre — c’est ce qui garde les Recipes interchangeables, puisque deux Recipes réalisant un même Component présentent alors la même surface à un consommateur, et que les échanger ne peut pas retirer silencieusement une clé dont un consommateur en était venu à dépendre. Une clé non déclarée n’est donc pas livrée à travers l’arête, et un template consommateur qui la lit produit une valeur vide au lieu d’échouer.
Le constat est énoncé à sa cause — sur la Recipe qui a publié la clé — parce que c’est là qu’il peut être nommé. Chez le consommateur, la clé est une référence de template que le compilateur ne peut pas attribuer à une cible particulière, et un diagnostic qui devinerait serait pire que l’absence de diagnostic. Les deux ne sont donc délibérément pas placés au même endroit : la valeur vide apparaît chez le consommateur, l’explication ici, et les deux apparaissent dans la même sortie du build.
Quel appariement est comparé. Les clés provides: écrites dans la Recipe liée, comparées aux clés spec.schema.provides: déclarées par le type de Component. Cet ensemble déclaré est le même que celui par rapport auquel une clé from: à l’intérieur d’un bloc inject: est vérifiée, de sorte que les deux s’accordent sur ce qu’un Component déclare. La comparaison est exacte et non un test de ressemblance ; contrairement aux deux lints de quasi-correspondance ci-dessus, elle n’a donc aucun seuil et n’apparie aucun nom.
La Recipe comparée est celle à laquelle l’instance est réellement liée, retrouvée par le même nom d’instance et le même type de catalogue que ceux par lesquels le rendu la lie, de sorte qu’une substitution de Recipe par instance dans le Manifest est respectée plutôt que noyée dans une moyenne. Une instance de composant dont le type ne se résout en aucun Component du catalogue est ignorée : aucune déclaration n’a été lue, ce qui n’est pas la même chose qu’une déclaration de rien.
Place dans le pipeline. Le lint s’exécute à la résolution, dans la même passe que les garde-fous sémantiques qui tiennent compte du catalogue, sur l’Aggregate résolu — avant le rendu, de sorte qu’il apparaît avec aggrega validate --release comme avec aggrega build. Les Components déclarés à la racine de l’Aggregate et les composants imbriqués dans des sous-systèmes sont couverts les uns comme les autres. Un composant qui provient d’un sous-agrégat n’est pas couvert : ses composants internes sont intégrés au graphe après l’exécution de cette passe, de sorte que la clé non déclarée d’un tel composant n’est toujours pas livrée aux consommateurs, mais qu’aucun avertissement ne la nomme.
Forme émise. Une ligne par instance de composant et par clé, qui nomme la Recipe ayant publié la clé et le Component qui ne la déclare pas :
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")Le constat appartient à l’instance qui le porte, de sorte que dix instances d’un même type de Component publiant la même clé non déclarée lèvent dix lignes plutôt qu’une, chacune nommant sa propre instance. Chaque ligne est attribuée à la Recipe qui a publié la clé, car c’est le document que vous modifiez pour le résoudre. Le parcours est déterministe, de sorte que la même entrée produit la même séquence d’avertissements à chaque exécution.
Visibilité dans l’éditeur. L’avertissement atteint aussi les diagnostics de l’éditeur par le serveur de langage, avec la gravité avertissement, positionné sur l’instance de composant dont le type: lie la Recipe. Un auteur qui ne lit jamais la sortie du terminal le voit quand même. Il est levé avant l’étape de rendu des artefacts, il n’a donc besoin d’aucun réglage : une session d’éditeur le fait apparaître que serve.build_on_inspect soit activé ou non.
Note de rédaction. Le lint est un avertissement et ne change jamais le verdict du build — avec une Recipe qui publie davantage que ce que déclare son Component, le build réussit tout de même. La correction est l’une de deux, et le choix de la bonne revient à l’auteur : déclarer la clé sur le Component lorsque des consommateurs doivent la lire, ou la laisser non déclarée lorsqu’elle est l’état de travail propre de la Recipe, auquel cas c’est dans locals: qu’un tel état a sa place. Le cas inverse n’est pas un avertissement : un Component qui déclare une clé que sa Recipe ne publie pas laisse le contrat non rempli et arrête le build.
Ghost Infrastructure Tracker warnings (Avertissements du tracker de Ghost Infrastructure)
Se déclenche quand une clé déclarée par un auteur atteint un nœud et qu’aucun template déclaré par la Recipe liée n’y fait jamais référence. Les clés non lues deviennent une infrastructure silencieuse : une configuration demandée par le développeur ou l’opérateur que la Recipe ne câble jamais dans la sortie rendue. Le tracker les fait apparaître afin que l’écart entre ce qui a été rédigé et ce que contient la sortie soit visible plutôt que silencieux.
Quelles clés rédigées sont comparées. Trois groupes, par nœud :
.values— le pilier propre du nœud, côté développeur..infra— le pilier propre du nœud, côté opérateur..context.uses.<alias>.values— les valeurs par connexion portées par chaque arêteuses:par laquelle le nœud consomme. Ce groupe est limité au consommateur d’office : la mapusesd’un nœud ne contient que les arêtes dont il est la source, de sorte qu’une valeur par connexion non lue est toujours attribuée au nœud qui l’a rédigée et jamais à la cible de l’arête.
Quelles références sont collectées. Chaque template déclaré par la Recipe liée. L’avertissement dit qu’une clé n’est lue par rien, ce qui est une affirmation sur la Recipe entière, de sorte que tout ce qui serait plus étroit que la Recipe entière la rendrait fausse plutôt qu’approximative — une clé consommée par une coordonnée source: serait signalée comme non lue par l’exécution même qui a récupéré la version qu’elle nommait. Les blocs lus sont :
valuesMapping:, la surcouche values transmise au fournisseur.source:— le champ entier là où il est rédigé comme une seule chaîne, et chacun de ses champs à valeur de chaîne là où il est rédigé comme un objet. Une coordonnée source est un template évalué pour chaque instance consommatrice, de sorte qu’une version, un nom de chart, une référence git ou un sous-répertoire de module choisis à partir de.valuesou de.infralisent ces clés.locals:etprovides:, chaque entrée.assertions:, chaque entrée.workload:, le corps de Workload synthétisé.artifacts:, le contenu de chaque entrée.pipeline:, l’entréewith:de chaque étape et son contrôlewhen:.
Trois limites en découlent, et toutes trois sont des limites de ce qui peut être affirmé honnêtement plutôt que des choix. Chacune réduit la lecture au silence plutôt que de l’élargir, ce qui est la direction qui coûte le moins : une clé non signalée coûte à un lecteur un avertissement qu’il peut encore trouver en lisant la Recipe, alors qu’une clé signalée à tort lui dit qu’un réglage qui fonctionne a été ignoré.
- Une Recipe sans
valuesMapping:en ligne n’est pas lue du tout. Ses clés sont sautées plutôt que signalées, quoi que fassent ses autres templates. - Un bloc que la Recipe importe depuis un fichier ou depuis une référence de bibliothèque n’est pas disponible à ce stade, de sorte que ses références ne peuvent pas être collectées. Les clés du nœud sont entièrement sautées plutôt que signalées — cela vaut aussi bien pour un
valuesMapping:importé que pour unworkload:importé et une entréeartifacts:importée. - Un template qui ne s’analyse pas ne produit aucun ensemble de références. Signaler chaque clé comme non lue enfouirait le diagnostic d’analyse que l’évaluation lève sur le même template, de sorte que rien n’est signalé à la place. Une entrée
artifacts:est lue avec les délimiteurs standard{{ }}, qui ne sont pas la paire que chaque fournisseur déclare pour ce champ ; lu avec la mauvaise paire, un tel corps produit des références que son auteur n’a jamais écrites, ou ne s’analyse pas, et les deux issues ne peuvent jamais que faire taire un avertissement.
Le valueSchema d’un socket n’est jamais signalé. usesSchema.<socket>.valueSchema déclare le contrat qu’une valeur par connexion doit satisfaire. C’est un schéma, pas une instance rédigée, et il ne fait pas partie des entrées comparées — il ne peut donc jamais être signalé. Ce que produit la valeur par défaut déclarée d’un socket est une instance comme une autre, lue ou non lue selon ses propres mérites.
Une référence qui nomme un pilier entier compte comme lue chaque clé qui s’y trouve. {{ .infra.port }} marque port comme lue et laisse les autres clés du pilier exposées à un avertissement. {{ optional .infra `port` 8080 }} transmet la map .infra entière à une fonction, de sorte que la référence collectée nomme le pilier plutôt qu’une clé qui s’y trouve, que chaque clé de ce pilier compte comme lue et que le pilier ne lève rien. Il en va de même pour le parcours d’un pilier avec range et pour l’accès à une entrée de uses par index. Un auteur de Recipe qui veut une couverture clé par clé écrit des références clé par clé.
Cela touche chacun des blocs ci-dessus, ce qui est bon à savoir avant qu’un pilier silencieux ne passe pour un avertissement manqué : une Recipe dont la version source: est écrite {{ optional .infra `source_version` "1.2.3" }} a transmis la map .infra entière à une fonction, de sorte que cette Recipe ne signale rien sur aucune clé .infra d’aucun nœud qu’elle rend. Le pilier .values n’est pas concerné — les deux sont comptés séparément.
Place dans le pipeline. Le tracker s’exécute au rendu de base, à côté de l’évaluation des templates. Chacun des templates de la Recipe est analysé et parcouru pour collecter les chemins de champ qualifiés par des points auxquels il fait référence (.values.port, .infra.replicas, .context.uses.<alias>.values.retry_budget) ; l’ensemble de clés résolu de chaque groupe est comparé à l’union de ces références, et la différence est l’ensemble non lu. Ce qui est parcouru, c’est la Recipe telle qu’elle est rédigée : une coordonnée source: est lue comme le texte de son template, et non comme la valeur que ce template a produite pour cette instance.
Forme émise. Une ligne par clé non lue, qui nomme le nœud, le chemin du groupe, la clé et la Recipe dont aucun template ne la lit :
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 keyLa ligne ne nomme aucun champ de la Recipe, et c’est délibéré : celui qui a rédigé la clé est le développeur, l’opérateur ou l’auteur de l’arête uses: qui la transporte, et aucun d’eux ne modifie la Recipe. Nommer le bloc dans lequel la référence a été cherchée donnerait à ce lecteur une coordonnée dans un document qu’il n’ouvre pas. Les deux remèdes que la ligne propose sont les deux sur lesquels il peut agir — une clé mal orthographiée est la cause habituelle, et une clé qui n’allait jamais être lue mérite d’être supprimée.
L’ordre est fixe : d’abord .values du nœud, puis son .infra, puis chaque alias uses dans l’ordre où les arêtes ont été émises, les clés étant triées au sein de chaque groupe. La même entrée produit donc la même séquence d’avertissements à chaque exécution.
Visibilité dans l’éditeur. L’avertissement n’atteint les diagnostics de l’éditeur que là où le serveur de langage exécute l’étape de rendu des artefacts pendant l’inspection d’un graphe IR — aggrega serve --build-on-inspect, ou la clé de configuration serve.build_on_inspect que l’option remplace, désactivée par défaut. Ce réglage ajoute les avertissements qu’un build lève pendant le rendu, et aucun des contrôles sur lesquels un build s’arrête. L’entrée nomme un nœud plutôt qu’une clé de rédaction, elle est donc affichée sur la clé kind: de l’Aggregate.
Pourquoi un avertissement et non un arrêt fatal. Les développeurs peuvent légitimement consommer différents sous-ensembles de .values dans une logique de template conditionnelle — une Recipe dont le template se ramifie sur .values.mode lit mode mais ne lit .values.replication_password que de façon conditionnelle, lorsque mode == "replication". Le parcours statique ne peut pas déterminer si une clé non référencée est indifférente ou un bogue. Le but du tracker est de rendre l’écart visible plutôt que de le contrôler ; l’omission silencieuse est le mode de défaillance que le tracker empêche.
Réponse de l’auteur de la Recipe. Lorsqu’un auteur de Recipe voit un avertissement de Ghost Infrastructure pour une clé qu’il s’attendait à voir consommée par la Recipe, la correction consiste à câbler la clé dans le template. Lorsque la clé non lue est une omission délibérée (une fonctionnalité que le chart ne prend pas en charge, une possibilité de rédaction que la Recipe ignore délibérément), l’auteur peut documenter l’omission dans le commentaire d’en-tête de la Recipe afin que les futurs lecteurs sachent que l’écart est intentionnel.
Unread declared-parameter warnings (Avertissements de paramètres déclarés non lus)
Se déclenche quand un Aggregate déclare une entrée sous spec.parameters: et qu’aucune référence {{ .parameters.<key> }} dans le texte propre de cet Aggregate ne la lit.
Un paramètre déclaré est la surface de rédaction permettant de faire varier une valeur par Release : la Release remplit la déclaration, et une référence porte la valeur fournie dans les valeurs du composant auxquelles elle appartient. Une déclaration que rien ne lit laisse cette variation sans endroit où aboutir — quoi qu’une Release fournisse pour elle, la sortie rendue est la même. C’est la forme, à l’échelle des paramètres, du même signe suspect que porte une clé values rédigée que rien ne consomme.
Une valeur par défaut n’est pas une exemption. Une valeur par défaut qu’aucune référence ne lit n’atteint pas davantage la sortie qu’une valeur fournie par une Release, de sorte qu’une déclaration avec valeur par défaut est signalée exactement comme une déclaration nue.
Quelles références sont collectées. Le texte propre de l’Aggregate, et rien d’autre. Trois conséquences en découlent :
- Un paramètre atteint uniquement par le prédicat
validate:du schéma d’un Component n’est pas visible ici. Un tel prédicat nomme le paramètre au moyen de la map de paramètres résolue plutôt qu’au moyen d’une référence pointée dans l’Aggregate, de sorte que la déclaration est signalée comme non lue alors même que le prédicat la lit. - Un texte qui ne s’analyse pas comme un template ne produit aucun ensemble de références. Signaler chaque déclaration comme non lue enfouirait le diagnostic que l’interpolation lève sur le même texte, de sorte que rien n’est signalé à la place.
- Une référence qui nomme la map
parametersentière — en l’itérant, ou en atteignant une entrée par index — compte chaque déclaration comme lue, car la référence collectée nomme alors la map plutôt qu’une clé qui s’y trouve et aucune affirmation clé par clé n’est possible.
Place dans le pipeline. La lecture s’exécute à la résolution, sur le texte brut de l’Aggregate et son contrat de paramètres déclaré — avant le rendu. Elle apparaît donc avec aggrega validate aussi bien qu’avec aggrega build.
Forme émise. Une ligne par déclaration non lue, qui nomme l’Aggregate et le localisateur de la déclaration :
lint: declared parameter is read by no reference in the Aggregate (Aggregate fullstack-app, at .spec.parameters.unread_probe, "unread_probe")Les constats arrivent dans l’ordre où l’Aggregate déclare ses paramètres, de sorte que le même Aggregate produit la même séquence à chaque exécution. Chacun porte le localisateur de la déclaration, qui nomme la clé fautive. Le message nomme lui aussi la clé, c’est pourquoi elle apparaît deux fois sur une ligne de terminal qui affiche aussi le localisateur : un éditeur montre le message à la position où il l’a placé et jamais le texte du localisateur, de sorte qu’un message qui omettrait la clé se lirait de la même façon pour chaque déclaration non lue.
Visibilité dans l’éditeur. L’avertissement atteint aussi les diagnostics de l’éditeur par le serveur de langage, avec la gravité avertissement, positionné sur la déclaration que nomme son localisateur plutôt que sur l’Aggregate dans son ensemble. Il est levé avant l’étape de rendu des artefacts, il n’a donc besoin d’aucun réglage : une session d’éditeur le fait apparaître que serve.build_on_inspect soit activé ou non.
Pourquoi un avertissement et non un arrêt fatal. Un paramètre peut être déclaré avant la référence qui le lira, et un parcours statique ne peut pas distinguer ce cas d’une erreur — la même raison pour laquelle la lecture des clés rédigées ne fait jamais qu’avertir. Le compilateur ne contrôle pas quels réglages un auteur expose.
Provider-binding unserved-capability warning (Avertissement de capacité non servie d’une liaison de fournisseur)
Se déclenche quand une entrée sous plugins.providers dans la configuration de l’espace de travail nomme une capability et aucun uri, et qu’aucun des plugins de fournisseur que lit le build ne sert cette capacité. Les plugins que lit un build sont ceux de ses répertoires de catalogue, les fournisseurs intégrés au compilateur et les plugins qu’enregistre son fichier de verrouillage.
Pourquoi il existe. Une liaison n’est lue que lorsque le capability: d’une Recipe demande sa capacité, et une entrée qui ne nomme aucun plugin ne sélectionne rien que la résolution de la capacité ne sélectionnerait pas sans elle. Ainsi, une entrée dont la capacité est mal orthographiée — hlem pour helm — n’est consultée par rien et ne change rien, et sans cet avertissement rien ne le dirait.
Pourquoi un avertissement et non un arrêt fatal. Les liaisons sont écrites une seule fois pour tout l’espace de travail, alors qu’un build porte sur une seule Release. Le plugin qui sert la capacité peut être un plugin que seule une autre Release de l’espace de travail lit, et ce build ne peut pas le voir, de sorte qu’un arrêt ici refuserait un espace de travail légal sur une supposition. Une entrée qui nomme aussi un plugin est un cas différent : un pull résout chacune de ces entrées, qu’une Recipe l’utilise ou non, de sorte que le build détient le plugin et sait ce qu’il sert, et une capacité que ce plugin ne sert pas provoque un arrêt — voir fatal-halts.md « A plugins.providers binding names a plugin that does not serve the capability (Une liaison nomme un plugin qui ne sert pas la capacité) ». Une entrée pour une capacité que sert effectivement un plugin lu par le build n’est signalée d’aucune façon, qu’une Recipe de cette Release l’utilise ou non.
Place dans le pipeline. Chaque build et chaque validation d’une Release lit chaque entrée de la configuration composée de l’espace de travail — les couches et leurs compléments providers_append ensemble — avant que le graphe de la Release ne soit analysé, de sorte que l’avertissement apparaît avec aggrega validate --release aussi bien qu’avec aggrega build, et avec aggrega pull, qui rend la Release une fois, sur le fichier de verrouillage qu’il s’apprête à écrire, pour découvrir les entrées externes que récupère un build de celle-ci. Ce jugement ne change rien au choix du plugin qui rend une Recipe ; celui-ci est lu dans le fichier de verrouillage.
Forme émise. Une ligne par entrée, dans l’ordre où la liste composée les porte, qui nomme la capacité et une capacité servie à une modification près, lorsqu’il en existe une :
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 readsSeuil. Une orthographe n’est proposée qu’à une distance d’une modification et seulement lorsque les deux noms comptent au moins quatre caractères, la même borne que celle qu’utilisent les lints de quasi-correspondance ci-dessus, et pour la même raison.
Visibilité dans l’éditeur. L’avertissement atteint les diagnostics de l’éditeur par le serveur de langage avec la gravité avertissement. L’entrée se trouve dans le fichier de configuration plutôt que dans le document en cours de modification, elle est donc placée en tête de ce document plutôt que sur une clé.
Couverture des métadonnées par entité
Les enveloppes d’entité qui portent metadata.labels et metadata.annotations varient selon le type. Component, Feature et les types de bibliothèque portent les deux ; Aggregate ne porte que les étiquettes ; Recipe, FeatureRecipe, Manifest, Release et Plugin n’acceptent aucune des deux clés au niveau de l’enveloppe. État du langage indique la situation de chaque entité et c’est la surface à consulter.
Visibilité dans l’éditeur. Aucun avertissement ne couvre ce point, quel que soit le réglage : il n’y a rien à signaler, car une entité porte ces clés ou ne les accepte pas, et une clé qu’un type n’accepte pas est une question à laquelle son schéma répond au chargement du document, et non quelque chose que l’étape de rendu signale après coup. Un auteur consulte la page d’état plutôt que d’attendre un avertissement.
Unsupported-field warnings (Avertissements de champ non pris en charge)
Une seule classe couvre tout ce que vous avez rédigé et que la cible ne peut pas honorer. Elle a deux membres — un champ de Workload que la cible ne peut pas exprimer, et une annotation aggrega.ai/ sur laquelle la cible n’agit pas — et ils partagent un seul code de classe et une seule option de suppression, car un auteur qui veut faire taire « les choses que cette cible ignore » veut les faire taire ensemble plutôt qu’un interrupteur à la fois.
A Workload field the target cannot express (Un champ de Workload que la cible ne peut pas exprimer)
Les cibles diffèrent en fidélité. Un champ de Workload qu’une cible exprime nativement peut n’avoir aucun équivalent sur une autre — Docker Compose n’a aucune notion de contrainte d’ordonnancement, de compte de service ou de classe de priorité, par exemple. Lorsqu’un Workload déclare un tel champ et que la cible ne peut pas l’exprimer, le champ est omis avec un avertissement, un avertissement par champ rédigé. Il n’est ni abandonné silencieusement ni traité comme une erreur fatale.
La différence avec un arrêt fatal est la granularité. Une forme non prise en charge arrête le build bruyamment — la cible ne peut pas du tout produire cette forme de charge de travail. Une forme prise en charge qui porte un champ inexprimable est rendue, sans ce champ, et le dit.
Sur la cible compose, la classe couvre actuellement scheduling, serviceAccount, replicas, runtimeClassName, priorityClassName, imagePullSecrets, dnsPolicy, dnsConfig.options, le runAsNonRoot d’un conteneur, et toute clé de ressource étendue sauf nvidia.com/gpu — amd.com/gpu, par exemple — puisque celle-ci est réservée aux GPU NVIDIA. Les cas ci-dessous émettent une variante partielle de la même classe, où le champ est réduit plutôt que supprimé :
persistentTemplate— la création de volumes par réplica à partir d’un modèle n’est pas disponible, de sorte que le volume se réduit à un seul volume persistant partagé plutôt que de disparaître.- Une entrée
attachmentsd’un conteneur avecas: env— compose ne peut pas alimenter une variable d’environnement à partir d’un rattachement, la variable est donc émise avec une valeur vide. L’avertissement nomme l’entrée à sa coordonnée rédigée (containers.<name>.attachments.<KEY>, ouinitContainers[<i>].attachments.<KEY>pour une entrée init positionnelle), de sorte qu’il est clair quelle variable arrive vide et à quel conteneur elle appartient. Une entrée avecas: fileest montée normalement par bind mount et ne lève rien. - Une entrée
volumesqu’aucun conteneur ne monte — l’avertissement nomme le volume à sa coordonnée rédigée (volumes.<name>). Ce qui atteint la sortie dépend de la variante : un volumepersistentoupersistentTemplateest tout de même déclaré comme volume nommé, qui est alors créé puis laissé inutilisé, tandis qu’un volumeconfigmap,secretouephemeraln’atteint la sortie qu’à travers le point de montage d’un conteneur, de sorte que, si rien ne le monte, la déclaration ne produit aucune sortie. Dans les deux cas, le volume que vous avez rédigé ne sert à rien : montez-le depuis un conteneur, ou supprimez-le. Chaque conteneur de la charge de travail compte comme monteur, conteneurs d’initialisation compris, de sorte qu’un volume monté uniquement par un conteneur d’initialisation ne lève rien. - Un bloc
healthqui déclare plus d’un emplacement de sonde — un service compose porte un seulhealthcheck, de sorte que l’ordre de prioritélive > ready > startupconserve un emplacement et que chaque autre emplacement déclaré n’atteint aucune partie de la sortie. L’avertissement nomme le bloc à sa coordonnée rédigée (containers.<name>.health, ouinitContainers[<i>].healthpour une entrée init positionnelle) et nomme à la fois l’emplacement qui a été traduit et les emplacements qui ont été abandonnés, de sorte qu’il est clair quelle sonde est active dans la sortie et quelle intention rédigée est inerte. Un bloc qui déclare un seul emplacement se traduit sans perte et ne lève rien. hostNetworksur une charge de travail qui déclare aussiinitContainers— le service propre de la charge de travail s’exécute sur le réseau du nœud, mais chaque conteneur d’initialisation devient son propre service qui rejoint le réseau de la frontière de plein droit, car partager l’espace de noms du service principal rendrait circulaire l’attente du service principal sur lui. C’est plus étroit que la forme de pod modélisée, où chaque conteneur partage un seul espace de noms, de sorte que la différence est nommée plutôt que laissée à découvrir à l’exécution. Une charge de travail qui déclarehostNetworksans conteneur d’initialisation se traduit sans perte et ne lève rien.
An annotation the target does not act on (Une annotation sur laquelle la cible n’agit pas)
Les annotations aggrega.ai/ sont des directives de plateforme qu’un fournisseur lit et applique à ce qu’il rend — un espace de noms, un préfixe de registre, un compte de service. Lesquelles d’entre elles un fournisseur lit relève de la déclaration propre de ce fournisseur, faite par type d’entrée, car un fournisseur qui possède chaque champ d’une unité de déploiement qu’il synthétise lui-même n’a souvent nulle part où placer la même valeur lorsqu’il rend un artefact vendorisé. Annotations bien connues en est la matrice.
La Recipe propre d’un nœud et chaque fonctionnalité rattachée à ce nœud sont rendues séparément, chacune par la cible que nomme son propre capability: et aux types d’entrée que déclarent ses propres source:, workload: et artifacts:. Lorsqu’une telle annotation atteint l’un de ces rendus et que la déclaration de la cible résolue ne couvre la clé sur aucun des types d’entrée que ce rendu déclare, la cible n’applique rien pour cette clé, et le build le signale par un avertissement qui nomme la clé, la cible et chaque type d’entrée que ce rendu déclare :
warning: node "frontend" (provider "helm-chart"): target "helm-chart" does not support annotation aggrega.ai/namespace on sourced input and ignored itCes conséquences découlent de la façon dont les annotations atteignent un rendu, et chacune d’elles est délibérée :
- Une seule ligne rédigée peut produire plusieurs avertissements. Une annotation de frontière se propage en cascade à chaque composant placé sous elle, et ces composants peuvent être rendus par des cibles différentes et des types d’entrée différents. Chaque avertissement est une affirmation vraie sur un seul rendu, vous en recevez donc un par rendu qui ne peut pas agir sur la clé — et c’est aussi ce qui vous indique quelles parties de votre sortie sont concernées.
- Une fonctionnalité rattachée à un nœud est jugée sur sa propre FeatureRecipe, et non sur la Recipe du nœud. Un rattachement qui génère ses propres ressources les rend par la cible que nomme sa FeatureRecipe, aux types d’entrée que déclare cette FeatureRecipe — de sorte qu’une annotation que la cible propre du nœud applique peut n’atteindre rien dans les fichiers du rattachement, et l’inverse est vrai aussi. Vous êtes informé de chacun indépendamment, car ce sont des fichiers différents. Il en va de même pour une fonctionnalité rattachée à une frontière plutôt qu’à un composant nommé. Un rattachement dont la FeatureRecipe ne déclare aucun de
source:,workload:etartifacts:ne rend aucun fichier propre — il contribue en injectant des valeurs, par l’arêteusesque porte sa Feature, ou par un pipeline sur des documents qu’autre chose a émis — il n’y a donc aucune sortie propre dont une annotation pourrait être absente, et rien n’est signalé à son sujet. - Un rendu qui déclare plus d’un type d’entrée est jugé sur tous. Ses types déclarés se composent par addition et leurs sorties s’additionnent, de sorte qu’une cible qui lit la clé sur l’un quelconque d’entre eux l’applique et que la valeur apparaît dans la sortie rendue. Rien n’est signalé dans ce cas, car il n’y a rien à rapporter. Un avertissement n’apparaît que lorsque chaque type déclaré manque la clé, et il les nomme tous —
on sourced or synthesized input. - Seules les clés
aggrega.ai/nues sont vérifiées. Une clé à sous-préfixe —compliance.aggrega.ai/data-class, ou votre propreacme.aggrega.ai/team— relève de votre vocabulaire, que le compilateur transmet sans l’interpréter. Rien n’avertit jamais à son sujet. - Une cible qui ne déclare aucune revendication de prise en charge ne lève rien. L’avertissement compare ce que vous avez rédigé à ce que le fournisseur a dit lire ; un fournisseur qui n’a rien dit ne lui donne rien à quoi comparer, et déduire un refus d’un silence rapporterait une affirmation que l’auteur du fournisseur n’a jamais faite. Un fournisseur qui ne lit aucune des clés le dit avec
readsNoWellKnownAnnotations: true, comme le faitterraform, et chaque clé nue qui atteint l’un de ses rendus fait alors l’objet d’un avertissement.
Pourquoi un avertissement et non un arrêt. Une frontière qui couvre légitimement des composants sur des cibles hétérogènes aura toujours un nœud qui ne peut pas agir sur une clé donnée — c’est la forme normale d’une Release qui s’étend sur plusieurs cibles, pas une erreur — de sorte que refuser le build rejetterait des Releases correctes. La valeur passe intacte, et l’avertissement vous le dit.
Le code de classe et la garantie hors bande
Chaque avertissement porte le code de classe stable, permettant une correspondance automatique, unsupported-field, de sorte que l’outillage peut établir la correspondance avec la classe plutôt que d’analyser le texte du message. Chaque membre de la classe — le champ omis purement et simplement, le champ en forme réduite et l’annotation sur laquelle rien n’agit — porte ce seul code, et c’est ce qui permet à un seul filtre de masquer toute la classe. Les avertissements circulent hors bande par rapport aux artefacts rendus, ce qui signifie que les octets rendus sont identiques octet pour octet, que les avertissements apparaissent ou non — les masquer ne peut pas modifier votre sortie.
Visibilité dans l’éditeur. Chaque membre de la classe n’atteint les diagnostics de l’éditeur que là où le serveur de langage exécute l’étape de rendu des artefacts pendant l’inspection d’un graphe IR — aggrega serve --build-on-inspect, ou la clé de configuration serve.build_on_inspect que l’option remplace, désactivée par défaut. Ce réglage ajoute les avertissements qu’un build lève pendant le rendu, et aucun des contrôles sur lesquels un build s’arrête. Le code de classe ci-dessus circule sur le diagnostic publié comme sur la ligne du terminal, de sorte qu’un client d’éditeur établit la correspondance avec la même classe que celle que lit un auteur. Chaque entrée nomme un nœud et une cible plutôt qu’une clé de rédaction, elle est donc affichée sur la clé kind: de l’Aggregate.
Masquer la classe
Les deux commandes qui effectuent un rendu acceptent --no-unsupported-field-warnings, qui fait taire cette seule classe tandis que tous les autres avertissements de rendu continuent d’apparaître :
aggrega build --release release.yaml --no-unsupported-field-warningsaggrega validate ./catalog/recipe/compose/mariadb/1.0.0/recipe.yaml --no-unsupported-field-warningsL’option ne concerne que l’affichage et ne modifie pas la sortie rendue. aggrega lint n’a pas d’option équivalente car il n’exécute aucune passe de rendu — il ne vérifie que les conventions de publication, de sorte qu’aucun avertissement de rendu ne peut y survenir.
Recourez à l’option lorsque vous avez accepté délibérément la fidélité réduite — une cible compose utilisée pour le développement local, où les champs d’ordonnancement et de compte de service du Workload de production sont censés être inertes. Sinon, laissez-la désactivée : l’avertissement est la façon dont vous apprenez qu’un champ que vous avez rédigé n’atteint pas la cible.
A declared-sensitive value travels as a literal (Une valeur déclarée sensible circule comme littéral)
Se déclenche quand un rattachement remplit un emplacement en livrant une donnée que son schéma déclare sensible dans une clé de livraison sous forme de valeur littérale, plutôt que sous forme de référence que la cible résout lors du déploiement.
Forme émise. Une ligne par clé de livraison, qui nomme l’instance du rattachement, le mécanisme de livraison dans lequel la clé aboutit et la clé elle-même, attribuée au nœud et à la cible qui l’ont rendue :
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 insteadLe code de classe. L’avertissement porte le code de classe stable, permettant une correspondance automatique, sensitive-by-value, de sorte que l’outillage établit la correspondance avec la classe plutôt que d’analyser le texte du message. Le code circule sur la ligne du terminal et sur le diagnostic structuré que publie le serveur de langage, de sorte qu’un auteur et un client d’éditeur lisent la même classe — sous la condition de visibilité dans l’éditeur décrite ci-dessous, qui détermine si le serveur de langage publie cet avertissement ou non.
Visibilité dans l’éditeur. L’avertissement n’atteint les diagnostics de l’éditeur que là où le serveur de langage exécute l’étape de rendu des artefacts pendant l’inspection d’un graphe IR — aggrega serve --build-on-inspect, ou la clé de configuration serve.build_on_inspect que l’option remplace, désactivée par défaut. Ce réglage ajoute les avertissements qu’un build lève pendant le rendu, et aucun des contrôles sur lesquels un build s’arrête. L’entrée nomme un nœud et une cible plutôt qu’une clé de rédaction, elle est donc affichée sur la clé kind: de l’Aggregate.
C’est une classe à part entière, et --no-unsupported-field-warnings ne la couvre pas. Cette option fait taire la classe de champ non pris en charge décrite ci-dessus ; cet avertissement continue d’apparaître à côté d’elle. Aucune option ne fait taire celui-ci.
Le build réussit et les octets rendus sont inchangés. L’avertissement circule hors bande par rapport aux artefacts rendus, comme le fait la classe de champ non pris en charge, de sorte que ce qui atteint votre sortie est identique, que la ligne apparaisse ou non.
A declared-sensitive value reaches the target through a values mapping (Une valeur déclarée sensible atteint la cible par un mappage values)
Se déclenche quand un rendu à partir d’une source: remet à sa cible la sortie d’un valuesMapping: alors que l’entité dont ce mappage lit les values déclare sensible une feuille values : le mappage d’une Recipe sur une feuille que déclare son Component, ou le mappage de la FeatureRecipe d’une Feature rattachée à un composant sur une feuille que déclare cette Feature. Un mappage est un unique template dont les clés de sortie sont sa propre invention, de sorte qu’aucune déclaration n’en nomme aucune, et la cible ne reçoit aucun marquage de sensibilité par clé pour la feuille. C’est la seule forme de rendu où une déclaration n’atteint aucune clé rendue alors que l’auteur dispose encore d’un levier sur elle.
Forme émise. Une ligne par feuille déclarée, qui nomme la feuille à sa coordonnée rédigée et la Recipe ou FeatureRecipe dont le mappage conditionne la jonction, attribuée au nœud et à la cible qui l’ont rendue. La ligne d’une Feature rattachée commence par le nom sous lequel elle est rattachée, car un composant peut porter plusieurs rattachements d’une même Feature et leurs lignes seraient sinon identiques — la deuxième ligne ci-dessous est une Feature rattachée au composant api sous le nom 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 themEn quoi consiste le levier. Sans mappage, les valeurs que reçoit un rendu à partir d’une source sont indexées par les chemins des feuilles déclarées eux-mêmes, de sorte que la déclaration rejoint exactement sa clé rendue et que le marquage circule avec elle — sur la cible Terraform, c’est le fichier de surcharge généré décrit à Entrées de module déclarées sensibles. Avec un mappage, le marquage qui arrive bien couvre la sortie du mappage dans son ensemble, et seulement là où le mappage lit la valeur déclarée : il régit le texte qu’un plugin compose lorsqu’il refuse ou avertit, et ne modifie aucun octet rendu.
Trois formes restent silencieuses, et délibérément. Un rendu d’artefacts seuls et un rendu de charge de travail seule ne remettent à leur cible aucune map de valeurs, de sorte qu’une feuille values n’y a aucune clé rendue à marquer, quelle que soit sa rédaction. Une Feature rattachée à une frontière ne déclenche pas non plus d’avertissement, quoi que mappe sa FeatureRecipe : une frontière ne porte aucun bloc values:, de sorte qu’un tel rattachement est rendu contre un pilier values vide, qu’aucune des feuilles values de sa Feature ne peut y porter une donnée, et que supprimer le mappage ne marquerait rien. Chacune est une propriété permanente de la forme plutôt que quelque chose qu’un auteur peut changer, de sorte qu’un avertissement à son sujet se déclencherait à chaque build et n’indiquerait rien à faire ; le plafond est plutôt enseigné à Déclarer une feuille sensible. Un rendu à partir d’une source: sans valuesMapping: est silencieux lui aussi, car le marquage y arrive.
Le code de classe. L’avertissement porte le code de classe stable, permettant une correspondance automatique, sensitivity-not-conveyed, de sorte que l’outillage établit la correspondance avec la classe plutôt que d’analyser le texte du message : l’outil build de l’assistant liste chaque constat sous advisories avec ce code. Il nomme une classe de constat plutôt qu’une condition enregistrée, il n’a donc pas de ligne dans le tableau en haut de cette page.
Visibilité dans l’éditeur. L’avertissement atteint les diagnostics de l’éditeur, avec la gravité avertissement et en portant la même ligne que celle qu’affiche un build dans le terminal, chaque fois que le serveur de langage rend la Release — un build ou un aperçu de build qui lui est demandé, ou une inspection de graphe IR avec aggrega serve --build-on-inspect, ou la clé de configuration serve.build_on_inspect que l’option remplace, désactivée par défaut. L’entrée nomme un nœud et une cible plutôt qu’une clé de rédaction, elle est donc affichée sur la clé kind: de l’Aggregate.
C’est une classe à part entière, et --no-unsupported-field-warnings ne la couvre pas. Cette option fait taire les avis de fidélité d’une cible, un jugement différent porté pour des raisons différentes ; cet avertissement continue d’apparaître à côté d’elle. Aucune option ne fait taire celui-ci.
Le build réussit et les octets rendus sont inchangés. L’avertissement rapporte une absence — aucune clé rendue ne porte le marquage — et un mappage est une forme ordinaire et prise en charge, il n’y a donc rien qui justifie un arrêt et rien ne bouge dans votre sortie, que la ligne apparaisse ou non.
A Terraform module call the engine fetches when it initialises (Un appel de module Terraform que le moteur récupère lors de son initialisation)
Se déclenche quand un module Terraform que le build vendorise, ou le corps Terraform rédigé d’une Recipe, déclare un bloc module dont la source est téléchargée par Terraform lorsque la configuration est initialisée plutôt que lue dans les fichiers que le build a placés : une adresse de registre, une URL git, Mercurial ou d’archive HTTP, un bucket S3 ou GCS, ou un chemin absolu — ou un chemin local qui remonte hors du module vendorisé, et qui nomme des fichiers que le build n’a pas vendorisés. Le verrouillage fixe le commit et l’empreinte d’archive du module vendorisé, et le fichier de verrouillage des dépendances propre à Terraform n’enregistre que les fournisseurs, de sorte que le module que nomme un tel appel est récupéré dans la version que le moteur sélectionne alors et que rien de ce que ce build enregistre ne le couvre.
Ce qui est lu. Les fichiers de configuration que le moteur charge lorsque le module est appelé — ceux qui se trouvent directement dans le répertoire propre du module et dans chaque répertoire qu’une source locale atteint à partir de là — et rien dans un répertoire que rien n’appelle, de sorte qu’un appel écrit dans le répertoire examples/ ou tests/ d’un module n’est pas signalé. Ce qui est lu, c’est ce que dit une source, jamais le module que nomme cette source. Un fichier sous spec.boundary.artifacts d’une Recipe est évalué et écrit par le compilateur lui-même et n’est remis à aucun fournisseur, de sorte qu’un bloc module qui y est écrit n’est pas lu et ne déclenche aucun avertissement. Validation structurelle des entrées, sur la page du fournisseur, énonce la règle en entier.
Forme émise. Une ligne par appel, qui nomme le nœud et le fournisseur, puis le bloc, le fichier et la ligne où il se trouve, et la source telle qu’elle est écrite ; une source qui remonte hors du module le dit au lieu de nommer un téléchargement :
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 vendoredLes appels arrivent dans l’ordre où le moteur les atteint — d’abord le répertoire propre du module, puis chaque répertoire dans l’ordre où une source locale l’atteint pour la première fois, et au sein d’un fichier dans l’ordre où ses blocs sont écrits — de sorte que la même entrée produit la même séquence à chaque exécution. Chaque exécution qui effectue un rendu les lève : aggrega build ; aggrega pull, qui rend la Release une fois pour découvrir ce que récupère un build de celle-ci ; et aggrega validate sur une Recipe dont l’espace de travail contient le module, qui rend cette Recipe à elle seule.
Le code de classe. Chaque avertissement porte le code de classe stable, permettant une correspondance automatique, module-fetched-at-init, de sorte que l’outillage établit la correspondance avec la classe plutôt que d’analyser le texte du message. Le code circule sur le diagnostic structuré : l’outil build de l’assistant liste chaque constat sous advisories avec ce code, et le serveur de langage le publie sur chaque entrée. Il nomme une classe de constat plutôt qu’une condition enregistrée, il n’a donc pas de ligne dans le tableau en haut de cette page.
Visibilité dans l’éditeur. L’avertissement atteint les diagnostics de l’éditeur sur la couche aggrega-build, avec la gravité avertissement, chaque fois que le serveur de langage rend la Release — un build ou un aperçu de build qui lui est demandé, ou une inspection de graphe IR avec aggrega serve --build-on-inspect, ou la clé de configuration serve.build_on_inspect que l’option remplace, désactivée par défaut. L’entrée nomme un nœud plutôt qu’une clé de rédaction, elle est donc affichée sur la clé kind: de l’Aggregate.
C’est une classe à part entière, et aucune option ne la fait taire. --no-unsupported-field-warnings fait taire la classe de champ non pris en charge et ne couvre pas celle-ci.
Le build réussit et les octets rendus sont inchangés. L’avertissement circule hors bande par rapport aux artefacts rendus, de sorte que le module vendorisé, le corps rédigé et la configuration racine sont identiques octet pour octet, qu’il apparaisse ou non.
Pourquoi un avertissement et non un arrêt. Un module qui appelle un autre module est une entrée légitime : Terraform récupère le module appelé et la configuration fonctionne. Ce à quoi l’auteur renonce, c’est l’épinglage de ce module par le build, ce qui est un fait à signaler plutôt qu’une faute à refuser, et c’est à l’auteur de décider si la récupération est acceptable.
A plugin ran with no recorded digest to check it against (Un plugin s’est exécuté sans empreinte enregistrée à laquelle le comparer)
Se déclenche quand le compilateur s’apprête à exécuter un plugin, qu’une empreinte enregistrée est censée gouverner les octets de ce plugin et que l’espace de travail n’en enregistre aucune pour lui. Le plugin s’exécute ; l’avertissement est la façon dont vous apprenez que rien n’a comparé les octets exécutés aux octets que quelqu’un a examinés.
aggrega pull écrit l’empreinte de chaque plugin qu’il acquiert dans le fichier de verrouillage de la Release, et chaque résolution ultérieure compare les octets qu’elle trouve à cette empreinte. Un espace de travail sur lequel aucun pull n’a encore été effectué, ou dont le fichier de verrouillage est antérieur à un plugin que la configuration a rattaché depuis, n’a aucune empreinte pour ce plugin — la comparaison n’a donc rien à comparer, et sans cette ligne elle réussirait en silence.
Une étape de pipeline, un fournisseur ou un plugin rattaché à un rôle de verdict dont l’entité Plugin est rédigée dans l’un de vos répertoires de catalogue n’a pas non plus d’empreinte, et un pull ne lui en donne pas : le pull n’épingle jamais une telle entité, et un build lit son .wasm à neuf à chaque fois — à côté de l’entité, dans le cas ordinaire — plutôt que de le confronter à quoi que ce soit qu’un pull ait enregistré. Un plugin rattaché à un rôle de transformation et rédigé à cet endroit est l’exception : ses octets façonnent la sortie rendue, donc un pull enregistre l’empreinte du .wasm qu’il trouve pour lui, et une fois qu’il l’a fait, un build vérifie ce plugin par rapport à l’empreinte et cette ligne n’est pas émise pour lui.
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 recordedC’est la ligne qu’un build, un pull ou une validation affiche parmi ses autres avertissements. Une commande qui résout un plugin en dehors d’une telle exécution — lors de l’installation, de la liste ou de l’exécution des plugins en ligne de commande propres à l’espace de travail, ou aggrega lint résolvant les plugins avec lesquels il effectue le lint — affiche la même phrase sur une ligne à part, sans indentation.
La ligne nomme la source dont proviennent les octets — le même mot que aggrega pull et aggrega plugin list utilisent pour elle — et se termine par ce qui vaut pour cette source. Pour des octets provenant du cache de contenu, la correction consiste à effectuer le pull de la Release, ce qui enregistre l’empreinte et fait de chaque exécution ultérieure de ce plugin une exécution vérifiée. Pour des octets lus à côté d’une entité Plugin dans un répertoire de catalogue, un pull n’enregistre l’empreinte que pour un plugin rattaché à un rôle de transformation, et la ligne le dit : pour tout autre plugin rédigé à cet endroit, aucun pull n’y change rien, et la façon de le placer sous une empreinte enregistrée est de le publier et de référencer l’entité publiée.
Elle est affichée une fois par plugin pour chaque commande, quel que soit le nombre de fois où la commande résout ce plugin. Un rendu résout son fournisseur une fois par nœud, et un build qui remplit son propre fichier de verrouillage peut rendre la Release plus d’une fois ; répéter la ligne à chaque fois l’enfouirait. Le service de l’éditeur l’affiche sur son propre flux d’erreur une seule fois pendant toute la durée de son exécution, tandis que chaque requête à laquelle il répond la signale à nouveau à l’éditeur — de sorte que, quelle que soit la réponse dont l’éditeur se sert, elle vous informe des plugins que cette exécution a utilisés sans vérification.
Visibilité dans l’éditeur. L’avertissement atteint les diagnostics de l’éditeur avec les autres avertissements de l’exécution, avec la gravité avertissement : une validation d’une Release le publie sur l’Aggregate de la Release, et un build ou un aperçu de build que l’éditeur demande le publie sur la couche aggrega-build. Il nomme un plugin plutôt qu’une clé que vous avez écrite, il est donc placé en tête du fichier. Comme chaque exécution signale ce qu’elle a résolu, l’entrée reste tant qu’une exécution résout le plugin sans vérification et disparaît avec la première exécution qui ne le fait pas. Il ne change aucun verdict et ne fait échouer aucune résolution, de sorte que ce qu’une session répond est identique qu’il soit affiché ou non.
Deux résolutions ne déclenchent rien, et aucune n’est un oubli :
- Un plugin que le compilateur porte en lui-même.
aggrega pullenregistre ce qu’il a récupéré, et il n’y a rien à récupérer pour des octets livrés dans le binaire — aucune empreinte n’est donc jamais enregistrée pour un tel plugin, et il n’y aurait rien que vous puissiez exécuter pour changer cela. Le binaire est l’identité de ces octets. Les plugins propres au compilateur et leurs versions sont listés paraggrega plugin listet inscrits dans la sectiontoolchaindu fichier de verrouillage. - Une résolution à laquelle aucune empreinte n’a jamais été destinée.
aggrega validate --plugin ./some.wasmdésigne un fichier que vous avez nommé sur la ligne de commande, etaggrega lintinspecte l’artefact même qu’il vérifie ; dans les deux cas, le plugin est le sujet plutôt qu’un outil auquel on fait confiance, il n’existe donc aucun enregistrement auquel il pourrait être tenu.
Pourquoi un avertissement et non un arrêt. Lire un document vaut la peine sur un espace de travail que personne n’a encore préparé — refuser de valider ou d’effectuer le lint tant que quelqu’un n’a pas exécuté aggrega pull rendrait les commandes de signalement inutilisables précisément au moment où elles sont le plus utiles. aggrega build ne produit aucun artefact sans fichier de verrouillage, donc le build ne rencontre cet avertissement que pour un plugin pour lequel son fichier de verrouillage n’enregistre aucune empreinte — le cas ordinaire étant un plugin lu à côté de son entité dans un répertoire de catalogue.
Là où un fichier de verrouillage manquant entraîne plutôt un refus. Lorsqu’un éditeur demande au service du compilateur le graphe d’une Release et que l’espace de travail n’a aucun fichier de verrouillage, le service s’arrête et en demande un plutôt que de dessiner un graphe. Un fichier de verrouillage qui existe et n’enregistre simplement aucune empreinte pour un plugin relève plutôt du cas ci-dessus : le plugin s’exécute, et cet avertissement est la façon dont vous l’apprenez. Un graphe dessiné est ce sur quoi un lecteur raisonne ensuite, et un graphe construit à partir d’octets non vérifiés aurait exactement l’aspect d’un graphe vérifié. Voir aggrega serve.
A published archive carries an entry Windows cannot use (Une archive publiée contient une entrée que Windows ne peut pas utiliser)
Se déclenche quand aggrega push — ou son --dry-run — publie une archive dont l’une des entrées contient une partie que Windows ne peut pas contenir telle qu’elle est écrite : un nom que Windows réserve à un périphérique, comme CON, PRN, AUX, NUL, COM1 ou LPT1, quelle que soit la casse et quelle que soit l’extension qui suit, ou une partie se terminant par un point ou une espace. aux/x.yaml en contient une dans son répertoire ; report. et COM1.yaml en contiennent une dans leur nom de fichier. Sous Windows, aggrega refuse de décompresser une telle entrée, de sorte qu’un espace de travail Windows ne peut pas utiliser la version du tout. L’avertissement se déclenche sur toutes les plateformes, car une publication est destinée à quiconque en effectue le pull, et c’est ainsi que son auteur l’apprend avant que quelqu’un sous Windows ne le découvre.
Ce qu’il lit. Les noms que l’archive contiendra : le nom de fichier propre du document de l’entité, puis chaque fichier que l’entité nomme à côté de lui — les fichiers que liste Empaquetage. Ainsi, un document appelé con.yaml qui importe un fichier de schéma déclenche l’avertissement pour son propre nom. Une entité qui ne nomme rien est publiée comme son seul document, qu’un consommateur dispose sous un nom choisi par le produit plutôt que sous celui que vous avez rédigé, elle ne fait donc jamais l’objet d’un avertissement, quel que soit le nom de son fichier. Un Plugin ne publie aucune archive et ne fait jamais l’objet d’un avertissement non plus.
Forme émise. Une ligne par entrée, sur la sortie d’erreur standard, dans l’ordre où les noms sont composés — d’abord le document, puis les fichiers qu’il porte dans l’ordre lexical — avant le compte rendu propre de l’exécution à blanc ou de la publication sur la sortie standard :
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 useLa première valeur entre guillemets est l’entrée telle que l’archive la nomme. La seconde est le premier de ses segments — les parties que séparent ses barres obliques — que Windows ne peut pas contenir, qui est la partie à renommer. La ligne commence par la phrase fixe de la condition. Elle est émise par la publication plutôt que par une règle qu’évalue un build, elle n’a donc aucune ligne dans le tableau en haut de cette page ; le tableau de toutes les conditions la liste sous E0344.
Il ne refuse rien. Le push, ou son exécution à blanc, se poursuit ou est refusé exactement comme il le serait sans l’avertissement, et se termine comme il l’aurait fait.
Où il parvient encore. L’outil publish-entity de l’assistant répond avec les mêmes entrées sous windows_unusable_entries, et aggrega serve répond à aggrega/publishEntity avec elles sous windowsUnusableEntries ; chacun est absent lorsqu’il n’y en a aucune. Voir aggrega mcp et aggrega serve. Le service transmet aussi la ligne d’avertissement elle-même à une requête qui a demandé à recevoir les signalements, parmi le reste du compte rendu de la publication.
Visibilité dans l’éditeur. Aucune sous forme de diagnostic : publier n’est pas un build, donc rien ici n’atteint une liste de problèmes. Un éditeur qui publie par le service lit windowsUnusableEntries dans la réponse.
Pourquoi un avertissement et non un arrêt. Un tel nom est légal, et Linux et macOS utilisent le fichier tel qu’il est nommé, donc refuser la publication reviendrait à refuser une entité fonctionnelle sur une supposition quant à qui en effectuera le pull. Renommer ou non relève de la décision de l’auteur.