Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Arrêts fatals

Un arrêt fatal est une erreur à la compilation qui stoppe le build avant que la moindre sortie ne soit produite. Chaque arrêt nomme le fichier, l’entité et le champ en faute, explique ce que le compilateur n’a pas pu résoudre et indique la modification de rédaction concrète qui le corrige. Le compilateur ne répare ni ne réécrit jamais silencieusement votre entrée — si quelque chose ne va pas, le build s’arrête et vous dit où.

Ce catalogue est organisé selon l’étape de la compilation à laquelle chaque arrêt se déclenche.

Chaque entrée ci-dessous cite le message qu’un build affiche pour la condition qu’elle documente : la phrase fixe qui énonce la condition, puis ce que cette occurrence a fourni. Dans un terminal, ce message apparaît à l’intérieur d’un cadre — un en-tête entre crochets portant la catégorie et le code court de la condition, un pointeur vers le fichier et la clé en faute suivi de l’instance que concerne l’échec, sous la forme (instance <name>) — ou cette instance seule, sous la forme instance <name>, lorsqu’aucun fichier ne s’applique — et le message sur la ligne en dessous — de sorte qu’une ligne entière collée depuis un build ne correspondra pas à une entrée de cette page, alors que le message qu’elle contient, si ; error-translation.md décrit le cadre en entier.

Si vous arrivez d’un build avec un code court en main — la lettre E et quatre chiffres, dans l’en-tête entre crochets du diagnostic — commencez par Trouver un arrêt à partir du code court affiché par le build au bas de cette page, qui liste chaque condition cataloguée ici en regard du code court qu’un build affiche pour elle.

Lors du chargement de vos fichiers

Le compilateur lit chaque Aggregate, Manifest, Component, Feature, Recipe, FeatureRecipe, Plugin et Release référencé par votre build, valide chacun par rapport à son schéma et interpole les paramètres typés de la Release dans l’Aggregate.

YAML anchor aliased inside its own content (Ancre YAML référencée par un alias à l’intérieur de son propre contenu)

Un document pose une ancre sur un nœud avec &name, puis y fait référence par un alias avec *name quelque part à l’intérieur du contenu que couvre cette ancre. Développer l’alias reproduit l’ancre, dont le contenu porte à nouveau l’alias, de sorte que le document décrit une structure sans fin. Il n’y a rien de fini à lire, encore moins à valider, et le build s’arrête au lieu d’entamer un parcours qui ne peut pas se terminer.

La lecture du YAML en arbre ne développe pas les alias, de sorte qu’un document de cette forme est lu sans objection et n’échoue que lorsque quelque chose le parcourt. Le refus se situe donc entre la lecture et le parcours — et un build lit le YAML rédigé à plus d’un endroit, si bien que la même condition peut être rencontrée à plus d’un endroit. Quatre endroits la signalent, chacun encadrant la même explication avec ce qui localise le document sur cette surface :

  • Un fichier d’entité, au moment où il est lu. Le build s’arrête avant que cette entité ne soit vérifiée par rapport à son schéma, de sorte que cet arrêt nomme une ancre plutôt qu’un champ et ne porte ni ligne ni colonne : à ce stade, le document n’a aucune position vers laquelle un diagnostic pourrait utilement pointer.
  • Un corps de schéma, au moment où il est compilé. Un pilier spec.schema: est compilé de la forme compacte en un document JSON Schema après la lecture de son fichier, de sorte que cet arrêt se déclenche pendant cette compilation plutôt qu’avant, et il porte bien une ligne. La forme qu’une lecture antérieure ne peut pas détecter est un corps d’échappement $jsonschema: : un corps d’échappement est un scalaire de bloc — du texte brut, sans ancres — pendant que le fichier qui l’entoure est lu, et ses ancres ne deviennent des ancres que lorsque ce texte est lui-même analysé, un niveau plus bas. Lorsque le cycle se trouvait dans un tel bloc, l’arrêt nomme aussi $jsonschema comme le mot-clé dont le corps le contenait.
  • Le schéma de charge de travail d’un Plugin fournisseur, au moment où le Plugin se charge. spec.provider.workloadSchema s’écrit comme un scalaire de bloc : du texte brut pendant que le fichier du Plugin lui-même est lu, sans ancres à ce moment-là, et ses ancres ne deviennent des ancres que lorsque ce texte est analysé comme un document à part entière, un niveau plus bas. Cette analyse et la compilation qui suit ont toutes deux lieu pendant le chargement du Plugin, de sorte que cet arrêt se déclenche à ce moment plutôt qu’à la lecture du fichier, et il porte une ligne. Lorsque le cycle se trouvait dans un échappement $jsonschema: au sein du corps du schéma, l’arrêt nomme aussi $jsonschema comme le mot-clé dont le corps le contenait. Voir ../entities/plugin.md pour la surface de rédaction du champ.
  • Un fragment CloudFormation rendu, au moment où le fournisseur le lit. Une Recipe cloudformation rédige un fragment, et un corps artifacts: est un template — ce que lit le fournisseur est donc le texte produit par le rendu de ce template, un contenu qui n’existait pas pendant la lecture de vos fichiers. Cet arrêt se déclenche donc pendant le rendu de la sortie, après que chaque contrôle de schéma a déjà réussi. Voir ../providers/cloudformation.md pour la surface de rédaction des fragments.

Le refus porte sur la récursion, jamais sur la réutilisation ni sur la profondeur. Poser une ancre sur un contenu partagé et y faire référence depuis de nombreux endroits est un modèle de rédaction pris en charge — voir ../entities/aggregate.md « Modèles d’ancres YAML (bloc defs:) » et ../entities/manifest.md « Ancres YAML pour des manifestes DRY » — et une référence qui se développe et se termine se charge normalement, quel que soit le nombre de fois où elle apparaît et quelle que soit la profondeur d’imbrication du document ; la profondeur à elle seule n’est jamais une raison de cet arrêt. Ce qui arrête le build, c’est une ancre atteinte alors que le build se trouve encore à l’intérieur de celle-ci, y compris lorsqu’elle est atteinte indirectement, par une seconde ancre déclarée sous elle. Le message nomme l’ancre sur laquelle la boucle se referme, qui n’est pas nécessairement l’ancre la plus externe du document.

Messages émis. Tous les quatre portent la même explication, et c’est délibéré : c’est une seule condition rencontrée en quatre endroits, et un auteur qui a appris à la lire une fois ne devrait pas avoir à l’apprendre de nouveau. Seul le cadre qui localise le document diffère.

anchor &<anchor> is aliased by *<anchor> inside its own content, so the document expands without end; point that alias at content declared outside &<anchor>, or write the content out in full (l’ancre est référencée par un alias à l’intérieur de son propre contenu, de sorte que le document se développe sans fin ; pointez cet alias vers un contenu déclaré en dehors de l’ancre, ou écrivez le contenu en entier)

Un fichier d’entité est encadré par le contrôle d’enveloppe qui le lisait et par le chemin depuis lequel il a été lu :

document envelope validation failed: envelope: parse <path>: <the explanation above> (échec de la validation de l’enveloppe du document : enveloppe : analyse)

Un corps de schéma est encadré par sa position dans le schéma, et par le mot-clé d’échappement lorsque le cycle se trouvait dans un bloc $jsonschema:. Le build le signale sous une étiquette CATALOG_ERROR, qui nomme aussi le fichier, l’entité et le pilier dont le corps n’a pas pu être compilé :

compactform at <schema-path>:<line> (keyword "$jsonschema"): <the explanation above> (compactform à l’emplacement, mot-clé)

Le schéma de charge de travail d’un Plugin fournisseur porte ce même cadre en forme compacte ; ce qui diffère, c’est l’étiquette CATALOG_ERROR qui l’entoure, qui nomme le Plugin et spec.provider.workloadSchema à la place de l’entité et de son pilier.

Un fragment rendu est encadré par le fournisseur qui l’a lu :

cloudformation-provider: parse fragment: <the explanation above> (cloudformation-provider : analyse du fragment)

Comment corriger : pointez l’alias vers un contenu déclaré en dehors de l’ancre à l’intérieur de laquelle il se trouve actuellement, ou écrivez en entier le contenu répété à l’endroit où il est utilisé. Dans un Aggregate ou un Manifest, le bloc defs: de premier niveau est l’emplacement naturel des ancres partagées — il se trouve en dehors de chaque bloc qui y fait référence, de sorte qu’une ancre qui y est déclarée ne peut pas être atteinte depuis son propre intérieur. Dans les autres types d’entités, qui n’ont pas de bloc defs:, posez l’ancre sur le contenu partagé à un endroit dont le bloc qui y fait référence n’est pas un descendant. Une ancre peut être référencée depuis un nombre quelconque d’endroits et depuis n’importe quelle profondeur ; la seule forme qu’elle ne peut pas prendre est une référence qui retombe à l’intérieur du contenu que couvre l’ancre.

Le même remède s’applique partout où l’arrêt a été rencontré, et le cadre vous indique quel document ouvrir : le fichier d’entité lui-même, le bloc $jsonschema: dans un pilier de schéma, le corps workloadSchema dans un Plugin fournisseur, ou le corps artifacts: dont le fournisseur a lu la sortie rendue. Dans ce dernier cas, l’ancre se trouve dans le template que vous avez rédigé, pas dans le texte rendu — le rendu l’a reproduite fidèlement.

Parameter type mismatch / contract violation (Type de paramètre non concordant / violation de contrat)

La Release a fourni une valeur dont le type ou la forme ne correspond pas à ce que l’Aggregate a déclaré pour ce paramètre. Le validateur des contrats de paramètres détecte les types non concordants, les violations d’enum, les violations de plage, les violations de motif, les chaînes qui ne sont pas des instances valides de leur format déclaré, les échecs de prédicats validate: et les paramètres obligatoires manquants, avant toute interpolation de template. Les noms que peut prendre un format, et ce que chacun vérifie, sont listés sous Formats nommés.

Message émis — la phrase qui énonce la condition, puis l’entité en faute, le chemin du champ et le détail de la contrainte :

parameter contract violated (Aggregate, at .spec.parameters.<parameter>, parameter "<parameter>" expected type <declared type>; got <received type>) (contrat de paramètre violé : le paramètre attendait le type déclaré et en a reçu un autre)

Pour un paramètre déclaré required: true sans default: et sans valeur fournie par la Release, le rapport porte une condition différente et un code court différent :

required parameter not supplied (Aggregate, at .spec.parameters.<parameter>, parameter "<parameter>" is required but not supplied by Release) (paramètre obligatoire non fourni : le paramètre est obligatoire mais la Release ne le fournit pas)

Seul le détail qui suit le chemin du champ change selon la contrainte non respectée. La phrase et le cadre entre parenthèses qui l’entoure sont les mêmes à chaque fois, ce qui fait de la phrase la partie sur laquelle établir la correspondance et du détail la partie à lire. Les détails qu’un build affiche, un par type de contrainte :

parameter "<parameter>" value <value> not in enum [<members>] (valeur du paramètre absente de l’enum) parameter "<parameter>" value "<value>" does not match pattern "<pattern>" (la valeur du paramètre ne correspond pas au motif) parameter "<parameter>" value "<value>" is not a valid <format>: <reason> (la valeur du paramètre n’est pas valide pour le format) parameter "<parameter>" value <value> above max <max> (valeur du paramètre supérieure au maximum) parameter "<parameter>" failed validate predicate (échec du prédicat validate du paramètre) parameter "<parameter>" validate predicate error: <detail> (erreur du prédicat validate du paramètre)

Le <reason> d’un échec de format indique ce qui ne va pas dans la valeur, dans les termes propres à ce format. Une valeur située dans un contrat imbriqué est désignée par son chemin, de sorte qu’un format qu’un contrat items: déclare est vérifié sur chaque élément et que le rapport désigne celui qui a échoué : le deuxième élément d’un paramètre hosts est signalé à .spec.parameters.hosts.1, son détail nommant "hosts.1".

Un paramètre qui déclare un validateMessage: remplace tout ce détail par son propre texte, de sorte que le rapport se lit parameter contract violated (Aggregate, at .spec.parameters.<parameter>, <the validateMessage you wrote>) — le cadre est inchangé et votre phrase se place là où serait le détail de la contrainte.

La même condition couvre un contrat qui, tel qu’il est écrit, ne peut rien contraindre. Un pattern: qui n’est pas une expression régulière valide est refusé à la lecture du contrat de paramètres de l’Aggregate, avant qu’aucune valeur de la Release ne soit vérifiée, de sorte qu’il arrête le build qu’une Release fournisse ou non le paramètre. Le rapport pointe vers la clé — .spec.parameters.<parameter>.pattern, ou le chemin à travers un contrat imbriqué comme .spec.parameters.<parameter>.items.pattern — et son détail nomme la déclaration, le motif et la raison :

parameter "<parameter>" pattern "<pattern>" does not compile: <reason> (le motif du paramètre ne se compile pas)

Un format: qui nomme un format hors de l’ensemble pris en charge ne peut rien contraindre non plus, et il est refusé au même point, avant qu’aucune valeur de la Release ne soit vérifiée, de sorte qu’il arrête lui aussi le build qu’une Release fournisse ou non le paramètre. À l’intérieur d’un contrat imbriqué — sous items:, properties: ou valuesType: — c’est cette condition qui le refuse : le rapport pointe vers la clé, par exemple .spec.parameters.<parameter>.items.format, et son détail nomme la déclaration, le format tel qu’il est écrit et chaque nom pris en charge :

parameter "<parameter>.items": format "<format>" is not supported; the supported formats are email, uri, hostname, ipv4, ipv6, uuid, date-time, date (format du paramètre non pris en charge ; les formats pris en charge sont email, uri, hostname, ipv4, ipv6, uuid, date-time, date)

Sur la déclaration propre d’un paramètre, le même nom est refusé une étape plus tôt, par le schéma de l’Aggregate, dont le format n’admet que les noms pris en charge. Ce refus est le document qui ne respecte pas le schéma de son type — une condition différente, avec son propre code court, E0215 — et aggrega pull et aggrega validate --release le listent après avoir signalé la référence aggregate: de la Release comme impossible à résoudre (E0170), puisque l’Aggregate qui porte le nom ne s’est pas chargé :

document envelope validation failed (Aggregate, at <path>); <line>:<column>: spec.parameters.<parameter>.format: enum: <format> does not equal any of: [email uri hostname ipv4 ipv6 uuid date-time date]. correct the document to match its kind’s schema (échec de la validation de l’enveloppe du document : le format ne figure pas parmi les valeurs admises ; corrigez le document pour qu’il corresponde au schéma de son type)

Le détail d’erreur de prédicat couvre les deux façons dont un prédicat validate: peut ne pas produire de verdict : une fonction que la surface n’enregistre pas, et une référence à autre chose que .value. Chacune est signalée par rapport au prédicat plutôt qu’à la valeur, et chacune nomme ce qu’elle n’a pas pu résoudre.

Un prédicat validate: lit la valeur en cours de validation sous le nom .value, et c’est le seul nom qu’il définit. Un prédicat qui nomme autre chose est refusé avant son exécution, de sorte qu’une référence mal saisie est signalée comme l’erreur de nommage qu’elle est, au lieu de se résoudre en rien et d’apparaître comme une valeur qui a échoué à la validation.

Comment corriger : modifiez la valeur de la Release pour qu’elle respecte les contraintes type / enum / min / max / pattern / format déclarées pour le paramètre, fournissez un paramètre obligatoire manquant, corrigez un pattern: qui ne se compile pas, remplacez un format: qui nomme un format non pris en charge par l’un des formats nommés ou supprimez-le, corrigez un prédicat validate: qui nomme autre chose que .value ou qui produit autre chose que true ou false, ou élargissez la déclaration de l’Aggregate pour qu’elle accepte la forme dont vous avez réellement besoin.

Règles de forme d’une Recipe

Une Recipe compose sa sortie à partir de trois types d’entrée — issu d’une source, synthétisé et artefacts — décrits dans ../../architecture/16-recipe-input-composition.md. La forme d’une Recipe valide est contrainte par les règles de composition ci-dessous. Elles diffèrent par le moment où elles sont vérifiées — au chargement de la Recipe, au rendu d’un nœud ou à l’émission de la sortie — lisez donc chaque entrée pour connaître le point auquel sa propre condition est vérifiée.

Chaque règle est nommée d’après ce qu’elle contraint. Il n’y a pas de numérotation, et aucun numéro n’est réservé : un nom indique quelle partie de la Recipe ouvrir, et continue de l’indiquer quelle que soit la façon dont la liste ci-dessous s’allonge ou est réordonnée. Lorsque vous devez consigner une condition de façon durable — dans un contrôle de CI, un ticket, un runbook — utilisez son code, l’identifiant que sentinels.md liste pour la condition et celui qui reste fixe à mesure que les paquets qui l’entourent évoluent.

Un arrêt lié à la forme d’une Recipe est composé de la même manière. Il commence par la phrase qui énonce la règle, nomme ensuite ce que cette Recipe particulière a fourni, puis le détail qui lui est propre :

<the rule's sentence> (Recipe <name>:<version>, rule <rule-name>, at <position>). <rule-specific detail> (la phrase de la règle, puis la Recipe avec son nom et sa version, le nom de la règle et la position ; ensuite le détail propre à la règle)

La phrase initiale est fixe pour chaque règle — le même texte chaque fois que cette règle arrête le build, quelle que soit l’étape qui l’a détectée — c’est donc la partie de la sortie sur laquelle établir la correspondance, et c’est le texte que sentinels.md liste pour la condition de la règle. Tout ce qui suit varie selon la Recipe en faute : les valeurs entre parenthèses indiquent quel document, quelle règle par son nom et où, et la phrase finale est le conseil pour cette occurrence. La position est le fichier depuis lequel la Recipe a été chargée lorsque la règle porte sur le document dans son ensemble, et un chemin pointé vers la clé que vous avez écrite — .spec.outputComponentLabels.hosting — lorsque la règle porte sur un seul élément à l’intérieur ; une clé qui contient elle-même des points ne peut pas s’écrire comme un segment supplémentaire sans se lire tout aussi bien comme deux, de sorte que le chemin s’arrête au bloc qui la contient et que le conseil cite plutôt la clé.

Le build affiche la ligne entière sous une étiquette CATALOG_ERROR, qui signale que l’échec est imputable à l’entité du catalogue (la Recipe, ou le fournisseur auquel elle est liée), et non à l’Aggregate ou à la Release. Le fichier depuis lequel la Recipe a été chargée est affiché à côté de l’étiquette, de sorte qu’une règle positionnée sur une clé vous indique tout de même quel fichier ouvrir.

valuesMapping requires source (le mappage des valeurs requiert une source)

Une Recipe déclare valuesMapping mais pas source. Sans source à laquelle superposer les valeurs, rien ne peut recevoir les valeurs mappées. Cette règle est vérifiée au chargement de la Recipe.

Message émis :

Recipe: valuesMapping requires source (Recipe <name>:<version>, rule values-mapping, at <path>). declare a source: pointer alongside valuesMapping (or remove the valuesMapping if no overlay is intended) (Recipe : valuesMapping requiert source ; déclarez un pointeur source: à côté de valuesMapping, ou supprimez valuesMapping si aucune superposition n’est prévue)

Comment corriger : ajoutez un pointeur source: (une référence à un chart, un module ou un fichier compose) à côté du valuesMapping, ou supprimez le valuesMapping et adoptez un autre type d’entrée (workload: pour une sortie synthétisée, artifacts: pour l’émission directe de manifestes).

workload: requires a provider that can synthesize (requiert un fournisseur capable de synthétiser)

Une Recipe déclare workload: (mode synthétisé) pour un fournisseur qui n’implémente pas la synthèse de Workload. La prise en charge du mode synthétisé est une propriété du fournisseur — le catalogue de la bibliothèque standard déclare workloadSchema sur les fournisseurs capables de synthèse par convention, mais la vérification se fonde sur la capacité du fournisseur, et non sur la présence de ce champ.

Deux surfaces le signalent, et une seule d’entre elles décide du build. L’arrêt est levé au moment du rendu, après que le fournisseur du nœud a été lié et une fois lus les types d’entrée que sa Recipe déclare, de sorte que ce rapport nomme le nœud. aggrega validate signale le même constat plus tôt, avant qu’aucun nœud ne soit lié, en lisant la Recipe seule — ce rapport nomme donc plutôt la Recipe et sa version. Les deux ne lisent pas le même ensemble de Recipes : le rapport anticipé est levé pour toute Recipe qui déclare workload:, tandis que l’arrêt est levé pour chaque type d’entrée déclaré par le nœud que son fournisseur ne peut pas honorer. Ainsi, une Recipe qui associe un workload: à un source: s’arrête quand même, et elle s’arrête pour la charge de travail — déclarer un type d’entrée que le fournisseur sait rendre ne fait pas franchir le contrôle à un type non pris en charge.

La seule limite à cela : artifacts: n’est vérifié par rapport à la prise en charge des artefacts autonomes que lorsqu’il est le seul type déclaré du nœud. Aux côtés d’un source: ou d’un workload:, ses fichiers passent comme sortie composée, que cette capacité ne régit pas.

Message émis au moment du rendu. La catégorie à laquelle l’échec est attribué vous parvient dans l’en-tête entre crochets du diagnostic plutôt qu’à l’intérieur du message. Le message commence par la phrase fixe qui énonce la condition, puis nomme le nœud, le fournisseur, le type déclaré qui a été refusé et les types que ce fournisseur prend en charge. Lorsqu’un nœud déclare deux types que son fournisseur ne peut pas honorer, c’est le premier dans l’ordre source → workload → artifacts qui est signalé, de sorte que le constat porte sur une seule ligne de votre Recipe :

provider does not support the node’s input kind (node "<node-id>"). provider "<provider-name>" does not support <mode> recipes (this provider supports: <kinds>); declare one of the supported input kinds, or target a provider that supports <mode> (le fournisseur ne prend pas en charge le type d’entrée du nœud ; déclarez l’un des types d’entrée pris en charge, ou ciblez un fournisseur qui prend en charge le mode)

L’en-tête porte la catégorie et le code court de cette condition, E0265, qui est l’identifiant à consigner lorsque vous devez nommer cet arrêt de façon durable — dans un contrôle d’intégration continue, un ticket ou un runbook. Un numéro est attribué une fois puis fixé, de sorte qu’il reste le même quelle que soit l’amélioration de la formulation qui l’entoure ; la table de toutes les conditions le résout, et la phrase initiale ci-dessus est ce sur quoi établir la correspondance lorsque vous partez d’un texte plutôt que d’un identifiant.

aggrega validate signale la même clause sous la Recipe qui porte le bloc, préfixée par la surface qui l’a lue et précédée du code court de cette condition, car le rapport anticipé est la même condition :

input-kind: [E0265] Recipe "<name>:<version>": provider "<provider-name>" does not support synthesized recipes (this provider supports: <kinds>); declare one of the supported input kinds, or target a provider that supports synthesized (le fournisseur ne prend pas en charge le mode synthétisé ; déclarez l’un des types d’entrée pris en charge, ou ciblez un fournisseur qui prend en charge le mode synthétisé)

Sur l’ensemble du catalogue, c’est une seule ligne ; avec --release, l’en-tête se place sur sa propre ligne au-dessus de la clause. Le diagnostic de l’éditeur pour le même constat porte E0265 comme code.

Comment corriger : liez la Recipe à un fournisseur qui effectue la synthèse (le plus souvent helm ou compose), ou migrez la Recipe vers un autre type d’entrée (artifacts: pour l’émission directe de manifestes, ou source: + valuesMapping: si un chart/module existe).

Validation du contenu du Workload par fournisseur. Aujourd’hui, le workloadSchema du fournisseur sert uniquement de documentation et ne valide pas le corps du Workload ; les corps sont validés par rapport au schéma Workload intégré, propriété de la plateforme. Lorsque le synthétiseur de Workload basé sur Wasm sera livré, workloadSchema deviendra le contrat par fournisseur par rapport auquel le synthétiseur valide le corps du Workload (un arrêt distinct, au niveau du contenu).

The provider does not support omits (Le fournisseur ne prend pas en charge omits)

Une Recipe ou une FeatureRecipe déclare omits: et le fournisseur qui en effectue le rendu ne déclare pas qu’il exclut des documents rendus. Exclure un document de ce qu’une source rend est une chose que seul le fournisseur peut faire — seul le fournisseur sait quels documents la source rend et comment chacun s’appelle —, si bien qu’un fournisseur qui ne le fait pas rendrait chaque document que les entrées nomment et signalerait un succès. Le build refuse plutôt avant que quoi que ce soit ne soit rendu, de sorte que la clé ne reste jamais silencieusement sans effet.

Le fait qu’un fournisseur exclue des documents est lu dans la propre déclaration du fournisseur de ce qu’il prend en charge, et non dans une liste de fournisseurs tenue par le compilateur. Chaque entrée compte, quel que soit ce que rend son when:, car la capacité du fournisseur à honorer la clé ne dépend pas des entrées qu’un build conserve. Les fournisseurs helm, compose et cloudformation honorent la clé. helm-chart et terraform transmettent leur source pour qu’elle soit rendue au moment où elle est déployée, si bien qu’au moment du build il n’existe aucun document rendu à exclure, et tous deux sont refusés.

Le refus est décidé une fois que la Recipe de chaque composant et la FeatureRecipe de chaque rattachement sont liées et que chaque fournisseur s’est décrit — avant que le premier composant ne soit rendu et avant qu’aucune entrée ne soit évaluée, si bien qu’un build refusé ici ne rend rien. La question est posée à chaque document qui rend une source : la Recipe d’un composant ; la FeatureRecipe qu’un rattachement lie sur un composant, une fois pour chaque composant portant le rattachement ; et une FeatureRecipe qui génère une seule fois pour une frontière, une fois, à la frontière qui la déclare. Chaque document fautif est signalé en un seul build ; lorsqu’il y en a plus d’un, les constats sont regroupés sous documents declaring omits whose provider does not honour them. Un document lié à un fournisseur que le build ne peut pas résoudre n’est pas signalé ici : ce build s’arrête là où le fournisseur est sélectionné, en nommant la liaison.

Message émis, positionné sur la clé propre du composant sous components: pour les entrées d’une Recipe (un composant écrit à l’intérieur d’un sous-système est d’abord positionné sous la clé de ce sous-système), sur la clé du rattachement dans le bloc features: qui l’a écrit pour celles d’une FeatureRecipe sur un composant, et sur .spec.boundaries.<boundary>.features.<attachment> dans la Release pour une FeatureRecipe qui génère une seule fois pour sa frontière. La catégorie vous parvient dans l’en-tête entre crochets ; le message nomme d’abord le fournisseur, puis le composant pour lequel le document est rendu :

provider does not support omits ("<provider-name>", node "<node-id>"). this provider’s contract does not declare that it leaves rendered documents out; remove the omits key, or render the source through a provider whose contract declares it (le fournisseur ne prend pas en charge omits : le contrat de ce fournisseur ne déclare pas qu’il exclut des documents rendus ; supprimez la clé omits, ou effectuez le rendu de la source via un fournisseur dont le contrat le déclare)

Le constat d’une FeatureRecipe nomme le rattachement après le composant — node "<node-id>", attachment "<attachment>" — et celui d’une FeatureRecipe qui génère une seule fois pour sa frontière nomme la frontière et le rattachement à la place d’un composant : boundary "<boundary>", attachment "<attachment>".

L’en-tête porte le code court de cette condition, E0335.

Comment corriger : supprimez la clé omits:, ou effectuez le rendu de la source via un fournisseur qui l’honore. Lorsqu’une Recipe helm-chart ou terraform prend pour source un chart ou un module local, une ligne dans le .aggregaignore à côté de la Recipe exclut plutôt un fichier de cette source, à partir de la prochaine fois où la Recipe est épinglée — voir aggrega pin.

The provider does not support boundary artifacts (Le fournisseur ne prend pas en charge les artefacts de frontière)

Une Recipe déclare spec.boundary.artifacts — des fichiers destinés à la sortie partagée de la frontière dans laquelle elle est rendue — et le fournisseur qui en effectue le rendu ne déclare pas qu’il accepte de tels fichiers. Le compilateur écrit lui-même ces fichiers, à côté de ce que le fournisseur assemble pour la frontière, et n’en transmet aucun au fournisseur, si bien que le fait qu’un fichier placé là ait un sens est une propriété de la cible du fournisseur. Une cible qui ne le lit pas le livrerait et l’ignorerait, et la configuration qu’il porte ne prendrait jamais effet ; le build refuse plutôt avant que quoi que ce soit ne soit rendu.

Le fait qu’un fournisseur accepte les fichiers est lu dans la propre déclaration du fournisseur de ce qu’il prend en charge, et non dans une liste de fournisseurs tenue par le compilateur. Toute entrée compte, quel que soit son rendu. Le fournisseur terraform les accepte, en écrivant chacun à côté de la configuration racine de la frontière ; helm, compose, helm-chart et cloudformation ne le font pas, et sont refusés.

Le refus est décidé une fois que la Recipe de chaque composant est liée et que chaque fournisseur s’est décrit — avant que le premier composant ne soit rendu et avant qu’aucune entrée ne soit évaluée, si bien qu’un build refusé ici ne rend rien. Chaque Recipe fautive est signalée en un seul build, une fois pour chaque composant qu’elle rend ; lorsqu’il y a plus d’un constat, ils sont regroupés sous Recipes declaring boundary artifacts whose provider does not accept them. Une Recipe liée à un fournisseur que le build ne peut pas résoudre n’est pas signalée ici : ce build s’arrête là où le fournisseur est sélectionné, en nommant la liaison.

Message émis, positionné sur .spec.boundary dans la Recipe, là où se fait la modification. La catégorie vous parvient dans l’en-tête entre crochets ; le message nomme d’abord le fournisseur, puis le composant pour lequel la Recipe est rendue :

provider does not support boundary artifacts ("<provider-name>", node "<node-id>"). this provider’s contract does not declare that it accepts files written to a boundary’s shared output; remove the boundary block, or render the Recipe through a provider whose contract declares it (le fournisseur ne prend pas en charge les artefacts de frontière : le contrat de ce fournisseur ne déclare pas qu’il accepte les fichiers écrits dans la sortie partagée d’une frontière ; supprimez le bloc boundary, ou effectuez le rendu de la Recipe via un fournisseur dont le contrat le déclare)

L’en-tête porte le code court de cette condition, E0351.

Comment corriger : supprimez le bloc boundary:, ou effectuez le rendu de la Recipe via un fournisseur qui l’accepte. Un fichier qui appartient au composant plutôt qu’à la frontière relève plutôt d’une entrée artifacts:.

At least one input kind must be present (Au moins un type d’entrée doit être présent)

Une Recipe ne déclare aucun type d’entrée : aucune source associée à valuesMapping, aucun workload:, aucun artifacts:. Une telle Recipe ne produit aucune sortie et n’a aucune surface de rendu. Cette règle est vérifiée lorsque la Recipe est chargée.

Un fichier de Recipe de cette forme se heurte d’abord au schéma de la Recipe : le schéma exige, pour tout fournisseur, l’un de source, valuesMapping, workload ou artifacts, si bien que la vérification de l’enveloppe du document refuse le fichier sous E0215 avant que cette règle ne s’exécute, avec une branche pour chaque clé :

document envelope validation failed (Recipe, at <path>); <line>:<column>: spec: no anyOf branch matched: branch[0]: validation: required: missing properties: [“source”]; branch[1]: validation: required: missing properties: [“valuesMapping”]; branch[2]: validation: required: missing properties: [“workload”]; branch[3]: validation: required: missing properties: [“artifacts”]. correct the document to match its kind’s schema (échec de la validation de l’enveloppe du document (Recipe) : spec : aucune branche anyOf ne correspond : branche[0] : validation : requis : propriétés manquantes : [“source”] ; branche[1] : validation : requis : propriétés manquantes : [“valuesMapping”] ; branche[2] : validation : requis : propriétés manquantes : [“workload”] ; branche[3] : validation : requis : propriétés manquantes : [“artifacts”]. corrigez le document pour qu’il corresponde au schéma de son type)

Message émis :

Recipe: at least one input kind required (Recipe <name>:<version>, rule input-kinds, at <path>). declare one of: source (with valuesMapping), workload, artifacts (Recipe : au moins un type d’entrée requis (Recipe, règle input-kinds). déclarez l’un de : source (avec valuesMapping), workload, artifacts)

Comment corriger : ajoutez le type d’entrée qui correspond à l’intention avec laquelle la Recipe a été rédigée. Une Recipe pour un service que le build ne provisionne pas — une base de données ou une API qui tourne déjà ailleurs — déclare un workload: de form: reference avec son endpoint (et éventuellement port), et publie ses valeurs de connexion sous provides: comme le fait toute Recipe : helm la rend sous forme d’ExternalName Service, compose ne rend rien pour elle, et avec l’un comme avec l’autre ses consommateurs lisent les valeurs publiées.

artifacts: entry keys must be unique (Les clés des entrées d’artefacts doivent être uniques)

Une Recipe déclare deux entrées ou plus sous artifacts: avec la même clé. La clé dicte le nom du fichier émis (que le corps de l’entrée soit rédigé en ligne ou chargé via un $import: propre à l’entrée) ; des clés en double émettraient un fichier du même nom dans le même répertoire de frontière.

Le build refuse la Recipe pendant le décodage du document vers sa forme typée, en nommant la clé répétée et la ligne où elle réapparaît. Cette étape s’exécute après la vérification du schéma de l’enveloppe et avant les règles de forme, si bien qu’une Recipe avec une clé artifacts: en double signale un schéma valide puis cet arrêt, et les autres règles de forme ne la signalent pas.

Comment corriger : renommez l’une des clés d’entrée en collision pour que chaque entrée de artifacts: ait un nom de fichier unique.

Emission-time filename collision across input kinds (Collision de noms de fichiers à l’émission entre types d’entrée)

Une Recipe et une FeatureRecipe déclarent chacune des types d’entrée qui produisent des fichiers : une source: que le fournisseur rend, un workload: que le fournisseur synthétise, des entrées artifacts: et un pipeline: dont les étapes peuvent émettre. Chacun choisit ses noms de sortie indépendamment des autres, et rien ne déclare ces noms distincts — si bien que deux d’entre eux peuvent produire un fichier sous un même nom, et un seul des deux survivrait. Le build s’arrête et nomme le nom de sortie ainsi que chaque bloc qui l’a produit.

La vérification s’exécute une fois par document émetteur, dès que l’émission propre à ce document est terminée et avant que sa sortie ne rejoigne un quelconque assemblage. Trois documents émettent, et chacun est vérifié séparément : la Recipe propre d’un composant, la FeatureRecipe qu’un rattachement lie sur un composant, et la FeatureRecipe que lie un rattachement à portée de frontière. C’est le fait de les garder séparés qui fait que le diagnostic nomme le bon document — les fichiers d’un rattachement sont rendus sous l’identité de son composant hôte, si bien qu’une collision dans la FeatureRecipe du rattachement est signalée contre cette FeatureRecipe plutôt que contre l’hôte.

Chaque nom en collision est signalé séparément, si bien qu’un document dont les blocs se sont rencontrés sur deux noms signale les deux. Un constat est positionné sur le document que vous modifiez pour le corriger : l’instance du composant pour une Recipe, et la FeatureRecipe elle-même pour un rattachement, dont le constat nomme aussi le rattachement — un composant ou une frontière peut en lier plusieurs.

Un bloc qui émet plusieurs fichiers sous un même nom ne relève pas de cet arrêt. Il s’agit d’un seul contributeur plutôt que de deux blocs qui se rencontrent, et les clés artifacts: en double au sein d’un bloc sont refusées pendant le décodage du document.

Message émis :

filename collision across input kinds: two input-kind blocks produced a file under one output name (output name <filename>, produced by <origin1>, <origin2>) (collision de noms de fichiers entre types d’entrée : deux blocs de type d’entrée ont produit un fichier sous un même nom de sortie)

Une collision dans une FeatureRecipe porte aussi le rattachement :

filename collision across input kinds: two input-kind blocks produced a file under one output name (output name <filename>, produced by <origin1>, <origin2>, attachment <instance>) (collision de noms de fichiers entre types d’entrée : deux blocs de type d’entrée ont produit un fichier sous un même nom de sortie)

Comment corriger : renommez le fichier en collision dans le type d’entrée que vous contrôlez. Si la collision implique un nom de fichier traduit par le Workload et une entrée artifacts:, les noms traduits par le Workload suivent les conventions de traduction du fournisseur (par ex. <release-name>-deployment.yaml pour helm, où le nom de la release est {{ .context.rendered_name }}) — ajustez le nom de fichier de artifacts: vers un nom que le fournisseur ne synthétise pas.

An output-label key uses a reserved namespace (Une clé d’étiquette de sortie utilise un espace de noms réservé)

Une Recipe nomme une clé d’étiquette sous aggrega.ai/ ou app.kubernetes.io/ — dans outputLabels:, le bloc qui appose des étiquettes littérales sur la sortie rendue, ou dans outputComponentLabels:, le bloc qui nomme les clés d’étiquette du composant dont les valeurs y sont promues. Les deux préfixes appartiennent à l’espace de clés de provenance propre à la plateforme : ce sont les clés que le build appose lui-même, si bien qu’une Recipe qui en apposerait une écrirait dans l’espace qui indique d’où vient une ressource. Les réserver est aussi ce qui maintient l’ensemble d’étiquettes d’une Recipe disjoint de l’ensemble de provenance, de sorte que les deux n’ont jamais à être réconciliés lorsqu’ils sont fusionnés. Cette règle est vérifiée lorsque la Recipe est chargée.

La réservation ne porte que sur la racine nue. Une clé qui porte simplement une racine réservée plus en profondeur dans un espace de noms qui lui est propre — component.aggrega.ai/hosting, par exemple — est un espace de clés différent que la plateforme ne possède pas, et reste utilisable.

Message émis. Une seule condition couvre les deux blocs, si bien que sa phrase ne peut pas dire lequel des deux a été rédigé ; le conseil qui la suit nomme le bloc en citant la clé que vous avez saisie et le bloc dans lequel vous l’avez saisie :

recipe output-labels constraint: key uses a reserved namespace (Recipe <name>:<version>, rule output-labels, at .spec.outputLabels). key "<key>" in outputLabels uses a reserved namespace ("aggrega.ai/" and "app.kubernetes.io/" are reserved for platform provenance) (contrainte output-labels de la recette : la clé utilise un espace de noms réservé (Recipe, règle output-labels). la clé dans outputLabels utilise un espace de noms réservé (les deux préfixes sont réservés à la provenance de la plateforme))

Une clé écrite dans le bloc promu est signalée sous le nom de règle de ce bloc, que le conseil nomme :

recipe output-labels constraint: key uses a reserved namespace (Recipe <name>:<version>, rule output-component-labels, at .spec.outputComponentLabels). key "<key>" in outputComponentLabels uses a reserved namespace ("aggrega.ai/" and "app.kubernetes.io/" are reserved for platform provenance) (contrainte output-labels de la recette : la clé utilise un espace de noms réservé (Recipe, règle output-component-labels). la clé dans outputComponentLabels utilise un espace de noms réservé (les deux préfixes sont réservés à la provenance de la plateforme))

Les clés du bloc littéral sont vérifiées dans l’ordre trié et celles du bloc promu dans l’ordre où vous les avez écrites, si bien qu’une Recipe qui enfreint la règle à plusieurs endroits signale toujours la même clé en premier.

Comment corriger : déplacez la clé dans un espace de noms qui vous appartient — votre propre domaine, ou un espace sous-préfixé tel que component.aggrega.ai/… — ou supprimez-la si la valeur souhaitée est une valeur que le build appose déjà. Les clés de provenance que porte une ressource rendue sont listées dans ../providers/well-known-annotations.md ; en relire une ne nécessite aucune déclaration dans la Recipe.

A promoted component label is also declared literally (Une étiquette de composant promue est aussi déclarée littéralement)

Une Recipe nomme une même clé à la fois dans outputComponentLabels: et dans outputLabels:. Les deux blocs apposent sur la même surface d’étiquettes à partir de sources différentes — le premier promeut la valeur que porte le composant, le second écrit la valeur saisie par l’auteur de la Recipe — si bien qu’une clé nommée dans les deux arriverait avec deux valeurs candidates et rien pour dire laquelle l’emporte. Cette règle est vérifiée lorsque la Recipe est chargée, après la règle de l’espace de noms réservé ci-dessus, si bien qu’une Recipe qui enfreint les deux signale d’abord l’espace de noms réservé : la correction de cette faute ne dépend pas de ce que contient l’autre bloc.

Message émis :

recipe output-component-labels constraint: key is also declared in outputLabels (Recipe <name>:<version>, rule output-component-labels, at .spec.outputComponentLabels.<key>). key "<key>" is promoted through outputComponentLabels and also declared literally in outputLabels; keep whichever source the label should come from and drop the other (contrainte output-component-labels de la recette : la clé est aussi déclarée dans outputLabels (Recipe, règle output-component-labels). la clé est promue via outputComponentLabels et aussi déclarée littéralement dans outputLabels ; conservez la source dont l’étiquette doit provenir et supprimez l’autre)

Comment corriger : décidez d’où vient la valeur de l’étiquette et supprimez l’autre déclaration. Conservez l’entrée outputComponentLabels: lorsque la valeur doit suivre ce que porte le composant, de sorte que deux composants liés à une même Recipe apposent leurs propres valeurs ; conservez l’entrée outputLabels: lorsque la valeur est propre à la Recipe et identique partout où la Recipe est liée.

Règles de forme de la FeatureRecipe

Une FeatureRecipe compose sa sortie à partir des mêmes types d’entrée qu’une Recipe, et la règle de composition ci-dessous la contraint comme elle contraint une Recipe. Elle est vérifiée lorsque la FeatureRecipe est chargée, et elle signale sous la forme que prend un arrêt de forme de Recipe — la phrase de la règle, puis le document fautif, le nom de la règle et le conseil pour cette occurrence — sous une balise CATALOG_ERROR.

Il n’y a délibérément aucune règle d’au moins un type d’entrée ici, et c’est la différence avec une Recipe. Une FeatureRecipe qui ne déclare qu’un fournisseur et ce qu’elle implémente est un rattachement légitime de pur câblage : elle ne rend rien, et son effet est la connexion que porte la Feature qu’elle implémente. Une FeatureRecipe qui ne déclare que injectMapping: est légitime de la même façon.

A FeatureRecipe’s valuesMapping requires source (Le mappage des valeurs d’une FeatureRecipe exige une source)

Une FeatureRecipe déclare valuesMapping mais pas source. Un mappage des valeurs est une surcouche : sans chart, module ou fichier sur lequel se superposer, les valeurs mappées n’ont rien à atteindre.

Message émis :

FeatureRecipe: valuesMapping requires source (FeatureRecipe <name>:<version>, rule values-mapping, at <path>). declare a source: pointer alongside valuesMapping (or remove the valuesMapping if no overlay is intended) (FeatureRecipe : valuesMapping exige source (FeatureRecipe, règle values-mapping). déclarez un pointeur source: à côté de valuesMapping (ou supprimez le valuesMapping si aucune surcouche n’est voulue))

Comment corriger : ajoutez le pointeur source: pour lequel la surcouche a été écrite, ou supprimez le valuesMapping et laissez le rattachement faire son travail autrement — artifacts: pour émettre ses propres fichiers, injectMapping: pour remodeler ce qu’il livre, ou aucun des deux, pour un rattachement de pur câblage.

A pipeline declares one step id twice (Un pipeline déclare deux fois un même id d’étape)

Une Recipe ou une FeatureRecipe déclare le même id sur deux étapes de son spec.pipeline. Une étape publie les sorties qu’elle renvoie sous son id, et une étape ultérieure du même pipeline les lit sous la forme .steps.<id>.outputs ; deux étapes partageant un id amèneraient donc cette étape ultérieure à lire les sorties de celle des deux qui a publié en dernier plutôt que celles de l’étape que vous visiez.

La règle porte sur le pipeline propre à un document. La Recipe d’un composant et les FeatureRecipes qui lui sont rattachées exécutent chacune leur pipeline séparément, et chaque pipeline démarre sans aucune sortie d’étape ; une étape d’une Recipe et une étape d’une FeatureRecipe rattachée peuvent donc porter le même id.

Aucun schéma ne peut exprimer cette règle — JSON Schema n’a aucun mot-clé pour une liste dont les entrées sont uniques selon l’un de leurs champs —, si bien qu’un éditeur qui connaît le schéma accepte un tel document, et la vérification s’exécute à la lecture du document, juste après la vérification du schéma. Chaque surface qui lit une Recipe ou une FeatureRecipe la signale : aggrega validate sur le fichier ou sur tout le catalogue, un build qui charge le catalogue, un pull qui admet une entité récupérée, les diagnostics de l’éditeur, et une modification de document, qui est refusée plutôt qu’écrite. Un document qui échoue aussi à son schéma signale d’abord les constats du schéma, puis ce refus une fois ceux-ci corrigés.

Chaque répétition est un constat à part entière, positionné sur l’id répété et nommant l’étape qui a déclaré l’id en premier, avec sa ligne et sa colonne. Lorsqu’un id apparaît trois fois, les deux étapes ultérieures nomment la première.

Message émis, pour une FeatureRecipe dont la deuxième étape répète l’id de la première. La catégorie et le code court de cette condition, E0370, vous parviennent dans l’en-tête entre crochets :

a pipeline declares one step id twice (FeatureRecipe, at <path>); <line>:<column>: spec.pipeline[1].id: step id "<id>" is already declared at spec.pipeline[0].id (line <line>, column <column>). give each step of the pipeline its own id, and point every .steps.<id> reference a later step makes at the step it means (un pipeline déclare deux fois un même id d’étape (FeatureRecipe) ; spec.pipeline[1].id : l’id d’étape est déjà déclaré en spec.pipeline[0].id. donnez à chaque étape du pipeline son propre id, et faites pointer chaque référence qu’une étape ultérieure fait vers l’étape qu’elle désigne)

Comment corriger : renommez l’une des deux étapes, de sorte que chaque id soit déclaré une seule fois. Parcourez ensuite les templates with: et when: de chaque étape ultérieure à la recherche de références .steps.<id> à l’id conservé, et faites pointer chacune vers l’étape dont elle désigne les sorties — c’est le renommage qui rend les sorties des deux étapes accessibles séparément.

A document declares an API version this compiler no longer reads (Un document déclare une version d’API que ce compilateur ne lit plus)

La ligne apiVersion d’un document déclare aggrega.ai/v1alpha1. Chaque type de document qui comporte une ligne apiVersion déclare aggrega.ai/v1beta1, la seule version que ce compilateur lit, et aucune conversion depuis la version antérieure n’a lieu : le document est refusé au moment de sa lecture, avant toute autre vérification, car tout autre constat porterait sur une version du document que le compilateur ne lit pas.

Chaque surface qui lit un document le signale : aggrega validate, un build, un pull qui admet une entité récupérée, les diagnostics de l’éditeur et une modification de document. Un document qui déclare une version que le compilateur n’a jamais lue est refusé à la place par le schéma de son type, sous E0215.

Message émis, pour un Component. La catégorie et le code court de cette condition, E0373, vous parviennent dans l’en-tête entre crochets :

a document declares an API version this compiler no longer reads (Component, at <path>); 1:1: apiVersion: the document declares aggrega.ai/v1alpha1, and this compiler reads aggrega.ai/v1beta1. change the apiVersion line to apiVersion: aggrega.ai/v1beta1 (un document déclare une version d’API que ce compilateur ne lit plus (Component) ; 1:1: apiVersion: le document déclare aggrega.ai/v1alpha1, et ce compilateur lit aggrega.ai/v1beta1. définissez aggrega.ai/v1beta1 dans la ligne apiVersion)

Comment corriger : remplacez la ligne apiVersion du document par apiVersion: aggrega.ai/v1beta1. Les champs de chaque type sont inchangés entre les deux versions, cette ligne constitue donc toute la modification.

A plugin declares a plugin ABI version this compiler no longer speaks (Un plugin déclare une version d’ABI de plugin que ce compilateur ne prend plus en charge)

Un plugin déclare l’ABI de plugin v1alpha1. Ce compilateur prend en charge l’ABI de plugin v1beta1 et aucune autre, si bien qu’un plugin construit sur l’ABI antérieure est refusé au lieu d’être exécuté. Un plugin indique son ABI à deux endroits, et chacun est refusé sous cette même condition : le rapport describe() que son module invité renvoie lors de son chargement, et le champ spec.abiVersion de son entité Plugin, refusé au moment de la lecture de l’entité, avant toute autre vérification. Un plugin qui déclare une version d’ABI que ce compilateur n’a jamais prise en charge est également refusé, par la vérification du descripteur (E0085) ou par le schéma Plugin (E0215).

Message émis, pour un module invité au chargement. La catégorie et le code court de cette condition, E0374, vous parviennent dans l’en-tête entre crochets :

plugin "<plugin>" declares abi_version “v1alpha1”, and this compiler speaks “v1beta1”; rebuild the plugin against the current plugin kit and publish it again: a plugin declares a plugin ABI version this compiler no longer speaks (le plugin déclare abi_version “v1alpha1”, et ce compilateur prend en charge “v1beta1” ; reconstruisez le plugin avec le kit de plugin actuel et publiez-le de nouveau : un plugin déclare une version d’ABI de plugin que ce compilateur ne prend plus en charge)

Message émis, pour une entité Plugin :

a plugin declares a plugin ABI version this compiler no longer speaks (Plugin, at <path>); <line>:<column>: spec.abiVersion: the Plugin declares abiVersion v1alpha1, and this compiler speaks v1beta1. rebuild the plugin against the current plugin kit and publish it again; its Plugin entity then declares abiVersion: v1beta1 (un plugin déclare une version d’ABI de plugin que ce compilateur ne prend plus en charge (Plugin) ; spec.abiVersion: le Plugin déclare abiVersion v1alpha1, et ce compilateur prend en charge v1beta1. reconstruisez le plugin avec le kit de plugin actuel et publiez-le de nouveau ; son entité Plugin déclare alors abiVersion v1beta1)

Comment corriger : reconstruisez le plugin avec la version actuelle de son kit de plugin, qui inscrit v1beta1 dans le rapport describe() du module invité, et publiez-le de nouveau, afin que l’entité générée à côté de lui déclare elle aussi abiVersion: v1beta1. Modifier seulement la ligne de l’entité ne suffit pas : le module invité lui-même signale toujours l’ABI antérieure et est refusé lors de son chargement.

An artifact carries a media type this compiler no longer reads (Un artefact porte un type de média que ce compilateur ne lit plus)

Un artefact récupéré depuis un registre porte un type de média sous lequel publiait une version antérieure — application/vnd.aggrega.<kind>.v1alpha1 avec son suffixe, sur le type d’artefact du manifeste, sa configuration ou l’une de ses couches. Ce compilateur publie et lit les types de média v1beta1, si bien que l’artefact est refusé nommément à la lecture de son manifeste, avant que quoi que ce soit de son contenu ne soit pris : qu’il s’agisse d’une entité de catalogue, d’un plugin et de son exécutable ou d’un paquet de documentation. Une indexation d’un registre ignore un tel artefact, en indiquant pourquoi. Un type de média en dehors de l’espace de noms application/vnd.aggrega. propre à Aggrega ne relève jamais de cette condition.

Message émis, pour un Component publié par une version antérieure. La catégorie et le code court de cette condition, E0375, vous parviennent dans l’en-tête entre crochets :

"<reference>" carries media type “application/vnd.aggrega.component.v1alpha1+yaml”, and this compiler reads “application/vnd.aggrega.component.v1beta1+yaml”; publish the artifact again with the current release: oci: artifact carries a media type this compiler no longer reads (porte le type de média “application/vnd.aggrega.component.v1alpha1+yaml”, et ce compilateur lit “application/vnd.aggrega.component.v1beta1+yaml” ; publiez de nouveau l’artefact avec la version actuelle : oci: l’artefact porte un type de média que ce compilateur ne lit plus)

Comment corriger : publiez de nouveau l’artefact avec la version actuelle de aggrega, qui écrit les types de média v1beta1. Un artefact publié par quelqu’un d’autre doit être republié par cette personne ; tant qu’elle ne l’a pas fait, il ne peut pas être lu.

A file cannot be read, or its bytes do not parse (Un fichier ne peut pas être lu, ou ses octets ne s’analysent pas)

Un fichier qu’un build devait lire, ou un document Aggrega qu’une vérification de tout le catalogue a lu sous les répertoires du catalogue, n’a rien produit que la surface qui le nommait ou le lisait puisse utiliser. Soit il n’a pas pu être lu depuis le disque, soit ses octets ont été analysés et l’analyse n’a pas abouti proprement. Rien en aval ne s’exécute dessus, car il n’y a aucun contenu à vérifier par rapport à un schéma, aucun composant à placer et aucun template à rendre.

La condition ne nomme aucun format, et c’est voulu. La plupart des fichiers qu’elle couvre sont lus comme du YAML ; les corps workload, values-mapping et artifact d’une Recipe sont lus comme du source de template Go et ne sont jamais analysés. Une phrase promettant du YAML ouvrirait un diagnostic sur un fichier template par une affirmation sur le format de ce fichier. Laquelle des deux défaillances s’est produite, et pour quel type de fichier, c’est ce que dit la proposition qui suit la phrase.

Les documents dont part un build — l’Aggregate, la Release et le Manifest — sont les sujets les plus courants, et l’arrêt est levé à chaque point où l’un des trois est lu. Le diagnostic nomme le document qui était lu et le chemin depuis lequel il l’a été. C’est le chemin qui distingue un fichier manquant d’un fichier mal formé : un échec de lecture cite la raison propre du système d’exploitation, et un échec d’analyse cite celle du parseur YAML, qui indique la ligne sur laquelle le parseur a abandonné.

Message émis, lorsque le fichier n’a pas pu être lu :

file load failed: the file could not be read, or its bytes did not parse (Aggregate, at <path>, failed to read file: <underlying reason>) (échec du chargement du fichier : le fichier n’a pas pu être lu, ou ses octets ne se sont pas analysés (Aggregate, échec de la lecture du fichier))

et lorsque son texte ne s’est pas analysé :

file load failed: the file could not be read, or its bytes did not parse (Aggregate, at <path>, failed to unmarshal YAML: <underlying reason>) (échec du chargement du fichier : le fichier n’a pas pu être lu, ou ses octets ne se sont pas analysés (Aggregate, échec du décodage du YAML))

Release et Manifest apparaissent à la place de Aggregate lorsque l’un de ceux-ci est le document lu. La même condition couvre aussi le contrat de paramètres lu dans le bloc parameters: déclaré d’un Aggregate, qui est lu dans le texte même de l’Aggregate avant que quoi que ce soit n’y soit interpolé.

Un parameters: { $import: … } d’une Release qui nomme un fichier que le build ne parvient pas à obtenir est aussi signalé ici, et dans les deux cas : le chemin ne nomme aucun fichier que le build puisse lire, ou le fichier est lu et ses octets ne s’analysent pas. Le sujet est la Release, et la proposition nomme la clé qui pointait vers le fichier :

file load failed: the file could not be read, or its bytes did not parse (Release, at .spec.parameters.$import: <path>, failed to read file: <underlying reason>) (échec du chargement du fichier : le fichier n’a pas pu être lu, ou ses octets ne se sont pas analysés (Release, échec de la lecture du fichier)) file load failed: the file could not be read, or its bytes did not parse (Release, at .spec.parameters.$import: <path>, failed to unmarshal YAML: <underlying reason>) (échec du chargement du fichier : le fichier n’a pas pu être lu, ou ses octets ne se sont pas analysés (Release, échec du décodage du YAML))

Un chemin relatif est résolu à partir du répertoire contenant la Release qui l’écrit — la Release qu’une commande nomme, ou un maillon de sa chaîne extends: —, d’où que la commande soit exécutée, de sorte que la ligne de commande et l’éditeur lisent le même fichier ; un chemin absolu nomme son propre emplacement. Vérifiez que l’extraction sur laquelle le build s’exécute contient le fichier à cet endroit : un fichier de paramètres présent sur votre machine et exclu du contrôle de version est absent lors d’une exécution d’intégration continue, et c’est ainsi qu’on rencontre le plus souvent cette erreur. Un chemin qui sort de l’espace de travail — ou, pour une Release nommée hors de l’espace de travail, du répertoire propre à cette Release — n’est pas lu du tout, et il est signalé sous « A reference to another file leads out of the directory it must stay inside » (Une référence à un autre fichier sort du répertoire dans lequel elle doit rester) plus bas.

Un $import: de schéma qui nomme un fichier que le build ne parvient pas à obtenir est aussi signalé ici, car le défaut est le même : la directive est bien formée et le fichier qu’elle nomme n’a pas produit de document. Le sujet est alors une entité de catalogue plutôt que l’un des trois, si bien que la proposition nomme la surface de schéma pour laquelle la résolution avait lieu — spec.schema, l’un de ses piliers comme spec.schema.values, ou le valueSchema d’un socket usesSchema — et le pointeur de source est la ligne sur laquelle la directive a été écrite :

file load failed: the file could not be read, or its bytes did not parse. <surface>: read imported schema <value>: <the operating system's reason> (échec du chargement du fichier : le fichier n’a pas pu être lu, ou ses octets ne se sont pas analysés. lecture du schéma importé)

avec resolve imported schema path à la place de read pour l’échec plus rare où le répertoire propre de l’entité n’a pas pu être établi du tout, et parse imported schema lorsque le fichier a été lu et que son texte n’est pas du YAML bien formé. Un défaut dans la directive que vous avez écrite — une clé sœur à côté d’elle, une valeur qui n’est pas un chemin, ou un contenu importé qui s’est analysé et n’est pas une map — est une condition différente et est signalé sous « A schema $import: cannot be applied » (Une importation de schéma ne peut pas être appliquée) plus bas.

Un import valuesMapping:, workload: ou artifacts.<name>: d’une Recipe ou d’une FeatureRecipe est aussi signalé ici, pour la même raison et avec le même remède : la directive est bien formée et le fichier qu’elle nomme n’a pas produit de contenu. Ces trois corps sont du source de template Go plutôt que des documents, si bien que seule la lecture peut échouer — rien ne les analyse à ce stade. L’entité et la clé qui a nommé le chemin figurent dans la proposition, et le pointeur de source est le chemin propre du fichier importé :

file load failed: the file could not be read, or its bytes did not parse (Recipe <name> valuesMapping file import, <the operating system's reason>). if you meant a library entry rather than a file, the reference needs its fragment — an $import: carrying none is read as a file path, and an unquoted value ends where a space before # starts a comment, so quote the whole reference (échec du chargement du fichier : le fichier n’a pas pu être lu, ou ses octets ne se sont pas analysés (Recipe, import de fichier valuesMapping). si vous vouliez une entrée de bibliothèque plutôt qu’un fichier, la référence a besoin de son fragment — un $import: qui n’en porte aucun est lu comme un chemin de fichier, et une valeur sans guillemets se termine là où une espace avant # commence un commentaire ; mettez donc toute la référence entre guillemets) file load failed: the file could not be read, or its bytes did not parse (Recipe <name> workload file import, <the operating system's reason>). if you meant a library entry rather than a file, the reference needs its fragment — an $import: carrying none is read as a file path, and an unquoted value ends where a space before # starts a comment, so quote the whole reference (échec du chargement du fichier : le fichier n’a pas pu être lu, ou ses octets ne se sont pas analysés (Recipe, import de fichier workload). si vous vouliez une entrée de bibliothèque plutôt qu’un fichier, la référence a besoin de son fragment — un $import: qui n’en porte aucun est lu comme un chemin de fichier, et une valeur sans guillemets se termine là où une espace avant # commence un commentaire ; mettez donc toute la référence entre guillemets) file load failed: the file could not be read, or its bytes did not parse (Recipe <name> artifact <key> file import, <the operating system's reason>). if you meant a library entry rather than a file, the reference needs its fragment — an $import: carrying none is read as a file path, and an unquoted value ends where a space before # starts a comment, so quote the whole reference (échec du chargement du fichier : le fichier n’a pas pu être lu, ou ses octets ne se sont pas analysés (Recipe, import de fichier d’un artifact). si vous vouliez une entrée de bibliothèque plutôt qu’un fichier, la référence a besoin de son fragment — un $import: qui n’en porte aucun est lu comme un chemin de fichier, et une valeur sans guillemets se termine là où une espace avant # commence un commentaire ; mettez donc toute la référence entre guillemets)

Le fragment est ce qui distingue une référence de bibliothèque d’un chemin : <Library>#/mappings/<entry> est résolu par rapport aux bibliothèques, et le même texte sans le fragment est un chemin relatif ordinaire. Il est facile de le perdre sans s’en apercevoir, car une valeur YAML simple se termine là où une espace avant # ouvre un commentaire — ainsi $import: LibBeta:1.0.0 #/workloads/Web parvient au build sous la forme LibBeta:1.0.0, et le build cherche alors un fichier de ce nom à côté de la Recipe. Mettez toute la référence entre guillemets pour conserver le fragment.

Les trois mêmes clés sur une FeatureRecipe signalent la même condition et se lisent de la même façon. Un import d’artifacts est lu deux fois au cours de la vie d’une Release — une fois lorsque aggrega pull fige l’épinglage de son contenu, et de nouveau lorsque l’entrée est rendue —, si bien que le même fichier manquant signale cette condition à celui des deux moments que vous atteignez en premier. Un défaut de forme dans la directive elle-même, comme une clé sœur à côté de $import: ou une référence oci:// portant un hôte, est une condition différente et est signalé sous sa propre entrée.

aggrega lint et aggrega validate sur tout le catalogue signalent aussi ici, pour un document sous les répertoires du catalogue qui déclare une apiVersion Aggrega — une ligne commençant, sans indentation, par apiVersion: et une valeur commençant par aggrega.ai/ — et qui ne peut pas être lu, ne s’analyse pas, ou ne se décode pas dans l’enveloppe que lit la vérification, comme des metadata écrites sous forme de liste. Aucun auteur n’a écrit de chemin vers lui : la vérification l’a lu parce qu’il se trouve dans un répertoire de catalogue. Chaque vérification lit tous les fichiers avant de s’arrêter, si bien qu’une seule exécution nomme chacun de ces documents ; elle ne vérifie rien d’autre et n’affiche aucun récapitulatif. Le YAML qui ne déclare aucune apiVersion Aggrega — dont les templates d’un chart Helm — est ignoré. L’en-tête compte les documents et nomme leurs fichiers, et chacun est listé en dessous avec la raison donnée par la lecture ou par le parseur :

<n> documents under the catalog directories declare an Aggrega apiVersion and could not be loaded, so nothing was checked: <path>, <path> (des documents sous les répertoires du catalogue déclarent une apiVersion Aggrega et n’ont pas pu être chargés, donc rien n’a été vérifié) file load failed: the file could not be read, or its bytes did not parse (catalog document, failed to unmarshal YAML: <the parser's reason>) (échec du chargement du fichier : le fichier n’a pas pu être lu, ou ses octets ne se sont pas analysés (document de catalogue, échec du décodage du YAML))

avec failed to decode the envelope: suivi de la ligne et de ce que le décodeur y a trouvé — line 4 (metadata): a list is written where a map is expected pour des metadata écrites sous forme de liste — pour un document qui s’analyse et ne se décode pas, et failed to read file: suivi de la raison du système d’exploitation pour un fichier qui n’a pas pu être lu. Un document qui se charge et déclare un type qu’aucun catalogue ne contient est nommé par le même arrêt, compté dans le même en-tête et listé sous sa propre condition — voir « A catalog document declares a kind a catalog does not hold » (Un document de catalogue déclare un type qu’un catalogue ne contient pas) plus bas.

Comment corriger : lisez le chemin dans le message plutôt que le nom du document — les deux diffèrent chaque fois qu’une référence a été résolue à un endroit inattendu. Pour un échec de lecture, vérifiez que le fichier existe à ce chemin, que le chemin est écrit comme l’écrit le document qui y fait référence, et que le build a la permission de le lire ; un fichier présent localement et absent de l’extraction d’un agent de build est le cas courant. Pour un échec d’analyse, ouvrez le fichier à la ligne que le parseur a nommée — une valeur sans guillemets contenant un deux-points, une tabulation utilisée pour l’indentation et un élément de liste indenté sous la mauvaise clé sont les trois causes qui expliquent la plupart d’entre eux.

A catalog document declares a kind a catalog does not hold (Un document de catalogue déclare un type qu’un catalogue ne contient pas)

Un document sous les répertoires du catalogue déclare une apiVersion Aggrega — une ligne commençant, sans indentation, par apiVersion: et une valeur commençant par aggrega.ai/ — et un kind qu’aucun catalogue ne contient : une faute de frappe comme Componnent, un type dans la mauvaise casse comme component, ou aucun kind du tout. Un catalogue range chaque document sous le type qu’il déclare, si bien qu’un tel document n’entre dans aucun catalogue : un build, inspect et toute autre commande qui charge le catalogue l’ignorent, et une référence à l’entité qu’il devait déclarer ne se résout en rien.

Un catalogue contient des documents Component, Feature, Recipe, FeatureRecipe, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary, Aggregate et Plugin. Trois autres types se trouvent légitimement dans ses répertoires et ne sont jamais signalés ici : un Manifest et une Release conservés à côté des entités, et un Workload dans le répertoire de la Recipe ou de la FeatureRecipe qui l’importe.

aggrega validate et aggrega lint sur tout le catalogue le signalent, ainsi que le lint circonscrit à une release, qui parcourt les mêmes répertoires. Chacun lit tous les fichiers avant de s’arrêter, si bien qu’une seule exécution nomme chacun de ces documents avec tout document qui ne peut pas être chargé du tout, sous un seul en-tête qui les compte et nomme leurs fichiers ; rien n’est vérifié et aucun récapitulatif n’est affiché. Chaque document est listé avec le type qu’il déclare, et la ligne se termine par les types qu’un catalogue contient :

<n> documents under the catalog directories declare an Aggrega apiVersion and could not be loaded, so nothing was checked: <path>, <path> (des documents sous les répertoires du catalogue déclarent une apiVersion Aggrega et n’ont pas pu être chargés, donc rien n’a été vérifié) catalog document declares a kind a catalog does not hold (kind “Componnent”). a catalog holds Component, Feature, Recipe, FeatureRecipe, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary, Aggregate and Plugin documents, and passes over a Workload, a Manifest or a Release; correct the kind, or move the file out of the catalog directories (un document de catalogue déclare un type qu’un catalogue ne contient pas (kind “Componnent”). un catalogue contient des documents Component, Feature, Recipe, FeatureRecipe, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary, Aggregate et Plugin, et ignore un Workload, un Manifest ou une Release ; corrigez le kind, ou déplacez le fichier hors des répertoires du catalogue)

avec no kind à la place de kind "<kind>" pour un document qui n’en déclare aucun.

Un build ne s’arrête pas sur un tel document : il l’ignore comme le fait tout chargement, et un document qu’aucune Release n’atteint ne fait jamais échouer un build. Lorsqu’une Release atteint l’entité, le build s’arrête à la référence, sous « A reference names no entity the catalog holds » (Une référence ne nomme aucune entité que contient le catalogue) plus bas, et la note sous cet échec nomme le fichier lorsqu’il déclare le nom que demande la référence — voir cette entrée.

Comment corriger : ouvrez le fichier que nomme le message et corrigez son kind pour qu’il soit le type qu’est le document — l’orthographe et la casse comptent toutes deux. Un fichier qui n’est pas du tout une entité de catalogue n’a pas sa place sous les répertoires du catalogue ; déplacez-le, ou donnez-lui une apiVersion qui n’est pas celle d’Aggrega s’il s’agit du document d’un autre outil.

A path names content outside the entity’s own directory (Un chemin désigne un contenu situé hors du répertoire propre de l’entité)

Le contenu d’une entité se trouve dans le répertoire propre de l’entité, car chaque fichier qu’une publication de l’entité emporte est pris à cet endroit. Un chemin qui en sort pointe vers un fichier qui ne voyagerait pas avec l’entité : le fichier n’est donc pas présent pour quiconque reçoit l’entité, et un pin enregistré sur ce fichier garantit des octets que ces destinataires ne peuvent pas obtenir.

Ainsi, chaque chemin qu’une entité écrit pour un contenu qu’elle emporte est lu par rapport au répertoire contenant le fichier de l’entité et doit rester à l’intérieur de celui-ci. Cela couvre la source: d’une Recipe et d’une FeatureRecipe — un chemin simple, ou l’url: de la forme structurée —, le fichier que chaque entrée valuesMapping:, workload: et artifacts: importe avec $import:, et chaque schéma qu’un Component ou une Feature importe, en entier, par pilier ou, pour un socket usesSchema, son valueSchema et son infraSchema. Trois formes sortent du répertoire : un chemin qui remonte au-dessus de celui-ci, un chemin absolu, qui désigne un emplacement sur la machine où il a été écrit, et un chemin écrit à l’intérieur du répertoire qu’un lien symbolique sur le trajet fait sortir — un répertoire le long du chemin, aussi bien que le fichier à son extrémité, qui est un lien menant hors du répertoire de l’entité. Un chemin qui remonte puis revient à l’intérieur — ./charts/../values.tmpl — est un chemin ordinaire à l’intérieur du répertoire, de même qu’un chemin passant par un lien qui mène ailleurs à l’intérieur de celui-ci. Une remontée qui rentre dans le répertoire par son propre nom — ../1.0.0/values.tmpl écrit dans un répertoire nommé 1.0.0 — est refusée, car le nom du répertoire ne fait pas partie de ce qui voyage : une entité publiée est lue depuis un répertoire que nomme le cache du destinataire, où ce nom ne trouve rien. Un chemin passant par un lien qui mène à l’extérieur est refusé, car une publication emporterait sinon les octets vers lesquels pointe le lien, où qu’il pointe, sous un nom interne à l’entité.

Il est refusé partout où l’entité est lue. Un aggrega validate sur l’ensemble du catalogue, aggrega validate sur le fichier propre de l’entité, aggrega pull et aggrega build le refusent à la lecture du fichier de l’entité, de même que aggrega pin d’une Recipe ou d’une FeatureRecipe et aggrega push de l’un quelconque des quatre types, avant que quoi que ce soit ne soit récupéré, écrit ou publié. Une source: écrite sous forme de template ne désigne rien tant que le build ne l’a pas évaluée ; un template produisant un chemin hors du répertoire est donc refusé par le build, au moment où la valeur existe.

Une Release est différente, et une référence d’entité aussi. Une Release pointe vers d’autres entités — son Aggregate, son Manifest, la Release qu’elle étend — et n’est jamais publiée, si bien que rien de ce qu’elle lit ne voyage nulle part : ces chemins, ainsi que le fichier qu’importent les parameters: d’une Release, sont lus tels qu’ils sont écrits. Le type d’un Aggregate désigne une autre entité par son identité plutôt que par un contenu que l’Aggregate emporte, et il est lui aussi résolu selon ses propres règles : par les répertoires du catalogue, le cache et le registre, jamais comme un chemin de fichier.

Message émis, qui désigne le chemin tel qu’il est écrit :

a path names content outside the entity’s own directory ("<path>"). remediation: move the file into the directory holding the entity, or a directory beneath it, and name it with a path relative to that directory. An entity’s content lives in the entity’s own directory because every file a publication of it carries is taken from there; a path that leaves it points at a file that would not travel with the entity (un chemin désigne un contenu situé hors du répertoire propre de l’entité. remède : déplacez le fichier dans le répertoire contenant l’entité, ou dans un répertoire situé en dessous, et désignez-le par un chemin relatif à ce répertoire. Le contenu d’une entité se trouve dans le répertoire propre de l’entité, car chaque fichier qu’une publication de celle-ci emporte est pris à cet endroit ; un chemin qui en sort pointe vers un fichier qui ne voyagerait pas avec l’entité)

et, pour un chemin qu’un lien fait sortir du répertoire, qui désigne le lien et l’endroit où il mène :

a path names content outside the entity’s own directory ("./frag/fragment.yaml", the link <entity-directory>/frag leads to <elsewhere>/frag). remediation: replace the link with a copy of what it leads to, placed inside the directory holding the entity. An entity’s content lives in the entity’s own directory because every file a publication of it carries is taken from there; a link leading out of it would carry the bytes it points at under a name inside the entity (un chemin désigne un contenu situé hors du répertoire propre de l’entité. remède : remplacez le lien par une copie de ce vers quoi il mène, placée à l’intérieur du répertoire contenant l’entité. Le contenu d’une entité se trouve dans le répertoire propre de l’entité, car chaque fichier qu’une publication de celle-ci emporte est pris à cet endroit ; un lien qui en sort emporterait les octets vers lesquels il pointe sous un nom interne à l’entité)

Le champ depuis lequel il a été lu est indiqué sur la ligne au-dessus du message : resolve Recipe source …, resolve Recipe artifact "<key>" $import target …, spec.schema.values: imported schema … ou, pour une source issue d’un template, node "<name>" source.

Comment corriger : déplacez le fichier dans le répertoire de l’entité, ou dans un répertoire situé en dessous, et écrivez son chemin relativement à ce répertoire. Lorsqu’un lien fait sortir le chemin, remplacez le lien par une copie de ce vers quoi il mène, à l’intérieur du répertoire de l’entité. Un chart que partagent plusieurs Recipes est copié dans le répertoire de chaque Recipe, puisque chacune est publiée séparément ; un schéma que partagent plusieurs Components a sa place dans une SchemaLibrary, que chaque Component référence ensuite par son identité, et un corps de mapping, de charge de travail ou d’artefact que partagent plusieurs Recipes a sa place dans le type de bibliothèque correspondant.

A Recipe’s source: names a kind nothing knows how to acquire (La source d’une Recipe désigne un type que rien ne sait acquérir)

La source: d’une Recipe indique vers quel type de chose elle pointe — un chart, un module, un projet compose — et chaque type est acquis par l’adaptateur de source qui sert ce type. Cette condition signale un type qu’aucun adaptateur de source ne sert, si bien que rien de ce que ce programme embarque ne peut récupérer la source. La source: d’une FeatureRecipe est soumise à la même règle.

Il est refusé à la lecture du document, avant que quoi que ce soit ne soit récupéré : la vérification de la Recipe seule le refuse, de même que chaque Release qui l’atteint. Rien n’a été tenté, car rien ne pouvait le tenter — c’est ce qui le distingue d’une acquisition qui s’est exécutée et a échoué.

Message émis, qui désigne le document, le type tel qu’il est écrit et les types servis :

no source adapter serves the source kind (Recipe <name>:<version>, rule source-kind, at <file>). the source names kind "<kind>"; name a kind a source adapter serves (<the served kinds>), or write the source as a single URI whose shape names its kind (aucun adaptateur de source ne sert le type de source (Recipe, règle source-kind). la source désigne un type ; désignez un type que sert un adaptateur de source, ou écrivez la source sous la forme d’un URI unique dont la forme désigne son type)

Comment corriger : corrigez le type dans la source: en un type que la chaîne d’outils sert — une faute d’orthographe et un type qui n’a réellement aucun adaptateur produisent le même message, et le message cite le type tel que vous l’avez écrit à côté des types servis ; la première chose à vérifier est donc l’orthographe par rapport à cette liste, que décrit aussi la page de la Recipe. Si le type est écrit comme vous l’entendiez, ce type n’est pas un type que ce build peut acquérir, et aucune modification de la Recipe n’y changera rien ; faites plutôt pointer la source: vers une forme servie, ou écrivez-la sous la forme d’un URI unique dont la forme désigne son type.

No source adapter is registered in this program for a source kind (Aucun adaptateur de source n’est enregistré dans ce programme pour un type de source)

Une source est récupérée par l’adaptateur enregistré pour son type. Cette condition signale une récupération lancée pour un type pour lequel aucun adaptateur n’est enregistré. Un type écrit par un auteur qu’aucun adaptateur ne sert est refusé à la lecture de sa Recipe (sous « A Recipe’s source: names a kind nothing knows how to acquire (La source d’une Recipe désigne un type que rien ne sait acquérir) » plus haut), si bien que rien de ce qu’écrit un auteur n’arrive jusqu’ici : elle signale un programme assemblé sans l’adaptateur d’un type qu’il sert, ou un programme construit sur les paquets Go d’Aggrega qui lance une récupération pour un type qu’il a lui-même assemblé.

Message émis, qui désigne le type :

kind "<kind>": no source adapter is registered in this program for the source kind (type : aucun adaptateur de source n’est enregistré dans ce programme pour le type de source)

Comment corriger : rien dans vos fichiers d’entité n’en est la cause. Signalez-le à la personne qui a compilé le binaire que vous exécutez.

A source URL carries a credential (Une URL de source contient un identifiant de connexion)

L’url d’une source est enregistrée telle que vous l’avez écrite — dans le fichier de verrouillage de la Release, dans l’entity.lock à côté de la Recipe et dans le cache des sources — et la Recipe elle-même est un fichier que vous commitez et pouvez publier. Un identifiant de connexion écrit dans l’URL voyagerait donc partout où voyage l’URL. Cette condition signale une source: de Recipe dont l’url écrit un utilisateur avant son hôte : https://user:token@host/…, ou un jeton écrit seul comme https://token@host/…, puisqu’un service joint par HTTP accepte couramment un jeton à la place de l’utilisateur. Sur http et https, tout utilisateur écrit à cet endroit compte ; sur un autre schéma, seul un mot de passe compte, car un utilisateur écrit seul à cet endroit désigne un compte — ssh://git@github.com/… est accepté, et l’agent SSH fournit sa clé. La source: d’une FeatureRecipe est soumise à la même règle.

Il est refusé à la lecture du document, avant que quoi que ce soit ne soit récupéré : la vérification de la Recipe seule le refuse, de même que chaque Release qui l’atteint, lors d’une validation, d’un pull, d’un pin ou d’un build. Le message désigne l’hôte et jamais l’identifiant de connexion. La vérification lit la partie de l’URL écrite avant l’hôte et rien d’autre ; un jeton porté dans une chaîne de requête ou un chemin n’est donc pas détecté — et il est enregistré tel qu’il est écrit, comme le reste de l’URL.

Message émis sur http ou https, qui désigne le document, la clé et l’hôte, puis l’endroit où l’identifiant de connexion doit figurer :

the source URL carries a credential (Recipe <name>:<version>, rule source-url, at <file>). spec.source.url names a user or password for host <host>; remove it from the URL and write the credential in the netrc file instead, as an entry “machine <host> login <user> password <secret>” (the file NETRC names, else .netrc in your home directory, or _netrc in %USERPROFILE% on Windows) (l’URL de source contient un identifiant de connexion (Recipe, règle source-url). spec.source.url désigne un utilisateur ou un mot de passe pour l’hôte ; retirez-le de l’URL et écrivez plutôt l’identifiant de connexion dans le fichier netrc, sous la forme d’une entrée « machine … login … password … » (le fichier que désigne NETRC, sinon .netrc dans votre répertoire personnel, ou _netrc dans %USERPROFILE% sous Windows))

et sur un autre schéma, où le remède consiste à retirer le mot de passe :

the source URL carries a credential (Recipe <name>:<version>, rule source-url, at <file>). spec.source.url names a password for host <host>; remove it from the URL, which is written into the lockfile and the cache as authored (l’URL de source contient un identifiant de connexion (Recipe, règle source-url). spec.source.url désigne un mot de passe pour l’hôte ; retirez-le de l’URL, qui est écrite dans le fichier de verrouillage et dans le cache telle qu’elle a été rédigée)

Comment corriger : retirez l’utilisateur et le mot de passe de l’url, en laissant l’URL qui désigne l’hôte. Pour une source récupérée par http ou https, placez l’identifiant de connexion dans une entrée machine pour cet hôte dans votre fichier netrc, que lit chaque récupération d’un dépôt classique de charts Helm, d’un fragment compose ou d’un dépôt Git par HTTP ou HTTPS — Authentification décrit quel fichier et quelle entrée. Pour un dépôt Git par SSH, l’agent SSH fournit la clé, et l’utilisateur peut rester. Si la Recipe a déjà été commitée ou publiée avec l’identifiant de connexion, celui-ci figure dans cet historique : changez-le également sur le serveur.

A {{ .parameters.* }} reference cannot be interpolated (Une référence aux paramètres ne peut pas être interpolée)

Le texte de l’Aggregate est évalué comme un template avant d’être lu comme un document, afin qu’une référence {{ .parameters.<key> }} soit remplacée par la valeur que la Release a fournie pour elle. Cet arrêt se déclenche lorsque cette évaluation ne peut pas aboutir : le texte ne s’analyse pas comme un template, ou il s’analyse et échoue pendant l’exécution.

L’interpolation a lieu avant que l’Aggregate soit analysé comme du YAML, c’est pourquoi une erreur à cet endroit est signalée sur l’Aggregate dans son ensemble plutôt que sur une clé qu’il contient — à ce stade, le document n’a pas encore de clés. C’est aussi pourquoi la référence peut rester sans guillemets : la substitution a lieu dans les octets bruts, et la règle de guillemets propre à YAML décide ensuite du type de la valeur ; une référence nue donne ainsi le type naturel de la valeur et une référence entre guillemets donne une chaîne.

Une référence désignant une clé que la Release n’a pas fournie n’est pas cet arrêt. Une clé absente se résout ici en une valeur vide et est interceptée, avec son type et son contrat, par les vérifications de paramètres décrites sous « Parameter type mismatch / contract violation (Type de paramètre non concordant / violation de contrat) » plus haut. Ce que signale cet arrêt, c’est un texte que le moteur de templates n’a pas pu traiter du tout — un {{ non fermé, un nom de fonction mal orthographié, un pipeline dont les étapes ne s’emboîtent pas. Lire un paramètre au moyen d’index — {{ index .parameters "db_size" }} — alors que la Release n’a fourni aucun paramètre de ce nom est un échec pendant l’exécution, et cet arrêt le porte, en désignant la clé : index s’arrête sur une clé de map que la map ne contient pas, sur chaque surface de template, comme le décrit « A template indexes a map with a key the map does not hold (Un template indexe une map avec une clé que la map ne contient pas) » plus bas.

Un texte qui ne s’analyse pas du tout est refusé en désignant le chemin propre de l’Aggregate, car ce fichier est disponible avant que quoi que ce soit ne le lise. Un module qu’importe la composition est évalué de la même manière un niveau plus bas, où son texte est lu depuis le catalogue au lieu d’être remis au build. L’arrêt est cette même condition et porte ce code dans les deux cas ; pour un module, il désigne aussi l’import qu’il suivait et le fichier depuis lequel le texte du module a été lu, et le message qu’il porte ne désigne que le type — la position que donne ce message est donc une position dans le texte propre du module, et non dans l’Aggregate dont vous êtes parti.

Messages émis, pour un template qui ne s’analyse pas, pour la même erreur dans un module qu’importe la composition, et pour un template qui échoue pendant l’exécution :

invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate <path>, “template parse error: <underlying reason>”) (référence de paramètre non valide : vérifiez que l’expression {{ .parameters.* }} désigne un paramètre déclaré et s’analyse comme un template Go (Aggregate, « erreur d’analyse du template »)) invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate, template parse error: <underlying reason>) (référence de paramètre non valide : vérifiez que l’expression {{ .parameters.* }} désigne un paramètre déclaré et s’analyse comme un template Go (Aggregate, erreur d’analyse du template)) invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate, template execution error: <underlying reason>) (référence de paramètre non valide : vérifiez que l’expression {{ .parameters.* }} désigne un paramètre déclaré et s’analyse comme un template Go (Aggregate, erreur d’exécution du template))

Le texte d’un Aggregate a une seule racine, .parameters ; une référence passant par une autre — {{ .values.app_token }} ou {{ $.values.app_token }} — ne lit donc rien et échoue pendant l’exécution. La raison commence alors par désigner la référence qu’elle a lue :

invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate, the template reads <reference>, and an Aggregate’s text defines no root but .parameters; template execution error: <underlying reason>) (référence de paramètre non valide : vérifiez que l’expression {{ .parameters.* }} désigne un paramètre déclaré et s’analyse comme un template Go (Aggregate, le template lit une référence, et le texte d’un Aggregate ne définit aucune racine autre que .parameters ; erreur d’exécution du template))

Comment corriger : ouvrez l’Aggregate et lisez la raison sous-jacente, qui désigne la position dans le texte et la construction qui a échoué. Vérifiez que chaque {{ a son }}, qu’une fonction que vous avez appelée fait partie de celles que la surface propose — l’interpolation de paramètres propose les fonctions de Sprig et rien d’autre, si bien que la fonction utilitaire optional n’est pas disponible ici — et que les étapes d’un pipeline acceptent ce que produit l’étape qui les précède. Si la raison désigne une clé qu’index n’a pas trouvée, lisez un paramètre éventuellement non défini avec un point ({{ .parameters.db_size }}) ou au moyen de get ou hasKey de Sprig. Si elle désigne une référence passant par une autre racine, déclarez la valeur comme paramètre de l’Aggregate et lisez-la sous la forme {{ .parameters.<key> }}. Si elle désigne quelque chose que vous n’avez jamais voulu comme template — undefined variable "$json" provenant d’une expression n8n, ou une fonction nommée d’après un nœud Flowise — le texte contient ses propres doubles accolades, y compris celles d’un commentaire : écrivez chaque {{ qu’il contient sous la forme {{"{{"}}, comme le décrit Texte qui contient ses propres doubles accolades.

The Release directory declares one Aggregate or Manifest twice (Le répertoire de la Release déclare deux fois un Aggregate ou un Manifest)

Une Release dont la référence aggregate: ou manifest: est une identité simple est résolue en examinant d’abord le répertoire propre de la Release, et cet examen a trouvé deux Aggregates — ou deux Manifests — portant le même metadata.name. Une référence par identité simple désigne une entité par ce nom, de sorte qu’un nom revendiqué deux fois est un nom dont le répertoire ne peut pas répondre.

L’examen refuse le répertoire dans son ensemble, et pas seulement le nom demandé par une référence. Il lit chaque Aggregate et chaque Manifest situé à côté de la Release, si bien qu’une paire en collision qu’aucune des deux références ne désigne arrête elle aussi le build : le répertoire est ambigu, que cette Release ait été ou non celle qui s’apprêtait à lire cette entité. Une référence écrite sous forme de chemin (./aggregate.yaml, ../shared/manifest.yaml) désigne un fichier plutôt qu’une entité et est résolue sans l’examen, de sorte qu’une Release dont aggregate: et manifest: sont tous deux des chemins ne l’exécute jamais.

Il s’agit de l’équivalent, dans le même répertoire, du refus d’identité dupliquée du catalogue, et les deux sont signalés séparément afin que le message nomme le répertoire dans lequel vous vous trouvez plutôt qu’un niveau du catalogue auquel vous ne pensiez peut-être pas.

Message émis :

duplicate Aggregate/Manifest identity (metadata.name) in the Release directory: Aggregate "<name>" declared more than once in <release-directory> (identité Aggregate/Manifest dupliquée (metadata.name) dans le répertoire de la Release : Aggregate déclaré plus d’une fois)

avec Manifest à la place de Aggregate lorsque deux Manifests entrent en collision.

Comment corriger : donnez à l’une des deux entités un metadata.name différent, ou sortez-la du répertoire de la Release. Deux Releases qui déploient réellement des Aggregates différents portant le même nom ont leur place dans des répertoires distincts ; copier une Release dans un fichier voisin sans renommer ce qu’elle contient est la façon habituelle dont ce cas survient.

A Release’s aggregate: or manifest: reference resolves to nothing (La référence d’une Release ne se résout en rien)

Une Release désigne un Aggregate ou un Manifest par identité simple et aucune entité de ce nom n’a été trouvée sur aucune des surfaces où une identité simple est recherchée : le répertoire propre de la Release, le catalogue et le registre.

Message émis, lorsque rien ne correspond nulle part :

aggregate/manifest reference unresolvable: no Aggregate named "<reference>" in the Release directory, catalog, or registry (référence aggregate/manifest non résoluble : aucun Aggregate de ce nom dans le répertoire de la Release, le catalogue ou le registre)

Un fichier du répertoire de la Release qui n’a pas pu être indexé modifie le rapport, car il modifie ce qui peut être affirmé honnêtement. Un tel fichier aurait pu être l’entité, aussi le message le dit-il plutôt que d’affirmer une absence qu’il ne peut pas établir, et il reprend l’échec d’analyse qui a empêché sa lecture :

aggregate/manifest reference unresolvable: Aggregate "<reference>" not found; unparseable file <path> could not be indexed and may be it: <parse failure> (référence aggregate/manifest non résoluble : Aggregate introuvable ; le fichier non analysable n’a pas pu être indexé et pourrait être celui-ci)

et lorsqu’un fichier non analysable est précisément celui que la référence désigne :

aggregate/manifest reference unresolvable: needed Aggregate "<reference>" is the unparseable file <path>: <parse failure> (référence aggregate/manifest non résoluble : l’Aggregate requis est le fichier non analysable)

Comment corriger : lorsque la référence est réellement absente, corrigez son orthographe — l’identité est le metadata.name de l’entité, pas son nom de fichier — ou ajoutez l’entité au répertoire de la Release ou au catalogue que lit le build. Lorsque le message nomme un fichier non analysable, corrigez d’abord ce fichier : son échec d’analyse est cité dans le message, et le réparer résout souvent la référence dans la même modification. Une référence ./ ou ../ est un chemin plutôt qu’une identité et est résolue comme tel, de sorte qu’un point initial change laquelle des deux erreurs vous cherchez.

A component is placed in more than one boundary (Un composant est placé dans plus d’une frontière)

L’arbre des frontières d’une Release place un composant dans deux frontières différentes. Les deux placements ne sont ni fusionnés ni classés, et ils ne peuvent pas l’être : la frontière d’un composant décide où sa sortie est écrite, dans quel sous-répertoire elle aboutit, à quelle sync wave il se joint, et quelles annotations et quelle infra de frontière il hérite — tandis que sa surface uses: par arête est lue par un parcours distinct. Un composant nommé deux fois tirerait l’emplacement de sa sortie d’un placement et sa configuration par arête de l’autre.

Une frontière place des composants de trois façons, et toutes trois comptent. En nommer un directement sous components:, par l’id qu’il porte une fois la composition terminée, le place. En nommer un dans le components: propre d’une entrée de routage, par le nom local qu’il porte dans ce sous-module, le place aussi. Et router un sous-module entier sous aggregates: place chaque composant que ce module contient. Cet arrêt couvre donc aussi un sous-module routé dans deux frontières, un module routé dans une frontière alors qu’un module imbriqué en lui est routé dans une autre, et un composant nommé dans une frontière alors que le module qui le contient est routé dans une frontière différente.

Router un module dans une frontière et nommer aussi l’un de ses composants sous cette même frontière n’est pas un conflit — les deux placements s’accordent sur l’endroit où le composant a sa place — et le build réussit. Un même id écrit deux fois sous une seule frontière est un conflit même dans ce cas : une entrée dans le components: de la frontière et une entrée pour ce même composant dans l’entrée de routage de la frontière sont deux entrées portant une configuration pour un seul composant, sans rien pour choisir entre elles.

Chaque placement fautif est signalé. Une Release qui place plusieurs composants deux fois s’arrête avec l’un de ces messages par entrée fautive dans un seul build, chacun à la clé de l’entrée qu’il conteste — de sorte que plusieurs d’entre eux ensemble forment un seul build nommant tout ce qu’il a trouvé, plutôt qu’une seule erreur écrite plusieurs fois.

Le placement qu’un message signale comme déjà en vigueur n’est pas toujours celui écrit en premier dans le fichier. Les entrées components: propres d’une frontière sont lues avant les composants que nomment ses entrées de routage et avant les sous-modules qu’elle route, et une frontière est lue avant les frontières imbriquées en elle ; les frontières écrites côte à côte sont lues dans l’ordre où elles apparaissent. Lorsque plusieurs placements antérieurs entrent en conflit, c’est le premier lu qui est nommé. Les deux emplacements sont nommés quel que soit leur ordre, et aucun n’est placé au-dessus de l’autre.

Message émis. La phrase énonce la règle ; ce qui suit nomme l’entrée fautive, la frontière où se trouve chacun des deux placements, le bloc dans lequel chacun a été écrit et le fichier qui les contient tous deux. Lorsqu’une entrée sous le components: d’une frontière rencontre une entrée antérieure sous celui d’une autre frontière :

component declared in more than one boundary: declare each component in exactly one boundary (Release <name>, at <field-path>, "<component>", named in the components block of boundary "<boundary-b>", while it is already named in the components block of boundary "<boundary-a>", that earlier entry naming "<component>", both declared in "<path>") (composant déclaré dans plus d’une frontière : déclarez chaque composant dans exactement une frontière (Release ; nommé dans le bloc components d’une frontière, alors qu’il est déjà nommé dans le bloc components d’une autre frontière ; tous deux déclarés dans le même fichier))

Les deux propositions qui nomment les frontières sont formulées selon le bloc dans lequel chaque entrée a été écrite. L’entrée fautive prend l’une des formes suivantes :

  • named in the components block of boundary "<boundary>" — la map components: propre de la frontière ;
  • named inside a routing entry in boundary "<boundary>" — la map components: d’une entrée de routage sous le aggregates: de cette frontière ;
  • routed as a sub-module into boundary "<boundary>" — l’entrée de routage elle-même.

Le placement antérieur, poursuivant la même phrase, prend l’une des formes suivantes :

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

Les deux propositions sont choisies indépendamment, de sorte que toute combinaison peut apparaître, et that earlier entry naming porte ce que désignait ce placement antérieur : l’id du composant, ou le préfixe du sous-module lorsque c’est un sous-module routé qui l’a placé.

Lorsque l’entrée fautive est elle-même une entrée de routage, ce qu’elle désigne est un sous-module plutôt qu’un composant unique, et le message le dit plutôt que de présenter un préfixe de module comme un nom de composant — ici en rencontrant un sous-module antérieur routé dans une autre frontière :

component declared in more than one boundary: declare each component in exactly one boundary (Release <name>, at <field-path>, sub-module "<module>", routed as a sub-module into boundary "<boundary-b>", while it is already placed by a sub-module routed into boundary "<boundary-a>", that earlier entry naming "<module>", both declared in "<path>") (composant déclaré dans plus d’une frontière : déclarez chaque composant dans exactement une frontière (Release ; sous-module routé comme sous-module dans une frontière, alors qu’il est déjà placé par un sous-module routé dans une autre frontière ; tous deux déclarés dans le même fichier))

Comment corriger : supprimez celui des deux placements que vous n’aviez pas voulu. Le message nomme les deux, le choix vous revient donc plutôt qu’au compilateur. Lorsqu’une déclaration directe et un module routé sont en désaccord, décidez si le composant appartient à son module ou existe seul : router le module le place avec tout ce que le module contient d’autre, et le nommer directement l’en sépare. Lorsque deux entrées de routage revendiquent un même module, supprimez le routage que vous n’aviez pas voulu — router un module dans une frontière y place chaque composant qu’il contient, si bien que deux entrées de ce type revendiquent le même ensemble de composants.

A Manifest annotation binding claims the reserved aggrega.ai/ prefix (Une liaison d’annotation du Manifest revendique le préfixe réservé)

Un Manifest déclare une liaison d’annotation sous une clé commençant par le préfixe nu aggrega.ai/. Ce préfixe est l’endroit où le build appose les clés qu’il émet lui-même, de sorte qu’une liaison revendiquant une clé à l’intérieur placerait votre routage et la propre sortie de la plateforme dans un même espace de clés, en concurrence pour les mêmes noms.

Il s’arrête, et ce ne pourrait pas être un avertissement. La réservation est tout ce qui fait de cet espace de clés celui de la plateforme ; admettre la liaison et la mentionner ensuite laisserait la collision dans le build.

La règle porte sur l’espace de clés que revendique une liaison écrite par l’auteur, de sorte qu’une clé pour laquelle le Manifest présenté ne déclare aucune liaison est ignorée plutôt que signalée — il n’y a aucune liaison qui puisse être en infraction.

Message émis. La clé fautive vient en tête, car c’est le sujet de la phrase, et les valeurs qui suivent sont chacune introduites par ce qu’elles sont :

manifest annotation binding uses reserved prefix (Manifest, at <field-path>, "<key>", reserved prefix "aggrega.ai/", routing to Feature "<feature-uri>", author the binding under a domain of your own such as "feature.<your-domain>/") (la liaison d’annotation du manifest utilise un préfixe réservé (Manifest ; préfixe réservé ; routage vers une Feature ; écrivez la liaison sous un domaine qui vous appartient))

Comment corriger : renommez la clé de liaison dans un espace de noms que vous contrôlez. Une clé à sous-préfixe est la forme prise en charge et n’est pas réservée : feature.aggrega.ai/… pour un raccourci de la bibliothèque standard, ou votre propre domaine — acme.aggrega.ai/…, compliance.example.com/… — pour un raccourci d’entreprise. Renommer la clé change ce qu’un auteur écrit sur un composant pour déclencher la liaison ; mettez donc à jour les annotations qui l’utilisent dans la même modification. Les clés propres de la plateforme sous le préfixe nu sont répertoriées dans ../providers/well-known-annotations.md.

Two Manifest annotation bindings compete for one routing slot (Deux liaisons d’annotation du Manifest se disputent un même emplacement de routage)

Deux liaisons d’annotation d’un même Manifest routent vers la même Feature, par le même pilier, au même chemin. Le rôle d’une liaison est d’indiquer où aboutit la valeur d’une annotation, et deux liaisons nommant une même destination laissent à la valeur deux routes et rien pour choisir entre elles au moment de l’expansion.

Une seule liaison peut déclarer une paire chemin-pilier donnée par Feature cible. Deux liaisons ciblant la même Feature à des chemins différents relèvent d’une écriture ordinaire et le build réussit ; de même pour deux liaisons routant le même chemin vers deux Features différentes.

Les liaisons sont parcourues dans l’ordre où le Manifest les déclare, de sorte que la liaison qu’un message nomme en premier est toujours la plus ancienne dans votre document.

Message émis :

manifest annotation bindings collide on same Feature path+pillar (Manifest, at <path>, annotation bindings "<first-key>" and "<second-key>" both target Feature "<feature-uri>" with path "<path>" routing to pillar "<pillar>"; only one binding may declare a given (path, pillar) pair per Feature) (les liaisons d’annotation du manifest entrent en collision sur le même chemin+pilier de Feature (Manifest ; les liaisons d’annotation ciblent toutes deux la Feature avec un chemin routant vers le pilier ; une seule liaison peut déclarer une paire (chemin, pilier) donnée par Feature))

Comment corriger : décidez quelle liaison possède la destination et retirez le chemin de la liste maps.infra ou maps.values de l’autre, ou supprimez entièrement la seconde liaison. Si les deux liaisons existent parce que vous vouliez que deux clés d’annotation atteignent un même champ de la Feature, conservez une liaison et faites passer les deux clés d’annotation par elle ; si elles existent parce que deux valeurs différentes devaient aboutir à deux endroits, corrigez le chemin écrit par erreur.

A Release reached resolution without passing through the load path (Une Release a atteint la résolution sans passer par le chemin de chargement)

Une Release est arrivée à la résolution en portant à la fois une surface components: de premier niveau non vide et une frontière default synthétisée. Cette combinaison ne peut pas être produite par une Release chargée normalement : le chemin de chargement replie un bloc components: de premier niveau dans la frontière par défaut et le vide, et un document qui a écrit les deux explicitement est refusé par son schéma avant d’arriver jusque-là.

Cet arrêt ne signale donc rien de ce que vous avez écrit. Il signale que quelque chose a atteint la résolution en contournant le chemin de chargement — le plus souvent une Release construite en mémoire par un programme qui embarque le compilateur plutôt que lue depuis un fichier — et il s’arrête là plutôt que de laisser un build se poursuivre sur un document dont les deux surfaces de composants sont en désaccord. Les lire dans un ordre ou dans l’autre produirait une sortie qui omet ou duplique silencieusement des composants, et le parcours des frontières et le parcours par arête ne seraient même pas d’accord entre eux sur lesquels.

Message émis :

release reached resolve un-normalized (non-empty root components alongside a synthesized default boundary): construct releases through the normalization core (types.NormalizeRelease via the load path), not a hand-built literal (la Release a atteint la résolution sans être normalisée (composants racine non vides à côté d’une frontière par défaut synthétisée) : construisez les Releases via le noyau de normalisation (types.NormalizeRelease via le chemin de chargement), et non avec un littéral construit à la main)

Comment corriger : rien, si vous écrivez du YAML — atteindre cet arrêt depuis aggrega build, aggrega validate ou l’éditeur signifie que le compilateur présente un défaut qui mérite d’être signalé, et la Release que vous construisiez n’est pas en cause. Si vous embarquez le compilateur et construisez une valeur Release dans votre propre code, construisez-la via le chemin de chargement plutôt que d’assembler directement la struct, afin que s’exécute la normalisation qui replie les composants racine dans la frontière par défaut.

A library reference expands into itself (Une référence de bibliothèque s’étend en elle-même)

Une chaîne de références entre documents revient à un document qu’elle a déjà atteint, de sorte que son expansion ne se terminerait jamais. Deux surfaces d’écriture atteignent la même condition, et toutes deux sont des chaînes entre entités de bibliothèque plutôt que quelque chose à l’intérieur d’un seul fichier : un $ref: depuis un pilier de schéma vers une entrée de SchemaLibrary qui, de référence en référence, revient en arrière, et un $import: vers une entrée de MappingLibrary ou de WorkloadLibrary qui fait de même.

La chaîne est comparée sur une clé canonique — l’identité de la bibliothèque et le nom de l’entrée, sans hôte de registre ni graphie de version — de sorte qu’un cycle ne peut pas échapper à la vérification en nommant la même entrée de deux façons différentes le long de son chemin. Une référence qui s’étend et se termine ne pose aucun problème, quel que soit le nombre de fois où elle apparaît et la profondeur de la chaîne ; la profondeur seule ne provoque jamais cet arrêt, et réutiliser une entrée de bibliothèque depuis de nombreux endroits est précisément l’usage pour lequel les bibliothèques existent.

Message émis, pour une chaîne $import:, qui nomme la boucle entière dans l’ordre où elle a été parcourue afin que vous voyiez quelle étape la ferme :

circular reference expansion: <Library>#/mappings/<entry> -> <Library>#/mappings/<entry> -> <Library>#/mappings/<entry> (expansion circulaire de références)

Une chaîne $ref: est signalée à la place par le compilateur de la forme compacte, qui l’encadre avec le document et le mot-clé qu’il lisait :

compactform at <consumer-file> (keyword "$ref"): circular cross-document $ref expansion: <Library>#/schemas/<entry> -> <Library>#/schemas/<entry> -> <Library>#/schemas/<entry> (compactform, mot-clé : expansion circulaire de $ref entre documents)

Comment corriger : lisez la chaîne dans le message et rompez-la à l’étape qui n’était pas voulue. Un cycle signifie généralement que deux entrées de bibliothèque ont chacune été écrites pour étendre l’autre ; regroupez la partie commune dans une troisième entrée à laquelle les deux font référence, ou intégrez-la dans l’une d’elles. La dernière étape affichée est celle qui a fermé la boucle, mais ce n’est pas nécessairement la mauvaise — la chaîne entière est imprimée précisément parce que le choix du maillon à couper vous revient.

La même condition sous-tend aussi le refus de récursion d’ancre documenté plus haut sous « YAML anchor aliased inside its own content (Ancre YAML référencée par un alias à l’intérieur de son propre contenu) ». Celui-là est une boucle à l’intérieur du texte propre d’un seul document ; celui-ci est une boucle entre documents. La chaîne du message distingue les deux d’un coup d’œil : une boucle entre documents nomme des entrées de bibliothèque, et une boucle à l’intérieur d’un document nomme une ancre.

A declared schema cannot be resolved (Un schéma déclaré ne peut pas être résolu)

Un schéma a atteint le moment d’être utilisé pour valider quelque chose et n’a pas pu du tout être assemblé en schéma. La cause la plus courante est un $ref: qui ne désigne rien de résoluble ; un schéma qui ne satisfait pas le méta-schéma JSON Schema aboutit au même arrêt, de même qu’une branche then: ou else: sous un mot-clé conditionnel qui ne peut pas être résolue à elle seule.

Le refus intervient avant que quoi que ce soit soit validé par rapport au schéma, et cet ordre est l’essentiel. Ignorer un schéma illisible laisserait non validé tout ce qu’il couvre pendant que le build signale un succès — une vérification qui a cessé de s’exécuter sans rien pour dire qu’elle s’est arrêtée.

Message émis, nommant la position dans le schéma, le mot-clé qui n’a pas pu être résolu et ce que la résolution a signalé :

validator/jsonschema: schema resolution failed (at <path-inside-the-schema>, keyword "<keyword>", <what resolution reported>) (validator/jsonschema : échec de la résolution du schéma (position, mot-clé))

Lorsque l’échec se situe à la racine du schéma plutôt qu’à un mot-clé qu’il contient, la position et le mot-clé sont omis et la phrase ne porte que la raison signalée.

Comment corriger : ouvrez le schéma à la position que nomme le message. Un $ref: est le coupable habituel : vérifiez que la cible existe, qu’une référence interne au document écrit exactement son chemin #/$defs/…, et qu’une référence entre documents nomme une entrée de SchemaLibrary que la fermeture des dépendances du build contient réellement. Lorsque le message nomme une branche then: ou else:, cette branche est un schéma à part entière et doit pouvoir être résolue par elle-même.

An x-aggrega-when: or x-aggrega-validate: predicate cannot be evaluated (Un prédicat ne peut pas être évalué)

Un schéma déclare l’un des deux mots-clés d’extension dont la valeur est un modèle, et le modèle n’a pas pu être utilisé : ce n’est pas une chaîne, il ne s’analyse pas comme un modèle, il a échoué à l’exécution, ou il a produit autre chose que true ou false.

x-aggrega-when: détermine si une branche conditionnelle d’un schéma s’applique ; x-aggrega-validate: détermine si une valeur satisfait une règle que les propres mots-clés du schéma ne peuvent pas exprimer. Les deux sont lus comme des verdicts, c’est pourquoi un résultat qui n’en est pas un est refusé plutôt qu’interprété : un prédicat produisant une chaîne vide serait lu comme faux et retirerait silencieusement la règle qu’il devait faire respecter.

Message émis :

validator/jsonschema: x-aggrega extension evaluation failed (at <path-inside-the-schema>, keyword "x-aggrega-validate", <what evaluation reported>) (validator/jsonschema : échec de l’évaluation de l’extension x-aggrega)

avec "x-aggrega-when" à la place du mot-clé lorsque c’est le prédicat de la condition qui est en faute, et la raison signalée nommant l’erreur du modèle — une position d’analyse, une fonction manquante, ou la valeur non booléenne que le modèle a produite.

Comment corriger : ouvrez le schéma à la position que nomme le message et lisez la raison signalée. Vérifiez que la valeur du mot-clé est une chaîne, que le modèle s’analyse et que chaque chemin qu’il parcourt existe réellement dans la valeur en cours de validation — un prédicat lit la valeur sous la forme .value, et chercher autre chose est l’erreur la plus courante. Si la raison nomme une clé que index n’a pas trouvée, testez plutôt la clé avec hasKey ou lisez-la avec get : index s’arrête sur une clé de map que la map ne contient pas, comme le décrit « A template indexes a map with a key the map does not hold (Un template indexe une map avec une clé que la map ne contient pas) » plus bas. Assurez-vous que le modèle se termine en produisant true ou false : une comparaison le fait, alors qu’un modèle qui se contente de produire la valeur ne le fait pas.

A Workload does not satisfy the Workload schema (Un Workload ne satisfait pas le schéma Workload)

Le bloc workload: d’une Recipe ou d’une FeatureRecipe a été lu et vérifié par rapport au schéma Workload, et un ou plusieurs champs ne le satisfont pas — une clé mal orthographiée, une valeur du mauvais type, un champ obligatoire omis, une valeur hors d’une plage ou d’une énumération déclarée.

Le rapport est groupé : un seul arrêt porte tous les champs en faute, de sorte qu’un Workload comportant quatre erreurs vous les signale toutes les quatre en un seul build plutôt qu’une par build. L’en-tête nomme le Workload, la Recipe qui le déclare et le fichier ; chaque constat en dessous nomme le chemin du champ dans le Workload, ce que le schéma y exigeait, et la correction lorsqu’elle peut être énoncée.

Message émis :

workload validation failed (Workload in Recipe <name>:<version>, at <path>, schema stage): .containers.<name>.<field>: <what the schema required> — <the fix, where one can be stated> .initContainers[<i>].<field>: <what the schema required> — <the fix, where one can be stated> (échec de la validation de la charge de travail (Workload dans la Recipe, étape du schéma))

Un échec sans détail par champ — le bloc n’a pas pu être lu du tout, plutôt que lu et jugé insuffisant — porte à la place la raison entière comme unique constat.

Lorsque le modèle workload: lit une valeur déclarée sensible, aucun constat ne cite de valeur. Il est impossible de savoir quel champ du document produit provient de cette valeur, donc chaque constat dont le texte pourrait contenir une valeur énonce la contrainte du schéma avec <redacted> à la place de la valeur, suivie d’un avis nommant la raison, et ne porte aucune correction dérivée de la valeur :

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

Un constat qui ne cite aucune valeur — une clé manquante, une clé que le Workload n’admet pas — se lit comme pour tout autre modèle. Voir vocabulary/compact-form-authoring.md « Ce qu’un refus dit d’une valeur déclarée ».

Le build signale l’arrêt sous une étiquette CATALOG_ERROR, car un bloc workload: est écrit par l’auteur de la Recipe et non par l’Aggregate ou la Release.

Comment corriger : ouvrez la Recipe aux chemins de champs indiqués et corrigez chacun d’eux. Les chemins sont donnés depuis la racine propre du Workload, donc .containers.main.health.ready est le bloc ready sous la clé health du conteneur main. Un conteneur nommé est désigné par sa clé et un conteneur d’initialisation par sa position, c’est pourquoi les deux se lisent différemment. Ce que chaque champ accepte se trouve dans la référence de rédaction du Workload.

Un champ que le schéma attend sous forme de texte, refusé parce que la valeur est un nombre ou un booléen, signifie presque toujours une expression de modèle sans guillemets. Un bloc workload: est rendu avant d’être vérifié, donc une expression écrite sans guillemets se développe en texte brut et YAML lit ensuite ce texte pour ce à quoi il ressemble. Une quantité de dimensionnement en cœurs entiers, une version composée uniquement de chiffres, un port, et les mots yes, no, on et off sont tous lus comme autre chose que du texte. Le constat indique quel type YAML a lu, et le remède consiste à mettre l’expression entre guillemets dans la Recipe — cpu: "{{ .infra.compute.cpu }}" plutôt que cpu: {{ .infra.compute.cpu }} — afin que la valeur reste du texte quoi que fournisse l’opérateur. Notez que la valeur de l’opérateur n’est pas en faute ici et que la mettre entre guillemets dans la Release ne change rien : les guillemets doivent se trouver dans la Recipe, autour de l’expression.

A Workload attachment names a slot the entity does not declare, or a delivery the slot forbids (Un rattachement de Workload nomme un emplacement que l’entité ne déclare pas, ou une livraison que l’emplacement interdit)

Une entrée attachments: d’un conteneur dans un bloc workload: fait référence à un emplacement de rattachement, et la référence ne correspond pas aux emplacements que le Component ou la Feature déclare dans son featuresSchema — ou, pour une entrée nommant une connexion avec connection:, aux emplacements que déclare le socket de cette connexion. Une entrée envFrom nommant une connexion est soumise aux mêmes règles de connexion. Le constat indique laquelle de ces formes vous avez.

  • L’emplacement n’est pas déclaré. Le from: de l’entrée nomme un emplacement que le featuresSchema de l’entité ne contient pas — une faute de frappe, ou un emplacement renommé d’un seul côté.
  • L’emplacement est en boîte noire. L’emplacement déclare une liste d’autorisation inject: vide, qui réserve la livraison à la mécanique interne de la Recipe. Un tel emplacement est rempli et consommé en interne, donc un Workload ne peut pas y accéder.
  • La livraison est hors de la liste d’autorisation de l’emplacement. Le as: de l’entrée nomme un mécanisme que la liste inject: de l’emplacement ne permet pas.
  • La connexion n’est pas l’une de celles que trace le composant. Le connection: de l’entrée nomme un alias sous lequel aucune connexion du composant n’est écrite.
  • Le socket de la connexion ne déclare pas l’emplacement. Le from: de l’entrée (ou, sur envFrom, secret:) nomme un emplacement que ne déclare pas le socket par lequel cette connexion est câblée.
  • L’emplacement est écrit sous son nom composé. Le from: (ou secret:) de l’entrée est le nom que prend le rattachement d’une connexion sur le composant — l’alias, un point et l’emplacement — écrit sans connection:. L’emplacement d’une connexion ne s’atteint qu’en nommant la connexion.

Toutes les entrées en faute de tous les conteneurs sont signalées ensemble, de sorte qu’un seul build les nomme toutes. Les constats sont groupés sous un en-tête unique nommant le Workload, sa Recipe et le fichier.

Message émis :

workload featuresSchema cross-check failed (Workload in Recipe <name>:<version>, at <path>, featuresSchema stage): .containers.<name>.attachments.<KEY>.from: references slot "<slot>" which is not declared in the Component’s featuresSchema — either declare the slot in the Component (or Feature) featuresSchema, or rename the reference to an existing slot .containers.<name>.attachments.<KEY>.from: slot "<slot>" is blackbox (no inject: allowlist) and cannot be referenced from a Workload attachments entry — blackbox slots are delivered by Recipe-internal plumbing; remove the Workload-side reference, or widen the slot’s inject allowlist if Workload-side delivery is intended .containers.<name>.attachments.<KEY>.as: delivery mechanism "<as>" is not permitted by slot "<slot>" (inject allowlist: [<mechanisms>]) — use one of the allowlisted delivery mechanisms ([<mechanisms>]), or widen the slot’s inject allowlist in the Component/Feature featuresSchema .containers.<name>.attachments.<KEY>.connection: names connection "<alias>" for slot "<slot>", but the component draws no connection under that alias — name a connection the component draws (<aliases>), or remove connection to read a slot the Component declares for its own attachments .containers.<name>.attachments.<KEY>.from: names slot "<slot>" of connection "<alias>", which socket "<socket>" does not declare — name a slot socket "<socket>" declares (<slots>), or declare the slot in that socket’s featuresSchema .containers.<name>.attachments.<KEY>.from: names "<alias>.<slot>", the name the compiler composes for slot "<slot>" of connection "<alias>"; a slot a connection’s socket declares is named by naming the connection — write connection: <alias> beside from: <slot> (échec du contrôle croisé du featuresSchema de la charge de travail (Workload dans la Recipe, étape featuresSchema) : fait référence à un emplacement non déclaré dans le featuresSchema du Component — déclarez l’emplacement dans le featuresSchema du Component (ou de la Feature), ou renommez la référence vers un emplacement existant ; l’emplacement est en boîte noire (aucune liste d’autorisation) et ne peut pas être référencé depuis une entrée attachments d’un Workload — les emplacements en boîte noire sont livrés par la mécanique interne de la Recipe ; supprimez la référence côté Workload, ou élargissez la liste d’autorisation inject de l’emplacement si une livraison côté Workload est voulue ; le mécanisme de livraison n’est pas permis par l’emplacement (liste d’autorisation inject) — utilisez l’un des mécanismes de livraison autorisés, ou élargissez la liste d’autorisation inject de l’emplacement dans le featuresSchema du Component/Feature ; nomme une connexion pour l’emplacement, mais le composant ne trace aucune connexion sous cet alias — nommez une connexion que trace le composant, ou supprimez connection pour lire un emplacement que le Component déclare pour ses propres rattachements ; nomme un emplacement de la connexion que le socket ne déclare pas — nommez un emplacement que déclare le socket, ou déclarez l’emplacement dans le featuresSchema de ce socket ; nomme le nom que le compilateur compose pour un emplacement d’une connexion ; un emplacement que déclare le socket d’une connexion se nomme en nommant la connexion — écrivez connection: à côté de from:)

Sur une entrée envFrom, les mêmes constats se trouvent à .containers.<name>.envFrom[<i>].connection et .containers.<name>.envFrom[<i>].secret.

Comment corriger : chaque constat nomme les deux côtés, le choix porte donc sur le côté à modifier. Pour un emplacement non déclaré, corrigez l’orthographe de from: ou déclarez l’emplacement dans le featuresSchema de l’entité — le suffixe .from du chemin du champ désigne la référence. Pour un emplacement en boîte noire, supprimez la référence côté Workload et laissez la Recipe livrer le matériau, à moins qu’une livraison côté Workload ne soit réellement voulue, auquel cas donnez à l’emplacement une liste d’autorisation inject:. Pour un mécanisme refusé, remplacez as: par l’un de ceux que nomme la liste d’autorisation, ou ajoutez-y le vôtre. Pour une connexion que le composant ne trace pas, corrigez l’alias en l’un de ceux que liste le constat, ou tracez la connexion dans l’Aggregate ou la Release. Pour un emplacement que le socket ne déclare pas, nommez l’un des emplacements que liste le constat, ou déclarez l’emplacement dans le featuresSchema du socket sur le Component. Pour un nom composé, écrivez la connexion et l’emplacement séparément, comme le montre le constat.

A Workload references a slot whose fill publishes no locator (Un Workload fait référence à un emplacement dont le remplissage ne publie aucun localisateur)

Une entrée attachments: d’un conteneur nomme un emplacement par référence, et le rattachement qui remplit cet emplacement ne publie pas les clés provides que lit une telle référence. Faire référence à un emplacement par son nom revient à demander que la ressource qu’il représente soit adressée dans la sortie produite — par le nom de la ressource, et par le champ qu’elle contient. Un remplissage qui ne publie ni l’un ni l’autre n’a aucun localisateur vers lequel pointer, donc la référence ne peut être transformée en rien.

Les clés requises dépendent de l’entrée, et le constat indique lesquelles il attendait. Une entrée qui nomme sa propre key: fournit elle-même le champ, donc seul le name de la ressource doit être publié — c’est ce qui lui permet de faire référence à une ressource à plusieurs clés. Une entrée qui ne nomme aucune key: lit l’unique champ publié de l’emplacement, donc name et key doivent tous deux être présents.

Le contrôle vérifie seulement si les clés sont présentes ; il n’inspecte jamais leurs valeurs. Toutes les entrées en faute sont signalées ensemble, sous un en-tête unique.

Message émis :

workload attachment slot is not referenceable (Workload in Recipe <name>:<version>, at <path>, slotReferenceability stage): .containers.<name>.attachments.<KEY>.from: slot "<slot>" is not referenceable: its resolved provides does not expose "<key>" (a workload attachment reference reads the provides keys name and key) — reference a slot filled by an attachment whose schema.provides declares the keys this reference reads, or deliver it through the slot’s inject pipe rather than a workload reference (l’emplacement de rattachement de la charge de travail n’est pas référençable (Workload dans la Recipe, étape slotReferenceability) : l’emplacement n’est pas référençable : ses provides résolus n’exposent pas la clé (une référence de rattachement de la charge de travail lit les clés provides name et key) — faites référence à un emplacement rempli par un rattachement dont le schema.provides déclare les clés que lit cette référence, ou livrez-le par le canal inject de l’emplacement plutôt que par une référence de la charge de travail)

Comment corriger : deux directions, et la bonne dépend de ce que vous vouliez dire. Si la référence est correcte, c’est le rattachement qui remplit l’emplacement qu’il faut changer : rattachez une Feature dont le schema.provides déclare name — et key, lorsque l’entrée n’en nomme pas elle-même — afin qu’il existe un localisateur vers lequel pointer. Si le matériau n’a jamais été destiné à être adressé par son nom dans la sortie, supprimez la référence et livrez-le plutôt par le canal inject: de l’emplacement, qui transporte la valeur plutôt qu’un pointeur vers l’endroit où elle se trouve.

A container gives one environment variable two values (Un conteneur donne deux valeurs à une même variable d’environnement)

Un conteneur d’un bloc workload: nomme deux fois la même variable d’environnement : une fois comme clé de ses variables, et une fois comme clé d’une entrée attachments livrée as: env. Un conteneur principal et un conteneur d’initialisation sont chacun vérifiés, aussi bien dans le Workload que rend la Recipe d’un composant que dans le Workload que rend une FeatureRecipe — celle rattachée à un composant comme celle déclarée à une frontière — et la vérification lit le Workload tel que son template l’a rendu.

Pourquoi le build s’arrête au lieu de choisir l’une des deux. L’environnement d’un conteneur est écrit à partir de ces deux collections dans un ordre fixe — les fournisseurs helm et compose écrivent d’abord chaque entrée lue depuis un rattachement, puis les simples variables après elles. Un nom écrit des deux façons atteindrait donc le processus avec la valeur que cet ordre fait gagner, ce qui découle de l’endroit où aboutissent les deux sortes d’entrées et non de ce que vous avez écrit ; le build refuse donc la paire au lieu d’en effectuer le rendu. La vérification s’exécute une seule fois, quel que soit le fournisseur qui rend le Workload, après les autres vérifications du Workload et avant que les entrées artifacts: soient évaluées ou que le Workload soit transmis à un fournisseur, de sorte qu’une paire refusée n’est jamais rendue. Une entrée attachments livrée as: file est montée comme fichier au lieu d’être définie dans l’environnement, elle ne forme donc jamais de paire.

La vérification ne compare que les noms ; elle ne lit jamais une valeur, si bien qu’aucun constat n’en cite une. Deux sortes d’entrées d’environnement échappent à ce qu’elle compare : une entrée envFrom définit les clés de la ConfigMap ou du Secret qu’elle nomme, qui ne sont pas connues au moment où le build s’exécute, et une entrée qu’une étape de pipeline écrit dans un document rendu ne fait pas partie du Workload que lit la vérification.

Chaque paire est un constat à part entière, positionné sur la clé workload: de la Recipe ou de la FeatureRecipe qui déclare le Workload, et nommant la variable et le conteneur — un conteneur principal par sa clé, un conteneur d’initialisation par sa place dans la liste initContainers. Les constats arrivent d’abord pour les conteneurs principaux, dans l’ordre où ils sont écrits, puis pour les conteneurs d’initialisation par position et, au sein d’un conteneur, dans l’ordre où ses entrées attachments sont écrites.

Message émis, pour une paire sur un conteneur principal du Workload d’une Recipe. La catégorie et le code court de cette condition, E0345, vous parviennent dans l’en-tête entre crochets, et la position se lit <path> at .spec.workload :

a container declares one environment variable twice ("<NAME>", container "<container>"). Rename one of the two, or write them under complementary template conditions so that only one of them renders (un conteneur déclare deux fois une même variable d’environnement. Renommez l’une des deux, ou écrivez-les sous des conditions de template complémentaires afin qu’une seule d’entre elles soit rendue)

Une paire sur un conteneur d’initialisation nomme plutôt sa place dans la liste — init container "initContainers[<i>]" — et le constat d’une FeatureRecipe nomme, après le conteneur, le rattachement qui la lie, attachment "<attachment>", car un composant peut porter plusieurs rattachements dont les FeatureRecipes sont des documents distincts.

Lorsqu’un Workload porte plusieurs paires, les constats sont regroupés sous une ligne qui nomme le document : containers of the Workload this Recipe renders name one environment variable twice ou, pour une FeatureRecipe, containers of the Workload rendered by the FeatureRecipe that attachment "<attachment>" binds name one environment variable twice.

Le build signale l’arrêt sous une étiquette CATALOG_ERROR, car un bloc workload: est écrit par l’auteur de la Recipe ou de la FeatureRecipe et non par l’Aggregate ou la Release.

Comment corriger : décidez laquelle des deux le conteneur doit recevoir. Si vous voulez les deux, renommez l’une d’elles, afin que le processus voie deux variables. Si ce sont des alternatives — une simple valeur de repli pour le cas où aucun identifiant de connexion n’est rattaché, par exemple — protégez-les par des conditions complémentaires afin qu’une seule exactement soit rendue : écrivez la variable sous {{ if not (hasKey (default dict .features) "<slot>") }} et l’entrée attachments sous {{ if hasKey (default dict .features) "<slot>" }}, ou sous les deux branches d’un même {{ if }}/{{ else }}. Une paire protégée de cette façon n’atteint jamais la vérification, car une seule des deux figure dans le Workload rendu.

A Release’s parameters: block is written in neither of its two shapes (Le bloc des paramètres d’une Release n’est écrit sous aucune de ses deux formes)

Une Release satisfait les paramètres déclarés par un Aggregate de l’une de deux façons, et le bloc est lu d’après sa forme. Soit c’est un mappage de noms de paramètres vers des valeurs écrites sur place, soit c’est un mappage d’exactement une clé, $import:, dont la valeur est le chemin d’un fichier YAML contenant ces valeurs. Un bloc qui n’est ni l’un ni l’autre est refusé à la lecture, avant que quoi que ce soit ne confronte les valeurs aux déclarations de l’Aggregate.

Trois formes sont refusées. Une valeur parameters: qui n’est pas du tout un mappage — un scalaire, ou une liste. Un mappage qui porte $import: à côté d’autres clés, ce qui demande à la fois les valeurs importées et les valeurs écrites sans donner de règle pour les combiner. Et un $import: dont la valeur n’est pas une simple chaîne, qui ne nomme donc aucun fichier.

Le schéma de la Release déclare les deux mêmes formes, de sorte qu’un fichier de Release qui porte l’une des trois rencontre d’abord le contrôle de l’enveloppe du document, sous E0215, qui essaie les deux formes et indique pourquoi chacune a échoué — ici pour une liste :

document envelope validation failed (Release, at <path>); <line>:<column>: spec.parameters: no oneOf branch matched (2 branches tried): branch[0]: type: expected object, got array; branch[1]: type: expected object, got array. correct the document to match its kind’s schema (échec de la validation de l’enveloppe du document (Release) ; spec.parameters : aucune branche oneOf ne correspond (2 branches essayées) : branch[0] : type : object attendu, array obtenu ; branch[1] : type : object attendu, array obtenu. corrigez le document pour qu’il corresponde au schéma de son type)

Pour $import: à côté d’une autre clé, la seconde branche se termine par additionalProperties: unexpected property: "<key>", et pour un $import: écrit comme une liste plutôt que comme une chaîne, elle se termine par validation: type: array has type "array", want "string".

Message émis, lorsque la valeur n’est pas un mappage, nommant ce qui y a été écrit — a list, par exemple :

parameters: shape must be an inline object or {$import: }: line <line>: <shape> is written where a map is expected (parameters : la forme doit être un objet en ligne ou {$import: chemin local} : à la ligne indiquée, une valeur est écrite là où un mappage est attendu)

et lorsque $import: partage le mappage avec autre chose, ou nomme quelque chose qui n’est pas un chemin :

parameters: shape must be an inline object or {$import: }: $import: must be the only key (got <n> keys) at line <line> (parameters : la forme doit être un objet en ligne ou {$import: chemin local} : $import doit être la seule clé, plusieurs clés trouvées à la ligne indiquée) parameters: shape must be an inline object or {$import: }: $import value must be a string scalar at line <line> (parameters : la forme doit être un objet en ligne ou {$import: chemin local} : la valeur de $import doit être un scalaire de type chaîne à la ligne indiquée)

Comment corriger : ouvrez la Release à la ligne que nomme le message. Écrivez les valeurs sur place sous parameters:, ou remplacez tout le bloc par une seule entrée $import: dont la valeur est un chemin entre guillemets. Si vous vouliez des valeurs écrites et un fichier importé de valeurs par défaut partagées, déplacez les valeurs écrites dans une Release qui étend par extends: celle qui contient l’import — superposer plusieurs sources de paramètres est précisément le rôle d’une chaîne extends:, et cette clé unique est lue depuis une seule source par conception.

An inline-or-import field is written in neither shape (Un champ « en ligne ou import » n’est écrit sous aucune des deux formes)

Trois champs qu’écrit une Recipe ou une FeatureRecipe — une entrée artifacts.<name>:, un valuesMapping: et un workload: — acceptent les deux mêmes formes. Soit le corps est écrit sur place, comme scalaire de type chaîne (un bloc | est l’écriture habituelle pour tout ce qui tient sur plusieurs lignes), soit la valeur est un mappage d’exactement une clé, $import:, qui nomme plutôt l’endroit où se trouve le corps. Ce qu’un $import: peut nommer diffère selon le champ : une entrée artifacts importe un chemin local ou un bundle tiré d’une ArtifactLibrary, tandis que valuesMapping: et workload: importent un chemin local ou une entrée tirée d’une bibliothèque désignée par son identité.

Un seul lecteur vérifie les trois, de sorte que les refus sont les trois mêmes quel que soit le champ en faute : un mappage qui porte plus d’une clé, un mappage dont l’unique clé n’est pas $import, et un $import: dont la valeur n’est pas une simple chaîne. Une valeur qui n’est ni un scalaire ni un mappage — une liste, le plus souvent — est refusée sur sa seule forme.

Les schémas de la Recipe et de la FeatureRecipe déclarent les deux mêmes formes pour chacun des trois champs, de sorte qu’un fichier qui porte l’un de ces cas rencontre d’abord le contrôle de l’enveloppe du document, sous E0215, qui nomme le champ et indique pourquoi chaque forme a échoué — la première branche est la forme écrite sur place, la seconde celle avec $import: :

document envelope validation failed (Recipe, at <path>); <line>:<column>: spec.artifacts.<name>: no oneOf branch matched (2 branches tried): branch[0]: validation: type: object has type “object”, want “string”; branch[1]: additionalProperties: unexpected property: “<key>”. correct the document to match its kind’s schema (échec de la validation de l’enveloppe du document (Recipe) ; spec.artifacts : aucune branche oneOf ne correspond (2 branches essayées) : branch[0] : validation : type : object a le type « object », « string » attendu ; branch[1] : additionalProperties : propriété inattendue. corrigez le document pour qu’il corresponde au schéma de son type)

C’est un mappage qui porte une clé à côté de $import:. Une clé unique qui n’est pas $import se termine par required: missing required property: $import, additionalProperties: unexpected property: "<key>", une liste se termine par type: expected object, got array, et un $import: qui n’est pas une chaîne nomme le type trouvé là où une chaîne était attendue, comme dans type: array has type "array", want "string".

Messages émis. Chacun s’ouvre sur la phrase propre au champ en faute, puis indique ce que le lecteur a trouvé et où :

artifacts entry: shape must be a string scalar or {$import: }: got <n> keys at line <line> (entrée artifacts : la forme doit être un scalaire de type chaîne ou {$import: chemin local} : plusieurs clés trouvées à la ligne indiquée) valuesmapping: shape must be a string scalar or {$import: }: got key "<key>" at line <line> (valuesmapping : la forme doit être un scalaire de type chaîne ou {$import: chemin ou identité de bibliothèque} : une autre clé trouvée à la ligne indiquée) workload: shape must be a string scalar or {$import: }: $import value must be a string scalar at line <line> (workload : la forme doit être un scalaire de type chaîne ou {$import: chemin ou identité de bibliothèque} : la valeur de $import doit être un scalaire de type chaîne à la ligne indiquée)

Chacun des trois champs peut signaler n’importe laquelle de ces fins ; une valeur qui n’a aucune des deux formes se termine par line <line>: <shape> is written where text or a map is expected, en nommant ce qui a été écrit — a list, le plus souvent.

Comment corriger : ouvrez l’entité à la ligne que nomme le message. Écrivez le corps sur place comme scalaire de bloc, ou remplacez toute la valeur par une seule entrée $import:. Un mappage qui porte $import: et quoi que ce soit d’autre n’est pas l’une des deux formes — déplacez les clés supplémentaires dans le fichier importé, ou écrivez le corps sur place. Un $import mal orthographié — il manque le $, le plus souvent — se lit comme une clé ordinaire et est signalé comme la clé unique qui n’est pas $import.

A reference to a library entry carries whitespace (Une référence à une entrée de bibliothèque contient des espaces blancs)

Une référence qui nomme une entrée à l’intérieur d’une bibliothèque s’écrit comme un seul jeton ininterrompu : la bibliothèque, une version minimale :<version> facultative, puis # et le chemin de l’entrée — BaseWorkloads:1.0.0#/workloads/StatelessService. Aucune de ses parties n’admet d’espace blanc. Les noms de bibliothèques et les noms d’entrées sont tous deux limités par les schémas de bibliothèque à des graphies d’identifiant, et une version est une version, de sorte qu’une espace, une tabulation ou un saut de ligne où que ce soit dans une référence n’appartient à aucune des trois parties.

Le refus couvre chaque surface qui désigne une entrée de bibliothèque par son identité : un valuesMapping:, un workload: et une entrée artifacts.<name>: écrits sous la forme $import:, ainsi qu’un $ref: de schéma. Un chemin local écrit sous la forme $import: ne contient pas de # et n’est pas une référence à une entrée de bibliothèque, de sorte qu’un chemin contenant une espace n’est pas touché.

Ce qui justifie de refuser plutôt que de nettoyer, c’est que la partie initiale d’une telle valeur est généralement une référence à part entière. Couper à l’espace blanc résoudrait cette référence et écarterait discrètement le reste de ce que l’auteur a écrit — et les deux moitiés d’un build ne sont pas tenues d’en écarter autant, si bien que l’une pourrait enregistrer une dépendance que l’autre n’a jamais vue. Refuser fait que la valeur signifie une seule chose.

Le refus est signalé à la ligne du document dont la référence a été lue :

library reference: a reference to a library entry carries no whitespace or line break: $import target "<reference>" at line <line> (référence de bibliothèque : une référence à une entrée de bibliothèque ne contient ni espace blanc ni saut de ligne : cible de $import à la ligne indiquée)

Une référence atteint un build depuis un autre endroit encore : le corps d’une entrée de bibliothèque qu’un build a déjà résolue, où un $import: à la racine du champ, sur la première ligne, pointe vers l’entrée d’une autre bibliothèque. Cette référence n’a jamais été lue depuis un document que le build a ouvert, elle est donc signalée sans ligne :

library reference: a reference to a library entry carries no whitespace or line break: "<reference>" (référence de bibliothèque : une référence à une entrée de bibliothèque ne contient ni espace blanc ni saut de ligne)

Comment corriger : ouvrez l’entité à la ligne que nomme le message et resserrez la référence pour qu’elle forme un seul jeton. Un saut de ligne avant le # en est la cause habituelle — une référence coupée sur deux lignes pour tenir dans une colonne se lit comme une seule valeur pour YAML et comme une référence cassée ici ; écrivez-la donc sur une seule ligne, quelle que soit sa longueur. L’autre cause est une espace finale avant le guillemet fermant : elle se retrouve dans la version minimale, où elle nomme une version qu’aucun artefact publié ne porte. Pour la seconde forme, la référence se trouve dans la bibliothèque nommée juste avant elle dans le message ; corrigez-la là où cette bibliothèque déclare l’entrée.

A library entry’s body is not the shape that library holds (Le corps d’une entrée de bibliothèque n’a pas la forme que contient cette bibliothèque)

Une bibliothèque publie des corps nommés que d’autres entités peuvent importer, et chaque sorte de bibliothèque contient une seule forme. Une entrée de MappingLibrary et une entrée de WorkloadLibrary contiennent chacune un corps de template, si bien que la valeur de l’entrée est un scalaire — un bloc |, en pratique. Une entrée d’ArtifactLibrary contient un bundle : les fichiers qui vont ensemble sous un même nom, si bien que l’entrée est un mappage du nom de fichier de sortie vers le corps de ce fichier, et chaque corps qu’elle contient est un scalaire.

Les corps sont capturés exactement tels qu’ils sont écrits et ne sont pas analysés au chargement de la bibliothèque. Le template qu’un corps contient est analysé là où il est importé, c’est pourquoi seule la forme est vérifiée ici — un corps qui n’est pas du tout un template se charge sans erreur et échoue à l’endroit où quelque chose en effectue le rendu.

Messages émis, chacun nommant la ligne et ce qui y a été écrit — a list, par exemple :

mappinglibrary: entry body must be a string scalar: line <line>: <shape> is written where text is expected (mappinglibrary : le corps de l’entrée doit être un scalaire de type chaîne : à la ligne indiquée, une valeur est écrite là où du texte est attendu) workloadlibrary: entry body must be a string scalar: line <line>: <shape> is written where text is expected (workloadlibrary : le corps de l’entrée doit être un scalaire de type chaîne : à la ligne indiquée, une valeur est écrite là où du texte est attendu) artifactlibrary: entry must be a mapping of filename to a string body: line <line>: <shape> is written where a map is expected (artifactlibrary : l’entrée doit être un mappage du nom de fichier vers un corps de type chaîne : à la ligne indiquée, une valeur est écrite là où un mappage est attendu)

et, pour un bundle dont l’entrée est un mappage mais dont l’un des fichiers n’est pas un scalaire, en nommant le fichier :

artifactlibrary: entry must be a mapping of filename to a string body: file "<filename>": line <line>: <shape> is written where text is expected (artifactlibrary : l’entrée doit être un mappage du nom de fichier vers un corps de type chaîne : dans le fichier et à la ligne indiqués, une valeur est écrite là où du texte est attendu)

Le build les signale sous une étiquette CATALOG_ERROR qui nomme le fichier qu’il lisait, avec la phrase ci-dessus en dessous.

Comment corriger : écrivez le corps comme scalaire de bloc sous sa clé. Un corps dont la première ligne ressemble à une clé YAML — ce qui est généralement le cas d’un template produisant du YAML — est lu comme un mappage imbriqué si le scalaire de bloc est absent, et c’est la cause courante. Pour une ArtifactLibrary, écrivez une clé par nom de fichier de sortie, avec chaque corps comme scalaire de bloc distinct ; un bundle écrit comme un seul corps est l’autre erreur de forme courante.

A $instantiate: reference cannot be resolved (Une référence ne peut pas être résolue)

Une SchemaLibrary peut déclarer des structures réutilisables sous spec.templates, chacune avec ses propres $params, et une entrée de schéma en instancie ensuite une en la nommant sous $instantiate: et en fournissant ses paramètres sous $args:. La substitution est littérale : un scalaire $<name> dans le corps du modèle est remplacé par la valeur de l’argument. Il n’y a ni évaluation d’expressions, ni condition, ni boucle, et une valeur substituée est insérée telle quelle au lieu d’être parcourue à la recherche d’autres marqueurs.

Trois fautes entraînent le refus de l’instanciation. Le nom sous $instantiate: n’est pas l’un de ceux que la bibliothèque déclare. Un paramètre que le modèle déclare sans default: n’a aucune entrée sous $args:. Ou bien la valeur d’un argument n’est pas du type que son paramètre déclare — et une clé de $args: qui ne nomme aucun paramètre déclaré est signalée de la même manière, au lieu d’être ignorée, de sorte qu’un nom d’argument mal orthographié constitue un refus plutôt qu’un paramètre qui prend silencieusement sa valeur par défaut.

Messages émis :

schemalibrary: template not found: "<template-name>" not declared in spec.templates (schemalibrary : modèle introuvable : non déclaré dans spec.templates) schemalibrary: template parameter missing: "<parameter-name>" (template "<template-name>") (schemalibrary : paramètre de modèle manquant) schemalibrary: template parameter type mismatch: <what the type check found> (schemalibrary : type de paramètre de modèle incompatible) schemalibrary: template parameter type mismatch: argument "<argument-name>" is not declared in template "<template-name>"’s $params (schemalibrary : type de paramètre de modèle incompatible : l’argument n’est pas déclaré dans les $params du modèle)

Comment corriger : pour un modèle introuvable, corrigez le nom en l’un de ceux que la bibliothèque déclare sous spec.templates — et vérifiez que vous importez la bibliothèque voulue. Pour un paramètre manquant, ajoutez-le à $args:, ou donnez au paramètre un default: dans le modèle afin que les appelants puissent l’omettre. Pour une incompatibilité de type, changez l’argument pour le type déclaré ou élargissez le type: du paramètre ; lorsque le message nomme un argument non déclaré, corrigez son orthographe ou supprimez-le.

A schema uses a JSON Schema keyword the library does not admit (Un schéma utilise un mot-clé JSON Schema que la bibliothèque n’admet pas)

$dynamicAnchor et $dynamicRef ne sont pas admis dans le contenu d’une SchemaLibrary. Ils reportent le choix du schéma vers lequel une référence se résout jusqu’au moment où la valeur est validée, ce qui fait dépendre le sens d’une entrée de bibliothèque de l’endroit d’où elle a été importée plutôt que de ce qu’elle dit — et le compilateur résout les structures d’une bibliothèque avant toute validation, il n’y a donc rien contre quoi une référence différée pourrait se résoudre.

Le refus est appliqué en trois points, qui ferment ensemble les deux voies par lesquelles le mot-clé pourrait arriver. Une entrée de schéma est analysée au chargement de la bibliothèque. Le corps d’un modèle est analysé au chargement de la bibliothèque, de sorte qu’un modèle qui contient littéralement le mot-clé échoue à ce moment-là plutôt qu’au premier build qui l’instancie. Et le corps substitué est analysé de nouveau après une instanciation, de sorte que fournir le mot-clé comme valeur d’argument ne permet pas de passer les deux premiers contrôles.

Message émis :

schemalibrary: forbidden JSON Schema keyword: "$dynamicRef" at line <line> (schemalibrary : mot-clé JSON Schema interdit, à la ligne indiquée)

Comment corriger : remplacez la référence différée par un $ref qui nomme directement une entrée de $defs. Lorsque la structure varie réellement d’un usage à l’autre, exprimez la variation sous forme de modèle avec $params et instanciez-le pour chaque usage — c’est la substitution que cette surface offre, et elle se résout avant que quoi que ce soit ne soit validé par rapport au résultat.

A document nests deeper than the reader will descend (Un document est imbriqué plus profondément que le lecteur ne descend)

Chaque mappage écrit par l’auteur est lu dans une structure qui préserve l’ordre dans lequel ses clés ont été écrites, car cet ordre atteint la sortie rendue et fait partie de ce qui rend un build identique octet pour octet d’une exécution à l’autre. Ce lecteur descend sur un nombre limité de niveaux — cent — et refuse d’aller plus loin, de sorte qu’une entrée qui épuiserait sinon la propre pile du lecteur est signalée comme le refus qu’elle est.

Message émis :

a document nests too many levels deep: it is read at most 100 levels deep (un document est imbriqué sur trop de niveaux : il est lu sur 100 niveaux de profondeur au plus)

Comment corriger : les documents réellement écrits par un auteur s’imbriquent sur quelques niveaux, donc un document qui en atteint cent est généré, traduit automatiquement ou accidentellement autoréférentiel. Cherchez une valeur qui s’est développée en elle-même — une ancre YAML qui référence le contenu dans lequel elle se trouve est refusée par son propre arrêt ci-dessus, mais un générateur qui émet la même structure de façon répétée ne l’est pas. Lorsque la profondeur est réelle, déplacez la branche profonde dans une entité à part et référencez-la par son nom.

A provider declares a well-known annotation at a scope it does not render (Un fournisseur déclare une annotation well-known à une portée dont il ne fait pas le rendu)

Un Plugin qui sert un fournisseur dit de lui-même deux choses qui doivent concorder. Sous spec.provider.wellKnownAnnotations, il liste les annotations sur lesquelles il agit, chacune avec les portées auxquelles il les lit. Sous contract.inputKinds, il indique les types d’entrée dont il fait le rendu. Une clé déclarée à une portée dont la même entité ne revendique pas le type d’entrée, ce sont ces deux déclarations qui se contredisent dans un même fichier, donc l’entité est refusée à son chargement.

La vérification est une comparaison de l’entité avec elle-même, c’est pourquoi elle ne nécessite aucun binaire de plugin et se déclenche partout où l’entité est lue — y compris lors d’un parcours du catalogue sur une machine qui n’a jamais récupéré l’artefact.

Deux entrées ne sont délibérément pas comparées. Une entrée de portée frontière ne nomme aucun type d’entrée, car elle est résolue une seule fois pour toute une frontière plutôt que sur le chemin de rendu d’un nœud donné. Une entrée qui ne déclare aucune portée ne fait aucune affirmation par chemin : elle dit seulement que le plugin lit la clé quelque part.

Ce que le refus n’établit pas, c’est qu’une déclaration laissée en place soit vraie. Rien ne peut prouver que le plugin qui sert un fournisseur lit une clé qu’il dit lire ; ce qu’une comparaison de deux champs écrits par l’auteur peut faire, c’est refuser la paire qui ne peut pas être vraie dans ses deux termes. Une clé déclarée à une portée dont le fournisseur fait effectivement le rendu, mais dont le plugin ne lit rien à cet endroit, passe ici.

Message émis :

provider "<plugin-name>" declares well-known annotation "<key>" at scope "<scope>", but its contract.inputKinds.<field> is not claimed; declare the key only at a scope the provider renders, or claim the input kind: wellKnownAnnotations: a key is declared at a scope the provider’s contract does not render (le fournisseur déclare une annotation well-known à une portée, mais son contract.inputKinds n’est pas revendiqué ; déclarez la clé uniquement à une portée dont le fournisseur fait le rendu, ou revendiquez le type d’entrée : wellKnownAnnotations : une clé est déclarée à une portée dont le contrat du fournisseur ne fait pas le rendu)

Comment corriger : le message nomme les deux moitiés. Retirez cette portée de la liste scope: de l’annotation, en laissant les portées dont le fournisseur fait effectivement le rendu, ou revendiquez le type d’entrée sous contract.inputKinds si le fournisseur en fait réellement le rendu.

A compact-form schema uses a keyword the compact form does not know (Un schéma en forme compacte utilise un mot-clé que la forme compacte ne connaît pas)

Un schéma écrit en forme compacte contient une clé qui n’est ni un mot-clé de la forme compacte, ni l’un des mots-clés JSON Schema que la forme transmet tels quels, ni l’un des trois marqueurs que la forme réserve — $jsonschema:, $mode: et $ref:. Les clés inconnues sont refusées à la lecture du schéma au lieu d’être écartées, car une contrainte mal saisie qui est ignorée ne devient aucune contrainte du tout, et un schéma qui semble appliqué et n’applique rien est pire qu’un schéma qui échoue.

Le refus se rencontre partout où un schéma est compilé. Les entrées d’une SchemaLibrary sont compilées au chargement du catalogue ; le spec.schema d’un Component, ses valueSchema et infraSchema par socket, et les schémas que déclarent une Feature et un Plugin fournisseur sont compilés à la lecture du catalogue. Le spec.schema d’un Component ou d’une Feature signale lui-même cette condition, en nommant l’entité et le champ ; le valueSchema ou l’infraSchema d’un socket la signale à l’intérieur de « A declared schema contract cannot be read as a schema (Un contrat de schéma déclaré ne peut pas être lu comme un schéma) » plus bas, avec la phrase citée ici comme détail.

La phrase propre au compilateur de la forme compacte nomme la position à l’intérieur du schéma, la ligne source et la clé qu’il n’a pas reconnue :

compactform at <path-inside-the-schema>:<line> (keyword "<key>"): unknown keyword (compactform : mot-clé inconnu)

Une clé écrite à côté d’un $ref: inter-documents est signalée sous la même condition, avec une phrase qui lui est propre, car seules trois clés sœurs peuvent accompagner une telle référence :

compactform at <path-inside-the-schema>:<line> (keyword "<key>"): cross-document $ref sibling not allowed (allowed: properties, required, description) (compactform : clé sœur d’un $ref inter-documents non autorisée (autorisées : properties, required, description))

et lorsque cette clé sœur demandait de rouvrir la structure fusionnée, la phrase indique plutôt la manière de le faire :

compactform at <path-inside-the-schema>:<line> (keyword "additionalProperties"): cross-document $ref sibling not allowed (allowed: properties, required, description); use $jsonschema: to embed an open-object schema if the merged shape must accept arbitrary properties (compactform : clé sœur d’un $ref inter-documents non autorisée (autorisées : properties, required, description) ; utilisez $jsonschema: pour incorporer un schéma d’objet ouvert si la structure fusionnée doit accepter des propriétés arbitraires)

La condition sous laquelle elle est enregistrée est compactform: unknown keyword, ce vers quoi son code court se résout.

Comment corriger : corrigez la clé à la position que la phrase nomme, en vous référant au vocabulaire des mots-clés dans compact-form-authoring.md — une faute de frappe est la cause la plus courante. Lorsque la structure a réellement besoin d’un mot-clé JSON Schema que la forme compacte ne contient pas, écrivez ce fragment sous $jsonschema:, qui incorpore du JSON Schema tel quel. À côté d’une référence inter-documents, ne gardez que properties:, required: et description: ; tout le reste appartient à l’entrée de bibliothèque vers laquelle pointe la référence.

A compact-form schema declares a field literally named type (Un schéma en forme compacte déclare un champ portant littéralement ce nom)

La forme compacte décide de ce que signifie un mappage d’après la structure de son contenu : une clé type: marque une feuille de contrainte, les mots-clés structurels de JSON Schema marquent un fragment à transmettre tel quel, et un mappage de noms simples marque un objet dont les enfants sont des schémas. Un schéma qui déclare un champ nommé type est la seule structure que ces lectures ne peuvent pas distinguer — il ressemble à une feuille de contrainte et se veut un objet à un seul champ —, donc la forme demande à l’auteur de dire laquelle, avec une clé $mode: définie à compact ou jsonschema.

Cette condition est ce que signale un $mode: écrit avec toute autre valeur. Le marqueur existe pour lever l’ambiguïté, donc une valeur qui ne lève rien est refusée plutôt que devinée.

La phrase propre au compilateur de la forme compacte :

compactform at <path-inside-the-schema>:<line> (keyword "$mode"): value must be compact or jsonschema (compactform : la valeur doit être l’une des deux indiquées)

La condition sous laquelle elle est enregistrée est compactform: ambiguous dispatch — $mode required, ce vers quoi son code court se résout.

Comment corriger : définissez $mode: compact lorsque le mappage est un objet en forme compacte dont l’un des champs s’appelle justement type, ou $mode: jsonschema lorsque le mappage est un fragment JSON Schema à prendre tel qu’il est écrit. Lorsqu’aucune des deux lectures n’était voulue, renommer le champ lève l’ambiguïté sans aucun marqueur.

A $jsonschema: escape carries content that is not a schema (Un échappement contient un contenu qui n’est pas un schéma)

La clé $jsonschema: incorpore tel quel un fragment JSON Schema, pour les structures que la forme compacte n’exprime pas. Ce qu’elle incorpore est pris tel qu’il est écrit et n’est jamais traduit, il doit donc être un schéma : un scalaire de bloc qui s’analyse comme du YAML, ou un mappage imbriqué. Un contenu qui n’est ni l’un ni l’autre est refusé ici au lieu d’être transmis pour servir de base à une validation, où l’échec serait signalé contre le consommateur du schéma plutôt que contre le schéma.

Quatre structures sont signalées sous cette condition, et la phrase vous dit laquelle vous avez. Le corps d’échappement ne s’analyse pas comme du YAML. La valeur de l’échappement n’est ni un scalaire de bloc ni un mappage. Une clé properties: contient quelque chose qui n’est pas un mappage de noms vers des schémas. Et, au niveau le plus externe, le document transmis au compilateur est vide ou contient un nœud pour lequel le lecteur n’a aucune règle.

Les phrases propres au compilateur de la forme compacte :

compactform at <path-inside-the-schema>:<line> (keyword "$jsonschema"): escape content does not parse as YAML: <what the parse reported> (compactform : le contenu de l’échappement ne s’analyse pas comme du YAML) compactform at <path-inside-the-schema>:<line> (keyword "$jsonschema"): expected block-scalar string or nested mapping (compactform : chaîne en scalaire de bloc ou mappage imbriqué attendu) compactform at <path-inside-the-schema>:<line> (keyword "properties"): expected a mapping of property names to schemas (compactform : mappage de noms de propriétés vers des schémas attendu) compactform: unsupported YAML node kind (compactform : type de nœud YAML non pris en charge)

La condition sous laquelle elle est enregistrée est compactform: $jsonschema content invalid, ce vers quoi son code court se résout.

Comment corriger : écrivez le corps d’échappement comme scalaire de bloc sous $jsonschema: — sinon, un corps dont la première ligne se lit comme une clé YAML est absorbé dans le mappage environnant, ce qui est la cause courante — et vérifiez que ce qu’il contient est un JSON Schema valide en soi. Lorsque le fragment était assez petit pour s’exprimer en forme compacte, supprimer l’échappement est la réponse la plus simple.

A compact-form constraint does not apply to the type it was written on (Une contrainte en forme compacte ne s’applique pas au type sur lequel elle a été écrite)

Les contraintes en forme compacte sont réparties selon le type déclaré du champ : min: et max: deviennent une borne numérique sur un nombre, une borne de longueur sur une chaîne et une borne de nombre d’éléments sur un tableau. Une contrainte doit donc se trouver sur un champ dont le type l’accepte, et le type doit être une valeur unique pour que la répartition ait seulement une réponse.

Quatre structures sont signalées sous cette condition. Une contrainte écrite là où type: est absent ou nomme une union, de sorte que rien ne décide de la borne voulue. Une contrainte écrite sur un type qui n’accepte aucune borne de ce genre — un objet, ou un booléen. Un type: dont la valeur n’est ni un nom scalaire ni une séquence de noms. Et un valuesType: auquel on donne autre chose qu’un nom scalaire.

Les phrases propres au compilateur de la forme compacte :

compactform at <path-inside-the-schema>:<line> (keyword "<constraint>"): constraint applies to a single declared type (integer/number/string/array); type: is unresolved (union or absent) — narrow type: to a single value or remove this constraint (compactform : la contrainte s’applique à un seul type déclaré (integer/number/string/array) ; le type n’est pas résolu (union ou absent) — restreignez le type à une seule valeur ou supprimez cette contrainte) compactform at <path-inside-the-schema>:<line> (keyword "<constraint>"): constraint applies to integer/number/string/array; declared type is <the type as written> (compactform : la contrainte s’applique à integer/number/string/array ; le type déclaré est celui indiqué) compactform at <path-inside-the-schema>:<line> (keyword "type"): expected a scalar type name or a sequence of type names (JSON Schema 2020-12 array-of-types); got unsupported node kind (compactform : nom de type scalaire ou séquence de noms de type attendu (tableau de types de JSON Schema 2020-12) ; type de nœud non pris en charge obtenu) compactform at <path-inside-the-schema>:<line> (keyword "valuesType"): expected a scalar type name (compactform : nom de type scalaire attendu)

La condition sous laquelle elle est enregistrée est compactform: constraint not valid for declared type, ce vers quoi son code court se résout.

Comment corriger : la phrase nomme les deux moitiés — la contrainte et le type qu’elle a rencontré. Restreignez type: à un seul nom lorsqu’il contient une union, ajoutez-le lorsqu’il manque, ou supprimez la contrainte lorsque le champ accepte réellement l’un de plusieurs types. Une borne qui doit varier selon le type s’exprime comme un ensemble d’alternatives sous $jsonschema:, où chaque branche porte son propre type et sa propre borne.

A $ref: is not written in a form the compiler can resolve (Une référence n’est pas écrite sous une forme que le compilateur peut résoudre)

Un schéma référence une autre structure avec $ref:, soit à l’intérieur du même document, soit d’un document à l’autre vers une entrée d’une SchemaLibrary. Deux conditions couvrent les deux façons dont une référence échoue, et la phrase vous indique laquelle vous concerne : la référence n’est pas écrite sous une forme que le compilateur lit, ou elle est bien formée et nomme une cible qui n’existe pas.

La référence n’est pas lisible. La valeur est vide, ou sa forme inter-documents n’est pas <Library>#/schemas/<Entry>, ou elle sépare la version avec @ — ce qui est signalé avec l’orthographe corrigée plutôt que par une plainte générique, car c’est l’erreur que cette forme attire le plus :

compactform at <path-inside-the-schema>:<line> (keyword "$ref"): expected a non-empty reference URL (compactform : une URL de référence non vide est attendue) compactform at <consumer-document> (keyword "$ref"): cross-document $ref shape must be <LibraryName>#/schemas/<EntryName>: <the value as written> (compactform : un $ref inter-documents doit avoir la forme indiquée) compactform at <consumer-document> (keyword "$ref"): cross-document $ref version separator is ’:’, not ’@’ — use <the corrected value>: <the value as written> (compactform : le séparateur de version d’un $ref inter-documents est ’:’, et non ’@’ — utilisez la valeur corrigée)

La condition sous laquelle ils sont enregistrés est compactform: $ref unresolvable.

La cible n’existe pas. La référence se lit correctement et la bibliothèque, ou l’entrée qu’elle contient, est absente — ou aucun catalogue de bibliothèques n’a été fourni pour la résolution :

compactform at <consumer-document> (keyword "$ref"): SchemaLibrary <library> not found in catalog (referenced from <consumer-document>): <the value as written> (compactform : SchemaLibrary introuvable dans le catalogue) compactform at <consumer-document> (keyword "$ref"): entry <entry> not found in SchemaLibrary <library>: <the value as written> (compactform : entrée introuvable dans la SchemaLibrary) compactform at <path-inside-the-schema>:<line> (keyword "$ref"): cross-document $ref but no SchemaLibrary catalog supplied: <the value as written> (compactform : $ref inter-documents, mais aucun catalogue de SchemaLibrary fourni)

La condition sous laquelle ils sont enregistrés est compactform: cross-document $ref target not found.

Séparer les deux est ce qui rend le rapport exploitable : le premier est une valeur à réécrire dans le document que vous avez sous les yeux, et le second est une question sur ce que le build peut voir. Une référence qui s’étend en elle-même est encore une troisième chose, et elle est signalée comme « A library reference expands into itself (Une référence de bibliothèque s’étend en elle-même) » plus haut.

Comment corriger : pour une référence illisible, réécrivez la valeur — <Library>#/schemas/<Entry> pour une référence inter-documents, #/$defs/<name> pour une référence à l’intérieur du même document — et utilisez : avant une version minimale plutôt que @. Pour une cible absente, vérifiez le nom de l’entrée auprès de la bibliothèque qui la publie, et vérifiez que la bibliothèque est atteignable depuis la fermeture des dépendances de la Release : une bibliothèque dont rien ne déclare dépendre n’est pas chargée, si bien qu’une référence correcte vers elle ne se résout toujours en rien.

Lorsque la bibliothèque ne se trouve que dans le cache d’artefacts. Le cache contient ce qu’une récupération y a déposé, et une bibliothèque en cache ne compte comme contenu de catalogue que lorsqu’une entrée du fichier de verrouillage de la Release garantit son digest. Lorsque le cache contient une SchemaLibrary qu’aucune entrée du fichier de verrouillage n’épingle et qu’aucun répertoire de catalogue ne fournit, le rapport est suivi d’une ligne remediation: qui nomme chacune de ces bibliothèques et l’action qui fonctionne pour la commande qui l’a signalée :

  • aggrega build et aggrega validate --release lisent le fichier de verrouillage de la Release, donc leur ligne nomme aggrega pull --release <release>, qui résout la bibliothèque et enregistre son entrée, ou l’écriture de la bibliothèque sous un répertoire de catalogue.
  • aggrega validate sans argument, et aggrega validate avec un chemin d’entité, que --release soit donné ou non, lisent les bibliothèques uniquement dans les répertoires de catalogue et ne lisent aucun fichier de verrouillage, si bien qu’une entrée enregistrée ne changerait pas leur verdict. Leur ligne le dit, et renvoie à l’écriture de la bibliothèque sous un répertoire de catalogue, ou à aggrega pull --release <release> suivi de aggrega validate --release <release>, qui vérifie la Release par rapport aux bibliothèques que son fichier de verrouillage épingle.

Un pull qui ne trouve pas une telle bibliothèque le signale sous A reference names no entity the catalog holds (Une référence ne nomme aucune entité que contient le catalogue), avec une ligne qui lui est propre.

A $ref: addresses a library by registry location (Une référence adresse une bibliothèque par son emplacement dans un registre)

Un $ref: inter-documents nomme sa bibliothèque par son identité — le nom nu de la bibliothèque, puis # et le chemin de l’entrée — et jamais par le registre sur lequel elle se trouve être publiée. Le registre par lequel un nom se résout relève de la configuration de l’espace de travail, et la version utilisée est la réponse du fichier de verrouillage ; une référence portant un hôte figerait donc dans le schéma deux choses que le build est censé décider, et ferait passer le schéma d’un espace de travail à l’autre comme une référence cassée.

Lorsque la valeur portant l’hôte se décompose malgré tout en une bibliothèque et une entrée, la phrase indique l’orthographe sous forme d’identité à utiliser à la place :

compactform at <consumer-document> (keyword "$ref"): cross-document $ref carries a registry host; reference the library by identity (use <Library>#/schemas/<Entry>): <the value as written> (compactform : le $ref inter-documents porte un hôte de registre ; référencez la bibliothèque par son identité)

et lorsque ce n’est pas le cas, la phrase se termine après la valeur :

compactform at <consumer-document> (keyword "$ref"): cross-document $ref carries a registry host; reference the library by identity: <the value as written> (compactform : le $ref inter-documents porte un hôte de registre ; référencez la bibliothèque par son identité)

La condition sous laquelle il est enregistré est compactform: cross-document $ref carries a registry host; reference the library by identity, ce vers quoi son code court se résout.

Comment corriger : supprimez l’hôte et tout ce qui précède le nom de la bibliothèque, pour ne laisser que <Library>#/schemas/<Entry>. Si une version minimale est souhaitée, écrivez-la après le nom de la bibliothèque sous la forme :<version>. La même règle régit les champs $import: d’une Recipe et d’une FeatureRecipe, qui sont signalés séparément sous « A library $import: addresses its library by registry location (Une importation de bibliothèque adresse sa bibliothèque par son emplacement dans un registre) » plus bas.

A schema $import: cannot be applied (Une importation de schéma ne peut pas être appliquée)

Le spec.schema d’un Component ou d’une Feature — son bloc entier ou l’un de ses piliers — ainsi que le valueSchema: ou l’infraSchema: d’un socket usesSchema peuvent chacun être écrits sous forme d’un $import: qui nomme un fichier à côté de l’entité. L’importation est appliquée au chargement de l’entité, de sorte que chaque lecteur ultérieur voit le contrat importé plutôt que le pointeur. Cette condition est ce qui se produit lorsque quelque chose que vous avez écrit est en faute : la directive elle-même, ou la structure de ce que le fichier qu’elle nomme s’est révélé contenir.

Ces fautes forment une seule condition parce que chacune rend la même surface inutilisable et vous laisse la même chose à faire — corriger la directive, ou le fichier qu’elle nomme. Le diagnostic commence par la phrase fixe puis indique de quelle faute il s’agit, de sorte que la phrase est la partie sur laquelle faire correspondre et la proposition qui la suit est ce sur quoi agir :

a schema $import: could not be applied. <surface>: <the clause for this occurrence> (une importation de schéma n’a pas pu être appliquée)

La proposition nomme la surface qu’elle a lue — spec.schema, l’un de ses piliers comme spec.schema.values, ou le valueSchema d’un socket — suivie de la faute précise. Les fautes, et ce que chacune signifie :

  • $import: must be the only key when a schema is imported from a file. (L’importation doit être la seule clé lorsqu’un schéma est importé depuis un fichier.) La directive partage son mappage avec du contenu de schéma écrit par l’auteur. $import: remplace une valeur entière, donc une clé sœur n’a rien avec quoi se combiner.
  • $import: value must be a path to a file. (La valeur de l’importation doit être le chemin d’un fichier.) La valeur est vide, ou n’est pas une chaîne unique.
  • $import: takes a file path beside this entity, not a registry location <value>. (L’importation prend un chemin de fichier à côté de cette entité, et non un emplacement de registre.) La valeur adresse un registre. Le registre par lequel un nom se résout relève de la configuration de l’espace de travail, donc une surface de schéma n’en porte jamais ; le message nomme à la place la forme de référence à utiliser.
  • $import: takes a file path beside this entity; reference the SchemaLibrary entry <value> with $ref: instead. (L’importation prend un chemin de fichier à côté de cette entité ; référencez plutôt l’entrée de la SchemaLibrary.) La valeur adresse une entrée de bibliothèque. Une entrée de bibliothèque se référence, elle ne s’importe pas — $ref: est le mot-clé qui en résout une.
  • imported schema <value> must be a YAML map of schema content; it is not. (le schéma importé doit être un mappage YAML de contenu de schéma ; ce n’est pas le cas.) Le fichier a été trouvé, lu et analysé, et ce qu’il a produit est un scalaire ou une séquence, il n’y a donc aucun contenu de schéma à substituer.

L’en-tête porte la catégorie et le code court de cette condition, E0266, qui est l’identifiant à consigner lorsque vous devez nommer cet arrêt de façon durable — dans un contrôle d’intégration continue, un ticket ou un runbook. Un numéro est attribué une fois puis fixé, de sorte qu’il reste le même quelle que soit l’amélioration de la formulation qui l’entoure ; la table de toutes les conditions le résout.

Une directive bien formée qui nomme un fichier que le build ne peut pas obtenir est signalée ailleurs, sous un code différent. Un chemin qui ne se résout pas, un fichier absent ou illisible, et des octets qui ne s’analysent pas en YAML ne sont pas des fautes dans ce que vous avez écrit — il n’y a aucun document importé à juger — ils sont donc signalés comme le chargement qu’ils sont, sous « A file cannot be read, or its bytes do not parse (Un fichier ne peut pas être lu, ou ses octets ne s’analysent pas) » plus haut, qui documente la proposition que porte chacun d’eux. Faites correspondre sur cette condition, et consignez son code, lorsque ce que vous interceptez est un fichier d’importation manquant ou illisible.

Un chemin est résolu par rapport au répertoire qui contient le fichier de l’entité, la même base que celle qu’utilise tout autre champ porteur d’importation. Une importation dont le contenu déclare lui-même un $import: est suivie, et une chaîne qui revient à un fichier déjà en cours de traitement est signalée comme « A library reference expands into itself (Une référence de bibliothèque s’étend en elle-même) » plus haut plutôt qu’ici. Une directive écrite dans un fichier apporté par une importation est signalée dans ce fichier et à la ligne correspondante, car c’est là que va la correction ; une directive écrite dans l’entité est signalée dans l’entité.

Comment corriger : faites de $import: la seule clé de son mappage, et donnez-lui un chemin relatif vers un fichier YAML à côté de l’entité dont le niveau supérieur est un mappage de contenu de schéma. Pour consommer une structure qu’une SchemaLibrary publie, utilisez plutôt $ref: <Library>#/schemas/<Entry> — une entrée de bibliothèque se référence plutôt qu’elle ne s’importe.

A schema block names a key that is not a data pillar (Un bloc de schéma nomme une clé qui n’est pas un pilier de données)

Le bloc spec.schema d’un Component ou d’une Feature porte les piliers de données de l’entité, et trois clés constituent tout ce qu’il admet : values, la structure que le développeur remplit pour chaque instance ; infra, le dimensionnement physique que l’opérateur fournit ; et provides, les clés que l’entité expose à ce qui la consomme. Cette condition est ce qui se produit lorsque le bloc porte une autre clé à son niveau supérieur.

L’ensemble est fermé plutôt qu’ouvert, pour la même raison que le contenu propre de chaque pilier est validé de façon fermée : un bloc qui énumère une surface légale fait de tout ce qui est hors de cette surface une erreur. Une clé que rien ne reconnaît porterait un contrat que rien ne compile jamais, contre lequel rien ne valide et que rien ne transmet à un consommateur — ce que vous avez écrit en dessous semblerait donc déclaré et serait inerte. C’est plus difficile à remarquer qu’un contrat que vous n’avez jamais écrit, et c’est pourquoi le bloc est refusé plutôt que la clé égarée ignorée.

Le diagnostic commence par la phrase fixe, puis nomme l’entité, la règle, l’endroit où la clé a été écrite, et ce qu’il faut écrire à la place :

a schema block declares a key that names no data pillar (<Kind> <name>, rule schema-pillars, at .spec.schema.<key>). rename "<key>" to one of the pillar keys, or remove it and the contract beneath it; allowed: values, infra, provides. See vocabulary/data-pillars.md for the canonical pillar set. (un bloc de schéma déclare une clé qui ne nomme aucun pilier de données, règle schema-pillars ; renommez la clé en l’une des clés de pilier, ou supprimez-la avec le contrat qu’elle porte ; autorisées : values, infra, provides. Voir vocabulary/data-pillars.md pour l’ensemble canonique des piliers.)

L’en-tête porte la catégorie et le code court de cette condition, E0267, qui est l’identifiant à consigner lorsque vous devez nommer cet arrêt de façon durable — dans un contrôle d’intégration continue, un ticket ou un runbook. Un numéro est attribué une fois puis fixé, de sorte qu’il reste le même quelle que soit l’amélioration de la formulation qui l’entoure ; la table de toutes les conditions le résout.

Deux choses écrites à cette position ne sont pas des clés de cet ensemble, et aucune n’est signalée ici. Un $import: qui nomme un fichier à côté de l’entité est remplacé par le contenu de ce fichier avant la lecture du bloc, de sorte que ce que cette condition inspecte est le niveau supérieur propre au document importé — une clé égarée à l’intérieur du fichier importé est signalée ici, et la directive elle-même jamais. Et un Component qui déclare extends écrit la chaîne nue inherited à la place du bloc, qui est un scalaire ne portant aucune clé.

Comment corriger : la phrase nomme la clé rencontrée et les trois qu’elle admet, si bien que la cause la plus fréquente — une faute de frappe, ou un singulier là où le nom du pilier est au pluriel — se voit à partir du seul diagnostic. Lorsque le contenu sous la clé égarée appartient à un pilier, déplacez-le sous values:, infra: ou provides: selon son appartenance ; data-pillars.md indique quel pilier possède quoi. S’il était conçu comme du contenu de schéma à part entière, il se place un niveau plus bas, à l’intérieur d’un pilier, plutôt qu’à côté des piliers. Une structure publiée par une SchemaLibrary s’atteint avec $ref: <Library>#/schemas/<Entry> écrit à l’intérieur d’un pilier, et non au niveau du bloc.

A plugin asks the host to parse a source while a parse is already running for it (Un plugin demande à l’hôte d’analyser une source alors qu’une analyse est déjà en cours pour lui)

Un plugin peut demander à l’hôte d’analyser une source et de lui renvoyer le résultat, afin qu’un plugin ayant besoin d’un document dans un certain format n’ait pas à embarquer de lecteur pour ce format. L’hôte exécute le plugin qui produit l’analyse et renvoie ce qu’il a produit. Cette condition est ce qui se produit lorsque le plugin atteint de cette manière demande lui-même une analyse : la requête rentrerait à nouveau dans le mécanisme même à l’intérieur duquel elle s’exécute déjà, et l’hôte refuse au lieu de descendre d’un niveau. Un seul niveau est ce que le mécanisme offre, et le refus est ce qui le maintient à un.

Le refus atteint le plugin, pas le build. L’hôte ne s’arrête pas là pour dérouler la pile ; il répond à l’appel par une enveloppe d’échec portant la phrase ci-dessous et un code qui désigne le refus, et le plugin demandeur la reçoit comme réponse à sa requête. Ce que fait ensuite le build dépend de ce que ce plugin fait de la réponse — un plugin qui la traite comme fatale met fin au build, un plugin qui la signale et continue, non. Le refus lui-même est le même dans les deux cas.

Ce n’est la faute d’aucun des deux plugins en particulier : la protection couvre n’importe quelle paire de plugins par laquelle la requête a transité plutôt qu’un appariement nommé, de sorte que le même refus se rencontre partout où l’on rentre à nouveau dans le mécanisme.

Message émis, tel que le plugin le reçoit :

aggrega_parse_source: producer-consumption re-entry denied: a producer reached through the host may not issue a further producer-consumption call (réentrée dans la consommation de producteur refusée : un producteur atteint par l’intermédiaire de l’hôte ne peut pas émettre d’autre appel de consommation de producteur)

Comment corriger : rien dans vos propres fichiers ne provoque cela et aucune modification de ce que vous écrivez ne le fait disparaître — c’est une propriété des plugins avec lesquels le build est configuré. Le plugin à corriger est celui qui demande une analyse depuis l’intérieur d’une analyse ; signalez donc la condition à son éditeur, en citant le message. Si ce plugin est le vôtre, faites-lui lire directement la source qui lui a été transmise plutôt que de demander à l’hôte d’en analyser une autre alors qu’il est lui-même en train de servir une analyse.

The workspace configuration is invalid (La configuration de l’espace de travail n’est pas valide)

Un espace de travail est décrit par un fichier .aggrega-config.yaml à sa racine : le registre vers lequel il publie et depuis lequel il récupère, l’emplacement du cache d’artefacts, les plugins rattachés à chaque socket et la position de chaque registre en matière de signature. Ce fichier est lu et vérifié par rapport à son schéma avant l’ouverture de tout fichier d’entité, car tout ce qui suit est lu à partir de lui.

Un fichier manquant n’est pas un échec. Un espace de travail sans fichier de configuration reçoit les valeurs par défaut documentées, donc cet arrêt ne nomme jamais un fichier absent. Il nomme le fichier qui portait la valeur — ou, pour un paramètre qu’une variable d’environnement remplace et que le schéma ne voit jamais, la variable.

La vérification s’exécute avant que le document ne soit transformé en paramètres typés. C’est cet ordre qui permet au message de nommer le chemin du champ auquel le schéma a objecté, plutôt que de signaler une incompatibilité de type survenue plus loin, sans champ à désigner.

Ces structures sont signalées ici au-delà d’une simple objection du schéma, chacune parce que le schéma seul ne peut dire qu’une chose trop générique pour qu’on puisse agir : une clé workspace: écrite sans rien en dessous, une clé dont la place est au niveau supérieur écrite à la place sous workspace:, un bloc cache: écrit sous un nom que le fichier n’utilise pas, un hôte de registre qui n’est pas écrit comme s’écrit un hôte de registre, et trois paramètres dont le schéma admet les valeurs mais que l’espace de travail ne peut pas utiliser — un artifact_cache_dir absolu ou qui nomme la racine même de l’espace de travail, une entrée signing.kinds qui nomme quelque chose qui n’est pas un type d’artefact publiable, et une entrée plugins.providers ou providers_append dont l’uri est un emplacement de registre écrit avec oci://. Une liaison de fournisseur nomme son plugin par son identité, provider/<name> avec un :<version> facultatif, car c’est à cette identité que la liaison est comparée lors de la résolution d’une capacité ; un emplacement de registre indique où un plugin est publié, et non de quel plugin il s’agit, de sorte qu’une entrée écrite ainsi ne pourrait jamais rien sélectionner. Une entrée qui nomme une fonction d’entrée avec function: et aucun uri: est également signalée ici, lorsqu’il s’agit d’une entrée plugins.linter ou linter_append ou d’une entrée plugins.governance ou governance_append dans un rôle de verdict, ir-verdict ou render-verdict : ces rattachements sélectionnent leur plugin par uri, si bien qu’une telle entrée ne rattache aucun plugin et que la fonction qu’elle nomme ne serait jamais appelée — un lint se poursuivrait comme si l’entrée n’existait pas, et un build ne s’arrêterait que plus tard, au moment de résoudre un plugin que l’entrée n’a jamais nommé.

Un répertoire de catalogue que la configuration liste — sous workspace.catalog_dirs ou catalog_dirs_append, ou dans l’entrée propre d’une Release sous workspace.releases, dans n’importe quel fichier à partir duquel la configuration est lue — est également signalé ici lorsqu’il n’est pas un répertoire : rien n’existe au chemin indiqué, ou bien s’y trouve un fichier ou un lien qui ne mène nulle part. Il est évalué au moment où un catalogue s’apprête à être lu à travers lui, de sorte que toute commande qui lit le catalogue le refuse avant de lire ou d’écrire quoi que ce soit, tandis qu’une commande qui ne lit aucun catalogue s’exécute quand même. Poursuivre la lecture sans lui reviendrait à construire avec moins de catalogues que ceux que vous avez listés, sans rien pour indiquer lesquels. Un répertoire que liste AGGREGA_CATALOG_DIRS est soumis à la même règle, et le refus nomme la variable à la place d’un fichier.

Un hôte de registre — le host d’une entrée registries, ou l’hôte par lequel commence default_registry lorsqu’il ne nomme pas l’une de ces entrées par son name:, auquel cas il désigne l’hôte de cette entrée — s’écrit comme l’hôte lui-même : en minuscules, contenant un point, ou localhost, ou un nom unique suivi d’un port, ou une adresse IP (une adresse IPv6 entre crochets), chacun avec un :port facultatif, et sans schéma ni identifiants de connexion. L’hôte d’une entrée registries ne porte aucun chemin ; default_registry peut faire suivre son hôte de / et d’un chemin de dépôt — des segments en minuscules joints par /, sans tag, digest ni / final. Une valeur qui nomme un hôte sous une autre graphie est refusée en indiquant la graphie à écrire — pour default_registry, l’emplacement entier, chemin compris — afin que la politique de confiance tenue sous cet hôte s’y applique ; cela inclut le port 443 sur un hôte atteint en HTTPS, puisqu’il s’agit du port par défaut de cet hôte. Un chemin qui n’est pas un chemin de dépôt est refusé en nommant l’hôte qu’il suit, et le name: d’une entrée suivi d’un chemin est refusé en nommant les deux graphies à écrire à la place, le nom seul ou l’hôte de l’entrée suivi du chemin, puisqu’un nom désigne l’hôte de son entrée et non un emplacement en dessous. Une valeur qui ne nomme aucun hôte — un nom unique sans port qu’aucune entrée ne porte, un texte contenant des espaces ou des accolades — est refusée comme n’étant pas un hôte, et pour default_registry le refus indique que le nom d’une entrée conviendrait aussi. AGGREGA_DEFAULT_REGISTRY est soumis à la même lecture et refusé de la même manière, en nommant la variable.

Messages émis. Une objection du schéma nomme le fichier, le chemin du champ et ce que le schéma a dit :

workspaceconfig: <path>: <field-path>: <the schema's own objection>: workspace configuration is invalid (la configuration de l’espace de travail n’est pas valide)

Les formes à correctif s’ouvrent sur le fichier et disent une phrase sur la structure précise à la place du chemin du champ et de l’objection du schéma. Un artifact_cache_dir qui nomme la racine de l’espace de travail :

<path>: artifact_cache_dir "<value>" names the workspace root itself; a catalog directory at the workspace root would then be stepped over as cache, leaving nothing to load — give the cache its own subdirectory (for example .aggrega/cache): workspace configuration is invalid (artifact_cache_dir nomme la racine même de l’espace de travail ; un répertoire de catalogue à la racine de l’espace de travail serait alors ignoré comme cache, ne laissant rien à charger — donnez au cache son propre sous-répertoire : la configuration de l’espace de travail n’est pas valide)

une entrée signing.kinds inutilisable, qui nomme aussi le joker couvrant tous les types :

<path>: signing.kinds entry "<kind>" is not a signable artifact kind; use a catalog entity or plugin kind, or "all" for every kind: workspace configuration is invalid (l’entrée signing.kinds n’est pas un type d’artefact signable ; utilisez un type d’entité de catalogue ou de plugin, ou le joker pour tous les types : la configuration de l’espace de travail n’est pas valide)

une liaison de fournisseur écrite comme un emplacement de registre, qui nomme l’entrée, la capacité et la forme à écrire :

<path>: plugins.providers[<n>] binds capability "<capability>" to "oci://<registry>/<repository>", which is where a plugin is published rather than which plugin it is; a provider binding names its plugin by its identity — write uri: provider/<name>, with an optional :<version>: workspace configuration is invalid (plugins.providers lie la capacité à un emplacement, qui indique où un plugin est publié plutôt que de quel plugin il s’agit ; une liaison de fournisseur nomme son plugin par son identité — écrivez uri avec l’identité du fournisseur, avec une version facultative : la configuration de l’espace de travail n’est pas valide)

un rattachement de linter ou de gouvernance en rôle de verdict qui nomme une fonction d’entrée et aucun plugin, dont le message nomme la liste, l’entrée et la fonction, ici sur plugins.linter :

<path>: plugins.linter[<n>] names the entry function "<function>" but no plugin uri; an attachment on this list selects its plugin by uri, so this one attaches no plugin and "<function>" is never called — add the uri of the plugin that exports it: workspace configuration is invalid (plugins.linter nomme la fonction d’entrée mais aucun uri de plugin ; un rattachement de cette liste sélectionne son plugin par uri, donc celui-ci ne rattache aucun plugin et la fonction n’est jamais appelée — ajoutez l’uri du plugin qui l’exporte : la configuration de l’espace de travail n’est pas valide)

un hôte de registre écrit sous une autre graphie, ici HUB.AGGREGA.AI :

<path>: default_registry "HUB.AGGREGA.AI" is not written as the registry host it names; write "hub.aggrega.ai" — lowercase, with no scheme, path, credentials or default port — which is the spelling that host’s trust policy is kept under: workspace configuration is invalid (default_registry n’est pas écrit comme l’hôte de registre qu’il nomme ; écrivez-le — en minuscules, sans schéma, chemin, identifiants de connexion ni port par défaut — ce qui est la graphie sous laquelle la politique de confiance de cet hôte est tenue : la configuration de l’espace de travail n’est pas valide)

un registre par défaut dont l’hôte est écrit sous une autre graphie avant son chemin de dépôt, ici GHCR.io/acme, dont le message nomme l’emplacement entier à écrire :

<path>: default_registry "GHCR.io/acme" is not written as the registry location it names; write "ghcr.io/acme" — the registry host lowercase, with no scheme, credentials or default port, followed by the repository path — which keeps that host’s trust policy applying to it: workspace configuration is invalid (default_registry n’est pas écrit comme l’emplacement de registre qu’il nomme ; écrivez-le — l’hôte du registre en minuscules, sans schéma, identifiants de connexion ni port par défaut, suivi du chemin de dépôt — ce qui maintient l’application de la politique de confiance de cet hôte : la configuration de l’espace de travail n’est pas valide)

le nom d’une entrée suivi d’un chemin, ici local/acme où l’entrée nommée local correspond à 127.0.0.1:5000 :

<path>: default_registry "local/acme" is the name of the registries entry "local" followed by a path, and an entry’s name stands for that entry’s host alone; write "local" to use the entry, or its host followed by the path, "127.0.0.1:5000/acme": workspace configuration is invalid (default_registry est le nom de l’entrée registries suivi d’un chemin, et le nom d’une entrée désigne uniquement l’hôte de cette entrée ; écrivez le nom seul pour utiliser l’entrée, ou son hôte suivi du chemin : la configuration de l’espace de travail n’est pas valide)

une valeur qui ne nomme aucun hôte, dont la phrase liste les formes que prend un hôte :

<path>: registries[<n>].host "<value>" is not a registry host; write a lowercase host name containing a dot (registry.example.com), localhost, a single name followed by a port (registry:5000), or an IP address, an IPv6 one in brackets — each with an optional :port and nothing else: workspace configuration is invalid (l’hôte de l’entrée registries n’est pas un hôte de registre ; écrivez un nom d’hôte en minuscules contenant un point (registry.example.com), localhost, un nom unique suivi d’un port (registry:5000), ou une adresse IP, une adresse IPv6 entre crochets — chacun avec un :port facultatif et rien d’autre : la configuration de l’espace de travail n’est pas valide)

un répertoire de catalogue listé où rien n’existe, dont le message nomme le fichier et la ligne, la liste, l’entrée telle qu’écrite et le chemin vers lequel elle a été résolue — la liste est workspace.catalog_dirs, workspace.catalog_dirs_append, ou la liste d’une entrée de Release telle que `catalog_dirs` of the `workspace.releases` entry "release.yaml" :

<path>:<line>: the `workspace.catalog_dirs` entry "<entry>" names <directory>, which does not exist; create that directory, or remove the entry: workspace configuration is invalid (l’entrée de workspace.catalog_dirs nomme un répertoire qui n’existe pas ; créez ce répertoire, ou supprimez l’entrée : la configuration de l’espace de travail n’est pas valide)

et un marqueur workspace: vide :

workspaceconfig: <path>: workspace must be a mapping; write workspace: {} to mark a workspace root with no catalog directories: workspace configuration is invalid (workspace doit être un mappage ; écrivez un mappage vide pour marquer une racine d’espace de travail sans répertoires de catalogue : la configuration de l’espace de travail n’est pas valide)

Deux autres nomment une clé écrite au mauvais endroit — default_registry, offline, auto_pull et artifact_cache_dir se trouvent tous au niveau supérieur et non sous workspace:, et le bloc du cache d’analyse est parse_cache:. Chacun indique quelle clé il désigne et où cette clé doit se trouver.

Comment corriger : ouvrez le fichier que nomme le message et allez au chemin du champ qu’il cite. Lorsque le message porte une phrase de correctif, il nomme directement la graphie ou l’emplacement correct, et aucune autre lecture n’est nécessaire. Lorsqu’il porte plutôt une objection du schéma, le chemin du champ est la clé en cause et l’objection indique ce que le schéma attendait à cet endroit — les pages des entités ne régissent pas ce fichier, lisez donc l’objection plutôt que de chercher un contrat d’entité. Un artifact_cache_dir s’écrit relativement à la racine de l’espace de travail et nécessite son propre sous-répertoire, afin qu’un répertoire de catalogue à la racine de l’espace de travail ne soit pas pris pour du cache et ignoré. Une liaison de fournisseur écrite comme un emplacement de registre se réécrit à la main avec l’identité du plugin — oci://hub.aggrega.ai/plugin/provider/compose devient provider/compose — car toute commande qui lit le fichier le refuse tant que ce n’est pas fait, aggrega plugin remove comprise ; aggrega plugin add provider écrit lui-même la forme par identité. Une entrée de linter ou de gouvernance en rôle de verdict qui nomme une fonction et aucun plugin reçoit l’uri du plugin qui exporte cette fonction ; si aucun ne l’exporte, supprimez l’entrée — dans la liste des linters, le linter standard s’exécute alors comme lorsqu’aucun linter n’est configuré. Un répertoire de catalogue listé qui n’est pas un répertoire est créé au chemin que nomme le refus, ou son entrée est supprimée de la ligne que nomme le refus ; une copie d’un projet faite sans un checkout voisin qu’il liste supprime cette entrée.

A plugin binding sets a key the socket it attaches to does not read (Une liaison de plugin définit une clé que le socket auquel elle se rattache ne lit pas)

Les sockets de la configuration de l’espace de travail rattachent les plugins de deux manières différentes, et une clé qui appartient à l’une n’a aucun sens pour l’autre. Plutôt que d’accepter la clé et de l’ignorer en silence, la configuration est refusée, de sorte qu’un opérateur apprend que le paramètre est inopérant au lieu de se demander plus tard pourquoi il n’a eu aucun effet.

Les deux incohérences sont le reflet l’une de l’autre.

  • Un socket transversal lié par capacité. Les sockets de gouvernance, de linter et d’importateur rattachent un plugin directement par uri:. Un plugin de gouvernance ou de linter ne sert aucune capacité, donc une liaison capability: à cet endroit serait recherchée par rapport à rien et ne correspondrait à rien — un rattachement qui ne peut jamais se résoudre. Un importateur annonce bien les formats qu’il prend en charge, mais c’est à l’importation, et non au rattachement, de dire quel format est voulu : un rattachement d’importateur désigne son importateur par uri:, et c’est ce qui le choisit parmi les importateurs annonçant le format demandé par une importation.
  • Un socket de fournisseur définissant une clé sans référent. Une liaison de fournisseur désigne une capacité et le plugin qui la sert, et le plugin pilote un ensemble fixe d’exports plutôt qu’un point d’entrée unique sélectionnable, donc function: n’y désigne rien. with: est refusé pour une autre raison : la configuration de rendu d’un fournisseur s’écrit dans la Recipe, donc la placer sur la liaison de l’espace de travail la met du mauvais côté de la séparation entre développeur et opérateur.

Messages émis. Une capacité sur un socket transversal :

workspaceconfig: the <socket> socket is bound by capability "<capability>", but the cross-cutting sockets attach by uri: their plugin serves no capability, so a capability lookup matches nothing; attach it with uri: instead: a cross-cutting socket is bound by capability but attaches by uri (le socket est lié par capacité, mais les sockets transversaux se rattachent par uri : leur plugin ne sert aucune capacité, donc une recherche par capacité ne correspond à rien ; rattachez-le plutôt par uri : un socket transversal est lié par capacité mais se rattache par uri)

un function: inopérant sur une liaison de fournisseur :

workspaceconfig: the provider socket binding for capability "<capability>" sets function:, but a provider drives a fixed set of phase-keyed exports rather than one selectable entry, so function: names nothing there; remove it: a provider socket binding sets a field with no referent on that socket (la liaison du socket de fournisseur pour la capacité définit ce champ, mais un fournisseur pilote un ensemble fixe d’exports associés aux phases plutôt qu’un point d’entrée unique sélectionnable, donc ce champ n’y désigne rien ; supprimez-le : une liaison de socket de fournisseur définit un champ sans référent sur ce socket)

et un with: inopérant, signalé sous la même structure et qui indique plutôt où la configuration doit se trouver :

workspaceconfig: the provider socket binding for capability "<capability>" sets with:, but provider render configuration belongs in the Recipe, not the workspace provider binding; remove it: a provider socket binding sets a field with no referent on that socket (la liaison du socket de fournisseur pour la capacité définit ce champ, mais la configuration de rendu du fournisseur appartient à la Recipe, pas à la liaison de fournisseur de l’espace de travail ; supprimez-le : une liaison de socket de fournisseur définit un champ sans référent sur ce socket)

Un function: écrit dans .aggrega-config.yaml n’atteint pas la phrase ci-dessus : le schéma de la configuration de l’espace de travail ne déclare aucune clé de ce nom sur une liaison de fournisseur, donc le fichier est refusé d’abord, sous E0224, et le remède est le même — supprimer la clé :

workspaceconfig: <file>: plugins.providers[<index>].function: against /$defs/FixedEntryPluginRef: unexpected property: “function”: workspace configuration is invalid (plugins.providers[].function : par rapport à /$defs/FixedEntryPluginRef : propriété inattendue : “function” : la configuration de l’espace de travail n’est pas valide)

Comment corriger : la correction se fait dans .aggrega-config.yaml et chaque message indique la modification exacte. Sur un rattachement de gouvernance, de linter ou d’importateur, remplacez le capability: par l’uri: du plugin que vous vouliez rattacher. Sur une liaison de fournisseur, supprimez la clé indiquée — et s’il s’agissait de with:, déplacez cette configuration dans la Recipe qui effectue le rendu via le fournisseur, car c’est la surface qui la lit.

A capability is bound to more than one provider plugin (Une capacité est liée à plus d’un plugin fournisseur)

Une capacité désigne une manière de transformer une charge de travail en artefacts, et exactement un plugin la sert dans un espace de travail résolu. Deux liaisons pour une même capacité ne laissent aucune réponse à la question de savoir laquelle effectue le rendu, et une configuration d’espace de travail est assemblée à partir de plusieurs couches — un fichier partagé, un fichier d’espace de travail et les fichiers compagnons d’ajout que chacun peut apporter —, si bien que la seconde liaison est souvent apportée par une couche dont l’auteur ne pouvait pas voir la première.

Le refus est ce qui rend cela visible. Laisser une liaison l’emporter en silence ferait dépendre la sortie rendue de la couche lue en dernier par hasard.

Message émis, qui nomme la capacité et la règle :

workspaceconfig: capability "<capability>" is bound to more than one provider plugin; keep exactly one plugins.providers entry per capability: capability is bound to more than one provider plugin (la capacité est liée à plus d’un plugin fournisseur ; conservez exactement une entrée plugins.providers par capacité : la capacité est liée à plus d’un plugin fournisseur)

Comment corriger : conservez une seule entrée plugins.providers pour la capacité que nomme le message et supprimez l’autre. Lorsque les deux proviennent de couches de configuration différentes, la couche à modifier est celle que vous contrôlez — supprimer votre propre entrée adopte celle qu’apporte la couche partagée, et conserver la vôtre signifie que c’est l’entrée de la couche partagée qui doit disparaître. Deux plugins qui servent réellement tous deux l’espace de travail servent deux capacités différentes, donc si vous voulez les deux, donnez à chacun sa propre capacité plutôt que d’en lier une deux fois.

An importer is attached by more than one plugins.importer entry (Un importateur est rattaché par plus d’une entrée)

Une entrée plugins.importer rattache l’importateur que désigne son uri : lorsque cet importateur annonce le format demandé par une importation, l’entrée décide quelle version de celui-ci s’exécute et lui transmet les with.sources et with.settings de l’entrée. Une entrée fait cela pour un importateur, donc une seconde entrée désignant le même importateur — la même identité, à la même version ou à une autre — ne serait lue par rien, et son with n’atteindrait aucun importateur sans qu’un mot soit dit. La configuration est plutôt refusée lors de son chargement, quelle que soit la commande qui la lit.

Une configuration d’espace de travail est assemblée à partir de plusieurs fichiers — le fichier global, chaque .aggrega-config.yaml depuis la racine du projet jusqu’au répertoire dans lequel une commande s’exécute, le fichier compagnon importer_append que chacun peut porter, et le .aggrega-config-append-ci.yaml d’un pipeline —, si bien que la seconde entrée est souvent écrite dans un autre fichier que la première. Le message nomme l’importateur et les deux entrées, la plus ancienne d’abord, chacune par la clé et la position sous lesquelles elle est écrite, le fichier dans lequel elle a été écrite, et son uri tel qu’il y est écrit.

Seule la liste des importateurs est examinée : les listes de gouvernance et de linter acceptent qu’un même plugin soit rattaché plus d’une fois, chaque rattachement portant son propre with. Une entrée dont l’uri est un chemin du système de fichiers ne désigne aucun importateur, elle n’est donc pas comparée.

Message émis :

importer "<identity>" is attached by <key>[<position>] in <file> (uri "<uri>") and again by <key>[<position>] in <file> (uri "<uri>"); keep exactly one plugins.importer entry per importer, its uri naming the version you want: importer is attached by more than one plugins.importer entry (l’importateur est rattaché par une entrée dans un fichier, puis à nouveau par une entrée dans un fichier ; conservez exactement une entrée plugins.importer par importateur, son uri désignant la version voulue : l’importateur est rattaché par plus d’une entrée plugins.importer)

Comment corriger : conservez une seule entrée pour l’importateur que nomme le message — celle dont l’uri désigne la version voulue, portant le with que vous voulez transmettre à cet importateur — et supprimez l’autre. Lorsque les deux se trouvent dans des fichiers différents, le fichier à modifier est celui que vous contrôlez : supprimer votre entrée adopte celle de l’autre fichier, et conserver la vôtre signifie que c’est l’entrée de l’autre fichier qui doit disparaître.

A provider binding names a capability containing a colon (Une liaison de fournisseur désigne une capacité contenant un deux-points)

Le capability: d’une Recipe est lu comme le nom de la capacité jusqu’à son dernier deux-points, suivi d’un épinglage de version — helm:1.0.0 demande la capacité helm à la version 1.0.0. Une entrée plugins.providers est recherchée sous ce nom, donc la capacité que désigne une liaison ne contient jamais de deux-points, et une entrée dont la capacité en contient un est une entrée qu’aucune Recipe ne peut jamais atteindre. Plutôt que de la laisser non lue dans la configuration, la configuration est refusée lors de son chargement, quelle que soit la commande qui l’a lue.

Seule la liste des fournisseurs est examinée. La liste des importateurs partage la structure des entrées, mais ses plugins sont rattachés par uri: et nomment leurs formats import:<format>, où le deux-points fait partie du nom. L’uri: d’une liaison peut tout de même se terminer par :<version> ; ce n’est pas la partie que lit cette règle.

Message émis, qui nomme la capacité :

the provider socket binding for capability "<capability>": a Recipe’s capability reference is read as the capability up to its last colon and a version pin after it, so the capability a binding names carries no colon; bind the capability name alone and let each Recipe pin the version it needs: a provider socket binding names a capability containing a colon, which no Recipe can select (la liaison du socket de fournisseur pour la capacité : la référence de capacité d’une Recipe est lue comme la capacité jusqu’à son dernier deux-points, suivie d’un épinglage de version, donc la capacité que désigne une liaison ne contient pas de deux-points ; liez le seul nom de la capacité et laissez chaque Recipe épingler la version dont elle a besoin : une liaison de socket de fournisseur désigne une capacité contenant un deux-points, qu’aucune Recipe ne peut sélectionner)

Comment corriger : écrivez le seul nom de la capacité dans l’entrée — capability: helm — et épinglez les versions là où elles doivent l’être : une Recipe épingle la version de fournisseur dont elle a besoin dans son propre capability:, et une liaison qui doit sélectionner une version particulière de son plugin l’écrit sur l’identité du plugin, uri: provider/helm:1.0.0.

A governance attachment declares no role, or one that is not a known role (Un rattachement de gouvernance ne déclare aucun rôle, ou un rôle qui n’est pas connu)

Un rattachement de gouvernance porte un rôle, et c’est le rôle — et non le type déclaré par le plugin lui-même — qui détermine où le rattachement s’exécute et ce qu’il peut faire : s’il accepte ou rejette un build, et s’il lit le graphe ou les artefacts rendus. Les rattachements sont répartis en lisant ce rôle, donc un rattachement qui n’en porte aucun, ou qui en porte un que personne ne reconnaît, ne se rattacherait à rien et serait ignoré en silence.

C’est ce silence que le refus empêche. Un plugin de gouvernance configuré et jamais consulté produit exactement la sortie d’un build qui n’a jamais été soumis à la gouvernance, et rien dans le résultat n’indique lequel des deux vous avez en main.

Messages émis, qui nomment tous deux le rattachement et listent les rôles existants. Un rôle manquant :

workspaceconfig: governance attachment "<uri>" declares no role; set role: to one of <the known roles>: a governance attachment declares no role or an unknown role (le rattachement de gouvernance ne déclare aucun rôle ; définissez le rôle sur l’un des rôles connus : un rattachement de gouvernance ne déclare aucun rôle ou déclare un rôle inconnu)

et un rôle non reconnu :

workspaceconfig: governance attachment "<uri>" declares unknown role "<role>"; use one of <the known roles>: a governance attachment declares no role or an unknown role (le rattachement de gouvernance déclare un rôle inconnu ; utilisez l’un des rôles connus : un rattachement de gouvernance ne déclare aucun rôle ou déclare un rôle inconnu)

Comment corriger : définissez role: sur le rattachement situé sous plugins.governance à l’un des rôles que liste le message. Le choix est une décision sur ce que vous voulez que le plugin fasse, et non sur le plugin : un rôle qui accepte ou rejette lit le build et renvoie un verdict, et un rôle qui transforme est une instruction explicite de laisser le plugin modifier ce qu’il reçoit. Le message liste l’ensemble complet, donc la graphie à utiliser se trouve dans le message lui-même.

A registry alias matches more than one host (Un alias de registre correspond à plus d’un hôte)

Un registre peut recevoir un alias court dans la configuration de l’espace de travail afin que les commandes et les références puissent le désigner sans écrire son hôte en entier. Un alias sélectionne exactement un hôte. Cette condition est ce que signale un jeton correspondant à l’alias de deux entrées de registre : il n’y a aucune réponse à la question de savoir quel hôte était visé, et en choisir un enverrait en silence des artefacts vers un registre que l’auteur n’a pas nommé, ou les en récupérerait.

Message émis, qui nomme l’alias, le nombre d’entrées qui l’ont revendiqué et les hôtes dont il s’agit :

registry alias "<alias>" matches <count> hosts (<hosts>); address the registry by host or remove the duplicate alias: registry alias matches more than one host (l’alias de registre correspond à plusieurs hôtes ; adressez le registre par son hôte ou supprimez l’alias en double : l’alias de registre correspond à plus d’un hôte)

Comment corriger : ouvrez .aggrega-config.yaml et attribuez l’alias à l’un des hôtes que liste le message, ou adressez le registre par son hôte et retirez l’alias de la référence. Le message nomme chaque hôte qui détient l’alias, donc les entrées à examiner figurent dans le message. Lorsque les entrées proviennent de couches de configuration différentes, modifiez la couche qui vous appartient.

The lockfile does not satisfy its schema (Le fichier de verrouillage ne satisfait pas son schéma)

Le fichier de verrouillage d’une release enregistre ce vers quoi le build s’est résolu : pour chaque entité, bibliothèque et plugin qu’il atteint, la version sélectionnée et le digest des octets à cette version. Il est lu et vérifié par rapport à son schéma avant d’être converti en épinglages typés, de sorte qu’un document non conforme est refusé avec le chemin du champ où il a échoué, plutôt que de produire en silence des épinglages lacunaires.

Le fichier de verrouillage est écrit par la machine. Il est produit par le pull qui résout une release, et il est commité afin que le même build se résolve de la même manière plus tard. Un échec de schéma est donc presque toujours une modification manuelle, une fusion qui a laissé le document à moitié résolu, ou un fichier de verrouillage écrit pour une forme antérieure du fichier — dont les entities ne portent aucun kind, par exemple — plutôt que quelque chose d’écrit délibérément.

Un fichier de verrouillage manquant est une condition différente et se signale différemment — le fichier de verrouillage est obligatoire, donc son absence est signalée là où le build le cherche, avec l’instruction d’exécuter le pull qui le crée.

Message émis, qui nomme le fichier, le chemin du champ et l’objection propre au schéma :

lockfile: <path>: <field-path>: <the schema's own objection>: lockfile: file failed schema validation (lockfile : lockfile : le fichier a échoué à la validation du schéma)

Un build, ainsi que aggrega pull --verify, ajoute la commande qui réécrit le fichier de verrouillage :

…: lockfile: file failed schema validation; run aggrega pull --release <release> to write it again from the Release (lockfile : le fichier n’a pas passé la validation de schéma ; exécutez la commande pour le réécrire à partir de la Release)

Un document entièrement vide se signale à part, puisqu’il n’y a aucun champ à nommer :

lockfile: <path>: document is empty (lockfile : le document est vide)

Comment corriger : ne réparez pas le fichier de verrouillage à la main. Relancez le pull pour la release, qui réécrit le document à partir de la résolution qu’il effectue, et commitez le résultat — c’est la nouvelle résolution qui produit un document dont les épinglages concordent avec ce que la release atteint réellement. Lorsque l’échec fait suite à une fusion, résoudre le conflit en relançant le pull plutôt qu’en modifiant le fichier est ce qui évite un document qui s’analyse correctement mais épingle les mauvaises versions. Le chemin du champ dans le message mérite d’être lu en premier : il vous indique si le dommage se situe dans une entrée ou dans la structure globale du document.

Lors de la résolution du catalogue

Après le chargement, le compilateur parcourt les deux niveaux du Manifest (mappage des types, puis mappage des noms) pour choisir la Recipe de chaque Component, et il parcourt toutes les chaînes extends des Manifests, Components ou Features. La propre chaîne extends d’une Release est suivie par le même parcours, une étape plus tôt : elle est suivie pendant la résolution de la Release, avant que le Manifest ou l’Aggregate qu’elle nomme ne soit recherché, de sorte que les conditions ci-dessous sont signalées pour la Release plutôt que pour un pointeur voisin que la chaîne devait fournir.

Cyclic extends chain (Chaîne extends cyclique)

Une chaîne de pointeurs extends boucle sur elle-même. Chaque type qui déclare extends — Component, Feature, Manifest et Release — est parcouru par un seul parcours de chaîne, de sorte qu’une boucle est signalée dans les mêmes termes partout où elle est trouvée.

Message émis. Il s’ouvre sur la phrase qui nomme la condition, puis viennent l’entité dont la résolution est partie et la règle qui l’a refusée, puis l’arête qui ferme la boucle — l’entité portant le extends: fautif et la référence qu’elle déclare :

cyclic extends chain (<kind> <name>, rule extends). <entity> extends <reference>, which is already in the chain; remove the extends on <entity>, or point it at an entity outside the chain (chaîne extends cyclique (type et nom, règle extends). L’entité étend la référence, qui est déjà dans la chaîne ; supprimez l’extends sur l’entité, ou faites-le pointer vers une entité hors de la chaîne)

L’entité nommée en premier et l’entité nommée dans l’arête sont généralement différentes, et c’est tout l’intérêt : une boucle est signalée pour chaque entité qui en fait partie, tandis que la ligne extends: à modifier est celle que nomme l’arête. Suivez l’arête, pas l’en-tête.

Pour un Manifest, <kind> vaut Manifest, chaque entité est nommée par son metadata.name, et <reference> est la valeur de extends: exactement telle qu’écrite — un chemin relatif comme ./base.yaml, ou le simple metadata.name d’un Manifest à côté de la Release. La forme que vous avez écrite ne change pas ce qui est signalé : un maillon de Manifest est le fichier vers lequel il se résout, de sorte que deux fichiers de Manifest qui déclarent par hasard un même metadata.name sont deux maillons et qu’une chaîne qui les traverse tous deux n’est pas une boucle.

Une Release se lit de la même façon, et la question de l’identité du fichier y compte davantage, car la structure qu’elle protège est courante : <kind> vaut Release, <reference> est le chemin relatif que nomme extends:, et un maillon de Release est le fichier vers lequel il se résout. Deux fichiers de Release qui nomment le système déployé plutôt que l’environnement — tous deux metadata.name: shared-release, l’un étendant l’autre — sont deux maillons, et une chaîne qui les traverse tous deux n’est pas une boucle.

Une boucle est signalée comme une boucle, quelle que soit sa longueur. Le parcours de chaîne n’applique sa borne de profondeur qu’à une chaîne qui se termine, de sorte qu’un cycle couvrant plus d’entités que la borne ne le permet est tout de même signalé ici plutôt que comme une chaîne trop profonde — le remède à une boucle n’est jamais de la raccourcir.

Comment corriger : ouvrez l’entité que nomme l’arête, et supprimez son extends: ou faites-le pointer vers une entité qui n’est pas déjà dans la chaîne. Là où plusieurs niveaux devaient partager du contenu, regrouper le contenu dupliqué dans une seule entité de base supprime à la fois la boucle et la duplication.

Recipe implements does not match the mapped component type (La déclaration d’implémentation de la Recipe ne correspond pas au type de composant mappé)

L’entrée de mappage du Manifest pointe vers une Recipe dont la déclaration spec.implements: ne correspond pas à la clé de type de composant de cette entrée de mappage. spec.implements est une ancre de cohérence plutôt qu’un mécanisme de répartition : la valeur du mappage nomme directement la Recipe, et cette vérification confirme que la Recipe nommée par l’auteur en est une qui déclare le type qu’il a mappé.

La vérification lit le Manifest composé avant qu’aucune Recipe ne soit résolue, de sorte qu’elle signale l’entrée de mappage écrite par l’auteur plutôt qu’un symptôme en aval.

Message émis :

manifest mapping entry’s recipe spec.implements does not match the mapped component-type / feature-type key (manifest mapping "<component-type>" -> "<recipe-uri>", recipe spec.implements is "<recipe-implements>", expected "<component-type>", or a type "<component-type>" extends) (la spec.implements de la recette de l’entrée de mappage du manifeste ne correspond pas à la clé de type de composant / type de fonctionnalité mappée (mappage du manifeste du type de composant vers l’URI de la recette, la spec.implements de la recette est la valeur déclarée, attendu le type de composant ou un type qu’il étend))

Chaque commande qui lit les dépendances d’une Release effectue cette vérification ; ce qui diffère, c’est ce que chacune fait du résultat. aggrega build et aggrega pull s’arrêtent, car toutes deux produisent quelque chose que vous utiliseriez ensuite — des artefacts rendus et un fichier de verrouillage. aggrega validate et aggrega lint signalent le constat avec tous les autres diagnostics trouvés, puis se terminent avec un code non nul : leur rôle est de vous dire tout ce qui ne va pas dans l’espace de travail, de sorte qu’une seule faute n’écourte pas le rapport. Dans l’éditeur, le constat est publié comme un diagnostic à côté des autres, et tout ce que ce document avait d’autre à signaler n’est pas affecté. Notez où il apparaît : l’éditeur publie le constat sur le Manifest dans lequel le mappage est écrit, sur la clé de l’entrée de mappage qu’il nomme, et non sur l’Aggregate — à la première ligne du Manifest lorsque son texte ouvert n’écrit pas cette entrée, comme pour une entrée qu’il hérite via extends. Les autres constats de niveau dépendances de la Release, qui ne nomment aucun document de votre espace de travail, restent sur l’Aggregate. Exécuter aggrega validate le signale quel que soit le document ouvert.

Une entrée de mappage qui nomme une Recipe que le catalogue ne contient pas ne relève pas de cette condition : la vérification n’a rien à comparer et ignore l’entrée, et la Recipe impossible à résoudre est signalée lors de la résolution des recettes.

Les entrées de FeatureRecipe suivent la même structure ; la vérification du mappage features.type émet manifest feature mapping ... featurerecipe spec.implements is ... (expected ...), et la branche des fonctionnalités compare directement la clé de mappage, de sorte qu’elle ne nomme aucune alternative extends.

Une clé components.type est aussi jugée par instance chaque fois qu’elle atteint une instance d’une autre version. Une clé qui ne nomme pas le type exact d’une instance l’atteint par la base du type, lorsqu’aucune clé ne nomme ce type exact et qu’aucune autre clé n’est écrite pour la même base — une clé écrite sans version, ou une clé qui nomme une autre version, peut donc l’atteindre. L’entrée seule ne peut donc pas dire si sa Recipe convient, si bien que le build juge à nouveau la Recipe pour chaque instance de composant que la clé atteint ainsi, le type propre de l’instance, à la version sous laquelle le build la compile, prenant la place de la clé : la version que nomme l’instance ou, pour une instance qui n’en nomme aucune, la version la plus élevée de ce Component que contient le catalogue. Une instance dont la version ne satisfait pas la spec.implements: de la Recipe — exactement, par plage caret, en étant sans version, ou à travers une base que le type de l’instance étend par extends — lève cette condition, signalée au chemin .spec.components.<instance> de l’instance plutôt qu’au fichier du Manifest :

manifest mapping entry’s recipe spec.implements does not match the mapped component-type / feature-type key (Manifest, at .spec.components.<instance>, "<instance>", of type "<component-type>", compiled as "<component-type>:<version>", reached through manifest mapping key "<key>", mapped to recipe "<recipe-uri>", whose spec.implements is "<recipe-implements>"). map this type at this version to a recipe that implements it, with a mapping key naming the version (la spec.implements de la recette de l’entrée de mappage du manifeste ne correspond pas à la clé de type de composant / type de fonctionnalité mappée (Manifest, au chemin de l’instance, instance du type de composant, compilée en tant que type et version, atteinte par la clé de mappage du manifeste, mappée vers la recette, dont la spec.implements est la valeur déclarée). mappez ce type à cette version vers une recette qui l’implémente, avec une clé de mappage qui nomme la version)

La valeur compiled as n’apparaît que pour une instance dont le type ne nomme aucune version ; une instance qui en nomme une montre sa version dans of type. Une clé qui nomme la version propre de l’instance n’exige pas de second jugement, puisque la vérification de l’entrée a déjà posé la question, et une entrée déjà refusée sur sa clé est signalée une fois, comme ci-dessus, plutôt qu’une fois de plus pour chaque instance. aggrega build et aggrega pull s’arrêtent sur elle, et aggrega validate --release la signale et se termine avec un code non nul. aggrega lint juge les entrées de mappage d’un Manifest et non les instances qu’elles atteignent, il ne la signale donc pas.

Comment corriger : corrigez la déclaration spec.implements: de la Recipe pour qu’elle corresponde à la clé de type de composant du Manifest, ou modifiez l’entrée du Manifest pour qu’elle pointe vers une Recipe dont la spec.implements: correspond bien à la clé de type de composant. Pour une instance qu’une clé atteint à une autre version, ajoutez une clé de mappage qui nomme la version de l’instance, mappée vers une Recipe qui l’implémente, ou faites pointer la clé qui l’atteint vers une telle Recipe.

Manifest mapping value is not a shape a recipe reference accepts (La valeur de mappage du Manifest n’a pas une structure qu’une référence de recette accepte)

Une valeur de mappage du Manifest nomme une Recipe ou une FeatureRecipe sous une structure que la grammaire des références ne peut pas exprimer. Une référence de recette accepte un nom simple, un nom avec une version, un nom qualifié par une capacité, ou un nom qualifié par une capacité avec une version — au plus un /. Une valeur qui en contient davantage (un chemin à la manière d’un type de composant comme core/helm/eso-aws-fetcher:1.0.0) ne peut jamais nommer une entité du catalogue, quel que soit le contenu du catalogue.

La structure est jugée pendant la composition du Manifest, avant toute recherche — le verdict vient du comptage des séparateurs dans une chaîne, il n’a donc besoin d’aucun catalogue. La juger à cet endroit est ce qui rend le diagnostic honnête : la recette que la valeur voulait désigner est souvent présente et correctement nommée, et s’entendre dire qu’elle manque vous fait chercher la mauvaise chose. Chaque commande qui résout les dépendances d’une Release la signale de la même façon, de sorte que cela ne dépend pas de celle que vous exécutez.

Message émis :

malformed recipe reference in a Manifest mapping value: spec.mappings.components.type.<key> maps to <value>, which carries <n> slash-separated segments; a recipe reference accepts "name", "name:version", "capability/name" or "capability/name:version"; correct the mapping value in the Manifest (référence de recette malformée dans une valeur de mappage du Manifest : la clé est mappée vers une valeur qui contient plusieurs segments séparés par des barres obliques ; une référence de recette accepte nom, nom:version, capacité/nom ou capacité/nom:version ; corrigez la valeur de mappage dans le Manifest)

La section features produit le même message pour sa propre coordonnée, et une référence de recette de fonctionnalité est nommée comme telle.

Une valeur dont le segment de capacité porte un épinglage de version — compose:1.2.3/svc:1.0.0 — est refusée de la même façon, avant toute recherche, de sorte que rien n’est récupéré d’un registre. Un épinglage appartient à la capability que déclare la Recipe, où il sélectionne quelle version du plugin servant cette capacité en fait le rendu ; une référence nomme la Recipe par sa capacité simple (compose/svc:1.0.0).

malformed recipe reference in a Manifest mapping value: spec.mappings.components.type.<key> maps to <value>, which carries a version pin in its capability segment <segment>; a pin belongs on the capability the recipe declares, and a recipe reference names the recipe by its bare capability, as "name", "name:version", "capability/name" or "capability/name:version"; correct the mapping value in the Manifest (référence de recette malformée dans une valeur de mappage du Manifest : la clé est mappée vers une valeur qui porte un épinglage de version dans son segment de capacité ; un épinglage appartient à la capacité que déclare la recette, et une référence de recette nomme la recette par sa capacité simple, sous la forme nom, nom:version, capacité/nom ou capacité/nom:version ; corrigez la valeur de mappage dans le Manifest)

Comment corriger : raccourcissez la valeur de mappage à une structure que la grammaire accepte. Une recette est identifiée par son propre metadata.name — éventuellement préfixé par sa spec.capability et suffixé par sa version —, jamais par le chemin du type de composant qu’elle implémente. La clé du mappage est le type de composant ; la valeur du mappage est la recette.

À ne pas confondre avec une valeur bien structurée qui nomme une recette que le catalogue ne contient pas : il s’agit d’une entité réellement absente, toujours signalée comme telle, avec l’URI et l’entrée de mappage qui y faisait référence.

Several Recipes implement one Component type (Plusieurs Recipes implémentent un même type de Component)

Deux Recipes ou plus déclarent le même type de Component sous spec.implements: — deux Recipes de version exacte pour un même type, ou une Recipe sans version à côté d’une Recipe épinglée.

Cela ne lève aucun arrêt propre, et ce n’est pas une ambiguïté que le build doit résoudre. La sélection de la Recipe se fait uniquement par mappage : rien ne lit spec.implements: pour choisir parmi les candidates, de sorte que, quel que soit le nombre de Recipes qui implémentent un type, celle qui fait le rendu d’une instance est celle vers laquelle le Manifest la mappe. spec.implements: est lu comme une ancre de cohérence — pour confirmer que la Recipe qu’un auteur a mappée en est une qui déclare le type sous lequel il l’a mappée — et comme source des candidates à l’épinglage qu’un arrêt suggère. Il ne sélectionne jamais.

Ce que vous rencontrez à la place, c’est l’arrêt pour une instance que le Manifest ne mappe vers rien, et cet arrêt liste chaque Recipe qui implémente le type pour que vous puissiez en épingler une — voir « No Recipe is mapped for a component or feature instance (Aucune Recipe n’est mappée pour une instance de composant ou de fonctionnalité) » plus bas. Il est signalé de la même façon qu’une seule Recipe implémente le type ou cinq, c’est pourquoi il n’existe pas de condition d’ambiguïté distincte à rechercher.

Comment corriger : ajoutez le mappage. Une entrée indexée par type route chaque instance du type ; une entrée indexée par nom route une instance nommée et est lue en premier, c’est donc aussi ainsi que vous donnez à une instance une Recipe différente de celle de ses sœurs.

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

Une Release utilise extends: pour hériter d’une Release de base mais déclare aussi son propre pointeur aggregate:. Le JSON Schema de la Release rejette cette structure lors de la validation du schéma (Couche 1, le contrôle de l’enveloppe) via une contrainte allOf : lorsque extends: est présent, aggregate: est interdit ; lorsque extends: est absent, aggregate: et manifest: sont tous deux requis.

Elle s’arrête comme une violation ordinaire de l’enveloppe, de sorte que le diagnostic prend la structure de cette classe — voir « La classe d’échecs de l’enveloppe du document » dans error-translation.md — et le constat pointe vers la clé qui n’est pas autorisée ici :

document envelope validation failed (Release, at <path>); <line>:<column>: spec.aggregate: value matches a shape that is not allowed here. correct the document to match its kind’s schema (échec de la validation de l’enveloppe du document (Release, au chemin) ; ligne et colonne : spec.aggregate: la valeur correspond à une structure qui n’est pas autorisée ici. corrigez le document pour qu’il corresponde au schéma de son type)

Comment corriger : supprimez le champ aggregate: de la Release enfant. L’héritage oblige intentionnellement l’enfant à déployer la même intention du développeur que la Release parente ; si vous devez déployer un Aggregate différent, rédigez une nouvelle Release sans extends:.

A feature attached by both the Aggregate and the Release cannot be merged (Une fonctionnalité rattachée à la fois par l’Aggregate et par la Release ne peut pas être fusionnée)

Lorsqu’un Manifest local étend un Manifest de base par extends, les deux niveaux (mappage type:, mappage name:) fusionnent indépendamment. Au sein de chaque niveau, les clés de l’enfant écrasent celles du parent au premier niveau — il s’agit d’un remplacement superficiel, pas d’une fusion profonde. Une entrée de l’enfant pour une clé donnée remplace entièrement l’entrée du parent pour cette clé.

Lorsque le même nom d’instance de fonctionnalité apparaît à la fois côté Aggregate et côté Release avec un état conflictuel non fusionnable (au-delà de la superposition infra permise), le compilateur s’arrête et positionne le diagnostic sur le rattachement qu’il n’a pas pu concilier. Les deux déclarations en conflit suivent dans un ordre fixe — d’abord le type déclaré par l’Aggregate, puis le type déclaré par la Release — pour que vous sachiez quel document a dit quoi sans ouvrir les deux.

Message émis :

feature merge conflict: reconcile the Aggregate and Release declarations for the feature (Aggregate <name>, at .spec.components.<component>.features.<attachment>, "<aggregate-declared-type>", "<release-declared-type>") (conflit de fusion de fonctionnalité : conciliez les déclarations de l’Aggregate et de la Release pour la fonctionnalité (Aggregate, au chemin du rattachement, type déclaré par l’Aggregate, type déclaré par la Release))

Il en va de même pour un rattachement que porte une connexion. Lorsque l’entrée de connexion de l’Aggregate et l’entrée de la Release pour la même connexion écrivent toutes deux un rattachement sous un même emplacement et nomment des Features différentes, le build s’arrête à l’entrée de la Release — là où le second type a été écrit — une fois la composition aplatie, en nommant les deux types, l’emplacement, la connexion, le socket et le composant :

feature merge conflict: reconcile the Aggregate and Release declarations for the feature (Release <release-name>, at .spec.boundaries.<boundary>.components.<component>.uses.<socket>.<alias>, the Aggregate names "<aggregate-declared-type>", the Release names "<release-declared-type>", for the slot "<slot>", on the connection "<alias>", through socket "<socket>", of component "<component>"). Drop the type from the Release’s entry so it sizes the attachment the Aggregate declares, or name the same Feature in both documents. (conflit de fusion de fonctionnalité : conciliez les déclarations de l’Aggregate et de la Release pour la fonctionnalité (Release, au chemin de la connexion, l’Aggregate nomme un type, la Release en nomme un autre, pour l’emplacement, sur la connexion, à travers le socket, du composant). Retirez le type de l’entrée de la Release pour qu’elle dimensionne le rattachement que déclare l’Aggregate, ou nommez la même Feature dans les deux documents.)

Comment corriger : conciliez les deux déclarations. Les déclarations côté Aggregate et côté Release d’une même instance de fonctionnalité se combinent par pilier — l’Aggregate fournit values, la Release fournit infra. Si les deux côtés spécifient le même champ hors pilier (comme type:), les valeurs doivent correspondre ; corrigez un côté pour qu’il corresponde à l’autre, ou supprimez la déclaration redondante.

Annotation binding does not resolve against its target Feature (La liaison d’annotation ne se résout pas par rapport à sa Feature cible)

Le champ feature: d’une liaison d’annotation du Manifest nomme une Feature que le catalogue ne charge pas, ou bien les listes maps.infra / maps.values de la liaison déclarent des chemins pointés que le spec.schema de la Feature nommée ne contient pas réellement. L’une ou l’autre condition arrête le chargement de l’espace de travail — la liaison synthétiserait des rattachements de Feature routant des valeurs vers des chemins que l’environnement d’exécution ne peut pas résoudre.

Une seule condition couvre les trois manières dont le routage d’une liaison ne se résout pas, et le diagnostic indique laquelle a été rencontrée :

  • Feature introuvable. La valeur feature: référence un URI de Feature absent du catalogue chargé.
  • Le schéma de la Feature ne se résout pas. La Feature nommée se charge, mais son spec.schema: ne se résout pas en une représentation JSON Schema 2020-12 — le contenu est mal formé, ou il nomme une référence inter-documents qui ne peut pas être suivie. Cette variante transporte à sa suite le diagnostic propre à l’échec de résolution, de sorte que la raison pour laquelle le schéma ne s’est pas résolu se lit dans le même arrêt.
  • Chemin de liaison absent du schéma cible. L’entrée maps.infra ou maps.values de la liaison nomme un chemin pointé que le spec.schema.<pillar>.<path> de la Feature ne déclare pas.

Message émis (variante Feature introuvable) :

annotation binding does not resolve against its target Feature (Manifest, at .spec.mappings.features.annotations.<key>, "<key>", routes to Feature "<feature-uri>", which this build’s catalog does not hold; correct or publish the Feature named under "feature") (la liaison d’annotation ne se résout pas par rapport à sa Feature cible (Manifest : route vers une Feature que le catalogue de ce build ne contient pas ; corrigez ou publiez la Feature nommée dans la liaison))

Message émis (variante où le schéma ne se résout pas) :

annotation binding does not resolve against its target Feature (Manifest, annotation binding routes to Feature "<feature-uri>", whose declared schema does not resolve: <resolution failure>) (la liaison d’annotation ne se résout pas par rapport à sa Feature cible (Manifest : la liaison d’annotation route vers une Feature dont le schéma déclaré ne se résout pas))

Cette variante nomme la Feature et l’échec de résolution, et ne porte ni la clé de la liaison ni une position dans la source — la faute se trouve dans le propre spec.schema: de la Feature, que la liaison ne fait que nommer. Pour trouver la liaison en cause, cherchez dans mappings.features.annotations l’URI de Feature que cite le message.

Message émis (variante chemin introuvable) :

annotation binding does not resolve against its target Feature (Manifest, at .spec.mappings.features.annotations.<key>, "<key>", routes to Feature "<feature-uri>", at pillar "<pillar>", and path "<path>", which that Feature does not declare a property for under "schema") (la liaison d’annotation ne se résout pas par rapport à sa Feature cible (Manifest : route vers une Feature, un pilier et un chemin pour lequel cette Feature ne déclare aucune propriété dans son schéma))

Comment corriger : vérifiez que l’URI feature: de la liaison existe dans le catalogue et correspond à l’URI, sensible à la casse, qu’une Recipe déclare dans implements:. Si la variante chemin introuvable se déclenche sur un chemin que le schéma de la Feature déclare bien, vérifiez la graphie du chemin pointé (sensible à la casse) et le nom du pilier (infra ou values).

A bound annotation value does not conform to the target Feature’s schema (Une valeur d’annotation liée n’est pas conforme au schéma de la Feature cible)

Une annotation que vous avez écrite route une valeur, via une liaison, vers un chemin de la Feature cible — et la valeur ne satisfait pas le sous-schéma que la Feature déclare à ce chemin, ou la Feature n’y déclare aucune propriété. La condition s’évalue sur la valeur plutôt que sur la liaison, ce qui explique qu’elle soit distincte de l’arrêt sur la cible de liaison décrit plus haut : celui-là refuse ce que le Manifest déclare, celle-ci refuse ce qui a été écrit à travers lui.

Validation complète au chemin localisé ; saut souple uniquement lorsque le chemin ne peut pas être localisé. Une fois le sous-schéma de la sous-clé liée localisé, la valeur est validée par rapport à l’ensemble complet des contraintes JSON Schema 2020-12 à ce chemin (type, enum, pattern, plage numérique, structure imbriquée d’objet ou de tableau) — un $ref / allOf / oneOf terminal est résolu par rapport aux définitions du schéma et validé, pas ignoré. La discipline du saut souple ne s’applique qu’à la navigation : lorsque le parcours rencontre une porte de sortie ($ref, patternProperties, oneOf/anyOf/allOf, ou additionalProperties doté d’un corps de schéma) sur un segment intermédiaire — avant d’atteindre la feuille liée — le chemin n’est pas résoluble statiquement, de sorte que le validateur continue sans lever l’erreur plutôt que de risquer un faux arrêt ; l’environnement d’exécution reste la surface de validation pour cette liaison.

Message émis (variante de conformité de la valeur) :

annotation subkey does not conform to the target Feature’s schema at the routed pillar: annotation subkey <subkey> value <value> does not conform to Feature <feature-uri> spec.schema.<pillar>.<subkey>: <constraint failure> (la sous-clé d’annotation n’est pas conforme au schéma de la Feature cible au pilier routé : la valeur de la sous-clé d’annotation n’est pas conforme au schéma de la Feature)

Message émis (variante de la sous-clé non déclarée) :

annotation subkey does not conform to the target Feature’s schema at the routed pillar: annotation subkey <subkey> is not declared at Feature <feature-uri> spec.schema.<pillar>.<subkey> (la sous-clé d’annotation n’est pas conforme au schéma de la Feature cible au pilier routé : la sous-clé d’annotation n’est pas déclarée dans le schéma de la Feature)

L’arrêt est levé sur l’annotation telle qu’elle est écrite, avant qu’elle ne soit développée en un rattachement de Feature, de sorte que le diagnostic nomme le document et la portée où la valeur a été écrite — la frontière et le composant pour une annotation côté Release, le chemin du composant pour une annotation côté Aggregate — ainsi que la clé d’annotation dont elle provient.

Une annotation injectée par un plugin de gouvernance est jugée de la même manière, et le diagnostic indique qui l’a écrite. Un plugin rattaché pour injecter des annotations définit sa valeur sur un composant de la Release, de sorte que la valeur est vérifiée exactement comme une valeur qu’un opérateur y aurait écrite — mais la ligne de la Release que désigne le diagnostic est une ligne que personne n’a écrite. Le diagnostic ajoute donc quel plugin a injecté la valeur et le rôle de gouvernance auquel il est rattaché, et la correction se trouve dans la décision de ce plugin plutôt que dans la Release.

Comment corriger : corrigez la valeur liée pour qu’elle satisfasse le sous-schéma déclaré, ou élargissez le schéma de cette propriété si la valeur est légitime. La variante de la sous-clé non déclarée est en général devancée par l’arrêt sur la cible de liaison décrit plus haut ; l’atteindre signifie que la liaison déclare le chemin et que le schéma de la Feature ne le contient pas, corrigez donc celui des deux qui est erroné. Lorsqu’un opérateur de composition intermédiaire rend un chemin non résoluble et que l’environnement d’exécution le rejette ensuite, restreignez le schéma pour exposer la propriété directement au chemin de la liaison.

An annotation subkey is not routed by its binding (Une sous-clé d’annotation n’est pas routée par sa liaison)

Une annotation que vous avez écrite porte des sous-clés sous une clé que revendique une liaison d’annotation du Manifest, et l’une de ces sous-clés est un nom que la liaison ne route pas : elle ne figure ni sous maps.infra ni sous maps.values. Chaque sous-clé est routée séparément, vers le chemin de Feature que la liaison déclare pour elle, de sorte qu’une sous-clé que la liaison ne nomme pas n’a nulle part où aller. Développer l’annotation sans elle laisserait hors du build une valeur que vous avez écrite sans que rien ne soit signalé, et une sous-clé à la graphie erronée en est la cause habituelle — le build s’arrête donc à la place, en nommant la sous-clé, la clé d’annotation sous laquelle elle a été écrite et chaque sous-clé que la liaison route.

L’arrêt est levé sur l’annotation telle qu’elle est écrite, avant qu’elle ne soit développée en un rattachement de Feature, comme pour les deux conditions voisines : « A bound annotation value does not conform to the target Feature’s schema (Une valeur d’annotation liée n’est pas conforme au schéma de la Feature cible) », plus haut, refuse une sous-clé que la liaison route lorsque la Feature refuse sa valeur, et « 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) », plus bas, refuse une sous-clé routée par le mauvais pilier. Une clé qu’aucune liaison ne revendique ne relève pas de cette condition : rien ne la route, et le build la laisse de côté.

Message émis, qui nomme le document et l’endroit où l’annotation a été écrite, la sous-clé, la clé d’annotation et les sous-clés que la liaison route :

annotation subkey is not routed by the annotation’s binding (Release <release-name>, at .spec.boundaries.<boundary>.annotations, "<subkey>", written under annotation "<key>", whose binding routes only "<subkey>, <subkey>") (la sous-clé d’annotation n’est pas routée par la liaison de l’annotation (Release : la sous-clé, écrite sous l’annotation dont la liaison ne route que les sous-clés indiquées))

Une annotation écrite dans un Aggregate est nommée de la même manière, à l’endroit où elle y a été écrite — (Aggregate <name>, at .spec.subsystems.<subsystem>.annotations, …) pour une annotation écrite sur un sous-système. Le build signale une annotation côté Release sous une étiquette OPS_ERROR et une annotation côté Aggregate sous une étiquette DEVELOPER_ERROR, d’après le document qui l’a écrite.

Comment corriger : comparez la sous-clé à celles que le message énumère. S’il s’agit d’une erreur de graphie, remplacez-la par la sous-clé que la liaison route. Si la valeur doit atteindre la Feature, la liaison doit la router : ajoutez le chemin à maps.infra ou à maps.values de la liaison dans le Manifest — un chemin que le schéma de la Feature déclare — ou retirez la sous-clé de l’annotation.

A bare annotation value does not route to exactly one path of its binding (Une valeur d’annotation simple n’est pas routée vers exactement un chemin de sa liaison)

Une annotation que vous avez écrite comme valeur simple — feature.aggrega.ai/monitoring: "30s" plutôt qu’une table de sous-clés — ne nomme aucune sous-clé, de sorte que rien en elle n’indique quel chemin de Feature elle remplit. Elle est placée au seul chemin que la liaison déclare, en comptant ensemble maps.infra et maps.values. Une liaison qui déclare plus d’un chemin laisse à la valeur plusieurs destinations et rien pour choisir entre elles, de sorte que le build s’arrête plutôt que d’en choisir une. Le compte porte sur les deux listes, de sorte qu’une liaison qui route un chemin par infra et un autre par values refuse une valeur simple quel que soit le document dans lequel elle est écrite.

L’arrêt est levé sur l’annotation telle qu’elle est écrite, avant qu’elle ne soit développée en un rattachement de Feature, comme pour les conditions voisines, de sorte que le diagnostic nomme le document et l’endroit où la valeur a été écrite. La vérification a lieu une fois par annotation que vous avez écrite : une valeur écrite sur une frontière ou un sous-système y est refusée, une seule fois, qu’un composant qu’elle contient la reprenne ou non. Chaque valeur de ce type dans le build est signalée, pas seulement la première. Le build signale une annotation côté Release sous une étiquette OPS_ERROR et une annotation côté Aggregate sous une étiquette DEVELOPER_ERROR, d’après le document qui l’a écrite. La condition est a scalar annotation value does not route to exactly one path of its binding, ce que aggrega explain affiche pour son code.

Message émis, qui nomme le document et l’endroit où l’annotation a été écrite, la clé d’annotation, la valeur et les chemins que la liaison route :

a scalar annotation value does not route to exactly one path of its binding (Release <release-name>, at .spec.boundaries.<boundary>.annotations, "<key>", carrying the bare value "<value>", whose binding routes "<path>, <path>, <path>") (une valeur d’annotation scalaire n’est pas routée vers exactement un chemin de sa liaison (Release : la clé porte une valeur simple, dont la liaison route les chemins indiqués))

Une valeur vide n’écrit rien ; elle est donc placée partout où l’une des deux listes contient un seul chemin, et refusée seulement là où aucune des deux n’en contient. Une liaison qui ne déclare aucun chemin est refusée au chargement du Manifest, car le schéma du Manifest en exige un, de sorte qu’un build n’atteint pas cette condition par ce biais.

Une annotation injectée par un plugin de gouvernance est jugée de la même manière, et son diagnostic ajoute quel plugin a injecté la valeur et le rôle de gouvernance auquel il est rattaché, comme le font les conditions voisines.

Comment corriger : écrivez l’annotation sous forme de table qui nomme la sous-clé à laquelle chaque valeur est destinée — feature.aggrega.ai/monitoring: {interval: 30s} — afin que chaque valeur soit routée par son propre nom ; ou donnez à la valeur unique une liaison qui lui est propre, sous une autre clé d’annotation, qui ne déclare que le chemin qu’elle remplit.

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)

Les annotations sont réparties par côté auteur, et cette répartition est la même que celle qui régit tout autre pilier écrit : une annotation côté Aggregate ne peut être routée que par un chemin de liaison ciblant values, et une annotation côté Release que par un chemin ciblant infra. Toute autre combinaison provoque un arrêt.

La répartition est ce qui empêche le raccourci des annotations de devenir un moyen d’écrire le pilier de l’autre côté. L’annotation d’un développeur apporte des values ; celle d’un opérateur apporte le dimensionnement infra. Une liaison qui déclare des chemins dans les deux piliers n’est pas en soi une erreur — chaque côté route le sous-ensemble qui lui est permis, et les chemins de l’autre côté ne lui sont tout simplement pas accessibles.

Une liaison qui déclare un même chemin dans les deux listes de piliers est le cas qui mène le plus souvent à cet arrêt. Le critère de départage du routage envoie un tel chemin par infra, ce qui le rend inaccessible depuis le côté Aggregate, et une annotation côté Aggregate routée vers lui s’arrête ici. L’avertissement qui signale cette structure de liaison avant qu’un build n’atteigne cet arrêt est décrit dans warnings.md.

Message émis :

annotation routes through a pillar its authoring side may not use: annotation <key> at <source> routes through pillar <pillar> at path <path>, but <side>-side annotations may only route through pillar <permitted-pillar> (l’annotation est routée par un pilier que son côté auteur ne peut pas utiliser : l’annotation est routée par un pilier à un chemin, mais les annotations de ce côté ne peuvent être routées que par le pilier permis)

Une annotation injectée par un plugin de gouvernance se trouve sur un composant de la Release ; c’est donc une annotation côté Release et la même répartition s’y applique. Son diagnostic ajoute quel plugin l’a injectée et le rôle de gouvernance auquel il est rattaché, parce que la clé de la Release qu’il désigne est une clé que personne n’a écrite.

Comment corriger : routez l’annotation depuis le côté dont la liaison cible le pilier, ou ajoutez une liaison — sous sa propre clé d’annotation — dont les chemins ciblent le pilier permis au côté auteur. Lorsqu’une liaison déclare le même chemin dans les deux listes de piliers, scindez-la en deux liaisons afin que chaque côté ait un chemin qu’il peut atteindre. Lorsque le diagnostic nomme un plugin qui injecte, l’annotation provient de la décision de ce plugin : corrigez le plugin, ou la liaison sous laquelle il injecte.

Authored values or infra do not conform to the declared schema (Les values ou infra écrits ne sont pas conformes au schéma déclaré)

Les values: ou infra: résolus d’une instance de composant — ou d’une Feature rattachée — ne sont pas conformes au schéma de catalogue déclaré. Le build valide chaque pilier par rapport à son schéma déclaré avant le rendu, de sorte qu’une clé mal saisie, une valeur de type incorrect, un nombre hors plage ou un champ obligatoire manquant est détecté à sa source plutôt que de produire un manifeste défectueux au moment du déploiement.

La vérification couvre les contraintes de schéma standard : une valeur du mauvais type (une chaîne là où le schéma déclare un entier), une valeur hors d’une plage déclarée ou d’un enum, une valeur qui ne satisfait pas un pattern déclaré, une chaîne qui n’est pas une instance valide de son format déclaré — l’un des formats nommés — et un champ obligatoire qui n’a pas été fourni. Un échec de format nomme le mot-clé et porte la valeur, le format et ce qui ne va pas — tel que aggrega pull et aggrega validate --release l’affichent pour un champ uri auquel on donne ::::, "format", "value \"::::\" is not a valid uri: a URI begins with a scheme followed by a colon, such as https:". Elle tient compte des valeurs par défaut : un champ auquel le schéma donne un default: est considéré comme fourni même lorsqu’il est omis, de sorte qu’un champ obligatoire doté d’une valeur par défaut ne déclenche jamais la vérification « manquant ».

Le pilier values est la surface de rédaction du développeur. Il est validé de façon fermée — une propriété que le schéma ne déclare pas est refusée comme probable faute de frappe. Un schéma values qui se compose au sein de son propre document (un #/$defs $ref local ou allOf) est résolu et validé par rapport à ce contexte de définitions.

Le pilier infra est la surface de dimensionnement de l’opérateur, et il n’est vérifié que lorsque le Component déclare un pilier schema.infra — cette déclaration est le contrat auquel le composant souscrit. Il est validé de façon fermée par rapport à cette déclaration et à rien d’autre, exactement comme le pilier values est validé par rapport à schema.values : une clé que le Component ne déclare pas est refusée comme faute de frappe, et une clé qu’il déclare voit son type et sa plage imposés. Un composant qui veut faire valider une clé superposée par le fournisseur, telle que replicas, déclare cette clé dans son propre schema.infra ; le vocabulaire accepté par un fournisseur s’atteint par le valuesMapping de sa Recipe plutôt que d’être superposé à la surface infra rédigée.

La vérification mesure le dimensionnement de chaque composant que la Release a placé, et une entrée qui n’écrit aucun bloc infra: est mesurée elle aussi : un bloc absent est un bloc vide, de sorte qu’une clé required: sans default: est signalée comme manquante — ce qui est précisément le cas qu’une telle clé existe pour détecter. Les deux façons de placer un composant comptent. Le nommer sous les components d’une frontière le place, et router sous aggregates le sous-module qui l’apporte le place aussi ; une entrée de routage place des composants sans rien dire d’aucun d’entre eux, de sorte qu’un composant placé ainsi part d’un bloc de dimensionnement vide et qu’une clé required: sans valeur par défaut sur son type est signalée comme manquante. Un composant que la Release ne place par aucune de ces deux voies n’est pas du tout mesuré par rapport à ce contrat. Il présente une autre faute, et le build signale celle-ci à la place : un composant qui n’est placé dans aucune frontière, avec les deux façons de le placer nommées.

Le contrat lie un composant où qu’il ait été rédigé : un composant qu’apporte un sous-module est mesuré exactement comme un composant que déclare l’Aggregate propre à la Release. La profondeur d’imbrication d’un composant ne change pas celles des contraintes de son type qui s’appliquent.

Les rattachements de Feature sont validés de la même façon, par rapport aux schema.values / schema.infra déclarés par la Feature rattachée. Les rattachements partagent une même surface, de sorte qu’une Feature d’identifiants de connexion — une Feature portant l’étiquette feature.aggrega.ai/kind: secret — est mesurée par rapport à son propre schéma déclaré exactement comme tout autre rattachement. La valeur vérifiée est le résultat fusionné effectif après la cascade des valeurs de rattachement à travers les portées (composant, sous-système, frontière et spécifique au composant) — de sorte qu’une valeur introduite légalement à une portée mais remplacée par une valeur illégale à une portée plus spécifique est détectée sur le résultat fusionné, et non sur le fragment. Un rattachement dont le type ne déclare aucun schéma n’est pas validé ; l’infra d’un rattachement est validé par rapport au schema.infra propre au rattachement (un rattachement est une surcouche et ne porte aucune union de fournisseurs).

Le constat d’un rattachement est signalé dans le document qui a écrit le pilier en échec, sous le nom de ce document, et classé sous son auteur. Ses values sont signalées au bloc de l’Aggregate qui les a écrites — l’entrée features: propre au composant, .spec.components.<component>.features.<attachment>.values.<field>, avant le bloc d’un sous-système qui atteint le composant — comme une faute du développeur. Son infra est signalé au bloc de la Release qui l’a écrit — l’entrée de la Release pour le composant, sous la frontière qui le nomme, avant le bloc features: propre à la frontière — comme une faute de l’opérateur. Un pilier que le document auquel il appartient n’a pas écrit est signalé là où le rattachement lui-même a été écrit, c’est-à-dire là où son type est nommé. Ainsi, un rattachement que seule la Release effectue, et qui ne porte pas de values, signale un champ qu’exigent les values de sa Feature à l’entrée de la Release et comme une faute de l’opérateur, à un chemin que la Release contient — l’entrée du composant, ou le bloc features: de la frontière pour un rattachement que la frontière effectue pour chaque composant qu’elle contient :

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

Le même rattachement écrit sur le composant dans l’Aggregate signale [DEVELOPER_ERROR E0168] à .spec.components.app.features.check.values.schema, sous le nom de l’Aggregate. Un éditeur affiche chacun sur le document qui l’a écrit, sur la clé la plus profonde de ce chemin que contient le document.

Un rattachement que porte une connexion est mesuré de la même façon, et signalé à l’entrée de connexion du document qui a écrit le pilier en échec plutôt qu’au bloc features: propre au composant, qui ne le contient pas. Ses values sont signalées à l’entrée de connexion de l’Aggregate, .spec.components.<component>.uses.<socket>.<alias>.features.<slot>.values.<field> — dans le document propre au sous-module, pour un composant qu’apporte un sous-module — et son infra à l’entrée de la Release pour cette connexion, sous la frontière qui nomme le composant lorsque la Release nomme des frontières. Un rattachement que seule la Release effectue est signalé à l’entrée de la Release pour les deux piliers : un tel rattachement ne porte pas de values, de sorte qu’une Feature dont les values exigent un champ le signale comme manquant à cet endroit, à l’entrée que l’opérateur a écrite.

La configuration de connexion par arête est validée de la même façon par rapport au contrat par arête du socket : les values d’une arête rédigées par le développeur par rapport au valueSchema du socket, et l’infra d’une arête rédigé par l’opérateur (depuis une Release) par rapport à l’infraSchema du socket. Un socket qui ne déclare aucun schéma par arête pour un pilier n’accepte aucune configuration validée pour celui-ci (omission = aucun contrat, rien à vérifier). Le diagnostic nomme l’arête par consommateur, socket et alias. Sur un composant que déclare l’Aggregate propre à la Release, l’infra de l’opérateur est mesuré pour chaque entrée que la Release écrit pour l’une de ses connexions — y compris une entrée qui ne porte aucun infra, ce qui permet de signaler comme manquante une clé required: sans valeur par défaut — et signalé à cette entrée dans la Release, sous la frontière qui nomme le composant lorsque la Release nomme des frontières, c’est-à-dire là où l’opérateur le modifie ; les values du développeur sont signalées à l’entrée de connexion dans l’Aggregate.

Une feuille déclarée sensitive: true voit son échec de contrainte retenu. Le texte de l’échec cite la valeur fautive, et un diagnostic de build est lu par quiconque observe le build ; aussi, sur une feuille déclarée sensible — ou n’importe où à l’intérieur d’un objet déclaré sensible — le <constraint failure> ci-dessous se lit <redacted> à la place. Il en va de même à une position qui contient une feuille déclarée sensible sous elle, le pilier lui-même compris : un $ref écrit à côté d’autres mots-clés est vérifié en entier là où il est écrit, de sorte qu’un échec à l’intérieur de la définition qu’il nomme est signalé à cette position et citerait sinon la valeur de la feuille. L’entité, le chemin du champ, le pilier et le nom du contrat sont toujours tous nommés, de sorte que le diagnostic vous indique toujours où se trouve l’échec ; seul le texte qui reproduirait la valeur est retiré. La sensibilité se lit par pilier, de sorte qu’une feuille nommée de la même façon dans values et infra n’est retenue que dans le pilier qui la déclare.

Message émis :

authored pillar does not conform to its declared schema (Aggregate <name>, at .spec.components.<component>.values.<field>, “values.<field>”, “<keyword>”, “<constraint failure>”) (le pilier rédigé n’est pas conforme à son schéma déclaré) authored pillar does not conform to its declared schema (Release <release-name>, at .spec.components.<component>.infra.<field>, “infra.<field>”, “<keyword>”, “<constraint failure>”) (le pilier rédigé n’est pas conforme à son schéma déclaré) authored pillar does not conform to its declared schema (Aggregate <name>, at .spec.components.<component>.features.<attachment>.values.<field>, values pillar does not conform to the Feature schema: <constraint failure>) (le pilier rédigé n’est pas conforme à son schéma déclaré : le pilier values n’est pas conforme au schéma de la Feature) authored pillar does not conform to its declared schema (Release <release-name>, at .spec.boundaries.<boundary>.components.<component>.features.<attachment>.infra.<field>, infra pillar does not conform to the Feature schema: <constraint failure>) (le pilier rédigé n’est pas conforme à son schéma déclaré : le pilier infra n’est pas conforme au schéma de la Feature) authored pillar does not conform to its declared schema (Release <release-name>, at .spec.boundaries.<boundary>.features.<attachment>.values.<field>, values pillar does not conform to the Feature schema: <constraint failure>) (le pilier rédigé n’est pas conforme à son schéma déclaré : le pilier values n’est pas conforme au schéma de la Feature) authored pillar does not conform to its declared schema (Aggregate <name>, at .spec.components.<component>.uses.<socket>.<alias>.values.<field>, “values.<field>”, “<keyword>”, “<constraint failure>”) (le pilier rédigé n’est pas conforme à son schéma déclaré) authored pillar does not conform to its declared schema (Aggregate <name>, at .spec.components.<component>.uses.<socket>.<alias>.features.<slot>.values.<field>, values pillar does not conform to the Feature schema: <constraint failure>) (le pilier rédigé n’est pas conforme à son schéma déclaré : le pilier values n’est pas conforme au schéma de la Feature) authored pillar does not conform to its declared schema (Release <release-name>, at .spec.components.<component>.uses.<socket>.<alias>.features.<slot>.values.<field>, values pillar does not conform to the Feature schema: <constraint failure>) (le pilier rédigé n’est pas conforme à son schéma déclaré : le pilier values n’est pas conforme au schéma de la Feature) authored pillar does not conform to its declared schema (Release <release-name>, at .spec.boundaries.<boundary>.components.<component>.uses.<socket>.<alias>.infra.<field>, “infra.<field>”, “<keyword>”, “<constraint failure>”) (le pilier rédigé n’est pas conforme à son schéma déclaré)

Comment corriger : corrigez la valeur fautive pour qu’elle satisfasse le schéma déclaré, ou — si la valeur est légitime — élargissez le schéma qui la déclare (les schema.values/schema.infra du Component, ou ceux de la Feature rattachée) pour qu’il la déclare. Inspectez le schéma déclaré d’un Component avec aggrega inspect <component-type> pour voir les types exacts, les plages, les valeurs par défaut et les champs obligatoires qu’attend chaque pilier.

A declared schema contract cannot be read as a schema (Un contrat de schéma déclaré ne peut pas être lu comme un schéma)

Un Component ou une Feature déclare un contrat de schéma qui ne fournit rien par rapport à quoi valider, de sorte que la configuration qu’il couvre est mesurée par rapport à rien. Trois contrats peuvent porter la faute, chacun rédigé dans son propre champ : le spec.schema propre à l’entité, et les deux contrats par arête que déclare un socket de dépendance — valueSchema pour le côté développeur d’une connexion et infraSchema pour celui de l’opérateur. Une entrée de SchemaLibrary, que ces contrats peuvent référencer, peut aussi porter la troisième des fautes ci-dessous ; la façon dont ce cas est signalé est exposée plus loin.

Trois fautes mènent à cet arrêt, et deux d’entre elles passent facilement inaperçues parce que le contrat semble correct. Un contrat de socket peut ne pas compiler du tout en JSON Schema 2020-12 — un mot-clé mal saisi en est la cause la plus courante ; un spec.schema propre à une entité qui ne compile pas est signalé à la place sous la condition de forme compacte rencontrée par sa compilation (E0120 pour un mot-clé inconnu, E0116 pour une contrainte que son type n’accepte pas). Ou il peut compiler proprement et ne construire pourtant aucun validateur : le corps est lisible comme forme compacte et n’est pas un schéma par rapport auquel quoi que ce soit puisse être validé, comme un scalaire simple là où doit figurer le schéma d’une propriété (items: nonsense). Ou il peut être bien formé à tous les autres égards et nommer un format hors de l’ensemble pris en charge — format: password, ou une faute de graphie telle que format: emial — qui est refusé plutôt que lu comme une contrainte qui ne vérifie rien, qu’une valeur atteigne le champ ou non ; les noms que peut prendre un format sont listés sous Formats nommés. Les trois forment une seule condition, car le remède est le même et laisser passer l’une d’elles a la même conséquence.

Ne déclarer aucun contrat et en déclarer un qui ne peut pas être lu sont deux situations différentes, et le build les traite différemment. Un champ qui ne déclare rien est ignoré : la conformité par pilier et par arête est optionnelle, de sorte qu’un socket qui ne contraint aucun des deux piliers relève de la rédaction ordinaire et ne suscite aucun diagnostic. Un champ qui déclare quelque chose d’illisible est refusé. Le laisser passer laisserait non validée chaque charge utile qu’il couvre pendant que le build annoncerait un succès — une vérification qui a cessé de s’exécuter sans rien pour dire qu’elle a cessé. C’est donc le refus qui sépare les deux : le silence signifie qu’il n’y avait rien à vérifier, et un arrêt signifie qu’il y avait quelque chose et qu’il n’a pas pu être lu.

Le refus nomme l’entité qui a déclaré le contrat plutôt que le document qui a écrit la configuration, car c’est là que va la correction. L’auteur d’un Aggregate à qui l’on remet un type de composant dont le contrat ne peut pas être lu n’a rien à changer dans son propre fichier. Le refus survient pendant la lecture du catalogue, où l’entité déclarante, le pilier, le champ rédigé et la ligne source sont tous connus — de sorte que la même faute est signalée de façon identique, que vous l’atteigniez depuis un build, depuis aggrega validate ou depuis l’outil de build qu’expose aggrega mcp. Un contrat que l’entité lit par $import: — son spec.schema entier, l’un de ses piliers, ou le contrat d’un socket — est signalé au fichier importé : l’emplacement nomme ce fichier et la ligne de celui-ci où le fragment est écrit, tandis que le message nomme toujours l’entité et le champ qui a déclaré le contrat. Les arrêts de forme compacte que rencontre le spec.schema propre à une entité sont localisés de la même façon.

Une entrée de SchemaLibrary qui nomme un format hors de l’ensemble pris en charge mène à cet arrêt lors de la lecture de sa bibliothèque, et le refus nomme la bibliothèque et l’entrée et pointe vers l’entrée dans le fichier de la bibliothèque. aggrega validate sur l’ensemble du catalogue lit chaque bibliothèque, de sorte qu’il signale l’entrée qu’un schéma la référence ou non, tandis qu’une Release dont la résolution des dépendances n’atteint jamais la bibliothèque ne la lit pas. Une Release dont les schémas atteignent bien l’entrée par un $ref: est refusée elle aussi, mais le refus ne nomme pas le format : aggrega pull signale la bibliothèque comme introuvable dans le catalogue (E0114), et aggrega validate --release signale la cible de la référence comme introuvable (E0121). Exécutez aggrega validate sur le catalogue pour voir l’entrée et le nom fautif.

Le message porte l’échec tel que l’a signalé l’outil qui l’a rencontré : pour un échec de compilation, la clé à l’intérieur du contrat, la ligne source et le mot-clé fautif ; pour un corps qui ne construit aucun validateur, la position que le validateur a refusée ; pour un nom de format hors de l’ensemble pris en charge, le champ, le mot-clé format, le nom tel qu’il est écrit et chaque nom pris en charge. Un $ref: inter-documents dans un contrat de socket dont l’entrée de SchemaLibrary n’est pas dans la fermeture chargée mène au même arrêt lorsque aggrega validate vérifie l’entité ou la Release ; dans le spec.schema propre à une entité, il est signalé comme le décrit « A $ref: is not written in a form the compiler can resolve (Une référence n’est pas écrite sous une forme que le compilateur peut résoudre) » ci-dessus. aggrega pull lit les deux emplacements pour les bibliothèques dont une Release a besoin, de sorte qu’une bibliothèque absente du catalogue arrête le pull plus tôt, comme le décrit « A reference names no entity the catalog holds (Une référence ne nomme aucune entité que contient le catalogue) » (E0114), quel que soit celui des deux qui la référence — et une bibliothèque que contient le catalogue est épinglée dans le fichier de verrouillage pour l’un comme pour l’autre.

Une contrainte bien formée à côté d’une contrainte illisible n’est pas appliquée. Un contrat est lu comme un seul document, de sorte qu’un unique fragment illisible désactive chaque contrainte déclarée à ses côtés. C’est pourquoi l’arrêt vaut plus que les contraintes qu’il coûte : l’alternative est un contrat qui semble appliqué, se lit comme appliqué et n’applique rien.

Message émis, qui nomme l’entité avec sa version et le champ qui déclare le contrat, puis le pilier que ce contrat contraint, puis l’échec — ici un contrat de socket contenant un mot-clé mal orthographié :

declared schema contract could not be compiled into a usable schema, so nothing was validated against it: correct the contract where it is declared, or remove it if the configuration it covers needs no validation. Component "<type>:<version>": spec.usesSchema.<socket>.valueSchema declares a schema no validator can be built from, so the values it constrains would go unmeasured: compactform at <key>:<line> (keyword "<keyword>"): unknown keyword (le contrat de schéma déclaré n’a pas pu être compilé en un schéma utilisable, donc rien n’a été validé par rapport à lui : corrigez le contrat là où il est déclaré, ou supprimez-le si la configuration qu’il couvre ne nécessite aucune validation. Component : spec.usesSchema.valueSchema du socket déclare un schéma à partir duquel aucun validateur ne peut être construit, donc les valeurs qu’il contraint ne seraient pas mesurées : compactform à la clé et à la ligne indiquées : mot-clé inconnu)

et un nom de format hors de l’ensemble pris en charge dans le pilier values d’un Component :

declared schema contract could not be compiled into a usable schema, so nothing was validated against it: correct the contract where it is declared, or remove it if the configuration it covers needs no validation. Component "<type>:<version>": spec.schema.values declares a schema no validator can be built from, so the values it constrains would go unmeasured: validator/jsonschema: schema resolution failed (at values.<field>, keyword "format", format "<format>" is not supported; the supported formats are email, uri, hostname, ipv4, ipv6, uuid, date-time, date) (le contrat de schéma déclaré n’a pas pu être compilé en un schéma utilisable, donc rien n’a été validé par rapport à lui : corrigez le contrat là où il est déclaré, ou supprimez-le si la configuration qu’il couvre ne nécessite aucune validation. Component : spec.schema.values déclare un schéma à partir duquel aucun validateur ne peut être construit, donc les valeurs qu’il contraint ne seraient pas mesurées : validator/jsonschema : échec de la résolution du schéma (au champ sous values, mot-clé format : le format n’est pas pris en charge ; les formats pris en charge sont email, uri, hostname, ipv4, ipv6, uuid, date-time, date))

Une Feature est désignée par Feature "<name>:<version>", le contrat d’un socket par son propre champ, par exemple spec.usesSchema.<socket>.infraSchema, et le pilier par celui que le contrat contraint — values, infra ou provides. aggrega validate, lorsqu’il reçoit le fichier propre à l’entité, nomme l’entité sans sa version. Une entrée de SchemaLibrary est désignée par sa bibliothèque et son entrée :

declared schema contract could not be compiled into a usable schema, so nothing was validated against it: correct the contract where it is declared, or remove it if the configuration it covers needs no validation. SchemaLibrary "<library>": schema "<entry>" names a format no validator can check, so the values it constrains would go unmeasured: validator/jsonschema: schema resolution failed (at <field>, keyword "format", format "<format>" is not supported; the supported formats are email, uri, hostname, ipv4, ipv6, uuid, date-time, date) (le contrat de schéma déclaré n’a pas pu être compilé en un schéma utilisable, donc rien n’a été validé par rapport à lui : corrigez le contrat là où il est déclaré, ou supprimez-le si la configuration qu’il couvre ne nécessite aucune validation. SchemaLibrary : le schéma nomme un format qu’aucun validateur ne peut vérifier, donc les valeurs qu’il contraint ne seraient pas mesurées : validator/jsonschema : échec de la résolution du schéma (au champ indiqué, mot-clé format : le format n’est pas pris en charge ; les formats pris en charge sont email, uri, hostname, ipv4, ipv6, uuid, date-time, date))

Comment corriger : ouvrez le champ que nomme le diagnostic et corrigez le fragment à la clé et à la ligne signalées — le plus souvent un mot-clé mal orthographié, à vérifier par rapport au vocabulaire des mots-clés dans vocabulary/compact-form-authoring.md, ou une valeur écrite là où doit figurer un schéma imbriqué. Lorsque l’échec nomme un format non pris en charge, écrivez l’un des formats nommés ou supprimez le format: ; un champ contenant des données secrètes déclare plutôt sensitive: true, car password n’est pas un format. Pour une entrée de SchemaLibrary, la correction se fait dans le fichier de bibliothèque que nomme le diagnostic. Lorsque l’échec nomme une référence entre documents, vérifiez que l’entrée de SchemaLibrary existe et que la bibliothèque est accessible depuis la fermeture des dépendances de la Release. Si la configuration couverte par ce champ ne nécessite réellement aucune validation, supprimez le champ plutôt que de laisser un contrat que rien ne peut lire.

Recipe source: is an empty string (Le champ source de la Recipe est une chaîne vide)

Une Recipe déclare source: "" — une chaîne vide. Le source: d’une Recipe choisit entre deux modes de rédaction : le mode sourceless, où il n’y a aucun artefact externe et où la sortie est produite entièrement à partir des autres types d’entrée de la Recipe, et le mode sourced, où source: nomme un chart, un module ou un fichier externe à partir duquel effectuer le rendu. Omettre le champ sélectionne le premier, une valeur non vide sélectionne le second, et une chaîne vide ne sélectionne ni l’un ni l’autre — il s’agit donc d’une ambiguïté plutôt que d’une valeur porteuse de sens. Un source: écrit comme null équivaut à l’omettre.

La Recipe est refusée au lieu que le compilateur choisisse à votre place l’une des deux lectures. La façon la plus courante d’écrire un source: vide est de supprimer un URI en laissant la clé : le mode sourced était voulu, et admettre la chaîne vide comme sourceless livrerait le composant sans l’artefact sans jamais dire laquelle des deux lectures a été retenue.

Cette règle est vérifiée au chargement de la Recipe, en lisant la valeur exactement telle que vous l’avez écrite, de sorte que chaque commande qui charge la Recipe nomme cette condition avant que quoi que ce soit tente d’utiliser la valeur vide. aggrega validate sur le fichier de la Recipe la refuse ; aggrega pull, un build, aggrega validate --release et l’outil de build qu’expose aggrega mcp la signalent pour une Release qui atteint la Recipe, avant la référence à la Recipe qui, de ce fait, n’a plus pu être résolue. Un pull nomme donc cette condition au lieu de signaler la référence vide comme une référence dont il ne peut déterminer le type de source. Elle est vérifiée avant les règles qui lisent si une source est déclarée, de sorte qu’une Recipe dont le source: est vide se voit signaler le source: plutôt qu’un valuesMapping sans rien à superposer ou un type d’entrée manquant.

Message émis, positionné sur le fichier de la Recipe dans lequel le source: vide a été écrit et sur la clé qu’il contient — .spec.source — plutôt que sur un composant qui lie la Recipe, car l’entrée est partagée par tous les composants qui le font :

recipe source is an empty string, which names neither sourceless mode nor sourced mode (Recipe <name>:<version>, at .spec.source). omit the source field for sourceless mode, or name a non-empty path or URI for sourced mode (le champ source de la recette est une chaîne vide, qui ne nomme ni le mode sourceless ni le mode sourced. omettez le champ source pour le mode sourceless, ou nommez un chemin ou un URI non vide pour le mode sourced)

Le build affiche la ligne sous une balise CATALOG_ERROR avec le code court de cette condition, E0251, et le fichier de la Recipe à côté.

Comment corriger : omettez entièrement le champ source: (ou définissez-le à null) si la Recipe est sourceless, ou fournissez un chemin / URI / objet source structuré non vide si la Recipe est sourced.

No Recipe is mapped for a component or feature instance (Aucune Recipe n’est mappée pour une instance de composant ou de fonctionnalité)

Le type d’une instance n’a aucun mappage de Manifest qui se résolve en une Recipe que contient le catalogue. La sélection de la Recipe se fait uniquement par mappage : le compilateur ne choisit jamais une Recipe en lisant spec.implements: et en choisissant parmi les candidates, donc un type non mappé provoque l’arrêt, quel que soit le nombre de Recipes qui l’implémentent. implements éclaire le choix ; l’auteur le fait ; le Manifest l’enregistre.

La même condition couvre un mappage qui existe mais ne mène nulle part — une valeur sous une structure de référence acceptée qui nomme une Recipe que le catalogue ne contient pas, y compris une Recipe présente sous une autre version que celle qu’épingle la valeur, et une dont le nom nu est proposé à la fois par deux capacités. Aucune ne se résout en une Recipe dont on puisse dire que l’auteur l’a choisie. Une valeur de mappage dont aucune référence ne peut exprimer la structure est signalée à part, sous « Manifest mapping value is not a shape a recipe reference accepts (La valeur de mappage du Manifest n’a pas une structure qu’une référence de recette accepte) » plus haut, de sorte que l’affirmation qu’une entité est absente n’est jamais faite qu’à propos d’une référence qui aurait pu se résoudre.

Messages émis, pour une instance de composant. Lorsqu’un mappage existe et nomme quelque chose d’absent :

no recipe resolved for component/feature instance: add an explicit Manifest mapping for its type (Manifest, at .spec.components.<instance>, "<instance>", of type "<type>", mapped to recipe "<uri>"). correct the mapping value in the Manifest, or publish the recipe it names (aucune recette résolue pour l’instance de composant/fonctionnalité : ajoutez un mappage de Manifest explicite pour son type (Manifest, avec l’instance, son type et la recette vers laquelle elle est mappée). corrigez la valeur de mappage dans le Manifest, ou publiez la recette qu’elle nomme)

Lorsqu’aucun mappage n’existe et que des Recipes implémentant le type sont présentes, elles sont listées comme les candidates à épingler :

no recipe resolved for component/feature instance: add an explicit Manifest mapping for its type (Manifest, at .spec.components.<instance>, "<instance>", of type "<type>", recipes implementing it "<recipe-uris>"). pin one of them in the Manifest (aucune recette résolue pour l’instance de composant/fonctionnalité : ajoutez un mappage de Manifest explicite pour son type (Manifest, avec l’instance, son type et les recettes qui l’implémentent). épinglez-en une dans le Manifest)

Et lorsque rien n’implémente le type, il n’y a rien à lister :

no recipe resolved for component/feature instance: add an explicit Manifest mapping for its type (Manifest, at .spec.components.<instance>, "<instance>", of type "<type>"). no recipe in the catalog implements this type; write one, then map the type to it (aucune recette résolue pour l’instance de composant/fonctionnalité : ajoutez un mappage de Manifest explicite pour son type (Manifest, avec l’instance et son type). aucune recette du catalogue n’implémente ce type ; écrivez-en une, puis mappez le type vers elle)

Dans un espace de travail qui ne nomme aucun répertoire de catalogue, les Recipes recherchées sont uniquement celles que le lockfile épingle : celles d’un registre ne sont pas listées, et un Manifest qui n’en mappe aucune pour le type n’en épingle aucune. Dans ce cas, lorsqu’aucune Recipe épinglée n’implémente le type, l’absence est constatée au regard des épinglages plutôt que du catalogue, et le message le précise :

no recipe resolved for component/feature instance: add an explicit Manifest mapping for its type (Manifest, at .spec.components.<instance>, "<instance>", of type "<type>"). no recipe the lockfile pins implements this type; with no catalog directory, the recipes searched are only those the lockfile pins, not a registry’s; pin one a registry publishes in the Manifest, or write one, then map the type to it (aucune recette résolue pour l’instance de composant/fonctionnalité : ajoutez dans le Manifest un mappage explicite pour son type (Manifest, à l’emplacement, pour l’instance et du type indiqués). aucune recette épinglée par le lockfile n’implémente ce type ; sans répertoire de catalogue, les recettes recherchées sont uniquement celles que le lockfile épingle, pas celles d’un registre ; épinglez dans le Manifest une recette publiée par un registre, ou écrivez-en une, puis mappez le type vers celle-ci)

Un type que l’Aggregate écrit sans version se voit proposer les Recipes implémentant la version à laquelle le build le compile — la version la plus élevée de ce Component que contient le catalogue. Une instance de core/datastore/postgres, le catalogue contenant ce Component en 1.0.0, se voit proposer toute Recipe déclarant spec.implements: core/datastore/postgres:1.0.0, ainsi que toute Recipe déclarant le type sans version ou une plage caret qui admet 1.0.0. Un type dont le catalogue ne contient aucun Component ne se voit proposer que les Recipes déclarant ce type sans version lui-même.

Une instance de fonctionnalité signale ces cas sous une forme qui lui est propre, chacun après la phrase de la condition. Un type de fonctionnalité que l’Aggregate écrit sans version est mis en correspondance comme l’est un type de composant, à la version à laquelle le build le compile — la version la plus élevée de cette Feature que contient le catalogue —, et un message qui nomme <type>:<version> nomme le type à cette version, c’est-à-dire ce qui a été recherché dans le catalogue. Lorsque la Recipe vers laquelle est mappé le composant d’un rattachement est connue, les FeatureRecipes sont départagées par la capacité à laquelle cette Recipe se lie : celles qui se lient à la capacité du composant sont proposées en premier, et une FeatureRecipe qui se lie à une autre capacité est tout de même rendue, comme sa propre sortie à côté de celle du composant plutôt qu’à l’intérieur de celle-ci ; ainsi, lorsqu’aucune ne se lie à la capacité du composant, ce sont celles-là qui sont proposées à la place. Un mappage qui ne mène nulle part se lit feature "<instance>" (type "<type>"): the Manifest maps it to feature recipe "<uri>", which is not in the catalog. Lorsque des FeatureRecipes implémentent le type pour la capacité du composant, seules celles-ci sont listées : feature "<instance>" (type "<type>"); feature recipes implementing it for capability "<capability>", the capability its component's Recipe binds to: [<recipe-uris>]; pin one in the Manifest. Lorsqu’elles ne l’implémentent que pour d’autres capacités : feature "<instance>" (type "<type>"); no feature recipe in the catalog implements <type>:<version> for capability "<capability>", the capability its component's Recipe binds to; feature recipes implementing it for other capabilities: [<recipe-uris>]; pin one of those in the Manifest, and it renders as its own output beside the component's, or write one for "<capability>", then map the type to it. Lorsqu’aucune n’implémente le type : feature "<instance>" (type "<type>"); no feature recipe in the catalog implements <type>:<version>; write one, then map the type to it. Et lorsque la capacité n’est pas connue — le mappage propre du composant ne se résout en aucune Recipe, ce qui est signalé séparément, ou le rattachement est écrit sur une frontière, dont les composants peuvent être rendus par plusieurs capacités —, chaque implémentation est listée : feature "<instance>" (type "<type>"); feature recipes implementing it: [<recipe-uris>]; pin one in the Manifest. Dans un espace de travail qui ne nomme aucun répertoire de catalogue, les FeatureRecipes recherchées sont uniquement celles que le lockfile épingle : celles d’un registre ne sont pas listées, et un Manifest qui n’en mappe aucune pour le type n’en épingle aucune. L’absence y est alors constatée au regard des épinglages plutôt que du catalogue, et les messages le précisent. Lorsqu’aucune n’implémente le type : feature "<instance>" (type "<type>"); no feature recipe the lockfile pins implements <type>:<version> for capability "<capability>", the capability its component's Recipe binds to; with no catalog directory, the feature recipes searched are only those the lockfile pins, not a registry's; pin one a registry publishes in the Manifest, where one for another capability renders as its own output beside the component's, or write one for "<capability>", then map the type to it — et lorsque la capacité n’est pas connue, le message n’en nomme aucune et se termine par pin one a registry publishes in the Manifest, or write one, then map the type to it. Lorsque des FeatureRecipes épinglées ne l’implémentent que pour d’autres capacités, le message pour ce cas indique no feature recipe the lockfile pins implements au lieu de no feature recipe in the catalog implements, avec la même proposition après la capacité.

Comment corriger : ajoutez le mappage que demande le message, sous spec.mappings.components.type dans le Manifest, avec le type de composant comme clé et la Recipe comme valeur. Lorsque le message liste des candidates, choisissez-en une — cette liste correspond exactement aux Recipes qui déclarent implémenter le type à la version vers laquelle le build le résout. Lorsqu’il nomme une Recipe absente du catalogue, corrigez la valeur ou ajoutez la Recipe à un répertoire de catalogue que lit le build ; une version dans la valeur doit correspondre à une version que contient le catalogue. Lorsque rien n’implémente le type, la pièce manquante est la Recipe elle-même. Lorsque le message indique que les recettes ou recettes de fonctionnalité recherchées sont uniquement celles que le lockfile épingle, l’espace de travail ne lit aucun répertoire de catalogue, si bien qu’un registre peut tout de même publier une Recipe ou une FeatureRecipe qui implémente le type : c’est le mappage du type vers celle-ci dans le Manifest qui amène le pull à la récupérer et à l’épingler.

A Manifest name mapping names nothing in the build (Un mappage par nom du Manifest ne nomme rien dans le build)

Une clé sous spec.mappings.components.name ou spec.mappings.features.name ne nomme aucune instance de composant, ni aucun rattachement, que contient le build. Le niveau name est comparé au nom exact de ce qui est réalisé : une clé components.name au nom d’une instance de composant tel que l’Aggregate l’écrit, et une clé features.name au nom propre d’un rattachement — la clé sous laquelle il est écrit dans les features: d’un composant, ou <alias>.<slot> pour un rattachement écrit sur une connexion — jamais au nom du composant sur lequel se trouve le rattachement. Une clé qui ne nomme rien ne serait jamais consultée : chaque instance à laquelle elle était destinée se résoudrait par le niveau type, et le build se terminerait sans un mot sur l’entrée qu’il a ignorée. Le build s’arrête donc à la place, avant tout rendu.

Le message nomme le Manifest, la clé et la section dans laquelle elle est écrite, les noms de cette nature que le build contient effectivement — restreints au type qu’implémente la Recipe ou la FeatureRecipe de l’entrée, lorsque ce type est connu et que le build en contient un — et, lorsqu’il peut le déterminer, le nom que vous vouliez probablement dire : pour une clé features.name qui est le nom d’un composant, les rattachements de ce type que porte le composant ; pour une clé components.name qui est le nom d’un rattachement, le composant qui le porte ; et sinon un nom à une modification près.

Message émis, pour une clé features.name écrite comme le nom du composant sur lequel se trouve le rattachement :

a Manifest name mapping’s key names no component instance or attachment in this build, so the entry binds nothing: Manifest "<manifest>", key "<component>" under mappings.features.name: no attachment in this build is named "<component>"; a features.name key names an attachment by its own name — the key it is written under in a component’s features, or <alias>.<slot> for one written on a connection — never the component it is attached to; attachments of type "<feature-type>" in this build: "<attachments>"; "<component>" is a component, and a features.name key names the attachment rather than the component it is attached to — did you mean "<attachment>"? (la clé d’un mappage par nom du Manifest ne nomme aucune instance de composant ni aucun rattachement dans ce build, donc l’entrée ne lie rien : Manifest, clé sous mappings.features.name : aucun rattachement de ce build ne porte ce nom ; une clé features.name nomme un rattachement par son propre nom — la clé sous laquelle il est écrit dans les features d’un composant, ou l’alias et l’emplacement pour un rattachement écrit sur une connexion — jamais le composant auquel il est rattaché ; rattachements du type indiqué dans ce build : listés ; ce nom est un composant, et une clé features.name nomme le rattachement plutôt que le composant auquel il est rattaché — vouliez-vous dire le rattachement suggéré ?)

Et pour une clé components.name à une modification près du nom d’une instance :

a Manifest name mapping’s key names no component instance or attachment in this build, so the entry binds nothing: Manifest "<manifest>", key "<key>" under mappings.components.name: no component instance in this build is named "<key>"; a components.name key names a component instance exactly as the Aggregate writes it; component instances of type "<component-type>" in this build: "<instances>"; did you mean "<instance>"? (la clé d’un mappage par nom du Manifest ne nomme aucune instance de composant ni aucun rattachement dans ce build, donc l’entrée ne lie rien : Manifest, clé sous mappings.components.name : aucune instance de composant de ce build ne porte ce nom ; une clé components.name nomme une instance de composant exactement comme l’Aggregate l’écrit ; instances de composant du type indiqué dans ce build : listées ; vouliez-vous dire l’instance suggérée ?)

Chaque clé qui ne nomme rien est signalée en un seul build, dans l’ordre où le Manifest les écrit.

Comment corriger : renommez la clé avec le nom que suggère le message, ou avec l’un des noms qu’il liste — pour un rattachement, le nom sous lequel il est écrit, et non celui de son composant. Si l’entrée n’est plus voulue, supprimez-la ; les instances de ce type se résolvent alors par le niveau type.

A Manifest maps two version-distinct keys onto one type (Un Manifest associe deux clés de versions distinctes à un même type)

Une recherche par type a trouvé plus d’une clé de mappage du Manifest. Les clés de type sont comparées avec tolérance de version, si bien que core/api-server, core/api-server:1.0.0 et core/api-server:2.0.0, écrites comme des clés de mappage distinctes, répondent toutes pour le même type de base — et une recherche qui en atteint deux a deux Recipes entre lesquelles choisir et aucune règle pour en préférer une.

Le build s’arrête au lieu de résoudre la clé qu’il se trouve avoir lue en premier. En choisir une rendrait la sortie générée dépendante de l’ordre dans lequel le mappage a été parcouru, ce qui est précisément ce qu’une sortie identique octet par octet exclut.

Message émis :

manifest maps multiple version-distinct keys to the same base type; the type-to-recipe lookup is ambiguous: type "<type>" matches version-distinct keys [<keys>] — pin the authored type’s version or remove the duplicate mapping keys (le Manifest associe plusieurs clés de versions distinctes au même type de base ; la recherche du type vers la Recipe est ambiguë : le type correspond à des clés de versions distinctes — épinglez la version du type écrit ou supprimez les clés de mappage en double)

Comment corriger : deux directions, et le message nomme les deux. Supprimez les clés de mappage en double, en gardant celle qui doit répondre pour le type — c’est la bonne solution lorsque les clés supplémentaires sont des restes d’une montée de version. Ou épinglez la version du côté de l’écriture, afin que le type que le composant déclare nomme exactement la clé que vous vouliez, ce qui est la bonne solution lorsque les différentes clés sont délibérées et que différents composants veulent réellement des Recipes différentes.

Two catalog entities in one directory share an identity (Deux entités de catalogue dans un même répertoire partagent une identité)

Deux entités du même type, chargées depuis le même répertoire de catalogue, portent la même identité. Une identité est ce que nomme une référence, donc deux fichiers revendiquant une même identité laissent à chaque référence vers elle deux réponses.

Au sein d’un répertoire, cela arrête le build ; d’un répertoire à l’autre, non. La même identité présente dans deux répertoires de catalogue différents est résolue par un masquage où le premier l’emporte — le répertoire listé en premier l’emporte — et c’est ce qui permet à un répertoire local de remplacer délibérément une entité publiée. Seule une collision à l’intérieur d’un même répertoire est une erreur d’écriture qu’aucune lecture ne rend intentionnelle.

La règle est la même pour chaque type d’entité indexé : Component, Feature, Recipe, FeatureRecipe, Plugin, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary et Aggregate. L’arrêt est positionné sur le second fichier et nomme le type et l’identité qui sont entrés en collision.

Message émis :

duplicate entity identity within a single catalog directory (Component identity "<identity>") (identité d’entité en double dans un même répertoire de catalogue (identité de Component))

avec le mot propre au type à la place de Component — recipe identity, feature recipe identity, Plugin identity, SchemaLibrary identity et ainsi de suite.

Comment corriger : renommez l’une des deux entités, ou déplacez-la dans un répertoire qui lui est propre. Pour une Recipe ou une FeatureRecipe, l’identité inclut la portée du fournisseur et la version, de sorte que deux fichiers qui ne diffèrent que par la version n’entrent pas en collision — une véritable collision signifie alors que la même version a été publiée deux fois. La cause habituelle est de copier le fichier d’une entité pour en commencer une nouvelle et d’oublier de modifier metadata.name.

Deux emplacements sont lus comme un tout plutôt qu’un fichier à la fois : un répertoire de catalogue, dont tout document situé en dessous peut fournir la réponse à une recherche par nom, et le répertoire contenant une Release, par rapport aux Aggregates et aux Manifests duquel est résolue une Release qui les nomme par identité. Un lien symbolique parmi ces fichiers peut mener n’importe où sur la machine, donc chacun de ces répertoires a un répertoire dans lequel ses lectures doivent rester, et un lien qui en sort n’est pas lu. La frontière de l’espace de travail énonce la règle appliquée ici, ainsi que les autres chemins qu’elle encadre.

Le répertoire dont il s’agit dépend de l’endroit où se trouve le répertoire lu :

  • L’espace de travail, pour un répertoire de catalogue ou le répertoire d’une Release situé à l’intérieur. Cela vaut pour le répertoire conventionnel catalog de l’espace de travail chaque fois que personne ne l’a nommé — lorsqu’il n’est lu que parce qu’il est là : il appartient alors à l’espace de travail lui-même, donc un catalog qui est lui-même un lien menant hors de l’espace de travail n’est pas lu.
  • Un répertoire que vous avez nommé et qui se trouve hors de l’espace de travail, pour ce qui se trouve en dessous : un répertoire de catalogue que vous passez avec --catalog, ou que la configuration de l’espace de travail liste sous catalog_dirs — pour l’espace de travail ou pour une seule Release — et le répertoire d’une Release que vous nommez, ou que la configuration nomme, qui se trouve hors de l’espace de travail. Le répertoire lui-même est utilisé tel que vous l’avez nommé — s’il est un lien, il est lu là où il pointe — et ce qui est lu en dessous reste à l’intérieur. Cela inclut le répertoire conventionnel catalog dès que vous le nommez : listé sous catalog_dirs, ou passé avec --catalog, un catalog qui est un lien menant hors de l’espace de travail est lu là où il pointe, comme tout autre répertoire que vous nommez. Nommer plutôt l’endroit vers lequel il pointe, sous n’importe quelle graphie, ou un répertoire au-dessus de cet endroit, le nomme aussi : le répertoire que vous avez nommé lit déjà ce qui s’y trouve, il est donc lu une seule fois, à travers ce répertoire. Nommer un répertoire dans la configuration est la façon dont un espace de travail lit des entités conservées en dehors de lui.

Ce qui est jugé, c’est chaque entrée dont la lecture tirerait quelque chose : un lien vers un fichier nommé comme un document YAML, et un lien vers un répertoire, qui peut contenir ses propres documents. Un lien qui mène quelque part à l’intérieur du répertoire dans lequel la lecture doit rester est lu là où le parcours le rencontre. Un lien vers un fichier dont aucune lecture du catalogue ne tire quoi que ce soit — un fichier de notes, une archive de chart — n’est pas jugé ici, et un lien qui ne mène nulle part n’a rien derrière lui à lire.

Une recherche dont dépend une compilation s’arrête sur un tel lien au lieu de le passer. L’entité derrière le lien pourrait être celle que nomme une référence, et la passer silencieusement laisserait une autre entité du même nom, provenant d’un répertoire de catalogue ultérieur, se résoudre à sa place. Ainsi aggrega build, aggrega pull, aggrega validate, aggrega inspect partout où il lit le catalogue, un lint d’une seule Release, et les requêtes de l’éditeur et d’un assistant qui construisent, prévisualisent, représentent en graphe, valident ou décrivent une Release s’arrêtent tous avant que quoi que ce soit ne soit résolu, en nommant le lien. Un lint de l’ensemble du catalogue s’arrête de la même façon : son verdict répond de chaque document que contiennent les répertoires de catalogue, il ne signale donc pas un catalogue propre alors que l’un d’eux n’a pas pu être lu. Le répertoire de la Release est soumis à la même règle partout où une Release nomme son Aggregate ou son Manifest par identité, ou qu’un Manifest nomme de cette façon le Manifest qu’il étend, et l’analyse s’arrête sur un lien parmi les documents situés à côté de la Release même lorsque le lien n’est pas celui que nomme une référence, pour la même raison qu’un doublon l’y arrête : le répertoire ne peut pas répondre d’un nom tant que l’un de ses documents ne peut pas être lu. La Release sur laquelle l’opération a été lancée — ou un Manifest que vous inspectez seul — n’est pas l’un de ces documents : elle a été lue là où elle a été nommée, donc une Release qui est elle-même un lien menant à l’extérieur est lue là où elle pointe, et ce qu’elle nomme est recherché à côté du lien, dans le répertoire où vous l’avez nommée (Une Release ou un Manifest nommé à travers un lien).

Un listage passe au contraire sur un tel lien, et ne liste rien de ce qui se trouve derrière. L’index des entités de l’éditeur, ses complétions et les candidats qu’il propose ne listent pas une entité que représente un lien menant à l’extérieur, et l’index des entités nomme un tel lien à l’intérieur de l’espace de travail parmi les liens qu’il n’a pas lus.

Les fichiers de configuration de l’espace de travail sont tenus à l’espace de travail de la même façon. Chaque .aggrega-config.yaml depuis la racine de l’espace de travail jusqu’au répertoire dans lequel une commande s’exécute, et le .aggrega-config-append-ci.yaml qu’un pipeline conserve à côté de l’un d’eux, est le contenu propre de l’espace de travail. Un fichier qui est un lien menant hors de l’espace de travail — ou qui est atteint par un lien de répertoire menant à l’extérieur — n’est pas lu, et comme chaque commande, le serveur de langage de l’éditeur et les outils d’un assistant lisent la configuration avant toute autre chose, chacun s’arrête là, en nommant le lien, au lieu de fonctionner avec une configuration faite de ce qui restait. Le serveur de langage, et le serveur d’un assistant qui communique sur ses propres flux, démarrent malgré tout sur un tel espace de travail : les listages de ses Releases et de ses entités répondent, lus sans rien de configuré, et nomment le fichier parmi les liens qu’ils n’ont pas lus, tandis que toute autre requête que décide la configuration est refusée avec cette condition, en nommant le lien. Le remède que nomme ce message est celui de la configuration elle-même : le fichier de configuration global est la seule configuration lue où qu’elle soit conservée, nommée avec --config ou AGGREGA_CONFIG.

Le fichier de verrouillage d’une Release est tenu de la même façon, là où il est lu comme là où il est écrit. Le fichier de verrouillage situé à côté d’une Release est lu pour les épinglages par rapport auxquels se résolvent un build, un pull, une validation, un lint, une inspection, aggrega cache prune et les requêtes de l’éditeur et d’un assistant, et il est tenu au répertoire auquel son écriture est tenue : l’espace de travail, ou le répertoire propre de la Release pour une Release nommée en dehors de celui-ci. Un fichier de verrouillage qui est un lien menant à l’extérieur n’est pas lu, et chacune de ces opérations s’arrête en nommant le lien au lieu de se résoudre par rapport à des épinglages conservés ailleurs sur la machine, ou sans eux. Le remède que nomme ce message est celui du fichier de verrouillage lui-même : il n’a qu’un seul emplacement, à côté de la Release, là où un pull l’écrit.

Un fichier lu à côté d’une entité est tenu de la même façon. Deux opérations lisent un fichier situé à côté du document propre d’une entité plutôt qu’un fichier nommé par une référence. Épingler une entité, ou la publier, lit chaque autre document YAML du répertoire de l’entité pour déterminer si une autre entité le partage. Le chargement d’une entité Plugin écrite dans un répertoire de catalogue lit le .wasm construit déposé à côté d’elle. Chacun est tenu au répertoire sous lequel le document propre de l’entité a été lu — l’espace de travail, un répertoire de catalogue que vous avez nommé hors de celui-ci, ou, pour une entité que vous épinglez ou publiez en nommant son document hors de l’espace de travail, le répertoire propre de ce document — et un fichier qui est un lien menant hors de ce répertoire n’est pas lu. aggrega pin, aggrega push avec ou sans --dry-run, un pull qui épingle, ainsi que l’épinglage et la publication par l’éditeur et par un assistant s’arrêtent en nommant le lien, car un document resté non lu pourrait être l’entité qui fait obstacle. Un build ou un pull qui charge le plugin s’arrête lui aussi en nommant le lien, au lieu d’exécuter des octets conservés ailleurs sur la machine ou de chercher le plugin ailleurs. Le remède que nomme ce message est celui d’un fichier situé à côté d’une entité : conservez-y le fichier lui-même.

Le cache d’artefacts de l’espace de travail est tenu de la même façon, là où il est lu comme là où il est écrit. Tout ce qui est lu depuis le cache sous artifact_cache_dir — une entité, un plugin ou une bibliothèque en cache et le manifeste à côté, une archive source et ses métadonnées, une entrée externe épinglée, un bundle de signature, l’index de recherche local d’un registre — et chaque entrée de l’espace de travail que listent aggrega cache status, aggrega cache prune et aggrega cache clear est tenu au répertoire auquel est tenue une écriture dans le cache : le répertoire du cache lui-même, le .aggrega/cache par défaut tout autant qu’un répertoire que la configuration nomme en remontant hors de la racine de l’espace de travail. Tout ce qui s’y trouve et qui est un lien menant hors du répertoire du cache — ailleurs dans l’espace de travail comme n’importe où ailleurs — n’est pas lu, pas plus que ce qui se trouve derrière un répertoire de cache écrit à l’intérieur de la racine de l’espace de travail qui est lui-même un lien menant hors de l’espace de travail : un build, un pull, une validation, une recherche, les trois commandes du cache et les requêtes de l’éditeur et d’un assistant qui lisent le cache s’arrêtent en nommant le lien — y compris le contenu que le cache conserve sous un digest enregistré, puisqu’un digest dit ce que sont les octets, et non d’où ils peuvent être lus. Un répertoire de cache écrit à l’intérieur de la racine de l’espace de travail qui est un lien vers un autre endroit de l’espace de travail est lu là où il mène. L’avis de dépréciation qu’affiche aggrega inspect, qui ne décide de rien, est laissé de côté. Un prune ou un clear traite l’un des répertoires propres du cache qui est un lien menant hors du répertoire du cache, ou un répertoire de cache qui est lui-même un lien menant hors de l’espace de travail, comme la suppression qu’il serait, sous « A path the operation writes leads through a link out of the directory it must stay inside (Un chemin que l’opération écrit mène, par un lien, hors du répertoire dans lequel il doit rester) », avant de lister quoi que ce soit. Le remède que nomme ce message est celui du cache lui-même : une fois le lien supprimé, un pull remplit à nouveau le cache, et un cache conservé ailleurs se nomme avec artifact_cache_dir, relativement à la racine de l’espace de travail, plutôt que d’être atteint par un lien.

Un dépôt qu’une source récupère est tenu à son propre checkout. Lorsqu’un pull — aggrega pull, ou un build ou une requête de l’éditeur ou d’un assistant qui résout les dépendances d’une Release — récupère une source git-repository, il extrait le dépôt et archive le répertoire que nomme la source, et le checkout est un répertoire à part entière : chaque lien que contient le dépôt, module_subdir lui-même compris, est tenu à celui-ci. Un lien vers un fichier ou un répertoire à l’intérieur du dépôt est archivé comme ce vers quoi il pointe, sous le nom du lien. Un lien menant hors du dépôt — qui pourrait pointer vers n’importe quel fichier de la machine exécutant le pull — n’est pas lu : le pull s’arrête en nommant le lien et sa destination, et rien n’est mis en cache. Le checkout est un répertoire temporaire supprimé dès que le pull s’arrête, donc le message nomme le lien par sa place dans le dépôt — chart/secret.txt, comme dans la première ligne de la sortie en ligne de commande et dans la phrase — et le répertoire dans lequel il doit rester comme le dépôt et la révision que nomme la source : which must stay inside the repository <url> at <ref> (commit <commit>), ou at commit <commit> lorsque la source ne nomme aucun ref ou nomme le commit lui-même. L’endroit vers lequel mène le lien est nommé comme l’emplacement qu’il est sur votre machine. Le remède que nomme ce message est celui du dépôt lui-même : le lien y est commité, c’est donc là qu’il se modifie — en le faisant pointer à l’intérieur du dépôt, ou en le remplaçant par le fichier lui-même — et la source nomme ensuite une révision qui contient la modification. Un lien de répertoire qui ramène dans un répertoire que l’archivage lit déjà à travers lui arrête aussi le pull, car l’arborescence qu’il représente n’a pas de fin ; ce refus est une erreur ordinaire plutôt que cette condition.

Les surcouches que lit une génération de catalogue sont tenues de la même façon. aggrega plugin gen-catalog --from-embedded lit chaque surcouche située sous le répertoire de surcouches qu’on lui donne — saisi avec --overlay, choisi dans l’éditeur ou nommé par un assistant — et tient chacune au répertoire sous lequel ce répertoire de surcouches est lu : l’espace de travail, pour un répertoire de surcouches situé à l’intérieur, et le répertoire de surcouches lui-même pour un répertoire nommé hors de l’espace de travail. Le répertoire de surcouches est utilisé tel que vous l’avez nommé — s’il est un lien, il est lu là où il pointe. Une surcouche située en dessous qui est un lien menant hors du répertoire auquel elle est tenue n’est pas lue, pas plus qu’un lien de répertoire menant hors de celui-ci, qui peut contenir ses propres surcouches : la génération s’arrête en nommant le lien, sans rien écrire, au lieu de générer sans la surcouche. Une surcouche qui est un lien menant ailleurs à l’intérieur du répertoire auquel elle est tenue est lue là où elle pointe ; un lien de répertoire menant à l’intérieur n’est pas parcouru. Le remède que nomme ce message est celui d’une surcouche : conservez la surcouche elle-même sous le répertoire de surcouches, ou nommez comme répertoire de surcouches un répertoire contenant toutes les surcouches.

Un répertoire que vous importez est tenu à lui-même. aggrega import appliqué à un répertoire, l’outil d’importation de l’assistant et la méthode aggrega/import de la session remettent à l’importateur les fichiers du répertoire que ses motifs de fichier sélectionnent, chacun à sa place dans le répertoire, de sorte que le répertoire est celui à l’intérieur duquel ces lectures restent, où qu’il se trouve — à l’intérieur de l’espace de travail comme à l’extérieur. Ce qui est évalué, c’est chaque entrée dont l’importation prendrait quelque chose : un lien vers un fichier qu’un des motifs pertinents sélectionne — les motifs de l’importateur qui sert le format nommé ou, lorsque le format est reconnu, ceux de chaque importateur parmi lesquels l’importation choisit, y compris les importateurs core du compilateur — et un lien vers un répertoire, dans lequel on n’entre jamais. Un lien qui sort du répertoire, vers un autre endroit de l’espace de travail ou ailleurs, n’est pas lu : l’importation s’arrête en nommant le lien avant qu’aucun fichier du répertoire ne soit ouvert, sans rien écrire. Un lien sélectionné vers un fichier situé ailleurs à l’intérieur du répertoire est lu là où il pointe, sous le nom propre du lien, et un lien vers un fichier qu’aucun motif ne sélectionne n’est ni évalué ni lu. Le répertoire lui-même est utilisé tel que vous l’avez nommé — un répertoire qui est un lien est lu là où il pointe. Atteint par l’intermédiaire d’un listener, l’outil de l’assistant nomme le lien par sa place dans l’espace de travail et ne dit rien de l’endroit où il mène. Le remède que nomme ce message est celui d’un répertoire importé : conservez le fichier lui-même dans le répertoire plutôt qu’un lien vers lui, ou importez le répertoire vers lequel mène le lien.

Message émis. Il s’ouvre sur la phrase propre à la condition, puis le chemin que la lecture a atteint, le répertoire à l’intérieur duquel il doit rester, le lien rencontré en chemin et l’endroit vers lequel ce lien mène, puis le remède :

a file this operation reads leads through a link out of the directory it must stay inside (reading <workspace>/catalog-local/component/app/1.0.0/component.yaml, which must stay inside <workspace>, the link <workspace>/catalog-local/component/app/1.0.0/component.yaml leads to <elsewhere>/component.yaml). nothing was read through that link. Remove the link, or make it lead to a place inside <workspace>. To read what is kept outside, list the directory holding it as a catalog directory in the workspace configuration, rather than reaching it through a link beneath one: a listed directory is read where it leads, even when it is itself a link (un fichier que cette opération lit sort, par un lien, du répertoire à l’intérieur duquel il doit rester (en lisant un fichier qui doit rester à l’intérieur de l’espace de travail, le lien mène ailleurs). rien n’a été lu par ce lien. Supprimez le lien, ou faites-le mener à un endroit à l’intérieur de l’espace de travail. Pour lire ce qui est conservé à l’extérieur, listez le répertoire qui le contient comme répertoire de catalogue dans la configuration de l’espace de travail, plutôt que de l’atteindre par un lien situé sous l’un d’eux : un répertoire listé est lu là où il mène, même lorsqu’il est lui-même un lien)

Le diagnostic ne porte aucune catégorie : ce qui est en cause, c’est l’agencement sur le disque plutôt qu’un document que vous avez écrit.

Comment corriger : remplacez le lien par une copie de ce vers quoi il mène, ou supprimez-le ; ou, lorsque l’entité doit rester à l’extérieur de l’espace de travail, listez le répertoire qui la contient sous catalog_dirs dans la configuration de l’espace de travail, ou passez-le avec --catalog, de sorte que le répertoire soit lu comme un répertoire de catalogue à part entière. Listez le répertoire vers lequel mène le lien, et non celui dans lequel il se trouve : un lien rencontré sous un répertoire est évalué de la même façon quelle que soit la manière dont ce répertoire a été lu, de sorte que le lister ne change rien. Lorsque le lien est le répertoire catalog conventionnel de l’espace de travail lui-même, il suffit de lister catalog — ou le répertoire vers lequel il pointe — sous catalog_dirs, ou de passer l’un ou l’autre avec --catalog, puisqu’un répertoire que vous nommez est lu là où il pointe. Lorsque le lien est le fichier de verrouillage d’une Release, supprimez-le et effectuez à nouveau le pull de la Release, ce qui écrit un nouveau fichier de verrouillage à côté d’elle. Un Manifest n’a pas de niveau de catalogue, donc un Manifest que la Release lit est conservé à côté de la Release elle-même. Lorsque le lien est un fichier de configuration, remplacez-le par une copie conservée dans l’espace de travail ; une configuration que vous voulez partager entre espaces de travail est lue en la nommant comme fichier de configuration global, avec --config ou AGGREGA_CONFIG, en dessous des fichiers propres à chaque espace de travail. Lorsque le lien se trouve à côté d’une entité en cours d’épinglage ou de publication, remplacez-le par le fichier lui-même, ou déplacez un document qui est une entité dans un répertoire à part ; lorsqu’il s’agit du .wasm à côté d’une entité Plugin, placez-y le .wasm compilé lui-même. Lorsque le lien est le répertoire du cache d’artefacts ou quelque chose qu’il contient, supprimez-le — un pull remplit à nouveau le cache — ou, pour conserver le cache ailleurs, définissez artifact_cache_dir sur ce répertoire, écrit relativement à la racine de l’espace de travail (../shared-cache). Lorsque le lien est committé dans un dépôt qu’une source git-repository récupère, modifiez-le dans ce dépôt — faites-le pointer à l’intérieur du dépôt, ou committez le fichier lui-même — et nommez la révision qui porte la modification. Lorsque le lien est une surcouche sous le répertoire des surcouches d’une génération de catalogue, remplacez-le par la surcouche elle-même, ou nommez comme répertoire des surcouches un répertoire contenant chaque surcouche. Lorsque le lien se trouve dans un répertoire que vous importez, conservez le fichier lui-même dans le répertoire plutôt qu’un lien vers lui, ou importez le répertoire vers lequel mène le lien.

A reference to another file leads out of the directory it must stay inside (Une référence à un autre fichier sort du répertoire à l’intérieur duquel elle doit rester)

Une Release et un Manifest peuvent nommer un autre fichier par un chemin : les aggregate: et manifest: d’une Release écrits sous la forme ./… ou ../…, son extends:, l’extends: d’un Manifest écrit sous forme de chemin, et les parameters: { $import: … } d’une Release. Un document de l’espace de travail n’atteint de cette façon que des fichiers à l’intérieur de l’espace de travail. Une Release située à l’extérieur de l’espace de travail — une Release que vous nommez sur la ligne de commande, ou que la configuration de l’espace de travail nomme — et un Manifest que vous nommez seul sur la ligne de commande à l’extérieur de l’espace de travail n’atteignent que des fichiers à l’intérieur de leur propre répertoire : ce répertoire est une racine à part entière, comme l’est un répertoire que vous nommez à l’extérieur de l’espace de travail, et chaque Release à laquelle mène sa chaîne extends: est tenue au même répertoire. Un chemin qui, tel qu’il est écrit, remonte hors de ce répertoire, et un chemin qui reste à l’intérieur tel qu’il est écrit mais rencontre en chemin un lien symbolique qui mène à l’extérieur, sont tous deux refusés, et rien n’est lu du fichier qu’ils nomment. Un chemin qui mène à un fichier pas encore présent sous le répertoire n’est pas refusé ici ; il est signalé comme un fichier qui n’a pas pu être lu. La frontière de l’espace de travail explique pourquoi une référence est tenue tout comme le chemin que vous nommez.

L’endroit à partir duquel un chemin est résolu suit la même règle que la référence du langage enseigne pour chaque clé : les aggregate: et manifest: d’une Release, et l’extends: d’un Manifest, à côté de la Release qu’une commande ou une requête nomme — ou, pour un Manifest que vous nommez seul, à côté de ce Manifest ; l’extends: d’une Release et un $import: des paramètres, à côté de la Release qui l’écrit, de sorte que chaque maillon d’une chaîne extends: nomme son parent à côté de lui-même. Le diagnostic nomme le répertoire à partir duquel il a été résolu.

Un nom plutôt qu’un chemin n’est pas évalué ici — aggregate: payments, extends: base-manifest. Il est recherché parmi les documents situés à côté de la Release et, pour un Aggregate, dans les répertoires de catalogue, qui sont tenus par la règle de « A file the operation reads leads through a link out of the directory it must stay inside (Un fichier que l’opération lit mène, par un lien, hors du répertoire dans lequel il doit rester) » ci-dessus.

Chaque surface qui résout ce qu’une Release nomme s’arrête dessus, avant que le fichier ne soit lu : aggrega pull, aggrega build, aggrega validate, aggrega inspect d’une Release ou d’un Manifest, un lint d’une seule Release, et les requêtes de l’éditeur et d’un assistant qui compilent, prévisualisent, représentent sous forme de graphe, valident ou décrivent une Release. Dans l’éditeur, le diagnostic est placé sur la clé de la Release qui a mené au fichier.

Message émis. Il s’ouvre sur la phrase propre à la condition, puis la référence telle qu’elle est écrite, le document dans lequel elle est écrite pour un extends: et un $import: des paramètres, le répertoire à partir duquel elle est résolue, l’endroit vers lequel elle mène, le répertoire à l’intérieur duquel elle doit rester, et le lien lorsque l’un d’eux la fait sortir ; puis le remède. Pour un document de l’espace de travail :

a reference a document makes to another file leads out of the directory it must stay inside (.spec.aggregate: ../shared/app.yaml, resolved from <workspace>, which leads to <elsewhere>/shared/app.yaml, outside the workspace <workspace>). nothing was read from that file. A document in the workspace reaches only files inside <workspace>: move the file there — or, where a link carries the reference out, make the link lead there — or open the workspace at a directory holding both documents. An Aggregate kept outside that directory is reached by its name rather than a path, from a catalog directory the workspace configuration lists (une référence qu’un document fait à un autre fichier sort du répertoire à l’intérieur duquel elle doit rester : la référence, résolue depuis l’espace de travail, mène hors de l’espace de travail. rien n’a été lu de ce fichier. Un document de l’espace de travail n’atteint que des fichiers à l’intérieur de l’espace de travail : déplacez-y le fichier — ou, lorsqu’un lien fait sortir la référence, faites mener le lien à cet endroit — ou ouvrez l’espace de travail dans un répertoire contenant les deux documents. Un Aggregate conservé hors de ce répertoire s’atteint par son nom plutôt que par un chemin, depuis un répertoire de catalogue que la configuration de l’espace de travail liste)

et pour une Release ou un Manifest nommé à l’extérieur de l’espace de travail, dont le propre répertoire est celui à l’intérieur duquel il doit rester :

a reference a document makes to another file leads out of the directory it must stay inside (.spec.aggregate: ../aggregates/app.yaml, resolved from <directory>, which leads to <parent>/aggregates/app.yaml, outside <directory>, the directory of a document named outside the workspace <workspace>). nothing was read from that file. A Release or a Manifest named outside the workspace — on the command line, or by the workspace configuration — reaches only files inside its own directory <directory>: move the file there — or, where a link carries the reference out, make the link lead there — or name the document from a workspace holding both documents. An Aggregate kept outside that directory is reached by its name rather than a path, from a catalog directory the workspace configuration lists (une référence qu’un document fait à un autre fichier sort du répertoire à l’intérieur duquel elle doit rester : la référence, résolue depuis le répertoire, mène hors du répertoire d’un document nommé à l’extérieur de l’espace de travail. rien n’a été lu de ce fichier. Une Release ou un Manifest nommé à l’extérieur de l’espace de travail — sur la ligne de commande, ou par la configuration de l’espace de travail — n’atteint que des fichiers à l’intérieur de son propre répertoire : déplacez-y le fichier — ou, lorsqu’un lien fait sortir la référence, faites mener le lien à cet endroit — ou nommez le document depuis un espace de travail contenant les deux documents. Un Aggregate conservé hors de ce répertoire s’atteint par son nom plutôt que par un chemin, depuis un répertoire de catalogue que la configuration de l’espace de travail liste)

avec written in <document> après la référence pour un extends: ou un $import: des paramètres, et the link <link> leads to <place> à la fin lorsqu’un lien fait sortir le chemin. Une référence aggregate: ou manifest: ne nomme aucun document : une Release qui en étend une autre peut l’avoir héritée d’une Release située plus haut dans la chaîne, et elle est résolue à côté de la Release que la commande nomme dans tous les cas.

La catégorie du diagnostic est [OPS_ERROR] : la référence est écrite dans une Release ou un Manifest.

Comment corriger : pour un Aggregate conservé à l’extérieur de l’espace de travail, écrivez son metadata.name plutôt qu’un chemin, et listez le répertoire qui le contient sous catalog_dirs dans la configuration de l’espace de travail, ou passez-le avec --catalog — un répertoire de catalogue est la manière dont un espace de travail atteint des entités conservées à l’extérieur de lui. Un Manifest, une Release qu’un extends: nomme et un fichier de paramètres sont lus à côté de la Release et jamais recherchés par leur nom ; conservez-les donc à l’intérieur de l’espace de travail, ou ouvrez l’espace de travail dans un répertoire qui contient à la fois la Release et le fichier. Pour une Release ou un Manifest que vous avez nommé depuis l’extérieur de l’espace de travail, conservez ce qu’il nomme dans son propre répertoire, ou compilez-le dans l’espace de travail qui contient à la fois le document et ce qu’il nomme. Lorsqu’un lien fait sortir le chemin, remplacez le lien par une copie de ce vers quoi il mène, ou faites-le mener à l’intérieur du répertoire.

No catalog version satisfies a version constraint (Aucune version du catalogue ne satisfait une contrainte de version)

Une référence nomme une entité que le catalogue contient et épingle une version qu’il ne contient pas : une version exacte absente, ou une plage caret à laquelle rien de disponible ne correspond. Cette condition se distingue d’une simple absence, où le nom lui-même est inconnu — ici l’entité existe et seule la version ne peut pas être satisfaite, c’est pourquoi le message le dit plutôt que de signaler l’entité comme manquante et de vous envoyer chercher une faute de frappe dans le nom.

Chaque type d’entité arrive ici par une seule sélection, de sorte qu’un épinglage impossible à satisfaire se comporte de la même façon où qu’il soit écrit : une faute de frappe de version dans le mappage d’une Recipe d’un Manifest est refusée exactement comme la même faute sur un type de composant.

La condition est récupérable, ce qui permet à l’éditeur de l’afficher comme diagnostic pendant que vous continuez à taper plutôt que d’abandonner le document. Sur la ligne de commande, elle est regroupée en un arrêt.

Message émis, pour une référence qu’atteignent les dépendances d’une Release — un type de composant, une valeur de mappage d’un Manifest — en nommant l’endroit où elle a été collectée :

no catalog version satisfies the referenced version constraint: entity "<reference>" (referenced from <referring paths>) (aucune version du catalogue ne satisfait la contrainte de version référencée)

Message émis, pour un épinglage sur un pointeur extends: :

no catalog version satisfies the referenced version constraint (Component <name>, at .extends, no catalog version satisfies extends parent "<reference>") (aucune version du catalogue ne satisfait la contrainte de version référencée : aucune version du catalogue ne satisfait le parent d’extends)

avec Feature à la place de Component lorsque c’est la chaîne d’une Feature qui porte l’épinglage.

Comment corriger : remplacez l’épinglage par une version que le catalogue contient, ou ajoutez cette version au catalogue. aggrega inspect liste les versions dans lesquelles une entité est disponible. Une plage caret à laquelle rien ne correspond signifie généralement que les versions disponibles sont toutes inférieures au plancher qu’elle nomme — élargissez la plage, ou publiez la version que la référence attend.

Un épinglage qui n’a aucune des formes que prend un épinglage est une condition différente, décrite sous « A version pin is none of the forms a pin takes (Un épinglage de version ne prend aucune des formes d’un épinglage) » ci-dessous.

A version pin is none of the forms a pin takes (Un épinglage de version ne prend aucune des formes d’un épinglage)

Une référence nomme une autre entité et peut épingler la version qu’elle veut après un deux-points, sous l’une de deux formes : un épinglage exact, c’est-à-dire une version sémantique telle que 1.0.0 — la forme que prend le metadata.version de chaque entité — ou un épinglage caret, ^ suivi d’une version telle que ^1.0.0, qui sélectionne la version la plus élevée compatible avec celle-ci. Un épinglage qui n’est ni l’un ni l’autre — un caret dont le texte ne se lit pas comme une plage de versions, comme ^garbage, ou un épinglage exact qui n’est pas une version sémantique, comme 1.x, 1.0 ou v1.0.0 — ne nomme aucune version, si bien qu’aucun catalogue ne pourrait contenir ce qu’il demande.

Un tel épinglage est signalé comme mal formé plutôt que comme une entité ou une version que le catalogue ne contient pas, de sorte que le diagnostic vous renvoie au texte que vous avez saisi au lieu de vous faire chercher quelque chose qui n’existe pas. C’est la même condition quel que soit l’endroit où l’épinglage est écrit : le type d’un composant ou d’une fonctionnalité, l’extends: d’un Component ou d’une Feature, une clé ou une valeur de mappage d’un Manifest, le spec.aggregate d’une Release, l’implements: d’une Recipe ou d’une FeatureRecipe, la version que le capability: d’une Recipe épingle lorsque le plugin qui la sert est sélectionné, et le plugin: d’une étape de pipeline.

Il est signalé là où est signalée une référence qui n’a pas pu être résolue, de sorte qu’un épinglage mal formé ne change jamais quelles références se résolvent — il change ce que dit l’échec. Un épinglage bien formé mais qu’aucune version disponible ne satisfait conserve la condition que cette surface signale pour lui : « No catalog version satisfies a version constraint (Aucune version du catalogue ne satisfait une contrainte de version) » ci-dessus, ou la condition d’élément introuvable de la surface sur laquelle il est écrit.

Seul le texte après le dernier deux-points est un épinglage, et seulement lorsqu’il ne contient pas de /. Une référence à un hôte de registre avec un port, telle que localhost:5000/core/api-server, ne porte donc aucun épinglage — le texte après le deux-points du port prolonge la référence — et elle n’est jamais signalée comme un épinglage mal formé.

Message émis, pour un épinglage caret sur un type de composant :

reference carries a malformed version pin (reference "<reference>", pin "<pin>", the text after ^ is not a version range, referenced from <authored location>). write the reference as , as : with a semantic version such as 1.0.0, or as :^ for the highest version compatible with it (la référence porte un épinglage de version mal formé (référence, épinglage, le texte après ^ n’est pas une plage de versions, référencée depuis l’emplacement où elle est écrite). écrivez la référence sous la forme nom, nom:version avec une version sémantique telle que 1.0.0, ou nom:^version pour la version la plus élevée compatible avec celle-ci)

Un épinglage exact affiche an exact pin must be a semantic version à la place de la clause du caret. La valeur qui suit indique où la référence a été écrite, dans les mots de la surface qui la signale — referenced from et l’emplacement où elle est écrite, in the Release's spec.aggregate ou in the recipe's spec.implements. Lorsqu’un mappage d’un Manifest est évalué par rapport à l’implements: de sa Recipe, l’entrée du mappage et le côté de celle-ci qui porte l’épinglage — in the mapping key ou in the recipe's spec.implements — viennent à la place avant la référence, et l’extends: d’un Component ou d’une Feature nomme l’entité qui étend et le champ avant celle-ci.

Comment corriger : réécrivez l’épinglage sous l’une des deux formes, ou supprimez-le pour sélectionner la version la plus élevée disponible. Un caractère générique tel que 1.x s’écrit comme un épinglage caret, ^1.0.0 ; une version avec un v initial ou moins de trois nombres s’écrit en entier, 1.0.0.

Every version a reference could select has been withdrawn (Toutes les versions qu’une référence pourrait sélectionner ont été retirées)

Une référence se résout en un dépôt que le registre contient, et chaque version parmi lesquelles la découverte des versions aurait pu choisir a été marquée comme retirée. Il ne reste rien d’éligible à sélectionner.

Ce n’est délibérément pas signalé comme une entité manquante. Le dépôt existe et contient toujours ces versions ; le dire absent nommerait le mauvais problème, vous ferait chercher une faute de frappe et ressemblerait à un repli silencieux plutôt qu’au refus qu’il est. Le message nomme chaque version retirée avec la raison enregistrée pour elle, de sorte que ce qui vous est dit est ce que l’éditeur a enregistré.

Nommer une version retirée explicitement n’est pas cet arrêt. Une version exacte contourne entièrement la découverte des versions, donc en épingler une est la façon de continuer délibérément à l’utiliser ; le build signale le retrait et poursuit.

Message émis :

every published version this reference could select has been withdrawn: <reference>: withdrawn: <version> (<recorded reason>), <version> (<recorded reason>) (toutes les versions publiées que cette référence pourrait sélectionner ont été retirées : retirées, chacune avec la raison enregistrée)

Comment corriger : lisez les raisons enregistrées, qui nomment généralement vers quoi migrer. Migrez vers ce qui remplace l’entité retirée — c’est le résultat qu’un retrait demande. Lorsque vous devez conserver l’ancienne pour l’instant, épinglez une version exacte dans la référence : nommer la version est ce qui indique que vous l’acceptez, et le build signale alors le retrait à chaque fois au lieu de refuser.

A plugins.providers binding names a plugin that does not serve the capability (Une liaison nomme un plugin qui ne sert pas la capacité)

Le bloc plugins.providers de l’espace de travail sélectionne une identité de plugin pour une capacité, et aucun Plugin de rendu de fournisseur servant cette capacité ne porte cette identité. La liaison est un choix explicite que le catalogue ne peut pas honorer, donc elle provoque un arrêt plutôt que de se replier silencieusement sur un autre plugin — un repli rendrait votre sortie au moyen d’un plugin que vous aviez dit de ne pas utiliser, sans rien dire.

Une liaison sélectionne selon l’identité de coordonnée du plugin — le type de plugin et le nom du plugin, qui est aussi ce que le fichier de verrouillage épingle — et elle peut porter une version après celle-ci.

Elle est évaluée qu’une Recipe demande ou non la capacité. Sinon, une liaison n’est lue que lorsque le capability: d’une Recipe la nomme, de sorte qu’une liaison dont la capacité a une graphie erronée ne serait consultée par rien ni signalée par rien. Chaque build et chaque aggrega validate --release vérifient donc chaque liaison qui nomme un plugin : un pull résout une telle liaison 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 est certainement erronée. La vérification lit les liaisons dans la configuration de l’espace de travail, pas le fichier de verrouillage, et elle ne change rien quant au plugin qui rend une Recipe — cela reste du ressort du fichier de verrouillage. Une liaison nommant un plugin que le build ne détient pas — un plugin de registre qu’aucun pull n’a encore récupéré — n’est évaluée qu’une fois qu’un pull l’a récupéré. Une liaison qui ne nomme aucun plugin est évaluée différemment, comme un avertissement : voir « A provider binding names a capability no plugin the build reads serves (Une liaison de fournisseur nomme une capacité qu’aucun plugin lu par le build ne sert) » sous « Conditions qui n’arrêtent pas un build » ci-dessous.

Message émis, qui ajoute ce que le plugin nommé sert effectivement, et une graphie à une modification près lorsque la capacité de la liaison en est une :

plugins.providers entry names a plugin no provider-rendering plugin serving the capability matches: capability "<capability>" is bound to plugin "<plugin-identity>", but no provider-rendering plugin serving "<capability>" matches that identity; "<plugin-identity>" serves "<served capability>", and "<capability>" is one edit from "<served capability>" (l’entrée plugins.providers nomme un plugin auquel ne correspond aucun plugin de rendu de fournisseur servant la capacité : la capacité est liée au plugin, mais aucun plugin de rendu de fournisseur qui la sert ne correspond à cette identité ; le plugin sert une autre capacité, et la capacité n’en est qu’à une modification)

Lorsque le plugin que nomme la liaison n’est pas dans le catalogue que lit le build, le message se termine après « matches that identity (correspond à cette identité) », car il n’y a rien à dire sur ce qu’il sert.

Comment corriger : vérifiez d’abord la graphie de la liaison par rapport à la coordonnée propre du plugin — une liaison qui nomme la capacité là où elle devrait nommer le plugin est l’erreur courante. Lorsque le message nomme une capacité à une modification de celle que vous avez écrite, la faute de frappe est dans le capability: de la liaison. Vérifiez ensuite que le plugin se trouve dans le catalogue que lit le build et qu’il liste cette capacité sous spec.provider.capabilities ; un plugin qui servait autrefois la capacité et ne la déclare plus produit exactement ce message. Supprimer la liaison est la bonne correction lorsqu’un seul plugin sert la capacité, puisque la liaison n’a alors rien à départager.

No provider plugin version satisfies a Recipe’s provider pin (Aucune version de plugin fournisseur ne satisfait l’épinglage de fournisseur d’une Recipe)

Une Recipe lie un fournisseur à version épinglée — helm:1.0.0 ou helm:^1.0.0 — et aucune version de Plugin de rendu de fournisseur ne satisfait l’épinglage. L’épinglage est une demande explicite, donc le build s’arrête plutôt que de l’ignorer et de rendre au moyen de n’importe quelle version qui sert le fournisseur à ce moment-là ; passer outre un épinglage en silence produirait une sortie dont la propre déclaration de l’auteur dit qu’elle ne devrait pas exister.

Deux situations y mènent, et le message les distingue : rien ne sert la capacité, ou quelque chose la sert et aucune de ses versions ne satisfait la contrainte.

Cela se distingue d’une version d’entité insatisfaisable ci-dessus. Celle-là concerne une entité de catalogue nommée à une version que le catalogue ne contient pas ; celle-ci concerne la sélection du plugin qui rend une capacité.

Messages émis :

no provider-rendering plugin version satisfies the recipe’s provider version pin: capability "<capability>" pins "<version>" but no provider-rendering plugin serves it (aucune version de plugin de rendu de fournisseur ne satisfait l’épinglage de version de fournisseur de la Recipe : la capacité épingle une version, mais aucun plugin de rendu de fournisseur ne la sert) no provider-rendering plugin version satisfies the recipe’s provider version pin: capability "<capability>" pins "<version>" but no serving plugin version satisfies it (aucune version de plugin de rendu de fournisseur ne satisfait l’épinglage de version de fournisseur de la Recipe : la capacité épingle une version, mais aucune version de plugin qui la sert ne la satisfait)

Comment corriger : élargissez ou corrigez l’épinglage dans le champ capability: de la Recipe, ou ajoutez au catalogue la version de plugin qu’il demande. Un épinglage caret correspond aux versions égales ou supérieures au plancher au sein de la même version majeure, donc un épinglage ^2.0.0 n’est pas satisfait par un plugin 1.x, aussi récent soit-il. Lorsque le message dit que rien ne sert la capacité, l’épinglage n’est pas le problème : le plugin manque entièrement, et retirer l’épinglage n’aidera pas.

No plugin advertises a requested parse or import format (Aucun plugin n’annonce un format d’analyse ou d’importation demandé)

Un format a été demandé et aucun plugin ne l’annonce. Les deux sockets qui routent par format ont chacun leur propre condition, et ils ne diffèrent que par le travail demandé : un plugin parseur lit un format source étranger, et un plugin importateur fait entrer un contenu étranger sous forme d’entités Aggrega.

L’espace des formats est ouvert et appartient entièrement aux plugins. Aucun des deux sockets ne contient de liste de formats connus du compilateur : un plugin déclare les formats qu’il gère comme des capacités, et un nouveau format est livré comme un nouveau plugin sans aucune modification du compilateur. Cet arrêt signale donc l’ensemble annoncé tel qu’il est plutôt qu’une énumération fixe, et chaque absence est signalée explicitement : soit la demande a un plugin qui l’annonce, soit elle ne peut pas être honorée. Rien ne remplace un plugin manquant, à l’unique exception des parseurs que le compilateur embarque, décrite ci-dessous.

Messages émis :

no parser plugin advertises the requested format: no parser plugin advertises "parse:<format>" (aucun plugin parseur n’annonce le format demandé) no importer plugin advertises the requested format: no importer plugin advertises "import:<format>" (aucun plugin importateur n’annonce le format demandé)

Un plugin parseur unique qui annonce le format mais porte une structure de version qui ne peut pas être résolue est traité comme si aucun plugin n’annonçait le format plutôt que comme un passage silencieux, et le dit :

no parser plugin advertises the requested format: no parser plugin version resolves for "parse:<format>" (aucun plugin parseur n’annonce le format demandé : aucune version de plugin parseur ne se résout pour le format)

Une analyse se replie sur les parseurs que le compilateur embarque. Un build analyse chaque fichier qu’il remet à une politique render-verdict dans un format que cette politique ne lit pas nativement, un importateur lit sa source au moyen du parseur de la syntaxe qu’il nomme, et une importation qui ne nomme aucun format analyse la source dans la syntaxe que nomme chaque signature applicable. Pour chaque syntaxe, c’est le parseur que sert le catalogue de l’espace de travail qui est utilisé et, lorsque le catalogue n’en sert aucun, le parseur que le compilateur embarque lui-même pour elle — parmi eux le parseur HCL au moyen duquel un build lit la sortie Terraform et le parseur JSON au moyen duquel lisent les importateurs core du compilateur, de sorte que ni une politique portant sur une sortie Terraform ni une importation passant par un importateur core n’a besoin d’un parseur dans le catalogue. Lorsque le catalogue sert un parseur pour une syntaxe, celui du compilateur ne joue aucun rôle, et deux parseurs de noms différents dans le catalogue sont refusés comme le décrit A parse or import format is advertised by more than one plugin (Un format d’analyse ou d’importation est annoncé par plus d’un plugin). Ainsi, cet arrêt nomme une syntaxe pour laquelle ni le catalogue ni le compilateur ne servent de parseur.

Comment corriger : vérifiez que le format est écrit comme le plugin l’annonce — la capacité est le préfixe du socket suivi du nom du format, donc un plugin qui annonce parse:hcl sert le format hcl et rien d’autre. Vérifiez ensuite que le plugin est présent dans le catalogue que lit le build. Lorsqu’aucun plugin n’existe pour le format, ce plugin est la pièce manquante ; le compilateur ne peut pas lire un format que rien n’annonce.

A parse or import format is advertised by more than one plugin (Un format d’analyse ou d’importation est annoncé par plus d’un plugin)

Deux plugins distincts ou plus annoncent le même format, et la demande ne peut pas être routée sans deviner lequel utiliser.

Un catalogue qui contient les deux est légitime et se charge sans objection. Deux éditeurs peuvent chacun livrer un parseur ou un importateur pour un même format, et fédérer leurs catalogues est une opération prise en charge. L’ambiguïté est une condition au point d’utilisation : elle provoque un arrêt lorsque le format disputé est effectivement demandé, de sorte qu’une paire concurrente située hors de portée d’un build ne le bloque jamais.

Chaque candidat est nommé, trié, de sorte que le message est le même à chaque exécution.

Messages émis :

format is advertised by more than one parser plugin: format "<format>" is advertised by parser plugins [<plugin-names>] (le format est annoncé par plus d’un plugin parseur) format is advertised by more than one importer plugin: format "<format>" is advertised by importer plugins [<plugin-names>] (le format est annoncé par plus d’un plugin importateur)

Pour un importateur, l’arrêt est levé sous une structure de plus : les entrées plugins.importer de l’espace de travail rattachent plus d’un des importateurs qui annoncent le format, et les importateurs qu’il nomme sont alors ceux qui sont rattachés.

Les importateurs parmi lesquels une importation choisit sont ceux du catalogue de l’espace de travail et les importateurs core du compilateur, qui annoncent leurs formats dans chaque espace de travail. Ainsi, un catalogue qui contient son propre importateur d’un autre nom pour un format que sert un importateur core — import:langflow ou import:flowise — rencontre cet arrêt lors d’une importation qui ne rattache ni l’un ni l’autre, et le message nomme l’importateur core à côté de celui du catalogue. Un importateur que le catalogue contient sous le nom même d’un importateur core n’est pas un second plugin qui annonce le format : au sein d’un même nom, la version la plus élevée est choisie, et un importateur à la version propre de l’importateur core, avec son module à côté de lui, s’exécute à sa place. Un importateur sans module à côté de lui n’est pas candidat là où un importateur de ce nom capable de s’exécuter annonce le format, comme le décrit Lequel s’exécute à côté de vos propres importateurs.

Comment corriger : pour un importateur, conservez les deux dans le catalogue — ou conservez le vôtre à côté de l’importateur core — et rattachez celui que vous voulez — une entrée plugins.importer dont l’uri le nomme par son identité et sa version, uri: importer/<name>:<version>, comme l’écrit aggrega plugin add importer. L’importateur rattaché est choisi parmi ceux qui annoncent le format, comme une entrée plugins.providers choisit parmi les plugins servant une capacité sur le socket fournisseur, décrit sous « A capability is served by more than one provider plugin (Une capacité est servie par plus d’un plugin fournisseur) » ci-dessous. Lorsque les importateurs nommés sont ceux que vos entrées rattachent, conservez l’entrée de celui que vous voulez et supprimez l’autre. Le socket d’analyse n’a pas de sélection de ce genre, donc pour un parseur le remède consiste à restreindre le catalogue que lit le build afin qu’il ne contienne que le plugin que vous voulez — pointer --catalog vers le répertoire qui contient votre choix est le moyen direct.

A plugins.importer entry pins a version of its importer the catalog does not hold (Une entrée épingle une version de son importateur que le catalogue ne contient pas)

Une entrée plugins.importer rattache un importateur par son identité et une version — une version exacte, uri: importer/<name>:1.2.0, ou une plage, uri: importer/<name>:^1.2.0 — et cet importateur annonce le format que l’import demande, mais aucune de ses versions parmi lesquelles l’import choisit ne satisfait l’épinglage — les versions que contient le catalogue de l’espace de travail et, pour un importateur core, également la version propre du compilateur : la version exacte n’y est pas, ou aucune de ses versions ne tombe dans la plage. La version est un choix explicite, donc l’import est refusé avant l’exécution de tout importateur, plutôt que d’exécuter une autre version de l’importateur à sa place.

Ce cas est distinct de celui où aucun importateur n’annonce le format, décrit plus haut : ici, l’importateur fait partie de ceux parmi lesquels l’import choisit et annonce le format, et seule manque la version que nomme l’entrée. Un épinglage qui n’a aucune des formes que prend un épinglage de version, comme :latest, est signalé à la place comme malformé, comme le décrit « A version pin is none of the forms a pin takes (Un épinglage de version ne prend aucune des formes d’un épinglage) ».

Message émis, qui nomme la capacité du format et la version que l’entrée épingle :

no importer plugin version satisfies the plugins.importer entry’s version pin: capability "import:<format>" pins "<version>" but no serving plugin version satisfies it (aucune version de plugin importateur ne satisfait l’épinglage de version de l’entrée plugins.importer : la capacité épingle une version, mais aucune version de plugin qui la sert ne la satisfait)

Comment corriger : remplacez la version dans l’uri de l’entrée par une version que le catalogue contient — pour un importateur core, la version propre du compilateur en fait aussi partie —, ou élargissez la plage, ou ajoutez au catalogue la version que nomme l’entrée. Une plage caret correspond aux versions égales ou supérieures à son plancher au sein de la même version majeure, donc ^2.0.0 n’est pas satisfaite par un importateur 1.x, aussi récent soit-il.

A plugin reference carries a registry host or an artifact path (Une référence de plugin contient un hôte de registre ou un chemin d’artefact)

Une référence de Plugin commence par un segment en forme d’hôte de registre — un segment contenant un point ou deux-points, comme un nom DNS ou un couple hôte et port — ou par un chemin d’artefact. Un Plugin est désigné par son identité de coordonnée : son type de plugin, une barre oblique, son nom et, facultativement, une version. Le pull lie cette identité à un emplacement physique en préfixant le registre configuré et le chemin du plugin lui-même, de sorte qu’une référence qui en contient déjà un serait préfixée deux fois et liée à un emplacement impossible à récupérer.

Elle est refusée là où l’emplacement est formé plutôt qu’au moment de la récupération, de sorte que le message nomme ce que vous avez écrit au lieu d’apparaître plus tard sous la forme d’une erreur de tag illisible.

Message émis, encadré par le pull qui formait l’emplacement, avec le remède sur la ligne en dessous :

catalog: tier-3 pull <uri>: wasm plugin reference must be the plugin coordinate identity (<pluginType>/<name>:<version>), not a registry-qualified or artifact path: "<identity>" (catalogue : pull de niveau 3 : la référence de plugin wasm doit être l’identité de coordonnée du plugin, et non un chemin qualifié par un registre ou un chemin d’artefact) remediation: remove the registry host and the artifact path, leaving the coordinate alone — <pluginType>/<name>:<version>, for example provider/helm:1.0.0; the pull prefixes the configured registry itself, so a reference that already carries one is prefixed twice (remède : supprimez l’hôte du registre et le chemin de l’artefact pour ne laisser que la coordonnée ; le pull préfixe lui-même le registre configuré, donc une référence qui en contient déjà un est préfixée deux fois)

Comment corriger : supprimez tout ce qui précède le type de plugin pour ne laisser que la coordonnée — provider/helm:1.0.0, et non hub.example.com/plugin/provider/helm:1.0.0. Le registre à partir duquel un build effectue le pull relève de la configuration de l’espace de travail et ne fait pas partie d’une identité, ce qui permet de servir un même catalogue depuis plus d’un registre sans modifier les entités qu’il contient.

A plugin or recipe reference carries no scope (Une référence de plugin ou de recette ne porte aucune portée)

Une référence de Plugin ou de Recipe n’a pas de segment de portée en tête — aucune barre oblique, ou un segment vide avant la barre oblique, comme dans /name. Les deux types sont identifiés par deux parties, et la première est ce qui distingue deux entités de même nom : un Plugin par son type de plugin et son nom, une Recipe par son fournisseur et son nom. Deux sockets peuvent chacun contenir un plugin appelé redact, et deux fournisseurs peuvent chacun livrer une recette appelée postgres, donc la portée fait partie de l’identité plutôt que d’en être une décoration.

Un emplacement construit à partir d’une portée vide contient un segment de chemin vide — une double barre oblique — qui ne peut pas être résolu, donc la référence est refusée là où l’emplacement est formé plutôt que d’être laissée échouer plus tard sous la forme d’une récupération illisible.

Les deux remèdes sont l’inverse du cas du plugin qualifié décrit plus haut et l’un de l’autre, c’est pourquoi chacun est formulé séparément : ici, il manque un segment à une référence et vous en ajoutez un, tandis qu’une référence qualifiée en porte un de trop et vous le supprimez.

Messages émis, chacun encadré par le pull et portant son propre remède en dessous :

catalog: tier-3 pull <uri>: wasm plugin reference must carry a pluginType scope (<pluginType>/<name>); an empty scope cannot bind to an OCI location: "<identity>" (catalogue : pull de niveau 3 : la référence de plugin wasm doit porter une portée pluginType ; une portée vide ne peut pas être liée à un emplacement OCI) remediation: add the missing pluginType segment — write the reference as <pluginType>/<name>, for example provider/helm or governance/redact, using the pluginType the plugin entity declares under metadata.pluginType (remède : ajoutez le segment pluginType manquant — écrivez la référence sous la forme type de plugin, barre oblique et nom — en utilisant le pluginType que l’entité du plugin déclare)

catalog: tier-3 pull <uri>: recipe reference must be provider-scoped (<provider>/<name>); an empty provider cannot bind to an OCI location: "<identity>" (catalogue : pull de niveau 3 : la référence de recette doit avoir un fournisseur pour portée ; un fournisseur vide ne peut pas être lié à un emplacement OCI) remediation: no local catalog directory held this reference, so it was looked for in the registry, where a provider segment is required; re-run as aggrega pull --release <release> --catalog <dir> so the directory that holds it is searched first (--catalog is repeatable) (remède : aucun répertoire de catalogue local ne contenait cette référence, elle a donc été recherchée dans le registre, où un segment de fournisseur est requis ; relancez le pull en indiquant avec l’option de catalogue le répertoire qui la contient, afin qu’il soit parcouru en premier ; l’option est répétable)

Comment corriger : pour un plugin, préfixez le type de plugin que l’entité Plugin déclare sous metadata.pluginType. Pour une recette, préfixez le fournisseur que la Recipe déclare sous spec.capability. Le remède pour la recette mentionne une seconde possibilité qui mérite d’être lue : atteindre le registre signifie que les répertoires de catalogue locaux ont été parcourus en premier et qu’aucun ne contenait la référence ; si la recette doit provenir d’un répertoire local, pointez donc le build vers ce répertoire plutôt que d’ajouter une portée.

The build consumes an artifact its publisher has deprecated (Le build consomme un artefact que son éditeur a déprécié)

Une référence que ce build résout porte un marqueur de dépréciation enregistré par son éditeur, et la gravité de ce marqueur est égale ou supérieure à la gravité que l’espace de travail a configurée comme seuil d’arrêt. Un marqueur est attaché à un artefact publié a posteriori, de sorte qu’un artefact qui se construisait proprement hier peut en porter un aujourd’hui sans que rien n’ait changé dans vos propres fichiers.

Le signalement et l’arrêt sont distincts, et seul l’arrêt est configurable. Chaque marqueur enregistré est signalé, à toute gravité, et aucune configuration ne le fait taire. C’est halt_on_deprecated_severity qui décide si un marqueur arrête aussi le build, en comparant la gravité enregistrée au seuil configuré dans l’ordre warning < error < retracted. Sans seuil configuré, rien ne s’arrête et chaque marqueur est un avertissement. Une gravité hors de ces trois valeurs, ou un seuil hors de celles-ci, ne correspond jamais : une valeur malformée ne peut ni provoquer un arrêt ni en supprimer un.

Chaque notification est affichée avant l’arrêt du build, pas seulement celle qui l’a arrêté, de sorte que relever le seuil ne vous fait jamais perdre un constat — l’arrêt lui-même nomme la seule référence sur laquelle il s’est arrêté. Les constats sont triés par référence, de sorte que le même fichier de verrouillage signale la même séquence à chaque exécution et que celui qui provoque l’arrêt est toujours le même.

Deux magasins sont vérifiés et tous deux signalent de la même manière : les références que le fichier de verrouillage épingle, et les plugins enregistrés comme approuvés pour un verdict d’acceptation ou de rejet. Aucune des deux vérifications n’atteint un registre — toutes deux lisent ce qui était déjà enregistré —, de sorte que le build reste ahead-of-time.

Message émis. Chaque constat est affiché au fil du parcours, puis l’arrêt répète celui qui a atteint le seuil et nomme le paramètre qui a arrêté le build :

deprecation: <reference> is retracted: <the publisher's recorded message> (recorded in the lockfile at pull, as of <when>; re-run `aggrega pull` to refresh it)

deprecation: build consumes a deprecated entity: <reference> is retracted: <the publisher's recorded message> (recorded in the lockfile at pull, as of <when>; re-run aggrega pull to refresh it): halt_on_deprecated_severity is "error" (dépréciation: le build consomme une entité dépréciée : la référence est retirée, avec le message enregistré par l’éditeur (enregistré dans le fichier de verrouillage lors du pull ; relancez le pull pour l’actualiser) : halt_on_deprecated_severity a la valeur indiquée)

Un marqueur de l’une des deux gravités consultatives est indiqué comme deprecated (warning) ou deprecated (error) à la place de retracted. La distinction est conservée parce que les deux signifient des choses différentes — déconseillé mais toujours sélectionnable, par opposition à exclu de la sélection — et signaler le plus fort comme le plus faible minimiserait ce qui s’est produit.

Comment corriger : lisez le message enregistré, qui est l’explication de l’éditeur lui-même sur ce vers quoi migrer, puis migrez. Là où vous ne pouvez pas encore migrer, relever halt_on_deprecated_severity — ou le désactiver — retransforme l’arrêt en un avertissement que vous continuez de voir ; c’est une acceptation délibérée plutôt qu’un contournement, et la notification continue de s’afficher. Un marqueur enregistré pour une version que vous n’utilisez plus disparaît lorsque le fichier de verrouillage est actualisé avec aggrega pull.

A trusted plugin’s recorded digest disagrees with the cached artifact (Le digest enregistré d’un plugin approuvé ne concorde pas avec l’artefact en cache)

Un plugin rattaché dans un rôle qui accepte ou rejette un build possède un digest enregistré comme approuvé, et le manifeste en cache du plugin en signale un autre. Les deux sont comparés avant la lecture de l’exécutable du plugin, et un désaccord arrête la résolution à ce stade.

La comparaison est ce qui fait du digest enregistré une autorité plutôt qu’une simple redite. Sans elle, les octets d’un plugin ne sont jamais vérifiés que par rapport à un épinglage dérivé du manifeste même dont il valide ensuite les octets — cohérent avec lui-même par construction, et incapable de remarquer que l’artefact entier a été remplacé. Comparer ce qui a été enregistré avec ce que le manifeste signale maintenant est ce qui donne à cette vérification un avis extérieur.

Ce cas est distinct d’une non-concordance du digest de contenu, qui signale des octets résolus en désaccord avec le digest annoncé pour eux. Ici, rien n’a été lu, et les octets peuvent très bien concorder avec le manifeste ; ce qui est en désaccord, c’est l’artefact même qui est résolu. Il importe de distinguer les deux parce que les remèdes sont opposés — l’un est un artefact corrompu ou altéré, l’autre un plugin légitimement modifié dont la nouvelle identité n’a pas encore été examinée.

Message émis :

resolve cached plugin "<plugin-identity>": the digest recorded as trusted for it is <recorded-digest>, but the plugin manifest in the content cache reports <cached-digest>; review what changed and re-record the trusted digest, or restore the recorded artifact: the digest recorded as trusted for this plugin does not match the digest its cached manifest reports (résolution du plugin en cache : le digest enregistré comme approuvé pour celui-ci diffère de celui que signale le manifeste du plugin dans le cache de contenu ; examinez ce qui a changé et réenregistrez le digest approuvé, ou restaurez l’artefact enregistré : le digest enregistré comme approuvé pour ce plugin ne correspond pas au digest que signale son manifeste en cache)

Comment corriger : déterminez ce qui a changé avant de réenregistrer quoi que ce soit — il s’agit d’un plugin qui peut rejeter vos builds, et le digest enregistré est l’attestation que quelqu’un l’a examiné. Là où le changement est attendu, parce que vous avez mis à niveau le plugin délibérément, examinez le nouvel artefact et réenregistrez le digest approuvé pour celui-ci. Là où il ne l’est pas, restaurez l’artefact que nomme l’enregistrement ; le désaccord vous indique que l’identité a changé sans que personne ne l’ait décidé.

An extends: chain cannot be assembled (Une chaîne d’extension ne peut pas être assemblée)

La chaîne extends: d’un Component, d’une Feature, d’un Manifest ou d’une Release nomme un parent qui ne peut pas être résolu, de sorte que la chaîne ne peut pas être transformée en une seule entité résolue.

Cette condition est distincte d’un cycle, qui a sa propre condition et son propre remède — voir « Cyclic extends chain (Chaîne extends cyclique) » plus haut ; d’une chaîne qui dépasse la borne de profondeur, qui a sa propre condition plus bas ; et d’un épinglage de version insatisfiable, où le parent existe et seule la version n’existe pas.

Message émis, qui nomme l’entité portant l’extends: non résoluble et la référence qu’elle déclare :

inheritance merge failed (Component <name>, at .spec.extends, <entity> extends <reference>, which no catalog entity provides). Verify the extends reference names an entity present in the catalog (échec de la fusion d’héritage : l’entité étend une référence qu’aucune entité du catalogue ne fournit. Vérifiez que la référence extends nomme une entité présente dans le catalogue)

Lorsque la vérification qui le signale lit un parent dans le cache d’artefacts selon l’épinglage d’un lockfile — la vérification extends d’un build et de aggrega validate --release, aggrega validate sur l’ensemble du catalogue, et aggrega inspect, ainsi que les mêmes vérifications exécutées depuis l’éditeur et l’outil validate de l’assistant —, le conseil se poursuit en nommant le pull : « a base published to a registry is fetched by aggrega pull --release <release> » (une base publiée dans un registre est récupérée par la commande indiquée). La validation d’un seul fichier d’entité ne lit aucun lockfile ; un pull ne changerait donc rien à ce qu’elle lit, et son message s’arrête au catalogue.

Feature apparaît à la place de Component lorsque c’est la chaîne d’une Feature qui a échoué. Comme pour une boucle, l’entité nommée en premier est celle à partir de laquelle la résolution a commencé, et l’entité nommée dans l’arête est celle dont il faut ouvrir la ligne extends: ; le long d’une chaîne à plusieurs niveaux, elles diffèrent.

L’extends: d’un Manifest est résolu par rapport à un autre endroit, il reçoit donc un autre conseil. Un Manifest est une configuration d’opérateur rédigée à côté de la Release plutôt qu’un contenu de catalogue, et son extends: nomme un fichier par chemin relatif ou le metadata.name d’un Manifest dans le répertoire propre de la Release — jamais une entité du catalogue. Son message se termine donc par ce vers quoi la référence n’a pas pu être résolue et par l’endroit où chercher à la place :

inheritance merge failed (Manifest <name>, at .spec.extends, <entity> extends <reference>, which could not be resolved: <what looking produced>). Verify the extends reference is a relative path or the name of a Manifest in the Release’s directory (échec de la fusion d’héritage : l’entité étend une référence qui n’a pas pu être résolue. Vérifiez que la référence extends est un chemin relatif ou le nom d’un Manifest dans le répertoire de la Release)

Ce détail final est l’échec que la recherche elle-même a signalé — le fichier qui n’a pas pu être lu, ou l’analyse qui n’a indexé aucun Manifest sous ce nom —, il indique donc généralement laquelle des deux formes a été essayée et pourquoi elle n’a rien donné.

L’extends: d’une Release est résolu par rapport à un répertoire, et il accepte une seule forme. Une Release nomme son parent par un chemin relatif — ./base-release.yaml, ou ../shared/base-release.yaml. Le répertoire par rapport auquel il est résolu est celui qui contient la Release qui écrit la référence, et chaque maillon d’une chaîne est résolu par rapport à son propre répertoire — ainsi, une Release en milieu de chaîne placée dans un sous-répertoire nomme son parent à côté d’elle-même, où que se trouve la Release que nomme une commande. Un jeton nu n’est pas un chemin et ne nomme pas une Release que le compilateur cherchera, il est donc signalé ici plutôt que recherché à un endroit où il ne peut pas être trouvé :

inheritance merge failed (Release <name>, at .spec.extends, <entity> extends <reference>, which could not be resolved: <what looking produced>). Verify the extends reference is a relative path to a Release file, such as ./base-release.yaml, resolved from the directory holding this Release (échec de la fusion d’héritage : l’entité étend une référence qui n’a pas pu être résolue. Vérifiez que la référence extends est un chemin relatif vers un fichier de Release, tel que ./base-release.yaml, résolu à partir du répertoire qui contient cette Release)

Comment corriger : pour un Component ou une Feature, vérifiez que la valeur de extends: nomme une entité que contient le catalogue, écrite comme le metadata.name propre de cette entité — casse comprise. Une base publiée dans un registre est lue depuis le cache d’artefacts selon l’épinglage que le lockfile de la Release enregistre pour elle ; lorsque la base se trouve dans un registre, exécutez donc aggrega pull --release <release> : le pull suit la chaîne, récupère la base et l’épingle. Pour un Manifest, vérifiez que le fichier se trouve là où pointe le chemin relatif, ou qu’un Manifest ayant ce metadata.name se trouve dans le répertoire de la Release et s’analyse correctement. Pour une Release, vérifiez que la valeur commence par ./ ou ../ et que le fichier vers lequel elle pointe est présent et s’analyse comme une Release.

An extends: chain runs past the depth bound (Une chaîne d’extension dépasse la borne de profondeur)

La chaîne extends: d’un Component, d’une Feature, d’un Manifest ou d’une Release se termine proprement mais traverse plus d’entités que la borne de dix ne le permet.

Elle a sa propre condition plutôt que de partager celle du dessus, parce que les deux remèdes n’ont rien en commun : un parent absent est une référence à corriger, et une chaîne trop profonde est une structure à aplatir. La borne est une protection contre un accident de rédaction plutôt qu’une limite structurelle — les architectes étendent généralement une base d’un ou deux niveaux, et une chaîne de dix niveaux est d’ordinaire une arborescence de base qui a grandi plutôt qu’une conception délibérée.

Seule une chaîne qui SE TERMINE l’atteint. Une chaîne qui revient sur elle-même est signalée comme une boucle quelle que soit sa longueur, de sorte que cette condition ne remplace jamais un cycle et que son conseil — raccourcir la chaîne — n’est jamais donné pour un cycle.

Message émis, qui nomme la borne et la longueur atteinte par la chaîne :

extends chain exceeds maximum depth (Component <name>, rule extends). the bound is 10 and this chain reaches <length>; shorten the chain, or extend a base that sits closer to its root (la chaîne extends dépasse la profondeur maximale. la borne est 10 et cette chaîne va au-delà ; raccourcissez la chaîne, ou étendez une base plus proche de sa racine)

Feature, Manifest ou Release apparaît à la place de Component lorsque c’est l’une de ces chaînes qui a échoué. La borne est la même, dix, pour chaque type qui déclare extends, et elle compte les entités de la chaîne plutôt que les maillons entre elles : une chaîne d’exactement dix entités se construit, et c’est la onzième entité que ce cas signale. Ainsi, une entité qui étend une base qui étend une base — trois entités, deux maillons — en est à trois.

Comment corriger : réduisez le milieu de la chaîne. Une chaîne aussi profonde signifie généralement que chaque niveau ajoute peu, et regrouper plusieurs niveaux en une seule entité de base est à la fois la correction et la structure la plus claire. Là où les niveaux sont réellement distincts, une entité plus bas dans la chaîne peut étendre directement une base plus proche de la racine au lieu d’hériter à travers chaque niveau intermédiaire. Une chaîne de Manifest aussi profonde est généralement une pile de surcouches par environnement — regroupez les niveaux que personne ne fait varier dans la base qu’ils surchargent.

An assertion name is declared twice along an extends: chain (Un nom d’assertion est déclaré deux fois le long d’une chaîne d’extension)

Une entité et quelque chose qu’elle étend déclarent tous deux une assertion sous le même nom, et les deux déclarent des règles différentes. Les assertions d’une entité qui étend s’ajoutent à celles de sa base ; elles n’en remplacent jamais une. Un nom déclaré deux fois avec deux règles différentes supprimerait donc silencieusement l’invariant de la base, ce qui est l’inverse de la raison d’être de l’extension d’une entité.

Déclarer le même nom avec la règle identique n’est pas une collision et se construit. C’est ce qui garde la vérification idempotente le long d’une chaîne : sans cela, une chaîne à trois niveaux entrerait à chaque fois en collision avec son propre niveau intermédiaire.

L’ordre fait partie du contrat plutôt que d’être accessoire. Les assertions sont évaluées dans l’ordre fusionné et la première qui échoue provoque l’arrêt, de sorte que l’invariant d’une base est vérifié avant celui d’un descendant, et le long d’une chaîne l’ensemble s’accumule depuis la racine vers le bas.

Message émis :

assertion name declared twice across the extends chain (Component <name>:<version>, rule assertions, at .spec.assertions.<key>). assertion "<key>" is already declared by the base Component "<base>", carrying a different rule; rename the extending entity’s assertion; an extending entity’s assertions add to the base’s and never replace one (nom d’assertion déclaré deux fois le long de la chaîne extends. l’assertion est déjà déclarée par le Component de base, avec une règle différente ; renommez l’assertion de l’entité qui étend ; les assertions d’une entité qui étend s’ajoutent à celles de la base et n’en remplacent jamais une)

Comment corriger : renommez l’assertion de l’entité qui étend, que le message nomme avec la base qui la déclare déjà. Là où vous vouliez remplacer la règle de la base, ce n’est pas quelque chose que l’extension prend en charge — restreignez l’assertion de la base pour qu’elle soit vraie pour chaque entité qui l’étend, ou déplacez la règle vers le bas, sur les entités qui en ont réellement besoin. Là où les deux règles sont censées être les mêmes, rendez-les textuellement identiques et la collision disparaît.

Une Release route les composants de son Aggregate de l’une de deux manières : des frontières nommées sous boundaries:, ou des composants de premier niveau sous components:. Les deux s’excluent mutuellement, et un document unique qui déclare les deux est refusé dès sa lecture. Cette condition est la même règle appliquée le long d’une chaîne extends: : une base qui déclare des frontières nommées et un enfant qui déclare des composants de premier niveau sont chacun bien formés à eux seuls, et ce n’est qu’en les fusionnant que les deux choix se retrouvent dans une seule Release résolue.

Aucun des deux documents n’est erroné à lui seul, c’est pourquoi le message les nomme tous les deux, ainsi que les deux clés. Un diagnostic ne nommant que la Release vers laquelle la build a été dirigée vous enverrait vers le fichier qui ne contient rien d’erroné.

Une chaîne dont les maillons concordent n’est pas touchée. Chaque maillon qui déclare des frontières nommées se compose normalement, de même que chaque maillon qui déclare des composants de premier niveau. C’est le mélange qui s’arrête.

Message émis, nommant les deux fichiers et la clé que chacun déclare :

release extends chain composes both named boundaries and top-level components: declare one routing shape across the chain, never both (Release <release-file>, boundaries declared by "<file>", components declared by "<file>") (la chaîne d’extension de la Release compose à la fois des frontières nommées et des composants de premier niveau : déclarez une seule structure de routage sur toute la chaîne, jamais les deux — Release, fichier qui déclare les frontières, fichier qui déclare les composants)

Comment corriger : choisissez la structure de routage que la chaîne doit utiliser et écrivez-la sur toute la chaîne. Là où la base déclare des frontières nommées, un enfant qui veut configurer des composants les désigne à l’intérieur de la frontière qui les contient plutôt qu’à la racine de la Release — c’est aussi ce qui lui permet de changer le dimensionnement d’un composant sans redéclarer la topologie. Là où la base déclare des composants de premier niveau, un enfant qui a besoin de frontières nommées décrit une structure de routage différente de celle de sa base, et il vaut mieux l’écrire comme une Release à part entière que comme un enfant de celle-ci.

An external input’s URL uses a scheme that is not allowed (L’URL d’une entrée externe utilise un schéma non autorisé)

Une URL vers laquelle pointe une entité utilise un schéma hors de l’ensemble autorisé. Trois sont autorisés : https ; http, mais uniquement vers un hôte de loopback, de sorte que le texte en clair ne puisse jamais atteindre que la machine locale ; et oci, pour le contenu récupéré depuis un registre.

Messages émis, pour une URL http hors loopback et pour tout autre schéma :

externalinputs: "<url>": plain http is allowed for loopback hosts only (allowed schemes: https, http to a loopback host, oci): externalinputs: URL scheme is not allowed (externalinputs : http en clair n’est autorisé que pour les hôtes de loopback (schémas autorisés : https, http vers un hôte de loopback, oci) : externalinputs : le schéma de l’URL n’est pas autorisé) externalinputs: "<url>": scheme "<scheme>" is not allowed (allowed schemes: https, http to a loopback host, oci): externalinputs: URL scheme is not allowed (externalinputs : le schéma n’est pas autorisé (schémas autorisés : https, http vers un hôte de loopback, oci) : externalinputs : le schéma de l’URL n’est pas autorisé)

Comment corriger : passez l’URL en https, ou en oci lorsque le contenu est publié dans un registre. Une URL http en clair vers un hôte distant est refusée plutôt que rétrogradée, la correction consiste donc à la faire pointer vers le schéma sécurisé ; un serveur de développement local continue de fonctionner en http, car un hôte de loopback est autorisé.

A render requests an external input the lockfile does not pin (Un rendu demande une entrée externe que le fichier de verrouillage n’épingle pas)

Un élément dont une build a besoin est récupéré depuis une URL que le fichier de verrouillage n’épingle pas. Une build effectue le rendu de la clôture que son fichier de verrouillage enregistre et ne récupère rien, il n’existe donc aucun paramètre qui permettrait à cette exécution d’acquérir l’URL à la place : la clôture figée est ce qui rend une build reproductible, et élargir discrètement l’ensemble des entrées est la seule chose qu’elle ne doit pas faire.

Atteindre cet arrêt est donc instructif plutôt qu’une erreur de configuration. Les épinglages étaient complets lorsque la Release a été résolue, donc une URL non épinglée signifie désormais que quelque chose a changé depuis — une valeur qui oriente les références qu’un rendu demande, un chart qui s’est mis à pointer ailleurs, ou un fichier de verrouillage résolu par rapport à une autre Release.

Message émis :

"<url>" is not pinned in the lockfile; run aggrega pull --release <release> to pin every external input this Release’s render consumes, then build again: externalinputs: acquisition is disabled for unpinned inputs (n’est pas épinglée dans le fichier de verrouillage ; exécutez la commande pour épingler chaque entrée externe que consomme le rendu de cette Release, puis relancez la build : externalinputs : l’acquisition est désactivée pour les entrées non épinglées)

Comment corriger : épinglez l’entrée. aggrega pull --release <path> effectue le rendu de la Release pour découvrir quelles entrées externes elle consomme, récupère chacune d’elles et enregistre son digest dans le fichier de verrouillage à côté des épinglages de dépendances — après quoi chaque build ultérieure la sert depuis l’enregistrement épinglé et n’a besoin d’aucun réseau. Lorsque l’URL est nouvelle parce qu’un élément que vous avez écrit s’est mis à pointer vers elle, résoudre à nouveau la Release est l’étape qui a été sautée ; lorsqu’elle est inattendue, il vaut la peine de trouver la référence qui l’a introduite avant de l’épingler.

Fetched bytes do not match a pinned digest (Les octets récupérés ne correspondent pas à un digest épinglé)

Une URL épinglée a été récupérée à nouveau — parce que sa copie stockée manquait — et ce qui est revenu n’est pas ce que le fichier de verrouillage a épinglé. Le digest enregistré l’emporte toujours : rien n’est écrit dans le magasin et aucun octet n’est renvoyé.

Un réapprovisionnement est récupéré par le digest enregistré plutôt que par le tag de l’URL, de sorte qu’un tag déplacé pour pointer vers un autre contenu ne peut pas changer ce que sert une entrée épinglée. Atteindre cet arrêt signifie donc que c’est le contenu derrière le digest lui-même qui n’est pas revenu intact.

Messages émis, pour le contenu récupéré depuis un registre et pour le contenu récupéré via HTTPS :

externalinputs: "<url>": refilled manifest digest is <digest>, pinned digest is <digest>: externalinputs: fetched bytes mismatch the pinned digest (externalinputs : le digest du manifeste réapprovisionné diffère du digest épinglé : externalinputs : les octets récupérés ne correspondent pas au digest épinglé) externalinputs: "<url>": refetched bytes hash to <digest>, pinned digest is <digest>: externalinputs: fetched bytes mismatch the pinned digest (externalinputs : le hash des octets récupérés à nouveau diffère du digest épinglé : externalinputs : les octets récupérés ne correspondent pas au digest épinglé)

Comment corriger : traitez-le d’abord comme une question de chaîne d’approvisionnement plutôt que comme un fichier de verrouillage à rafraîchir — l’épinglage est l’affirmation que ces octets exacts sont ceux avec lesquels vous avez effectué la build, et le refus est cette affirmation qui tient. Vérifiez que la source publie toujours le contenu que nomme le digest, et si quelque chose entre vous et elle réécrit les réponses ; un proxy ou un miroir servant un substitut est une cause courante. Ce n’est qu’une fois que vous savez ce qui a changé et que vous l’acceptez que vous devriez épingler à nouveau avec aggrega pull, qui enregistre le nouveau digest.

A stored external input no longer matches its record (Une entrée externe stockée ne correspond plus à son enregistrement)

Une entrée épinglée a été relue depuis le magasin local et ne correspond pas à l’enregistrement épinglé pour elle. La vérification s’exécute à chaque lecture, avant que les octets ne soient servis, de sorte qu’un magasin corrompu ou altéré se révèle au point d’utilisation plutôt que d’alimenter discrètement une build.

Ce qui est comparé dépend de la manière dont l’entrée est épinglée. Le contenu récupéré via HTTPS est épinglé en hachant la charge utile, il est donc rehaché à chaque lecture et les deux digests sont signalés. Le contenu récupéré depuis un registre est épinglé par le digest de son manifeste, qui engage la charge utile par le manifeste propre du registre plutôt qu’en la hachant directement, de sorte qu’une copie stockée est vérifiée par rapport à la taille enregistrée — la vérification complète du digest s’ancre plutôt à l’acquisition et à chaque réapprovisionnement adressé par digest.

Messages émis :

externalinputs: "<url>": store blob sha256 is <digest>, pinned digest is <digest>: externalinputs: store blob mismatches its pinned record (externalinputs : le sha256 du blob du magasin diffère du digest épinglé : externalinputs : le blob du magasin ne correspond pas à son enregistrement épinglé) externalinputs: "<url>": store blob sha256/<digest> is <n> bytes but the pinned record says <n>: externalinputs: store blob mismatches its pinned record (externalinputs : la taille en octets du blob sha256 du magasin diffère de celle qu’indique l’enregistrement épinglé : externalinputs : le blob du magasin ne correspond pas à son enregistrement épinglé)

Comment corriger : supprimez le blob en cause du magasin et laissez l’exécution suivante le réapprovisionner depuis la source, ce qui est vérifié par rapport au digest enregistré avant que quoi que ce soit ne soit écrit. Si un réapprovisionnement signale alors lui aussi une divergence de digest, le désaccord se situe en amont plutôt qu’en local, et c’est l’entrée ci-dessus qu’il faut lire. Un magasin partagé entre plusieurs machines, ou restauré depuis une sauvegarde prise en pleine écriture, est la cause locale habituelle.

A guard needs a catalog entity the build resolved and cannot see (Une garde a besoin d’une entité du catalogue que la build a résolue et qu’elle ne peut pas voir)

Une garde sémantique a cherché l’entité du catalogue derrière le type d’un composant, et l’entité est absente de la vue fournie à la garde — alors même que la résolution a résolu ce type comme une référence de catalogue. Une référence réellement impossible à résoudre s’arrête plus tôt, à la résolution, donc atteindre une garde avec l’entité manquante signifie que l’ensemble résolu de la build et la vue de la garde ont divergé.

La build s’arrête plutôt que de sauter la garde. Sauter la garde retirerait une vérification sans rien pour signaler qu’elle a disparu, et les composants dont la garde s’occupait passeraient sans examen pendant que la build signalerait un succès.

Un type écrit comme un chemin relatif — commençant par ./ ou ../ — n’est pas jugé ici : un type n’est jamais lu comme un fichier, une telle valeur ne nomme donc aucune entité du catalogue et est refusée plus tôt, lorsque les dépendances de la Release sont résolues, comme une référence qu’aucun catalogue ne contient. Seule une référence de catalogue sous forme de jeton simple atteint cet arrêt.

Partout où la condition est remplie, elle est signalée avec les mêmes mots, de sorte que le texte nomme le type et la faute plutôt que la vérification qui l’a levée.

Elle ne nomme pas non plus de document ni de clé à l’intérieur de l’un d’eux, ce qui est délibéré et constitue le seul endroit où cet arrêt se lit différemment de tous les autres. Tout autre arrêt se positionne sur le fichier et le champ que vous modifieriez pour le lever ; il n’existe ici aucun fichier de ce type, une position vous enverrait donc vers une clé qui n’est pas en faute. C’est à la place le type sur lequel les deux vues divergent qui est signalé, car c’est lui qui rend la divergence reproductible pour qui l’examine.

Message émis :

the compiler’s own views of the catalog disagree (internal error: this build resolved a component type that the catalog it reads then held no entry for. This is a fault in the compiler rather than in an authored document, so there is nothing to correct in the Aggregate, the Release or the catalog. Please report it, naming the command that produced this build and the type the views disagree on: "<type>") (les vues propres au compilateur sur le catalogue divergent (erreur interne : cette build a résolu un type de composant pour lequel le catalogue qu’elle lit ne contenait ensuite aucune entrée. Il s’agit d’une faute du compilateur plutôt que d’un document écrit par un auteur, il n’y a donc rien à corriger dans l’Aggregate, la Release ou le catalogue. Veuillez la signaler en nommant la commande qui a produit cette build et le type sur lequel les vues divergent))

Comment corriger : rien dans vos propres fichiers — ceci signale une incohérence interne au compilateur plutôt qu’une faute dans ce que vous avez écrit, et il vaut la peine de la signaler comme une anomalie avec le type que nomme le message. Le type du composant est presque certainement correct.

A reference names no entity the catalog holds (Une référence ne nomme aucune entité que contient le catalogue)

Avant qu’une build n’effectue le rendu de quoi que ce soit, l’ensemble des entités dont dépend une Release est parcouru et chacune est épinglée, de sorte que le fichier de verrouillage enregistre exactement ce que la build lira. Une référence à laquelle le catalogue ne peut pas répondre interrompt ce parcours : rien ne peut être épinglé pour elle, et continuer écrirait un fichier de verrouillage privé d’une entrée dont la build aura besoin plus tard, sans que rien ne le signale.

Le refus nomme la référence et l’endroit où elle a été collectée, car une entité est atteinte depuis de nombreux endroits et l’endroit qui la nomme est celui où va la correction. Une référence de bibliothèque est signalée seule, sans chemin de collecte — une bibliothèque est atteinte depuis les entités qui la référencent par $ref ou $import, et le nom en échec constitue l’intégralité de la faute.

Message émis, pour une entité du catalogue — la partie finale liste les endroits qui la référencent :

resolve: no entity in the catalog matches this URI: entity "<reference>" (referenced from <referring paths>) (resolve : aucune entité du catalogue ne correspond à cet URI : entité, avec les chemins depuis lesquels elle est référencée)

pour une bibliothèque :

resolve: no entity in the catalog matches this URI: library "<reference>" (resolve : aucune entité du catalogue ne correspond à cet URI : bibliothèque)

et pour un plugin lié à un socket de fournisseur, qui est nommé par la clé de configuration de l’espace de travail qui le contenait plutôt que par un document du catalogue :

resolve: no entity in the catalog matches this URI: entity "<reference>" (referenced from .aggrega-config.yaml.plugins.providers) (resolve : aucune entité du catalogue ne correspond à cet URI : entité, référencée depuis .aggrega-config.yaml.plugins.providers)

Lorsqu’un fichier sous les répertoires de catalogue déclare le nom que demande la référence sous un type d’entité qu’aucun catalogue ne contient — un kind mal orthographié, par exemple —, la note sous cet échec nomme ce fichier, le type qu’il déclare et les types que contient un catalogue, et omet le conseil sur l’endroit où les entités locales sont lues, sur une build qui remplit son fichier de verrouillage comme sur une build qui le lit, et sur toute autre surface qui signale cet échec ; voir Un fichier de catalogue refusé et l’échec qu’il explique.

Comment corriger : lisez la référence exactement telle que le message la cite. Un nom qui n’existe pas, une version qui n’a jamais été publiée et un nom simple dont l’espace de travail ne vise pas le registre arrivent tous ici de façon identique, vérifiez donc les trois dans cet ordre : corrigez la graphie ; confirmez que la version existe ; confirmez que le registre qui la contient est configuré et joignable. Lorsque l’entité est une entité que vous écrivez en local, confirmez que le fichier se trouve dans le catalogue que parcourt la build.

Lorsque aggrega pull, ou aggrega build --auto-pull, s’arrête sur une référence de bibliothèque alors que le cache d’artefacts contient une SchemaLibrary qu’aucune entrée du fichier de verrouillage n’épingle et qu’aucun répertoire de catalogue ne fournit, une ligne remediation: suit le message, nommant chacune de ces bibliothèques. Une bibliothèque en cache ne compte comme contenu du catalogue que lorsqu’une entrée du fichier de verrouillage se porte garante de son digest, et le pull enregistre cette entrée depuis le registre qui sert la bibliothèque. En mode hors ligne, le pull ne peut ni récupérer la bibliothèque ni enregistrer d’entrée pour elle, la ligne indique donc d’exécuter aggrega pull --release <release> là où il peut atteindre un registre, ou d’écrire la bibliothèque sous un répertoire de catalogue. En mode connecté, aucun répertoire de catalogue ni aucun registre que lit le pull ne sert la bibliothèque, il n’y a donc aucune entrée à enregistrer, et la ligne indique d’écrire la bibliothèque sous un répertoire de catalogue.

A library reference is not written in the identity form (Une référence de bibliothèque n’est pas écrite sous la forme d’identité)

Un $ref: ou un $import: entre bibliothèques nomme la bibliothèque par son identité, puis l’entrée qu’elle contient : le nom simple de la bibliothèque, éventuellement un : et une version minimale, puis # et le chemin de l’entrée sur la surface que lit le champ. Cette forme ne comporte aucun hôte de registre. Le registre par lequel un nom est résolu relève de la configuration de l’espace de travail, et la version qu’utilise une build est la réponse du fichier de verrouillage, de sorte qu’une référence portant l’un ou l’autre figerait dans le document quelque chose que la build est censée décider.

Sont refusés ici : une valeur portant un hôte de registre ; une ancre interne au document écrite là où une référence entre bibliothèques était attendue ; un nom de bibliothèque vide ; et @ écrit comme séparateur de version, qui est signalé avec la graphie corrigée plutôt que comme une plainte générique sur la structure, car c’est l’erreur que cette forme attire le plus.

Message émis :

resolve: invalid library reference URI: "<the value as written>" (resolve : URI de référence de bibliothèque non valide)

et lorsque @ a été utilisé comme séparateur, en citant ce que la valeur devrait indiquer à la place :

resolve: invalid library reference URI: version separator is ’:’, not ’@’ — use "<the corrected value>" (resolve : URI de référence de bibliothèque non valide : le séparateur de version est ’:’, et non ’@’ — utilisez la valeur corrigée)

Comment corriger : réécrivez la valeur sous la forme <Library>#<entry-path>, en ajoutant :<version> après le nom de la bibliothèque uniquement là où vous avez besoin d’une version minimale pour borner la version qui peut être sélectionnée. Supprimez tout hôte de registre. Lorsque la référence devait pointer à l’intérieur du même document, une ancre interne au document est une chose différente d’une référence de bibliothèque, et le champ sur lequel vous l’avez écrite attend la forme de bibliothèque.

Two consumers of one library require incompatible versions (Deux consommateurs d’une même bibliothèque exigent des versions incompatibles)

Plusieurs entités peuvent référencer une même bibliothèque, chacune indiquant une version minimale ou aucune, et la version que la build sélectionne est la plus haute version minimale indiquée par l’une d’elles. C’est ce qui permet à un consommateur qui demande moins de recevoir malgré tout une version qui le satisfait, et c’est pourquoi l’ajout d’un consommateur avec une version minimale plus haute fait monter tout le monde au lieu de répartir la build entre deux copies.

La règle ne tient que tant que les versions minimales s’accordent sur le premier numéro de version. Deux consommateurs qui indiquent des versions majeures différentes demandent deux bibliothèques qui portent par hasard le même nom, et aucune sélection unique ne satisfait les deux — ainsi, plutôt que d’en choisir une et de laisser l’autre consommateur lire une structure pour laquelle il n’a pas été écrit, la build s’arrête et signale le désaccord. Un consommateur qui n’indique aucune version minimale ne prend part à rien ici : la sélection est décidée par les consommateurs qui ont épinglé une version.

Message émis. Les consommateurs sont comparés dans l’ordre trié : le premier à indiquer une version minimale fixe la version majeure, et le message énumère chaque consommateur comparé, jusqu’au premier inclus dont la version minimale indique une version majeure différente, avec la version qu’il exigeait — ainsi, les mêmes documents nomment toujours les mêmes consommateurs :

resolve: minimal version selection conflict — incompatible library version requirements: library "<library>" has consumers requiring incompatible majors: <consumer> wants <version>; <consumer> wants <version> (résolution : conflit de sélection de version minimale — exigences de version de bibliothèque incompatibles : la bibliothèque a des consommateurs qui exigent des versions majeures incompatibles : le consommateur veut la version ; le consommateur veut la version)

Comment corriger : relevez la version minimale du consommateur le plus bas jusqu’à la même version majeure, ce qui est la réponse ordinaire dès lors que la structure la plus récente est celle que tout le monde veut. Lorsque les deux versions majeures sont réellement nécessaires en même temps, il s’agit de deux bibliothèques : publiez l’ancienne structure sous un nom qui lui est propre et faites pointer vers elle le consommateur qui en a besoin, afin que chaque référence nomme ce pour quoi elle a été écrite.

The chain of module imports is deeper than the pin walk descends (La chaîne d’importations de modules est plus profonde que ce que descend le parcours d’épinglage)

L’épinglage parcourt chaque module qu’un Aggregate importe, puis chaque module que ceux-ci importent, de sorte que l’ensemble complet atteint le fichier de verrouillage et pas seulement le premier niveau. Un module déjà enregistré n’est pas parcouru une seconde fois, ce qui met fin à une boucle ordinaire — un Aggregate qui importe un module qui l’importe à son tour se termine sans erreur, après avoir enregistré chacun une seule fois.

Une borne de profondeur de dix sert de garde-fou pour la chaîne que la détection des répétitions ne peut pas voir : une chaîne qui présente une identité nouvelle à chaque niveau, comme le fait un module republié sous une nouvelle version à chaque étape. La borne est la même que celle qu’applique le constructeur de graphe, de sorte qu’une composition qui s’épingle est aussi une composition qui se construit.

Message émis :

resolve: sub-aggregate inclusion depth exceeded: "<module>" at depth <depth> (résolution : profondeur d’inclusion des sous-agrégats dépassée : à la profondeur)

Comment corriger : raccourcissez la chaîne. Une chaîne aussi profonde reflète généralement l’organisation d’une entreprise plutôt que celle de la Release ; cherchez donc les niveaux qui n’apportent aucun composant qui leur soit propre et fusionnez-les dans leur parent. Lorsque chaque niveau n’existe que pour republier le niveau inférieur sous une nouvelle version, ce sont les versions qui forment la chaîne : importez directement le module que vous voulez réellement, dans la version que vous voulez.

Il s’agit de la borne du parcours d’épinglage. Le constructeur de graphe applique la sienne, signalée plus bas sous « Sub-aggregate nesting depth exceeded (Profondeur d’imbrication des sous-agrégats dépassée) », et les deux sont des signalements distincts de la même borne atteinte en deux points — le premier pendant le remplissage du fichier de verrouillage, le second pendant la construction du graphe.

The catalog view a build was given cannot load the bodies pinning needs (La vue du catalogue fournie à une build ne peut pas charger les corps dont l’épinglage a besoin)

Deux des axes que l’épinglage parcourt demandent au catalogue plus qu’une réponse sur la version : ils ont besoin des documents eux-mêmes. Les modules qu’un Aggregate importe doivent être lus pour trouver ce qu’ils importent à leur tour. Les Recipes, FeatureRecipes et Plugins qu’une build lie doivent être lus pour trouver les artefacts et les bibliothèques qu’ils nomment. Une vue du catalogue capable de résoudre une version mais incapable de restituer ces corps laisse les deux axes sans rien à lire.

Les deux sont refusés d’emblée plutôt qu’ignorés, et la raison tient à ce qu’un saut produirait : un fichier de verrouillage privé d’une classe entière d’entrées, écrit sans erreur, qu’une build ultérieure reconstruit fidèlement et trouve incomplet. Aucun des deux messages ne contient de valeurs propres, car aucun ne porte sur un document que vous avez écrit — chacun indique quel axe ne peut pas être calculé :

resolve: catalog lookup cannot load resolved sub-aggregate bodies (résolution : la recherche dans le catalogue ne peut pas charger les corps des sous-agrégats résolus) resolve: catalog lookup cannot load resolved recipe and plugin bodies (résolution : la recherche dans le catalogue ne peut pas charger les corps de Recipe et de plugin résolus)

Comment corriger : rien dans vos fichiers ne produit l’un ou l’autre, et aucune modification de ce que vous avez écrit n’en fait disparaître un — la faute tient à la manière dont la build a été câblée, et non à ce qu’on lui a demandé de construire. Signalez-la avec la commande que vous avez exécutée et la configuration de l’espace de travail sur laquelle elle a été exécutée.

An annotation-transform plugin names a component it was not given, or injects a value no annotation takes (Un plugin annotation-transform nomme un composant qui ne lui a pas été fourni, ou injecte une valeur qu’aucune annotation n’accepte)

Un opérateur peut rattacher un plugin de gouvernance dans un rôle qui ajoute des annotations, et ce rattachement est une déclaration : l’opérateur a demandé la transformation, de sorte que ce que le plugin ajoute est explicite plutôt qu’injecté dans le dos de quiconque. Le rôle est restreint en conséquence. Le plugin reçoit les coordonnées de composants que vos documents déclarent, et peut ajouter des annotations sur celles-ci, chacune portant une valeur que vous auriez pu écrire vous-même sur cette annotation : une chaîne, ou un objet de sous-clés. La structure qu’il renvoie n’admet aucun autre champ, de sorte qu’il ne reste à vérifier, lorsque sa sortie est appliquée, que si chaque injection a nommé une coordonnée qui lui a été fournie et si chaque valeur est une valeur qu’une annotation accepte.

Une injection qui nomme une paire frontière-composant hors de cet ensemble arrête la build. Un plugin qui atteindrait un composant que vos documents n’ont jamais exposé configurerait une infrastructure que personne n’a déclarée, et les annotations qu’il ajoute sont développées en rattachements de Feature exactement comme celles qui sont écrites par l’auteur, de sorte que l’effet serait l’apparition de ressources à partir d’un composant que l’opérateur ne lui a pas présenté.

Une injection dont la valeur est null, une liste, un nombre, un booléen ou un objet sans sous-clés arrête elle aussi la build. Null et un objet vide se lisent comme la valeur que vous écrivez pour exclure un composant d’une annotation dont il hériterait, et le rôle ajoute des annotations au lieu d’en retirer ; les autres structures ne sont pas des valeurs qu’une annotation accepte. La sortie entière est vérifiée avant que la moindre partie n’en soit appliquée, de sorte qu’une sortie refusée ne change rien.

Chaque injection acceptée porte aussi une annotation d’accompagnement, aggrega.ai/injected-by, qui nomme le plugin qui l’a effectuée. C’est l’hôte qui écrit cette annotation ; un plugin ne peut pas en fournir une, de sorte que ce qu’elle dit de la provenance d’une annotation injectée n’est pas au plugin de le façonner.

Message émis, pour une coordonnée qui n’a pas été fournie au plugin et pour une valeur qu’aucune annotation n’accepte :

annotation-transform plugin output was rejected: an injection targets a component coordinate the host did not supply, or carries a value that is not a string or an object of subkeys: injection targets boundary "<boundary>" component "<component>" (annotation "<key>") (la sortie du plugin annotation-transform a été rejetée : une injection cible une coordonnée de composant que l’hôte n’a pas fournie, ou porte une valeur qui n’est ni une chaîne ni un objet de sous-clés : l’injection cible la frontière, composant (annotation)) annotation-transform plugin output was rejected: an injection targets a component coordinate the host did not supply, or carries a value that is not a string or an object of subkeys: injection for boundary "<boundary>" component "<component>" (annotation "<key>") carries a list; an injected annotation value is a string or an object of subkeys (la sortie du plugin annotation-transform a été rejetée : une injection cible une coordonnée de composant que l’hôte n’a pas fournie, ou porte une valeur qui n’est ni une chaîne ni un objet de sous-clés : l’injection pour la frontière, composant (annotation) porte une liste ; une valeur d’annotation injectée est une chaîne ou un objet de sous-clés)

Comment corriger : la faute est celle du plugin et non de vos documents — corrigez-le pour qu’il n’injecte que sur les coordonnées qui lui sont remises, chacune arrivant dans son entrée, et seulement une chaîne ou un objet de sous-clés comme valeur. Lorsque le composant du message est un composant que vous vous attendiez à ce que le plugin voie, vérifiez que la Release le déclare à l’intérieur d’une frontière : seules les coordonnées de composants déclarés sont transmises. Retirer le rattachement de plugins.governance est le moyen immédiat de débloquer une build pendant que le plugin est corrigé.

A plugin reference is not a Plugin entity (Une référence de plugin n’est pas une entité Plugin)

Un plugin est référencé par son entité Plugin, toujours dans la portée du type de socket propre au plugin : <pluginType>/<name>, éventuellement avec une version, comme dans parser/yaml ou parser/yaml:1.0.0. La portée est obligatoire et non une forme parmi d’autres — un name:version sans portée est refusé, parce que deux sockets peuvent contenir un plugin du même nom et que c’est la portée qui rend l’entité résoluble. Le binaire vers lequel pointe l’entité est atteint par l’entité, jamais nommé directement, de sorte que c’est l’entité qui porte la déclaration de capacité, les limites d’exécution et le jeu de commandes enregistré par rapport auxquels le chargement vérifie le binaire. Une référence qui ne nomme aucune entité Plugin n’a donc rien par rapport à quoi vérifier le binaire, et la build s’arrête plutôt que de charger des octets sur une référence non vérifiée.

Deux structures sont signalées ici, et elles sont vérifiées à des moments différents. Une référence dont la forme ne peut pas être une entité — un chemin du système de fichiers, ou une référence d’artefact telle qu’une URL oci://, un .wasm nu ou un condensé @sha256: — est refusée d’emblée sur les surfaces qui n’acceptent que des références d’entité. Une référence qui ne nomme aucune entité détenue par quoi que ce soit est refusée après la recherche, et ce que dit le message dépend de la façon dont elle est écrite : une URI d’entité Plugin — <pluginType>/<name>, éventuellement versionnée — est signalée comme une entité qu’aucun répertoire de catalogue ne contient, que le binaire n’embarque pas et qu’aucun pull n’a récupérée, et toute autre référence se voit indiquer de prendre cette forme. Les deux structures signalent la même condition, de sorte que la réponse d’une build à l’une ou à l’autre est la même.

Un pull refuse la seconde structure avant qu’une build ne la rencontre. Chaque Plugin que nomme la pipeline d’une Recipe ou d’une FeatureRecipe est résolu avec le reste des dépendances de la Release — depuis un répertoire de catalogue, la copie intégrée au binaire du compilateur, le cache de contenu ou un registre — et un Plugin qu’aucun d’eux ne contient arrête aggrega pull avant qu’il n’écrive le fichier de verrouillage, avec cette condition et le même message, en nommant la Recipe ou la FeatureRecipe dont la pipeline le nomme.

Toutes les surfaces ne refusent pas une forme qui n’est pas une entité. La surface des plugins de pipeline n’accepte que des références d’entité ; les surfaces auxquelles un opérateur rattache directement un plugin acceptent n’importe quelle forme et transmettent une référence qui n’est pas une entité pour qu’elle soit résolue comme un artefact. Ainsi, la même référence peut être acceptée à un point de rattachement et refusée à un autre, et cette différence tient à la surface, non à la référence.

Messages émis. Un chemin du système de fichiers :

plugin reference is not a Plugin entity: "<reference>" is a filesystem path, but a pipeline plugin must be a plugin-type-scoped Plugin entity URI (<pluginType>/<name>, optionally versioned, as in parser/yaml or parser/yaml:1.0.0) (la référence de plugin n’est pas une entité Plugin : est un chemin du système de fichiers, mais un plugin de pipeline doit être une URI d’entité Plugin dans la portée d’un type de plugin (éventuellement versionnée))

une référence d’artefact :

plugin reference is not a Plugin entity: "<reference>" is an artifact reference (an oci:// scheme, a bare .wasm, or an @sha256: digest), but a pipeline plugin must be a plugin-type-scoped Plugin entity URI (<pluginType>/<name>, optionally versioned, as in parser/yaml or parser/yaml:1.0.0) (la référence de plugin n’est pas une entité Plugin : est une référence d’artefact (un schéma d’URL, un fichier Wasm nu ou un condensé), mais un plugin de pipeline doit être une URI d’entité Plugin dans la portée d’un type de plugin (éventuellement versionnée))

une URI d’entité Plugin que rien ne contient :

plugin reference is not a Plugin entity: "<reference>" is a Plugin entity URI, but no catalog directory holds the entity it names, the binary does not carry it, and no pull has fetched it into the content cache; place the Plugin entity in a catalog directory, or publish it to a registry and run aggrega pull (la référence de plugin n’est pas une entité Plugin : est une URI d’entité Plugin, mais aucun répertoire de catalogue ne contient l’entité qu’elle nomme, le binaire ne l’embarque pas et aucun pull ne l’a récupérée dans le cache de contenu ; placez l’entité Plugin dans un répertoire de catalogue, ou publiez-la dans un registre et exécutez le pull)

et toute autre référence qui ne nomme aucune entité — une référence sans portée de type de plugin, avec plus d’un / avant sa version, ou portant un hôte de registre :

plugin reference is not a Plugin entity: "<reference>" must be a plugin-type-scoped Plugin entity URI (<pluginType>/<name>, optionally versioned, as in parser/yaml or parser/yaml:1.0.0); a bare .wasm reference or an artifact reference names no Plugin entity (la référence de plugin n’est pas une entité Plugin : doit être une URI d’entité Plugin dans la portée d’un type de plugin (éventuellement versionnée) ; une référence à un fichier Wasm nu ou une référence d’artefact ne nomme aucune entité Plugin)

Comment corriger : écrivez la référence sous la forme de l’identité de l’entité Plugin dans la portée de son type de socket, éventuellement avec sa version — <pluginType>/<name> ou <pluginType>/<name>:<version>. Si vous pointiez directement vers un fichier ou un artefact, publiez ou écrivez une entité Plugin pour celui-ci et référencez-la à la place — c’est dans l’entité que résident les déclarations que le chargement vérifie, de sorte qu’aucune forme équivalente ne permet de s’en passer. Lorsque le message indique que la référence est une URI d’entité Plugin, sa forme est correcte et c’est l’entité qui manque : placez l’entité Plugin dans un répertoire de catalogue que l’espace de travail répertorie, avec son .wasm compilé à côté, ou publiez le plugin dans un registre que l’espace de travail lit et exécutez aggrega pull, qui le récupère dans le cache de contenu — et vérifiez que la version que vous indiquez existe bien.

A cached signature bundle does not match the digest recorded for it (Un bundle de signature en cache ne correspond pas au digest enregistré pour lui)

Un artefact dont la signature a été vérifiée lors de sa récupération conserve ce fait dans son entrée du fichier de verrouillage — ou, pour un plugin rattaché à un rôle de verdict, dans son entrée de plugins-trust.yaml — sous la forme d’un digest enregistré des éléments de signature, qui sont mis en cache à côté de l’artefact. Avant tout rendu, la build relit ces éléments en cache pour chaque entrée qu’elle lit et qui en enregistre un — une entité de catalogue de n’importe quel type, une bibliothèque, un plugin — et en recalcule le hash, qui doit être celui enregistré. Un plugin que le fichier de verrouillage épingle, et un plugin rattaché à un rôle de verdict, voit ses éléments vérifiés à nouveau lorsque ses octets sont chargés, ce qui atteint les commandes qui chargent un plugin en dehors d’une build — dont aggrega lint --release et aggrega validate --release. Un bundle manquant, illisible ou dont le hash diffère signifie que les éléments examinés ne sont pas ce qui se trouve désormais sur le disque, et l’exécution s’arrête plutôt que d’utiliser un artefact dont les preuves de signature ont changé à l’insu de l’enregistrement.

La nouvelle vérification est une comparaison de hash, rien de plus. Elle ne revérifie aucune signature, ne contacte aucun réseau et ne consulte aucun élément de confiance, si bien qu’elle tient dans une build sans aucun accès réseau — ce qui permet à un artefact vérifié une fois de rester vérifié au fil des builds hors ligne ultérieures.

Le pull suivant le répare. Un pull soumet au même contrôle chaque entrée servie par le cache de contenu et, lorsque le contrôle refuse une entrée, il interroge à nouveau le registre de l’artefact sur la signature — quoi que dise l’exigence de signature, par la même vérification que celle que reçoit un artefact qu’il récupère —, enregistre sur l’entrée ce que cette vérification établit et met en cache le bundle qu’elle désigne, en réécrivant une copie en cache qui ne correspond plus à son digest. Un plugin rattaché à un rôle de verdict est vérifié à nouveau à chaque pull, quoi qu’enregistre son entrée, et son bundle est mis en cache de la même manière. Le message relatif à une entrée servie par le cache de contenu désigne donc ce pull. Une entrée lue dans un répertoire de catalogue, dans la copie intégrée au binaire du compilateur ou à côté de la Release n’est jamais soumise à un registre, si bien qu’un pull laisse telle quelle une signature enregistrée sur elle, et son message ne désigne aucun pull.

Messages émis, qui désignent l’artefact, le fichier en cache et — pour une entrée servie par le cache de contenu — le pull qui la répare, le fichier dans lequel il enregistre la signature et la Release qu’il récupère. Depuis le contrôle de la build, illisible ou absent :

artifact "<reference>": cached signature bundle <path> is unreadable: cached signature bundle does not match its recorded digest. remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (artefact : le bundle de signature en cache est illisible : le bundle de signature en cache ne correspond pas à son digest enregistré. remède : exécutez le pull pour vérifier à nouveau la signature de l’artefact auprès de son registre, l’enregistrer dans le fichier et mettre en cache le bundle qu’elle désigne)

et divergent :

artifact "<reference>": cached signature bundle <path> has digest <actual>, recorded digest is <recorded>: cached signature bundle does not match its recorded digest. remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (artefact : le bundle de signature en cache a un digest différent de celui enregistré : le bundle de signature en cache ne correspond pas à son digest enregistré. remède : exécutez le pull pour vérifier à nouveau la signature de l’artefact auprès de son registre, l’enregistrer dans le fichier et mettre en cache le bundle qu’elle désigne)

et, lorsque les octets d’un plugin sont chargés depuis le cache de contenu, en désignant aussi leur provenance :

plugin "<reference>" resolved from <source>: cached signature bundle <path> is unreadable: cached signature bundle does not match its recorded digest. remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (plugin résolu depuis sa source : le bundle de signature en cache est illisible : le bundle de signature en cache ne correspond pas à son digest enregistré. remède : exécutez le pull pour vérifier à nouveau la signature de l’artefact auprès de son registre, l’enregistrer dans le fichier et mettre en cache le bundle qu’elle désigne)

plugin "<reference>" resolved from <source>: cached signature bundle <path> has digest <actual>, recorded digest is <recorded>: cached signature bundle does not match its recorded digest. remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (plugin résolu depuis sa source : le bundle de signature en cache a un digest différent de celui enregistré : le bundle de signature en cache ne correspond pas à son digest enregistré. remède : exécutez le pull pour vérifier à nouveau la signature de l’artefact auprès de son registre, l’enregistrer dans le fichier et mettre en cache le bundle qu’elle désigne)

<file> est le fichier de verrouillage de la Release, ou plugins-trust.yaml dans le répertoire de la Release. Pour une entrée au sujet de laquelle aucun pull n’interroge de registre, le message s’arrête avant remediation:.

Un pull qui n’a aucun registre à interroger s’arrête à la place. Une entité de catalogue ou une bibliothèque est nommée sans registre et est liée à un registre par le default_registry de l’espace de travail. Lorsque l’espace de travail n’en nomme aucun — il le faisait lorsque la signature a été enregistrée, et ne le fait plus —, aucun registre n’est configuré pour être interrogé à nouveau sur l’entrée, si bien que le pull s’arrête avec cette condition plutôt que d’écrire un fichier de verrouillage que la build suivante refuse, et laisse le fichier de verrouillage tel qu’il était. Son message comporte, après l’étape que le pull effectuait :

verify: "<reference>" records a signature a build does not accept, and no registry is configured to ask about it again: cached signature bundle <path> is unreadable: cached signature bundle does not match its recorded digest (verify : enregistre une signature qu’une build n’accepte pas, et aucun registre n’est configuré pour être interrogé à nouveau à son sujet : le bundle de signature en cache est illisible : le bundle de signature en cache ne correspond pas à son digest enregistré)

Comment corriger : rien dans vos fichiers d’entité ne provoque ceci — le cache appartient à la build, pas à vous. Exécutez aggrega pull --release <release>, la commande que le message désigne : elle vérifie à nouveau la signature de l’artefact et écrit ensemble la signature et son bundle, ce qui répare un bundle supprimé ou modifié depuis le pull qui l’a mis en cache. En mode hors ligne, ce pull s’arrête — avec le refus hors ligne, parce que réparer implique d’interroger le registre, ou, pour un plugin rattaché à un rôle de verdict, avant cela, en désignant le .wasm du plugin comme un fichier qu’il n’a pas pu résoudre, parce qu’un pull résout ce .wasm depuis le registre du plugin ; autoriser le réseau pour cette seule exécution le répare. Lorsque le pull s’arrête en indiquant qu’aucun registre n’est configuré pour être interrogé sur l’entrée, définissez default_registry sur le registre depuis lequel l’artefact a été récupéré par pull, puis relancez le pull. Lorsque l’espace de travail ignore la vérification de signature pour l’artefact, le pull n’enregistre à la place aucune signature sur l’entrée, ce que la build admet sous ce même réglage. Lorsque la signature que sert le registre ne se vérifie pas, le pull s’arrête avec le refus propre à cette vérification : la signature enregistrée et les éléments que sert l’éditeur sont réellement en désaccord, et c’est une question pour celui qui publie l’artefact. Pour une entrée dont le message ne désigne aucun pull — une entrée lue dans un répertoire de catalogue, dans la copie intégrée au binaire du compilateur ou à côté de la Release —, supprimez la signature de son entrée : une telle entrée n’est jamais soumise à une exigence de signature, si bien que la build peut alors se poursuivre.

A recorded signature was made for a different artifact (Une signature enregistrée a été créée pour un autre artefact)

Une signature indique pour quel artefact elle a été créée. Lorsqu’un pull vérifie la signature d’un artefact, il enregistre ce fait sur l’entrée du fichier de verrouillage de l’artefact — ou, pour un plugin rattaché à un rôle de verdict, sur son entrée dans plugins-trust.yaml — et met en cache la signature qu’il a vérifiée. Avant tout rendu, la build lit, dans la signature en cache de chaque entrée servie par le cache de contenu, pour quel artefact elle a été créée, et ce doit être l’artefact que la build elle-même a lu pour l’entrée : celui dont le manifeste est conservé à côté de ses octets dans le cache de contenu, jamais quoi que ce soit que l’entrée enregistre. Une signature créée pour un autre artefact arrête la build. C’est à cela que ressemble une signature copiée d’une entrée vers une autre : la signature en cache qu’elle désigne est intacte — elle correspond toujours au digest enregistré pour elle — et elle a été créée pour l’artefact de l’autre entrée.

Elle ne dépend pas d’une exigence de signature. Une signature enregistrée est confrontée à ce qu’elle affirme, qu’une signature soit exigée ou non, comme l’est le contrôle qui vérifie que la signature en cache correspond à son digest enregistré.

Un plugin est contrôlé de la même manière où qu’il soit chargé. Un plugin que le fichier de verrouillage épingle, et un plugin rattaché à un rôle de verdict, voit sa signature enregistrée confrontée à l’artefact à partir duquel ses octets ont été lus lorsque ces octets sont chargés depuis le cache de contenu, ce qui atteint les commandes qui chargent un plugin en dehors d’une build — dont aggrega lint --release et aggrega validate --release, ainsi que les mêmes opérations atteintes via aggrega serve et aggrega mcp.

Ce que lit le contrôle, et ce qu’il ne peut pas distinguer. Il lit la signature en cache et le manifeste à côté de l’artefact, et compare des hash : il ne vérifie aucune signature, ne contacte aucun réseau et ne consulte aucun élément de confiance, si bien qu’il tient dans une build sans aucun accès réseau. Il lit pour quel artefact une signature a été créée sous les deux formes qu’un pull accepte — une signature faite sur l’artefact lui-même, ce que produisent les signataires propres à la chaîne d’outils, et une déclaration signée qui désigne l’artefact —, si bien qu’une signature copiée d’une entrée vers une autre est refusée sous l’une ou l’autre forme. C’est la même lecture qu’un pull applique à chaque signature qu’il accepte : un pull refuse une signature qui se vérifie mais que la lecture ne trouve pas créée pour l’artefact, ou dont elle ne peut pas du tout lire l’artefact, si bien qu’aucune signature qu’un pull enregistre n’est illisible pour le contrôle. Une entrée lue dans un répertoire de catalogue, dans la copie intégrée au binaire du compilateur ou à côté de la Release n’a pas de manifeste, si bien que sa signature enregistrée n’est confrontée qu’à son digest enregistré ; il en va de même d’une signature placée à la main dans le cache sous une forme qui n’est aucune de ces deux. Et comme aucune signature n’est vérifiée, une signature écrite à la main dans le cache, établie pour l’artefact propre de l’entrée, ne se distingue pas d’une signature qu’un pull a vérifiée.

Le pull suivant le répare. Un pull soumet au même contrôle chaque entrée servie par le cache de contenu et, lorsque le contrôle refuse une entrée, il interroge à nouveau le registre de l’artefact sur la signature — quoi que dise l’exigence de signature — et enregistre sur l’entrée ce que cette vérification établit, à la place de la signature copiée. Un plugin rattaché à un rôle de verdict est vérifié à nouveau à chaque pull, quoi qu’enregistre son entrée. Seule une entrée servie par le cache de contenu est contrôlée quant à l’artefact pour lequel sa signature a été créée, si bien que chaque refus de cette condition par une build ou par un chargement de plugin désigne ce pull.

Messages émis, qui désignent l’entrée, le fichier qui enregistre la signature, la signature en cache, le manifeste que la build a lu pour l’entrée et le pull qui la répare. Depuis le contrôle de la build :

artifact "<reference>": signing: the recorded signature was made for a different artifact (<file> records it, cached signature bundle <path>, the artifact read has manifest <manifest-digest>). remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (artefact : signing : la signature enregistrée a été créée pour un autre artefact, avec le fichier qui l’enregistre, le bundle de signature en cache et le manifeste de l’artefact lu. remède : exécutez le pull pour vérifier à nouveau la signature de l’artefact auprès de son registre, l’enregistrer dans le fichier et mettre en cache le bundle qu’elle désigne)

et, lorsque les octets d’un plugin sont chargés, en désignant aussi leur provenance :

plugin "<reference>" resolved from <source>: signing: the recorded signature was made for a different artifact (<file> records it, cached signature bundle <path>, the artifact read has manifest <manifest-digest>). remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (plugin résolu depuis sa source : signing : la signature enregistrée a été créée pour un autre artefact, avec le fichier qui l’enregistre, le bundle de signature en cache et le manifeste de l’artefact lu. remède : exécutez le pull pour vérifier à nouveau la signature de l’artefact auprès de son registre, l’enregistrer dans le fichier et mettre en cache le bundle qu’elle désigne)

<file> est le fichier de verrouillage de la Release, ou plugins-trust.yaml dans le répertoire de la Release.

Un pull qui n’a aucun registre à interroger s’arrête à la place, comme il le fait pour un bundle de signature en cache qui ne correspond plus à son digest : lorsqu’une entité de catalogue ou une bibliothèque porte une signature copiée et que l’espace de travail ne nomme plus de default_registry auquel la lier, le pull s’arrête avec cette condition et laisse le fichier de verrouillage tel qu’il était. Son message comporte, après l’étape que le pull effectuait :

verify: "<reference>" records a signature a build does not accept, and no registry is configured to ask about it again: signing: the recorded signature was made for a different artifact (cached signature bundle <path>, the artifact read has manifest <manifest-digest>) (verify : enregistre une signature qu’une build n’accepte pas, et aucun registre n’est configuré pour être interrogé à nouveau à son sujet : signing : la signature enregistrée a été créée pour un autre artefact, avec le bundle de signature en cache et le manifeste de l’artefact lu)

Comment corriger : rien dans vos fichiers d’entité ne provoque ceci — la signature que l’entrée enregistre appartient à un autre artefact. Exécutez aggrega pull --release <release>, la commande que le message désigne : elle vérifie la signature propre de l’entrée auprès de son registre et l’enregistre à la place de la signature copiée, pour une entrée du fichier de verrouillage comme pour un plugin rattaché à un rôle de verdict. Restaurer depuis la gestion de versions la signature enregistrée propre de l’entrée, lorsque le fichier est commité, fonctionne aussi. En mode hors ligne, le pull s’arrête — avec le refus hors ligne, parce que réparer implique d’interroger le registre, ou, pour un plugin rattaché à un rôle de verdict, avant cela, en désignant le .wasm du plugin comme un fichier qu’il n’a pas pu résoudre, parce qu’un pull résout ce .wasm depuis le registre du plugin ; autoriser le réseau pour cette seule exécution le répare. Lorsque le pull s’arrête en indiquant qu’aucun registre n’est configuré pour être interrogé sur l’entrée, définissez default_registry sur le registre depuis lequel l’artefact a été récupéré par pull, puis relancez le pull. Lorsque l’espace de travail ignore la vérification de signature pour l’artefact, le pull n’enregistre à la place aucune signature sur l’entrée, ce que la build admet sous ce même réglage.

No verified signature is recorded for an artifact that requires one (Aucune signature vérifiée n’est enregistrée pour un artefact qui en exige une)

Un pull qui récupère un artefact depuis un registre vérifie sa signature au regard de la politique de confiance de ce registre et enregistre le fait vérifié sur l’entrée du fichier de verrouillage de l’artefact. Une build n’atteint aucun registre, elle lit donc le fait enregistré au lieu de vérifier à nouveau — et, avant tout rendu, elle soumet chaque entrée qu’elle lit à l’exigence que le pull a appliquée lorsqu’il a récupéré l’artefact. Une entrée servie par le cache de contenu, pour un artefact pour lequel une signature est exigée, qui n’enregistre aucune signature vérifiée arrête la build : rien de ce que détient la build n’indique que l’artefact à partir duquel elle s’apprête à effectuer le rendu ait jamais été vérifié.

L’exigence est celle du pull, paramètre par paramètre. Une signature est exigée là où la politique de signature valable pour tout l’espace de travail couvre le type de l’artefact, ou là où l’entrée propre du registre dans .aggrega-config.yaml — ou, pour hub.aggrega.ai sans entrée propre, la politique intégrée du hub officiel — en exige une ; un artefact dont le type n’a pas pu être déterminé compte comme exigé sous une politique active. Ce qui permet à un pull d’admettre un artefact sans signature permet aussi à la build d’admettre son entrée : skip_signature_verification au niveau supérieur, le même interrupteur sur l’entrée propre du registre sauf pour un type que la politique valable pour tout l’espace de travail exige, et un registre marqué advisory.

La provenance d’une entrée se lit dans la build, jamais dans le fichier de verrouillage. Chaque entrée servie par le cache de contenu est soumise à l’exigence, quoi que l’entrée enregistre par ailleurs, de sorte que retirer le digest du manifeste d’une entrée en même temps que sa signature ne l’en exempte pas. Une entrée lue depuis un répertoire de catalogue, depuis la copie intégrée au binaire du compilateur ou depuis l’emplacement voisin de la Release n’y est jamais soumise, car aucune signature de registre n’existe pour des octets qui ne proviennent pas d’un registre. Les entrées de chaque section sont contrôlées de la même façon — entités de catalogue, bibliothèques et artefacts de plugin — et chaque entrée que le contrôle refuse est nommée dans la même exécution.

Un plugin rattaché dans un rôle de verdict est soumis au même contrôle, par plugins-trust.yaml. Un rattachement plugins.governance dans un rôle ir-verdict ou render-verdict, et tout rattachement plugins.linter, ne façonne aucun octet rendu, il n’a donc pas d’entrée dans le fichier de verrouillage ; le relevé à côté du fichier de verrouillage porte sa signature vérifiée à la place. Chaque plugin de ce genre que la build lit depuis le cache de contenu est soumis à la même exigence, par les mêmes paramètres : une entrée de ce relevé qui n’enregistre aucune signature arrête la build, et l’absence de toute entrée pour le plugin aussi — supprimer le relevé ne l’en exempte pas. Un plugin servi depuis un répertoire de catalogue ou depuis la copie intégrée au binaire du compilateur n’y est pas soumis. L’exigence s’applique à un tel plugin partout où il est chargé pour une Release, pas seulement dans une build : aggrega lint --release et aggrega validate --release, ainsi que les mêmes opérations atteintes par aggrega serve et aggrega mcp, échouent sur cette condition lorsqu’elles le chargent.

Messages émis, nommant l’entrée, le fichier qui n’enregistre aucune signature pour elle, les paramètres qui exigent sa signature et la commande qui l’enregistre dans ce fichier. Pour une entrée du fichier de verrouillage, nommant le fichier de verrouillage :

signing: no verified signature is recorded for an artifact that requires one ("<reference>", <lockfile-path> records no signature for it, required by <the settings that require it>). remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry and record it in <lockfile-path> (signing : aucune signature vérifiée n’est enregistrée pour un artefact qui en exige une : le fichier de verrouillage n’enregistre aucune signature pour lui, exigée par les paramètres indiqués. remède : exécutez le pull pour vérifier la signature de l’artefact auprès de son registre et l’enregistrer dans le fichier de verrouillage)

et pour un plugin rattaché dans un rôle de verdict, nommant son relevé :

signing: no verified signature is recorded for an artifact that requires one ("<plugin>", <record-path> records no signature for it, required by <the settings that require it>). remediation: run aggrega pull --release <release> to verify the plugin’s signature at its registry and record it in <record-path> (signing : aucune signature vérifiée n’est enregistrée pour un artefact qui en exige une : le relevé n’enregistre aucune signature pour le plugin, exigée par les paramètres indiqués. remède : exécutez le pull pour vérifier la signature du plugin auprès de son registre et l’enregistrer dans le relevé)

Les deux fichiers sont nommés par leur chemin à côté de la Release donnée à la commande : <lockfile-path> est le fichier de verrouillage de la Release, et <record-path> est plugins-trust.yaml dans le répertoire de la Release.

Les paramètres sont nommés dans les termes mêmes du fichier de configuration : `signing.required` at the top level of the workspace configuration, `signing.required` on the `registries` entry for "<host>" ou the official hub's built-in signature requirement for "hub.aggrega.ai", réunis lorsque plusieurs s’appliquent.

Comment corriger : exécutez le pull que nomme le message. Pour une entrée servie par le cache de contenu qui n’enregistre aucune signature là où une est exigée, le pull demande sa signature au registre de l’artefact, par le digest de manifeste que l’entrée enregistre, exactement comme il le fait pour un artefact qu’il récupère, et enregistre la signature vérifiée sur l’entrée — ainsi la build suivante la lit. Un plugin rattaché dans un rôle de verdict fait de toute façon l’objet d’une demande à chaque pull, et le pull enregistre ce qu’il a vérifié sur l’entrée du plugin dans plugins-trust.yaml, en créant l’entrée là où il n’y en a pas. Un registre qui ne rattache aucune signature, ou une signature que la configuration de confiance n’accepte pas, arrête plutôt ce pull, en nommant l’artefact, et c’est une question pour celui qui le publie. En mode hors ligne, le pull ne peut pas demander : sur une entrée du fichier de verrouillage, il refuse en indiquant comment autoriser le réseau pour une exécution, et sur un plugin rattaché dans un rôle de verdict, il s’arrête avant de demander, en nommant le .wasm du plugin comme un fichier qu’il n’a pas pu résoudre, car un pull résout ce .wasm depuis le registre du plugin. Restaurer la signature enregistrée de l’entrée depuis le contrôle de version corrige le problème sans le réseau, là où le cache contient encore les éléments de signature que cet enregistrement nomme. Là où l’artefact n’est pas censé être signé, c’est l’exigence qu’il faut changer, et le message nomme de quel paramètre il s’agit — mais l’assouplir signifie que les artefacts de ce registre ne sont plus contrôlés lors d’un pull non plus ; préférez donc restreindre les types de la politique valable pour tout l’espace de travail plutôt que de désactiver une exigence.

A recorded signature is not the one a pull would record (Une signature enregistrée n’est pas celle qu’enregistrerait un pull)

aggrega pull --verify signale si l’exécution de aggrega pull maintenant modifierait les fichiers qu’un pull écrit, et la signature qu’un pull a vérifiée pour un artefact fait partie de ce qu’il écrit : la signature sur une entrée du fichier de verrouillage, et sur une entrée de plugins-trust.yaml pour un plugin rattaché dans un rôle de verdict. Cette condition est ce qu’une vérification signale pour chaque signature enregistrée qu’un pull simple écrirait différemment — une qu’il enregistrerait là où aucune n’est enregistrée, une qu’il remplacerait ou une qu’il effacerait. La vérification n’écrit aucun des deux fichiers et nomme chaque entrée de ce genre, dans l’un ou l’autre fichier, dans la même exécution.

Deux entrées du fichier de verrouillage sont signalées sans interroger de registre, car un pull les réécrit quelle que soit la réponse du registre ; elles sont donc signalées aussi en mode hors ligne : une entrée servie par le cache de contenu qui n’enregistre aucune signature là où la configuration de confiance en exige une — le pull enregistre la signature de l’artefact, ou s’arrête là où il ne peut pas en établir une — et une entrée dont la signature enregistrée a été faite pour un autre artefact, que le pull remplace par celle de l’artefact lui-même.

Toute autre entrée qu’un pull rechercherait à nouveau fait l’objet d’une demande, car seule la réponse du registre indique si le pull la modifierait : une entrée dont la vérification a récupéré les octets parce que le cache de contenu ne les contenait pas, et une entrée dont le bundle de signature en cache a été supprimé, est illisible ou a été altéré. La vérification interroge le registre comme le ferait le pull, signale l’entrée là où la réponse enregistre, remplace ou efface sa signature, et met en cache le bundle qu’elle a vérifié comme le fait un pull. En mode hors ligne, une telle entrée n’est ni interrogée ni signalée : la vérification affiche une ligne qui la nomme et indique que sa signature n’a pas été contrôlée.

Pour le relevé de confiance des plugins, chaque pull vérifie la signature de chaque plugin rattaché dans un rôle de verdict auprès de son registre, et une vérification aussi : est signalée une entrée dont cette vérification enregistrerait, remplacerait ou effacerait la signature, ainsi qu’un plugin pour lequel le relevé ne contient aucune entrée là où une build le refuse parce qu’il n’enregistre aucune signature, car un pull écrit une entrée portant sa signature et la build refuse le plugin jusque-là. Tout autre plugin que le relevé ne contient pas encore est une première apparition et n’est pas signalé. En mode hors ligne, une vérification n’interroge aucun registre sur ces plugins : elle lit chacun depuis le cache de contenu, comme le lit une build, et contrôle son identité et ses fonctions hôte comme le fait une vérification connectée. Elle signale sans interroger un plugin qu’une build refuse parce qu’il n’enregistre aucune signature — son entrée n’en enregistre aucune, ou le relevé ne contient aucune entrée pour lui — et un plugin qu’une build refuse parce que la signature qu’enregistre son entrée a été faite pour un autre artefact, car un pull réécrit cette entrée quelle que soit la réponse du registre ; elle affiche une ligne qui nomme chaque autre entrée et indique que sa signature n’a pas été contrôlée.

Les marqueurs de dépréciation ne sont pas comparés. Un marqueur rattaché à un artefact après le pull est l’état du registre et évolue sans que rien ne change dans l’espace de travail ; une vérification qui échouerait sur un tel marqueur ferait donc échouer un contrôle portant sur des fichiers que personne n’a touchés — la raison pour laquelle un marqueur enregistré avertit une build au lieu de l’arrêter.

Messages émis, un par entrée, nommant l’entrée, le fichier et ce qu’il enregistre, ce qu’un pull enregistrerait à la place, et le pull qui met le fichier à jour. Là où la réponse du registre, ou la vérification propre du relevé, donne la signature qu’un pull enregistrerait :

signing: a recorded signature is not the one a pull would record ("<reference>", <file> records <signature>, a pull would record <signature>). remediation: run aggrega pull --release <release> to bring <file> up to date (signing : une signature enregistrée n’est pas celle qu’enregistrerait un pull : le fichier enregistre une signature, un pull en enregistrerait une autre. remède : exécutez le pull pour mettre le fichier à jour)

pour une entrée qui n’enregistre aucune signature là où une est exigée — une entrée du fichier de verrouillage ou, en mode hors ligne, une entrée du relevé de confiance des plugins :

signing: a recorded signature is not the one a pull would record ("<reference>", <file> records no signature, a pull would ask its registry for the signature a requirement asks for and record it). remediation: run aggrega pull --release <release> to bring <file> up to date (signing : une signature enregistrée n’est pas celle qu’enregistrerait un pull : le fichier n’enregistre aucune signature, un pull demanderait à son registre la signature qu’une exigence demande et l’enregistrerait. remède : exécutez le pull pour mettre le fichier à jour)

pour une entrée dont la signature enregistrée a été faite pour un autre artefact — une entrée du fichier de verrouillage ou, en mode hors ligne, une entrée du relevé de confiance des plugins :

signing: a recorded signature is not the one a pull would record ("<reference>", <file> records <signature>, made for another artifact, a pull would ask its registry for this artifact’s own signature and record it). remediation: run aggrega pull --release <release> to bring <file> up to date (signing : une signature enregistrée n’est pas celle qu’enregistrerait un pull : le fichier enregistre une signature faite pour un autre artefact, un pull demanderait à son registre la signature propre de cet artefact et l’enregistrerait. remède : exécutez le pull pour mettre le fichier à jour)

et pour un plugin pour lequel le relevé ne contient aucune entrée, là où une build le refuse parce qu’il n’enregistre aucune signature — la seconde forme en mode hors ligne, où la vérification n’interroge aucun registre :

signing: a recorded signature is not the one a pull would record ("<plugin>", <record-path> records no entry for it and a signature is required for it, a pull would record <signature>). remediation: run aggrega pull --release <release> to bring <record-path> up to date (signing : une signature enregistrée n’est pas celle qu’enregistrerait un pull : le relevé ne contient aucune entrée pour le plugin et une signature est exigée pour lui, un pull enregistrerait une signature. remède : exécutez le pull pour mettre le relevé à jour)

signing: a recorded signature is not the one a pull would record ("<plugin>", <record-path> records no entry for it and a signature is required for it, a pull would ask its registry for the signature a requirement asks for and record it). remediation: run aggrega pull --release <release> to bring <record-path> up to date (signing : une signature enregistrée n’est pas celle qu’enregistrerait un pull : le relevé ne contient aucune entrée pour le plugin et une signature est exigée pour lui, un pull demanderait à son registre la signature qu’une exigence demande et l’enregistrerait. remède : exécutez le pull pour mettre le relevé à jour)

<signature> indique une signature par son mode, son signataire et le digest de son bundle — a keyed signature by keyed:sha256:<fingerprint> with bundle digest sha256:<digest>, avec issued by <issuer> après le signataire pour une signature sans clé — ou vaut no signature. <file> est le fichier de verrouillage de la Release, <lockfile-path>, ou plugins-trust.yaml dans le répertoire de la Release, <record-path>.

Comment corriger : exécutez le pull que nomme le message. Il écrit dans le fichier nommé la signature que le message dit qu’il écrirait, et met son bundle en cache, de sorte que la vérification suivante réussit. Là où le message dit qu’un pull interrogerait le registre, le pull enregistre ce que le registre vérifie — et s’arrête plutôt, en nommant l’artefact, là où le registre rattache une signature que la configuration de confiance n’accepte pas, ou aucune là où une est exigée, ce qui est une question pour celui qui le publie. En mode hors ligne, ce pull s’arrête : sur une entrée du fichier de verrouillage avec le refus hors ligne, car il doit interroger le registre, et sur un plugin rattaché dans un rôle de verdict avant cela, en nommant le .wasm du plugin comme un fichier qu’il n’a pas pu résoudre, car un pull résout ce .wasm depuis le registre du plugin. Autoriser le réseau pour cette seule exécution met le fichier à jour. Là où le message dit qu’un pull n’enregistrerait aucune signature, le registre n’en rattache plus et rien ne l’exige : le pull efface la signature de l’entrée, ce qu’une build admet sous les mêmes paramètres — si vous ne vous attendiez pas à ce que le registre cesse de signer l’artefact, c’est aussi une question pour son éditeur.

A plugin’s .wasm is not on this machine (Le fichier Wasm d’un plugin n’est pas sur cette machine)

Le .wasm d’un plugin est lu depuis l’un de quatre emplacements, dans cet ordre : les plugins intégrés au binaire du compilateur, un fichier à côté de l’entité Plugin du plugin dans un répertoire de catalogue, un chemin explicite du système de fichiers que nomme la référence, et le cache de contenu de l’espace de travail que remplit aggrega pull. La résolution d’un plugin lit uniquement ce qui se trouve déjà sur la machine et ne récupère rien, donc cette condition signale qu’aucun des quatre ne contient les octets — et non qu’un téléchargement a échoué. Un plugin fait exception : un importateur core dont une importation a besoin. Son module est lu uniquement depuis le binaire ou le cache de contenu, jamais à côté d’une entité de catalogue, et lorsque aucun des deux ne le contient, l’importation le récupère une fois depuis le registre par défaut de l’espace de travail ; la condition signale alors aussi que la récupération n’a pas été possible — l’espace de travail est hors ligne, son registre n’a pas pu être joint ou ne contient pas le module, ou l’espace de travail ne nomme aucun registre par défaut. Un module qui a été récupéré et dont la vérification échoue est refusé sous sa propre condition à la place, une non-correspondance de digest ou un refus de signature, et rien n’est conservé.

Le fichier à côté de l’entité est nommé d’après le type de plugin et le nom de l’entité, et le refus du pull ci-dessous donne le nom : pour pipeline-step/patch, c’est pipeline-step--patch.wasm, dans le répertoire où se trouve le document de l’entité.

Une entité Plugin rédigée dans l’un de vos répertoires de catalogue est refusée lorsque le pull la résout. Un pull ne récupère jamais le .wasm d’une telle entité : il cherche dans les quatre emplacements ci-dessus, exactement là où cherche une build. Une étape de pipeline, un fournisseur ou un plugin rattaché à un rôle de verdict n’est pas épinglé du tout, et une build lit son entité depuis le répertoire de catalogue à chaque fois. Un plugin rattaché à un rôle de transformation est épinglé, parce que ses octets façonnent la sortie rendue : le pull enregistre son entité et le digest de contenu du .wasm qu’il y a trouvé, et une build refuse un .wasm qui ne correspond plus. Ainsi, un pull qui ne trouve l’artefact dans aucun des quatre emplacements s’arrête là, avant d’écrire le fichier de verrouillage ou tout entity.lock, plutôt que de laisser une build échouer plus tard, à l’étape qui charge le plugin. Un .wasm que le binaire embarque, ou un fichier déjà présent dans le cache de contenu, satisfait le pull exactement comme il satisfait la build, de sorte qu’une entité pour un plugin livré avec le compilateur n’a besoin d’aucun fichier à côté d’elle.

Messages émis. Le refus du pull, qui pointe vers le répertoire où il attendait le fichier, avec, en dessous, la résolution qu’il a demandée :

plugin artifact not found on this machine (Plugin entity "<reference>" is authored in a catalog directory, expected <file> in <directory>). Place the built .wasm beside the entity under that name, or publish the plugin and reference the published Plugin entity instead of the one in the catalog directory (artefact de plugin introuvable sur cette machine : l’entité Plugin est rédigée dans un répertoire de catalogue, et le fichier indiqué était attendu dans le répertoire indiqué. Placez le .wasm compilé à côté de l’entité sous ce nom, ou publiez le plugin et référencez l’entité Plugin publiée au lieu de celle du répertoire de catalogue)

un plugin qu’une build ou une importation charge sans qu’aucune source ne contienne ses octets — et un plugin rattaché à un rôle de verdict que aggrega pull --verify lit en mode hors ligne depuis le cache de contenu, comme le fait une build. Lorsque l’entité Plugin du plugin se trouve dans un dossier de catalogue, en nommant la version à laquelle il se trouve et l’endroit où va son module :

plugin "<reference>" at version <version> is not on this machine; place its module, named <file>, beside its Plugin entity in <directory>: plugin artifact not found on this machine (le plugin, dans la version indiquée, n’est pas sur cette machine ; placez son module, sous le nom indiqué, à côté de son entité Plugin dans le répertoire indiqué : artefact de plugin introuvable sur cette machine)

et sinon, en nommant chaque emplacement où le module a été cherché :

plugin "<reference>" is not on this machine: the binary does not carry its module, no catalog folder holds its Plugin entity and the content cache a pull fetches into does not hold it: plugin artifact not found on this machine (le plugin n’est pas sur cette machine : le binaire ne contient pas son module, aucun dossier de catalogue ne contient son entité Plugin et le cache de contenu dans lequel un pull récupère ne le contient pas : artefact de plugin introuvable sur cette machine)

Un lint, qui ne cherche que dans le binaire, nomme uniquement le premier de ces emplacements.

et de même pour une référence écrite comme un emplacement de registre :

plugin "<reference>" not resolvable: an OCI plugin URI requires a prior aggrega pull --release <release> (so its bytes are cached) or an explicit local path; plugin resolution does not fetch from a registry: plugin artifact not found on this machine (plugin non résoluble : une URI de plugin OCI exige un pull préalable, pour que ses octets soient en cache, ou un chemin local explicite ; la résolution des plugins ne récupère rien depuis un registre : artefact de plugin introuvable sur cette machine)

un importateur core qu’une importation n’a pu ni lire ni récupérer, en nommant l’importateur, sa version et la raison — ici, l’espace de travail hors ligne — puis ce qui place son module sur la machine :

core importer "<importer>" at version <version> is not on this machine, and the workspace is offline, so its registry <host> is not asked for it; run the import once with the network available, which fetches it from the workspace’s default registry, verifies it and keeps it in the content cache for every later import, or place its module, named <file>, beside a Plugin entity of <importer> at <version> in a catalog folder: plugin artifact not found on this machine (l’importateur core, dans la version indiquée, n’est pas sur cette machine, et l’espace de travail est hors ligne, donc son registre n’est pas interrogé ; exécutez l’importation une fois avec le réseau disponible, ce qui le récupère depuis le registre par défaut de l’espace de travail, le vérifie et le conserve dans le cache de contenu pour chaque importation ultérieure, ou placez son module, sous le nom indiqué, à côté d’une entité Plugin de cet importateur dans cette version dans un dossier de catalogue : artefact de plugin introuvable sur cette machine)

Les autres raisons se lisent its registry <host> could not be reached (<cause>), its registry <host> holds no <location>:<version> et the workspace names no default registry to fetch it from ; les deux dernières ne nomment que le second remède, parce qu’une exécution avec le réseau disponible ne les changerait pas.

Comment corriger : lorsque l’entité est une entité que vous rédigez, compilez le plugin et placez son .wasm à côté de l’entité sous le nom que donne le message — ou publiez le plugin avec aggrega push et référencez l’entité publiée à la place de la copie du catalogue, puisque ni un pull ni une build ne récupère le .wasm d’une entité de votre catalogue. Lorsque le plugin est un plugin que vous consommez depuis un registre, exécutez aggrega pull pour la Release, ce qui le met en cache. Lorsque vous attendiez que le compilateur embarque lui-même le plugin, vérifiez que le binaire que vous exécutez le fait : aggrega plugin list nomme les plugins intégrés. Lorsqu’il s’agit d’un importateur core, exécutez l’importation une fois là où l’espace de travail peut joindre son registre par défaut — cette exécution le récupère, le vérifie et le met en cache, et chaque importation ultérieure est hors ligne — ou, lorsque ce registre ne le contient pas, placez son module à côté d’une entité Plugin de cet importateur dans cette version dans un dossier de catalogue, sous le nom que donne le message ; cette entité s’exécute alors à la place de l’importateur core.

A plugin recorded as a trusted gate is no longer attached (Un plugin enregistré comme contrôle approuvé n’est plus rattaché)

Un plugin qui rend un verdict d’acceptation ou de rejet sur une build est enregistré une fois résolu, de sorte que l’espace de travail conserve un relevé des contrôles qui ont été examinés. Cette condition est ce que signale un contrôle enregistré que plus rien ne rattache. Elle arrête la build plutôt que de la laisser passer silencieusement, parce que sa sortie serait autrement indiscernable d’une sortie que le contrôle a approuvée : une build où le contrôle est silencieusement absent et une build que le contrôle a laissée passer produisent les mêmes fichiers, et personne qui examine le résultat ne pourrait dire laquelle des deux il a entre les mains.

C’est une question différente de celle d’un plugin dont les octets ont dérivé. Celle-là refuse d’exécuter un plugin qui n’est pas celui examiné — une question d’identité. Celle-ci refuse de construire avec un contrôle examiné entièrement manquant — une question de présence. Les remèdes diffèrent en conséquence : restaurer l’artefact, contre restaurer le rattachement.

Ce que cela établit, et ce que cela n’établit pas. Confronter la configuration au relevé établit que chaque contrôle enregistré est toujours rattaché et que l’artefact de chacun est celui enregistré. Cela n’établit rien quant au fait qu’un contrôle rattaché rende effectivement un verdict : un rattachement dont la fonction d’entrée nomme un export déclaré qui ne rend aucun verdict s’exécute, ne signale rien et laisse passer la build, et aucune comparaison avec le relevé ne le remarque — le plugin qui s’est exécuté est exactement celui enregistré et il n’a simplement rien exécuté. Deux cas voisins arrêtent bien la build, et ils sont nommés pour que cette borne ne soit pas lue comme plus large qu’elle ne l’est : une fonction d’entrée nommant un export que le plugin ne déclare pas est refusée au chargement du plugin, et une sortie portant une clé que la structure du verdict ne déclare pas est refusée au lieu d’être lue comme une liste de verdicts vide.

Message émis, qui nomme le relevé, les contrôles retirés et les deux remèdes :

a plugin recorded as trusted for an accept-or-reject verdict is no longer attached at any verdict role: <record-path> records <plugin> as trusted, but no verdict attachment in the workspace configuration names it; a gate that was reviewed and is now absent leaves output indistinguishable from output that gate approved. Attach the plugin again under plugins.governance at an ir-verdict or render-verdict role, or under plugins.linter; or, if it was meant to go, run aggrega pull --upgrade --release <release> <plugin> to drop it from the record — an ordinary aggrega pull leaves the record as it is, so only an explicit upgrade removes an entry (un plugin enregistré comme approuvé pour un verdict d’acceptation ou de rejet n’est plus rattaché à aucun rôle de verdict : le relevé enregistre le plugin comme approuvé, mais aucun rattachement de verdict dans la configuration de l’espace de travail ne le nomme ; un contrôle qui a été examiné et qui est maintenant absent laisse une sortie indiscernable d’une sortie que ce contrôle a approuvée. Rattachez à nouveau le plugin dans la section de gouvernance des plugins à un rôle de verdict IR ou de verdict de rendu, ou dans la section du linter ; ou, s’il devait partir, exécutez la mise à niveau ciblée pour le retirer du relevé — un pull ordinaire laisse le relevé tel quel, donc seule une mise à niveau explicite retire une entrée)

Lorsque plus d’un contrôle a été retiré, ils sont nommés ensemble dans une seule commande de mise à niveau plutôt que dans une commande chacun : une mise à niveau ciblée prend plusieurs cibles et laisse intact chaque épinglage qu’elle n’a pas nommé, donc les nommer ensemble est à la fois plus court et plus restreint que l’actualisation complète qu’exigerait l’alternative.

Comment corriger : le message propose deux remèdes parce que vous seul savez lequel s’applique. Si le contrôle a été retiré par erreur, rattachez à nouveau le plugin sous plugins.governance à un rôle de verdict, ou sous plugins.linter. S’il devait partir, dites-le explicitement avec la mise à niveau ciblée que le message détaille, qui est ce qui retire son entrée. Ne modifiez ni ne supprimez le relevé pour lever cette condition — c’est un relevé commité de ce qui a été examiné, et un pull ordinaire le laisse délibérément tel quel, parce qu’adopter une suppression en silence est exactement ce que ce refus existe pour empêcher.

A gate recorded as trusted resolves to a different identity (Un contrôle enregistré comme approuvé se résout en une identité différente)

Un plugin qui rend un verdict d’acceptation ou de rejet sur une build est enregistré une fois résolu, avec la version et le digest d’artefact vers lesquels il s’est résolu. Cette condition est ce que signale une résolution ultérieure lorsqu’elle atteint une version différente ou des octets différents pour un contrôle que le relevé contient déjà, alors que l’exécution n’a jamais demandé que cette identité soit adoptée.

Une seule condition couvre à la fois une version déplacée et des octets déplacés, parce que le relevé est adressé par l’identité du plugin et porte la version et le digest comme champs d’une seule entrée : comparer une résolution avec lui est une seule comparaison avec un seul résultat. Une republication qui n’a changé aucun octet et un nouveau push à la même version sont le même événement du point de vue d’un relecteur — l’identité n’est plus celle qui a été examinée.

C’est une question différente de celle d’un contrôle enregistré que plus rien ne rattache, qui est une question de présence plutôt que d’identité. C’est aussi différent d’un plugin dont les octets en cache ne concordent pas avec le digest enregistré : celle-là refuse d’exécuter un plugin qui n’est pas celui examiné, et son remède est de restaurer ou de réenregistrer l’artefact, tandis que celle-ci refuse d’adopter une nouvelle identité sans qu’on le lui demande, et son remède est de nommer le plugin dans une mise à niveau. Deux remèdes, deux conditions.

Demander la nouvelle identité est ce qu’un pull offre déjà, et il y a deux façons de la demander. Une actualisation complète résout tout à nouveau, et une mise à niveau ciblée résout à nouveau les plugins qu’elle nomme ; l’une comme l’autre est lue comme une demande de la nouvelle identité, et le relevé est mis à jour. Tout autre pull conserve l’identité enregistrée et s’arrête, ce qui est le but de l’enregistrer — un relevé qui adopterait ce qui se résout ensuite suivrait la résolution au lieu de la gouverner. Une première apparition n’est pas un désaccord : une identité que le relevé ne contient pas encore est simplement renseignée.

La comparaison s’exécute aussi sur un pull qui ne fait que vérifier, qui n’écrit ni le relevé ni le fichier de verrouillage. Une vérification qui ignorerait le relevé tout en contrôlant le fichier de verrouillage à côté signalerait un accord qu’elle n’a jamais cherché.

Message émis, qui nomme le plugin, les deux identités et les deux remèdes :

plugin "<plugin-identity>": <record-path> records version <recorded-version> with digest <recorded-digest> as trusted for it, but this resolution reports version <resolved-version> with digest <resolved-digest>; review what changed and adopt it with aggrega pull --upgrade --release <release> <plugin>, or restore the recorded identity: the plugin identity recorded as trusted no longer matches what this resolution reports (plugin : le relevé enregistre pour lui une version et un digest comme approuvés, mais cette résolution indique une autre version et un autre digest ; examinez ce qui a changé et adoptez-le avec la mise à niveau ciblée, ou restaurez l’identité enregistrée : l’identité du plugin enregistrée comme approuvée ne correspond plus à ce que cette résolution indique)

Comment corriger : décidez laquelle des deux identités est celle que vous voulez, parce que vous seul le pouvez. Si le déplacement est voulu — le contrôle a été republié et vous avez examiné ce qui a changé — adoptez-le avec la mise à niveau ciblée que le message détaille, qui résout à nouveau ce plugin et réécrit son entrée. Si vous ne l’attendiez pas, l’identité enregistrée est celle qui a été examinée : restaurez la version ou l’artefact que nomme le relevé, et cherchez pourquoi la référence se résout désormais ailleurs. Ne modifiez pas le relevé pour lever cette condition — c’est une déclaration commitée de ce qui a été examiné, et un pull ordinaire le laisse délibérément tel quel, parce qu’adopter en silence un contrôle modifié est exactement ce que ce refus existe pour empêcher.

A Plugin entity’s claims disagree with the plugin’s own self-report (Les affirmations d’une entité Plugin contredisent l’auto-description du plugin lui-même)

Une entité Plugin indique ce qu’offre le plugin vers lequel elle pointe : quels exports il possède, sur quoi chacun d’eux opère et avec quelle portée, et — pour un plugin qui sert un fournisseur — comment il se comporte lors du rendu. Le plugin signale les mêmes choses à son propre sujet lorsqu’il est chargé. Cette condition est ce que signale un désaccord entre les deux.

La comparaison se fait export par export, indexée par nom, et elle ne va que dans un sens : tout ce que l’entité affirme doit correspondre, et le plugin peut offrir davantage. Une entité qui décrit une partie de la surface du plugin n’est pas tenue d’énumérer le reste ; un export que le plugin déclare et que l’entité omet n’est donc pas un désaccord. Constitue en revanche un désaccord un export affirmé que le plugin ne déclare pas, ou un export affirmé dont operates ou scope diffère de ce que le plugin signale. Le sélecteur libre n’est pas comparé.

Lorsque l’entité rédige aussi un bloc de comportement de rendu, ses champs sont comparés un par un — les types d’entrée, le mode d’assemblage, la paire de délimiteurs des modèles d’artefact, l’annotation du nom d’assemblage, l’affirmation d’instance réutilisable, l’affirmation de liaison entre frontières, l’affirmation sur les entrées omises et le répertoire d’imbrication — et c’est le premier en désaccord qui est nommé. Une entité qui ne rédige aucun bloc de ce type saute entièrement cette comparaison.

La même vérification s’exécute à la publication, de sorte qu’une incohérence apparaît normalement avant que l’entité ne soit publiée plutôt qu’au moment où une build la charge.

Messages émis. Un export affirmé que le plugin n’a pas :

entity "<entity>" claims export "<export>", which the plugin’s describe() does not declare: wasm: entity contract claim does not match plugin describe() (l’entité affirme un export que le describe() du plugin ne déclare pas : wasm : l’affirmation du contrat de l’entité ne correspond pas au describe() du plugin)

un champ d’un export affirmé :

entity "<entity>" export "<export>" declares operates "<claimed>" but the plugin’s describe() reports "<reported>": wasm: entity contract claim does not match plugin describe() (l’export de l’entité déclare une valeur pour operates, mais le describe() du plugin en signale une autre : wasm : l’affirmation du contrat de l’entité ne correspond pas au describe() du plugin)

et un champ de comportement de rendu, signalé avec la même structure en nommant le champ en désaccord :

entity "<entity>" declares boundary_assembly "<claimed>" but the plugin’s describe() reports "<reported>": wasm: entity contract claim does not match plugin describe() (l’entité déclare une valeur pour boundary_assembly, mais le describe() du plugin en signale une autre : wasm : l’affirmation du contrat de l’entité ne correspond pas au describe() du plugin)

Comment corriger : c’est l’affirmation de l’entité Plugin qu’il faut corriger, pas votre Aggregate ni votre Release. Alignez l’affirmation sur ce que le plugin signale — le message nomme les deux valeurs, si bien que le sens dans lequel elle doit évoluer est visible dans le message lui-même. Si l’entité est une entité que vous publiez, la régénérer à partir du binaire est le moyen fiable d’accorder les deux ; si vous consommez une entité publiée, sélectionnez une version dont l’affirmation correspond au binaire vers lequel elle pointe, et signalez le désaccord à celui qui l’a publiée.

A Plugin entity’s recorded command set does not match the plugin (L’ensemble de commandes enregistré d’une entité Plugin ne correspond pas au plugin)

Un plugin qui fournit des commandes de terminal a ces commandes enregistrées dans son entité Plugin. Ce relevé est écrit automatiquement plutôt que rédigé : il est lu dans le plugin et consigné, de sorte qu’il reflète exactement le binaire. Cette condition est ce que signale un relevé qui a cessé de le refléter — une différence dans le nom d’une commande, dans son court texte d’aide ou dans l’ordre dans lequel les commandes sont déclarées.

La comparaison exige une égalité complète, et c’est délibéré. Les affirmations de capacités et d’exports ailleurs sur l’entité sont choisies par leur auteur : un auteur peut légitimement décrire une partie de la surface et laisser le reste de côté, elles sont donc vérifiées comme un sous-ensemble. Le relevé des commandes n’est pas choisi par un auteur ; tout ce qui n’est pas un accord exact signifie donc que le relevé s’est écarté de ce que le plugin offre réellement, et une liste de commandes proche mais inexacte est ce qui routerait mal une invocation.

Un plugin chargé sans entité n’est pas vérifié ici. Le relevé se trouve sur l’entité ; des octets chargés directement n’en portent donc aucun, et la comparaison n’a rien sur quoi s’exécuter.

Message émis, nommant les deux ensembles et la manière de les réenregistrer :

wasm: plugin "<plugin>": recorded command mirror <recorded set> does not match the plugin describe() commands <reported set>; re-run aggrega plugin sync and commit the result: wasm: recorded command mirror does not match plugin describe() (wasm : pour le plugin indiqué, le miroir de commandes enregistré ne correspond pas aux commandes du describe() du plugin ; relancez la synchronisation des plugins et validez le résultat par un commit : wasm : le miroir de commandes enregistré ne correspond pas au describe() du plugin)

La même comparaison à la publication signale les ensembles sans l’instruction de réenregistrement :

plugin "<plugin>": recorded command mirror <recorded set> does not match the plugin describe() commands <reported set>: wasm: recorded command mirror does not match plugin describe() (pour le plugin indiqué, le miroir de commandes enregistré ne correspond pas aux commandes du describe() du plugin : wasm : le miroir de commandes enregistré ne correspond pas au describe() du plugin)

Comment corriger : réenregistrez l’ensemble à partir du binaire et validez le résultat par un commit — le message nomme la commande qui le fait. Ne modifiez pas le relevé à la main pour le faire correspondre : il est géré automatiquement, et une modification manuelle qui concorde aujourd’hui est redérivée et écrasée lors du prochain enregistrement. Si vous consommez une entité publiée plutôt que de la publier, l’entité a été publiée avec un relevé que son propre binaire ne confirme pas, et c’est une question pour son éditeur.

A Plugin entity’s recorded version does not match the plugin (La version enregistrée d’une entité Plugin ne correspond pas au plugin)

Un plugin signale la version que sa build y a enregistrée, et son entité Plugin enregistre aussi une version ; les deux doivent être la même chaîne. Les recettes de build avec lesquelles les plugins d’Aggrega sont construits prennent cette version dans le tag qui publie le plugin — le propre tag du compilateur pour un plugin livré avec le compilateur, un tag propre au plugin pour un plugin livré en dehors —, de sorte qu’une build du commit que nomme le tag signale la version publiée, et qu’une build de tout autre commit signale une version de développement telle que 1.0.0-3-g1a2b3c4. Cette condition est ce que signale une paire qui s’est désunie, et elle est vérifiée avant la publication du moindre octet afin qu’une paire divergente n’atteigne pas un catalogue.

La comparaison est une correspondance exacte de chaînes. Un plugin construit sans version de build enregistrée en signale une vide, et c’est alors à cette valeur vide que la version de l’entité doit être égale — la vérification ne traite pas « aucune version signalée » comme « toute version acceptée », car son but est que la version d’une entité publiée dise toujours ce que son binaire signale réellement.

Message émis :

plugin "<plugin>": recorded metadata.version "<recorded>" does not match the plugin describe() version "<reported>": wasm: entity metadata.version does not match plugin describe() (pour le plugin indiqué, la metadata.version enregistrée ne correspond pas à la version du describe() du plugin : wasm : la metadata.version de l’entité ne correspond pas au describe() du plugin)

À la publication, le refus nomme aussi le fichier de l’entité, le .wasm et le remède :

Plugin <plugin>: metadata.version in <entity-path> does not match the .wasm describe() version at <path> — set metadata.version to the release you are publishing and build the plugin from a clean checkout of the commit that release’s tag names, so it reports that version itself; for a new release, commit the entity with the source it releases and tag that commit first: plugin "<plugin>": recorded metadata.version "<recorded>" does not match the plugin describe() version "<reported>": wasm: entity metadata.version does not match plugin describe() (pour le Plugin indiqué, la metadata.version du fichier de l’entité ne correspond pas à la version du describe() du .wasm au chemin indiqué — définissez metadata.version sur la version que vous publiez et construisez le plugin à partir d’un checkout propre du commit que nomme le tag de cette version, afin qu’il signale lui-même cette version ; pour une nouvelle version, validez l’entité avec la source qu’elle publie et posez d’abord le tag sur ce commit : pour le plugin indiqué, la metadata.version enregistrée ne correspond pas à la version du describe() du plugin : wasm : la metadata.version de l’entité ne correspond pas au describe() du plugin)

Comment corriger : définissez la metadata.version de l’entité sur la version que vous publiez, et construisez le plugin à partir d’un checkout propre du commit que nomme le tag de cette version, afin qu’il signale lui-même cette version. Pour une nouvelle version, validez l’entité avec la source qu’elle publie et posez d’abord le tag sur ce commit — le tag doit nommer un commit qui contient déjà l’entité. Ne copiez pas dans l’entité la version que signale le plugin : une build de tout autre commit signale une version de développement, et la copier publierait cette build sous une version qu’aucun tag de version ne nomme. Si le plugin ne signale aucune version, il a été construit sans que sa version soit enregistrée ; construisez-le avec sa version enregistrée.

A plugin was built from a working tree with uncommitted changes (Un plugin a été construit à partir d’un arbre de travail contenant des modifications non validées)

La build d’un plugin enregistre sa version à partir du commit dont elle est issue, et une build faite à partir d’un arbre de travail contenant des modifications non validées porte la marque -dirty à la fin de cette version — 1.0.0-dirty sur un tag, 1.0.0-3-g1a2b3c4-dirty au-delà d’un tag. Une telle version est une version sémantique valide, mais elle nomme un commit qui ne contient pas les octets construits, de sorte que personne ne peut reconstruire ce qui serait publié à partir de la version sous laquelle cela serait publié. La publication d’un Plugin refuse un plugin dont la propre version porte la marque, avant la publication du moindre octet et avant que le registre ne soit contacté ; une exécution à blanc le refuse aussi.

Seule la marque est refusée. Une version de développement construite à partir d’un commit, telle que 1.0.0-3-g1a2b3c4, nomme un commit qui contient bien ce qui a été construit, et elle est publiée ; il en va de même pour une préversion telle que 1.0.0-rc.1. Valider un plugin par rapport à son entité en dehors d’une publication ne déclenche pas cette condition, car une build en cours de développement est couramment faite à partir d’un arbre modifié.

La vérification lit la version que le plugin signale à propos de sa propre build, et elle s’exécute avant la comparaison avec la metadata.version de l’entité — de sorte qu’un plugin construit avec des modifications non validées sous une entité qui enregistre la version propre est signalé ici, plutôt que comme une version enregistrée qui ne correspond pas au plugin.

Message émis, nommant le plugin, la version qu’il signale et le remède :

Plugin <plugin>: the .wasm at <path> was built from a working tree with uncommitted changes — set metadata.version in <entity-path> to the release you are publishing and build the plugin from a clean checkout of the commit that release’s tag names, so it reports that version itself; for a new release, commit the entity with the source it releases and tag that commit first: plugin was built from a working tree with uncommitted changes, so no commit reproduces the version it reports (plugin "<plugin>", describe() version "<version>", which ends with "-dirty") (pour le Plugin indiqué, le .wasm au chemin indiqué a été construit à partir d’un arbre de travail contenant des modifications non validées — définissez metadata.version dans le fichier de l’entité sur la version que vous publiez et construisez le plugin à partir d’un checkout propre du commit que nomme le tag de cette version, afin qu’il signale lui-même cette version ; pour une nouvelle version, validez l’entité avec la source qu’elle publie et posez d’abord le tag sur ce commit : le plugin a été construit à partir d’un arbre de travail contenant des modifications non validées, donc aucun commit ne reproduit la version qu’il signale (avec le plugin et sa version describe(), qui se termine par la marque dirty))

Comment corriger : construisez le plugin à partir d’un checkout propre du commit que nomme le tag de la version, afin qu’il signale la version publiée que l’entité enregistre. Pour publier la modification elle-même, définissez la metadata.version de l’entité sur la nouvelle version, validez l’entité avec la modification, posez le tag sur ce commit et construisez à cet endroit. Valider la modification et reconstruire ne suffit pas à ouvrir la voie à une publication : le plugin reconstruit signale une version de développement, et la copier dans l’entité publierait la build sous une version qu’aucun tag de version ne nomme.

A Plugin entity’s recorded host functions do not match the binary (Les fonctions hôte enregistrées d’une entité Plugin ne correspondent pas au binaire)

Un plugin déclare lesquels des appels propres à l’hôte il utilise, et cet ensemble est enregistré sur son entité Plugin lorsque le plugin est publié — lu dans le binaire lui-même plutôt que rédigé. Lorsque le plugin est récupéré, l’ensemble est à nouveau dérivé des octets dont le contenu vient d’être vérifié, puis comparé au relevé. Une différence dans un sens ou dans l’autre arrête la récupération.

Ceci s’ajoute à l’épinglage du contenu au lieu de le répéter, et intercepte deux choses que l’épinglage seul n’intercepte pas : un binaire publié par autre chose que le chemin de publication ordinaire, qui ne porte aucun relevé ou un relevé qui ne décrit pas ses propres octets ; et une faute dans l’étape d’enregistrement elle-même. L’épinglage établit que les octets sont ceux qui ont été épinglés ; ceci établit que ce qui a été consigné à leur sujet est vrai pour eux.

Une entité ne portant aucun relevé est comparée à un ensemble vide, qui correspond à un plugin n’utilisant aucun des appels de l’hôte — la même concordance bénigne dans un sens comme dans l’autre ; une entité sans relevé n’est donc pas refusée faute d’en avoir un.

Message émis, nommant le plugin, les deux ensembles et l’artefact dont proviennent les octets :

plugin "<plugin>": stamped spec.runtime.hostFunctions <recorded set> does not match <derived set> derived from the verified .wasm <artifact>: wasm: stamped host-function record does not match .wasm imports (pour le plugin indiqué, le spec.runtime.hostFunctions apposé ne correspond pas à l’ensemble dérivé du .wasm vérifié : wasm : le relevé apposé des fonctions hôte ne correspond pas aux imports du .wasm)

La même comparaison exécutée pendant la validation d’un plugin signale les deux ensembles sans l’artefact :

plugin "<plugin>": recorded host-function record <recorded set> does not match the .wasm imports <derived set>: wasm: stamped host-function record does not match .wasm imports (pour le plugin indiqué, le relevé des fonctions hôte enregistré ne correspond pas aux imports du .wasm : wasm : le relevé apposé des fonctions hôte ne correspond pas aux imports du .wasm)

Comment corriger : rien dans vos fichiers d’entité ne provoque cette condition et aucune modification de ce que vous rédigez ne la lève. Republiez le plugin par le chemin de publication ordinaire, qui dérive le relevé du binaire et écrit les deux ensemble. Si vous consommez un plugin publié, l’entité et le binaire vers lequel elle pointe ont été publiés de manière désynchronisée ; signalez donc l’incohérence à son éditeur en citant les deux ensembles du message — et ne modifiez pas le relevé à la main pour le faire concorder, car il est dérivé et non rédigé, et la dérivation suivante écarte la modification.

The lockfile no longer matches what the release resolves to (Le fichier de verrouillage ne correspond plus à ce vers quoi la Release se résout)

Le fichier de verrouillage d’une Release épingle chaque entité, bibliothèque et plugin que la Release atteint, chacun avec la version sélectionnée et un digest, et il enregistre les fichiers de Release eux-mêmes — la Release et chaque Release qu’elle étend — par le digest de leur contenu. Le digest d’une entité couvre ce que porte une publication de celle-ci : son document et chaque fichier qu’elle nomme à côté d’elle, chacun par son chemin et ses octets. Celui d’une bibliothèque et celui d’un plugin couvrent leurs octets. Résoudre à nouveau la Release produit le même ensemble, et les deux sont comparés. Cette condition est ce que signale un désaccord.

Chaque désaccord est collecté avant qu’aucun ne soit signalé, sur tout ce que le fichier de verrouillage épingle, de sorte qu’une seule exécution vous montre la situation complète plutôt qu’une entrée à la fois.

Ces structures de désaccord sont signalées, et il vaut la peine de les distinguer, car les remèdes diffèrent :

  • Une référence que le fichier de verrouillage n’épingle pas. La Release atteint désormais quelque chose pour lequel le fichier de verrouillage n’a aucune entrée — une dépendance ajoutée depuis le pull qui l’a écrit. L’entrée indique l’endroit où la Release la demande, de sorte qu’une Recipe ou FeatureRecipe que le Manifest lie est signalée avec l’entrée de mapping qui la lie, et une que le niveau name lie nomme l’instance ou le rattachement pour lequel elle a été choisie.
  • Une référence épinglée dont la paire a bougé. Le fichier de verrouillage épingle une paire version-digest et la résolution en a produit une autre. Il s’agit de contenu vendorisé dont les octets ont changé, ou de quelque chose dans l’espace de travail qui a changé : le document d’une entité ou d’une bibliothèque modifié, un fichier qu’une entité nomme — un chart sous sa source, un fichier qu’elle importe, l’entity.lock à côté d’elle — modifié, ajouté ou supprimé, ou le .wasm à côté de l’entité d’un plugin remplacé. L’entrée nomme l’entité plutôt que le fichier ; un simple aggrega pull --release <release> nomme un fichier qui a bougé sous le verrou d’une Recipe ou d’une FeatureRecipe, comme le décrit An entity reads an input the lock beside it records no pin for (Une entité lit une entrée pour laquelle le lock à côté d’elle n’enregistre aucun épinglage). Un registre qui sert d’autres octets sous une version épinglée n’est pas signalé ici : le pull qui les récupère les refuse, comme le décrit Fetched or cached bytes do not match the digest committed for them (Les octets récupérés ou en cache ne correspondent pas au digest déclaré pour eux).
  • Une référence épinglée que la Release n’atteint plus. Le fichier de verrouillage épingle encore quelque chose dont plus rien dans la Release ne dépend.
  • Un fichier de Release modifié depuis le pull. La Release, ou une Release qu’elle étend, ne contient plus les octets que le fichier de verrouillage a enregistrés pour elle. Tout ce que la Release demande — quelle version de source récupérer, quels composants placer où — est résolu à partir de ce que contient le fichier, de sorte que les épinglages enregistrés peuvent ne plus décrire ce qu’elle demande désormais. Ceci est signalé ici, avant tout rendu, plutôt que comme l’erreur sur laquelle le rendu aurait échoué : une version de source modifiée apparaîtrait sinon plus tard comme une récupération qui ne trouve aucun épinglage. Un fichier de verrouillage qui n’enregistre aucun fichier de Release signale la Release comme non enregistrée, et un fichier de Release que la Release n’étend plus est signalé comme n’étant plus lu.
  • Une référence de source qui a bougé sur son dépôt distant. Une source écrite à un ref: git est enregistrée au commit vers lequel le ref s’est résolu. Chaque pull qui n’est pas une mise à niveau demande au dépôt distant où pointe désormais le ref, tout comme aggrega pull --verify là où le réseau est joignable ; un ref qui se résout vers un commit différent est signalé ici plutôt qu’adopté. Seuls ces deux-là le signalent : une build lit le commit enregistré et ne demande pas.

La comparaison porte sur le contenu, de sorte qu’un contenu identique atteint par un autre chemin ne dérive pas : ce qui doit différer pour que cela se déclenche, ce sont les octets. Pour un fichier de Release, cela inclut un commentaire ou une modification d’espaces, exactement comme pour l’Aggregate et le Manifest que la Release nomme. Pour une entité, c’est le contenu de ce qu’elle porte, de sorte que la même entité lue depuis un répertoire de catalogue et récupérée depuis un registre ne dérive pas, pas plus qu’un checkout dont les fichiers ne diffèrent que par les bits de permission, bit d’exécution compris, ni une publication dont l’archive a été compressée différemment.

Message émis. La phrase propre à la condition l’ouvre, et chaque divergence collectée suit, chacune nommant son axe — et, pour une entité, son type, car une entité est identifiée par son type et son URI ensemble ; ainsi, une Release dont l’Aggregate et le Manifest partagent un nom a deux entrées, et une modification de l’un ou de l’autre est signalée pour celui qui a été modifié :

lockfile: out of date; it no longer matches what its Release resolves to: entity "<uri>" (<kind>) not in lockfile (referenced from <site>) (lockfile : obsolète ; il ne correspond plus à ce vers quoi sa Release se résout : entité, avec son type, absente du fichier de verrouillage, avec l’endroit d’où elle est référencée) <axis> "<uri>" changed: lockfile=(<version>,<digest>) current=(<version>,<digest>) (la référence indiquée a changé sur l’axe indiqué : la version et le digest du fichier de verrouillage diffèrent des valeurs actuelles) entity "<uri>" (<kind>) changed: lockfile=(<version>,<digest>) current=(<version>,<digest>) (l’entité indiquée, du type indiqué, a changé : la version et le digest du fichier de verrouillage diffèrent des valeurs actuelles) <axis> "<uri>" no longer used by the release (la référence indiquée sur l’axe indiqué n’est plus utilisée par la Release) release document "<file>" was edited after the lockfile was written: its content no longer matches the recorded digest (lockfile=<digest> current=<digest>), so the pins may no longer describe what it asks for; re-resolving the Release records the files it reads as they now stand (le document de Release indiqué a été modifié après l’écriture du fichier de verrouillage : son contenu ne correspond plus au digest enregistré, de sorte que les épinglages peuvent ne plus décrire ce qu’il demande ; résoudre à nouveau la Release enregistre les fichiers qu’elle lit tels qu’ils sont désormais)

<site> est l’endroit où la Release demande la référence, écrit comme le chemin vers l’entrée qui la nomme — manifest.spec.mappings.components.name.db-primary, par exemple — avec jusqu’à trois de ces endroits listés dans l’ordre trié et ... après eux lorsqu’il y en a davantage. Une référence dont la résolution n’enregistre aucun endroit de ce type est signalée sans la parenthèse.

Un pull qui signale une référence de source déplacée nomme l’artefact tel que son auteur l’a écrit, avec chart= et module_subdir= là où la source les nomme :

source-artifact kind=<kind> url=<url>: reference "<ref>" moved — the lockfile pins <commit>, and it now resolves to <commit>; adopt where it now points with aggrega pull --upgrade --release <release> (source-artifact : la référence indiquée a bougé — le fichier de verrouillage épingle un commit, et elle se résout désormais vers un autre ; adoptez sa nouvelle cible avec un pull de mise à niveau)

Une build affiche le remède après les entrées :

run aggrega pull --release <release> to re-resolve the Release and rewrite its lockfile (exécutez le pull pour résoudre à nouveau la Release et réécrire son fichier de verrouillage)

Quelles commandes tiennent une release à son lockfile. aggrega build compare avant le rendu et s’arrête. aggrega validate --release, ainsi que chaque sélection de aggrega inspect qui résout une release — la vue par défaut, --resolved, --ir-graph et --closure — effectuent la même comparaison dès que les dépendances de la release sont résolues, et s’arrêtent avec le même message et le même remède, sans rien écrire sur la sortie standard ; aucun des deux ne laisse donc passer un lockfile qu’un build refuse comme dérivé. Les outils de l’assistant build, validate avec release et describe avec release refusent dans les mêmes conditions. aggrega pull l’exécute par rapport au lockfile qu’il s’apprête à écrire, et aggrega pull --verify par rapport à celui présent sur le disque. Une commande qui ne résout aucune release — aggrega validate sans argument, qui ne lit alors les épinglages du lockfile que pour trouver un parent extends, ou avec un chemin d’entité, et aggrega inspect --raw ou --output yaml sans --ir-graph — n’est pas tenue à un lockfile, pas plus qu’une release sans lockfile à côté d’elle. Le serveur de langage de l’éditeur arrête ses builds sur ce point, et le signale lors d’une requête de graphe comme un avertissement sur le lockfile tout en dessinant quand même le graphe.

Comment corriger : résolvez à nouveau la Release et validez (par un commit) le fichier de verrouillage réécrit. Pour tout ce qu’une build signale, un simple aggrega pull --release <release> — la commande que la build affiche — constitue toute la correction : il résout la Release telle qu’elle est désormais, réécrit les épinglages qui ont bougé et conserve tous les autres, de sorte que rien ne bouge que vous n’ayez touché. Lorsque ce qui a bougé est un fichier sous la source locale d’une Recipe ou d’une FeatureRecipe, ce pull s’arrête d’abord en nommant aggrega pin pour l’entité, car enregistrer le nouvel épinglage à côté d’elle est l’étape de l’auteur ; exécutez cette commande, ou passez --pin-sources au pull, et le pull élimine la dérive. La seule entrée qu’un simple pull n’élimine pas est une référence de source qui a bougé sur son dépôt distant, car l’éliminer signifie adopter le commit que la référence nomme désormais : aggrega pull --upgrade --release <release> le fait, et l’entrée le dit — lorsque l’entity.lock de la Recipe enregistre cette source, la mise à niveau s’arrête de la même façon jusqu’à ce que le nouveau commit soit épinglé à côté d’elle. Lisez les entrées avant de le faire, car la troisième structure est celle qui mérite qu’on s’y arrête : une référence que la Release n’atteint plus est généralement une dépendance que vous avez supprimée volontairement, mais si vous ne l’avez pas supprimée, quelque chose d’autre a changé qui l’a rendue inatteignable. Une paire qui a bougé sur une référence que vous n’avez pas touchée signifie que le contenu à cette version n’est pas le contenu qui a été examiné, ce qui est une question pour celui qui le fournit plutôt que quelque chose à adopter sans regarder.

Un pull exécute cette même comparaison sur le fichier de verrouillage qu’il s’apprête à écrire et n’en écrit pas un que la comparaison refuse, de sorte qu’un fichier de verrouillage qu’un pull vient d’écrire la passe pour une build qui reçoit les mêmes entrées. Lorsque cette condition réapparaît juste après un pull qui s’est terminé, les deux exécutions ont reçu des entrées différentes : un répertoire de catalogue passé à l’une et pas à l’autre, ou une configuration de l’espace de travail modifiée entre les deux. Exécutez le pull et la build sur les mêmes entrées.

An artifact is not at the source the build was told to find it (Un artefact ne se trouve pas à la source où la build devait le trouver)

Une référence de catalogue nomme un artefact et une version. Cette condition signale que rien ne répond à cette paire — ni dans le registre vers lequel la référence se résout, ni dans le cache local d’artefacts depuis lequel la build lit.

Une build lit le cache ; elle ne sort pas d’elle-même vers l’extérieur. L’acquisition est une étape distincte : le pull qui résout une Release récupère ce dont la Release a besoin et l’écrit dans le cache, puis la build lit ce qui s’y trouve. Cette condition atteint donc une build comme un échec de cache, et atteint un pull comme un registre qui n’a pas un tel artefact. Lorsqu’une build est configurée pour remplir son fichier de verrouillage au démarrage, l’acquisition qu’elle exécute est ce même pull.

Messages émis. Un registre sans un tel tag, et une récupération qui a résolu un manifeste dont le blob de contenu est absent :

oci: "<reference>:<version>": oci: artifact not found at remote source (oci : pour la référence et la version indiquées : oci : artefact introuvable à la source distante)

oci: content for "<reference>:<version>": oci: artifact not found at remote source (oci : contenu pour la référence et la version indiquées : oci : artefact introuvable à la source distante)

une lecture du cache qui n’a trouvé aucune entrée, ce qui est la structure que rencontre une build :

oci: cache miss for <reference>@<version>: oci: artifact not found at remote source (oci : échec de cache pour la référence et la version indiquées : oci : artefact introuvable à la source distante)

et de même pour un artefact en cache dont le manifeste manque à côté de lui :

oci: manifest cache miss for <reference>@<version>: oci: artifact not found at remote source (oci : échec de cache du manifeste pour la référence et la version indiquées : oci : artefact introuvable à la source distante)

Comment corriger : vérifiez d’abord la référence et la version — une version qui n’existe plus et un nom comportant une faute de frappe produisent la même réponse, et le message cite les deux pour qu’on puisse les comparer avec le catalogue. Lorsque la référence est correcte, l’artefact n’a pas été acquis : exécutez le pull pour la Release, qui récupère ce que la Release atteint et remplit le cache. Lorsque l’espace de travail est hors ligne, ce pull doit être exécuté depuis un endroit disposant d’un accès réseau ; une build hors ligne ne lit que ce qui est déjà en cache, et c’est ce qu’elle dit lorsque le cache ne le contient pas.

The registry will not serve an artifact without credentials it accepts (Le registre ne sert pas un artefact sans identifiants qu’il accepte)

Le registre a répondu, et il a décliné : soit aucun identifiant n’a été présenté, soit ceux présentés n’ont pas été acceptés. C’est distinct d’un registre qui n’a pas pu être joint du tout — ici l’échange a eu lieu et la réponse a été non.

Quatre moments la signalent, tous pendant l’acquisition ou la publication d’artefacts : la résolution d’une référence, le pull de son contenu, l’énumération des versions que contient un dépôt, et la vérification d’un identifiant au moment où il est stocké.

Messages émis, chacun nommant ce qui était demandé et citant ce que le registre a répondu :

oci: resolve "<reference>:<version>": <what the registry replied>: oci: authentication required or failed (oci : résolution de la référence indiquée, avec la réponse du registre : oci : authentification requise ou échouée)

l’énumération des versions d’un dépôt, qui nomme plutôt le statut :

oci: tags/list "<repository>": status <code>: oci: authentication required or failed (oci : tags/list du dépôt indiqué, avec le code de statut : oci : authentification requise ou échouée)

et la vérification d’un identifiant au moment où il est stocké :

oci: verify credential for "<host>": <what the registry replied>: oci: authentication required or failed (oci : vérification de l’identifiant pour l’hôte indiqué, avec la réponse du registre : oci : authentification requise ou échouée)

Lorsque l’échec est signalé par une étape qui fournit un remède, la ligne se termine par la commande de connexion à exécuter sur l’hôte qu’elle a déduit :

remediation: aggrega login <host> (or docker login <host>) before re-running aggrega pull —release <release> (remède : exécutez aggrega login, ou docker login, pour l’hôte indiqué avant de réexécuter aggrega pull —release pour la Release indiquée)

et, là où une importation récupérait l’un des importateurs core du compilateur, la même connexion avant d’exécuter à nouveau l’importation :

remediation: aggrega login <host> (or docker login <host>) before re-running the import (correctif : aggrega login (ou docker login) avant de relancer l’importation)

Un dépôt classique de charts Helm ou une archive de chart, un fragment compose et un dépôt Git récupérés via http ou https signalent également cette condition lorsque le serveur refuse la requête comme non autorisée, et leur remède nomme l’entrée netrc à ajouter plutôt qu’une connexion, puisque c’est dans ce fichier que ces récupérations lisent leur identifiant :

remediation: add an entry for <host> (machine <host> login <user> password <secret>) to the netrc file <path>, then run the command again (remède : ajoutez au fichier netrc une entrée pour l’hôte (avec machine, login et password), puis relancez la commande)

Comment corriger : cela relève de l’opérateur plutôt que de l’auteur de l’entité — rien dans un Aggregate, un Component ou une Recipe ne le provoque. Le hub officiel, hub.aggrega.ai, sert à tout le monde ce qu’il publie, si bien que la lecture depuis celui-ci ne nécessite aucun identifiant, alors que la publication vers celui-ci en nécessite un ; un autre registre peut aussi exiger un identifiant pour la lecture. Connectez-vous à l’hôte que nomme le message — ou, pour une source récupérée via http ou https, ajoutez l’entrée netrc que nomme le remède — et relancez l’acquisition. Si vous êtes déjà connecté, l’identifiant du magasin n’est pas un identifiant que cet hôte accepte pour ce dépôt : connectez-vous à nouveau pour l’actualiser, et vérifiez que le compte dispose d’un accès en lecture au dépôt vers lequel la référence se résout, car un dépôt privé répond exactement ainsi à un compte qui ne peut pas le voir. Si la référence se résout vers un hôte auquel vous ne vous attendiez pas, l’alias de registre ou le registre par défaut dans .aggrega-config.yaml pointe ailleurs.

The netrc file cannot be read (Le fichier netrc ne peut pas être lu)

Un dépôt de charts Helm classique ou une archive de chart, un fragment compose et un dépôt Git récupérés via http ou https prennent leur identifiant dans le fichier netrc, qui est lu lorsqu’une telle source est récupérée — par un pull, un épinglage ou une build qui remplit son fichier de verrouillage. Quel fichier est lu, et quelle entrée répond à une requête, est exposé dans Authentification. Cette condition signale un fichier netrc qui existe et n’a pas pu être utilisé : il n’a pas pu être lu — c’est un répertoire, par exemple, ou vous n’avez pas l’autorisation de le lire — ou il ne suit pas le format netrc. Le format est lu de manière stricte, car un mot lu au mauvais endroit décale tous les mots qui le suivent : un mot-clé mal orthographié transformerait sinon le mot de passe qui le suit en mot-clé suivant, et la requête partirait sans identifiant, ou avec le mauvais, alors que le fichier semblait correct.

Un fichier qui n’existe pas ne relève pas de cette condition : il ne contient aucun identifiant, et une requête qui en a besoin reçoit pour réponse le refus du serveur. Un fichier que d’autres utilisateurs de la machine peuvent lire n’en relève pas non plus : sous Linux et macOS, il donne lieu à un avertissement nommant le fichier, et il est tout de même lu.

Le message nomme le fichier et, pour une faute de format, la ligne, et indique ce qui ne va pas uniquement en termes de format — jamais un mot que contient le fichier, puisqu’un mot mal placé peut être un mot de passe. Le diagnostic ne porte aucune catégorie : le fichier netrc est votre propre fichier d’identifiants et non un document que lit la build.

Message émis pour une faute de format, qui est l’un des cas suivants : un mot placé là où un mot-clé est attendu, un mot-clé non suivi de sa valeur, un login, password ou account placé avant toute entrée machine ou default, et un mot entre guillemets non fermé sur la ligne où il s’ouvre :

the netrc file could not be read (file <path>, line <line>, a word stands where a keyword is expected (machine, default, login, password, account or macdef)). Correct the file, or set NETRC to the path of another netrc file to read instead (le fichier netrc n’a pas pu être lu : dans le fichier et à la ligne indiqués, un mot se trouve là où un mot-clé est attendu (machine, default, login, password, account ou macdef). Corrigez le fichier, ou définissez NETRC sur le chemin d’un autre fichier netrc à lire à la place)

et pour un fichier qui n’a pas pu être lu, en citant pourquoi :

the netrc file could not be read (file <path>, <why it could not be read>). Correct the file, or set NETRC to the path of another netrc file to read instead (le fichier netrc n’a pas pu être lu : le fichier indiqué, avec la raison pour laquelle il n’a pas pu être lu. Corrigez le fichier, ou définissez NETRC sur le chemin d’un autre fichier netrc à lire à la place)

Comment corriger : ouvrez le fichier que nomme le message. Pour une faute de format, allez à la ligne qu’il nomme : chaque entrée est machine <host> — ou default — suivi de login <user> et de password <secret>, et un mot-clé mal orthographié ou laissé sans sa valeur en est la cause habituelle. Pour un fichier qui n’a pas pu être lu, faites-en un fichier que vous pouvez lire, lisible par vous seul (chmod 600). Si le fichier n’est pas celui que vous vouliez faire lire, définissez NETRC sur le chemin de celui que vous vouliez.

The registry could not be reached (Le registre est injoignable)

La conversation avec le registre n’a jamais eu lieu : la résolution de noms, la connexion ou la négociation sécurisée a échoué. C’est le pendant d’un registre qui a répondu et refusé — ici, rien n’a été établi dans un sens ou dans l’autre, de sorte que l’état de l’artefact à l’autre extrémité est inconnu plutôt que connu comme manquant.

C’est aussi ce que signale un échec de transport sans cause plus précise pendant l’acquisition de la source d’une Recipe ; c’est donc, sur ce chemin, la réponse générale « l’autre extrémité n’a pas pu être jointe » plutôt qu’une affirmation sur le niveau qui a échoué.

Message émis, qui nomme la source en cours d’acquisition et cite l’échec de transport sous-jacent, avec le remède que porte la condition :

sourceresolver: kind=<kind> url=<url> version=<version>: oci: network unreachable (cause: <the transport failure>); remediation: check network connectivity to <host>; corporate proxies typically need HTTPS_PROXY exported (sourceresolver : avec le type, l’URL et la version indiqués : oci : réseau injoignable (cause : l’échec de transport) ; remède : vérifiez la connectivité réseau vers l’hôte indiqué ; les proxys d’entreprise exigent généralement que HTTPS_PROXY soit exportée)

Comment corriger : la correction revient à l’opérateur et se situe hors de votre catalogue. Vérifiez que l’hôte indiqué dans le message est joignable depuis l’endroit où la commande s’exécute. Lorsque l’environnement atteint le réseau via un proxy, le proxy doit être exporté dans l’environnement, comme l’indique le remède — un proxy configuré uniquement pour un navigateur ou un gestionnaire de paquets ne sera pas pris en compte. Lorsque l’hôte est joignable manuellement mais pas d’ici, la différence tient généralement à des identifiants exigés par un proxy ou à un certificat d’interception que la négociation n’a pas accepté. Une fois les artefacts en cache, les builds suivantes lisent le cache et n’ont plus du tout besoin du réseau.

A server did not answer in time (Un serveur n’a pas répondu à temps)

Une requête est restée en attente du serveur auquel elle s’adressait — un registre, ou tout autre serveur qu’une commande atteint, comme le journal de transparence dans lequel une signature est consignée — et a été retirée. Une requête attend au plus 30 secondes que le serveur commence sa réponse une fois la requête entièrement envoyée, et au plus 30 secondes la partie suivante d’une réponse déjà en cours d’arrivée ; au-delà de l’un ou l’autre, elle est refusée sous cette condition, qui nomme le serveur et l’attente. C’est ce que produit un serveur qui accepte une connexion et ne répond jamais, et ce que produit aussi une adresse qui n’en accepte jamais aucune, plutôt qu’une commande qui attend sans fin. Un parcours de toute la liste des dépôts d’un registre attend en revanche sur chaque page aussi longtemps que le parcours peut durer, et il est borné par sa propre condition, E0377.

Seule l’attente est bornée. Un téléchargement ou un envoi qui continue d’avancer prend le temps qu’il faut, car l’attente n’est mesurée que tant que rien n’arrive. Un chart Helm que le source: d’une Recipe récupère via HTTPS n’est soumis qu’à l’attente du début de sa réponse, et cette expiration est signalée dans les propres termes de la bibliothèque réseau plutôt que sous cette condition. Une requête qu’une commande réémet déjà lorsqu’elle expire — une lecture pendant aggrega registry update, une écriture pendant une publication — est d’abord réémise, de sorte que le refus est ce qui reste après sa dernière tentative.

Message émis, pour une liste de versions à laquelle le registre n’a pas répondu :

aggrega plugin add: 127.0.0.1:18471: list versions for plugin/cli/mo: oci: list tags: Get “http://127.0.0.1:18471/v2/plugin/cli/mo/tags/list”: 127.0.0.1:18471 did not answer within 30s: egress: the server did not answer in time (aggrega plugin add : 127.0.0.1:18471 : lister les versions de plugin/cli/mo : oci : lister les tags : Get : 127.0.0.1:18471 n’a pas répondu dans les 30s : egress : le serveur n’a pas répondu à temps)

et pour une réponse qui s’est interrompue en cours de route :

<host> stopped answering: nothing more of its answer arrived for 30s: egress: the server did not answer in time (a cessé de répondre : plus rien de sa réponse n’est arrivé pendant 30s : egress : le serveur n’a pas répondu à temps)

Comment corriger : la correction revient à l’opérateur et se situe en dehors de votre catalogue. Vérifiez que le serveur nommé par le message est en service et joignable depuis l’endroit où la commande s’exécute ; un registre sous charge ou en maintenance répond de nouveau plus tard, et il suffit de relancer la commande. Lorsque l’environnement atteint le réseau via un proxy, vérifiez que le proxy transmet la requête plutôt que de la retenir. L’attente est fixe ; aucun paramètre ne permet de l’allonger.

A registry’s repository listing did not end in time (La liste des dépôts d’un registre ne s’est pas terminée à temps)

Un parcours de toute la liste des dépôts d’un registre a duré cinq minutes sans atteindre la fin de la liste, et a été arrêté. Deux commandes parcourent la liste : aggrega plugin add, uniquement lorsqu’aucun plugin ne porte exactement le nom qui lui a été donné et qu’elle en cherche un dont le nom le contient, et aggrega registry update, qui liste les dépôts d’un registre avant de lire chacun d’eux. Une liste qui ne cesse de nommer de nouveaux dépôts et une liste qu’un registre sert trop lentement pour qu’elle s’achève se terminent toutes deux ici plutôt que de bloquer la commande ; le parcours ne produit alors aucun dépôt, de sorte que rien n’est choisi ni indexé à partir d’une liste tronquée. Le message indique combien de dépôts la liste avait nommés au moment de l’arrêt.

Message émis, pour l’ajout d’un plugin dont la requête est une partie d’un nom :

aggrega plugin add: 127.0.0.1:18472: no cli plugin is named “mo”, and searching every repository for a name containing it did not finish; name the plugin exactly, as aggrega plugin add cli <name>: the walk was stopped after 5m0s, before the listing ended (repositories named so far: 146): registry: the repository listing did not end in time (aggrega plugin add : 127.0.0.1:18472 : aucun plugin cli ne s’appelle « mo », et la recherche dans chaque dépôt d’un nom qui le contient ne s’est pas terminée ; nommez le plugin exactement, comme aggrega plugin add cli suivi du nom : le parcours a été arrêté après 5m0s, avant la fin de la liste (dépôts nommés jusqu’ici : 146) : registry : la liste des dépôts ne s’est pas terminée à temps)

Comment corriger : pour aggrega plugin add, nommez le plugin exactement — aggrega plugin add cli moo plutôt que aggrega plugin add cli mo —, ce qui recherche le plugin sous ce nom en une seule requête et ne parcourt jamais la liste. Pour aggrega registry update, c’est la liste du registre qui est en cause : vérifiez auprès de la personne qui exploite le registre que sa liste se termine, et relancez la mise à jour une fois que c’est le cas. La limite de cinq minutes est fixe ; aucun paramètre ne permet de l’allonger.

A registry kept asking to slow down (Un registre a continué de demander de ralentir)

Un registre trop occupé répond 429 Too Many Requests, ou 503 Service Unavailable avec un en-tête Retry-After indiquant combien de temps attendre. Chaque requête qu’une commande adresse à un registre attend aussi longtemps que le registre le demande — dix secondes lorsqu’il ne le précise pas — puis est redemandée ; chaque requête vers ce registre attend avec elle, et moins de requêtes lui sont envoyées à la fois jusqu’à ce qu’il réponde de nouveau. Un registre qui ne répond rien d’autre que « ralentissez » pendant cinq minutes est refusé sous cette condition, en nommant le registre, sa dernière réponse et depuis combien de temps il ne répondait rien d’autre, de même qu’une requête dont le propre délai expire pendant qu’elle attend. aggrega registry update signale alors ce registre comme non indexé, et celui-ci conserve l’index qu’il avait avant l’exécution.

Message émis, pour un registre qui a demandé de ralentir pendant cinq minutes :

<host> kept asking to slow down: its last answer was 429 Too Many Requests, and it had answered nothing else for 5m0s: oci: the registry kept asking to slow down (a continué de demander de ralentir : sa dernière réponse était 429 Too Many Requests, et il n’avait rien répondu d’autre pendant 5m0s : oci: le registre a continué de demander de ralentir)

et pour une requête dont le propre délai a mis fin à l’attente :

<host> kept asking to slow down: its last answer was 429 Too Many Requests, and it had answered nothing else for <how long> when the request’s own time ran out: oci: the registry kept asking to slow down (a continué de demander de ralentir : sa dernière réponse était 429 Too Many Requests, et il n’avait rien répondu d’autre lorsque le propre délai de la requête a expiré : oci: le registre a continué de demander de ralentir)

Comment corriger : la cause est la limite de débit du registre, et non quelque chose que vous avez écrit. Un registre qui limite la fréquence à laquelle un client peut l’interroger limite généralement tout ce qui provient de la même adresse ; vérifiez donc si d’autres commandes ou d’autres machines derrière cette adresse l’interrogent au même moment, et exécutez de nouveau la commande une fois qu’elles ont terminé. Si vous exploitez vous-même le registre, vérifiez sa limite de débit. La limite de cinq minutes est fixe ; aucun paramètre ne la prolonge.

Fetched or cached bytes do not match the digest committed for them (Les octets récupérés ou en cache ne correspondent pas au digest déclaré pour eux)

Chaque artefact porte un manifeste qui déclare le digest de son contenu, et le fichier de verrouillage épingle indépendamment le digest de ce manifeste. Les deux déclarations sont vérifiées en recalculant le hachage des octets disponibles et en comparant. C’est ce que signale une comparaison qui échoue, et elle se déclenche de la même façon sur des octets tout juste récupérés et sur des octets relus depuis le cache.

Deux conditions, et celle qui se déclenche indique quel niveau était en désaccord. L’une nomme un contenu qui ne correspond pas au digest que déclare son propre manifeste. L’autre nomme un manifeste en cache qui ne correspond pas au digest que le fichier de verrouillage a épinglé pour lui — le contrôle qui empêche un manifeste altéré de devenir l’autorité à laquelle se fie un contrôle de contenu ultérieur. C’est l’épinglage qui donne son sens à ce second contrôle : il provient du fichier de verrouillage plutôt que d’une nouvelle dérivation du manifeste à partir des octets en cache, de sorte que les deux sont réellement indépendants.

Une entité est ensuite confrontée à sa propre ligne, avant ce que portent les octets. Une fois que les octets d’une entité en cache concordent avec leur manifeste, ils sont comparés au digest que le fichier de verrouillage enregistre pour l’entité, qui couvre les fichiers que porte sa publication — chacun par son chemin et ses octets — plutôt que les octets compressés. Ainsi, les mêmes fichiers publiés avec une autre compression concordent toujours, tandis que des fichiers différents sous la même version ne concordent pas, et un désaccord est signalé sous la condition de contenu. Un pull qui respecte un épinglage effectue la même comparaison sur ce qu’un registre sert sous la version épinglée.

Aucun de ces contrôles n’a besoin du réseau. Chacun est une comparaison de hachages sur des octets déjà disponibles, ce qui permet à une build entièrement hors ligne d’établir malgré tout que ce qu’elle lit est ce qui a été épinglé.

Messages émis. Le contenu par rapport à son manifeste :

oci: content digest <computed> != manifest layer <committed>: oci: content digest mismatch (oci : le digest calculé du contenu diffère de celui que déclare la couche du manifeste : oci : discordance du digest de contenu)

une entité plugin, que le manifeste déclare à une autre position :

oci: config digest <computed> != manifest config <committed>: oci: content digest mismatch (oci : le digest calculé de la configuration diffère de celui de la configuration du manifeste : oci : discordance du digest de contenu)

un manifeste en cache par rapport au digest épinglé :

oci: cached manifest digest <computed> != pinned <pinned>: oci: cached manifest digest mismatch (oci : le digest calculé du manifeste en cache diffère de celui qui est épinglé : oci : discordance du digest du manifeste en cache)

une entité en cache par rapport à sa ligne, et un registre qui sert un autre contenu sous une version épinglée :

catalog: cached <uri> content digest <computed> does not match lockfile pin <pinned>: oci: content digest mismatch (catalog : le digest de contenu de l’entité en cache indiquée ne correspond pas à l’épinglage du fichier de verrouillage : oci : discordance du digest de contenu)

oci: content digest mismatch: pinned entity "<uri>": registry now serves digest <computed> for the pinned version, not the pinned digest <pinned>; run aggrega pull --upgrade --release <release> to update the pin (oci : discordance du digest de contenu : entité épinglée indiquée : le registre sert désormais pour la version épinglée un digest différent du digest épinglé ; exécutez le pull de mise à niveau pour mettre à jour l’épinglage)

Les deux sont encadrés par ce qui était en cours de lecture. Une entité épinglée qu’aucune source ne détient à son épinglage, avec la condition du manifeste lorsque le manifeste de l’entrée de cache était en désaccord, et celle du contenu sinon :

pinned entity <uri>: no source holds the pinned bytes <pinned> (<what each source it read held>); with a registry reachable, aggrega pull --release <release> fetches the pinned version again: <the message above> (entité épinglée indiquée : aucune source ne détient les octets épinglés, avec ce que détenait chaque source lue ; avec un registre joignable, le pull récupère de nouveau la version épinglée : le message ci-dessus)

Une entrée d’archive qui nomme un chemin sortant de l’archive est elle aussi signalée sous la condition de contenu, car un bundle qui s’y essaie n’est pas le bundle qui avait été déclaré :

path traversal entry "<name>": oci: content digest mismatch (entrée de traversée de chemin indiquée : oci : discordance du digest de contenu)

Les deux portent le même remède lorsque l’étape qui les fait remonter en fournit un :

remediation: run aggrega pull —upgrade —release <release> to refresh the lockfile and cache (remède : exécutez aggrega pull —upgrade —release pour la Release indiquée afin d’actualiser le fichier de verrouillage et le cache)

Comment corriger : rien dans vos fichiers d’entité ne provoque cela, et aucune modification de rédaction ne l’élimine. Actualisez ensemble le cache et le fichier de verrouillage avec aggrega pull --upgrade --release <release>, qui récupère de nouveau depuis la source et réécrit les deux. Si cela l’élimine, la copie en cache avait été altérée ou tronquée depuis son écriture. Si la discordance survit à une actualisation, les octets que sert l’éditeur diffèrent réellement de ce qui a été épinglé — une version republiée, ce qui est une question à poser à son éditeur, et qui mérite d’être posée avant d’adopter le nouveau digest plutôt qu’après.

A manifest carries no layer of the expected kind, or more than one (Un manifeste ne porte aucune couche du type attendu, ou en porte plusieurs)

Le manifeste d’un artefact liste ses couches, et celle qui porte le contenu est sélectionnée par son type de média plutôt que par sa position. C’est ce qui permet à un artefact de regrouper plus d’une couche — un chart accompagné d’une couche de provenance détachée, par exemple — tout en faisant ressortir le contenu de façon fiable.

Deux structures ne laissent rien à sélectionner. Aucune couche du type attendu signifie que le manifeste décrit autre chose que ce que la référence était censée désigner. Plus d’une signifie que le choix n’a pas de réponse, et prendre la première serait parfois juste et parfois faux sans que rien ne le signale.

Messages émis, chacun nommant le type de média attendu. Aucune :

oci: manifest has no layer of media type "<media-type>": oci: manifest has no layer of the expected content media type (oci : le manifeste n’a aucune couche du type de média indiqué : oci : le manifeste n’a aucune couche du type de média de contenu attendu)

et plus d’une, ce qui nomme aussi leur nombre :

oci: manifest has <count> layers of media type "<media-type>"; expected exactly one: oci: manifest has multiple layers of the expected content media type (oci : le manifeste a plusieurs couches du type de média indiqué ; une seule était attendue : oci : le manifeste a plusieurs couches du type de média de contenu attendu)

Comment corriger : la correction revient à l’éditeur plutôt qu’à vous — le manifeste n’est pas quelque chose qu’écrit un auteur de catalogue. Vérifiez d’abord que la référence pointe là où vous l’entendiez : une référence qui se résout en un autre type d’artefact produit la première structure, car le manifeste est un vrai manifeste pour autre chose. Si la référence est juste, l’artefact a été publié avec un manifeste qui ne le décrit pas comme le type qu’il est censé être ; transmettez donc le type de média du message à son éditeur. Publier par le chemin de publication ordinaire produit un manifeste avec exactement une couche de contenu ; un artefact dans l’une ou l’autre structure a donc été assemblé autrement.

A published bundle holds no entity, or holds two (Un bundle publié ne contient aucune entité, ou en contient deux)

Une entité qui déclare des fichiers à côté de son document — le chart local d’une Recipe ou son verrou, le schéma importé d’un Component — est publiée sous forme de .tar.gz regroupant l’entité avec ces fichiers. En relire un signifie retrouver l’entité parmi eux — et le fichier dans lequel elle a été rédigée peut porter n’importe quel nom, de sorte que ce qui l’identifie est le préambule d’entité qu’elle porte plutôt que son nom. Le document à la racine du bundle dont le kind: est un type d’entité publiable est l’entité ; un fragment compose, un modèle de chart ou un manifeste Kubernetes à côté ne l’est pas, pas plus qu’un document d’entité situé plus bas dans une arborescence source/, qui est du contenu que l’entité livre plutôt que l’entité elle-même.

Deux structures ne laissent rien à sélectionner, et toutes deux sont des propriétés de la manière dont l’artefact a été publié.

Aucun document d’entité à la racine du bundle. Le bundle a été empaqueté sans l’entité à sa racine — son document omis, ou placé dans un sous-répertoire plutôt qu’à côté des fichiers qu’il porte. Le message liste ce que porte effectivement la racine du bundle, ce qui suffit généralement à voir ce qui s’est produit.

Deux documents d’entité à la racine du bundle. Le bundle a été empaqueté à partir d’un répertoire entier dans lequel deux entités ont été rédigées — ce que aggrega push ne fait jamais, puisque chaque entité ne porte que les fichiers qu’elle déclare, mais qu’un autre client peut faire. Empaquetées ainsi, chacune de leurs coordonnées publiées porte les mêmes octets — répondre avec l’une ou l’autre renverrait donc l’autre entité sous le nom demandé, sans que rien en aval ne puisse le remarquer. Il n’y a aucun choix sûr à faire, donc aucun n’est fait.

Messages émis, qui listent ce qui a été trouvé. Aucun, lorsque le bundle porte d’autres fichiers :

bundle root carries no entity document among <file>, <file>: oci: published bundle carries no entity document (la racine du bundle ne porte aucun document d’entité parmi les fichiers indiqués : oci : le bundle publié ne porte aucun document d’entité)

aucun, lorsqu’il ne porte rien du tout :

bundle root carries no files at all: oci: published bundle carries no entity document (la racine du bundle ne porte aucun fichier : oci : le bundle publié ne porte aucun document d’entité)

et plus d’un, ce qui nomme à la fois leur nombre et les documents en collision :

bundle root carries <count> entity documents (<file>, <file>): oci: published bundle carries more than one entity document (la racine du bundle porte plusieurs documents d’entité, dans les fichiers indiqués : oci : le bundle publié porte plus d’un document d’entité)

Comment corriger : les deux reviennent à l’éditeur plutôt qu’à vous, et la correction se trouve dans le répertoire de version depuis lequel l’entité a été publiée. Donnez à chaque entité son propre répertoire de version, afin que ce répertoire contienne une seule entité et les fichiers qui lui appartiennent — la disposition que suit déjà toute entité publiée, où le répertoire porte le nom du metadata.version de l’entité et se trouve sous le nom propre de l’entité. Publiez ensuite de nouveau à une nouvelle version : les octets publiés sont figés, donc republier par-dessus la version existante est refusé plutôt que corrigé. Si vous consommez plutôt que vous ne publiez, transmettez le message à l’éditeur de l’artefact ; les noms de fichier qu’il contient identifient le répertoire à scinder.

A published artifact cannot be read as an entity (Un artefact publié ne peut pas être lu comme une entité)

La lecture d’une entité à partir de la coordonnée où elle est publiée part des octets que le registre y sert — aggrega inspect oci://… les lit pour que vous puissiez les examiner, et un pull de dépendances lit ceux d’une archive de la même façon pour trouver la version qu’il épingle. Deux structures de ces octets ne contiennent aucune entité à lire.

Une archive qui ne se décompresse pas. Une entité publiée avec les fichiers qu’elle déclare est publiée sous forme de .tar.gz, et les octets commencent comme tel, mais le flux de compression ou l’archive qu’il contient n’est pas bien formé — le plus souvent parce qu’il a été tronqué. Les octets correspondent toujours au digest que le propre manifeste de l’artefact enregistre pour eux ; ils sont donc exactement ce qui a été publié : le dommage s’est produit avant ou pendant la publication plutôt qu’en chemin vers vous.

Un document qui n’est pas une entité. La coordonnée porte un seul document, et celui-ci ne s’analyse pas, ne déclare aucun kind:, ou déclare un type qui n’est jamais publié, comme une Release ou un Manifest. La référence nomme alors quelque chose publié à côté du catalogue plutôt qu’une entité — un artefact de données publié avec aggrega push-artifact, par exemple.

Messages émis. Une archive dont le flux de compression n’est pas bien formé, avec l’erreur qui l’a arrêtée :

oci: unbundle gzip: <archive error>: oci: published bundle cannot be unpacked (oci : décompression gzip du bundle : l’erreur d’archive : oci : le bundle publié ne peut pas être décompressé)

une archive qui s’arrête au milieu d’un fichier :

read <file> from the published bundle: <archive error>: oci: published bundle cannot be unpacked (lecture du fichier indiqué depuis le bundle publié : l’erreur d’archive : oci : le bundle publié ne peut pas être décompressé)

un document déclarant un type qui n’est jamais publié :

the published document declares kind <kind>, which a registry does not publish: oci: published artifact is not an entity document (le document publié déclare un type qu’un registre ne publie pas : oci : l’artefact publié n’est pas un document d’entité)

et des octets qui ne sont pas du tout un document :

the published bytes do not parse as a document (<parse error>): oci: published artifact is not an entity document (les octets publiés ne s’analysent pas comme un document, avec l’erreur d’analyse : oci : l’artefact publié n’est pas un document d’entité)

Comment corriger : une archive qui ne se décompresse pas doit être remplacée par l’éditeur. Les octets publiés sont figés, donc le remède consiste à publier de nouveau l’entité à une nouvelle version ; si vous la consommez, transmettez le message à son éditeur. Un document qui n’est pas une entité signifie presque toujours que la référence n’est pas celle que vous vouliez : vérifiez qu’elle nomme la coordonnée où une entité est publiée, c’est-à-dire la référence qu’affiche aggrega push lorsqu’il en publie une.

The registry could not answer what is attached to an artifact (Le registre n’a pas pu répondre sur ce qui est rattaché à un artefact)

Les signatures et les autres rattachements sont accrochés à un artefact plutôt que logés à l’intérieur, et les trouver est une question posée au registre. Cette condition indique que la question est restée sans réponse — le registre ne sert pas cette recherche, l’artefact auquel les rattachements sont accrochés n’a pas pu être localisé, ou la requête elle-même a échoué.

Ce n’est pas la même chose qu’une réponse « rien n’est rattaché », et confondre les deux est exactement ce que cette condition existe pour empêcher. Un artefact qui ne porte réellement aucune signature se résout normalement et produit une liste vide. Celle-ci indique que la liste n’a jamais été obtenue, de sorte qu’on ne sait rien du tout de ce qui est rattaché.

L’arrêt de la build dépend de l’exigence ou non d’une signature, et les deux directions sont délibérées :

  • Une signature est requise. La build s’arrête. Un contrôle requis qui n’a pas pu s’exécuter n’a pas réussi, et admettre l’artefact reposerait sur une question que personne n’a réussi à poser.
  • Aucune signature n’est requise. La build continue et le dit à voix haute, plutôt qu’en silence. La recherche n’a rien produit à vérifier dans un sens ou dans l’autre, donc refuser rejetterait un artefact sur la foi d’une question restée sans réponse — mais le silence se lirait comme un pull propre d’un artefact non signé, ce qu’il n’est pas.

Messages émis. Un registre qui ne sert pas la recherche :

oci: target does not support referrer discovery: <target kind>: oci: referrer discovery could not be completed (oci : la cible ne prend pas en charge la découverte des referrers, avec le type de cible indiqué : oci : la découverte des referrers n’a pas pu être menée à bien)

l’artefact lui-même introuvable :

oci: resolve subject "<reference>": <the underlying failure>: oci: referrer discovery could not be completed (oci : résolution du sujet indiqué : l’échec sous-jacent : oci : la découverte des referrers n’a pas pu être menée à bien)

et la recherche qui échoue :

oci: list referrers of "<reference>": <the underlying failure>: oci: referrer discovery could not be completed (oci : liste des referrers de la référence indiquée : l’échec sous-jacent : oci : la découverte des referrers n’a pas pu être menée à bien)

Lorsqu’aucune signature n’est requise, le même texte apparaît plutôt sous forme d’avis :

signature verification could not run for <uri> (the registry could not answer the signature lookup and no signature is required; continuing): <the message above> (la vérification de la signature n’a pas pu s’exécuter pour l’artefact indiqué (le registre n’a pas pu répondre à la recherche de signature et aucune signature n’est requise ; poursuite) : le message ci-dessus)

Comment corriger : la correction revient à l’opérateur et relève du registre plutôt que de votre catalogue. Lorsque le registre ne sert pas du tout les recherches de rattachements, il ne peut pas porter de signatures ; mettez donc l’artefact en miroir vers un registre qui le peut, ou cessez d’exiger des signatures de cet hôte dans .aggrega-config.yaml — et notez laquelle de ces deux options vous choisissez, car la seconde signifie que les signatures de cet hôte ne sont plus vérifiées. Lorsque la recherche a échoué pour un registre qui la sert, il s’agit d’un problème de transport ou d’autorisation propre au point de terminaison des rattachements, et relancer une fois le registre joignable est tout le remède.

An artifact that must be signed carries no signature (Un artefact qui doit être signé ne porte aucune signature)

Une signature est requise pour un artefact lorsque la politique de signature propre à l’espace de travail couvre son type ou que le registre dont il provient est configuré pour en exiger une. Cette condition signale que le registre a répondu à la recherche de rattachements, que rien n’était rattaché et qu’une signature était requise.

Les deux exigences sont une seule position lue à deux portées. La politique à l’échelle de l’espace de travail impose une signature à un type compris dans son périmètre même depuis un hôte dont l’entrée propre n’en exige aucune ; un hôte qui n’exige rien n’exempte donc pas un artefact que couvre la politique à l’échelle de l’espace de travail.

Lorsqu’aucune signature n’est requise, ce n’est pas du tout un échec. L’artefact est vérifié si une signature est présente et passe sans bruit s’il n’y en a aucune, ce qui rend utilisable sans cérémonie un hôte dépourvu de position configurée.

Un artefact dont le type n’a pas pu être déterminé alors qu’une politique à l’échelle de l’espace de travail est active est traité comme exigeant une signature plutôt que comme exempté, de sorte qu’un artefact inclassable ne peut pas échapper à une politique activée.

Message émis, encadré par la référence qu’il vérifiait :

verifying the signature of <uri>: signing: no signature found for an artifact that requires one (vérification de la signature de l’artefact indiqué : signing : aucune signature trouvée pour un artefact qui en exige une)

Comment corriger : la correction revient à l’opérateur ou à l’éditeur, pas à l’auteur de l’entité. Si vous vous attendiez à ce que l’artefact soit signé, il a été publié sans signature — transmettez la référence à son éditeur, puisque lui seul peut en rattacher une. Si l’artefact n’est pas censé être signé, c’est l’exigence qu’il faut changer : elle provient soit de l’entrée du registre dans .aggrega-config.yaml, soit de la politique de signature à l’échelle de l’espace de travail, et la référence du message vous indique quel hôte examiner. Désactiver une exigence signifie que les artefacts de cet hôte ne sont plus vérifiés ; préférez donc restreindre la portée de la politique à un type plutôt que de la désactiver complètement.

A signature does not verify (Une signature ne se vérifie pas)

Une signature a été trouvée et contrôlée, et le contrôle a échoué. C’est l’issue négative générale de ce contrôle, qui couvre une chaîne de certificats qui ne remonte pas aux éléments de confiance, une signature sans entrée dans le journal de transparence là où il en faut une, une signature portant sur un autre artefact que celui en main, un bundle qui a été altéré, et un bundle contrôlé par rapport à une clé épinglée avec laquelle il ne se vérifie pas.

Elle est délibérément distincte d’une signature dont le signataire n’est pas approuvé. Celle-là est structurellement saine et faite par le mauvais signataire ; celle-ci n’a pas du tout passé le contrôle. Les garder séparées est ce qui vous permet de distinguer « l’artefact n’est pas ce qui a été signé » de « l’artefact a été signé par quelqu’un que vous n’avez pas accepté ».

L’artefact pour lequel une signature a été faite est vérifié deux fois. Une fois que le contrôle cryptographique de la signature tient, la chaîne d’outils lit dans la signature elle-même pour quel artefact elle a été faite — la même lecture à laquelle chaque build ultérieure soumet la signature enregistrée, ce qui permet à une build de refuser une signature copiée d’un artefact sur un autre sans rien vérifier — et refuse la signature lorsque cette lecture ne nomme pas l’artefact en main, ou lorsque la signature est sous une forme dont la lecture ne peut pas déduire l’artefact. Les deux formes qu’un pull accepte sont lues : une signature faite sur l’artefact lui-même, et une déclaration signée qui le nomme. La lecture suit les règles propres du contrôle cryptographique, de sorte que, sur une signature que ce contrôle accepte, les deux concordent ; un refus de ce type signifie qu’ils ne concordaient pas, et mérite d’être signalé avec la référence et le message plutôt que contourné par la configuration.

Lorsque l’entrée d’un registre marque la vérification comme consultative, le même texte est signalé sous forme d’avis et l’exécution continue.

Messages émis. Du contrôle lui-même, citant ce que le vérificateur a signalé :

signing: signature bundle does not verify: <what the verifier reported> (signing : le bundle de signature ne se vérifie pas : ce que le vérificateur a signalé)

et, lorsque le contrôle cryptographique tient et que la lecture de l’artefact pour lequel la signature a été faite ne concorde pas :

signing: signature bundle does not verify: its cryptographic check holds, but it does not name <manifest-digest> as the artifact it was made for (signing : le bundle de signature ne se vérifie pas : son contrôle cryptographique tient, mais il ne nomme pas le digest du manifeste indiqué comme l’artefact pour lequel il a été fait)

signing: signature bundle does not verify: its cryptographic check holds, but it is in a form from which the artifact it was made for cannot be read (signing : le bundle de signature ne se vérifie pas : son contrôle cryptographique tient, mais il est sous une forme dont l’artefact pour lequel il a été fait ne peut pas être lu)

chacun encadré par la référence en cours de vérification :

verifying the signature of <uri>: <the message above> (vérification de la signature de l’artefact indiqué : le message ci-dessus)

et, lorsque l’entrée du registre rend la vérification consultative, sous forme d’avis plutôt que d’arrêt :

signature verification failed for <uri> (advisory; continuing): <the message above> (la vérification de la signature a échoué pour l’artefact indiqué (consultative ; poursuite) : le message ci-dessus)

Comment corriger : rien dans vos fichiers d’entité n’en est la cause et aucune modification d’authoring ne l’élimine. Traitez-le comme une affirmation sur l’artefact plutôt que sur votre configuration : les octets en main ne sont pas les octets qui ont été signés, ou la signature n’est pas une signature que les éléments de confiance configurés peuvent contrôler. Acquérez d’abord de nouveau l’artefact, car une copie en cache tronquée ou altérée échoue exactement de cette façon et une nouvelle récupération l’élimine. Si le problème survit à une nouvelle récupération, transmettez la référence et les propres mots du vérificateur à l’éditeur de l’artefact. Ne recourez pas au paramètre consultatif pour le contourner — ce paramètre maintient le contrôle en marche et l’empêche d’arrêter la build, ce qui est un choix délibéré d’accepter des artefacts non vérifiés de cet hôte plutôt qu’un moyen d’en corriger un.

A signature verifies but its signer is not one the registry trusts (Une signature se vérifie, mais son signataire n’est pas l’un de ceux que le registre approuve)

La signature a passé le contrôle — la chaîne de certificats remonte aux éléments de confiance et l’entrée de transparence est présente — et l’identité de ce certificat ne correspond à aucune des identités configurées comme acceptables pour le registre. L’artefact a été signé par un signataire réel qui n’a pas été accepté.

Les deux moitiés d’une identité sont comparées, le sujet et l’émetteur qui s’en est porté garant, et l’une comme l’autre peut être celle qui ne correspondait pas. Le message nomme les deux lorsqu’elles peuvent être lues sur le certificat, car un signataire présentant un sujet attendu sous un émetteur que personne n’a accepté paraît identique à un mauvais sujet, à moins que les deux ne soient affichées.

Messages émis. Avec les deux moitiés lisibles :

signing: signature identity is not trusted for this registry: <what the verifier reported>; signer presented issuer "<issuer>" with identity "<subject>", but no trusted identity permits that issuer (signing : l’identité de la signature n’est pas approuvée pour ce registre : ce que le vérificateur a signalé ; le signataire a présenté l’émetteur indiqué avec l’identité indiquée, mais aucune identité approuvée n’autorise cet émetteur)

et, lorsqu’elles ne peuvent pas être lues, en se rabattant sur le rapport propre du vérificateur :

signing: signature identity is not trusted for this registry: <what the verifier reported> (signing : l’identité de la signature n’est pas approuvée pour ce registre : ce que le vérificateur a signalé)

Comment corriger : il s’agit d’une décision de l’opérateur, et d’une vraie décision plutôt que d’une formalité. Comparez l’émetteur et l’identité du message avec les identités approuvées configurées pour ce registre dans .aggrega-config.yaml. Si le signataire est un signataire que vous entendez accepter, ajoutez-le — une entrée nomme une identité, ou un motif qui lui correspond, avec l’émetteur, et les deux doivent être justes. Sinon, l’artefact a été signé par quelqu’un que vous n’avez pas accepté, et ajouter l’identité pour faire passer la build est la seule réponse à éviter. Les registres qui annoncent leur propre politique de confiance peuvent la faire épingler lors de l’ajout du registre, ce qui est la manière d’y faire entrer les identités prévues sans les recopier.

A keyless trust policy names no acceptable signer (Une politique de confiance sans clé ne nomme aucun signataire acceptable)

La vérification sans clé décide d’accepter ou non un artefact en comparant l’identité de son certificat de signature à un ensemble d’identités configurées comme acceptables. Un ensemble vide est refusé plutôt que traité comme une politique : une comparaison avec rien accepterait tous les signataires ou les rejetterait tous, et aucune de ces deux issues n’est ce que voulait un opérateur qui a configuré la vérification.

Message émis, qui est la phrase propre de la condition :

signing: keyless verification requires at least one trusted identity (signing : la vérification sans clé exige au moins une identité approuvée)

Comment corriger : configurez au moins une identité approuvée pour le registre dans .aggrega-config.yaml. Une entrée nomme l’identité — sous forme de sujet exact ou de motif qui lui correspond — avec l’émetteur qui s’en porte garant, et les deux sont obligatoires. Lorsque le registre annonce sa propre politique de confiance, épingler cette politique lors de l’ajout du registre remplit l’ensemble à partir de ce que le registre publie. Si vous n’avez pas du tout l’intention de vérifier les signatures de ce registre, c’est un paramètre différent d’un ensemble d’identités vide, et le définir explicitement est ce qui le dit.

The pinned trust root cannot be read (La racine de confiance épinglée ne peut pas être lue)

Une racine de confiance épinglée dans l’espace de travail est ce qui permet à un contrôle sans clé de vérifier sans accès réseau où qu’il s’exécute : un fichier dont le contenu constitue les éléments par rapport auxquels chaque signature est contrôlée. Cette condition signale que le fichier situé au chemin configuré n’a pas pu être transformé en éléments de confiance utilisables — il est absent, il n’est pas lisible, ou son contenu n’est pas une racine de confiance.

Elle s’arrête plutôt que de se rabattre sur autre chose. Une racine épinglée est un choix délibéré de contrôler les signatures par rapport à des éléments que vous maîtrisez ; en récupérer une discrètement à la place remplacerait ce choix par un autre et produirait un résultat de vérification que personne n’a demandé.

Message émis, qui nomme le chemin et cite ce que la lecture a signalé :

signing: cannot load pinned trust root: <path>: <what the read reported> (signing : impossible de charger la racine de confiance épinglée : le chemin indiqué : ce que la lecture a signalé)

Comment corriger : cela revient à l’opérateur. Vérifiez que le chemin configuré pour la racine de confiance existe et est lisible par la personne qui exécute la commande — un chemin relatif à un autre répertoire de travail et un fichier présent mais illisible sont tous deux signalés ici. Si le fichier existe et est lisible, son contenu n’est pas une racine de confiance ; remplacez-le donc par un bundle à jour provenant de la source dont vous l’avez obtenu plutôt que de le modifier. Si une racine épinglée n’était pas voulue, c’est la configuration qu’il faut changer : supprimez l’épinglage et la vérification utilise les éléments qui lui seraient fournis autrement.

A pinned verification key is not the key profile the verifier accepts (Une clé de vérification épinglée n’est pas du profil de clé que le vérificateur accepte)

La signature et la vérification avec une clé détenue utilisent un seul profil de clé, et une clé de toute autre sorte est refusée plutôt que tentée. C’est une affirmation sur le type de la clé, pas sur le fait qu’elle vérifie quoi que ce soit.

Les deux moments où elle est signalée correspondent à des tâches différentes. L’un est le chargement d’une clé avec laquelle signer, qui a lieu là où un artefact est publié ; l’autre est le contrôle d’une signature par rapport à une clé épinglée pour un registre, qui a lieu là où un artefact est vérifié. Le refus est le même dans les deux cas.

Messages émis, chacun nommant l’algorithme de la clé réellement fournie — an RSA key ou an Ed25519 key. Une clé de vérification épinglée :

signing: unsupported held-key type: pinned key is <the key's algorithm>, want ECDSA P-256 (signing : type de clé détenue non pris en charge : la clé épinglée utilise l’algorithme indiqué, ECDSA P-256 attendu)

et une clé chargée pour signer :

signing: unsupported held-key type: held key is <the key's algorithm>, want ECDSA P-256 (signing : type de clé détenue non pris en charge : la clé détenue utilise l’algorithme indiqué, ECDSA P-256 attendu)

Comment corriger : fournissez une clé du profil que nomme le message. Si vous vérifiez, la clé est celle épinglée pour le registre dans .aggrega-config.yaml, et elle doit être la moitié publique de la clé avec laquelle l’éditeur signe — une non-concordance ici signifie généralement que le mauvais fichier a été épinglé, puisqu’une clé du bon type mais qui n’est pas la bonne clé est plutôt signalée comme une signature qui ne se vérifie pas. Si vous signez, générez une clé du profil nommé, ou utilisez la voie sans clé, qui n’a besoin d’aucune clé détenue.

The workspace is offline and the step needs the network (L’espace de travail est hors ligne et l’étape a besoin du réseau)

Un espace de travail peut être marqué hors ligne, et ce paramètre est un refus plutôt qu’une préférence : chaque étape qui atteindrait le réseau est refusée là où elle est construite, avant toute ouverture de connexion. Refuser tôt est ce qui fait dire à l’échec « cet espace de travail est hors ligne » au lieu d’apparaître plus tard sous forme de délai d’attente dépassé sans explication.

Une seule décision, lue en un seul endroit. Une étape qui doit savoir à l’avance si le réseau pourrait être atteint pose la même question que la récupération elle-même, de sorte qu’un contrôle et l’opération qu’il protège ne peuvent pas aboutir à des conclusions différentes.

Ce paramètre touche plusieurs sortes de travaux, tous par le même refus : l’acquisition d’un artefact depuis un registre, l’acquisition de la source d’une Recipe par le réseau, la récupération d’une entrée externe, l’obtention d’une identité avec laquelle signer et la récupération d’éléments de confiance. Une build qui lit un cache rempli n’en touche aucun, ce qui est tout l’intérêt du paramètre.

Lorsque toute la commande est un aller-retour réseau, le refus vient en premier plutôt qu’en dernier. push, push-artifact et registry update existent pour atteindre un registre ; ils le disent donc avant de lire votre entité ou de parcourir vos dépôts, et ils nomment lequel des trois endroits a défini le mode — l’option que vous avez saisie, la variable d’environnement, ou le fichier et la clé qu’il contient. Un --dry-run est l’exception, et c’est une exception en raison de ce qu’il fait plutôt que de son nom : il indique ce qu’il publierait et n’appelle rien ; c’est donc la forme d’une publication sûre hors ligne, et il continue de fonctionner.

Message émis, qui porte son propre remède et est la phrase propre de la condition :

egress: network access refused because the workspace is offline; remediation: pass --offline=false to allow the network for this one run, or clear the top-level offline key in the configuration file (or AGGREGA_OFFLINE) to allow it from now on; where the work is a build that needs content the machine does not have, run aggrega pull --release <release> from a connected environment first to populate the cache (egress : accès réseau refusé parce que l’espace de travail est hors ligne ; remède : passez l’option qui autorise le réseau pour cette seule exécution, ou effacez la clé de premier niveau du mode hors ligne dans le fichier de configuration (ou AGGREGA_OFFLINE) pour l’autoriser désormais ; lorsque le travail est une build qui a besoin d’un contenu que la machine n’a pas, exécutez d’abord le pull de la Release indiquée depuis un environnement connecté pour remplir le cache)

Encadré par ce qui avait besoin du réseau — l’acquisition de la source d’une Recipe, par exemple :

sourceresolver: kind=<kind> url=<url> version=<version>: <the message above> (sourceresolver : avec le type, l’URL et la version indiqués : le message ci-dessus)

L’ajout du hub officiel dans un espace de travail hors ligne n’est pas refusé : le hub est ajouté sur sa base intégrée, et l’avis indique que le hub n’a pas été interrogé sur sa politique de confiance parce que l’espace de travail est hors ligne.

Comment corriger : le message nomme trois voies, et c’est à vous de décider laquelle s’applique. Lorsque le mode est défini et que vous voulez le dépasser pour cette seule commande, passez --offline=false ; c’est à cela que sert l’option, et c’est la seule réponse dont dispose quelqu’un qui n’a pas écrit lui-même le fichier de configuration. Lorsque l’espace de travail est censé être hors ligne, c’est le contenu manquant qu’il faut corriger : exécutez le pull depuis un endroit disposant d’un accès réseau pour que le cache contienne tout ce que la Release atteint ; la build hors ligne n’a ensuite besoin de rien d’autre. Lorsqu’il n’est pas du tout censé être hors ligne, effacez le paramètre à sa source — la clé de premier niveau offline dans .aggrega-config.yaml, ou la variable d’environnement que nomme le message, et c’est la variable qui surprend les gens parce qu’elle ne se trouve dans aucun fichier. Notez qu’un espace de travail hors ligne ne peut pas du tout signer par la voie sans clé, puisque délivrer un certificat et l’enregistrer sont des opérations réseau sans forme hors ligne.

Lors de la construction de la topologie

Une fois que chaque Component dispose d’une Recipe résolue, le compilateur assemble les Components en graphe IR en lisant le bloc uses: de chaque Component et en croisant les cibles et les rattachements de fonctionnalités.

Dangling uses target (Cible d’arête pendante)

Une arête uses: nomme un composant cible qui n’existe pas dans la topologie résolue. L’arrêt est agnostique vis-à-vis de l’origine — une arête de l’Aggregate écrite par le développeur et une arête câblée par une Release sont interceptées de la même façon. Une cible pendante est un arrêt fatal, et non une suppression silencieuse : une arête vers une cible inexistante disparaîtrait sinon et laisserait silencieusement vides les valeurs injectées du consommateur au moment du déploiement. C’est le pendant structurel de l’arrêt pour socket non déclaré ci-dessous : quel que soit le socket dans lequel une connexion est câblée, sa cible doit se résoudre en un composant existant avant que le type de l’arête ne soit vérifié.

Message émis. Le refus vient d’abord, puis la cible qui ne correspond à rien et le socket dans lequel la connexion a été câblée — puis ce qu’il faut faire :

uses edge target does not exist ("<target>", wired into socket "<socket>"). Point the target at a component the Aggregate declares, or declare a component under that name. (la cible de l’arête uses n’existe pas : la cible indiquée, câblée dans le socket indiqué. Faites pointer la cible vers un composant que l’Aggregate déclare, ou déclarez un composant sous ce nom.)

Le constat est positionné sur l’entrée rédigée qu’il concerne, dans le document où cette entrée a été écrite, de sorte qu’une connexion tracée par le propre bloc uses: d’un composant, une connexion projetée par un rattachement et une connexion câblée par une Release sont chacune signalées sur leur propre bloc. Chaque connexion fautive est signalée comme un constat distinct, de sorte qu’une seule build les nomme toutes au lieu de s’arrêter à la première.

Comment corriger : déclarez le composant cible manquant, ou corrigez le nom de la cible dans l’entrée uses: pour qu’il corresponde à un composant existant.

Two connections of one component under one alias (Deux connexions d’un composant sous un même alias)

Un composant lit chacune de ses connexions par son alias — la clé sous laquelle la connexion a été écrite ou, pour une connexion écrite comme entrée de liste, le nom propre de sa cible. Un modèle de Recipe lit les connexions d’un composant indexées par alias seul, et une assertion les lit indexées par socket puis par alias, de sorte que deux connexions d’un composant sous un même alias partageraient un seul emplacement dans au moins l’une de ces vues : la plus tardive l’occuperait, et l’autre serait absente de ce que voit le modèle ou l’assertion. Un alias nomme donc une seule connexion d’un composant — quel que soit le socket dans lequel chacune est câblée, quel que soit ce qui l’a tracée (le propre bloc uses: du composant, le bloc uses: d’un rattachement à n’importe quelle portée, ou une entrée par arête d’une Release), et quelle que soit sa cible. Une paire arrête la build une fois le graphe définitif, avant qu’aucune assertion ne s’exécute et avant que quoi que ce soit ne soit rendu.

La paire naît d’une rédaction légale sur chaque surface prise isolément : l’entrée propre d’un composant et celle d’un rattachement sur un même socket et un même alias ; une liste nommant deux fois une même cible (models: [llama, llama]) ; un alias écrit sur deux sockets (models: { local: … } à côté de databases: { local: … }) ; deux rattachements câblant un même alias ; ou une entrée de Release traçant une connexion sur un socket que l’Aggregate a laissé non lié, sous un alias que l’Aggregate a déjà utilisé sur un autre socket. Deux structures voisines n’atteignent jamais cet arrêt : une clé écrite deux fois dans un même bloc d’entrées à clé fait échouer le chargement du document, et une entrée de Release sur un socket et un alias qu’un autre bloc a déjà tracés configure cette connexion — ou, si elle nomme une cible différente, s’arrête comme un reciblage — au lieu d’en tracer une seconde.

Message émis. Le refus vient d’abord, puis l’alias et le composant, puis le socket de cette connexion, sa cible et l’endroit où son entrée a été écrite, puis la même chose pour la connexion qui détient déjà l’alias — puis ce qu’il faut faire :

connection alias is already used by another connection of the same component ("<alias>", on component "<component>", this connection wired into socket "<socket>", with target "<target>", written in "<file>", at "<key path>", the connection already holding the alias wired into socket "<socket>", with target "<target>", written in "<file>", at "<key path>"). Give one of the two connections an alias of its own: a component reads each connection by its alias, whatever socket it is wired into. A list entry takes its target’s name as its alias, so a target listed twice is listed once, or written as two keyed entries under two aliases. (l’alias de connexion est déjà utilisé par une autre connexion du même composant : l’alias et le composant indiqués, le socket, la cible, le fichier et le chemin de clés de cette connexion, puis les mêmes pour la connexion qui détient déjà l’alias. Donnez à l’une des deux connexions un alias qui lui soit propre : un composant lit chaque connexion par son alias, quel que soit le socket dans lequel elle est câblée. Une entrée de liste prend le nom de sa cible comme alias, donc une cible listée deux fois est listée une seule fois, ou écrite comme deux entrées à clé sous deux alias.)

Lorsque les deux connexions ont été écrites au même chemin de clés — une liste nommant deux fois une même cible —, chacune est aussi nommée par sa place dans cette liste, list entry "2" à côté de list entry "1", qui est la seule chose distinguant les deux entrées.

Le constat est positionné sur l’entrée propre de la connexion la plus tardive — celle tracée en second, qui est celle qui aurait sinon occupé l’emplacement de l’alias — dans le document où cette entrée a été écrite. Ainsi, une entrée de Release, ou un rattachement que la Release écrit, est classé comme une faute d’exploitation, et une entrée dans l’Aggregate comme une faute du développeur. Chaque connexion fautive est signalée comme un constat distinct, de sorte qu’une seule build les nomme toutes.

Certaines structures sont nommées moins exactement. Un nom de rattachement déclaré à plus d’une portée — sur un composant et sur le sous-système qui le contient, par exemple — trace une connexion depuis chaque bloc déclarant, et la build enregistre les deux sous le seul nom du rattachement. Les deux connexions sont alors nommées sur l’un des blocs déclarants — le propre bloc de rattachements du composant, partout où le nom y est déclaré — et aucune ne porte de position de liste. Il en va de même à l’intérieur d’un Aggregate importé, où les blocs déclarants — celui d’un composant et celui de l’un des propres sous-systèmes du module — sont nommés dans le propre document du module. Dans chacune de ces structures, la paire est tout de même refusée.

Comment corriger : donnez à l’une des deux connexions un alias qui lui soit propre. Pour une liste nommant deux fois une même cible, listez la cible une seule fois, ou écrivez les deux connexions comme des entrées à clé sous deux alias. Pour un alias sur deux sockets, renommez l’une des deux clés. Un rattachement câblant un socket sous un alias que le composant utilise déjà prend une clé différente dans son propre bloc uses:.

uses: socket not declared in the owning entity’s usesSchema (Socket non déclaré dans le schéma de sockets de l’entité propriétaire)

Un bloc uses: nomme un socket que l’entité propriétaire de la surface ne déclare pas dans son usesSchema, sur l’une des deux surfaces où seul un socket déclaré peut être nommé : le uses: d’un rattachement de Feature, où le socket doit être déclaré sur la Feature rattachée, et le uses: par arête d’une Release, où il doit être déclaré sur le Component consommateur. Une Release ne peut câbler ou configurer des arêtes qu’à l’intérieur des sockets que le usesSchema du Component déclare déjà.

La surface des rattachements est vérifiée à chaque portée à laquelle un rattachement est écrit : sur un composant, sur un sous-système — de l’Aggregate ou d’un module qu’il importe —, sur une frontière de Release et sur une entrée de composant de Release, y compris l’entrée d’un composant qu’un module fournit. Les propres déclarations d’un module sont vérifiées une fois construite la composition qui l’importe, et le constat nomme l’Aggregate du module et la clé à l’intérieur de son document.

Le bloc uses: propre à un composant n’est délibérément pas l’une de ces surfaces, si bien que cet arrêt ne se déclenche pas pour lui. Un développeur possède la topologie que l’Aggregate déclare et peut nommer un socket que le catalogue n’a pas déclaré ; le silence du catalogue sur un socket signifie que la connexion n’a pas été anticipée, et non qu’elle est interdite. Un tel socket est légal et son arête est construite — ce à quoi il renonce, ce sont le sélecteur et le contrat par arête qu’apporte un socket déclaré. Un nom de socket mal orthographié à cet endroit n’est donc pas un arrêt mais une connexion ad hoc à part entière, et il est signalé par un avertissement nommant les deux graphies — voir warnings.md « Uses-socket near-miss lint (Lint de quasi-correspondance des sockets uses) ».

Message émis :

unknown uses socket: name a socket the entity declares in its usesSchema — only a component’s own uses block may name one the catalog did not declare (Release <release-name>, at .spec.components.<component>, "<component-type>", "<socket-name>", "<declared-sockets>") (socket uses inconnu : nommez un socket que l’entité déclare dans son usesSchema — seul le propre bloc uses d’un composant peut en nommer un que le catalogue n’a pas déclaré ; avec la Release, l’entrée du composant, le type de composant, le nom du socket et les sockets déclarés)

La branche des rattachements nomme le type de fonctionnalité à la place du type de composant ; une Feature rattachée qui ne déclare aucun usesSchema signale à la place que les déclarations uses: ne sont pas autorisées pour elle.

Comment corriger : sur un rattachement, corrigez le nom du socket en l’un de ceux que la Feature rattachée déclare, ou déclarez ce socket dans le usesSchema de la Feature. Sur une entrée par arête d’une Release, corrigez le nom du socket en l’un de ceux que le Component consommateur déclare — une Release ne peut pas introduire un socket que le Component ne déclare pas, et déplacer la déclaration dans l’entité de catalogue est la voie prise en charge. Si l’entité de catalogue ne déclare aucun usesSchema, elle n’accepte aucune déclaration uses: sur cette surface — supprimez le bloc.

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)

Le bloc features: d’une entrée de connexion nomme un rattachement qu’aucun emplacement du socket de la connexion ne déclare. Les rattachements qu’une connexion porte forment un ensemble fermé : le socket par lequel la connexion est câblée déclare, dans un featuresSchema sur l’entrée du usesSchema du Component consommateur, chaque emplacement qu’une connexion sur ce socket peut remplir, et un rattachement sous tout autre nom est refusé au chargement de la build. Un socket qui ne déclare aucun featuresSchema n’admet aucun rattachement sur ses connexions, pas plus qu’un socket que l’Aggregate nomme sans que le Component le déclare — un tel socket ne déclare aucun emplacement.

La règle s’applique aux deux documents qui écrivent les rattachements d’une connexion : l’entrée de connexion de l’Aggregate sous le uses: d’un composant, et l’entrée uses: par arête de la Release. Pour un composant qu’un sous-agrégat fournit, les noms du développeur sont vérifiés une fois lu le propre document du sous-agrégat, et le constat nomme le fichier de ce document et l’entrée du composant qu’il contient. Les noms de la Release sont vérifiés une fois la composition aplatie, pour chaque composant visé par la Release, et le constat nomme l’entrée propre de la Release — à l’intérieur de la frontière où elle se trouve, ou sous l’entrée de routage qui atteint le composant d’un sous-agrégat. Une entrée de Release sur un socket que le Component ne déclare pas est signalée par l’arrêt pour socket non déclaré ci-dessus, qui liste les sockets qui existent réellement, plutôt que par celui-ci.

Message émis. Le refus vient d’abord, puis le document et l’entrée, le nom du rattachement, la connexion, le socket, le composant et les emplacements que le socket déclare — puis ce qu’il faut faire :

a connection carries an attachment under a name its socket declares no slot for (Aggregate <aggregate-name>, at .spec.components.<component>.uses.<socket>.<alias>, "<attachment>", on the connection "<alias>", through socket "<socket>", of component "<component>", the socket declaring the slots "<slots>"). Write the attachment under one of the slots the socket declares, or declare this slot in the socket’s featuresSchema on the Component. (une connexion porte un rattachement sous un nom pour lequel son socket ne déclare aucun emplacement : l’Aggregate, l’entrée, le rattachement, la connexion, le socket et le composant indiqués, avec les emplacements que le socket déclare. Écrivez le rattachement sous l’un des emplacements que le socket déclare, ou déclarez cet emplacement dans le featuresSchema du socket sur le Component.)

Lorsque le nom est à une modification près d’un emplacement que le socket déclare — un caractère interverti, omis, doublé ou erroné, la structure que prend une faute de frappe —, cet emplacement est nommé juste après lui, de sorte que la graphie probablement voulue figure dans la même phrase :

a connection carries an attachment under a name its socket declares no slot for (Release <release-name>, at .spec.boundaries.<boundary>.components.<component>.uses.<socket>.<alias>, "credentail", near the declared slot "credential", on the connection "<alias>", …) (une connexion porte un rattachement sous un nom pour lequel son socket ne déclare aucun emplacement : la Release et l’entrée indiquées, le nom du rattachement près de l’emplacement déclaré, la connexion indiquée, …)

Aucun avertissement distinct n’est levé pour un tel nom. Sur le propre bloc features: d’un composant, un nom à une modification près d’un emplacement déclaré est légal et ne donne lieu qu’à l’avertissement décrit sous « An attachment name is one edit from a declared slot (Un nom de rattachement est à une modification près d’un emplacement déclaré) » ci-dessous ; sur une connexion, le nom est refusé, et le refus porte lui-même l’appariement.

Lorsque le socket ne déclare aucun emplacement, la liste est absente et la recommandation se lit « The socket declares no slots, so no connection wired through it carries an attachment: remove the attachment, or declare the slot in the socket’s featuresSchema on the Component. (Le socket ne déclare aucun emplacement, donc aucune connexion câblée par son intermédiaire ne porte de rattachement : supprimez le rattachement, ou déclarez l’emplacement dans le featuresSchema du socket sur le Component.) » Lorsque le Component ne déclare pas du tout le socket, elle se lit « The component’s type does not declare this socket, so the socket declares no slots and no connection wired through it carries an attachment: remove the attachment, or declare the socket and its slot in the Component’s usesSchema. (Le type du composant ne déclare pas ce socket, donc le socket ne déclare aucun emplacement et aucune connexion câblée par son intermédiaire ne porte de rattachement : supprimez le rattachement, ou déclarez le socket et son emplacement dans le usesSchema du Component.) »

Chaque rattachement fautif est signalé comme un constat distinct, de sorte qu’une seule build les nomme tous.

Comment corriger : écrivez le rattachement sous un emplacement que le socket déclare ; ou, si la connexion a besoin d’un emplacement que le socket n’a pas, déclarez-le dans le featuresSchema du socket sur le Component. Sur un socket que le Component ne déclare pas, déclarez le socket et son emplacement dans le usesSchema du Component, ou supprimez le rattachement.

Release retargets a developer-declared edge (La Release recible une arête déclarée par le développeur)

Une entrée uses: par arête d’une Release nomme une cible différente de celle que le développeur a déjà câblée pour le même socket et le même alias. Une Release peut configurer une arête déclarée par le développeur (définir infra par arête, en nommant la même cible ou en l’omettant) et peut câbler une arête dans un socket déclaré mais non lié, mais elle ne peut pas recibler une arête déclarée par le développeur — le développeur possède l’architecture qu’il a rédigée.

Les deux cibles sont comparées telles qu’elles ont été écrites, et non telles qu’elles se résolvent. Un target: peut nommer l’alias publié d’un sous-agrégat plutôt qu’un id de composant, et cet alias se résout vers le composant pour lequel le module le publie — une entrée de Release qui répète exactement l’alias écrit par le développeur est donc une configuration et est acceptée, tout comme l’est la répétition d’un simple id de composant.

L’arête conserve la cible que le développeur lui a donnée, que cet arrêt se déclenche ou non, et le bloc infra: de l’entrée de Release ne lui est pas appliqué. Un reciblage refusé n’est jamais appliqué à moitié.

Message émis. Le refus vient d’abord, puis la cible que le développeur a déclarée, la cible que la Release a nommée et le socket — puis ce qu’il faut faire :

release edge retargets a developer-declared edge (declared target "<declared-target>", target the Release names "<release-target>", wired into socket "<socket>"). Drop the target from the Release entry to configure the connection as it was declared, or change the target where the connection is declared. (l’arête de la Release recible une arête déclarée par le développeur : la cible déclarée, la cible que la Release nomme et le socket dans lequel elle est câblée, tels qu’indiqués. Retirez la cible de l’entrée de la Release pour configurer la connexion telle qu’elle a été déclarée, ou changez la cible là où la connexion est déclarée.)

Le constat est positionné sur l’entrée rédigée dans laquelle la connexion a été déclarée, dans le document qui l’a déclarée. Chaque entrée fautive est signalée comme un constat distinct, de sorte qu’une seule build les nomme toutes au lieu d’une par exécution.

Comment corriger : retirez le target divergent de l’entrée uses: de la Release pour configurer l’arête existante (infra par arête uniquement), ou, si la connexion appartient réellement à un autre socket, câblez-la par un socket que le développeur a laissé non lié. Pour changer la cible elle-même, changez-la dans l’Aggregate, là où la topologie est rédigée.

Release per-edge configuration has no edge to apply to (La configuration par arête de la Release n’a aucune arête à laquelle s’appliquer)

Une entrée uses: par arête d’une Release définit infra:, des rattachements sous features:, ou les deux, mais aucune arête n’existe au consommateur, au socket et à l’alias qu’elle nomme, une fois toutes les arêtes de la build tracées.

Les deux choses qu’une entrée de Release peut faire sont câbler une arête et en configurer une, et ce qu’elle fait dépend de ce qu’elle nomme ou non un target:. Une entrée avec une cible crée l’arête qu’elle configure. Une entrée sans cible configure une arête qui doit déjà exister — déclarée par le développeur dans l’Aggregate, ou apportée par une Feature rattachée. Une entrée qui ne nomme aucune cible et ne correspond à aucune arête existante ne s’applique donc à rien : le bloc infra: et les rattachements qui se trouvent dessous n’atteignent jamais aucune sortie. La build s’arrête plutôt que d’accepter une rédaction qui ne fait rien, car une build réussie se lirait sinon comme la confirmation que l’infrastructure a été appliquée et que la connexion porte ce que l’entrée y a mis.

L’alias fait partie de ce qu’une entrée nomme, de sorte qu’une entrée configurant un alias que le développeur n’a jamais déclaré n’atteint aucune arête, même lorsque le socket est lié sous un autre alias. Il en va de même d’une entrée nommant un composant que l’Aggregate ne déclare pas.

Deux conditions voisines sont signalées par leurs propres arrêts plutôt que par celui-ci, car chacune a davantage à vous dire. Un socket que le usesSchema du Component consommateur ne déclare pas est signalé comme socket non déclaré, ce qui permet de lister les sockets qui existent réellement. Un target: ne nommant aucun composant est signalé comme cible pendante. Un composant désactivé par un interrupteur active: emporte ses arêtes avec lui, par conception, de sorte qu’une entrée laissée sur lui est acceptée plutôt qu’arrêtée.

Chaque entrée fautive est signalée. Une Release comportant plusieurs entrées qui n’atteignent aucune arête s’arrête avec un de ces messages par entrée en une seule build, dans l’ordre où le document les déclare, au lieu de signaler la première et de laisser les autres à la build suivante.

Message émis, lorsque l’entrée nomme un composant qui existe. Il porte le chemin de l’entrée elle-même, de sorte que c’est la ligne à modifier qui est nommée plutôt que le composant qui la contient :

release per-edge configuration has no edge to apply to (Release <release-name>, at .spec.boundaries.<boundary>.components.<consumer>.uses.<socket>.<alias>, "<consumer>", on socket "<socket>", under alias "<alias>"). Give the entry a target to wire the edge, or remove it: an entry with no target configures an edge that must already exist. (la configuration par arête de la Release n’a aucune arête à laquelle s’appliquer : la Release, l’entrée, le consommateur, le socket et l’alias indiqués. Donnez une cible à l’entrée pour câbler l’arête, ou supprimez-la : une entrée sans cible configure une arête qui doit déjà exister.)

Une Release qui nomme ses composants au niveau supérieur plutôt que sous des frontières porte la structure que son auteur a écrite — .spec.components.<consumer>.uses.<socket>.<alias> — et un composant nommé à l’intérieur d’une entrée de routage aggregates: est nommé à travers cette entrée, sous le nom local qu’il y porte.

Lorsque l’entrée nomme un composant que l’Aggregate ne déclare pas, l’arrêt provient d’une étape antérieure de la build et se lit ainsi, en nommant ce que l’entrée définit — infra, features ou infra and features :

release per-edge configuration has no edge to apply to: release edge <consumer>/<socket>/<alias> sets <infra|features|infra and features> on <consumer>, which is not a component in the topology (la configuration par arête de la Release n’a aucune arête à laquelle s’appliquer : l’arête de la Release indiquée définit les blocs indiqués sur le consommateur indiqué, qui n’est pas un composant de la topologie)

Comment corriger : ajoutez un target: à l’entrée, ce qui câble l’arête et lui applique la configuration ; corrigez l’alias en celui que l’Aggregate a déclaré pour cette connexion, de sorte que l’entrée configure l’arête existante ; corrigez le nom du composant en un nom que l’Aggregate déclare ; ou supprimez l’entrée si la configuration n’est plus souhaitée.

A Release attachment takes the name of a connection’s attachment (Un rattachement de la Release prend le nom du rattachement d’une connexion)

Une Release écrit un rattachement sous le nom que prend un rattachement sur l’une des connexions d’un composant : l’alias de la connexion, un point et l’emplacement que le rattachement remplit — gpt.credential pour le rattachement remplissant l’emplacement credential sur la connexion gpt. Le rattachement d’une connexion s’écrit sur son entrée de connexion — la connexion de l’Aggregate sous le uses: du composant, ou l’entrée uses: par arête de la Release pour la même connexion — et devient un rattachement du composant consommateur sous ce nom composé. La Release écrit des rattachements à deux autres portées dont les clés peuvent contenir un point, de sorte que le nom composé peut y être écrit aussi :

  • Le propre bloc features: d’une entrée de composant, qui se rattache à ce composant.
  • Le propre bloc features: d’une frontière, qui se rattache à chaque composant placé dans cette frontière ou dans une frontière imbriquée en son sein — y compris les composants d’un sous-agrégat que la frontière intègre par routage sans les nommer. Une clé à cet endroit s’arrête lorsqu’elle est égale au nom composé sur l’un quelconque des composants qu’elle atteint, qu’elle nomme ou non un type:.

La build s’arrête plutôt que de fondre l’un ou l’autre dans le rattachement de la connexion, car aucun des deux documents ne montrerait alors l’intégralité de ce que la build en fait. L’emplacement d’un socket est rempli par connexion, par l’entrée propre de la connexion, et jamais par un rattachement qui y descend en cascade depuis une portée plus large. Une clé à point que ne prend aucun rattachement de connexion des composants qu’elle atteint est un nom de rattachement ordinaire, et n’est pas refusée.

La vérification couvre un rattachement que l’un ou l’autre document a placé sur la connexion, ainsi qu’un composant qu’un sous-agrégat apporte comme un composant que l’Aggregate déclare.

Message émis, pour une clé sur une entrée de composant. Le refus vient d’abord, puis la Release et l’entrée de composant, la clé que la Release a écrite, le composant, la connexion, le socket et l’emplacement — puis l’entrée de connexion sur laquelle l’écrire :

a Release attachment takes the name of an attachment one of a component’s connections carries (Release <release-name>, at .spec.components.<component>, "<alias>.<slot>", of component "<component>", on the connection "<alias>", through socket "<socket>", in the slot "<slot>"). Write it on the connection entry, under uses.<socket>.<alias>.features.<slot>, and remove "<alias>.<slot>" from this entry’s features: an attachment a connection carries is written on that connection and nowhere else. (un rattachement de la Release prend le nom d’un rattachement que porte l’une des connexions d’un composant : la Release, l’entrée de composant, la clé, le composant, la connexion, le socket et l’emplacement indiqués. Écrivez-le sur l’entrée de connexion, sous le chemin indiqué, et retirez la clé des features de cette entrée : un rattachement que porte une connexion s’écrit sur cette connexion et nulle part ailleurs.)

Message émis, pour une clé sur une frontière. Il nomme le bloc de rattachements de la frontière et le composant dont la connexion porte le rattachement :

a Release attachment takes the name of an attachment one of a component’s connections carries (Release <release-name>, at .spec.boundaries.<boundary>.features, "<alias>.<slot>", of component "<component>", on the connection "<alias>", through socket "<socket>", in the slot "<slot>"). Write it on component "<component>"’s connection entry, under uses.<socket>.<alias>.features.<slot>, and remove "<alias>.<slot>" from this boundary’s features: an attachment a connection carries is written on that connection and nowhere else. (un rattachement de la Release prend le nom d’un rattachement que porte l’une des connexions d’un composant : la Release, le bloc de rattachements de la frontière, la clé, le composant, la connexion, le socket et l’emplacement indiqués. Écrivez-le sur l’entrée de connexion du composant indiqué, sous le chemin indiqué, et retirez la clé des features de cette frontière : un rattachement que porte une connexion s’écrit sur cette connexion et nulle part ailleurs.)

Une clé sur une frontière qui atteint plusieurs composants dont les connexions portent le nom composé est signalée une fois pour chacun d’eux, car chaque connexion est une modification distincte.

Le constat est positionné sur le bloc dans lequel la clé a été écrite — l’entrée de composant, ou le features: de la frontière — car la clé elle-même contient un point et une position ne peut pas adresser une telle clé ; la clé est nommée dans le message à la place. Dans une Release qui nomme des frontières, une entrée de composant se lit .spec.boundaries.<boundary>.components.<component>, un composant nommé à l’intérieur d’une entrée de routage aggregates: est nommé à travers cette entrée, sous le nom local qu’il y porte, et le bloc d’une frontière imbriquée se lit .spec.boundaries.<outer>.boundaries.<inner>.features.

Comment corriger : déplacez le rattachement sur l’entrée de la Release pour cette connexion — uses.<socket>.<alias>.features.<slot> sous le composant — en n’y écrivant que infra: pour dimensionner un rattachement que l’Aggregate déclare, ou type: et infra: pour un rattachement que seule la Release crée ; puis retirez la clé à point du features: du composant ou de la frontière. Une clé valable pour toute la frontière et destinée aux connexions de plusieurs composants s’écrit une fois sur chacune de ces connexions.

A Release connection attachment names no Feature type (Un rattachement de connexion de la Release ne nomme aucun type de Feature)

Une entrée uses: par arête d’une Release place un rattachement sur une connexion, sous un emplacement pour lequel l’Aggregate ne déclare aucun rattachement sur cette connexion, et ne nomme aucun type:. Un rattachement qu’une Release écrit sur une connexion est l’une de deux choses. Soit il dimensionne un rattachement que l’Aggregate déclare déjà sur la même connexion, et ne nomme aucun type parce que la déclaration de l’Aggregate le nomme ; soit c’est un rattachement que seule la Release crée, et l’entrée de la Release est alors le seul endroit d’où son type de Feature peut provenir. Sans type, rien ne peut choisir une FeatureRecipe pour le rattachement.

La vérification couvre un composant qu’un sous-agrégat apporte comme un composant que l’Aggregate déclare. Un composant qu’un interrupteur active: a désactivé emporte ses connexions avec lui, de sorte qu’une entrée laissée sur lui n’est pas vérifiée.

Message émis. Le refus vient d’abord, puis la Release et l’entrée de connexion, l’emplacement, la connexion, le socket et le composant — puis ce qu’il faut faire :

a Release connection attachment names no Feature type, and the type is required for an attachment only the Release makes (Release <release-name>, at .spec.components.<component>.uses.<socket>.<alias>, "<slot>", on the connection "<alias>", through socket "<socket>", of component "<component>"). Name the Feature this attachment attaches under its type, or declare the attachment on the Aggregate’s connection entry and size it here. (un rattachement de connexion de la Release ne nomme aucun type de Feature, et le type est requis pour un rattachement que seule la Release crée : la Release, l’entrée de connexion, l’emplacement, la connexion, le socket et le composant indiqués. Nommez, par son type, la Feature que ce rattachement rattache, ou déclarez le rattachement sur l’entrée de connexion de l’Aggregate et dimensionnez-le ici.)

Chaque rattachement fautif est signalé comme un constat distinct, de sorte qu’une seule build les nomme tous.

Comment corriger : ajoutez un type: nommant la Feature que le rattachement rattache ; ou, lorsqu’il revient au développeur de déclarer le rattachement, déclarez-le sur l’entrée de connexion de l’Aggregate avec ses values: et ne gardez que infra: sur l’entrée de la Release.

Component identity cannot be stamped on what it emits (L’identité du Component ne peut pas être estampillée sur ce qu’il émet)

L’identité d’un composant n’est pas seulement une clé dans votre Aggregate — c’est un nom à l’intérieur du cluster. Chaque ressource qu’un composant émet est estampillée avec elle, sous aggrega.ai/component-id et app.kubernetes.io/name, et les synthétiseurs de charges de travail nomment d’après elle ce qu’ils émettent. L’identité doit donc être un nom que la cible acceptera, et un nom qui signifie ce qu’il dit.

Un nom que vous avez écrit atteint sa sortie exactement tel que vous l’avez écrit, et c’est ce qui fait du nom dans votre Aggregate le nom que vous pouvez rechercher dans votre cluster. Cela vaut la peine, et c’est pourquoi une identité que la cible refuserait est signalée ici plutôt que réparée sans bruit en quelque chose que vous n’avez jamais écrit.

Un caractère fait exception, et c’est un caractère que vous ne pouvez pas écrire : le point qui joint le nom d’un module au nom d’un composant qu’il contient. Il est exclu de tout nom que vous rédigez précisément pour que cette jonction soit sans ambiguïté, et il est retiré de l’identité avant qu’elle ne soit estampillée — data-layer.main-db est estampillé sous la forme data-layer-zdmain-db. Cela ne coûte aucun nom que quiconque a tapé, et c’est ce qui permet tout simplement d’estampiller un composant qu’apporte un Aggregate importé : un point n’est pas un caractère qu’un nom de Service accepte, et dans une adresse de cluster il sépare un service de son namespace, de sorte qu’un nom à point transmis à un consommateur comme hôte se résoudrait en un autre service au lieu d’échouer.

Deux structures sont refusées.

Une identité que l’alphabet d’estampillage ne peut pas porter. L’identité est écrite dans la valeur de label que porte chaque ressource émise, et cet alphabet admet les lettres, les chiffres, -, _ et ., et exige que la valeur commence et se termine par une lettre ou un chiffre. Les règles des noms rédigés en sont proches mais pas identiques — elles permettent à un nom de commencer ou de se terminer par - ou _ — si bien que _api et api- sont tous deux des noms que vous pouvez écrire et qu’aucun des deux ne peut être estampillé.

La longueur que peut avoir un nom n’est pas demandée ici. Elle relève de la cible sur laquelle un composant est déployé, et des cibles différentes répondent différemment : cette condition couvre les structures qu’aucune cible ne pourrait porter. Un nom refusé pour sa longueur est signalé à la place par le propre refus de la cible, qui porte la raison de cette cible et la longueur qu’elle accepterait.

Une identité qui commence comme commence une identité composée. Les ressources qu’une Feature émet ne peuvent pas être estampillées avec un nom de composant que vous avez écrit, si bien qu’Aggrega compose pour elles une identité à partir des parties que vous avez écrites, derrière un préfixe fixe qui indique où la Feature a été rattachée. Lorsque la Feature est rattachée à un composant unique, l’identité est composée à partir de ce composant et de la clé sous laquelle la Feature est rattachée, et elle commence par cfr--. Lorsqu’elle est rattachée à une frontière entière, le nom d’aucun composant ne s’applique, si bien que l’identité est composée à partir du chemin de la frontière et du nom sous lequel la Feature est rattachée, et elle commence par bfr--. C’est le préfixe qui indique au lecteur duquel des deux provient une ressource, plutôt que d’un composant. bfr-- et cfr-- sont donc tous deux réservés au début d’une identité de composant. Un composant nommé bfr--api ou cfr--api serait estampillé de façon identique à une identité composée, et rien dans la sortie émise ne permettrait de distinguer les deux. Seul le préfixe complet est réservé : un composant nommé bfr, cfr, bfr-api ou bfrontend porte un nom ordinaire et la build réussit.

La vérification lit l’identité que porte effectivement un composant, qui, pour un composant apporté par un Aggregate importé, est l’identité qualifiée — le nom du module, un point et le nom propre du composant. Deux noms acceptables chacun séparément peuvent donc tout de même se joindre en une identité qui ne l’est pas : un module nommé bfr--x et un composant nommé y qu’il contient se joignent en bfr--x.y, qui commence comme commence une identité composée. L’arrêt nomme l’identité jointe tout en pointant vers la clé que vous avez écrite.

Message émis, pour une identité que la cible refuserait :

component identity cannot be the name its emitted resources are stamped with: rename the component (Aggregate, at <field-path>, "<identity>", which must "<rule>") (l’identité du composant ne peut pas être le nom estampillé sur les ressources qu’il émet : renommez le composant ; avec l’Aggregate, le chemin du champ et l’identité indiqués, et la règle que celle-ci doit respecter)

et pour une identité qui commence comme commence une identité composée, où <opening> est celui des préfixes réservés auquel le nom correspond :

component identity cannot be the name its emitted resources are stamped with: rename the component (Aggregate, at <field-path>, "<identity>", which must not open with the reserved "<opening>") (l’identité du composant ne peut pas être le nom estampillé sur les ressources qu’il émet : renommez le composant ; avec l’Aggregate, le chemin du champ et l’identité indiqués, qui ne doit pas commencer par le préfixe réservé indiqué)

Comment corriger : renommez le composant, sur chaque surface qui le nomme — l’Aggregate qui le déclare et la Release qui le place et le configure. Donnez-lui un nom qui commence et se termine par une lettre ou un chiffre et qui ne commence ni par bfr-- ni par cfr--. Renommer un composant change le nom que ses ressources portent dans le cluster ; sur une application déjà déployée, traitez-le donc comme tout autre renommage de ressource.

The target will not accept a name derived from an authored identity (La cible n’accepte pas un nom dérivé d’une identité rédigée)

Chaque cible dérive ses propres noms de l’identité d’un composant : un installateur de charts dérive un nom de release, un orchestrateur de conteneurs dérive des noms de service. Cet arrêt est cette cible qui indique qu’elle ne peut pas utiliser l’un d’eux.

Aggrega ne détient les règles de nommage d’aucune cible. Il ne sait pas quelle longueur un nom peut avoir, quels caractères une cible admet, ni ce que la grammaire d’une cible exige au début d’un nom — et il ne le sait délibérément pas, parce que cela varie selon la cible, selon le type de ressource sur lequel un nom aboutit, et parfois selon un service au sein d’un même fournisseur. Ainsi, avant qu’un nom ne soit arrêté, le compilateur interroge le fournisseur qui rendra le composant, et cet arrêt rapporte la réponse du fournisseur. C’est pourquoi le message porte le mot propre de la cible pour ce qui a refusé (release name, Service name) et la raison propre de la cible, plutôt qu’une règle écrite dans le compilateur.

Pourquoi le nom est refusé plutôt que raccourci. Un nom que vous avez écrit est le nom sous lequel votre charge de travail est déployée : le raccourcir renommerait chaque ressource dans chaque sortie existante, et le ferait en votre nom sans que vous l’ayez demandé. La personne qui peut choisir un autre nom est celle qui a écrit celui-ci, de sorte que l’arrêt pointe vers la clé spec.components que vous avez écrite et laisse le nom tel quel. Les noms qu’Aggrega compose lui-même — l’identité d’une Feature rattachée à une frontière entière, par exemple — sont en revanche raccourcis, parce qu’ils sont assemblés à partir de parties écrites dans plusieurs documents et qu’aucun auteur ne peut à lui seul voir la longueur qu’ils atteignent.

Deux réponses qu’une cible peut donner, et elles mènent à des endroits différents. Lorsqu’un nom plus court serait accepté, l’arrêt indique la longueur qui conviendrait, de sorte qu’un nouveau nom est choisi une fois plutôt que deux. Lorsqu’aucune longueur n’aiderait — un caractère que la grammaire de la cible refuse à la position où il a abouti —, aucune longueur n’est indiquée, car raccourcir ne peut pas l’atteindre. Le cas le plus courant du second type : une cible dont les noms sont en minuscules uniquement échappe chaque caractère qu’elle n’admet pas, et chaque échappement commence par un trait d’union, si bien qu’un nom dont le premier caractère est échappé produit un nom commençant par un trait d’union. Une cible qui exige une lettre minuscule ou un chiffre à cet endroit le refuse, si court que soit le reste. Une cible peut aussi soumettre le début d’un nom à la règle plus stricte des ressources nommées d’après lui : la cible helm refuse un nom commençant par un chiffre, signalé comme Service name, parce que Helm accepte un tel nom de release alors que le cluster refuse un Service Kubernetes nommé d’après lui.

Une troisième forme n’apparaît que pour un nom composé : une cible peut indiquer une longueur inférieure à l’identité la plus courte que le compilateur peut composer à partir des parties qui lui ont été données, puisqu’une identité composée réserve de la place pour un discriminant. L’arrêt le dit et nomme le remède — raccourcir les parties rédigées — plutôt que de signaler le fournisseur comme défaillant.

Certains noms n’existent que pour la charge de travail qu’un composant rend. Le provider est interrogé une fois le Workload de ce composant résolu, et la question porte le form du Workload et ses clés Service, de sorte qu’une cible puisse aussi juger les noms qu’elle en construit. Avec la cible helm, cela en ajoute deux : un CronJob name, de 52 caractères au plus et jugé seulement pour un Workload scheduled, car le cluster nomme le Job de chaque exécution d’après le CronJob en y ajoutant un suffixe ; et chaque Service name, <release name>-<service key>, de 63 caractères au plus. Un nom de Service est construit à partir des parties de deux auteurs — le nom de votre composant et la clé que la charge de travail déclare, dans la Recipe ou dans une FeatureRecipe —, si bien que sa raison nomme la clé et l’endroit où la charge de travail la déclare, spec.workload.services.<key>, à côté du champ que vous avez écrit. Une clé assez longue pour ne laisser de place à aucun nom de composant n’indique aucune longueur dans laquelle choisir, et la raison dit que c’est la clé qui doit être plus courte. Ces noms ne sont pas jugés pour une Feature rattachée à toute une boundary : son identité est fixée avant que son Workload soit résolu, car l’endroit où sa sortie est assemblée peut en dépendre.

Message émis, pour une identité rédigée :

the target will not accept a name derived from this component’s authored identity: rename the component (component "<identity>", written at <field-path>, which the target cannot use as a <name-kind>, <the target's reason>). choose a name of at most <n> characters that the target accepts (la cible n’accepte pas un nom dérivé de l’identité rédigée de ce composant : renommez le composant (le composant indiqué, écrit au chemin indiqué, que la cible ne peut pas utiliser comme le type de nom indiqué, avec la raison de la cible). choisissez un nom que la cible accepte, d’au plus le nombre de caractères indiqué)

Comment corriger : renommez le composant en un nom que la cible accepte, sur chaque surface qui le nomme — l’Aggregate qui le déclare et la Release qui le place et le configure. Lorsque le message indique une longueur, restez dans cette limite. Lorsqu’il n’en indique pas, lisez la raison de la cible : il s’agit généralement d’un caractère que la cible n’admet pas, et le plus souvent d’une lettre majuscule au début du nom — ou, avec la cible helm, d’un chiffre à cet endroit. Préférez des lettres minuscules et des chiffres, avec des traits d’union entre les mots ; le chapitre sur le nommage explique ce que coûte un nom avec chaque type de cible. Lorsque la raison nomme une clé Service, la longueur peut aussi être regagnée en raccourcissant cette clé là où la charge de travail la déclare — et lorsque la raison dit que la clé ne laisse aucune place, seule cette solution fonctionne. Renommer un composant change le nom que portent ses ressources ; sur une application déjà déployée, traitez-le donc comme tout autre renommage de ressource.

Lorsque l’identité est une identité que le compilateur a composée plutôt qu’une que vous avez écrite, le même arrêt rapporte la valeur composée et vous demande de raccourcir les parties à partir desquelles elle a été construite — le nom sous lequel vous avez rattaché une Feature et le chemin de la frontière à laquelle vous l’avez rattachée.

A provider never accepted a name the compiler composed (Un fournisseur n’a jamais accepté un nom composé par le compilateur)

Celui-ci signale un défaut dans un plugin, et non dans quoi que ce soit que vous avez écrit.

Arrêter un nom composé est un échange : le compilateur propose une identité, le fournisseur l’accepte ou indique quelle longueur elle ne devrait pas dépasser, le compilateur en compose une plus courte, et le fournisseur est interrogé à nouveau. Un second refus est normal et attendu — raccourcir à une longueur peut faire aboutir un caractère là où la grammaire de cette cible ne l’admet pas, et le fait que le fournisseur le dise est la manière dont un compilateur qui ne connaît la grammaire d’aucune cible et un fournisseur qui la connaît parviennent à un accord.

Ce qui n’est pas normal, c’est un fournisseur qui n’accepte jamais rien : un fournisseur qui indique une longueur, reçoit un nom de cette longueur et le refuse à nouveau. L’échange est borné, et lorsque la borne est atteinte, la build s’arrête et nomme le fournisseur plutôt que d’utiliser un nom auquel le fournisseur n’a jamais consenti. Un nom arrêté par abandon serait apposé sur de vraies ressources sans que rien dans la sortie n’enregistre qu’aucun accord n’a été trouvé, et la conséquence ferait surface au moment de l’application plutôt que dans la build qui l’a produit.

Message émis :

provider guest never accepted a component identity the compiler composed for it (provider guest "<provider>", refused <n> proposals, the last of them "<identity>"). report the defect to whoever maintains that provider plugin (le guest fournisseur n’a jamais accepté une identité de composant que le compilateur a composée pour lui (le guest fournisseur indiqué a refusé le nombre de propositions indiqué, la dernière étant l’identité indiquée). signalez le défaut à la personne qui maintient ce plugin fournisseur)

Comment corriger : signalez-le à la personne qui maintient le plugin fournisseur nommé, en citant la dernière proposition du message. Aucune modification de rédaction ne permet de le contourner : le compilateur a déjà proposé chaque longueur que le fournisseur a demandée. Si le fournisseur est l’un de ceux que vous maintenez, la vérification à faire est qu’un nom coupé à une borne qu’il indique est un nom qu’il accepte ensuite.

Required uses: socket not populated (Socket requis non renseigné)

Un Component déclare dans son usesSchema un socket marqué required: true, et rien dans la build ne câble de connexion sur ce socket pour l’une des instances de ce Component.

Trois surfaces peuvent le câbler, et l’arrêt ne se déclenche que lorsque les trois sont vides. Le propre bloc uses: de l’instance dans l’Aggregate ; une entrée uses: par arête d’une Release qui nomme un target:, laquelle crée la connexion dans un socket déclaré mais non lié ; et l’ensemble de connexions que la composition a produit, qui est ce qui répond pour un composant fourni par un Aggregate importé — le bloc uses: d’un tel composant se trouve dans le propre document de cet Aggregate, lu seulement une fois la composition assemblée. Comme la troisième surface est la dernière à être complète, la vérification s’exécute une fois que la composition entière existe plutôt que pendant la lecture des deux documents rédigés, et elle pose la même question à chaque composant, quel que soit le document qui l’a déclaré.

Deux structures qui semblent devoir renseigner le socket ne le font pas. Une entrée de Release qui ne nomme aucun target: configure une connexion qui doit déjà exister plutôt que d’en créer une, et ne câble donc rien (et, lorsqu’elle porte infra:, est signalée par son propre arrêt ci-dessus). Et le uses: d’un rattachement de Feature nomme des sockets déclarés sur la Feature rattachée, un ensemble de sockets distinct sur une entité distincte, de sorte qu’un rattachement ne peut jamais renseigner un socket propre à un Component.

Message émis :

required uses socket not populated (Component, at .spec.components.<instance>.uses.<socket>, "<socket-name>", declared required by component type "<component-type>") (socket uses requis non renseigné (Component, au chemin du socket, avec le nom du socket, déclaré requis par le type de composant indiqué))

Le constat est positionné sur l’entrée de socket que l’auteur doit écrire, .spec.components.<instance>.uses.<socket>. Le nom d’instance qu’elle contient est le nom que le composant porte dans le document qui le déclare, de sorte que, pour un composant fourni par un Aggregate importé, le localisateur nomme une clé que contient le propre fichier de cet Aggregate plutôt que le nom préfixé que la composition lui a donné.

Chaque socket requis non renseigné est signalé, sur chaque composant : une seule build vous les signale tous plutôt que le premier seulement.

Comment corriger : ajoutez une entrée uses: pour le socket requis, en la câblant vers une cible que le selector: du socket accepte ; ou câblez-le depuis la Release avec une entrée qui nomme un target:. Si le socket ne doit plus être requis, mettez à jour le usesSchema du Component pour définir required: false, ou supprimez la déclaration required.

Sub-aggregate nesting depth exceeded (Profondeur d’imbrication des sous-agrégats dépassée)

Une chaîne d’importations de sous-agrégats dépasse la profondeur d’imbrication maximale du compilateur. La limite empêche un aplatissement incontrôlé de topologies profondément imbriquées et impose une décomposition architecturale au-delà d’un seuil.

Message émis :

max sub-aggregate nesting depth exceeded: depth <depth> at prefix <flattened-prefix>. (profondeur d’imbrication maximale des sous-agrégats dépassée : la profondeur indiquée au préfixe aplati indiqué.)

Comment corriger : restructurez la topologie de l’agrégat pour réduire l’imbrication. Une imbrication aussi profonde indique généralement que la forme de l’Aggregate reflète la hiérarchie organisationnelle plutôt que la topologie de déploiement — envisagez d’aplatir des groupes de sous-agrégats en sous-systèmes de même niveau au sein d’un seul Aggregate parent.

Feature type mismatch between Aggregate and Release (Non-concordance du type de Feature entre Aggregate et Release)

L’Aggregate et la Release rattachent tous deux une fonctionnalité avec le même nom d’instance, mais chacun déclare un type: différent, et le rattachement de la Release atteint le composant depuis les features: d’une frontière. Lorsque la Release l’écrit plutôt sur sa propre entrée pour le composant, le même conflit est refusé plus tôt et signalé comme E0153, sous « A feature attached by both the Aggregate and the Release cannot be merged (Une fonctionnalité rattachée à la fois par l’Aggregate et par la Release ne peut pas être fusionnée) » ci-dessus.

Message émis :

feature type mismatch between Aggregate and Release (node <node-id>, attachment <instance-name>, existing type <type-in-aggregate> conflicts with <type-in-release>) (non-concordance du type de fonctionnalité entre Aggregate et Release (le nœud et le rattachement indiqués, le type existant dans l’Aggregate est en conflit avec le type dans la Release))

Comment corriger : soit supprimez le type: de la Release (elle en héritera de l’Aggregate), soit modifiez l’un des deux côtés pour que les deux déclarent le même type. La Release peut omettre type: ou répéter le type de l’Aggregate, mais elle ne peut pas en substituer un autre.

Cyclic extends on Components or Features (Extends cyclique sur des Components ou des Features)

La chaîne extends: d’un Component ou la chaîne extends: d’une Feature boucle sur elle-même.

Message émis, avec Feature à la place de Component lorsque c’est la chaîne d’une Feature qui boucle :

cyclic extends chain (Component <name>, rule extends). <entity> extends <reference>, which is already in the chain; remove the extends on <entity>, or point it at an entity outside the chain (chaîne extends cyclique (Component indiqué, règle extends). L’entité étend la référence, qui est déjà dans la chaîne ; supprimez l’extends sur l’entité, ou faites-le pointer vers une entité hors de la chaîne)

Comment corriger : ouvrez l’entité que l’arête nomme — qui, le long d’une chaîne de trois maillons ou plus, n’est pas l’entité nommée en tête du message — et supprimez son extends: ou faites-le pointer ailleurs.

A component the composition holds is placed in no boundary (Un composant que la composition contient n’est placé dans aucune frontière)

Une Release place un composant dans une frontière de deux manières, et l’une ou l’autre compte. Elle nomme le composant sous les components d’une frontière, en l’adressant par l’id que le composant porte une fois la composition entière aplatie. Ou elle route le module qui fournit le composant dans une frontière sous aggregates, ce qui place d’un coup chaque composant que ce module contient.

Un composant qui n’atteint ni l’une ni l’autre est rendu en dehors de toute frontière que la Release a déclarée. Son répertoire de sortie, sa sync wave, ses annotations et son infra par composant ne viennent alors de nulle part — et la build réussirait sinon, émettrait les artefacts et ne dirait rien du fait que la configuration de l’opérateur ne lui a jamais été appliquée. Deux composants séparés par cette ligne sont aussi rendus dans des sorties différentes et perdent l’ordre qu’ils ont lorsqu’ils sont placés ensemble.

Deux structures n’y tombent délibérément pas. Une Release qui déclare des components de premier niveau plutôt que des frontières nommées place tout ce qu’elle nomme : normaliser une telle Release lui donne une frontière propre contenant exactement ces composants. Et un composant dont la Release n’a placé le module entier nulle part est signalé à la place une seule fois pour le module, sous l’entrée ci-dessous — une faute, un remède, une clé à modifier — plutôt qu’une fois par composant dont la propre déclaration est correcte.

Message émis. La valeur à la fin est l’id que le composant porte une fois la composition aplatie, qui, pour un composant fourni par un module, est le nom de ce module, un point et le nom propre du composant :

component placed in no boundary: name it under a boundary’s components, or place the sub-module that contributes it under aggregates (Release <name>, at <authored key>, "<component-id>") (composant non placé dans une frontière : nommez-le parmi les composants d’une frontière, ou placez le sous-module qui le fournit parmi les agrégats (avec la Release, la clé rédigée et l’id du composant indiqués))

Comment corriger : nommez le composant sous les components d’une frontière, en utilisant exactement l’id que cite le message — pour un composant fourni par un module, c’est l’id préfixé, et non le nom écrit dans le propre fichier du module. Ou, lorsque le module entier appartient à une seule frontière, routez-le là sous aggregates et laissez chaque composant qu’il contient être placé d’un coup.

A sub-module’s components are placed in no boundary (Les composants d’un sous-module ne sont placés dans aucune frontière)

La forme à l’échelle du module de la règle ci-dessus : un module que la composition a intégré a fourni des composants, et aucune frontière n’en contient aucun. Elle est signalée une seule fois pour le module plutôt qu’une fois par composant, parce qu’un module placé nulle part est une seule faute de rédaction avec un seul remède à une seule clé — et la signaler par composant nommerait des composants dont les propres déclarations sont parfaitement correctes.

La règle lit le placement plutôt que la graphie, de sorte qu’un module dont les composants sont chacun nommés individuellement sous les components d’une frontière est placé et passe : le refuser faute d’entrée de routage rejetterait une forme de rédaction que le langage admet. Un module placé seulement en partie passe aussi — savoir lesquels de ses composants portent leurs propres entrées relève de la règle des composants, et ceux qu’il a omis y sont signalés, chacun à sa propre clé.

Un module qui n’a fourni aucun composant n’y tombe pas : il n’y a rien à placer. Pas plus qu’un module qu’un interrupteur active: à false a retiré, et qui n’a jamais été composé du tout.

Message émis, positionné sur l’entrée aggregates qui a déclaré le module, sous le nom local que le document importateur a écrit :

sub-module placed in no boundary: route it into a boundary under aggregates, or name its components there under components (Release <name>, at <authored key>, "<module-path>") (sous-module non placé dans une frontière : routez-le dans une frontière parmi les agrégats, ou nommez-y ses composants parmi les composants (avec la Release, la clé rédigée et le chemin du module indiqués))

Comment corriger : ajoutez une entrée aggregates pour le module sous la frontière à laquelle il appartient, ce qui place chaque composant qu’il fournit. Ou, lorsque ses composants appartiennent à des frontières différentes, nommez chacun d’eux sous la frontière à laquelle il appartient, en utilisant les id préfixés qu’ils portent une fois aplatis.

A boundary names a component the composition does not hold (Une frontière nomme un composant que la composition ne contient pas)

Le pendant, du côté des noms en trop, des deux règles ci-dessus, et une question distincte plutôt qu’une branche de l’une ou de l’autre : les premières demandent d’un composant si quelque chose l’a placé, celle-ci demande d’une entrée écrite par la Release si quelque chose lui répond. Aucune n’implique l’autre. Une Release peut nommer un composant qui n’existe pas alors que chaque composant existant est correctement placé, et elle peut laisser un composant réel non placé alors que chaque entrée qu’elle a écrite se résout.

L’entrée qui ne nomme rien ne configure rien : son directory, son subDirectory, son syncWave, ses annotations et son infra par composant sont écrits pour un composant qui n’est pas là, de sorte que rien n’est rendu sous eux et que la build réussirait sinon avec la configuration de l’opérateur silencieusement inerte.

Une frontière nomme un composant de deux manières, et les deux sont vérifiées. Sous components, une entrée adresse le composant par l’id qu’il porte une fois la composition aplatie — de sorte qu’un composant fourni par un module s’écrit avec le préfixe de ce module devant son propre nom. Dans une entrée de routage aggregates, une entrée adresse le composant par le nom local qu’il porte dans ce module, qui se résout en le même id. Le message cite l’id que l’entrée a adressé, qui, sur l’axe routé, n’est pas le nom qu’écrit le fichier : le fichier porte la moitié locale et le module fournit le reste.

Un sous-système n’apporte rien à l’id d’un composant, de sorte qu’un composant déclaré dans un sous-système s’adresse par son nom nu. Une entrée écrite comme si le sous-système faisait partie de l’id n’adresse rien et tombe sous cette règle.

Un composant désactivé par un interrupteur active: à false n’y tombe pas. Désactiver un composant est un acte de rédaction, et la Release qui le configure n’est pas censée être réécrite dans la même modification — refuser l’entrée rendrait l’interrupteur inutilisable aussi longtemps qu’une Release nommerait le composant.

Message émis :

boundary names a component the composition does not hold: correct the name, or remove the entry (Release <name>, at <authored key>, "<addressed id>") (la frontière nomme un composant que la composition ne contient pas : corrigez le nom, ou supprimez l’entrée (avec la Release, la clé rédigée et l’id adressé indiqués))

Comment corriger : comparez l’id que cite le message aux composants que la composition contient réellement. Un préfixe de module manquant et un nom de sous-système écrit dans l’id sont les deux causes courantes ; retirez le sous-système, ajoutez le préfixe du module ou corrigez la graphie. Lorsque l’entrée est restée d’un composant qui a depuis été supprimé ou renommé, supprimez-la.

A uses edge targets a component an active: toggle removed (Une arête cible un composant qu’un interrupteur a retiré)

Le pendant de l’arrêt pour cible pendante ci-dessus, signalé séparément pour que l’auteur sache pourquoi la cible manque. La cible n’est pas absente parce qu’elle n’a jamais été déclarée — elle est déclarée, et elle a été délibérément retirée de cette build parce que son interrupteur active: s’est résolu en false, emportant ses arêtes avec elle. Un composant qui a subsisté en dépend encore, et laisser disparaître l’arête laisserait silencieusement vides les valeurs injectées de ce consommateur au moment du déploiement.

Message émis. Le refus vient d’abord, puis la cible que l’interrupteur a retirée et le socket dans lequel la connexion a été câblée — puis ce qu’il faut faire :

uses edge target was pruned because its active toggle resolved to false ("<target>", wired into socket "<socket>"). Keep the target’s active toggle true, or drop the dependency on it. (la cible de l’arête uses a été retirée parce que son interrupteur active s’est résolu en false : la cible indiquée, câblée dans le socket indiqué. Laissez l’interrupteur de la cible à true, ou supprimez la dépendance envers elle.)

Le constat est positionné sur l’entrée rédigée qu’il concerne, sur les mêmes chemins que nomme l’arrêt pour cible pendante ci-dessus, et chaque connexion fautive est signalée plutôt que la première seulement.

Comment corriger : décidez lequel des deux a sa place dans cet environnement. Réactivez la cible — lorsque son interrupteur lit un paramètre, cela signifie fournir le paramètre pour cette Release. Ou soumettez le consommateur au même interrupteur, de sorte que les deux partent ensemble et qu’aucune arête ne reste à pointer vers rien. Ou, lorsque le consommateur n’en a réellement plus besoin, retirez l’arête du bloc uses: du consommateur.

A uses target names a module’s component the module does not export (Une cible d’arête nomme un composant d’un module que le module n’exporte pas)

Un module publie son interface sous exportedComponents:, et un document qui importe le module n’atteint les composants du module que par ces noms : le nom du module, un point et l’un de ses alias. Une cible uses: qui atteint un composant à l’intérieur d’un module d’une autre manière — par le nom du composant dans le module, ou par un chemin qui traverse le module jusqu’à un module imbriqué en lui — arrête la build, parce que la connexion se lierait à quelque chose que l’auteur du module n’a pas publié et qu’il est libre de renommer ou de supprimer. Le propre bloc uses: d’un composant, celui d’un rattachement et une connexion câblée par une Release y sont soumis de la même façon. Les modules dans lesquels une connexion entre se lisent à partir de l’endroit où se trouve son consommateur, de sorte qu’une connexion entre deux composants d’un même module — y compris une Release qui les câble l’un à l’autre — ne traverse aucune interface et n’est pas refusée. Une cible qui ne répond à aucun composant est signalée à la place par l’arrêt pour cible pendante, de sorte qu’un nom mal saisi est signalé une seule fois.

Message émis. Le refus vient d’abord, puis la cible telle qu’écrite, le module dans lequel elle entre et les alias que ce module exporte, et le socket — puis ce qu’il faut faire :

uses edge target names a component its module does not export ("<target>", module "<module>", which exports "<aliases>", wired into socket "<socket>"). Name the component through one of the module’s exported aliases, or list it under the module’s exportedComponents. (la cible de l’arête uses nomme un composant que son module n’exporte pas : la cible, le module, les alias qu’il exporte et le socket dans lequel elle est câblée, indiqués. Nommez le composant par l’un des alias exportés du module, ou listez-le parmi les composants exportés du module.)

Un module qui n’exporte rien est désigné comme exportant "nothing". Le constat est positionné sur l’entrée rédigée dans le document qui a tracé la connexion.

Comment corriger : nommez le composant par un alias que le module exporte — finance-db-subsystem.primary_db plutôt que finance-db-subsystem.internal-pg-primary — ou, lorsque vous êtes l’auteur du module et entendez publier le composant, listez-le sous les exportedComponents du module, sous son propre nom si c’est le nom que les importateurs doivent utiliser.

An active: toggle does not resolve to true or false (Un interrupteur ne se résout ni en true ni en false)

Un interrupteur active: atteint le constructeur de graphe déjà résolu en un littéral — un booléen écrit directement, ou une référence de paramètre dans laquelle les valeurs de la Release ont été substituées avant la lecture du document. Il est alors lu strictement : un littéral qui n’est pas un booléen arrête la build plutôt que de prendre une valeur par défaut quelconque. La règle est la même pour l’interrupteur d’un composant et pour celui d’un module.

Un littéral vide est le cas qui mérite d’être nommé, parce que c’est ce que produit un paramètre non satisfait. Un interrupteur qui lit {{ .parameters.<key> }} ne se résout en rien tant que ce paramètre n’a pas de valeur, et lire ce rien comme « présent » déploierait l’entité même que l’auteur a soumise au paramètre. Seul un interrupteur que personne n’a écrit vaut par défaut présent, et cela se lit à partir de l’absence de l’interrupteur plutôt que de sa valeur — c’est pourquoi écrire active: sans rien après n’équivaut pas à omettre la clé.

Message émis :

active toggle did not resolve to a boolean (node "<node>", active resolved to "<value>") (l’interrupteur active ne s’est pas résolu en booléen (le nœud indiqué, active résolu en la valeur indiquée))

et, lorsqu’il ne s’est résolu en rien du tout, avec la recommandation qui nomme la cause habituelle :

active toggle did not resolve to a boolean (node "<node>", active resolved to ""). a toggle reading a parameter resolves to nothing until that parameter is fulfilled (l’interrupteur active ne s’est pas résolu en booléen (le nœud indiqué, active résolu en une chaîne vide). un interrupteur qui lit un paramètre ne se résout en rien tant que ce paramètre n’est pas satisfait)

Comment corriger : écrivez true ou false. Lorsque l’interrupteur lit un paramètre, fournissez ce paramètre dans la Release, ou donnez-lui un default: là où il est déclaré dans l’Aggregate, afin que chaque environnement ait une réponse. Pour rendre une entité présente sans condition, retirez la clé active: plutôt que de la laisser vide.

A module a composition imports cannot be loaded, or imports itself (Un module qu’une composition importe ne peut pas être chargé, ou s’importe lui-même)

Un Aggregate compose d’autres Aggregates en les nommant sous aggregates:, et chacun est chargé et parcouru à son tour pour que ses composants rejoignent le graphe. Deux choses arrêtent ici ce parcours.

Le module ne peut pas être chargé du tout — la référence ne se résout en rien que le catalogue puisse renvoyer, ou le document qui se trouve derrière ne peut pas être lu. La raison donnée par le chargeur est portée sous l’arrêt plutôt que fondue en lui, de sorte que ce qui a échoué est signalé dans les propres mots du chargeur.

Ou le module nomme un type déjà présent sur la chaîne en cours de parcours. Le développer reproduirait la chaîne qui le contient, sans fin. C’est signalé à l’endroit où la référence ferme la boucle, en nommant à la fois le type et sa place dans la composition.

Message émis, pour une référence circulaire :

sub-aggregate load failed (circular sub-aggregate reference "<module-type>", at "<path in the composition>") (échec du chargement du sous-agrégat (référence circulaire de sous-agrégat, avec le type de module et le chemin dans la composition indiqués))

et pour un échec de chargement, où l’arrêt se lit comme la phrase seule, positionné sur le chemin du module, avec la propre raison du chargeur en dessous :

sub-aggregate load failed (échec du chargement du sous-agrégat)

Comment corriger : pour un échec de chargement, lisez la raison sous l’arrêt — un nom ou une version auxquels le catalogue ne sait pas répondre est le cas courant, et la correction va dans l’entrée aggregates: qui le nomme. Pour une référence circulaire, rompez la boucle : le chemin du message est l’endroit où la chaîne se ferme, et l’un des modules qui la composent doit cesser d’importer celui qui l’importe. Lorsque deux modules ont réellement besoin des composants l’un de l’autre, la partie partagée a sa place dans un troisième module que les deux importent.

Two instances flatten to one identifier (Deux instances s’aplatissent en un seul identifiant)

Composer un Aggregate aplatit chaque composant en un seul ensemble, et un composant fourni par un module porte le nom de ce module, un point et son propre nom. L’ensemble refuse de contenir deux entrées sous un même identifiant : la seconde remplacerait la première, et l’un des deux composants disparaîtrait de la sortie sans que rien ne soit dit.

Cet arrêt est celui qui est levé lorsque les composants d’un module sont fusionnés, et la surface de rédaction n’offre pas les noms qui le produiraient. Chaque composant qu’un module fournit porte le nom de ce module devant le sien ; un nom d’instance s’écrit avec des lettres, des chiffres, - et _, il ne peut donc pas porter le point qui joint les deux, et deux identifiants construits à partir de noms de module différents ne peuvent pas se rencontrer. Deux modules importés sous un même nom forment une seule clé en double, et le document est refusé au chargement. Cet arrêt sert donc de filet de sécurité pour une composition assemblée par autre chose que le chemin de rédaction ordinaire, et en rencontrer un mérite d’être signalé plutôt que contourné.

Deux composants d’un même Aggregate qui aboutissent à un même identifiant constituent un arrêt différent, et la rédaction ordinaire le produit — voir Two subsystems declare a component under one name (Deux sous-systèmes déclarent un composant sous un même nom) ci-dessous.

Message émis :

flattened node ID collision: rename one of the colliding instances so their flattened IDs differ (id "<identifier>", path "<path in the composition>", collides with existing entry from "<the other contributor>") (collision d’ID de nœuds aplatis : renommez l’une des instances en collision pour que leurs ID aplatis diffèrent (l’identifiant et le chemin dans la composition indiqués, en collision avec l’entrée existante provenant de l’autre contributeur indiqué))

Comment corriger : renommez l’une des deux instances que nomme le message, dans le document qui la déclare et dans chaque entrée de Release qui l’adresse.

Two subsystems declare a component under one name (Deux sous-systèmes déclarent un composant sous un même nom)

Les sous-systèmes regroupent les composants d’un Aggregate pour le lecteur et pour ce qui se propage en cascade vers eux ; ils ne qualifient pas le nom auquel un composant répond. Un composant déclaré sous subsystems.frontend s’adresse comme api, et non comme frontend.api, et un composant fourni par un module porte le nom de ce module plutôt que celui du sous-système. Deux sous-systèmes d’un même Aggregate peuvent donc chacun déclarer un composant appelé api, et les deux répondent alors au même identifiant.

Le document est bien formé — les deux sont des clés distinctes dans des blocs distincts, et c’est exactement pourquoi rien ne le refuse plus tôt — mais un seul composant peut porter un identifiant. La build s’arrête plutôt que de garder celui qui a été lu en dernier et de faire le rendu comme si un seul composant avait été déclaré.

Le même nom deux fois dans un seul sous-système est une faute différente : ce sont deux entrées sous une même clé, et le document est refusé à la lecture.

Message émis :

components in different subsystems take the same identity: rename one of them, since a subsystem contributes nothing to a component’s identity (Aggregate, at .spec.subsystems.<second>.components.<identifier>, "<identifier>", declared under subsystems "<first>, <second>") (des composants de sous-systèmes différents prennent la même identité : renommez l’un d’eux, puisqu’un sous-système n’apporte rien à l’identité d’un composant (avec l’Aggregate, le chemin et l’identifiant indiqués, déclaré sous les sous-systèmes indiqués))

Comment corriger : renommez l’un des deux composants, dans le document qui le déclare et dans chaque entrée de Release qui l’adresse. Lorsque les deux sont réellement le même composant voulu à deux endroits, déclarez-le une seule fois et faites-en dépendre l’autre sous-système. Renommer le sous-système n’aide pas : le sous-système ne fait pas partie du nom.

A re-published component alias points back at itself (Un alias de composant republié pointe vers lui-même)

Un module publie une partie de lui-même en exportant des composants sous des alias, et un Aggregate qui l’importe peut republier l’un de ces alias sous un nom qui lui est propre. Résoudre un tel alias suit la chaîne des republications jusqu’au composant qu’il nomme en définitive, de sorte qu’une arête pointant vers le nom public atteint un composant réel.

Une chaîne qui repasse par un alias avant d’atteindre un composant n’aboutit jamais. Le parcours s’arrête plutôt que de la suivre indéfiniment, et nomme la chaîne qu’il a parcourue pour que le maillon qui ferme la boucle soit visible.

Rien de ce que vous pouvez écrire ne produit une telle chaîne. L’arbre des importations est acyclique, et chaque maillon nomme quelque chose de plus profondément imbriqué que le maillon précédent, de sorte qu’une chaîne assemblée à partir d’importations descend et se termine. Cet arrêt sert donc de filet de sécurité pour une table d’alias assemblée par autre chose que le chemin de rédaction ordinaire, plutôt que pour une structure qu’un Aggregate peut déclarer.

Message émis :

re-exported component alias forms a cycle (alias chain <first> -> <second> -> <first>) (l’alias de composant réexporté forme un cycle (avec la chaîne d’alias indiquée))

Comment corriger : rien dans vos fichiers ne le produit, et aucune modification de rédaction ne le fait disparaître. Signalez-le avec la commande que vous avez exécutée et la chaîne d’alias que nomme le message, qui est le détail indiquant où la boucle s’est fermée.

An Aggregate reached graph building without being normalised (Un Aggregate a atteint la construction du graphe sans avoir été normalisé)

Un Aggregate écrit avec des composants à son premier niveau et un Aggregate écrit avec des sous-systèmes nommés prennent la même forme lors de leur lecture : les composants de premier niveau sont intégrés dans un sous-système que fournit le compilateur, et le premier niveau est vidé. C’est cette intégration qui permet à tout ce qui suit de poser une seule question à une seule forme.

Un Aggregate qui arrive à la construction du graphe avec les deux renseignés n’a pas été produit par cette lecture. Les deux formes s’excluent mutuellement là où elles sont rédigées — un document qui déclare les deux est refusé au chargement — et l’intégration est ce qui en fait ensuite une seule forme, de sorte que rien de ce qu’un auteur peut écrire n’arrive jusqu’ici. Cet arrêt sert de filet de sécurité pour un Aggregate assemblé par autre chose que le chemin de chargement ordinaire, et en rencontrer un mérite d’être signalé plutôt que contourné.

Son message commence ainsi :

aggregate reached topology un-normalized (non-empty root components alongside a synthesized default subsystem) (l’agrégat a atteint la topologie sans être normalisé (composants racine non vides à côté d’un sous-système par défaut synthétisé))

et se poursuit avec le chemin de construction qu’attend le compilateur, qui est une note pour la personne qui débogue la build plutôt qu’une instruction de rédaction.

Comment corriger : rien dans vos fichiers ne le produit, et aucune modification de rédaction ne le fait disparaître. Signalez-le avec la commande que vous avez exécutée.

A label-transform plugin’s patch reaches outside node labels (Le patch d’un plugin label-transform sort des labels des nœuds)

Un plugin de gouvernance rattaché dans un rôle label-transform reçoit une projection du graphe — une entrée par nœud, portant les labels de ce nœud et les valeurs que déclare son instance, toute valeur que son Component déclare sensible étant retenue — et renvoie des patchs portant sur les labels des nœuds. L’hôte les applique aux seuls labels, puis vérifie que ce qui est revenu est toujours cette vue des labels : les mêmes nœuds, chacun ne portant que des labels, chaque valeur de label étant une chaîne.

Tout le reste est refusé et la build s’arrête. Ajouter ou supprimer un nœud, ou modifier un champ d’un nœud autre que ses labels, c’est précisément l’apparition silencieuse d’une infrastructure que personne n’a déclarée — aussi, plutôt que d’absorber une modification que le rôle ne couvre pas, la build indique quelle règle de confinement le patch a enfreinte. Les labels sont toute la surface du rôle, et un opérateur qui a rattaché le plugin a déclaré cela et rien de plus.

Messages émis. Le patch a été refusé avant d’être appliqué :

mutator patch rejected: patch <n> does not decode as a JSON Patch document: <what the reader could not do> (patch du mutateur refusé : le patch indiqué ne se décode pas comme un document JSON Patch : ce que le lecteur n’a pas pu faire) mutator patch rejected: patch <n> does not apply to the node-label surface: <what the patch engine refused> (patch du mutateur refusé : le patch indiqué ne s’applique pas à la surface des labels des nœuds : ce que le moteur de patch a refusé)

ou le résultat de son application n’était pas la vue que l’hôte avait transmise :

mutator patch rejected: mutated node set changed size (a mutator may not add or remove nodes) (patch du mutateur refusé : l’ensemble de nœuds muté a changé de taille (un mutateur ne peut ni ajouter ni supprimer de nœuds)) mutator patch rejected: mutated node set introduced node "<node>" (a mutator may not add nodes) (patch du mutateur refusé : l’ensemble de nœuds muté a introduit le nœud indiqué (un mutateur ne peut pas ajouter de nœuds)) mutator patch rejected: node "<node>" gained a field outside "labels" (a mutator may only touch labels) (patch du mutateur refusé : le nœud indiqué a acquis un champ en dehors des labels (un mutateur ne peut toucher qu’aux labels)) mutator patch rejected: node "<node>" lost its "labels" field (patch du mutateur refusé : le nœud indiqué a perdu son champ de labels) mutator patch rejected: node "<node>" carries a non-string label value after patching: <what the reader found> (patch du mutateur refusé : le nœud indiqué porte une valeur de label qui n’est pas une chaîne après l’application du patch : ce que le lecteur a trouvé)

Comment corriger : la faute revient au plugin plutôt qu’à vos documents. Corrigez-le pour que chaque opération qu’il renvoie adresse une entrée sous les labels d’un nœud et ne définisse que des valeurs de type chaîne — une valeur de label numérique ou booléenne est le cas courant, puisque la surface n’accepte que des chaînes. Retirer le rattachement de plugins.governance est le moyen immédiat de débloquer une build pendant que le plugin est corrigé.

Omission intentionnelle : la topologie n’est pas tenue d’être acyclique

Aggrega autorise les cycles dans la topologie : il n’exige pas que le graphe de dépendances soit un graphe orienté acyclique. Les architectures agent à agent, les modèles de rappel et les paires à authentification mutuelle produisent tous des arêtes cycliques, et le compilateur les accepte. L’ordonnancement au moment du déploiement relève du moteur de rendu (par un syncWave par frontière ou un équivalent), et non du graphe IR.

Lors de la vérification des contrats inject

Le compilateur parcourt chaque bloc inject: — aussi bien le self-inject (un Component qui s’injecte dans lui-même) que le uses-inject (câblage d’un Component à l’autre) — et valide le contrat de livraison par rapport au schéma provides: du Component cible, à la partition de labels de la Feature et à l’ensemble des clés de livraison déclarées. Une clé from: sur un bloc écrit par le propre composant de l’Aggregate est vérifiée dès que le catalogue est résolu, de sorte qu’elle échoue sur la ligne que vous avez écrite ; une clé sur le bloc d’un composant qu’un module fournit est vérifiée une fois construite la composition qui importe le module, et échoue sur la ligne du propre document du module ; une clé from: sur une connexion qu’une Feature rattachée fournit est vérifiée une fois que chaque surface capable de tracer une connexion a apporté sa contribution, ce qui est le premier moment où une telle connexion existe et peut être vérifiée.

Inject from key is not in the target’s provides (La clé d’inject ne figure pas parmi ce que la cible fournit)

Une entrée inject: fait référence à une clé from: que la source qu’elle lit ne publie pas : le schéma provides: du Component cible pour le propre bloc d’un composant ou pour une connexion, et la FeatureRecipe de la Feature attachée pour le propre bloc inject: d’une Feature attachée.

La vérification s’applique partout où la connexion a été écrite. Une connexion uses: atteint la topologie construite depuis plus d’une surface de rédaction — le propre bloc uses: d’un Component et le bloc uses: d’une Feature qui lui est rattachée, que ce rattachement soit écrit sur le composant, sur un sous-système, sur une frontière de Release ou sur l’entrée de composant d’une frontière de Release — et la même clé mal orthographiée est refusée sur chacune d’elles. Le diagnostic pointe vers le bloc dont l’auteur l’a écrite : la propre entrée uses: d’un rattachement, à l’endroit où le rattachement lui-même a été déclaré, plutôt que le bloc uses: du composant consommateur, qui pour une connexion fournie ne contient rien du tout.

Ce par rapport à quoi la référence se résout dépend de l’endroit où elle se trouve. Un from: de self-inject au niveau du Component se résout par rapport au propre provides: de ce même Component. Un from: sur une connexion uses: se résout par rapport au provides: du composant vers lequel pointe cette connexion — et lorsque deux surfaces écrivent un même socket et un même alias, chaque connexion se résout par rapport à la cible qu’elle nomme elle-même, dans la même build qui refuse la paire parce qu’elle partage un alias. Un Component qui ne déclare aucun provides: refuse toute référence from: qui le vise.

Le propre bloc inject: d’une Feature attachée. Là, un from: est résolu par rapport aux clés que la FeatureRecipe de la Feature publie dans son provides:, telles qu’évaluées pour le composant auquel la Feature est attachée, et il est vérifié lorsque ce composant est rendu. Une clé que la FeatureRecipe ne publie pas ne placerait rien dans l’environnement, le fichier ou l’argument du composant ; le build s’arrête donc à la place — sauf si la FeatureRecipe lit elle-même les entrées de la Feature attachée, à .inject, dans un template qu’elle évalue par rapport au propre contexte de rendu de la Feature attachée — celui qui porte .inject : son mappage de valeurs, sa charge de travail, ses artefacts, ses omissions ou le with: ou le when: d’une étape de pipeline, écrits en ligne ou importés. Ses locals:, provides:, source: et assertions: ne portent pas de .inject, et son injectMapping: est évalué par rapport au contexte du composant ; une lecture dans l’un d’eux ne compte donc pas. Une telle FeatureRecipe reçoit chaque entrée telle qu’elle est écrite et la livre à sa manière ; ses entrées ne sont donc pas refusées, et une clé qu’elle ne publie pas ne livre rien par la livraison propre du composant et reste à la disposition de la FeatureRecipe. Le fait qu’une FeatureRecipe lise .inject est déterminé à partir des chemins que nomment ses templates : un template qui transmet tout son contexte (toJson .) ou qui atteint les entrées par une fonction telle que index . "inject" ne compte pas comme une lecture des entrées, et ses entrées qui nomment une clé non publiée sont refusées. Une Feature attachée à une frontière dont la FeatureRecipe est rendue une seule fois pour cette frontière est vérifiée par rapport à cette unique évaluation ; là où aucune frontière contenant le composant n’en a produit, il n’y a rien par rapport à quoi vérifier ses clés et elles ne sont pas refusées. Un from: qui nomme une clé publiée livre comme auparavant. Le constat est positionné sur la propre entrée de la Feature attachée, dans le document qui l’a écrite — .spec.components.<component>.features.<attachment> dans l’Aggregate, par exemple — et une entrée dont la clé de livraison est également déjà détenue par une autre source inject est aussi signalée sous « An attachment delivers a key another inject source already claimed (Un attachement livre une clé qu’une autre source inject a déjà revendiquée) », puisque chacune exige sa propre correction.

Sur le propre bloc inject: d’un composant, une entrée value: porte un littéral et n’est résolue par rapport à rien, de sorte qu’un littéral qui ressemble par hasard à une clé provides n’y est pas refusé ; sur une connexion, une entrée value: est refusée, comme le décrit « An inject: entry on a connection carries a literal (Une entrée d’inject sur une connexion porte un littéral) » ci-dessous. Seul from: nomme une clé.

La propre surface uses: par arête de la Release porte target et infra et aucun inject:, de sorte qu’une connexion câblée à cet endroit n’impose aucune livraison et n’a aucune clé from: à vérifier.

Message émis, pour un from: lu sur le propre bloc inject: d’un Component. Le refus vient d’abord, puis la clé fautive, le type de composant par rapport auquel elle a été résolue, et les clés déclarées de ce type, triées — les alternatives parmi lesquelles choisir :

invalid inject key: the from-key must name a provides key its source publishes (Aggregate <name>, at .spec.components.<component>.inject.<mechanism>.<delivery-key>, "<from-key>", "<component-type>", "<key-1>", "<key-2>") (clé inject invalide : la from-key doit nommer une clé provides que sa source publie (avec l’Aggregate, le chemin, la from-key, le type de composant et les clés déclarées indiqués))

Pour un from: lu sur une connexion uses:, le même refus vient en tête, et le mécanisme et la clé de livraison sous lesquels l’entrée a été écrite précèdent la clé fautive :

invalid inject key: the from-key must name a provides key its source publishes (Aggregate <name>, at .spec.components.<component>.uses.<socket>.<alias>, "<mechanism>", "<delivery-key>", "<from-key>", "<component-type>", "<key-1>") (clé inject invalide : la from-key doit nommer une clé provides que sa source publie (avec l’Aggregate et la connexion indiqués, le mécanisme, la clé de livraison, la from-key, le type de composant et la clé déclarée))

Pour un from: lu sur le propre bloc inject: d’une Feature attachée, la clé fautive vient en premier, puis l’in: et le mécanisme de l’entrée, la FeatureRecipe par rapport à laquelle elle a été résolue, et chaque clé que publie cette FeatureRecipe, dans l’ordre trié :

invalid inject key: the from-key must name a provides key its source publishes (Aggregate <name>, at .spec.components.<component>.features.<attachment>, "<from-key>", in "<in>", mechanism "<mechanism>", FeatureRecipe "<feature-recipe>", publishes "<key-1>", publishes "<key-2>") (clé inject invalide : la from-key doit nommer une clé provides que sa source publie (avec l’Aggregate, le chemin, la from-key, l’in, le mécanisme, la FeatureRecipe et les clés publiées indiqués))

Lorsque la cible ne déclare aucune clé provides:, il n’y a aucune alternative à lister, de sorte que le message s’arrête après le type de composant — ou, sur le bloc d’une Feature attachée, après la FeatureRecipe.

Comment corriger : soit modifiez la clé from: pour qu’elle corresponde à l’une des clés déclarées listées dans le message, soit étendez le schéma provides: du Component cible pour déclarer la clé dont vous avez besoin. Sur le bloc d’une Feature attachée, remplacez la clé from: par une clé que publie la FeatureRecipe, ou — lorsque la FeatureRecipe vous appartient — publiez la clé dans son provides:, ou faites-lui lire elle-même l’entrée à .inject si elle livre la valeur à sa manière.

Required feature not attached (Fonctionnalité requise non rattachée)

Le Component déclare un mandat de présence — une annotation features.aggrega.ai/requiredType.<label> — qui nomme un type de Feature absent des rattachements avec lesquels cette instance de composant se retrouve, en comptant chaque portée : les blocs de niveau composant et de niveau sous-système de l’Aggregate, les blocs de niveau frontière et de niveau composant de la Release, et l’expansion pilotée par les annotations.

Message émis :

missing required feature: attach a Feature of the required type to the component (<required-type>, required by component type <component-type>, under the requirement label <label>) (fonctionnalité requise manquante : rattachez au composant une Feature du type requis (le type requis indiqué, exigé par le type de composant indiqué, sous le label d’exigence indiqué))

Les trois valeurs sont le type de Feature qu’exige le mandat — que la phrase qui précède nomme déjà, si bien qu’il figure sans légende —, puis le type de composant qui déclare le mandat et le label que porte le mandat, chacun accompagné d’une légende pour qu’un lecteur puisse distinguer deux références d’entité. Un composant qui exige deux types différents émet deux messages qui diffèrent, et deux composants qui déclarent le mandat depuis des types différents apprennent quel type a formulé chaque exigence. Le constat est positionné sur la propre clé du composant sous components:, et un composant écrit à l’intérieur d’un sous-système est d’abord positionné sous la clé de ce sous-système.

Le nom sous lequel un rattachement est écrit n’a ici aucune importance : le mandat demande si un rattachement du type nommé est présent ou non. Lier un emplacement le satisfait, et un rattachement sous n’importe quel autre nom aussi.

Comment corriger : rattachez une Feature du type requis au composant dans l’Aggregate ou dans la Release, ou à une portée plus large dont le composant hérite. Si le Component ne doit plus l’exiger, supprimez l’annotation du mandat de sa déclaration de catalogue.

Malformed attachment requirement (Exigence de rattachement mal formée)

La déclaration d’un mandat de présence ne peut pas être évaluée. La valeur d’une annotation est une chaîne opaque, si bien que rien n’en valide la forme avant que le compilateur ne la lise : une valeur qui n’est pas une URI de type de Feature, ou une clé qui nomme la famille de mandats sans label après le préfixe, est signalée comme une déclaration défectueuse plutôt que comme une exigence non satisfaite — une faute de frappe ne doit jamais se lire comme une exigence satisfaite.

Messages émis :

malformed attachment requirement (<key>, declared by component type <component-type>, which cannot be evaluated because the value must be a Feature type URI of the form <publisher>/<name> in lower-case kebab segments, as in core/prometheus-exporter). Correct that annotation on the component type’s catalog entity. (exigence de rattachement mal formée (la clé indiquée, déclarée par le type de composant indiqué, qui ne peut pas être évaluée parce que la valeur doit être une URI de type de Feature de la forme éditeur/nom en segments kebab en minuscules, comme dans l’exemple indiqué). Corrigez cette annotation sur l’entité de catalogue du type de composant.)

malformed attachment requirement (<key>, declared by component type <component-type>, which cannot be evaluated because the key needs a label naming the requirement, as in features.aggrega.ai/requiredType.database). Correct that annotation on the component type’s catalog entity. (exigence de rattachement mal formée (la clé indiquée, déclarée par le type de composant indiqué, qui ne peut pas être évaluée parce que la clé a besoin d’un label nommant l’exigence, comme dans l’exemple indiqué). Corrigez cette annotation sur l’entité de catalogue du type de composant.)

Le message commence par la clé d’annotation — la déclaration dont traite l’arrêt — et nomme ensuite le type de composant dont la déclaration est défectueuse, de sorte qu’il nomme l’entité à corriger même si le constat est positionné sur l’instance de composant qui utilise ce type : l’instance est l’endroit où vous le voyez, et l’entité de catalogue est l’endroit où se trouve le remède.

Cet arrêt est levé dès que la composition est assemblée, ce qui est plus tôt que toute vérification qui lit le graphe terminé. Une build portant un mandat défectueux le signale donc seul : les vérifications qui s’exécuteraient ensuite ne sont pas atteintes, car elles raisonnent sur ce que dit la déclaration et la déclaration ne peut pas être lue. Corrigez-le et relancez la build pour voir le reste.

Comment corriger : corrigez l’entité de catalogue du Component. Le remède se trouve dans le catalogue, et non dans l’Aggregate — c’est pourquoi cet arrêt est distinct de « Required feature not attached (Fonctionnalité requise non rattachée) », où ce sont vos propres documents qu’il faut modifier.

Required attachment slot not bound (Emplacement de rattachement requis non lié)

Une entité de catalogue déclare un emplacement de rattachement avec required: true dans son featuresSchema, et rien ne lie le nom de cet emplacement sur une instance de l’entité. La vérification porte sur les rattachements avec lesquels l’instance se retrouve une fois toutes les portées fusionnées — les blocs features: de niveau composant et de niveau sous-système de l’Aggregate, les blocs de niveau frontière et de niveau composant de la Release, et les rattachements produits par l’expansion pilotée par les annotations — de sorte qu’un justificatif d’identité rattaché une fois à une portée dont l’instance hérite lie l’emplacement exactement comme le fait un remplissage rédigé sur l’instance.

Message émis :

required attachment slot unfilled (<slot>, declared required by component type <component-type>). Attach a Feature at that name, in the Aggregate or in the Release, on the component or at a scope above it. (emplacement de rattachement requis non rempli (l’emplacement indiqué, déclaré requis par le type de composant indiqué). Rattachez une Feature sous ce nom, dans l’Aggregate ou dans la Release, sur le composant ou à une portée au-dessus de lui.)

Les deux valeurs sont le propre nom de l’emplacement et le type de composant qui le déclare, de sorte qu’une instance qui laisse deux emplacements non liés émet deux messages qui diffèrent. Le constat est positionné sur la clé de l’emplacement sous le bloc features: du composant dans l’Aggregate ; comme cette clé est précisément ce qui manque, un éditeur le place sur la clé existante la plus proche — le bloc features: là où le composant en écrit un, et le composant lui-même là où il n’en écrit pas. Rien n’a écrit le rattachement manquant, si bien qu’aucun auteur de document n’est désigné par lui : le constat reste sur le composant et est classé comme faute du développeur, et le remède nomme les deux documents, car l’un ou l’autre peut remplir l’emplacement — l’Aggregate sur le composant ou sur un sous-système qui le contient, la Release sur son entrée pour le composant ou sur une frontière qui le contient.

Un emplacement que déclare un socket — dans le featuresSchema d’une entrée de usesSchema — est exigé de chaque connexion câblée par ce socket plutôt que du composant : chaque connexion le remplit pour elle-même, sur sa propre entrée dans l’Aggregate ou dans la Release, et aucune portée supérieure ne l’atteint. Ainsi, un socket avec deux connexions, dont l’une remplit l’emplacement, ne signale que l’autre, en la nommant :

required attachment slot unfilled ("<slot>", declared required by socket "<socket>", of component type "<component-type>", left unfilled by the connection "<alias>"). Attach a Feature under that slot in this connection’s features, on its entry in the Aggregate or in the Release. (emplacement de rattachement requis non rempli (l’emplacement indiqué, déclaré requis par le socket indiqué, du type de composant indiqué, laissé vide par la connexion indiquée). Rattachez une Feature sous cet emplacement dans les fonctionnalités de cette connexion, sur son entrée dans l’Aggregate ou dans la Release.)

Ce constat est positionné sur l’entrée de la connexion dans le document qui a tracé la connexion — l’entrée uses: de l’Aggregate, ou l’entrée par arête de la Release pour une connexion que la Release a câblée. Une connexion que trace une Feature rattachée est câblée dans un socket que déclare la Feature, et non dans l’un de ceux du composant, si bien que ce n’est pas à elle de remplir les emplacements des sockets du composant.

Comment corriger : rattachez une Feature sous le nom de l’emplacement, dans l’Aggregate ou dans la Release — sur le composant, ou à une portée plus large que partagent tous les consommateurs de l’emplacement ; pour l’emplacement d’un socket, sur la connexion que nomme le constat. Un rattachement sous un nom différent ne lie pas l’emplacement : un emplacement est un point de liaison nommé, donc le nom est la liaison. Si l’emplacement ne doit plus être requis, mettez à jour le featuresSchema de l’entité de catalogue — celui du composant ou celui du socket — pour supprimer la déclaration required.

Two Features declared to conflict reach one component (Deux Features déclarées en conflit atteignent un même composant)

Le champ interoperability.conflictsWith d’une Feature nomme les Features aux côtés desquelles elle ne peut pas être rattachée, et un composant finit par porter la Feature et l’une de celles qu’elle nomme. La vérification porte sur les rattachements avec lesquels le composant se retrouve une fois toutes les portées fusionnées — les blocs features: de niveau composant et de niveau sous-système de l’Aggregate, les blocs de niveau frontière de la Release (chaque frontière dans laquelle se trouve le composant, y compris les frontières imbriquées) et ses entrées de niveau composant, et les rattachements produits par l’expansion pilotée par les annotations. Ainsi, une paire provoque un arrêt lorsque les deux sont écrites sur le composant, lorsque l’une se trouve sur une frontière ou un sous-système qui le contient, ou lorsque l’une se trouve sur une frontière extérieure et l’autre sur une frontière imbriquée à l’intérieur de celle-ci. Deux Features rattachées à des frontières sœurs qui ne partagent aucun composant ne se rencontrent jamais, et une frontière qui ne contient aucun composant n’atteint rien, si bien qu’aucun de ces cas ne provoque d’arrêt.

Une seule déclaration suffit : l’arrêt se déclenche lorsque la liste de l’une ou l’autre Feature nomme l’autre. Les noms sont comparés sans leur éventuelle version, des deux côtés, de sorte qu’une entrée correspond à toutes les versions de la Feature qu’elle nomme. Le compilateur compare les noms que l’auteur de la Feature a déclarés aux Features que porte le composant, et n’interprète rien de plus dans l’un ou l’autre.

Message émis :

a Feature reaches a component alongside a Feature it declares a conflict with ("<feature>", attached in the Release on boundary "<boundary-path>", conflicts with "<other-feature>", attached in the Aggregate on component "<component>", on component "<component>"). Attach only one of the two where they meet: remove one attachment, or move it to a scope that does not hold this component. (une Feature atteint un composant aux côtés d’une Feature avec laquelle elle déclare un conflit (la Feature indiquée, rattachée dans la Release sur la frontière indiquée, est en conflit avec l’autre Feature indiquée, rattachée dans l’Aggregate sur le composant indiqué, sur le composant indiqué). Ne rattachez qu’une seule des deux là où elles se rencontrent : supprimez un rattachement, ou déplacez-le vers une portée qui ne contient pas ce composant.)

La première valeur est la Feature dont la liste nomme l’autre — celle que nomme la phrase qui précède — suivie de chaque endroit où elle a été rattachée ; puis la Feature avec laquelle elle est en conflit, et chaque endroit où celle-ci a été rattachée ; et enfin le composant où elles se rencontrent. Chaque endroit est formulé dans les mots du document que vous ouvririez pour le modifier : attached in the Aggregate on component, attached in the Aggregate on subsystem, attached in the Release on boundary (le chemin d’une frontière imbriquée joint ses niveaux par /), attached in the Release on the entry for component suivi de in boundary, ou attached by annotation-driven expansion of suivi de l’annotation, puis de declared at et de l’endroit où elle a été écrite. Un rattachement écrit sur une connexion est formulé comme l’entrée de cette connexion, puisque c’est cette entrée, et non le propre bloc du composant, qui est l’endroit où il se modifie : attached in the Aggregate on the connection suivi de through socket et of component, ou attached in the Release on the connection suivi de through socket, of the entry for component et in boundary. Une Feature rattachée à deux endroits les liste tous les deux. Le constat est positionné sur la propre clé du composant sous components:, et une paire qui se rencontre sur plusieurs composants est signalée une fois pour chacun d’eux, dans l’ordre dans lequel l’Aggregate déclare les composants.

Comment corriger : ne rattachez qu’une seule des deux là où elles se rencontrent — supprimez l’un des rattachements, ou déplacez-en un vers une portée qui ne contient pas ce composant, comme une frontière sœur. Lorsque le rattachement provient de l’expansion pilotée par les annotations, c’est l’annotation qu’il faut modifier, et non le bloc sur lequel elle s’est étendue. Si les deux Features peuvent en fait être combinées, c’est la déclaration qui est erronée : supprimez l’autre Feature de la liste conflictsWith sur l’entité de catalogue de la Feature qui la déclare.

Attachment does not conform to its declared slot shape (Le rattachement n’est pas conforme à la forme déclarée de son emplacement)

Un rattachement lie un emplacement déclaré mais ne correspond pas à la forme que cet emplacement déclare. Le cas courant est la livraison : la liste d’autorisation inject d’un emplacement nomme les mécanismes par lesquels un remplissage peut livrer son matériau, et une liste d’autorisation vide est blackbox — la Recipe livre le matériau en interne et un remplissage ne peut imposer aucune livraison. Un bloc inject: {} vide n’impose aucune livraison ; il est donc conforme à la forme de tout emplacement, liste d’autorisation vide comprise, et reçoit le même verdict où que le rattachement soit écrit : sur un composant que l’Aggregate déclare, sur un composant qu’un module importé fournit, ou à une portée plus large. Un rattachement sous un nom qu’aucun emplacement ne déclare est un rattachement libre et ne porte aucune contrainte d’emplacement.

Message émis, lorsque le rattachement impose une livraison que son emplacement n’accepte pas — l’emplacement, puis le mécanisme, puis chaque mécanisme qu’accepte la liste d’autorisation inject de l’emplacement, dans l’ordre où l’emplacement les déclare (aucun ne suit pour une liste d’autorisation vide) :

attachment does not conform to its declared slot shape (Aggregate <name>, at .spec.components.<component>.features.<attachment>, "<slot>", "<mechanism>", "<permitted-mechanism>") (le rattachement n’est pas conforme à la forme déclarée de son emplacement (avec l’Aggregate, le chemin, l’emplacement, le mécanisme et le mécanisme autorisé indiqués))

Un composant qu’un module importé fournit est vérifié une fois construite la composition qui l’importe, et il est signalé sous une seconde forme. Celle-ci nomme l’Aggregate du module et la clé, dans le document du module, que l’emplacement ne déclare pas — un mécanisme sous le bloc inject: du rattachement, ou le bloc inject: lui-même lorsqu’il nomme un mécanisme quelconque sur un emplacement dont la liste d’autorisation est vide :

attachment does not conform to its declared slot shape (Aggregate <name>, at .spec.components.<component>.features.<attachment>.<key>, attachment does not conform to the declared slot shape: this key is not part of the slot’s declaration — <remedy>) (le rattachement n’est pas conforme à la forme déclarée de son emplacement (avec l’Aggregate et le chemin indiqués, le rattachement n’est pas conforme à la forme d’emplacement déclarée : cette clé ne fait pas partie de la déclaration de l’emplacement — le remède indiqué))

où <remedy> dépend de la clé :

  • remove it, pour un bloc inject: qui nomme un mécanisme sur un emplacement dont la liste d’autorisation est vide ;
  • remove it, or add it to the slot's inject allowlist in the entity's featuresSchema, pour un mécanisme que la liste d’autorisation d’un emplacement peut nommer — env, file ou arg ;
  • remove it: a slot's inject allowlist in the entity's featuresSchema accepts only env, file and arg, pour tout autre mécanisme, qu’aucun emplacement ne peut déclarer.

Un rattachement déclaré à une portée plus large — à l’échelle d’un sous-système, en cascade sur chaque composant en dessous — est soumis à la même forme, et il est vérifié par rapport à l’emplacement sur chaque composant qu’il atteint. Le même rattachement peut donc être conforme pour un composant et non conforme pour un autre, si bien que cette forme nomme le composant et l’emplacement par rapport auquel il a échoué, et situe le rattachement à la portée où il a été déclaré plutôt qu’à une clé de son bloc de livraison :

attachment does not conform to its declared slot shape (Aggregate <name>, at .spec.subsystems.<scope>.features.<attachment>, this attachment is declared at a scope that reaches component <component>, whose attachment slot <slot> does not accept the delivery it carries: move the attachment down to the components that may receive it) (le rattachement n’est pas conforme à la forme déclarée de son emplacement (avec l’Aggregate et le chemin indiqués, ce rattachement est déclaré à une portée qui atteint le composant indiqué, dont l’emplacement de rattachement indiqué n’accepte pas la livraison qu’il porte : descendez le rattachement vers les composants qui peuvent le recevoir))

Un rattachement que porte une connexion n’atteint jamais cet arrêt. Sa forme est fermée là où il est écrit : sur l’entrée de connexion de l’Aggregate, il accepte type, description et values, et sur celle de la Release type, description et infra, de sorte qu’il ne peut imposer aucune livraison — un inject: écrit à cet endroit est refusé au chargement du document, en nommant la clé — et l’entrée du Workload qui le livre est soumise à la place à la liste d’autorisation inject de l’emplacement du socket. Aucune portée n’atteint non plus l’emplacement d’un socket, si bien que la forme à l’échelle d’une portée décrite ci-dessus n’a pas d’équivalent sur une connexion.

Comment corriger : les formes appellent deux modifications différentes, et le chemin de champ vous indique laquelle vous avez. Lorsqu’il nomme un rattachement sur un composant, ou une clé à l’intérieur de celui-ci, la faute porte sur la livraison : supprimez-la, ou déplacez ses entrées sous un mécanisme que nomme la liste d’autorisation inject de l’emplacement. Lorsque le matériau doit réellement atteindre la charge de travail par un mécanisme que l’emplacement ne liste pas, la liste d’autorisation dans le featuresSchema de l’entité de catalogue peut être élargie — mais seulement avec env, file ou arg, les mécanismes qu’un emplacement peut déclarer ; un Component qui y nomme tout autre mécanisme échoue à la validation lors de son chargement, si bien que pour tout autre mécanisme, le supprimer est la seule correction. Lorsqu’il nomme un rattachement à une portée, le rattachement est bien formé et la faute porte sur son placement : descendez-le sur les composants dont l’emplacement accepte la livraison, en laissant hors de son atteinte les composants qui réservent la livraison à leur Recipe.

Duplicate delivery key across inject sources (Clé de livraison en double entre les sources d’inject)

La même clé de livraison (par exemple, le même nom de variable d’environnement) est revendiquée deux fois parmi les sources d’inject rédigées par le développeur pour un composant — au niveau du Component et sous une entrée uses[], par deux entrées uses[] sur le même composant, ou sous deux mécanismes de livraison du propre bloc inject: du Component. La livraison ne peut pas provenir de deux endroits à la fois, si bien qu’une clé revendiquée deux fois est une contradiction et non une question de savoir laquelle l’emporte.

La build lit cela à quatre endroits, parce qu’ils voient des ensembles différents de sources rédigées et de connexions de dépendance et leur posent des questions différentes, et chacun signale sous sa propre forme.

Le premier lit les connexions que vous avez écrites dans l’Aggregate, et signale pendant la résolution de vos fichiers. Il nomme le mécanisme de livraison, la clé, puis le socket et l’alias de la première connexion, dans l’ordre de rédaction, qui la revendique aussi :

duplicate delivery key across inject sources (Aggregate <name>, at .spec.components.<component>.inject.<mechanism>.<key>, "<mechanism>", "<key>", "<socket>", "<alias>") (clé de livraison en double entre les sources d’inject (avec l’Aggregate, le chemin, le mécanisme, la clé, le socket et l’alias indiqués))

Le deuxième lit ce même bloc rédigé et lui pose une question différente : à savoir si le composant revendique une clé sous deux de ses propres mécanismes de livraison, sans aucune connexion en jeu. Il signale une fois par mécanisme revendiquant la clé, positionné sur la propre entrée de ce mécanisme, et nomme le mécanisme dont traite le constat, la clé, puis chaque autre mécanisme qui la revendique, dans l’ordre de rédaction :

duplicate delivery key across inject sources (Aggregate <name>, at .spec.components.<component>.inject.<mechanism>.<key>, "<mechanism>", "<key>", "<other-mechanism>") (clé de livraison en double entre les sources d’inject (avec l’Aggregate, le chemin, le mécanisme, la clé et l’autre mécanisme indiqués))

Aucun des deux mécanismes n’est fautif, et c’est à vous d’agir sur les deux constats : renommez la clé sous l’un d’eux, ou supprimez l’une des deux livraisons. Les mécanismes qu’un composant peut utiliser sont une question distincte, à laquelle répond sa liste d’autorisation spec.inject — voir « Self-inject mechanism not in the component’s allowlist (Mécanisme de self-inject absent de la liste d’autorisation du composant) » ci-dessous.

Un composant qu’un module fournit rencontre lui aussi ces deux premières formes, lues dans le propre document du module une fois construite la composition qui l’importe ; elles nomment alors l’Aggregate du module et la clé dans son document.

Le troisième lit les connexions que porte la topologie terminée, y compris celles qu’un rattachement de Feature a fournies en votre nom. Il s’exécute avant tout rendu, et nomme la clé de livraison que vous avez écrite ainsi que le socket de dépendance qui la livre aussi :

duplicate delivery key across self-inject and uses-inject ("<key>", socket "<socket>") (clé de livraison en double entre self-inject et uses-inject (la clé indiquée, le socket indiqué))

Une clé rédigée livrée par deux sockets de dépendance est signalée une fois par socket, de sorte qu’une seule build vous les signale tous plutôt que celui qui a été atteint en premier.

Le quatrième lit la même topologie terminée et lui pose une question différente : à savoir si deux des propres connexions de dépendance d’un composant livrent une même clé entre elles, sans que le composant lui-même ne revendique rien. Il signale une fois sur chaque connexion, positionné sur la propre entrée de livraison de cette connexion, et nomme le chemin de l’entrée suivi de chaque socket qui livre la clé :

duplicate delivery key across inject sources ("inject.<mechanism>.<key>", "<socket>", "<socket>") (clé de livraison en double entre les sources d’inject (avec le chemin de l’entrée et les sockets indiqués))

Un socket nommé deux fois est ce qui vous indique que les deux connexions se trouvent sur un même socket sous des alias différents — la position est alors la seule chose qui les distingue ; lisez donc le chemin de champ de chacun des deux constats plutôt que les noms des sockets.

Aucune des deux connexions n’est fautive, et c’est à vous d’agir sur les deux : renommez l’une des clés, ou supprimez l’une des deux livraisons.

Lorsque la clé est un chemin, le chemin de champ nomme à la place le bloc du mécanisme. Ce qu’exprime une clé de livraison est l’affaire du mécanisme lui-même, et un mécanisme file livre dans un chemin de montage — une telle clé contient donc des points, alors qu’un chemin de champ sépare ses propres étapes avec eux. Un chemin de champ s’arrête à la dernière étape qu’il peut nommer sans ambiguïté plutôt que d’en écrire une qui se lirait comme un parcours à travers des clés que votre document ne contient pas ; pour une clé comme /etc/app/config.yaml, il se lit donc .spec.components.<component>.inject.<mechanism> et s’arrête là. Le message nomme la clé dans les deux cas, ce qui rend le constat tout aussi exploitable — mais l’endroit du message où la lire diffère selon les quatre formes ci-dessus ; lisez donc le chemin de champ pour le bloc, puis prenez la clé dans celle des quatre que vous avez : lorsque le détail commence par le mécanisme de livraison, la clé est la valeur entre guillemets qui le suit immédiatement ; lorsque le détail commence par la clé seule, c’est la première valeur entre guillemets ; et lorsque le détail commence par le propre chemin de l’entrée de livraison, la clé est la dernière étape de ce chemin.

Comment corriger : renommez l’une des clés en conflit, ou supprimez la déclaration en double. Notez que l’injectMapping d’une FeatureRecipe qui réécrit une clé livrée par le propre bloc inject: du composant ou par l’un des blocs inject: de ses connexions constitue une interception intentionnelle et n’est signalé ni ici ni ailleurs.

Une clé revendiquée par une Feature rattachée au composant rencontre le même espace partagé depuis la troisième de ses trois surfaces de rédaction, et elle est signalée sous « An attachment delivers a key another inject source already claimed (Un rattachement livre une clé qu’une autre source d’inject a déjà revendiquée) » ci-dessous ; une clé que livrent deux Features rattachées, la seconde des deux la livrant par l’injectMapping de sa FeatureRecipe, est signalée sous « Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Deux Features rattachées livrent une même clé, la seconde par l’injectMapping de sa FeatureRecipe) ».

Self-inject on a component without an allowlist (Self-inject sur un composant sans liste d’autorisation)

Le développeur a écrit un bloc inject: au niveau du composant, mais l’entité de catalogue du Component ne déclare pas spec.inject. Les Components sans liste d’autorisation spec.inject sont des types Black-Box — ils ne reçoivent aucune injection rédigée par le développeur.

Message émis :

self-inject on component without spec.inject allowlist (Aggregate <name>, at .spec.components.<component>.inject, "inject", "<component-type>") (self-inject sur un composant sans liste d’autorisation spec.inject (avec l’Aggregate, le chemin, la clé inject et le type de composant indiqués))

Le constat est positionné sur le bloc inject: lui-même, qui est l’élément à supprimer.

Comment corriger : supprimez le bloc inject: de cette instance de Component, ou passez à un type de Component White-Box dont la déclaration de catalogue inclut spec.inject.

Self-inject mechanism not in the component’s allowlist (Mécanisme de self-inject absent de la liste d’autorisation du composant)

Le développeur a écrit un bloc inject: au niveau du composant en utilisant un mécanisme (par exemple env ou une forme précise de montage de fichier) qui ne figure pas dans la liste d’autorisation spec.inject du Component.

Message émis :

self-inject on component without spec.inject allowlist (Aggregate <name>, at .spec.components.<component>.inject.<mechanism>, "<component-type>", "<mechanism>", "<allowlisted-mechanism-1>", "<allowlisted-mechanism-2>", …) (self-inject sur un composant sans liste d’autorisation spec.inject (avec l’Aggregate, le chemin, le type de composant, le mécanisme et les mécanismes autorisés indiqués))

Les mécanismes que le type autorise suivent celui qui a été imposé, de sorte que le message porte à la fois ce qui a été écrit et ce que le type permet. Un type qui ne déclare aucune liste d’autorisation signale le mécanisme imposé sans rien après.

Cette règle comme la précédente s’appliquent à un composant qu’un module fournit, une fois construite la composition qui importe le module ; le constat nomme alors l’Aggregate du module et la clé dans son document.

Comment corriger : passez à un mécanisme figurant dans la liste d’autorisation, ou, si le Component doit prendre en charge le mécanisme dont vous avez besoin, étendez sa liste d’autorisation spec.inject dans le catalogue.

uses edge dictates delivery on a socket that allowlists none (Une arête impose la livraison sur un socket qui n’autorise aucun mécanisme)

Un bloc inject: sur une arête uses: se câble dans un socket dont l’entrée de usesSchema ne déclare aucune liste d’autorisation inject:, ou en déclare une vide. Un tel socket est une connexion Black-Box : l’entité qui l’a déclaré traite en interne les valeurs de la dépendance, de sorte que le consommateur prend ce qu’émet la Recipe du producteur et ne choisit pas la forme de livraison. Une clé inject: absente et inject: [] sont la même déclaration.

Le socket est lu sur l’entité, quelle qu’elle soit, qui l’a déclaré : une arête rédigée sur un rattachement de Feature se résout par rapport au usesSchema de la Feature rattachée, et toute autre arête par rapport à celui du Component consommateur.

Message émis. Le refus vient d’abord, puis les mécanismes que l’arête a imposés, le socket et l’entité dont la déclaration a été lue — puis ce qu’il faut faire :

uses-edge inject dictates a delivery mechanism the socket does not permit ("<mechanism>", on socket "<socket>", declared on the component type "<component-type>"). The socket declares no delivery allowlist, so it permits no dictation at all — the entity that declared it delivers the dependency’s values itself. Remove the inject block from this connection and read the values from the connection’s provides in the consuming Recipe, or declare the mechanisms the socket permits in its usesSchema entry. (l’inject de l’arête uses impose un mécanisme de livraison que le socket n’autorise pas (le mécanisme indiqué, sur le socket indiqué, déclaré sur le type de composant indiqué). Le socket ne déclare aucune liste d’autorisation de livraison, il n’autorise donc aucune imposition — l’entité qui l’a déclaré livre elle-même les valeurs de la dépendance. Supprimez le bloc inject de cette connexion et lisez les valeurs dans les provides de la connexion dans la Recipe consommatrice, ou déclarez les mécanismes que le socket autorise dans son entrée usesSchema.)

Le constat est positionné sur l’entrée rédigée qu’il concerne, dans le document où cette entrée a été écrite : .spec.components.<consumer>.uses.<socket>.<alias> pour une arête tracée par le propre bloc uses: d’un composant, et .spec.components.<consumer>.features.<attachment>.uses.<socket>.<alias> pour une arête tracée par un rattachement — enraciné dans le bloc qui a déclaré le rattachement, qui peut être celui d’un sous-système ou d’une frontière plutôt que celui du composant lui-même. Lorsque le socket a été déclaré sur la Feature rattachée, le message nomme le type de fonctionnalité à la place du type de composant. Chaque arête fautive est signalée comme un constat distinct, de sorte qu’une seule build les nomme toutes.

Comment corriger : supprimez le bloc inject: de l’arête et lisez plutôt les valeurs de la dépendance depuis .context.uses.<alias>.provides.<name> dans la Recipe consommatrice ; ou, si la connexion doit être transparente, déclarez les mécanismes de livraison que le socket autorise dans la liste d’autorisation inject: de son entrée de usesSchema.

Un socket que l’entité déclarante n’a jamais déclaré du tout est un cas différent et n’est pas refusé ici : un socket ad hoc ne porte aucune liste d’autorisation, il n’y a donc rien en dehors de quoi l’arête pourrait se trouver.

uses edge dictates a delivery mechanism outside the socket’s allowlist (Une arête impose un mécanisme de livraison en dehors de la liste d’autorisation du socket)

Un bloc inject: sur une arête uses: nomme un mécanisme de livraison que la liste d’autorisation inject: du socket ne mentionne pas. La liste d’autorisation est la déclaration, par l’entité déclarante, des formes de livraison à partir desquelles son point d’entrée peut effectivement lire les valeurs de la dépendance, de sorte qu’un mécanisme en dehors de celle-ci livrerait des valeurs que rien ne consomme.

Chaque mécanisme que nomme le bloc est vérifié, et chacun de ceux qui sont en dehors de la liste d’autorisation est signalé, de sorte qu’une seule build les nomme tous au lieu d’un par exécution.

Message émis. Le refus vient d’abord, puis le mécanisme refusé, le socket, ce que ce socket autorise, et l’entité dont la déclaration a été lue :

uses-edge inject dictates a delivery mechanism the socket does not permit ("<mechanism>", on socket "<socket>", which permits "<mechanism-1>, <mechanism-2>", declared on the component type "<component-type>"). Dictate one of the mechanisms the socket permits, or widen that socket’s inject allowlist in the declaring entity’s usesSchema entry. (l’inject de l’arête uses impose un mécanisme de livraison que le socket n’autorise pas (le mécanisme indiqué, sur le socket indiqué, qui autorise les mécanismes indiqués, déclaré sur le type de composant indiqué). Imposez l’un des mécanismes que le socket autorise, ou élargissez la liste d’autorisation inject de ce socket dans l’entrée usesSchema de l’entité déclarante.)

Le constat est positionné sur l’entrée rédigée qu’il concerne, sur les mêmes chemins que nomme le refus ci-dessus. Lorsque le socket a été déclaré sur la Feature rattachée, le message nomme le type de fonctionnalité à la place du type de composant.

Comment corriger : passez à l’un des mécanismes autorisés, ou, si l’entité doit prendre en charge le mécanisme dont vous avez besoin, élargissez la liste d’autorisation inject: de ce socket dans son entrée usesSchema du catalogue.

An inject: entry carries both a literal and a source key (Une entrée d’inject porte à la fois un littéral et une clé source)

Une entrée inject: livre l’une de deux choses : un littéral, écrit sous value: — sur le propre bloc d’un composant, le seul endroit où un littéral est livré — ou une clé lue dans le composant vers lequel pointe la connexion, écrite sous from:. Une entrée qui porte les deux dit deux choses à la fois et n’offre aucune règle pour choisir entre elles, elle est donc refusée plutôt que de laisser l’une des deux l’emporter discrètement.

Les schémas de rédaction n’admettent qu’exactement l’un des deux, de sorte qu’un document lu depuis un fichier est refusé à son chargement. Ceci est la vérification qui se tient derrière celle-là : elle lit chaque bloc inject: que portent l’Aggregate et la Release pendant que les deux documents sont résolus, de sorte qu’un document construit par une autre voie qu’un fichier est tout de même refusé avant que quoi que ce soit ne soit construit à partir de lui, plutôt que de voir un champ choisi en silence. Elle couvre les mêmes blocs que la vérification de forme ci-dessous.

Chaque mécanisme de livraison contenant une entrée fautive est signalé comme un constat distinct, positionné sur ce mécanisme dans le document qui l’a écrit — .spec.components.<component>.inject.env pour le propre bloc d’un composant — et tous ceux de la build sont signalés en une fois. Le constat nomme le mécanisme puis le champ in: de chaque entrée fautive dans la liste de ce mécanisme.

Message émis :

inject entry carries both value: and from:; schema requires exactly one ("<mechanism>", "<in-1>", "<in-2>") (l’entrée d’inject porte les deux champs ; le schéma en exige exactement un (avec le mécanisme et les entrées indiqués))

Comment corriger : ouvrez chaque entrée que nomme le message et supprimez celui des deux dont elle n’a pas besoin. Conservez from: là où la valeur doit venir du composant vers lequel pointe la connexion — il nomme une clé que déclare le provides: de ce composant. Conservez value: là où la valeur est un littéral que fournit ce côté, sur le propre bloc d’un composant ; sur une connexion et sur le propre bloc d’une Feature attachée, un littéral est refusé, conservez donc from: à cet endroit.

An inject: entry on a connection carries a literal (Une entrée d’inject sur une connexion porte un littéral)

Une connexion livre au composant consommateur ce que publie le composant vers lequel elle pointe : chaque entrée du bloc inject: de la connexion nomme sous from: l’une des clés provides: de ce composant. Un littéral écrit sous value: ne nomme rien de ce que publie la cible, il n’a donc pas sa place sur une connexion, et l’entrée est refusée plutôt qu’abandonnée. Un littéral qu’un composant se livre à lui-même appartient au propre bloc inject: du composant, où value: est admis.

Chaque connexion est vérifiée, quel que soit le document qui l’a tracée : une sur le propre bloc uses: d’un composant, une que trace une Feature rattachée dans l’Aggregate, et une que trace un rattachement écrit dans la Release. Elle est refusée avant que quoi que ce soit ne soit rendu, de sorte que aggrega validate --release la signale tout comme aggrega build.

Chaque entrée fautive est signalée comme un constat distinct, positionné sur l’entrée de la connexion dans le document qui l’a tracée — .spec.components.<component>.uses.<socket>.<alias> pour la propre connexion d’un composant, .spec.components.<component>.features.<attachment>.uses.<socket>.<alias> pour une connexion que trace un rattachement, et, dans la Release, le même chemin sous l’entrée du rattachement, comme .spec.boundaries.<boundary>.components.<component>.features.<attachment>.uses.<socket>.<alias> — et toutes celles de la build sont signalées en une fois. Un constat dans l’Aggregate est classé sous DEVELOPER_ERROR, un constat dans la Release sous OPS_ERROR. Le constat nomme le mécanisme et le champ in: de l’entrée.

Message émis :

inject entry on a connection carries value:; a connection delivers the target’s published keys, each named with from: ("<mechanism>", "<in>") (l’entrée d’inject sur une connexion porte un littéral ; une connexion livre les clés publiées de la cible, chacune nommée comme source (avec le mécanisme et l’entrée indiqués))

Comment corriger : lorsque la valeur est l’une de celles que publie la cible, remplacez value: par from: nommant cette clé provides:. Lorsqu’il s’agit d’un littéral dont le composant consommateur a besoin, déplacez l’entrée vers le propre bloc inject: de ce composant, dont les mécanismes sont régis par la liste d’autorisation spec.inject de son type de Component.

An inject: entry on an attached Feature carries a literal (Une entrée d’injection sur une Feature attachée porte un littéral)

Le bloc inject: écrit sur une Feature attachée livre au composant ce que publie la FeatureRecipe de cet attachement : chaque entrée nomme l’une des clés que publie le provides: de la FeatureRecipe, sous from:. Un littéral écrit sous value: ne nomme rien que publie l’attachement, de sorte que rien n’atteindrait le composant sous l’in: de cette entrée ; l’entrée est refusée plutôt que construite puis abandonnée. Un littéral dont le composant a besoin a sa place dans le propre bloc inject: du composant, où value: est admis et livré.

Chaque attachement sur lequel un Aggregate écrit un bloc inject: est vérifié : celui du propre bloc features: d’un composant et celui du bloc features: d’un sous-système, qui atteint chaque composant que contient le sous-système — dans l’Aggregate que nomme la Release et dans chaque module que cet Aggregate importe sous aggregates:, à n’importe quelle profondeur. Une connexion que trace un attachement porte son propre bloc inject:, et un littéral à cet endroit relève du refus des connexions décrit ci-dessus. Un attachement de la Release n’écrit aucun bloc inject: propre. L’entrée est refusée avant tout rendu, de sorte que aggrega validate --release la signale tout comme aggrega build.

Chaque entrée fautive est signalée comme un constat distinct, classé sous DEVELOPER_ERROR contre l’Aggregate dont le document a écrit le bloc — le propre document d’un module pour un attachement écrit dans un module — et positionné sur le mécanisme de livraison à l’intérieur du bloc de l’attachement dans ce document : .spec.components.<component>.features.<attachment>.inject.<mechanism>, ou .spec.subsystems.<subsystem>.features.<attachment>.inject.<mechanism> pour l’attachement d’un sous-système. Toutes celles d’un document sont signalées en une fois ; celles d’un module importé sont signalées dès que l’Aggregate importateur passe la vérification. Le constat nomme le mécanisme et l’in: de l’entrée. Une entrée qui porte à la fois value: et from: est signalée une seule fois, sous « An inject: entry carries both a literal and a source key (Une entrée d’injection porte à la fois un littéral et une clé source) » ci-dessus.

Message émis :

inject entry on an attachment carries value:; an attachment delivers the keys its FeatureRecipe publishes, each named with from:, and a literal belongs in the component’s own inject block ("<mechanism>", "<in>") (une entrée inject sur un attachement porte un littéral ; un attachement livre les clés que publie sa FeatureRecipe, chacune nommée comme clé source, et un littéral a sa place dans le propre bloc inject du composant)

Comment corriger : lorsque la valeur est l’une de celles que publie la FeatureRecipe de l’attachement, remplacez value: par from: nommant cette clé provides:. Lorsqu’il s’agit d’un littéral dont le composant a besoin, déplacez l’entrée vers le propre bloc inject: du composant, dont les mécanismes sont régis par la liste d’autorisation spec.inject de son type de Component :

components:
api:
type: core/api
inject:
env:
- in: LITERAL_NAME
value: a-literal # the literal, delivered by the component's own block
features:
token:
type: core/token
inject:
env:
- in: TOKEN_NAME
from: name # a key the attachment's FeatureRecipe publishes

An inject: delivery is not a list of entries (Une livraison d’inject n’est pas une liste d’entrées)

Chaque mécanisme de livraison d’un bloc inject: — env, file, arg, ou un mécanisme nommé à côté d’eux — est une liste d’entrées, chacune portant in: et exactement l’un de from: ou value:. Un mécanisme contenant autre chose, comme une correspondance de noms vers des clés, ne livre rien que le compilateur puisse lire, il est donc refusé plutôt qu’abandonné. Un mécanisme écrit sans aucune valeur ne livre rien et n’est pas refusé.

Les schémas de rédaction n’admettent que la liste, de sorte qu’un document lu depuis un fichier est refusé à son chargement, en tant que document qui ne correspond pas au schéma de son type. Ceci est la vérification qui se tient derrière celle-là : elle lit chaque bloc inject: que portent l’Aggregate et la Release pendant que les deux documents sont résolus, de sorte qu’un document construit par une autre voie qu’un fichier est tout de même refusé avant que quoi que ce soit ne soit construit à partir de lui, plutôt que de voir la livraison disparaître. Elle couvre chaque bloc que porte l’un ou l’autre document : dans l’Aggregate, le propre bloc d’un composant, celui d’un rattachement, et ceux des connexions que trace l’un ou l’autre ; dans la Release, ceux des connexions que tracent ses rattachements.

Chaque mécanisme fautif est signalé comme un constat distinct, positionné sur ce mécanisme dans le document qui l’a écrit et nommant le mécanisme, et tous ceux de la build sont signalés en une fois. Les constats de l’Aggregate sont signalés avant ceux de la Release.

Message émis :

inject delivery: shape must be a list of entries, each in: with exactly one of from: or value: ("<mechanism>") (livraison inject : la forme doit être une liste d’entrées, chacune avec une destination et exactement une source ou un littéral (avec le mécanisme indiqué))

La position est le chemin de clés que l’auteur a écrit. Dans l’Aggregate, .spec.components.<component>.inject.<mechanism> pour le propre bloc d’un composant, .spec.components.<component>.uses.<socket>.<alias>.inject.<mechanism> pour un bloc sur l’une de ses connexions, et .spec.components.<component>.features.<attachment>… pour celui d’un rattachement, avec .subsystems.<name> pour chaque sous-système dans lequel un composant ou un rattachement est déclaré. Dans la Release, le bloc sur une connexion que trace un rattachement, à travers ce rattachement — .spec.boundaries.<boundary>.features.<attachment>.uses.<socket>.<alias>.inject.<mechanism> pour un rattachement à l’échelle de toute la frontière, .spec.boundaries.<boundary>.components.<component>.features.<attachment>… pour un rattachement sur un composant, avec .boundaries.<name> pour chaque frontière imbriquée et .aggregates.<module> pour chaque entrée de routage par laquelle un composant est nommé.

Comment corriger : écrivez sous forme de liste chaque mécanisme que nomme le message. Une entrée DB_URL: host sous env: devient - in: DB_URL avec from: host lorsque host nomme une clé provides: — celle du composant connecté sur une connexion, celle du composant lui-même sur son propre bloc — ou, sur le propre bloc du composant, avec value: host lorsqu’il s’agit d’un littéral que fournit ce côté.

The Feature filling an attachment slot does not satisfy the slot’s selector (La Feature qui remplit un emplacement de rattachement ne satisfait pas le sélecteur de l’emplacement)

Un Component déclare des points de liaison nommés pour les Features qu’il attend, et un emplacement peut déclarer un selector: qui contraint les labels de ce qui le remplit. Un rattachement lie un emplacement en portant le nom de l’emplacement ; lorsqu’il le fait, les labels de la Feature qu’il nomme sont confrontés à cette contrainte, et un remplissage qui ne la satisfait pas arrête la build. Un emplacement qui ne déclare aucune contrainte accepte n’importe quel remplissage.

Savoir si un emplacement peut seulement rester non lié est une autre question, avec un autre remède, signalée par son propre arrêt ci-dessus : celui-ci présuppose un remplissage et demande si ce remplissage est admissible, de sorte qu’un emplacement non lié ne le concerne pas.

Deux issues sont signalées sous cette même condition, et le message les distingue par ce que dit sa dernière valeur. Un remplissage qui n’a pas satisfait la contrainte nomme la Feature dont les labels n’ont pas correspondu. Une contrainte qui n’a pas pu être lue du tout nomme à la place la raison — une expression que le comparateur de labels n’a pas pu évaluer — ce qui est une faute dans la propre déclaration de l’emplacement plutôt que dans ce qui lui a été rattaché.

Message émis, lorsque les labels du remplissage n’ont pas satisfait la contrainte :

attachment slot selector unsatisfied ("<selector>", declared on slot "<slot>", not satisfied by the labels of the Feature filling it, "<feature-type>"). Add the labels the slot’s selector requires to the Feature’s labels, or fill the slot with a Feature that already carries them. (sélecteur de l’emplacement de rattachement non satisfait (le sélecteur indiqué, déclaré sur l’emplacement indiqué, non satisfait par les labels de la Feature qui le remplit, le type de Feature indiqué). Ajoutez aux labels de la Feature les labels qu’exige le sélecteur de l’emplacement, ou remplissez l’emplacement avec une Feature qui les porte déjà.)

et lorsque la contrainte elle-même n’a pas pu être évaluée :

attachment slot selector unsatisfied ("<selector>", declared on slot "<slot>", which could not be evaluated: "<why it could not be evaluated>"). Correct the selector on the slot’s declaration in the component’s catalog entity. (sélecteur de l’emplacement de rattachement non satisfait (le sélecteur indiqué, déclaré sur l’emplacement indiqué, qui n’a pas pu être évalué : avec la raison indiquée). Corrigez le sélecteur dans la déclaration de l’emplacement, dans l’entité de catalogue du composant.)

Il est positionné sur la clé du remplissage dans le document qui a écrit le remplissage, et classé sous l’auteur de ce document : le bloc features: du composant dans l’Aggregate est une faute du développeur, et un remplissage que seule la Release effectue — sur son entrée pour le composant, ou sur une frontière qui le contient — est une faute de l’opérateur, signalée sur le propre chemin de la Release :

[OPS_ERROR E0008] release.yaml at .spec.boundaries.main.components.app.features.identity
attachment slot selector unsatisfied ("feature.aggrega.ai/kind!=secret", declared on slot "identity", not satisfied by the labels of the Feature filling it, "core/secret-value"). Add the labels the slot's selector requires to the Feature's labels, or fill the slot with a Feature that already carries them.

Le même remplissage écrit sur le composant dans l’Aggregate signale [DEVELOPER_ERROR E0008] aggregate.yaml at .spec.components.app.features.identity.

Un emplacement que déclare un socket — dans le featuresSchema d’une entrée de usesSchema — soumet de la même manière le remplissage de chaque connexion à son selector:. Le rattachement qu’une connexion porte dans l’emplacement est confronté à la contrainte, et un remplissage qu’elle n’admet pas arrête la build, en nommant le socket et la connexion en plus de l’emplacement :

attachment slot selector unsatisfied ("<selector>", declared on slot "<slot>", of socket "<socket>", filled on the connection "<alias>", not satisfied by the labels of the Feature filling it, "<feature-type>"). Add the labels the slot’s selector requires to the Feature’s labels, or fill the slot with a Feature that already carries them. (sélecteur de l’emplacement de rattachement non satisfait (le sélecteur indiqué, déclaré sur l’emplacement indiqué, du socket indiqué, rempli sur la connexion indiquée, non satisfait par les labels de la Feature qui le remplit, le type de Feature indiqué). Ajoutez aux labels de la Feature les labels qu’exige le sélecteur de l’emplacement, ou remplissez l’emplacement avec une Feature qui les porte déjà.)

Il est positionné sur la clé du rattachement sous le features: de cette connexion, dans le document qui a écrit le remplissage : l’entrée de connexion de l’Aggregate, ou l’entrée par arête de la Release pour un remplissage que seule la Release effectue.

Un sélecteur d’emplacement que la grammaire ne peut pas lire est aussi refusé avant que quoi que ce soit ne remplisse l’emplacement. aggrega validate, sur l’ensemble du catalogue ou sur un seul Component ou une seule Feature, lit chaque sélecteur d’emplacement que déclare le document propre de l’entité — les emplacements propres d’un Component, les emplacements que déclarent ses sockets, et les emplacements d’une Feature — et refuse celui que la grammaire ne peut pas lire sous cette même condition, que quelque chose remplisse l’emplacement ou non. Le message est la forme « n’a pas pu être évalué » ci-dessus ; un emplacement que déclare un socket ajoute le socket :

attachment slot selector unsatisfied ("<selector>", declared on slot "<slot>", of socket "<socket>", which could not be evaluated: "<why it could not be evaluated>"). Correct the selector on the slot’s declaration in the socket’s featuresSchema on the component’s catalog entity. (sélecteur d’emplacement de rattachement non satisfait, déclaré sur l’emplacement du socket, qui n’a pas pu être évalué. Corrigez le sélecteur dans la déclaration de l’emplacement, dans le featuresSchema du socket, sur l’entité de catalogue du composant.)

Sur un emplacement d’une Feature, le remède nomme plutôt l’entité de catalogue de la Feature. Rien n’a rempli l’emplacement, la faute revient donc à l’entité de catalogue : elle est classée comme CATALOG_ERROR et nomme le fichier de l’entité.

Comment corriger : pour un remplissage qui n’a pas satisfait la contrainte, rattachez une Feature dont les labels la satisfont — le sélecteur dans le message indique quels labels sont demandés — ou élargissez le selector: de l’emplacement dans le Component qui le déclare. Lorsque le message indique que la contrainte n’a pas pu être évaluée, la faute est dans l’expression du sélecteur : corrigez-la dans la déclaration d’emplacement du Component, ou dans celle du socket.

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)

La surface de rattachement propre d’un Component est ouverte : un rattachement sous un nom qu’aucun emplacement ne déclare est un rattachement libre, et il est légal. Une seule structure sur cette surface arrête la build, parce que c’est la structure que prend un remplissage destiné à un emplacement lorsqu’il est écrit sous le mauvais nom. La build s’arrête lorsque toutes ces conditions sont réunies pour un même rattachement :

  • il est écrit sur le composant lui-même — sur le propre bloc features: du composant dans l’Aggregate, ou sur l’entrée de la Release pour ce seul composant ;
  • son nom n’est pas un emplacement que déclare le type du composant ;
  • les labels de sa Feature satisfont le selector: d’un emplacement que déclare le type ;
  • rien ne lie cet emplacement sur le composant une fois toutes les portées fusionnées.

Laissé tel quel, un tel rattachement est un rattachement libre tandis que l’emplacement auquel il était destiné reste vide — et un emplacement facultatif laissé vide produit une build verte et ne livre rien. La règle vaut pour toute Feature, pas seulement pour les justificatifs d’identité.

Tout le reste de la surface reste libre. Un rattachement dont la Feature ne correspond à aucun emplacement déclaré n’arrête pas la build ; un rattachement supplémentaire à côté d’un emplacement que quelque chose lie déjà non plus, tant qu’aucun autre emplacement auquel il correspond n’est laissé vide. Un rattachement que le composant hérite d’un sous-système ou d’une frontière de Release n’est jamais jugé, de sorte que la structure partagée — un justificatif d’identité rattaché une seule fois à une portée où se trouvent plusieurs composants, sans qu’aucun composant ne remplisse l’emplacement — n’arrête pas la build. Un emplacement qui ne déclare aucun selector: ne dit rien de la Feature à laquelle il est destiné, si bien qu’aucun rattachement n’y est soumis de cette manière. Un rattachement que porte une connexion n’est pas non plus jugé ici : les emplacements d’un socket forment un ensemble fermé, et tout autre nom sur une connexion arrête la build sous « 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) ».

Message émis. La phrase de la condition vient d’abord, puis le nom sous lequel le rattachement a été écrit, le composant, la Feature qu’il rattache et l’emplacement vide auquel il correspond — puis ce qu’il faut faire :

attachment written under a name no slot declares fits a slot its component leaves empty ("<attachment>", on component "<component>", attaching the Feature "<feature-type>", which fits the empty slot "<slot>"). Attach it as "<slot>" to fill the slot. (un rattachement écrit sous un nom qu’aucun emplacement ne déclare correspond à un emplacement que son composant laisse vide (le rattachement indiqué, sur le composant indiqué, rattachant la Feature indiquée, qui correspond à l’emplacement vide indiqué). Rattachez-le sous le nom de l’emplacement indiqué pour remplir l’emplacement.)

Lorsque la Feature correspond à plus d’un emplacement vide, le message les nomme tous, dans l’ordre où le type du composant les déclare, et vous laisse le choix :

attachment written under a name no slot declares fits a slot its component leaves empty ("<attachment>", on component "<component>", attaching the Feature "<feature-type>", which fits the empty slot "<slot>", and the empty slot "<another-slot>"). Attach it under the name of the slot it is meant to fill. (un rattachement écrit sous un nom qu’aucun emplacement ne déclare correspond à un emplacement que son composant laisse vide (le rattachement indiqué, sur le composant indiqué, rattachant la Feature indiquée, qui correspond à l’emplacement vide indiqué et à l’autre emplacement vide indiqué). Rattachez-le sous le nom de l’emplacement qu’il doit remplir.)

Il est positionné sur la clé du rattachement dans le document qui l’a écrit, et classé sous l’auteur de ce document. Un rattachement sur le propre bloc features: du composant dans l’Aggregate est signalé à .spec.components.<component>.features.<attachment> comme une faute du développeur ; un rattachement que seule la Release a écrit, sur son entrée pour le composant, y est signalé — sous la frontière qui nomme le composant, .spec.boundaries.<boundary>.components.<component>.features.<attachment> — comme une faute de l’opérateur :

[OPS_ERROR E0328] release.yaml at .spec.boundaries.main.components.app.features.metrics
attachment written under a name no slot declares fits a slot its component leaves empty ("metrics", on component "app", attaching the Feature "core/prometheus-exporter", which fits the empty slot "identity"). Attach it as "identity" to fill the slot.

L’emplacement vide lui-même est un constat distinct lorsqu’il est requis, signalé sur le composant dans l’Aggregate sous « Required attachment slot not bound (Emplacement de rattachement requis non lié) ».

En quoi cela diffère de l’avertissement de quasi-correspondance. L’avertissement décrit sous « An attachment name is one edit from a declared slot (Un nom de rattachement est à une modification près d’un emplacement déclaré) » porte sur la façon dont un nom est orthographié : un nom à une modification près d’un emplacement dont la Feature du rattachement ne satisfait pas le selector:, ce qui n’arrête pas la build et signale un avertissement. Cet arrêt porte sur ce à quoi la Feature correspond, quel que soit le nom : le nom peut être n’importe lequel, et l’emplacement auquel elle correspond doit avoir été laissé vide. Lorsqu’un nom est à une modification près d’un emplacement et que sa Feature correspond bien à cet emplacement, aucun avertissement n’est levé, et si l’emplacement est laissé vide, cet arrêt est le seul constat signalé.

Comment corriger : rattachez-le sous le nom de l’emplacement, afin qu’il remplisse l’emplacement — le message nomme l’emplacement, ou chaque candidat lorsqu’il y en a plusieurs. S’il s’agit réellement d’un rattachement distinct, remplissez aussi l’emplacement, puisqu’un rattachement supplémentaire est libre une fois que chaque emplacement auquel il correspond est lié ; ou, lorsqu’il doit atteindre plusieurs composants, rattachez-le au sous-système ou à la frontière de Release où ils se trouvent. Si la Feature ne doit jamais remplir cet emplacement, restreignez le selector: de l’emplacement dans le Component qui le déclare.

An attachment delivers a key another inject source already claimed (Un rattachement livre une clé qu’une autre source d’inject a déjà revendiquée)

Trois surfaces de rédaction livrent dans le canal d’injection d’un composant au moyen d’un bloc inject: : le propre bloc inject: du composant, les blocs inject: sur les entrées de son bloc de dépendances, et le bloc sur chaque Feature qui lui est rattachée. Elles partagent un seul espace à clés par mécanisme de livraison, si bien qu’une clé que deux d’entre elles revendiquent est ambiguë quant à la valeur qui arrive, et la build s’arrête plutôt que de laisser une surface en évincer silencieusement une autre. Une Feature rattachée peut aussi livrer d’une seconde manière, par l’injectMapping de sa FeatureRecipe ; cette voie rencontre le même espace une fois que chaque bloc a livré, et elle est signalée ci-dessous sous « Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Deux Features rattachées livrent une même clé, la seconde par l’injectMapping de sa FeatureRecipe) ».

Cette condition est le côté de cet espace qui concerne le bloc du rattachement. Elle est signalée lorsque le propre bloc inject: d’un rattachement revendique une clé qu’une livraison antérieure détient déjà — l’entrée ci-dessus, sous « Duplicate delivery key across inject sources (Clé de livraison en double entre les sources d’inject) », est la même règle lue du côté rédigé par le développeur, et à elles deux elles couvrent la revendication de chaque bloc.

C’est l’ordre qui décide qui est entré en collision. La première revendication sous une clé est celle qui la détient, et les revendications ultérieures sont celles qui sont signalées — un rattachement dont la clé est déjà prise en est donc informé, tandis qu’un rattachement qui a revendiqué en premier n’est pas informé d’un rattachement ultérieur qui n’a rien évincé. Une revendication qui n’a rien livré du tout laisse la clé libre et ne prend part à rien de tout cela.

Le constat est positionné sur la propre entrée du rattachement à l’intérieur du bloc du composant, qui est la position à modifier ; le message nomme la clé et le mécanisme dans l’espace à clés duquel elle se trouve. Chaque clé en collision est signalée séparément, de sorte qu’un rattachement qui duplique deux clés vous informe des deux.

Message émis :

duplicate delivery key across attachment-inject and another inject source ("<key>", mechanism "<mechanism>") (clé de livraison en double entre l’inject du rattachement et une autre source d’inject (la clé indiquée, le mécanisme indiqué))

Comment corriger : aucun des deux côtés n’est fautif, et c’est à vous d’agir sur les deux. Renommez la clé du côté que vous contrôlez — le plus souvent la propre entrée inject: du composant, puisque le mapping de la Feature est écrit dans un document de catalogue — ou supprimez l’une des deux livraisons. Lorsque le rattachement est réellement censé fournir la valeur, supprimez la revendication rédigée par le développeur plutôt que celle du rattachement. Notez que l’injectMapping de la FeatureRecipe d’une Feature qui écrit une clé est une voie différente et n’est pas signalé ici : réécrire une clé que le propre bloc inject: du composant ou l’une de ses connexions a livrée est une interception et n’est pas signalé du tout, et écrire une clé qu’une autre Feature rattachée a livrée est signalé sous l’entrée suivante.

Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Deux Features rattachées livrent une même clé, la seconde par l’injectMapping de sa FeatureRecipe)

Une Feature rattachée livre dans le canal d’injection de son composant par deux voies : le bloc inject: écrit sur le rattachement, et l’injectMapping de sa FeatureRecipe, dont la sortie nomme la clé de livraison — souvent à partir d’une valeur que porte le rattachement, comme la variable d’environnement choisie pour un justificatif d’identité. Lorsque deux Features rattachées arrivent à une même clé sous un même mécanisme de livraison, et que la seconde des deux y arrive par son mapping, la build s’arrête. Si on la laissait se poursuivre, le composant lirait la valeur écrite en dernier, quelle qu’elle soit, si bien qu’un justificatif d’identité pourrait être présenté à la place d’un autre sans que rien dans la sortie ne le signale.

Elle couvre chaque Feature rattachée, où qu’elle ait été rattachée : le propre bloc features: du composant, un sous-système, une frontière de Release ou une entrée de composant de la Release, l’expansion d’une annotation, et l’entrée features: d’une connexion. La première des deux livraisons peut être le mapping de l’autre Feature ou son propre bloc inject: — la build signale les deux appariements sous cette même condition.

C’est l’ordre qui décide qui est entré en collision. Chaque bloc inject: livre avant qu’aucun mapping ne soit rendu, et les mappings sont rendus dans un ordre fixe — l’ordre dans lequel le mapping d’inject parcourt les Features rattachées d’un composant, décrit dans le pipeline de compilation — si bien que la première livraison sous une clé est celle qui la détient, et la Feature ultérieure est celle qui est signalée. La présence seule décide : les valeurs ne sont pas comparées, de sorte que deux Features qui livrent la même valeur sous une même clé sont tout de même signalées. Une clé que la sortie d’un mapping ne porte pas du tout n’est pas une livraison ; une clé qu’elle porte avec une valeur vide en est une, parce que la valeur vide remplace ce qui s’y trouvait. Une même clé sous deux mécanismes de livraison différents constitue deux clés, et non une collision.

Ce qui n’est pas signalé. L’injectMapping d’une FeatureRecipe qui réécrit une clé que le propre bloc inject: du composant ou l’un des blocs inject: de ses connexions a livrée est une interception — une Feature de routage qui qualifie un hôte, une garde qui redirige un service amont — et la valeur du mapping remplace cette seule entrée. Le mapping d’une Feature qui réécrit une clé que son propre bloc inject: a livrée revient à cette Feature transformant sa propre livraison, et n’est pas signalé non plus.

Le constat est positionné sur la propre entrée de la Feature ultérieure — dans le bloc features: du composant ou, pour une Feature que porte une connexion, sur son entrée sous cette connexion dans le document qui l’a écrite, comme .spec.components.<component>.uses.<socket>.<alias>.features.<slot> dans l’Aggregate. Le message nomme la clé, le mécanisme de livraison et les deux Features par les noms qu’elles portent sur le composant ; une Feature que porte une connexion est nommée par l’alias de la connexion et l’emplacement qu’elle remplit, joints par un point. Chaque clé en collision est signalée séparément.

Message émis :

duplicate delivery key across two attachments: an attachment’s FeatureRecipe writes a delivery key another attachment already delivered ("<key>", mechanism "<mechanism>", attachment "<attachment>", delivered first by attachment "<other-attachment>"). Give one of the two attachments a key of its own, or attach one fewer: the key this attachment delivers under is chosen by its FeatureRecipe, which can read the attachment’s own values and infra, and the other’s is chosen the same way or by its own inject block where it delivered through one. A Release sets an attachment’s infra and never its values, so where a key is chosen by a value, attach that attachment in the Aggregate with the value, and keep giving the rest from the Release. (clé de livraison en double entre deux rattachements : la FeatureRecipe d’un rattachement écrit une clé de livraison qu’un autre rattachement a déjà livrée. Donnez à l’un des deux rattachements une clé qui lui soit propre, ou rattachez-en un de moins : la clé sous laquelle ce rattachement livre est choisie par sa FeatureRecipe, qui peut lire les values et l’infra propres au rattachement, et celle de l’autre est choisie de la même façon, ou par son propre bloc inject lorsqu’il a livré par ce biais. Une Release définit l’infra d’un rattachement et jamais ses values ; lorsqu’une clé est choisie par une valeur, effectuez donc ce rattachement dans l’Aggregate avec la valeur, et continuez à fournir le reste depuis la Release.)

Comment corriger : donnez à l’une des deux Features une clé qui lui soit propre — pour une Feature de justificatif d’identité, c’est généralement la clé que nomment ses valeurs — ou supprimez l’un des deux rattachements. Lorsque les deux sont censées fournir une même variable, décidez laquelle le composant doit lire et ne rattachez que celle-là. Deux justificatifs d’identité qu’une Release rattache d’elle-même arrivent tous deux sous la clé que leur Feature nomme par défaut, car une Release ne peut pas écrire les values d’un rattachement : rattachez l’un d’eux dans l’Aggregate avec la valeur qui nomme sa clé, et donnez son origine depuis la Release sur la même entrée.

A component declares an inject mechanism the attached Feature maps nothing to (Un composant déclare un mécanisme d’inject vers lequel la Feature rattachée ne mappe rien)

La liste d’autorisation spec.inject d’un Component peut nommer des mécanismes de livraison au-delà des mécanismes standard — un mécanisme que la logique interne du composant comprend, et pour lequel tout ce qui y livre doit produire une valeur. Lorsqu’une Feature est rattachée à un tel composant, c’est l’injectMapping de la FeatureRecipe qui indique sous quel mécanisme chaque valeur qu’elle produit est livrée. Un mécanisme que le composant a déclaré et pour lequel le mapping ne produit aucune clé est une livraison qui n’aurait silencieusement jamais lieu, si bien que la build s’arrête à la place.

Un mapping qui ne dit rien des mécanismes n’est pas un mapping qui les exclut tous. Une FeatureRecipe dont le mapping se rend sous forme de dictionnaire plat de livraisons n’affirme rien du tout sur les mécanismes — c’est l’écriture ordinaire pour une Feature qui produit des livraisons sous forme de variables d’environnement — et il en va de même d’un rattachement qui lie une FeatureRecipe sans mapping à évaluer. Aucun des deux n’est signalé ici ; cette condition ne concerne qu’un mapping qui nomme des mécanismes et en omet un que le composant a déclaré.

Chaque mécanisme non mappé est un constat distinct, de sorte qu’un composant qui en déclare deux, dont aucun n’est mappé par un rattachement, vous informe des deux. Le constat est positionné sur l’entrée du rattachement dans votre propre fichier, et nomme aussi la FeatureRecipe — parce que c’est le document dans lequel le mapping est écrit, et qu’il se trouve tout à fait ailleurs.

Message émis :

custom inject mechanism has no matching key in injectMapping output; add the mechanism’s key to the Recipe injectMapping ("<mechanism>", recipe "<featurerecipe>") (le mécanisme d’inject personnalisé n’a pas de clé correspondante dans la sortie de l’injectMapping ; ajoutez la clé du mécanisme à l’injectMapping de la Recipe (le mécanisme indiqué, la FeatureRecipe indiquée))

Comment corriger : le message nomme les deux moitiés. Ajoutez la clé du mécanisme à l’injectMapping de la FeatureRecipe afin que la Feature produise une valeur pour ce mécanisme, ou retirez le mécanisme de la liste d’autorisation spec.inject du Component lorsque rien n’est censé livrer sous ce mécanisme. Lorsque la FeatureRecipe appartient au catalogue de quelqu’un d’autre, rattacher une Feature dont le mapping couvre le mécanisme est la troisième réponse.

An attached Feature’s injectMapping output cannot be read (La sortie injectMapping d’une Feature rattachée ne peut pas être lue)

L’injectMapping d’une FeatureRecipe est un template, et ce qu’il produit est lu comme du YAML : un dictionnaire dont les clés sont des mécanismes de livraison — env, file, arg ou un mécanisme propre au composant — ou un dictionnaire plat de livraisons d’environnement. Lorsque la sortie ne se lit comme ni l’un ni l’autre, aucune de ses clés ne peut être livrée, si bien que la build s’arrête plutôt que de rendre le composant comme si la Feature rattachée n’avait rien livré. Un justificatif d’identité est le cas qui compte le plus : un composant qui attend un mot de passe qu’il n’a jamais reçu pourrait sinon s’exécuter sans, et rien dans la sortie ne le signalerait.

La cause habituelle est une valeur que le template a écrite telle quelle entre guillemets. Un guillemet double à l’intérieur termine prématurément le scalaire entre guillemets, et une barre oblique inverse commence un échappement que YAML peut ne pas connaître, si bien qu’un mapping qui se rend correctement pour la plupart des valeurs se casse pour celle qui contient un tel caractère — souvent un mot de passe. Une sortie vide, ou qui s’analyse comme un dictionnaire ne livrant rien, ne relève pas de cette condition : elle ne livre rien, et c’est ce qu’elle dit.

Le cadre au-dessus du message nomme le composant en cours de rendu, puis le rattachement par le nom qu’il porte sur le composant et la FeatureRecipe dans laquelle le mapping est écrit, sous la forme feature "<attachment>" (recipe "<featurerecipe>") injectMapping output. Sous le message figure la raison pour laquelle la sortie n’a pas pu être lue — la ligne et ce que YAML y a trouvé, comme yaml: line 2: found unknown escape character. Lorsque le template lit une valeur qu’un auteur a déclarée sensible et que la raison dépend de ce que contient cette valeur, la raison est retenue et une phrase l’indiquant figure à sa place, de sorte que l’arrêt ne cite jamais la valeur qui a cassé la sortie. La build signale l’arrêt sous une étiquette CATALOG_ERROR, parce que le mapping est écrit par l’auteur de la FeatureRecipe.

Message émis :

FeatureRecipe injectMapping output could not be read as a dictionary of deliveries (la sortie injectMapping de la FeatureRecipe n’a pas pu être lue comme un dictionnaire de livraisons)

Comment corriger : dans l’injectMapping de la FeatureRecipe, écrivez chaque valeur au moyen de toJson — {{ .values.key }}: {{ .values.origin | toJson }} — qui l’écrit comme une chaîne JSON que YAML relit exactement, quels que soient les caractères qu’elle contient. Lorsque la FeatureRecipe appartient au catalogue de quelqu’un d’autre, la valeur peut aussi être modifiée pour ne contenir ni guillemet double ni barre oblique inverse jusqu’à ce que le mapping soit corrigé.

An attached Feature’s injectMapping output writes deliveries under a key nothing delivers (La sortie injectMapping d’une Feature rattachée écrit des livraisons sous une clé que rien ne livre)

La sortie de l’injectMapping d’une FeatureRecipe est fusionnée dans le canal d’injection du composant selon ses clés de premier niveau. env, file et arg sont livrés comme ces mécanismes, et toute autre clé est livrée comme un mécanisme à part entière sous ce nom, que la Recipe du composant lit à .context.inject.<name>. La vue all est différente : elle est construite à partir des mécanismes après la fusion, jamais fusionnée depuis une sortie, si bien que les valeurs qu’un mapping écrit sous all: n’atteignent rien. La sortie se lit malgré tout sans erreur, si bien que sans cet arrêt une build qui lit ces valeurs de façon facultative réussit sans elles — un justificatif d’identité écrit à cet endroit n’atteint jamais le composant, et rien dans la build ne nomme le mapping qui l’a perdu.

Elle s’applique partout où all: porte au moins une entrée, seul ou à côté d’autres mécanismes ; les autres mécanismes de la même sortie ne sont pas le problème, et un all: écrit vide ne perd rien et n’est pas signalé. Un dictionnaire plat qui porte par hasard une clé nommée all avec une seule valeur est une livraison d’environnement nommée all, et non cette condition.

Le constat est positionné sur l’entrée du rattachement dans votre propre fichier, et nomme la clé et la FeatureRecipe dans laquelle le mapping est écrit — parce que c’est le document à modifier, et qu’il se trouve tout à fait ailleurs — ainsi que les clés qu’une sortie peut porter. Chacune de ces clés est un constat distinct. La build le signale sous une étiquette CATALOG_ERROR.

Message émis :

FeatureRecipe injectMapping output writes a key no delivery mechanism of the host reads ("all", recipe "<featurerecipe>", an output may carry "env, file, arg, or a custom mechanism the host's Recipe reads under its own name") (la sortie injectMapping de la FeatureRecipe écrit une clé qu’aucun mécanisme de livraison de l’hôte ne lit (la clé all, la FeatureRecipe indiquée et les clés qu’une sortie peut porter))

Comment corriger : dans l’injectMapping de la FeatureRecipe, déplacez les entrées placées sous all: vers le mécanisme à partir duquel le composant les lit — généralement env:, ou le nom du mécanisme que lit la Recipe du composant. Lorsque la FeatureRecipe appartient au catalogue de quelqu’un d’autre, rattachez plutôt une Feature dont le mapping livre la valeur.

Lors du rendu de la sortie

Une fois chaque contrat validé, le compilateur évalue les templates Go sur les valeurs des Component, les blocs injectMapping des FeatureRecipe et les sources des Recipe et des FeatureRecipe, puis transmet le résultat au moteur de rendu.

provides: template references a non-self-contained root (Le template provides référence une racine non autonome)

Le template provides: d’une Recipe référence une racine en dehors de l’ensemble autonome. Le bloc provides est évalué lors de l’évaluation des provides, avant que le canal d’inject ne soit hydraté et avant que les arêtes inter-nœuds ne soient parcourues, de sorte qu’il ne peut référencer que des données appartenant à son propre nœud : .context.instance_id, .context.rendered_name là où le fournisseur du nœud en signale un, .values, .infra, les .locals résolus du nœud et des chaînes statiques. La vérification est une liste d’autorisation positive, de sorte que toute autre racine provoque un arrêt — .context.inject et .context.uses (inter-nœuds), .context.annotations.*, .context.labels, .context.metadata et .metadata.* (des données liées au placement ou au déploiement que la surface des provides n’expose pas), et .attachment_name (la passe des provides d’une Recipe de base ne résout aucun rattachement). Référencer l’une de ces racines provoque un arrêt explicite plutôt que le rendu silencieux d’une valeur vide.

.locals fait partie de la surface : les locals d’un nœud sont résolus dans le préambule de la même étape, avant ses provides, de sorte qu’un template provides les lit et reçoit des valeurs résolues.

Message émis :

provides block references a root outside the self-contained set ("<expression>") (le bloc provides référence une racine en dehors de l’ensemble autonome (avec l’expression indiquée))

L’arrêt est positionné sur la Recipe qui déclare l’entrée et sur la clé rédigée à l’intérieur — .spec.provides.<name> —, de sorte qu’il nomme le bloc à modifier plutôt que le composant qui a lié la Recipe. Chaque entrée qui sort de la surface est signalée dans la même build ; lorsqu’il y en a plusieurs, les constats sont regroupés sous provides entries that reach outside the data they are evaluated against.

Comment corriger : remaniez le template pour qu’il ne puise que dans les propres piliers de la Recipe. Si la valeur dépend de la sortie d’un autre nœud, cette dépendance a sa place dans le bloc uses[].inject d’un appelant, pas dans les provides de la cible. Si la valeur est calculée, placez l’expression dans une entrée locals: et lisez-la depuis provides — l’expression réside alors en un seul endroit. Si vous cherchiez à atteindre le namespace de déploiement (ou d’autres données de placement) pour construire un hôte inter-namespaces, publiez ici l’hôte nu et qualifiez-le du côté du consommateur avec une fonctionnalité de routage — les provides du producteur ne doivent pas dépendre de l’endroit où il a été déployé.

Le provides: d’une FeatureRecipe suit la même règle des locals : ses propres locals: sont résolus avant son provides:, de sorte qu’une entrée provides d’une FeatureRecipe lit elle aussi .locals.

locals: entry references a sibling defined later in the same block (Une entrée de locals référence une entrée sœur définie plus loin dans le même bloc)

Un bloc locals: se résout dans l’ordre où ses entrées sont écrites, et une entrée ne lit qu’une entrée sœur définie au-dessus d’elle. Une référence directe .locals.<key> à une entrée que le bloc définit plus loin provoque un arrêt : le compilateur ne trie ni ne réordonne jamais le bloc pour faire résoudre la référence, car la sortie émise suivrait alors une inférence plutôt que ce qui a été rédigé. Sans l’arrêt, la référence se résoudrait via la politique des clés manquantes en une chaîne vide, de sorte qu’un nom d’hôte ou un nom de secret dérivé perdrait silencieusement le segment à partir duquel il a été construit.

Les deux résolutions d’un bloc locals: tranchent cette faute, et l’une d’elles est l’épinglage. Un bloc est résolu à deux fins différentes : pour que les propres templates de la Recipe puissent le lire pendant le rendu d’un artefact, et pour qu’une coordonnée source: structurée puisse être résolue et l’artefact qu’elle nomme épinglé. La faute est tranchée à partir de l’ordre des clés déclaré et du texte rédigé, qui est tout ce dont elle a besoin, de sorte que les deux résolutions l’atteignent et signalent la même condition — aggrega pull, et une build qui remplit le lockfile, refusent le bloc exactement comme le fait un rendu. Deux conséquences méritent d’être connues lors de la rédaction. Le bloc entier est lu pendant la résolution d’une coordonnée, de sorte qu’une entrée hors d’ordre provoque un arrêt même là où chaque champ source: est littéral et ne lit aucun local. Et une Recipe dont le source: est une simple chaîne, ou qui ne déclare aucun source:, ne résout aucune coordonnée, de sorte que sur cette Recipe la faute est signalée lors du rendu de la sortie.

Message émis, pour une entrée du propre bloc locals: de la Recipe d’un composant. Il est positionné sur la clé rédigée à l’intérieur de la Recipe, et chaque entrée fautive est signalée dans une seule build ; lorsqu’il y en a plusieurs, les constats sont regroupés sous locals entries that read a sibling they cannot :

locals entry references a sibling defined later in the same block ("<expression>", the key it names is "<referenced>", resolved at this point "<the locals available here>", reached through the component "<component>"). define "<referenced>" above "<key>" in the locals block (l’entrée de locals référence une entrée sœur définie plus loin dans le même bloc (avec l’expression, la clé qu’elle nomme, les locals résolus à ce stade et le composant par lequel elle a été atteinte indiqués). définissez la clé nommée au-dessus de l’entrée indiquée dans le bloc locals)

Une autoréférence est la même condition — la clé est déclarée et non résolue — et aucun réordonnancement ne la corrige, de sorte que le message le dit à la place de l’instruction de déplacement :

locals entry references a sibling defined later in the same block ("<expression>", the key it names is "<key>", resolved at this point "<the locals available here>", reached through the component "<component>"). a locals entry cannot read itself; compute the value from .values and .infra directly (l’entrée de locals référence une entrée sœur définie plus loin dans le même bloc (avec l’expression, la clé qu’elle nomme, les locals résolus à ce stade et le composant par lequel elle a été atteinte indiqués). une entrée de locals ne peut pas se lire elle-même ; calculez la valeur directement à partir de .values et .infra)

Une Recipe est liée par de nombreux composants, de sorte qu’une erreur dans un bloc partagé est signalée une fois pour chaque composant qui le lie — et reached through the component est ce qui distingue ces constats. Ils partagent une position, car ils concernent tous la même entrée rédigée dans le même document ; la position indique où modifier, et le nom du composant indique lequel de vos composants chaque constat représente. Les constats ne sont pas fusionnés en un seul, car les fusionner dirait que quelque chose ne va pas sans dire quels composants cela atteint, et c’est la partie sur laquelle vous devez agir.

La même faute dans un bloc locals: que déclare la recette d’une Feature est signalée de la même façon : positionnée sur la clé rédigée à l’intérieur de cette recette, nommée par le composant sur lequel se trouve le rattachement, et regroupée avec toute entrée sœur portant la même faute. Lorsque la recette est rattachée à plus d’un endroit, la faute est signalée une fois pour chacun — chaque rattachement lie ce bloc indépendamment, de sorte que chacun est une occurrence distincte plutôt que la répétition d’une seule.

Lorsque cette forme signale une autoréférence, sa clause de position nomme l’entrée référente elle-même plutôt qu’une entrée ultérieure, car c’est là que se trouve la clé.

Comment corriger : déplacez l’entrée référencée au-dessus de son lecteur. Réordonner un bloc locals: est un changement de comportement partout où une entrée en lit une autre, de sorte que la correction est exactement le réordonnancement que nomme le message. Une autoréférence — une entrée qui nomme sa propre clé — ne peut pas être corrigée par un réordonnancement ; calculez plutôt la valeur directement à partir de .values et .infra, ce que le message dit à la place de l’instruction de déplacement.

locals: key does not exist (La clé de locals n’existe pas)

Un template lit .locals.<key> pour une clé que le bloc locals: ne déclare pas du tout — une faute de frappe, ou une clé qui a été renommée ou supprimée. Chaque surface qui lit le pilier déclenche cet arrêt : une entrée locals:, un template provides:, un template source: de Recipe, et la résolution d’une coordonnée source: structurée, qui lit le bloc entier pour épingler l’artefact que la coordonnée nomme. Le pilier des locals est une map ouverte à clés, de sorte qu’une clé inconnue sous celui-ci passe la vérification de racine et se résoudrait sinon en une chaîne vide ; l’arrêt est ce qui empêche cette valeur vide d’atteindre un artefact émis.

Message émis, lorsque la référence fautive se trouve dans un template provides: :

template references a key the locals block does not declare (Recipe <recipe> provides[<key>] references <expression>, the locals block declares no <referenced>, it declares <the keys it does declare>). correct the key name (le template référence une clé que le bloc locals ne déclare pas (l’entrée provides indiquée de la Recipe indiquée référence l’expression indiquée, le bloc locals ne déclare pas la clé indiquée, il déclare les clés indiquées). corrigez le nom de la clé)

Message émis, lorsqu’elle se trouve dans une entrée locals: elle-même. Il porte le composant par lequel le bloc a été lié, pour la raison qu’énonce l’arrêt d’ordre ci-dessus — un bloc partagé est signalé une fois par composant qui le lie, et c’est ce qui distingue ces constats :

template references a key the locals block does not declare ("<expression>", the missing key is "<referenced>", the block declares "<the keys it does declare>", reached through the component "<component>"). correct the key name (le template référence une clé que le bloc locals ne déclare pas (avec l’expression, la clé manquante, les clés que le bloc déclare et le composant par lequel elle a été atteinte indiqués). corrigez le nom de la clé)

Comment corriger : corrigez le nom de la clé en l’un de ceux que le bloc déclare ; le message les liste. L’arrêt est distinct de l’arrêt d’ordre ci-dessus car les remèdes diffèrent — aucun réordonnancement ne fait résoudre une clé qui n’existe pas.

La vérification lit le chemin vers lequel une référence se résout plutôt que ce qui a été tapé, de sorte qu’un alias du bloc est suivi : une clé atteinte via le point qu’un corps with .locals relie à nouveau, ou via une variable liée à .locals, est vérifiée exactement dans les mêmes termes que l’écriture directe et provoque un arrêt de la même façon, tout comme une clé lue sur le bloc entre parenthèses — {{ (.locals).nope }} ou {{ ($.locals).nope }} — car les parenthèses produisent le bloc lui-même et rien de plus. Une seule écriture échappe à la vérification : une clé atteinte via un appel dont le texte du template ne peut pas nommer le résultat — {{ index .locals "nope" }}, ou {{ (default dict .locals).nope }} — car ce que produit un tel appel est décidé à l’exécution du template plutôt que par ce qui est écrit. Une clé absente lue comme un champ sur le résultat d’un tel appel — la forme (default dict .locals).nope — ne provoque pas d’arrêt et rend le texte de substitution du moteur de templates <no value>. Une clé absente atteinte via index provoque un arrêt, mais en tant que « A template indexes a map with a key the map does not hold (Un template indexe une map avec une clé que la map ne contient pas) » ci-dessous plutôt qu’en tant que cette vérification : index provoque un arrêt sur toute clé de map que la map ne contient pas. index reste donc le moyen d’atteindre une clé dont le nom est lui-même calculé, et un nom calculé que le bloc ne déclare pas est tout de même signalé par sa clé.

Template references a root the render context does not define (Le template référence une racine que le contexte de rendu ne définit pas)

Un template référence une racine de premier niveau — le premier segment du chemin après le point initial — que son contexte de rendu ne définit pas : une faute de frappe comme {{ .valeus.port }}, ou une racine qui n’existe pas sur la surface en cours de rédaction. La vérification est une liste d’autorisation positive portant sur les noms de racine, et l’ensemble admis est dérivé de la forme même du contexte de rendu plutôt que tenu comme une liste distincte à côté de lui, de sorte que l’ensemble que la build refuse et l’ensemble que le contexte fournit réellement ne peuvent pas diverger. Le diagnostic nomme la référence fautive et liste les racines que ce contexte définit.

L’arrêt se déclenche de manière identique, que la référence soit nue ou enveloppée dans un repli default, if, with ou range, et la forme enveloppée est celle qui compte le plus : un wrapper peut fournir un repli pour une clé absente sous une racine définie, mais jamais pour une racine absente, de sorte que sans cet arrêt la forme enveloppée se résoudrait discrètement en une valeur vide et laisserait la build se terminer avec succès. Une clé absente sous une racine définie n’est pas affectée et suit toujours la politique missingkey=zero des templates de valeur décrite dans « Missing template key — asymmetric policy (Clé de template manquante — politique asymétrique) » ci-dessous, de sorte que les idiomes de clé facultative tels que {{ .values.optional_field | default "fallback" }} continuent de fonctionner.

Le même arrêt couvre une clé mal saisie un niveau plus bas, sous un pilier dont la forme est déclarée. Certains piliers ont un ensemble de clés que le compilateur définit : .context, .metadata, .inject, .workload et .boundary dans le contexte de rendu des Recipe et FeatureRecipe, et .manifest dans un template de chemin. Une référence à une clé que l’un de ces piliers ne définit pas — {{ .context.nmae }}, {{ .metadata.typo }}, {{ .workload.containres }}, {{ .boundary.nmae }} — provoque un arrêt exactement comme une racine erronée, et le diagnostic liste les clés que ce pilier définit. Dans les templates propres au rattachement d’une Feature, .inject définit une clé supplémentaire pour chaque mécanisme de livraison que nomme le bloc inject: propre au rattachement, à côté de env, file, arg et all : un rattachement qui écrit un mécanisme vault_ref: se lit à {{ .inject.vault_ref.VAULT_PATH }}, et le diagnostic liste .inject.vault_ref parmi les clés que définit .inject. Un mécanisme que le rattachement ne nomme pas provoque un arrêt même à l’intérieur d’un if ou d’un with, car la référence est vérifiée avant l’exécution du template. Pour lire un mécanisme que le rattachement pourrait ne pas nommer, protégez-le : {{ with .inject }}{{ if hasKey . "vault_ref" }}{{ index . "vault_ref" "VAULT_PATH" }}{{ end }}{{ end }}. Avec la paire protégée, le build aboutit que le rattachement nomme ou non le mécanisme, et qu’il écrive ou non un bloc inject: — .inject ne contient alors rien, de sorte que le with saute son corps, là où hasKey appliqué directement à .inject provoquerait un arrêt sur une valeur qui n’est pas une map. À l’intérieur de la protection, index provoque toujours un arrêt sur une clé que le mécanisme nommé ne contient pas. D’autres piliers sont ouverts, car ce qu’ils contiennent sont des données à clés plutôt qu’un ensemble que le compilateur déclare — parmi eux .values, .infra, .locals, .provides, .features et .steps dans le contexte de rendu, et .parameters et .parent_boundary dans un template de chemin. Un pilier ouvert accepte n’importe quelle clé. Une clé absente sous un pilier ouvert ne relève pas de cet arrêt — elle suit la politique des clés manquantes de la surface décrite dans « Missing template key — asymmetric policy (Clé de template manquante — politique asymétrique) » ci-dessous, de sorte que {{ .values.optional_field | default "fallback" }} et tout autre idiome de clé facultative continuent de fonctionner.

Quels piliers sont déclarés et lesquels sont ouverts est une propriété de la surface, et non quelque chose qu’un template peut influencer : le compilateur le lit dans la forme du contexte de rendu qu’il s’apprête à fournir. C’est ce qui permet à l’arrêt sur faute de frappe et au rendu de la clé facultative de coexister dans le même template.

Une surface peut aussi restreindre une clé que son pilier définit par ailleurs, et un tel signalement n’est pas une faute de frappe. Lorsqu’une clé porte une réponse dénuée de sens — ou appartenant à un autre nœud — sur une surface particulière, cette surface refuse la référence plutôt que de la résoudre vers la mauvaise chose, et le diagnostic liste les clés qu’elle définit. Deux cas à connaître, tous deux {{ .context.rendered_name }}. Dans les propres templates d’un rattachement de Feature, la clé porte le nom du composant hôte tel que le propre fournisseur de l’hôte le signale, de sorte qu’elle est refusée sur un rattachement d’un hôte dont le fournisseur ne signale aucun nom — un hôte qui place seul un ensemble d’artefacts, ou un hôte dont le rendu passe par un fournisseur qui ne dérive aucun nom de ce genre — et admise sur tout autre hôte. {{ .context.instance_id }} est admise sur cette surface et nomme le composant hôte pour lequel le rattachement se résout, ce qui est le nom que portent les propres ressources de l’hôte sur un tel hôte. Dans les entrées locals: d’une Recipe, la clé est refusée quoi que signale le fournisseur du nœud : un local partage son contexte avec le template source: de la Recipe, et le fait que le nœud fournisse une source est l’une des choses dont dépend le nom, de sorte que le nom n’y est pas proposé. Le diagnostic liste .context.instance_id comme l’unique clé que .context y définit ; lisez plutôt le nom rendu dans une entrée provides: ou un template en ligne. Voir ../templates/rendered-resource-names.md pour ce que nomme chacune des deux clés et où chacune est lisible.

Message émis lorsque la racine elle-même n’est pas définie :

template references a root the render context does not define (template <template-name> references <dotted-path>, the render context defines <the roots that context defines>) (le template référence une racine que le contexte de rendu ne définit pas (le template indiqué référence le chemin indiqué, le contexte de rendu définit les racines indiquées))

Et lorsque la racine est correcte mais qu’une clé sous un pilier déclaré ne l’est pas :

template references a root the render context does not define (template <template-name> references <dotted-path>, <pillar> defines <the keys that pillar defines>) (le template référence une racine que le contexte de rendu ne définit pas (le template indiqué référence le chemin indiqué, le pilier indiqué définit les clés indiquées))

Comment corriger : corrigez la référence en l’une de celles que liste le diagnostic — la plupart des signalements sont une faute de frappe sur .values, .infra ou .context, ou sur une clé sous .context ou .metadata. Supprimer le wrapper de repli ne lève pas l’arrêt, et en ajouter un ne l’a jamais supprimé ; le wrapper ne faisait que masquer quelle référence était erronée. Si les données appartiennent réellement à un autre nœud, elles atteignent ce template par le canal d’inject — câblez-les avec une entrée uses[].inject sur le consommateur et lisez-les depuis .context.inject — plutôt que par une racine qui leur serait propre.

La vérification couvre chaque surface de template que le moteur de rendu évalue, chacune par rapport à l’ensemble de références que sa propre surface définit : valuesMapping, injectMapping et workload des Recipe et FeatureRecipe, les corps artifacts:, les entrées provides: et locals:, source:, les corps when: et with: des étapes pipeline, assertions:, les templates value: de self-inject au niveau du composant dans un Aggregate, et les templates de chemin des frontières de la Release (directory: / subDirectory:). Deux de ces surfaces nomment certains refus avec un diagnostic propre, car l’erreur qu’elles décrivent est plus précise que « cette référence n’existe pas » : un template de chemin qui cherche à atteindre une variable qui ne lui est pas fournie relève de « Path-template references a variable outside the allowlist (Le template de chemin référence une variable en dehors de la liste d’autorisation) » ci-dessous, et une FeatureRecipe de portée frontière qui cherche à atteindre un pilier par composant relève de « FeatureRecipe template references a field outside its scope’s allowlist (Le template de FeatureRecipe référence un champ en dehors de la liste d’autorisation de sa portée) ». Tout le reste que refusent ces deux surfaces — y compris une clé mal saisie sous un pilier qu’elles admettent — signale cet arrêt, de sorte qu’aucun diagnostic ne vous dit que votre référence est quelque chose qu’elle n’est pas.

An artifacts: template reads a pillar the Recipe does not declare (Un template artifacts lit un pilier que la Recipe ne déclare pas)

Le template d’une entrée artifacts: lit .workload, ou une clé en dessous, dans une Recipe qui ne déclare aucun workload: ; ou il lit .source, ou une clé en dessous, dans une Recipe qui ne déclare aucun source:. Les deux piliers sont toujours présents dans le contexte de rendu des artefacts — ce sont des racines que la surface définit —, de sorte que la référence est bien formée et que l’arrêt porte sur l’absence de la déclaration plutôt que sur une référence erronée. Une Recipe qui rend un Deployment à partir de sa charge de travail synthétisée et une Recipe qui rend un chart à partir d’une source sont des formes différentes, et un corps artifacts: écrit pour l’une d’elles cherche à atteindre un pilier que l’autre ne remplit jamais.

La vérification s’exécute avant que l’entrée ne soit évaluée, et c’est cet ordre qui rend le signalement utile. Un pilier absent arrive au template comme une valeur vide, de sorte que, laissée à l’évaluation, la build soit n’insérerait rien dans le fichier émis, soit échouerait avec ce que le moteur de templates dit de la lecture d’une clé sur rien — et ni l’un ni l’autre ne nomme le pilier ou la déclaration manquante. Refuser d’abord permet à l’arrêt de nommer l’expression exacte qui a cherché à atteindre le pilier, citée telle que vous l’avez écrite.

Un source: déclaré mais dont le rendu donne une chaîne vide est lu comme une absence de source, car ce que lit la vérification est la source après l’évaluation de son propre template. C’est la même valeur à partir de laquelle le fournisseur effectue ensuite le rendu, de sorte qu’une Recipe dont le source: s’est résolu en rien n’a pas non plus de source à offrir à un corps artifacts:.

Message émis, sous une seule forme quel que soit l’endroit où l’entrée artifacts: a été écrite. Ce qui varie n’est pas la phrase mais les légendes qui la suivent, qui disent quel document contient l’entrée.

Chaque référence fautive du template est nommée, de sorte qu’un corps qui cherche à atteindre deux piliers absents vous signale les deux plutôt que celui qui est venu en premier. Chaque référence est signalée sur le document qui déclare l’entrée, citée telle que vous l’avez écrite et légendée avec la sortie à laquelle elle appartient :

artifact template references a pillar the Recipe does not declare (<expression>, artifact <output-name>) (le template d’artefact référence un pilier que la Recipe ne déclare pas (avec l’expression et l’artefact indiqués))

L’expression nomme le pilier dans son premier segment, et c’est ce qui vous indique quelle déclaration manque : .source.chart cherche à atteindre source:, .workload.containers cherche workload:.

Une entrée que déclare la propre Recipe d’un composant est signalée sur le bloc artifacts: de cette Recipe.

Une entrée que déclare une FeatureRecipe — rattachée à un composant en tant que fonctionnalité, ou déclarée sur une frontière — est vérifiée par rapport aux piliers que déclare cette FeatureRecipe plutôt qu’à ceux du composant hôte, est signalée sur le bloc artifacts: de la FeatureRecipe, et porte une légende supplémentaire nommant le rattachement qui la lie :

artifact template references a pillar the Recipe does not declare (<expression>, artifact <output-name>, attachment <attachment-name>) (le template d’artefact référence un pilier que la Recipe ne déclare pas (avec l’expression, l’artefact et le rattachement indiqués))

La légende du rattachement dit ce que la position ne peut pas dire à elle seule : un composant peut porter plusieurs rattachements, et un rattachement déclaré sur une frontière atteint chaque composant que contient la frontière. La phrase elle-même nomme une Recipe dans les deux cas ; ce sont la position et la légende du rattachement ensemble qui disent quel document ouvrir.

Lorsqu’un template nomme plusieurs références, chacune reçoit son propre signalement sous une ligne nommant l’entrée qu’elles partagent, et cette ligne nomme aussi le document :

artifact <output-name> references pillars its Recipe does not declare (l’artefact indiqué référence des piliers que sa Recipe ne déclare pas)

artifact <output-name> references pillars the FeatureRecipe attachment <attachment-name> binds does not declare (l’artefact indiqué référence des piliers que la FeatureRecipe liée par le rattachement indiqué ne déclare pas)

Chacun de ces signalements porte la même condition d’arrêt, quel que soit le document qu’il concerne, de sorte que tout ce qui fait correspondre sur la condition plutôt que sur le texte ne voit aucune différence entre eux.

Comment corriger : déclarez le pilier que lit le template, ou cessez de le lire. Le déclarer est la correction lorsque le corps artifacts: va avec cette forme de Recipe — ajoutez le workload: qu’attendent les références du template aux conteneurs, ports ou volumes, ou le source: dont il interpole le chemin du chart ou du module. Supprimer la référence est la correction lorsque le corps a été écrit pour une autre Recipe et réutilise un fragment qui ne s’applique pas ici ; lorsque la valeur vient réellement d’ailleurs, publiez-la via le provides: du nœud producteur et lisez-la depuis le canal d’inject au lieu de chercher à atteindre un pilier que cette Recipe ne remplit pas. Protéger la référence avec un wrapper de repli ne lève pas l’arrêt — c’est le pilier qui manque, pas la clé en dessous — et déplacer la référence vers une autre entrée de la même Recipe ne le lève pas non plus, car chaque entrée d’un même bloc artifacts: est évaluée par rapport aux mêmes piliers.

Cet arrêt est distinct de « Template references a root the render context does not define (Le template référence une racine que le contexte de rendu ne définit pas) » ci-dessus, et il vaut la peine de distinguer les deux car les remèdes diffèrent. Celui-là se déclenche sur une racine que la surface ne définit pas du tout, ou sur une clé mal saisie sous un pilier dont la forme est fixe — {{ .workload.containres }} sur une Recipe qui déclare bel et bien une charge de travail. Celui-ci se déclenche sur une référence correctement orthographiée à un pilier qui n’est tout simplement pas là.

A template reads a rendered name the node’s provider does not report (Un template lit un nom rendu que le fournisseur du nœud ne signale pas)

Un template lit {{ .context.rendered_name }} — le nom que le fournisseur lié donne à la sortie qu’il rend pour le nœud, à partir d’une source fournie par l’auteur ou d’une charge de travail qu’il synthétise — sur un nœud dont le fournisseur ne signale aucun nom de ce genre. La référence est bien formée et la clé est l’une de celles que définit le contexte de rendu ; ce qui manque, c’est une réponse pour ce nœud.

Le refus existe parce que l’alternative est pire qu’un arrêt. Le nom atteint un template sous forme de simple chaîne, de sorte qu’un nœud qui n’en a pas ferait disparaître la référence au rendu et émettrait une adresse à laquelle il manque un segment — .svc.cluster.local là où un nom d’hôte était voulu — avec un code de sortie zéro, sans rien à lire dans la build. Cet artefact se déploie, et ce qu’il nomme n’existe pas. Refuser avant que quoi que ce soit ne soit évalué signale plutôt la faute sur le template que l’auteur a écrit.

Le fait que le fournisseur d’un nœud signale un tel nom est établi par la liaison de la Recipe, avant toute évaluation, de sorte que rien n’est deviné ici.

Deux signalements, et celui que vous obtenez dépend du nœud plutôt que de l’endroit où vous avez écrit la référence. Un nœud qui ne fournit aucune source propre, sous un fournisseur qui ne signale aucun nom pour lui, a des ressources nommées d’après son identité, de sorte qu’il existe une valeur correcte et que le signalement la nomme. Un nœud qui fournit bien une source, sous un fournisseur qui ne dérive aucun nom pour lui, n’a pas de substitut — et y proposer l’identité vous enverrait vers une valeur qui ne nomme aucune des ressources de ce nœud, de sorte que le signalement le dit à la place.

Message émis, lorsque le nœud ne fournit aucune source propre :

template reads the name the target gives the resources it renders for the node, and this node’s provider reports no such name; a conforming template reads a value the node’s own provider supplies (".context.rendered_name", provider "<provider>"). read {{ .context.instance_id }} instead: this node supplies no source of its own, so its resources are named after the node’s identity (le template lit le nom que la cible donne aux ressources qu’elle rend pour le nœud, et le fournisseur de ce nœud ne signale aucun nom de ce genre ; un template conforme lit une valeur que fournit le propre fournisseur du nœud (avec la clé et le fournisseur indiqués). lisez plutôt la clé indiquée : ce nœud ne fournit aucune source propre, de sorte que ses ressources sont nommées d’après l’identité du nœud)

Et lorsqu’il fournit bien une source, sous un fournisseur qui ne dérive aucun nom de ce genre :

template reads the name the target gives the resources it renders for the node, and this node’s provider reports no such name; a conforming template reads a value the node’s own provider supplies (".context.rendered_name", provider "<provider>"). write a value that does not depend on a name this target derives: it reports none for the output it renders from supplied source, so there is nothing of that kind to read here (le template lit le nom que la cible donne aux ressources qu’elle rend pour le nœud, et le fournisseur de ce nœud ne signale aucun nom de ce genre ; un template conforme lit une valeur que fournit le propre fournisseur du nœud (avec la clé et le fournisseur indiqués). écrivez une valeur qui ne dépende pas d’un nom que cette cible dérive : elle n’en signale aucun pour la sortie qu’elle rend à partir d’une source fournie, de sorte qu’il n’y a rien de ce genre à lire ici)

Lorsque la référence se trouve dans un template autre qu’une entrée provides:, le signalement nomme en outre le champ dans lequel elle a été écrite — field "valuesMapping", field "artifacts[probe.tf.json]" — car la clé d’une entrée artifacts: est un nom de fichier de sortie et contient le caractère avec lequel la position sépare ses propres segments, de sorte que la position s’arrête au bloc qui contient l’entrée.

Quels templates elle couvre : chaque template qu’une Recipe écrit en ligne — ses entrées provides:, son valuesMapping:, son corps workload:, chaque entrée artifacts:, et les with: et when: de chaque étape de pipeline. Une surface de template reste en dehors : une entrée valuesMapping:, workload: ou artifacts: fournie via $import: — que l’import nomme un fichier local ou une entrée de bibliothèque — ne porte aucun texte dans la Recipe tant que le rendu ne la résout pas, de sorte qu’une référence à l’intérieur d’un tel corps est rendue comme une valeur vide au lieu de provoquer un arrêt.

Comment corriger : lisez la clé que nomme le signalement. Lorsque la sortie de votre nœud est quelque chose de construit pour lui sous un fournisseur qui ne signale aucun nom — une charge de travail synthétisée, un ensemble d’artefacts placé —, {{ .context.instance_id }} est le nom que portent réellement ces ressources, et c’est la bonne valeur plutôt qu’un repli. Lorsque votre nœud fournit son propre chart ou module et que le signalement ne propose aucun substitut, le nom que vous cherchiez à atteindre n’est pas un nom que ce fournisseur dérive : publiez quelque chose qui n’en dépend pas, ou nommez la ressource dans la source que vous avez fournie et relisez ce nom depuis une valeur que vous définissez. ../templates/rendered-resource-names.md expose quels fournisseurs signalent un nom et, pour chacun des autres, pourquoi il n’en existe aucun à signaler.

A template reads its callers’ render facts without declaring it (Un template lit les faits de rendu de ses appelants sans le déclarer)

Un template d’une FeatureRecipe rattachée à un composant lit render_facts sous .context.used_by — ce que les composants qui se connectent à l’hôte du rattachement ont signalé sur leurs propres rendus — et la FeatureRecipe ne définit pas readsCallerRenderFacts: true.

La clé est ce qui décide du moment où le rattachement est rendu. Sans elle, le rattachement est rendu juste après le composant auquel il est rattaché, et un composant qui se connecte et qui vient plus tard dans l’ordre de la build n’a pas encore été rendu à ce moment-là, de sorte que ce qu’il a émis ne peut pas être là pour être lu. Refuser le template avant tout rendu signale la déclaration manquante sur le champ que vous avez écrit, au lieu d’une build dont le template lit ce que certains de ses appelants ont émis et pas les autres.

Message émis :

template reads its callers’ render facts, but the FeatureRecipe does not set readsCallerRenderFacts (<reference>, written in <field>) (le template lit les faits de rendu de ses appelants, mais la FeatureRecipe ne définit pas readsCallerRenderFacts (avec la référence et le champ dans lequel elle est écrite indiqués))

La référence est citée par rapport à la connexion sur laquelle elle a été lue — .render_facts, ou .render_facts.<name> — car un template lit les appelants une connexion à la fois, à l’intérieur de {{ range .context.used_by }} ou sur une connexion qu’il choisit. Le champ nomme le bloc dans lequel le template a été écrit : valuesMapping, workload ou artifacts[<output-name>]. Un with: ou un when: d’une étape de pipeline qui lit les mêmes faits est signalé par l’entrée suivante à la place, quoi que définisse la FeatureRecipe, car définir la clé ne permettrait pas à une étape de les lire. Lorsque plusieurs champs lisent les faits, chacun reçoit son propre signalement sous une ligne nommant ce qu’ils partagent :

attachment templates reading their callers’ render facts without declaring it (templates de rattachement qui lisent les faits de rendu de leurs appelants sans le déclarer)

Comment corriger : définissez readsCallerRenderFacts: true dans le spec de la FeatureRecipe. Ses rattachements sont alors rendus après que chaque composant a été rendu, et rien d’autre ne change dans ce qu’ils rendent — voir la page de l’entité FeatureRecipe. La clé est le contrat, et cet arrêt vous aide seulement à trouver un template qui en a visiblement besoin : la vérification lit le template tel qu’il est écrit, de sorte qu’une référence construite pendant l’exécution du template, ou une référence écrite dans un contenu importé d’un fichier ou d’une bibliothèque, ne provoque pas d’arrêt — définissez tout de même la clé sur une telle FeatureRecipe. Un template qui lit un champ nommé render_facts sur une autre liste à côté de .context.used_by provoque également un arrêt, tout comme un template qui lit les propres faits de son hôte en tant que .render_facts à l’intérieur de {{ with .context }} à côté — écrivez ceux de l’hôte en entier sous la forme .context.render_facts, qui n’est jamais pris pour ceux des appelants ; définir la clé lève l’un comme l’autre sans autre coût que le rendu plus tardif.

Une FeatureRecipe qui effectue son rendu une seule fois pour une frontière (executionScope: boundary) n’est pas vérifiée ici : les templates qui produisent ses ressources n’ont aucun .context à lire, et une référence à celui-ci est refusée à la place comme un champ en dehors de la liste d’autorisation de sa portée.

A pipeline step reads its callers’ render facts (Une étape de pipeline lit les faits de rendu de ses appelants)

Le with: ou le when: d’une étape de pipeline, dans une FeatureRecipe rattachée à un composant, lit render_facts sous .context.used_by — ce que les composants qui se connectent à l’hôte du rattachement ont signalé sur leurs propres rendus.

Une étape de pipeline ne voit jamais ces connexions. Une étape peut réécrire les propres documents du composant hôte, et la propre sortie d’un composant reste la même quel que soit celui qui s’y connecte, de sorte que les templates d’une étape sont évalués sans .context.used_by — pour toute FeatureRecipe, qu’elle définisse ou non readsCallerRenderFacts: true. Cette clé décide du moment où le rendu du rattachement a lieu, jamais de ce que voit une étape. Une étape lisant les faits de ses appelants ne lirait donc rien, et la build s’arrête avant tout rendu plutôt que de rendre cette lecture comme une valeur vide.

Message émis :

pipeline step reads its callers’ render facts, but a pipeline step does not read the components connecting to its host; it reads only the host’s own render facts (<reference>, written in <field>) (l’étape de pipeline lit les faits de rendu de ses appelants, mais une étape de pipeline ne lit pas les composants qui se connectent à son hôte ; elle lit uniquement les propres faits de rendu de l’hôte (avec la référence et le champ où elle est écrite indiqués))

La référence est citée relativement à la connexion sur laquelle elle a été lue — .render_facts, ou .render_facts.<name> — comme dans l’entrée ci-dessus, et le champ nomme l’étape par son id : pipeline[<step>].with ou pipeline[<step>].when. Lorsque plusieurs étapes lisent les faits, chacune reçoit son propre signalement sous une ligne qui nomme ce qu’elles ont en commun :

pipeline steps reading their callers’ render facts (étapes de pipeline lisant les faits de rendu de leurs appelants)

Comment corriger : dans une étape, lisez les propres faits de rendu de l’hôte dans .context.render_facts, écrit en entier — ils proviennent du propre rendu de l’hôte, de sorte que les lire ne fait rien dépendre de qui s’y connecte. Lisez plutôt les faits des appelants dans les templates qui produisent les propres ressources du rattachement — son valuesMapping:, workload: ou artifacts: — avec readsCallerRenderFacts: true défini, comme le décrit la page de l’entité FeatureRecipe. Définir la clé seule ne lève pas cet arrêt. La vérification lit le template tel qu’il est écrit, avec les limites que décrit l’entrée ci-dessus : une référence construite pendant l’exécution du template, ou une référence écrite dans du contenu importé d’un fichier ou d’une bibliothèque, ne provoque pas d’arrêt, et une étape qui lit un champ nommé render_facts sur une autre liste à côté de .context.used_by, ou les propres faits de son hôte sous la forme .render_facts à l’intérieur de {{ with .context }} à côté, provoque elle aussi un arrêt.

Une FeatureRecipe dont le rendu a lieu une seule fois pour une frontière (executionScope: boundary) n’est pas vérifiée ici, pour la raison que donne l’entrée ci-dessus.

A template reads its targets’ render facts without declaring it (Un template lit les faits de rendu de ses cibles sans le déclarer)

Un template dans une FeatureRecipe rattachée à un composant lit render_facts sous .context.uses — ce que les composants auxquels l’hôte du rattachement est câblé ont signalé sur leurs propres rendus — et la FeatureRecipe ne définit pas readsTargetRenderFacts: true.

La clé décide deux choses. Elle fait effectuer le rendu du rattachement une fois que chaque composant a été rendu : sans elle, le rendu du rattachement a lieu juste après le composant auquel il est rattaché, et une cible qui vient plus loin dans l’ordre de la build n’a pas encore été rendue à ce moment-là. Et c’est elle qui place les faits de chaque cible sur les connexions que lit le rattachement : sans elle, aucune entrée de .context.uses ne porte .render_facts. Refuser le template avant tout rendu signale la déclaration manquante sur le champ que vous avez écrit, plutôt qu’une build dont le template ne lit rien là où il attendait les faits d’une cible.

Message émis :

template reads the render facts of a component its host is wired to, but the FeatureRecipe does not set readsTargetRenderFacts (<reference>, written in <field>) (le template lit les faits de rendu d’un composant auquel son hôte est câblé, mais la FeatureRecipe ne définit pas readsTargetRenderFacts (avec la référence et le champ où elle est écrite indiqués))

La référence est celle que le template a écrite : en entier sous l’alias d’une connexion — .context.uses.<alias>.render_facts, ou .context.uses.<alias>.render_facts.<name> — ou, lorsque le template lit les connexions une à une, à l’intérieur de {{ range .context.uses }}, {{ with .context.uses.<alias> }} ou sur une connexion qu’il choisit, relativement à cette connexion : .render_facts, ou .render_facts.<name>. Le champ nomme le bloc dans lequel le template a été écrit : valuesMapping, workload ou artifacts[<output-name>]. Un with: ou un when: d’étape de pipeline lisant les mêmes faits est signalé à la place par l’entrée suivante, quoi que définisse la FeatureRecipe. Lorsque plusieurs champs lisent les faits, chacun reçoit son propre signalement sous une ligne qui nomme ce qu’ils ont en commun :

attachment templates reading the render facts of the components their host is wired to, without declaring it (templates de rattachement lisant les faits de rendu des composants auxquels leur hôte est câblé, sans le déclarer)

Comment corriger : définissez readsTargetRenderFacts: true dans le spec de la FeatureRecipe — readsCallerRenderFacts: true ne lève pas cet arrêt, puisqu’il place des faits sur les composants qui se connectent à l’hôte plutôt que sur ceux auxquels il est câblé. Cela effectue le rendu de ses rattachements après que chaque composant a été rendu, place les faits de chaque cible sur sa connexion, et ne change rien d’autre à ce qu’ils rendent — voir la page de l’entité FeatureRecipe. La clé est le contrat, et cet arrêt vous aide seulement à trouver un template qui en a visiblement besoin : la vérification lit le template tel qu’il est écrit, de sorte qu’une référence construite pendant l’exécution du template, ou une référence écrite dans du contenu importé d’un fichier ou d’une bibliothèque, ne provoque pas d’arrêt — définissez tout de même la clé sur une telle FeatureRecipe. Un template qui lit .context.uses d’une manière quelconque et lit aussi un champ nommé render_facts sur une autre valeur — dont les faits d’un appelant à l’intérieur de {{ range .context.used_by }} — provoque lui aussi un arrêt ; définissez la clé, et aussi readsCallerRenderFacts lorsque le template lit les faits de ses appelants.

Une FeatureRecipe dont le rendu a lieu une seule fois pour une frontière (executionScope: boundary) n’est pas vérifiée ici, pour la raison que donne l’entrée sur les appelants ci-dessus.

A pipeline step reads its targets’ render facts (Une étape de pipeline lit les faits de rendu de ses cibles)

Le with: ou le when: d’une étape de pipeline, dans une FeatureRecipe rattachée à un composant, lit render_facts sous .context.uses — ce que les composants auxquels l’hôte du rattachement est câblé ont signalé sur leurs propres rendus.

Une étape lit les connexions que son hôte établit, comme les lit la propre Recipe de l’hôte, et jamais les faits de rendu de leurs cibles — pour toute FeatureRecipe, qu’elle définisse ou non readsTargetRenderFacts: true. Une étape peut réécrire les propres documents du composant hôte, et le propre rendu de l’hôte lit ce que ses cibles publient, jamais ce qu’elles ont émis, de sorte que les templates d’une étape sont évalués sans ces faits. Une étape qui les lirait ne lirait donc rien, et la build s’arrête avant tout rendu plutôt que de rendre cette lecture comme une valeur vide.

Message émis :

pipeline step reads the render facts of a component its host is wired to, but a pipeline step reads only the host’s own render facts (<reference>, written in <field>) (l’étape de pipeline lit les faits de rendu d’un composant auquel son hôte est câblé, mais une étape de pipeline lit uniquement les propres faits de rendu de l’hôte (avec la référence et le champ où elle est écrite indiqués))

La référence est citée comme dans l’entrée ci-dessus, et le champ nomme l’étape par son id : pipeline[<step>].with ou pipeline[<step>].when. Lorsque plusieurs étapes lisent les faits, chacune reçoit son propre signalement sous une ligne qui nomme ce qu’elles ont en commun :

pipeline steps reading the render facts of the components their host is wired to (étapes de pipeline lisant les faits de rendu des composants auxquels leur hôte est câblé)

Comment corriger : dans une étape, lisez les propres faits de rendu de l’hôte dans .context.render_facts, écrit en entier. Lisez plutôt les faits des cibles dans les templates qui produisent les propres ressources du rattachement — son valuesMapping:, workload: ou artifacts: — avec readsTargetRenderFacts: true défini, comme le décrit la page de l’entité FeatureRecipe. Définir la clé seule ne lève pas cet arrêt. La vérification lit le template tel qu’il est écrit, avec les limites que décrit l’entrée ci-dessus.

Une FeatureRecipe dont le rendu a lieu une seule fois pour une frontière (executionScope: boundary) n’est pas vérifiée ici, pour la raison que donne l’entrée sur les appelants ci-dessus.

Cross-node type safety violation via selector: (Violation de la sûreté de typage inter-nœuds via selector)

Un seul arrêt couvre les deux expressions de labels qu’un auteur de catalogue écrit pour contraindre ce qui peut être câblé ou rattaché, car les deux échouent de la même façon : un ensemble de labels qui ne satisfait pas une expression qu’une entité du catalogue a déclarée.

Une arête uses: dont la cible ne satisfait pas le selector: de son socket. Un socket usesSchema déclare un champ selector: qui exclut le Component cible relié à l’autre extrémité de l’arête. Le sélecteur est la façon dont l’auteur du catalogue dit « ce socket n’accepte que des cibles dont les labels correspondent à cette expression » ; une arête qui satisfait la recherche par nom de socket mais pas l’expression du sélecteur est une violation de la sûreté de typage.

Message émis :

selector violation ("", declared on socket "", not satisfied by the labels of ""). Add the labels the selector requires to the target’s component type, or wire the socket to a component that already carries them. (violation de sélecteur (l’expression indiquée, déclarée sur le socket indiqué, n’est pas satisfaite par les labels de la cible indiquée). Ajoutez au type de composant de la cible les labels que le sélecteur exige, ou câblez le socket à un composant qui les porte déjà.)

Un rattachement dont le composant ne satisfait pas le champ appliesTo: de la Feature. Une Feature déclare à quels composants elle peut être rattachée, sur appliesTo: et sur appliesToAnyOf:. Les exigences de l’expression unique valent ensemble et les alternatives valent alternativement, une seule d’entre elles suffisant ; les deux surfaces doivent être satisfaites, et une surface que la Feature omet est satisfaite par n’importe quoi. Un rattachement dont le composant porte des labels que la déclaration de la Feature n’admet pas relève de la même classe de violation que le cas de l’arête ci-dessus.

Message émis :

selector violation ("", declared by Feature "", not satisfied by the labels of ""). Add the labels the Feature’s appliesTo requires to this component’s type, or attach a Feature whose applicability the component already satisfies. (violation de sélecteur (l’expression appliesTo indiquée, déclarée par la Feature indiquée, n’est pas satisfaite par les labels du composant indiqué). Ajoutez au type de ce composant les labels qu’exige le champ appliesTo de la Feature, ou rattachez une Feature dont le composant satisfait déjà l’applicabilité.)

L’une ou l’autre expression peut aussi être écrite sous une forme que la grammaire des labels ne peut pas lire du tout. Cela est signalé comme le même arrêt, dont la dernière valeur est la raison pour laquelle elle n’a pas pu être lue plutôt que l’ensemble de labels qui ne l’a pas satisfaite — c’est ce qui distingue une expression qui n’a pas pu être évaluée d’une expression qui a été évaluée et s’est révélée fausse :

selector violation ("", declared by Feature "", which could not be evaluated: ""). Correct the appliesTo selector on the Feature’s catalog entity. (violation de sélecteur (l’expression appliesTo indiquée, déclarée par la Feature indiquée, qui n’a pas pu être évaluée, pour la raison indiquée). Corrigez le sélecteur appliesTo sur l’entité de catalogue de la Feature.)

Un sélecteur de socket que la grammaire ne peut pas lire est aussi refusé avant que quoi que ce soit ne câble le socket. aggrega validate, sur l’ensemble du catalogue ou sur un seul Component ou une seule Feature, lit chaque sélecteur de socket que déclare le document propre de l’entité, et refuse celui que la grammaire ne peut pas lire sous cette même condition, qu’une arête soit câblée ou non à travers le socket :

selector violation ("", declared on socket "", which could not be evaluated: ""). Correct the selector on the socket’s declaration in the component type’s usesSchema. (violation de sélecteur, déclaré sur le socket, qui n’a pas pu être évalué. Corrigez le sélecteur dans la déclaration du socket, dans le usesSchema du type de composant.)

Sur un socket d’une Feature, le remède nomme plutôt le usesSchema de la Feature. Rien n’a câblé le socket, la faute revient donc à l’entité de catalogue : elle est classée comme CATALOG_ERROR et nomme le fichier de l’entité.

L’arrêt porte la clé rédigée qu’il concerne — l’entrée de socket uses:, ou l’entrée features: qui nomme le rattachement — avec le fichier qui la déclare, de sorte que la position qu’il signale est l’entrée que vous modifiez plutôt que le début du document. Un Component rédigé à l’intérieur d’un sous-système est positionné sur le sous-système sous lequel il a été rédigé, niveau par niveau. Un rattachement est positionné sur l’entrée features: qui l’a écrit, dans le document qui l’a écrit, et attribué à l’auteur de ce document : le propre bloc du composant ou le bloc d’un sous-système dans l’Aggregate, une faute du développeur ; et, pour un rattachement que seule la Release effectue, son entrée pour le composant ou le bloc features: d’une frontière contenant le composant, une faute de l’opérateur. Lorsque les deux documents écrivent le rattachement, il est positionné là où son type est nommé, ce que fait toujours l’Aggregate. Un rattachement écrit sur une connexion est positionné sur sa clé sous le features: de cette connexion, dans le document qui l’a écrit — l’entrée de connexion de l’Aggregate, ou l’entrée par arête de la Release pour un rattachement que seule la Release effectue. Une Feature que la Release seule rattache à un composant que sa déclaration n’admet pas donne :

[OPS_ERROR E0007] release.yaml at .spec.boundaries.main.components.app.features.metrics
selector violation ("component.aggrega.ai/type in (server, worker)", declared by Feature "core/prometheus-exporter", not satisfied by the labels of "app"). Add the labels the Feature's appliesTo requires to this component's type, or attach a Feature whose applicability the component already satisfies.

et le même rattachement écrit sur le composant dans l’Aggregate donne [DEVELOPER_ERROR E0007] aggregate.yaml at .spec.components.app.features.metrics. Un rattachement produit par l’expansion pilotée par les annotations n’a été écrit par aucune entrée features:, il est donc positionné sur la propre clé features: du composant dans le document qui déclare le composant, comme une faute du développeur.

Comment corriger une violation d’arête : soit routez l’arête uses: vers un Component dont les labels satisfont le sélecteur, soit ajustez l’expression du sélecteur dans l’entité du catalogue pour qu’elle accepte la classe de cible voulue. Examinez les metadata.labels du Component cible avec aggrega inspect pour confirmer quels labels il porte.

Comment corriger une violation de rattachement : soit rattachez la Feature à un composant dont la déclaration de la Feature admet les labels, soit élargissez le champ appliesTo: de la Feature — en ajoutant une alternative sous appliesToAnyOf: lorsque la Feature sert réellement plus d’une classe de composants. Lorsque le composant est censé remplir les conditions et ne les remplit pas, l’élément manquant est généralement un label : examinez-le avec aggrega inspect et ajoutez ce que demande l’expression sur les metadata.labels du Component.

Unknown provider (Fournisseur inconnu)

Une Recipe déclare capability: <name> où <name> ne nomme aucun fournisseur que le compilateur sert. Le compilateur ne peut pas acheminer le rendu vers un fournisseur dont il n’a jamais entendu parler.

Message émis :

unknown provider: <provider-name> (fournisseur inconnu : le nom indiqué)

Comment corriger : vérifiez que le nom du fournisseur est correctement orthographié — cloudformation, compose, helm, helm-chart et terraform sont les noms que servent les plugins fournisseurs intégrés. Si vous visiez un fournisseur d’entreprise personnalisé, assurez-vous qu’un Plugin de rendu de fournisseur servant ce nom (pluginType: provider avec le nom dans ses spec.provider.capabilities) est présent dans l’espace de travail du catalogue vers lequel pointe la build.

A capability is served by more than one provider plugin (Une capacité est servie par plus d’un plugin fournisseur)

Une build atteint une capacité — ou un pull en résout une — servie par plus d’un Plugin de rendu de fournisseur (pluginType: provider, chacun listant cette capacité dans ses spec.provider.capabilities), et l’espace de travail n’a pas sélectionné lequel en effectue le rendu. Plutôt que de choisir un fournisseur arbitrairement, la build s’arrête et nomme les deux candidats. Un catalogue qui contient deux plugins pour la même capacité est légal — deux éditeurs peuvent chacun livrer un plugin pour helm ou compose, et le catalogue accepte les deux. L’ambiguïté n’apparaît qu’au point d’utilisation : l’arrêt se déclenche lorsqu’une build ou un pull atteint effectivement la capacité contestée, pas au chargement.

Message émis. La règle qui a arrêté la build vient en tête, et les détails — quelle capacité, quels candidats et la liaison à écrire — la suivent :

capability is served by more than one provider plugin; add a plugins.providers entry to select one: capability "<capability-name>" is served by more than one provider plugin (<plugin-1>, <plugin-2>); add a plugins.providers entry for "<capability-name>" selecting one (la capacité est servie par plus d’un plugin fournisseur ; ajoutez une entrée plugins.providers pour en sélectionner un : la capacité indiquée est servie par plus d’un plugin fournisseur (ceux indiqués) ; ajoutez une entrée plugins.providers pour la capacité indiquée qui en sélectionne un)

Comment corriger : ajoutez une entrée plugins.providers dans la configuration de l’espace de travail, ayant pour clé la capacité et dont la valeur sélectionne l’identité du plugin qui en effectue le rendu. Conservez les deux plugins dans le catalogue fédéré ; la liaison indique à cet espace de travail vers lequel acheminer la capacité contestée.

The plugin serving a provider cannot assemble what that provider combines (Le plugin qui sert un fournisseur ne peut pas assembler ce que ce fournisseur combine)

Un fournisseur indique ce que devient la sortie par nœud d’un groupe d’acheminement : la sortie de chaque nœud écrite directement au chemin d’acheminement, les fragments fusionnés en un seul document, ou chaque nœud placé à sa propre position dans une structure englobante unique. Lorsqu’un fournisseur indique que la sortie est combinée — un fichier compose fusionné, un chart parapluie — le plugin qui le sert doit offrir l’export qui effectue la combinaison. Cet arrêt se déclenche lorsqu’il ne le fait pas : le plugin annonce le rendu par nœud (render_node) et aucun assemble_boundary correspondant, de sorte que les nœuds du groupe peuvent être rendus mais que leur sortie ne peut pas être fusionnée.

Les deux moitiés de ce désaccord appartiennent au plugin. Ce que devient la sortie d’un groupe d’acheminement fait partie de ce que le plugin signale sur lui-même lorsqu’il est chargé, et l’export qui effectuerait la combinaison est l’une des entrées sous spec.exports d’une entité Plugin, vérifiée par rapport à ce même signalement — l’arrêt nomme donc un plugin qui revendique un assemblage que sa surface d’export ne fournit pas.

La build s’arrête plutôt que de sauter l’assemblage. Le sauter écrirait le fragment de chaque nœud au chemin où un seul artefact était attendu et signalerait un succès, et rien plus loin ne peut distinguer ces fragments de la sortie plate par nœud qu’un fournisseur ne revendiquant aucun assemblage émet par conception — un artefact manquant apparaîtrait donc là où la sortie est appliquée plutôt qu’au moment de la build.

Un groupe d’acheminement sans chemin d’acheminement est ignoré. Une sortie écrite à aucun chemin est une sortie par nœud, donc rien n’y est assemblé sur quoi une revendication de combinaison pourrait porter.

Message émis — un constat par groupe d’acheminement fautif, qui nomme le fournisseur et le chemin auquel ce groupe s’assemble :

provider expected to assemble its dispatch group provides no boundary assembler ("<provider>", dispatch path "<path>") (le fournisseur censé assembler son groupe d’acheminement ne fournit aucun assembleur de frontière (avec le fournisseur et le chemin d’acheminement indiqués))

Lorsque plus d’un groupe d’acheminement est fautif, les constats arrivent ensemble sous le signalement dispatch groups whose provider offers no boundary assembler.

Comment corriger : servez la capacité avec un plugin qui annonce à la fois render_node et assemble_boundary — voir ../entities/plugin.md pour la surface de rédaction spec.exports, et ../schema/plugins/wasm-provider.md pour ce que reçoit l’export d’assemblage. Si vous rédigez le plugin, il vous revient d’aligner les deux côtés : ajoutez l’export d’assemblage, ou ne signalez aucune revendication d’assemblage et laissez la sortie de chaque nœud arriver au chemin d’acheminement sans fusion. Si vous utilisez un plugin publié, sélectionnez une version qui offre les deux exports, ou sélectionnez un plugin dont le fournisseur ne revendique aucun assemblage pour cette capacité.

A boundary-level Feature’s output reaches no assembled file (La sortie d’une Feature de portée frontière n’atteint aucun fichier assemblé)

Une Feature rattachée sous le features: d’une frontière, dont la FeatureRecipe déclare executionScope: boundary, effectue son rendu une seule fois pour toute la frontière, et sa sortie va dans le répertoire auquel le directory: et le subDirectory: propres à la frontière s’évaluent pour elle. Un fournisseur qui fusionne sa sortie en un seul document — compose, en un seul docker-compose.yaml ; cloudformation, en une seule stack — n’écrit la contribution d’une telle Feature que dans le cadre du fichier qu’il y assemble à partir des composants de la frontière. Ce fichier n’existe que là où la sortie d’au moins un composant arrive dans le même répertoire sous le même fournisseur.

Il n’existe pas là où les composants de la frontière arrivent ailleurs : lorsqu’ils se trouvent dans des frontières imbriquées dont le subDirectory: les envoie ailleurs — "{{ .component_id }}", par exemple, de sorte que chaque composant obtienne son propre fichier — ou sous un répertoire que la sortie de la Feature ne partage pas. Rien n’est assemblé dans le répertoire de la Feature, donc sa sortie ne serait écrite nulle part — pour le pont compose, un service de passerelle qu’aucun fichier ne contient — et la build signalerait un succès. La build s’arrête à la place.

Une Feature dont le fournisseur écrit chaque contribution sous forme de fichiers propres — helm, helm-chart et terraform — n’est pas concernée : ces fichiers sont écrits, que quelque chose soit assemblé à côté d’eux ou non.

Message émis — un constat par Feature fautive, positionné à son entrée sous le features: de la frontière, qui nomme la frontière, la Feature, le chemin d’acheminement vers lequel sa sortie a été dirigée et le fournisseur :

boundary-level Feature’s output is routed to a dispatch path nothing assembles (boundary "<boundary>", feature "<instance>", dispatch path "<path>", provider "<provider>"). attach the Feature at a boundary whose output path also receives its components, or give the boundary’s components the directory the Feature’s output is routed to (la sortie de la Feature de portée frontière est dirigée vers un chemin d’acheminement où rien n’est assemblé (avec la frontière, l’instance de Feature, le chemin d’acheminement et le fournisseur indiqués). rattachez la Feature à une frontière dont le chemin de sortie reçoit aussi ses composants, ou donnez aux composants de la frontière le répertoire vers lequel la sortie de la Feature est dirigée)

Un pont compose rattaché à une frontière parente bridge, dont l’unique frontière enfant place chaque composant sous subDirectory: "{{ .component_id }}", affiche :

[OPS_ERROR E0365] release-compose.yaml at .spec.boundaries.bridge.features.gateway
boundary-level Feature's output is routed to a dispatch path nothing assembles (boundary "bridge", feature "gateway", dispatch path "bridge/compose", provider "compose"). attach the Feature at a boundary whose output path also receives its components, or give the boundary's components the directory the Feature's output is routed to

Lorsque plus d’une Feature est fautive, les constats arrivent ensemble sous le signalement boundary-level Features whose output is routed to a dispatch path nothing assembles.

Comment corriger : faites du répertoire de la Feature un répertoire où arrivent aussi les composants de sa frontière. Rattachez la Feature à une frontière dont le propre chemin de sortie reçoit ces composants, ou donnez aux composants le répertoire vers lequel la sortie de la Feature est dirigée — pour les frontières enfants, directory: "{{ .parent_boundary.directory }}" sans subDirectory: propre, afin qu’elles partagent le fichier du parent. Le message nomme le répertoire vers lequel la sortie de la Feature a été dirigée, qui est celui à partager.

Path-template references a variable outside the allowlist (Le template de chemin référence une variable en dehors de la liste d’autorisation)

Un template directory: ou subDirectory: référence un nom de variable que la liste d’autorisation des variables de template de chemin n’inclut pas — par exemple une faute de frappe comme {{ .parmaeters.region }}, ou un champ qui existe dans le contexte de rendu de la Recipe mais n’est pas exposé aux templates de chemin (comme .context.inject ou .values). Le même arrêt couvre {{ .component_id }} dans un template directory: : la variable existe, et les templates subDirectory: peuvent la lire, mais le directory: d’une frontière est évalué une seule fois pour toute la frontière plutôt qu’une fois par composant, de sorte qu’une variable par composant à cet endroit ferait dépendre le chemin émis du composant qui se trouverait évalué en premier.

Les templates de chemin sont validés au moment de l’analyse, avant que tout travail de rendu ne commence, par rapport aux variables que le contexte de template de chemin définit, moins celles que la surface concernée refuse. Le compilateur évalue aussi les templates de chemin avec la sémantique missingkey=error, de sorte qu’une référence présente dans la liste d’autorisation mais non définie au moment de l’évaluation produit une erreur explicite plutôt que de rendre discrètement une chaîne vide dans un chemin de répertoire.

Cet arrêt concerne la variable. Une clé mal saisie sous une variable autorisée — {{ .manifest.recipe_nmae }} — signale plutôt « Template references a root the render context does not define (Le template référence une racine que le contexte de rendu ne définit pas) » ci-dessus, en nommant les clés que .manifest définit, car la variable elle-même a été admise et seule la clé était erronée.

Message émis :

path template references a field not in the documented allowlist ("<dotted-path>", written in "<directory|subDirectory>", the render context defines "<the variables that field may read>") (le template de chemin référence un champ absent de la liste d’autorisation documentée (avec le chemin indiqué, écrit dans le champ indiqué ; le contexte de rendu définit les variables indiquées))

Comment corriger : corrigez le nom du champ en l’un de ceux de la liste d’autorisation des templates de chemin, ou supprimez la référence. La liste d’autorisation de directory: est {{ .capability }}, {{ .boundary_name }}, {{ .parameters.X }}, {{ .manifest.recipe_name }} et {{ .parent_boundary.* }} ; subDirectory: ajoute {{ .component_id }}. Les autres surfaces (valuesMapping de la Recipe, injectMapping de la FeatureRecipe, etc.) utilisent une autre forme de contexte ; les références à .context.*, .values, .infra ou .locals ne sont délibérément pas exposées aux templates de chemin, car l’émission des chemins est une question structurelle, et non une question de rendu des valeurs.

Path collision: two contributors emit at incompatible paths (Collision de chemins : deux contributeurs émettent à des chemins incompatibles)

Deux frontières dont les déclarations de chemin s’évaluent au même chemin d’assemblage passent par des fournisseurs différents. Les deux y assemblent, et chacun écrit des fichiers dont l’autre ne sait rien, de sorte que l’un remplace discrètement l’autre sur le disque — et la build qui a produit la sortie remplacée semble avoir réussi.

Le subDirectory: par défaut donne à chaque fournisseur un sous-chemin qui lui est propre, de sorte que deux fournisseurs n’atteignent un même chemin que là où les déclarations ont été écrites pour s’évaluer de la même façon : deux frontières partageant un directory: et fixant toutes deux subDirectory: au même littéral, par exemple.

Messages émis. Un constat est signalé par frontière contributrice, de sorte que chaque frontière dont la sortie a atteint le chemin est nommée individuellement plutôt que regroupée dans une liste à l’intérieur d’un seul message. La faute est la rencontre de deux fournisseurs à un même chemin, il y a donc toujours au moins deux constats, et ils arrivent ensemble sous un signalement qui indique ce qu’ils ont en commun :

assembly paths reached by more than one provider (chemins d’assemblage atteints par plus d’un fournisseur)

Chaque constat nomme le chemin, la frontière dont la sortie l’a atteint et le fournisseur par lequel passe cette frontière :

dispatch path produced multiple provider outputs ("<path>", boundary "<boundary>", provider "<provider>") (le chemin d’acheminement a produit plusieurs sorties de fournisseur (avec le chemin, la frontière et le fournisseur indiqués))

Une build dont les frontières api-net et db-net déclarent toutes deux directory: ./dist/shared et subDirectory: merged, l’une passant par helm et l’autre par compose, affiche :

[OPS_ERROR E0048]
assembly paths reached by more than one provider
caused by (2):
[OPS_ERROR]
dispatch path produced multiple provider outputs ("dist/shared/merged", boundary "db-net", provider "compose")
---
[OPS_ERROR]
dispatch path produced multiple provider outputs ("dist/shared/merged", boundary "api-net", provider "helm")

Le signalement porte le code court et chaque constat en dessous ne porte que sa catégorie, ce qui est la forme qu’utilise tout signalement d’échecs collectés — voir error-translation.md pour cette grammaire.

Comment corriger : donnez à chaque frontière un directory: distinct (afin qu’elles s’assemblent à des chemins séparés), ou laissez subDirectory: à sa valeur par défaut afin que la sortie de chaque fournisseur arrive à un sous-chemin qui lui est propre. Le motif du pont compose fusionne intentionnellement deux sous-frontières en un seul chemin d’assemblage ; ce motif exige que les deux frontières ciblent le même fournisseur et portent des annotations résolues en cascade compatibles.

A boundary’s output directory is not a directory beneath the output root (Le répertoire de sortie d’une frontière n’est pas un répertoire sous la racine de sortie)

Le directory: et le subDirectory: d’une frontière sont évalués et joints pour former le répertoire sous lequel sa sortie est écrite, et ce chemin est normalisé une fois : out/a, out//a, ./out/a et out/a/ sont un seul répertoire. Lorsque le chemin normalisé n’est pas un répertoire sous la racine de sortie, la build s’arrête avant que quoi que ce soit ne soit écrit. Il s’agit d’un chemin qui remonte hors de la racine de sortie (.., ../escape, a/../..), d’un chemin absolu (/srv/out), ou d’un chemin qui ne nomme aucun répertoire : une valeur vide, ou une valeur qui se normalise en la racine de sortie elle-même, comme directory: "." avec le sous-répertoire désactivé.

Le chemin est vérifié tel qu’il a été évalué, de sorte que c’est le résultat d’un template qui est jugé, et non le texte écrit. Le message nomme le champ d’où vient la faute — directory: lorsque le répertoire seul sort déjà de la racine de sortie ou lorsqu’aucun sous-répertoire n’y est joint, subDirectory: sinon — ainsi que la valeur à laquelle ce champ s’est évalué et le chemin qu’il a produit.

Message émis :

boundary output directory does not name a directory beneath the output root (Release "<release>", boundary "<boundary>", directory: "<value>", output path "<path>"). write a directory beneath the output root, such as “deploy/prod” — no leading ”/”, no ”..” climbing above it, and not the output root itself (le répertoire de sortie de la frontière ne nomme pas un répertoire sous la racine de sortie (avec la Release, la frontière, la valeur de directory et le chemin de sortie indiqués). écrivez un répertoire sous la racine de sortie, comme « deploy/prod » — sans « / » initial, sans « .. » qui remonte au-dessus, et pas la racine de sortie elle-même)

Lorsque la faute vient du sous-répertoire, la troisième valeur indique subDirectory: "<value>" à la place.

Comment corriger : écrivez le champ que nomme le message comme un répertoire sous la racine de sortie. Un répertoire destiné à se trouver à côté de la racine de sortie doit plutôt se trouver à l’intérieur. Pour écrire la sortie d’une frontière directement dans son directory:, définissez subDirectory: "." — le répertoire lui-même doit tout de même nommer un répertoire qui lui est propre.

A boundary-level Feature is named . or .. (Une Feature de portée frontière est nommée . ou ..)

Un fournisseur qui donne à chaque contributeur un répertoire qui lui est propre — terraform, sous modules/, et helm-chart, sous charts/ — place une Feature rattachée à une frontière dans un répertoire nommé d’après la seule instance, à côté des composants de la frontière. La clé features: d’une frontière admet . et .., et aucun des deux n’est un nom de répertoire : . placerait les fichiers de la Feature dans le répertoire qui contient tous les contributeurs, et .. dans celui du dessus, de sorte que les fichiers arriveraient hors de la position que le fournisseur a donnée à la Feature. La build s’arrête à la place. Tout autre nom est laissé intact, y compris un nom à points comme audit.v2.

Message émis :

boundary-level Feature instance name is not a directory name (Release "<release>", boundary "<boundary>", feature "<instance>"). rename the Feature instance under the boundary’s features to an ordinary name, such as “audit” (le nom d’instance de la Feature de portée frontière n’est pas un nom de répertoire (avec la Release, la frontière et l’instance de Feature indiquées). renommez l’instance de Feature sous les features de la frontière avec un nom ordinaire, comme « audit »)

Comment corriger : renommez l’instance sous le features: de la frontière avec un nom ordinaire.

Instance-ID collision across boundaries assembling to the same path (Collision d’ID d’instance entre frontières assemblées au même chemin)

Deux frontières qui s’assemblent au même tuple (chemin, fournisseur) apportent des composants aux ID d’instance identiques. L’assemblage fusionné ne peut pas distinguer les deux fragments de composant — un seul chart Helm ne peut pas porter deux Deployments nommés web-server, et un seul fichier docker-compose ne peut pas porter deux services nommés api.

Message émis :

multiple contributors share an instance ID at the same dispatch path: dispatch path "<path>" provider "<provider>" already contains node "<instance-id>" (contributing boundaries: [<boundaries>]); component instance IDs must be unique within an assembly group (plusieurs contributeurs partagent un ID d’instance au même chemin d’acheminement : le chemin d’acheminement et le fournisseur indiqués contiennent déjà le nœud indiqué (avec les frontières contributrices indiquées) ; les ID d’instance des composants doivent être uniques au sein d’un groupe d’assemblage)

Comment corriger : renommez l’un des composants en collision dans l’Aggregate, ou séparez les deux frontières sur des chemins directory: distincts afin que chaque instance de composant arrive dans son propre assemblage.

Two contributors write the same output path (Deux contributeurs écrivent le même chemin de sortie)

Deux contributeurs à un même assemblage produisent un fichier au même chemin de sortie. Ce cas est distinct de la collision d’ID d’instance ci-dessus : les composants portent des noms différents et l’assemblage sait les distinguer — ce sont les fichiers qu’ils émettent qui aboutissent à un même chemin. Cela se produit le plus souvent lorsqu’un fournisseur écrit la sortie de chaque contributeur côte à côte plutôt que sous une position par composant, de sorte que deux composants dont les Recipes émettent le même nom de fichier (deux entrées artifacts: toutes deux nommées main.tf, par exemple) se rencontrent sur un même chemin. La propre sortie de l’assembleur peut entrer en collision avec le fichier d’un contributeur de la même manière.

Le fait que deux contributeurs émettant un même nom de fichier entrent en collision dépend de l’endroit où leur fournisseur les place. Un fournisseur qui imbrique chaque contributeur sous sa propre position dans l’assemblage garde séparés deux fichiers de même nom ; un fournisseur qui écrit les contributeurs côte à côte ne le fait pas. La comparaison porte sur le chemin final où un fichier serait écrit, et non sur le nom que le contributeur a émis, de sorte que le cas imbriqué n’est pas signalé.

La build s’arrête plutôt que d’écrire l’un des deux fichiers et d’écarter l’autre. Il n’existe aucune résolution silencieuse correcte : renommer un fichier ou lui ajouter un suffixe inventerait un nom que personne n’a rédigé, et fusionner leurs contenus inventerait un document que personne n’a écrit. Chaque chemin en collision est signalé, et chaque contributeur qui l’écrit est nommé, de sorte qu’une seule build vous donne la vue d’ensemble plutôt qu’une collision à la fois.

Messages émis. Un constat est signalé par chemin en collision — une seule fois, quel que soit le nombre de frontières ayant alimenté l’assemblage où elle s’est produite —, de sorte qu’une build dont les contributeurs se sont rencontrés sur deux chemins vous informe des deux et qu’aucune collision n’est signalée deux fois :

assembled output collision: two contributors write the same output path (output path "<output-path>", written by "<contributor-1> and <contributor-2>", assembled within "<boundary-1> and <boundary-2>") (collision dans la sortie assemblée : deux contributeurs écrivent le même chemin de sortie (avec le chemin de sortie, les contributeurs qui l’écrivent et les frontières au sein desquelles il a été assemblé indiqués))

Chaque contributeur est nommé d’après ce qu’il est, ce qui indique où son nom est écrit : component <name> pour une instance de composant, feature <name> pour une fonctionnalité rattachée à une frontière, et the <provider> assembly pour la propre sortie fusionnée de l’assemblage. Les contributeurs sont listés dans l’ordre de leurs noms, de sorte que la phrase est la même à chaque build de la même entrée.

Un fichier qu’une Recipe apporte à la sortie partagée de la frontière est lui aussi soumis à cette règle. Le bloc boundary: d’une Recipe écrit ses fichiers à côté de la propre sortie assemblée du fournisseur, une fois par nom de fichier. Plusieurs composants qui déclarent un nom avec des octets identiques forment un seul fichier et n’entrent jamais en collision ; le déclarer avec des octets différents provoque ici une collision, qui nomme le fichier et chaque composant qui l’a déclaré, et il en va de même pour un nom que l’assemblage du fournisseur écrit lui-même — aggrega.modules.tf pour terraform, par exemple, qui nomme the terraform assembly parmi les contributeurs. Un fichier que plusieurs composants ont déclaré de manière identique et qui rencontre le propre fichier de l’assemblage est nommé avec tous ces composants, sous la forme component <name-1> and component <name-2>.

Les frontières qui ont alimenté l’assemblage sont nommées elles aussi, et elles sont listées plutôt que désignées individuellement. Des frontières dont les déclarations directory: s’évaluent de la même manière s’assemblent comme une seule, et rien dans une collision n’indique dans laquelle d’entre elles les contributeurs qui se sont rencontrés ont été déclarés — le constat vous donne donc chaque frontière dont la déclaration pourrait les séparer et n’affirme d’aucune qu’elle est celle qui est en faute. Le constat est signalé sur le document de la Release dans son ensemble pour la même raison : nommer une frontière à l’intérieur vous enverrait vers un document qui n’a peut-être rien apporté au chemin.

Lorsque plusieurs chemins entrent en collision, les constats arrivent ensemble sous un signalement qui indique ce qu’ils ont en commun :

assembled output paths written by more than one contributor (chemins de la sortie assemblée écrits par plus d’un contributeur)

Comment corriger : renommez le fichier émis dans la Recipe que vous contrôlez — une clé de artifacts:, la clé d’un bloc boundary:, ou le nom de fichier que dérive une traduction de Workload — afin que les deux ne se rencontrent plus. Lorsque deux Recipes déclarent un même fichier partagé et désignent la même configuration, rendez leurs déclarations identiques octet pour octet. Lorsque les deux contributeurs relèvent réellement de sorties distinctes, donnez à leurs frontières des chemins directory: distincts afin que chacune s’assemble séparément.

The same name is derived more than once inside the output (Le même nom est dérivé plus d’une fois à l’intérieur de la sortie)

Un assemblage finit par utiliser le même nom deux fois pour quelque chose à l’intérieur des fichiers qu’il émet, à un endroit où il n’y a de place que pour un seul. Cela se produit de deux façons : deux contributeurs dérivent le même nom, ou la propre sortie d’un seul contributeur porte ce nom deux fois. Ce cas est distinct des deux collisions ci-dessus : lorsque deux contributeurs sont en cause, les composants portent des noms différents et leurs fichiers aboutissent à des chemins différents, de sorte que rien dans la structure de l’assemblage n’est faux — c’est un nom dans le contenu, comme l’identifiant qu’une cible utilise pour adresser une ressource, ou le nom sous lequel une sortie est publiée pour qu’une autre y fasse référence.

Les noms comparés découlent de ce que le fournisseur fait de la sortie d’un assemblage. Lorsque le fournisseur fusionne cette sortie en un seul document — un template de stack, un fichier compose —, les noms à l’intérieur de ce document sont comparés entre eux, et un contributeur dont la sortie est écrite sous forme de fichiers distincts qui lui sont propres reste en dehors. Ses noms n’en rencontrent aucun autre, de sorte que rien ne s’arrête entre eux, et rien de ce que vous pourriez renommer n’y changerait quoi que ce soit. Lorsque le fournisseur écrit plutôt la sortie de chaque contributeur sous forme de fichiers qui lui sont propres — un rendu de chart, un ensemble de manifestes —, chaque contributeur à l’assemblage est comparé à tous les autres, car un nom dans une telle sortie est unique dans tout ce qui lit ces fichiers comme un ensemble plutôt qu’au sein d’un seul fichier.

Les propres ressources d’une FeatureRecipe suivent le même chemin que celles de son composant hôte, car un rattachement contribue à l’assemblage auquel appartient son hôte. Ainsi, lorsque le fournisseur fusionne, les noms d’un rattachement sont comparés à ceux de son composant hôte et à ceux de chaque autre rattachement, exactement comme le sont les noms de deux composants : tous aboutissent dans le même document, et de deux noms égaux, l’un y supplante l’autre. Lorsque le fournisseur ne fusionne pas, les ressources du rattachement sont écrites sous un répertoire nommant le composant auquel il est rattaché, et ses noms sont tout de même comparés à chaque contributeur à l’assemblage — c’est là qu’est détectée une identité de ressource qui doit être unique dans tout un cluster. La comparaison est donc la même dans les deux cas, et seul diffère l’endroit où se retrouve le nom qui serait supplanté.

Une moitié de l’arrêt n’est en rien concernée par tout cela : la propre sortie d’un seul contributeur portant un nom deux fois. Il s’agit d’un nom utilisé deux fois dans une sortie qu’un seul contributeur a écrite, de sorte qu’il provoque un arrêt où que cette sortie ait été écrite, et les deux choses à séparer se trouvent toujours à l’intérieur.

La plupart de ces noms sont propres à un fournisseur, dérivés de l’instance de composant et de la ressource, de sorte que deux composants peuvent aboutir à un même nom chaque fois que les parties dont il est dérivé concordent — et un composant peut aboutir deux fois à un même nom de la même manière, lorsque deux de ses propres ressources sont construites à partir de parties qui concordent. Comme le nom réside dans les octets mêmes du fichier, l’assemblage ne peut pas le voir : le fournisseur signale les noms qu’il a dérivés, et la build les compare.

Un type de nom appartient à la build plutôt qu’à un fournisseur, et il est signalé de la même manière : l’identité dont est étiquetée chaque ressource qu’émet une FeatureRecipe, qui atteint votre sortie sous la forme du label aggrega.ai/component-id. Elle est signalée sous le type de nom component-id, de sorte que vous pouvez retrouver la même chaîne dans votre propre sortie émise. Lorsqu’une FeatureRecipe synthétise ses ressources, cette identité est aussi ce d’après quoi elles sont nommées ; lorsqu’elle effectue le rendu d’un chart ou d’un fragment fourni par son auteur, les noms dans ce rendu restent ceux du composant hôte et seuls les labels portent l’identité.

Pour une fonctionnalité rattachée à un composant, elle est composée du composant auquel la fonctionnalité est rattachée et de la clé que vous avez écrite sous features:, derrière un préfixe fixe. Le composant hôte fait partie de la valeur parce qu’un même nom de fonctionnalité rattaché à plusieurs composants émet un ensemble distinct de ressources sur chacun, et chaque ensemble a besoin d’une identité propre.

Pour une fonctionnalité rattachée à une frontière, elle est composée du nom de la fonctionnalité et de chaque segment du chemin de la frontière, derrière un préfixe qui lui est propre. Les deux cas composent plutôt que de substituer : un caractère que l’alphabet des labels refuse est transcrit plutôt que remplacé, et les parties sont jointes par une séquence qu’aucune partie écrite ne peut contenir, de sorte que deux rattachements que vous savez distinguer aboutissent toujours à deux identités. Le seul résidu est la longueur : une identité composée trop longue pour une valeur de label est raccourcie autour d’un digest de sa totalité, et deux identités raccourcies peuvent en principe se rencontrer. Cet arrêt signale une telle rencontre entre deux contributeurs dont les noms sont comparés, et deux rattachements sur un même composant sont deux tels contributeurs partout où le fournisseur de leur hôte les assemble ensemble. Voir ../providers/well-known-annotations.md pour la façon dont chacune est construite.

Un rendu Kubernetes signale un type de nom qui lui est propre : le nom que porte dans son metadata.name chaque ressource produite par son propre rendu. Un tel nom doit être unique au sein de son kind — et, pour un type que le cluster conserve dans des namespaces, au sein de son namespace — plutôt que dans toute la sortie, de sorte que le type de nom indique auquel de ces périmètres il se limite. Il commence par resource-names puis porte le kind de la ressource et le namespace où la ressource aboutit, qui est celui que la ressource nomme pour elle-même ou, lorsqu’elle n’en nomme aucun, celui dont la frontière est annotée. Ainsi, resource-names:Service--default désigne les noms des Services qui aboutissent dans default. Un type que l’API Kubernetes conserve en dehors de tout namespace — un ClusterRole, une StorageClass, une CustomResourceDefinition — et un type personnalisé qu’une CustomResourceDefinition du même rendu déclare avec la portée Cluster portent leur seul kind, quel que soit le namespace qu’écrit leur document : resource-names:ClusterRole désigne les noms de chaque ClusterRole que porte la sortie. Tout ce qui sort des lettres et des chiffres est transcrit plutôt que remplacé et les deux parties sont jointes par une séquence qu’aucune partie écrite ne peut contenir, de sorte que deux paires différentes n’aboutissent jamais à un même type de nom, et qu’un type seul n’aboutit jamais au type de nom d’un type et d’un namespace. Un Service et un Deployment peuvent partager un nom, et deux namespaces contiennent indépendamment un même nom d’un type à namespace, de sorte qu’aucun de ces cas ne provoque d’arrêt. Le nom lui-même est signalé exactement tel que votre chart l’a écrit, ce qui en fait la chaîne à rechercher dans vos templates.

Ainsi, deux contributeurs à une même sortie qui écrivent chacun un même objet à l’échelle du cluster sous un même nom provoquent un arrêt même lorsque la Release les place dans deux namespaces, car appliquer les deux écrit cet objet unique deux fois ; et un chart qui écrit un tel objet sous deux namespaces différents, que le rendu émet sous forme de deux fichiers, provoque un arrêt comme un seul contributeur portant le nom deux fois. Un type que rien dans le rendu ne classe — un type personnalisé dont le rendu n’émet pas la CustomResourceDefinition, ou un document qui ne nomme aucun apiVersion — est comparé au sein de son namespace, comme l’est un type à namespace, car rien dans le rendu n’indique que le cluster le conserve en dehors d’un namespace ; deux contributeurs écrivant un tel objet dans deux namespaces ne se rencontrent donc pas.

Les noms sont comparés entre les contributeurs à une même sortie, et jamais entre deux sorties. Deux frontières sont deux sorties lorsque chacune possède un répertoire propre — un qu’elle nomme, ou celui qui est attribué à chaque frontière ne nommant aucun directory: — et rien dans une build n’indique si deux sorties sont appliquées à un même cluster ou à deux : la CustomResourceDefinition d’un même opérateur livrée à chacun de deux clusters est le même nom dans deux sorties, et c’est correct. Ainsi, deux frontières qui écrivent chacune un même objet à l’échelle du cluster sous un même nom n’arrêtent pas la build, même lorsque les deux sont appliquées à un même cluster ; dans ce cas, émettez l’objet depuis une seule d’entre elles.

La disposition qui atteint le plus souvent cet arrêt est celle de deux Features rattachées à un même composant, chacune livrant un chart fourni par son auteur. Les deux charts effectuent leur rendu avec le même nom de release — celui du composant hôte, afin que rattacher un chart ne renomme pas des ressources que son auteur a déjà déclarées et déployées — et nommer une ressource d’après le nom de release est l’une des choses les plus courantes que fait un chart. Rien dans la structure de la sortie n’est faux : les deux ressources portent simplement un même nom. Lorsque le fournisseur du composant écrit des documents distincts, chaque rattachement écrit sous un répertoire qui lui est propre et appliquer les deux laisse celui qui a été appliqué en dernier ; lorsqu’il replie son groupe en un seul document, les deux rattachements contribuent à ce document et, des deux noms, l’un supplante l’autre à l’intérieur. Renommez la ressource dans le chart que vous contrôlez, ou donnez-lui un nom portant quelque chose qui distingue les deux rattachements — et c’est le rattachement qui doit atteindre le template, car les deux charts effectuent leur rendu avec le nom de release de l’hôte, de sorte que renommer le rattachement seul ne change rien. Transmettez .attachment_name au chart via le valuesMapping: de la FeatureRecipe, et définissez-le sur celle des propres valeurs du chart à partir de laquelle sont construits les noms de ses ressources.

Une deuxième disposition atteint le même arrêt avec une seule Feature au lieu de deux : un chart dont le template écrit un nom de ressource sous forme de littéral, rattaché à deux composants. Chaque hôte en effectue le rendu sous un nom de release qui lui est propre, de sorte que le littéral est la seule raison pour laquelle les deux copies portent un même nom — nommez la ressource d’après .Release.Name et l’hôte y figure de nouveau, ce que fait déjà un chart qui construit les noms de ses ressources à partir de son identité de release.

Une troisième disposition présente la même structure, une surface de rédaction plus loin : une FeatureRecipe livrant ses ressources via artifacts: plutôt que via un chart, rattachée sous un même nom à deux composants, et dont le corps écrit un nom de ressource sous forme de littéral. La sortie de chaque rattachement aboutit sous un répertoire nommant son hôte, de sorte que les chemins émis diffèrent et que rien dans la structure de la sortie n’est faux — mais les deux corps portent le même nom, et appliquer les deux laisse celui qui a été appliqué en dernier. Un nom dans un corps d’artifacts est comparé exactement comme l’est un nom dont un chart a effectué le rendu : les deux décrivent la même ressource dans le même cluster, de sorte que la provenance du nom ne change rien à ce qui se passe lorsque les deux sont appliqués. Cette lecture repose sur le fait que les deux noms soient lus ensemble, ce qui se produit lorsqu’un fournisseur écrit la sortie de chaque contributeur sous forme de fichiers qu’une cible lit comme un seul ensemble. Lorsque le fournisseur fusionne plutôt la sortie d’un assemblage en un seul document, les fichiers de chaque rattachement restent en dehors de ce document et un nom à l’intérieur de l’un d’eux est limité à celui-ci, de sorte que deux tels rattachements ne se rencontrent jamais et que la build se poursuit.

Tous les noms ne sont pas signalés, de sorte qu’une build qui ne s’arrête pas n’a pas établi que chaque nom que sa sortie finira par porter a été comparé. Une ressource dont le nommage est laissé au cluster — une ressource déclarant generateName au lieu de name — ne porte encore aucun nom, il n’y en a donc aucun à signaler. Et un nom écrit dans un autre champ pour qu’un contrôleur le lise plus tard n’est pas un nom de ressource, donc rien ne le compare. Ces deux limites sont des propriétés de la lecture du document émis, de sorte qu’elles s’appliquent toutes deux à un corps d’artifacts exactement comme à un template de chart rendu.

Un corps artifacts: est un template, de sorte qu’un nom qu’il contient et qui doit être distinct pour chaque hôte est composé plutôt qu’écrit sous forme de littéral. .context.rendered_name est le nom que lui donne le propre fournisseur du composant hôte — sous helm, son nom de release, écrit dans les caractères qu’autorise un nom Kubernetes — et .attachment_name est la clé sous laquelle vous l’avez rattaché, de sorte que {{ .context.rendered_name }}-{{ .attachment_name }} donne à une ressource un nom qui lui est propre sur chaque hôte et sous chaque rattachement. Sur un hôte dont le fournisseur ne signale aucun nom de ce type, composez-le plutôt à partir de .context.instance_id, l’identité de l’hôte. Un même corps rédigé atteint chaque hôte auquel il est rattaché en portant les noms qu’il contient, et un littéral est le même sur tous — donnez donc cette structure à un nom qui doit être unique dans le cluster.

Rien de la signification d’un nom n’est interprété — deux noms signalés sont soit le même texte, soit non —, c’est pourquoi le même signalement couvre tous les types de nom, quel que soit celui qui l’a dérivé.

Un nom peut apparaître dans plus d’un signalement pour un même composant, car chaque partie d’un composant est signalée au moment de son rendu. Il s’agit d’une seule ressource nommée dans chaque signalement auquel elle appartient, et non d’un nom utilisé deux fois, et cela ne provoque pas d’arrêt. Ce qui provoque un arrêt, c’est un seul signalement portant un nom deux fois, car ce signalement décrit une sortie où le nom est réellement utilisé deux fois.

Cette lecture dépend de ce qui compte comme un seul contributeur, et pour le type component-id la réponse est le rattachement plutôt que le composant ou la frontière où il se trouve. Un rattachement est identifié par les deux coordonnées que vous avez écrites pour lui — le composant auquel il est rattaché avec la clé sous features:, ou le chemin de la frontière avec le nom à cette frontière —, de sorte que deux rattachements sur un même composant sont deux contributeurs, exactement comme le sont deux rattachements sur des composants différents, et qu’un nom de fonctionnalité écrit à deux frontières constitue deux contributeurs même si le nom est le même à chacune. C’est le fait d’être deux contributeurs qui rend leurs identités comparables dans chacune de ces dispositions ; la question de savoir si deux d’entre eux sont comparés suit la même règle que tout autre nom ici, de sorte que, lorsque le fournisseur fusionne, un rattachement dont la sortie est écrite sous forme de fichiers distincts qui lui sont propres reste en dehors du document fusionné et n’est comparé qu’à lui-même. Deux rattachements qui aboutissent à une même identité provoquent donc un arrêt partout où leur sortie peut atteindre celle de l’autre, et chaque constat nomme ses deux coordonnées afin que vous puissiez savoir quelles deux choses séparer. Comme les deux coordonnées font partie de la valeur composée, deux rattachements que vous savez distinguer aboutissent à deux identités à toute longueur qui tient — la disposition qui atteint cet arrêt est donc celle où une valeur trop longue pour sa cible a été raccourcie et où deux valeurs raccourcies se sont rencontrées. Lorsque deux identités raccourcies se rencontrent et que leur sortie ne peut pas atteindre celle de l’autre — deux rattachements sur un même composant, sous un fournisseur qui fusionne, chacun écrit sous forme de fichiers distincts qui lui sont propres —, rien ne les compare, et les deux ensembles de ressources portent à eux deux un même aggrega.ai/component-id.

Une disposition mérite d’être énoncée explicitement, car elle semble devoir provoquer un arrêt et ne le fait pas : rattacher une fonctionnalité sous le même nom à deux composants est entièrement pris en charge et ne nécessite aucun renommage. Le composant fait partie de la valeur composée, de sorte que metrics sur api et metrics sur web aboutissent à deux identités et que les ressources de chaque composant reçoivent une identité propre — ce qui importe, car une cascade qui attribue par conception un même nom de rattachement à de nombreux composants ne laisse à un auteur aucun autre nom à écrire. Chaque façon dont une FeatureRecipe livre des ressources appose son identité sur ce qu’elle émet, y compris celle qui ne fait qu’embarquer une source et en effectue le rendu telle quelle, de sorte que chacune d’elles est comparée ; une fonctionnalité dont la FeatureRecipe n’émet rien du tout n’a rien à comparer.

La build s’arrête plutôt que de garder l’un et d’écarter l’autre. Il n’existe aucune résolution silencieuse correcte : garder le premier retirerait entièrement de la sortie une ressource que vous avez déclarée et laisserait la build signaler un succès, et tout ce qui faisait référence à la ressource retirée se résoudrait discrètement vers celle qui subsiste. Chaque nom en collision est signalé, chacun avec le type de nom qu’il est et avec chaque contributeur qui l’a dérivé nommé — de sorte qu’une seule build vous donne la vue d’ensemble plutôt qu’une collision à la fois. Un contributeur dont la propre sortie porte le nom deux fois est nommé comme ayant dérivé le nom plus d’une fois, ce qui vous indique que les deux choses à séparer se trouvent à l’intérieur de ce seul composant plutôt qu’entre deux composants.

Messages émis. Un constat est signalé par contributeur et par nom en collision, de sorte que chaque contributeur qui a dérivé le nom est nommé séparément plutôt que regroupé dans une liste à l’intérieur d’un seul message. Lorsque deux contributeurs ont dérivé le nom, il y a au moins deux constats, et ils arrivent ensemble sous un signalement qui indique ce qu’ils ont en commun :

dispatch groups whose contributors derive one name more than once in one key space (groupes d’acheminement dont les contributeurs dérivent un même nom plus d’une fois dans un même espace de clés)

Chaque constat nomme le nom, le type de nom qu’il est, le contributeur qui l’a dérivé, ainsi que le fournisseur et le chemin de l’assemblage dans lequel leur sortie est fusionnée :

derived name collision: one name is derived more than once in one key space ("<name>", key space "<kind-of-name>", derived by component "<contributor>", provider "<provider>", dispatch path "<path>") (collision de noms dérivés : un même nom est dérivé plus d’une fois dans un même espace de clés (avec le nom, l’espace de clés, le composant qui l’a dérivé, le fournisseur et le chemin d’acheminement indiqués))

Le contributeur est nommé d’après ce qu’il est, ce qui indique où son nom est écrit : derived by component pour une instance de composant, et derived by feature pour une fonctionnalité rattachée à une frontière.

Lorsque le propre nom du contributeur ne suffit pas à l’identifier, une deuxième coordonnée suit, et laquelle dépend du type. Une fonctionnalité rattachée à une frontière porte le chemin de la frontière, car un même nom de fonctionnalité peut être écrit à plus d’une frontière :

derived name collision: one name is derived more than once in one key space ("<name>", key space "<kind-of-name>", derived by feature "<feature-name>", attached at boundary "<boundary-path>", provider "<provider>", dispatch path "<path>") (collision de noms dérivés : un même nom est dérivé plus d’une fois dans un même espace de clés (avec le nom, l’espace de clés, la fonctionnalité qui l’a dérivé, la frontière à laquelle elle est rattachée, le fournisseur et le chemin d’acheminement indiqués))

Un composant porte la clé du rattachement dont le rendu a dérivé le nom, car un composant porte un rattachement par clé que vous avez écrite :

derived name collision: one name is derived more than once in one key space ("<name>", key space "<kind-of-name>", derived by component "<component>", carrying attachment "<attachment-key>", provider "<provider>", dispatch path "<path>") (collision de noms dérivés : un même nom est dérivé plus d’une fois dans un même espace de clés (avec le nom, l’espace de clés, le composant qui l’a dérivé, le rattachement qu’il porte, le fournisseur et le chemin d’acheminement indiqués))

Le propre rendu d’un composant — un nom que son fournisseur a dérivé pour le composant lui-même plutôt que pour l’un de ses rattachements — ne porte aucune deuxième coordonnée, de sorte que le constat se termine par le nom du composant.

Lorsque la propre sortie d’un seul contributeur porte le nom deux fois, ce contributeur est le seul constat, de sorte qu’il arrive seul, sans signalement au-dessus de lui — et il est nommé comme ayant dérivé le nom plus d’une fois, plutôt que comme ayant rencontré un autre contributeur :

derived name collision: one name is derived more than once in one key space ("<name>", key space "<kind-of-name>", derived more than once by component "<contributor>", provider "<provider>", dispatch path "<path>") (collision de noms dérivés : un même nom est dérivé plus d’une fois dans un même espace de clés (avec le nom, l’espace de clés, le composant qui l’a dérivé plus d’une fois, le fournisseur et le chemin d’acheminement indiqués))

La deuxième coordonnée suit ici le contributeur dans les mêmes conditions que ci-dessus, de sorte qu’une répétition à l’intérieur de la propre sortie d’un rattachement nomme ce rattachement plutôt que seulement le composant qui le porte.

Comment corriger : lorsque deux contributeurs sont nommés, renommez l’un d’eux dans l’Aggregate, afin que les noms qui en sont dérivés ne concordent plus avec ceux de l’autre. Lorsque le type de nom est component-id, chaque constat nomme déjà l’élément à renommer : carrying attachment "…" est la clé sous le bloc features: de ce composant, et un feature "…" attached at boundary "…" est le nom sous le bloc features: de cette frontière. Lorsque les deux constats ne diffèrent que par la frontière qu’ils nomment, les deux rattachements portent un même nom à deux frontières — renommez l’un d’eux, ou donnez aux deux frontières des chemins directory: distincts afin que leur sortie ne soit plus fusionnée. Lorsque les deux noms sont des noms que la build a composés, ils n’ont pu se rencontrer qu’après avoir été raccourcis pour tenir dans la cible ; raccourcissez donc vous-même les parties dont ils sont composés plutôt que de laisser la build le faire. Lorsque les deux noms sont dérivés de quelque chose que vous avez défini explicitement — une valeur que la Recipe transmet au fournisseur, ou une annotation que le fournisseur lit —, modifiez plutôt cela sur celui des deux que vous contrôlez. Lorsque les deux contributeurs relèvent réellement de sorties distinctes, donnez à leurs frontières des chemins directory: distincts afin que chacune s’assemble séparément et que les deux noms ne se rencontrent jamais. Lorsqu’un seul contributeur est nommé comme ayant dérivé le nom plus d’une fois, les deux éléments en collision se trouvent tous deux à l’intérieur de ce seul composant : trouvez les deux ressources que produit sa Recipe dont les noms concordent, et changez ce d’après quoi l’une d’elles est nommée — la clé sous laquelle elle est déclarée, ou une valeur à partir de laquelle elle est construite — afin que le fournisseur dérive un nom distinct pour chacune. Lorsque le type de nom se réduit à un type à portée cluster, comme resource-names:ClusterRole, les documents nommés décrivent un seul objet dans le cluster, quels que soient les namespaces où ils ont été placés : émettez-le depuis un seul contributeur — au moyen d’une valeur que propose son chart, comme un commutateur pour installer ses définitions — ou, lorsque les deux sont censés être deux objets, donnez à l’un d’eux un nom qui lui est propre dans le chart ou le corps que vous contrôlez ; un seul contributeur nommé deux fois pour cet objet l’écrit sous deux namespaces, et l’un des deux documents est celui à supprimer.

An authored export name is one the build derives for a cross-stack reference (Un nom d’exportation rédigé est un nom que la build dérive pour une référence inter-stacks)

Le bloc Outputs: d’une Recipe cloudformation est du CloudFormation rédigé, et une entrée de ce bloc peut porter son propre Export: avec un Name: ; ce nom atteint la stack assemblée exactement tel qu’il est écrit. Par ailleurs, lorsqu’une arête uses passe d’une frontière à une autre, le fournisseur publie la valeur consommée sous forme d’Output de stack avec un Export sous un nom qu’il dérive de la release, de la frontière, du composant et de la clé fournie. Cet arrêt se déclenche là où les deux se rencontrent : le nom que vous avez écrit est le nom que la dérivation a produit pour la même build, de sorte que la stack déclarerait un même nom d’exportation deux fois depuis deux endroits, et un nom d’exportation doit être unique.

Seule la coïncidence provoque un arrêt. Déclarer un nom d’exportation sur une entrée Outputs est pris en charge, et un nom qui ne concorde avec aucun nom dérivé est publié aux côtés des noms dérivés sans commentaire — sur chaque entrée sauf la sortie de stack sur laquelle une référence inter-stacks publie sa propre exportation, pour une clé qu’elle consomme. Un Export: à cet endroit provoque un arrêt à moins qu’il ne porte exactement le nom dérivé ; ce cas est The output a cross-stack reference publishes on already carries an Export (La sortie sur laquelle une référence inter-stacks publie porte déjà un Export).

L’arrêt donne le nom d’exportation dérivé avec les quatre parties à partir desquelles il a été construit, afin que vous puissiez voir quelle référence inter-frontières l’a produit, et il nomme la sortie de stack sous laquelle se trouve votre déclaration — marquée comme un nom que le fournisseur assemble plutôt qu’un nom qu’une Recipe a écrit, car le fournisseur construit ce nom en encodant le composant et l’entrée dans les lettres et les chiffres qu’admet un ID logique, de sorte que ce n’est pas la chaîne sous laquelle l’un ou l’autre a été écrit. Le nom d’exportation est la partie à rechercher. Votre entrée l’écrit exactement comme l’arrêt, ce qui fait des deux une collision, de sorte que c’est la seule chaîne qui apparaît à la fois dans le message et dans vos propres fichiers.

La comparaison se limite à une seule stack : les noms d’exportation que cette stack déclare, face aux noms dérivés pour les références inter-frontières qui y publient. Deux stacks ne sont pas comparées entre elles, et un nom d’exportation écrit sous forme de fonction intrinsèque CloudFormation est résolu au moment du déploiement, de sorte qu’il n’y a aucun nom à comparer. Ce qu’un nom rencontre parmi les exportations déjà déployées dans un compte et une région est une propriété du déploiement, qu’une build n’observe pas.

Message émis. La condition nomme le type d’échec et la propre phrase du fournisseur indique ce qui s’est passé ; le signalement qui l’entoure nomme aussi l’arête uses en cours de câblage :

two things a plugin produced occupy one name in its output (deux choses qu’un plugin a produites occupent un même nom dans sa sortie) cloudformation-provider: an export name a cross-boundary link derives is already declared by another Outputs entry in the same stack: the link derives the export name <export-name> for provides key <provides-key> of component <component> in boundary <boundary> of Release <release>, and another Outputs entry of the same stack already declares that same export name — that declaration sits under the stack output <stack-output>, a name this provider assembles rather than one a Recipe wrote; each shadowing Outputs entry spells its export name exactly as the halt does, so searching your Recipes for that name reaches the entry — rename the export name the entry declares, or remove that entry’s Export block and let the link publish the export (un nom d’exportation que dérive un lien inter-frontières est déjà déclaré par une autre entrée Outputs dans la même stack : le lien dérive le nom d’exportation indiqué pour la clé provides indiquée du composant indiqué dans la frontière indiquée de la Release indiquée, et une autre entrée Outputs de la même stack déclare déjà ce même nom d’exportation — cette déclaration se trouve sous la sortie de stack indiquée, un nom que ce fournisseur assemble plutôt qu’un nom qu’une Recipe a écrit ; chaque entrée Outputs qui le masque écrit son nom d’exportation exactement comme l’arrêt, de sorte que rechercher ce nom dans vos Recipes mène à l’entrée — renommez le nom d’exportation que déclare l’entrée, ou supprimez le bloc Export de cette entrée et laissez le lien publier l’exportation)

Comment corriger : recherchez dans vos Recipes le nom d’exportation que nomme l’arrêt — l’entrée Outputs qui le déclare l’écrit de façon identique —, puis renommez ce nom d’exportation pour qu’il ne concorde plus, ou supprimez le bloc Export: de cette entrée et laissez le câblage inter-stacks publier lui-même l’exportation. Le supprimer est généralement la bonne décision lorsque l’entrée existait pour exporter la même valeur que celle que consomme l’arête : le fournisseur publie de toute façon un Export pour cette valeur, de sorte que celui qui a été rédigé n’apporte rien. Conservez plutôt l’Export: rédigé et renommez-le lorsque l’entrée exporte la valeur pour un autre consommateur qui l’importe sous un nom que vous avez choisi.

The output a cross-stack reference publishes on already carries an Export (La sortie sur laquelle une référence inter-stacks publie porte déjà un Export)

Lorsqu’une arête uses passe d’une frontière à une autre, le fournisseur publie l’Export de la valeur consommée sur la sortie de stack qu’il assemble pour le composant producteur et la clé fournie — la même sortie qu’atteint une Recipe cloudformation lorsque son bloc Outputs: écrit une entrée sous cette clé. Un Export: déjà présent sur cette sortie n’est conservé que si son Name: est exactement le nom que dérive le fournisseur : c’est l’exportation qu’une référence inter-stacks antérieure vers la même valeur a déjà publiée, de sorte que chaque consommateur importe ce nom unique. Tout autre Export: à cet endroit provoque un arrêt, car écrire l’exportation du fournisseur écraserait ce que vous avez écrit, et conserver le vôtre laisserait chaque consommateur importer un nom que la référence n’a jamais publié.

L’arrêt se déclenche sur quatre formes de Export: sur cette sortie :

  • un Name: qui est une chaîne différente ;
  • un Name: écrit sous forme de fonction intrinsèque CloudFormation, qui se résout au moment du déploiement, de sorte que le fournisseur ne peut pas lire ce qu’elle exprime ;
  • un bloc Export: qui ne nomme rien ;
  • un Export: écrit comme une valeur simple plutôt que comme un bloc.

Un nom d’exportation que vous déclarez sur toute autre entrée Outputs est comparé séparément, sous An authored export name is one the build derives for a cross-stack reference (Un nom d’exportation rédigé est un nom que la build dérive pour une référence inter-stacks).

Message émis. La condition nomme le type d’échec et la propre phrase du fournisseur indique ce qui s’est passé ; le signalement qui l’entoure nomme aussi l’arête uses en cours de câblage :

two things a plugin produced occupy one name in its output (deux choses qu’un plugin a produites occupent un même nom dans sa sortie) cloudformation-provider: the stack output a cross-boundary link publishes its export on already carries an Export the link did not write: the link derives the export name <export-name> for provides key <provides-key> of component <component> in boundary <boundary> of Release <release>, and the stack output this provider assembles for that key and component <what-it-found>; remove that entry’s Export block and let the link publish the export every consumer imports (la sortie de stack sur laquelle un lien inter-frontières publie son exportation porte déjà un Export que le lien n’a pas écrit : le lien dérive le nom d’exportation indiqué pour la clé provides indiquée du composant indiqué dans la frontière indiquée de la Release indiquée, et la sortie de stack que ce fournisseur assemble pour cette clé et ce composant présente ce qui est indiqué ; supprimez le bloc Export de cette entrée et laissez le lien publier l’exportation que chaque consommateur importe)

<what-it-found> est l’un des éléments suivants, dans l’ordre des formes ci-dessus :

already declares the export name <name> (déclare déjà le nom d’exportation indiqué) already declares an export name that is not a string — one given as an intrinsic, which resolves at deploy time, so this provider cannot read what it spells (déclare déjà un nom d’exportation qui n’est pas une chaîne — un nom donné sous forme de fonction intrinsèque, qui se résout au moment du déploiement, de sorte que ce fournisseur ne peut pas lire ce qu’elle exprime) already carries an Export block declaring no export name (porte déjà un bloc Export qui ne déclare aucun nom d’exportation) already carries an Export that is not a block, where CloudFormation expects one carrying a Name (porte déjà un Export qui n’est pas un bloc, là où CloudFormation en attend un portant un Name)

Comment corriger : dans la Recipe du composant que nomme l’arrêt, trouvez l’entrée Outputs écrite sous la clé fournie qu’il nomme, et supprimez le bloc Export: de cette entrée — le câblage inter-stacks publie alors l’exportation que chaque consommateur importe. Si vous avez aussi besoin que la valeur soit exportée sous un nom qui vous est propre, pour un consommateur extérieur à cette build, écrivez cet Export: sur une entrée Outputs sous une clé différente : un nom d’exportation y est pris en charge, tant qu’il ne s’agit pas d’un nom que la build dérive.

Chart-name mismatch on a merged helm-chart umbrella (Nom de chart discordant sur un chart parapluie helm-chart fusionné)

Deux frontières ou plus contribuent au même chemin d’assemblage du fournisseur helm-chart, mais leurs annotations aggrega.ai/chart-name effectives (résolues par la cascade d’annotations des frontières) ne concordent pas. Un chart parapluie Helm a exactement un nom de chart ; le moteur de rendu ne peut pas choisir l’un des candidats en conflit.

Messages émis. Un constat est signalé par frontière contributrice, chacun portant la valeur vers laquelle cette frontière s’est résolue, de sorte que les noms discordants arrivent un par constat plutôt que sous la forme d’une seule collection imprimée. Le signalement sous lequel ils arrivent indique ce qu’ils ont en commun :

merged dispatch groups whose boundaries disagree on the assembly name (groupes d’acheminement fusionnés dont les frontières ne s’accordent pas sur le nom d’assemblage)

Chaque constat nomme la valeur vers laquelle cette frontière s’est résolue, l’annotation dont elle a été lue, la frontière, le fournisseur et le chemin vers lequel elles fusionnent :

merged-path assembly has conflicting assembly-name annotation values ("<value>", annotation "<annotation>", boundary "<boundary>", provider "<provider>", dispatch path "<path>") (l’assemblage à chemin fusionné présente des valeurs en conflit pour l’annotation du nom d’assemblage (avec la valeur, l’annotation, la frontière, le fournisseur et le chemin d’acheminement indiqués))

Comment corriger : déclarez une annotation aggrega.ai/chart-name concordante sur chaque frontière contributrice (le mécanisme de cascade rend cela DRY lorsque les contributeurs partagent une frontière parente — déclarez-la une seule fois sur la parente), ou répartissez les frontières sur des chemins directory: distincts afin que chacune obtienne son propre chart parapluie.

FeatureRecipe template references a field outside its scope’s allowlist (Le template de FeatureRecipe référence un champ en dehors de la liste d’autorisation de sa portée)

Une FeatureRecipe avec executionScope: boundary référence un champ propre au composant tel que .context.instance_id, .context.inject ou .context.uses — des champs qui n’ont aucune valeur significative à la portée frontière — dans un template qui s’exécute une seule fois pour la frontière : ses locals:, provides:, valuesMapping:, artifacts: ou le with: ou le when: d’une étape de pipeline. La condition symétrique s’applique : une FeatureRecipe de portée composant (la valeur par défaut) qui référence des champs .boundary.* échoue au même validateur. La validation s’exécute à l’analyse, par rapport à la liste d’autorisation des champs de la portée concernée, avant que tout travail de rendu ne commence. L’injectMapping d’une FeatureRecipe de portée frontière n’est pas vérifié ici : il s’exécute une fois pour chaque composant qu’atteint le rattachement, dans le contexte de ce composant, de sorte qu’il lit .context.*, et une référence à .boundary qu’il contient est signalée par « Template references a root the render context does not define (Le template référence une racine que le contexte de rendu ne définit pas) » ci-dessus.

Message émis :

FeatureRecipe template references a per-component-only field with executionScope: boundary ("<dotted-path>", written in "<field>", the render context defines "<the roots the boundary-scope context defines>") (le template de FeatureRecipe référence un champ propre au composant avec executionScope: boundary (avec le chemin indiqué, écrit dans le champ indiqué ; le contexte de rendu définit les racines indiquées))

Une FeatureRecipe de portée frontière dont le valuesMapping lit .context.instance_id affiche :

[CATALOG_ERROR E0039] scope-probe-fr at .spec.valuesMapping
FeatureRecipe template references a per-component-only field with executionScope: boundary (".context.instance_id", written in "valuesMapping", the render context defines ".values, .infra, .locals, .provides, .features, .metadata, .steps, .source, .boundary")

Comment corriger : réécrivez le template en fonction des champs disponibles dans la portée, ou changez l’executionScope de la FeatureRecipe. Les FeatureRecipes de portée frontière référencent .boundary.path, .boundary.boundary_name, .boundary.components, les collections .boundary.*_uses_edges, .boundary.labels, .boundary.annotations et .boundary.feature_attachments. Les FeatureRecipes de portée Component référencent .context.instance_id, .context.inject, .context.uses, .context.labels, .context.annotations. Les deux portées partagent .values, .infra, .locals, .provides, .steps et .metadata. Un paramètre de Release n’est pas un pilier à part entière sur cette surface — il atteint un template de FeatureRecipe par une entrée values ou infra qui le référence.

Self-inject value template references cross-node data (Le template de valeur de self-inject référence des données entre nœuds)

Un template inject: value: au niveau du composant puise dans .context.inject ou .context.uses. Le canal d’inject est précisément ce que cette passe est en train de construire — un template à l’intérieur de la propre valeur de self-inject d’un composant ne peut pas y lire.

C’est le .context de la surface qui en décide ainsi : il porte instance_id, labels et annotations, et rien d’autre. .context.inject et .context.uses sont donc des clés que le contexte de cette surface ne définit pas, et la référence provoque un arrêt en tant que « Template references a root the render context does not define (Le template référence une racine que le contexte de rendu ne définit pas) » ci-dessus, à l’analyse, avant que quoi que ce soit ne soit rendu. Le diagnostic nomme le mécanisme et la clé de livraison auxquels appartient le template, et liste les clés que .context définit ici — de sorte que le même signalement couvre à la fois une véritable tentative d’atteindre des données entre nœuds et une simple faute de frappe telle que {{ .context.nmae }}, qui est l’erreur la plus courante et qui aurait sinon été rendue comme rien.

Message émis — le détail au niveau de la référence ; le signalement englobant nomme aussi le nœud, le mécanisme et la clé de livraison :

template references a root the render context does not define (template self-inject.<mechanism>[<key>] references .context.inject, .context defines .context.instance_id, .context.labels, .context.annotations) (le template référence une racine que le contexte de rendu ne définit pas (le template de self-inject indiqué référence le chemin indiqué, le contexte définit les clés indiquées))

Chaque cadre du signalement relève du domaine du développeur, car un bloc inject: au niveau du composant est rédigé dans l’Aggregate.

Comment corriger : déplacez le câblage entre composants dans une entrée uses[].inject — c’est là que le contexte entre nœuds est disponible. Gardez les templates value: de self-inject au niveau du composant fermés sur les values et l’infra propres au composant, ses .context.instance_id / .context.labels / .context.annotations, et .metadata.

Missing template key — asymmetric policy (Clé de template manquante — politique asymétrique)

Le traitement des clés manquantes dépend de la surface de template. Là où un rendu vide aboutit à un endroit circonscrit — un champ de manifeste que l’auteur peut relire — l’absence est tolérée et la lecture ne rend rien. Là où un rendu vide produirait au contraire une structure erronée ou un verdict erroné, la surface refuse la référence plutôt que de la résoudre en rien.

  • L’interpolation des paramètres dans un Aggregate — les références {{ .parameters.<key> }} que porte le texte propre de l’Aggregate — est la plus précoce de ces surfaces : elle s’exécute sur le document brut avant la résolution du catalogue, de sorte que sa politique s’applique à du texte qu’aucune autre surface n’a encore vu. Une référence à un paramètre que la Release n’a jamais renseigné est rendue comme rien, et un pipe default ou une garde if sur une telle lecture se comporte exactement comme sur le paramètre non renseigné. Une référence que le template itère continue d’itérer comme rien, ce qui est ce que veut un range sur une liste facultative — à moins que le texte ne l’affiche aussi, auquel cas elle provoque un arrêt comme le décrit « A template reads and iterates a path that holds nothing (Un template lit et itère un chemin qui ne contient rien) » ci-dessous. Une référence dont le parent est absent — .parameters.db.host alors qu’aucun paramètre db n’a été renseigné — provoque toujours un arrêt, car il n’y a rien dans quoi descendre et fournir un parent échangerait l’arrêt contre un artefact discrètement erroné. Une limite mérite d’être énoncée comme une limite plutôt que comme une politique : une référence ancrée à une racine que la surface ne définit pas est laissée telle quelle plutôt que rendue comme rien, de sorte qu’elle subsiste dans le document interpolé sous la forme du texte de substitution propre au moteur de templates, <no value>. Rien sur cette surface ne provoque d’arrêt à cause de cela, alors ancrez chaque référence de paramètre à .parameters, et lisez un <no value> égaré comme une racine mal orthographiée.
  • Les templates de chemin (directory: / subDirectory: des frontières de la Release) sont évalués avec missingkey=error. Une référence à une variable que la surface ne leur fournit pas provoque un arrêt à l’analyse — voir « Path-template references a variable outside the allowlist (Le template de chemin référence une variable en dehors de la liste d’autorisation) » ci-dessus — de même qu’une clé mal saisie sous .manifest, dont les clés sont déclarées. Une référence admise mais non définie au moment de l’évaluation, telle qu’une clé de .parameters que la Release ne fournit pas, produit une erreur explicite plutôt que de rendre discrètement une chaîne vide dans un chemin de répertoire.
  • Les assertions (sur un Component, une Feature, une Recipe ou une FeatureRecipe) sont évaluées avec missingkey=error. Une référence à une clé non définie provoque un arrêt avec un diagnostic de clé inexistante qui nomme l’entité, l’instance et l’assertion. C’est cette rigueur qui rend une assertion digne de confiance : un prédicat dont la référence serait rendue comme une valeur vide comparerait avec rien et réussirait, de sorte qu’une seule faute de frappe retirerait discrètement la règle que l’assertion avait été écrite pour faire respecter. Comme la référence nue provoque un arrêt avant qu’un repli puisse s’exécuter, un simple default ne fournit pas de repli pour un champ facultatif sur cette surface — protégez la référence avec hasKey, ou utilisez le helper optional, qui effectue directement la vérification de présence. Lire la clé via index n’en fournit pas non plus : index provoque un arrêt sur une clé de map que la map ne contient pas, en nommant la clé.
  • Les templates de valeur (valuesMapping de la Recipe, entrées locals: et provides:, corps artifacts:, corps de Workload, injectMapping et pipeline.with de la FeatureRecipe, et templates value: de self-inject au niveau du composant) sont évalués avec missingkey=zero, de sorte qu’une référence à une clé non définie n’arrête pas la build — la lecture ne rend rien, et c’est rien qui atteint l’artefact. Ce qui provoque bel et bien encore un arrêt sur cette surface est une référence qui descend à travers un conteneur que l’auteur n’a jamais fourni — .values.tls.ca alors qu’aucun tls n’a été rédigé — car il n’y a rien dans quoi descendre. Seule la clé finale d’une référence dont tous les conteneurs sont présents est rendue comme rien. Un champ de premier niveau que le contexte définit mais pour lequel il ne contient rien — .workload sur une Recipe qui n’en synthétise aucun, .features sur un composant sans rattachements — est rendu comme rien de la même façon lorsqu’il est lu en entier. Une référence est une seule référence quelle que soit son écriture : .values.list, $.values.list et (.values).list nomment la même clé, de sorte qu’itérer avec range dans une écriture revient à itérer dans toutes, et une clé lue sur un pilier entre parenthèses est rendue, ou provoque un arrêt, exactement comme l’écriture directe. Une clé que le template parcourt avec range continue d’itérer comme rien lorsqu’elle n’est pas définie, et une clé qu’il à la fois affiche et parcourt provoque un arrêt lorsqu’elle n’est pas définie — voir « A template reads and iterates a path that holds nothing (Un template lit et itère un chemin qui ne contient rien) » ci-dessous. Les protections fonctionnent comme prévu : {{ .values.optional_field | default "fallback" }} fournit bien le repli, car une valeur non définie compte comme vide pour default et comme fausse pour if. Les auteurs qui ont besoin du discriminant entre absent et zéro — distinguer « clé absente » de « clé présente et vide » — utilisent le helper optional documenté dans templates/sprig-functions.md, et lisent une clé donnée d’une seule façon par template : une clé que le même template lit aussi en tant que .values.<key> compte comme présente, de sorte que optional signale sa valeur vide plutôt que le repli. Ce que cette politique ne couvre pas, c’est une lecture via index : indexer une map avec une clé qu’elle ne contient pas provoque un arrêt qui nomme la clé, ici comme sur toute surface — voir « A template indexes a map with a key the map does not hold (Un template indexe une map avec une clé que la map ne contient pas) » ci-dessous.
  • Une coordonnée source: — les champs à template d’un bloc source: structuré sur une Recipe ou une FeatureRecipe (version, ref, chart, module_subdir) — est évaluée avec missingkey=error. Une référence à une clé que rien ne fournit provoque un arrêt qui nomme le champ de la source, plutôt que de se résoudre en rien : une version ou un ref vide épinglerait un artefact différent de celui que l’auteur a nommé, et l’épinglage est ce que chaque build ultérieure reproduit. Cette surface est aussi celle où l’ensemble des fonctions disponibles diffère, et où une référence locals: que refuse l’ordre de rédaction propre au bloc provoque un arrêt avant que quoi que ce soit ne soit évalué — voir ci-dessous.
  • Les contrats de paramètres typés interceptent les cas de paramètre requis manquant et de violation de contrat au niveau de la couche des contrats de paramètres, avant que l’interpolation ne s’exécute — voir « Parameter type mismatch / contract violation (Type de paramètre non concordant / violation de contrat) » ci-dessus.

L’ensemble de helpers est le même pour les templates de valeur, les templates de chemin et les assertions : les fonctions de Sprig plus celles propres à Aggrega (optional et capitalizedWords). Le fail de Sprig en fait partie, de sorte qu’un template de valeur peut arrêter la build avec un message qui lui est propre, comme le décrit « A value template failed while it ran (Un template de valeur a échoué pendant son exécution) » ci-dessous ; une assertion est la surface écrite pour cela, puisque arrêter la build est toute sa raison d’être. Entre ces trois, ce qui diffère est la politique des clés manquantes — optional est aussi disponible dans un template de chemin, où il lit une clé dans .parameters sans que la politique stricte ne se déclenche d’abord. La résolution d’une coordonnée source: diffère par l’ensemble de fonctions lui-même, et a sa propre sous-section ci-dessous. L’interpolation des paramètres dans un Aggregate n’offre que les fonctions de Sprig, de sorte qu’aucun des deux helpers d’Aggrega n’y est disponible. Une fonction lit de la même façon sur chacune de ces surfaces, la coordonnée et l’interpolation comprises : index, qui provoque un arrêt en nommant la clé lorsque la map qu’elle lit ne la contient pas.

Le message qu’affiche une absence dans un template de chemin est cité sous l’entrée qui documente cette condition, « Path-template references a variable outside the allowlist (Le template de chemin référence une variable en dehors de la liste d’autorisation) » ci-dessus, de sorte qu’il est écrit une seule fois plutôt que répété ici.

Comment corriger : pour les absences dans un template de chemin, corrigez le nom du champ en l’un de ceux de la liste d’autorisation documentée dans path-template-variables.md. Pour une absence dans une assertion, corrigez la référence — la plupart des signalements sont une clé mal orthographiée — ou, lorsque le champ est réellement facultatif, protégez-la avec hasKey ou utilisez le helper optional ; envelopper la référence nue dans un default ne lèvera pas l’arrêt, car la référence se résout avant que le repli ne s’exécute, et la lire via index non plus, car index provoque un arrêt sur une clé que la map ne contient pas. Pour les absences dans un template de valeur lorsque le rendu vide n’est pas souhaité, utilisez le helper optional ou fournissez la clé manquante sous forme de déclaration parameters.* typée sur l’Aggregate avec une valeur de Release, sous forme d’entrée provides: d’un Component en amont câblée via uses[].inject, ou sous forme d’entrée locals: sur la même entité.

Resolving a source: coordinate registers a narrower function set (La résolution d’une coordonnée source enregistre un ensemble de fonctions plus restreint)

Un bloc source: structuré est résolu afin que l’artefact qu’il nomme puisse être épinglé, et cette résolution enregistre les helpers propres à Aggrega et rien d’autre — optional et capitalizedWords sont disponibles, et index provoque un arrêt sur une clé de map que la map ne contient pas exactement comme lorsque la Recipe effectue son rendu ; les fonctions de Sprig ne le sont pas. Parmi les surfaces sur lesquelles une Recipe ou une FeatureRecipe rédige des templates, c’est celle dont l’ensemble de fonctions diffère, de sorte qu’une expression rendue correctement ailleurs dans la même Recipe peut être refusée ici. L’ensemble plus restreint est délibéré : ce qui est épinglé est déterminé par les values et l’infra que l’auteur fournit, et les fonctions de Sprig comprennent des fonctions qui lisent l’horloge, l’environnement, une source aléatoire ou le réseau.

Appeler une fonction de Sprig dans un champ source:, ou dans une entrée locals: que ce champ lit, provoque un arrêt à l’analyse. Le diagnostic a pour en-tête E0111 et nomme l’entrée, le champ source: qui la lit, la fonction qu’il n’a pas pu résoudre et les helpers que cette surface enregistre :

resolve: parse template at <name>:<version>.spec.locals.<key>, read by <name>:<version>.spec.source.<field>: resolve: source-template parse error (cause: template: <name>:<version>.spec.locals.<key>:1: function "<function>" not defined); a source field, and every locals entry it reads, is evaluated when the source is resolved with Aggrega’s own helpers only (optional, capitalizedWords and index), not the Sprig functions a render adds; write the value without that function, or move the value into a locals entry no source field reads (résolution : analyse du template à l’entrée de locals indiquée, lue par le champ source indiqué : résolution : erreur d’analyse du template de source (cause : la fonction indiquée n’est pas définie) ; un champ source, et chaque entrée de locals qu’il lit, est évalué lorsque la source est résolue avec les seuls helpers propres à Aggrega (optional, capitalizedWords et index), et non avec les fonctions de Sprig qu’ajoute un rendu ; écrivez la valeur sans cette fonction, ou déplacez la valeur dans une entrée de locals qu’aucun champ source ne lit)

Un champ source: qui appelle lui-même la fonction est signalé de la même façon, en nommant le champ seul.

L’étendue est celle des entrées que la coordonnée lit. La résolution d’une coordonnée évalue chaque entrée locals: qu’un champ source: lit, et chaque entrée qu’une telle entrée lit à son tour — et aucune autre. Une entrée qu’aucun champ source: n’atteint n’est ni évaluée, ni analysée, ni vérifiée pendant la résolution de la source, de sorte qu’une entrée de locals dont le rendu a besoin — une entrée qui fait de l’arithmétique avec les fonctions de Sprig, ou qui nomme une ressource d’après .context.instance_id — n’a aucun effet sur l’épinglage de l’artefact ; elle est évaluée, et tout défaut qu’elle contient signalé, lorsque la Recipe effectue son rendu. Les entrées qu’un champ lit sont déterminées d’après son texte, de sorte qu’un champ qui lit .locals d’une manière qui ne nomme aucune entrée précise — {{ index .locals "version" }}, le bloc entier passé à optional ou lié à une variable — fait évaluer à la place chaque entrée, et le diagnostic d’une entrée qu’il atteint ainsi le dit : au lieu de read by <field>, il indique evaluated for <field>, which reads the locals block as a whole rather than by entry, so every entry is evaluated.

Deux formes se situent en dehors de cette surface, et savoir dans laquelle se trouve une Recipe explique pourquoi la même expression est acceptée dans une Recipe et refusée dans une autre :

  • Un source: écrit sous forme de chaîne simple — un URI ou un chemin local plutôt qu’une map — est pris tel quel, de sorte qu’il n’a aucun champ à évaluer et que le bloc locals: n’est pas du tout résolu ici.
  • Une entité qui ne déclare aucun source: ne résout aucune coordonnée, de sorte que son bloc locals: n’est résolu que pour le rendu propre à cette entité, où l’ensemble complet de fonctions s’applique.

Le contrat d’ordre des références est ici le même pour chaque entrée que la coordonnée lit. La résolution d’une coordonnée refuse les mêmes références qu’un rendu refuse dans chaque entrée qu’elle évalue : une entrée qui lit une entrée sœur que le bloc déclare plus bas, et tout template qui lit une clé que le bloc ne déclare pas. Les deux signalent les conditions documentées ci-dessus sous « locals: entry references a sibling defined later in the same block (Une entrée de locals référence une entrée sœur définie plus loin dans le même bloc) » et « locals: key does not exist (La clé de locals n’existe pas) » — la même condition, avec le même remède, quelle que soit la résolution qui l’a atteinte en premier — et le signalement nomme le champ source: pour lequel l’entrée a été évaluée. Un défaut dans une entrée qu’aucun champ source: ne lit est refusé lorsque la Recipe effectue son rendu, sous la même condition.

Ce que cette surface laisse en revanche de côté, c’est une entrée qu’une coordonnée ne peut réellement pas résoudre : une entrée qui lit des données qui n’existent que pendant le rendu d’un artefact, .context.instance_id étant le cas pour lequel cela existe. Une telle entrée est ignorée, de sorte qu’une Recipe dont la coordonnée en atteint une sur une branche qu’elle ne prend pas est tout de même épinglée. Là où la coordonnée elle-même avait besoin de cette entrée, la résolution provoque un arrêt en nommant le champ source: — le signalement de clé manquante décrit ci-dessus pour cette surface, avec pour en-tête E0110 — et cite, à côté de la clé qu’elle n’a pas pu lire, pourquoi cette entrée ne contient aucune valeur ici :

resolve: evaluate template at <name>:<version>.spec.source.<field>: resolve: source-template evaluation failure at lock time (cause: template: … map has no entry for key "<key>"); it reads <name>:<version>.spec.locals.<key>, which could not be evaluated here (cause: template: … map has no entry for key "context") (résolution : évaluation du template au champ source indiqué : résolution : échec d’évaluation du template de source au moment du verrouillage (cause : la map n’a aucune entrée pour la clé indiquée) ; il lit l’entrée de locals indiquée, qui n’a pas pu être évaluée ici (cause : la map n’a aucune entrée pour la clé context))

Ni un champ source: ni une entrée locals: qu’il lit ne peuvent lire .provides. Un bloc locals: alimente un bloc provides: et jamais l’inverse, de sorte qu’un template sur cette surface qui lit .provides est refusé pour ce qu’il est, une référence inverse, plutôt que de se résoudre en rien. Le refus n’est pas une absence au moment du verrouillage qu’une phase ultérieure viendrait combler — aucun ordre ne rend la référence valide — de sorte qu’il est signalé de la même façon partout où la coordonnée est résolue. Le diagnostic a pour en-tête E0112 ; il nomme le champ, ou l’entrée et le champ qui la lit, dit ce qui ne va pas dans la référence et indique la surface que l’expression peut lire à la place :

source-version template at <name>:<version>.spec.source.<field> references .provides, which is an invalid reverse reference (locals feed provides, never the reverse) — refactor to read only .values and .infra (and .locals over the same): resolve: source-template references .provides (invalid reverse reference) (le template de version de source au champ source indiqué référence .provides, ce qui est une référence inverse non valide (locals alimente provides, jamais l’inverse) — refactorisez pour ne lire que .values et .infra (et .locals sur ceux-ci) : résolution : le template de source référence .provides (référence inverse non valide))

Où l’arrêt apparaît : pendant le remplissage ou l’actualisation du lockfile — aggrega pull, ou une build qui le remplit (--auto-pull, --upgrade ou le paramètre auto_pull de l’espace de travail). Chaque échec est signalé comme un seul diagnostic, ayant pour en-tête le code de ce qui s’est mal passé — E0111 pour un template qui ne s’analyse pas, E0112 pour une référence à .provides, E0110 pour un template analysé qui n’a pas pu être évalué — dans le terminal comme dans un éditeur connecté à aggrega serve. Une clé manquante sur un champ source:, contrairement à une fonction indisponible, est signalée à l’exécution plutôt qu’à l’analyse, en nommant le champ et la clé qui n’a pas pu être lue.

Comment corriger : optional est enregistré sur cette surface et sur chaque template de valeur, template de chemin et assertion, ce qui en fait le choix portable — {{ optional .values "chart_version" "25.0.8" }} au lieu de {{ default "25.0.8" .values.chart_version }}. Lisez la différence sémantique avant de substituer : optional se déclenche quand la clé est absente, tandis que default se déclenche quand la valeur est vide, de sorte qu’une clé rédigée comme chaîne vide ou comme zéro conserve sa valeur rédigée avec optional et est remplacée avec default. Lorsque l’expression a réellement besoin d’une fonction de Sprig — remodeler une chaîne plutôt que fournir un repli — gardez-la hors de ce que la coordonnée lit : dans une entrée locals: qu’aucun champ source: ne lit, ou sur la surface qui la consomme (valuesMapping, un corps de Workload, une entrée artifacts:).

A template indexes a map with a key the map does not hold (Un template indexe une map avec une clé que la map ne contient pas)

Un template lit une map via index — {{ index .values "replicas" }}, ou {{ index .context.inject.env $apiKeyVar }} avec un nom de clé que le template a calculé — et la map ne contient pas la clé demandée. index provoque là un arrêt et nomme la clé, sur chaque surface qui évalue un template : templates de valeur, entrées locals: et provides:, templates de chemin, assertions, une coordonnée source: structurée, l’interpolation des paramètres dans un Aggregate et les prédicats validate: de ses paramètres, ainsi que les prédicats x-aggrega-when: et x-aggrega-validate: d’un schéma.

C’est une propriété de index seul, et la politique des clés manquantes d’aucune surface ne la modifie. Une lecture par point d’une clé non définie sous un pilier ouvert ne rend toujours rien sur un template de valeur, comme le décrit « Missing template key — asymmetric policy (Clé de template manquante — politique asymétrique) » ci-dessus, et un template qui teste si l’auteur a fourni une telle clé n’est pas concerné. Ce qui provoque un arrêt, c’est de demander à index une clé que la map ne contient pas. index est la façon dont un template atteint une clé dont il calcule le nom — un identifiant lu sous le nom de variable que la Recipe consommatrice a choisi, par exemple — et sans l’arrêt cette lecture placerait le texte de substitution du moteur de templates <no value> dans l’artefact pendant que la build réussit : un serveur démarré avec ce texte comme clé. Toute autre réponse que donne index est celle du moteur de templates lui-même : une position dans une liste ou une chaîne, une position hors limites, une clé que la map contient — y compris une clé dont la valeur est null, qui affiche <no value>.

Message émis, comme dernière ligne du signalement — les cadres au-dessus nomment le nœud et le champ où se trouve le template, et sur un template de valeur d’une Recipe ou d’une FeatureRecipe, l’en-tête porte le code de cette condition :

template: <template>:<line>:<column>: executing "<template>" at <index <map> <key>>: error calling index: template indexes a map with a key the map does not hold (key "<key>"). read a key that may be absent through a function that tests for it first, such as optional, get or hasKey (template : exécution du template indiqué, à la ligne et à la colonne indiquées, dans l’expression index indiquée : erreur lors de l’appel de index : le template indexe une map avec une clé que la map ne contient pas (avec la clé indiquée). lisez une clé qui peut être absente via une fonction qui en vérifie d’abord la présence, comme optional, get ou hasKey)

Sur une surface qui signale un échec de template sous une condition qui lui est propre — une entrée provides: (« A provides: template could not be evaluated (Un template de provides ne peut pas être évalué) »), l’interpolation des paramètres (« A {{ .parameters.* }} reference cannot be interpolated (Une référence aux paramètres ne peut pas être interpolée) »), un prédicat de schéma (« An x-aggrega-when: or x-aggrega-validate: predicate cannot be evaluated (Un prédicat ne peut pas être évalué) »), une coordonnée source: (« Resolving a source: coordinate registers a narrower function set (La résolution d’une coordonnée source enregistre un ensemble de fonctions plus restreint) ») — l’en-tête porte le code de cette condition et la ligne ci-dessus est la raison qu’il porte, clé comprise.

Comment corriger : décidez si la clé peut légitimement être absente.

  • Elle le peut. Lisez-la via une fonction qui en vérifie d’abord la présence : {{ optional .values "replicas" 1 }} renvoie le repli lorsque la clé est absente et la valeur, quelle qu’elle soit, lorsqu’elle est présente ; le get de Sprig renvoie une chaîne vide pour une clé absente ; hasKey teste sans lire. optional est enregistré sur chaque surface sauf l’interpolation des paramètres et les prédicats d’un paramètre ou d’un schéma, qui offrent get et hasKey de Sprig ; une coordonnée source: enregistre optional et pas Sprig.
  • Elle ne doit pas l’être. Fournissez-la. La clé que nomme le message est celle que le template a demandée, de sorte que les causes habituelles sont une clé publiée sous un autre nom — un identifiant dont la key n’est pas le nom de variable que lit la Recipe — une clé mal orthographiée dans le template ou dans les valeurs rédigées, et une connexion qui livrerait la clé et n’est pas câblée.

A template reads and iterates a path that holds nothing (Un template lit et itère un chemin qui ne contient rien)

Un template affiche un chemin tel quel et itère aussi sur ce même chemin — "user": "{{ .values.user }}" et "users": "{{ range .values.user }}…{{ end }}" dans un même valuesMapping, par exemple — et les données ne contiennent rien à cet endroit : la clé n’est pas définie, elle contient null, ou c’est un champ de premier niveau que le contexte définit et pour lequel il ne contient rien, tel que .workload sur une Recipe qui n’en synthétise aucun. La build s’arrête avant que le template ne s’exécute et nomme le chemin, sur chaque surface qui rend une valeur non définie comme rien : les templates de valeur que liste « Missing template key — asymmetric policy (Clé de template manquante — politique asymétrique) » ci-dessus, et l’interpolation des paramètres dans un Aggregate.

Chaque lecture prise seule a une réponse. Une valeur non définie qui est affichée ne rend rien, et une valeur parcourue avec range n’itère sur rien. Un chemin lu des deux façons ne peut avoir ni l’une ni l’autre : le rendre comme rien ferait échouer le range sur du texte, et le laisser non défini afficherait dans l’artefact le texte de substitution du moteur de templates <no value> pendant que la build réussit. Aucune des deux réponses n’est donc donnée, et la build s’arrête à la place.

Ce qui compte comme afficher le chemin est étroit, et la ligne est tracée là où le template l’affiche à coup sûr :

  • Il est affiché lorsqu’une action se compose du chemin et de rien d’autre — {{ .values.user }}, {{ $.values.user }}, {{ (.values).user }}, ou une variable liée au chemin, {{ $u }} après {{ $u := .values.user }} — à un point que le template atteint à chaque exécution.
  • Il n’est pas affiché lorsque la lecture se trouve dans un corps if, with ou range ou une branche else, car l’exécution de cette lecture dépend d’une condition, et la condition peut être le test même qui l’empêche de rencontrer le vide — ainsi {{ if .values.user }}{{ .values.user }}{{ end }} à côté d’un range .values.user est rendu comme il l’a toujours été. Il n’est pas non plus affiché lorsqu’il est le test propre d’une garde, l’affectation d’une variable ou l’argument d’une fonction — {{ .values.user | quote }}, {{ toYaml .values.user }} — dont la sortie est la réponse de la fonction plutôt que le texte de substitution.

Un affichage dans un corps qui s’exécute bel et bien sur un chemin ne contenant rien écrit toujours <no value>, ce que cette vérification n’atteint pas. Une écriture d’un chemin est le même chemin que toute autre, de sorte qu’un affichage dans une écriture et un range dans une autre sont jugés ensemble, et le message cite l’écriture que le template a utilisée en premier. Un chemin qui contient une valeur est affiché et itéré comme il l’a toujours été, et un chemin dont le parent ne contient rien est laissé à l’arrêt que provoque déjà la descente à travers le vide.

Message émis, comme dernière ligne du signalement — les cadres au-dessus nomment le nœud et le template, et l’en-tête porte le code de cette condition :

template reads a path as a value and iterates it, and the data holds nothing at that path (path <path>). supply a value at the path, guard the printed read with an if or with over the path, or read it one way only (le template lit un chemin comme valeur et l’itère, et les données ne contiennent rien à ce chemin (avec le chemin indiqué). fournissez une valeur au chemin, protégez la lecture affichée avec un if ou un with sur le chemin, ou lisez-le d’une seule façon)

L’interpolation des paramètres dans un Aggregate signale aussi la même ligne sous le code de cette condition. Une entrée provides: signale un échec de template sous « A provides: template could not be evaluated (Un template de provides ne peut pas être évalué) », de sorte que là l’en-tête porte le code de cette condition et la ligne ci-dessus est la raison qu’il porte, chemin compris.

Comment corriger : décidez laquelle des deux lectures le template entend faire.

  • Le chemin doit être là. Fournissez-le — dans les values: de l’Aggregate, l’infra: de la Release ou le paramètre que la Release renseigne — ou déclarez-le obligatoire dans le schéma qui le régit, afin que son absence soit signalée là où il est rédigé.
  • Le chemin peut être absent. Protégez la lecture affichée : {{ with .values.user }}{{ . }}{{ end }} ou {{ if .values.user }}{{ .values.user }}{{ end }} n’affiche rien lorsqu’il n’est pas défini, et le range à côté continue d’itérer comme rien.
  • Une seule lecture suffit. Lisez le chemin d’une seule façon — un range qui écrit aussi ce dont il a besoin, ou un affichage via une fonction telle que toYaml ou join qui répond elle-même pour une valeur non définie.

A value template failed while it ran (Un template de valeur a échoué pendant son exécution)

Le template de valeur d’une Recipe ou d’une FeatureRecipe — l’un des templates que liste « Missing template key — asymmetric policy (Clé de template manquante — politique asymétrique) » ci-dessus, parmi lesquels un corps de Workload, un corps artifacts: ou une entrée locals: — a été analysé, a commencé à s’exécuter et s’est arrêté avant de produire son texte. Ce qui l’a arrêté est la raison propre au moteur de templates, que l’arrêt porte sous lui : une référence qui descend à travers un conteneur que rien n’a fourni, comme {{ .values.tls.ca }} alors qu’aucun tls n’a été rédigé ; une comparaison entre des valeurs de deux types, comme {{ if eq .context.instance_id 1 }}, qui compare du texte avec un nombre et provoque un arrêt avec cannot compare text with a number ; ou un appel au fail de Sprig, qu’un template de valeur peut effectuer pour refuser une entrée avec un message qui lui est propre.

Quatre échecs sur ces templates sont plutôt signalés sous des conditions qui leur sont propres. Une entrée provides: est signalée sous « A provides: template could not be evaluated (Un template de provides ne peut pas être évalué) » ci-dessous, avec cette phrase et la raison du moteur à l’intérieur de son message. Une lecture via index d’une clé que la map ne contient pas est signalée sous « A template indexes a map with a key the map does not hold (Un template indexe une map avec une clé que la map ne contient pas) » ci-dessus. Un template qui affiche et parcourt avec range un même chemin qui ne contient rien est refusé avant de s’exécuter, sous « A template reads and iterates a path that holds nothing (Un template lit et itère un chemin qui ne contient rien) » ci-dessus. Et un template dont l’analyse échoue s’arrête avant de s’exécuter, il ne relève donc pas de cette condition.

Message émis — les cadres au-dessus de lui nomment l’instance du composant et le template, comme recipe "<recipe>" workload template ou Recipe "<recipe>" locals["<key>"], et la ligne propre au moteur de templates suit en dessous :

a value template failed while it ran (un template de valeur a échoué pendant son exécution)

La ligne du moteur se lit template: <template>:<line>:<column>: executing "<template>" at <<expression>>: <reason> — pour un appel à fail, error calling fail: <the message the template wrote>. La build signale l’arrêt sous une étiquette CATALOG_ERROR, car le template est écrit par l’auteur de la Recipe ou de la FeatureRecipe. aggrega pull rencontre le même échec lorsqu’il effectue le rendu de la Release pour découvrir les entrées externes qu’elle lit : il signale l’échec, écrit tout de même les épinglages de dépendances du lockfile et indique que les épinglages des entrées externes peuvent être incomplets ; la build, elle, s’arrête sur cet échec.

Comment corriger : lisez la raison du moteur à la fin du signalement — elle nomme le template, la ligne et la colonne, et l’expression sur laquelle il s’est arrêté. Pour un conteneur que rien n’a fourni, fournissez-le, ou protégez la lecture afin qu’elle ne descende jamais dans quelque chose d’absent : {{ with .values.tls }}{{ .ca }}{{ end }}, ou le helper optional. Pour deux types comparés, comparez ce qui est comparable — un nombre avec un nombre écrit sans guillemets, du texte avec du texte écrit entre guillemets — ou convertissez l’un des deux côtés en texte avec toString. Pour un appel à fail, le message est celui de l’auteur du template, et il dit ce dont la Recipe a besoin : fournissez-le-lui, ou associez le composant à une Recipe qui accepte ce que vous avez écrit.

A governance plugin rejected the build (Un plugin de gouvernance a rejeté la build)

Un opérateur peut rattacher un plugin de gouvernance dans un rôle de verdict, sur le graphe que le compilateur a construit ou sur les artefacts dont il a effectué le rendu. Un tel plugin lit et renvoie un verdict. L’hôte n’a aucun chemin qui appliquerait une modification revenant de ce plugin, de sorte qu’un rôle de verdict peut rejeter une build et ne peut pas la réécrire pour la rendre conforme — le rejet est tout ce qu’il peut faire, et ce qu’il faut changer est laissé à celui qui le lit.

Seul un verdict d’arrêt interrompt la build. Les verdicts d’avertissement et d’information sont signalés et la build continue. Chaque verdict d’arrêt renvoyé par un plugin est signalé, dans l’ordre où le plugin les a émis, de sorte qu’une seule exécution vous les fait tous connaître.

Le message qu’affiche une build est celui du plugin lui-même, restitué exactement tel qu’il a été renvoyé et encadré uniquement par le plugin qui l’a renvoyé — son degré de précision, et la facilité d’agir à partir de lui, relèvent donc du plugin plutôt que du compilateur. Tout détail facultatif porté par le verdict suit entre crochets, chaque partie nommée : un code, un identifiant de règle, une classification, une référence de source, un emplacement, une suggestion. La condition sous laquelle il est enregistré est policy violation, ce à quoi se résout un code court dans l’en-tête du diagnostic.

Le refus est attribué au rattachement de gouvernance plutôt qu’à l’un de vos documents, il ne porte donc aucune position de fichier : aucune clé ne l’a produit, et la réponse consiste soit à satisfaire la politique, soit à reconsidérer le rattachement.

Message émis :

policy plugin "<plugin>" rejected the build: <the plugin's own message> [code=<code>; rule_id=<rule>; classification=<class>; source_ref=<reference>; location=<where>; suggest=<suggestion>] (le plugin de politique indiqué a rejeté la build : avec le message propre au plugin et, entre crochets, le code, l’identifiant de règle, la classification, la référence de source, l’emplacement et la suggestion indiqués)

La partie entre crochets n’est présente que lorsque le verdict portait des détails, et chaque partie à l’intérieur seulement lorsque le plugin l’a définie.

Comment corriger : lisez le message du plugin et la suggestion, s’il en a fourni une. Lorsque le constat est correct, modifiez ce à quoi il s’oppose. Lorsque la politique ne devrait pas s’appliquer à cette Release, c’est une question qui porte sur le rattachement : les rattachements de gouvernance se configurent sous plugins.governance dans la configuration de l’espace de travail, et le choix du plugin qui s’exécute dans quel rôle est une décision de l’opérateur plutôt que quelque chose qu’un document peut remplacer.

A governance attachment’s settings do not match the plugin’s declared schema (Les paramètres d’un rattachement de gouvernance ne correspondent pas au schéma déclaré du plugin)

Un plugin de gouvernance peut déclarer un schéma pour les paramètres que son rattachement lui transmet. Les paramètres écrits sous with.settings du rattachement sont vérifiés par rapport à ce schéma avant que le plugin ne soit invoqué, de sorte qu’un rattachement mal configuré est signalé comme la faute de configuration qu’il est, plutôt que d’atteindre le plugin sous forme d’entrée mal formée et de revenir sous la forme de ce que le plugin en fait.

Cet ordre est la raison d’être de la vérification. Il rend aussi cette condition nettement distincte d’un rejet : le plugin ne s’est pas exécuté, aucun verdict n’a été rendu, et rien de la build n’a été jugé. Un plugin qui ne déclare aucun schéma de paramètres accepte n’importe quels paramètres, de sorte qu’un rattachement à l’un de ces plugins ne rencontre jamais cette condition.

La vérification couvre chaque rôle de gouvernance. Un rattachement rédigé au rôle ir-verdict, render-verdict, label-transform ou annotation-transform voit ses paramètres vérifiés par rapport au schéma avant que le plugin ne soit invoqué — with.settings est la même clé rédigée dans chaque rôle, et chaque rôle la lit d’abord par rapport au schéma. Un rôle de transformation s’exécute là où la build l’applique, ce qui, dans une build qui effectue d’abord un pull, a lieu pendant ce pull, de sorte que le message s’y ouvre par l’étape qui l’a invoqué, comme dans auto-pull: label-transform:.

Message émis — le rôle auquel le rattachement a été rédigé et le plugin qu’il nomme, puis la phrase fixe, puis ce que la vérification du schéma a trouvé :

ir-verdict: plugin "<the attachment's uri>": with.settings does not satisfy the plugin’s declared settings schema: <what the schema check found>: policy attachment settings do not satisfy the plugin’s declared settings schema (ir-verdict : le plugin indiqué : with.settings ne satisfait pas le schéma de paramètres déclaré du plugin : avec le résultat indiqué de la vérification du schéma : les paramètres du rattachement de politique ne satisfont pas le schéma de paramètres déclaré du plugin)

La clause initiale se lit render-verdict pour un rattachement rédigé à ce rôle. Ce que la vérification du schéma a trouvé est le rapport propre au validateur de schéma et s’étend sur plus d’une ligne.

Comment corriger : corrigez les paramètres sous with.settings de ce rattachement dans plugins.governance. Le détail au milieu du message nomme la clé fautive et ce que le schéma attendait à cet endroit ; la référence propre au plugin documente les paramètres qu’il déclare.

A pipeline step failed (Une étape de pipeline a échoué)

Une FeatureRecipe peut déclarer un pipeline : une séquence d’étapes, chacune invoquant un export de plugin sur les documents que le nœud a émis, afin qu’une Feature puisse façonner la sortie produite par la Recipe propre au composant. C’est la condition sous laquelle une étape signale un échec pour toute raison autre qu’un patch ciblant quelque chose que l’ensemble de documents ne contient pas, qui a son propre signalement ci-dessous.

Ce qui a échoué est nommé d’après l’id de l’étape et son index, et la clause qui suit indique quelle partie a cédé : le rendu de l’entrée with de l’étape, l’appel lui-même, une sortie que l’hôte n’a pas pu lire, une erreur renvoyée par le plugin, un diagnostic de gravité erreur émis par le plugin, un patch rejeté par le moteur de patch, ou un patch nommant une portée que le parcours n’a pas.

Une étape en échec est annulée en entier. Les documents sont restaurés dans l’état où ils étaient avant l’exécution de l’étape, et les propres sorties de l’étape sont abandonnées avec eux, de sorte que le when ou le with d’une étape ultérieure ne peut pas lire un résultat partiel. Une étape déclarée optional: true est alors signalée comme un avertissement et le parcours continue ; une étape qui n’est pas facultative arrête la build. Ce que optional: ne tolère pas, c’est un contrat déclaré violé — voir l’entrée ci-dessous.

Messages émis :

pipeline step failed: step "<id>" (index <n>) with: <what the render could not do> (échec de l’étape de pipeline : dans l’entrée de l’étape indiquée, à l’index indiqué, le rendu n’a pas pu faire ce qui est indiqué) pipeline step failed: step "<id>" (index <n>) invoke: <what the call could not do> (échec de l’étape de pipeline : lors de l’invocation de l’étape indiquée, à l’index indiqué, l’appel n’a pas pu faire ce qui est indiqué) pipeline step failed: step "<id>" (index <n>) error diagnostic: <the plugin's message> (échec de l’étape de pipeline : l’étape indiquée, à l’index indiqué, a émis un diagnostic d’erreur avec le message du plugin indiqué) pipeline step failed: scope "<scope>" key "<key>": <what the patch engine refused> (échec de l’étape de pipeline : dans la portée et la clé indiquées, le moteur de patch a refusé ce qui est indiqué) pipeline step failed: unknown patch scope "<scope>" (échec de l’étape de pipeline : portée de patch inconnue, celle indiquée)

Comment corriger : lisez l’id de l’étape, puis la clause après l’index — elle indique quelle moitié de l’étape examiner. Un échec de with est un template dans le bloc with: propre à l’étape, et c’est à vous de le corriger. Un diagnostic d’erreur, ce sont les propres mots du plugin sur votre entrée. Un patch refusé et une portée inconnue sont la sortie du plugin face à ce que le nœud a émis, et relèvent de l’auteur du plugin. Lorsqu’une étape est réellement autorisée à échouer — un enrichissement facultatif plutôt qu’une transformation requise — déclarez-la optional: true, en gardant à l’esprit que cela tolère un échec et non un contrat rompu.

A pipeline step’s typed input or output does not satisfy its declared contract (L’entrée ou la sortie typée d’une étape de pipeline ne satisfait pas son contrat déclaré)

Un export de plugin peut déclarer un schéma pour l’entrée qu’il reçoit et pour les sorties qu’il renvoie. Les deux sont vérifiés : la valeur with rendue avant l’appel, et les sorties renvoyées après celui-ci. Un diagnostic dont le contrat partagé ne déclare pas la gravité est refusé sur le même principe.

Cela provoque un arrêt même pour une étape déclarée optional: true, et c’est précisément cette distinction qui fait que la condition est séparée d’un échec d’étape. Facultatif tolère une étape qui n’a pas pu faire son travail — un appel qui a échoué, un plugin qui a émis une objection. Il ne tolère pas une sortie que l’hôte ne peut pas acheminer, ni une entrée qui n’a jamais eu la structure que l’export disait recevoir : un contrat déclaré est un engagement, et une build qui sauterait discrètement une étape dont le contrat a été rompu signalerait un succès pour une Feature qui n’a rien fait.

Messages émis :

pipeline step "<id>" with input does not satisfy the declared input contract: <what the schema check found>: pipeline step typed-I/O contract violation (l’entrée de l’étape de pipeline indiquée ne satisfait pas le contrat d’entrée déclaré : avec le résultat indiqué de la vérification du schéma : violation du contrat d’E/S typées de l’étape de pipeline) pipeline step "<id>" returned outputs that do not satisfy the declared output contract: <what the schema check found>: pipeline step typed-I/O contract violation (l’étape de pipeline indiquée a renvoyé des sorties qui ne satisfont pas le contrat de sortie déclaré : avec le résultat indiqué de la vérification du schéma : violation du contrat d’E/S typées de l’étape de pipeline)

et, pour une gravité de diagnostic que le contrat ne déclare pas, qui arrive à l’intérieur du cadre d’échec de l’étape :

pipeline step failed: step "<id>" (index <n>): <the severity the host could not route>: pipeline step typed-I/O contract violation (échec de l’étape de pipeline : l’étape indiquée, à l’index indiqué : avec la gravité indiquée que l’hôte n’a pas pu acheminer : violation du contrat d’E/S typées de l’étape de pipeline)

Lorsque le template with de l’étape lit une valeur déclarée sensible, une violation d’entrée ne nomme aucune valeur. Ce que la vérification du schéma a trouvé est remplacé par chaque position en échec et le mot-clé qui l’a refusée, conclus par un avis qui nomme la raison — at '/origin': pattern (the value is withheld because the template that rendered this input reads a value declared sensitive) — de sorte que le champ à corriger est tout de même nommé. Voir vocabulary/compact-form-authoring.md « Ce qu’un refus dit d’une valeur déclarée ».

Comment corriger : pour une violation d’entrée, corrigez le bloc with: de l’étape par rapport au schéma que déclare son export — le détail nomme le champ et ce qui était attendu. Une violation de sortie et une gravité non déclarée sont au plugin de les corriger ; la déclaration de l’étape n’est pas ce qui est erroné, de sorte que la marquer comme facultative ne lèvera ni l’une ni l’autre.

A pipeline patch addresses a document the set does not hold, or one with no tree to address (Un patch de pipeline cible un document que l’ensemble ne contient pas, ou un document sans arbre à cibler)

Une étape de pipeline cible un document par une portée et une clé, et deux formes d’adresse sont refusées.

L’ensemble ne le contient pas. L’étape a appliqué un patch à une paire portée-clé qui ne figure pas parmi les documents qui lui ont été transmis. Rien ne serait modifié, alors plutôt que d’appliquer un patch à rien et de signaler un succès, le parcours s’arrête :

pipeline patch targets a document not present in the set: scope "<scope>" key "<key>" (le patch de pipeline cible un document absent de l’ensemble : avec la portée et la clé indiquées)

Il ne porte aucun arbre à cibler. Certaines unités n’ont aucune structure vers laquelle un patch peut pointer — un corps binaire, du texte libre, une région que le fournisseur ne peut pas parcourir en toute sécurité. Une telle unité est tout de même transmise à l’étape, étiquetée avec son type de média et ses octets, de sorte qu’elle peut être sélectionnée et émise en entier ; ce qu’elle ne peut pas recevoir, c’est un patch, car il n’y a rien par rapport à quoi un chemin pourrait se résoudre. Un patch visant une telle unité s’arrête plutôt que d’être discrètement ignoré :

pipeline patch targets an opaque (non-structured) unit: scope "<scope>" key "<key>" (le patch de pipeline cible une unité opaque, non structurée : avec la portée et la clé indiquées)

Ce qui compte comme structuré est la lecture propre que le fournisseur fait de l’unité plutôt qu’un test fixe, de sorte que le même contenu peut être ciblable sous un fournisseur et opaque sous un autre.

Les deux sont des refus propres au parcours, et une build les signale sur le nœud dont le pipeline a appliqué le patch, de sorte que le message ci-dessus arrive sous un arrêt qui nomme ce nœud. Cet arrêt est la forme qui interrompt la build des deux mêmes fautes d’adressage, documentée sous « A pipeline step addresses documents the node does not have (Une étape de pipeline cible des documents que le nœud n’a pas) » ci-dessous — qui couvre aussi la troisième adresse avec laquelle une étape peut n’atteindre rien, une demande des documents d’un composant hôte à un emplacement où il n’y en a aucun.

Comment corriger : les deux relèvent de l’auteur du plugin plutôt que de vous. Une étape reçoit l’ensemble de documents sur lequel elle s’exécute et peut lire quelles clés il contient, de sorte qu’une cible absente est une étape qui cible un document que ce nœud n’a pas émis — appliquez le patch à un document présent, ou émettez d’abord celui que vous vouliez et appliquez-lui le patch dans une étape ultérieure. Pour une unité opaque, remplacez le patch par une émission de l’unité entière : un corps opaque est remplacé plutôt que modifié.

A patch’s test operation did not match the document (L’opération de test d’un patch ne correspondait pas au document)

Un patch peut porter une opération test, qui affirme ce qui se trouve à un chemin avant que les opérations suivantes ne soient appliquées. Le moteur refuse le patch entier lorsque l’assertion ne tient pas, et c’est ce qui rend un patch conditionnel réellement conditionnel plutôt qu’optimiste : un plugin qui teste avant de modifier indique qu’il ne touchera pas à un document qu’il ne reconnaît pas.

Deux formes sont signalées sous cette condition. Il n’y a rien du tout au chemin, ce que le message indique. Ou il y a une valeur et ce n’est pas celle qui est affirmée, ce qui est signalé comme le simple refus — ni la valeur affirmée ni celle trouvée ne sont citées.

Messages émis :

jsonpatch: test operation failed: no value at path (jsonpatch : échec de l’opération de test : aucune valeur au chemin) jsonpatch: test operation failed (jsonpatch : échec de l’opération de test)

Lorsque la sortie d’une étape de pipeline portait le patch, le refus arrive sous l’échec de cette étape, en nommant l’étape. Lorsque c’est le patch d’un plugin label-transform qui le portait, il arrive sous le refus du patch de labels.

Comment corriger : la faute revient au plugin plutôt qu’à vos documents. Un test qui attendait une valeur que le document n’a pas signifie généralement que le plugin s’exécute sur une structure pour laquelle il n’a pas été écrit — la sortie d’un autre fournisseur, ou un document qu’une étape antérieure du même pipeline a déjà modifié. Lorsque c’est à vous de corriger le patch, assouplissez le test pour qu’il corresponde à ce que le document porte réellement, ou faites en sorte que la condition when de l’étape écarte le cas plutôt que de le tester à l’intérieur du patch.

A workload: form and the fields beside it do not agree (La forme d’une charge de travail et les champs à côté d’elle ne concordent pas)

Un workload: déclare une form: — la structure de ce qui est exécuté, exprimée en termes que chaque cible comprend plutôt que dans le vocabulaire d’une cible en particulier. Certains champs n’ont de sens que sur une forme, et une forme déclarée sans le champ dont elle a besoin n’a rien de cohérent à rendre. Les deux directions sont vérifiées, avant qu’une cible ne traduise la charge de travail, de sorte que le désaccord est signalé une seule fois par rapport à ce que vous avez écrit plutôt qu’une fois par cible, avec les mots que chaque cible a pour le dire.

Cinq appariements sont appliqués, et chacun signale sa propre phrase qui nomme les deux moitiés et ce qu’il faut écrire :

workload declares a persistentTemplate volume but is not form: stateful; declare form: stateful (la charge de travail déclare un volume persistentTemplate mais n’est pas form: stateful ; déclarez form: stateful) workload is form: reference but declares no endpoint; set endpoint to the external host or URL the reference points at (la charge de travail est form: reference mais ne déclare aucun endpoint ; définissez endpoint sur l’hôte externe ou l’URL vers lequel pointe la référence) workload declares an endpoint but is not form: reference; declare form: reference or remove the endpoint (la charge de travail déclare un endpoint mais n’est pas form: reference ; déclarez form: reference ou supprimez l’endpoint) workload is form: scheduled but declares no schedule; set schedule to a 5-field cron expression or an @-macro (e.g. @daily) (la charge de travail est form: scheduled mais ne déclare aucune planification ; définissez schedule sur une expression cron à 5 champs ou une macro @, par ex. @daily) workload declares a schedule but is not form: scheduled; declare form: scheduled or remove the schedule (la charge de travail déclare une planification mais n’est pas form: scheduled ; déclarez form: scheduled ou supprimez la planification)

Chacune est positionnée sur l’instance de composant dont la charge de travail était lue, et signalée comme une faute de traduction, car le désaccord se situe entre deux champs d’un même bloc écrit par l’auteur.

Les conditions sous lesquelles elles sont enregistrées, qui sont ce vers quoi leurs codes courts se résolvent, sont persistentTemplate volume requires form: stateful, form: reference requires an endpoint, endpoint requires form: reference, form: scheduled requires a schedule et schedule requires form: scheduled.

Un appariement ne fonctionne que dans un sens. Une charge de travail form: stateful sans template de claim par réplique est ordinaire et ne déclenche rien — la règle est qu’un template de claim a besoin de l’identité stable par réplique que seule cette forme fournit, et non que la forme ait besoin d’un template de claim. Les deux autres appariements fonctionnent dans les deux sens, car un endpoint et une planification ont chacun exactement une forme sur laquelle ils ont un sens.

Les deux appariements portant sur endpoint figurent aussi dans le schéma Workload, de sorte qu’une charge de travail qui enfreint l’un d’eux est refusée à l’étape du schéma, sous E0214, avant que sa phrase ci-dessus ne soit atteinte. Un endpoint: sur toute forme autre que reference — y compris une form: omise, puisqu’elle se lit comme stateless — est refusé sous la forme

workload validation failed (Workload in Recipe <name>:<version>, at <path>, schema stage): .endpoint: value matches a shape that is not allowed here (échec de la validation de la charge de travail, dans le Workload de la Recipe et au chemin indiqués, étape du schéma : .endpoint : la valeur correspond à une forme qui n’est pas autorisée ici)

et form: reference sans endpoint: se termine à la place par .endpoint: missing required property: endpoint. Le remède est celui que donne la phrase de l’appariement.

Comment corriger : chaque phrase nomme les deux champs et donne les deux réponses. Ajoutez le champ dont la forme a besoin, ou changez la forme pour celle à laquelle le champ appartient, ou supprimez le champ là où une modification l’a laissé — supprimer une valeur schedule: en laissant la clé est la forme que cette erreur prend le plus souvent.

A workload schedule: is not an expression the check accepts (La planification d’une charge de travail n’est pas une expression que la vérification accepte)

Une charge de travail form: scheduled porte un schedule: indiquant quand elle s’exécute, et la structure de la valeur est vérifiée avant qu’une cible ne la lise. Deux écritures sont acceptées : l’une des cinq macros @hourly, @daily, @weekly, @monthly et @yearly, ou une expression crontab à cinq champs dont les champs n’utilisent que des chiffres et les caractères *, ,, - et /.

Ce que la vérification lit et ne lit pas. Elle compte les champs et examine les caractères qu’ils contiennent. Elle n’évalue ni les plages, ni l’arithmétique des pas, ni les noms des jours de la semaine, de sorte qu’une expression à cinq champs dont les nombres sont hors plage passe ici et c’est à la cible de la rejeter. Une expression à six champs portant un champ initial de secondes est refusée : cinq champs, c’est ce que cette surface accepte, et une cible qui veut des secondes les reçoit d’une autre manière.

Message émis :

workload schedule is not a valid cron expression; use a 5-field crontab expression (e.g. “0 0 * * *”) or one of @hourly, @daily, @weekly, @monthly, @yearly (la planification de la charge de travail n’est pas une expression cron valide ; utilisez une expression crontab à 5 champs, comme celle de l’exemple, ou l’une de @hourly, @daily, @weekly, @monthly, @yearly)

La condition sous laquelle il est enregistré est schedule is not a valid cron expression, ce vers quoi son code court se résout.

Comment corriger : comptez d’abord les champs — une planification avec quatre ou six champs est la cause la plus fréquente, et un espace en trop à l’intérieur d’un champ le divise en deux. Remplacez un jour ou un mois nommé par son numéro, et recourez à une macro lorsque l’une d’elles dit ce que vous vouliez.

A workload suspend: is set on a form other than scheduled (La suspension d’une charge de travail est définie sur une forme autre que planifiée)

suspend: true suspend la planification récurrente d’une charge de travail form: scheduled : la ressource planifiée est rendue, et aucune exécution ne démarre depuis sa planification tant qu’elle n’est pas reprise. Aucune autre forme ne porte de planification, donc sur toute autre forme le champ n’a rien à suspendre, et la build s’arrête plutôt que de rendre une charge de travail qui l’abandonne discrètement. La vérification s’exécute avec les autres appariements de forme, avant qu’une cible ne traduise la charge de travail, et une form: omise se lit ici aussi comme stateless.

Message émis :

workload declares suspend but is not form: scheduled; declare form: scheduled with a schedule or remove suspend (la charge de travail déclare suspend mais n’est pas form: scheduled ; déclarez form: scheduled avec une planification ou supprimez suspend)

Elle est positionnée sur l’instance de composant dont la charge de travail était lue, et signalée comme une faute de traduction. La condition sous laquelle elle est enregistrée est suspend requires form: scheduled, ce vers quoi son code court se résout.

La règle ne fonctionne que dans un sens, et seulement sur true. Une charge de travail form: scheduled sans suspend: est ordinaire et s’exécute selon sa planification, et suspend: false, la valeur par défaut, ne déclenche rien sur aucune forme.

Comment corriger : lorsque la charge de travail devait s’exécuter uniquement quand quelqu’un la lance, faites-en une charge de travail form: scheduled avec un schedule: et conservez suspend: true ; sinon, conservez la forme telle qu’elle a été écrite et supprimez suspend:, qu’aucune autre forme ne lit.

A library $import: is not written in the bare-name form (Une importation de bibliothèque n’est pas écrite sous la forme à nom nu)

Trois champs d’une Recipe et d’une FeatureRecipe peuvent tirer leur corps d’une bibliothèque au lieu de l’écrire sur place : une entrée artifacts.<name>:, un valuesMapping: et un workload:. Chacun écrit $import: avec le nom nu de la bibliothèque, puis #, puis le chemin de l’entrée sur la surface que ce champ lit — respectivement #/artifacts/, #/mappings/ et #/workloads/. Une valeur qui n’a pas cette forme ne nomme rien que la build puisse résoudre, et elle est refusée au moment où le champ est résolu.

Les trois champs sont délibérément le reflet les uns des autres, de sorte que la faute se lit de la même façon sur les trois et seule la surface change :

artifacts $import: is not a bare-name artifact-library reference (#/artifacts/): "<the value as written>" (l’importation d’artifacts n’est pas une référence à une bibliothèque d’artefacts sous forme de nom nu : avec la valeur indiquée, telle qu’elle a été écrite) valuesMapping $import: is not a bare-name mapping-library reference (#/mappings/): "<the value as written>" (l’importation de valuesMapping n’est pas une référence à une bibliothèque de mappings sous forme de nom nu : avec la valeur indiquée, telle qu’elle a été écrite) workload $import: is not a bare-name workload-library reference (#/workloads/): "<the value as written>" (l’importation de workload n’est pas une référence à une bibliothèque de workloads sous forme de nom nu : avec la valeur indiquée, telle qu’elle a été écrite)

Une version écrite avec @ est signalée avec l’orthographe à utiliser à la place, plutôt que d’aboutir à une plainte indiquant que la bibliothèque est introuvable, car c’est l’erreur que cette forme attire le plus :

artifacts $import: is not a bare-name artifact-library reference (#/artifacts/): version separator is ’:’, not ’@’ — use "<the corrected value>" (l’importation d’artifacts n’est pas une référence à une bibliothèque d’artefacts sous forme de nom nu : le séparateur de version est ’:’, et non ’@’ — utilisez la valeur corrigée indiquée)

Une autre forme est signalée ici, et ce n’est pas une faute d’écriture. Le corps propre d’un fichier d’un bundle d’ArtifactLibrary ne peut pas lui-même être un $import: d’un autre bundle : un emplacement de fichier ne peut pas s’étendre en plusieurs fichiers, de sorte qu’une importation imbriquée est refusée plutôt que résolue en quelque chose que l’auteur n’a pas écrit. Composez plutôt les bundles à l’endroit où ils sont consommés.

Une entrée artifacts: que la Recipe propre à un composant écrit est décidée avant tout rendu, de sorte que le signalement est positionné sur le bloc artifacts: de cette Recipe et nomme la référence, le bundle, le fichier dont le corps porte l’importation imbriquée, et l’entrée à laquelle l’importation a été écrite. Chaque fichier du bundle ayant cette forme est signalé en une seule build ; lorsqu’il y en a plus d’un, les constats sont regroupés sous artifacts entries whose library import the compiler cannot resolve :

artifacts $import: is not a bare-name artifact-library reference (#/artifacts/) ("<the value as written>", bundle "<bundle>", bundle file "<filename>", artifacts entry "<key>"). a bundle file body cannot import another bundle — compose the two at the artifacts entry that consumes them (l’importation d’artifacts n’est pas une référence à une bibliothèque d’artefacts sous forme de nom nu, avec la valeur telle qu’elle a été écrite, le bundle, le fichier de bundle et l’entrée d’artifacts indiqués. Le corps d’un fichier de bundle ne peut pas importer un autre bundle — composez les deux à l’entrée d’artifacts qui les consomme)

Une entrée artifacts: qu’écrit une FeatureRecipe signale la même condition au moment où le bundle est résolu, en nommant le premier fichier ayant cette forme :

artifacts $import: is not a bare-name artifact-library reference (#/artifacts/): bundle "<bundle>" file "<filename>" body is a field-root $import: (nested library import inside a bundle file is not supported; compose at the consumption site) (l’importation d’artifacts n’est pas une référence à une bibliothèque d’artefacts sous forme de nom nu : le corps du fichier indiqué du bundle indiqué est une importation à la racine du champ ; une importation de bibliothèque imbriquée dans un fichier de bundle n’est pas prise en charge ; composez à l’endroit de la consommation)

Un valuesMapping: que la Recipe propre à un composant écrit est décidé avant tout rendu, de sorte que le signalement est positionné sur la clé valuesMapping: de cette Recipe et porte l’orthographe à utiliser :

valuesMapping $import: is not a bare-name mapping-library reference (#/mappings/) ("<the value as written>"). name the library and the entry either side of the fragment — write #/mappings/ (l’importation de valuesMapping n’est pas une référence à une bibliothèque de mappings sous forme de nom nu, avec la valeur indiquée, telle qu’elle a été écrite. Nommez la bibliothèque et l’entrée de part et d’autre du fragment — écrivez la forme indiquée)

Un valuesMapping: qu’écrit une FeatureRecipe est signalé au moment où la référence est résolue, sous la forme que porte la liste ci-dessus.

Un workload: que la Recipe propre à un composant écrit est décidé avant tout rendu, de sorte que le signalement est positionné sur la clé workload: de cette Recipe et porte l’orthographe à utiliser :

workload $import: is not a bare-name workload-library reference (#/workloads/) ("<the value as written>"). name the library and the entry either side of the fragment — write #/workloads/ (l’importation de workload n’est pas une référence à une bibliothèque de workloads sous forme de nom nu, avec la valeur indiquée, telle qu’elle a été écrite. Nommez la bibliothèque et l’entrée de part et d’autre du fragment — écrivez la forme indiquée)

Un workload: qu’écrit une FeatureRecipe est signalé au moment où la référence est résolue, sous la forme que porte la liste ci-dessus.

Comment corriger : réécrivez la valeur sous la forme <Library>#<entry-path>, en ajoutant :<version> après le nom de la bibliothèque uniquement lorsque vous avez besoin d’un plancher sur la version qui peut être sélectionnée. Vérifiez que le fragment correspond au champ — un chemin d’entrée #/mappings/… sur un workload: nomme une surface que ce champ ne lit pas, et il est signalé ici plutôt que comme une entrée manquante. La même forme d’identité régit le $ref: d’un schéma, dont les refus sont documentés sous « A $ref: is not written in a form the compiler can resolve (Une référence n’est pas écrite sous une forme que le compilateur peut résoudre) » plus haut.

A library $import: names a library or an entry the catalog does not hold (Une importation de bibliothèque nomme une bibliothèque ou une entrée que le catalogue ne contient pas)

Un $import: est écrit correctement et ce vers quoi il pointe n’est pas là. Six conditions couvrent les deux moitiés d’une référence pour les trois types de bibliothèque, et celle que vous obtenez indique quelle moitié examiner : la bibliothèque elle-même est absente de ce que la build peut voir, ou la bibliothèque est là et ne publie pas l’entrée.

L’ensemble par rapport auquel une référence se résout est le catalogue propre de l’espace de travail, plus les bibliothèques que le lockfile a épinglées et introduites pendant le chargement de la build. Ainsi, une bibliothèque dont rien dans la fermeture des dépendances de la Release ne déclare dépendre ne fait pas partie de cet ensemble, aussi correcte que paraisse la référence vers elle.

La bibliothèque n’est pas là :

artifact-library import references an ArtifactLibrary not present in the catalog: ArtifactLibrary "<library>" (bundle "<entry>") (une importation de bibliothèque d’artefacts référence une ArtifactLibrary absente du catalogue : avec l’ArtifactLibrary et le bundle indiqués) mapping-library import references a MappingLibrary not present in the catalog: MappingLibrary "<library>" (entry "<entry>") (une importation de bibliothèque de mappings référence une MappingLibrary absente du catalogue : avec la MappingLibrary et l’entrée indiquées) workload-library import references a WorkloadLibrary not present in the catalog: WorkloadLibrary "<library>" (entry "<entry>") (une importation de bibliothèque de workloads référence une WorkloadLibrary absente du catalogue : avec la WorkloadLibrary et l’entrée indiquées)

L’entrée n’est pas là :

artifact-library import references a bundle not present in the ArtifactLibrary: bundle "<entry>" in ArtifactLibrary "<library>" (une importation de bibliothèque d’artefacts référence un bundle absent de l’ArtifactLibrary : avec le bundle et l’ArtifactLibrary indiqués) mapping-library import references an entry not present in the MappingLibrary: entry "<entry>" in MappingLibrary "<library>" (une importation de bibliothèque de mappings référence une entrée absente de la MappingLibrary : avec l’entrée et la MappingLibrary indiquées) workload-library import references an entry not present in the WorkloadLibrary: entry "<entry>" in WorkloadLibrary "<library>" (une importation de bibliothèque de workloads référence une entrée absente de la WorkloadLibrary : avec l’entrée et la WorkloadLibrary indiquées)

Une entrée artifacts: qu’écrit la Recipe propre d’un composant signale un bundle manquant sous une forme qui lui est propre. Cette entrée est décidée avant que quoi que ce soit ne soit rendu, de sorte que le signalement est positionné sur le bloc artifacts: de cette Recipe et nomme l’entrée à laquelle l’importation a été écrite, ainsi que les deux moitiés de la référence :

artifact-library import references a bundle not present in the ArtifactLibrary ("<entry>", ArtifactLibrary "<library>", artifacts entry "<key>") (une importation de bibliothèque d’artefacts référence un bundle absent de l’ArtifactLibrary : avec le bundle, l’ArtifactLibrary et l’entrée d’artifacts indiqués)

Un valuesMapping: qu’écrit la Recipe propre d’un composant signale une entrée manquante sous une forme qui lui est propre, pour la même raison : lui aussi est décidé avant que quoi que ce soit ne soit rendu, de sorte que le signalement est positionné sur la clé valuesMapping: de cette Recipe et nomme les deux moitiés de la référence :

mapping-library import references an entry not present in the MappingLibrary ("<entry>", MappingLibrary "<library>") (une importation de bibliothèque de mappings référence une entrée absente de la MappingLibrary : avec l’entrée et la MappingLibrary indiquées)

Un workload: qu’écrit la Recipe propre d’un composant signale une entrée manquante sous une forme qui lui est propre, pour la même raison : lui aussi est décidé avant que quoi que ce soit ne soit rendu, de sorte que le signalement est positionné sur la clé workload: de cette Recipe et nomme les deux moitiés de la référence :

workload-library import references an entry not present in the WorkloadLibrary ("<entry>", WorkloadLibrary "<library>") (une importation de bibliothèque de workloads référence une entrée absente de la WorkloadLibrary : avec l’entrée et la WorkloadLibrary indiquées)

Une entrée artifacts: qu’écrit une FeatureRecipe, un valuesMapping: ou un workload: qu’écrit une FeatureRecipe, et toute référence à une bibliothèque que la build ne peut pas voir, sont signalés au moment où la référence est résolue, sous les formes que portent les deux listes ci-dessus.

Chacun nomme à la fois la bibliothèque et l’entrée, quelle que soit la moitié qui a échoué, de sorte qu’un seul signalement suffit à distinguer une bibliothèque manquante d’une entrée manquante sans rien ouvrir.

Comment corriger : pour une entrée manquante, vérifiez le nom par rapport à ce que publie la bibliothèque — un nom d’entrée est une clé de la map propre à cette bibliothèque, et il est sensible à la casse. Pour une bibliothèque manquante, la référence est généralement correcte et c’est la fermeture qui est incomplète : déclarez la dépendance à cette bibliothèque pour qu’elle soit chargée, et actualisez le lockfile pour qu’elle soit épinglée. Une bibliothèque atteignable dans un espace de travail et pas dans un autre est la même erreur vue de l’autre côté.

A library $import: addresses its library by registry location (Une importation de bibliothèque adresse sa bibliothèque par son emplacement dans un registre)

Un $import: de bibliothèque nomme sa bibliothèque par son identité, jamais par le registre sur lequel elle se trouve être publiée. Le registre par lequel un nom se résout relève de la configuration de l’espace de travail, et la version utilisée est la réponse du lockfile ; une référence portant un hôte fige donc dans un document de catalogue deux choses que la build est censée décider — et le document cesse alors de fonctionner dans tout espace de travail configuré différemment.

Les cas où une telle référence peut encore atteindre cet arrêt sont plus restreints qu’il n’y paraît. Les champs $import: propres d’une Recipe et d’une FeatureRecipe sont refusés plus tôt, par leur schéma, qui n’admet aucun préfixe de registre à aucune des trois positions. Ce qui reste est la référence qu’aucun schéma ne décrit : une référence lue dans le corps même d’une entrée de bibliothèque, que l’entité qui la consomme n’a pas écrite et ne peut voir qu’une fois le corps résolu.

Message émis, depuis les surfaces valuesMapping: et workload:, où le résolveur ne signale que la valeur :

library $import: carries a registry host; reference the library by bare-name identity: "<the value as written>" (l’importation de bibliothèque porte un hôte de registre ; référencez la bibliothèque par son identité de nom nu : avec la valeur indiquée, telle qu’elle a été écrite)

Une entrée artifacts: n’atteint pas cet arrêt, et la raison mérite d’être connue si vous l’y cherchez. Sa propre référence est refusée avec le reste du document, comme toute autre position ; et, contrairement aux deux autres surfaces, un fichier de bundle dont le corps est lui-même une importation est rejeté plutôt que suivi — il n’existe donc aucun corps d’où pourrait arriver une référence portant un hôte.

Comment corriger : supprimez l’hôte et tout ce qui précède le nom de la bibliothèque, pour ne laisser que <Library>#<entry-path>. Lorsque la valeur fautive se trouve dans une bibliothèque que vous consommez plutôt que dans une bibliothèque que vous publiez, la correction revient à l’auteur de cette bibliothèque ; en attendant qu’elle arrive, importer une autre entrée ou écrire le corps sur place débloque la build.

Two artifact outputs of one Recipe carry the same filename (Deux sorties d’artefacts d’une même Recipe portent le même nom de fichier)

Le bloc artifacts: d’une Recipe nomme une sortie par clé, et un bundle importé à une clé apporte ses fichiers sous celle-ci. Deux sorties aboutissant à un même nom de fichier signifieraient que l’une écrase l’autre, de sorte que la build s’arrête plutôt que de choisir laquelle survit.

Il s’agit d’une protection résiduelle, et le dire fait partie de ce qu’elle est. Une sortie est nommée d’après la clé sous laquelle elle a été rédigée, les clés de map sont uniques au sein d’un document, et la surface de rédaction limite une clé à un seul nom de fichier — deux entrées rédigées ne peuvent donc pas entrer en collision, et une clé ne peut pas non plus écrire le nom imbriqué que produit le bundle d’une autre clé. Ce que la protection couvre encore, c’est le contenu qui a atteint la projection sans passer par le refus des clés en double propre à un document rédigé : un état assemblé pendant l’exécution de la build plutôt que lu dans un fichier. Une collision signalée ici pointe donc vers la manière dont la build a été assemblée plutôt que vers une ligne que vous pouvez voir.

Elle est levée par Recipe, sur les sorties propres de cette Recipe, et c’est ce qui la distingue de deux contributeurs différents aboutissant à un même chemin dans un assemblage — c’est « Two contributors write the same output path (Deux contributeurs écrivent le même chemin de sortie) » ci-dessus, avec un remède différent.

Message émis :

artifacts output filename collision: two artifact outputs carry the same filename (Recipe "<recipe>", artifact output "<filename>" emitted more than once) (collision de nom de fichier d’une sortie d’artifacts : deux sorties d’artefacts portent le même nom de fichier, avec la Recipe et la sortie d’artefact indiquées, émise plus d’une fois)

Comment corriger : ouvrez la Recipe que nomme le message et vérifiez ses clés artifacts: par rapport aux fichiers qu’apporte tout bundle qu’elle importe. Lorsque les clés sont réellement distinctes et que la collision persiste, rien dans le document n’est en cause, et le signalement mérite d’être remonté à ceux qui maintiennent la build.

An ArtifactLibrary bundle file names no file of its own under the key it was imported at (Un fichier de bundle d’une ArtifactLibrary ne nomme aucun fichier qui lui soit propre sous la clé à laquelle il a été importé)

Une entrée artifacts: qui importe un bundle se développe en une sortie par fichier de ce bundle, chacune imbriquée sous la clé à laquelle l’importation a été écrite. La clé nomme donc un répertoire, et chaque fichier qu’apporte le bundle se place sous celui-ci, sous un nom qui lui est propre. Un nom de fichier qui remonte hors de ce répertoire, nomme un emplacement absolu ou ne nomme rien du tout ne s’y place pas, et la build s’arrête plutôt que de placer le fichier à un endroit que la Recipe consommatrice n’a jamais choisi.

Ne rien nommer couvre tout nom qui n’est pas l’unique écriture d’un seul fichier sous la clé. . et ./, ainsi qu’un nom qui se replie sur la clé comme x/.., nomment la clé elle-même, de sorte que le fichier serait écrit là où doit se trouver le répertoire de la clé. Un nom avec un / final ou doublé, ou avec une partie . ou .. — x/, a//b, ./a, a/./b, a/../b — est une seconde écriture d’un fichier qu’un autre nom peut porter : a//b à côté de a/b sont deux noms pour un même fichier, et l’un serait écrit par-dessus l’autre sans qu’aucune collision ne soit signalée. Le nom vide est refusé lui aussi.

Ce qu’elle empêche, c’est une réorganisation silencieuse plutôt qu’une écriture hors du répertoire de sortie. L’endroit où les fichiers sont écrits est protégé à nouveau, de sorte qu’un nom qui remonte suffisamment est de toute façon refusé là. Le nom qui franchit cette protection est celui qui remonte d’exactement un niveau : il retombe à l’intérieur du répertoire de sortie, à une position que personne n’a choisie. C’est pire qu’une écriture refusée, car toute protection contre les collisions sur ce chemin lit un nom tel qu’il a été composé plutôt que tel qu’il se résout — deux fichiers de ce type peuvent donc se résoudre sur une même sortie sans que rien ne signale de collision, et celui qui survit n’est décidé par rien de ce que quiconque a écrit.

Une arborescence imbriquée écrite simplement à l’intérieur de la clé n’est pas touchée. Un bundle est libre de porter ses propres sous-répertoires, comme rbac/role.yaml, et les imbriquer sous la clé de consommation est précisément le rôle de la clé. Un nom qui contient simplement des points à l’intérieur d’une partie, comme ..config ou role.v1.yaml, est un nom ordinaire.

La Recipe consommatrice et le bundle publié sont généralement écrits par des auteurs différents, c’est pourquoi le message nomme les deux moitiés ensemble, avec le remède.

Une entrée artifacts: qu’écrit la Recipe propre d’un composant est décidée avant que quoi que ce soit ne soit rendu, de sorte que le signalement est positionné sur le bloc artifacts: de cette Recipe et nomme d’abord le fichier, puis la bibliothèque dont il provient et l’entrée à laquelle il est consommé. Chaque fichier du bundle dont le nom est refusé est signalé en une seule build ; lorsqu’il y en a plusieurs, les constats sont regroupés sous artifacts entries whose library import the compiler cannot resolve :

artifact-library bundle file name does not name a file of its own beneath the artifacts key its output is nested under ("<filename>", ArtifactLibrary "<library>", artifacts entry "<key>"). rename the file inside the ArtifactLibrary bundle to an ordinary file name beneath the artifacts key it is consumed at, such as “config.yaml” or “rbac/role.yaml” — no ”.” or ”..” part, and no leading, trailing or doubled ”/” (le nom d’un fichier du bundle d’une bibliothèque d’artefacts ne nomme pas un fichier qui lui soit propre sous la clé d’artifacts sous laquelle sa sortie est imbriquée, avec le fichier, l’ArtifactLibrary et l’entrée d’artifacts indiqués. renommez le fichier à l’intérieur du bundle de l’ArtifactLibrary en un nom de fichier ordinaire sous la clé d’artifacts à laquelle il est consommé, comme « config.yaml » ou « rbac/role.yaml » — aucune partie « . » ou « .. », et aucun « / » initial, final ou doublé)

Une entrée artifacts: qu’écrit une FeatureRecipe signale la même condition au moment où le bundle est résolu, en nommant la recette dans laquelle elle a été écrite et le premier fichier de ce type :

artifact-library bundle file name does not name a file of its own beneath the artifacts key its output is nested under (Recipe "<recipe>", artifact "<key>", bundle file "<filename>"). rename the file inside the ArtifactLibrary bundle to an ordinary file name beneath the artifacts key it is consumed at, such as “config.yaml” or “rbac/role.yaml” — no ”.” or ”..” part, and no leading, trailing or doubled ”/” (le nom d’un fichier du bundle d’une bibliothèque d’artefacts ne nomme pas un fichier qui lui soit propre sous la clé d’artifacts sous laquelle sa sortie est imbriquée, avec la Recipe, l’artefact et le fichier de bundle indiqués. renommez le fichier à l’intérieur du bundle de l’ArtifactLibrary en un nom de fichier ordinaire sous la clé d’artifacts à laquelle il est consommé, comme « config.yaml » ou « rbac/role.yaml » — aucune partie « . » ou « .. », et aucun « / » initial, final ou doublé)

Comment corriger : renommez le fichier à l’intérieur de l’ArtifactLibrary en un nom de fichier ordinaire sous la clé. Lorsque la bibliothèque n’est pas la vôtre, importer un autre bundle ou écrire l’entrée sur place débloque la build pendant que la correction est apportée en amont. Un fichier destiné à aboutir tout à fait ailleurs est une seconde entrée artifacts: à la clé à laquelle il appartient, et non un nom qui s’y rend en remontant.

An imported artifact no longer matches the digest recorded beside its Recipe (Un artefact importé ne correspond plus au digest enregistré à côté de sa Recipe)

Une entrée artifacts: qui importe un fichier local voit son contenu épinglé lorsque la Recipe est épinglée — par aggrega pin, ou par un pull ou un push auquel il est demandé d’exécuter la même étape : le digest des octets du fichier est enregistré dans entity.lock, à côté de la Recipe. Une entrée du boundary.artifacts: d’une Recipe est épinglée et comparée de la même manière, et enregistrée sous boundary/<key>, qui est le nom que lui donne le message. Chaque build relit le fichier, en recalcule le digest et refuse le désaccord — ainsi, un fichier modifié après avoir été épinglé n’est jamais rendu comme s’il avait été vérifié. aggrega pull --verify effectue la même comparaison et signale un désaccord avec le même message.

Ce qui est comparé, c’est le contenu de l’entrée, et non ce que son rendu a produit. Le corps d’un artefact est un template, et son évaluation substitue des valeurs qui diffèrent selon l’instance du composant, de sorte qu’un digest sur la sortie serait en désaccord pour chaque instance dont les valeurs diffèrent. Le contenu enregistré est le même texte pour chaque instance qui lie la Recipe, et c’est ce qui fait d’un seul digest enregistré la bonne référence de comparaison.

Une Recipe que personne n’a épinglée n’a aucun épinglage à côté d’elle, et une build ne la compare pas. L’absence d’épinglage n’est pas un désaccord pour une build ; elle signifie qu’il n’y a rien à comparer. Un pull sur une telle Recipe s’arrête en revanche, comme le décrit An entity reads an input the lock beside it records no pin for (Une entité lit une entrée pour laquelle le lock à côté d’elle n’enregistre aucun épinglage). Un lockfile écrit avant la modification du fichier signale en premier, car la ligne de l’entité couvre aussi le fichier importé, comme l’expose A local source no longer matches the pins recorded beside its Recipe (Une source locale ne correspond plus aux épinglages enregistrés à côté de sa Recipe), où la même section indique quand cette comparaison est celle que rencontre une build.

Trois surfaces portent la même vérification sur des documents différents — la Recipe propre d’un composant, une Feature rattachée à un composant et une Feature rattachée à une frontière — de sorte que le contenu de la FeatureRecipe est mesuré par rapport au digest enregistré à côté de la FeatureRecipe plutôt qu’à côté de la Recipe du composant hôte. Sur les deux surfaces de rattachement, le message nomme aussi le rattachement, et c’est ce qui indique quel document ouvrir.

Messages émis :

imported artifact content does not match the digest recorded for it in entity.lock ("<artifact>", imported file "<path>", its content digests to "<digest>", the recorded pin is "<digest>"). If the file was changed on purpose, run aggrega pin on the entity that imports it to record its new digest; otherwise restore the file (le contenu de l’artefact importé ne correspond pas au digest enregistré pour lui dans entity.lock, avec l’artefact, le fichier importé, le digest de son contenu et l’épinglage enregistré indiqués. Si le fichier a été modifié volontairement, exécutez aggrega pin sur l’entité qui l’importe pour enregistrer son nouveau digest ; sinon, restaurez le fichier) imported artifact content does not match the digest recorded for it in entity.lock ("<artifact>", imported file "<path>", its content digests to "<digest>", the recorded pin is "<digest>", attachment "<attachment>"). If the file was changed on purpose, run aggrega pin on the entity that imports it to record its new digest; otherwise restore the file (le contenu de l’artefact importé ne correspond pas au digest enregistré pour lui dans entity.lock, avec l’artefact, le fichier importé, le digest de son contenu, l’épinglage enregistré et le rattachement indiqués. Si le fichier a été modifié volontairement, exécutez aggrega pin sur l’entité qui l’importe pour enregistrer son nouveau digest ; sinon, restaurez le fichier)

Comment corriger : deux réponses, et la bonne dépend de ce que la modification était voulue ou non. Si elle l’était, exécutez aggrega pin sur la Recipe pour que l’épinglage soit repris à partir des octets actuels du fichier, et commitez le entity.lock qu’il réécrit. Si elle ne l’était pas, restaurez le fichier — le digest enregistré est la trace des octets qui ont été épinglés, et une build qui rendrait le fichier modifié livrerait un contenu que rien n’a vérifié.

A local source no longer matches the pins recorded beside its Recipe (Une source locale ne correspond plus aux épinglages enregistrés à côté de sa Recipe)

Une Recipe ou une FeatureRecipe dont le source: nomme un répertoire ou un fichier à côté d’elle voit cette source épinglée lorsque l’entité est épinglée — par aggrega pin, ou par un pull ou un push auquel il est demandé d’exécuter la même étape. Le entity.lock à côté de l’entité enregistre un digest par fichier que la source apporte à ce que porte une publication de l’entité, indexé par le chemin du fichier. Dès que le lock les enregistre, chaque build compare la source telle qu’elle est à ces épinglages avant que le fournisseur ne la lise, et refuse un désaccord — ainsi, un chart ou un module modifié après avoir été épinglé n’est jamais rendu comme s’il avait été vérifié. aggrega pull --verify effectue la même comparaison et signale un désaccord avec le même message. Une build nomme l’instance de composant dont elle résolvait la source et, en dessous, le document de la Recipe.

La source est comparée comme un seul ensemble de fichiers. Un fichier dont le contenu a changé, un fichier ajouté à la source et un fichier qui en a été retiré changent chacun ce à partir de quoi l’entité est rendue, donc chacun est signalé, avec le digest que le fichier a maintenant et le digest enregistré pour lui. Un fichier à côté de l’entité que la source n’apporte pas — une note ou un README près de la Recipe — n’est pas comparé. Une source écrite comme template, telle que ./charts/{{ .values.flavour }}, apporte chaque fichier du répertoire de l’entité, car le répertoire qu’elle nomme est décidé par chaque Release ; pour cette forme, une modification de n’importe quel fichier du répertoire est signalée.

Une Recipe dont le lock n’enregistre aucun épinglage pour sa source n’a rien qu’une build puisse comparer. Une build ne la refuse pas ; un pull ou un push qui n’épingle pas la refuse, comme le décrit An entity reads an input the lock beside it records no pin for (Une entité lit une entrée pour laquelle le lock à côté d’elle n’enregistre aucun épinglage). Les épinglages qu’un lock enregistre encore pour une source locale que la Recipe ne déclare plus n’épinglent rien de ce qu’elle lit, et ne sont donc comparés à rien. Une Recipe qu’un pull a résolue depuis un registre est couverte à la place par le digest que le lockfile enregistre pour ce que porte sa publication.

Un lockfile écrit avant la modification signale en premier. Le lockfile enregistre l’entité d’après ce qu’elle porte, et les fichiers de la source en font partie, donc une build ou aggrega pull --verify disposant d’un lockfile écrit avant qu’un fichier ne change s’arrête avant que cette comparaison ne s’exécute, The lockfile no longer matches what the release resolves to (Le fichier de verrouillage ne correspond plus à ce vers quoi la Release se résout) nommant l’entité et les deux digests. Un simple aggrega pull nomme le fichier qui a changé, avec An entity reads an input the lock beside it records no pin for (Une entité lit une entrée pour laquelle le lock à côté d’elle n’enregistre aucun épinglage). Il en va de même pour un fichier importé. Lorsque le lockfile n’a aucune entrée propre à l’entité, c’est cette comparaison que rencontrent une build et un pull de vérification : une Recipe ou une FeatureRecipe que le Manifest nomme par une référence qui est aussi le nom d’un Component ou d’une Feature qu’atteint la Release est enregistrée sous cette référence comme Component ou Feature, de sorte que rien ne change dans le lockfile lorsque les fichiers de la Recipe changent.

Messages émis :

the files of the entity’s local source do not match the pins recorded for them in entity.lock (file <path> digests to <digest> and its recorded pin is <digest>). If the source was changed on purpose, run aggrega pin on the entity to record its files again; otherwise restore the files (les fichiers de la source locale de l’entité ne correspondent pas aux épinglages enregistrés pour eux dans entity.lock, avec le fichier, son digest et son épinglage enregistré indiqués. Si la source a été modifiée volontairement, exécutez aggrega pin sur l’entité pour enregistrer à nouveau ses fichiers ; sinon, restaurez les fichiers) the files of the entity’s local source do not match the pins recorded for them in entity.lock (file <path> digests to <digest> and no pin is recorded for it). If the source was changed on purpose, run aggrega pin on the entity to record its files again; otherwise restore the files (les fichiers de la source locale de l’entité ne correspondent pas aux épinglages enregistrés pour eux dans entity.lock, avec le fichier et son digest indiqués, pour lequel aucun épinglage n’est enregistré. Si la source a été modifiée volontairement, exécutez aggrega pin sur l’entité pour enregistrer à nouveau ses fichiers ; sinon, restaurez les fichiers) the files of the entity’s local source do not match the pins recorded for them in entity.lock (file <path> is no longer in the source and its recorded pin is <digest>). If the source was changed on purpose, run aggrega pin on the entity to record its files again; otherwise restore the files (les fichiers de la source locale de l’entité ne correspondent pas aux épinglages enregistrés pour eux dans entity.lock, avec le fichier indiqué, qui ne fait plus partie de la source, et son épinglage enregistré. Si la source a été modifiée volontairement, exécutez aggrega pin sur l’entité pour enregistrer à nouveau ses fichiers ; sinon, restaurez les fichiers)

Comment corriger : comme pour un fichier importé, deux réponses, et la bonne dépend de ce que la modification était voulue ou non. Si elle l’était, exécutez aggrega pin sur la Recipe pour que les fichiers de sa source soient à nouveau épinglés, et commitez le entity.lock qu’il réécrit. Si elle ne l’était pas, restaurez les fichiers que nomme le message.

Chaque fichier que porte une publication d’une entité est lu dans le répertoire propre de l’entité, et un lien symbolique qui s’y trouve est refusé plutôt que suivi. Le suivre publierait les octets vers lesquels il pointe sous le nom propre du lien — où qu’il pointe, y compris hors du répertoire de l’entité — dans un artefact dont le digest est ensuite calculé et qui, lorsque la signature s’applique, est signé. L’ignorer à la place publierait un artefact dont le contenu diffère silencieusement de votre répertoire. Ainsi, chaque forme de lien est refusée de la même manière : un lien vers un fichier, un lien vers un répertoire, un lien qui ne pointe nulle part, un lien qui pointe vers lui-même, et deux liens qui pointent l’un vers l’autre.

Le refus a lieu partout où les fichiers de l’entité sont lus : par aggrega pin, par une publication avant qu’elle n’empaquette quoi que ce soit (exécution à blanc comprise), par un pull et un pull de vérification qui confrontent le entity.lock aux fichiers de l’entité, par une build qui compare une source locale à ses épinglages, et par un rendu qui lit un répertoire de source locale avant que quoi que ce soit n’en soit remis à un fournisseur. Le message nomme le lien par son chemin à côté du document de l’entité, et le diagnostic est positionné sur le lien lui-même.

Un lien que vos règles d’exclusion laissent de côté n’est pas un fichier que porte l’entité, il est donc ignoré comme tout autre fichier que ces règles laissent de côté, et jamais suivi. Ces règles sont celles enregistrées dans le entity.lock lorsque l’entité a été épinglée, de sorte qu’une ligne que vous ajoutez à .aggregaignore prend effet lorsque vous épinglez à nouveau l’entité.

Message émis :

a symbolic link sits among the files an entity carries (<path>). remediation: replace the link with a copy of what it points to, placed inside the entity’s own directory. A link met inside a source directory can instead be left out with a line in the .aggregaignore beside the entity, which takes effect when the entity is pinned again. A link is refused rather than followed because the bytes it points to would travel under the link’s name, from wherever it points (un lien symbolique figure parmi les fichiers que porte une entité, avec le chemin indiqué. remède : remplacez le lien par une copie de ce vers quoi il pointe, placée dans le répertoire propre de l’entité. Un lien rencontré dans un répertoire de source peut à la place être laissé de côté par une ligne dans le .aggregaignore à côté de l’entité, qui prend effet lorsque l’entité est à nouveau épinglée. Un lien est refusé plutôt que suivi parce que les octets vers lesquels il pointe voyageraient sous le nom du lien, où qu’il pointe)

Comment corriger : lorsque l’entité a besoin de ce vers quoi pointe le lien, remplacez le lien par une copie de sa cible dans le répertoire de l’entité, et épinglez à nouveau l’entité. Lorsque le lien est là pour votre propre commodité et que l’entité ne le lit pas, ajoutez son chemin au .aggregaignore à côté du document de l’entité et épinglez à nouveau. Quels fichiers sont livrés avec une entité décrit les règles qui décident de ce que porte une entité.

An entity reads an input the lock beside it records no pin for (Une entité lit une entrée pour laquelle le lock à côté d’elle n’enregistre aucun épinglage)

Une Recipe ou une FeatureRecipe peut dépendre d’octets extérieurs à son propre document : un source: distant dont les coordonnées sont écrites en entier, un fichier qu’une entrée artifacts importe avec $import, et les fichiers d’un source: qui nomme un répertoire ou un fichier à côté d’elle. L’épinglage de chacun est enregistré dans le entity.lock à côté de l’entité, et l’enregistrer est l’étape de l’auteur de l’entité, aggrega pin. Un pull n’enregistre donc pas ces épinglages de lui-même : sur une entité de l’un de vos répertoires de catalogue que la Release construit, il compare ce que l’étape enregistrerait avec ce que contient le lock, et s’arrête lorsqu’il manque un épinglage au lock — ou qu’il en contient un auquel l’entrée ne correspond plus — plutôt que d’écrire dans le répertoire de l’auteur sans y avoir été invité. Une build qui remplit son propre lockfile est un pull et s’arrête de la même manière.

Un push s’arrête sur la même comparaison, pour la seule entité qu’il s’apprête à publier. Avant que le bundle ne soit construit, et avant qu’un registre ne soit contacté, il compare ce que l’étape enregistrerait pour l’entité avec le lock à côté d’elle, et refuse de la même manière — exécution à blanc comprise — à moins qu’il n’ait été demandé au push d’exécuter l’étape lui-même. Ce que le message suggère à la fin diffère entre les deux, car chaque commande a ses propres moyens de faire enregistrer les épinglages ; ce qu’il signale, non.

Une source locale est confrontée à ses épinglages comme un seul ensemble de fichiers. Lorsque le lock n’en enregistre aucun, chaque fichier qu’apporte la source est signalé ici comme manquant. Lorsqu’il les enregistre, un fichier ajouté depuis l’épinglage est signalé comme manquant et un fichier modifié ou retiré comme un épinglage auquel l’entrée ne correspond plus, et une build signale la même modification comme A local source no longer matches the pins recorded beside its Recipe (Une source locale ne correspond plus aux épinglages enregistrés à côté de sa Recipe). Les épinglages qu’un lock enregistre encore pour une source locale que la Recipe ne déclare plus — son source: retiré, ou nommant désormais un artefact distant — n’épinglent rien de ce que lit la Recipe, donc ils n’arrêtent ni un pull, ni un push, ni un pull de vérification, ni une build ; le prochain aggrega pin les supprime.

Le message nomme chaque entrée manquante, par classe. Chacune est une remote source, nommée par son url et la version vers laquelle elle s’est résolue, un imported file, nommé par la clé artifacts qui le consomme, ou un local source file, nommé par son chemin à côté de l’entité — vous savez ainsi si c’est une source ou un fichier qui doit être épinglé. Chaque entité de ce type dans la Release est signalée en une seule exécution.

Une entité résolue depuis un registre n’est jamais confrontée à cela par un pull, car sa publication l’a déjà été. Elle se trouve dans le cache de contenu plutôt que dans un répertoire dont vous êtes l’auteur, de sorte qu’un pull ne lit ni n’écrit aucun lock à côté d’elle, et ses sources sont confrontées au lockfile de la Release. Une entité publiée avec aggrega push a été refusée à la publication à moins que son lock n’enregistre chaque épinglage que l’étape aurait enregistré pour elle à ce moment-là, et ce lock voyage à l’intérieur du bundle publié.

Messages émis, par un pull et par un push :

an input the entity reads has no pin recorded for it in the entity.lock beside it (Recipe "<name>", remote source <url>@<version>: no pin recorded, imported file <key>: the recorded pin no longer matches it). remediation: run aggrega pin <entity-path> and commit the entity.lock it writes beside the entity; to have every pull in this workspace record the pins itself instead, set pin_sources_at_pull: true in the workspace configuration (une entrée que lit l’entité n’a aucun épinglage enregistré pour elle dans le entity.lock à côté d’elle, avec la Recipe indiquée, une source distante indiquée avec sa version pour laquelle aucun épinglage n’est enregistré, et un fichier importé indiqué auquel l’épinglage enregistré ne correspond plus. remède : exécutez aggrega pin sur le chemin d’entité indiqué et commitez le entity.lock qu’il écrit à côté de l’entité ; pour que chaque pull de cet espace de travail enregistre plutôt les épinglages lui-même, définissez pin_sources_at_pull: true dans la configuration de l’espace de travail) an input the entity reads has no pin recorded for it in the entity.lock beside it (Recipe "<name>", remote source <url>@<version>: no pin recorded). remediation: run aggrega pin <entity-path> and commit the entity.lock it writes beside the entity; to have this publication record the pins itself instead, re-run it with --pin-sources; to have every publication in this workspace record them, set pin_sources_at_push: true in the workspace configuration (une entrée que lit l’entité n’a aucun épinglage enregistré pour elle dans le entity.lock à côté d’elle, avec la Recipe indiquée et une source distante indiquée avec sa version pour laquelle aucun épinglage n’est enregistré. remède : exécutez aggrega pin sur le chemin d’entité indiqué et commitez le entity.lock qu’il écrit à côté de l’entité ; pour que cette publication enregistre plutôt les épinglages elle-même, relancez-la avec —pin-sources ; pour que chaque publication de cet espace de travail les enregistre, définissez pin_sources_at_push: true dans la configuration de l’espace de travail)

La proposition centrale du message de la publication nomme ce qu’accepte la surface depuis laquelle vous avez publié : --pin-sources dans un terminal, le champ pinSources sur le daemon, et l’argument pin_sources de l’outil de l’assistant.

Comment corriger : lorsque l’entité est la vôtre, exécutez aggrega pin sur elle et commitez le entity.lock qu’il écrit, puis relancez le pull ou le push — ou faites le push avec --pin-sources, qui exécute l’étape avant que le bundle ne soit construit. Lorsqu’elle appartient à quelqu’un d’autre — un catalogue que vous consommez depuis un répertoire qui lui est propre —, celui qui la publie ne l’a pas encore épinglée ; définissez pin_sources_at_pull: true dans la configuration de votre espace de travail pour que chaque pull enregistre lui-même les épinglages, ou passez --pin-sources à un seul pull. aggrega pin décrit l’étape en entier.

A provides: template could not be evaluated (Un template de provides ne peut pas être évalué)

Une entrée provides: est un template qui produit la valeur qu’un autre composant lit par une connexion de dépendance. Cette condition est ce que signale une entrée qui n’a pas pu être évaluée : un template qui ne s’analyse pas, une fonction qu’il appelle et que cette surface n’enregistre pas, une référence qui descend à travers quelque chose que le contexte de rendu n’a pas fourni, ou une lecture par index d’une clé que la map ne contient pas.

Elle se distingue des deux refus qui s’exécutent avant l’évaluation sur le même bloc — une référence à une racine hors de l’ensemble autonome, et une référence que refuse l’ordre d’écriture propre au bloc — tous deux documentés plus haut. Ceux-là nomment l’expression à changer ; celle-ci porte ce que l’évaluation elle-même a signalé, et c’est pourquoi l’entrée est nommée à côté.

Message émis, qui nomme l’instance de composant, l’entrée à l’intérieur du bloc et ce que l’évaluation a signalé :

provides template evaluation failed (node "<instance>", provides["<key>"], <what the evaluation reported>) (l’évaluation du template de provides a échoué, avec le nœud, la clé de provides et ce que l’évaluation a signalé indiqués)

L’en-tête porte le code de cette condition, E0056, quoi que l’évaluation ait signalé. Lorsque l’évaluation s’est arrêtée sur une condition d’arrêt qui lui est propre — une lecture par index d’une clé que la map ne contient pas est la plus courante —, cette condition est signalée sous celle-ci plutôt qu’à sa place : sous caused by (2):, la phrase de cette condition vient en premier et le signalement propre de l’évaluation en second, sa phrase comprise. Ainsi, un lecteur qui fait correspondre les codes associe chaque entrée provides: en échec à E0056, et lit ce qui a fait échouer l’évaluation dans la condition située en dessous, dont la phrase renvoie à son propre code dans le tableau de toutes les conditions — E0327 pour la clé absente.

Comment corriger : ouvrez le bloc provides: de la Recipe à la clé que nomme le message et lisez la raison signalée — elle nomme généralement une position d’analyse ou une fonction. La gestion des clés manquantes sur cette surface rend une clé finale absente comme rien plutôt que d’échouer, donc un échec ici est un défaut structurel : un template qui ne s’analyse pas, une référence qui descend à travers un conteneur qui n’a jamais été fourni, ou une lecture par index d’une clé que la map ne contient pas, que nomme la raison signalée. Lorsque la valeur est réellement facultative, lisez-la au moyen du helper optional plutôt que de descendre dans quelque chose qui pourrait ne pas être là.

A Recipe or FeatureRecipe does not publish a provides key its contract declares (Une Recipe ou une FeatureRecipe ne publie pas une clé provides que son contrat déclare)

Un Component et une Feature déclarent chacun, sous schema.provides, les clés que publiera tout ce qui les lie — le contrat de sortie par rapport auquel un consommateur écrit ses connexions. La Recipe liée à un Component et la FeatureRecipe liée à une Feature doivent produire chaque clé que nomme ce contrat. Celle qui ne le fait pas est refusée, car la clé manquante ne livrerait sinon absolument rien : la référence du consommateur arriverait comme une variable non définie, un argument vide ou un fichier qui n’existe pas, sans que rien ne dise pourquoi.

Le contrat est la présence des clés, et rien de plus. Chaque clé déclarée doit apparaître ; les clés supplémentaires sont autorisées. Les valeurs elles-mêmes ne sont jamais inspectées — ce sont des pointeurs opaques acheminés sous forme de chaînes, de sorte que les types qu’un contrat déclare restent une indication destinée au consommateur plutôt qu’une vérification que fait la build.

Chaque manque est signalé. Une Recipe à laquelle il manque trois clés produit trois constats, chacun positionné sur sa propre entrée dans le bloc provides: de cette Recipe, de sorte que les trois sont corrigés à partir d’une seule build. Le message nomme la clé manquante, le type dont le contrat la déclare, et l’instance à laquelle la Recipe était liée — c’est cette dernière qui distingue deux constats lorsqu’une Recipe sert plusieurs instances d’un même type.

Message émis :

Recipe or FeatureRecipe does not publish a provides key its abstract entity’s schema.provides contract declares ("<key>", declared by component type "<type>", bound to component instance "<instance>") (la Recipe ou la FeatureRecipe ne publie pas une clé provides que déclare le contrat schema.provides de son entité abstraite (avec la clé indiquée, déclarée par le type de composant indiqué, liée à l’instance de composant indiquée))

L’appariement entre Feature et FeatureRecipe signale la même condition par la résolution propre au rattachement, en nommant la paire et la clé :

Recipe or FeatureRecipe does not publish a provides key its abstract entity’s schema.provides contract declares (<attachment context>, <the FeatureRecipe> does not publish provides key "<key>" declared by <the Feature>’s schema.provides contract) (la Recipe ou la FeatureRecipe ne publie pas une clé provides que déclare le contrat schema.provides de son entité abstraite (avec le contexte de rattachement indiqué : la FeatureRecipe indiquée ne publie pas la clé provides indiquée, déclarée par le contrat schema.provides de la Feature indiquée))

Là, il signale la première clé manquante dans l’ordre trié et s’arrête, de sorte que cet appariement nomme une clé par build tandis que l’appariement du Component les nomme toutes. Les clés sont parcourues dans l’ordre trié dans les deux cas, ce qui rend les deux identiques d’une exécution à l’autre.

Comment corriger : ajoutez la clé manquante au bloc provides: de la Recipe ou de la FeatureRecipe, ou retirez-la du schema.provides du Component ou de la Feature lorsque rien n’est censé la publier. Une clé dont le template ne rend rien est tout de même publiée, avec la chaîne vide comme valeur, de sorte qu’une entrée présente et vide remplit le contrat et n’est pas signalée ici. Lorsqu’une valeur vide doit arrêter la build, refusez-la dans une assertion : les assertions d’une Recipe lisent ses valeurs provides: résolues.

An assertion stopped the build (Une assertion a arrêté la build)

Un Component, une Feature, une Recipe ou une FeatureRecipe peut porter des assertions: — des templates nommés dont le but est de refuser une entrée plutôt que de produire du texte. Une assertion appelle fail, et c’est cet appel qui arrête la build ; l’argument est le message que son auteur a écrit pour quiconque la rencontre.

Les assertions sont évaluées à deux moments, de sorte qu’une règle lit l’état qui la concerne : celles d’un Component ou d’une Feature s’exécutent une fois le catalogue résolu et avant tout rendu, et celles d’une Recipe ou d’une FeatureRecipe s’exécutent une fois la liaison établie et avant le rendu de cette liaison.

Une référence à une clé que rien ne fournit est également signalée ici. La surface évalue avec une gestion stricte des clés manquantes, précisément pour qu’un prédicat dont la référence a été rendue vide ne puisse pas se comparer à rien et passer discrètement — une seule faute de frappe mettrait sinon hors service la règle que l’assertion a été écrite pour faire respecter. C’est pourquoi un simple default ne fournit pas de repli sur cette surface : la référence nue arrête l’évaluation avant que le repli puisse s’exécuter. Conditionnez la référence avec hasKey, ou utilisez le helper optional ; la lire via index provoque aussi un arrêt, en nommant la clé, comme le décrit « A template indexes a map with a key the map does not hold (Un template indexe une map avec une clé que la map ne contient pas) ».

Message émis, qui nomme le genre d’entité et le type, l’instance et l’assertion, puis porte le message que l’assertion elle-même a écrit :

<entity-kind> "<type>" instance "<instance>" assertion "<name>": assertion "<kind>/<type>/<instance>/<name>": template: <kind>/<type>/<instance>/<name>:<line>:<column>: executing "<kind>/<type>/<instance>/<name>" at <fail …>: error calling fail: assertion failed: <the message the assertion wrote> (assertion indiquée de l’instance indiquée, du type et du genre d’entité indiqués : assertion indiquée : template : à la ligne et à la colonne indiquées : exécution de l’assertion indiquée dans l’expression fail indiquée : erreur lors de l’appel de fail : échec de l’assertion : avec le message écrit par l’assertion)

et, pour une clé que rien ne fournit, la phrase du moteur de templates après celle de la condition elle-même :

<entity-kind> "<type>" instance "<instance>" assertion "<name>": assertion "<kind>/<type>/<instance>/<name>": assertion failed: template: <kind>/<type>/<instance>/<name>:<line>:<column>: executing "<kind>/<type>/<instance>/<name>" at <.reference>: map has no entry for key "<key>" (assertion indiquée de l’instance indiquée, du type et du genre d’entité indiqués : assertion indiquée : échec de l’assertion : template : à la ligne et à la colonne indiquées : exécution de l’assertion indiquée à la référence indiquée : la map n’a aucune entrée pour la clé indiquée)

et lorsque c’est l’évaluation qui a échoué plutôt que le prédicat :

<entity-kind> "<type>" instance "<instance>" assertion "<name>": assertion "<kind>/<type>/<instance>/<name>" parse: <what the parse reported> (assertion indiquée de l’instance indiquée, du type et du genre d’entité indiqués : analyse de l’assertion indiquée : avec le résultat de l’analyse indiqué)

Une valeur déclarée sensible n’apparaît pas dans le message. Lorsque l’assertion lit une telle valeur et appelle fail avec sa phrase écrite en toutes lettres sous la forme d’une seule chaîne entre guillemets — fail "…", sans rien qui y soit transmis par un pipe et sans rien de composé —, le message porte cette phrase telle qu’elle est écrite, quoi que contienne la valeur, car la phrase ne cite rien de ce que l’assertion a lu. Lorsque son message cite la valeur, le message affiche <redacted> à la place de la valeur. Lorsque le message est composé de toute autre manière et que ce qu’a fait l’assertion dépendait de ce que contient la valeur, le message qui suit l’expression en échec est remplacé par failure text withheld: this template reads a value declared sensitive, and the failure depends on what that value holds ; l’arrêt et son code restent inchangés. Ce qui compte comme déclaré, et quels refus sortent de ce cadre, est décrit dans vocabulary/compact-form-authoring.md « Ce qu’un refus dit d’une valeur déclarée ».

Vérifiée seule, une entité signale une assertion en échec comme un avertissement. aggrega validate appliqué au fichier d’une Recipe, la vérification de ce fichier par l’éditeur via aggrega serve et l’outil validate de aggrega mcp appliqué à une entity construisent la Recipe autour d’espaces réservés et de valeurs par défaut du schéma plutôt que des valeurs que fixe une Release, de sorte qu’ils ne peuvent pas distinguer une assertion qui attend une Release d’une assertion défectueuse. Là, une assertion qui appelle fail — celle de la Recipe elle-même, ou une que déclare le Component qu’elle implémente — est signalée comme un avertissement portant le message ci-dessus, conclu par la phrase A Release must satisfy this assertion before a build of it can pass., et la vérification réussit. Une référence à une clé que rien ne fournit et une assertion qui ne s’analyse pas ne sont pas des assertions en échec : chacune est une faute dans le texte même de l’assertion, et cette vérification la juge comme elle juge toute autre faute. Une build a toujours une Release, et s’arrête sur l’assertion comme décrit ici ; voir une assertion en échec est un avertissement.

Comment corriger : le message après le dernier deux-points est celui de l’auteur de l’assertion, et c’est lui qui dit quoi changer — une assertion est écrite de sorte que la rencontrer vous donne la réponse. Lorsque le signalement est une clé manquante plutôt que la phrase de l’auteur, c’est l’assertion elle-même qui est en faute : corrigez la référence, ou conditionnez-la comme décrit ci-dessus. Lorsque la règle ne devrait pas s’appliquer à cette Release, c’est une question qui concerne l’entité portant l’assertion plutôt que votre propre fichier.

A pipeline step addresses documents the node does not have (Une étape de pipeline cible des documents que le nœud n’a pas)

Une étape de pipeline cible un document par une portée et une clé. Trois conditions couvrent les façons dont une adresse n’atteint rien, et chacune arrête la build plutôt que de laisser une étape signaler un succès sur une modification qui n’a jamais eu lieu.

Le nœud ne l’a pas émis. Un patch nomme une paire portée-clé qui ne figure pas parmi les documents produits par ce nœud :

node "<instance>": pipeline PATCH targets a document the node did not emit (nœud indiqué : le PATCH de pipeline cible un document que le nœud n’a pas émis)

Il n’y a aucun hôte à cibler. Une étape a cherché les documents d’un composant hôte à un emplacement où il n’y en a aucun — le pipeline propre d’un composant, dont la seule portée est sa propre sortie, ou une Feature rattachée à une frontière plutôt qu’à un seul composant. La portée hôte est vide partout où un tel pipeline s’exécute, de sorte qu’une adresse dans celle-ci ne se résout en rien :

node "<instance>": pipeline /host operation from a step with no host component (nœud indiqué : opération /host de pipeline depuis une étape sans composant hôte)

Le document ne porte aucun arbre à cibler. Certaines unités n’ont aucune structure vers laquelle un chemin peut pointer — un corps binaire, du texte libre, une région que la cible ne peut pas parcourir en toute sécurité. Une telle unité est tout de même transmise à l’étape, de sorte qu’elle peut être sélectionnée et émise en entier ; ce qu’elle ne peut pas recevoir, c’est un patch :

node "<instance>": pipeline PATCH target is not parseable structured YAML/JSON (nœud indiqué : la cible du PATCH de pipeline n’est pas du YAML/JSON structuré analysable) pipeline PATCH target is not parseable structured YAML/JSON (node "<instance>", document "<key>") (la cible du PATCH de pipeline n’est pas du YAML/JSON structuré analysable (avec le nœud et le document indiqués))

Chacune arrive avec le compte rendu propre au parcours de l’adresse en dessous, et chacune est positionnée sur l’instance de composant dont le pipeline l’a produite.

Deux des trois sont aussi signalées avant tout parcours. Le fait qu’un emplacement ait ou non des documents hôtes découle de l’endroit où le pipeline a été écrit, de sorte qu’une étape déclarant opérer sur des documents hôtes à un emplacement qui n’en a pas est nommée dès que la build sait ce que déclare chaque plugin, sans attendre le rendu d’un nœud — et une Feature rattachée à une frontière est nommée à côté de l’étape :

pipeline /host operation from a step with no host component (opération /host de pipeline depuis une étape sans composant hôte) pipeline /host operation from a step with no host component ("<attachment>") (opération /host de pipeline depuis une étape sans composant hôte (avec le rattachement indiqué))

Les deux lectures sont une répartition d’une seule condition plutôt que le même constat fait deux fois : ce qu’une déclaration peut établir est établi à partir de la déclaration, et ce que seule l’exécution peut voir reste à l’exécution — une étape déclarant sa propre portée peut tout de même renvoyer une opération visant une autre portée.

Ces trois conditions sont la forme qui arrête la build des refus d’adressage que signale le parcours du pipeline lui-même, documentés sous « A pipeline patch addresses a document the set does not hold, or one with no tree to address (Un patch de pipeline cible un document que l’ensemble ne contient pas, ou un document sans arbre à cibler) » ci-dessus.

Comment corriger : les trois relèvent de l’auteur de l’étape plutôt que de vous. Pour une cible absente, appliquez le patch à un document que le nœud émet réellement, ou émettez celui que vous vouliez dans une étape antérieure et appliquez-lui le patch dans une étape ultérieure — une étape peut lire quelles clés lui ont été transmises. Pour un hôte manquant, déplacez l’étape vers un emplacement où se trouve un composant hôte, ciblez plutôt les propres documents de l’emplacement, ou supprimez-la. Pour une unité sans arbre, remplacez le patch par une émission de l’unité entière : un corps opaque est remplacé plutôt que modifié.

A pipeline patch addresses output that has not been assembled yet (Un patch de pipeline cible une sortie qui n’a pas encore été assemblée)

Certains fournisseurs regroupent la sortie par nœud d’un groupe d’acheminement en un seul document — un fichier compose fusionné, un chart parapluie. Tant que cette fusion n’a pas eu lieu, il n’y a pas de documents distincts, seulement des fragments, de sorte qu’un patch qui en cible un n’a rien vers quoi pointer. Un pipeline visant un tel composant est donc différé en entier et rejoué une fois que la fusion a produit les documents, ce qui est le chemin ordinaire et ne demande rien à l’auteur.

Cette condition est ce qui atteint la build lorsqu’un patch arrive malgré tout sur un fragment. Le cas qu’elle nomme est la sortie propre d’une Feature rattachée. Lorsque le fournisseur du composant regroupe son groupe, l’ensemble du pipeline du rattachement est retenu jusqu’à ce que la fusion ait produit les documents — et ce qui est transmis à ce rejeu, ce sont uniquement les documents du composant. Une étape visant la sortie propre de la Feature n’est proposée que pendant le rendu du composant, c’est-à-dire avant toute fusion, de sorte qu’elle n’a rien à cibler. Cela vaut quelle que soit la façon dont la sortie propre de la Feature circule : qu’elle rejoigne la fusion ou qu’elle soit écrite comme des documents à part entière, sa propre portée n’est jamais la portée que porte le rejeu.

L’émission n’est jamais concernée. Une émission ajoute un document plutôt que d’en modifier un, et s’exécute par nœud pour chaque fournisseur, de sorte qu’elle est entièrement en dehors de tout cela.

La condition est signalée avant tout parcours, à partir de ce que déclarent les plugins et les fournisseurs, et de nouveau comme garde-fou pendant le rendu d’un nœud. Messages émis :

pipeline PATCH targets an assembler provider’s pre-assembly fragments ("<attachment>") (le PATCH de pipeline cible les fragments de pré-assemblage d’un fournisseur assembleur (avec le rattachement indiqué)) pipeline PATCH targets an assembler provider’s pre-assembly fragments (node "<instance>", <scope>-scope document "<key>" is rendered by an assembler provider). the post-assembly phase re-runs this PATCH once the documents are discrete (le PATCH de pipeline cible les fragments de pré-assemblage d’un fournisseur assembleur (nœud indiqué ; le document indiqué, dans la portée indiquée, est rendu par un fournisseur assembleur). la phase de post-assemblage réexécute ce PATCH une fois que les documents sont distincts)

Comment corriger : ciblez les documents du composant plutôt que ceux propres à la Feature, ce qui est la forme rejouée après la fusion ; ou placez le composant sur un fournisseur qui ne regroupe pas son groupe d’acheminement ; ou supprimez l’étape. Laquelle des trois est la bonne dépend de ce que l’étape devait changer, et le message nomme la portée qu’elle a ciblée afin que vous puissiez le déterminer. Modifier la capability: propre à la FeatureRecipe n’en fait pas partie : cela ne change pas la portée transmise au rejeu après la fusion, et c’est précisément l’objet de cette condition.

A pipeline step’s plugin does not claim the provider rendering what it addresses (Le plugin d’une étape de pipeline ne revendique pas le fournisseur qui effectue le rendu de ce que l’étape cible)

Un plugin utilisé par une étape de pipeline peut déclarer les fournisseurs avec lesquels il a été testé. Cette liste est une revendication explicite plutôt qu’un « tout ce qui est similaire » implicite : exécuter un plugin avec un fournisseur qu’il ne nomme pas risque un patch écrit pour une autre forme de sortie, de sorte que la build s’arrête plutôt que d’essayer.

Le fournisseur auquel une étape est confrontée est celui qui effectue le rendu des documents que cette étape cible — le fournisseur propre du composant pour une étape visant les documents du composant, et le fournisseur propre de la Feature pour une étape visant ceux de la Feature. Sur une Feature rattachée à un composant, les deux se présentent, et ce sont deux valeurs différentes issues de deux documents différents.

Une liste de revendications vide ou absente ne correspond à rien, de sorte que chaque étape utilisant un tel plugin est signalée ici. Un plugin que la build n’a pas pu interroger est un cas différent et n’est pas signalé ici : une autodéclaration impossible à obtenir est l’absence d’une revendication plutôt qu’une revendication vide, et une telle étape s’arrête sur l’échec même de résolution, de chargement ou d’autodéclaration, qui est ce qu’il faut réparer.

La condition est signalée dès que la build sait ce que chaque plugin déclare sur lui-même, avant l’exécution qui invoquerait l’étape, et une fois par étape rédigée plutôt qu’une fois par build — de sorte qu’un auteur voit toutes les étapes fautives d’un pipeline à partir d’une seule build. Les noms de Provider sont comparés à l’identique.

Messages émis, le premier depuis le pipeline propre d’un composant et le second depuis celui d’une Feature, qui nomme aussi le rattachement :

pipeline plugin is not compatible with the rendering provider ("<provider>") (le plugin de pipeline n’est pas compatible avec le fournisseur de rendu, celui indiqué) pipeline plugin is not compatible with the rendering provider ("<attachment>", "<provider>") (le plugin de pipeline n’est pas compatible avec le fournisseur de rendu (avec le rattachement et le fournisseur indiqués))

Comment corriger : le constat est positionné sur l’étape rédigée, et le fournisseur qu’il nomme est ce avec quoi la déclaration doit être réconciliée. Lorsque le plugin est le vôtre, ajoutez le fournisseur à la compatibilité qu’il déclare, une fois que vous l’avez testé avec celui-ci. Sinon, sélectionnez une version du plugin qui revendique le fournisseur, effectuez le rendu de cette portée via un fournisseur que le plugin revendique, ou supprimez l’étape.

A provider refused a node’s input (Un fournisseur a refusé l’entrée d’un nœud)

Un fournisseur peut vérifier l’entrée qui lui est transmise pour un composant avant d’en effectuer le rendu, et signaler ce qu’il trouve. Les constats au niveau de gravité arrêt arrêtent la build ; ceux aux niveaux de gravité avertissement et information sont présentés à côté de la sortie de la build et ne changent rien aux octets émis.

Il s’agit de la lecture que le fournisseur lui-même fait de votre entrée, et non de celle du compilateur ; ce à quoi il objecte et la précision avec laquelle il le dit relèvent donc du fournisseur. Le compilateur nomme le composant et le fournisseur, et transmet les messages du fournisseur tels qu’ils ont été renvoyés ; lorsqu’un fournisseur en a signalé plusieurs, ils arrivent ensemble, séparés par des points-virgules, de sorte qu’une seule build vous les fait tous connaître.

Le même acheminement est utilisé que l’entrée appartienne à la Recipe propre d’un composant ou à une Feature rattachée, de sorte que la vérification d’un fournisseur se lit de manière identique dans les deux cas.

Message émis :

provider rejected node input: node "<instance>", provider "<provider>": <the provider's messages> (le fournisseur a rejeté l’entrée du nœud : avec le nœud, le fournisseur et les messages du fournisseur indiqués)

Comment corriger : lisez les messages du fournisseur — ils nomment ce qu’il n’a pas pu accepter dans l’entrée résolue. L’entrée est assemblée à partir des valeurs de la Recipe et de la configuration propre du composant, de sorte que la correction se trouve généralement dans l’une d’elles ; la page de référence propre au fournisseur indique ce qu’il exige. Lorsque le fournisseur objecte à quelque chose que vous ne pouvez pas modifier depuis un document, c’est une question pour l’auteur de la Recipe ou du plugin.

A provider rendered the same input twice and produced different output (Un fournisseur a effectué deux fois le rendu de la même entrée et a produit des sorties différentes)

À entrée identique, une build produit une sortie identique — c’est le contrat à l’aune duquel les outils de revue et les outils de déploiement lisent le résultat d’une build. Un mode de build optionnel le vérifie directement : chaque composant est rendu deux fois à partir de la même entrée et les octets émis sont comparés. Un fournisseur dont les deux rendus divergent transporte un état de l’un à l’autre, ou n’est pas, d’une autre manière, une fonction de son entrée, et la build s’arrête.

La build ordinaire effectue le rendu de chaque composant une seule fois, de sorte que cette condition ne se rencontre que dans le mode de vérification. Rien dans une build normale ne change du fait que ce mode soit disponible.

Ce qui est comparé, c’est la sortie brute émise par le fournisseur — les mêmes octets dans lesquels sont découpés les artefacts rendus —, de sorte qu’une différence n’importe où dans ce qu’il a produit est détectée, et pas seulement une différence qui subsiste jusque dans un fichier final.

Message émis :

rendering node "<instance>": node "<instance>" (provider "<provider>"): two renders of identical input produced different output: provider render is not deterministic (rendu du nœud indiqué : nœud indiqué, avec le fournisseur indiqué : deux rendus d’une entrée identique ont produit des sorties différentes : le rendu du fournisseur n’est pas déterministe)

Comment corriger : trouvez d’abord ce qui diffère entre deux builds du composant que nomme le message — construisez-le deux fois et comparez les sorties. Lorsque la différence est une valeur qu’un chart que vous utilisez comme source génère à nouveau à chaque rendu — un mot de passe aléatoire, une clé générée, un horodatage dans un Secret ou une ConfigMap —, la faute se trouve dans la sortie de ce chart plutôt que dans le fournisseur, et vous pouvez la lever vous-même de l’une de deux manières. Fournissez la valeur, via le paramètre que le chart propose pour elle, depuis le valuesMapping: de la Recipe, de sorte que le chart cesse de la générer. Ou, lorsque le document généré est un document que la Release ne doit pas livrer — un Secret que l’opérateur fournit séparément, par exemple —, laissez-le hors de la build avec une entrée omits: sur la Recipe ; voir Recipe → Le champ omits:. Sinon, la faute est celle du fournisseur et non de vos documents, et rien de ce que vous pouvez écrire ne la lève. Signalez-la à l’éditeur du plugin qui sert ce fournisseur, en nommant le composant que le message identifie — les causes habituelles sont un horodatage, une valeur aléatoire ou un ordre qui suit l’itération d’une map plutôt que l’ordre écrit par l’auteur. Tant qu’elle n’est pas corrigée, le mode de build ordinaire n’est pas affecté, et épingler le plugin à une version qui a passé la vérification est la réponse pratique.

An omits entry left out nothing the source rendered (Une entrée omits n’a rien laissé de côté de ce que la source a rendu)

Chaque entrée de la liste omits: d’une Recipe ou d’une FeatureRecipe qui s’applique à une build — son when: absent, vide ou vrai — doit laisser hors de la sortie au moins une chose que la source a rendue : un document qu’un chart rend, un service, un volume ou un config qu’un fichier compose déclare, ou une ressource qu’un template CloudFormation déclare. Le fournisseur qui effectue le rendu de la source confronte chaque entrée à ce qu’il a rendu et indique combien d’unités chacune a laissées de côté ; une entrée qui n’en a laissé aucune de côté arrête la build.

Une entrée qui ne correspond à rien est une affirmation sur la source qui n’est plus vraie. La cause habituelle est une mise à niveau de la source qui a renommé ou supprimé ce que l’entrée désigne — et un document ou un service renommé se trouve alors dans la sortie sous son nouveau nom, ce qui est exactement ce que l’entrée avait été écrite pour tenir à l’écart —, et l’autre est une erreur dans l’entrée elle-même. Passer outre livrerait ce que l’entrée devait laisser de côté, de sorte que la build s’arrête et nomme l’entrée.

Le message nomme le nœud, le fournisseur, le document qui déclare l’entrée et la position de l’entrée dans la liste omits: de ce document, en comptant à partir de 0, ainsi que le kind, le nom et le namespace auxquels l’entrée s’est résolue, le namespace seulement lorsque l’entrée en désigne un. Pour une FeatureRecipe rattachée à un composant, le nœud est ce composant ; pour une FeatureRecipe rattachée à une frontière, la ligne au-dessus du message nomme le rattachement et sa frontière. Lorsque plusieurs entrées ne correspondaient à rien, c’est la première dans l’ordre où vous les avez écrites qui est nommée, de sorte que la même entrée est nommée à chaque exécution. Un champ dont le template a lu une valeur déclarée sensible est affiché comme <redacted> plutôt que comme ce à quoi il s’est résolu. Une entrée que son when: a écartée n’est jamais transmise au fournisseur ni vérifiée.

Message émis. La catégorie vous parvient dans l’en-tête entre crochets :

an omits entry left out nothing the source rendered (node "<node-id>", provider "<provider>", "<document>" omits[<position>], kind "<kind>", name "<name>", namespace "<namespace>"). correct the entry so it names something the source renders, or remove it; a source upgrade that renamed or removed it is the usual cause (une entrée omits n’a rien laissé de côté de ce que la source a rendu (avec le nœud, le fournisseur, la position dans la liste omits du document, le kind, le nom et le namespace indiqués). corrigez l’entrée pour qu’elle désigne quelque chose que la source rend, ou supprimez-la ; la cause habituelle est une mise à niveau de la source qui a renommé ou supprimé ce qu’elle désignait)

L’en-tête porte le code court de cette condition, E0334.

Comment corriger : comparez l’entrée à ce que la source rend maintenant — lancez une build sans l’entrée et lisez ce que le composant rend —, puis corrigez le kind, le nom ou le namespace de l’entrée, ou supprimez l’entrée lorsque ce qu’elle désignait a disparu. Pour un chart, une entrée désigne un document par le kind et le metadata.name propres au document et, lorsque l’entrée indique un namespace, par le namespace dans lequel se trouve le document ; pour un fichier compose, elle désigne un service, un volume ou un config par sa clé ; pour un template CloudFormation, elle désigne une ressource par son Type et son ID logique, dans n’importe lequel des templates de la source. Voir Recipe → Le champ omits:.

A provider’s omitted counts do not match the omits entries it was handed (Les décomptes d’omissions d’un fournisseur ne correspondent pas aux entrées omits qui lui ont été transmises)

Un fournisseur qui déclare laisser de côté des unités rendues indique, pour chaque entrée omits: qui lui a été transmise, à combien d’unités cette entrée a correspondu — un décompte par entrée, dans l’ordre dans lequel les entrées ont été transmises. Un rapport absent, qui contient trop peu ou trop de décomptes, ou qui contient un décompte inférieur à zéro ne laisse aucun moyen de savoir si une entrée a laissé quoi que ce soit de côté, de sorte que la build s’arrête. Rien de ce que vous avez écrit n’en est la cause : cela signale un fournisseur dont la sortie renvoyée ne respecte pas le contrat qu’il déclare.

Message émis. Le message nomme le nœud et le fournisseur, puis combien d’entrées ont été transmises et ce qui est revenu — soit combien de décomptes, soit le décompte inférieur à zéro et l’entrée pour laquelle il a été donné :

a provider’s omitted counts do not match the omits entries it was handed (node "<node-id>", provider "<provider>", handed <n> omits entries, returned <m> omitted counts) (les décomptes d’omissions d’un fournisseur ne correspondent pas aux entrées omits qui lui ont été transmises (avec le nœud et le fournisseur indiqués, le nombre indiqué d’entrées omits transmises et le nombre indiqué de décomptes d’omissions renvoyés))

L’en-tête porte le code court de cette condition, E0336.

Comment corriger : signalez-le à l’éditeur du plugin qui sert ce fournisseur, en nommant le composant que le message identifie. Ce que doit un fournisseur est exposé dans le contrat des plugins sous Laisser de côté des unités rendues.

Assembled output still carries a cross-boundary placeholder (La sortie assemblée porte encore un espace réservé entre frontières)

Lorsqu’une connexion de dépendance passe entre deux sorties assemblées, la valeur qu’elle porte ne peut pas être connue pendant le rendu du côté consommateur — elle est publiée par l’autre côté et résolue une fois que les deux ont été assemblés. La build écrit donc un espace réservé dans l’entrée du composant consommateur, et le fournisseur le remplace par sa propre forme de référence croisée une fois que l’assemblage existe.

Cette condition est ce que signale un espace réservé qui a survécu à ce remplacement. Survivre signifie que la résolution ne l’a jamais atteint : la valeur a abouti à un endroit que le fournisseur ne pouvait pas cibler — le plus souvent insérée dans une chaîne plus longue au lieu de constituer une valeur entière —, ou un franchissement a été marqué sans rien de l’autre côté pour le résoudre. Un espace réservé n’est jamais une sortie valide, de sorte que la build s’arrête plutôt que de livrer un fichier qui en contient un.

Le message nomme le fournisseur qui a écrit le fichier et le chemin où se trouve le fichier : un chemin n’est unique qu’au sein d’un même assemblage, de sorte que ce sont les deux ensemble qui identifient un fichier. Chaque fichier fautif est signalé, et pas seulement le premier, et chacun est signalé une seule fois, quel que soit le nombre de frontières qui ont alimenté l’assemblage où il se trouve. Il est signalé sur le document de la Release dans son ensemble plutôt que sur une frontière qu’il contient — la faute réside dans la manière dont une valeur a atteint le fichier, et non dans une déclaration de frontière, de sorte qu’aucune déclaration de frontière n’est ce qu’il faut modifier.

Message émis :

assembled output retains an unresolved cross-boundary link placeholder ("<provider>", "<output-path>") (la sortie assemblée conserve un espace réservé de lien entre frontières non résolu (avec le fournisseur et le chemin de sortie indiqués))

Comment corriger : la cause la plus courante est une valeur que le côté consommateur a interpolée dans une chaîne plus longue. Une référence croisée doit constituer la totalité de la valeur sous laquelle elle est injectée ; modifiez donc le mapping de la Recipe pour la livrer entière, et composez plutôt autour d’elle dans le vocabulaire propre de la cible. Lorsque la valeur est entière et que l’espace réservé survit tout de même, la faute se trouve du côté du fournisseur dans la résolution et relève de l’éditeur de ce plugin.

Un template peut lire les valeurs d’un producteur directement sur une connexion, à .context.uses.<alias>.provides — ou, dans une FeatureRecipe de portée frontière, sur les connexions de la frontière sous .boundary. Lorsque la connexion relie deux composants dont le rendu aboutit à des sorties différentes et que le fournisseur la câble avec une référence qui lui est propre, chacune de ces valeurs atteint le template sous la forme d’un espace réservé que le fournisseur remplace une fois les deux sorties assemblées : par une référence inter-stacks, ou par la valeur elle-même. Un template ne peut donc que copier une telle valeur — l’écrire entière, à l’intérieur d’une chaîne plus longue, ou au moyen d’une fonction qui la laisse telle quelle, comme quote.

Une comparaison, un branchement, une longueur ou une fonction qui modifie la valeur — eq, if, len, upper, trimPrefix — serait décidé par rapport à l’espace réservé plutôt qu’à la valeur, silencieusement. La build le vérifie en évaluant le template deux fois, une fois sur les espaces réservés et une fois sur les valeurs réelles, et s’arrête là où les deux divergent une fois chaque espace réservé réécrit. Cela s’applique à chaque template qui lit une telle connexion : les templates propres d’une Recipe, l’injectMapping: d’une FeatureRecipe rattachée et les templates d’une FeatureRecipe de portée frontière.

Le message nomme le template — le champ et la Recipe à laquelle il appartient — et, pour chaque valeur provides dont dépend la différence, le composant consommateur, l’alias et le socket de la connexion, et le composant producteur. Une valeur que le template n’a fait que copier n’est pas nommée.

Message émis :

a template does more than copy a value it reads off a cross-boundary link (template "<template>", provides key "<key>" that component "<consumer>" reads off its connection "<alias>" on socket "<socket>" to component "<producer>"). Copy the value as it stands, whole or inside a larger string, because the provider writes in its place what the value becomes in the other output, and branch on a value of the component’s own instead (un template fait plus que copier une valeur qu’il lit sur un lien entre frontières (avec le template indiqué et la clé provides indiquée que le composant consommateur indiqué lit sur sa connexion indiquée, sur le socket indiqué, vers le composant producteur indiqué). Copiez la valeur telle qu’elle se présente, entière ou à l’intérieur d’une chaîne plus longue, car le fournisseur écrit à sa place ce que la valeur devient dans l’autre sortie, et faites plutôt reposer le branchement sur une valeur propre au composant)

Comment corriger : copiez la valeur que nomme le message plutôt que de la tester ou de la transformer, et fondez la décision sur une valeur que le composant consommateur rédige lui-même — l’une de ses propres clés values ou infra — plutôt que sur ce que lit sa connexion. Le fournisseur CloudFormation décrit ce que devient une valeur copiée dans l’autre stack.

A provider named a directory for a contributor that is not one directory (Un fournisseur a nommé pour un contributeur un répertoire qui n’est pas un répertoire unique)

Un fournisseur qui place chaque contributeur sous sa propre position à l’intérieur d’une même sortie englobante déclare le répertoire sous lequel se trouvent ces positions, et la build y compose l’identité de chaque composant. La valeur doit nommer exactement un répertoire : une valeur contenant un séparateur de chemin, ou nommant le répertoire courant ou le répertoire parent, placerait les fichiers d’un composant ailleurs que sous sa propre position — soit entièrement hors de l’assemblage, soit réorganisés silencieusement à l’intérieur.

La build s’arrête plutôt que de composer un tel chemin. Le message nomme le fournisseur qui a déclaré la valeur et la valeur elle-même, de sorte qu’il est clair quel fournisseur modifier et ce qu’il a déclaré.

Un fournisseur qui ne déclare aucun répertoire de ce type n’est pas concerné. Chaque contributeur se trouve alors directement dans le répertoire de déploiement sous son propre nom, de sorte que s’abstenir de nommer un répertoire englobant est une réponse légitime et non un oubli.

Message émis :

provider named a directory for each contributor’s own sub-directory that is not a single directory name: provider "<provider>" declared nest_segment "<value>"; the value must name one directory, carrying no path separator and naming neither the current nor the parent directory (le fournisseur a nommé, pour le sous-répertoire propre de chaque contributeur, un répertoire qui n’est pas un nom de répertoire unique : le fournisseur indiqué a déclaré nest_segment avec la valeur indiquée ; la valeur doit nommer un seul répertoire, sans séparateur de chemin et sans nommer ni le répertoire courant ni le répertoire parent)

Comment corriger : rien dans aucun document de catalogue ne produit cette valeur, il n’y a donc rien à corriger dans vos propres fichiers — elle provient du plugin qui sert le fournisseur. Signalez-la à l’éditeur de ce plugin, en citant la valeur que nomme le message. Lorsque le plugin est le vôtre, déclarez un nom de répertoire unique, ou n’en déclarez aucun et laissez chaque contributeur se trouver dans le répertoire de déploiement.

A boundary-scope Feature is attached only to a component (Une Feature de portée frontière n’est rattachée qu’à un composant)

Une FeatureRecipe peut déclarer qu’elle génère une seule fois pour une frontière plutôt qu’une fois pour chaque composant — une ressource partagée pour tout ce que contient la frontière, au lieu d’une par composant. La frontière est donc l’endroit où un tel rattachement doit être écrit : un rattachement de ce nom écrit uniquement sur un composant ne nomme aucune portée pour laquelle la recette pourrait générer, de sorte que rien ne décide sur quelle frontière il s’exécuterait, quelles valeurs il lirait, ni où sa sortie serait écrite.

L’écrire aussi sur un composant est courant et n’est pas signalé. Un rattachement déclaré sur une frontière atteint chaque composant que contient cette frontière, y compris ceux des portées imbriquées à l’intérieur, de sorte que le porter est la forme normale. Ce qui est vérifié, c’est si la portée propre au composant, ou une portée qui l’englobe, déclare le nom — la recherche progresse vers l’extérieur depuis l’endroit où se trouve le composant et s’arrête à la première portée qui le déclare. Un composant qui reprend sur lui-même un rattachement que sa portée englobante déclare déjà effectue son rendu exactement comme la forme déclarée sur la seule portée, et il est admis pour la même raison.

Un composant placé dans aucune portée n’a rien à parcourir, de sorte qu’un rattachement de portée frontière sur lui est signalé ici — ce qui est la lecture honnête, puisqu’il n’existe aucune portée pour laquelle une telle recette pourrait générer.

Message émis, qui nomme le rattachement et la portée dans laquelle se trouve le composant :

attachment binds a FeatureRecipe with executionScope: boundary and no boundary holding the component declares it ("<attachment>", on a component in boundary "<boundary>") (le rattachement lie une FeatureRecipe avec executionScope: boundary et aucune frontière contenant le composant ne le déclare (avec le rattachement indiqué, sur un composant dans la frontière indiquée))

et, pour un composant dans aucune portée, qui ne fournit aucune valeur de ce type :

attachment binds a FeatureRecipe with executionScope: boundary and no boundary holding the component declares it ("<attachment>") (le rattachement lie une FeatureRecipe avec executionScope: boundary et aucune frontière contenant le composant ne le déclare (avec le rattachement indiqué))

Comment corriger : déclarez le rattachement sous features: sur la frontière pour laquelle il doit générer — la portée dans laquelle se trouve le composant, ou une portée qui l’englobe — plutôt que seulement sur le composant. Si vous vouliez une génération par composant, rattachez plutôt une Feature dont la FeatureRecipe ne déclare pas la portée frontière.

The sandbox refused a plugin (Le bac à sable a refusé un plugin)

Chaque plugin signale ce qu’il est et ce dont il a besoin avant d’être autorisé à effectuer le moindre travail, et le bac à sable lit ce signalement au regard de ce qu’il est disposé à accorder. Cette condition couvre toute la classe de signalements que le bac à sable n’accepte pas, et la phrase indique quelle partie a été refusée : une version de l’interface des plugins que l’hôte ne parle pas, un type de plugin pour lequel l’hôte n’a pas de vocabulaire, un plugin demandant un accès réseau sortant ou un accès au système de fichiers, un plugin nommant un appel hôte hors de l’ensemble que l’hôte offre ou important depuis un espace de noms hors de l’ensemble qu’il admet, un export manquant ou mal formé, un champ portant une valeur hors de l’ensemble auquel il est restreint, ou une autodéclaration qui n’est pas lisible du tout.

Le refus a lieu avant que le plugin ne s’exécute, et un plugin refusé est arrêté avant que l’échec ne se propage, de sorte que rien de ce qu’il a demandé n’est accordé, même brièvement.

Une partie de ce qu’un plugin ne peut pas avoir n’est pas vérifiée ici, parce qu’elle n’est jamais accordée. L’hôte donne à un invité une horloge figée, aucun système de fichiers, aucun environnement et aucun endroit où sa propre sortie pourrait aller, de sorte qu’un invité qui tente d’atteindre l’un d’eux échoue lors de la tentative plutôt que d’être refusé d’emblée. Ce que couvre cette condition, c’est le signalement que le plugin fait de lui-même, vérifié avant son démarrage.

Messages émis. La phrase de la condition clôt chacun d’eux, et ce qui la précède nomme le plugin et la partie de son signalement qui a été refusée. Une version d’interface que l’hôte ne parle pas :

plugin "<plugin>" declares abi_version "<declared>"; host speaks "<supported>": wasm: plugin rejected by the sandbox (le plugin indiqué déclare l’abi_version indiquée ; l’hôte parle la version prise en charge indiquée : wasm : plugin refusé par le bac à sable)

un type de plugin pour lequel l’hôte n’a pas de vocabulaire :

plugin "<plugin>" declares unknown plugin_type "<declared>": wasm: plugin rejected by the sandbox (le plugin indiqué déclare un plugin_type inconnu, celui indiqué : wasm : plugin refusé par le bac à sable)

une autodéclaration qui ne peut pas être lue :

wasm: plugin "<plugin>" describe() output is not valid JSON: <what the read reported>: wasm: plugin rejected by the sandbox (wasm : la sortie de describe() du plugin indiqué n’est pas du JSON valide : avec le résultat indiqué de la lecture : wasm : plugin refusé par le bac à sable)

un plugin auquel manque l’export qu’exige son type, nommé à partir du même registre que celui d’où le type lui-même est lu :

<kind> plugin "<plugin>" declares no "<export>" export: wasm: plugin rejected by the sandbox (le plugin indiqué, du type indiqué, ne déclare pas l’export indiqué : wasm : plugin refusé par le bac à sable)

un champ restreint à un ensemble fixe qui porte autre chose — la même forme couvre le mode d’assemblage, ainsi que les champs operates et scope de chaque export :

plugin "<plugin>" export "<export>" declares unknown scope "<declared>" (want "own", "host", or empty): wasm: plugin rejected by the sandbox (l’export indiqué du plugin indiqué déclare une portée inconnue, celle indiquée (attendu : l’une des valeurs indiquées, ou vide) : wasm : plugin refusé par le bac à sable)

une capacité appariée déclarée sans ses deux exports, ou les exports sans la revendication :

plugin "<plugin>" declares the cross-boundary linking capability but does not export both "link_publish" and "link_resolve": wasm: plugin rejected by the sandbox (le plugin indiqué déclare la capacité de liaison entre frontières mais n’exporte pas les deux exports indiqués : wasm : plugin refusé par le bac à sable)

un nom de capacité qu’une Recipe ne pourrait jamais sélectionner — un fournisseur servant un nom qui contient un deux-points, ou une étape de pipeline compatible avec un tel nom — parce que le capability: d’une Recipe est lu comme le nom jusqu’à son dernier deux-points, suivi d’un épinglage de version. Le parse:<format> d’un parser et l’import:<format> d’un importateur ne sont pas refusés : le deux-points fait partie de ces noms, et ils sont recherchés par format plutôt que par l’intermédiaire d’une Recipe. Le même refus empêche que l’entité d’un tel plugin soit générée pour publication :

plugin "<plugin>" (plugin_type "provider") serves the capability "<name>", which contains a colon; a Recipe’s capability reference is read as the capability up to its last colon and a version pin after it, so no Recipe can name "<name>": report the capability name without a colon: wasm: plugin rejected by the sandbox (le plugin indiqué (avec le plugin_type indiqué) sert la capacité indiquée, qui contient un deux-points ; la référence de capacité d’une Recipe est lue comme la capacité jusqu’à son dernier deux-points, suivie d’un épinglage de version, de sorte qu’aucune Recipe ne peut nommer cette capacité : signalez le nom de la capacité sans deux-points : wasm : plugin refusé par le bac à sable)

et les appels hôtes qu’un plugin revendique au regard de ceux que son binaire utilise réellement, ce qui est vérifié dans les deux sens, de sorte qu’un plugin ne peut ni annoncer une surface qu’il n’utilise pas, ni en cacher une qu’il utilise :

plugin "<plugin>" declares host function "<name>" in describe() that its wasm does not import: wasm: plugin rejected by the sandbox (le plugin indiqué déclare dans describe() la fonction hôte indiquée, que son wasm n’importe pas : wasm : plugin refusé par le bac à sable) plugin "<plugin>" imports host function "<name>" that its describe() does not declare: wasm: plugin rejected by the sandbox (le plugin indiqué importe la fonction hôte indiquée, que son describe() ne déclare pas : wasm : plugin refusé par le bac à sable)

Comment corriger : rien dans vos fichiers d’entités n’en est la cause, et aucune modification de rédaction ne le lève — le signalement refusé est celui du plugin lui-même. Si vous consommez un plugin publié, signalez le message à son éditeur et, en attendant, sélectionnez une version que l’hôte accepte. Si le plugin est le vôtre, le message nomme le champ et les deux valeurs, de sorte que la correction est celle qu’indique la phrase : parlez la version d’interface que parle l’hôte, déclarez un type qu’il connaît, gardez chaque champ dans l’ensemble auquel il est restreint, déclarez l’export qu’exige votre type, et déclarez exactement les appels hôtes qu’utilise votre binaire — ni plus, ni moins.

A plugin is not the kind of plugin the socket expects (Un plugin n’est pas du type de plugin qu’attend le socket)

Chaque point de rattachement indique vers quel type de plugin il achemine, et chaque plugin signale son propre type. Cette condition est ce que signale un désaccord entre les deux : un plugin qui sert un fournisseur rattaché là où un linter est attendu, un parser rattaché là où un importateur est attendu, un plugin qui n’est pas une commande de terminal exécuté comme tel. La vérification a lieu au chargement du plugin, de sorte qu’un plugin du mauvais type n’atteint jamais le travail qu’on lui aurait demandé de faire.

La raison pour laquelle elle s’arrête plutôt que d’essayer malgré tout est que les types ne partagent pas d’interface. Un plugin d’un autre type serait appelé par des exports qu’il n’a pas, et ce qui reviendrait serait lu au regard d’une structure qu’il n’a jamais produite.

La lecture de l’autodéclaration d’un plugin sans affirmer de type n’est pas concernée. Une surface qui veut seulement savoir ce qu’un plugin dit de lui-même — lister ce qui est configuré, générer une entité pour un plugin — n’exprime aucune attente, et cette vérification y est sautée.

Message émis, qui nomme le plugin et les deux types, le type attendu étant donné en toutes lettres ainsi que par sa valeur déclarée :

wasm: plugin "<plugin>": expected a <kind in words> plugin (plugin type "<expected>") but its describe() reports plugin type "<reported>": wasm: declared plugin type does not match plugin describe() (wasm : le plugin indiqué : un plugin du type indiqué en toutes lettres était attendu (avec le type de plugin attendu indiqué), mais son describe() signale le type de plugin indiqué : wasm : le type de plugin déclaré ne correspond pas au describe() du plugin)

Comment corriger : rattachez un plugin du type qu’accepte le point de rattachement — le message nomme le type attendu. Si le plugin est bien celui que vous vouliez, le rattachement n’est pas au bon endroit : déplacez-le vers la surface à laquelle appartient son type. Si vous rédigez le plugin et qu’il devrait être du type attendu, il signale le mauvais type sur lui-même, et c’est une correction à apporter au plugin plutôt qu’à la configuration qui le rattache.

A plugin failed while it was running (Un plugin a échoué pendant son exécution)

Un plugin à qui l’on a demandé de faire quelque chose n’est pas revenu avec un résultat. Trois conditions couvrent ce cas, et ce qui les distingue est uniquement la manière dont l’échec s’est propagé — un plugin qui a planté, un plugin qui a arrêté sa propre exécution, et un plugin qui s’est exécuté jusqu’au bout et a signalé qu’il ne pouvait pas faire ce qui était demandé. Elles forment délibérément une seule taxonomie, afin qu’une build traite de la même façon toutes les manières dont un plugin peut échouer.

Un plugin qui a planté. La plupart des fautes à l’intérieur d’un plugin — une instruction inatteignable, une division par zéro, une lecture hors de sa mémoire — sont transformées en échecs ordinaires à la sortie et n’atteignent jamais cette condition. Elle est le filet derrière ce chemin, pour un plantage qui lui échappe.

Un plugin qui a arrêté sa propre exécution. Un plugin qui demande à se terminer fait quelque chose dont le modèle des plugins n’a pas l’usage : un plugin renvoie son résultat par l’appel avec lequel il a été invoqué, et non en se terminant. Sa propre exécution s’arrête ; le processus de la build n’est pas touché.

Un plugin qui a signalé un échec. L’enveloppe de résultat qu’un plugin renvoie comporte un emplacement où il peut dire qu’il n’a pas pu aller au bout, et un message qui le dit est transmis comme un échec plutôt que lu comme un résultat.

Messages émis, chacun nommant le plugin ou l’export et portant ce que l’échec a fourni. Un plantage porte la valeur récupérée :

wasm: guest plugin "<plugin>" panicked in <export>: <the recovered value>: wasm: guest plugin panicked during call (wasm : le plugin invité indiqué a paniqué dans l’export indiqué : avec la valeur récupérée indiquée : wasm : le plugin invité a paniqué pendant l’appel)

un plugin qui s’est arrêté de lui-même porte le code avec lequel il s’est arrêté :

wasm: plugin "<plugin>" call to <export> invoked proc_exit(<code>): wasm: plugin invoked proc_exit (wasm : l’appel du plugin indiqué à l’export indiqué a invoqué proc_exit avec le code indiqué : wasm : le plugin a invoqué proc_exit)

et un échec signalé porte le message propre au plugin :

call "<export>": wasm: guest plugin reported an error: <the plugin's message> (appel de l’export indiqué : wasm : le plugin invité a signalé une erreur : avec le message du plugin indiqué)

Comment corriger : rien dans vos fichiers d’entités n’est la cause d’aucune des trois, et aucune modification de rédaction ne les lève — chacune est une faute à l’intérieur du plugin. Signalez le message à l’éditeur du plugin, en nommant l’export qu’il identifie, et épinglez le plugin à une version qui fonctionnait pendant sa correction. Si le plugin est le vôtre : renvoyez un échec dans l’enveloppe de résultat plutôt que de planter ou de quitter, afin que la build reçoive un message qu’elle peut afficher ; et lorsque l’échec signalé est la réponse réfléchie du plugin lui-même, son message est ce que verra un lecteur, il vaut donc la peine de dire ce que, dans l’entrée, il n’a pas pu accepter.

A plugin returned something that is not the shape the socket reads (Un plugin a renvoyé quelque chose qui n’a pas la structure que lit le socket)

Chaque point de rattachement lit le résultat qu’il reçoit en retour au regard de la structure qu’il attend, et refuse tout le reste — un champ que la structure ne déclare pas, un champ dont la valeur n’est pas du type déclaré pour lui, ou des octets qui ne forment pas du tout un résultat bien formé.

Il refuse plutôt que de lire ce qu’il peut, et la raison en est que lire ce qu’il peut se ferait en silence. L’export qu’appelle un rattachement peut être choisi pour chaque rattachement, de sorte qu’un rattachement peut nommer un export dont le résultat a une structure entièrement différente. Sauter les parties qui ne correspondent pas donne un résultat vide — et un résultat vide est en soi une réponse légitime : aucun verdict renvoyé, aucun constat soulevé. Les deux seraient alors indiscernables, et une build continuerait exactement comme si le plugin l’avait approuvée.

Message émis, qui nomme l’export d’où est revenu le résultat et porte la raison de l’échec de la lecture — ensemble, ils identifient l’export que le rattachement aurait dû nommer :

call "<export>": wasm: guest plugin returned an output that is not the shape the socket reads: <what could not be read> (appel de l’export indiqué : wasm : le plugin invité a renvoyé une sortie qui n’a pas la structure que lit le socket : avec ce qui n’a pas pu être lu, indiqué)

Comment corriger : vérifiez la fonction d’entrée que nomme le rattachement au regard des exports que déclare le plugin — un rattachement pointé vers le mauvais export est la cause courante, et la raison dans le message nomme le champ qui n’a pas sa place. Si l’export est le bon, le plugin renvoie une structure que le point de rattachement ne lit pas, ce qui est une correction à apporter au plugin ; signalez-le à l’éditeur du plugin, en citant à la fois l’export et la raison.

A plugin returned a diagnostic at a severity that is not declared (Un plugin a renvoyé un diagnostic d’une gravité qui n’est pas déclarée)

Un plugin peut renvoyer des observations en même temps que son résultat, et chacune porte une gravité tirée d’un ensemble fermé : l’une arrête la build et nomme ce qu’il faut corriger, une autre est affichée à côté d’une build qui se termine tout de même, et la dernière enregistre l’observation et ne change rien. Une gravité hors de cet ensemble est une gravité pour laquelle l’hôte n’a aucun acheminement, et la build s’arrête.

Il refuse plutôt que de choisir un acheminement, et les deux alternatives sont pires. Passer outre une observation qu’il ne peut pas acheminer reviendrait à la traiter comme s’il n’y avait rien à faire — ce qui, lorsque le plugin décide s’il accepte la build, se lit comme une approbation : une objection soulevée par le plugin laisserait passer la build sans jamais être affichée. La traiter comme la gravité qui arrête la build rejetterait une build sur une valeur que personne n’a choisie. Les deux se font en silence, de sorte que l’hôte dit que la valeur est erronée et que c’est le plugin qui est corrigé.

La vérification s’exécute une seule fois, là où le résultat est lu, plutôt qu’à chaque endroit où une observation est affichée par la suite — c’est aussi le seul point où l’identité du plugin est encore à portée de main, puisqu’une observation intégrée à un signalement ne sait plus quel plugin l’a soulevée.

Message émis, qui nomme le plugin, l’export, l’observation fautive, sa valeur et les valeurs déclarées :

plugin "<plugin>" call "<export>": wasm: guest plugin returned a diagnostic whose severity the contract does not declare: diagnostic <index> has severity "<value>"; the declared severities are "halt", "warn" and "info" (appel de l’export indiqué du plugin indiqué : wasm : le plugin invité a renvoyé un diagnostic dont le contrat ne déclare pas la gravité : le diagnostic à l’index indiqué a la gravité indiquée ; les gravités déclarées sont les trois indiquées)

Comment corriger : rien dans vos fichiers d’entités n’en est la cause — la valeur provient du plugin. Signalez-la à l’éditeur du plugin, en citant la valeur que nomme le message. Si le plugin est le vôtre, émettez l’une des trois gravités déclarées ; le message les nomme, et l’index vous indique quelle observation examiner.

A provider returned two output files under one path (Un fournisseur a renvoyé deux fichiers de sortie sous un même chemin)

Un fournisseur renvoie sa sortie sous la forme d’une liste de fichiers, chacun nommant le chemin auquel il est écrit. L’hôte les collecte indexés par chemin et écrit les octets de chaque fichier tels quels, sans exécuter de sérialiseur qui lui soit propre. Deux fichiers nommant le même chemin laissent cette collection avec deux valeurs pour une seule clé.

Il refuse plutôt que d’en choisir un, parce qu’aucun des deux choix ne peut être distingué de l’autre après coup. Garder le dernier écarte un fichier que le fournisseur a demandé d’écrire ; garder le premier en écarte un ultérieur. Dans les deux cas, la sortie sur disque est bien formée et compte un fichier de moins, sans que rien n’enregistre qu’un fichier a été écarté — et le chemin qui a survécu est celui qui aurait survécu de toute façon, de sorte que rien dans le résultat n’indique qu’une collision a eu lieu. Lequel des deux était voulu est une question à laquelle seul le fournisseur peut répondre.

Elle est levée partout où un fournisseur renvoie des fichiers : lors du rendu d’un nœud, et lors de l’assemblage de la sortie d’un groupe d’acheminement en un seul artefact. La condition et la correction sont les mêmes dans les deux cas, donc les deux la signalent.

Message émis, qui nomme le chemin renvoyé deux fois et le nœud ou le chemin d’acheminement pour lequel il a été renvoyé :

provider guest returned two output files under one path; a conforming guest returns each output path at most once (path "<path>", node "<node>") (l’invité fournisseur a renvoyé deux fichiers de sortie sous un même chemin ; un invité conforme renvoie chaque chemin de sortie au plus une fois (avec le chemin et le nœud indiqués))

Comment corriger : rien dans vos fichiers d’entités n’en est la cause — les chemins proviennent du fournisseur. Signalez-le à son éditeur, en citant le chemin que nomme le message. Si le fournisseur est le vôtre, renvoyez chaque chemin de sortie au plus une fois : construisez la liste des chemins au regard d’un ensemble, de sorte qu’un second fichier sur un même chemin soit intercepté là où il est produit, et donnez au second fichier un chemin distinct si les deux sont voulus.

A provider reported a render fact whose value is not a list (Un fournisseur a signalé un fait de rendu dont la valeur n’est pas une liste)

Un fournisseur peut signaler, à côté de ses fichiers, des faits sur la sortie dont il a effectué le rendu — un nom et une valeur chacun, dans le vocabulaire documenté propre à ce fournisseur — et les Features rattachées à un composant les lisent depuis leurs templates. La valeur de chaque fait est une liste, même lorsqu’elle ne contient qu’une entrée : un même nom peut être signalé par plus d’un rendu d’un composant, les appels à son propre fournisseur et les rendus des Features qui lui sont rattachées, et les listes sont réunies en une seule sous ce nom pour les templates qui le lisent. Un fournisseur ne peut pas savoir, au moment du rendu, si son signalement sera le seul sous un nom, de sorte qu’une valeur qui est un objet, une chaîne, un nombre, un booléen ou null est refusée là où le fournisseur la remet, pour chaque rendu, qu’un template lise ou non le fait.

Message émis, qui nomme le fait, le nœud pour lequel il a été signalé, le fournisseur qui l’a signalé et la nature de la valeur :

provider guest reported a render fact whose value is not a list; a conforming guest reports every render fact’s value as a JSON array, even with one entry (fact "<fact>", node "<node>", provider "<provider>", its value is <kind>) (l’invité fournisseur a signalé un fait de rendu dont la valeur n’est pas une liste ; un invité conforme signale la valeur de chaque fait de rendu sous forme de tableau JSON, même avec une seule entrée (avec le fait, le nœud et le fournisseur indiqués ; sa valeur est de la nature indiquée))

Comment corriger : rien dans vos fichiers d’entités n’en est la cause — la valeur provient du fournisseur. Signalez-le à son éditeur, en citant le fait que nomme le message. Si le fournisseur est le vôtre, signalez la valeur de ce fait sous forme de tableau JSON — un objet seul devient une liste contenant cet objet — et documentez-le comme une liste dans les faits que signale votre fournisseur ; voir Signaler des faits sur ce qu’un invité a émis.

Lorsqu’une connexion passe d’un groupe d’acheminement à un autre, le fournisseur de chaque côté est invité à la câbler : l’extrémité consommée publie une identité, l’extrémité consommatrice se résout au regard de celle-ci, et chacune peut renvoyer un câblage structurel à appliquer à la sortie de son propre groupe. Chaque élément de câblage nomme le fichier de sortie auquel il s’applique. Une passe ultérieure découpe ce fichier, applique les opérations et le réassemble fidèlement à l’octet près.

Un nom qui ne correspond à aucun fichier émis ne laisse rien à découper à cette passe, et elle refuse plutôt que de passer outre le câblage. Les opérations qu’il porte sont ce qui résout la connexion, de sorte que les écarter laisse une sortie assemblée qui référence une extrémité que rien n’a câblée — ce qui échoue au moment du déploiement, loin du fournisseur qui l’a causé, et ressemble à une erreur dans la connexion plutôt que dans le câblage.

Les fichiers qu’un élément de câblage peut nommer sont les fichiers que le rendu propre de ce groupe a renvoyés. Ils sont remis au fournisseur lors du même appel, de sorte que le fournisseur n’a jamais à deviner un nom : il en choisit un dans l’ensemble qu’il a reçu.

Message émis, qui nomme le fichier demandé par le câblage et l’extrémité pour laquelle il a été renvoyé :

link patch names an output file the dispatch group did not emit; a conforming link patch names a file the group’s own render returned (file "<file>", node "<node>") (le patch de lien nomme un fichier de sortie que le groupe d’acheminement n’a pas émis ; un patch de lien conforme nomme un fichier que le rendu propre du groupe a renvoyé (avec le fichier et le nœud indiqués))

Comment corriger : rien dans vos fichiers d’entités n’en est la cause — le nom provient du fournisseur. Signalez-le à son éditeur, en citant le fichier que nomme le message. Si le fournisseur est le vôtre, prenez le nom du fichier parmi les fichiers assemblés que l’appel vous remet plutôt que d’un nom construit indépendamment — un chemin composé à la main devient obsolète dès que change le rendu qui le produit, et voici à quoi cela ressemble.

A pipeline step’s file emission carries no file (L’émission de fichier d’une étape de pipeline ne porte aucun fichier)

Une étape de pipeline peut émettre un nouveau document à côté de ceux qu’elle patche. Chaque émission déclare son type, et une émission de type fichier porte le fichier qu’elle écrit : le chemin et le contenu.

Ici, le type est correct et le fichier est absent, de sorte que l’étape a déclaré une intention que sa réponse ne réalise pas. C’est la différence entre cet arrêt et l’arrêt pour un type non défini plus bas : l’hôte sait exactement quoi faire d’une émission emit_file et n’a rien sur quoi le faire.

Il refuse plutôt que de ne rien émettre, parce qu’une émission qui ne fournirait silencieusement aucun fichier serait invisible. Une étape qui émet un document est souvent toute la raison de sa présence dans le pipeline, et sa sortie est un fichier qui n’existait pas auparavant — une build qui la sauterait produirait donc une sortie à laquelle manque un document, tandis que l’étape signale qu’elle s’est exécutée.

Message émis, qui nomme le nœud et celle des émissions de l’étape qui était fautive :

emit_file side effect carries no file; a conforming emit_file side effect carries a file with its path and content (node "<node>", side effect <index>) (l’effet de bord emit_file ne porte aucun fichier ; un effet de bord emit_file conforme porte un fichier avec son chemin et son contenu (avec le nœud et l’index de l’effet de bord indiqués))

Comment corriger : rien dans vos fichiers d’entités n’en est la cause — la réponse provient du plugin. Signalez-le à l’éditeur du plugin, en citant l’index que nomme le message. Si le plugin est le vôtre, renseignez le membre fichier de chaque émission emit_file, avec son chemin et son contenu ; l’index indique quelle émission de la réponse de cette étape examiner.

A pipeline step declares an emission kind the contract does not define (Une étape de pipeline déclare un type d’émission que le contrat ne définit pas)

Chaque émission que renvoie une étape de pipeline déclare son type, et le contrat en définit deux : l’un écrit un fichier, l’autre fournit un document de ressource personnalisée. Le type est une chaîne ouverte dans le format d’échange, ce qui permet d’ajouter un type ultérieur sans casser les plugins existants.

Cette ouverture est précisément la raison pour laquelle un type non défini est refusé plutôt qu’ignoré. Une valeur que l’hôte ne définit pas ne peut pas être distinguée, par sa seule structure, d’une valeur qu’une version ultérieure définira — un hôte qui la sauterait écarterait donc silencieusement ce que l’étape voulait dire par là, à chaque build, tandis que l’étape signale un succès. Refuser garde le point d’extension ouvert sans en faire une brèche : un type que cette build ne définit pas est signalé comme non défini, en citant la valeur envoyée par l’étape, plutôt qu’accepté et ignoré.

Message émis, qui nomme le nœud, l’émission fautive et le type qu’elle a déclaré :

side effect declares a kind the plugin contract does not define; a conforming side effect declares emit_file or emit_crd (node "<node>", side effect <index>, kind "<value>") (l’effet de bord déclare un type que le contrat des plugins ne définit pas ; un effet de bord conforme déclare emit_file ou emit_crd (avec le nœud, l’index de l’effet de bord et le type indiqués))

Comment corriger : rien dans vos fichiers d’entités n’en est la cause — la valeur provient du plugin. Signalez-la à l’éditeur du plugin, en citant le type que nomme le message. Si le plugin est le vôtre, déclarez l’un des types que liste le message ; une faute de frappe dans un type défini est la cause courante, et la valeur citée en retour est celle que vous avez envoyée.

A provider’s reassembly is handed a unit its own carve never produced (Le réassemblage d’un fournisseur reçoit une unité que son propre découpage n’a jamais produite)

Un fournisseur dont la forme de sortie ne peut pas être ciblée directement peut la découper lui-même : il divise un fichier de sortie en unités adressables, chacune sous un jeton, et les renvoie. Une étape de pipeline cible alors une unité par ce jeton, et le réassemblage réinsère les unités modifiées dans le fichier fidèlement à l’octet près. Les deux moitiés forment un seul contrat — les jetons sous lesquels un fichier est découpé sont les jetons que résout son réassemblage.

Lorsque le réassemblage reçoit un jeton que le découpage de ce même fichier n’a pas produit, il n’existe aucune plage d’octets où le contenu modifié puisse revenir. Il refuse plutôt que d’écarter l’unité, parce qu’une unité écartée donne un fichier bien formé auquel manque une modification qu’une étape devait apporter : rien n’a échoué, rien n’est malformé, et la modification est tout simplement absente.

Les deux moitiés ne peuvent diverger que là où elles sont séparées — un codec qui découpe lui-même et emprunte le réassemblage structurel standard pour le reste. Découper sous un ensemble de jetons et réassembler au regard d’un autre produit alors exactement ceci. Un codec qui possède les deux moitiés ne peut pas y parvenir : son propre réassemblage répond de ses propres jetons.

Message émis, qui nomme le jeton qui ne s’est résolu en rien et le fichier au regard duquel il a été nommé :

reassemble names a patched unit token the carve did not produce; a conforming codec carves and reassembles a file under the same tokens (token "<token>", file "<file>") (le réassemblage nomme un jeton d’unité patchée que le découpage n’a pas produit ; un codec conforme découpe et réassemble un fichier sous les mêmes jetons (avec le jeton et le fichier indiqués))

Comment corriger : rien dans vos fichiers d’entités n’en est la cause. Si le fournisseur est le vôtre, faites en sorte que les jetons que produit une moitié soient ceux que résout l’autre : dérivez-les une seule fois et transmettez-les, plutôt que de les dériver indépendamment de chaque côté, et lorsque le découpage réécrit un fichier avant de le diviser, réassemblez au regard de la même forme réécrite. Si le fournisseur n’est pas le vôtre, signalez-le à son éditeur, en citant le jeton que nomme le message.

A workload declares a form compose cannot express (Une charge de travail déclare une forme que compose ne peut pas exprimer)

Le fournisseur compose effectue le rendu de services de longue durée. Une charge de travail qui déclare s’exécuter en une copie par machine, s’exécuter selon une planification, ou s’exécuter une fois puis se terminer n’a pas d’équivalent propre sur une seule machine, de sorte que le rendu s’arrête plutôt que d’émettre un simple service — qui la démarrerait, la maintiendrait en marche et représenterait de façon inexacte ce qui était demandé.

Message émis. La condition nomme le genre d’échec — un fournisseur sans expression pour quelque chose que la build déclare — et la phrase propre au fournisseur nomme la forme qu’il a reçue :

a plugin has no expression for a construct this build declares (un plugin n’a aucune expression pour une construction que cette build déclare) compose: workload form "<form>" has no compose mapping; compose supports stateless and stateful only: compose cannot express this workload form (compose : la forme de charge de travail indiquée n’a aucune correspondance compose ; compose ne prend en charge que stateless et stateful : compose ne peut pas exprimer cette forme de charge de travail)

Comment corriger : lorsque la cible est réellement un environnement compose sur une seule machine, exprimez le travail sous la forme d’un service de longue durée — les formes stateless et stateful sont les deux dont il effectue le rendu. Si la forme est bien celle que vous vouliez, effectuez le rendu de cette frontière par un fournisseur dont la cible possède un équivalent : une copie par machine, une exécution planifiée et un job exécuté jusqu’à son terme ont tous des expressions directes ailleurs, et le choix du fournisseur relève de la frontière plutôt que de la charge de travail.

A container declares a field compose has no primitive for (Un conteneur déclare un champ pour lequel compose n’a pas de primitive)

Deux champs de conteneur n’ont pas d’équivalent compose, et tous deux arrêtent le rendu plutôt que d’être écartés.

Les hooks qui s’exécutent lorsqu’un conteneur démarre ou est sur le point de s’arrêter. compose n’a rien qui les exécute, et un hook qui n’est silencieusement pas exécuté est une surprise de correction qui apparaît à l’exécution plutôt qu’à la build.

L’environnement en bloc tiré d’un objet nommé. compose peut lire des variables depuis un fichier, mais une référence à un objet n’est pas un fichier — réinterpréter l’un comme l’autre changerait ce que reçoit le conteneur sans le dire.

Les deux sont vérifiés pour les conteneurs ordinaires et pour les conteneurs qui s’exécutent avant le conteneur principal, de sorte que le même champ provoque un arrêt partout où il est déclaré et que le message nomme le conteneur d’où il provient.

Messages émis. Les deux signalent la même condition — un fournisseur sans expression pour quelque chose que la build déclare — et c’est la phrase propre au fournisseur qui dit de quel champ il s’agit :

a plugin has no expression for a construct this build declares (un plugin n’a aucune expression pour une construction que cette build déclare) compose: node "<node>" container "<container>": compose: node "<node>" declares container lifecycle hooks; compose has no lifecycle-hook primitive: compose has no lifecycle-hook primitive; container declares lifecycle hooks (compose : dans le nœud et le conteneur indiqués : compose : le nœud indiqué déclare des hooks de cycle de vie de conteneur ; compose n’a pas de primitive de hook de cycle de vie : compose n’a pas de primitive de hook de cycle de vie ; le conteneur déclare des hooks de cycle de vie)

a plugin has no expression for a construct this build declares (un plugin n’a aucune expression pour une construction que cette build déclare) compose: node "<node>" container "<container>": compose: node "<node>" declares container envFrom; compose has no env-from-object primitive: compose has no env-from-object primitive; container declares envFrom (compose : dans le nœud et le conteneur indiqués : compose : le nœud indiqué déclare envFrom pour le conteneur ; compose n’a pas de primitive d’environnement depuis un objet : compose n’a pas de primitive d’environnement depuis un objet ; le conteneur déclare envFrom)

Comment corriger : pour une cible compose, supprimez le champ et faites son travail autrement — le travail de démarrage relève d’un conteneur qui s’exécute avant le conteneur principal, et le travail d’arrêt de la gestion des signaux propre au conteneur ; l’environnement en bloc peut être écrit sous forme de variables explicites, ou fourni depuis un fichier que la cible compose peut lire. Si le champ est bien celui que vous vouliez, effectuez le rendu de cette frontière par un fournisseur dont la cible possède la primitive.

An omits entry names a kind or a namespace a compose file does not have (Une entrée omits désigne un kind ou un namespace qu’un fichier compose n’a pas)

Une entrée omits: sur une Recipe ou une FeatureRecipe qui prend pour source un fichier compose laisse de côté une unité de premier niveau de ce fichier, et un fichier compose a exactement trois kinds qu’une entrée peut désigner — un service, un volume et un config, chacun indiqué par sa clé sous services:, volumes: ou configs: — et aucun namespace. Une entrée désignant tout autre kind, dont le Secret d’un document de chart ou un network compose, ou portant un namespace, ne désigne rien que le fichier puisse laisser de côté, de sorte que le rendu s’arrête plutôt que de traiter l’entrée comme une entrée qui ne correspondait à rien. Les kinds sont comparés exactement, de sorte que Service est refusé là où service est voulu. Chaque entrée est vérifiée avant que quoi que ce soit soit laissé de côté, et c’est la première en défaut, dans l’ordre où les entrées ont été écrites, qui est nommée.

Messages émis. Tous deux signalent la condition d’une construction pour laquelle un fournisseur n’a aucune expression, et la phrase propre au fournisseur nomme l’entrée et les kinds qu’il accepte. Un champ dont le template a lu une valeur déclarée sensible est affiché comme <redacted> :

a plugin has no expression for a construct this build declares (un plugin n’a aucune expression pour une construction que cette build déclare) compose: an omits entry (name "<name>") names kind "<kind>": compose leaves out a service, a volume or a config, each named by its key under services:, volumes: or configs:, and no other kind (compose : une entrée omits (avec le nom indiqué) désigne le kind indiqué : compose laisse de côté un service, un volume ou un config, chacun désigné par sa clé sous services:, volumes: ou configs:, et aucun autre kind)

a plugin has no expression for a construct this build declares (un plugin n’a aucune expression pour une construction que cette build déclare) compose: an omits entry (kind "<kind>", name "<name>") names namespace "<namespace>", and a compose file has no namespaces: compose leaves out a service, a volume or a config, each named by its key under services:, volumes: or configs:, and no other kind; remove the namespace from the entry (compose : une entrée omits (avec le kind et le nom indiqués) désigne le namespace indiqué, et un fichier compose n’a pas de namespace : compose laisse de côté un service, un volume ou un config, chacun désigné par sa clé sous services:, volumes: ou configs:, et aucun autre kind ; supprimez le namespace de l’entrée)

Comment corriger : désignez l’unité comme le fait le fichier compose — kind: service, volume ou config, et comme name: sa clé sous cette section — et retirez le namespace:. Voir compose → Mode avec source.

An omits entry names a namespace a CloudFormation template does not have (Une entrée omits désigne un namespace qu’un template CloudFormation n’a pas)

Une entrée omits: sur une Recipe ou une FeatureRecipe qui prend pour source un template CloudFormation laisse de côté une ressource, désignée par son Type comme kind de l’entrée et par son ID logique comme name de l’entrée. Un template n’a pas de namespace, de sorte qu’une entrée portant un namespace ne désigne rien qu’un template puisse laisser de côté, et le rendu s’arrête plutôt que de traiter l’entrée comme une entrée qui ne correspondait à rien. Chaque entrée est vérifiée avant que quoi que ce soit soit laissé de côté, et c’est la première portant un namespace, dans l’ordre où les entrées ont été écrites, qui est nommée.

Message émis. Il signale la condition d’une construction pour laquelle un fournisseur n’a aucune expression, et la phrase propre au fournisseur nomme l’entrée et ce que ce fournisseur laisse de côté. Un champ dont le template a lu une valeur déclarée sensible est affiché comme <redacted> :

a plugin has no expression for a construct this build declares (un plugin n’a aucune expression pour une construction que cette build déclare) cloudformation-provider: an omits entry (kind "<kind>", name "<name>") names namespace "<namespace>", and a CloudFormation template has no namespaces: cloudformation leaves out a resource, named by its Type as the entry’s kind and its logical ID under Resources as the entry’s name; remove the namespace from the entry (cloudformation-provider : une entrée omits (avec le kind et le nom indiqués) désigne le namespace indiqué, et un template CloudFormation n’a pas de namespace : cloudformation laisse de côté une ressource, désignée par son Type comme kind de l’entrée et par son ID logique sous Resources comme nom de l’entrée ; supprimez le namespace de l’entrée)

Comment corriger : retirez le namespace: de l’entrée, qui désigne la ressource par son seul Type et son ID logique. Voir cloudformation → Laisser des ressources hors d’un template source.

A published port declares a transport compose cannot spell (Un port publié déclare un transport que compose ne sait pas écrire)

Un port compose publié porte son transport sous forme de suffixe sur l’entrée, et ce suffixe a deux graphies. Un port déclarant tout autre transport n’a aucune graphie compose.

Le rendu s’arrête plutôt que de supprimer le suffixe, car un port publié qui se rabat silencieusement sur le transport par défaut démarre en transportant un trafic que ses clients ne peuvent pas atteindre — ce qui est exactement la défaillance que la déclaration d’un transport existe pour empêcher, réintroduite au moment de la traduction.

Un port qui ne déclare aucun transport n’est pas concerné. Il est publié sans suffixe, exactement comme le serait un port qui n’a jamais porté de transport.

Message émis. La condition nomme le type de défaillance — une valeur sans représentation dans ce que le fournisseur émet — et la phrase propre au fournisseur la suit :

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) compose: node "<node>" apply service ports: compose publishes a port’s transport as a tcp or udp suffix; this port declares a transport compose cannot express (compose : dans le nœud indiqué, application des ports du service : compose publie le transport d’un port sous forme de suffixe tcp ou udp ; ce port déclare un transport que compose ne peut pas exprimer)

Comment corriger : pour une cible compose, déclarez le transport du port comme l’un des deux que compose sait écrire, ou laissez-le non déclaré et laissez l’entrée être publiée sans suffixe. Si le transport est bien celui que vous vouliez, effectuez le rendu de cette frontière par un fournisseur dont la cible peut l’exprimer.

A resources quantity cannot be converted to a compose value (Une quantité de ressources ne peut pas être convertie en valeur compose)

Les quantités de processeur et de mémoire d’un conteneur, ainsi que son nombre nvidia.com/gpu, sont écrites dans la notation que Kubernetes utilise pour les ressources, et compose les porte dans des unités qui lui sont propres — un nombre de GPU devient le nombre d’une réservation de périphériques NVIDIA —, de sorte que chacune est lue comme une quantité et convertie à partir de sa valeur. Deux choses l’empêchent, et le message dit laquelle il a rencontrée : une valeur qui n’est pas du tout une quantité, et une quantité pour laquelle compose n’a pas de forme exacte — un montant négatif, un montant de mémoire qui n’est pas un nombre entier d’octets, un montant de processeur plus fin que neuf décimales d’un cœur, un nombre de GPU qui n’est pas un nombre entier de périphériques, ou un montant au-delà du plus grand que compose peut contenir. Un conteneur dont la requête et la limite nvidia.com/gpu demandent des nombres différents arrête aussi le rendu, car compose réserve un seul nombre pour un service. Le rendu s’arrête plutôt que d’arrondir la valeur ou d’émettre une approximation, car une limite qui n’est silencieusement pas la limite demandée est le genre de différence que personne ne cherche jusqu’à ce que quelque chose soit arrêté pour l’avoir dépassée.

Messages émis. Chacun s’ouvre sur la condition — une valeur sans représentation dans ce que le fournisseur émet —, puis nomme la ressource, indique si la valeur est une requête ou une limite, son chemin dans le Workload et la valeur. Une valeur qui n’est pas une quantité est suivie de ce qui l’a empêchée d’en être une et de la forme que prend une quantité :

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) compose: node "<node>" container "<container>": compose: the <cpu|memory|nvidia.com/gpu> <request|limit> at <path>: "<value>" is not a quantity: <reason>; a quantity is a number such as 2, 0.5 or 1.5, with an optional sign and at most one of an integer exponent (1e3, 5E-2) or a unit suffix (n, u, m, k, M, G, T, P, E, Ki, Mi, Gi, Ti, Pi, Ei): resources quantity cannot be converted to a compose deploy.resources value (compose : dans le nœud et le conteneur indiqués : compose : la requête ou la limite indiquée de la ressource indiquée, au chemin indiqué : la valeur indiquée n’est pas une quantité : avec la raison indiquée ; une quantité est un nombre tel que 2, 0.5 ou 1.5, avec un signe facultatif et au plus un exposant entier (1e3, 5E-2) ou un suffixe d’unité (n, u, m, k, M, G, T, P, E, Ki, Mi, Gi, Ti, Pi, Ei) : la quantité resources ne peut pas être convertie en valeur deploy.resources de compose)

Une quantité que compose ne peut pas représenter est suivie de la plage que compose admet pour cette ressource :

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) compose: node "<node>" container "<container>": compose: the memory <request|limit> at <path> is "<value>", a quantity compose cannot represent exactly; a compose memory value is a whole number of bytes from 0 to 9223372036854775807: resources quantity cannot be converted to a compose deploy.resources value (compose : dans le nœud et le conteneur indiqués : compose : la requête ou la limite de mémoire indiquée, au chemin indiqué, est la valeur indiquée, une quantité que compose ne peut pas représenter exactement ; une valeur de mémoire compose est un nombre entier d’octets de 0 à 9223372036854775807 : la quantité resources ne peut pas être convertie en valeur deploy.resources de compose)

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) compose: node "<node>" container "<container>": compose: the cpu <request|limit> at <path> is "<value>", a quantity compose cannot represent exactly; a compose cpus value is a core count from 0 to 9223372036.854775807 with at most nine decimal places: resources quantity cannot be converted to a compose deploy.resources value (compose : dans le nœud et le conteneur indiqués : compose : la requête ou la limite cpu indiquée, au chemin indiqué, est la valeur indiquée, une quantité que compose ne peut pas représenter exactement ; une valeur cpus de compose est un nombre de cœurs de 0 à 9223372036.854775807 avec au plus neuf décimales : la quantité resources ne peut pas être convertie en valeur deploy.resources de compose)

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) compose: node "<node>" container "<container>": compose: the nvidia.com/gpu <request|limit> at <path> is "<value>", a quantity compose cannot represent exactly; a compose device count is a whole number of devices from 0 to 9223372036854775807: resources quantity cannot be converted to a compose deploy.resources value (compose : dans le nœud et le conteneur indiqués : compose : la requête ou la limite nvidia.com/gpu indiquée, au chemin indiqué, est la valeur indiquée, une quantité que compose ne peut pas représenter exactement ; un nombre de périphériques compose est un nombre entier de périphériques de 0 à 9223372036854775807 : la quantité resources ne peut pas être convertie en valeur deploy.resources de compose)

Une requête et une limite de GPU qui demandent des nombres différents nomment les deux chemins et les deux nombres :

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) compose: node "<node>" container "<container>": compose: the nvidia.com/gpu request at <path> and the limit at <path> ask for different counts (<request> and <limit>); compose reserves one device count for a service, so write the same count in both or only the limit: resources quantity cannot be converted to a compose deploy.resources value (compose : dans le nœud et le conteneur indiqués : compose : la requête nvidia.com/gpu au chemin indiqué et la limite au chemin indiqué demandent des nombres différents (ceux indiqués) ; compose réserve un seul nombre de périphériques pour un service, écrivez donc le même nombre dans les deux ou seulement la limite : la quantité resources ne peut pas être convertie en valeur deploy.resources de compose)

Lorsque le template du Workload lit une valeur qu’un auteur a déclarée sensible, aucun message ne cite la valeur qu’il a refusée, et les deux nombres sont omis de la même façon.

Comment corriger : lorsque la valeur n’est pas une quantité, écrivez-la sous la forme décrite dans Workload → Quantités de ressources ; un suffixe isolé tel que m est ce qu’un template laisse lorsque la valeur qu’il interpole est vide, de sorte que l’entrée à corriger est celle que le template a lue. Lorsqu’il s’agit d’une quantité que compose ne peut pas représenter, écrivez un montant dans la plage que le message indique — la mémoire comme un nombre entier d’octets dans n’importe quelle unité (1536Mi plutôt que 1.5001Gi), le temps processeur avec au plus neuf décimales d’un cœur, et un nombre de GPU comme un nombre entier de périphériques (1, et non 0.5 ou 500m). Lorsqu’une requête et une limite de GPU ne concordent pas, écrivez le même nombre dans les deux, ou écrivez seulement la limite, qui est le nombre que Kubernetes planifie pour le même Workload.

A resource quantity the helm provider emits is not a quantity (Une quantité de ressource que le fournisseur helm émet n’est pas une quantité)

Le fournisseur helm copie telle quelle chaque quantité de ressource dans les manifestes qu’il émet — les valeurs resources.requests et resources.limits de chaque conteneur et conteneur d’initialisation, ressources étendues comprises, et les ephemeral.sizeLimit, persistent.size et persistentTemplate.size de chaque volume — et vérifie d’abord chacune par rapport à la forme d’une quantité, sur le Workload tel que les templates de la Recipe l’ont évalué. Une valeur hors de cette forme arrête la build ici, là où elle se construirait autrement sans erreur et serait refusée par le cluster lors de l’installation du chart.

Message émis. Il s’ouvre sur la condition, puis nomme le nœud, le chemin du champ dans le Workload, la valeur et ce qui l’a empêchée d’être une quantité, et indique la forme que prend une quantité :

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) helm: node "<node>": <path>: "<value>" is not a quantity: <reason>; a quantity is a number such as 2, 0.5 or 1.5, with an optional sign and at most one of an integer exponent (1e3, 5E-2) or a unit suffix (n, u, m, k, M, G, T, P, E, Ki, Mi, Gi, Ti, Pi, Ei) (helm : dans le nœud indiqué : chemin indiqué : la valeur indiquée n’est pas une quantité : avec la raison indiquée ; une quantité est un nombre tel que 2, 0.5 ou 1.5, avec un signe facultatif et au plus un exposant entier (1e3, 5E-2) ou un suffixe d’unité (n, u, m, k, M, G, T, P, E, Ki, Mi, Gi, Ti, Pi, Ei))

Comment corriger : écrivez la valeur sous la forme décrite dans Workload → Quantités de ressources. Lorsque le champ est un template, la valeur à corriger est celle que le template a lue : un suffixe isolé tel que m ou Mi est ce qu’un template laisse lorsque la valeur qu’il interpole est vide, et un paramètre de la Release atteint le champ exactement tel qu’il a été écrit.

A service type the helm provider cannot render (Un type de service que le fournisseur helm ne peut pas rendre)

Le fournisseur helm effectue le rendu de chaque entrée services d’un Workload sous la forme d’un Service Kubernetes dont le type est le type de l’entrée. Une entrée Loopback demande que ses ports soient joignables depuis l’adresse de loopback propre à l’hôte et depuis nulle part ailleurs, et un Service Kubernetes n’a aucun type qui fasse cela : les adresses de nœud sur lesquelles écoute un Service NodePort sont un réglage de l’ensemble du cluster, et non d’un seul Service. La build s’arrête donc sur la première entrée Loopback, dans l’ordre où les services sont déclarés, avant qu’aucune ressource ne soit écrite.

La build s’arrête plutôt que d’effectuer le rendu de l’entrée sous un autre type, car chacun des types qu’un Service possède change ce que le port atteint : un Service ClusterIP abandonne la portée publiée que l’entrée demande, et un Service NodePort publie le port sur chaque adresse de nœud que le cluster autorise — l’exposition plus large que l’entrée existe pour éviter.

Message émis. Il s’ouvre sur la condition, puis nomme le nœud, le chemin du service dans le Workload et le type :

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) helm: node "<node>": services.<service>: type “Loopback” publishes the service’s ports on the host’s loopback address only, and a Kubernetes Service has no type that does; declare ClusterIP to keep the ports inside the cluster, or NodePort or LoadBalancer to publish them outside it (helm : dans le nœud indiqué : service indiqué sous services: le type « Loopback » publie les ports du service uniquement sur l’adresse de loopback de l’hôte, et un Service Kubernetes n’a aucun type qui le fasse ; déclarez ClusterIP pour garder les ports à l’intérieur du cluster, ou NodePort ou LoadBalancer pour les publier à l’extérieur)

Comment corriger : pour une cible helm, déclarez le type qui indique jusqu’où le port doit porter dans le cluster — ClusterIP pour le garder à l’intérieur, NodePort ou LoadBalancer pour le publier. Une entrée Loopback est destinée à une cible compose, qui publie le port sur 127.0.0.1 ; voir Workload → services.

A Kubernetes version the helm provider cannot render a chart for (Une version de Kubernetes pour laquelle le fournisseur helm ne peut pas effectuer le rendu d’un chart)

Le fournisseur helm effectue le rendu d’un chart depuis la source pour la version de Kubernetes que l’annotation aggrega.ai/kubernetes-version nomme sur un composant ou sur sa frontière, et lit la valeur de la façon dont helm template --kube-version lit son option. Une valeur que cette option refuserait — "one.two", "latest", un nombre seul tel que "1", un nombre écrit avec un zéro initial tel que "01.20" — n’a aucune version que le chart puisse lire comme .Capabilities.KubeVersion, de sorte que la build s’arrête avant que le rendu du chart ne soit effectué.

La build s’arrête plutôt que d’effectuer le rendu du chart pour la version par défaut, car un chart lit la version pour choisir une version d’API, un champ ou un mécanisme entier, et un chart rendu pour une version autre que celle que vous avez nommée émet la forme correspondant à cette autre version — une forme que le cluster sur lequel il est déployé peut ne pas exécuter.

Une valeur vide n’est pas refusée. Elle est traitée comme non définie, et le rendu du chart est effectué pour la version par défaut : celle pour laquelle le helm template standard de la même version de helm effectue le rendu.

Message émis. Il s’ouvre sur la condition, puis nomme le nœud et la frontière dans laquelle il est placé, l’annotation, la valeur et ce qui l’a empêchée d’être une version, et indique la forme à écrire :

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) helm: node "<node>" in boundary "<boundary>": annotation aggrega.ai/kubernetes-version: "<value>" is not a Kubernetes version a chart can be rendered for: <reason>; write the version of the cluster the chart deploys to, such as “1.31” or “v1.31.2”, on the component or on its boundary (helm : dans le nœud indiqué, dans la frontière indiquée : annotation aggrega.ai/kubernetes-version : la valeur indiquée n’est pas une version de Kubernetes pour laquelle le rendu d’un chart peut être effectué : avec la raison indiquée ; écrivez la version du cluster sur lequel le chart est déployé, telle que « 1.31 » ou « v1.31.2 », sur le composant ou sur sa frontière)

Le message nomme à la fois le nœud et sa frontière, car le fournisseur lit ensemble les annotations d’un composant et celles de sa frontière, la valeur propre au composant l’emportant, de sorte que la valeur peut avoir été écrite sur l’un ou sur l’autre.

Comment corriger : écrivez la version du cluster sur lequel le chart est déployé — une version majeure et mineure telle que "1.31", ou une version complète telle que "v1.31.2" — sur le composant ou sur sa frontière, ou supprimez l’annotation pour effectuer le rendu pour la version par défaut. Voir helm → La version de Kubernetes pour laquelle un chart est rendu.

A health probe cannot be turned into a compose healthcheck (Une sonde de santé ne peut pas être transformée en healthcheck compose)

Une sonde de santé déclarée devient un healthcheck compose, et deux choses peuvent l’empêcher.

Une sonde qui vérifie un chemin via HTTP, sur un conteneur qui ne publie aucun port. La vérification est construite comme une requête vers un port du conteneur, de sorte que sans port déclaré, il n’y a aucune adresse sur laquelle la construire.

Une sonde qui ne déclare aucun moyen de vérification — ni un chemin, ni un port auquel se connecter, ni une commande à exécuter. Il n’y a rien à transformer en vérification. Il s’agit d’une garde derrière le schéma plutôt que d’une forme que vous êtes susceptible d’écrire : on vérifie qu’une sonde possède l’un des trois avant qu’elle n’arrive ici.

Messages émis. Tous deux signalent la même condition — quelque chose dont le fournisseur a besoin et qu’il n’a pas pu résoudre en exactement une valeur — et la phrase propre au fournisseur dit laquelle :

a plugin could not resolve something it requires to exactly one value (un plugin n’a pas pu résoudre en exactement une valeur quelque chose dont il a besoin) compose: node "<node>" container "<container>": probe http: requires at least one container port; container declares none (compose : dans le nœud et le conteneur indiqués : sonde http : requiert au moins un port de conteneur ; le conteneur n’en déclare aucun)

a plugin could not resolve something it requires to exactly one value (un plugin n’a pas pu résoudre en exactement une valeur quelque chose dont il a besoin) compose: node "<node>" container "<container>": probe declares no shape (http/tcp/exec) (compose : dans le nœud et le conteneur indiqués : la sonde ne déclare aucune forme (http/tcp/exec))

Comment corriger : déclarez le port sur lequel la vérification doit être effectuée sur le même conteneur que la sonde — une sonde via HTTP lit le premier port du conteneur, donc le port doit exister pour que la vérification puisse être construite. Si le conteneur ne publie réellement rien, vérifiez-le d’une autre façon : une sonde qui exécute une commande n’a besoin d’aucun port. Pour une sonde sans moyen de vérification déclaré, donnez-lui l’un des trois.

A configmap volume has no file behind it (Un volume configmap n’a aucun fichier derrière lui)

Un volume qui monte de la configuration est fourni par le mécanisme propre à compose pour cela, référencé par son nom, et l’entrée qui contient le contenu provient d’un fichier que la Recipe émet. Cette condition est ce que signale une référence sans entrée correspondante : le fichier n’est pas là, de sorte que le montage existerait sans rien derrière lui et que le conteneur démarrerait en lisant un chemin vide.

La vérification porte sur l’ensemble de la sortie assemblée plutôt que composant par composant, et c’est délibéré : la référence et l’entrée qui contient le contenu arrivent par des voies différentes et peuvent provenir de composants différents du même groupe, de sorte que la sortie assemblée est le premier point où les deux sont présentes. Une vérification par composant refuserait une référence dont le contenu est fourni par un autre composant du même groupe.

Chaque référence non résolue est signalée, et pas seulement la première, dans un ordre stable, de sorte qu’une seule build les nomme toutes.

Message émis. La condition vient en tête, puis chaque service, la référence qu’il a faite et l’endroit où elle est montée :

a plugin could not resolve something it requires to exactly one value (un plugin n’a pas pu résoudre en exactement une valeur quelque chose dont il a besoin) compose AssembleBoundary: service "<service>" references config "<name>" mounted at "<path>"; declare each one as a top-level configs: entry from the Recipe’s artifacts: input: configmap volume requires a file emitted via the Recipe’s artifacts: input; none found (compose AssembleBoundary : le service indiqué référence la config indiquée, montée au chemin indiqué ; déclarez chacune comme entrée configs: de premier niveau à partir de l’entrée artifacts: de la Recipe : un volume configmap requiert un fichier émis via l’entrée artifacts: de la Recipe ; aucun trouvé)

Comment corriger : émettez le fichier depuis l’entrée artifacts: de la Recipe sous le nom que le volume référence — les deux sont appariés par ce nom, de sorte qu’un écart entre ce que le volume demande et ce que la Recipe émet est la cause courante. Si le contenu devait provenir d’ailleurs, le volume n’est pas le bon mécanisme pour cela : une valeur qui relève de l’environnement va plutôt là.

What an omits entry left out is still named by the compose file (Ce qu’une entrée omits a laissé de côté est encore nommé par le fichier compose)

Une entrée omits: laisse de côté un service, un volume ou un config d’un fichier compose source, et compose refuse un fichier qui en nomme un qu’il ne déclare pas. Ainsi, une fois les unités des entrées supprimées, chaque référence que le reste du fichier fait encore à l’une d’elles arrête le rendu : un service nommé par depends_on, links, volumes_from, extends, une valeur build.additional_contexts ou un mode réseau, IPC, PID ou UTS service: ; un volume nommé comme source d’une entrée volumes: ; un config nommé par une entrée configs: — lus dans chaque service, dans les hooks pre_start de chaque service et dans chaque job. La liste complète, et les valeurs qui ne font que ressembler à des références, se trouvent dans compose → Mode avec source.

La vérification lit le fichier propre à la Recipe ou à la FeatureRecipe qui déclare l’entrée, de sorte qu’elle arrête le rendu même lorsqu’un autre contributeur au même fichier assemblé déclare une unité portant le nom de celle laissée de côté. Chaque référence est signalée, et pas seulement la première — les services dans l’ordre des clés, puis les jobs, les hooks de chaque service après lui — de sorte qu’une seule build les nomme toutes.

Message émis. La condition vient en tête, puis chaque entrée qui fait référence, l’unité qu’elle nomme et le champ dans lequel se trouve la référence :

a plugin could not resolve something it requires to exactly one value (un plugin n’a pas pu résoudre en exactement une valeur quelque chose dont il a besoin) compose: what an omits entry left out is still named by the file: service "<service>" names <kind> "<name>" at <field>; compose refuses a file naming a service, a volume or a config it does not declare: leave out what names it as well, change the reference through valuesMapping, or remove the entry (compose : ce qu’une entrée omits a laissé de côté est encore nommé par le fichier : le service indiqué nomme l’unité du kind et du nom indiqués dans le champ indiqué ; compose refuse un fichier nommant un service, un volume ou un config qu’il ne déclare pas : laissez aussi de côté ce qui le nomme, modifiez la référence via valuesMapping, ou supprimez l’entrée)

Une unité dont le nom d’entrée a été construit à partir d’une valeur déclarée sensible est affichée comme <redacted>.

Comment corriger : décidez lequel des deux vous vouliez. Si le service qui fait référence a encore besoin de l’unité, conservez-la : supprimez l’entrée. Sinon, modifiez la référence via le valuesMapping: de la Recipe — une liste à cet endroit remplace la liste du fichier de base, donc depends_on: [] en vide une — ou laissez de côté le service qui fait référence avec une entrée qui lui est propre.

What an omits entry left out is still named by a CloudFormation template (Ce qu’une entrée omits a laissé de côté est encore nommé par un template CloudFormation)

Une entrée omits: laisse de côté une ressource d’un template CloudFormation source, et CloudFormation refuse un template qui nomme une ressource qu’il ne déclare pas. Ainsi, une fois les ressources des entrées supprimées, chaque référence que les templates restants font encore à l’une d’elles arrête le rendu : un Ref, un Fn::GetAtt sous sa forme de liste ou sa forme de chaîne à point, le DependsOn d’une ressource, ou une variable d’un Fn::Sub — lus n’importe où dans le corps de chaque ressource et de chaque sortie. La liste complète, et les valeurs qui ne font que ressembler à des références, se trouvent dans cloudformation → Laisser des ressources hors d’un template source.

La vérification lit ensemble les templates propres à la Recipe ou à la FeatureRecipe qui déclare l’entrée : une référence à un ID logique qu’un autre de ces templates déclare encore n’est pas arrêtée, tandis qu’une référence à une ressource laissée de côté arrête le rendu même lorsqu’un autre composant déclare une ressource portant cet ID logique. Chaque référence est signalée, et pas seulement la première — template par template dans l’ordre où la source les porte, pour chaque template ses ressources puis ses sorties dans l’ordre des clés — de sorte qu’une seule build les nomme toutes.

Message émis. La condition vient en tête, puis chaque référence : le template dans lequel elle se trouve, la ressource qu’elle nomme, la façon dont elle la nomme, et l’endroit où elle se situe sous forme de chemin depuis la racine du template :

a plugin could not resolve something it requires to exactly one value (un plugin n’a pas pu résoudre en exactement une valeur quelque chose dont il a besoin) cloudformation-provider: what an omits entry left out is still named by the source’s templates: template "<template>" names resource "<logical-id>" (type "<type>") by <Ref|Fn::GetAtt|DependsOn|Fn::Sub> at <path>; CloudFormation refuses a template naming a resource it does not declare: leave out what names it as well, or remove the entry (cloudformation-provider : ce qu’une entrée omits a laissé de côté est encore nommé par les templates de la source : le template indiqué nomme la ressource indiquée (du type indiqué) de la façon indiquée au chemin indiqué ; CloudFormation refuse un template nommant une ressource qu’il ne déclare pas : laissez aussi de côté ce qui la nomme, ou supprimez l’entrée)

Lorsque les champs d’une entrée ont été construits à partir d’une valeur déclarée sensible, l’ID logique et le type de sa ressource sont affichés comme <redacted>, de même que toute étape du chemin qui écrit cet ID logique.

Comment corriger : décidez lequel des deux vous vouliez. Si la ressource qui fait référence a encore besoin de celle laissée de côté, conservez-la : supprimez l’entrée. Sinon, laissez aussi de côté la ressource qui fait référence, avec une entrée qui lui est propre — une valeur liée à un paramètre ne remplace qu’une référence à ce paramètre, de sorte qu’une référence à une ressource ne peut pas être modifiée par ce moyen. Une sortie qui nomme la ressource ne peut pas être laissée de côté, de sorte qu’une ressource nommée par une sortie reste.

A valuesMapping key names no parameter of a sourced CloudFormation template (Une clé valuesMapping ne nomme aucun paramètre d’un template CloudFormation source)

Un template CloudFormation source reçoit des valeurs par les Parameters qu’il déclare, et le valuesMapping de la Recipe ou de la FeatureRecipe qui le prend pour source écrit une clé par paramètre qu’il renseigne. Une clé qui ne nomme aucun paramètre déclaré par un template de la source n’a nulle part où aller, de sorte que le rendu s’arrête plutôt que de l’abandonner — la défaillance que CloudFormation lui-même signalerait pour un paramètre inconnu, signalée tant qu’il vous appartient encore de la corriger. Seul un valuesMapping renseigne des paramètres : les valeurs que rien n’a mappées ne sont jamais lues de cette façon, de sorte que les valeurs propres d’un composant ou d’un rattachement écrites pour ses autres entrées ne rencontrent jamais ce cas.

Message émis. La condition vient en tête, puis chaque clé qui n’a rien nommé et ce que déclare chaque template de la source :

a plugin could not resolve something it requires to exactly one value (un plugin n’a pas pu résoudre en exactement une valeur quelque chose dont il a besoin) cloudformation-provider: the Recipe’s or FeatureRecipe’s valuesMapping writes the key "<key>", and no template of the source declares a parameter of that name: template "<template>" declares "<parameter>", …; a sourced template takes values only through the parameters it declares, so rename the key to the parameter it is meant for, or remove it from the valuesMapping (cloudformation-provider : le valuesMapping de la Recipe ou de la FeatureRecipe écrit la clé indiquée, et aucun template de la source ne déclare de paramètre portant ce nom : le template indiqué déclare le paramètre indiqué, … ; un template source ne reçoit des valeurs que par les paramètres qu’il déclare, renommez donc la clé du nom du paramètre auquel elle est destinée, ou supprimez-la du valuesMapping)

Comment corriger : comparez la clé avec les paramètres que le message liste — une clé mal orthographiée est la cause habituelle — et renommez-la, ou supprimez-la du valuesMapping. Voir cloudformation → Valeurs des paramètres d’un template source.

Another component references a CloudFormation parameter a sourced template’s binding filled (Un autre composant référence un paramètre CloudFormation que la liaison d’un template source a renseigné)

Renseigner le paramètre d’un template source via le valuesMapping de la Recipe ou de la FeatureRecipe de la Feature rattachée qui le prend pour source remplace chaque référence à ce paramètre dans chaque template de cette source et supprime sa déclaration. Le contenu provenant d’ailleurs dans la même stack assemblée — le fragment ou le template source d’un autre composant, ou le fragment du composant auquel une Feature est rattachée — qui nomme encore le paramètre via Ref, une variable Fn::Sub ou le Fn::ValueOf d’une règle nomme alors quelque chose que la stack ne déclare plus, ce que CloudFormation refuse lors du déploiement de la stack, de sorte que l’assemblage s’arrête. Un nom qu’un composant de la stack déclare encore, comme paramètre qui lui est propre ou comme ID logique d’une ressource, est une référence que la stack résout et n’est pas arrêté.

Message émis. La condition vient en tête, puis chaque référence : le composant et le template dans lesquels elle se trouve, le paramètre, et le composant dont le valuesMapping de la Recipe ou de la FeatureRecipe rattachée l’a renseigné — une Feature rattachée à un composant est nommée par ce composant, et une Feature rattachée à une frontière par l’identité que ses ressources portent comme aggrega.ai/component-id, composée du chemin de la frontière et du nom du rattachement, telle que bfr--stack--aux :

a plugin could not resolve something it requires to exactly one value (un plugin n’a pas pu résoudre en exactement une valeur quelque chose dont il a besoin) cloudformation-provider: a parameter a sourced template’s binding filled is still referenced from elsewhere in the assembled stack: component "<component>"’s template "<template>" references parameter "<parameter>", which the valuesMapping of a Recipe or FeatureRecipe rendering for component "<component>" binds; …; binding a parameter removes its declaration from the source that declares it, and no template in the stack declares it any more, so the reference names nothing CloudFormation can resolve: reference what the binding component publishes instead, declare the parameter in the template that references it, or remove the key from the valuesMapping (cloudformation-provider : un paramètre que la liaison d’un template source a renseigné est encore référencé depuis ailleurs dans la stack assemblée : le template indiqué du composant indiqué référence le paramètre indiqué, que lie le valuesMapping d’une Recipe ou d’une FeatureRecipe effectuant le rendu pour le composant indiqué ; … ; lier un paramètre supprime sa déclaration de la source qui le déclare, et aucun template de la stack ne le déclare plus, de sorte que la référence ne nomme rien que CloudFormation puisse résoudre : référencez plutôt ce que publie le composant qui effectue la liaison, déclarez le paramètre dans le template qui le référence, ou supprimez la clé du valuesMapping)

Comment corriger : si le composant qui fait référence a besoin de la valeur, faites en sorte que le composant qui la renseigne la publie via provides et référencez-la ; ou déclarez le paramètre dans le template qui fait référence afin qu’il reçoive sa propre valeur ; ou supprimez la clé du valuesMapping, afin que le paramètre reste déclaré et que chaque composant lise la valeur transmise lors du déploiement de la stack. Voir cloudformation → Valeurs des paramètres d’un template source.

A value bound to a CloudFormation parameter cannot take the parameter’s type (Une valeur liée à un paramètre CloudFormation ne peut pas prendre le type du paramètre)

Un littéral lié à un paramètre est converti de la façon dont CloudFormation convertit la même valeur transmise pour le Type de ce paramètre lors du déploiement de la stack. Lorsqu’aucune conversion de ce genre n’existe, le rendu s’arrête : une valeur qui n’est pas un nombre liée à un Number ou à un List<Number>, une liste ou un mapping lié à un paramètre qui prend une seule valeur, et tout littéral lié à un paramètre AWS::SSM::Parameter::Value<…>, dont CloudFormation lit la valeur dans Parameter Store plutôt que dans le template. Une liste liée à un paramètre que le template nomme comme variable Fn::Sub arrête aussi le rendu, car une variable substitue une seule chaîne.

Message émis. La condition vient en tête, puis le paramètre, son template et son type, et pourquoi la valeur ne convient pas ; aucune valeur n’est citée :

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) cloudformation-provider: parameter "<parameter>" of template "<template>" is of type <type>, and <why the value does not fit> (cloudformation-provider : le paramètre indiqué du template indiqué est du type indiqué, et la valeur ne convient pas pour la raison indiquée)

Comment corriger : liez une valeur du type du paramètre — ou, pour un type Parameter Store, une référence dynamique {{resolve:ssm:…}} ou une fonction intrinsèque — ou laissez le paramètre non lié pour une valeur transmise lors du déploiement de la stack.

A value bound to a CloudFormation parameter is one its constraints refuse (Une valeur liée à un paramètre CloudFormation est une valeur que ses contraintes refusent)

Un littéral lié à un paramètre est vérifié par rapport aux contraintes que le template déclare pour ce paramètre — AllowedValues, AllowedPattern, MinLength, MaxLength, MinValue et MaxValue —, la vérification que CloudFormation effectue sur une valeur transmise lors du déploiement de la stack, avancée au moment de la build afin que renseigner un paramètre ne supprime aucune vérification que le template a déclarée. Une fonction intrinsèque et une référence dynamique sont laissées à la vérification de CloudFormation, puisque leur valeur n’existe pas avant le déploiement de la stack.

Message émis. La condition vient en tête, puis le paramètre, son template et la contrainte ; aucune valeur n’est citée :

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) cloudformation-provider: the value bound to parameter "<parameter>" of template "<template>" does not satisfy its <constraint>, which CloudFormation would refuse when the stack deploys; bind a value the parameter admits (cloudformation-provider : la valeur liée au paramètre indiqué du template indiqué ne satisfait pas sa contrainte indiquée, que CloudFormation refuserait lors du déploiement de la stack ; liez une valeur que le paramètre admet)

Comment corriger : liez une valeur que la contrainte admet ; la propre déclaration du paramètre dans le template indique ce qu’il autorise.

A secret bound to a CloudFormation parameter would be written into the template (Un secret lié à un paramètre CloudFormation serait écrit dans le template)

Une valeur liée à un paramètre est écrite dans le template, où quiconque peut lire le template de la stack peut la lire. Le rendu s’arrête sur un littéral lié à un paramètre que le template déclare NoEcho et, lorsque le valuesMapping de la Recipe ou de la FeatureRecipe lit une valeur qu’un auteur a déclarée sensible, sur chaque littéral que ce mapping lie, puisqu’aucune partie de sa sortie ne peut être ramenée à la valeur dont elle provient. Une référence dynamique et une fonction intrinsèque sont écrites telles qu’elles sont données — le texte à l’intérieur d’une fonction intrinsèque compris —, de sorte qu’une valeur sensible que le mapping insère dans une chaîne Fn::Sub atteint le template sous la forme de ce texte, et seule une référence dynamique tient le secret lui-même hors du template.

Message émis. La condition vient en tête, puis les paramètres et ce qu’il faut lier à la place ; aucune valeur n’est citée. L’un des suivants :

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) cloudformation-provider: parameter "<parameter>" of template "<template>" is declared NoEcho, and the value bound to it would be written into the template as it stands; bind a dynamic reference ({{resolve:secretsmanager:…}} or {{resolve:ssm-secure:…}}) or an intrinsic function instead, or leave the parameter unbound for a deploy-time value (cloudformation-provider : le paramètre indiqué du template indiqué est déclaré NoEcho, et la valeur qui lui est liée serait écrite telle quelle dans le template ; liez plutôt une référence dynamique ({{resolve:secretsmanager:…}} ou {{resolve:ssm-secure:…}}) ou une fonction intrinsèque, ou laissez le paramètre non lié pour une valeur fournie au moment du déploiement)

cloudformation-provider: the Recipe’s or FeatureRecipe’s valuesMapping reads a value declared sensitive, so a literal it produces is refused, and binding parameter(s) "<parameter>", … would write a literal into the template as it stands; … (cloudformation-provider : le valuesMapping de la Recipe ou de la FeatureRecipe lit une valeur déclarée sensible, de sorte qu’un littéral qu’il produit est refusé, et lier le ou les paramètres indiqués, … écrirait un littéral tel quel dans le template ; …)

Comment corriger : stockez le secret dans Secrets Manager ou sous forme de chaîne sécurisée dans Parameter Store et liez une référence dynamique qui pointe vers lui — {{resolve:secretsmanager:<secret>}} ou {{resolve:ssm-secure:<name>}} — plutôt que de l’insérer dans le texte d’une fonction intrinsèque, ou laissez le paramètre non lié pour une valeur transmise lors du déploiement de la stack. Voir cloudformation → Valeurs des paramètres d’un template source.

A dynamic reference is bound where CloudFormation does not resolve it (Une référence dynamique est liée là où CloudFormation ne la résout pas)

CloudFormation résout une référence dynamique dans les propriétés d’une ressource, mais pas dans les données utilisateur EC2 ni dans les métadonnées AWS::CloudFormation::Init, et il montre les Outputs d’un template à quiconque lit la stack. Ainsi, une référence dynamique liée à un paramètre auquel un template quelconque de la source fait référence dans une propriété UserData, dans ces métadonnées ou dans ses Outputs arrête le rendu plutôt que d’atteindre un endroit où elle ne peut pas être déployée ou bien est exposée.

Message émis. La condition vient en tête, puis le paramètre, le template et l’endroit où ce template y fait référence ; aucune valeur n’est citée :

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) cloudformation-provider: the value bound to parameter "<parameter>" is a dynamic reference, and template "<template>" references the parameter in <where>, where CloudFormation does not resolve a dynamic reference or shows it to whoever reads the stack; bind an intrinsic function instead, or leave the parameter unbound for a deploy-time value (cloudformation-provider : la valeur liée au paramètre indiqué est une référence dynamique, et le template indiqué fait référence au paramètre à l’endroit indiqué, où CloudFormation ne résout pas une référence dynamique ou la montre à quiconque lit la stack ; liez plutôt une fonction intrinsèque, ou laissez le paramètre non lié pour une valeur fournie au moment du déploiement)

Comment corriger : laissez le paramètre non lié et transmettez sa valeur lors du déploiement de la stack, ou liez une fonction intrinsèque qui produit ce dont le template a besoin à cet endroit.

A rule reads a bound CloudFormation parameter by name (Une règle lit par son nom un paramètre CloudFormation lié)

Fn::ValueOf dans les Rules d’un template désigne un paramètre par son ID logique plutôt que par Ref, et lit la valeur transmise pour celui-ci lors du déploiement de la stack. Lier le paramètre supprime sa déclaration de chaque template de la source, ce qui laisserait la règle — dans n’importe lequel de ces templates — ne désigner rien, de sorte que le rendu s’arrête.

Message émis. La condition vient en tête, puis la règle, son template et le paramètre :

a plugin has no expression for a construct this build declares (un plugin n’a aucune expression pour une construction que cette build déclare) cloudformation-provider: rule "<rule>" of template "<template>" reads parameter "<parameter>" through Fn::ValueOf, which names a declared parameter by its logical ID, and binding the parameter removes its declaration from the source; leave the parameter unbound so the rule can read it at deploy (cloudformation-provider : la règle indiquée du template indiqué lit le paramètre indiqué par Fn::ValueOf, qui désigne un paramètre déclaré par son ID logique, et lier le paramètre supprime sa déclaration de la source ; laissez le paramètre non lié afin que la règle puisse le lire lors du déploiement)

Comment corriger : supprimez la clé du paramètre du valuesMapping, afin que le paramètre reste déclaré et que la règle lise la valeur transmise lors du déploiement de la stack.

The assembled CloudFormation stack cannot carry a transform (La stack CloudFormation assemblée ne peut pas porter une transformation)

Le Transform de la stack assemblée est construit à partir de celui de chaque composant, et une transformation traite le template entier, de sorte qu’une transformation dont l’effet ne se limite pas au contenu écrit pour elle est refusée plutôt que de pouvoir changer la façon dont le contenu d’un autre composant est déployé : AWS::CodeDeployBlueGreen et AWS::Include toujours, une macro que votre compte définit et AWS::ServiceCatalog à côté de tout autre composant, AWS::LanguageExtensions à côté du contenu serverless d’un autre composant, et AWS::Serverless-2016-10-31 lorsque ses Globals atteindraient les ressources serverless d’un autre composant ou que l’une de ses sources d’événements désigne une ressource qu’un autre composant déclare. Le tableau complet se trouve dans cloudformation → Sections de premier niveau dans la stack assemblée.

Message émis. La condition vient en tête, puis chaque composant de la stack, la transformation et les composants qui la déclarent, et la raison pour laquelle elle ne peut pas être portée :

a plugin has no expression for a construct this build declares (un plugin n’a aucune expression pour une construction que cette build déclare) cloudformation-provider: the assembled stack of component "<component>", … cannot carry the transform "<transform>", declared by component "<component>": <why> (cloudformation-provider : la stack assemblée du composant indiqué, … ne peut pas porter la transformation indiquée, déclarée par le composant indiqué : avec la raison indiquée)

Comment corriger : placez le composant qui déclare la transformation dans une frontière qui lui est propre, afin que sa stack ne contienne rien que la transformation puisse changer ; ou, lorsque le message désigne du contenu qu’un autre composant déclare, déplacez ce contenu dans le composant qui déclare la transformation.

Two components order one pair of transforms oppositely (Deux composants ordonnent une même paire de transformations en sens inverse)

La stack assemblée exécute ses transformations dans un seul ordre, construit à partir de l’ordre propre à chaque composant et de celui que CloudFormation documente. Lorsque deux ordres ne peuvent pas être respectés tous les deux — deux composants qui listent une même paire de transformations dans le sens inverse, ou un composant qui liste AWS::Serverless-2016-10-31 avant AWS::LanguageExtensions, que CloudFormation documente dans l’autre sens —, il n’existe pas d’ordre unique à écrire, de sorte que le rendu s’arrête.

Message émis. La condition vient en tête, puis la paire et qui l’a ordonnée dans chaque sens :

a plugin could not resolve something it requires to exactly one value (un plugin n’a pas pu résoudre en exactement une valeur quelque chose dont il a besoin) cloudformation-provider: the transforms "<first>" and "<second>" are ordered both ways — "<first>" before "<second>" by <who>, and "<second>" before "<first>" by <who> — and the assembled stack’s Transform runs them in one order; declare them in one order (cloudformation-provider : les transformations indiquées sont ordonnées dans les deux sens — la première avant la seconde par l’auteur indiqué, et la seconde avant la première par l’auteur indiqué — et le Transform de la stack assemblée les exécute dans un seul ordre ; déclarez-les dans un seul ordre)

Comment corriger : déclarez la paire dans un seul ordre dans chaque composant qui liste les deux, en suivant l’ordre propre à CloudFormation lorsqu’il en documente un.

Two entries reach one stack output name (Deux entrées atteignent un même nom de sortie de stack)

Un nom de sortie de stack n’admet que des lettres et des chiffres, de sorte qu’il est construit à partir de ce que vous avez écrit en encodant les caractères que cet alphabet n’admet pas plutôt qu’en les supprimant. Deux entrées que vous avez écrites distinctes restent donc distinctes, et cet arrêt est ce qui signale le cas où deux d’entre elles atteignent malgré tout un même nom. Le rendu s’arrête plutôt que d’émettre une seule sortie là où deux entrées ont été écrites, ce qui supprimerait silencieusement l’une d’elles.

Chaque nom derrière lequel deux entrées ou plus se sont rencontrées est signalé, et chaque entrée derrière chaque nom est nommée, dans un ordre stable — ainsi une seule build vous montre la collision entière plutôt qu’un seul de ses côtés.

Message émis, qui commence par la condition et se poursuit avec le détail propre au fournisseur :

two things a plugin produced occupy one name in its output (deux choses qu’un plugin a produites occupent un même nom dans sa sortie) cloudformation-provider: two entries an author wrote reach one stack Output name: <the entries that met> reach the Output name "<name>"; an Output name is built by encoding the component and the entry into the letters and digits a logical id admits, rather than by dropping what it does not, so two entries an author wrote apart stay apart — renaming either end clears the build (cloudformation-provider : deux entrées qu’un auteur a écrites atteignent un même nom d’Output de stack : les entrées indiquées qui se sont rencontrées atteignent le nom d’Output indiqué ; un nom d’Output est construit en encodant le composant et l’entrée dans les lettres et les chiffres qu’admet un ID logique, plutôt qu’en supprimant ce qu’il n’admet pas, de sorte que deux entrées qu’un auteur a écrites distinctes restent distinctes — renommer l’une ou l’autre extrémité débloque la build)

Comment corriger : renommez l’une des entrées, ou l’un des composants, afin que les deux n’atteignent plus un même nom — le message nomme les deux côtés. Le nom porte la ponctuation et la casse que vous avez écrites, encodées plutôt que supprimées, de sorte qu’une différence de l’une ou de l’autre s’y retrouve et que deux entrées écrites différemment reçoivent des noms distincts.

A CloudFormation fragment writes one key twice (Un fragment CloudFormation écrit une même clé deux fois)

Un mapping contient une valeur par clé, de sorte qu’un fragment qui écrit la même clé deux fois conserverait le corps venu en dernier et écarterait l’autre. Lorsque le mapping est le bloc qui contient les ressources ou les sorties, le corps écarté est une ressource ou une sortie qui a été écrite et qui ne figurerait pas dans le résultat. Le rendu s’arrête à la place.

Les deux endroits où la clé a été écrite sont signalés, car une clé écrite deux fois correspond généralement à deux modifications censées être deux clés différentes — et l’auteur a besoin des deux pour savoir laquelle changer.

Message émis, qui commence par la condition et se poursuit avec le détail propre au fournisseur :

two things a plugin produced occupy one name in its output (deux choses qu’un plugin a produites occupent un même nom dans sa sortie) cloudformation-provider: one mapping key is written more than once: the key "<key>" is written at line <first> and again at line <second>; a mapping holds one value per key, so one of the two bodies would be dropped — remove one, or rename one so each key is written once (cloudformation-provider : une clé de mapping est écrite plus d’une fois : la clé indiquée est écrite à la ligne indiquée et de nouveau à la seconde ligne indiquée ; un mapping contient une valeur par clé, de sorte que l’un des deux corps serait supprimé — supprimez-en un, ou renommez-en un afin que chaque clé soit écrite une seule fois)

Comment corriger : ouvrez le fragment aux deux lignes que nomme le message. Lorsque les deux corps devaient être une seule chose, supprimez celui qui est désormais redondant ; lorsqu’ils devaient être deux, renommez-en un afin que chacun ait sa propre clé. Le fragment est un template, vérifiez donc le texte rendu plutôt que la seule source lorsqu’une clé est composée plutôt qu’écrite littéralement.

A cross-boundary reference has no consuming stack to be written into (Une référence entre frontières n’a aucune stack consommatrice dans laquelle être écrite)

Lorsqu’une connexion de dépendance passe entre deux sorties assemblées séparément, le côté consommateur est rendu avec un espace réservé et la référence est écrite une fois que les deux côtés existent. Cette condition est ce qui se produit lorsque la sortie assemblée du côté consommateur ne contient aucun template de stack : il n’y a aucun document dans lequel écrire la référence, de sorte que l’espace réservé ne peut pas être remplacé.

Message émis. La condition nomme le type de défaillance, et la phrase propre au fournisseur indique quelle entrée :

a plugin could not resolve something it requires to exactly one value (un plugin n’a pas pu résoudre en exactement une valeur quelque chose dont il a besoin) cloudformation-provider: cross-boundary link resolve received no consumer stack template (cloudformation-provider : la résolution du lien entre frontières n’a reçu aucun template de stack consommatrice)

Comment corriger : rien de ce que vous écrivez dans le composant consommateur ne produit ceci — c’est la forme de ce que sa frontière a assemblé. Vérifiez que le côté consommateur est bien rendu par le fournisseur CloudFormation : une connexion qui passe vers une frontière qui assemble autre chose n’a aucune stack dans laquelle la référence peut arriver, et la connexion doit relier deux frontières qu’assemble le même fournisseur. Lorsque les deux côtés devraient être CloudFormation, la frontière consommatrice n’a produit aucun template de stack, ce qui est une question pour quiconque a rédigé les Recipes qui y contribuent.

A cross-boundary reference was spliced into a longer string (Une référence entre frontières a été insérée dans une chaîne plus longue)

Une référence croisée CloudFormation est un objet plutôt que du texte, de sorte qu’elle ne peut remplacer une valeur que dans son entier. Cette condition est ce que signale un espace réservé trouvé à l’intérieur d’une chaîne plus large — une valeur composée autour de lui, plutôt que livrée comme la totalité de ce qui a été injecté. Il n’y a rien contre quoi échanger l’objet, de sorte que le rendu s’arrête plutôt que d’émettre une référence sous une forme que la cible ne peut pas lire.

Message émis. La condition vient en tête, puis la valeur et la connexion par laquelle elle est arrivée :

a plugin has no representation for a value it was given (un plugin n’a aucune représentation pour une valeur qui lui a été transmise) cloudformation-provider: cross-boundary link value is interpolated into a larger string; only a whole-scalar injection can carry a cross-stack reference: output key "<key>" on socket "<socket>" (cloudformation-provider : la valeur du lien entre frontières est interpolée dans une chaîne plus large ; seule une injection d’un scalaire entier peut porter une référence inter-stacks : avec la clé de sortie indiquée sur le socket indiqué)

Comment corriger : livrez la valeur dans son entier plutôt que de composer autour d’elle. Lorsque le côté consommateur a besoin de la valeur à l’intérieur d’une chaîne plus longue — une chaîne de connexion, une URL —, construisez cette composition dans le vocabulaire propre de la cible à partir de la référence, plutôt que dans le template de la Recipe avant que la référence n’existe. Le mapping qui injecte la valeur est l’endroit où l’insertion se produit, c’est donc la ligne à changer.

Two rendered resources land at one output file (Deux ressources rendues aboutissent à un même fichier de sortie)

Chaque ressource rendue est écrite dans un fichier dont le nom découle de ce qu’est la ressource et de son nom. Deux ressources qui partagent ces éléments portent le même nom de fichier, de sorte que l’une occuperait l’emplacement de l’autre et le rendu s’arrête plutôt que d’émettre un seul fichier là où deux ressources ont été rendues.

Deux ressources dont le rendu est identique ne constituent pas une collision. Lorsque le contenu correspond octet pour octet, en conserver une ne fait rien perdre et le rendu continue — ainsi un template inclus deux fois avec le même résultat n’est pas signalé.

Message émis. La condition vient en tête, puis les deux templates qui les ont produites et le fichier où elles se sont rencontrées :

two things a plugin produced occupy one name in its output (deux choses qu’un plugin a produites occupent un même nom dans sa sortie) helm: node "<node>": rendered resources "<one template>" and "<the other>" both derive output "<file>" with differing content: two rendered resources derive the same output filename with differing content (helm : dans le nœud indiqué : les ressources rendues indiquées, l’une et l’autre, dérivent toutes deux la sortie indiquée avec un contenu différent : deux ressources rendues dérivent le même nom de fichier de sortie avec un contenu différent)

Comment corriger : donnez aux deux ressources des identités distinctes — le nom est ce qui diffère habituellement, et le nom de fichier en découle. Le message nomme les deux templates, ouvrez-les donc et vérifiez ce que chacun produit : deux templates qui rendent la même ressource sous un même nom signifient souvent que l’un d’eux est une copie plus ancienne. Lorsque les deux sont voulues, ce sont deux ressources et chacune a besoin de son propre nom.

A synthesized StatefulSet has no single service to govern it (Un StatefulSet synthétisé n’a pas de service unique pour le gouverner)

Une charge de travail qui déclare un stockage par instance est rendue sous forme de StatefulSet, et un StatefulSet nomme un service qui le gouverne — celui qui donne à chaque instance son adresse stable. Ce service est celui qui est déclaré sans adresse de cluster propre. Deux formes arrêtent le rendu : aucun n’est déclaré, il n’y a donc rien à nommer ; et plus d’un, de sorte que la question de savoir lequel gouverne n’a pas de réponse. L’une comme l’autre produirait un StatefulSet que la cible refuse, donc le rendu s’arrête au lieu d’en émettre un.

Messages émis. Les deux signalent la même condition — quelque chose dont le fournisseur a besoin et qu’il n’a pas pu résoudre en exactement une valeur — et la phrase propre au fournisseur indique laquelle des deux formes a été rencontrée. Chacun est affiché sous un cadre qui nomme le nœud :

a plugin could not resolve something it requires to exactly one value (un plugin n’a pas pu résoudre en exactement une valeur quelque chose dont il a besoin) synthesized StatefulSet requires a headless governing Service (declare a service with type: Headless); none found: synthesized StatefulSet has no headless governing Service (le StatefulSet synthétisé requiert un Service headless qui le gouverne (déclarez un service avec type: Headless) ; aucun trouvé : le StatefulSet synthétisé n’a aucun Service headless qui le gouverne)

a plugin could not resolve something it requires to exactly one value (un plugin n’a pas pu résoudre en exactement une valeur quelque chose dont il a besoin) synthesized StatefulSet declares more than one headless Service; the governing Service is ambiguous (declare exactly one type: Headless service): synthesized StatefulSet has more than one headless Service (le StatefulSet synthétisé déclare plus d’un Service headless ; le Service qui le gouverne est ambigu (déclarez exactement un service type: Headless) : le StatefulSet synthétisé a plus d’un Service headless)

Comment corriger : déclarez exactement un service de type headless sur la charge de travail. Lorsqu’aucun n’est déclaré, ajoutez-le — une charge de travail avec un stockage par instance en a besoin, et c’est lui qui donne à chaque instance une adresse qui lui reste attachée. Lorsque plusieurs sont déclarés, gardez celui qui doit gouverner et donnez aux autres un type ordinaire, ou supprimez-les ; un second service headless est généralement un service qui n’avait pas besoin d’être headless.

A plugin reported a failure it did not classify (Un plugin a signalé une défaillance qu’il n’a pas classée)

Un plugin qui arrête un build signale deux choses : une phrase à lui qui dit ce qui s’est passé, et le type de défaillance que cette phrase nomme. Les types forment un petit ensemble que le compilateur déclare — une construction sans expression, une entrée qui n’a pas pu être résolue en une seule valeur, deux choses produites qui veulent un même nom, une valeur sans représentation — et cette condition est celle qu’un plugin choisit lorsque sa défaillance ne correspond à aucun d’eux.

C’est un repli plutôt qu’une destination. Un plugin qui y recourt là où l’un des autres types convient vous en dit moins qu’il n’en sait, et la formulation dit clairement que le plugin a renoncé à classer, et non que quelque chose a simplement mal tourné — ainsi un repli trop utilisé est reconnaissable plutôt qu’impossible à distinguer d’un signalement correct.

Message émis. La condition vient en tête et la phrase propre au plugin la suit :

a plugin reported a failure that none of the declared kinds names (un plugin a signalé une défaillance qu’aucun des types déclarés ne nomme) <the plugin's own sentence>

Comment corriger : lisez la phrase propre au plugin, qui est l’endroit où se trouve tout ce qui est propre à votre build. La condition elle-même vous dit seulement que le plugin n’avait aucun type pour elle. Si le plugin est le vôtre, choisissez le type que la défaillance est réellement ; sinon, c’est la phrase à citer à son éditeur.

A plugin named a condition the socket does not declare (Un plugin a nommé une condition que le socket ne déclare pas)

Un plugin signale une condition que ce compilateur déclare plutôt que d’inventer un numéro à lui, de sorte que l’identifiant qui vous parvient est toujours un identifiant auquel aggrega explain répond. Cet arrêt est ce que produit un signalement qui nomme autre chose : un numéro sous lequel rien n’est enregistré, un numéro qui a été retiré, un code court écrit différemment de l’enregistrement vers lequel il se résout, ou une paire d’identifiants qui nomment deux conditions différentes.

Il s’arrête plutôt que d’abandonner silencieusement le signalement. Supprimer les identifiants et laisser valoir la condition générique de défaillance d’un plugin produirait un build qui ressemble exactement à celui d’un plugin qui n’a nommé aucune condition, de sorte que la personne qui doit le corriger n’apprendrait jamais qu’il y avait quelque chose à corriger. Signaler plutôt le numéro proposé vous remettrait un identifiant qui ne se résout en rien.

Votre build reçoit malgré tout ce qui l’a arrêté. L’arrêt cite le numéro fautif, dit pourquoi il ne se résout en aucune condition, nomme les conditions génériques auxquelles un plugin recourt lorsqu’il n’a pas de meilleure identité, et transmet inchangée la phrase propre au plugin.

Message émis :

wasm: guest plugin named a condition the socket does not declare: the guest named "<offered>", and <why it resolves to no condition>; a plugin names a condition this compiler declares, and reaches for one of <the generic conditions and their codes> when it has none better: <the plugin's own sentence> (wasm : le plugin invité a nommé une condition que le socket ne déclare pas : l’invité a nommé la valeur indiquée, avec le motif indiqué pour lequel elle ne se résout en aucune condition ; un plugin nomme une condition que ce compilateur déclare, et recourt à l’une des conditions génériques indiquées, avec leurs codes, lorsqu’il n’en a pas de meilleure : suivi de la phrase propre au plugin)

Comment corriger : rien dans vos fichiers d’entités ne provoque cela — c’est le signalement du plugin qui est erroné, et la défaillance qu’il signalait est réelle. Agissez d’après la phrase propre au plugin, qui est la dernière partie du message. Si le plugin est le vôtre, signalez une condition que ce compilateur déclare — l’un des types génériques que liste le message, lorsque la défaillance ne correspond à aucune des conditions plus spécifiques ; si le plugin n’est pas le vôtre, citez le numéro fautif à son éditeur.

A source artifact is cached without a workspace root to anchor it (Un artefact source est mis en cache sans racine d’espace de travail à laquelle l’ancrer)

Un artefact source acquis est stocké dans un emplacement sous le cache d’artefacts de l’espace de travail, et le chemin vers cet emplacement est construit à partir de la racine de l’espace de travail vers l’extérieur. Cette condition signale que la racine arrive vide, ce qui laisserait relatif le chemin de l’emplacement — résolu par rapport au répertoire dans lequel le processus se trouve au moment où les octets sont écrits, et plaçant le cache à un endroit que personne n’a choisi.

Il est refusé plutôt que résolu, car un emplacement écrit au mauvais endroit est pire que pas d’emplacement du tout : les lectures ultérieures regardent dans le bon, ne trouvent rien et acquièrent de nouveau, de sorte que ce que vous verriez est un cache qui ne semble jamais rien contenir, et rien d’autre qui en indique la raison.

Message émis. La phrase propre à la condition l’ouvre, et ce qui identifie l’artefact suit :

cacheslot: empty workspaceRoot (kind=<kind> url=<url> chart=<chart> version=<version>) (cacheslot : workspaceRoot vide (avec les kind, url, chart et version indiqués))

Comment corriger : rien dans vos fichiers d’entités ne provoque cela et aucune modification de ce que vous écrivez ne le fait disparaître — la racine de l’espace de travail est fournie par ce qui pilote le build, et non écrite dans un catalogue. Exécutez le build depuis l’intérieur de l’espace de travail, afin que la racine soit découverte plutôt que passée comme rien. Si vous pilotez le compilateur depuis votre propre logiciel, passez explicitement la racine de l’espace de travail ; un appelant qui veut réellement le cache relatif au répertoire courant passe un simple point, qui est accepté et l’exprime délibérément.

A value would place a cached file outside the cache (Une valeur placerait un fichier mis en cache hors du cache)

Une entité en cache et un artefact source en cache vivent chacun dans un emplacement que le cache nomme pour lui, et cet emplacement est composé à partir de valeurs : la référence de l’entité et la version vers laquelle elle s’est résolue, ou le type, url, chart, module_subdir, la version et le digest d’une source. Chaque valeur nomme une position dans l’agencement. Cette condition signale une valeur qui déplacerait ce qui est écrit pour elle ailleurs qu’à la position qu’elle nomme — à côté d’un autre emplacement, ou entièrement hors du cache — et la refuse avant que quoi que ce soit n’y soit écrit ou lu.

La plupart de ces valeurs proviennent d’un endroit que le cache ne contrôle pas : un corps servi par un registre, un enregistrement relu depuis le disque, une coordonnée écrite par l’auteur d’une Recipe ou d’une FeatureRecipe. Une version qui est un chemin plutôt qu’une version, un chemin url ou un module_subdir qui remonte au-dessus de sa place, et une référence qui se résout en un répertoire fait de points sont chacun refusés ici. Une valeur qui nomme un seul répertoire — et un chemin url ou un module_subdir qui reste à sa place ou en dessous — n’est pas touchée.

Un module_subdir qui remonte est refusé avant que quoi que ce soit ne soit récupéré. Pour une source git-repository, la même valeur nomme aussi le répertoire du dépôt que le pull archive, et une valeur qui remonte au-dessus du dépôt ferait lire au pull les fichiers situés à côté de son checkout. Le pull juge donc module_subdir avant de récupérer le dépôt, et refuse une valeur qui remonte avec cette condition, en la citant sous sa clé : rien n’est récupéré, et rien à côté du checkout n’est lu. Une barre oblique inverse dans cette valeur est lue comme un séparateur, comme la lit un chemin Windows, de sorte que ..\shared est refusé sur toutes les machines plutôt que d’être lu à côté du checkout sur l’une d’elles ; un séparateur en tête ou en fin de valeur est supprimé, de sorte que /charts/app nomme charts/app.

Message émis. La phrase propre à la condition l’ouvre, puis la valeur telle qu’elle a été écrite sous la clé sous laquelle elle a été écrite, et le remède :

a value a cache location is built from would place cached files outside the place it names in the cache (version "../../../etc" for entity "demo/app/web"). a version, a name, a kind or a host names one directory of the cache, so it carries no / or \ and is neither . nor ..; a URL path or a module subdirectory may name directories beneath its place but may not climb above it. Correct the value where it was written, or, where a registry served it, ask its publisher to publish a version that carries a well-formed one (une valeur à partir de laquelle un emplacement du cache est construit placerait des fichiers mis en cache hors de l’endroit qu’elle nomme dans le cache (la version indiquée pour l’entité indiquée). une version, un nom, un type ou un hôte nomme un seul répertoire du cache, il ne contient donc ni barre oblique ni barre oblique inverse et n’est ni un point simple ni un point double ; un chemin d’URL ou un sous-répertoire de module peut nommer des répertoires sous sa place mais ne peut pas remonter au-dessus. Corrigez la valeur là où elle a été écrite, ou, lorsqu’un registre l’a servie, demandez à son éditeur de publier une version qui en porte une bien formée)

Comment corriger : lorsque la valeur est une valeur que vous avez écrite — source.version, url ou module_subdir d’une Recipe ou d’une FeatureRecipe — corrigez-la pour qu’elle nomme un seul répertoire, ou un chemin qui reste à l’intérieur de sa place ; le message cite la valeur et la clé depuis laquelle elle a été lue. Lorsqu’un registre l’a servie, l’entité publiée porte une version ou une coordonnée qui n’en est pas une, ce qu’aucune modification de votre part ne peut corriger : le message nomme ce qui a été récupéré, et le remède revient à son éditeur.

Plusieurs opérations écrivent ou suppriment des fichiers qui leur sont propres, à des endroits qu’elles déterminent elles-mêmes plutôt qu’à des endroits que vous avez nommés : le répertoire de sortie d’un build et chaque fichier qu’il y écrit, ainsi que le répertoire .trace qu’un build tracé remplace ; le fichier de verrouillage d’une Release, et le registre de confiance des plugins à côté de lui, qu’écrit un pull ; le fichier entity.lock à côté d’une entité, qu’écrit aggrega pin, et qu’un pull qui épingle des sources écrit à côté de chaque entité qu’il épingle ; le fichier .aggrega-config.yaml de l’espace de travail, lorsqu’une commande écrit la configuration de l’espace de travail ; le cache d’artefacts et chacun de ses sous-arbres, qu’un pull remplit et que aggrega cache clear et aggrega cache prune vident ; les bundles de signature qu’un pull conserve dans ce cache pour chaque artefact dont il a vérifié la signature ; les brouillons qu’écrit aggrega import ; les entités Plugin qu’écrit aggrega plugin gen-catalog sous son répertoire de sortie ; et le marqueur .aggrega/active-release qu’écrit le serveur de langage de l’éditeur lorsqu’une Release par défaut est enregistrée, ainsi que le répertoire .aggrega qui le contient. Il en va de même quelle que soit la surface qui a lancé l’opération — la ligne de commande, le serveur de langage de l’éditeur ou les outils d’un assistant. La frontière de l’espace de travail énonce la règle appliquée ici, ainsi que les chemins qui sortent de l’espace de travail à dessein.

Chacun de ces endroits a un répertoire dans lequel il doit rester, et lequel dépend du répertoire sous lequel l’opération le compose :

  • L’espace de travail, pour tout ce qui est composé à l’intérieur. C’est le cas habituel, et il vaut aussi pour un répertoire que vous avez nommé et qui se trouve à l’intérieur de l’espace de travail. Les dist et .trace d’un build sont toujours composés ici, sous la racine de l’espace de travail, quel que soit le dossier depuis lequel le build est exécuté, tout comme les brouillons d’un import qui ne nomme aucun répertoire de sortie.
  • Un répertoire que vous avez nommé et qui se trouve hors de l’espace de travail, pour tout ce qui est composé en dessous : le répertoire de sortie que vous passez à aggrega plugin gen-catalog ou à aggrega import ; le répertoire d’une Release que vous nommez, ou que nomme la configuration de l’espace de travail, qui se trouve hors de l’espace de travail, pour le fichier de verrouillage et le registre de confiance à côté d’elle ; et le répertoire d’une entité que vous nommez à aggrega pin, ou un répertoire de catalogue que vous nommez avec --catalog ou que la configuration liste sous catalog_dirs, pour le fichier entity.lock à côté de chaque entité qui s’y trouve. Le répertoire lui-même est utilisé tel que vous l’avez nommé — s’il est un lien, l’écriture passe à travers lui, là où il pointe — et ce qui est écrit en dessous reste à l’intérieur.
  • Le répertoire du cache d’artefacts lui-même, pour tout ce qui est écrit dans le cache en dessous et tout ce que aggrega cache clear et aggrega cache prune y suppriment — le .aggrega/cache par défaut tout autant qu’un artifact_cache_dir que la configuration écrit en remontant hors de la racine de l’espace de travail (../shared-cache). L’un des répertoires propres du cache, ou un fichier qu’il contient, qui est un lien menant hors du répertoire du cache est refusé même lorsqu’il mène ailleurs à l’intérieur de l’espace de travail, de sorte que rien de ce qui est écrit dans le cache, et rien de ce qu’un clear ou un prune supprime, n’aboutit sur un fichier hors de celui-ci. L’endroit où se trouve le répertoire du cache lui-même est jugé en premier : un répertoire écrit à l’intérieur de la racine de l’espace de travail est suivi partout où il mène à l’intérieur de l’espace de travail et refusé, tenu à l’espace de travail, là où il en sort ; un répertoire écrit en remontant hors de la racine de l’espace de travail est utilisé tel que vous l’avez nommé, l’écriture passant à travers lui jusqu’à l’endroit où il pointe s’il est un lien.

Chacun de ces endroits est vérifié avant que quoi que ce soit n’y soit écrit ou supprimé. La partie la plus profonde du chemin qui existe, chaque lien symbolique en chemin étant suivi, doit être le répertoire dans lequel il doit rester ou se trouver en dessous. Un lien n’importe où en chemin qui mène hors de ce répertoire — un dist lié à un répertoire situé ailleurs, un fichier de verrouillage lié à un fichier d’un autre projet, un .aggrega/cache lié à un répertoire partagé avec d’autres travaux, un répertoire sous un répertoire de sortie de gen-catalog lié ailleurs — ferait aboutir l’écriture ou la suppression à l’extérieur, donc l’opération s’arrête à la place, et ce chemin est laissé exactement tel qu’il était. Cela compte surtout pour un build : vider et réécrire un répertoire de sortie qui est un lien supprimerait et réécrirait sinon un répertoire situé ailleurs sur la machine.

Un lien qui ne mène nulle part est traité pour ce qu’il est — pas quelque chose qui existe — donc c’est le répertoire qui le contient qui est vérifié. Lorsqu’un tel lien se trouve tout au bout d’un chemin que l’opération s’apprête à créer, le fichier serait créé là où pointe le lien, donc l’endroit vers lequel il pointe est vérifié aussi. Un lien qui pointe quelque part à l’intérieur du répertoire dans lequel le chemin doit rester est suivi comme d’habitude.

Message émis. La phrase propre à la condition l’ouvre, puis le chemin que l’opération s’apprêtait à écrire ou à supprimer — writing ou removing indique lequel — le répertoire dans lequel il doit rester, le lien qu’il rencontre en chemin et l’endroit où mène ce lien, puis le remède. Un build dont le dist est un lien menant hors de l’espace de travail est arrêté à la première chose qu’il toucherait, le vidage de la sortie précédente :

a path this operation writes or deletes leads through a link out of the directory it must stay inside (removing <workspace>/dist/boundaries, which must stay inside <workspace>, the link <workspace>/dist leads to <elsewhere>/dist-target). nothing was written to or removed from that path. Remove the link, or make it lead to a place inside <workspace>, and run the operation again (un chemin que cette opération écrit ou supprime mène, par un lien, hors du répertoire dans lequel il doit rester (suppression du chemin indiqué, qui doit rester à l’intérieur de l’espace de travail indiqué ; le lien indiqué mène à la destination indiquée). rien n’a été écrit dans ce chemin ni supprimé de celui-ci. Supprimez le lien, ou faites-le mener à un endroit à l’intérieur de l’espace de travail indiqué, et relancez l’opération)

Le diagnostic ne porte aucune catégorie : ce qui est en cause, c’est l’agencement sur le disque plutôt qu’un document que vous avez écrit.

Comment corriger : supprimez le lien que nomme le message et relancez l’opération, afin qu’elle crée un vrai répertoire ou un vrai fichier à cet endroit ; ou faites mener le lien quelque part à l’intérieur du répertoire que nomme le message, où il est suivi. Rien dans vos fichiers d’entités ne provoque cela et aucune modification de ce que vous écrivez ne le fait disparaître.

A name the operation writes holds a part Windows cannot hold (Un nom que l’opération écrit contient une partie que Windows ne peut pas contenir)

Sous Windows, certains noms n’atteignent pas un fichier tels qu’ils sont écrits. Un nom que Windows réserve à un périphérique — CON, PRN, AUX, NUL, CONIN$, CONOUT$, de COM0 à COM9 et de LPT0 à LPT9, ainsi que les noms COM et LPT écrits avec un un, un deux ou un trois en exposant — nomme le périphérique plutôt qu’un fichier, quelle que soit la casse et quelle que soit l’extension qui le suit, si bien que nul, Aux.yaml et com1.txt sont tous des périphériques. Et une partie de chemin se terminant par un point ou une espace est une partie que Windows peut tronquer au lieu de la conserver telle qu’elle est écrite. Écrire un tel nom placerait ses octets ailleurs que dans le fichier qu’il nomme.

Ainsi, lorsqu’une opération s’apprête à écrire, sous un répertoire d’une machine Windows, un nom qu’elle n’a pas choisi elle-même, un nom contenant une telle partie est refusé avant que quoi que ce soit ne soit écrit : une entrée de l’archive qu’un artefact source ou une entité de catalogue apporte, lorsque le cache dispose l’archive pour la lire ; un fichier qu’un build rend dans son répertoire de sortie ; un brouillon qu’un importateur renvoie à aggrega import, lors d’une exécution à blanc comme lors d’une écriture ; et le document que aggrega edit-document réécrit, quelle que soit la surface qui a demandé la modification. Chaque partie du nom est jugée, une barre oblique inverse étant lue comme un séparateur, comme Windows la lit — ainsi aux/x.yaml est refusé pour son répertoire aux, report. pour son point final et .. \evil.yaml pour sa première partie, deux caractères point et une espace. Un ensemble refusé pour un seul nom n’écrit aucun des autres : une archive n’est pas disposée, la sortie d’un build n’est ni vidée ni écrite, et aucun brouillon n’atteint le disque.

Sous Linux et macOS, les mêmes noms sont écrits tels qu’ils sont nommés, et cette condition ne se déclenche jamais. Un nom qui remonte hors du répertoire sous lequel il est écrit est une faute différente, refusée sur toutes les plateformes avec le message propre à cette opération avant que cette condition-ci ne soit évaluée.

Message émis. La phrase propre à la condition l’ouvre, puis viennent le nom, la partie que Windows ne peut pas contenir et le répertoire sous lequel le nom devait être écrit, puis le remède :

a name this operation writes holds a path segment Windows cannot hold as written (the name "aux/x.yaml", its segment "aux", beneath <directory>). It was not written. Windows reserves device names such as CON, PRN, AUX, NUL, COM1 and LPT1, in any letter case and whatever extension follows, and does not hold a segment ending in a full stop or a space as written; rename that segment where the name is produced (un nom que cette opération écrit contient un segment de chemin que Windows ne peut pas contenir tel qu’il est écrit (le nom, son segment et le répertoire indiqués). Il n’a pas été écrit. Windows réserve des noms de périphérique tels que CON, PRN, AUX, NUL, COM1 et LPT1, quelle que soit la casse et quelle que soit l’extension qui suit, et ne conserve pas tel qu’il est écrit un segment se terminant par un point ou une espace ; renommez ce segment là où le nom est produit)

Le diagnostic ne porte aucune catégorie : le nom provient de ce qui l’a produit — l’éditeur d’une archive, une Recipe ou une bibliothèque, un importateur, le chemin qu’une modification nomme — plutôt que d’un document unique auquel le compilateur imputerait la faute.

Comment corriger : renommez la partie que le message nomme là d’où vient le nom. Pour une entrée d’archive, il s’agit de l’artefact source ou de l’entité publiés, que seul leur éditeur peut modifier. Pour un fichier rendu, c’est le nom de sortie que lui donne une Recipe ou une ArtifactLibrary ; pour un brouillon, l’importateur qui l’a nommé ; pour une modification, le chemin du document. Rien sur la machine Windows ne rend le nom utilisable tel qu’il est écrit.

Conditions qui n’arrêtent pas un build

Toutes les conditions ci-dessus arrêtent un build. Certaines conditions portent un code court et un message qui leur sont propres sans jamais en arrêter un, et elles sont cataloguées ici afin qu’un code que vous avez en main renvoie toujours à quelque chose, quelle que soit la page d’où vous venez.

Elles se répartissent en quatre types, et la différence mérite d’être connue avant de chercher une correction.

  • Un avertissement. Le build le signale et poursuit, et la sortie rendue est la même que vous y donniez suite ou non. Chacun est expliqué en entier dans warnings.md — ce qui le déclenche, à quel endroit de la compilation il est lu, ce qu’il affiche et ce qu’il faut faire — et les entrées ci-dessous indiquent quelle section, plutôt que de le répéter ici.
  • Une condition que l’éditeur absorbe. L’intégration de l’éditeur y répond elle-même, et elle n’atteint ni la sortie d’un build ni un diagnostic.
  • Un garde-fou derrière un refus antérieur. La règle qu’il protège est appliquée avant lui par une condition qui, elle, arrête le build, si bien qu’un build rencontre d’abord la condition antérieure.
  • Un refus sur une commande qui n’est pas un build. C’est un arrêt ferme avec un véritable remède — il met fin à la commande qui l’a rencontré, et rien n’est publié, écrit ou modifié — mais aucune étape de la compilation ne l’atteint, donc aucun build ne le signale. Publier ou signer un artefact, épingler les entrées d’une entité, ajouter un registre, modifier un document, transformer la description d’une source étrangère en fichiers de rédaction en brouillon, et vérifier un catalogue entier — pour sa correction ou au regard des conventions de publication — sont les situations où on les rencontre, et chaque entrée indique à quelle commande elle appartient et qui détient la correction.

An annotation binding declares one path in both pillar lists (Une liaison d’annotation déclare un même chemin dans les deux listes de piliers)

Un avertissement. Une liaison d’annotation du Manifest nomme le même chemin pointé à la fois dans sa liste maps.infra et dans sa liste maps.values. Déclarer ce chevauchement est légal et le compilateur ne le contrôle pas : le critère de départage du routage envoie de manière déterministe le chemin par infra, ce qui rend le côté values de ce chemin inaccessible depuis l’Aggregate.

Son message commence ainsi :

annotation binding declares one path in both pillar lists (une liaison d’annotation déclare un même chemin dans les deux listes de piliers)

C’est ce qui vous avertit avant qu’un build ne rencontre l’arrêt décrit ci-dessus sous « 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) » — l’avertissement est la surface précoce, cet arrêt est celle qui fait respecter la règle. Le lint est expliqué sous « Binding-map-overlap lint (Lint de chevauchement des maps de liaison) » dans warnings.md.

An attachment name is one edit from a declared slot (Un nom de rattachement est à une modification près d’un emplacement déclaré)

Un avertissement. Un composant rattache une Feature sous un nom qui n’est pas l’un des emplacements déclarés de son type mais qui se trouve à une seule modification de l’un d’eux — la structure que prend une faute de frappe dans un nom d’emplacement. Un rattachement sous un nom qu’aucun emplacement ne déclare est légal, donc rien ne s’arrête ; ce que l’avertissement nomme, c’est la conséquence, à savoir que le rattachement est un rattachement libre et non le remplissage de l’emplacement que vous vouliez, et que l’emplacement reste vide. Sur une connexion, la même faute de frappe n’est pas légale et provoque un arrêt à la place, qui nomme l’emplacement proche ; 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) ». Lorsque la Feature du rattachement satisfait le selector: de l’emplacement proche, l’avertissement n’est pas levé : cet appariement est jugé par l’arrêt décrit sous « 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) », qui le signale lorsque l’emplacement reste vide.

Son message commence ainsi :

attachment name is a near miss for a declared slot (le nom du rattachement est une quasi-correspondance avec un emplacement déclaré)

Expliqué sous « Attachment-slot near-miss lint (Lint de quasi-correspondance des emplacements de rattachement) » dans warnings.md, avec le seuil d’appariement et ce qu’il ne détecte délibérément pas.

A uses: socket name is one edit from a declared socket (Un nom de socket est à une modification près d’un socket déclaré)

Un avertissement. Le propre bloc uses: d’un composant nomme un socket que son type ne déclare pas mais qui se trouve à une seule modification de l’un d’eux. Un développeur possède la topologie que l’Aggregate déclare et peut nommer un socket que le catalogue n’avait pas anticipé, si bien qu’un nom de socket que le type ne déclare pas est légal sur cette surface et que rien ne s’arrête. Ce que l’avertissement nomme, c’est la conséquence : le nom mal orthographié trace une connexion ad hoc à part entière, sans sélecteur ni contrat par arête, tandis que le socket que vous vouliez reste non câblé.

Son message commence ainsi :

uses socket name is a near miss for a declared socket (le nom du socket uses est une quasi-correspondance avec un socket déclaré)

Expliqué sous « Uses-socket near-miss lint (Lint de quasi-correspondance des sockets uses) » dans warnings.md. Les deux surfaces voisines où un nom de socket absent du usesSchema de l’entité propriétaire provoque bel et bien un arrêt sont traitées ci-dessus sous « uses: socket not declared in the owning entity’s usesSchema (Socket non déclaré dans le schéma de sockets de l’entité propriétaire) ».

A Recipe publishes a provides key its Component does not declare (Une Recipe publie une clé que son Component ne déclare pas)

Un avertissement. La Recipe liée à un composant publie sous provides: une clé que le type du composant ne déclare pas dans son contrat spec.schema.provides:. Publier davantage que ce que le Component déclare est légal et le reste — le contrat exige le sous-ensemble et permet le sur-ensemble. Ce que l’avertissement nomme, c’est une conséquence invisible des deux côtés : un consommateur qui lit à travers une arête uses: voit le contrat déclaré de la cible, et non ce que sa Recipe émet, donc une clé non déclarée n’est pas livrée et un template consommateur qui la lit est rendu vide.

Son message commence ainsi :

Recipe publishes a provides key its Component does not declare (la Recipe publie une clé provides que son Component ne déclare pas)

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 provoque un arrêt. Expliqué sous « Undeclared-provides-key lint (Lint des clés provides non déclarées) » dans warnings.md.

A declared parameter is read by nothing (Un paramètre déclaré n’est lu par rien)

Un avertissement. Un Aggregate déclare une entrée sous spec.parameters: et aucune référence {{ .parameters.<key> }} dans le texte propre de cet Aggregate ne la lit, donc quoi qu’une Release fournisse pour elle, la sortie rendue est la même. Le compilateur ne contrôle pas quels réglages un auteur expose, et un paramètre peut légitimement être déclaré avant la référence qui le lira, donc ceci avertit plutôt que d’arrêter.

Son message commence ainsi :

declared parameter is read by no reference in the Aggregate (le paramètre déclaré n’est lu par aucune référence dans l’Aggregate)

Expliqué sous « Unread declared-parameter warnings (Avertissements de paramètres déclarés non lus) » dans warnings.md, y compris pourquoi une valeur par défaut n’est pas une exemption et quelles références la lecture peut voir ou non.

A provider binding names a capability no plugin the build reads serves (Une liaison de fournisseur nomme une capacité qu’aucun plugin lu par le build ne sert)

Un avertissement. Une entrée plugins.providers nomme une capacité et aucun plugin, et aucun des plugins de fournisseur que le build lit — dans les répertoires de catalogue, à l’intérieur du compilateur ou parmi ceux que le fichier de verrouillage enregistre — ne sert cette capacité. C’est la structure que prend une capacité mal orthographiée, et une telle entrée n’est lue par rien : une liaison n’est consultée que lorsqu’une Recipe demande sa capacité, et une liaison qui ne nomme aucun plugin ne sélectionne rien que la résolution de la capacité ne sélectionnerait pas sans elle.

Il avertit plutôt que d’arrêter parce que le build ne peut pas en être sûr. Les liaisons sont écrites une seule fois pour tout l’espace de travail alors qu’un build porte sur une seule Release, donc le plugin qui sert la capacité peut être un plugin que seule une autre Release lit. L’entrée qui nomme un plugin est jugée différemment, et provoque un arrêt là où elle est certainement erronée — voir ci-dessus « A plugins.providers binding names a plugin that does not serve the capability (Une liaison nomme un plugin qui ne sert pas la capacité) ».

Son message commence ainsi :

plugins.providers entry names a capability no provider-rendering plugin the build reads serves (l’entrée plugins.providers nomme une capacité qu’aucun plugin de rendu de fournisseur lu par le build ne sert)

et se poursuit avec la capacité, puis avec une capacité servie à une modification près, lorsqu’il en existe une. Expliqué sous « Provider-binding unserved-capability warning (Avertissement de capacité non servie d’une liaison de fournisseur) » dans warnings.md.

An editor position falls outside the document (Une position de l’éditeur tombe hors du document)

Une condition que l’éditeur absorbe. Les fonctionnalités de l’éditeur qui dépendent de l’emplacement de votre curseur — aller à la définition, survol, complétion — localisent d’abord le curseur dans la structure analysée du document. Cette condition est ce que cette étape signale lorsque la position désigne une ligne que le document n’a pas, ce qui se produit de façon transitoire pendant qu’une modification est en cours et que la position envoyée par l’éditeur a été mesurée sur un texte que le document a déjà dépassé.

Son message est :

position out of range (position hors limites)

Elle n’atteint aucun build ni aucun diagnostic. Toute fonctionnalité susceptible de la rencontrer répond sans résultat plutôt que de faire remonter une erreur, ce qui est le comportement que demande le protocole de l’éditeur : une requête à laquelle on ne peut pas répondre ne renvoie rien, et l’éditeur redemande après la frappe suivante.

Il n’y a rien à corriger dans vos fichiers, et rien n’apparaît dans un build. Une fonctionnalité qui reste sans réponse au lieu de se rétablir à la modification suivante mérite d’être signalée comme un défaut.

The schema-merge step’s own input guard (Le garde-fou d’entrée propre à l’étape de fusion des schémas)

Un garde-fou qu’un build n’atteint pas. Lorsqu’un Component ou une Feature en étend un autre et que tous deux déclarent des schémas, ces schémas sont combinés en un seul. La bibliothèque qui effectue la combinaison refuse une entrée qu’elle ne peut pas fusionner structurellement :

merger: invalid merge input (merger: entrée de fusion non valide)

Il appartient à l’étape de combinaison, qu’un build atteint bel et bien chaque fois qu’une entité qui en étend une autre et sa base déclarent toutes deux des schémas. Ce contre quoi il protège, c’est de recevoir une chaîne vide, ou une entrée de chaîne dont le schéma est absent — et l’appelant ne peut lui transmettre ni l’une ni l’autre : il n’assemble la chaîne qu’à partir de schémas qu’il a déjà trouvés présents, et ne combine que lorsque cette chaîne n’est pas vide.

Le garde-fou reste parce qu’il est le refus d’une entrée malformée par une bibliothèque exportée. Le supprimer ne supprimerait aucun arrêt qu’un build puisse atteindre ; cela transformerait un refus clair en plantage pour un appelant extérieur au compilateur qui transmettrait une telle entrée, ce qui est strictement pire.

La chaîne elle-même ne relève pas de cette étape. Une chaîne qui boucle et une chaîne qui dépasse la borne de profondeur sont refusées par l’unique parcours de extends: avant qu’un schéma ne soit combiné — voir ci-dessus « Cyclic extends chain (Chaîne extends cyclique) » et « An extends: chain runs past the depth bound (Une chaîne d’extension dépasse la borne de profondeur) ».

Il est catalogué parce qu’il est déclaré et porte un code qui lui est propre, si bien qu’un code que vous avez en main renvoie à quelque chose. Rien de ce que vous pouvez rédiger n’en produit un, et en rencontrer un signifierait que l’agencement décrit ci-dessus ne tient plus — cela mérite d’être signalé comme un défaut plutôt que contourné.

An explicit value displaced one an annotation supplied (Une valeur explicite a supplanté celle qu’une annotation fournissait)

Un avertissement. L’expansion pilotée par les annotations transforme une annotation que porte un Aggregate ou une Release en un rattachement de Feature doté de sa propre configuration. Lorsque le même rattachement porte aussi une configuration écrite explicitement — sur le composant, sur une portée au-dessus de lui ou dans la Release —, la valeur explicite l’emporte sur chaque clé que les deux couvrent. C’est la règle voulue et la sortie émise n’est pas erronée, donc le build se termine. Ce que l’avertissement nomme, c’est la conséquence : la contribution de l’annotation à cette clé n’est plus visible nulle part dans la sortie, et l’auteur qui a écrit l’annotation peut ne pas savoir qu’elle a été supprimée.

Il signale chaque supplantation plutôt que seulement celles qui ont changé quelque chose. La fusion écrase la valeur supprimée, il ne reste donc aucune comparaison à faire ni rien qui puisse dire si les deux concordaient — la trace qu’une supplantation a eu lieu est l’intégralité de la preuve. Il est lu une fois que toute la cascade des rattachements et l’expansion ont été réunies, ce qui est le premier moment où cette trace existe.

Son message commence ainsi :

annotation contribution overridden by an explicit value (contribution de l’annotation remplacée par une valeur explicite)

et se poursuit avec l’annotation qui a été supplantée, puis les coordonnées de la clé qui l’a supplantée, puis l’endroit où l’annotation supplantée a été écrite. La position qui le précède est le document où se trouve le constat et la clé qu’il contient :

<file> at <authored key>: annotation contribution overridden by an explicit value ("<annotation-key>", component "<component>", attachment "<attachment>", pillar "<pillar>", key "<the key at issue>", annotation declared at "<where the annotation was written>") (dans le fichier et à la clé indiqués : contribution de l’annotation remplacée par une valeur explicite (annotation, composant, rattachement, pilier, clé en cause et endroit où l’annotation a été déclarée indiqués))

Deux de ces valeurs se lisent facilement de travers. La valeur component n’est nommée que lorsque l’entrée qui supplante a un composant : une entrée écrite pour toute une portée n’a pas de composant propre, et en nommer un qu’elle n’a jamais eu enverrait un lecteur vers une clé que personne n’a écrite. Et annotation declared at nomme l’endroit où l’annotation supplantée a été écrite, c’est-à-dire la portée dont elle a été héritée partout où elle n’a pas été écrite sur le composant qui l’a supplantée — ce n’est donc pas la clé du composant répétée sous une autre légende.

Que faire : rien, lorsque la valeur explicite est celle que vous vouliez. L’avertissement existe pour que la précédence soit un choix plutôt qu’une surprise. Lorsque ce n’est pas ce que vous vouliez, il y a deux façons d’en sortir, et elles diffèrent par leur portée. Supprimez l’entrée explicite, et la valeur de l’annotation parvient jusqu’à cette clé. Ou retirez l’annotation du composant ou de la portée qui la porte, et aucune contribution n’est faite — ce qui affecte aussi toutes les autres clés que cette annotation fournit. Lorsque les deux côtés sont voulus mais pour des clés différentes, restreignez celui qui va plus loin que prévu afin que les deux ne se chevauchent plus.

A connection crosses between two different providers’ assembled outputs (Une connexion passe entre les sorties assemblées de deux fournisseurs différents)

Lorsque les deux extrémités d’une connexion de dépendance s’assemblent dans des sorties différentes, un fournisseur qui annonce le lien entre frontières la câble nativement — en publiant une référence du côté producteur et en la résolvant du côté consommateur. Ce câblage est écrit dans le vocabulaire propre d’un fournisseur, et un fournisseur ne peut pas résoudre une référence qu’un autre a publiée. Une connexion dont les deux extrémités sont rendues par des fournisseurs différents n’est donc câblée par aucun des deux.

Ceci avertit et n’arrête pas le build. La connexion porte toujours sa valeur : le contrat d’injection achemine le scalaire du côté producteur jusqu’au côté consommateur exactement comme partout ailleurs, si bien que ce qui subsiste est une connexion fonctionnelle câblée de la manière ordinaire plutôt qu’une connexion cassée. Ce que le constat vous indique, c’est que le câblage natif auquel vous vous attendiez peut-être n’a pas eu lieu — et la sortie est inchangée que vous y donniez suite ou non.

Il suffit qu’un fournisseur annonce le lien pour que ce soit signalé. Les deux extrémités n’ont pas besoin de le revendiquer : une seule revendication signifie que le câblage natif était attendu et qu’il est impossible, et l’auteur qui a rattaché ce fournisseur est celui qui le voulait. Exiger les deux revendications ne dirait rien dans la Release mixte ordinaire, où un fournisseur établit le lien et l’autre non, ce qui est précisément le cas visé.

L’endroit où les extrémités ont été placées n’entre pas en compte. Une sortie assemblée est identifiée par son chemin et son fournisseur ensemble, si bien que deux extrémités dont les fournisseurs diffèrent se trouvent toujours dans des sorties différentes, quel que soit leur placement. Ce qui est lu, ce sont les deux fournisseurs et leurs deux revendications.

Il est signalé une fois par connexion de ce type, positionné sur le document et la clé où la connexion a été écrite.

Message émis, qui commence par l’extrémité distante puis nomme le socket et le fournisseur de chaque extrémité :

cross-boundary link between endpoints rendered by different providers is not supported ("<target-component>", socket "<socket>", consumer provider "<provider>", target provider "<provider>") (le lien entre frontières entre des extrémités rendues par des fournisseurs différents n’est pas pris en charge (composant cible, socket, fournisseur du consommateur et fournisseur cible indiqués))

Comment corriger : lorsque la valeur scalaire que la connexion porte déjà suffit, il n’y a rien à faire — il s’agit d’un avis plutôt que d’une faute. Lorsque le câblage natif est voulu, les deux extrémités doivent être rendues par un seul fournisseur : déplacez une extrémité dans une frontière qui passe par le fournisseur de l’autre, ou servez les deux capacités avec un seul. Lorsque ni l’un ni l’autre n’est possible, la forme qui porte la valeur est celle dont dispose la Release, et la connexion fonctionne.

A command-line plugin runner was built without a way to find plugins (Un exécuteur de plugins en ligne de commande a été construit sans moyen de trouver les plugins)

Un plugin qui apporte une commande de terminal est exécuté par un composant qui doit d’abord transformer la référence du plugin en octets. Cette condition signale que ce composant a été construit sans la partie qui effectue cette transformation, si bien qu’il n’existe aucun chemin de la référence vers quoi que ce soit à exécuter.

Elle concerne une commande de terminal plutôt qu’un build, donc aucune étape de la compilation ne l’atteint : elle est levée là où une commande installée est aiguillée, et la réponse qu’elle produit est l’échec du démarrage de cette commande plutôt qu’un arrêt dans un build.

Aucun chemin de l’outil en ligne de commande livré ne peut la lever. Chaque endroit où l’outil construit ce composant fournit la fonction de recherche, si bien que le garde-fou ne se déclenche que là où autre chose le construit en omettant la fonction de recherche.

Message émis, qui est la phrase propre de la condition :

cliplugin: no plugin resolver configured (cliplugin: aucun résolveur de plugins configuré)

Comment corriger : rien dans vos fichiers d’entités ne provoque cela, et rien de ce que vous pouvez écrire dans un catalogue ou un espace de travail ne le fait disparaître. Lorsque vous exécutez l’outil en ligne de commande publié, ce n’est pas une condition que vous pouvez atteindre — une commande installée qui ne démarre pas signale autre chose, et le message qu’elle a affiché est celui à lire. Lorsque vous intégrez l’exécuteur de plugins dans votre propre logiciel, fournissez, en le construisant, la fonction de recherche qui résout une référence de plugin en ses octets.

A registry alias is already bound to another host (Un alias de registre est déjà lié à un autre hôte)

Un refus lors de l’ajout d’un registre à l’espace de travail, et non lors d’un build. Un alias est un nom court qui sélectionne une entrée de registre, il est donc unique parmi les entrées. L’enregistrement d’un alias déjà détenu par un hôte différent est refusé plutôt que de le laisser masquer la liaison existante, ce qui changerait silencieusement la cible de chaque référence utilisant cet alias.

Ajouter de nouveau le même hôte sous son alias existant n’est pas un conflit — cela met à jour l’entrée sur place, ce que fait la réexécution de la commande pour changer les autres paramètres d’un hôte.

Message émis, qui nomme l’alias et l’hôte qui le détient déjà :

workspaceconfig: registry alias "<alias>" is already used by host "<host>"; choose a different alias or address that host directly: registry alias is already used by another host (workspaceconfig: l’alias de registre indiqué est déjà utilisé par l’hôte indiqué ; choisissez un autre alias ou adressez-vous directement à cet hôte : l’alias de registre est déjà utilisé par un autre hôte)

Comment corriger : la correction revient à l’opérateur, en ligne de commande. Donnez au nouveau registre un alias différent, ou laissez-le sans alias et désignez-le par son hôte. Si vous vouliez déplacer l’alias vers le nouvel hôte, retirez-le d’abord de l’entrée que le message nomme dans .aggrega-config.yaml — le refus existe pour que déplacer un alias soit une chose que vous faites exprès plutôt qu’un effet secondaire de l’ajout d’un registre.

A registry serves a trust document that cannot be read as one (Un registre sert un document de confiance qui ne peut pas être lu comme tel)

Un refus lors de l’ajout d’un registre, et non lors d’un build. Un registre peut publier les identités de signature par lesquelles il s’attend à ce que les artefacts soient signés, afin que l’ajout du registre puisse les épingler au lieu d’obliger un opérateur à les retranscrire. Cette condition signale un registre qui a répondu par un document qui n’est pas utilisable comme politique de confiance.

C’est un refus ferme précisément parce que le point de terminaison a répondu. Un registre qui ne publie rien est une issue ordinaire et attendue, qui est tolérée ; un registre qui publie quelque chose d’illisible est une mauvaise configuration, et n’en épingler rien laisserait le registre silencieusement non épinglé tout en ayant l’air de l’avoir été.

Trois structures sont signalées ici : un contenu qui ne se décode pas du tout, y compris un document portant un champ que le format ne définit pas ; une entrée d’identité qui ne nomme ni une identité exacte ni un motif ; et une entrée d’identité sans émetteur. Les deux dernières sont refusées parce qu’une telle entrée ne peut jamais correspondre à une signature, si bien qu’elle affaiblirait l’épinglage tout en paraissant le renforcer.

Messages émis. Contenu qui ne se décode pas :

registrytrust: advertised trust config is malformed: <what the decoder reported> (registrytrust: la configuration de confiance annoncée est malformée, suivie de ce qu’a signalé le décodeur)

une entrée d’identité sans rien sur quoi établir une correspondance :

registrytrust: advertised trust config is malformed: <list>[<index>]: an identity entry must set identity or identity_regexp (registrytrust: la configuration de confiance annoncée est malformée : dans la liste et à l’index indiqués, une entrée d’identité doit définir identity ou identity_regexp)

et une sans émetteur :

registrytrust: advertised trust config is malformed: <list>[<index>]: an identity entry must set issuer (registrytrust: la configuration de confiance annoncée est malformée : dans la liste et à l’index indiqués, une entrée d’identité doit définir issuer)

Chacun est encadré par la commande qui l’a rencontré :

aggrega registry add: <the message above> (aggrega registry add: le message ci-dessus)

Comment corriger : la correction revient à celui qui exploite le registre, pas à vous — transmettez-lui le message, car il nomme l’entrée exacte et ce qui lui manque. Pour avancer entre-temps, ajoutez le registre sans épingler la politique qu’il annonce et fournissez vous-même les identités ou la clé ; la commande les accepte directement, ce que vous faites aussi pour un registre qui ne publie aucune politique.

A registry publishes no trust document (Un registre ne publie aucun document de confiance)

Une issue ordinaire et attendue plutôt qu’une faute, et elle n’arrête rien. Un registre peut publier les identités de signature qu’il attend, et la plupart ne le font pas. Interrogé, un tel registre répond qu’il n’en a pas, et l’ajout du registre se poursuit — l’issue est signalée comme un avis et les identités sont épinglées à la main à la place.

Elle est délibérément distincte d’un registre qui n’a pas pu être joint. Celui-ci a répondu ; la réponse était qu’il ne publie aucune politique. Tenir les deux à part, c’est ce qui permet de tolérer une absence délibérée tout en laissant un problème d’accessibilité visible en tant que tel.

Signalée comme un avis, qui nomme le registre, ce qu’il a répondu et ce qu’il faut faire à la place :

Notice: <host> publishes no trust policy (HTTP 404); pin its trust by hand with —identity or —key (Avis : l’hôte indiqué ne publie aucune politique de confiance (HTTP 404) ; épinglez sa confiance à la main avec —identity ou —key)

La condition sous laquelle elle est enregistrée est registrytrust: registry advertises no trust config.

Le hub officiel est l’exception : il embarque une base de référence intégrée, donc lorsqu’il ne publie aucun document, c’est cette base de référence qui est épinglée à la place, et l’avis indique ce que le hub a répondu et que la base de référence est utilisée à sa place plutôt que de vous demander d’épingler des identités.

Comment corriger : rien n’est cassé. Si vous voulez que les signatures de ce registre soient vérifiées, fournissez l’identité ou la clé lors de son ajout, exactement comme le dit l’avis — c’est le chemin normal pour un registre qui ne publie aucune politique. Sinon, le registre est ajouté sans position de signature et les artefacts qui en proviennent ne sont vérifiés que lorsqu’ils portent une signature.

A registry is added offline with no trust policy to pin (Un registre est ajouté hors ligne sans politique de confiance à épingler)

Un refus lors de l’ajout d’un registre, et non lors d’un build. L’ajout d’un registre est le seul moment où sa confiance est épinglée : les identités de signature qu’il annonce sont récupérées une fois, et chaque pull ultérieur vérifie par rapport à cette copie épinglée. Lorsque l’espace de travail est hors ligne, cette récupération ne peut pas avoir lieu, donc le registre n’est jamais interrogé. Plutôt que d’écrire une entrée qui ne fait confiance à rien — et à laquelle chaque pull ultérieur soumettrait le registre —, l’ajout d’un registre autre que le hub officiel est refusé à moins que vous ne fournissiez vous-même la politique.

Trois cas ne sont pas refusés. Fournir des identités ou une clé enregistre exactement celles-ci et n’effectue aucune récupération, donc cela fonctionne de la même façon hors ligne qu’en ligne. Le hub officiel est ajouté sur sa base de référence intégrée, qu’il porte que la récupération ait lieu ou non. Et demander l’absence de récupération — --fetch-trust=false — enregistre l’entrée à partir des options, exactement comme en ligne.

On le rencontre partout où un registre est ajouté : aggrega registry add, aggrega config init --registry <host>, les requêtes aggrega/registryAdd et aggrega/configInit de aggrega serve, dont le message d’erreur porte le code court devant la phrase, et les outils d’enregistrement de aggrega mcp, qui exécutent ces commandes. L’initialisation d’une configuration n’accepte ni identités ni clé, donc hors ligne elle ne peut initialiser que le hub ; ajoutez plutôt tout autre registre avec aggrega registry add.

Message émis, qui est la phrase propre de la condition :

a registry other than the official hub is not registered offline without a trust policy supplied by hand, because the policy it advertises cannot be fetched; register it once while online, or pin its trust by hand with aggrega registry add <host> --identity <identity>=<issuer> or --key <public-key-file> (un registre autre que le hub officiel n’est pas enregistré hors ligne sans politique de confiance fournie à la main, car la politique qu’il annonce ne peut pas être récupérée ; enregistrez-le une fois en ligne, ou épinglez sa confiance à la main avec une identité et son émetteur ou avec un fichier de clé publique)

encadré par la commande qui l’a rencontré et par le registre qu’il nomme :

aggrega registry add: <host>: <the message above> (aggrega registry add: l’hôte indiqué, puis le message ci-dessus)

Comment corriger : enregistrez le registre une fois pendant que l’espace de travail est en ligne — passez --offline=false pour cette seule exécution, ou effacez le paramètre offline — afin que sa politique annoncée soit récupérée et épinglée ; rien n’est à répéter ensuite, puisque les pulls ultérieurs vérifient par rapport à la copie épinglée. Si vous ne pouvez pas passer en ligne, fournissez la politique à la main : une ou plusieurs entrées --identity <identity>=<issuer> pour un registre sans clé, ou --key pointant vers son fichier de clé publique pour un registre à clé, c’est-à-dire ce que vous auriez épinglé à partir de son annonce.

A tag is already published with different content (Un tag est déjà publié avec un contenu différent)

Un refus lors de la publication, et non lors d’un build. Les octets publiés sont figés : avant que quoi que ce soit ne soit téléversé, la version cible est recherchée et le digest vers lequel elle pointe est comparé au digest que produirait le contenu en main. Une version pointant déjà vers un contenu différent est refusée.

Republier un contenu identique octet pour octet n’est pas un conflit. Les digests correspondent, rien n’est téléversé, et la commande signale que la version est déjà publiée — relancer une publication partiellement réussie est donc sans risque, et cela complète la publication : la date de publication qui manque encore à la version, ainsi que sa signature lorsque le push signe, sont attachées, et une version à laquelle ne manque ni l’une ni l’autre ne reçoit rien, comme le décrit Compléter une publication qu’un push antérieur a laissée partielle.

Aucune option ne permet de passer outre. Un contenu modifié est publié sous une nouvelle version, ce qui laisse aux consommateurs une version vers laquelle migrer délibérément plutôt qu’une version qui a changé à leur insu.

Messages émis, nommant la version, le digest qu’elle contient et le digest proposé. Lors de la publication d’une entité de catalogue, qui nomme aussi la vérification qui contrôle la montée de version :

aggrega push: <reference>:<version> is already published as <existing digest>; refusing to overwrite with <proposed digest> — publish a new version (aggrega lint —pre-publish verifies the bump): oci: tag already published with different content (aggrega push: la version indiquée est déjà publiée avec le digest existant indiqué ; refus de l’écraser avec le digest proposé — publiez une nouvelle version (aggrega lint —pre-publish vérifie la montée de version) : oci: tag déjà publié avec un contenu différent)

et lors de la publication d’un artefact de données :

aggrega push-artifact: <reference>:<version> is already published as <existing digest>; refusing to overwrite with <proposed digest> — publish a new version: oci: tag already published with different content (aggrega push-artifact: la version indiquée est déjà publiée avec le digest existant indiqué ; refus de l’écraser avec le digest proposé — publiez une nouvelle version : oci: tag déjà publié avec un contenu différent)

Comment corriger : augmentez la version et publiez à nouveau. Pour une entité de catalogue, cela signifie metadata.version et le répertoire par version dans lequel se trouve l’entité, qui changent ensemble. Avant cela, vérifiez que la modification est bien voulue : deux digests qui diffèrent sur une version que vous pensez ne pas avoir touchée signifient que le contenu sur disque n’est pas le contenu qui a été publié, et comprendre pourquoi vaut mieux que de publier par-dessus. La vérification préalable à la publication nommée dans le message compare une version à la précédente et permet de confirmer que la montée de version est correcte.

An entity shares its directory with another entity (Une entité partage son répertoire avec une autre entité)

Un refus lors de l’épinglage et de la publication, et non lors d’un build. Chaque type d’entité a son propre répertoire, sauf les trois qu’une racine d’espace de travail contient côte à côte : un Aggregate, une Release et un Manifest. Une entité publiée est un artefact à une coordonnée pour chaque version, et le répertoire dans lequel elle est rédigée le reflète — l’étape d’épinglage écrit l’unique fichier entity.lock qu’un répertoire peut accueillir, et une publication empaquette l’entité depuis son répertoire. Ainsi, une entité de tout autre type ayant une autre entité à côté d’elle est refusée à ces deux moments : par aggrega pin, par un pull ou un push auquel on demande d’épingler au nom de l’auteur, et par aggrega push, qu’il épingle ou non. Elle est refusée avant que quoi que ce soit ne soit récupéré, et rien n’est écrit.

Un répertoire contenant plusieurs entités se charge, passe le lint, se valide et se construit quand même. La disposition n’est jugée que lorsque quelque chose est produit à partir du répertoire, ce qui est aussi le moment où le message peut nommer l’entité qui fait obstacle. Un pull qui n’épingle pas n’écrit rien à côté de l’entité et n’est pas refusé.

Ce qui compte comme entité à côté est tout autre document YAML situé directement dans le même répertoire dont le kind: est un type d’entité. Les fichiers propres d’un chart, un fragment compose, un manifeste Kubernetes ou un README ne sont pas des entités, et un sous-répertoire — un chart local, une arborescence source/ — n’est pas à côté de l’entité, quel que soit son contenu. Seuls le type et le nom de chaque voisin sont lus, donc rien de ce qu’un voisin déclare ne peut changer la réponse.

Le nom du répertoire n’est pas jugé. Une entité seule dans son répertoire est épinglée et publiée à la version qu’elle déclare, où que se trouve ce répertoire ; la disposition <name>/<version>/ qu’utilise le catalogue de la bibliothèque standard est une convention et non une vérification.

Message émis, nommant l’entité, chaque entité à côté d’elle et les fichiers à déplacer :

the entity shares its directory with another entity, and an entity of its kind has a directory of its own (Recipe "<name>", beside it: Recipe "<name>" in <file>). remediation: give each entity a directory of its own — move <file> into a directory of its own, together with any file only that entity reads; only the Aggregate, Manifest and Release kinds may share a directory with other entities (l’entité partage son répertoire avec une autre entité, et une entité de son type a son propre répertoire (la Recipe indiquée et, à côté d’elle, la Recipe indiquée dans le fichier indiqué). remède : donnez à chaque entité son propre répertoire — déplacez le fichier indiqué dans un répertoire qui lui est propre, avec tout fichier que seule cette entité lit ; seuls les types Aggregate, Manifest et Release peuvent partager un répertoire avec d’autres entités)

Comment corriger : déplacez chaque entité que nomme le message dans son propre répertoire, en emportant les fichiers qu’elle seule lit — un chart local, un fichier importé, et le fichier entity.lock s’il enregistre les épinglages de cette entité — et exécutez aggrega pin sur chacune de celles qui lisent une source distante ou importent un fichier, afin que chaque lock enregistre sa propre entité. Disposer chacune sous la forme <kind>/<provider-or-publisher>/…/<name>/<version>/ la place là où le catalogue de la bibliothèque standard place chaque entité. Un répertoire de catalogue est trouvé en le parcourant, donc un build sur le catalogue rend la même sortie après le déplacement.

An entity kind has no artifact media type (Un type d’entité n’a pas de type de média d’artefact)

Un refus lors de la publication, et non lors d’un build. Chaque type d’entité publiable a un type de média pour chacune des deux formes que prend son artefact — son document seul, ou une archive du document et des fichiers qu’il déclare — et l’empaquetage d’une entité le recherche par type. Cette condition signale un type sans entrée.

Aucun build ne l’atteint. Le seul autre endroit où la même recherche s’exécute traite une entrée manquante comme « ceci n’est pas une bibliothèque » et poursuit, donc la condition n’y est jamais remontée.

Message émis, la phrase propre à la condition encadrée par la commande et le fichier qu’elle empaquetait :

aggrega push: bundle <path>: oci: unknown entity kind for mediatype dispatch (aggrega push: bundle au chemin indiqué : oci: type d’entité inconnu pour la sélection du type de média)

Comment corriger : comparez le champ kind: du fichier que vous publiez aux types qu’affiche aggrega push --list-kinds — un type mal orthographié ou non pris en charge est signalé ici, et corriger le champ est tout le remède. Si le type figure dans cette liste, il s’agit d’une lacune de la chaîne d’outils et non de votre entité, et cela vaut la peine de la signaler en citant le type.

A published archive carries an entry Windows cannot use (Une archive publiée contient une entrée que Windows ne peut pas utiliser)

Un avertissement levé lorsqu’une entité est publiée ; il n’arrête jamais rien, et un build ne le lève pas. Une entité qui apporte des fichiers à côté de son document est publiée sous forme d’archive, et chaque nom que contient l’archive — le nom de fichier propre du document de l’entité, puis chaque fichier qu’elle apporte — est jugé selon la règle que l’arrêt « A name the operation writes holds a part Windows cannot hold (Un nom que l’opération écrit contient une partie que Windows ne peut pas contenir) » ci-dessus applique sous Windows : une partie que Windows réserve à un périphérique, quelle que soit la casse et quelle que soit l’extension qui la suit, ou une partie se terminant par un point ou une espace. Ainsi aux/x.yaml le provoque pour son répertoire aux, report. pour son point final, et un document nommé con.yaml qui importe un fichier de schéma pour son propre nom. Une entité qui n’apporte rien est publiée comme son seul document, disposé sous un nom que choisit le produit, et un Plugin ne publie aucune archive, donc ni l’un ni l’autre ne le provoque.

Il est levé sur toutes les plateformes, et il ne refuse rien. Un espace de travail sous Windows refuse de disposer une telle entrée, sous cet arrêt, et ne peut donc pas utiliser la version ; l’avertissement est la façon dont l’éditeur l’apprend avant que quelqu’un sous Windows ne le fasse. La publication, ou son exécution à blanc, se poursuit ou s’arrête exactement comme elle le ferait sans lui.

Chaque surface qui publie une entité le lève, chacune sous sa propre forme. aggrega push, et son --dry-run, affiche une ligne par entrée sur la sortie d’erreur standard, chacune commençant par warning: . L’outil publish-entity de l’assistant répond avec les entrées sous windows_unusable_entries, et le texte de la réponse les nomme aussi. aggrega serve répond à aggrega/publishEntity avec elles sous windowsUnusableEntries, et transmet les lignes d’avertissement elles-mêmes à une requête qui a demandé à en être informée. Chaque réponse omet le champ lorsqu’il n’y a aucune entrée de ce genre.

Son message commence ainsi :

an entry this publication carries cannot be used on Windows (une entrée que porte cette publication ne peut pas être utilisée sous Windows)

et se poursuit avec l’entrée et la première de ses parties que Windows ne peut pas contenir, puis le remède. Expliqué sous « A published archive carries an entry Windows cannot use (Une archive publiée contient une entrée que Windows ne peut pas utiliser) » dans warnings.md.

Comment corriger : renommez la partie que nomme le message, sur disque et partout où les déclarations de l’entité nomment le fichier, puis publiez à nouveau. Si la version n’est pas destinée à être utilisée sous Windows, rien n’est à changer.

Two catalog identities publish to one repository location (Deux identités de catalogue publient vers un même emplacement de dépôt)

Un refus lors de la vérification d’un catalogue entier, et non lors d’un build. L’endroit où une entité est publiée est dérivé de son identité et mis en minuscules, donc deux identités qui ne diffèrent que par la casse aboutissent au même endroit. Publier les deux laisserait les octets d’une entité écrasés par ceux de l’autre, et rien dans l’une ou l’autre entité ne le signalerait.

La vérification porte sur tout le catalogue à la fois, car une collision est une propriété d’une paire et non de l’une ou l’autre entité prise isolément — aucune n’est erronée en elle-même, et lire l’une ou l’autre isolément ne montre rien.

Message émis. Le cadre de la vérification du catalogue l’ouvre, puis viennent la phrase propre à la condition, puis chaque groupe en collision, chacun nommant l’emplacement partagé et les identités qui l’atteignent :

catalog validation failed: oci: distinct catalog identities map to the same OCI repository location: (la validation du catalogue a échoué : oci: des identités de catalogue distinctes correspondent au même emplacement de dépôt OCI)

  • <location> <- <identity>, <identity>

Comment corriger : renommez l’une des entités que nomme le message, dans son metadata.name et dans le répertoire qui le reflète. Le choix de celle à renommer vous appartient ; les paires ne différant que par la casse sont la forme courante, et choisir une graphie et l’utiliser de façon cohérente est ce qui empêche la paire de se reproduire. Renommer est un vrai changement de l’identité d’une entité, donc tout ce qui fait référence à l’ancien nom doit suivre — c’est une raison de régler la collision avant que l’un ou l’autre nom ne soit publié plutôt qu’après.

Keyless signing was asked for without the services it needs (La signature sans clé a été demandée sans les services dont elle a besoin)

Un refus lors de la signature pendant la publication, et non lors d’un build. La signature sans clé n’a pas de forme hors ligne : elle obtient une identité, fait émettre un certificat de courte durée pour celle-ci, enregistre la signature là où elle pourra être vérifiée plus tard, puis jette la clé. Chacune de ces étapes est un échange avec un service en fonctionnement. Cette condition signale que l’identité dont part le flux n’était pas disponible, donc le flux est refusé plutôt que démarré puis abandonné en cours de route.

Deux formes la signalent : rien n’est configuré pour fournir une identité, ou quelque chose est configuré mais n’a rien produit.

Un espace de travail hors ligne le signale différemment, sous le refus qui couvre chaque étape réseau, car le refus se produit avant même qu’une identité ne soit demandée.

Messages émis. Aucune source d’identité :

signing: keyless signing requires a live identity provider, Fulcio, and Rekor: an identity token source is required (signing: la signature sans clé nécessite un fournisseur d’identité actif, Fulcio et Rekor : une source de jeton d’identité est requise)

et une source qui n’a rien produit :

signing: keyless signing requires a live identity provider, Fulcio, and Rekor: an identity token is required (signing: la signature sans clé nécessite un fournisseur d’identité actif, Fulcio et Rekor : un jeton d’identité est requis)

Comment corriger : la correction revient à l’opérateur, dans la manière dont la publication est exécutée. Dans un pipeline automatisé, l’identité provient des propres identifiants du pipeline, donc cela signifie généralement que le job n’a pas reçu l’autorisation qui les délivre. En exécution interactive, l’identité provient de la connexion, que la commande vous demandera d’effectuer. Si vous ne voulez pas du tout d’identité active, signez plutôt avec une clé détenue — ce chemin n’a besoin d’aucun de ces services, et c’est celui à utiliser depuis un environnement qui ne peut pas les joindre.

An unsigned publish targets a registry or a policy that requires a signature (Une publication non signée vise un registre ou une politique qui exige une signature)

Un refus lors de la publication, et non lors d’un build. Là où une signature est exigée, le contenu non signé n’est pas publié. La vérification s’exécute avant que le moindre octet ne soit téléversé, donc rien de partiel n’atteint le registre.

Deux conditions, car une exigence a deux sources et les remèdes diffèrent. L’une est la position propre du registre de destination, qui s’applique à tout ce qui y est publié. L’autre est la politique de signature de l’espace de travail, qui couvre un ensemble de types d’artefacts où qu’ils soient publiés. Lorsque les deux s’appliquent, c’est celle du registre qui est signalée, car nommer la destination est la plus utile des deux.

Aucune option ne permet ici de publier un contenu non signé. Désactiver explicitement la signature n’assouplit pas le refus — cela ne change que la valeur par défaut pour les artefacts dont la signature est facultative.

La signature est produite avant le téléversement et non après, donc un échec de signature aboutit lui aussi ici et rien n’est publié.

Messages émis. L’exigence propre du registre :

aggrega push: registry "<host>" requires signatures; re-run signing the artifact (there is no flag to push unsigned content here): signing: registry requires signatures; refusing to push unsigned content (aggrega push: le registre indiqué exige des signatures ; relancez en signant l’artefact (aucune option ne permet ici de pousser un contenu non signé) : signing: le registre exige des signatures ; refus de pousser un contenu non signé)

celle de la politique de l’espace de travail, qui nomme le type ayant fait entrer l’artefact dans sa portée :

aggrega push: the signing policy requires a signature for kind "<kind>"; re-run signing the artifact (there is no flag to push unsigned content here): signing: signing policy requires a signature for this artifact kind; refusing to push unsigned content (aggrega push: la politique de signature exige une signature pour le type indiqué ; relancez en signant l’artefact (aucune option ne permet ici de pousser un contenu non signé) : signing: la politique de signature exige une signature pour ce type d’artefact ; refus de pousser un contenu non signé)

et une signature qui n’a pas pu être produite, signalée sous la condition du registre et citant l’échec sous-jacent :

aggrega push: sign <reference>:<version>: <the underlying failure>: signing: registry requires signatures; refusing to push unsigned content (aggrega push: signature de la version indiquée : l’échec sous-jacent indiqué : signing: le registre exige des signatures ; refus de pousser un contenu non signé)

Une forme d’échec de signature est nommée spécifiquement, car un rejet générique pousse les gens à obtenir de nouveau un identifiant qui ne peut pas aider :

aggrega push: sign <reference>:<version>: the identity token carries no verified email or subject claim — the OIDC flow/client did not return an email-scoped identity (re-exporting or re-acquiring the token will not help); configure the identity provider/client/scope to return one: <the underlying failure>: signing: registry requires signatures; refusing to push unsigned content (aggrega push: signature de la version indiquée : le jeton d’identité ne porte aucune revendication e-mail ou subject vérifiée — le flux/client OIDC n’a pas renvoyé d’identité de portée e-mail (réexporter ou obtenir de nouveau le jeton n’aidera pas) ; configurez le fournisseur d’identité/le client/la portée pour en renvoyer une : l’échec sous-jacent indiqué : signing: le registre exige des signatures ; refus de pousser un contenu non signé)

Comment corriger : la correction revient à l’opérateur. Signez l’artefact et publiez à nouveau — soit avec une clé détenue, soit par la voie sans clé, selon ce pour quoi l’espace de travail est configuré. Si vous ne vous attendiez pas à ce qu’une signature soit exigée, le message indique quelle source l’a exigée : la position propre d’un registre se trouve dans l’entrée de ce registre dans .aggrega-config.yaml, et l’exigence limitée à un type se trouve dans la politique de signature de tout l’espace de travail. Assouplir l’une ou l’autre est une décision sur ce que vous acceptez de publier sans signature, donc restreindre la portée de la politique vaut généralement mieux que la désactiver.

References signed together need different signing credentials (Des références signées ensemble nécessitent des identifiants de signature différents)

Un refus lors de la signature, et non lors d’un build. aggrega sign avec plusieurs références, et aggrega deprecate --from avec un fichier de lot, signent tout ce qu’on leur donne avec un seul identifiant : une seule clé détenue, ou une seule identité sans clé. L’identifiant dont une référence a besoin est décidé par la configuration de son registre — un signing.key_path qui s’applique à ce registre sélectionne la clé qu’il nomme, et là où aucun ne s’applique la référence est signée sans clé. Lorsque les références nommées ensemble nécessiteraient des identifiants différents — une clé pour un registre et aucune pour un autre, ou deux clés différentes —, rien n’est signé, et le message nomme les registres de chaque côté.

La vérification s’exécute avant qu’une identité ne soit demandée et avant que le moindre registre ne soit lu, donc rien n’est signé ni attaché et personne n’est sollicité pour une exécution qui n’aura pas lieu. Une signature ne peut pas être reprise à quiconque l’a récupérée, c’est pourquoi l’exécution est refusée plutôt que signée avec l’identifiant dont l’une des références a besoin.

Une clé passée avec --key décide pour chaque référence. Elle s’applique à chaque référence nommée, quoi que dise la configuration pour chaque registre, donc une telle exécution n’est jamais refusée ici.

On le rencontre partout où un lot est signé : aggrega sign, aggrega deprecate --from, les requêtes aggrega/signArtifacts et aggrega/deprecateArtifact de aggrega serve, dont le message d’erreur porte le code court devant la phrase, et les outils sign-artifacts et deprecate-artifact de aggrega mcp. Un appel d’outil qui atteint un serveur par un listener n’utilise jamais une clé que nomme la configuration, donc là chaque référence est signée avec l’identité qu’envoie l’appel et l’appel n’est pas refusé ici.

Message émis. La phrase propre à la condition l’ouvre, chaque identifiant suit avec les registres pour lesquels il signerait, et le remède vient en dernier :

aggrega sign: signing: the references named together need different signing credentials, so nothing was signed (<registry> signs with the held key signing.key_path names, <registry> signs keyless: no signing.key_path applies). remediation: sign them in separate runs, one per credential: the references on <registry>, then the references on <registry>; each run signs as it would on its own (aggrega sign: signing: les références nommées ensemble nécessitent des identifiants de signature différents, donc rien n’a été signé (le registre indiqué signe avec la clé détenue que nomme signing.key_path, le registre indiqué signe sans clé : aucun signing.key_path ne s’applique). remède : signez-les dans des exécutions séparées, une par identifiant : les références sur le registre indiqué, puis les références sur le registre indiqué ; chaque exécution signe comme elle le ferait seule)

et, lorsqu’un registre du lot exige des signatures, en le nommant à la fin du remède :

aggrega sign: signing: the references named together need different signing credentials, so nothing was signed (<registry> signs with the held key signing.key_path names, <registry> signs keyless: no signing.key_path applies). remediation: sign them in separate runs, one per credential: the references on <registry>, then the references on <registry>; each run signs as it would on its own, and <registry> requires signatures, so this refusal holds back signing that would otherwise have gone ahead rather than signing that cannot be done (aggrega sign: signing: les références nommées ensemble nécessitent des identifiants de signature différents, donc rien n’a été signé (le registre indiqué signe avec la clé détenue que nomme signing.key_path, le registre indiqué signe sans clé : aucun signing.key_path ne s’applique). remède : signez-les dans des exécutions séparées, une par identifiant : les références sur le registre indiqué, puis les références sur le registre indiqué ; chaque exécution signe comme elle le ferait seule, et le registre indiqué exige des signatures, donc ce refus retient une signature qui aurait sinon eu lieu, et non une signature impossible)

Un second registre ayant sa propre clé est nommé comme signant « with a different held key (avec une autre clé détenue) ». Le chemin d’une clé n’est jamais affiché : le message nomme le paramètre, qui est ce que vous pouvez changer.

Comment corriger : répartissez les références selon l’identifiant dont leurs registres ont besoin et lancez une exécution par identifiant — un aggrega sign nommant les références sur les registres signés avec une clé, un autre nommant le reste ; pour aggrega deprecate --from, un fichier de lot par identifiant. Chaque exécution signe alors comme elle l’aurait fait seule. Pour signer plutôt chaque référence avec une seule clé en une seule exécution, passez cette clé avec --key.

A detached signature does not verify against the key supplied (Une signature détachée ne se vérifie pas avec la clé fournie)

Le résultat négatif de la vérification d’une signature nue sur une charge utile par rapport à une clé publique, entièrement hors ligne : la charge utile diffère de ce qui a été signé, la signature a été altérée, ou la clé n’est pas celle qui l’a produite.

Rien dans la chaîne d’outils livrée ne l’atteint. La vérification à laquelle elle appartient n’a aucun appelant en dehors de ses propres tests, donc aucune commande qu’un utilisateur exécute — build, pull ou publication — ne la signale. Elle est cataloguée ici pour que le code renvoie à quelque chose, et non parce qu’un build peut l’afficher. La vérification qu’un pull effectue réellement porte sur un bundle de signature complet et est signalée séparément.

Message émis, citant ce que le vérificateur a signalé :

signing: signature does not verify: <what the verifier reported> (signing: la signature ne se vérifie pas, suivi de ce que le vérificateur a signalé)

Comment corriger : rien dans vos fichiers d’entité n’en est la cause, et rien de ce que vous pouvez écrire dans un catalogue ou un espace de travail ne l’élimine. Si vous exécutez l’outil en ligne de commande publié, ce n’est pas une condition que vous pouvez atteindre, et un problème de signature que vous observez réellement est signalé à la place par l’une des conditions de vérification de bundle ci-dessus. Si vous utilisez le paquet de signature directement depuis votre propre logiciel, la charge utile, la signature et la clé doivent être les trois qui vont ensemble — une charge utile resérialisée entre la signature et la vérification est la cause habituelle, puisque les octets diffèrent alors même si le contenu se lit de la même façon.

A resolved artifact is not a documentation bundle (Un artefact résolu n’est pas un bundle de documentation)

Une référence qui se résout en un artefact d’un autre type — une entité de catalogue, un plugin — est rejetée plutôt que mise en cache comme documentation, de sorte qu’une référence mal pointée échoue là où elle est pointée plutôt que plus tard sous la forme d’un bundle illisible.

Où elle survient. Le bundle de documentation est acquis dans le cache que partagent tous les projets de la machine, depuis le registre configuré de l’espace de travail sous l’espace de noms réservé docs : par le serveur destiné aux assistants une fois, au démarrage et avant qu’il ne réponde à quoi que ce soit, par aggrega explain et par l’explication d’un code dans un éditeur la première fois que l’un ou l’autre en a besoin, et par aggrega scaffold --example — dans chaque cas uniquement là où la machine ne détient aucune copie qu’admet la vérification de signature de l’espace de travail. C’est la vérification que chaque acquisition exécute sur ce qui est revenu.

Elle n’arrête jamais une session. L’acquisition signale son résultat sur le flux de journal du serveur et la connexion se poursuit dans tous les cas ; ce que coûte un artefact rejeté, ce sont les ressources de documentation, qui répondent alors « introuvable » pour cette session. aggrega scaffold --example n’a rien à écrire sans le bundle, donc là il s’agit du refus de la commande, et rien n’est écrit.

Message émis, nommant la référence et les deux types de média :

docscache: <reference>@<version> has media type "<what was found>", want "<what a documentation bundle is>": docscache: artifact is not a documentation bundle (docscache: la référence indiquée à la version indiquée a le type de média trouvé, alors qu’est attendu celui d’un bundle de documentation : docscache: l’artefact n’est pas un bundle de documentation)

Comment corriger : rien dans vos fichiers d’entité n’en est la cause, et aucune modification de rédaction ne l’élimine. La référence qu’a utilisée l’acquisition pointe vers quelque chose qui n’est pas un bundle de documentation — vérifiez le registre configuré de l’espace de travail, puisque la référence du bundle en est dérivée, et une référence bien formée qui pointe vers un autre artefact se résout avec succès et n’échoue qu’ici.

A page is absent from a documentation bundle (Une page est absente d’un bundle de documentation)

Un bundle de documentation a été mis en cache et son contenu vérifié, et la page demandée — ou, pour aggrega scaffold --example, le répertoire de l’exemple — ne s’y trouve pas. C’est différent de n’avoir aucun bundle : le bundle est présent et sain, et l’entrée y manque.

Elle n’atteint aucun build. La surface qui sert les pages de documentation à un éditeur ou à un assistant la transforme en une réponse « introuvable » ordinaire pour la ressource demandée. aggrega scaffold --example la signale comme un refus nommant l’exemple et le bundle, suivi d’un renvoi vers aggrega scaffold --example --list, qui affiche les exemples que le bundle contient réellement, et n’écrit rien.

Il vaut la peine de savoir distinguer laquelle des deux réponses « introuvable » vous obtenez, même si la surface les présente de la même façon. Celle-ci signifie que le bundle est en cache et sain et que la page n’y est pas. L’autre — aucun bundle que l’espace de travail puisse lire, parce qu’aucun n’est en cache ou que la seule copie est une copie que refuse la vérification de signature de l’espace de travail — signifie que l’acquisition ne s’est pas achevée, et le flux de journal du serveur dit pourquoi.

Message émis, nommant la page et le bundle dans lequel elle a été cherchée :

page "<page>" in <reference>@<version>: docscache: page not found in documentation bundle (la page indiquée dans la référence indiquée à la version indiquée : docscache: page introuvable dans le bundle de documentation)

Comment corriger : rien n’est cassé dans vos fichiers. Une page qui manque dans le bundle manque parce que le bundle lui est antérieur ou parce que le chemin demandé n’est pas celui sous lequel elle est publiée — le bundle est acquis à la version que le serveur indique comme la sienne, donc une page ajoutée après cette version n’y figure pas. Si la page n’a jamais existé, la requête a nommé un chemin que la documentation n’utilise pas, et la documentation publiée est l’endroit où trouver celui qu’elle utilise.

An edit would produce a document its schema refuses (Une modification produirait un document que son schéma refuse)

Un refus lors d’une modification de document, et non lors d’un build. Une modification structurée — ajouter un composant, rattacher une Feature, câbler une arête ou définir une valeur — est composée et insérée dans le document, et le résultat est ensuite vérifié par rapport au schéma du type de document qu’il est. Lorsque cette vérification objecte, la modification est refusée et rien n’est écrit. Elle relève d’aggrega edit-document, et de la même capacité atteinte par un éditeur via aggrega serve ou par un assistant, qui sont de minces points d’entrée vers une seule implémentation.

Le type est lu dans le document, jamais fourni par l’appelant. Un appelant nommant le type pourrait nommer le mauvais, et le résultat serait alors vérifié par rapport à un schéma selon lequel le document n’est pas écrit — ce qui admettrait exactement la modification que cette vérification existe pour refuser.

Le fichier reste identique octet pour octet, et l’écriture est atomique, donc une modification refusée ne se distingue pas d’une modification jamais tentée, et une requête corrigée peut être réessayée sur le document dont vous êtes parti.

Son objet est une requête bien formée. La requête nommait une modification que cette capacité applique, et le document qu’elle aurait produit est un document que le schéma de rédaction aurait refusé si vous l’aviez tapé à la main — c’est pourquoi aucune règle de rédaction n’est rappelée pour lui : demander à une Release de porter une valeur du développeur est refusé par le même schéma dans les deux cas. Une requête qui n’a jamais visé une modification — un chemin de nœud qui n’atteint rien dans le document, une valeur écrite comme un mapping là où un scalaire est attendu, une entrée déjà présente portant autre chose — est refusée pour ses propres raisons, et chaque surface le signale dans son propre canal.

Un document qui était déjà invalide le signale aussi. La vérification s’exécute même lorsque la modification n’a rien changé, donc une modification sur un document que le produit refuserait de lire le dit au lieu de signaler un succès.

La vérification est celle qu’applique chaque lecture du document, donc elle refuse aussi une Recipe ou une FeatureRecipe dont le pipeline déclare deux fois un même id d’étape, une règle qu’aucun schéma ne peut exprimer ; l’objection qui suit la phrase s’ouvre alors sur la phrase et le conseil propres à cette condition, comme décrit sous A pipeline declares one step id twice (Un pipeline déclare deux fois un même id d’étape).

Message émis, portant l’objection propre du schéma après la phrase — le type de document et le fichier, puis la position, la clé en faute et ce que le schéma a dit à cet endroit — et se terminant par le conseil :

the edit was refused because the resulting document would not be valid, and nothing was written: document envelope validation failed (<kind>, at <path>); <line>:<column>: <field-path>: … <the schema's own objection>. correct the document to match its kind’s schema (la modification a été refusée car le document résultant ne serait pas valide, et rien n’a été écrit : la validation de l’enveloppe du document a échoué (le type indiqué, au chemin indiqué) ; la ligne et la colonne indiquées : le chemin de champ indiqué : … suivi de l’objection propre du schéma. corrigez le document pour qu’il corresponde au schéma de son type)

Comment corriger : ouvrez le document à la position que cite le message et lisez l’objection, qui dit ce que le schéma attendait à cette clé. La modification à faire porte généralement sur la requête plutôt que sur le document — demandez une entrée que le schéma admet à cet endroit, et la même requête s’applique proprement. Si la clé est une clé que le type de ce document ne peut pas porter du tout, elle appartient à la surface de rédaction qui le peut, et la page d’entité de ce type nomme les champs qu’il déclare. Ce qui est sémantiquement admissible n’est pas décidé à ce stade — si un socket de dépendance est un socket que déclare le producteur, par exemple — donc ce refus porte toujours sur la forme du document, jamais sur ce qui peut être consommé à travers une connexion.

An annotation key uses a prefix the platform reserves (Une clé d’annotation utilise un préfixe que la plateforme réserve)

Un refus lors de la vérification d’une entité au regard des conventions de publication, et non lors d’un build. Le préfixe aggrega.ai/, ainsi que feature.aggrega.ai/ en dehors d’une Feature, appartiennent à la plateforme : une clé écrite sous l’un d’eux porte une signification que la plateforme attribue, donc une entité qui vous appartient et qui y écrit revendique un espace de noms qu’elle ne détient pas.

Elle donne un avertissement pendant la rédaction et un refus au point de contrôle de publication, et les deux lectures nomment cette même condition. Ce qui a été trouvé est le même dans les deux cas ; seule la conséquence diffère. Cette répartition est le comportement de la plupart des règles des conventions de publication cataloguées ici, elle est donc énoncée une fois et considérée comme acquise dans les entrées ci-dessous qui ne disent pas le contraire — les deux qui comparent avec une version déjà publiée le disent dans leurs propres entrées, car elles ne peuvent pas du tout s’exécuter sur un contenu local.

Son message commence ainsi :

an annotation key on the entity uses a prefix the platform reserves (une clé d’annotation de l’entité utilise un préfixe que la plateforme réserve)

Comment corriger : déplacez la clé sous un préfixe qui appartient à votre propre organisation. Si un espace de travail a malgré tout une raison d’écrire sous le préfixe réservé, cette règle fait partie de celles qui ont une option d’exclusion, décrites sous « Les règles de discipline » dans aggrega-lint.md.

An entity’s name does not follow the shape its kind expects (Le nom d’une entité ne suit pas la forme qu’attend son type)

Un refus lors de la vérification d’une entité au regard des conventions de publication, et non lors d’un build. Chaque type d’entité porte une convention de forme de nom — un nombre de segments pour les types cloud-native, PascalCase pour les types de bibliothèque — et le nom que déclare cette entité ne correspond pas à celui qu’attend son type.

Son message commence ainsi :

the entity’s name does not follow the documented name shape for its kind (le nom de l’entité ne suit pas la forme de nom documentée pour son type)

Comment corriger : renommez l’entité selon la forme qu’attend son type ; les conventions par type sont listées sous « Les règles de discipline » dans aggrega-lint.md, avec l’option d’exclusion pour un catalogue qui nomme délibérément ses entités à sa manière.

A schema uses a dynamic reference that cannot be resolved ahead of time (Un schéma utilise une référence dynamique qui ne peut pas être résolue à l’avance)

Un refus lors de la vérification d’une entité au regard des conventions de publication, et non lors d’un build. Un schéma que porte l’entité utilise une construction de référence dynamique, dont la cible est choisie pendant qu’un document est validé plutôt que fixée au moment où le schéma est écrit. Ici, les références sont développées à l’avance, il n’y a donc aucune validation en cours par rapport à laquelle une telle construction pourrait se résoudre.

Son message commence ainsi :

a schema in the entity uses a dynamic reference construct that cross-document reference resolution cannot follow (un schéma de l’entité utilise une construction de référence dynamique que la résolution des références entre documents ne peut pas suivre)

Comment corriger : remplacez la construction dynamique par une référence simple qui nomme directement la cible. Si le schéma a réellement besoin de la construction et ne sera pas référencé entre documents, la règle prévoit une option d’exclusion décrite sous « Les règles de discipline » dans aggrega-lint.md.

A schema declares an identifier the platform owns (Un schéma déclare un identifiant qui appartient à la plateforme)

Un refus lors de la vérification d’une entité au regard des conventions de publication, et non lors d’un build. Un schéma que porte l’entité déclare son propre identifiant, alors que l’identifiant canonique est dérivé de l’identité de l’entité. L’identifiant déclaré supplante l’identifiant dérivé, donc une référence écrite par rapport à l’identifiant canonique cesse de se résoudre.

Son message commence ainsi :

a schema in the entity declares an identifier of its own, where the platform owns that schema’s identity (un schéma de l’entité déclare son propre identifiant, alors que l’identité de ce schéma appartient à la plateforme)

Comment corriger : supprimez l’identifiant déclaré et laissez-le être dérivé. L’option d’exclusion, pour un schéma publié délibérément sous son propre identifiant, est décrite sous « Les règles de discipline » dans aggrega-lint.md.

A Component’s category label and its directory name different categories (L’étiquette de catégorie d’un Component et son répertoire nomment des catégories différentes)

Un refus lors de la vérification d’une entité au regard des conventions de publication, et non lors d’un build. Un Component porte une étiquette de catégorie et est rangé sous un répertoire de catégorie ; la convention veut que les deux nomment la même catégorie, afin que le répertoire qu’un lecteur parcourt et l’étiquette qu’un sélecteur fait correspondre ne puissent pas diverger.

Son message commence ainsi :

the entity’s category label does not match the category directory the entity is filed under (l’étiquette de catégorie de l’entité ne correspond pas au répertoire de catégorie sous lequel l’entité est rangée)

Comment corriger : modifiez celui des deux qui est erroné pour qu’ils concordent — déplacez le fichier sous le répertoire que nomme son étiquette, ou corrigez l’étiquette pour la catégorie que nomme le répertoire. L’ensemble fermé des catégories, ainsi que l’option d’exclusion, figurent sous « Les règles de discipline » dans aggrega-lint.md.

A schema extension is written directly into schema content (Une extension de schéma est écrite directement dans le contenu du schéma)

Un refus lors de la vérification d’une entité au regard des conventions de publication, et non lors d’un build. Un Component ou une Feature écrit une extension de schéma Aggrega directement dans le contenu de son schéma, alors que l’entité dispose d’une surface de premier ordre pour déclarer la même chose. La forme écrite directement fonctionne, et la convention préfère la surface déclarée parce que c’est celle qu’enseignent les pages des entités et celle que lisent les outils.

C’est la seule règle du groupe qu’un build signale aussi, sous forme d’avertissement qui n’arrête pas le build. La vérification de l’entité au regard des conventions de publication au point de contrôle de publication élève le même constat au rang de refus.

Son message commence ainsi :

the entity writes an Aggrega schema extension directly into schema content instead of declaring it under usesSchema or featuresSchema (l’entité écrit une extension de schéma Aggrega directement dans le contenu du schéma au lieu de la déclarer dans le schéma des sockets ou dans le schéma des rattachements)

Comment corriger : déplacez l’extension vers la surface de sockets ou de rattachements propre à l’entité, là où les pages des entités component.md et feature.md la déclarent. L’option d’exclusion figure sous « Les règles de discipline » dans aggrega-lint.md.

A Plugin pins neither runtime cap, so the platform’s own apply (Un Plugin n’épingle aucune des deux limites d’exécution, donc celles de la plateforme s’appliquent)

Un avertissement levé lorsqu’une entité est vérifiée au regard des conventions de publication, pendant la rédaction comme au point de contrôle de publication ; il n’arrête jamais rien, et un build ne le lève pas. Un Plugin déclare le plafond de mémoire et la limite de temps que l’hôte applique lorsqu’il charge et exécute le plugin. Un Plugin qui ne déclare ni l’un ni l’autre s’exécute avec les valeurs par défaut de la plateforme, ce qui est un résultat pris en charge et non une erreur — ce que cela signale, c’est donc que les valeurs par défaut sont en vigueur et qu’il est possible de les épingler explicitement.

Son message commence ainsi :

the Plugin entity declares no runtime resource cap of its own, so the platform defaults apply (l’entité Plugin ne déclare aucune limite de ressources d’exécution qui lui soit propre, donc les valeurs par défaut de la plateforme s’appliquent)

Comment corriger : épinglez les limites dont le plugin a réellement besoin, ou laissez délibérément les valeurs par défaut en place. Cette règle n’a aucun paramètre d’exclusion, et la raison en est qu’elle signale un fait concernant l’entité plutôt qu’un jugement porté sur elle : il n’y a rien à assouplir. Les champs sont décrits dans plugin.md.

An attachment slot admits only secret material without saying it handles it (Un emplacement de rattachement n’admet que des données secrètes sans indiquer qu’il les traite)

Un avertissement levé lorsqu’une entité est vérifiée au regard des conventions de publication, pendant la rédaction comme au point de contrôle de publication ; il n’arrête jamais rien, et un build ne le lève pas. Un emplacement de rattachement peut imposer, par son sélecteur, que seule une Feature porteuse de secrets puisse le remplir, et il peut indiquer séparément que tout ce qui le remplit traite des données secrètes. Le sélecteur établit quels remplissages sont admissibles ; l’indication établit le traitement. Un emplacement qui impose le premier et omet la seconde laisse le traitement être déduit du sélecteur plutôt que lu sur l’emplacement. Chaque emplacement que déclare une entité est vérifié : ceux de son propre bloc de rattachements et, sur un Component, ceux qu’un socket de dépendance déclare pour chaque connexion câblée à travers lui — le constat concernant l’emplacement d’un socket nomme le socket à côté de l’emplacement.

Son message commence ainsi :

an attachment slot admits only secret material and does not declare that it handles it (un emplacement de rattachement n’admet que des données secrètes et ne déclare pas qu’il les traite)

Comment corriger : déclarez le traitement sur l’emplacement, à côté du sélecteur qui impose ce qu’il admet. Cette règle n’a aucun paramètre d’exclusion, pour la même raison que la règle des limites du Plugin n’en a pas : elle signale un fait concernant l’entité et vous laisse la décision.

A Recipe publishes a provides key its Component does not declare, checked at publication (Une Recipe publie une clé que son Component ne déclare pas, avec vérification à la publication)

Un avertissement levé lorsqu’une entité est vérifiée au regard des conventions de publication, pendant la rédaction comme au point de contrôle de publication ; il n’arrête jamais rien, et un build ne le lève pas. Une Recipe publie une clé sous provides:, et le Component que la Recipe implémente ne déclare pas cette clé dans le pilier provides de son schéma. Un consommateur qui câble à travers une connexion lit le contrat déclaré du Component plutôt que ce qu’émet la Recipe, donc la clé est produite puis refusée là où quelque chose tente de la consommer.

🔴 Deux conditions décrivent ce cas, et elles ne sont pas une seule et même condition. L’avertissement que signale un build est documenté ci-dessus sous « A Recipe publishes a provides key its Component does not declare (Une Recipe publie une clé que son Component ne déclare pas) » ; celle-ci est levée lorsque l’entité est vérifiée au regard des conventions de publication, et elle porte son propre code. Le constat est le même fait rencontré sur deux surfaces — lisez le code dans le diagnostic pour savoir lequel vous avez en main.

Son message commence ainsi :

the Recipe publishes a provides key the Component it implements does not declare, so a consumer wiring that key is refused (la Recipe publie une clé provides que le Component qu’elle implémente ne déclare pas, donc un consommateur qui câble cette clé est refusé)

Comment corriger : déclarez la clé sur le Component, afin que le contrat que lit un consommateur inclue ce qu’émet la Recipe — ou cessez de la publier depuis la Recipe là où rien n’est censé la consommer. L’option d’exclusion figure sous « Les règles de discipline » dans aggrega-lint.md.

A Component’s metrics annotation and its provides key disagree (L’annotation de métriques d’un Component et sa clé provides ne concordent pas)

Un avertissement levé lorsqu’une entité est vérifiée au regard des conventions de publication, pendant la rédaction comme au point de contrôle de publication ; il n’arrête jamais rien, et un build ne le lève pas. Un Component peut indiquer comment s’authentifient les métriques de son produit, dans son annotation observability.aggrega.ai/metrics-credential — none, target-key ou separate-token — et il peut déclarer la clé provides metrics_credential_required, que chacune de ses Recipes publie pour dire si les métriques d’une instance nécessitent une information d’identification. Les deux sont un même fait concernant le produit vu de deux côtés, donc un Component qui indique que ses métriques ne nécessitent aucune information d’identification ne déclare aucune clé de ce genre, et un Component qui indique qu’elles en nécessitent une la déclare. Cette condition signale un Component où les deux ne concordent pas, en nommant le Component, la valeur de l’annotation et la clé en trop ou manquante.

Son message commence ainsi :

a Component’s annotation stating how its metrics authenticate disagrees with whether it declares the provides key saying an instance’s metrics need a credential (l’annotation d’un Component qui indique comment s’authentifient ses métriques ne concorde pas avec le fait qu’il déclare ou non la clé provides indiquant que les métriques d’une instance nécessitent une information d’identification)

Comment corriger : corrigez celui des deux qui est erroné — déclarez metrics_credential_required dans le pilier provides, et publiez-la depuis chaque Recipe, là où les métriques nécessitent une information d’identification ; supprimez-la là où elles n’en nécessitent pas ; ou changez l’annotation pour la valeur qui décrit le produit. Cette règle n’a aucun paramètre d’exclusion, pour la même raison que la règle des limites du Plugin n’en a pas ; les valeurs qu’elle lit, et les Components qu’elle laisse non lus, figurent sous « Les règles de discipline » dans aggrega-lint.md.

A connection and the target it reaches do not name one key (Une connexion et la cible qu’elle atteint ne nomment pas une même clé)

Un avertissement levé lorsqu’une Release est vérifiée au regard des conventions de publication ; il n’arrête jamais rien, et un build ne le lève pas. Un serveur qui vérifie une clé conserve la clé qu’il vérifie dans un emplacement qui lui est propre, et un appelant présente une clé sur la connexion par laquelle il atteint ce serveur. Aucune des deux extrémités ne voit celle de l’autre, donc les deux ne sont une seule clé que parce que leurs auteurs écrivent le même localisateur aux deux extrémités. Cette condition signale une connexion dont la cible déclare l’emplacement de la clé qu’elle exige de ses appelants, dans les cas où elles ne sont pas une même clé : la connexion porte une information d’identification et l’emplacement de clé de la cible n’est pas rempli, l’emplacement de clé de la cible est rempli et la connexion ne porte aucune information d’identification, ou les deux sont remplis et écrivent leurs localisateurs différemment.

Contrairement aux règles qui la précèdent, celle-ci lit une Release entière plutôt qu’une seule entité, on ne la rencontre donc que lorsqu’une Release est vérifiée, et jamais au point de contrôle de publication, qui vérifie une seule entité isolément ; partout où elle est signalée, c’est un conseil. Le constat nomme le composant, la connexion, la cible et les deux emplacements, et ne cite jamais aucun des deux localisateurs. Un scrape — une connexion sur le socket scrape_target — est jugé d’après ce que sa cible indique sur ses métriques : pas du tout là où l’annotation observability.aggrega.ai/metrics-credential de la cible indique none, jamais par rapport à la clé de la cible là où elle indique separate-token, et comme toute autre connexion sinon ; une connexion sur tout autre socket est jugée quoi qu’indique la cible.

Son message commence ainsi :

a connection and the target it reaches do not name one key: they write different locators for it, or only one of them names one (une connexion et la cible qu’elle atteint ne nomment pas une même clé : elles écrivent des localisateurs différents pour celle-ci, ou une seule d’entre elles en nomme une)

Comment corriger : faites lire aux deux extrémités un seul paramètre — le champ credential de la connexion et le champ api_key de la cible — afin que la clé que présente l’appelant et la clé que vérifie le serveur ne puissent pas être écrites différemment ; ou, là où une connexion n’est censée présenter aucune clé, retirez-lui l’information d’identification. Les emplacements lus, ce qui est comparé et l’option d’exclusion figurent sous « Les règles de discipline » dans aggrega-lint.md.

The change being published breaks what the evolution rubric allows (La modification en cours de publication enfreint ce que permet la grille d’évolution)

Un refus lors de la vérification qui précède la publication, et non lors d’un build. La version en cours de publication est comparée à la version déjà publiée avant elle, et la différence entre les deux est classée selon une grille documentée. Cette condition signale que la différence est de celles auxquelles la grille s’oppose.

Elle a besoin d’un prédécesseur publié avec lequel comparer, donc elle et la vérification de la montée de version ci-dessous sont les deux règles de ce groupe qui ne peuvent pas s’exécuter sur le seul contenu local : sans consultation d’un registre, il n’y a rien à comparer, et la vérification est ignorée plutôt que réussie.

Son message commence ainsi :

the version being published changes the published predecessor in a way the documented evolution rubric objects to (la version en cours de publication modifie le prédécesseur publié d’une manière à laquelle s’oppose la grille d’évolution documentée)

Comment corriger : lisez la classification dans le diagnostic, qui nomme ce qui, dans la modification, a suscité l’objection de la grille, et rendez la modification compatible ou publiez-la sous une version qui l’admet. La grille est exposée sous « La grille de montée de version » dans aggrega-lint.md.

The version offered is a smaller bump than the change requires (La version proposée est une montée de version plus petite que ce qu’exige la modification)

Un refus lors de la vérification qui précède la publication, et non lors d’un build. La modification en cours de publication est classée selon la grille d’évolution, et la version proposée pour elle est un pas plus petit que ce qu’exige cette classification — une suppression ou une restriction proposée comme patch, par exemple. Une montée de version excessive est toujours acceptée ; c’est une montée insuffisante qui s’arrête ici.

Contrairement aux règles qui la précèdent, celle-ci est tranchée ici plutôt que par le plugin des conventions. La montée de version proposée n’est connue qu’au moment de la publication, et aucune compilation n’est alors en cours, donc la comparaison entre la classification et la version proposée est faite à ce moment-là.

Son message commence ainsi :

the version bump being published is smaller than the evolution check’s classification of the change requires (la montée de version en cours de publication est plus petite que ce qu’exige la classification de la modification par la vérification d’évolution)

Comment corriger : publiez sous la version qu’exige la classification ; le diagnostic indique laquelle. Si vous pensez que la modification est plus petite que ce qu’indique sa classification, la grille sous « La grille de montée de version » dans aggrega-lint.md dit ce qui place une modification dans chaque classe. La première publication d’une entité n’a pas de prédécesseur, donc la comparaison est ignorée et signalée comme non effectuée plutôt que réussie.

An import stopped partway through translating a source (Une importation s’est arrêtée en cours de traduction d’une source)

Un refus lors de la transformation d’une description source étrangère en brouillons de fichiers de rédaction, et non lors d’un build. L’importer a signalé un diagnostic suffisamment grave pour arrêter la traduction, donc ce qu’il a produit est partiel : une partie de la source est devenue des brouillons de fichiers de rédaction et une autre non.

Le résultat partiel est délibéré et non un débris. Il nomme l’issue et non la cause — ce qui n’a pas pu être traduit est signalé dans les diagnostics qui l’accompagnent, un par construction que l’importer n’a pas pu transposer, dans les propres termes de l’importer. Cette condition est ce qui permet à un appelant de distinguer « l’importation s’est arrêtée et a produit une partie d’une réponse » de « l’importation a échoué purement et simplement », qui sont des situations différentes avec des étapes suivantes différentes.

Son message commence ainsi :

the importer reported a diagnostic that stops the import, so the source was not fully turned into draft authoring files (l’importer a signalé un diagnostic qui arrête l’importation, donc la source n’a pas été entièrement transformée en brouillons de fichiers de rédaction)

Comment corriger : lisez les diagnostics signalés à côté — chacun nomme une construction de la source que l’importer n’a pas pu traduire. La correction se trouve dans la source que vous avez fournie, ou consiste à terminer le brouillon à la main : une importation produit un point de départ à modifier, donc une construction qui n’a pas survécu à la traduction est à rédiger directement côté Aggrega. aggrega-import.md décrit ce que produit la commande et où elle écrit.

More than one importer recognises the source (Plusieurs importers reconnaissent la source)

Un refus lors de la transformation d’une description source étrangère en brouillons de fichiers de rédaction, et non lors d’un build. L’importation n’a nommé aucun format, donc le format a été reconnu à partir des signatures que déclarent les importers — ceux du catalogue de l’espace de travail comme les importers de base du compilateur, chacun d’eux nommant la syntaxe dans laquelle une source est lue, les noms de fichiers auxquels il s’applique et les chemins que son arbre analysé doit ou ne doit pas contenir — et des signatures d’importers servant plus d’un format correspondaient à la source. L’importation ne choisit pas entre eux : le format d’une source relève de la déclaration des importers, et non de celle du compilateur, et choisir serait une supposition qui remettrait la source à un importer auquel elle n’est peut-être pas destinée.

Ce n’est pas la même chose qu’un même format annoncé par plusieurs importers, décrit sous « A parse or import format is advertised by more than one plugin (Un format d’analyse ou d’importation est annoncé par plus d’un plugin) » ci-dessus. Là, le format est établi et les importers qui le servent sont en concurrence, donc une entrée plugins.importer choisit parmi eux ; ici, ce sont les formats eux-mêmes qui diffèrent, donc aucun rattachement ne tranche la question, alors que nommer le format la tranche. Un importer qui reconnaît une source la reconnaît comme chaque format qu’il annonce, donc un importer qui annonce plus d’un format, dont l’une des signatures correspond, est également refusé ici.

Son message commence ainsi :

more than one importer recognises the source (plusieurs importers reconnaissent la source)

La suite du message nomme la source et chaque format comme lequel elle a été reconnue, dans l’ordre des identités et des versions des importers, puis le remède :

more than one importer recognises the source (source "<source>", recognised as "<format>", "<format>"). Pass —format to name the one to read it as (for example —format <format> or —format <format>) (plusieurs importers reconnaissent la source (source indiquée, reconnue comme les formats indiqués). Passez —format pour nommer celui dans lequel la lire (par exemple —format suivi de l’un des formats))

Comment corriger : nommez le format — --format sur aggrega import, ou format sur l’outil d’importation de l’assistant et sur la méthode aggrega/import de la session. Lorsque l’un des importers ne devrait jamais reconnaître une telle source, la modification porte sur les signatures de cet importer, que son auteur déclare dans son auto-déclaration describe() et que son entité Plugin enregistre lorsqu’elle est générée ; ou, lorsqu’il s’agit d’un importer que contient le catalogue de l’espace de travail, laissez-le hors du catalogue que lit l’espace de travail — un importer de base fait toujours partie de ceux qui sont essayés, donc une source que l’un d’eux reconnaît en même temps qu’un autre importer se tranche en nommant le format. aggrega-import.md décrit comment un format est reconnu.

No importer recognises the source (Aucun importer ne reconnaît la source)

Un refus lors de la transformation d’une description source étrangère en brouillons de fichiers de rédaction, et non lors d’un build. L’importation n’a nommé aucun format, donc le format a été reconnu à partir des signatures que déclarent les importers — ceux du catalogue de l’espace de travail comme les importers de base du compilateur — et les signatures d’aucun format ne correspondaient à la source. L’importation ne devine pas : remettre la source à un importer qui n’a jamais déclaré lire cette forme produirait un brouillon à partir d’une source à laquelle il n’est peut-être pas destiné.

C’est le pendant de « More than one importer recognises the source (Plusieurs importers reconnaissent la source) » ci-dessus. Là, plusieurs formats revendiquent la source ; ici, aucun. Dans les deux cas, nommer le format tranche la question, et rien n’est écrit tant qu’il n’est pas nommé.

Son message commence ainsi :

no importer recognises the source (aucun importer ne reconnaît la source)

La suite du message nomme la source, puis le remède et chaque format qu’annoncent les importers du catalogue, dans l’ordre où ils ont été lus :

no importer recognises the source (source "<source>"). Pass —format to name it explicitly (for example —format <format> or —format <format>) (aucun importer ne reconnaît la source (source indiquée). Passez —format pour le nommer explicitement (par exemple —format suivi de l’un des formats annoncés))

Lorsqu’aucun importer n’annonce le moindre format, le remède le dit à la place des exemples.

Un répertoire se voit proposer un autre remède, car nommer un format quelconque ne peut pas l’aider. Un répertoire n’est lu qu’à travers les motifs de fichier que déclare son importer, et une signature qui ne déclare aucun motif de fichier ne s’applique à aucun des fichiers d’un répertoire — ainsi un répertoire contenant, par exemple, un seul export Langflow n’est reconnu par aucune signature, et nommer le format langflow serait à son tour refusé sous An importer that declares no file patterns is handed a directory (Un importer qui ne déclare aucun motif de fichier reçoit un répertoire). Le refus d’un répertoire le nomme donc comme répertoire et propose d’importer l’un de ses fichiers seul, ou de nommer un format dont l’importer déclare des motifs de fichier — uniquement ces formats, relevés dans les propres déclarations des importers :

no importer recognises the source (directory "<directory>"). Import one of the directory’s files on its own, or pass —format naming a format whose importer reads a directory through the file patterns it declares (for example —format <format> or —format <format>) (aucun importer ne reconnaît la source (répertoire). Importez seul l’un des fichiers du répertoire, ou passez —format en nommant un format dont l’importer lit un répertoire à travers les motifs de fichier qu’il déclare (par exemple —format ou —format))

Lorsqu’aucun importer ne déclare de motif de fichier, le refus propose d’importer seul l’un des fichiers du répertoire et indique qu’aucun importer du catalogue ne déclare les motifs de fichier à travers lesquels un répertoire est lu.

Comment corriger : nommez le format — --format sur aggrega import, ou format sur l’outil d’importation de l’assistant et sur la méthode aggrega/import de la session, chacun formulant le refus autour du champ qu’il prend et l’ouvrant par le code court de cette condition ; la réponse de la session porte en outre les deux codes de la condition dans ses données. Pour un répertoire, importez seul le fichier que vous visiez — une signature qui ne nomme aucun fichier s’applique à un fichier importé seul, quel que soit son nom — ou nommez l’un des formats que le refus énumère. Lorsque la source aurait dû être reconnue, la modification porte sur les signatures de l’importer qui sert son format, que son auteur déclare dans son auto-déclaration describe() et que son entité Plugin enregistre lorsqu’elle est générée. aggrega-import.md décrit comment un format est reconnu.

An importer that declares no file patterns is handed a directory (Un importer qui ne déclare aucun motif de fichier reçoit un répertoire)

Un refus lors de la transformation d’une description source étrangère en brouillons de fichiers de rédaction, et non lors d’un build. La source nommée est un répertoire, et un répertoire est remis à son importer sous la forme exacte des fichiers que sélectionnent les motifs de fichiers déclarés par l’importer — quels fichiers d’un répertoire un importer lit relève donc de la propre déclaration de l’importer. L’importer qui sert le format de la source ne déclare aucun motif de fichier : il lit un seul fichier, et ne dit rien des fichiers d’un répertoire qui sont les siens.

Rien n’est ouvert. L’importation s’arrête une fois l’importer résolu et avant qu’aucun fichier du répertoire ne soit lu, plutôt que de remettre à l’importer chaque fichier que contient le répertoire.

Son message commence ainsi :

the importer serving the source’s format declares no file patterns, so it reads one file and cannot read a directory (l’importer qui sert le format de la source ne déclare aucun motif de fichier, donc il lit un seul fichier et ne peut pas lire un répertoire)

La suite du message nomme le format, l’importer et le répertoire tel que vous l’avez nommé, puis le remède :

the importer serving the source’s format declares no file patterns, so it reads one file and cannot read a directory (format "<format>", importer "importer/<name>", directory "<directory>"). Import one of the directory’s files on its own instead; the importer reads a directory once it declares the file patterns its files are named by (l’importer qui sert le format de la source ne déclare aucun motif de fichier, donc il lit un seul fichier et ne peut pas lire un répertoire (format, importer et répertoire indiqués). Importez plutôt l’un des fichiers du répertoire isolément ; l’importer lit un répertoire dès qu’il déclare les motifs de fichiers qui nomment ses fichiers)

Comment corriger : importez isolément un fichier du format. Pour qu’un importer lise des répertoires de son format, son auteur déclare les motifs qui nomment ses fichiers — le champ files d’une signature de reconnaissance dans son auto-déclaration describe(), que son entité Plugin enregistre lorsqu’elle est générée. aggrega-import.md décrit ce que lit l’importation d’un répertoire.

No file in the directory matches the importer’s file patterns (Aucun fichier du répertoire ne correspond aux motifs de fichiers de l’importer)

Un refus lors de la transformation d’une description source étrangère en brouillons de fichiers de rédaction, et non lors d’un build. La source nommée est un répertoire, le format est établi, et l’importer qui le sert déclare des motifs de fichiers — mais aucun fichier que contient le répertoire, à quelque profondeur que ce soit, ne correspond à l’un d’eux. Ne remettre aucune source à l’importer le ferait échouer sur une source vide, en des termes portant sur le contenu plutôt que sur les fichiers lus, donc l’importation s’arrête ici sans rien avoir lu.

Lorsque le format a été reconnu plutôt que nommé, l’importer dont la signature a reconnu le répertoire correspondait à l’un de ses fichiers, donc on ne rencontre cette condition que lorsque l’importer qui s’exécute n’est pas celui-là — un autre importer du même format que sélectionne une entrée plugins.importer, ou une autre version de celui-ci.

Son message commence ainsi :

no file in the directory matches the file patterns the importer serving the source’s format declares (aucun fichier du répertoire ne correspond aux motifs de fichiers que déclare l’importer qui sert le format de la source)

La suite du message nomme le format, l’importer, le répertoire tel que vous l’avez nommé et chaque motif que déclare l’importer, puis le remède :

no file in the directory matches the file patterns the importer serving the source’s format declares (format "<format>", importer "importer/<name>", directory "<directory>", file patterns "<pattern>", "<pattern>"). Name a directory holding a file one of those patterns matches, or the format of an importer whose patterns match the files this directory holds (aucun fichier du répertoire ne correspond aux motifs de fichiers que déclare l’importer qui sert le format de la source (format, importer, répertoire et motifs de fichiers indiqués). Nommez un répertoire contenant un fichier auquel l’un de ces motifs correspond, ou le format d’un importer dont les motifs correspondent aux fichiers que contient ce répertoire)

Comment corriger : importez le répertoire qui contient les fichiers du format — un motif est comparé à la fin du chemin d’un fichier à l’intérieur du répertoire, donc un fichier à n’importe quelle profondeur compte — ou nommez le format dans lequel sont les fichiers du répertoire. aggrega-import.md décrit ce que lit l’importation d’un répertoire.

A file read from the directory and a file named in the importer’s with.sources have the same name (Un fichier lu dans le répertoire et un fichier nommé dans les sources de l’importer portent le même nom)

Un refus lors de la transformation d’une description source étrangère en brouillons de fichiers de rédaction, et non lors d’un build. La source nommée est un répertoire, et ses fichiers parviennent à l’importer comme des sources nommées, chacun sous son chemin à l’intérieur du répertoire. L’entrée plugins.importer qui rattache l’importer nomme ses propres fichiers sous with.sources, qui lui parviennent aussi comme des sources nommées, chacun sous son nom de base — et un même nom est porté par les deux. Un nom est la manière dont un importer distingue une source d’une autre, donc lui remettre les deux laisserait l’une masquer l’autre sans rien pour dire laquelle ; l’importation s’arrête plutôt, sans rien remettre.

Son message commence ainsi :

a file read from the directory and a file named in the importer’s with.sources have the same name (un fichier lu dans le répertoire et un fichier nommé dans les sources de l’importer portent le même nom)

La suite du message nomme le nom et le fichier de with.sources, puis le remède :

a file read from the directory and a file named in the importer’s with.sources have the same name (name "<name>", the with.sources file "<path>"). Each source reaches the importer under one name, so rename one of the two files, or leave the file out of the importer’s with.sources (un fichier lu dans le répertoire et un fichier nommé dans les sources de l’importer portent le même nom (nom et fichier with.sources indiqués). Chaque source parvient à l’importer sous un seul nom, donc renommez l’un des deux fichiers, ou laissez le fichier hors des with.sources de l’importer)

Comment corriger : renommez l’un des deux fichiers, ou retirez le fichier du champ with.sources de l’entrée lorsque le répertoire le contient déjà. Un fichier de with.sources garde son nom de base, donc c’est un fichier du même nom au premier niveau du répertoire qu’il rencontre ; un fichier situé dans un répertoire inférieur porte ce répertoire dans son nom. Quel importer transforme une source en brouillons décrit le champ with.sources d’une entrée.

An import’s target names a capability no Recipe in the catalog binds to (La cible d’une importation nomme une capacité à laquelle aucune Recipe du catalogue ne se lie)

Un refus lors de la transformation d’une description source étrangère en brouillons de fichiers de rédaction, et non lors d’un build. L’importation a reçu une cible — --target sur aggrega import, ou target sur l’outil d’importation de l’assistant et sur la méthode aggrega/import de la session — afin qu’elle produise un brouillon de Manifest associant chaque type de composant du brouillon à une Recipe de ce fournisseur. La cible est une capacité de fournisseur, comparée au spec.capability auquel se lie chaque Recipe du catalogue de l’espace de travail, et aucune Recipe de ce catalogue ne se lie à celle qui a été donnée. Un Manifest produit pour elle n’associerait rien du tout, et chaque type de composant paraîtrait alors absent du catalogue alors que ce qui est erroné est l’option elle-même — le plus souvent une faute de frappe.

Rien ne s’exécute et rien n’est écrit. L’importation s’arrête une fois le catalogue chargé, avant que le format de la source ne soit reconnu et avant que l’importer ne s’exécute, donc aucun brouillon n’est produit et aucun fichier n’est écrit, y compris lors d’une exécution à blanc.

Son message commence ainsi :

no Recipe in the workspace’s catalog binds to the capability the import’s target names (aucune Recipe du catalogue de l’espace de travail ne se lie à la capacité que nomme la cible de l’importation)

La suite du message nomme la cible exactement telle qu’elle a été donnée et les capacités auxquelles les Recipes du catalogue se lient effectivement, chacune une fois et dans l’ordre trié, puis le remède :

no Recipe in the workspace’s catalog binds to the capability the import’s target names (target "<target>", the catalog’s Recipes bind to "<capability>", "<capability>"). Name one of those capabilities as the target, or leave the target out and no Manifest is drafted; nothing was drafted or written (aucune Recipe du catalogue de l’espace de travail ne se lie à la capacité que nomme la cible de l’importation (cible indiquée, capacités auxquelles se lient les Recipes du catalogue). Nommez l’une de ces capacités comme cible, ou omettez la cible et aucun Manifest n’est produit ; rien n’a été produit ni écrit)

Lorsque le catalogue ne contient aucune Recipe, le message le dit à la place de la liste, et le remède consiste à ajouter au catalogue une Recipe du fournisseur.

Comment corriger : nommez l’une des capacités que liste le message — compose ou helm, par exemple, telles que les écrit le spec.capability d’une Recipe — ou omettez la cible, ce qui ne produit aucun brouillon de Manifest. Lorsque le fournisseur que vous visiez en est un pour lequel le catalogue ne contient encore aucune Recipe, ajoutez ses Recipes à un dossier de catalogue que l’espace de travail lit en premier. aggrega-import.md décrit ce que produit une importation à laquelle une cible est donnée.

A child Release inherits a boundary directory that resolves where its parent writes (Une Release enfant hérite d’un répertoire de frontière qui se résout là où écrit sa Release parente)

Un avertissement. Une Release en étend une autre et hérite d’elle le répertoire de sortie d’une frontière, et ce répertoire ne contient aucune variable de template — il se résout donc vers le même chemin pour les deux, et le build de l’enfant écrit là où écrit le build du parent.

Hériter du répertoire est la forme prise en charge et non une erreur. Un répertoire est un template, donc un parent l’écrit une fois et un enfant qui renseigne un paramètre le résout ailleurs sans rien dupliquer ; c’est toute la raison pour laquelle un enfant n’a pas besoin de reformuler la topologie de frontières de son parent. Ce qui est étroit et réel, c’est le cas résiduel que celui-ci nomme : sans variable à l’intérieur, il ne reste rien à résoudre différemment.

Il ne peut pas provoquer d’arrêt, et c’est une propriété de la règle plutôt qu’une précaution à son égard. Écrire dans le même chemin résolu est quelque chose qu’un auteur peut légitimement vouloir — un enfant qui ne remplace que les Recipes de rendu pour comparer leur sortie, ou qui ne modifie que le dimensionnement — donc une règle qui s’arrêterait sur cette déduction refuserait une entrée légitime sur une supposition.

Son message commence ainsi :

inherited boundary directory carries no template variable, so it resolves to the path the extended Release writes to (le répertoire de frontière hérité ne contient aucune variable de template, donc il se résout vers le chemin dans lequel écrit la Release étendue)

Comment corriger : lorsque les deux devaient écrire à des endroits différents, placez une référence de paramètre dans le répertoire et laissez chaque Release la renseigner. Lorsque écrire dans un seul chemin est ce que vous vouliez, rien n’est à changer — l’avertissement vous a dit ce qu’il va se passer, et le build produit sa sortie dans les deux cas.

Retrouver un arrêt à partir du code court affiché par le build

L’en-tête entre crochets d’un diagnostic d’arrêt nomme la catégorie à laquelle l’échec est imputable et, lorsque l’échec nomme l’une des conditions cataloguées ici, le code court de cette condition — la lettre E et quatre chiffres, comme dans [CATALOG_ERROR E0209]. Un numéro est attribué une fois puis fixé, donc un code court que vous collez dans un rapport ou une recherche nomme toujours la condition qu’il nommait lorsque vous l’avez noté. Les deux autres identifiants que porte une condition, et lequel des trois utiliser et quand, sont expliqués dans sentinels.md.

La propre ligne de message de la condition s’ouvre par une phrase fixe qui énonce la condition. Tout ce qui suit cette phrase varie selon l’occurrence — le document en cause, la clé rédigée, la valeur fautive et le conseil pour cette occurrence — et les entrées ci-dessus citent la forme entière pour la condition que chacune documente. La phrase fixe est la partie qui est la même à chaque fois, et c’est ce qui en fait la partie sur laquelle établir la correspondance.

Le tableau ci-dessous met les deux en regard, limité à cette page : pour chaque condition cataloguée ici, le code court qu’affiche un build et la phrase par laquelle s’ouvre sa ligne de message, en regard de l’entrée ci-dessus qui explique la correction à apporter à la rédaction. Les titres des entrées sont cités exactement, de sorte que rechercher l’un d’eux dans cette page mène à son entrée. Le tableau de toutes les conditions résout un code court parmi toutes les conditions que déclare le compilateur, y compris celles qu’aucune entrée ici ne couvre.

Lorsqu’une entrée apparaît en regard de deux codes courts, elle couvre deux conditions distinctes et chacune enregistre sa propre phrase ; lisez les phrases plutôt que le titre partagé pour savoir laquelle un build a signalée.

aggrega explain <code> effectue cette recherche pour vous dans le terminal, en prenant l’un ou l’autre des codes de la condition et en affichant la condition avec l’entrée ci-dessus qui la documente. Il est décrit dans aggrega explain.

Code courtS’ouvre parDocumenté sous
E0001cliplugin: no plugin resolver configuredA command-line plugin runner was built without a way to find plugins (Un exécuteur de plugins en ligne de commande a été construit sans moyen de trouver les plugins)
E0003malformed attachment requirementMalformed attachment requirement (Exigence de rattachement mal formée)
E0004annotation contribution overridden by an explicit valueAn explicit value displaced one an annotation supplied (Une valeur explicite a supplanté celle qu’une annotation fournissait)
E0005policy violationA governance plugin rejected the build (Un plugin de gouvernance a rejeté la build)
E0006required attachment slot unfilledRequired attachment slot not bound (Emplacement de rattachement requis non lié)
E0007selector violationCross-node type safety violation via selector: (Violation de la sûreté de typage inter-nœuds via selector)
E0008attachment slot selector unsatisfiedThe Feature filling an attachment slot does not satisfy the slot’s selector (La Feature qui remplit un emplacement de rattachement ne satisfait pas le sélecteur de l’emplacement)
E0009pipeline step typed-I/O contract violationA pipeline step’s typed input or output does not satisfy its declared contract (L’entrée ou la sortie typée d’une étape de pipeline ne satisfait pas son contrat déclaré)
E0010pipeline step failedA pipeline step failed (Une étape de pipeline a échoué)
E0011pipeline patch targets a document not present in the setA pipeline patch addresses a document the set does not hold, or one with no tree to address (Un patch de pipeline cible un document que l’ensemble ne contient pas, ou un document sans arbre à cibler)
E0012pipeline patch targets an opaque (non-structured) unitA pipeline patch addresses a document the set does not hold, or one with no tree to address (Un patch de pipeline cible un document que l’ensemble ne contient pas, ou un document sans arbre à cibler)
E0013feature type mismatch between Aggregate and ReleaseFeature type mismatch between Aggregate and Release (Non-concordance du type de Feature entre Aggregate et Release)
E0014inject entry carries both `value:` and `from:`; schema requires exactly oneAn inject: entry carries both a literal and a source key (Une entrée d’inject porte à la fois un littéral et une clé source)
E0015uses-edge inject dictates a delivery mechanism the socket does not permituses edge dictates delivery on a socket that allowlists none (Une arête impose la livraison sur un socket qui n’autorise aucun mécanisme); uses edge dictates a delivery mechanism outside the socket’s allowlist (Une arête impose un mécanisme de livraison en dehors de la liste d’autorisation du socket)
E0016jsonpatch: test operation failedA patch’s test operation did not match the document (L’opération de test d’un patch ne correspondait pas au document)
E0017annotation-transform plugin output was rejected: an injection targets a component coordinate the host did not supply, or carries a value that is not a string or an object of subkeysAn annotation-transform plugin names a component it was not given, or injects a value no annotation takes (Un plugin annotation-transform nomme un composant qui ne lui a pas été fourni, ou injecte une valeur qu’aucune annotation n’accepte)
E0018policy attachment settings do not satisfy the plugin's declared settings schemaA governance attachment’s settings do not match the plugin’s declared schema (Les paramètres d’un rattachement de gouvernance ne correspondent pas au schéma déclaré du plugin)
E0019endpoint requires form: referenceA workload: form and the fields beside it do not agree (La forme d’une charge de travail et les champs à côté d’elle ne concordent pas)
E0020schedule is not a valid cron expressionA workload schedule: is not an expression the check accepts (La planification d’une charge de travail n’est pas une expression que la vérification accepte)
E0021persistentTemplate volume requires form: statefulA workload: form and the fields beside it do not agree (La forme d’une charge de travail et les champs à côté d’elle ne concordent pas)
E0022pipeline PATCH target is not parseable structured YAML/JSONA pipeline step addresses documents the node does not have (Une étape de pipeline cible des documents que le nœud n’a pas)
E0023form: reference requires an endpointA workload: form and the fields beside it do not agree (La forme d’une charge de travail et les champs à côté d’elle ne concordent pas)
E0024schedule requires form: scheduledA workload: form and the fields beside it do not agree (La forme d’une charge de travail et les champs à côté d’elle ne concordent pas)
E0025form: scheduled requires a scheduleA workload: form and the fields beside it do not agree (La forme d’une charge de travail et les champs à côté d’elle ne concordent pas)
E0026imported artifact content does not match the digest recorded for it in entity.lockAn imported artifact no longer matches the digest recorded beside its Recipe (Un artefact importé ne correspond plus au digest enregistré à côté de sa Recipe)
E0027artifacts $import: is not a bare-name artifact-library reference (<Library>#/artifacts/<entry>)A library $import: is not written in the bare-name form (Une importation de bibliothèque n’est pas écrite sous la forme à nom nu)
E0028artifacts output filename collision: two artifact outputs carry the same filenameTwo artifact outputs of one Recipe carry the same filename (Deux sorties d’artefacts d’une même Recipe portent le même nom de fichier)
E0029artifact template references a pillar the Recipe does not declareAn artifacts: template reads a pillar the Recipe does not declare (Un template artifacts lit un pilier que la Recipe ne déclare pas)
E0030artifact-library import references a bundle not present in the ArtifactLibraryA library $import: names a library or an entry the catalog does not hold (Une importation de bibliothèque nomme une bibliothèque ou une entrée que le catalogue ne contient pas)
E0031artifact-library import references an ArtifactLibrary not present in the catalogA library $import: names a library or an entry the catalog does not hold (Une importation de bibliothèque nomme une bibliothèque ou une entrée que le catalogue ne contient pas)
E0032assembled output collision: two contributors write the same output pathTwo contributors write the same output path (Deux contributeurs écrivent le même chemin de sortie)
E0033assertion failedAn assertion stopped the build (Une assertion a arrêté la build)
E0034duplicate delivery key across attachment-inject and another inject sourceAn attachment delivers a key another inject source already claimed (Un rattachement livre une clé qu’une autre source d’inject a déjà revendiquée)
E0035provider expected to assemble its dispatch group provides no boundary assemblerThe plugin serving a provider cannot assemble what that provider combines (Le plugin qui sert un fournisseur ne peut pas assembler ce que ce fournisseur combine)
E0036merged-path assembly has conflicting assembly-name annotation valuesChart-name mismatch on a merged helm-chart umbrella (Nom de chart discordant sur un chart parapluie helm-chart fusionné)
E0037cross-boundary link between endpoints rendered by different providers is not supportedA connection crosses between two different providers’ assembled outputs (Une connexion passe entre les sorties assemblées de deux fournisseurs différents)
E0038derived name collision: one name is derived more than once in one key spaceThe same name is derived more than once inside the output (Le même nom est dérivé plus d’une fois à l’intérieur de la sortie)
E0039FeatureRecipe template references a per-component-only field with executionScope: boundaryFeatureRecipe template references a field outside its scope’s allowlist (Le template de FeatureRecipe référence un champ en dehors de la liste d’autorisation de sa portée)
E0040library $import: carries a registry host; reference the library by bare-name identityA library $import: addresses its library by registry location (Une importation de bibliothèque adresse sa bibliothèque par son emplacement dans un registre)
E0041multiple contributors share an instance ID at the same dispatch pathInstance-ID collision across boundaries assembling to the same path (Collision d’ID d’instance entre frontières assemblées au même chemin)
E0042locals entry references a sibling defined later in the same blocklocals: entry references a sibling defined later in the same block (Une entrée de locals référence une entrée sœur définie plus loin dans le même bloc)
E0043template references a key the locals block does not declarelocals: key does not exist (La clé de locals n’existe pas)
E0044mapping-library import references an entry not present in the MappingLibraryA library $import: names a library or an entry the catalog does not hold (Une importation de bibliothèque nomme une bibliothèque ou une entrée que le catalogue ne contient pas)
E0045valuesMapping $import: is not a bare-name mapping-library reference (<Library>#/mappings/<entry>)A library $import: is not written in the bare-name form (Une importation de bibliothèque n’est pas écrite sous la forme à nom nu)
E0046mapping-library import references a MappingLibrary not present in the catalogA library $import: names a library or an entry the catalog does not hold (Une importation de bibliothèque nomme une bibliothèque ou une entrée que le catalogue ne contient pas)
E0047assembled output retains an unresolved cross-boundary link placeholderAssembled output still carries a cross-boundary placeholder (La sortie assemblée porte encore un espace réservé entre frontières)
E0048dispatch path produced multiple provider outputsPath collision: two contributors emit at incompatible paths (Collision de chemins : deux contributeurs émettent à des chemins incompatibles)
E0049path template references a field not in the documented allowlistPath-template references a variable outside the allowlist (Le template de chemin référence une variable en dehors de la liste d’autorisation)
E0050pipeline /host operation from a step with no host componentA pipeline step addresses documents the node does not have (Une étape de pipeline cible des documents que le nœud n’a pas)
E0051pipeline PATCH targets an assembler provider's pre-assembly fragmentsA pipeline patch addresses output that has not been assembled yet (Un patch de pipeline cible une sortie qui n’a pas encore été assemblée)
E0052pipeline PATCH targets a document the node did not emitA pipeline step addresses documents the node does not have (Une étape de pipeline cible des documents que le nœud n’a pas)
E0053pipeline plugin is not compatible with the rendering providerA pipeline step’s plugin does not claim the provider rendering what it addresses (Le plugin d’une étape de pipeline ne revendique pas le fournisseur qui effectue le rendu de ce que l’étape cible)
E0054provider rejected node inputA provider refused a node’s input (Un fournisseur a refusé l’entrée d’un nœud)
E0055Recipe or FeatureRecipe does not publish a provides key its abstract entity's schema.provides contract declaresA Recipe or FeatureRecipe does not publish a provides key its contract declares (Une Recipe ou une FeatureRecipe ne publie pas une clé provides que son contrat déclare)
E0056provides template evaluation failedA provides: template could not be evaluated (Un template de provides ne peut pas être évalué)
E0057provides block references a root outside the self-contained setprovides: template references a non-self-contained root (Le template provides référence une racine non autonome)
E0058provider render is not deterministicA provider rendered the same input twice and produced different output (Un fournisseur a effectué deux fois le rendu de la même entrée et a produit des sorties différentes)
E0059duplicate delivery key across self-inject and uses-injectDuplicate delivery key across inject sources (Clé de livraison en double entre les sources d’inject)
E0060template references a root the render context does not defineTemplate references a root the render context does not define (Le template référence une racine que le contexte de rendu ne définit pas); Self-inject value template references cross-node data (Le template de valeur de self-inject référence des données entre nœuds)
E0061unknown providerUnknown provider (Fournisseur inconnu)
E0062custom inject mechanism has no matching key in injectMapping output; add the mechanism's key to the Recipe injectMappingA component declares an inject mechanism the attached Feature maps nothing to (Un composant déclare un mécanisme d’inject vers lequel la Feature rattachée ne mappe rien)
E0063workload-library import references an entry not present in the WorkloadLibraryA library $import: names a library or an entry the catalog does not hold (Une importation de bibliothèque nomme une bibliothèque ou une entrée que le catalogue ne contient pas)
E0064workload $import: is not a bare-name workload-library reference (<Library>#/workloads/<entry>)A library $import: is not written in the bare-name form (Une importation de bibliothèque n’est pas écrite sous la forme à nom nu)
E0065workload-library import references a WorkloadLibrary not present in the catalogA library $import: names a library or an entry the catalog does not hold (Une importation de bibliothèque nomme une bibliothèque ou une entrée que le catalogue ne contient pas)
E0066uses edge target does not existDangling uses target (Cible d’arête pendante)
E0067active toggle did not resolve to a booleanAn active: toggle does not resolve to true or false (Un interrupteur ne se résout ni en true ni en false)
E0068max sub-aggregate nesting depth exceededSub-aggregate nesting depth exceeded (Profondeur d’imbrication des sous-agrégats dépassée)
E0069mutator patch rejectedA label-transform plugin’s patch reaches outside node labels (Le patch d’un plugin label-transform sort des labels des nœuds)
E0070re-exported component alias forms a cycleA re-published component alias points back at itself (Un alias de composant republié pointe vers lui-même)
E0071release edge retargets a developer-declared edgeRelease retargets a developer-declared edge (La Release recible une arête déclarée par le développeur)
E0072sub-aggregate load failedA module a composition imports cannot be loaded, or imports itself (Un module qu’une composition importe ne peut pas être chargé, ou s’importe lui-même)
E0073flattened node ID collision: rename one of the colliding instances so their flattened IDs differTwo instances flatten to one identifier (Deux instances s’aplatissent en un seul identifiant)
E0074release per-edge configuration has no edge to apply toRelease per-edge configuration has no edge to apply to (La configuration par arête de la Release n’a aucune arête à laquelle s’appliquer)
E0075aggregate reached topology un-normalized (non-empty root components alongside a synthesized default subsystem)An Aggregate reached graph building without being normalised (Un Aggregate a atteint la construction du graphe sans avoir été normalisé)
E0076sub-module placed in no boundary: route it into a boundary under `aggregates`, or name its components there under `components`A sub-module’s components are placed in no boundary (Les composants d’un sous-module ne sont placés dans aucune frontière)
E0077uses edge target was pruned because its active toggle resolved to falseA uses edge targets a component an active: toggle removed (Une arête cible un composant qu’un interrupteur a retiré)
E0078producer-consumption re-entry denied: a producer reached through the host may not issue a further producer-consumption callA plugin asks the host to parse a source while a parse is already running for it (Un plugin demande à l’hôte d’analyser une source alors qu’une analyse est déjà en cours pour lui)
E0079wasm: recorded command mirror does not match plugin describe()A Plugin entity’s recorded command set does not match the plugin (L’ensemble de commandes enregistré d’une entité Plugin ne correspond pas au plugin)
E0080wasm: entity contract claim does not match plugin describe()A Plugin entity’s claims disagree with the plugin’s own self-report (Les affirmations d’une entité Plugin contredisent l’auto-description du plugin lui-même)
E0081wasm: guest plugin returned a diagnostic whose severity the contract does not declareA plugin returned a diagnostic at a severity that is not declared (Un plugin a renvoyé un diagnostic d’une gravité qui n’est pas déclarée)
E0082wasm: guest plugin reported an errorA plugin failed while it was running (Un plugin a échoué pendant son exécution)
E0083wasm: guest plugin panicked during callA plugin failed while it was running (Un plugin a échoué pendant son exécution)
E0084wasm: stamped host-function record does not match .wasm importsA Plugin entity’s recorded host functions do not match the binary (Les fonctions hôte enregistrées d’une entité Plugin ne correspondent pas au binaire)
E0085wasm: plugin rejected by the sandboxThe sandbox refused a plugin (Le bac à sable a refusé un plugin)
E0086wasm: plugin invoked proc_exitA plugin failed while it was running (Un plugin a échoué pendant son exécution)
E0087wasm: declared plugin type does not match plugin describe()A plugin is not the kind of plugin the socket expects (Un plugin n’est pas du type de plugin qu’attend le socket)
E0088wasm: entity metadata.version does not match plugin describe()A Plugin entity’s recorded version does not match the plugin (La version enregistrée d’une entité Plugin ne correspond pas au plugin)
E0089every published version this reference could select has been withdrawnEvery version a reference could select has been withdrawn (Toutes les versions qu’une référence pourrait sélectionner ont été retirées)
E0090format is advertised by more than one importer pluginA parse or import format is advertised by more than one plugin (Un format d’analyse ou d’importation est annoncé par plus d’un plugin)
E0091format is advertised by more than one parser pluginA parse or import format is advertised by more than one plugin (Un format d’analyse ou d’importation est annoncé par plus d’un plugin)
E0092capability is served by more than one provider plugin; add a plugins.providers entry to select oneA capability is served by more than one provider plugin (Une capacité est servie par plus d’un plugin fournisseur)
E0093manifest maps multiple version-distinct keys to the same base type; the type-to-recipe lookup is ambiguousA Manifest maps two version-distinct keys onto one type (Un Manifest associe deux clés de versions distinctes à un même type)
E0094duplicate entity identity within a single catalog directoryTwo catalog entities in one directory share an identity (Deux entités de catalogue dans un même répertoire partagent une identité)
E0095malformed recipe reference in a Manifest mapping valueManifest mapping value is not a shape a recipe reference accepts (La valeur de mappage du Manifest n’a pas une structure qu’une référence de recette accepte)
E0096manifest mapping entry's recipe spec.implements does not match the mapped component-type / feature-type keyRecipe implements does not match the mapped component type (La déclaration d’implémentation de la Recipe ne correspond pas au type de composant mappé)
E0097no importer plugin advertises the requested formatNo plugin advertises a requested parse or import format (Aucun plugin n’annonce un format d’analyse ou d’importation demandé)
E0098no parser plugin advertises the requested formatNo plugin advertises a requested parse or import format (Aucun plugin n’annonce un format d’analyse ou d’importation demandé)
E0099no recipe resolved for component/feature instance: add an explicit Manifest mapping for its typeNo Recipe is mapped for a component or feature instance (Aucune Recipe n’est mappée pour une instance de composant ou de fonctionnalité)
E0100plugins.providers entry names a plugin no provider-rendering plugin serving the capability matchesA plugins.providers binding names a plugin that does not serve the capability (Une liaison nomme un plugin qui ne sert pas la capacité)
E0101no provider-rendering plugin version satisfies the recipe's provider version pinNo provider plugin version satisfies a Recipe’s provider pin (Aucune version de plugin fournisseur ne satisfait l’épinglage de fournisseur d’une Recipe)
E0102wasm plugin reference must be the plugin coordinate identity (<pluginType>/<name>:<version>), not a registry-qualified or artifact pathA plugin reference carries a registry host or an artifact path (Une référence de plugin contient un hôte de registre ou un chemin d’artefact)
E0103no catalog version satisfies the referenced version constraintNo catalog version satisfies a version constraint (Aucune version du catalogue ne satisfait une contrainte de version)
E0104wasm plugin reference must carry a pluginType scope (<pluginType>/<name>); an empty scope cannot bind to an OCI locationA plugin or recipe reference carries no scope (Une référence de plugin ou de recette ne porte aucune portée)
E0105recipe reference must be provider-scoped (<provider>/<name>); an empty provider cannot bind to an OCI locationA plugin or recipe reference carries no scope (Une référence de plugin ou de recette ne porte aucune portée)
E0106resolve: invalid library reference URIA library reference is not written in the identity form (Une référence de bibliothèque n’est pas écrite sous la forme d’identité)
E0107resolve: minimal version selection conflict — incompatible library version requirementsTwo consumers of one library require incompatible versions (Deux consommateurs d’une même bibliothèque exigent des versions incompatibles)
E0108resolve: catalog lookup cannot load resolved sub-aggregate bodiesThe catalog view a build was given cannot load the bodies pinning needs (La vue du catalogue fournie à une build ne peut pas charger les corps dont l’épinglage a besoin)
E0109resolve: catalog lookup cannot load resolved recipe and plugin bodiesThe catalog view a build was given cannot load the bodies pinning needs (La vue du catalogue fournie à une build ne peut pas charger les corps dont l’épinglage a besoin)
E0110resolve: source-template evaluation failure at lock timeResolving a source: coordinate registers a narrower function set (La résolution d’une coordonnée source enregistre un ensemble de fonctions plus restreint)
E0111resolve: source-template parse errorResolving a source: coordinate registers a narrower function set (La résolution d’une coordonnée source enregistre un ensemble de fonctions plus restreint)
E0112resolve: source-template references .provides (invalid reverse reference)Resolving a source: coordinate registers a narrower function set (La résolution d’une coordonnée source enregistre un ensemble de fonctions plus restreint)
E0113resolve: sub-aggregate inclusion depth exceededThe chain of module imports is deeper than the pin walk descends (La chaîne d’importations de modules est plus profonde que ce que descend le parcours d’épinglage)
E0114resolve: no entity in the catalog matches this URIA reference names no entity the catalog holds (Une référence ne nomme aucune entité que contient le catalogue)
E0115compactform: ambiguous dispatch — $mode requiredA compact-form schema declares a field literally named type (Un schéma en forme compacte déclare un champ portant littéralement ce nom)
E0116compactform: constraint not valid for declared typeA compact-form constraint does not apply to the type it was written on (Une contrainte en forme compacte ne s’applique pas au type sur lequel elle a été écrite)
E0117compactform: $jsonschema content invalidA $jsonschema: escape carries content that is not a schema (Un échappement contient un contenu qui n’est pas un schéma)
E0118compactform: cross-document $ref carries a registry host; reference the library by identityA $ref: addresses a library by registry location (Une référence adresse une bibliothèque par son emplacement dans un registre)
E0119compactform: $ref unresolvableA $ref: is not written in a form the compiler can resolve (Une référence n’est pas écrite sous une forme que le compilateur peut résoudre)
E0120compactform: unknown keywordA compact-form schema uses a keyword the compact form does not know (Un schéma en forme compacte utilise un mot-clé que la forme compacte ne connaît pas)
E0121compactform: cross-document $ref target not foundA $ref: is not written in a form the compiler can resolve (Une référence n’est pas écrite sous une forme que le compilateur peut résoudre)
E0122deprecation: build consumes a deprecated entityThe build consumes an artifact its publisher has deprecated (Le build consomme un artefact que son éditeur a déprécié)
E0123docscache: artifact is not a documentation bundleA resolved artifact is not a documentation bundle (Un artefact résolu n’est pas un bundle de documentation)
E0124docscache: page not found in documentation bundleA page is absent from a documentation bundle (Une page est absente d’un bundle de documentation)
E0125egress: network access refused because the workspace is offline; remediation: pass `--offline=false` to allow the network for this one run, or clear the top-level `offline` key in the configuration file (or AGGREGA_OFFLINE) to allow it from now on; where the work is a build that needs content the machine does not have, run `aggrega pull --release <release>` from a connected environment first to populate the cacheThe workspace is offline and the step needs the network (L’espace de travail est hors ligne et l’étape a besoin du réseau)
E0126externalinputs: acquisition is disabled for unpinned inputsA render requests an external input the lockfile does not pin (Un rendu demande une entrée externe que le fichier de verrouillage n’épingle pas)
E0127externalinputs: fetched bytes mismatch the pinned digestFetched bytes do not match a pinned digest (Les octets récupérés ne correspondent pas à un digest épinglé)
E0128externalinputs: URL scheme is not allowedAn external input’s URL uses a scheme that is not allowed (L’URL d’une entrée externe utilise un schéma non autorisé)
E0129externalinputs: store blob mismatches its pinned recordA stored external input no longer matches its record (Une entrée externe stockée ne correspond plus à son enregistrement)
E0130lockfile: out of date; it no longer matches what its Release resolves toThe lockfile no longer matches what the release resolves to (Le fichier de verrouillage ne correspond plus à ce vers quoi la Release se résout)
E0131lockfile: file failed schema validationThe lockfile does not satisfy its schema (Le fichier de verrouillage ne satisfait pas son schéma)
E0132oci: manifest has multiple layers of the expected content media typeA manifest carries no layer of the expected kind, or more than one (Un manifeste ne porte aucune couche du type attendu, ou en porte plusieurs)
E0133oci: cached manifest digest mismatchFetched or cached bytes do not match the digest committed for them (Les octets récupérés ou en cache ne correspondent pas au digest déclaré pour eux)
E0135oci: content digest mismatchFetched or cached bytes do not match the digest committed for them (Les octets récupérés ou en cache ne correspondent pas au digest déclaré pour eux)
E0136oci: network unreachableThe registry could not be reached (Le registre est injoignable)
E0137oci: artifact not found at remote sourceAn artifact is not at the source the build was told to find it (Un artefact ne se trouve pas à la source où la build devait le trouver)
E0138oci: authentication required or failedThe registry will not serve an artifact without credentials it accepts (Le registre ne sert pas un artefact sans identifiants qu’il accepte)
E0139oci: tag already published with different contentA tag is already published with different content (Un tag est déjà publié avec un contenu différent)
E0140oci: manifest has no layer of the expected content media typeA manifest carries no layer of the expected kind, or more than one (Un manifeste ne porte aucune couche du type attendu, ou en porte plusieurs)
E0141oci: distinct catalog identities map to the same OCI repository locationTwo catalog identities publish to one repository location (Deux identités de catalogue publient vers un même emplacement de dépôt)
E0142oci: referrer discovery could not be completedThe registry could not answer what is attached to an artifact (Le registre n’a pas pu répondre sur ce qui est rattaché à un artefact)
E0143oci: unknown entity kind for mediatype dispatchAn entity kind has no artifact media type (Un type d’entité n’a pas de type de média d’artefact)
E0144cached signature bundle does not match its recorded digestA cached signature bundle does not match the digest recorded for it (Un bundle de signature en cache ne correspond pas au digest enregistré pour lui)
E0145plugin reference is not a Plugin entityA plugin reference is not a Plugin entity (Une référence de plugin n’est pas une entité Plugin)
E0146circular reference expansionA library reference expands into itself (Une référence de bibliothèque s’étend en elle-même)
E0147registrytrust: advertised trust config is malformedA registry serves a trust document that cannot be read as one (Un registre sert un document de confiance qui ne peut pas être lu comme tel)
E0148registrytrust: registry advertises no trust configA registry publishes no trust document (Un registre ne publie aucun document de confiance)
E0149attachment name is a near miss for a declared slotAn attachment name is one edit from a declared slot (Un nom de rattachement est à une modification près d’un emplacement déclaré)
E0150attachment does not conform to its declared slot shapeAttachment does not conform to its declared slot shape (Le rattachement n’est pas conforme à la forme déclarée de son emplacement)
E0151component declared in more than one boundary: declare each component in exactly one boundaryA component is placed in more than one boundary (Un composant est placé dans plus d’une frontière)
E0152duplicate Aggregate/Manifest identity (metadata.name) in the Release directoryThe Release directory declares one Aggregate or Manifest twice (Le répertoire de la Release déclare deux fois un Aggregate ou un Manifest)
E0153feature merge conflict: reconcile the Aggregate and Release declarations for the featureA feature attached by both the Aggregate and the Release cannot be merged (Une fonctionnalité rattachée à la fois par l’Aggregate et par la Release ne peut pas être fusionnée)
E0154the compiler's own views of the catalog disagreeA guard needs a catalog entity the build resolved and cannot see (Une garde a besoin d’une entité du catalogue que la build a résolue et qu’elle ne peut pas voir)
E0155duplicate delivery key across inject sourcesDuplicate delivery key across inject sources (Clé de livraison en double entre les sources d’inject)
E0156invalid inject key: the from-key must name a provides key its source publishesInject from key is not in the target’s provides (La clé d’inject ne figure pas parmi ce que la cible fournit)
E0158invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go templateA {{ .parameters.* }} reference cannot be interpolated (Une référence aux paramètres ne peut pas être interpolée)
E0160manifest annotation bindings collide on same Feature path+pillarTwo Manifest annotation bindings compete for one routing slot (Deux liaisons d’annotation du Manifest se disputent un même emplacement de routage)
E0161manifest annotation binding uses reserved prefixA Manifest annotation binding claims the reserved aggrega.ai/ prefix (Une liaison d’annotation du Manifest revendique le préfixe réservé)
E0162missing required feature: attach a Feature of the required type to the componentRequired feature not attached (Fonctionnalité requise non rattachée)
E0163required uses socket not populatedRequired uses: socket not populated (Socket requis non renseigné)
E0164parameter contract violatedParameter type mismatch / contract violation (Type de paramètre non concordant / violation de contrat)
E0165required parameter not suppliedParameter type mismatch / contract violation (Type de paramètre non concordant / violation de contrat)
E0167Recipe publishes a provides key its Component does not declareA Recipe publishes a provides key its Component does not declare (Une Recipe publie une clé que son Component ne déclare pas)
E0168authored pillar does not conform to its declared schemaAuthored values or infra do not conform to the declared schema (Les values ou infra écrits ne sont pas conformes au schéma déclaré)
E0169self-inject on component without spec.inject allowlistSelf-inject on a component without an allowlist (Self-inject sur un composant sans liste d’autorisation); Self-inject mechanism not in the component’s allowlist (Mécanisme de self-inject absent de la liste d’autorisation du composant)
E0170aggregate/manifest reference unresolvableA Release’s aggregate: or manifest: reference resolves to nothing (La référence d’une Release ne se résout en rien)
E0171unknown uses socket: name a socket the entity declares in its usesSchema — only a component's own uses block may name one the catalog did not declareuses: socket not declared in the owning entity’s usesSchema (Socket non déclaré dans le schéma de sockets de l’entité propriétaire)
E0172release reached resolve un-normalized (non-empty root components alongside a synthesized default boundary)A Release reached resolution without passing through the load path (Une Release a atteint la résolution sans passer par le chemin de chargement)
E0173declared parameter is read by no reference in the AggregateA declared parameter is read by nothing (Un paramètre déclaré n’est lu par rien)
E0174uses socket name is a near miss for a declared socketA uses: socket name is one edit from a declared socket (Un nom de socket est à une modification près d’un socket déclaré)
E0175file load failed: the file could not be read, or its bytes did not parseA file cannot be read, or its bytes do not parse (Un fichier ne peut pas être lu, ou ses octets ne s’analysent pas)
E0176signing: keyless signing requires a live identity provider, Fulcio, and RekorKeyless signing was asked for without the services it needs (La signature sans clé a été demandée sans les services dont elle a besoin)
E0177signing: no signature found for an artifact that requires oneAn artifact that must be signed carries no signature (Un artefact qui doit être signé ne porte aucune signature)
E0178signing: keyless verification requires at least one trusted identityA keyless trust policy names no acceptable signer (Une politique de confiance sans clé ne nomme aucun signataire acceptable)
E0179signing: signature does not verifyA detached signature does not verify against the key supplied (Une signature détachée ne se vérifie pas avec la clé fournie)
E0180signing: signature bundle does not verifyA signature does not verify (Une signature ne se vérifie pas)
E0181signing: signing policy requires a signature for this artifact kind; refusing to push unsigned contentAn unsigned publish targets a registry or a policy that requires a signature (Une publication non signée vise un registre ou une politique qui exige une signature)
E0182signing: cannot load pinned trust rootThe pinned trust root cannot be read (La racine de confiance épinglée ne peut pas être lue)
E0183signing: registry requires signatures; refusing to push unsigned contentAn unsigned publish targets a registry or a policy that requires a signature (Une publication non signée vise un registre ou une politique qui exige une signature)
E0184signing: unsupported held-key typeA pinned verification key is not the key profile the verifier accepts (Une clé de vérification épinglée n’est pas du profil de clé que le vérificateur accepte)
E0185signing: signature identity is not trusted for this registryA signature verifies but its signer is not one the registry trusts (Une signature se vérifie, mais son signataire n’est pas l’un de ceux que le registre approuve)
E0186no source adapter serves the source kindA Recipe’s source: names a kind nothing knows how to acquire (La source d’une Recipe désigne un type que rien ne sait acquérir)
E0187cacheslot: empty workspaceRootA source artifact is cached without a workspace root to anchor it (Un artefact source est mis en cache sans racine d’espace de travail à laquelle l’ancrer)
E0188artifacts entry: shape must be a string scalar or {$import: <local-path>}An inline-or-import field is written in neither shape (Un champ « en ligne ou import » n’est écrit sous aucune des deux formes)
E0189artifactlibrary: entry must be a mapping of filename to a string bodyA library entry’s body is not the shape that library holds (Le corps d’une entrée de bibliothèque n’a pas la forme que contient cette bibliothèque)
E0190schemalibrary: forbidden JSON Schema keywordA schema uses a JSON Schema keyword the library does not admit (Un schéma utilise un mot-clé JSON Schema que la bibliothèque n’admet pas)
E0191mappinglibrary: entry body must be a string scalarA library entry’s body is not the shape that library holds (Le corps d’une entrée de bibliothèque n’a pas la forme que contient cette bibliothèque)
E0192a document nests too many levels deepA document nests deeper than the reader will descend (Un document est imbriqué plus profondément que le lecteur ne descend)
E0193parameters: shape must be an inline object or {$import: <local-path>}A Release’s parameters: block is written in neither of its two shapes (Le bloc des paramètres d’une Release n’est écrit sous aucune de ses deux formes)
E0194schemalibrary: template not foundA $instantiate: reference cannot be resolved (Une référence ne peut pas être résolue)
E0195schemalibrary: template parameter missingA $instantiate: reference cannot be resolved (Une référence ne peut pas être résolue)
E0196schemalibrary: template parameter type mismatchA $instantiate: reference cannot be resolved (Une référence ne peut pas être résolue)
E0197valuesmapping: shape must be a string scalar or {$import: <path-or-library-identity>}An inline-or-import field is written in neither shape (Un champ « en ligne ou import » n’est écrit sous aucune des deux formes)
E0198wellKnownAnnotations: a key is declared at a scope the provider's contract does not renderA provider declares a well-known annotation at a scope it does not render (Un fournisseur déclare une annotation well-known à une portée dont il ne fait pas le rendu)
E0199workloadlibrary: entry body must be a string scalarA library entry’s body is not the shape that library holds (Le corps d’une entrée de bibliothèque n’a pas la forme que contient cette bibliothèque)
E0200workload: shape must be a string scalar or {$import: <path-or-library-identity>}An inline-or-import field is written in neither shape (Un champ « en ligne ou import » n’est écrit sous aucune des deux formes)
E0201assertion name declared twice across the extends chainAn assertion name is declared twice along an extends: chain (Un nom d’assertion est déclaré deux fois le long d’une chaîne d’extension)
E0202cyclic extends chainCyclic extends chain (Chaîne extends cyclique); Cyclic extends on Components or Features (Extends cyclique sur des Components ou des Features)
E0204FeatureRecipe: valuesMapping requires sourceA FeatureRecipe’s valuesMapping requires source (Le mappage des valeurs d’une FeatureRecipe exige une source)
E0205inheritance merge failedAn extends: chain cannot be assembled (Une chaîne d’extension ne peut pas être assemblée)
E0207recipe output-component-labels constraint: key is also declared in outputLabelsA promoted component label is also declared literally (Une étiquette de composant promue est aussi déclarée littéralement)
E0208recipe output-labels constraint: key uses a reserved namespaceAn output-label key uses a reserved namespace (Une clé d’étiquette de sortie utilise un espace de noms réservé)
E0209Recipe: valuesMapping requires sourcevaluesMapping requires source (le mappage des valeurs requiert une source)
E0210Recipe: at least one input kind requiredAt least one input kind must be present (Au moins un type d’entrée doit être présent)
E0211filename collision across input kinds: two input-kind blocks produced a file under one output nameEmission-time filename collision across input kinds (Collision de noms de fichiers à l’émission entre types d’entrée)
E0212workload attachment slot is not referenceableA Workload references a slot whose fill publishes no locator (Un Workload fait référence à un emplacement dont le remplissage ne publie aucun localisateur)
E0213workload featuresSchema cross-check failedA Workload attachment names a slot the entity does not declare, or a delivery the slot forbids (Un rattachement de Workload nomme un emplacement que l’entité ne déclare pas, ou une livraison que l’emplacement interdit)
E0214workload validation failedA Workload does not satisfy the Workload schema (Un Workload ne satisfait pas le schéma Workload)
E0215document envelope validation failedYAML anchor aliased inside its own content (Ancre YAML référencée par un alias à l’intérieur de son propre contenu); Divergent Release (extends + aggregate pointer) (Release divergente (extends + pointeur aggregate))
E0216validator/jsonschema: x-aggrega extension evaluation failedAn x-aggrega-when: or x-aggrega-validate: predicate cannot be evaluated (Un prédicat ne peut pas être évalué)
E0218validator/jsonschema: schema resolution failedA declared schema cannot be resolved (Un schéma déclaré ne peut pas être résolu)
E0220extends chain exceeds maximum depthAn extends: chain runs past the depth bound (Une chaîne d’extension dépasse la borne de profondeur)
E0221merger: invalid merge inputThe schema-merge step’s own input guard (Le garde-fou d’entrée propre à l’étape de fusion des schémas)
E0222registry alias matches more than one hostA registry alias matches more than one host (Un alias de registre correspond à plus d’un hôte)
E0223a cross-cutting socket is bound by capability but attaches by uriA plugin binding sets a key the socket it attaches to does not read (Une liaison de plugin définit une clé que le socket auquel elle se rattache ne lit pas)
E0224workspace configuration is invalidThe workspace configuration is invalid (La configuration de l’espace de travail n’est pas valide)
E0225capability is bound to more than one provider pluginA capability is bound to more than one provider plugin (Une capacité est liée à plus d’un plugin fournisseur)
E0226registry alias is already used by another hostA registry alias is already bound to another host (Un alias de registre est déjà lié à un autre hôte)
E0227a governance attachment declares no role or an unknown roleA governance attachment declares no role, or one that is not a known role (Un rattachement de gouvernance ne déclare aucun rôle, ou un rôle qui n’est pas connu)
E0228a provider socket binding sets a field with no referent on that socketA plugin binding sets a key the socket it attaches to does not read (Une liaison de plugin définit une clé que le socket auquel elle se rattache ne lit pas)
E0229position out of rangeAn editor position falls outside the document (Une position de l’éditeur tombe hors du document)
E0246the digest recorded as trusted for this plugin does not match the digest its cached manifest reportsA trusted plugin’s recorded digest disagrees with the cached artifact (Le digest enregistré d’un plugin approuvé ne concorde pas avec l’artefact en cache)
E0247a plugin recorded as trusted for an accept-or-reject verdict is no longer attached at any verdict roleA plugin recorded as a trusted gate is no longer attached (Un plugin enregistré comme contrôle approuvé n’est plus rattaché)
E0248wasm: guest plugin returned an output that is not the shape the socket readsA plugin returned something that is not the shape the socket reads (Un plugin a renvoyé quelque chose qui n’a pas la structure que lit le socket)
E0250provider named a directory for each contributor's own sub-directory that is not a single directory nameA provider named a directory for a contributor that is not one directory (Un fournisseur a nommé pour un contributeur un répertoire qui n’est pas un répertoire unique)
E0251recipe source is an empty string, which names neither sourceless mode nor sourced modeRecipe source: is an empty string (Le champ source de la Recipe est une chaîne vide)
E0252artifact-library bundle file name does not name a file of its own beneath the artifacts key its output is nested underAn ArtifactLibrary bundle file names no file of its own under the key it was imported at (Un fichier de bundle d’une ArtifactLibrary ne nomme aucun fichier qui lui soit propre sous la clé à laquelle il a été importé)
E0253annotation binding does not resolve against its target FeatureAnnotation binding does not resolve against its target Feature (La liaison d’annotation ne se résout pas par rapport à sa Feature cible)
E0254annotation subkey does not conform to the target Feature's schema at the routed pillarA bound annotation value does not conform to the target Feature’s schema (Une valeur d’annotation liée n’est pas conforme au schéma de la Feature cible)
E0255annotation routes through a pillar its authoring side may not useAn 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)
E0256annotation binding declares one path in both pillar listsAn annotation binding declares one path in both pillar lists (Une liaison d’annotation déclare un même chemin dans les deux listes de piliers)
E0257declared schema contract could not be compiled into a usable schema, so nothing was validated against it: correct the contract where it is declared, or remove it if the configuration it covers needs no validationA declared schema contract cannot be read as a schema (Un contrat de schéma déclaré ne peut pas être lu comme un schéma)
E0259attachment binds a FeatureRecipe with executionScope: boundary and no boundary holding the component declares itA boundary-scope Feature is attached only to a component (Une Feature de portée frontière n’est rattachée qu’à un composant)
E0260component placed in no boundary: name it under a boundary's `components`, or place the sub-module that contributes it under `aggregates`A component the composition holds is placed in no boundary (Un composant que la composition contient n’est placé dans aucune frontière)
E0261boundary names a component the composition does not hold: correct the name, or remove the entryA boundary names a component the composition does not hold (Une frontière nomme un composant que la composition ne contient pas)
E0262component identity cannot be the name its emitted resources are stamped with: rename the componentComponent identity cannot be stamped on what it emits (L’identité du Component ne peut pas être estampillée sur ce qu’il émet)
E0263the target will not accept a name derived from this component's authored identity: rename the componentThe target will not accept a name derived from an authored identity (La cible n’accepte pas un nom dérivé d’une identité rédigée)
E0264provider guest never accepted a component identity the compiler composed for itA provider never accepted a name the compiler composed (Un fournisseur n’a jamais accepté un nom composé par le compilateur)
E0265provider does not support the node's input kindworkload: requires a provider that can synthesize (requiert un fournisseur capable de synthétiser)
E0266a schema `$import:` could not be appliedA schema $import: cannot be applied (Une importation de schéma ne peut pas être appliquée)
E0267a schema block declares a key that names no data pillarA schema block names a key that is not a data pillar (Un bloc de schéma nomme une clé qui n’est pas un pilier de données)
E0268reassemble names a patched unit token the carve did not produce; a conforming codec carves and reassembles a file under the same tokensA provider’s reassembly is handed a unit its own carve never produced (Le réassemblage d’un fournisseur reçoit une unité que son propre découpage n’a jamais produite)
E0269provider guest returned two output files under one path; a conforming guest returns each output path at most onceA provider returned two output files under one path (Un fournisseur a renvoyé deux fichiers de sortie sous un même chemin)
E0270link patch names an output file the dispatch group did not emit; a conforming link patch names a file the group's own render returnedA provider’s link wiring names an output file that was never emitted (Le câblage de lien d’un fournisseur nomme un fichier de sortie qui n’a jamais été émis)
E0271emit_file side effect carries no file; a conforming emit_file side effect carries a file with its path and contentA pipeline step’s file emission carries no file (L’émission de fichier d’une étape de pipeline ne porte aucun fichier)
E0272side effect declares a kind the plugin contract does not define; a conforming side effect declares emit_file or emit_crdA pipeline step declares an emission kind the contract does not define (Une étape de pipeline déclare un type d’émission que le contrat ne définit pas)
E0273template reads the name the target gives the resources it renders for the node, and this node's provider reports no such name; a conforming template reads a value the node's own provider suppliesA template reads a rendered name the node’s provider does not report (Un template lit un nom rendu que le fournisseur du nœud ne signale pas)
E0274the plugin identity recorded as trusted no longer matches what this resolution reportsA gate recorded as trusted resolves to a different identity (Un contrôle enregistré comme approuvé se résout en une identité différente)
E0275the edit was refused because the resulting document would not be valid, and nothing was writtenAn edit would produce a document its schema refuses (Une modification produirait un document que son schéma refuse)
E0276the version being published changes the published predecessor in a way the documented evolution rubric objects toThe change being published breaks what the evolution rubric allows (La modification en cours de publication enfreint ce que permet la grille d’évolution)
E0277an annotation key on the entity uses a prefix the platform reservesAn annotation key uses a prefix the platform reserves (Une clé d’annotation utilise un préfixe que la plateforme réserve)
E0278the entity's name does not follow the documented name shape for its kindAn entity’s name does not follow the shape its kind expects (Le nom d’une entité ne suit pas la forme qu’attend son type)
E0279a schema in the entity uses a dynamic reference construct that cross-document reference resolution cannot followA schema uses a dynamic reference that cannot be resolved ahead of time (Un schéma utilise une référence dynamique qui ne peut pas être résolue à l’avance)
E0280a schema in the entity declares an identifier of its own, where the platform owns that schema's identityA schema declares an identifier the platform owns (Un schéma déclare un identifiant qui appartient à la plateforme)
E0281the entity's category label does not match the category directory the entity is filed underA Component’s category label and its directory name different categories (L’étiquette de catégorie d’un Component et son répertoire nomment des catégories différentes)
E0282the entity writes an Aggrega schema extension directly into schema content instead of declaring it under usesSchema or featuresSchemaA schema extension is written directly into schema content (Une extension de schéma est écrite directement dans le contenu du schéma)
E0283the Plugin entity declares no runtime resource cap of its own, so the platform defaults applyA Plugin pins neither runtime cap, so the platform’s own apply (Un Plugin n’épingle aucune des deux limites d’exécution, donc celles de la plateforme s’appliquent)
E0284an attachment slot admits only secret material and does not declare that it handles itAn attachment slot admits only secret material without saying it handles it (Un emplacement de rattachement n’admet que des données secrètes sans indiquer qu’il les traite)
E0285the Recipe publishes a provides key the Component it implements does not declare, so a consumer wiring that key is refusedA Recipe publishes a provides key its Component does not declare, checked at publication (Une Recipe publie une clé que son Component ne déclare pas, avec vérification à la publication)
E0286the version bump being published is smaller than the evolution check's classification of the change requiresThe version offered is a smaller bump than the change requires (La version proposée est une montée de version plus petite que ce qu’exige la modification)
E0287the importer reported a diagnostic that stops the import, so the source was not fully turned into draft authoring filesAn import stopped partway through translating a source (Une importation s’est arrêtée en cours de traduction d’une source)
E0288a plugin has no expression for a construct this build declaresA workload declares a form compose cannot express (Une charge de travail déclare une forme que compose ne peut pas exprimer); A container declares a field compose has no primitive for (Un conteneur déclare un champ pour lequel compose n’a pas de primitive); An omits entry names a kind or a namespace a compose file does not have (Une entrée omits désigne un kind ou un namespace qu’un fichier compose n’a pas); An omits entry names a namespace a CloudFormation template does not have (Une entrée omits désigne un namespace qu’un template CloudFormation n’a pas); A rule reads a bound CloudFormation parameter by name (Une règle lit par son nom un paramètre CloudFormation lié); The assembled CloudFormation stack cannot carry a transform (La stack CloudFormation assemblée ne peut pas porter une transformation)
E0289a plugin could not resolve something it requires to exactly one valueA health probe cannot be turned into a compose healthcheck (Une sonde de santé ne peut pas être transformée en healthcheck compose); A configmap volume has no file behind it (Un volume configmap n’a aucun fichier derrière lui); What an omits entry left out is still named by the compose file (Ce qu’une entrée omits a laissé de côté est encore nommé par le fichier compose); What an omits entry left out is still named by a CloudFormation template (Ce qu’une entrée omits a laissé de côté est encore nommé par un template CloudFormation); A valuesMapping key names no parameter of a sourced CloudFormation template (Une clé valuesMapping ne nomme aucun paramètre d’un template CloudFormation source); Another component references a CloudFormation parameter a sourced template’s binding filled (Un autre composant référence un paramètre CloudFormation que la liaison d’un template source a renseigné); Two components order one pair of transforms oppositely (Deux composants ordonnent une même paire de transformations en sens inverse); A cross-boundary reference has no consuming stack to be written into (Une référence entre frontières n’a aucune stack consommatrice dans laquelle être écrite); A synthesized StatefulSet has no single service to govern it (Un StatefulSet synthétisé n’a pas de service unique pour le gouverner)
E0290two things a plugin produced occupy one name in its outputAn authored export name is one the build derives for a cross-stack reference (Un nom d’exportation rédigé est un nom que la build dérive pour une référence inter-stacks); The output a cross-stack reference publishes on already carries an Export (La sortie sur laquelle une référence inter-stacks publie porte déjà un Export); Two entries reach one stack output name (Deux entrées atteignent un même nom de sortie de stack); A CloudFormation fragment writes one key twice (Un fragment CloudFormation écrit une même clé deux fois); Two rendered resources land at one output file (Deux ressources rendues aboutissent à un même fichier de sortie)
E0291a plugin has no representation for a value it was givenA published port declares a transport compose cannot spell (Un port publié déclare un transport que compose ne sait pas écrire); A resources quantity cannot be converted to a compose value (Une quantité de ressources ne peut pas être convertie en valeur compose); A resource quantity the helm provider emits is not a quantity (Une quantité de ressource que le fournisseur helm émet n’est pas une quantité); A service type the helm provider cannot render (Un type de service que le fournisseur helm ne peut pas rendre); A Kubernetes version the helm provider cannot render a chart for (Une version de Kubernetes pour laquelle le fournisseur helm ne peut pas effectuer le rendu d’un chart); A value bound to a CloudFormation parameter cannot take the parameter’s type (Une valeur liée à un paramètre CloudFormation ne peut pas prendre le type du paramètre); A value bound to a CloudFormation parameter is one its constraints refuse (Une valeur liée à un paramètre CloudFormation est une valeur que ses contraintes refusent); A secret bound to a CloudFormation parameter would be written into the template (Un secret lié à un paramètre CloudFormation serait écrit dans le template); A dynamic reference is bound where CloudFormation does not resolve it (Une référence dynamique est liée là où CloudFormation ne la résout pas); A cross-boundary reference was spliced into a longer string (Une référence entre frontières a été insérée dans une chaîne plus longue)
E0292a plugin reported a failure that none of the declared kinds namesA plugin reported a failure it did not classify (Un plugin a signalé une défaillance qu’il n’a pas classée)
E0293wasm: guest plugin named a condition the socket does not declareA plugin named a condition the socket does not declare (Un plugin a nommé une condition que le socket ne déclare pas)
E0294components in different subsystems take the same identity: rename one of them, since a subsystem contributes nothing to a component's identityTwo subsystems declare a component under one name (Deux sous-systèmes déclarent un composant sous un même nom)
E0295library reference: a reference to a library entry carries no whitespace or line breakA reference to a library entry carries whitespace (Une référence à une entrée de bibliothèque contient des espaces blancs)
E0296release extends chain composes both named boundaries and top-level components: declare one routing shape across the chain, never bothA Release chain’s links disagree about the routing shape (Les maillons d’une chaîne de Release divergent sur la structure de routage)
E0297inherited boundary directory carries no template variable, so it resolves to the path the extended Release writes toA child Release inherits a boundary directory that resolves where its parent writes (Une Release enfant hérite d’un répertoire de frontière qui se résout là où écrit sa Release parente)
E0298oci: published bundle carries no entity documentA published bundle holds no entity, or holds two (Un bundle publié ne contient aucune entité, ou en contient deux)
E0299oci: published bundle carries more than one entity documentA published bundle holds no entity, or holds two (Un bundle publié ne contient aucune entité, ou en contient deux)
E0300oci: published bundle cannot be unpackedA published artifact cannot be read as an entity (Un artefact publié ne peut pas être lu comme une entité)
E0301oci: published artifact is not an entity documentA published artifact cannot be read as an entity (Un artefact publié ne peut pas être lu comme une entité)
E0302an input the entity reads has no pin recorded for it in the entity.lock beside itAn entity reads an input the lock beside it records no pin for (Une entité lit une entrée pour laquelle le lock à côté d’elle n’enregistre aucun épinglage)
E0303the entity shares its directory with another entity, and an entity of its kind has a directory of its ownAn entity shares its directory with another entity (Une entité partage son répertoire avec une autre entité)
E0304a path names content outside the entity's own directoryA path names content outside the entity’s own directory (Un chemin désigne un contenu situé hors du répertoire propre de l’entité)
E0305the files of the entity's local source do not match the pins recorded for them in entity.lockA local source no longer matches the pins recorded beside its Recipe (Une source locale ne correspond plus aux épinglages enregistrés à côté de sa Recipe)
E0306plugin artifact not found on this machineA plugin’s .wasm is not on this machine (Le fichier Wasm d’un plugin n’est pas sur cette machine)
E0307a value a cache location is built from would place cached files outside the place it names in the cacheA value would place a cached file outside the cache (Une valeur placerait un fichier mis en cache hors du cache)
E0308a Feature reaches a component alongside a Feature it declares a conflict withTwo Features declared to conflict reach one component (Deux Features déclarées en conflit atteignent un même composant)
E0309a symbolic link sits among the files an entity carriesA symbolic link sits among the files an entity carries (Un lien symbolique figure parmi les fichiers que porte une entité)
E0310a registry other than the official hub is not registered offline without a trust policy supplied by hand, because the policy it advertises cannot be fetched; register it once while online, or pin its trust by hand with `aggrega registry add <host> --identity <identity>=<issuer>` or `--key <public-key-file>`A registry is added offline with no trust policy to pin (Un registre est ajouté hors ligne sans politique de confiance à épingler)
E0311reference carries a malformed version pinA version pin is none of the forms a pin takes (Un épinglage de version ne prend aucune des formes d’un épinglage)
E0312a provider socket binding names a capability containing a colon, which no Recipe can selectA provider binding names a capability containing a colon (Une liaison de fournisseur désigne une capacité contenant un deux-points)
E0313plugins.providers entry names a capability no provider-rendering plugin the build reads servesA provider binding names a capability no plugin the build reads serves (Une liaison de fournisseur nomme une capacité qu’aucun plugin lu par le build ne sert)
E0314plugin was built from a working tree with uncommitted changes, so no commit reproduces the version it reportsA plugin was built from a working tree with uncommitted changes (Un plugin a été construit à partir d’un arbre de travail contenant des modifications non validées)
E0315a connection carries an attachment under a name its socket declares no slot forA connection carries an attachment under a name its socket declares no slot for (Une connexion porte un rattachement sous un nom pour lequel son socket ne déclare aucun emplacement)
E0316a Release attachment takes the name of an attachment one of a component's connections carriesA Release attachment takes the name of a connection’s attachment (Un rattachement de la Release prend le nom du rattachement d’une connexion)
E0317a Release connection attachment names no Feature type, and the type is required for an attachment only the Release makesA Release connection attachment names no Feature type (Un rattachement de connexion de la Release ne nomme aucun type de Feature)
E0318duplicate delivery key across two attachments: an attachment's FeatureRecipe writes a delivery key another attachment already deliveredTwo attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Deux Features rattachées livrent une même clé, la seconde par l’injectMapping de sa FeatureRecipe)
E0319connection alias is already used by another connection of the same componentTwo connections of one component under one alias (Deux connexions d’un composant sous un même alias)
E0320a path this operation writes or deletes leads through a link out of the directory it must stay insideA path the operation writes leads through a link out of the directory it must stay inside (Un chemin que l’opération écrit mène, par un lien, hors du répertoire dans lequel il doit rester)
E0321a file this operation reads leads through a link out of the directory it must stay insideA file the operation reads leads through a link out of the directory it must stay inside (Un fichier que l’opération lit mène, par un lien, hors du répertoire dans lequel il doit rester)
E0323template reads its callers' render facts, but the FeatureRecipe does not set readsCallerRenderFactsA template reads its callers’ render facts without declaring it (Un template lit les faits de rendu de ses appelants sans le déclarer)
E0324a reference a document makes to another file leads out of the directory it must stay insideA reference to another file leads out of the directory it must stay inside (Une référence à un autre fichier sort du répertoire à l’intérieur duquel elle doit rester)
E0325provider guest reported a render fact whose value is not a list; a conforming guest reports every render fact's value as a JSON array, even with one entryA provider reported a render fact whose value is not a list (Un fournisseur a signalé un fait de rendu dont la valeur n’est pas une liste)
E0326pipeline step reads its callers' render facts, but a pipeline step does not read the components connecting to its host; it reads only the host's own render factsA pipeline step reads its callers’ render facts (Une étape de pipeline lit les faits de rendu de ses appelants)
E0327template indexes a map with a key the map does not holdA template indexes a map with a key the map does not hold (Un template indexe une map avec une clé que la map ne contient pas)
E0328attachment written under a name no slot declares fits a slot its component leaves emptyAn attachment written under another name fits a slot its component leaves empty (Un rattachement écrit sous un autre nom correspond à un emplacement que son composant laisse vide)
E0329a connection and the target it reaches do not name one key: they write different locators for it, or only one of them names oneA connection and the target it reaches do not name one key (Une connexion et la cible qu’elle atteint ne nomment pas une même clé)
E0330signing: the references named together need different signing credentials, so nothing was signedReferences signed together need different signing credentials (Des références signées ensemble nécessitent des identifiants de signature différents)
E0331signing: no verified signature is recorded for an artifact that requires oneNo verified signature is recorded for an artifact that requires one (Aucune signature vérifiée n’est enregistrée pour un artefact qui en exige une)
E0332signing: the recorded signature was made for a different artifactA recorded signature was made for a different artifact (Une signature enregistrée a été créée pour un autre artefact)
E0333signing: a recorded signature is not the one a pull would recordA recorded signature is not the one a pull would record (Une signature enregistrée n’est pas celle qu’enregistrerait un pull)
E0334an omits entry left out nothing the source renderedAn omits entry left out nothing the source rendered (Une entrée omits n’a rien laissé de côté de ce que la source a rendu)
E0335provider does not support omitsThe provider does not support omits (Le fournisseur ne prend pas en charge omits)
E0336a provider's omitted counts do not match the omits entries it was handedA provider’s omitted counts do not match the omits entries it was handed (Les décomptes d’omissions d’un fournisseur ne correspondent pas aux entrées omits qui lui ont été transmises)
E0337no importer plugin version satisfies the plugins.importer entry's version pinA plugins.importer entry pins a version of its importer the catalog does not hold (Une entrée épingle une version de son importateur que le catalogue ne contient pas)
E0338importer is attached by more than one plugins.importer entryAn importer is attached by more than one plugins.importer entry (Un importateur est rattaché par plus d’une entrée)
E0339more than one importer recognises the sourceMore than one importer recognises the source (Plusieurs importers reconnaissent la source)
E0340a name this operation writes holds a path segment Windows cannot hold as writtenA name the operation writes holds a part Windows cannot hold (Un nom que l’opération écrit contient une partie que Windows ne peut pas contenir)
E0341the importer serving the source's format declares no file patterns, so it reads one file and cannot read a directoryAn importer that declares no file patterns is handed a directory (Un importer qui ne déclare aucun motif de fichier reçoit un répertoire)
E0342no file in the directory matches the file patterns the importer serving the source's format declaresNo file in the directory matches the importer’s file patterns (Aucun fichier du répertoire ne correspond aux motifs de fichiers de l’importer)
E0343a file read from the directory and a file named in the importer's `with.sources` have the same nameA file read from the directory and a file named in the importer’s with.sources have the same name (Un fichier lu dans le répertoire et un fichier nommé dans les sources de l’importer portent le même nom)
E0344an entry this publication carries cannot be used on WindowsA published archive carries an entry Windows cannot use (Une archive publiée contient une entrée que Windows ne peut pas utiliser)
E0345a container declares one environment variable twiceA container gives one environment variable two values (Un conteneur donne deux valeurs à une même variable d’environnement)
E0346a Component's annotation stating how its metrics authenticate disagrees with whether it declares the provides key saying an instance's metrics need a credentialA Component’s metrics annotation and its provides key disagree (L’annotation de métriques d’un Component et sa clé provides ne concordent pas)
E0347template reads the render facts of a component its host is wired to, but the FeatureRecipe does not set readsTargetRenderFactsA template reads its targets’ render facts without declaring it (Un template lit les faits de rendu de ses cibles sans le déclarer)
E0348pipeline step reads the render facts of a component its host is wired to, but a pipeline step reads only the host's own render factsA pipeline step reads its targets’ render facts (Une étape de pipeline lit les faits de rendu de ses cibles)
E0349no Recipe in the workspace's catalog binds to the capability the import's target namesAn import’s target names a capability no Recipe in the catalog binds to (La cible d’une importation nomme une capacité à laquelle aucune Recipe du catalogue ne se lie)
E0350no importer recognises the sourceNo importer recognises the source (Aucun importer ne reconnaît la source)
E0351provider does not support boundary artifactsThe provider does not support boundary artifacts (Le fournisseur ne prend pas en charge les artefacts de frontière)
E0352boundary output directory does not name a directory beneath the output rootA boundary’s output directory is not a directory beneath the output root (Le répertoire de sortie d’une frontière n’est pas un répertoire sous la racine de sortie)
E0353boundary-level Feature instance name is not a directory nameA boundary-level Feature is named . or .. (Une Feature de portée frontière est nommée . ou ..)
E0354a template does more than copy a value it reads off a cross-boundary linkA template did more than copy a value it read off a cross-boundary link (Un template a fait plus que copier une valeur qu’il a lue sur un lien entre frontières)
E0355inject delivery: shape must be a list of entries, each `in:` with exactly one of `from:` or `value:`An inject: delivery is not a list of entries (Une livraison d’inject n’est pas une liste d’entrées)
E0356suspend requires form: scheduledA workload suspend: is set on a form other than scheduled (La suspension d’une charge de travail est définie sur une forme autre que planifiée)
E0357a Manifest name mapping's key names no component instance or attachment in this build, so the entry binds nothingA Manifest name mapping names nothing in the build (Un mappage par nom du Manifest ne nomme rien dans le build)
E0358uses edge target names a component its module does not exportA uses target names a module’s component the module does not export (Une cible d’arête nomme un composant d’un module que le module n’exporte pas)
E0359no source adapter is registered in this program for the source kindNo source adapter is registered in this program for a source kind (Aucun adaptateur de source n’est enregistré dans ce programme pour un type de source)
E0360the netrc file could not be readThe netrc file cannot be read (Le fichier netrc ne peut pas être lu)
E0361the source URL carries a credentialA source URL carries a credential (Une URL de source contient un identifiant de connexion)
E0362inject entry on a connection carries `value:`; a connection delivers the target's published keys, each named with `from:`An inject: entry on a connection carries a literal (Une entrée d’inject sur une connexion porte un littéral)
E0363annotation subkey is not routed by the annotation's bindingAn annotation subkey is not routed by its binding (Une sous-clé d’annotation n’est pas routée par sa liaison)
E0364a value template failed while it ranA value template failed while it ran (Un template de valeur a échoué pendant son exécution)
E0365boundary-level Feature's output is routed to a dispatch path nothing assemblesA boundary-level Feature’s output reaches no assembled file (La sortie d’une Feature de portée frontière n’atteint aucun fichier assemblé)
E0366FeatureRecipe injectMapping output could not be read as a dictionary of deliveriesAn attached Feature’s injectMapping output cannot be read (La sortie injectMapping d’une Feature rattachée ne peut pas être lue)
E0367a scalar annotation value does not route to exactly one path of its bindingA bare annotation value does not route to exactly one path of its binding (Une valeur d’annotation simple n’est pas routée vers exactement un chemin de sa liaison)
E0368FeatureRecipe injectMapping output writes a key no delivery mechanism of the host readsAn attached Feature’s injectMapping output writes deliveries under a key nothing delivers (La sortie injectMapping d’une Feature rattachée écrit des livraisons sous une clé que rien ne livre)
E0369template reads a path as a value and iterates it, and the data holds nothing at that pathA template reads and iterates a path that holds nothing (Un template lit et itère un chemin qui ne contient rien)
E0370a pipeline declares one step id twiceA pipeline declares one step id twice (Un pipeline déclare deux fois un même id d’étape)
E0371catalog document declares a kind a catalog does not holdA catalog document declares a kind a catalog does not hold (Un document de catalogue déclare un type qu’un catalogue ne contient pas)
E0372inject entry on an attachment carries `value:`; an attachment delivers the keys its FeatureRecipe publishes, each named with `from:`, and a literal belongs in the component's own inject blockAn inject: entry on an attached Feature carries a literal (Une entrée d’injection sur une Feature attachée porte un littéral)
E0373a document declares an API version this compiler no longer readsA document declares an API version this compiler no longer reads (Un document déclare une version d’API que ce compilateur ne lit plus)
E0374a plugin declares a plugin ABI version this compiler no longer speaksA plugin declares a plugin ABI version this compiler no longer speaks (Un plugin déclare une version d’ABI de plugin que ce compilateur ne prend plus en charge)
E0375oci: artifact carries a media type this compiler no longer readsAn artifact carries a media type this compiler no longer reads (Un artefact porte un type de média que ce compilateur ne lit plus)
E0376egress: the server did not answer in timeA server did not answer in time (Un serveur n’a pas répondu à temps)
E0377registry: the repository listing did not end in timeA registry’s repository listing did not end in time (La liste des dépôts d’un registre ne s’est pas terminée à temps)
E0378oci: the registry kept asking to slow downA registry kept asking to slow down (Un registre a continué de demander de ralentir)

Le domaine du linter (non fatal)

Le compilateur est strictement sans parti pris quant à l’exécution. Il n’arrête jamais le build pour des motifs qui sont seulement suspects — valeurs inutilisées, secrets orphelins, cibles déconnectées. Tout au plus, un tel motif suscite un avertissement — celui du build lui-même, pour les quelques-uns catalogués ci-dessus sous « Conditions qui n’arrêtent pas un build », comme un paramètre déclaré que rien ne lit — et le reste relève du domaine du linter, où les entreprises choisissent d’adopter des plugins Wasm qui appliquent leurs propres conventions.

Informations d’identification orphelines

Une Feature d’informations d’identification rattachée sans contrat de livraison inject: n’est pas une erreur de compilation. Le compilateur de base conserve la déclaration dans le graphe IR et n’émet aucun avertissement. Les plugins linter d’entreprise peuvent détecter ce motif et avertir à son sujet ; les renderers d’entreprise peuvent aussi choisir de monter implicitement les secrets orphelins selon leurs propres conventions Black-Box. Comme les deux interprétations sont valides, le compilateur de base ne prend aucun parti.