Una detención fatal es un error en tiempo de compilación que detiene la compilación antes de que se produzca ninguna salida. Cada detención nombra el archivo, la entidad y el campo erróneo, explica qué no pudo resolver el compilador y señala el cambio de autoría concreto que la corrige. El compilador nunca repara ni reescribe en silencio tu entrada — si algo está mal, la compilación se detiene y te dice dónde.
Este catálogo está organizado según la etapa de la compilación en la que se produce cada detención.
Cada entrada a continuación cita el mensaje que imprime una compilación para la condición que documenta: la frase fija que enuncia la condición y, después, lo que haya aportado esa ocurrencia. En un terminal, ese mensaje aparece dentro de un marco — un encabezado entre corchetes que lleva la categoría y el código corto de la condición, un puntero al archivo y la clave erróneos seguido de la instancia a la que se refiere el fallo como (instance <name>) — o solo esa instancia, como instance <name>, donde no corresponde ningún archivo — y el mensaje en la línea de abajo — de modo que una línea entera pegada de una compilación no coincidirá con ninguna entrada de aquí, mientras que el mensaje que contiene sí; error-translation.md expone el marco por completo.
Si llegas desde una compilación con un código corto en la mano — la letra E y cuatro dígitos, en el encabezado entre corchetes del diagnóstico —, empieza por Encontrar una detención a partir del código corto que imprimió la compilación al final de esta página, que enumera cada condición catalogada aquí junto al código corto que una compilación imprime para ella.
Al cargar tus archivos
El compilador lee cada Aggregate, Manifest, Component, Feature, Recipe, FeatureRecipe, Plugin y Release a los que hace referencia tu compilación, valida cada uno con su esquema e interpola los parámetros tipados de la Release en el Aggregate.
YAML anchor aliased inside its own content (Ancla YAML referenciada mediante un alias dentro de su propio contenido)
Un documento ancla un nodo con &name y luego lo referencia mediante un alias con *name en algún lugar dentro del contenido que cubre esa ancla. Expandir el alias reproduce el ancla, cuyo contenido vuelve a llevar el alias, de modo que el documento describe una estructura sin fin. No hay nada finito que leer, y mucho menos que validar, y la compilación se detiene en lugar de iniciar un recorrido que no puede terminar.
Leer YAML en un árbol no expande los alias, así que un documento con esta forma se lee sin objeciones y solo falla cuando algo lo recorre. Por eso el rechazo se sitúa entre la lectura y el recorrido — y una compilación lee el YAML escrito por el autor en más de un punto, así que la misma condición puede encontrarse en más de uno. Cuatro puntos la informan, y cada uno enmarca la misma explicación con lo que localiza el documento en esa superficie:
Un archivo de entidad, mientras se lee. La compilación se detiene antes de que esa entidad se compruebe con su esquema, así que esta detención nombra un ancla en lugar de un campo y no lleva línea ni columna: en ese momento el documento no tiene ninguna posición a la que un diagnóstico pueda apuntar de forma útil.
Un cuerpo de esquema, mientras se compila. Un pilar spec.schema: se compila desde la forma compacta a un documento JSON Schema después de leerse su archivo, así que esta detención se produce durante esa compilación y no antes, y sí lleva una línea. La forma que una lectura anterior no puede detectar es un cuerpo de escape $jsonschema:: un cuerpo de escape es un escalar de bloque — texto plano, sin anclas — mientras se lee el archivo que lo rodea, y sus anclas solo se convierten en anclas cuando ese texto se analiza a su vez, un nivel más abajo. Cuando el ciclo estaba dentro de un bloque así, la detención nombra además $jsonschema como la palabra clave cuyo cuerpo lo contenía.
El esquema de carga de trabajo de un Plugin proveedor, mientras se carga el Plugin.spec.provider.workloadSchema se escribe como un escalar de bloque: texto plano mientras se lee el propio archivo del Plugin, sin anclas en ese momento, y sus anclas solo se convierten en anclas cuando ese texto se analiza como un documento propio, un nivel más abajo. Ese análisis y la compilación que le sigue ocurren ambos mientras se carga el Plugin, así que esta detención se produce ahí y no al leerse el archivo, y lleva una línea. Cuando el ciclo estaba dentro de un escape $jsonschema: en el cuerpo del esquema, la detención nombra además $jsonschema como la palabra clave cuyo cuerpo lo contenía. Consulta ../entities/plugin.md para la superficie de autoría del campo.
Un fragmento de CloudFormation renderizado, mientras el proveedor lo lee. Una Recipe cloudformation escribe un fragmento, y un cuerpo artifacts: es una plantilla — así que lo que lee el proveedor es el texto que produjo el renderizado de esa plantilla, contenido que no existía mientras se leían tus archivos. Por eso esta detención se produce mientras se renderiza la salida, cuando todas las comprobaciones de esquema ya se han superado. Consulta ../providers/cloudformation.md para la superficie de autoría de los fragmentos.
El rechazo es de la recursión, nunca de la reutilización ni de la profundidad. Anclar contenido compartido y referenciarlo desde muchos lugares es un patrón de autoría admitido — consulta ../entities/aggregate.md «Patrones de anclas YAML (bloque defs:)» y ../entities/manifest.md «Anclas YAML para manifiestos DRY» — y una referencia que se expande y termina se carga con normalidad, por muchas veces que aparezca y por muy profundo que sea el anidamiento del documento; la profundidad por sí sola nunca es motivo de esta detención. Lo que detiene la compilación es un ancla alcanzada mientras la compilación sigue dentro de ella, también cuando se alcanza de forma indirecta, a través de una segunda ancla declarada debajo de ella. El mensaje nombra el ancla sobre la que se cierra el bucle, que no es necesariamente el ancla más externa del documento.
Mensajes emitidos. Los cuatro llevan la misma explicación, y es deliberado: es una sola condición encontrada en cuatro puntos, y un autor que ha aprendido a leerla una vez no debería tener que aprenderla de nuevo. Solo cambia el marco que localiza el documento.
anchor &<anchor> is aliased by *<anchor> inside its own content, so the document expands without end; point that alias at content declared outside &<anchor>, or write the content out in full (el ancla está referenciada mediante un alias dentro de su propio contenido, así que el documento se expande sin fin; apunta ese alias a contenido declarado fuera del ancla, o escribe el contenido completo)
Un archivo de entidad se enmarca con la comprobación de envoltura que lo estaba leyendo y con la ruta desde la que se leyó:
document envelope validation failed: envelope: parse <path>: <the explanation above> (falló la validación de la envoltura del documento: envoltura: análisis)
Un cuerpo de esquema se enmarca con su posición dentro del esquema y, cuando el ciclo estaba dentro de un bloque $jsonschema:, con la palabra clave de escape. La compilación lo informa bajo una etiqueta CATALOG_ERROR, que nombra además el archivo, la entidad y el pilar cuyo cuerpo no se pudo compilar:
compactform at <schema-path>:<line> (keyword "$jsonschema"): <the explanation above> (compactform en la posición, palabra clave)
El esquema de carga de trabajo de un Plugin proveedor lleva ese mismo marco de forma compacta; lo que cambia es la etiqueta CATALOG_ERROR que lo rodea, que nombra el Plugin y spec.provider.workloadSchema en lugar de la entidad y su pilar.
Un fragmento renderizado se enmarca con el proveedor que lo leyó:
cloudformation-provider: parse fragment: <the explanation above> (cloudformation-provider: análisis del fragmento)
Cómo corregirlo: apunta el alias a contenido declarado fuera del ancla dentro de la que se encuentra ahora, o escribe completo el contenido repetido en el punto de uso. En un Aggregate o un Manifest, el bloque defs: de nivel raíz es el lugar natural para las anclas compartidas — está fuera de todo bloque que lo referencia, así que un ancla declarada allí no puede alcanzarse desde dentro de sí misma. En los demás tipos de entidad, que no tienen bloque defs:, ancla el contenido compartido en algún lugar del que el bloque que lo referencia no sea descendiente. Un ancla puede referenciarse desde cualquier número de lugares y desde cualquier profundidad; la única forma que no puede adoptar es una referencia que vuelva a caer dentro del contenido que cubre el ancla.
El mismo remedio se aplica dondequiera que se haya encontrado la detención, y el marco te dice qué documento abrir: el propio archivo de entidad, el bloque $jsonschema: dentro de un pilar de esquema, el cuerpo workloadSchema dentro de un Plugin proveedor o el cuerpo artifacts: cuya salida renderizada leyó el proveedor. En este último caso, el ancla está en la plantilla que escribiste, no en el texto renderizado — el renderizado la reprodujo fielmente.
Parameter type mismatch / contract violation (Tipo de parámetro no coincidente / infracción del contrato)
La Release proporcionó un valor cuyo tipo o forma no coincide con lo que el Aggregate declaró para ese parámetro. El validador de contratos de parámetros detecta discrepancias de tipo, infracciones de enum, infracciones de rango, infracciones de patrón, cadenas que no son instancias válidas de su format declarado, predicados validate: no satisfechos y parámetros obligatorios ausentes, antes de que se ejecute cualquier interpolación de plantillas. Los nombres que puede tomar un format, y lo que comprueba cada uno, se enumeran en Formatos con nombre.
Mensaje emitido — la frase que enuncia la condición, luego la entidad en falta, la ruta del campo y el detalle de la restricción:
parameter contract violated (Aggregate, at .spec.parameters.<parameter>, parameter "<parameter>" expected type <declared type>; got <received type>) (contrato de parámetro infringido: el parámetro esperaba el tipo declarado y recibió otro)
Para un parámetro declarado required: true sin default: y sin un valor proporcionado por la Release, el informe contiene una condición distinta y un código corto distinto:
required parameter not supplied (Aggregate, at .spec.parameters.<parameter>, parameter "<parameter>" is required but not supplied by Release) (parámetro obligatorio no proporcionado: el parámetro es obligatorio, pero la Release no lo proporciona)
Solo el detalle que sigue a la ruta del campo cambia según la restricción incumplida. La frase y el marco entre paréntesis que la rodea son los mismos cada vez, lo que convierte la frase en la parte con la que comparar y el detalle en la parte que leer. Los detalles que imprime una compilación, uno por tipo de restricción:
parameter "<parameter>" value <value> not in enum [<members>] (valor del parámetro fuera del enum) parameter "<parameter>" value "<value>" does not match pattern "<pattern>" (el valor del parámetro no coincide con el patrón) parameter "<parameter>" value "<value>" is not a valid <format>: <reason> (el valor del parámetro no es válido para el formato) parameter "<parameter>" value <value> above max <max> (valor del parámetro por encima del máximo) parameter "<parameter>" failed validate predicate (el predicado validate del parámetro no se cumplió) parameter "<parameter>" validate predicate error: <detail> (error del predicado validate del parámetro)
El <reason> de un fallo de formato indica qué falla en el valor en los términos propios de ese formato. Un valor dentro de un contrato anidado se nombra por su ruta, de modo que un format que declara un contrato items: se comprueba en cada elemento y el informe nombra el que falló: el segundo elemento de un parámetro hosts se notifica en .spec.parameters.hosts.1, y su detalle nombra "hosts.1".
Un parámetro que declara un validateMessage: sustituye todo ese detalle por su propio texto, de modo que el informe dice parameter contract violated (Aggregate, at .spec.parameters.<parameter>, <the validateMessage you wrote>) — el marco no cambia y tu frase ocupa el lugar del detalle de la restricción.
La misma condición cubre un contrato que, tal como está escrito, no puede restringir nada. Un pattern: que no es una expresión regular válida se rechaza cuando se lee el contrato de parámetros del Aggregate, antes de comprobar cualquier valor de la Release, de modo que detiene la compilación tanto si una Release proporciona el parámetro como si no. El informe apunta a la clave — .spec.parameters.<parameter>.pattern, o la ruta a través de un contrato anidado como .spec.parameters.<parameter>.items.pattern — y su detalle nombra la declaración, el patrón y el motivo:
parameter "<parameter>" pattern "<pattern>" does not compile: <reason> (el patrón del parámetro no compila)
Un format: que nombra un formato fuera del conjunto admitido tampoco puede restringir nada, y se rechaza en el mismo punto, antes de comprobar cualquier valor de la Release, de modo que también detiene la compilación tanto si una Release proporciona el parámetro como si no. Dentro de un contrato anidado — bajo items:, properties: o valuesType: — es esta condición la que lo rechaza: el informe apunta a la clave, como .spec.parameters.<parameter>.items.format, y su detalle nombra la declaración, el formato tal como está escrito y cada nombre admitido:
parameter "<parameter>.items": format "<format>" is not supported; the supported formats are email, uri, hostname, ipv4, ipv6, uuid, date-time, date (formato del parámetro no admitido; los formatos admitidos son email, uri, hostname, ipv4, ipv6, uuid, date-time, date)
En la propia declaración de un parámetro, el mismo nombre se rechaza un paso antes, por el esquema del Aggregate, cuyo format solo acepta los nombres admitidos. Ese rechazo es el documento que no cumple el esquema de su tipo — una condición distinta, con su propio código corto, E0215 — y aggrega pull y aggrega validate --release lo enumeran después de notificar la referencia aggregate: de la Release como no resoluble (E0170), ya que el Aggregate que contiene el nombre no se cargó:
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 (falló la validación del sobre del documento: el formato no está entre los valores permitidos; corrige el documento para que coincida con el esquema de su tipo)
El detalle de error del predicado cubre las dos formas en que un predicado validate: puede no producir un veredicto: una función que la superficie no registra y una referencia a algo distinto de .value. Cada una se notifica respecto al predicado y no respecto al valor, y cada una nombra lo que no pudo resolver.
Un predicado validate: lee el valor sometido a validación como .value, y ese es el único nombre que define. Un predicado que nombra cualquier otra cosa se rechaza antes de ejecutarse, de modo que una referencia mal escrita se notifica como el error de nomenclatura que es, en lugar de resolverse en nada y aparecer como un valor que no superó la validación.
Cómo corregirlo: cambia el valor de la Release para que cumpla las restricciones type / enum / min / max / pattern / format declaradas del parámetro, proporciona un parámetro obligatorio ausente, corrige un pattern: que no compila, sustituye un format: que nombra un formato no admitido por uno de los formatos con nombre o elimínalo, corrige un predicado validate: que nombra algo distinto de .value o que produce algo distinto de true o false, o amplía la declaración del Aggregate para que acepte la forma que realmente necesitas.
Reglas de forma de la Recipe
Una Recipe compone su salida a partir de tres tipos de entrada — de origen, sintetizada y artefactos — descritos en ../../architecture/16-recipe-input-composition.md. La forma de una Recipe válida está restringida por las reglas de composición que siguen. Difieren en cuándo se comprueban — cuando se carga la Recipe, cuando un nodo se renderiza o cuando se emite la salida — así que lee cada entrada para saber en qué punto se comprueba su propia condición.
Cada regla recibe su nombre de lo que restringe. No hay numeración, y ningún número está reservado: un nombre dice qué parte de la Recipe abrir, y lo sigue diciendo por mucho que la lista siguiente crezca o se reordene. Cuando necesites registrar una condición de forma duradera — en una comprobación de CI, una incidencia, un runbook — usa su código, el identificador que sentinels.md enumera para la condición y el que permanece fijo mientras evolucionan los paquetes que lo rodean.
Una detención por la forma de una Recipe se compone de la misma manera. Comienza con la frase que enuncia la regla, luego nombra lo que esta Recipe en particular proporcionó y, después, el detalle específico de ella:
<the rule's sentence> (Recipe <name>:<version>, rule <rule-name>, at <position>). <rule-specific detail> (la frase de la regla, luego la Recipe con su nombre y versión, el nombre de la regla y la posición; después, el detalle específico de la regla)
La frase inicial es fija para cada regla — el mismo texto cada vez que esa regla detiene la compilación, sea cual sea la etapa que la detectó —, por lo que es la parte de la salida con la que comparar, y es el texto que sentinels.md enumera para la condición de la regla. Todo lo que sigue varía según la Recipe en falta: los valores entre paréntesis dicen qué documento, qué regla por su nombre y dónde, y la frase final es el consejo para esa aparición. La posición es el archivo desde el que se cargó la Recipe cuando la regla trata del documento en su conjunto, y una ruta con puntos hasta la clave que escribiste — .spec.outputComponentLabels.hosting — cuando la regla trata de una sola cosa dentro de él; una clave que lleva puntos propios no puede escribirse como un segmento más sin leerse igualmente como dos, así que la ruta se detiene en el bloque que la contiene y el consejo cita la clave en su lugar.
La compilación imprime la línea completa bajo una etiqueta CATALOG_ERROR, que indica que el fallo es atribuible a la entidad del catálogo (la Recipe, o el proveedor al que se vincula), no al Aggregate ni a la Release. El archivo desde el que se cargó la Recipe se imprime junto a la etiqueta, de modo que una regla posicionada en una clave sigue indicándote qué archivo abrir.
valuesMapping requires source (el mapeo de valores requiere una fuente)
Una Recipe declara valuesMapping pero no source. Sin una fuente sobre la que superponerlos, no hay nada que reciba los valores mapeados. Esta regla se comprueba cuando se carga la Recipe.
Mensaje emitido:
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 requiere source; declara un puntero source: junto a valuesMapping, o elimina valuesMapping si no se pretende ninguna superposición)
Cómo corregirlo: añade un puntero source: (una referencia a un chart, un módulo o un archivo compose) junto al valuesMapping, o elimina el valuesMapping y adopta un tipo de entrada distinto (workload: para salida sintetizada, artifacts: para la emisión directa de manifiestos).
workload: requires a provider that can synthesize (requiere un proveedor capaz de sintetizar)
Una Recipe declara workload: (modo sintetizado) para un proveedor que no implementa la síntesis de Workload. El soporte del modo sintetizado es una propiedad del proveedor — el catálogo de la biblioteca estándar declara workloadSchema en los proveedores capaces de sintetizar por convención, pero la comprobación se basa en la capacidad del proveedor, no en la presencia de ese campo.
Dos superficies lo notifican, y solo una de ellas decide la compilación. La detención se produce en el momento del renderizado, después de vincular el proveedor del nodo y una vez leídos los tipos de entrada que declara su Recipe, por lo que ese informe nombra el nodo. aggrega validate notifica el mismo hallazgo antes, antes de vincular ningún nodo, leyendo la Recipe por sí sola — así que ese informe nombra en su lugar la Recipe y su versión. Los dos no leen el mismo conjunto de Recipes: el informe temprano se produce para cualquier Recipe que declare workload:, mientras que la detención se produce para cada tipo de entrada que declara el nodo y que su proveedor no puede atender. Así, una Recipe que combina un workload: con un source: se detiene igualmente, y se detiene por la carga de trabajo — declarar un tipo de entrada que el proveedor puede renderizar no hace pasar el control a uno no admitido.
El único límite a eso: artifacts: se comprueba frente al soporte de artefactos independientes solo cuando es el único tipo declarado del nodo. Junto a un source: o un workload:, sus archivos pasan como salida compuesta, que esa capacidad no gobierna.
Mensaje emitido en el momento del renderizado. La categoría a la que se atribuye el fallo te llega en la cabecera entre corchetes del diagnóstico, y no dentro del mensaje. El mensaje comienza con la frase fija que enuncia la condición y luego nombra el nodo, el proveedor, el tipo declarado que se rechazó y los tipos que ese proveedor sí admite. Cuando un nodo declara dos tipos que su proveedor no puede atender, se notifica el primero en el orden source → workload → artifacts, de modo que el hallazgo se refiere a una sola línea de tu 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> (el proveedor no admite el tipo de entrada del nodo; declara uno de los tipos de entrada admitidos o apunta a un proveedor que admita el modo)
La cabecera lleva la categoría y el código corto de esta condición, E0265, que es el identificador que debes registrar cuando necesites nombrar esta detención de forma duradera — en una comprobación de integración continua, una incidencia o un runbook. Un número se asigna una vez y después queda fijo, por lo que sigue siendo el mismo por mucho que mejore la redacción que lo rodea; la tabla de todas las condiciones lo resuelve, y la frase inicial de arriba es con lo que comparar cuando trabajas a partir de texto y no de un identificador.
aggrega validate notifica la misma cláusula bajo la Recipe que contiene el bloque, precedida por la superficie que la leyó y encabezada por el código corto de esta condición, porque el informe temprano es la misma condición:
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 (el proveedor no admite el modo sintetizado; declara uno de los tipos de entrada admitidos o apunta a un proveedor que admita el modo sintetizado)
Sobre todo el catálogo es una sola línea; con --release, la cabecera queda en su propia línea encima de la cláusula. El diagnóstico del editor para el mismo hallazgo lleva E0265 como código.
Cómo corregirlo: vincula la Recipe a un proveedor que sintetice (lo más habitual, helm o compose), o migra la Recipe a un tipo de entrada distinto (artifacts: para la emisión directa de manifiestos, o source: + valuesMapping: si existe un chart/módulo).
Validación del contenido del Workload por proveedor. Hoy, el workloadSchema del proveedor es solo documentación y no valida el cuerpo del Workload; los cuerpos se validan frente al esquema de Workload integrado que pertenece a la plataforma. Cuando se publique el sintetizador de Workload basado en Wasm, workloadSchema pasará a ser el contrato por proveedor frente al cual el sintetizador valida el cuerpo del Workload (una detención distinta, a nivel de contenido).
The provider does not support omits (El proveedor no admite omits)
Una Recipe o una FeatureRecipe declara omits: y el proveedor que la renderiza no declara que excluya documentos renderizados. Excluir un documento de lo que renderiza una fuente es algo que solo puede hacer el proveedor — solo el proveedor sabe qué documentos renderiza la fuente y cómo se llama cada uno —, de modo que un proveedor que no lo hace renderizaría todos los documentos que nombran las entradas y notificaría éxito. En su lugar, la compilación lo rechaza antes de que se renderice nada, así que la clave nunca queda sin efecto en silencio.
Si un proveedor excluye documentos se lee de la propia declaración del proveedor sobre lo que admite, no de una lista de proveedores que mantenga el compilador. Cuenta cada entrada, renderice lo que renderice su when:, porque que el proveedor pueda respetar la clave no depende de qué entradas conserve una compilación. Los proveedores helm, compose y cloudformation respetan la clave. helm-chart y terraform pasan su fuente para que se renderice cuando se despliega, por lo que en tiempo de compilación no existe ningún documento renderizado que excluir, y ambos se rechazan.
El rechazo se decide una vez que la Recipe de cada componente y la FeatureRecipe de cada vinculación están enlazadas y cada proveedor se ha descrito a sí mismo — antes de que se renderice el primer componente y antes de que se evalúe ninguna entrada, por lo que una compilación rechazada aquí no renderiza nada. Se comprueba en cada documento que renderiza una fuente: la Recipe de un componente; la FeatureRecipe que una vinculación enlaza en un componente, una vez por cada componente que lleva la vinculación; y una FeatureRecipe que genera una sola vez para un límite, una vez, en el límite que la declara. Cada documento en falta se notifica en una sola compilación; cuando hay más de uno, los hallazgos se agrupan bajo documents declaring omits whose provider does not honour them. Un documento enlazado a un proveedor que la compilación no puede resolver no se notifica aquí: esa compilación se detiene donde se selecciona el proveedor, nombrando el enlace.
Mensaje emitido, posicionado en la propia clave del componente bajo components: para las entradas de una Recipe (un componente escrito dentro de un subsistema se posiciona primero bajo la clave de ese subsistema), en la clave de la vinculación en el bloque features: que la escribió para las de una FeatureRecipe en un componente, y en .spec.boundaries.<boundary>.features.<attachment> en la Release para una FeatureRecipe que genera una sola vez para su límite. La categoría te llega en el encabezado entre corchetes; el mensaje nombra primero el proveedor y luego el componente para el que se renderiza el documento:
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 (el proveedor no admite omits: el contrato de este proveedor no declara que excluya documentos renderizados; elimina la clave omits o renderiza la fuente mediante un proveedor cuyo contrato lo declare)
El hallazgo de una FeatureRecipe nombra la vinculación después del componente — node "<node-id>", attachment "<attachment>" — y el de una FeatureRecipe que genera una sola vez para su límite nombra el límite y la vinculación en lugar de un componente: boundary "<boundary>", attachment "<attachment>".
El encabezado lleva el código corto de esta condición, E0335.
Cómo corregirlo: elimina la clave omits: o renderiza la fuente mediante un proveedor que la respete. Cuando una Recipe helm-chart o terraform toma como fuente un chart o un módulo local, una línea en el .aggregaignore junto a la Recipe excluye en su lugar un archivo de esa fuente, a partir de la próxima vez que se fije la Recipe — consulta aggrega pin.
The provider does not support boundary artifacts (El proveedor no admite artefactos de límite)
Una Recipe declara spec.boundary.artifacts — archivos para la salida compartida del límite en el que se renderiza — y el proveedor que la renderiza no declara que acepte tales archivos. El compilador escribe esos archivos por sí mismo, junto a lo que el proveedor ensambla para el límite, y no le pasa ninguno al proveedor, así que si un archivo colocado ahí significa algo es una propiedad del destino del proveedor. Un destino que no lo lee lo entregaría y lo ignoraría, y la configuración que lleva nunca surtiría efecto; en su lugar, la compilación lo rechaza antes de que se renderice nada.
Si un proveedor acepta los archivos se lee de la propia declaración del proveedor sobre lo que admite, no de una lista de proveedores que mantenga el compilador. Cuenta cualquier entrada, sea cual sea el resultado de renderizarla. El proveedor terraform los acepta y escribe cada uno junto a la configuración raíz del límite; helm, compose, helm-chart y cloudformation no, y se rechazan.
El rechazo se decide una vez que la Recipe de cada componente está enlazada y cada proveedor se ha descrito a sí mismo — antes de que se renderice el primer componente y antes de que se evalúe ninguna entrada, por lo que una compilación rechazada aquí no renderiza nada. Cada Recipe en falta se notifica en una sola compilación, una vez por cada componente que renderiza; cuando hay más de un hallazgo, se agrupan bajo Recipes declaring boundary artifacts whose provider does not accept them. Una Recipe enlazada a un proveedor que la compilación no puede resolver no se notifica aquí: esa compilación se detiene donde se selecciona el proveedor, nombrando el enlace.
Mensaje emitido, posicionado en .spec.boundary en la Recipe, donde está la edición. La categoría te llega en el encabezado entre corchetes; el mensaje nombra primero el proveedor y luego el componente para el que se renderiza la Recipe:
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 (el proveedor no admite artefactos de límite: el contrato de este proveedor no declara que acepte archivos escritos en la salida compartida de un límite; elimina el bloque boundary o renderiza la Recipe mediante un proveedor cuyo contrato lo declare)
El encabezado lleva el código corto de esta condición, E0351.
Cómo corregirlo: elimina el bloque boundary: o renderiza la Recipe mediante un proveedor que lo acepte. Un archivo que pertenece al componente y no al límite es, en cambio, una entrada de artifacts:.
At least one input kind must be present (Debe haber al menos un tipo de entrada)
Una Recipe no declara ningún tipo de entrada: ninguna source emparejada con valuesMapping, ningún workload:, ningún artifacts:. Una Recipe así no produce ninguna salida y no tiene superficie de renderizado. Esta regla se comprueba cuando se carga la Recipe.
Un archivo de Recipe con esa forma se encuentra primero con el esquema de la Recipe: el esquema exige, en cualquier proveedor, uno de source, valuesMapping, workload o artifacts, por lo que la comprobación de la envoltura del documento rechaza el archivo con E0215 antes de que se ejecute esta regla, con una rama por cada clave:
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 (falló la validación de la envoltura del documento (Recipe): spec: ninguna rama anyOf coincidió: rama[0]: validación: obligatorio: faltan propiedades: [“source”]; rama[1]: validación: obligatorio: faltan propiedades: [“valuesMapping”]; rama[2]: validación: obligatorio: faltan propiedades: [“workload”]; rama[3]: validación: obligatorio: faltan propiedades: [“artifacts”]. corrige el documento para que coincida con el esquema de su tipo)
Mensaje emitido:
Recipe: at least one input kind required (Recipe <name>:<version>, rule input-kinds, at <path>). declare one of: source (with valuesMapping), workload, artifacts (Recipe: se requiere al menos un tipo de entrada (Recipe, regla input-kinds). declara uno de: source (con valuesMapping), workload, artifacts)
Cómo corregirlo: añade el tipo de entrada que corresponda a la intención con la que se escribió la Recipe. Una Recipe para un servicio que la compilación no aprovisiona — una base de datos o una API que ya se ejecuta en otro lugar — declara un workload: de form: reference con su endpoint (y opcionalmente port), y publica sus valores de conexión bajo provides: como cualquier Recipe: helm la renderiza como un ExternalName Service, compose no renderiza nada para ella, y con ambos sus consumidores leen los valores publicados.
artifacts: entry keys must be unique (Las claves de las entradas de artefactos deben ser únicas)
Una Recipe declara dos o más entradas bajo artifacts: con la misma clave. La clave dicta el nombre del archivo emitido (tanto si el cuerpo de la entrada se escribe en línea como si se carga mediante un $import: por entrada); las claves duplicadas emitirían un archivo con el mismo nombre en el mismo directorio del límite.
La compilación rechaza la Recipe mientras decodifica el documento a su forma tipada, nombrando la clave repetida y la línea en la que se repite. Ese paso se ejecuta después de la comprobación del esquema de la envoltura y antes de las reglas de forma, por lo que una Recipe con una clave artifacts: duplicada informa de un esquema válido y luego de esta detención, y las demás reglas de forma no informan sobre ella.
Cómo corregirlo: cambia el nombre de una de las claves de entrada en conflicto para que cada entrada de artifacts: tenga un nombre de archivo único.
Emission-time filename collision across input kinds (Colisión de nombres de archivo en tiempo de emisión entre tipos de entrada)
Una Recipe y una FeatureRecipe declaran cada una tipos de entrada que producen archivos: una source: que el proveedor renderiza, un workload: que el proveedor sintetiza, entradas de artifacts: y un pipeline: cuyos pasos pueden emitir. Cada uno elige sus nombres de salida con independencia de los demás, y nada declara que esos nombres sean distintos — así que dos de ellos pueden producir un archivo con un mismo nombre, y solo uno de los dos sobreviviría. La compilación se detiene y nombra el nombre de salida junto con cada bloque que lo produjo.
La comprobación se ejecuta una vez por cada documento emisor, en cuanto se completa la emisión propia de ese documento y antes de que su salida se una a cualquier ensamblaje. Emiten tres documentos, y cada uno se comprueba por separado: la Recipe propia de un componente, la FeatureRecipe que una vinculación enlaza en un componente y la FeatureRecipe que enlaza una vinculación con ámbito de límite. Mantenerlos separados es lo que hace que el diagnóstico nombre el documento correcto — los archivos de una vinculación se renderizan bajo la identidad de su componente anfitrión, así que una colisión en la FeatureRecipe de la vinculación se notifica contra esa FeatureRecipe y no contra el anfitrión.
Cada nombre en colisión se notifica por separado, de modo que un documento cuyos bloques coincidieron en dos nombres notifica ambos. Un hallazgo se posiciona en el documento que editas para corregirlo: la instancia del componente para una Recipe, y la propia FeatureRecipe para una vinculación, cuyo hallazgo nombra también la vinculación — un componente o un límite pueden enlazar varias.
Un bloque que emite varios archivos con un mismo nombre no es esta detención. Se trata de un único contribuyente y no de dos bloques que coinciden, y las claves artifacts: duplicadas dentro de un bloque se rechazan mientras se decodifica el documento.
Mensaje emitido:
filename collision across input kinds: two input-kind blocks produced a file under one output name (output name <filename>, produced by <origin1>, <origin2>) (colisión de nombres de archivo entre tipos de entrada: dos bloques de tipo de entrada produjeron un archivo con un mismo nombre de salida)
Una colisión en una FeatureRecipe incluye también la vinculación:
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>) (colisión de nombres de archivo entre tipos de entrada: dos bloques de tipo de entrada produjeron un archivo con un mismo nombre de salida)
Cómo corregirlo: cambia el nombre del archivo en colisión en el tipo de entrada que controles. Si la colisión implica un nombre de archivo traducido por el Workload y una entrada de artifacts:, los nombres traducidos por el Workload siguen las convenciones de traducción del proveedor (p. ej., <release-name>-deployment.yaml para helm, donde el nombre de la release es {{ .context.rendered_name }}) — ajusta el nombre de archivo de artifacts: a uno que el proveedor no sintetice.
An output-label key uses a reserved namespace (Una clave de etiqueta de salida usa un espacio de nombres reservado)
Una Recipe nombra una clave de etiqueta bajo aggrega.ai/ o app.kubernetes.io/ — en outputLabels:, el bloque que estampa etiquetas literales en la salida renderizada, o en outputComponentLabels:, el bloque que nombra las claves de etiqueta del componente cuyos valores se promueven a ella. Ambos prefijos pertenecen al propio espacio de claves de procedencia de la plataforma: son las claves que la compilación estampa por sí misma, así que una Recipe que estampara una escribiría en el espacio que dice de dónde procede un recurso. Reservarlos es también lo que mantiene el conjunto de etiquetas de una Recipe disjunto del conjunto de procedencia, de modo que nunca haya que conciliar ambos cuando se fusionan. Esta regla se comprueba cuando se carga la Recipe.
La reserva se aplica solo a la raíz desnuda. Una clave que simplemente lleva una raíz reservada más adentro, dentro de un espacio de nombres propio — component.aggrega.ai/hosting, por ejemplo — es un espacio de claves distinto que no pertenece a la plataforma, y sigue pudiendo usarse.
Mensaje emitido. Una sola condición cubre ambos bloques, así que su frase no puede decir cuál de los dos se escribió; el consejo que la sigue nombra el bloque citando la clave que escribiste y el bloque en el que la escribiste:
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) (restricción output-labels de la receta: la clave usa un espacio de nombres reservado (Recipe, regla output-labels). la clave en outputLabels usa un espacio de nombres reservado (los dos prefijos están reservados para la procedencia de la plataforma))
Una clave escrita en el bloque promovido se notifica con el nombre de regla de ese bloque, que el consejo nombra:
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) (restricción output-labels de la receta: la clave usa un espacio de nombres reservado (Recipe, regla output-component-labels). la clave en outputComponentLabels usa un espacio de nombres reservado (los dos prefijos están reservados para la procedencia de la plataforma))
Las claves del bloque literal se comprueban ordenadas y las del bloque promovido en el orden en que las escribiste, así que una Recipe que incumple la regla en varios puntos siempre notifica primero la misma clave.
Cómo corregirlo: mueve la clave a un espacio de nombres que te pertenezca — tu propio dominio, o uno con subprefijo como component.aggrega.ai/… — o elimínala si el valor que querías es uno que la compilación ya estampa. Las claves de procedencia que lleva un recurso renderizado se enumeran en ../providers/well-known-annotations.md; volver a leer una no requiere ninguna declaración en la Recipe.
A promoted component label is also declared literally (Una etiqueta de componente promovida también se declara literalmente)
Una Recipe nombra una misma clave tanto en outputComponentLabels: como en outputLabels:. Los dos bloques estampan sobre la misma superficie de etiquetas desde fuentes distintas — el primero promueve el valor que lleva el componente, el segundo escribe el valor que tecleó el autor de la Recipe —, así que una clave nombrada en ambos llegaría con dos valores candidatos y nada que diga cuál prevalece. Esta regla se comprueba cuando se carga la Recipe, después de la regla del espacio de nombres reservado anterior, así que una Recipe que incumple ambas notifica primero el espacio de nombres reservado: la corrección de ese fallo no depende de lo que contenga el otro bloque.
Mensaje emitido:
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 (restricción output-component-labels de la receta: la clave también se declara en outputLabels (Recipe, regla output-component-labels). la clave se promueve mediante outputComponentLabels y también se declara literalmente en outputLabels; conserva la fuente de la que debe proceder la etiqueta y elimina la otra)
Cómo corregirlo: decide de dónde procede el valor de la etiqueta y elimina la otra declaración. Conserva la entrada de outputComponentLabels: cuando el valor deba seguir lo que lleve el componente, de modo que dos componentes enlazados a una misma Recipe estampen sus propios valores; conserva la entrada de outputLabels: cuando el valor sea propio de la Recipe y sea el mismo dondequiera que se enlace la Recipe.
Reglas de forma de la FeatureRecipe
Una FeatureRecipe compone su salida a partir de los mismos tipos de entrada que una Recipe, y la regla de composición siguiente la restringe igual que restringe a una Recipe. Se comprueba cuando se carga la FeatureRecipe, y notifica con la forma que adopta una detención de forma de Recipe — la frase de la regla, luego el documento en falta, el nombre de la regla y el consejo para esa aparición — bajo una etiqueta CATALOG_ERROR.
Aquí deliberadamente no hay ninguna regla de al menos un tipo de entrada, y esa es la diferencia con una Recipe. Una FeatureRecipe que solo declara un proveedor y lo que implementa es una vinculación legítima de solo cableado: no renderiza nada, y su efecto es la conexión que lleva la Feature que implementa. Una FeatureRecipe que solo declara injectMapping: es legítima del mismo modo.
A FeatureRecipe’s valuesMapping requires source (El mapeo de valores de una FeatureRecipe requiere una fuente)
Una FeatureRecipe declara valuesMapping pero no source. Un mapeo de valores es una superposición, así que sin un chart, un módulo o un archivo sobre el que superponerse, los valores mapeados no tienen nada a lo que llegar.
Mensaje emitido:
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 requiere source (FeatureRecipe, regla values-mapping). declara un puntero source: junto a valuesMapping (o elimina el valuesMapping si no se pretende ninguna superposición))
Cómo corregirlo: añade el puntero source: para el que se escribió la superposición, o elimina el valuesMapping y deja que la vinculación haga su trabajo de otra manera — artifacts: para emitir archivos propios, injectMapping: para remodelar lo que entrega, o ninguno de los dos, para una vinculación de solo cableado.
A pipeline declares one step id twice (Un pipeline declara dos veces un mismo id de paso)
Una Recipe o una FeatureRecipe declara el mismo id en dos pasos de su spec.pipeline. Un paso publica las salidas que devuelve bajo su id, y un paso posterior del mismo pipeline las lee como .steps.<id>.outputs, así que dos pasos que compartieran un id harían que ese paso posterior leyera las salidas del que de los dos publicó en último lugar en vez de las del que querías.
La regla abarca el pipeline propio de un documento. La Recipe de un componente y las FeatureRecipes vinculadas a él ejecutan cada una su pipeline por separado, y cada pipeline empieza sin salidas de pasos, así que un paso de una Recipe y un paso de una FeatureRecipe vinculada pueden llevar el mismo id.
Ningún esquema puede expresar esta regla — JSON Schema no tiene ninguna palabra clave para una lista cuyas entradas sean únicas según uno de sus campos —, así que un editor que conoce el esquema acepta un documento así, y la comprobación se ejecuta mientras se lee el documento, justo después de la comprobación del esquema. Toda superficie que lee una Recipe o una FeatureRecipe lo notifica: aggrega validate sobre el archivo o sobre todo el catálogo, una compilación que carga el catálogo, un pull que admite una entidad descargada, los diagnósticos del editor y una edición de documento, que se rechaza en lugar de escribirse. Un documento que además no supera su esquema notifica primero los hallazgos del esquema, y este rechazo una vez corregidos.
Cada repetición es un hallazgo propio, situado en el id repetido y nombrando el paso que declaró primero el id, con su línea y su columna. Cuando un id aparece tres veces, los dos pasos posteriores nombran el primero.
Mensaje emitido, para una FeatureRecipe cuyo segundo paso repite el id del primero. La categoría y el código corto de esta condición, E0370, te llegan en el encabezado entre corchetes:
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 declara dos veces un mismo id de paso (FeatureRecipe); spec.pipeline[1].id: el id de paso ya está declarado en spec.pipeline[0].id. da a cada paso del pipeline su propio id, y haz que cada referencia que hace un paso posterior apunte al paso al que se refiere)
Cómo corregirlo: cambia el nombre de uno de los dos pasos, de modo que cada id se declare una sola vez. Después revisa las plantillas with: y when: de cada paso posterior en busca de referencias .steps.<id> al id que conservaste, y haz que cada una apunte al paso cuyas salidas quiere decir — es el cambio de nombre lo que hace que las salidas de los dos pasos sean accesibles por separado.
A document declares an API version this compiler no longer reads (Un documento declara una versión de API que este compilador ya no lee)
La línea apiVersion de un documento declara aggrega.ai/v1alpha1. Todo tipo de documento que lleva una línea apiVersion declara aggrega.ai/v1beta1, la única versión que lee este compilador, y no se realiza ninguna conversión desde la versión anterior: el documento se rechaza al leerse, antes de comprobar ninguna otra cosa, porque cualquier otro hallazgo se referiría a una versión del documento que el compilador no lee.
Toda superficie que lee un documento lo informa: aggrega validate, una compilación, un pull que admite una entidad obtenida, los diagnósticos del editor y una edición del documento. Un documento que declara una versión que el compilador nunca ha leído lo rechaza en su lugar el esquema de su tipo, con E0215.
Mensaje emitido, para un Component. La categoría y el código corto de esta condición, E0373, te llegan en el encabezado entre corchetes:
a document declares an API version this compiler no longer reads (Component, at <path>); 1:1: apiVersion: the document declares aggrega.ai/v1alpha1, and this compiler reads aggrega.ai/v1beta1. change the apiVersion line to apiVersion: aggrega.ai/v1beta1 (un documento declara una versión de API que este compilador ya no lee (Component); 1:1: apiVersion: el documento declara aggrega.ai/v1alpha1, y este compilador lee aggrega.ai/v1beta1. cambia la línea apiVersion a aggrega.ai/v1beta1)
Cómo corregirlo: cambia la línea apiVersion del documento a apiVersion: aggrega.ai/v1beta1. Los campos de cada tipo no cambian entre las dos versiones, así que esa línea es todo el cambio.
A plugin declares a plugin ABI version this compiler no longer speaks (Un plugin declara una versión de la ABI de plugins que este compilador ya no admite)
Un plugin declara la ABI de plugins v1alpha1. Este compilador admite la ABI de plugins v1beta1 y ninguna otra, así que un plugin compilado con la anterior se rechaza en lugar de ejecutarse. Un plugin indica su ABI en dos lugares, y cada uno se rechaza con esta misma condición: el informe describe() que devuelve su módulo invitado al cargarse, y el campo spec.abiVersion de su entidad Plugin, que se rechaza al leerse la entidad, antes de comprobar ninguna otra cosa. También se rechaza un plugin que declara una versión de ABI que este compilador nunca ha admitido, mediante la comprobación del descriptor (E0085) o mediante el esquema Plugin (E0215).
Mensaje emitido, para un módulo invitado al cargarse. La categoría y el código corto de esta condición, E0374, te llegan en el encabezado entre corchetes:
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 (el plugin declara abi_version “v1alpha1”, y este compilador admite “v1beta1”; recompila el plugin con el kit de plugins actual y vuelve a publicarlo: un plugin declara una versión de la ABI de plugins que este compilador ya no admite)
Mensaje emitido, para una entidad 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 declara una versión de la ABI de plugins que este compilador ya no admite (Plugin); spec.abiVersion: el Plugin declara abiVersion v1alpha1, y este compilador admite v1beta1. recompila el plugin con el kit de plugins actual y vuelve a publicarlo; su entidad Plugin declara entonces abiVersion v1beta1)
Cómo corregirlo: recompila el plugin con la versión actual de su kit de plugins, que estampa v1beta1 en el informe describe() del módulo invitado, y vuelve a publicarlo, de modo que la entidad generada junto a él también declare abiVersion: v1beta1. Editar solo la línea de la entidad no basta: el propio módulo invitado sigue informando la ABI anterior y se rechaza al cargarse.
An artifact carries a media type this compiler no longer reads (Un artefacto lleva un tipo de medio que este compilador ya no lee)
Un artefacto obtenido de un registro lleva un tipo de medio con el que publicaba una versión anterior — application/vnd.aggrega.<kind>.v1alpha1 con su sufijo, en el tipo de artefacto del manifiesto, en su configuración o en una de sus capas. Este compilador publica y lee los tipos de medio v1beta1, así que el artefacto se rechaza por su nombre al leerse su manifiesto, antes de tomar nada de su contenido: ya sea una entidad del catálogo, un plugin y su ejecutable o un paquete de documentación. Una indexación de un registro omite un artefacto así, indicando el motivo. Un tipo de medio fuera del espacio de nombres application/vnd.aggrega. propio de Aggrega nunca corresponde a esta condición.
Mensaje emitido, para un Component publicado por una versión anterior. La categoría y el código corto de esta condición, E0375, te llegan en el encabezado entre corchetes:
"<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 (lleva el tipo de medio “application/vnd.aggrega.component.v1alpha1+yaml”, y este compilador lee “application/vnd.aggrega.component.v1beta1+yaml”; vuelve a publicar el artefacto con la versión actual: oci: el artefacto lleva un tipo de medio que este compilador ya no lee)
Cómo corregirlo: vuelve a publicar el artefacto con la versión actual de aggrega, que escribe los tipos de medio v1beta1. Un artefacto que publica otra persona le corresponde a ella volver a publicarlo; hasta que lo haga, no se puede leer.
A file cannot be read, or its bytes do not parse (No se puede leer un archivo, o sus bytes no se pueden analizar)
Un archivo que una compilación tenía que leer, o un documento de Aggrega que una comprobación de todo el catálogo leyó bajo los directorios del catálogo, no produjo nada que la superficie que lo nombró o lo leyó pudiera usar. O no se pudo leer del disco, o sus bytes se analizaron y el análisis no terminó limpiamente. Nada posterior se ejecuta sobre él, porque no hay contenido que comprobar con un esquema, ni componentes que colocar, ni plantilla que renderizar.
La condición no nombra ningún formato, y eso es deliberado. La mayoría de los archivos que abarca se leen como YAML; los cuerpos workload, values-mapping y artifact de una Recipe se leen como código fuente de plantillas Go y nunca se analizan. Una frase que prometiera YAML encabezaría un diagnóstico sobre un archivo de plantilla con una afirmación sobre el formato de ese archivo. Cuál de los dos fallos ocurrió, y para qué tipo de archivo, es lo que dice la cláusula que sigue a la frase.
Los documentos de los que parte una compilación — el Aggregate, la Release y el Manifest — son los sujetos más comunes, y la detención se produce en cada punto en que se lee uno de los tres. El diagnóstico nombra qué documento se estaba leyendo y la ruta desde la que se leyó. La ruta es lo que distingue un archivo ausente de uno mal formado: un fallo de lectura cita el motivo propio del sistema operativo, y un fallo de análisis cita el del analizador YAML, que incluye la línea en la que el analizador se rindió.
Mensaje emitido, cuando no se pudo leer el archivo:
file load failed: the file could not be read, or its bytes did not parse (Aggregate, at <path>, failed to read file: <underlying reason>) (falló la carga del archivo: no se pudo leer el archivo, o sus bytes no se pudieron analizar (Aggregate, falló la lectura del archivo))
y cuando su texto no se pudo analizar:
file load failed: the file could not be read, or its bytes did not parse (Aggregate, at <path>, failed to unmarshal YAML: <underlying reason>) (falló la carga del archivo: no se pudo leer el archivo, o sus bytes no se pudieron analizar (Aggregate, falló la deserialización del YAML))
Release y Manifest aparecen en lugar de Aggregate cuando uno de ellos es el documento que se lee. La misma condición abarca también el contrato de parámetros leído del bloque parameters: declarado de un Aggregate, que se lee del propio texto del Aggregate antes de que se interpole nada en él.
Un parameters: { $import: … } de una Release que nombra un archivo que la compilación no puede obtener también se notifica aquí, y en ambos casos: la ruta no nombra ningún archivo que la compilación pueda leer, o el archivo se lee y sus bytes no se pueden analizar. El sujeto es la Release, y la cláusula nombra la clave que apuntaba al archivo:
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>) (falló la carga del archivo: no se pudo leer el archivo, o sus bytes no se pudieron analizar (Release, falló la lectura del archivo)) 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>) (falló la carga del archivo: no se pudo leer el archivo, o sus bytes no se pudieron analizar (Release, falló la deserialización del YAML))
Una ruta relativa se resuelve desde el directorio que contiene la Release que la escribe — la Release que nombra un comando, o un eslabón de su cadena extends: —, desde dondequiera que se ejecute el comando, de modo que la línea de comandos y el editor leen el mismo archivo; una ruta absoluta nombra su propio lugar. Confirma que el checkout sobre el que se ejecuta la compilación contiene el archivo en ese lugar: un archivo de parámetros presente en tu máquina y excluido del control de versiones está ausente durante una ejecución de integración continua, que es la forma habitual de encontrarse con este error. Una ruta que sale del espacio de trabajo — o, para una Release nombrada fuera del espacio de trabajo, del directorio propio de esa Release — no se lee en absoluto, y se notifica en «A reference to another file leads out of the directory it must stay inside» (Una referencia a otro archivo sale del directorio en el que debe permanecer) más abajo.
Un $import: de esquema que nombra un archivo que la compilación no puede obtener también se notifica aquí, porque el fallo es el mismo: la directiva está bien formada y el archivo que nombra no produjo un documento. El sujeto es entonces una entidad de catálogo en lugar de uno de los tres, así que la cláusula nombra la superficie de esquema para la que se estaba resolviendo — spec.schema, uno de sus pilares como spec.schema.values, o el valueSchema de un socket usesSchema — y el puntero de origen es la línea en la que se escribió la directiva:
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> (falló la carga del archivo: no se pudo leer el archivo, o sus bytes no se pudieron analizar. lectura del esquema importado)
con resolve imported schema path en lugar de read para el fallo más raro en que no se pudo establecer en absoluto el directorio propio de la entidad, y parse imported schema cuando el archivo se leyó y su texto no es YAML bien formado. Un fallo en la directiva que escribiste — una clave hermana junto a ella, un valor que no es una ruta, o un contenido importado que se analizó y no es un mapa — es una condición distinta y se notifica en «A schema $import: cannot be applied» (No se puede aplicar una importación de esquema) más abajo.
Una importación valuesMapping:, workload: o artifacts.<name>: de una Recipe o de una FeatureRecipe también se notifica aquí, por la misma razón y con el mismo remedio: la directiva está bien formada y el archivo que nombra no produjo contenido. Esos tres cuerpos son código fuente de plantillas Go en lugar de documentos, así que solo puede fallar la lectura — nada los analiza en este punto. La entidad y la clave que nombró la ruta viajan en la cláusula, y el puntero de origen es la ruta propia del archivo importado:
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 (falló la carga del archivo: no se pudo leer el archivo, o sus bytes no se pudieron analizar (Recipe, importación de archivo valuesMapping). si te referías a una entrada de biblioteca en lugar de un archivo, la referencia necesita su fragmento — un $import: que no lleva ninguno se lee como una ruta de archivo, y un valor sin comillas termina donde un espacio antes de # inicia un comentario, así que pon entre comillas toda la referencia) 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 (falló la carga del archivo: no se pudo leer el archivo, o sus bytes no se pudieron analizar (Recipe, importación de archivo workload). si te referías a una entrada de biblioteca en lugar de un archivo, la referencia necesita su fragmento — un $import: que no lleva ninguno se lee como una ruta de archivo, y un valor sin comillas termina donde un espacio antes de # inicia un comentario, así que pon entre comillas toda la referencia) 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 (falló la carga del archivo: no se pudo leer el archivo, o sus bytes no se pudieron analizar (Recipe, importación de archivo de un artifact). si te referías a una entrada de biblioteca en lugar de un archivo, la referencia necesita su fragmento — un $import: que no lleva ninguno se lee como una ruta de archivo, y un valor sin comillas termina donde un espacio antes de # inicia un comentario, así que pon entre comillas toda la referencia)
El fragmento es lo que distingue una referencia de biblioteca de una ruta: <Library>#/mappings/<entry> se resuelve contra las bibliotecas, y el mismo texto sin el fragmento es una ruta relativa normal. Es fácil perderlo sin darse cuenta, porque un valor YAML simple termina donde un espacio antes de # abre un comentario — así, $import: LibBeta:1.0.0 #/workloads/Web llega a la compilación como LibBeta:1.0.0, y la compilación busca entonces un archivo con ese nombre junto a la Recipe. Pon entre comillas toda la referencia para conservar el fragmento.
Las mismas tres claves en una FeatureRecipe notifican la misma condición y se leen de la misma manera. Una importación de artifacts se lee dos veces a lo largo de la vida de una Release — una vez cuando aggrega pull congela el pin de su contenido, y otra cuando se renderiza la entrada —, así que el mismo archivo ausente notifica esta condición en el primero de los dos momentos al que llegues. Un fallo de forma en la propia directiva, como una clave hermana junto a $import: o una referencia oci:// que incluye un host, es una condición distinta y se notifica en su propia entrada.
aggrega lint y aggrega validate sobre todo el catálogo también lo notifican aquí, para un documento bajo los directorios del catálogo que declara una apiVersion de Aggrega — una línea que empieza, sin sangría, por apiVersion: y un valor que comienza por aggrega.ai/ — y que no se puede leer, no se puede analizar o no se decodifica en el sobre que lee la comprobación, como un metadata escrito como lista. Ningún autor escribió una ruta hacia él: la comprobación lo leyó porque está en un directorio de catálogo. Cada comprobación lee todos los archivos antes de detenerse, así que una sola ejecución nombra cada uno de esos documentos; no comprueba nada más ni imprime ningún resumen. El YAML que no declara ninguna apiVersion de Aggrega — entre él, las plantillas de un chart de Helm — se omite. El encabezado cuenta los documentos y nombra sus archivos, y cada uno aparece debajo con el motivo que dio la lectura o el analizador:
<n> documents under the catalog directories declare an Aggrega apiVersion and could not be loaded, so nothing was checked: <path>, <path> (documentos bajo los directorios del catálogo declaran una apiVersion de Aggrega y no se pudieron cargar, así que no se comprobó nada) 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>) (falló la carga del archivo: no se pudo leer el archivo, o sus bytes no se pudieron analizar (documento de catálogo, falló la deserialización del YAML))
con failed to decode the envelope: y la línea y lo que el decodificador encontró allí — line 4 (metadata): a list is written where a map is expected para un metadata escrito como lista — para un documento que se analiza y no se decodifica, y failed to read file: y el motivo del sistema operativo para un archivo que no se pudo leer. Un documento que se carga y declara un tipo que ningún catálogo contiene lo nombra la misma detención, se cuenta en el mismo encabezado y aparece bajo su propia condición — consulta «A catalog document declares a kind a catalog does not hold» (Un documento de catálogo declara un tipo que un catálogo no contiene) más abajo.
Cómo corregirlo: lee la ruta del mensaje en lugar del nombre del documento — ambos difieren siempre que una referencia se resolvió en un lugar inesperado. Para un fallo de lectura, confirma que el archivo existe en esa ruta, que la ruta está escrita como la escribe el documento que hace referencia a ella y que la compilación tiene permiso para leerlo; un archivo presente en local y ausente del checkout de un agente de compilación es el caso habitual. Para un fallo de análisis, abre el archivo en la línea que nombró el analizador — un valor sin comillas que contiene dos puntos, un tabulador usado para la sangría y un elemento de lista sangrado bajo la clave equivocada son los tres que explican la mayoría.
A catalog document declares a kind a catalog does not hold (Un documento de catálogo declara un tipo que un catálogo no contiene)
Un documento bajo los directorios del catálogo declara una apiVersion de Aggrega — una línea que empieza, sin sangría, por apiVersion: y un valor que comienza por aggrega.ai/ — y un kind que ningún catálogo contiene: una errata como Componnent, un tipo con las mayúsculas equivocadas como component, o ningún kind en absoluto. Un catálogo archiva cada documento bajo el tipo que declara, así que un documento así no entra en ningún catálogo: una compilación, inspect y cualquier otro comando que carga el catálogo lo omiten, y una referencia a la entidad que debía declarar no se resuelve en nada.
Un catálogo contiene documentos Component, Feature, Recipe, FeatureRecipe, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary, Aggregate y Plugin. Otros tres tipos se encuentran legítimamente en sus directorios y nunca se notifican aquí: un Manifest y una Release guardados junto a las entidades, y un Workload en el directorio de la Recipe o FeatureRecipe que lo importa.
Lo notifican aggrega validate y aggrega lint sobre todo el catálogo, y el lint acotado a una release, que recorre los mismos directorios. Cada uno lee todos los archivos antes de detenerse, así que una sola ejecución nombra cada uno de esos documentos junto con cualquier documento que no se pueda cargar en absoluto, bajo un único encabezado que los cuenta y nombra sus archivos; no se comprueba nada y no se imprime ningún resumen. Cada documento aparece con el tipo que declara, y la línea se cierra con los tipos que contiene un catálogo:
<n> documents under the catalog directories declare an Aggrega apiVersion and could not be loaded, so nothing was checked: <path>, <path> (documentos bajo los directorios del catálogo declaran una apiVersion de Aggrega y no se pudieron cargar, así que no se comprobó nada) catalog document declares a kind a catalog does not hold (kind “Componnent”). a catalog holds Component, Feature, Recipe, FeatureRecipe, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary, Aggregate and Plugin documents, and passes over a Workload, a Manifest or a Release; correct the kind, or move the file out of the catalog directories (un documento de catálogo declara un tipo que un catálogo no contiene (kind “Componnent”). un catálogo contiene documentos Component, Feature, Recipe, FeatureRecipe, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary, Aggregate y Plugin, y omite un Workload, un Manifest o una Release; corrige el kind, o mueve el archivo fuera de los directorios del catálogo)
con no kind en lugar de kind "<kind>" para un documento que no declara ninguno.
Una compilación no se detiene ante un documento así: lo omite como hace toda carga, y un documento al que no llega ninguna Release nunca hace fallar una compilación. Cuando una Release llega a la entidad, la compilación se detiene en la referencia, en «A reference names no entity the catalog holds» (Una referencia no nombra ninguna entidad que contenga el catálogo) más abajo, y la nota bajo ese fallo nombra el archivo cuando declara el nombre que pide la referencia — consulta esa entrada.
Cómo corregirlo: abre el archivo que nombra el mensaje y corrige su kind al tipo que es el documento — tanto la ortografía como las mayúsculas importan. Un archivo que no es en absoluto una entidad de catálogo no debe estar bajo los directorios del catálogo; muévelo fuera, o dale una apiVersion que no sea la de Aggrega si es el documento de otra herramienta.
A path names content outside the entity’s own directory (Una ruta nombra contenido fuera del directorio propio de la entidad)
El contenido de una entidad reside en el directorio propio de la entidad, porque cada archivo que lleva una publicación de la entidad se toma de ahí. Una ruta que sale de él apunta a un archivo que no viajaría con la entidad, así que el archivo no está ahí para nadie que reciba la entidad, y un pin registrado sobre él avala bytes que esos destinatarios no pueden obtener.
Por eso, cada ruta que una entidad escribe para el contenido que lleva se lee respecto al directorio que contiene el archivo de la entidad y debe permanecer dentro de él. Esto abarca la source: de una Recipe y de una FeatureRecipe — una ruta simple, o la url: de la forma estructurada —, el archivo que cada entrada de valuesMapping:, workload: y artifacts: importa con $import:, y cada esquema que un Component o una Feature importa, completo, por pilar o, para un socket usesSchema, su valueSchema y su infraSchema. Tres formas salen del directorio: una ruta que sube por encima de él, una ruta absoluta, que nombra un lugar en la máquina en la que se escribió, y una ruta escrita dentro del directorio que un enlace simbólico en el camino saca de él — un directorio a lo largo de la ruta, así como el archivo al final de ella, que sea un enlace que lleva fuera del directorio de la entidad. Una ruta que sube y vuelve a entrar — ./charts/../values.tmpl — es una ruta normal dentro del directorio, y también lo es una que pasa por un enlace que lleva a otro lugar dentro de él. Una subida que vuelve a entrar en el directorio por su propio nombre — ../1.0.0/values.tmpl escrita en un directorio llamado 1.0.0 — se rechaza, porque el nombre del directorio no forma parte de lo que viaja: una entidad publicada se lee desde un directorio que nombra la caché del destinatario, donde ese nombre no encuentra nada. Una ruta que pasa por un enlace que lleva al exterior se rechaza porque, de lo contrario, una publicación llevaría los bytes a los que apunta el enlace, desde dondequiera que apunte, bajo un nombre dentro de la entidad.
Se rechaza dondequiera que se lea la entidad. Un aggrega validate de todo el catálogo, aggrega validate sobre el propio archivo de la entidad, aggrega pull y aggrega build la rechazan mientras se lee el archivo de la entidad, y también lo hacen aggrega pin de una Recipe o de una FeatureRecipe y aggrega push de cualquiera de los cuatro tipos, antes de que se descargue, escriba o publique nada. Una source: escrita como plantilla no nombra nada hasta que la compilación la evalúa, así que una plantilla que produce una ruta fuera del directorio la rechaza la compilación, en el momento en que el valor existe.
Una Release es distinta, y también lo es una referencia a una entidad. Una Release apunta a otras entidades — su Aggregate, su Manifest, la Release que extiende — y nunca se publica, así que nada de lo que lee viaja a ninguna parte: esas rutas, y el archivo que importan los parameters: de una Release, se leen tal como están escritos. El type de un Aggregate nombra otra entidad por su identidad, no por contenido que el Aggregate lleve, y también se resuelve en sus propios términos: a través de los directorios del catálogo, la caché y el registro, nunca como ruta de archivo.
Mensaje emitido, que nombra la ruta tal como está escrita:
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 (una ruta nombra contenido fuera del directorio propio de la entidad. solución: mueve el archivo al directorio que contiene la entidad, o a un directorio por debajo de él, y nómbralo con una ruta relativa a ese directorio. El contenido de una entidad reside en el directorio propio de la entidad porque cada archivo que lleva una publicación de ella se toma de ahí; una ruta que sale de él apunta a un archivo que no viajaría con la entidad)
y, para una ruta que un enlace saca del directorio, que nombra el enlace y adónde lleva:
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 (una ruta nombra contenido fuera del directorio propio de la entidad. solución: sustituye el enlace por una copia de aquello a lo que lleva, colocada dentro del directorio que contiene la entidad. El contenido de una entidad reside en el directorio propio de la entidad porque cada archivo que lleva una publicación de ella se toma de ahí; un enlace que sale de él llevaría los bytes a los que apunta bajo un nombre dentro de la entidad)
El campo del que se leyó se nombra en la línea situada encima del mensaje: resolve Recipe source …, resolve Recipe artifact "<key>" $import target …, spec.schema.values: imported schema … o, para una fuente generada con plantilla, node "<name>" source.
Cómo corregirlo: mueve el archivo al directorio de la entidad, o a un directorio por debajo de él, y escribe su ruta relativa a ese directorio. Donde un enlace saque la ruta al exterior, sustituye el enlace por una copia de aquello a lo que lleva, dentro del directorio de la entidad. Un chart que comparten varias Recipes se copia en el directorio de cada Recipe, ya que cada una se publica por separado; un esquema que comparten varios Components pertenece a una SchemaLibrary, a la que cada Component hace referencia después por su identidad, y un cuerpo de mapping, de carga de trabajo o de artefacto que comparten varias Recipes pertenece al tipo de biblioteca correspondiente.
A Recipe’s source: names a kind nothing knows how to acquire (La fuente de una Recipe nombra un tipo que nada sabe cómo adquirir)
La source: de una Recipe indica a qué tipo de cosa apunta — un chart, un módulo, un proyecto compose — y cada tipo lo adquiere el adaptador de fuentes que sirve ese tipo. Esta condición informa de un tipo que ningún adaptador de fuentes sirve, así que nada de lo que incluye este programa puede descargar la fuente. La source: de una FeatureRecipe está sujeta a la misma regla.
Se rechaza al leer el documento, antes de descargar nada: comprobar la Recipe por sí sola lo rechaza, y también lo hace cada Release que llega a ella. No se intentó nada, porque nada podía intentarlo — y eso es lo que lo distingue de una adquisición que se ejecutó y falló.
Mensaje emitido, que nombra el documento, el tipo tal como está escrito y los tipos que se sirven:
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 (ningún adaptador de fuentes sirve el tipo de fuente (Recipe, regla source-kind). la fuente nombra un tipo; nombra un tipo que sirva un adaptador de fuentes, o escribe la fuente como un único URI cuya forma nombre su tipo)
Cómo corregirlo: corrige el tipo en la source: por uno que la cadena de herramientas sirva — una errata y un tipo que realmente no tiene adaptador producen el mismo mensaje, y el mensaje cita el tipo tal como lo escribiste junto a los tipos que se sirven, así que lo primero que hay que comprobar es la ortografía frente a esa lista, que también describe la página de la Recipe. Si el tipo está escrito como pretendías, ese tipo no es uno que esta compilación pueda adquirir, y ningún cambio en la Recipe lo hará posible; haz que la source: apunte en su lugar a una forma que se sirva, o escríbela como un único URI cuya forma nombre su tipo.
No source adapter is registered in this program for a source kind (No hay ningún adaptador de fuentes registrado en este programa para un tipo de fuente)
Una fuente la descarga el adaptador registrado para su tipo. Esta condición informa de una descarga despachada para un tipo para el que no hay ningún adaptador registrado. Un tipo escrito por el autor que ningún adaptador sirve se rechaza al leer su Recipe (en «A Recipe’s source: names a kind nothing knows how to acquire (La fuente de una Recipe nombra un tipo que nada sabe cómo adquirir)» más arriba), así que nada de lo que escribe un autor llega hasta aquí: informa de un programa ensamblado sin el adaptador para un tipo que sirve, o de un programa construido sobre los paquetes Go de Aggrega que despacha una descarga para un tipo que ensambló él mismo.
Mensaje emitido, que nombra el tipo:
kind "<kind>": no source adapter is registered in this program for the source kind (tipo: no hay ningún adaptador de fuentes registrado en este programa para el tipo de fuente)
Cómo corregirlo: nada en tus archivos de entidades lo causa. Infórmalo a quien haya compilado el binario que estás ejecutando.
A source URL carries a credential (Una URL de fuente contiene una credencial)
La url de una fuente se registra tal como la escribiste — en el archivo de bloqueo de la Release, en el entity.lock junto a la Recipe y en la caché de fuentes — y la propia Recipe es un archivo que confirmas con commit y que puedes publicar. Así que una credencial escrita en la URL viajaría a todas partes adonde viaje la URL. Esta condición informa de una source: de una Recipe cuya url escribe un usuario antes de su host: https://user:token@host/…, o un token escrito solo como https://token@host/…, ya que un servicio al que se accede por HTTP suele aceptar un token en el lugar del usuario. Por http y https cuenta cualquier usuario escrito ahí; por otro esquema solo cuenta una contraseña, porque un usuario escrito solo ahí nombra una cuenta — ssh://git@github.com/… se acepta, y el agente SSH proporciona su clave. La source: de una FeatureRecipe está sujeta a la misma regla.
Se rechaza al leer el documento, antes de descargar nada: comprobar la Recipe por sí sola lo rechaza, y también lo hace cada Release que llega a ella, en una validación, un pull, un pin o una compilación. El mensaje nombra el host y nunca la credencial. La comprobación lee la parte de la URL escrita antes del host y nada más, así que un token incluido en una cadena de consulta o en una ruta no se detecta — y se registra tal como está escrito, como el resto de la URL.
Mensaje emitido por http o https, que nombra el documento, la clave y el host, y después dónde debe ir la credencial:
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) (la URL de la fuente contiene una credencial (Recipe, regla source-url). spec.source.url nombra un usuario o una contraseña para el host; quítalo de la URL y escribe en su lugar la credencial en el archivo netrc, como una entrada «machine … login … password …» (el archivo que nombra NETRC, si no .netrc en tu directorio personal, o _netrc en %USERPROFILE% en Windows))
y por otro esquema, donde la solución es quitar la contraseña:
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 (la URL de la fuente contiene una credencial (Recipe, regla source-url). spec.source.url nombra una contraseña para el host; quítala de la URL, que se escribe en el archivo de bloqueo y en la caché tal como se redactó)
Cómo corregirlo: quita el usuario y la contraseña de la url, dejando la URL que nombra el host. Para una fuente descargada por http o https, pon la credencial en una entrada machine para ese host en tu archivo netrc, que lee cada descarga de un repositorio clásico de charts de Helm, de un fragmento compose o de un repositorio Git por HTTP o HTTPS — Autenticación describe qué archivo y qué entrada. Para un repositorio Git por SSH, el agente SSH proporciona la clave, y el usuario puede quedarse. Si la Recipe ya se confirmó o se publicó con la credencial dentro, la credencial está en ese historial: cámbiala también en el servidor.
A {{ .parameters.* }} reference cannot be interpolated (No se puede interpolar una referencia a parámetros)
El texto del Aggregate se evalúa como una plantilla antes de leerse como un documento, de modo que una referencia {{ .parameters.<key> }} se sustituye por el valor que la Release proporcionó para ella. Esta detención se produce cuando esa evaluación no puede completarse: el texto no se analiza como plantilla, o se analiza y falla durante la ejecución.
La interpolación ocurre antes de que el Aggregate se analice como YAML, por lo que un fallo aquí se informa sobre el Aggregate en su conjunto y no en una clave dentro de él — en ese momento el documento aún no tiene claves. También por eso la referencia puede dejarse sin comillas: la sustitución ocurre en los bytes sin procesar, y la propia regla de comillas de YAML decide después el tipo del valor, así que una referencia sin comillas produce el tipo natural del valor y una entre comillas produce una cadena.
Una referencia que nombra una clave que la Release no proporcionó no es esta detención. Una clave ausente se resuelve aquí como un valor vacío y la detectan, con su tipo y su contrato, las comprobaciones de parámetros descritas en «Parameter type mismatch / contract violation (Tipo de parámetro no coincidente / infracción del contrato)» más arriba. Lo que informa esta detención es texto que el motor de plantillas no pudo procesar en absoluto — un {{ sin cerrar, un nombre de función mal escrito, un pipeline cuyas etapas no encajan entre sí. Leer un parámetro mediante index — {{ index .parameters "db_size" }} — cuando la Release no proporcionó ese parámetro es un fallo durante la ejecución, y esta detención lo transmite, nombrando la clave: index se detiene ante una clave de mapa que el mapa no contiene en todas las superficies de plantilla, como describe «A template indexes a map with a key the map does not hold (Una plantilla indexa un mapa con una clave que el mapa no contiene)» más abajo.
El texto que no se analiza en absoluto se rechaza nombrando la ruta del propio Aggregate, porque ese archivo está disponible antes de que nada lo lea. Un módulo que importa la composición se evalúa de la misma manera un nivel más adentro, donde su texto se lee del catálogo en lugar de entregarse a la compilación. La detención es esta misma condición y lleva este código en ambos casos; para un módulo nombra también el import que estaba siguiendo y el archivo del que se leyó el texto del módulo, y el mensaje que lleva nombra solo el tipo — así que la posición que da ese mensaje es una posición en el texto del propio módulo, no en el Aggregate del que partiste.
Mensajes emitidos, para una plantilla que no se analiza, para el mismo fallo en un módulo que importa la composición, y para una plantilla que falla durante la ejecución:
invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate <path>, “template parse error: <underlying reason>”) (referencia de parámetro no válida: comprueba que la expresión {{ .parameters.* }} nombre un parámetro declarado y se analice como plantilla Go (Aggregate, «error de análisis de la plantilla»)) invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate, template parse error: <underlying reason>) (referencia de parámetro no válida: comprueba que la expresión {{ .parameters.* }} nombre un parámetro declarado y se analice como plantilla Go (Aggregate, error de análisis de la plantilla)) invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate, template execution error: <underlying reason>) (referencia de parámetro no válida: comprueba que la expresión {{ .parameters.* }} nombre un parámetro declarado y se analice como plantilla Go (Aggregate, error de ejecución de la plantilla))
El texto de un Aggregate tiene una sola raíz, .parameters, así que una referencia a través de cualquier otra — {{ .values.app_token }} o {{ $.values.app_token }} — no lee nada y falla durante la ejecución. El motivo empieza entonces nombrando la referencia que leyó:
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>) (referencia de parámetro no válida: comprueba que la expresión {{ .parameters.* }} nombre un parámetro declarado y se analice como plantilla Go (Aggregate, la plantilla lee una referencia, y el texto de un Aggregate no define ninguna raíz salvo .parameters; error de ejecución de la plantilla))
Cómo corregirlo: abre el Aggregate y lee el motivo subyacente, que nombra la posición en el texto y la construcción que falló. Confirma que cada {{ tiene su }}, que una función que llamaste es una de las que ofrece la superficie — la interpolación de parámetros ofrece las funciones de Sprig y nada más, así que la función auxiliar optionalno está disponible aquí — y que las etapas de un pipeline aceptan lo que produce la etapa anterior. Si el motivo nombra una clave que index no encontró, lee un parámetro que puede no estar definido con un punto ({{ .parameters.db_size }}) o mediante get o hasKey de Sprig. Si nombra una referencia a través de otra raíz, declara el valor como parámetro del Aggregate y léelo como {{ .parameters.<key> }}. Si nombra algo que nunca pretendiste como plantilla — undefined variable "$json" procedente de una expresión de n8n, o una función con el nombre de un nodo de Flowise — el texto contiene llaves dobles propias, incluidas las de un comentario: escribe cada {{ que contenga como {{"{{"}}, como describe Texto que contiene sus propias llaves dobles.
The Release directory declares one Aggregate or Manifest twice (El directorio de la Release declara dos veces un Aggregate o un Manifest)
Una Release cuya referencia aggregate: o manifest: es una identidad simple se resuelve examinando primero el propio directorio de la Release, y ese examen encontró dos Aggregates — o dos Manifests — con el mismo metadata.name. Una referencia por identidad simple nombra una entidad por ese nombre, así que un nombre reclamado dos veces es uno por el que el directorio no puede responder.
El examen rechaza el directorio en su conjunto, no solo el nombre que pidió una referencia. Lee cada Aggregate y cada Manifest que hay junto a la Release, de modo que un par en colisión que ninguna de las dos referencias nombra también detiene la compilación: el directorio es ambiguo tanto si esta Release era la que iba a leer esa entidad como si no. Una referencia escrita como ruta (./aggregate.yaml, ../shared/manifest.yaml) apunta a un archivo en lugar de a una entidad y se resuelve sin el examen, así que una Release cuyos aggregate: y manifest: son ambos rutas nunca lo ejecuta.
Esta es la contrapartida, en el mismo directorio, del rechazo por identidad duplicada del catálogo, y ambos se notifican por separado para que el mensaje nombre el directorio en el que te encuentras en lugar de un nivel del catálogo en el que quizá no estabas pensando.
Mensaje emitido:
duplicate Aggregate/Manifest identity (metadata.name) in the Release directory: Aggregate "<name>" declared more than once in <release-directory> (identidad Aggregate/Manifest duplicada (metadata.name) en el directorio de la Release: Aggregate declarado más de una vez)
con Manifest en lugar de Aggregate cuando colisionan dos Manifests.
Cómo corregirlo: da a una de las dos entidades un metadata.name distinto, o sácala del directorio de la Release. Dos Releases que realmente despliegan Aggregates distintos con el mismo nombre deben estar en directorios propios; copiar una Release a un archivo contiguo sin renombrar lo que contiene es la forma habitual en que esto ocurre.
A Release’s aggregate: or manifest: reference resolves to nothing (La referencia de una Release no se resuelve en nada)
Una Release nombra un Aggregate o un Manifest por identidad simple y no se encontró ninguna entidad con ese nombre en ninguna de las superficies en las que se busca una identidad simple: el propio directorio de la Release, el catálogo y el registro.
Mensaje emitido, cuando nada coincidió en ningún sitio:
aggregate/manifest reference unresolvable: no Aggregate named "<reference>" in the Release directory, catalog, or registry (referencia aggregate/manifest no resoluble: ningún Aggregate con ese nombre en el directorio de la Release, el catálogo ni el registro)
Un archivo del directorio de la Release que no se pudo indexar cambia el informe, porque cambia lo que se puede afirmar con honestidad. Ese archivo podría haber sido la entidad, así que el mensaje lo dice en lugar de afirmar una ausencia que no puede establecer, e incluye el fallo de análisis que impidió leerlo:
aggregate/manifest reference unresolvable: Aggregate "<reference>" not found; unparseable file <path> could not be indexed and may be it: <parse failure> (referencia aggregate/manifest no resoluble: Aggregate no encontrado; el archivo no analizable no se pudo indexar y puede ser el buscado)
y cuando un archivo no analizable es precisamente el que la referencia nombra:
aggregate/manifest reference unresolvable: needed Aggregate "<reference>" is the unparseable file <path>: <parse failure> (referencia aggregate/manifest no resoluble: el Aggregate necesario es el archivo no analizable)
Cómo corregirlo: si la referencia realmente no existe, corrige su ortografía — la identidad es el metadata.name de la entidad, no su nombre de archivo — o añade la entidad al directorio de la Release o al catálogo que lee la compilación. Si el mensaje nombra un archivo no analizable, corrige primero ese archivo: su fallo de análisis aparece citado en el mensaje, y repararlo a menudo resuelve la referencia en la misma edición. Una referencia ./ o ../ es una ruta y no una identidad, y se resuelve como tal, así que un punto inicial cambia cuál de los dos errores estás buscando.
A component is placed in more than one boundary (Un componente está colocado en más de un límite)
El árbol de límites de una Release coloca un componente en dos límites distintos. Las dos colocaciones no se fusionan ni se jerarquizan, y no pueden hacerlo: el límite de un componente decide dónde se escribe su salida, en qué subdirectorio termina, a qué sync wave se une y qué anotaciones e infra de límite hereda — mientras que su superficie uses: por arista la lee un recorrido aparte. Un componente nombrado dos veces tomaría la ubicación de su salida de una colocación y su configuración por arista de la otra.
Un límite coloca componentes de tres maneras, y las tres cuentan. Nombrar uno directamente bajo components:, por el id que lleva una vez completada la composición, lo coloca. Nombrar uno dentro del propio components: de una entrada de enrutamiento, por el nombre local que lleva dentro de ese submódulo, también lo coloca. Y enrutar un submódulo entero bajo aggregates: coloca cada componente que ese módulo contiene. Así que esta detención también cubre un submódulo enrutado a dos límites, un módulo enrutado a un límite con un módulo anidado en él enrutado a otro, y un componente nombrado en un límite mientras el módulo que lo contiene está enrutado a otro distinto.
Enrutar un módulo a un límite y nombrar también uno de sus componentes bajo ese mismo límite no es un conflicto — ambas colocaciones coinciden en dónde pertenece el componente — y la compilación se completa. Un mismo id escrito dos veces bajo un solo límite es un conflicto incluso ahí: una entrada en el components: del límite y una entrada para ese mismo componente dentro de la entrada de enrutamiento del límite son dos entradas que llevan configuración para un solo componente, sin nada con lo que elegir entre ellas.
Se notifica cada colocación infractora. Una Release que coloca varios componentes dos veces se detiene con uno de estos mensajes por cada entrada infractora en una sola compilación, cada uno en la clave de la entrada a la que objeta — de modo que varios de ellos juntos son una sola compilación que nombra todo lo que encontró, y no un único fallo escrito más de una vez.
La colocación que un mensaje indica como ya vigente no siempre es la escrita primero en el archivo. Las propias entradas components: de un límite se leen antes que los componentes que nombran sus entradas de enrutamiento y antes que los submódulos que enruta, y un límite se lee antes que los límites anidados en él; los límites escritos uno junto a otro se leen en el orden en que aparecen. Cuando entra en conflicto más de una colocación anterior, se nombra la primera leída. Ambos sitios se nombran en cualquier orden en que aparezcan, y ninguno se sitúa por encima del otro.
Mensaje emitido. La frase enuncia la regla; lo que sigue nombra la entrada infractora, el límite en el que está cada una de las dos colocaciones, el bloque en el que se escribió cada una y el archivo que contiene ambas. Cuando una entrada bajo el components: de un límite se encuentra con una entrada anterior bajo el de otro límite:
component declared in more than one boundary: declare each component in exactly one boundary (Release <name>, at <field-path>, "<component>", named in the components block of boundary "<boundary-b>", while it is already named in the components block of boundary "<boundary-a>", that earlier entry naming "<component>", both declared in "<path>") (componente declarado en más de un límite: declara cada componente en exactamente un límite (Release; nombrado en el bloque components de un límite, mientras ya está nombrado en el bloque components de otro límite; ambos declarados en el mismo archivo))
Las dos cláusulas que nombran los límites se redactan según el bloque en el que se escribió cada entrada. La entrada infractora toma una de estas:
named in the components block of boundary "<boundary>" — el propio mapa components: del límite;
named inside a routing entry in boundary "<boundary>" — el mapa components: de una entrada de enrutamiento bajo el aggregates: de ese límite;
routed as a sub-module into boundary "<boundary>" — la propia entrada de enrutamiento.
La colocación anterior, continuando la misma frase, toma una de estas:
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>".
Las dos cláusulas se eligen de forma independiente, así que puede aparecer cualquier combinación de ellas, y that earlier entry naming lleva lo que abordaba esa colocación anterior: el id del componente, o el prefijo del submódulo cuando lo colocó un submódulo enrutado.
Cuando la entrada infractora es ella misma una entrada de enrutamiento, lo que aborda es un submódulo y no un único componente, y el mensaje lo dice en lugar de presentar un prefijo de módulo como nombre de componente — aquí al encontrarse con un submódulo anterior enrutado a otro límite:
component declared in more than one boundary: declare each component in exactly one boundary (Release <name>, at <field-path>, sub-module "<module>", routed as a sub-module into boundary "<boundary-b>", while it is already placed by a sub-module routed into boundary "<boundary-a>", that earlier entry naming "<module>", both declared in "<path>") (componente declarado en más de un límite: declara cada componente en exactamente un límite (Release; submódulo enrutado como submódulo a un límite, mientras ya está colocado por un submódulo enrutado a otro límite; ambos declarados en el mismo archivo))
Cómo corregirlo: elimina, de las dos colocaciones, la que no pretendías. El mensaje nombra ambas, así que la elección es tuya y no del compilador. Cuando una declaración directa y un módulo enrutado no coinciden, decide si el componente pertenece a su módulo o va por su cuenta: enrutar el módulo lo coloca junto con todo lo demás que contiene el módulo, y nombrarlo directamente lo separa de ello. Cuando dos entradas de enrutamiento reclaman un mismo módulo, elimina el enrutamiento que no pretendías — enrutar un módulo a un límite coloca allí cada componente que contiene, así que dos entradas así reclaman el mismo conjunto de componentes.
A Manifest annotation binding claims the reserved aggrega.ai/ prefix (Un enlace de anotación del Manifest reclama el prefijo reservado)
Un Manifest declara un enlace de anotación bajo una clave que empieza por el prefijo simple aggrega.ai/. Ese prefijo es donde la compilación estampa las claves que emite ella misma, así que un enlace que reclamara una clave dentro de él pondría tu enrutamiento y la propia salida de la plataforma en un mismo espacio de claves, compitiendo por los mismos nombres.
Se detiene, y no podría ser un aviso. La reserva es todo lo que hace que ese espacio de claves sea de la plataforma; admitir el enlace y mencionarlo después dejaría la colisión en la compilación.
La regla trata del espacio de claves que reclama un enlace escrito por el autor, así que una clave para la que el Manifest presentado no declara ningún enlace se omite en lugar de notificarse — no hay ningún enlace que pueda infringirla.
Mensaje emitido. La clave infractora va primero, porque es de lo que trata la frase, y los valores que siguen se introducen cada uno por lo que son:
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>/") (el enlace de anotación del manifest usa un prefijo reservado (Manifest; prefijo reservado; enrutamiento hacia una Feature; escribe el enlace bajo un dominio propio))
Cómo corregirlo: renombra la clave del enlace a un espacio de nombres que controles. Una clave con subprefijo es la forma admitida y no está reservada: feature.aggrega.ai/… para un atajo de la biblioteca estándar, o tu propio dominio — acme.aggrega.ai/…, compliance.example.com/… — para uno empresarial. Renombrar la clave cambia lo que un autor escribe en un componente para activar el enlace, así que actualiza las anotaciones que lo usan en la misma edición. Las claves propias de la plataforma bajo el prefijo simple se enumeran en ../providers/well-known-annotations.md.
Two Manifest annotation bindings compete for one routing slot (Dos enlaces de anotación del Manifest compiten por un mismo slot de enrutamiento)
Dos enlaces de anotación de un mismo Manifest enrutan a la misma Feature, a través del mismo pilar, en la misma ruta. La función de un enlace es indicar dónde termina el valor de una anotación, y dos enlaces que nombran un único destino dejan el valor con dos enrutamientos y nada con lo que elegir entre ellos en el momento de la expansión.
Solo un enlace puede declarar un par ruta-pilar dado por cada Feature de destino. Dos enlaces que apuntan a la misma Feature en rutas distintas son autoría corriente y la compilación se completa; también lo son dos enlaces que enrutan la misma ruta a dos Features distintas.
Los enlaces se recorren en el orden en que el Manifest los declara, así que el enlace que un mensaje nombra primero es siempre el anterior en tu documento.
Mensaje emitido:
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) (los enlaces de anotación del manifest colisionan en la misma ruta+pilar de la Feature (Manifest; ambos enlaces de anotación apuntan a la Feature con una ruta que enruta al pilar; solo un enlace puede declarar un par (ruta, pilar) dado por Feature))
Cómo corregirlo: decide qué enlace es dueño del destino y quita la ruta de la lista maps.infra o maps.values del otro, o elimina por completo el segundo enlace. Si los dos enlaces existen porque querías que dos claves de anotación llegaran a un mismo campo de la Feature, conserva un enlace y deja que ambas claves de anotación se enruten a través de él; si existen porque dos valores distintos debían terminar en dos lugares, corrige la ruta que se escribió por error.
A Release reached resolution without passing through the load path (Una Release llegó a la resolución sin pasar por la ruta de carga)
Una Release llegó a la resolución con una superficie components: de nivel superior no vacía y, a la vez, un límite default sintetizado. Esa combinación no puede producirla una Release cargada normalmente: la ruta de carga incorpora un bloque components: de nivel superior al límite predeterminado y lo vacía, y un documento que escribió ambos explícitamente es rechazado por su esquema antes de llegar tan lejos.
Así que esta detención no notifica nada que tú hayas escrito. Notifica que algo llegó a la resolución rodeando la ruta de carga — casi siempre una Release construida en memoria por un programa que integra el compilador en lugar de leída de un archivo — y se detiene ahí en lugar de dejar que una compilación continúe sobre un documento cuyas dos superficies de componentes no coinciden. Leerlas en un orden u otro produciría una salida que omite o duplica componentes de forma silenciosa, y el recorrido de límites y el recorrido por arista ni siquiera coincidirían entre sí sobre cuáles.
Mensaje emitido:
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 llegó a la resolución sin normalizar (componentes raíz no vacíos junto a un límite predeterminado sintetizado): construye las Releases a través del núcleo de normalización (types.NormalizeRelease mediante la ruta de carga), no con un literal construido a mano)
Cómo corregirlo: nada, si estás escribiendo YAML — llegar a esta detención desde aggrega build, aggrega validate o el editor significa que el compilador tiene un defecto que vale la pena notificar, y la Release que estabas compilando no tiene la culpa. Si estás integrando el compilador y construyes un valor Release en tu propio código, constrúyelo a través de la ruta de carga en lugar de ensamblar la struct directamente, para que se ejecute la normalización que incorpora los componentes raíz al límite predeterminado.
A library reference expands into itself (Una referencia a una biblioteca se expande en sí misma)
Una cadena de referencias entre documentos vuelve a un documento que ya ha alcanzado, así que expandirla nunca terminaría. Dos superficies de autoría llegan a la misma condición, y ambas son cadenas entre entidades de biblioteca, no algo dentro de un solo archivo: un $ref: desde un pilar de esquema hacia una entrada de una SchemaLibrary que, referencia tras referencia, vuelve atrás, y un $import: hacia una entrada de una MappingLibrary o una WorkloadLibrary que hace lo mismo.
La cadena se compara sobre una clave canónica — la identidad de la biblioteca y el nombre de la entrada, sin host de registro ni grafía de versión — de modo que un ciclo no puede escapar a la comprobación nombrando la misma entrada de dos formas distintas a lo largo de su camino. Una referencia que se expande y termina no es problema, por muchas veces que aparezca y por profunda que sea la cadena; la profundidad por sí sola nunca causa esta detención, y reutilizar una entrada de biblioteca desde muchos lugares es el patrón para el que existen las bibliotecas.
Mensaje emitido, para una cadena $import:, que nombra el bucle completo en el orden en que se recorrió para que veas qué paso lo cierra:
Una cadena $ref: la notifica en cambio el compilador de la forma compacta, que la enmarca con el documento y la palabra clave que estaba leyendo:
compactform at <consumer-file> (keyword "$ref"): circular cross-document $ref expansion: <Library>#/schemas/<entry> -> <Library>#/schemas/<entry> -> <Library>#/schemas/<entry> (compactform, palabra clave: expansión circular de $ref entre documentos)
Cómo corregirlo: lee la cadena del mensaje y rómpela en el paso que no era intencionado. Un ciclo suele significar que dos entradas de biblioteca se escribieron cada una para extender la otra; reúne la parte compartida en una tercera entrada a la que ambas hagan referencia, o intégrala en una de ellas. El último paso mostrado es el que cerró el bucle, pero no es necesariamente el erróneo — la cadena completa se imprime precisamente porque qué eslabón cortar es decisión tuya.
La misma condición respalda también el rechazo por recursión de ancla documentado más arriba en «YAML anchor aliased inside its own content (Ancla YAML referenciada mediante un alias dentro de su propio contenido)». Aquel es un bucle dentro del propio texto de un solo documento; este es un bucle entre documentos. La cadena del mensaje distingue ambos de un vistazo: un bucle entre documentos nombra entradas de biblioteca, y un bucle dentro de uno nombra un ancla.
A declared schema cannot be resolved (Un esquema declarado no se puede resolver)
Un esquema llegó al punto de usarse para validar algo y no se pudo ensamblar en un esquema en absoluto. La causa más común es un $ref: que no nombra nada resoluble; un esquema que no satisface el metaesquema de JSON Schema llega a la misma detención, igual que una rama then: o else: bajo una palabra clave condicional que no se puede resolver por sí sola.
El rechazo llega antes de que se valide nada contra el esquema, y ese orden es lo esencial. Pasar por alto un esquema ilegible dejaría sin validar todo lo que cubre mientras la compilación notifica éxito — una comprobación que ha dejado de ejecutarse sin nada que diga que se detuvo.
Mensaje emitido, que nombra la posición dentro del esquema, la palabra clave que no se pudo resolver y lo que notificó la resolución:
validator/jsonschema: schema resolution failed (at <path-inside-the-schema>, keyword "<keyword>", <what resolution reported>) (validator/jsonschema: falló la resolución del esquema (posición, palabra clave))
Cuando el fallo está en la raíz del esquema y no en una palabra clave dentro de él, se omiten la posición y la palabra clave y la frase lleva solo el motivo notificado.
Cómo corregirlo: abre el esquema en la posición que nombra el mensaje. Un $ref: es el culpable habitual: confirma que el destino existe, que una referencia interna al documento escribe exactamente su ruta #/$defs/… y que una referencia entre documentos nombra una entrada de una SchemaLibrary que el cierre de dependencias de la compilación realmente contiene. Cuando el mensaje nombra una rama then: o else:, esa rama es un esquema por derecho propio y tiene que poder resolverse por sí misma.
An x-aggrega-when: or x-aggrega-validate: predicate cannot be evaluated (No se puede evaluar un predicado)
Un esquema declara una de las dos palabras clave de extensión cuyo valor es una plantilla, y la plantilla no se pudo usar: no es una cadena, no se analiza como plantilla, falló durante la ejecución o produjo algo distinto de true o false.
x-aggrega-when: decide si una rama condicional de un esquema se aplica; x-aggrega-validate: decide si un valor satisface una regla que las propias palabras clave del esquema no pueden expresar. Ambas se leen como veredictos, por eso un resultado que no lo es se rechaza en lugar de interpretarse: un predicado que produjera una cadena vacía se leería como falso y retiraría silenciosamente la regla que se escribió para hacer cumplir.
Mensaje emitido:
validator/jsonschema: x-aggrega extension evaluation failed (at <path-inside-the-schema>, keyword "x-aggrega-validate", <what evaluation reported>) (validator/jsonschema: falló la evaluación de la extensión x-aggrega)
con "x-aggrega-when" en lugar de la palabra clave cuando el que falla es el predicado del condicional, y el motivo informado nombrando el error de la plantilla — una posición de análisis, una función que falta o el valor no booleano que produjo la plantilla.
Cómo corregirlo: abre el esquema en la posición que indica el mensaje y lee el motivo informado. Confirma que el valor de la palabra clave es una cadena, que la plantilla se analiza y que cada ruta que recorre existe realmente en el valor que se valida — un predicado lee el valor como .value, y buscar cualquier otra cosa es el error más común. Si el motivo nombra una clave que index no encontró, comprueba la clave con hasKey o léela con get en su lugar: index se detiene ante una clave que el mapa no contiene, como describe «A template indexes a map with a key the map does not hold (Una plantilla indexa un mapa con una clave que el mapa no contiene)» más abajo. Asegúrate de que la plantilla termine produciendo true o false: una comparación lo hace, mientras que una plantilla que solo renderiza el valor no.
A Workload does not satisfy the Workload schema (Un Workload no satisface el esquema Workload)
El bloque workload: de una Recipe o de una FeatureRecipe se leyó y se comprobó contra el esquema Workload, y uno o más campos no lo satisfacen — una clave mal escrita, un valor del tipo incorrecto, un campo obligatorio omitido, un valor fuera de un rango o de una enumeración declarados.
El informe está agrupado: una sola detención incluye todos los campos con errores, de modo que un Workload con cuatro errores te informa de los cuatro en una sola compilación en lugar de uno por compilación. El encabezado nombra el Workload, la Recipe que lo declara y el archivo; cada hallazgo debajo de él nombra la ruta del campo dentro del Workload, lo que el esquema exigía allí y la corrección, cuando se puede indicar.
Mensaje emitido:
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> (falló la validación de la carga de trabajo (Workload en la Recipe, etapa del esquema))
Un fallo sin detalle por campo — el bloque no se pudo leer en absoluto, en lugar de leerse y encontrarse deficiente — incluye en su lugar el motivo completo como único hallazgo.
Cuando la plantilla workload: lee un valor declarado sensible, ningún hallazgo cita un valor. No se puede saber qué campo del documento renderizado procede de ese valor, así que cada hallazgo cuyo texto podría contener un valor enuncia la restricción del esquema con <redacted> en lugar del valor, cerrada por un aviso que nombra el motivo, y no incluye ninguna corrección derivada del valor:
.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 hallazgo que no cita ningún valor — una clave que falta, una clave que el Workload no admite — se lee igual que para cualquier otra plantilla. Consulta vocabulary/compact-form-authoring.md «Qué dice un rechazo sobre un valor declarado».
La compilación informa de la detención bajo una etiqueta CATALOG_ERROR, porque un bloque workload: lo escribe el autor de la Recipe y no el Aggregate ni la Release.
Cómo corregirlo: abre la Recipe en las rutas de campo indicadas y corrige cada una. Las rutas se dan desde la raíz propia del Workload, así que .containers.main.health.ready es el bloque ready bajo la clave health del contenedor main. Un contenedor con nombre se indica por su clave y un contenedor de inicialización por su posición, por eso los dos se leen de forma distinta. Lo que acepta cada campo está en la referencia de autoría de Workload.
Un campo que el esquema quiere como texto, rechazado porque el valor es un número o un booleano, casi siempre significa una expresión de plantilla sin comillas. Un bloque workload: se renderiza antes de comprobarse, así que una expresión escrita sin comillas se expande en texto desnudo y YAML lee entonces ese texto como lo que parece. Una cantidad de dimensionamiento en núcleos enteros, una versión formada solo por dígitos, un puerto y las palabras yes, no, on y off se leen todos como algo distinto de texto. El hallazgo dice qué tipo leyó YAML, y el remedio es poner entre comillas la expresión en la Recipe — cpu: "{{ .infra.compute.cpu }}" en lugar de cpu: {{ .infra.compute.cpu }} — para que el valor siga siendo texto sea cual sea lo que proporcione el operador. Ten en cuenta que el valor del propio operador no tiene la culpa aquí y que ponerlo entre comillas en la Release no cambia nada: las comillas tienen que estar en la Recipe, alrededor de la expresión.
A Workload attachment names a slot the entity does not declare, or a delivery the slot forbids (Una vinculación de Workload nombra un slot que la entidad no declara, o una entrega que el slot prohíbe)
Una entrada attachments: de un contenedor dentro de un bloque workload: hace referencia a un slot de vinculación, y la referencia no coincide con los slots que el Component o la Feature declara en su featuresSchema — o, para una entrada que nombra una conexión con connection:, con los slots que declara el socket de esa conexión. Una entrada envFrom que nombra una conexión está sujeta a las mismas reglas de conexión. El hallazgo dice cuál de estas formas tienes.
El slot no está declarado. El from: de la entrada nombra un slot que el featuresSchema de la entidad no contiene — un error tipográfico, o un slot que se renombró solo en un lado.
El slot es de caja negra. El slot declara una lista de permitidos inject: vacía, que reserva la entrega a la mecánica interna de la propia Recipe. Un slot así se llena y se consume internamente, de modo que un Workload no puede acceder a él.
La entrega está fuera de la lista de permitidos del slot. El as: de la entrada nombra un mecanismo que la lista inject: del slot no permite.
La conexión no es una de las que traza el componente. El connection: de la entrada nombra un alias bajo el cual no está escrita ninguna conexión del componente.
El socket de la conexión no declara el slot. El from: de la entrada (o, en envFrom, secret:) nombra un slot que no declara el socket a través del cual está cableada esa conexión.
El slot está escrito con su nombre compuesto. El from: (o secret:) de la entrada es el nombre que toma la vinculación de una conexión en el componente — el alias, un punto y el slot — escrito sin connection:. El slot de una conexión solo se alcanza nombrando la conexión.
Todas las entradas con errores de todos los contenedores se informan juntas, de modo que una sola compilación las nombra todas. Los hallazgos se agrupan bajo un único encabezado que nombra el Workload, su Recipe y el archivo.
Mensaje emitido:
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> (falló la verificación cruzada del featuresSchema de la carga de trabajo (Workload en la Recipe, etapa featuresSchema): hace referencia a un slot que no está declarado en el featuresSchema del Component — declara el slot en el featuresSchema del Component (o de la Feature), o cambia el nombre de la referencia a un slot existente; el slot es de caja negra (sin lista de permitidos) y no se puede referenciar desde una entrada attachments de un Workload — los slots de caja negra se entregan mediante la mecánica interna de la Recipe; elimina la referencia del lado del Workload, o amplía la lista de permitidos inject del slot si se pretende una entrega del lado del Workload; el slot no permite el mecanismo de entrega (lista de permitidos inject) — usa uno de los mecanismos de entrega permitidos, o amplía la lista de permitidos inject del slot en el featuresSchema del Component/Feature; nombra una conexión para el slot, pero el componente no traza ninguna conexión con ese alias — nombra una conexión que trace el componente, o elimina connection para leer un slot que el Component declara para sus propias vinculaciones; nombra un slot de la conexión que el socket no declara — nombra un slot que declare el socket, o declara el slot en el featuresSchema de ese socket; nombra el nombre que el compilador compone para un slot de una conexión; un slot que declara el socket de una conexión se nombra nombrando la conexión — escribe connection: junto a from:)
En una entrada envFrom los mismos hallazgos se encuentran en .containers.<name>.envFrom[<i>].connection y .containers.<name>.envFrom[<i>].secret.
Cómo corregirlo: cada hallazgo nombra ambos lados, así que la elección es qué lado cambiar. Para un slot no declarado, corrige la escritura de from: o declara el slot en el featuresSchema de la entidad — el sufijo .from de la ruta del campo señala la referencia. Para un slot de caja negra, elimina la referencia del lado del Workload y deja que la Recipe entregue el material, a menos que la entrega del lado del Workload se quiera de verdad, en cuyo caso da al slot una lista de permitidos inject:. Para un mecanismo rechazado, cambia as: a uno que nombre la lista de permitidos, o añade el tuyo a ella. Para una conexión que el componente no traza, corrige el alias a uno de los que enumera el hallazgo, o traza la conexión en el Aggregate o en la Release. Para un slot que el socket no declara, nombra uno de los slots que enumera el hallazgo, o declara el slot en el featuresSchema del socket en el Component. Para un nombre compuesto, escribe la conexión y el slot por separado, como muestra el hallazgo.
A Workload references a slot whose fill publishes no locator (Un Workload hace referencia a un slot cuyo relleno no publica ningún localizador)
Una entrada attachments: de un contenedor nombra un slot por referencia, y la vinculación que llena ese slot no publica las claves provides que lee una referencia así. Hacer referencia a un slot por su nombre significa pedir que el recurso que representa se direccione en la salida renderizada — por el nombre del recurso y por el campo que contiene. Un relleno que no publica ninguno de los dos no tiene ningún localizador al que apuntar, así que la referencia no se puede convertir en nada.
Qué claves se requieren depende de la entrada, y el hallazgo dice cuáles esperaba. Una entrada que nombra su propia key: aporta ella misma el campo, así que solo debe publicarse el name del recurso — que es lo que le permite hacer referencia a un recurso de varias claves. Una entrada que no nombra ninguna key: lee el único campo publicado del slot, así que deben estar tanto name como key.
La comprobación solo lee si las claves están presentes; nunca inspecciona sus valores. Todas las entradas con errores se informan juntas, bajo un único encabezado.
Mensaje emitido:
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 (el slot de vinculación de la carga de trabajo no es referenciable (Workload en la Recipe, etapa slotReferenceability): el slot no es referenciable: sus provides resueltos no exponen la clave (una referencia de vinculación de la carga de trabajo lee las claves provides name y key) — haz referencia a un slot llenado por una vinculación cuyo schema.provides declare las claves que lee esta referencia, o entrégalo mediante el canal inject del slot en lugar de mediante una referencia de la carga de trabajo)
Cómo corregirlo: dos direcciones, y cuál es la correcta depende de lo que querías decir. Si la referencia es correcta, lo que hay que cambiar es la vinculación que llena el slot: vincula una Feature cuyo schema.provides declare name — y key, cuando la entrada no nombra una propia — para que haya un localizador al que apuntar. Si el material nunca debió direccionarse por nombre en la salida, elimina la referencia y entrégalo en su lugar mediante el canal inject: del slot, que transporta el valor en lugar de un puntero al lugar donde reside.
A container gives one environment variable two values (Un contenedor da dos valores a una misma variable de entorno)
Un contenedor de un bloque workload: nombra dos veces la misma variable de entorno: una vez como clave de sus variables y otra como clave de una entrada attachments entregada as: env. Se comprueban tanto un contenedor principal como un contenedor de inicialización, por igual en el Workload que renderiza la Recipe de un componente y en el Workload que renderiza una FeatureRecipe — la vinculada a un componente y la declarada en un límite — y la comprobación lee el Workload tal como lo renderizó su plantilla.
Por qué se detiene en lugar de elegir una. El entorno de un contenedor se escribe a partir de esas dos colecciones en un orden fijo — los proveedores helm y compose escriben primero cada entrada leída de una vinculación y después las variables simples. Un nombre escrito de ambas formas llegaría por tanto al proceso con el valor que ese orden deje ganar, lo cual es consecuencia de dónde acaban los dos tipos y no de nada que hayas escrito, así que la compilación rechaza el par en lugar de renderizarlo. La comprobación se ejecuta una sola vez, sea cual sea el proveedor que renderice el Workload, después de las demás comprobaciones del Workload y antes de que se evalúen las entradas artifacts: o de que el Workload se entregue a cualquier proveedor, de modo que un par rechazado nunca se renderiza. Una entrada attachments entregada as: file se monta como archivo en lugar de establecerse en el entorno, por lo que nunca forma un par.
La comprobación solo compara nombres; nunca lee un valor, así que ningún hallazgo cita uno. Dos tipos de entrada de entorno quedan fuera de lo que compara: una entrada envFrom establece las claves del ConfigMap o del Secret que nombra, que no se conocen cuando se ejecuta la compilación, y una entrada que un paso del pipeline escribe en un documento renderizado no forma parte del Workload que lee la comprobación.
Cada par es un hallazgo propio, situado en la clave workload: de la Recipe o FeatureRecipe que declara el Workload, y nombra la variable y el contenedor — un contenedor principal por su clave, un contenedor de inicialización por su posición en la lista initContainers. Los hallazgos llegan primero para los contenedores principales, en el orden en que están escritos, luego para los contenedores de inicialización por posición y, dentro de un contenedor, en el orden en que están escritas sus entradas attachments.
Mensaje emitido, para un par en un contenedor principal del Workload de una Recipe. La categoría y el código corto de esta condición, E0345, te llegan en la cabecera entre corchetes, y la posición se lee <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 contenedor declara dos veces una misma variable de entorno. Cambia el nombre de una de las dos, o escríbelas bajo condiciones de plantilla complementarias para que solo se renderice una de ellas)
Un par en un contenedor de inicialización nombra en su lugar su posición en la lista — init container "initContainers[<i>]" — y el hallazgo de una FeatureRecipe nombra, después del contenedor, la vinculación que la enlaza, attachment "<attachment>", porque un componente puede llevar varias vinculaciones cuyas FeatureRecipes son documentos separados.
Cuando un Workload lleva varios pares, los hallazgos se agrupan bajo una línea que nombra el documento: containers of the Workload this Recipe renders name one environment variable twice o, para una FeatureRecipe, containers of the Workload rendered by the FeatureRecipe that attachment "<attachment>" binds name one environment variable twice.
La compilación informa de la detención bajo una etiqueta CATALOG_ERROR, porque un bloque workload: lo escribe el autor de la Recipe o de la FeatureRecipe y no el Aggregate ni la Release.
Cómo corregirlo: decide cuál de las dos debe recibir el contenedor. Si quieres ambas, cambia el nombre de una de ellas, para que el proceso vea dos variables. Si son alternativas — un valor de respaldo simple para cuando no hay ninguna credencial vinculada, por ejemplo — protégelas con condiciones complementarias para que se renderice exactamente una: escribe la variable bajo {{ if not (hasKey (default dict .features) "<slot>") }} y la entrada attachments bajo {{ if hasKey (default dict .features) "<slot>" }}, o bajo las dos ramas de un mismo {{ if }}/{{ else }}. Un par protegido de esa forma nunca llega a la comprobación, porque en el Workload renderizado solo está una de las dos.
A Release’s parameters: block is written in neither of its two shapes (El bloque de parámetros de una Release no está escrito en ninguna de sus dos formas)
Una Release satisface los parámetros que declaró un Aggregate de una de dos maneras, y el bloque se lee según su forma. O bien es un mapeo de nombres de parámetros a valores escritos en el propio lugar, o bien es un mapeo de exactamente una clave, $import:, cuyo valor es la ruta de un archivo YAML que contiene esos valores. Un bloque que no es ninguna de las dos cosas se rechaza al leerse, antes de que nada contraste los valores con las declaraciones del Aggregate.
Se rechazan tres formas. Un valor parameters: que no es un mapeo en absoluto — un escalar o una lista. Un mapeo que lleva $import: junto a otras claves, lo que pide a la vez los valores importados y los escritos sin dar ninguna regla para combinarlos. Y un $import: cuyo valor no es una cadena simple, que por tanto no nombra ningún archivo.
El esquema de la Release declara las mismas dos formas, así que un archivo de Release que lleve cualquiera de las tres se encuentra primero con la comprobación de la envoltura del documento, bajo E0215, que prueba ambas formas y dice por qué falló cada una — aquí para una lista:
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 (falló la validación de la envoltura del documento (Release); spec.parameters: ninguna rama oneOf coincide (2 ramas probadas): branch[0]: type: se esperaba object, se obtuvo array; branch[1]: type: se esperaba object, se obtuvo array. corrige el documento para que coincida con el esquema de su tipo)
Para $import: junto a otra clave, la segunda rama termina con additionalProperties: unexpected property: "<key>", y para un $import: escrito como lista en lugar de como cadena termina con validation: type: array has type "array", want "string".
Mensaje emitido cuando el valor no es un mapeo, que nombra lo que se escribió allí — a list, por ejemplo:
parameters: shape must be an inline object or {$import: }: line <line>: <shape> is written where a map is expected (parameters: la forma debe ser un objeto en línea o {$import: ruta local}: en la línea indicada hay un valor escrito donde se espera un mapeo)
y cuando $import: comparte el mapeo con otra cosa, o nombra algo que no es una ruta:
parameters: shape must be an inline object or {$import: }: $import: must be the only key (got <n> keys) at line <line> (parameters: la forma debe ser un objeto en línea o {$import: ruta local}: $import debe ser la única clave, se encontraron varias claves en la línea indicada) parameters: shape must be an inline object or {$import: }: $import value must be a string scalar at line <line> (parameters: la forma debe ser un objeto en línea o {$import: ruta local}: el valor de $import debe ser un escalar de cadena en la línea indicada)
Cómo corregirlo: abre la Release en la línea que indica el mensaje. Escribe los valores en el propio lugar bajo parameters:, o sustituye el bloque entero por una única entrada $import: cuyo valor sea una ruta entre comillas. Si querías valores escritos y un archivo importado de valores predeterminados compartidos, mueve los escritos a una Release que con extends: extienda la que contiene la importación — superponer varias fuentes de parámetros es justo para lo que sirve una cadena extends:, y esta única clave se lee de una sola fuente por diseño.
An inline-or-import field is written in neither shape (Un campo en línea o de importación no está escrito en ninguna de las dos formas)
Tres campos que escribe una Recipe o una FeatureRecipe — una entrada artifacts.<name>:, un valuesMapping: y un workload: — aceptan las mismas dos formas. O bien el cuerpo se escribe en el propio lugar, como escalar de cadena (un bloque | es la escritura habitual para cualquier cosa de varias líneas), o bien el valor es un mapeo de exactamente una clave, $import:, que nombra en cambio dónde está el cuerpo. Lo que un $import: puede nombrar varía según el campo: una entrada de artifacts importa una ruta local o un bundle de una ArtifactLibrary, mientras que valuesMapping: y workload: importan una ruta local o una entrada de una biblioteca por identidad.
Un único lector comprueba los tres, así que los rechazos son los mismos tres sea cual sea el campo con el error: un mapeo que lleva más de una clave, un mapeo cuya única clave no es $import y un $import: cuyo valor no es una cadena simple. Un valor que no es ni un escalar ni un mapeo — casi siempre una lista — se rechaza solo por su forma.
Los esquemas de Recipe y FeatureRecipe declaran las mismas dos formas para cada uno de los tres campos, así que un archivo que lleve cualquiera de estos casos se encuentra primero con la comprobación de la envoltura del documento, bajo E0215, que nombra el campo y dice por qué falló cada forma — la primera rama es la forma escrita en el propio lugar, la segunda la de $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 (falló la validación de la envoltura del documento (Recipe); spec.artifacts: ninguna rama oneOf coincide (2 ramas probadas): branch[0]: validación: type: object tiene el tipo «object», se esperaba «string»; branch[1]: additionalProperties: propiedad inesperada. corrige el documento para que coincida con el esquema de su tipo)
Eso es un mapeo que lleva una clave junto a $import:. Una sola clave que no es $import termina con required: missing required property: $import, additionalProperties: unexpected property: "<key>", una lista termina con type: expected object, got array, y un $import: que no es una cadena nombra el tipo encontrado donde se esperaba una cadena, como en type: array has type "array", want "string".
Mensajes emitidos. Cada uno empieza con la frase del campo con el error y luego dice qué encontró el lector y dónde:
artifacts entry: shape must be a string scalar or {$import: }: got <n> keys at line <line> (entrada de artifacts: la forma debe ser un escalar de cadena o {$import: ruta local}: se encontraron varias claves en la línea indicada) valuesmapping: shape must be a string scalar or {$import: }: got key "<key>" at line <line> (valuesmapping: la forma debe ser un escalar de cadena o {$import: ruta o identidad de biblioteca}: se encontró otra clave en la línea indicada) workload: shape must be a string scalar or {$import: }: $import value must be a string scalar at line <line> (workload: la forma debe ser un escalar de cadena o {$import: ruta o identidad de biblioteca}: el valor de $import debe ser un escalar de cadena en la línea indicada)
Cualquiera de los tres campos puede informar de cualquiera de esos finales; un valor que no tiene ninguna de las dos formas termina con line <line>: <shape> is written where text or a map is expected, nombrando lo que se escribió — casi siempre a list.
Cómo corregirlo: abre la entidad en la línea que indica el mensaje. Escribe el cuerpo en el propio lugar como escalar de bloque, o sustituye el valor entero por una única entrada $import:. Un mapeo que lleva $import: y cualquier otra cosa no es ninguna de las dos formas — mueve las claves adicionales al archivo importado, o escribe el cuerpo en el propio lugar. Un $import mal escrito — casi siempre porque falta el $ — se lee como una clave corriente y se informa como la única clave que no es $import.
A reference to a library entry carries whitespace (Una referencia a una entrada de biblioteca contiene espacios en blanco)
Una referencia que nombra una entrada dentro de una biblioteca se escribe como un único token sin interrupciones: la biblioteca, una versión mínima :<version> opcional, y luego # y la ruta de la entrada — BaseWorkloads:1.0.0#/workloads/StatelessService. Ninguna de sus partes admite espacios en blanco. Tanto los nombres de biblioteca como los nombres de entrada están limitados por los esquemas de biblioteca a grafías de identificador, y una versión es una versión, así que un espacio, una tabulación o un salto de línea en cualquier punto de una referencia no pertenece a ninguna de las tres partes.
El rechazo cubre toda superficie que se dirige a una entrada de biblioteca por identidad: un valuesMapping:, un workload: y una entrada artifacts.<name>: escritos como $import:, y un $ref: de esquema. Una ruta local escrita como $import: no lleva # y no es una referencia a una entrada de biblioteca, así que una ruta que contiene un espacio no se toca.
Lo que hace que valga la pena rechazarlo en lugar de arreglarlo es que la parte inicial de un valor así suele ser una referencia por derecho propio. Recortar en el espacio en blanco resolvería esa referencia y descartaría sin aviso el resto de lo que escribió el autor — y las dos mitades de una compilación no tienen por qué descartar la misma cantidad, así que una podría registrar una dependencia que la otra nunca vio. Rechazarlo mantiene que el valor signifique una sola cosa.
El rechazo se informa en la línea del documento del que se leyó la referencia:
library reference: a reference to a library entry carries no whitespace or line break: $import target "<reference>" at line <line> (referencia de biblioteca: una referencia a una entrada de biblioteca no contiene espacios en blanco ni saltos de línea: destino de $import en la línea indicada)
Una referencia llega a una compilación desde un lugar más: el cuerpo de una entrada de biblioteca que una compilación ya ha resuelto, donde un $import: en la raíz del campo, en la primera línea, apunta a la entrada de otra biblioteca. Esa referencia nunca se leyó de un documento que abriera la compilación, así que se informa sin línea:
library reference: a reference to a library entry carries no whitespace or line break: "<reference>" (referencia de biblioteca: una referencia a una entrada de biblioteca no contiene espacios en blanco ni saltos de línea)
Cómo corregirlo: abre la entidad en la línea que indica el mensaje y junta la referencia para que sea un único token. Un salto de línea antes del # es la causa habitual — una referencia partida en dos líneas para que quepa en una columna es un solo valor para YAML y una referencia rota aquí, así que escríbela en una sola línea por larga que sea. La otra es un espacio final antes de la comilla de cierre: queda dentro de la versión mínima, donde nombra una versión que ningún artefacto publicado lleva. Para la segunda forma, la referencia está dentro de la biblioteca nombrada justo antes de ella en el mensaje; corrígela donde esa biblioteca declara la entrada.
A library entry’s body is not the shape that library holds (El cuerpo de una entrada de biblioteca no tiene la forma que contiene esa biblioteca)
Una biblioteca publica cuerpos con nombre para que otras entidades los importen, y cada tipo de biblioteca contiene una sola forma. Una entrada de una MappingLibrary y una entrada de una WorkloadLibrary contienen cada una un cuerpo de plantilla, así que el valor de la entrada es un escalar — en la práctica, un bloque |. Una entrada de una ArtifactLibrary contiene un bundle: los archivos que van juntos bajo un mismo nombre, así que la entrada es un mapeo del nombre del archivo de salida al cuerpo de ese archivo, y cada cuerpo que contiene es un escalar.
Los cuerpos se capturan exactamente como están escritos y no se analizan cuando se carga la biblioteca. La plantilla que contiene un cuerpo se analiza donde se importa, por eso aquí solo se comprueba la forma — un cuerpo que no es en absoluto una plantilla se carga sin problemas y falla en el punto en que algo lo renderiza.
Mensajes emitidos, cada uno de los cuales nombra la línea y lo que se escribió allí — a list, por ejemplo:
mappinglibrary: entry body must be a string scalar: line <line>: <shape> is written where text is expected (mappinglibrary: el cuerpo de la entrada debe ser un escalar de cadena: en la línea indicada hay un valor escrito donde se espera texto) workloadlibrary: entry body must be a string scalar: line <line>: <shape> is written where text is expected (workloadlibrary: el cuerpo de la entrada debe ser un escalar de cadena: en la línea indicada hay un valor escrito donde se espera texto) artifactlibrary: entry must be a mapping of filename to a string body: line <line>: <shape> is written where a map is expected (artifactlibrary: la entrada debe ser un mapeo del nombre de archivo a un cuerpo de cadena: en la línea indicada hay un valor escrito donde se espera un mapeo)
y, para un bundle cuya entrada es un mapeo pero uno de cuyos archivos no es un escalar, nombrando el archivo:
artifactlibrary: entry must be a mapping of filename to a string body: file "<filename>": line <line>: <shape> is written where text is expected (artifactlibrary: la entrada debe ser un mapeo del nombre de archivo a un cuerpo de cadena: en el archivo y la línea indicados hay un valor escrito donde se espera texto)
La compilación los informa bajo una etiqueta CATALOG_ERROR que nombra el archivo que estaba leyendo, con la frase anterior debajo.
Cómo corregirlo: escribe el cuerpo como escalar de bloque bajo su clave. Un cuerpo cuya primera línea parece una clave YAML — lo que suele ocurrir con una plantilla que produce YAML — se lee como un mapeo anidado si falta el escalar de bloque, y esa es la causa habitual. Para una ArtifactLibrary, escribe una clave por cada nombre de archivo de salida, con cada cuerpo como su propio escalar de bloque; un bundle escrito como un único cuerpo es el otro error de forma habitual.
A $instantiate: reference cannot be resolved (No se puede resolver una referencia)
Una SchemaLibrary puede declarar estructuras reutilizables bajo spec.templates, cada una con sus propios $params, y una entrada de esquema instancia luego una de ellas nombrándola bajo $instantiate: y proporcionando sus parámetros bajo $args:. La sustitución es literal: un escalar $<name> en el cuerpo de la plantilla se reemplaza por el valor del argumento. No hay evaluación de expresiones, ni condicionales ni bucles, y un valor sustituido se inserta tal cual, sin recorrerse en busca de más marcadores.
Tres fallos provocan el rechazo de la instanciación. El nombre bajo $instantiate: no es uno de los que declara la biblioteca. Un parámetro que la plantilla declara sin default: no tiene ninguna entrada bajo $args:. O el valor de un argumento no es del tipo que declara su parámetro — y una clave de $args: que no nombra ningún parámetro declarado se informa de la misma manera, en lugar de ignorarse, de modo que un nombre de argumento mal escrito es un rechazo en lugar de un parámetro que toma silenciosamente su valor predeterminado.
Mensajes emitidos:
schemalibrary: template not found: "<template-name>" not declared in spec.templates (schemalibrary: plantilla no encontrada: no declarada en spec.templates) schemalibrary: template parameter missing: "<parameter-name>" (template "<template-name>") (schemalibrary: falta un parámetro de la plantilla) schemalibrary: template parameter type mismatch: <what the type check found> (schemalibrary: el tipo de un parámetro de la plantilla no coincide) schemalibrary: template parameter type mismatch: argument "<argument-name>" is not declared in template "<template-name>"’s $params (schemalibrary: el tipo de un parámetro de la plantilla no coincide: el argumento no está declarado en los $params de la plantilla)
Cómo corregirlo: para una plantilla no encontrada, corrige el nombre por uno que la biblioteca declare bajo spec.templates — y comprueba que estás importando la biblioteca que querías. Para un parámetro que falta, añádelo a $args:, o dale al parámetro un default: en la plantilla para que quienes la llaman puedan omitirlo. Para un tipo que no coincide, cambia el argumento al tipo declarado o amplía el type: del parámetro; cuando el mensaje nombra un argumento que no está declarado, corrige su ortografía o elimínalo.
A schema uses a JSON Schema keyword the library does not admit (Un esquema usa una palabra clave de JSON Schema que la biblioteca no admite)
$dynamicAnchor y $dynamicRef no se admiten en el contenido de una SchemaLibrary. Aplazan la decisión de a qué esquema se resuelve una referencia hasta que se valida el valor, lo que hace que el significado de una entrada de biblioteca dependa de dónde se importó en lugar de lo que dice — y el compilador resuelve las estructuras de una biblioteca antes de cualquier validación, así que no hay nada contra lo que pueda resolverse una referencia aplazada.
El rechazo se aplica en tres puntos, que juntos cierran las dos vías por las que podría llegar la palabra clave. Una entrada de esquema se analiza al cargarse la biblioteca. El cuerpo de una plantilla se analiza al cargarse la biblioteca, de modo que una plantilla que contiene literalmente la palabra clave falla en ese punto y no en la primera compilación que la instancie. Y el cuerpo sustituido se analiza de nuevo tras una instanciación, de modo que proporcionar la palabra clave como valor de un argumento no supera los dos primeros controles.
Mensaje emitido:
schemalibrary: forbidden JSON Schema keyword: "$dynamicRef" at line <line> (schemalibrary: palabra clave de JSON Schema prohibida, en la línea indicada)
Cómo corregirlo: sustituye la referencia aplazada por un $ref que nombre directamente una entrada de $defs. Cuando la estructura varía realmente según el uso, expresa la variación como una plantilla con $params e instánciala en cada uso — esa es la sustitución que ofrece esta superficie, y se resuelve antes de que nada se valide contra el resultado.
A document nests deeper than the reader will descend (Un documento se anida a más profundidad de la que desciende el lector)
Cada mapeo escrito por el autor se lee en una estructura que conserva el orden en que se escribieron sus claves, porque ese orden llega a la salida renderizada y forma parte de lo que hace que una compilación sea idéntica byte a byte entre ejecuciones. Ese lector desciende un número limitado de niveles — cien — y se niega a ir más allá, de modo que una entrada que, de otro modo, agotaría la propia pila del lector se informa como el rechazo que es.
Mensaje emitido:
a document nests too many levels deep: it is read at most 100 levels deep (un documento se anida con demasiados niveles de profundidad: se lee como máximo hasta 100 niveles de profundidad)
Cómo corregirlo: los documentos escritos realmente por un autor se anidan unos pocos niveles, así que un documento que llega a cien está generado, traducido automáticamente o es accidentalmente autorreferencial. Busca un valor que se haya expandido en sí mismo — un ancla YAML que referencia el contenido dentro del cual se encuentra se rechaza por su propia detención más arriba, pero un generador que emite repetidamente la misma estructura no. Cuando la profundidad es real, extrae la rama profunda a una entidad propia y referénciala por su nombre.
A provider declares a well-known annotation at a scope it does not render (Un proveedor declara una anotación well-known en un nivel que no renderiza)
Un Plugin que sirve a un proveedor dice dos cosas sobre sí mismo que tienen que coincidir. Bajo spec.provider.wellKnownAnnotations enumera las anotaciones sobre las que actúa, cada una con los niveles en los que las lee. Bajo contract.inputKinds indica qué tipos de entrada renderiza. Una clave declarada en un nivel cuyo tipo de entrada la misma entidad no reivindica supone que esas dos afirmaciones se contradicen en un mismo archivo, así que la entidad se rechaza al cargarse.
La comprobación es una comparación de la entidad consigo misma, por eso no necesita ningún binario del plugin y se activa allí donde se lee la entidad — incluido un recorrido del catálogo en una máquina que nunca ha descargado el artefacto.
Dos entradas no se comparan, de forma deliberada. Una entrada a nivel de límite no nombra ningún tipo de entrada, porque se resuelve una sola vez para todo un límite y no en la ruta de renderizado de un nodo concreto. Una entrada que no declara ningún nivel no hace ninguna afirmación por ruta: solo dice que el plugin lee la clave en algún lugar.
Lo que el rechazo no establece es que una declaración que se mantiene sea verdadera. Nada puede demostrar que el plugin que sirve a un proveedor lea una clave que dice leer; lo que una comparación de dos campos escritos por el autor puede hacer es rechazar el par que no puede ser verdadero en ambos términos. Una clave declarada en un nivel que el proveedor sí renderiza, cuyo plugin no lee nada allí, pasa aquí.
Mensaje emitido:
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 (el proveedor declara una anotación well-known en un nivel, pero su contract.inputKinds no está reivindicado; declara la clave solo en un nivel que el proveedor renderice, o reivindica el tipo de entrada: wellKnownAnnotations: una clave está declarada en un nivel que el contrato del proveedor no renderiza)
Cómo corregirlo: el mensaje nombra ambas mitades. Elimina ese nivel de la lista scope: de la anotación, dejando los niveles que el proveedor sí renderiza, o reivindica el tipo de entrada bajo contract.inputKinds si el proveedor de hecho lo renderiza.
A compact-form schema uses a keyword the compact form does not know (Un esquema en forma compacta usa una palabra clave que la forma compacta no conoce)
Un esquema escrito en forma compacta contiene una clave que no es ni una palabra clave de la forma compacta, ni una de las palabras clave de JSON Schema que la forma deja pasar, ni uno de los tres marcadores que la forma reserva — $jsonschema:, $mode: y $ref:. Las claves desconocidas se rechazan al leer el esquema en lugar de descartarse, porque una restricción mal escrita que se ignora se convierte en ninguna restricción, y un esquema que parece aplicarse y no aplica nada es peor que uno que falla.
El rechazo aparece allí donde se compila un esquema. Las entradas de una SchemaLibrary se compilan al cargarse el catálogo; el spec.schema de un Component, sus valueSchema e infraSchema por socket, y los esquemas que declaran una Feature y un Plugin proveedor se compilan al leerse el catálogo. El spec.schema de un Component o de una Feature informa de esta condición por sí mismo, nombrando la entidad y el campo; el valueSchema o el infraSchema de un socket la informa dentro de «A declared schema contract cannot be read as a schema (Un contrato de esquema declarado no se puede leer como esquema)» más abajo, con la frase citada aquí como detalle.
La propia frase del compilador de la forma compacta nombra la posición dentro del esquema, la línea de origen y la clave que no reconoció:
Una clave escrita junto a un $ref: entre documentos se informa bajo la misma condición, con una frase propia, porque solo tres claves hermanas pueden acompañar a una referencia así:
compactform at <path-inside-the-schema>:<line> (keyword "<key>"): cross-document $ref sibling not allowed (allowed: properties, required, description) (compactform: clave hermana de un $ref entre documentos no permitida (permitidas: properties, required, description))
y, cuando esa clave hermana pedía reabrir la estructura combinada, la frase indica en cambio la manera de hacerlo:
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: clave hermana de un $ref entre documentos no permitida (permitidas: properties, required, description); usa $jsonschema: para incrustar un esquema de objeto abierto si la estructura combinada debe aceptar propiedades arbitrarias)
La condición bajo la que se registra es compactform: unknown keyword, que es aquello a lo que se resuelve su código corto.
Cómo corregirlo: corrige la clave en la posición que nombra la frase, conforme al vocabulario de palabras clave de compact-form-authoring.md — un error ortográfico es la causa más común. Cuando la estructura necesita realmente una palabra clave de JSON Schema que la forma compacta no incluye, escribe ese fragmento bajo $jsonschema:, que incrusta JSON Schema tal cual. Junto a una referencia entre documentos, conserva solo properties:, required: y description:; todo lo demás pertenece a la entrada de biblioteca a la que apunta la referencia.
A compact-form schema declares a field literally named type (Un esquema en forma compacta declara un campo que se llama literalmente así)
La forma compacta decide qué significa un mapeo a partir de la estructura de su contenido: una clave type: marca una hoja de restricción, las palabras clave estructurales de JSON Schema marcan un fragmento que se deja pasar, y un mapeo de nombres simples marca un objeto cuyos hijos son esquemas. Un esquema que declara un campo llamadotype es la única estructura que esas lecturas no pueden distinguir — parece una hoja de restricción y se quiere como un objeto con un solo campo —, así que la forma pide al autor que diga cuál, con una clave $mode: establecida en compact o jsonschema.
Esta condición es lo que informa un $mode: escrito con cualquier otro valor. El marcador existe para resolver la ambigüedad, así que un valor que no resuelve nada se rechaza en lugar de adivinarse.
La propia frase del compilador de la forma compacta:
compactform at <path-inside-the-schema>:<line> (keyword "$mode"): value must be compact or jsonschema (compactform: el valor debe ser uno de los dos indicados)
La condición bajo la que se registra es compactform: ambiguous dispatch — $mode required, que es aquello a lo que se resuelve su código corto.
Cómo corregirlo: establece $mode: compact cuando el mapeo es un objeto en forma compacta entre cuyos campos resulta haber uno llamado type, o $mode: jsonschema cuando el mapeo es un fragmento de JSON Schema que debe tomarse tal como está escrito. Cuando no se pretendía ninguna de las dos lecturas, renombrar el campo elimina la ambigüedad sin ningún marcador.
A $jsonschema: escape carries content that is not a schema (Un escape contiene un contenido que no es un esquema)
La clave $jsonschema: incrusta tal cual un fragmento de JSON Schema, para las estructuras que la forma compacta no expresa. Lo que incrusta se toma tal como está escrito y nunca se traduce, así que tiene que ser un esquema: un escalar de bloque que se analice como YAML, o un mapeo anidado. Un contenido que no es ninguna de las dos cosas se rechaza aquí en lugar de transmitirse para validar contra él, donde el fallo se informaría contra el consumidor del esquema en lugar de contra el esquema.
Cuatro estructuras se informan bajo esta condición, y la frase te dice cuál tienes. El cuerpo de escape no se analiza como YAML. El valor del escape no es ni un escalar de bloque ni un mapeo. Una clave properties: contiene algo que no es un mapeo de nombres a esquemas. Y, en el nivel más externo, el documento entregado al compilador está vacío o contiene un nodo para el que el lector no tiene ninguna regla.
Las propias frases del compilador de la forma compacta:
compactform at <path-inside-the-schema>:<line> (keyword "$jsonschema"): escape content does not parse as YAML: <what the parse reported> (compactform: el contenido del escape no se analiza como YAML) compactform at <path-inside-the-schema>:<line> (keyword "$jsonschema"): expected block-scalar string or nested mapping (compactform: se esperaba una cadena escalar de bloque o un mapeo anidado) compactform at <path-inside-the-schema>:<line> (keyword "properties"): expected a mapping of property names to schemas (compactform: se esperaba un mapeo de nombres de propiedades a esquemas) compactform: unsupported YAML node kind (compactform: tipo de nodo YAML no admitido)
La condición bajo la que se registra es compactform: $jsonschema content invalid, que es aquello a lo que se resuelve su código corto.
Cómo corregirlo: escribe el cuerpo de escape como escalar de bloque bajo $jsonschema: — de lo contrario, un cuerpo cuya primera línea se lee como una clave YAML queda absorbido en el mapeo circundante, que es la causa habitual — y comprueba que lo que contiene es JSON Schema válido por sí mismo. Cuando el fragmento era lo bastante pequeño como para expresarse en forma compacta, quitar el escape es la respuesta más sencilla.
A compact-form constraint does not apply to the type it was written on (Una restricción en forma compacta no se aplica al tipo sobre el que se escribió)
Las restricciones en forma compacta se despachan según el tipo declarado del campo: min: y max: se convierten en un límite numérico sobre un número, un límite de longitud sobre una cadena y un límite de cantidad sobre un array. Así que una restricción tiene que estar en un campo cuyo tipo la acepte, y el tipo tiene que ser un único valor para que el despacho tenga siquiera una respuesta.
Cuatro estructuras se informan bajo esta condición. Una restricción escrita donde type: falta o nombra una unión, de modo que nada decide qué límite se pretendía. Una restricción escrita sobre un tipo que no admite ningún límite de esa clase — un objeto, o un booleano. Un type: cuyo valor no es ni un nombre escalar ni una secuencia de nombres. Y un valuesType: al que se le da algo distinto de un nombre escalar.
Las propias frases del compilador de la forma compacta:
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 restricción se aplica a un único tipo declarado (integer/number/string/array); el tipo no está resuelto (unión o ausente) — restringe el tipo a un único valor o elimina esta restricción) 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 restricción se aplica a integer/number/string/array; el tipo declarado es el indicado) 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: se esperaba un nombre de tipo escalar o una secuencia de nombres de tipo (array de tipos de JSON Schema 2020-12); se obtuvo un tipo de nodo no admitido) compactform at <path-inside-the-schema>:<line> (keyword "valuesType"): expected a scalar type name (compactform: se esperaba un nombre de tipo escalar)
La condición bajo la que se registra es compactform: constraint not valid for declared type, que es aquello a lo que se resuelve su código corto.
Cómo corregirlo: la frase nombra ambas mitades — la restricción y el tipo con el que se encontró. Restringe type: a un único nombre cuando contiene una unión, añádelo cuando falta, o elimina la restricción cuando el campo admite realmente cualquiera de varios tipos. Un límite que tiene que variar con el tipo se expresa como un conjunto de alternativas bajo $jsonschema:, donde cada rama lleva su propio tipo y su propio límite.
A $ref: is not written in a form the compiler can resolve (Una referencia no está escrita en una forma que el compilador pueda resolver)
Un esquema hace referencia a otra estructura con $ref:, ya sea dentro del mismo documento o entre documentos hacia una entrada de una SchemaLibrary. Dos condiciones cubren las dos maneras en que una referencia falla, y la frase te dice cuál tienes: la referencia no está escrita en una forma que el compilador lea, o está bien formada y nombra un destino que no existe.
La referencia no es legible. El valor está vacío, o su forma entre documentos no es <Library>#/schemas/<Entry>, o separa la versión con @ — lo cual se informa con la grafía corregida en lugar de con una queja genérica, porque es el error que esta forma provoca con más frecuencia:
compactform at <path-inside-the-schema>:<line> (keyword "$ref"): expected a non-empty reference URL (compactform: se esperaba una URL de referencia no vacía) compactform at <consumer-document> (keyword "$ref"): cross-document $ref shape must be <LibraryName>#/schemas/<EntryName>: <the value as written> (compactform: un $ref entre documentos debe tener la forma indicada) compactform at <consumer-document> (keyword "$ref"): cross-document $ref version separator is ’:’, not ’@’ — use <the corrected value>: <the value as written> (compactform: el separador de versión de un $ref entre documentos es ’:’, no ’@’ — usa el valor corregido)
La condición bajo la que se registran es compactform: $ref unresolvable.
El destino no existe. La referencia se lee correctamente y la biblioteca, o la entrada dentro de ella, está ausente — o no se proporcionó ningún catálogo de bibliotecas contra el que resolverla:
compactform at <consumer-document> (keyword "$ref"): SchemaLibrary <library> not found in catalog (referenced from <consumer-document>): <the value as written> (compactform: SchemaLibrary no encontrada en el catálogo) compactform at <consumer-document> (keyword "$ref"): entry <entry> not found in SchemaLibrary <library>: <the value as written> (compactform: entrada no encontrada en 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 entre documentos, pero no se proporcionó ningún catálogo de SchemaLibrary)
La condición bajo la que se registran es compactform: cross-document $ref target not found.
Mantener los dos separados es lo que hace que el informe sea accionable: el primero es un valor que hay que reescribir en el documento que estás mirando, y el segundo es una pregunta sobre lo que la compilación puede ver. Una referencia que se expande en sí misma es otra cosa más, y se informa como «A library reference expands into itself (Una referencia a una biblioteca se expande en sí misma)» más arriba.
Cómo corregirlo: para una referencia ilegible, reescribe el valor — <Library>#/schemas/<Entry> para una referencia entre documentos, #/$defs/<name> para una dentro del mismo documento — y usa : antes de una versión mínima en lugar de @. Para un destino ausente, confirma el nombre de la entrada con la biblioteca que la publica, y confirma que la biblioteca es alcanzable desde el cierre de dependencias de la Release: una biblioteca de la que nada declara depender no se carga, así que una referencia correcta a ella sigue sin resolverse en nada.
Cuando la biblioteca solo está en la caché de artefactos. La caché contiene lo que una descarga dejó allí, y una biblioteca en caché cuenta como contenido del catálogo solo donde una entrada del archivo de bloqueo de la Release respalda su digest. Cuando la caché contiene una SchemaLibrary que ninguna entrada del archivo de bloqueo fija y que ningún directorio de catálogo proporciona, el informe va seguido de una línea remediation: que nombra cada una de esas bibliotecas y la acción que funciona para el comando que lo informó:
aggrega build y aggrega validate --release leen el archivo de bloqueo de la Release, así que su línea nombra aggrega pull --release <release>, que resuelve la biblioteca y registra su entrada, o la escritura de la biblioteca bajo un directorio de catálogo.
aggrega validate sin argumentos, y aggrega validate con la ruta de una entidad, se indique o no --release, leen las bibliotecas solo de los directorios de catálogo y no leen ningún archivo de bloqueo, así que una entrada registrada no cambiaría su veredicto. Su línea lo dice, y remite a la escritura de la biblioteca bajo un directorio de catálogo, o a aggrega pull --release <release> seguido de aggrega validate --release <release>, que comprueba la Release frente a las bibliotecas que fija su archivo de bloqueo.
A $ref: addresses a library by registry location (Una referencia direcciona una biblioteca por su ubicación en un registro)
Un $ref: entre documentos nombra su biblioteca por identidad — el nombre simple de la biblioteca, luego # y la ruta de la entrada — y nunca por el registro en el que resulte estar publicada. A través de qué registro se resuelve un nombre es configuración del espacio de trabajo, y qué versión se usa es la respuesta del archivo de bloqueo, así que una referencia que lleve un host fijaría en el esquema dos cosas que corresponde decidir a la compilación, y movería el esquema entre espacios de trabajo como una referencia rota.
Donde el valor que lleva el host aún se descompone en una biblioteca y una entrada, la frase incluye la grafía en forma de identidad que se debe usar en su lugar:
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: el $ref entre documentos lleva un host de registro; haz referencia a la biblioteca por identidad)
y donde no, la frase termina después del valor:
compactform at <consumer-document> (keyword "$ref"): cross-document $ref carries a registry host; reference the library by identity: <the value as written> (compactform: el $ref entre documentos lleva un host de registro; haz referencia a la biblioteca por identidad)
La condición bajo la que se registra es compactform: cross-document $ref carries a registry host; reference the library by identity, que es aquello en lo que se resuelve su código corto.
Cómo corregirlo: elimina el host y todo lo que precede al nombre de la biblioteca, dejando <Library>#/schemas/<Entry>. Donde se quiera una versión mínima, escríbela después del nombre de la biblioteca como :<version>. La misma regla rige los campos $import: de una Recipe y de una FeatureRecipe, que se informan por separado en «A library $import: addresses its library by registry location (Una importación de biblioteca direcciona su biblioteca por su ubicación en un registro)» más abajo.
A schema $import: cannot be applied (No se puede aplicar una importación de esquema)
El spec.schema de un Component o de una Feature — su bloque entero o uno de sus pilares — y el valueSchema: o el infraSchema: de un socket usesSchema pueden escribirse cada uno como un $import: que nombra un archivo junto a la entidad. La importación se aplica cuando se carga la entidad, así que todo lector posterior ve el contrato importado en lugar del puntero. Esta condición es lo que ocurre cuando la culpa es de algo que escribiste: la directiva misma, o la estructura de lo que resultó contener el archivo que nombra.
Esos fallos son una sola condición porque cada uno deja inutilizable la misma superficie y te da lo mismo que hacer — corregir la directiva, o el archivo que nombra. El diagnóstico empieza con la frase fija y luego dice qué fallo es, así que la frase es la parte con la que hacer coincidencia y la cláusula que la sigue es aquello sobre lo que actuar:
a schema $import: could not be applied. <surface>: <the clause for this occurrence> (no se pudo aplicar una importación de esquema)
La cláusula nombra la superficie que leyó — spec.schema, uno de sus pilares como spec.schema.values, o el valueSchema de un socket — seguida del fallo concreto. Los fallos, y lo que significa cada uno:
$import: must be the only key when a schema is imported from a file. (La importación debe ser la única clave cuando un esquema se importa desde un archivo.) La directiva comparte su mapeo con contenido de esquema escrito por el autor. $import: sustituye un valor entero, así que una clave hermana no tiene nada con lo que combinarse.
$import: value must be a path to a file. (El valor de la importación debe ser la ruta de un archivo.) El valor está vacío, o no es una única cadena.
$import: takes a file path beside this entity, not a registry location <value>. (La importación toma la ruta de un archivo junto a esta entidad, no una ubicación de registro.) El valor direcciona un registro. A través de qué registro se resuelve un nombre es configuración del espacio de trabajo, así que una superficie de esquema nunca lleva uno; el mensaje nombra en su lugar la forma de referencia que se debe usar.
$import: takes a file path beside this entity; reference the SchemaLibrary entry <value> with $ref: instead. (La importación toma la ruta de un archivo junto a esta entidad; haz referencia en su lugar a la entrada de la SchemaLibrary.) El valor direcciona una entrada de biblioteca. A una entrada de biblioteca se hace referencia, no se importa — $ref: es la palabra clave que la resuelve.
imported schema <value> must be a YAML map of schema content; it is not. (el esquema importado debe ser un mapa YAML de contenido de esquema; no lo es.) El archivo se encontró, se leyó y se analizó, y lo que produjo es un escalar o una secuencia, así que no hay contenido de esquema que sustituir.
La cabecera lleva la categoría y el código corto de esta condición, E0266, que es el identificador que hay que registrar cuando necesites nombrar esta detención de forma duradera — en un control de integración continua, una incidencia o un runbook. Un número se asigna una vez y luego queda fijo, así que sigue siendo el mismo por mucho que mejore la redacción a su alrededor; la tabla de todas las condiciones lo resuelve.
Una directiva bien formada que nombra un archivo que la compilación no puede obtener se informa en otro lugar, con un código distinto. Una ruta que no se resuelve, un archivo que no existe o no se puede leer, y bytes que no se analizan como YAML no son fallos en lo que escribiste — no hay ningún documento importado que juzgar — así que se informan como la carga que son, en «A file cannot be read, or its bytes do not parse (No se puede leer un archivo, o sus bytes no se pueden analizar)» más arriba, que documenta la cláusula que lleva cada uno de ellos. Haz coincidencia con esa condición, y registra su código, cuando lo que estás capturando es un archivo de importación ausente o ilegible.
Una ruta se resuelve respecto al directorio que contiene el archivo de la entidad, la misma base que usa cualquier otro campo que lleve una importación. Una importación cuyo contenido declara a su vez un $import: se sigue, y una cadena que vuelve a un archivo que ya se está procesando se informa como «A library reference expands into itself (Una referencia a una biblioteca se expande en sí misma)» más arriba en lugar de aquí. Una directiva escrita dentro de un archivo que trajo una importación se informa en ese archivo y en la línea correspondiente, porque es allí donde va la corrección; una directiva escrita en la entidad se informa en la entidad.
Cómo corregirlo: haz que $import: sea la única clave de su mapeo, y dale una ruta relativa a un archivo YAML junto a la entidad cuyo nivel superior sea un mapa de contenido de esquema. Para consumir una estructura que publica una SchemaLibrary, usa en su lugar $ref: <Library>#/schemas/<Entry> — a una entrada de biblioteca se hace referencia en lugar de importarla.
A schema block names a key that is not a data pillar (Un bloque de esquema nombra una clave que no es un pilar de datos)
El bloque spec.schema de un Component o de una Feature lleva los pilares de datos de la entidad, y tres claves son todo lo que admite: values, la estructura que el desarrollador rellena por instancia; infra, el dimensionamiento físico que proporciona el operador; y provides, las claves que la entidad expone a quien la consuma. Esta condición es lo que ocurre cuando el bloque lleva alguna otra clave en su nivel superior.
El conjunto es cerrado en lugar de abierto, por la misma razón por la que el contenido de cada pilar se valida de forma cerrada: un bloque que enumera una superficie legal convierte en error todo lo que queda fuera de esa superficie. Una clave que nada reconoce llevaría un contrato que nada compila nunca, contra el que nada valida y que nada entrega a un consumidor — así que lo que escribiste debajo de ella parecería declarado y sería inerte. Eso es más difícil de notar que un contrato que nunca escribiste, y por eso se rechaza el bloque en lugar de ignorar la clave extraviada.
El diagnóstico empieza con la frase fija, luego nombra la entidad, la regla, el sitio donde se escribió la clave y qué escribir en su lugar:
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 bloque de esquema declara una clave que no nombra ningún pilar de datos, regla schema-pillars; renombra la clave a una de las claves de pilar, o elimínala junto con el contrato que hay debajo; permitidas: values, infra, provides. Consulta vocabulary/data-pillars.md para el conjunto canónico de pilares.)
La cabecera lleva la categoría y el código corto de esta condición, E0267, que es el identificador que hay que registrar cuando necesites nombrar esta detención de forma duradera — en un control de integración continua, una incidencia o un runbook. Un número se asigna una vez y luego queda fijo, así que sigue siendo el mismo por mucho que mejore la redacción a su alrededor; la tabla de todas las condiciones lo resuelve.
Dos cosas escritas en esa posición no son claves de este conjunto, y ninguna se informa aquí. Un $import: que nombra un archivo junto a la entidad se sustituye por el contenido de ese archivo antes de leer el bloque, así que lo que inspecciona esta condición es el nivel superior del propio documento importado — una clave extraviada dentro del archivo importado se informa aquí, y la directiva misma nunca. Y un Component que declara extends escribe la cadena simple inherited en lugar del bloque, que es un escalar sin ninguna clave.
Cómo corregirlo: la frase nombra la clave que encontró y las tres que admite, así que la causa más común — una errata, o un singular donde el nombre del pilar es plural — se ve solo con el diagnóstico. Donde el contenido bajo la clave extraviada pertenece a un pilar, muévelo bajo values:, infra: o provides: según dicte su pertenencia; data-pillars.md indica qué pilar posee qué. Donde se pretendía como contenido de esquema por derecho propio, va un nivel más abajo, dentro de un pilar, en lugar de junto a los pilares. A una estructura publicada por una SchemaLibrary se llega con $ref: <Library>#/schemas/<Entry> escrito dentro de un pilar, no a nivel del bloque.
A plugin asks the host to parse a source while a parse is already running for it (Un plugin pide al host que analice una fuente mientras ya hay un análisis en curso para él)
Un plugin puede pedir al host que analice una fuente y le devuelva el resultado, de modo que un plugin que necesita un documento en algún formato no tenga que incluir un lector para él. El host ejecuta el plugin que produce el análisis y devuelve lo que este produjo. Esta condición es lo que ocurre cuando el plugin al que se llegó de ese modo pide a su vez un análisis: la solicitud volvería a entrar en el mismo mecanismo dentro del cual ya se está ejecutando, y el host la rechaza en lugar de descender un nivel. Un nivel de esto es lo que ofrece el mecanismo, y el rechazo es lo que lo mantiene en uno.
La denegación llega al plugin, no a la compilación. El host no se detiene ahí ni deshace la pila; responde a la llamada con un sobre de error que lleva la frase de abajo y un código que identifica el rechazo, y el plugin que lo pidió lo recibe como respuesta a su solicitud. Lo que hace después la compilación depende de lo que ese plugin haga con la respuesta — un plugin que la trata como fatal termina la compilación, uno que la informa y continúa, no. El rechazo en sí es el mismo en ambos casos.
No es culpa de ninguno de los dos plugins en particular: la protección cubre cualquier par de plugins por el que se haya encaminado la solicitud, en lugar de un emparejamiento concreto, de modo que el mismo rechazo aparece dondequiera que se vuelva a entrar en el mecanismo.
Mensaje emitido, tal como lo recibe el plugin:
aggrega_parse_source: producer-consumption re-entry denied: a producer reached through the host may not issue a further producer-consumption call (reentrada en el consumo de productor denegada: un productor alcanzado a través del host no puede emitir otra llamada de consumo de productor)
Cómo corregirlo: nada en tus propios archivos causa esto y ningún cambio en lo que escribes lo resuelve — es una propiedad de los plugins con los que está configurada la compilación. El plugin que hay que corregir es el que pide un análisis desde dentro de un análisis, así que informa de la condición a quien lo publica, citando el mensaje. Si ese plugin es tuyo, haz que lea directamente la fuente que se le entregó en lugar de pedir al host que analice otra mientras él mismo está atendiendo un análisis.
The workspace configuration is invalid (La configuración del espacio de trabajo no es válida)
Un espacio de trabajo se describe mediante un .aggrega-config.yaml en su raíz: en qué registro publica y de cuál descarga, dónde reside la caché de artefactos, qué plugins están vinculados a qué sockets y cuál es la postura de firma de cada registro. Ese archivo se lee y se comprueba contra su esquema antes de abrir cualquier archivo de entidad, porque todo lo que sigue se lee de él.
Un archivo ausente no es un fallo. Un espacio de trabajo sin archivo de configuración recibe los valores predeterminados documentados, así que esta detención nunca nombra un archivo que no existe. Nombra el archivo que contenía el valor — o, para un ajuste que una variable de entorno sobrescribe y que el esquema nunca ve, la variable.
La comprobación se ejecuta antes de que el documento se convierta en ajustes tipados. Ese orden es lo que permite que el mensaje nombre la ruta del campo que el esquema objetó, en lugar de informar de una discrepancia de tipo desde algún punto posterior sin ningún campo al que señalar.
Estas estructuras se informan aquí más allá de una simple objeción del esquema, cada una porque el esquema, por sí mismo, únicamente puede decir algo demasiado genérico para actuar: una clave workspace: escrita sin nada debajo, una clave cuyo lugar es el nivel superior escrita en cambio debajo de workspace:, un bloque cache: escrito con un nombre que el archivo no usa, un host de registro que no está escrito como se escribe un host de registro, y tres ajustes cuyos valores el esquema admite pero que el espacio de trabajo no puede usar — un artifact_cache_dir que es absoluto o que nombra la propia raíz del espacio de trabajo, una entrada de signing.kinds que nombra algo que no es un tipo de artefacto publicable, y una entrada de plugins.providers o providers_append cuyo uri es una ubicación de registro escrita con oci://. Un enlace de proveedor nombra su plugin por su identidad, provider/<name> con un :<version> opcional, porque esa identidad es con lo que se compara el enlace cuando se resuelve una capacidad; una ubicación de registro dice dónde se publica un plugin, no qué plugin es, así que una entrada escrita así nunca podría seleccionar nada. Una entrada que nombra una función de entrada con function: y ningún uri: también se informa aquí, cuando es una entrada de plugins.linter o linter_append o una entrada de plugins.governance o governance_append en un rol de veredicto, ir-verdict o render-verdict: esas vinculaciones seleccionan su plugin por uri, así que una entrada así no vincula ningún plugin y la función que nombra nunca se llamaría — un lint seguiría ejecutándose como si la entrada no estuviera, y una compilación solo se detendría más tarde, al tener que resolver un plugin que la entrada nunca nombró.
Un directorio de catálogo que la configuración enumera — en workspace.catalog_dirs o catalog_dirs_append, o en la entrada propia de una Release en workspace.releases, en cualquier archivo del que se lea la configuración — también se informa aquí cuando no es un directorio: no existe nada en la ruta, o hay ahí un archivo o un enlace que no lleva a ninguna parte. Se evalúa cuando un catálogo está a punto de leerse a través de él, de modo que todo comando que lee el catálogo lo rechaza antes de leer o escribir nada, mientras que un comando que no lee ningún catálogo sigue ejecutándose. Seguir leyendo sin él compilaría con menos catálogos de los que enumeraste, sin nada que diga cuáles. Un directorio que enumera AGGREGA_CATALOG_DIRS se somete a la misma regla, y el rechazo nombra la variable en lugar de un archivo.
Un host de registro — el host de una entrada de registries, o el host con el que empieza default_registry cuando no nombra una de esas entradas por su name:, en cuyo caso representa el host de esa entrada — se escribe como el propio host: en minúsculas, conteniendo un punto, o localhost, o un único nombre seguido de un puerto, o una dirección IP (una IPv6 entre corchetes), cada uno con un :port opcional, y sin esquema ni credenciales. El host de una entrada de registries no lleva ruta; default_registry puede añadir tras su host / y una ruta de repositorio — segmentos en minúsculas unidos por /, sin etiqueta, digest ni / final. Un valor que nombra un host con otra grafía se rechaza indicando la grafía que hay que escribir — para default_registry, la ubicación completa, ruta incluida — para que se le aplique la política de confianza guardada bajo ese host; eso incluye el puerto 443 en un host al que se accede por HTTPS, ya que es el puerto predeterminado de ese host. Una ruta que no es una ruta de repositorio se rechaza nombrando el host al que sigue, y el name: de una entrada seguido de una ruta se rechaza nombrando las dos grafías que se deben escribir en su lugar, el nombre solo o el host de la entrada seguido de la ruta, ya que un nombre representa el host de su entrada y no una ubicación bajo él. Un valor que no nombra ningún host — un único nombre sin puerto que ninguna entrada lleva, un texto con espacios o llaves — se rechaza por no ser un host, y para default_registry el rechazo dice que el nombre de una entrada también serviría. AGGREGA_DEFAULT_REGISTRY se somete a la misma lectura y se rechaza de la misma manera, nombrando la variable.
Mensajes emitidos. Una objeción del esquema nombra el archivo, la ruta del campo y lo que dijo el esquema:
workspaceconfig: <path>: <field-path>: <the schema's own objection>: workspace configuration is invalid (la configuración del espacio de trabajo no es válida)
Las formas con corrección empiezan con el archivo y, en lugar de la ruta del campo y la objeción del esquema, dicen una frase sobre la estructura concreta. Un artifact_cache_dir que nombra la raíz del espacio de trabajo:
<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 nombra la propia raíz del espacio de trabajo; un directorio de catálogo en la raíz del espacio de trabajo se omitiría entonces como caché, sin dejar nada que cargar — da a la caché su propio subdirectorio: la configuración del espacio de trabajo no es válida)
una entrada de signing.kinds inutilizable, que también nombra el comodín que cubre todos los tipos:
<path>: signing.kinds entry "<kind>" is not a signable artifact kind; use a catalog entity or plugin kind, or "all" for every kind: workspace configuration is invalid (la entrada de signing.kinds no es un tipo de artefacto firmable; usa un tipo de entidad de catálogo o de plugin, o el comodín para todos los tipos: la configuración del espacio de trabajo no es válida)
un enlace de proveedor escrito como ubicación de registro, que nombra la entrada, la capacidad y la forma que hay que escribir:
<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 enlaza la capacidad a una ubicación, que indica dónde se publica un plugin y no qué plugin es; un enlace de proveedor nombra su plugin por su identidad — escribe uri con la identidad del proveedor, con una versión opcional: la configuración del espacio de trabajo no es válida)
una vinculación de linter o de gobernanza en rol de veredicto que nombra una función de entrada y ningún plugin, cuyo mensaje nombra la lista, la entrada y la función, aquí en 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 nombra la función de entrada pero ningún uri de plugin; una vinculación de esta lista selecciona su plugin por uri, así que esta no vincula ningún plugin y la función nunca se llama — añade el uri del plugin que la exporta: la configuración del espacio de trabajo no es válida)
un host de registro escrito con otra grafía, aquí 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 no está escrito como el host de registro que nombra; escríbelo — en minúsculas, sin esquema, ruta, credenciales ni puerto predeterminado — que es la grafía bajo la que se guarda la política de confianza de ese host: la configuración del espacio de trabajo no es válida)
un registro predeterminado cuyo host está escrito con otra grafía antes de su ruta de repositorio, aquí GHCR.io/acme, cuyo mensaje nombra la ubicación completa que hay que escribir:
<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 no está escrito como la ubicación de registro que nombra; escríbela — el host del registro en minúsculas, sin esquema, credenciales ni puerto predeterminado, seguido de la ruta de repositorio — lo que mantiene aplicada la política de confianza de ese host: la configuración del espacio de trabajo no es válida)
el nombre de una entrada seguido de una ruta, aquí local/acme donde la entrada llamada local corresponde a 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 es el nombre de la entrada de registries seguido de una ruta, y el nombre de una entrada representa solo el host de esa entrada; escribe solo el nombre para usar la entrada, o su host seguido de la ruta: la configuración del espacio de trabajo no es válida)
un valor que no nombra ningún host, cuya frase enumera las formas que adopta un host:
<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 (el host de la entrada de registries no es un host de registro; escribe un nombre de host en minúsculas que contenga un punto (registry.example.com), localhost, un único nombre seguido de un puerto (registry:5000), o una dirección IP, una IPv6 entre corchetes — cada uno con un :port opcional y nada más: la configuración del espacio de trabajo no es válida)
un directorio de catálogo enumerado donde no existe nada, cuyo mensaje nombra el archivo y la línea, la lista, la entrada tal como está escrita y la ruta a la que se resolvió — la lista es workspace.catalog_dirs, workspace.catalog_dirs_append, o la lista de una entrada de Release como `catalog_dirs` of the `workspace.releases` entry "release.yaml":
<path>:<line>: the `workspace.catalog_dirs` entry "<entry>" names <directory>, which does not exist; create that directory, or remove the entry: workspace configuration is invalid (la entrada de workspace.catalog_dirs nombra un directorio que no existe; crea ese directorio o elimina la entrada: la configuración del espacio de trabajo no es válida)
y un marcador workspace: vacío:
workspaceconfig: <path>: workspace must be a mapping; write workspace: {} to mark a workspace root with no catalog directories: workspace configuration is invalid (workspace debe ser un mapeo; escribe un mapeo vacío para marcar una raíz de espacio de trabajo sin directorios de catálogo: la configuración del espacio de trabajo no es válida)
Otros dos nombran una clave escrita en el lugar equivocado — default_registry, offline, auto_pull y artifact_cache_dir están todas en el nivel superior y no debajo de workspace:, y el bloque de la caché de análisis es parse_cache:. Cada uno dice a qué clave se refiere y dónde va esa clave.
Cómo corregirlo: abre el archivo que nombra el mensaje y ve a la ruta del campo que cita. Cuando el mensaje lleva una frase de corrección, nombra directamente la grafía o la ubicación correctas y no hace falta leer nada más. Cuando en cambio lleva una objeción del esquema, la ruta del campo es la clave errónea y la objeción dice qué esperaba ahí el esquema — las páginas de entidades no rigen este archivo, así que lee la objeción en lugar de buscar un contrato de entidad. Un artifact_cache_dir se escribe relativo a la raíz del espacio de trabajo y necesita un subdirectorio propio, para que un directorio de catálogo en la raíz del espacio de trabajo no se confunda con caché y se omita. Un enlace de proveedor escrito como ubicación de registro se reescribe a mano con la identidad del plugin — oci://hub.aggrega.ai/plugin/provider/compose pasa a ser provider/compose — porque todo comando que lee el archivo lo rechaza hasta que se hace, aggrega plugin remove incluido; aggrega plugin add provider escribe por sí mismo la forma con identidad. Una entrada de linter o de gobernanza en rol de veredicto que nombra una función y ningún plugin recibe el uri del plugin que exporta esa función; si ninguno la exporta, elimina la entrada — en la lista de linters, el linter estándar se ejecuta entonces como lo hace cuando no hay ningún linter configurado. Un directorio de catálogo enumerado que no es un directorio se crea en la ruta que nombra el rechazo, o su entrada se elimina de la línea que nombra el rechazo; una copia de un proyecto hecha sin un checkout hermano que este enumera elimina esa entrada.
A plugin binding sets a key the socket it attaches to does not read (Un enlace de plugin establece una clave que el socket al que se vincula no lee)
Los sockets de la configuración del espacio de trabajo vinculan plugins de dos maneras distintas, y una clave que pertenece a una de ellas no significa nada en la otra. En lugar de aceptar la clave e ignorarla en silencio, la configuración se rechaza, de modo que un operador sabe que el ajuste es inerte en vez de preguntarse más tarde por qué no tuvo efecto.
Las dos discrepancias son una el reflejo de la otra.
Un socket transversal enlazado por capacidad. Los sockets de gobernanza, de linter y de importador vinculan un plugin directamente mediante uri:. Un plugin de gobernanza o de linter no sirve ninguna capacidad, así que un enlace capability: ahí se buscaría contra nada y no coincidiría con nada — una vinculación que nunca puede resolverse. Un importador sí anuncia los formatos que maneja, pero qué formato se quiere lo dice la importación, no la vinculación: una vinculación de importador nombra su importador mediante uri:, y eso es lo que lo elige entre los importadores que anuncian el formato que pide una importación.
Un socket de proveedor que establece una clave sin referente. Un enlace de proveedor nombra una capacidad y el plugin que la sirve, y el plugin maneja un conjunto fijo de exportaciones en lugar de una única entrada seleccionable, así que function: no nombra nada en él. with: se rechaza por otro motivo: la configuración de renderizado de un proveedor se escribe en la Recipe, así que ponerla en el enlace del espacio de trabajo la coloca en el lado equivocado de la separación entre desarrollador y operador.
Mensajes emitidos. Una capacidad en 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 (el socket está enlazado por capacidad, pero los sockets transversales se vinculan por uri: su plugin no sirve ninguna capacidad, así que una búsqueda por capacidad no coincide con nada; vincúlalo mediante uri en su lugar: un socket transversal está enlazado por capacidad pero se vincula por uri)
un function: inerte en un enlace de proveedor:
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 (el enlace del socket de proveedor para la capacidad establece este campo, pero un proveedor maneja un conjunto fijo de exportaciones asociadas a fases en lugar de una única entrada seleccionable, así que el campo no nombra nada ahí; elimínalo: un enlace de socket de proveedor establece un campo sin referente en ese socket)
y un with: inerte, que se informa con la misma estructura e indica en cambio dónde va la configuración:
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 (el enlace del socket de proveedor para la capacidad establece este campo, pero la configuración de renderizado del proveedor va en la Recipe, no en el enlace de proveedor del espacio de trabajo; elimínalo: un enlace de socket de proveedor establece un campo sin referente en ese socket)
Un function: escrito en .aggrega-config.yaml no llega a su frase de arriba: el esquema de la configuración del espacio de trabajo no declara esa clave en un enlace de proveedor, así que el archivo se rechaza antes, con E0224, y el remedio es el mismo — eliminar la clave:
workspaceconfig: <file>: plugins.providers[<index>].function: against /$defs/FixedEntryPluginRef: unexpected property: “function”: workspace configuration is invalid (plugins.providers[].function: frente a /$defs/FixedEntryPluginRef: propiedad inesperada: “function”: la configuración del espacio de trabajo no es válida)
Cómo corregirlo: la corrección está en .aggrega-config.yaml y cada mensaje nombra la edición exacta. En una vinculación de gobernanza, de linter o de importador, sustituye el capability: por el uri: del plugin que querías vincular. En un enlace de proveedor, elimina la clave nombrada — y, si era with:, mueve esa configuración a la Recipe que renderiza a través del proveedor, que es la superficie que la lee.
A capability is bound to more than one provider plugin (Una capacidad está enlazada a más de un plugin proveedor)
Una capacidad nombra una forma de convertir una carga de trabajo en artefactos, y exactamente un plugin la sirve en un espacio de trabajo resuelto. Dos enlaces para una misma capacidad no dejan respuesta a cuál de ellos renderiza, y una configuración del espacio de trabajo se ensambla a partir de varias capas — un archivo compartido, un archivo del espacio de trabajo y los archivos complementarios de anexado que cada uno puede aportar —, así que el segundo enlace lo aporta a menudo una capa cuyo autor no podía ver el primero.
El rechazo es lo que lo hace visible. Dejar que un enlace gane en silencio haría que la salida renderizada dependiera de qué capa se leyó por casualidad en último lugar.
Mensaje emitido, que nombra la capacidad y la regla:
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 capacidad está enlazada a más de un plugin proveedor; mantén exactamente una entrada plugins.providers por capacidad: la capacidad está enlazada a más de un plugin proveedor)
Cómo corregirlo: mantén una sola entrada plugins.providers para la capacidad que nombra el mensaje y elimina la otra. Si las dos proceden de capas de configuración distintas, la capa que hay que editar es la que controlas — eliminar tu propia entrada adopta la que aporta la capa compartida, y mantener la tuya significa que es la entrada de la capa compartida la que tiene que desaparecer. Dos plugins que de verdad sirven ambos al espacio de trabajo sirven dos capacidades distintas, así que, si quieres ambos, da a cada uno su propia capacidad en lugar de enlazar una dos veces.
An importer is attached by more than one plugins.importer entry (Un importador está vinculado por más de una entrada)
Una entrada plugins.importer vincula el importador que nombra su uri: donde ese importador anuncia el formato que pide una importación, la entrada decide qué versión de él se ejecuta y le entrega los with.sources y with.settings de la entrada. Una entrada hace eso para un importador, así que una segunda entrada que nombrara el mismo importador — la misma identidad, en la misma versión o en otra — no sería leída por nada, y su with no llegaría a ningún importador sin que se dijera una palabra. En cambio, la configuración se rechaza al cargarse, sea cual sea el comando que la lea.
Una configuración del espacio de trabajo se ensambla a partir de varios archivos — el archivo global, cada .aggrega-config.yaml desde la raíz del proyecto hasta el directorio en el que se ejecuta un comando, el archivo complementario importer_append que cada uno puede llevar y el .aggrega-config-append-ci.yaml de un pipeline —, así que la segunda entrada suele estar escrita en un archivo distinto del de la primera. El mensaje nombra el importador y ambas entradas, la anterior primero, cada una por la clave y la posición bajo las que está escrita, el archivo en el que se escribió y su uri tal como está escrito allí.
Solo se evalúa la lista de importadores: las listas de gobernanza y de linter aceptan un plugin vinculado más de una vez, y cada vinculación lleva su propio with. Una entrada cuyo uri es una ruta del sistema de archivos no nombra ningún importador, así que no se compara.
Mensaje emitido:
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 (el importador está vinculado por una entrada en un archivo y de nuevo por una entrada en un archivo; mantén exactamente una entrada plugins.importer por importador, con su uri nombrando la versión que quieres: el importador está vinculado por más de una entrada plugins.importer)
Cómo corregirlo: mantén una sola entrada para el importador que nombra el mensaje — aquella cuyo uri nombra la versión que quieres y que lleva el with que quieres entregar a ese importador — y elimina la otra. Si las dos están en archivos distintos, el archivo que hay que editar es el que controlas: eliminar tu entrada adopta la del otro archivo, y mantener la tuya significa que es la entrada del otro archivo la que tiene que desaparecer.
A provider binding names a capability containing a colon (Un enlace de proveedor nombra una capacidad que contiene dos puntos)
El capability: de una Recipe se lee como el nombre de la capacidad hasta sus últimos dos puntos y una fijación de versión después de ellos — helm:1.0.0 pide la capacidad helm en la versión 1.0.0. Una entrada plugins.providers se busca por ese nombre, así que la capacidad que nombra un enlace nunca lleva dos puntos, y una entrada cuya capacidad los lleve es una que ninguna Recipe puede alcanzar nunca. En lugar de dejarla en la configuración sin leer, la configuración se rechaza al cargarse, sea cual sea el comando que la haya leído.
Solo se evalúa la lista de proveedores. La lista de importadores comparte la estructura de las entradas, pero sus plugins se vinculan mediante uri: y nombran sus formatos import:<format>, donde los dos puntos forman parte del nombre. El uri: de un enlace puede terminar aun así en :<version>; no es la parte que lee esta regla.
Mensaje emitido, que nombra la capacidad:
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 (el enlace del socket de proveedor para la capacidad: la referencia a la capacidad de una Recipe se lee como la capacidad hasta sus últimos dos puntos y una fijación de versión después de ellos, así que la capacidad que nombra un enlace no lleva dos puntos; enlaza solo el nombre de la capacidad y deja que cada Recipe fije la versión que necesita: un enlace de socket de proveedor nombra una capacidad que contiene dos puntos, que ninguna Recipe puede seleccionar)
Cómo corregirlo: escribe solo el nombre de la capacidad en la entrada — capability: helm — y fija las versiones donde corresponde: una Recipe fija la versión del proveedor que necesita en su propio capability:, y un enlace que deba seleccionar una versión concreta de su plugin la escribe en la identidad del plugin, uri: provider/helm:1.0.0.
A governance attachment declares no role, or one that is not a known role (Una vinculación de gobernanza no declara ningún rol, o declara uno que no es un rol conocido)
Una vinculación de gobernanza lleva un rol, y es el rol — no el tipo declarado por el propio plugin — lo que fija dónde se ejecuta la vinculación y qué puede hacer: si acepta o rechaza una compilación, y si lee el grafo o los artefactos renderizados. Las vinculaciones se despachan leyendo ese rol, así que una vinculación que no lleve ninguno, o que lleve uno que nadie reconoce, no se vincularía a nada y se pasaría por alto en silencio.
Ese silencio es lo que el rechazo evita. Un plugin de gobernanza que está configurado y nunca se consulta produce exactamente la salida de una compilación que nunca se sometió a gobernanza, y nada en el resultado dice cuál de las dos tienes en la mano.
Mensajes emitidos, ambos nombran la vinculación y enumeran los roles que existen. Un rol ausente:
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 (la vinculación de gobernanza no declara ningún rol; establece el rol en uno de los roles conocidos: una vinculación de gobernanza no declara ningún rol o declara un rol desconocido)
y uno no reconocido:
workspaceconfig: governance attachment "<uri>" declares unknown role "<role>"; use one of <the known roles>: a governance attachment declares no role or an unknown role (la vinculación de gobernanza declara un rol desconocido; usa uno de los roles conocidos: una vinculación de gobernanza no declara ningún rol o declara un rol desconocido)
Cómo corregirlo: establece role: en la vinculación bajo plugins.governance en uno de los roles que enumera el mensaje. Cuál elegir es una decisión sobre lo que quieres que haga el plugin, no sobre el plugin: un rol que acepta o rechaza lee la compilación y devuelve un veredicto, y un rol que transforma es una instrucción explícita de dejar que el plugin cambie lo que recibe. El mensaje enumera el conjunto completo, así que la grafía que hay que usar está en el propio mensaje.
A registry alias matches more than one host (Un alias de registro coincide con más de un host)
A un registro se le puede dar un alias corto en la configuración del espacio de trabajo para que los comandos y las referencias puedan nombrarlo sin escribir su host completo. Un alias selecciona exactamente un host. Esta condición es lo que informa un token que coincide con el alias de dos entradas de registro: no hay respuesta a qué host se quería decir, y elegir uno enviaría en silencio artefactos a un registro que el autor no nombró, o los descargaría de él.
Mensaje emitido, que nombra el alias, cuántas entradas lo reclamaron y qué hosts son:
registry alias "<alias>" matches <count> hosts (<hosts>); address the registry by host or remove the duplicate alias: registry alias matches more than one host (el alias de registro coincide con varios hosts; designa el registro por su host o elimina el alias duplicado: el alias de registro coincide con más de un host)
Cómo corregirlo: abre .aggrega-config.yaml y asigna el alias a uno de los hosts que enumera el mensaje, o designa el registro por su host y quita el alias de la referencia. El mensaje nombra cada host que tiene el alias, así que qué entradas revisar está en el mensaje. Si las entradas proceden de capas de configuración distintas, edita la capa que te pertenece.
The lockfile does not satisfy its schema (El archivo de bloqueo no cumple su esquema)
El archivo de bloqueo de una release registra a qué se resolvió la compilación: para cada entidad, biblioteca y plugin que alcanza, la versión seleccionada y el digest de los bytes en esa versión. Se lee y se comprueba contra su esquema antes de convertirse en fijaciones tipadas, de modo que un documento que no encaja se rechaza con la ruta del campo en la que falló, en lugar de producir en silencio fijaciones con huecos.
El archivo de bloqueo lo escribe la máquina. Lo produce el pull que resuelve una release, y se confirma en el repositorio para que la misma compilación se resuelva de la misma manera más adelante. Por eso un fallo de esquema es casi siempre una edición a mano, una fusión que dejó el documento a medio resolver o un archivo de bloqueo escrito para una forma anterior del archivo — uno cuyas entities no llevan kind, por ejemplo —, y no algo escrito deliberadamente.
Un archivo de bloqueo ausente es una condición distinta y se informa de otra manera — el archivo de bloqueo es obligatorio, así que su ausencia se informa donde la compilación lo busca, con la instrucción de ejecutar el pull que lo crea.
Mensaje emitido, que nombra el archivo, la ruta del campo y la objeción propia del esquema:
lockfile: <path>: <field-path>: <the schema's own objection>: lockfile: file failed schema validation (lockfile: lockfile: el archivo no superó la validación de esquema)
Una compilación, y también aggrega pull --verify, añaden el comando que vuelve a escribir el archivo de bloqueo:
…: lockfile: file failed schema validation; run aggrega pull --release <release> to write it again from the Release (lockfile: el archivo no superó la validación de esquema; ejecuta el comando para volver a escribirlo a partir de la Release)
Un documento completamente vacío se informa por separado, ya que no hay ningún campo que nombrar:
lockfile: <path>: document is empty (lockfile: el documento está vacío)
Cómo corregirlo: no repares el archivo de bloqueo a mano. Vuelve a ejecutar el pull para la release, que reescribe el documento a partir de la resolución que realiza, y confirma el resultado — volver a resolver es lo que produce un documento cuyas fijaciones coinciden con lo que la release alcanza realmente. Si el fallo siguió a una fusión, resolver el conflicto volviendo a hacer el pull en lugar de editar el documento es lo que evita un documento que se analiza bien pero fija las versiones equivocadas. Vale la pena leer primero la ruta del campo del mensaje: te dice si el daño está en una entrada o en la estructura general del documento.
Al resolver el catálogo
Tras la carga, el compilador recorre los dos niveles del Manifest (mapeo de tipos, luego mapeo de nombres) para elegir la Recipe de cada Component, y recorre todas las cadenas extends de Manifests, Components o Features. La propia cadena extends de una Release se sigue con el mismo recorrido, un paso antes: se sigue mientras se resuelve la Release, antes de buscar el Manifest o el Aggregate que nombra, de modo que las condiciones siguientes se informan contra la Release y no contra un puntero hermano que la cadena iba a aportar.
Cyclic extends chain (Cadena extends cíclica)
Una cadena de punteros extends vuelve sobre sí misma. Cada tipo que declara extends — Component, Feature, Manifest y Release — se recorre con un único recorrido de cadena, de modo que un bucle se informa con las mismas palabras dondequiera que se encuentre.
Mensaje emitido. Comienza con la frase que nombra la condición, luego la entidad desde la que partió la resolución y la regla que la rechazó, y después la arista que cierra el bucle — la entidad que lleva el extends: problemático y la referencia que declara:
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 (cadena extends cíclica (tipo y nombre, regla extends). La entidad extiende la referencia, que ya está en la cadena; elimina el extends de la entidad, o haz que apunte a una entidad fuera de la cadena)
La entidad nombrada en primer lugar y la entidad nombrada en la arista suelen ser distintas, y de eso se trata: un bucle se informa contra cada entidad que forma parte de él, mientras que la línea extends: que hay que editar es la que nombra la arista. Sigue la arista, no el encabezado.
Para un Manifest, <kind> es Manifest, cada entidad se nombra por su metadata.name, y <reference> es el valor de extends: exactamente como está escrito — una ruta relativa como ./base.yaml, o el metadata.name simple de un Manifest junto a la Release. Cuál de las dos formas hayas escrito no cambia lo que se informa: un eslabón de Manifest es el archivo al que se resuelve, de modo que dos archivos de Manifest que casualmente declaran un mismo metadata.name son dos eslabones y una cadena que pasa por ambos no es un bucle.
Una Release se lee de la misma manera, y la cuestión de la identidad del archivo importa más allí porque la estructura que protege es habitual: <kind> es Release, <reference> es la ruta relativa que nombra extends:, y un eslabón de Release es el archivo al que se resuelve. Dos archivos de Release que nombran el sistema desplegado en lugar del entorno — ambos metadata.name: shared-release, uno extendiendo al otro — son dos eslabones, y una cadena que pasa por ambos no es un bucle.
Un bucle se informa como bucle, sea cual sea su longitud. El recorrido de cadena aplica su límite de profundidad solo a una cadena que termina, de modo que un ciclo que abarca más entidades de las que permite el límite se sigue informando aquí y no como una cadena demasiado profunda — el remedio para un bucle nunca es acortarlo.
Cómo corregirlo: abre la entidad que nombra la arista y elimina su extends: o haz que apunte a una entidad que no esté ya en la cadena. Donde varios niveles debían compartir contenido, reunir el contenido duplicado en una única entidad base elimina a la vez el bucle y la duplicación.
Recipe implements does not match the mapped component type (La declaración de implementación de la Recipe no coincide con el tipo de componente mapeado)
La entrada de mapeo del Manifest apunta a una Recipe cuya declaración spec.implements: no coincide con la clave de tipo de componente de esa entrada de mapeo. spec.implements es un ancla de coherencia y no un mecanismo de despacho: el valor del mapeo nombra la Recipe directamente, y esta comprobación confirma que la Recipe que nombró el autor es una que declara el tipo que mapeó.
La comprobación lee el Manifest compuesto antes de que se resuelva ninguna Recipe, de modo que informa la entrada de mapeo que escribió el autor y no un síntoma posterior de ella.
Mensaje emitido:
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 receta de la entrada de mapeo del manifiesto no coincide con la clave de tipo de componente / tipo de funcionalidad mapeada (mapeo del manifiesto del tipo de componente al URI de la receta, la spec.implements de la receta es el valor declarado, se esperaba el tipo de componente o un tipo que este extiende))
Todo comando que lee las dependencias de una Release realiza esta comprobación; lo que difiere es lo que cada uno hace con el resultado.aggrega build y aggrega pull se detienen, porque ambos producen algo que luego usarías — artefactos renderizados y un archivo de bloqueo. aggrega validate y aggrega lint informan el hallazgo junto con todos los demás diagnósticos que encontraron y luego terminan con un código distinto de cero: su tarea es decirte todo lo que está mal en el espacio de trabajo, así que un solo fallo no recorta el informe. En el editor el hallazgo se publica como un diagnóstico junto a los demás, y lo que ese documento tuviera que informar no se ve afectado. Fíjate dónde aparece: el editor publica el hallazgo en el Manifest en el que está escrito el mapeo, en la clave de la entrada de mapeo que nombra, y no en el Aggregate — en la primera línea del Manifest cuando su texto abierto no escribe esa entrada, como en el caso de una entrada que hereda mediante extends. Los demás hallazgos a nivel de dependencias de la Release, que no nombran ningún documento de tu espacio de trabajo, permanecen en el Aggregate. Ejecutar aggrega validate lo informa sea cual sea el documento que tengas abierto.
Una entrada de mapeo que nombra una Recipe que el catálogo no contiene no es esta condición: la comprobación no tiene nada con qué comparar y omite la entrada, y la Recipe irresoluble se informa cuando se resuelven las recetas.
Las entradas de FeatureRecipe siguen la misma estructura; la comprobación del mapeo features.type emite manifest feature mapping ... featurerecipe spec.implements is ... (expected ...), y la rama de funcionalidades compara con la propia clave de mapeo, así que no nombra ninguna alternativa extends.
Una clave components.type también se juzga por instancia siempre que alcanza una instancia de otra versión. Una clave que no nombra el tipo exacto de una instancia la alcanza a través de la base del tipo, cuando ninguna clave nombra ese tipo exacto y no hay otra clave escrita para la misma base — de modo que una clave escrita sin versión, o una que nombra otra versión, puede alcanzarla. Por tanto, la entrada por sí sola no puede decir si su Recipe encaja, así que la compilación vuelve a juzgar la Recipe para cada instancia de componente que la clave alcanza de ese modo, con el tipo propio de la instancia, en la versión con la que la compilación la compila, en el lugar de la clave: la versión que nombra la instancia o, para una instancia que no nombra ninguna, la versión más alta de ese Component que contiene el catálogo. Una instancia cuya versión no satisface la spec.implements: de la Recipe — exactamente, por rango caret, por no tener versión, o a través de una base que el tipo de la instancia extiende con extends — genera esta condición, informada en la ruta .spec.components.<instance> de la instancia en lugar de en el archivo del Manifest:
manifest mapping entry’s recipe spec.implements does not match the mapped component-type / feature-type key (Manifest, at .spec.components.<instance>, "<instance>", of type "<component-type>", compiled as "<component-type>:<version>", reached through manifest mapping key "<key>", mapped to recipe "<recipe-uri>", whose spec.implements is "<recipe-implements>"). map this type at this version to a recipe that implements it, with a mapping key naming the version (la spec.implements de la receta de la entrada de mapeo del manifiesto no coincide con la clave de tipo de componente / tipo de funcionalidad mapeada (Manifest, en la ruta de la instancia, instancia del tipo de componente, compilada como tipo y versión, alcanzada mediante la clave de mapeo del manifiesto, mapeada a la receta, cuya spec.implements es el valor declarado). mapea este tipo en esta versión a una receta que lo implemente, con una clave de mapeo que nombre la versión)
El valor compiled as aparece solo para una instancia cuyo tipo no nombra versión; una instancia que nombra una muestra su versión en of type. Una clave que nombra la versión propia de la instancia no necesita un segundo juicio, ya que la comprobación sobre la entrada ya planteó la pregunta, y una entrada ya rechazada por su clave se informa una vez, como arriba, en lugar de una vez más por cada instancia. aggrega build y aggrega pull se detienen ante ella, y aggrega validate --release la informa y termina con un código distinto de cero. aggrega lint juzga las entradas de mapeo de un Manifest y no las instancias que alcanzan, así que no la informa.
Cómo corregirlo: corrige la declaración spec.implements: de la Recipe para que coincida con la clave de tipo de componente del Manifest, o cambia la entrada del Manifest para que apunte a una Recipe cuya spec.implements: sí coincida con la clave de tipo de componente. Para una instancia que una clave alcanza en otra versión, añade una clave de mapeo que nombre la versión de la instancia, mapeada a una Recipe que la implemente, o haz que la clave que la alcanza apunte a una Recipe así.
Manifest mapping value is not a shape a recipe reference accepts (El valor de mapeo del Manifest no tiene una estructura que acepte una referencia de receta)
Un valor de mapeo del Manifest nombra una Recipe o una FeatureRecipe con una estructura que la gramática de referencias no puede expresar. Una referencia de receta acepta un nombre simple, un nombre con versión, un nombre calificado por capacidad o un nombre calificado por capacidad con versión — como máximo una /. Un valor que lleva más que eso (una ruta al estilo de un tipo de componente como core/helm/eso-aws-fetcher:1.0.0) nunca puede nombrar una entidad del catálogo, contenga lo que contenga el catálogo.
La estructura se juzga mientras se compone el Manifest, antes de buscar nada — el veredicto surge de contar separadores en una cadena, así que no necesita ningún catálogo. Juzgarla ahí es lo que hace honesto el diagnóstico: la receta a la que el valor se refería suele estar presente y bien nombrada, y que te digan que falta te lleva a buscar lo que no es. Todo comando que resuelve las dependencias de una Release lo informa de la misma manera, así que no depende de cuál ejecutes.
Mensaje emitido:
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 (referencia de receta mal formada en un valor de mapeo del Manifest: la clave se mapea a un valor que lleva varios segmentos separados por barras; una referencia de receta acepta nombre, nombre:versión, capacidad/nombre o capacidad/nombre:versión; corrige el valor de mapeo en el Manifest)
La sección features produce el mismo mensaje con su propia coordenada, y una referencia de receta de funcionalidad se nombra como tal.
Un valor cuyo segmento de capacidad lleva una fijación de versión — compose:1.2.3/svc:1.0.0 — se rechaza de la misma manera, antes de buscar nada, de modo que no se descarga nada de un registro. Una fijación corresponde a la capability que declara la Recipe, donde selecciona qué versión del plugin que sirve esa capacidad la renderiza; una referencia nombra la Recipe por su capacidad 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 (referencia de receta mal formada en un valor de mapeo del Manifest: la clave se mapea a un valor que lleva una fijación de versión en su segmento de capacidad; una fijación corresponde a la capacidad que declara la receta, y una referencia de receta nombra la receta por su capacidad simple, como nombre, nombre:versión, capacidad/nombre o capacidad/nombre:versión; corrige el valor de mapeo en el Manifest)
Cómo corregirlo: acorta el valor de mapeo a una estructura que la gramática acepte. Una receta se identifica por su propio metadata.name — opcionalmente precedido de su spec.capability y seguido de su versión —, nunca por la ruta del tipo de componente que implementa. La clave del mapeo es el tipo de componente; el valor del mapeo es la receta.
No debe confundirse con un valor bien formado que nombra una receta que el catálogo no contiene: esa es una entidad realmente ausente y se sigue informando como tal, nombrando el URI y la entrada de mapeo que la referenciaba.
Several Recipes implement one Component type (Varias Recipes implementan un mismo tipo de Component)
Dos o más Recipes declaran el mismo tipo de Component en spec.implements: — dos Recipes de versión exacta para un mismo tipo, o una Recipe sin versión junto a una fijada.
Esto no genera ninguna detención propia, y no es una ambigüedad que la compilación tenga que resolver. La selección de la Recipe es solo por mapeo: nada lee spec.implements: para elegir entre los candidatos, así que, por muchas Recipes que implementen un tipo, la que renderiza una instancia es aquella a la que el Manifest la mapea. spec.implements: se lee como ancla de coherencia — para confirmar que la Recipe que mapeó un autor es una que declara el tipo bajo el que la mapeó — y como fuente de los candidatos de fijación que sugiere una detención. Nunca selecciona.
Lo que encuentras en cambio es la detención para una instancia que el Manifest no mapea a nada, y esa detención enumera cada Recipe que implementa el tipo para que puedas fijar una — consulta «No Recipe is mapped for a component or feature instance (Ninguna Recipe está mapeada para una instancia de componente o de funcionalidad)» más abajo. Se informa de la misma manera tanto si el tipo lo implementa una Recipe como si lo implementan cinco, por eso no existe una condición de ambigüedad aparte que consultar.
Cómo corregirlo: añade el mapeo. Una entrada con clave de tipo enruta cada instancia del tipo; una entrada con clave de nombre enruta una instancia nombrada y se lee primero, así que también es la forma de dar a una instancia una Recipe distinta de la de sus hermanas.
Una Release usa extends: para heredar de una Release base pero también declara su propio puntero aggregate:. El JSON Schema de la Release rechaza esta estructura en la validación del esquema (Capa 1, la comprobación de la envoltura) mediante una restricción allOf: cuando extends: está presente, aggregate: está prohibido; cuando extends: está ausente, se requieren tanto aggregate: como manifest:.
Se detiene como una violación ordinaria de la envoltura, así que el diagnóstico toma la estructura de esa clase — consulta «La clase de fallos de la envoltura del documento» en error-translation.md — y el hallazgo apunta a la clave que aquí no está permitida:
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 (falló la validación de la envoltura del documento (Release, en la ruta); línea y columna: spec.aggregate: el valor coincide con una estructura que aquí no está permitida. corrige el documento para que coincida con el esquema de su tipo)
Cómo corregirlo: elimina el campo aggregate: de la Release hija. La herencia obliga intencionadamente a la hija a desplegar la misma intención del desarrollador que la Release padre; si necesitas desplegar un Aggregate distinto, escribe una Release nueva sin extends:.
A feature attached by both the Aggregate and the Release cannot be merged (Una funcionalidad vinculada tanto por el Aggregate como por la Release no se puede fusionar)
Cuando un Manifest local extiende un Manifest base con extends, los dos niveles (mapeo type:, mapeo name:) se fusionan de forma independiente. Dentro de cada nivel, las claves del hijo sobrescriben las del padre en el nivel superior — es un reemplazo superficial, no una fusión profunda. Una entrada del hijo para una clave dada reemplaza por completo la entrada del padre para esa clave.
Cuando el mismo nombre de instancia de funcionalidad aparece tanto en el lado del Aggregate como en el de la Release con un estado en conflicto no fusionable (más allá de la superposición de infra permitida), el compilador se detiene y sitúa el diagnóstico en la vinculación que no pudo conciliar. Las dos declaraciones en conflicto siguen en un orden fijo — primero el tipo que declaró el Aggregate, luego el tipo que declaró la Release — para que puedas saber qué documento dijo qué sin abrir ambos.
Mensaje emitido:
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>") (conflicto de fusión de funcionalidad: concilia las declaraciones del Aggregate y de la Release para la funcionalidad (Aggregate, en la ruta de la vinculación, tipo declarado por el Aggregate, tipo declarado por la Release))
Lo mismo ocurre con una vinculación que lleva una conexión. Cuando la entrada de conexión del Aggregate y la entrada de la Release para la misma conexión escriben ambas una vinculación bajo un mismo slot y nombran Features distintas, la compilación se detiene en la entrada de la Release — donde se escribió el segundo tipo — una vez aplanada la composición, nombrando ambos tipos, el slot, la conexión, el socket y el componente:
feature merge conflict: reconcile the Aggregate and Release declarations for the feature (Release <release-name>, at .spec.boundaries.<boundary>.components.<component>.uses.<socket>.<alias>, the Aggregate names "<aggregate-declared-type>", the Release names "<release-declared-type>", for the slot "<slot>", on the connection "<alias>", through socket "<socket>", of component "<component>"). Drop the type from the Release’s entry so it sizes the attachment the Aggregate declares, or name the same Feature in both documents. (conflicto de fusión de funcionalidad: concilia las declaraciones del Aggregate y de la Release para la funcionalidad (Release, en la ruta de la conexión, el Aggregate nombra un tipo, la Release nombra otro, para el slot, en la conexión, a través del socket, del componente). Quita el tipo de la entrada de la Release para que dimensione la vinculación que declara el Aggregate, o nombra la misma Feature en ambos documentos.)
Cómo corregirlo: concilia las dos declaraciones. Las declaraciones del lado del Aggregate y del lado de la Release de la misma instancia de funcionalidad se combinan por pilar — el Aggregate aporta values, la Release aporta infra. Si ambos lados especifican el mismo campo fuera de los pilares (como type:), los valores deben coincidir; corrige un lado para que coincida con el otro, o elimina la declaración redundante.
Annotation binding does not resolve against its target Feature (El enlace de la anotación no se resuelve contra su Feature de destino)
El campo feature: de un enlace de anotación del Manifest nombra una Feature que el catálogo no carga, o las listas maps.infra / maps.values del enlace declaran rutas con puntos que el spec.schema de la Feature nombrada en realidad no contiene. Cualquiera de las dos condiciones detiene la carga del espacio de trabajo — el enlace sintetizaría vinculaciones de Feature que enrutan valores hacia rutas que el entorno de ejecución no puede resolver.
Una sola condición cubre las tres formas en que el enrutamiento de un enlace no llega a resolverse, y el diagnóstico indica cuál de ellas se dio:
Feature no encontrada. El valor de feature: hace referencia a un URI de Feature ausente del catálogo cargado.
El esquema de la Feature no se resuelve. La Feature nombrada se carga, pero su spec.schema: no se resuelve en una representación de JSON Schema 2020-12 — el contenido está mal formado, o nombra una referencia entre documentos que no se puede seguir. Esta variante lleva detrás el diagnóstico propio del fallo de resolución, de modo que el motivo por el que el esquema no se resolvió se puede leer en la misma detención.
Ruta del enlace ausente del esquema de destino. La entrada maps.infra o maps.values del enlace nombra una ruta con puntos que el spec.schema.<pillar>.<path> de la Feature no declara.
Mensaje emitido (variante de Feature no encontrada):
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") (el enlace de la anotación no se resuelve contra su Feature de destino (Manifest: enruta hacia una Feature que el catálogo de esta compilación no contiene; corregir o publicar la Feature nombrada en el enlace))
Mensaje emitido (variante en la que el esquema no se resuelve):
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>) (el enlace de la anotación no se resuelve contra su Feature de destino (Manifest: el enlace de la anotación enruta hacia una Feature cuyo esquema declarado no se resuelve))
Esta variante nombra la Feature y el fallo de resolución, y no lleva ni la clave del enlace ni una posición en el origen — el fallo está en el propio spec.schema: de la Feature, que el enlace solo nombra. Para encontrar el enlace causante, busca en mappings.features.annotations el URI de Feature que cita el mensaje.
Mensaje emitido (variante de ruta no encontrada):
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") (el enlace de la anotación no se resuelve contra su Feature de destino (Manifest: enruta hacia una Feature, un pilar y una ruta para la que esa Feature no declara ninguna propiedad en su esquema))
Cómo corregirlo: comprueba que el URI feature: del enlace exista en el catálogo y coincida con el URI, que distingue mayúsculas de minúsculas, que una Recipe declara en implements:. Si la variante de ruta no encontrada se dispara en una ruta que el esquema de la Feature sí declara, comprueba la grafía de la ruta con puntos (distingue mayúsculas de minúsculas) y el nombre del pilar (infra o values).
A bound annotation value does not conform to the target Feature’s schema (Un valor de anotación enlazado no se ajusta al esquema de la Feature de destino)
Una anotación que escribiste enruta un valor, a través de un enlace, hacia una ruta de la Feature de destino — y el valor no satisface el subesquema que la Feature declara en esa ruta, o la Feature no declara allí ninguna propiedad. La condición se evalúa sobre el valor y no sobre el enlace, y por eso es distinta de la detención por el destino del enlace descrita arriba: aquella rechaza lo que el Manifest declara, esta rechaza lo que se escribió a través de él.
Validación completa en la ruta localizada; omisión suave solo cuando la ruta no se puede localizar. Una vez localizado el subesquema de la subclave enlazada, el valor se valida contra el conjunto completo de restricciones de JSON Schema 2020-12 en esa ruta (tipo, enum, pattern, rango numérico, estructura anidada de objeto o array) — un $ref / allOf / oneOf terminal se resuelve contra las definiciones del esquema y se valida, no se omite. La disciplina de la omisión suave se aplica solo a la navegación: cuando el recorrido encuentra una vía de escape ($ref, patternProperties, oneOf/anyOf/allOf, o additionalProperties con cuerpo de esquema) en un segmento intermedio — antes de alcanzar la hoja enlazada — la ruta no se puede resolver estáticamente, así que el validador continúa sin generar el error en lugar de arriesgarse a una detención falsa; el entorno de ejecución sigue siendo la superficie de validación de ese enlace.
Mensaje emitido (variante de conformidad del valor):
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 subclave de la anotación no se ajusta al esquema de la Feature de destino en el pilar enrutado: el valor de la subclave de la anotación no se ajusta al esquema de la Feature)
Mensaje emitido (variante de subclave no declarada):
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 subclave de la anotación no se ajusta al esquema de la Feature de destino en el pilar enrutado: la subclave de la anotación no está declarada en el esquema de la Feature)
La detención se produce sobre la anotación tal como está escrita, antes de que se expanda en una vinculación de Feature, de modo que el diagnóstico nombra el documento y el nivel en el que se escribió el valor — el límite y el componente para una anotación del lado de la Release, la ruta del componente para una del lado del Aggregate — y la clave de anotación de la que procede.
Una anotación que inyectó un plugin de gobernanza se juzga de la misma manera, y el diagnóstico dice quién la escribió. Un plugin vinculado para inyectar anotaciones fija su valor en un componente de la Release, así que el valor se comprueba exactamente como uno que un operador hubiera escrito allí — pero la línea de la Release a la que apunta el diagnóstico es una que nadie escribió. Por eso el diagnóstico añade qué plugin inyectó el valor y el rol de gobernanza en el que está vinculado, y la corrección está en la decisión de ese plugin y no en la Release.
Cómo corregirlo: corrige el valor enlazado para que satisfaga el subesquema declarado, o amplía el esquema de esa propiedad si el valor es legítimo. La variante de subclave no declarada suele quedar anticipada por la detención por el destino del enlace descrita arriba; llegar a ella significa que el enlace declara la ruta y el esquema de la Feature no la contiene, así que corrige el que de los dos esté mal. Cuando un operador de composición intermedio hace que una ruta no se pueda resolver y el entorno de ejecución la rechaza después, restringe el esquema para que la propiedad aparezca directamente en la ruta del enlace.
An annotation subkey is not routed by its binding (Una subclave de anotación no es enrutada por su enlace)
Una anotación que escribiste lleva subclaves bajo una clave que reclama un enlace de anotación del Manifest, y una de esas subclaves es un nombre que el enlace no enruta: no figura ni en maps.infra ni en maps.values. Cada subclave se enruta por separado, hacia la ruta de Feature que el enlace declara para ella, así que una subclave que el enlace no nombra no tiene adónde ir. Expandir la anotación sin ella dejaría fuera de la compilación un valor que escribiste sin que nada lo advirtiera, y una subclave con una grafía errónea es la causa habitual — por eso la compilación se detiene en su lugar, nombrando la subclave, la clave de anotación bajo la que se escribió y cada subclave que el enlace enruta.
La detención se produce sobre la anotación tal como está escrita, antes de que se expanda en una vinculación de Feature, igual que en las dos condiciones contiguas: «A bound annotation value does not conform to the target Feature’s schema (Un valor de anotación enlazado no se ajusta al esquema de la Feature de destino)», más arriba, rechaza una subclave que el enlace enruta cuando la Feature rechaza su valor, y «An annotation routes through a pillar its authoring side may not use (Una anotación se enruta a través de un pilar que su lado de autoría no puede usar)», más abajo, rechaza una enrutada a través del pilar equivocado. Una clave que ningún enlace reclama no entra en esta condición: nada la enruta, y la compilación la pasa por alto.
Mensaje emitido, que nombra el documento y el lugar donde se escribió la anotación, la subclave, la clave de anotación y las subclaves que el enlace enruta:
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 subclave de la anotación no es enrutada por el enlace de la anotación (Release: la subclave, escrita bajo la anotación cuyo enlace solo enruta las subclaves indicadas))
Una anotación escrita en un Aggregate se nombra de la misma manera, en el lugar donde se escribió allí — (Aggregate <name>, at .spec.subsystems.<subsystem>.annotations, …) para una escrita en un subsistema. La compilación informa de una anotación del lado de la Release bajo una etiqueta OPS_ERROR y de una del lado del Aggregate bajo una etiqueta DEVELOPER_ERROR, según el documento que la escribió.
Cómo corregirlo: compara la subclave con las que enumera el mensaje. Si es un error de grafía, sustitúyela por la subclave que el enlace enruta. Si el valor debe llegar a la Feature, el enlace tiene que enrutarlo: añade la ruta a maps.infra o maps.values del enlace en el Manifest — una ruta que el esquema de la Feature declare — o elimina la subclave de la anotación.
A bare annotation value does not route to exactly one path of its binding (Un valor de anotación simple no se enruta hacia exactamente una ruta de su enlace)
Una anotación que escribiste como valor simple — feature.aggrega.ai/monitoring: "30s" en lugar de un mapa de subclaves — no nombra ninguna subclave, así que nada en ella indica qué ruta de Feature rellena. Se coloca en la única ruta que declara el enlace, contando juntas maps.infra y maps.values. Un enlace que declara más de una ruta deja al valor varios destinos posibles y nada con qué elegir entre ellos, así que la compilación se detiene en lugar de elegir uno. El recuento abarca ambas listas, así que un enlace que enruta una ruta a través de infra y otra a través de values rechaza un valor simple sea cual sea el documento en el que esté escrito.
La detención se produce sobre la anotación tal como está escrita, antes de que se expanda en una vinculación de Feature, igual que en las condiciones contiguas, de modo que el diagnóstico nombra el documento y el lugar donde se escribió el valor. La comprobación se hace una vez por cada anotación que escribiste: un valor escrito en un límite o en un subsistema se rechaza allí, una sola vez, tanto si un componente que contiene lo recoge como si no. Se informa de cada valor de este tipo en la compilación, no solo del primero. La compilación informa de una anotación del lado de la Release bajo una etiqueta OPS_ERROR y de una del lado del Aggregate bajo una etiqueta DEVELOPER_ERROR, según el documento que la escribió. La condición es a scalar annotation value does not route to exactly one path of its binding, que es lo que aggrega explain imprime para su código.
Mensaje emitido, que nombra el documento y el lugar donde se escribió la anotación, la clave de anotación, el valor y las rutas que el enlace enruta:
a scalar annotation value does not route to exactly one path of its binding (Release <release-name>, at .spec.boundaries.<boundary>.annotations, "<key>", carrying the bare value "<value>", whose binding routes "<path>, <path>, <path>") (un valor de anotación escalar no se enruta hacia exactamente una ruta de su enlace (Release: la clave lleva un valor simple, cuyo enlace enruta las rutas indicadas))
Un valor vacío no escribe nada, así que se coloca dondequiera que una de las dos listas contenga una sola ruta, y solo se rechaza donde ninguna de las dos la contiene. Un enlace que no declara ninguna ruta se rechaza al cargar el Manifest, porque el esquema del Manifest exige una, así que una compilación no llega a esta condición por esa vía.
Una anotación que inyectó un plugin de gobernanza se juzga de la misma manera, y su diagnóstico añade qué plugin inyectó el valor y el rol de gobernanza en el que está vinculado, como hacen las condiciones contiguas.
Cómo corregirlo: escribe la anotación como un mapa que nombre la subclave a la que va destinado cada valor — feature.aggrega.ai/monitoring: {interval: 30s} — para que cada valor se enrute por su propio nombre; o da al valor único un enlace propio, bajo otra clave de anotación, que declare solo la ruta que rellena.
An annotation routes through a pillar its authoring side may not use (Una anotación se enruta a través de un pilar que su lado de autoría no puede usar)
Las anotaciones se reparten por lado de autoría, y el reparto es el mismo que rige cualquier otro pilar escrito: una anotación del lado del Aggregate solo puede enrutarse a través de una ruta del enlace que apunte a values, y una anotación del lado de la Release solo a través de una ruta que apunte a infra. Cualquier otra combinación provoca una detención.
El reparto es lo que impide que el atajo de las anotaciones se convierta en una forma de escribir el pilar del otro lado. La anotación de un desarrollador aporta values; la de un operador aporta el dimensionamiento de infra. Un enlace que declara rutas en ambos pilares no es en sí un error — cada lado enruta el subconjunto que tiene permitido, y las rutas del otro lado simplemente no le son alcanzables.
Un enlace que declara una misma ruta en ambas listas de pilares es el caso que más a menudo llega a esta detención. El criterio de desempate del enrutamiento envía esa ruta a través de infra, lo que la hace inalcanzable desde el lado del Aggregate, y una anotación del lado del Aggregate que se enruta hacia ella se detiene aquí. El aviso que señala esa estructura de enlace antes de que una compilación llegue a esta detención se describe en warnings.md.
Mensaje emitido:
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> (la anotación se enruta a través de un pilar que su lado de autoría no puede usar: la anotación se enruta a través de un pilar en una ruta, pero las anotaciones de ese lado solo pueden enrutarse a través del pilar permitido)
Una anotación que inyectó un plugin de gobernanza está en un componente de la Release, así que es una anotación del lado de la Release y se le aplica el mismo reparto. Su diagnóstico añade qué plugin la inyectó y el rol de gobernanza en el que está vinculado, porque la clave de la Release a la que apunta es una que nadie escribió.
Cómo corregirlo: enruta la anotación desde el lado cuyo pilar es el destino del enlace, o añade un enlace — bajo su propia clave de anotación — cuyas rutas apunten al pilar permitido al lado de autoría. Cuando un enlace declara la misma ruta en ambas listas de pilares, divídelo en dos enlaces para que cada lado tenga una ruta que pueda alcanzar. Cuando el diagnóstico nombra un plugin que inyecta, la anotación procede de la decisión de ese plugin: corrige el plugin, o el enlace bajo el que inyecta.
Authored values or infra do not conform to the declared schema (Los values o infra escritos no se ajustan al esquema declarado)
Los values: o infra: resueltos de una instancia de componente — o de una Feature vinculada — no se ajustan al esquema de catálogo declarado. La compilación valida cada pilar contra su esquema declarado antes del renderizado, así que una clave mal escrita, un valor de tipo incorrecto, un número fuera de rango o un campo obligatorio ausente se detecta en su origen en lugar de producir un manifiesto defectuoso en el momento del despliegue.
La comprobación cubre las restricciones de esquema estándar: un valor del tipo incorrecto (una cadena donde el esquema declara un entero), un valor fuera de un rango declarado o de un enum, un valor que no cumple un pattern declarado, una cadena que no es una instancia válida de su format declarado — uno de los formatos con nombre — y un campo obligatorio que no se proporcionó. Un fallo de formato nombra la palabra clave e incluye el valor, el formato y lo que está mal en él — tal como lo imprimen aggrega pull y aggrega validate --release para un campo uri al que se le da ::::, "format", "value \"::::\" is not a valid uri: a URI begins with a scheme followed by a colon, such as https:". Tiene en cuenta los valores predeterminados: un campo al que el esquema da un default: se considera proporcionado aunque se omita, así que un campo obligatorio con valor predeterminado nunca activa la comprobación «ausente».
El pilar values es la superficie de autoría del desarrollador. Se valida de forma cerrada — una propiedad que el esquema no declara se rechaza como probable error tipográfico. Un esquema de values que se compone dentro de su propio documento (un #/$defs$ref local o allOf) se resuelve y se valida frente a ese contexto de definiciones.
El pilar infra es la superficie de dimensionamiento del operador, y solo se comprueba cuando el Component declara un pilar schema.infra — esa declaración es el contrato al que el componente se adhiere. Se valida de forma cerrada frente a esa declaración y frente a nada más, exactamente como el pilar values se valida frente a schema.values: una clave que el Component no declara se rechaza como error tipográfico, y a una clave que sí declara se le imponen su tipo y su rango. Un componente que quiere que se valide una clave superpuesta por el proveedor, como replicas, declara esa clave en su propio schema.infra; el vocabulario aceptado por un proveedor se alcanza a través del valuesMapping de su Recipe en lugar de superponerse a la superficie infra escrita.
La comprobación mide el dimensionamiento de cada componente que la Release colocó, y también se mide una entrada que no escribe ningún bloque infra:: un bloque ausente es un bloque vacío, así que una clave required: sin default: se informa como ausente — que es justo el caso que tal clave existe para detectar. Cuentan las dos formas de colocar un componente. Nombrarlo bajo los components de un límite lo coloca, y también lo hace enrutar bajo aggregates el submódulo que lo aporta; una entrada de enrutamiento coloca componentes sin decir nada de ninguno de ellos, así que un componente colocado de esa forma parte de un bloque de dimensionamiento vacío y una clave required: sin valor predeterminado en su tipo se informa como ausente. Un componente que la Release no coloca por ninguna de las dos vías no se mide en absoluto frente a este contrato. Tiene un fallo distinto, y la compilación informa de ese en su lugar: un componente que no está colocado en ningún límite, con las dos formas de colocarlo nombradas.
El contrato rige a un componente dondequiera que se haya escrito: un componente que aporta un submódulo se mide exactamente igual que uno que declara el propio Aggregate de la Release. El grado de anidamiento de un componente no cambia cuáles de las restricciones de su tipo se aplican.
Las vinculaciones de Feature se validan de la misma forma, frente a los schema.values / schema.infra que declara la Feature vinculada. Las vinculaciones comparten una sola superficie, así que una Feature de credenciales — una etiquetada feature.aggrega.ai/kind: secret — se mide frente a su propio esquema declarado exactamente como cualquier otra vinculación. El valor comprobado es el resultado fusionado efectivo después de que los valores de las vinculaciones se propagan en cascada por los niveles (componente, subsistema, límite y específico del componente) — así que un valor introducido legalmente en un nivel pero sobrescrito con un valor ilegal en un nivel más específico se detecta en el resultado fusionado, no en el fragmento. Una vinculación cuyo tipo no declara ningún esquema no se valida; el infra de una vinculación se valida frente al propio schema.infra de la vinculación (una vinculación es una superposición y no lleva ninguna unión de proveedores).
El hallazgo de una vinculación se informa en el documento que escribió el pilar que falla, bajo el nombre de ese documento, y se atribuye a su autor. Sus values se informan en el bloque del Aggregate que los escribió — la propia entrada features: del componente, .spec.components.<component>.features.<attachment>.values.<field>, antes del bloque de un subsistema que alcanza al componente — como fallo del desarrollador. Su infra se informa en el bloque de la Release que lo escribió — la entrada de la Release para el componente, bajo el límite que lo nombra, antes del propio bloque features: del límite — como fallo del operador. Un pilar que el documento al que pertenece no escribió se informa donde se escribió la vinculación misma, que es donde se nombra su type. Así, una vinculación que solo hace la Release, que no lleva values, informa de un campo que exigen los values de su Feature en la entrada de la Release y como fallo del operador, en una ruta que contiene la Release — la entrada del componente, o el bloque features: del límite para una vinculación que el límite hace para cada componente bajo él:
authored pillar does not conform to its declared schema (Release probe, at .spec.boundaries.main.components.app.features.check.values.schema, values pillar does not conform to the Feature schema: missing required property: schema (required))
La misma vinculación escrita en el componente en el Aggregate informa [DEVELOPER_ERROR E0168] en .spec.components.app.features.check.values.schema, bajo el nombre del Aggregate. Un editor muestra cada uno en el documento que lo escribió, en la clave más profunda de esa ruta que contiene el documento.
Una vinculación que lleva una conexión se mide de la misma forma, y se informa en la entrada de conexión del documento que escribió el pilar que falla, en lugar de en el propio bloque features: del componente, que no la contiene. Sus values se informan en la entrada de conexión del Aggregate, .spec.components.<component>.uses.<socket>.<alias>.features.<slot>.values.<field> — en el propio documento del submódulo, para un componente que aporta un submódulo — y su infra en la entrada de la Release para esa conexión, bajo el límite que nombra el componente cuando la Release nombra límites. Una vinculación que solo hace la Release se informa en la entrada de la Release para ambos pilares: tal vinculación no lleva values, así que una Feature cuyos values exigen un campo lo informa como ausente allí, en la entrada que escribió el operador.
La configuración de conexión por arista se valida de la misma forma frente al contrato por arista del socket: los values de una arista escritos por el desarrollador frente al valueSchema del socket, y el infra de una arista escrito por el operador (desde una Release) frente al infraSchema del socket. Un socket que no declara ningún esquema por arista para un pilar no acepta ninguna configuración validada para él (omisión = sin contrato, nada que comprobar). El diagnóstico nombra la arista por consumidor, socket y alias. En un componente que declara el propio Aggregate de la Release, el infra del operador se mide para cada entrada que la Release escribe para una de sus conexiones — incluida una entrada que no lleva infra, que es como una clave required: sin valor predeterminado se informa como ausente — y se informa en esa entrada de la Release, bajo el límite que nombra el componente cuando la Release nombra límites, que es donde el operador lo edita; los values del desarrollador se informan en la entrada de conexión del Aggregate.
Una hoja declarada sensitive: true tiene retenido su fallo de restricción. El texto del fallo cita el valor infractor, y un diagnóstico de compilación lo lee cualquiera que observe la compilación, así que en una hoja declarada sensible — o en cualquier lugar dentro de un objeto declarado sensible — el <constraint failure> de abajo dice en su lugar <redacted>. Lo mismo ocurre en una posición que contiene debajo una hoja declarada sensible, incluido el propio pilar: un $ref escrito junto a otras palabras clave se comprueba entero donde está escrito, así que un fallo dentro de la definición que nombra se informa en esa posición y, de otro modo, citaría el valor de la hoja. La entidad, la ruta del campo, el pilar y el nombre del contrato se siguen nombrando todos, así que el diagnóstico te sigue diciendo dónde está el fallo; solo se omite el texto que reproduciría el valor. La sensibilidad se lee por pilar, así que una hoja nombrada igual en values y en infra se retiene solo en el pilar que la declara.
Mensaje emitido:
authored pillar does not conform to its declared schema (Aggregate <name>, at .spec.components.<component>.values.<field>, “values.<field>”, “<keyword>”, “<constraint failure>”) (el pilar escrito no se ajusta a su esquema declarado) authored pillar does not conform to its declared schema (Release <release-name>, at .spec.components.<component>.infra.<field>, “infra.<field>”, “<keyword>”, “<constraint failure>”) (el pilar escrito no se ajusta a su esquema declarado) 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>) (el pilar escrito no se ajusta a su esquema declarado: el pilar values no se ajusta al esquema 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>) (el pilar escrito no se ajusta a su esquema declarado: el pilar infra no se ajusta al esquema 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>) (el pilar escrito no se ajusta a su esquema declarado: el pilar values no se ajusta al esquema 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>”) (el pilar escrito no se ajusta a su esquema declarado) 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>) (el pilar escrito no se ajusta a su esquema declarado: el pilar values no se ajusta al esquema 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>) (el pilar escrito no se ajusta a su esquema declarado: el pilar values no se ajusta al esquema 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>”) (el pilar escrito no se ajusta a su esquema declarado)
Cómo corregirlo: corrige el valor infractor para que cumpla el esquema declarado o — si el valor es legítimo — amplía el esquema que lo declara (los schema.values/schema.infra del Component, o los de la Feature vinculada) para que lo declare. Inspecciona el esquema declarado de un Component con aggrega inspect <component-type> para ver los tipos exactos, los rangos, los valores predeterminados y los campos obligatorios que espera cada pilar.
A declared schema contract cannot be read as a schema (Un contrato de esquema declarado no se puede leer como esquema)
Un Component o una Feature declara un contrato de esquema que no ofrece nada frente a lo que validar, así que la configuración que cubre se mide frente a nada. Tres contratos pueden llevar el fallo, cada uno escrito en su propio campo: el propio spec.schema de la entidad y los dos contratos por arista que declara un socket de dependencia — valueSchema para el lado del desarrollador de una conexión e infraSchema para el del operador. Una entrada de SchemaLibrary, a la que esos contratos pueden hacer referencia, también puede llevar el tercero de los fallos de abajo; cómo se informa ese caso se explica más adelante.
Tres fallos llevan a esta detención, y dos de ellos son fáciles de pasar por alto porque el contrato parece correcto. Un contrato de socket puede no compilar en absoluto a JSON Schema 2020-12 — una palabra clave mal escrita es la causa más común; un spec.schema propio de una entidad que no compila se informa en su lugar bajo la condición de forma compacta que encontró su compilación (E0120 para una palabra clave desconocida, E0116 para una restricción que su tipo no admite). O puede compilar limpiamente y aun así no construir ningún validador: el cuerpo es legible como forma compacta y no es un esquema frente al que se pueda validar nada, como un escalar simple donde corresponde el esquema de una propiedad (items: nonsense). O puede estar bien formado en todo lo demás y nombrar un formato fuera del conjunto admitido — format: password, o un error de grafía como format: emial — que se rechaza en lugar de leerse como una restricción que no comprueba nada, llegue o no algún valor al campo; los nombres que puede tomar un format se enumeran en Formatos con nombre. Los tres son una sola condición, porque el remedio es el mismo y dejar pasar cualquiera de ellos tiene la misma consecuencia.
No declarar ningún contrato y declarar uno que no se puede leer son situaciones distintas, y la compilación las trata de forma distinta. Un campo que no declara nada se omite: la conformidad por pilar y por arista es opcional, así que un socket que no restringe ninguno de los dos pilares es autoría corriente y no genera ningún diagnóstico. Un campo que declara algo ilegible se rechaza. Dejarlo pasar dejaría sin validar toda carga útil que cubre mientras la compilación informaba de éxito — una comprobación que ha dejado de ejecutarse sin nada que diga que se detuvo. Así que el rechazo es lo que mantiene separados los dos casos: el silencio significa que no había nada que comprobar, y una detención significa que había algo y no se pudo leer.
El rechazo nombra la entidad que declaró el contrato en lugar del documento que escribió la configuración, porque ahí es donde va la corrección. El autor de un Aggregate al que se le entrega un tipo de componente cuyo contrato no se puede leer no tiene nada que cambiar en su propio archivo. El rechazo llega al leerse el catálogo, donde la entidad declarante, el pilar, el campo escrito y la línea de origen se conocen todos — así que el mismo fallo se informa de forma idéntica tanto si llegas a él desde una compilación como desde aggrega validate o desde la herramienta de compilación que expone aggrega mcp. Un contrato que la entidad lee mediante $import: — su spec.schema entero, uno de sus pilares o el contrato de un socket — se informa en el archivo importado: la ubicación nombra ese archivo y la línea en la que está escrito el fragmento, mientras que el mensaje sigue nombrando la entidad y el campo que declaró el contrato. Las detenciones de forma compacta que encuentra el propio spec.schema de una entidad se ubican de la misma forma.
Una entrada de SchemaLibrary que nombra un formato fuera del conjunto admitido llega a esta detención cuando se lee su biblioteca, y el rechazo nombra la biblioteca y la entrada y apunta a la entrada en el archivo de la biblioteca. aggrega validate sobre todo el catálogo lee cada biblioteca, así que informa de la entrada tanto si algún esquema hace referencia a ella como si no, mientras que una Release cuya resolución de dependencias nunca llega a la biblioteca no la lee. Una Release cuyos esquemas sí llegan a la entrada mediante un $ref: también se rechaza, pero el rechazo no nombra el formato: aggrega pull informa de que la biblioteca no se encuentra en el catálogo (E0114), y aggrega validate --release informa de que el destino de la referencia no se encuentra (E0121). Ejecuta aggrega validate sobre el catálogo para ver la entrada y el nombre que falla.
El mensaje lleva el fallo tal como lo informó la herramienta que lo encontró: para un fallo de compilación, la clave dentro del contrato, la línea de origen y la palabra clave infractora; para un cuerpo que no construye ningún validador, la posición que rechazó el validador; para un nombre de formato fuera del conjunto admitido, el campo, la palabra clave format, el nombre tal como está escrito y cada nombre admitido. Un $ref: entre documentos en un contrato de socket cuya entrada de SchemaLibrary no está en la clausura cargada llega a la misma detención cuando aggrega validate comprueba la entidad o la Release; en el propio spec.schema de una entidad se informa como describe «A $ref: is not written in a form the compiler can resolve (Una referencia no está escrita en una forma que el compilador pueda resolver)» más arriba. aggrega pull lee ambos lugares para las bibliotecas que necesita una Release, así que una biblioteca ausente del catálogo detiene el pull antes, como describe «A reference names no entity the catalog holds (Una referencia no nombra ninguna entidad que contenga el catálogo)» (E0114), sea cual sea de los dos el que la referencia — y una biblioteca que contiene el catálogo se fija en el archivo de bloqueo para cualquiera de los dos.
Una restricción bien formada junto a una ilegible no se aplica. Un contrato se lee como un solo documento, así que un único fragmento ilegible desactiva toda restricción declarada junto a él. Por eso la detención vale más que las restricciones que cuesta: la alternativa es un contrato que parece aplicado, se lee como aplicado y no aplica nada.
Mensaje emitido, que nombra la entidad con su versión y el campo que declara el contrato, luego el pilar que ese contrato restringe y luego el fallo — aquí, un contrato de socket que contiene una palabra clave mal escrita:
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 (el contrato de esquema declarado no se pudo compilar en un esquema utilizable, así que no se validó nada con él: corrige el contrato donde está declarado, o elimínalo si la configuración que cubre no necesita validación. Component: spec.usesSchema.valueSchema del socket declara un esquema a partir del cual no se puede construir ningún validador, así que los valores que restringe quedarían sin medir: compactform en la clave y la línea indicadas: palabra clave desconocida)
y un nombre de formato fuera del conjunto admitido en el pilar values de 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) (el contrato de esquema declarado no se pudo compilar en un esquema utilizable, así que no se validó nada con él: corrige el contrato donde está declarado, o elimínalo si la configuración que cubre no necesita validación. Component: spec.schema.values declara un esquema a partir del cual no se puede construir ningún validador, así que los valores que restringe quedarían sin medir: validator/jsonschema: falló la resolución del esquema (en el campo bajo values, palabra clave format: el formato no es compatible; los formatos admitidos son email, uri, hostname, ipv4, ipv6, uuid, date-time, date))
Una Feature se nombra como Feature "<name>:<version>", el contrato de un socket por su propio campo, como spec.usesSchema.<socket>.infraSchema, y el pilar por el que restringe el contrato — values, infra o provides. aggrega validate, cuando recibe el propio archivo de la entidad, nombra la entidad sin su versión. Una entrada de SchemaLibrary se nombra por su biblioteca y su entrada:
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) (el contrato de esquema declarado no se pudo compilar en un esquema utilizable, así que no se validó nada con él: corrige el contrato donde está declarado, o elimínalo si la configuración que cubre no necesita validación. SchemaLibrary: el esquema nombra un formato que ningún validador puede comprobar, así que los valores que restringe quedarían sin medir: validator/jsonschema: falló la resolución del esquema (en el campo indicado, palabra clave format: el formato no es compatible; los formatos admitidos son email, uri, hostname, ipv4, ipv6, uuid, date-time, date))
Cómo corregirlo: abre el campo que nombra el diagnóstico y corrige el fragmento en la clave y la línea indicadas — casi siempre una palabra clave mal escrita, que se comprueba con el vocabulario de palabras clave de vocabulary/compact-form-authoring.md, o un valor escrito donde corresponde un esquema anidado. Cuando el fallo nombra un formato no admitido, escribe uno de los formatos con nombre o elimina el format:; un campo que contiene material secreto declara en su lugar sensitive: true, ya que password no es un formato. Para una entrada de SchemaLibrary, la corrección va en el archivo de biblioteca que nombra el diagnóstico. Cuando el fallo nombra una referencia entre documentos, confirma que la entrada de SchemaLibrary existe y que la biblioteca es alcanzable desde la clausura de dependencias de la Release. Si la configuración que cubre ese campo realmente no necesita validación, elimina el campo en lugar de dejar un contrato que nada puede leer.
Recipe source: is an empty string (El campo source de la Recipe es una cadena vacía)
Una Recipe declara source: "" — una cadena vacía. El source: de una Recipe elige entre dos modos de autoría: el modo sourceless, en el que no hay ningún artefacto externo y la salida se produce por completo a partir de los demás tipos de entrada de la Recipe, y el modo sourced, en el que source: nombra un chart, un módulo o un archivo externo a partir del cual renderizar. Omitir el campo selecciona el primero, un valor no vacío selecciona el segundo y una cadena vacía no selecciona ninguno — por eso es una ambigüedad y no un valor con significado. Un source: escrito como null equivale a omitirlo.
La Recipe se rechaza en lugar de que el compilador elija por ti una de las dos lecturas. La forma más habitual de escribir un source: vacío es borrar un URI y dejar la clave: se pretendía el modo sourced, y admitir la cadena vacía como sourceless entregaría el componente sin el artefacto y nunca diría cuál de las dos lecturas tomó.
Esta regla se comprueba al cargar la Recipe, leyendo el valor exactamente como lo escribiste, de modo que todo comando que carga la Recipe nombra esta condición antes de que algo intente usar el valor vacío. aggrega validate sobre el archivo de la Recipe lo rechaza; aggrega pull, una compilación, aggrega validate --release y la herramienta de compilación que expone aggrega mcp lo informan para una Release que llega a la Recipe, antes de la referencia a la Recipe que por ese motivo ya no pudo resolverse. Por eso un pull nombra esta condición en lugar de informar de la referencia vacía como una cuyo tipo de source no sabe determinar. Se comprueba antes de las reglas que leen si hay un source declarado, de modo que a una Recipe cuyo source: está vacío se le informa del source: y no de un valuesMapping sin nada que superponer ni de un tipo de entrada que falta.
Mensaje emitido, situado en el archivo de la Recipe en el que se escribió el source: vacío y en la clave que contiene — .spec.source — y no en un componente que enlaza la Recipe, porque la entrada la comparten todos los componentes que lo hacen:
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 (el campo source de la receta es una cadena vacía, que no nombra ni el modo sourceless ni el modo sourced. omite el campo source para el modo sourceless, o nombra una ruta o un URI no vacíos para el modo sourced)
La compilación imprime la línea bajo una etiqueta CATALOG_ERROR con el código corto de esta condición, E0251, y el archivo de la Recipe junto a ella.
Cómo corregirlo: omite por completo el campo source: (o ponlo a null) si la Recipe es sourceless, o proporciona una ruta / URI / objeto source estructurado no vacío si la Recipe es sourced.
No Recipe is mapped for a component or feature instance (Ninguna Recipe está mapeada para una instancia de componente o de funcionalidad)
El tipo de una instancia no tiene ningún mapeo del Manifest que se resuelva en una Recipe que contenga el catálogo. La selección de la Recipe es solo por mapeo: el compilador nunca elige una Recipe leyendo spec.implements: y eligiendo entre los candidatos, así que un tipo sin mapeo provoca una detención, por muchas Recipes que lo implementen. implements orienta la elección; el autor la toma; el Manifest la registra.
La misma condición cubre un mapeo que existe pero no lleva a ninguna parte — un valor con una estructura de referencia aceptada que nombra una Recipe que el catálogo no contiene, incluida una presente con una versión distinta de la que fija el valor, y una cuyo nombre simple ofrecen a la vez dos capacidades. Ninguna se resuelve en una Recipe que pueda decirse que el autor eligió. Un valor de mapeo cuya estructura no puede expresar ninguna referencia se informa por separado, en «Manifest mapping value is not a shape a recipe reference accepts (El valor de mapeo del Manifest no tiene una estructura que acepte una referencia de receta)» más arriba, de modo que la afirmación de que una entidad está ausente solo se hace sobre una referencia que podría haberse resuelto.
Mensajes emitidos, para una instancia de componente. Donde existe un mapeo y nombra algo ausente:
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 (no se resolvió ninguna receta para la instancia de componente/funcionalidad: añade un mapeo explícito del Manifest para su tipo (Manifest, con la instancia, su tipo y la receta a la que está mapeada). corrige el valor del mapeo en el Manifest, o publica la receta que nombra)
Donde no existe ningún mapeo y hay Recipes que implementan el tipo, se enumeran como los candidatos que fijar:
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 (no se resolvió ninguna receta para la instancia de componente/funcionalidad: añade un mapeo explícito del Manifest para su tipo (Manifest, con la instancia, su tipo y las recetas que lo implementan). fija una de ellas en el Manifest)
Y donde nada implementa el tipo, no hay nada que enumerar:
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 (no se resolvió ninguna receta para la instancia de componente/funcionalidad: añade un mapeo explícito del Manifest para su tipo (Manifest, con la instancia y su tipo). ninguna receta del catálogo implementa este tipo; escribe una y luego mapea el tipo a ella)
En un espacio de trabajo que no nombra ningún directorio de catálogo, las Recipes buscadas son solo las que fija el lockfile: las de un registro no se listan, y un Manifest que no asigna ninguna para el tipo no fija ninguna. Allí, cuando ninguna Recipe fijada implementa el tipo, la ausencia se afirma respecto a lo fijado y no respecto al catálogo, y el mensaje lo indica:
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 (no se resolvió ninguna receta para la instancia de componente/funcionalidad: añade en el Manifest una asignación explícita para su tipo (Manifest, en la posición, para la instancia y del tipo indicados). ninguna receta fijada por el lockfile implementa este tipo; sin directorio de catálogo, las recetas buscadas son solo las que fija el lockfile, no las de un registro; fija en el Manifest una que publique un registro, o escribe una y luego asigna el tipo a ella)
A un tipo que el Aggregate escribe sin versión se le ofrecen las Recipes que implementan la versión con la que la compilación lo compila — la versión más alta de ese Component que contiene el catálogo. A una instancia de core/datastore/postgres, con el catálogo conteniendo ese Component en 1.0.0, se le ofrece toda Recipe que declare spec.implements: core/datastore/postgres:1.0.0, así como cualquiera que declare el tipo sin versión o un rango caret que admita 1.0.0. A un tipo del que el catálogo no contiene ningún Component solo se le ofrecen las Recipes que declaran ese mismo tipo sin versión.
Una instancia de funcionalidad informa estos casos con una forma propia, cada uno después de la frase de la condición. Un tipo de funcionalidad que el Aggregate escribe sin versión se empareja como un tipo de componente, en la versión con la que la compilación lo compila — la versión más alta de esa Feature que contiene el catálogo —, y un mensaje que nombra <type>:<version> nombra el tipo en esa versión, que es lo que se buscó en el catálogo. Cuando se conoce la Recipe a la que está asignado el componente de una asociación, las FeatureRecipes se distinguen por la capacidad a la que se vincula esa Recipe: las que se vinculan a la capacidad del componente se ofrecen primero, y una FeatureRecipe que se vincula a otra capacidad se renderiza igualmente, como su propia salida junto a la del componente en lugar de dentro de ella, así que, cuando ninguna se vincula a la capacidad del componente, se ofrecen esas en su lugar. Una asignación que no lleva a ninguna parte dice feature "<instance>" (type "<type>"): the Manifest maps it to feature recipe "<uri>", which is not in the catalog. Cuando hay FeatureRecipes que implementan el tipo para la capacidad del componente, solo se listan esas: 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. Cuando lo implementan solo para otras capacidades: 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. Cuando ninguna implementa el tipo en absoluto: feature "<instance>" (type "<type>"); no feature recipe in the catalog implements <type>:<version>; write one, then map the type to it. Y cuando no se conoce la capacidad — la propia asignación del componente no se resuelve en ninguna Recipe, lo que se informa por separado, o la asociación está escrita en una frontera, cuyos componentes pueden renderizarse mediante varias capacidades —, se lista cada implementación: feature "<instance>" (type "<type>"); feature recipes implementing it: [<recipe-uris>]; pin one in the Manifest. En un espacio de trabajo que no nombra ningún directorio de catálogo, las FeatureRecipes buscadas son solo las que fija el lockfile: las de un registro no se listan, y un Manifest que no asigna ninguna para el tipo no fija ninguna. Allí las afirmaciones de ausencia se hacen respecto a lo fijado y no respecto al catálogo, y lo indican. Cuando ninguna implementa el tipo: feature "<instance>" (type "<type>"); no feature recipe the lockfile pins implements <type>:<version> for capability "<capability>", the capability its component's Recipe binds to; with no catalog directory, the feature recipes searched are only those the lockfile pins, not a registry's; pin one a registry publishes in the Manifest, where one for another capability renders as its own output beside the component's, or write one for "<capability>", then map the type to it — y cuando no se conoce la capacidad, el mensaje no nombra ninguna y termina con pin one a registry publishes in the Manifest, or write one, then map the type to it. Cuando hay FeatureRecipes fijadas que lo implementan solo para otras capacidades, el mensaje para ese caso dice no feature recipe the lockfile pins implements en lugar de no feature recipe in the catalog implements, con la misma cláusula después de la capacidad.
Cómo corregirlo: añade el mapeo que pide el mensaje, bajo spec.mappings.components.type en el Manifest, con el tipo de componente como clave y la Recipe como valor. Donde el mensaje enumera candidatos, elige uno — esa lista son exactamente las Recipes que declaran implementar el tipo en la versión a la que la compilación lo resuelve. Donde nombra una Recipe que no está en el catálogo, corrige el valor o añade la Recipe a un directorio de catálogo que lea la compilación; una versión en el valor tiene que coincidir con una versión que contenga el catálogo. Donde nada implementa el tipo, la pieza que falta es la propia Recipe. Donde el mensaje dice que las recetas o recetas de funcionalidad buscadas son solo las que fija el lockfile, el espacio de trabajo no lee ningún directorio de catálogo, así que un registro puede publicar igualmente una Recipe o una FeatureRecipe que implemente el tipo: asignar el tipo a ella en el Manifest es lo que hace que el pull la descargue y la fije.
A Manifest name mapping names nothing in the build (Un mapeo por nombre del Manifest no nombra nada de la compilación)
Una clave bajo spec.mappings.components.name o spec.mappings.features.name no nombra ninguna instancia de componente, ni ninguna vinculación, que contenga la compilación. El nivel name se compara con el nombre exacto de lo que se realiza: una clave components.name con el nombre de una instancia de componente tal como lo escribe el Aggregate, y una clave features.name con el nombre propio de una vinculación — la clave bajo la que está escrita en los features: de un componente, o <alias>.<slot> para una vinculación escrita en una conexión — nunca con el nombre del componente en el que se encuentra la vinculación. Una clave que no nombra nada nunca se consultaría: cada instancia a la que estaba destinada se resolvería mediante el nivel type, y la compilación terminaría sin decir una palabra sobre la entrada que ignoró. Por eso la compilación se detiene, antes de que se renderice nada.
El mensaje nombra el Manifest, la clave y la sección en la que está escrita, los nombres de esa clase que la compilación sí contiene — restringidos al tipo que implementa la Recipe o la FeatureRecipe de la entrada, donde ese tipo se conoce y la compilación contiene uno de él — y, donde puede saberlo, el nombre que probablemente querías decir: para una clave features.name que es el nombre de un componente, las vinculaciones de ese tipo que lleva el componente; para una clave components.name que es el nombre de una vinculación, el componente que la lleva; y, en otro caso, un nombre a una edición de distancia.
Mensaje emitido, para una clave features.name escrita como el nombre del componente en el que se encuentra la vinculación:
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 clave de un mapeo por nombre del Manifest no nombra ninguna instancia de componente ni vinculación de esta compilación, así que la entrada no enlaza nada: Manifest, clave bajo mappings.features.name: ninguna vinculación de esta compilación se llama así; una clave features.name nombra una vinculación por su propio nombre — la clave bajo la que está escrita en los features de un componente, o el alias y el slot para una escrita en una conexión — nunca el componente al que está vinculada; vinculaciones del tipo indicado en esta compilación: enumeradas; ese nombre es un componente, y una clave features.name nombra la vinculación y no el componente al que está vinculada — ¿querías decir la vinculación sugerida?)
Y para una clave components.name a una edición de distancia del nombre de una instancia:
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 clave de un mapeo por nombre del Manifest no nombra ninguna instancia de componente ni vinculación de esta compilación, así que la entrada no enlaza nada: Manifest, clave bajo mappings.components.name: ninguna instancia de componente de esta compilación se llama así; una clave components.name nombra una instancia de componente exactamente como la escribe el Aggregate; instancias de componente del tipo indicado en esta compilación: enumeradas; ¿querías decir la instancia sugerida?)
Cada clave que no nombra nada se informa en una sola compilación, en el orden en que el Manifest las escribe.
Cómo corregirlo: cambia el nombre de la clave al que sugiere el mensaje, o a uno de los nombres que enumera — para una vinculación, el nombre bajo el que está escrita, no el de su componente. Si la entrada ya no se quiere, elimínala; las instancias de ese tipo se resuelven entonces mediante el nivel type.
A Manifest maps two version-distinct keys onto one type (Un Manifest asigna dos claves de versión distinta a un mismo tipo)
Una búsqueda por tipo coincidió con más de una clave de mapeo del Manifest. Las claves de tipo se comparan con tolerancia de versión, de modo que core/api-server, core/api-server:1.0.0 y core/api-server:2.0.0, escritas como claves de mapeo separadas, responden todas por el mismo tipo base — y una búsqueda que alcanza dos de ellas tiene dos Recipes entre las que elegir y ninguna regla para preferir una.
La compilación se detiene en lugar de resolver la clave que haya leído primero. Elegir una haría que la salida renderizada dependiera del orden en que se recorrió el mapeo, que es exactamente lo que la salida idéntica byte a byte descarta.
Mensaje emitido:
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 (el Manifest asigna varias claves de versión distinta al mismo tipo base; la búsqueda de tipo a Recipe es ambigua: el tipo coincide con claves de versión distinta — fija la versión del tipo escrito o elimina las claves de mapeo duplicadas)
Cómo corregirlo: dos direcciones, y el mensaje nombra ambas. Elimina las claves de mapeo duplicadas y conserva la que debe responder por el tipo — esto es lo correcto cuando las claves adicionales son restos de un cambio de versión. O fija la versión en el lado de la autoría, de modo que el tipo que declara el componente nombre exactamente la clave que querías, lo cual es lo correcto cuando las varias claves son deliberadas y distintos componentes realmente quieren Recipes distintas.
Two catalog entities in one directory share an identity (Dos entidades del catálogo en un mismo directorio comparten una identidad)
Dos entidades del mismo tipo, cargadas desde el mismo directorio de catálogo, tienen la misma identidad. Una identidad es lo que nombra una referencia, así que dos archivos que reclaman una misma identidad dejan a cada referencia a ella con dos respuestas.
Dentro de un directorio esto detiene la compilación; entre directorios, no. La misma identidad presente en dos directorios de catálogo distintos se resuelve como un ocultamiento en el que gana el primero — gana el directorio listado antes —, que es lo que permite a un directorio local sobrescribir deliberadamente una entidad publicada. Solo una colisión dentro de un mismo directorio es un error de autoría que ninguna lectura vuelve intencionado.
La regla es la misma para cada tipo de entidad indexado: Component, Feature, Recipe, FeatureRecipe, Plugin, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary y Aggregate. La detención se sitúa en el segundo archivo y nombra el tipo y la identidad que colisionaron.
Mensaje emitido:
duplicate entity identity within a single catalog directory (Component identity "<identity>") (identidad de entidad duplicada dentro de un mismo directorio de catálogo (identidad de Component))
con la palabra propia del tipo en lugar de Component — recipe identity, feature recipe identity, Plugin identity, SchemaLibrary identity y así sucesivamente.
Cómo corregirlo: cambia el nombre de una de las dos entidades o muévela a un directorio propio. Para una Recipe o una FeatureRecipe, la identidad incluye el ámbito del proveedor y la versión, así que dos archivos que solo difieren en la versión no colisionan — una colisión real ahí significa que la misma versión se publicó dos veces. La causa habitual es copiar el archivo de una entidad para empezar una nueva y olvidar cambiar metadata.name.
A file the operation reads leads through a link out of the directory it must stay inside (Un archivo que la operación lee lleva, a través de un enlace, fuera del directorio dentro del cual debe permanecer)
Dos lugares se leen como un todo en lugar de un archivo cada vez: un directorio de catálogo, desde cualquier documento bajo el cual puede responder una búsqueda por nombre, y el directorio que contiene una Release, contra cuyos Aggregates y Manifests se resuelve una Release que los nombra por identidad. Un enlace simbólico entre esos archivos puede llevar a cualquier parte de la máquina, así que cada uno de esos directorios tiene un directorio dentro del cual deben permanecer sus lecturas, y un enlace que sale de él no se lee. El límite del espacio de trabajo establece la regla que se aplica aquí y las demás rutas a las que afecta.
Qué directorio es depende de dónde se encuentre el directorio que se lee:
El espacio de trabajo, para un directorio de catálogo o el directorio de una Release que esté dentro de él. Esto vale para el directorio convencional catalog del espacio de trabajo siempre que nadie lo haya nombrado — cuando se lee solo porque está ahí: entonces es del propio espacio de trabajo, así que un catalog que sea a su vez un enlace que lleva fuera del espacio de trabajo no se lee.
Un directorio que nombraste y que está fuera del espacio de trabajo, para lo que está debajo de él: un directorio de catálogo que pasas con --catalog, o que la configuración del espacio de trabajo incluye en catalog_dirs — para el espacio de trabajo o para una sola Release —, y el directorio de una Release que nombras, o que nombra la configuración, que está fuera del espacio de trabajo. El directorio en sí se usa tal como lo nombraste — uno que es un enlace se lee allí adonde apunta — y lo que se lee debajo de él permanece dentro de él. Eso incluye el directorio convencional catalog una vez que lo nombras: incluido en catalog_dirs, o pasado con --catalog, un catalog que es un enlace que lleva fuera del espacio de trabajo se lee allí adonde apunta, como cualquier otro directorio que nombres. Nombrar en su lugar el sitio al que apunta, con cualquier grafía, o un directorio por encima de ese sitio, también lo nombra: el directorio que nombraste ya lee lo que hay allí, así que se lee una sola vez, a través de ese directorio. Nombrar un directorio en la configuración es la forma en que un espacio de trabajo lee entidades guardadas fuera de él.
Lo que se juzga es cada entrada de la que la lectura tomaría algo: un enlace a un archivo con nombre de documento YAML, y un enlace a un directorio, que puede contener documentos propios. Un enlace que lleva a algún lugar dentro del directorio en el que debe permanecer la lectura se lee donde el recorrido lo encuentra. Un enlace a un archivo del que ninguna lectura del catálogo toma nada — un archivo de notas, un archivo comprimido de chart — no se juzga aquí, y un enlace que no lleva a ninguna parte no tiene nada detrás que leer.
Una búsqueda de la que depende una compilación se detiene en un enlace así en lugar de pasarlo por alto. La entidad detrás del enlace podría ser la que nombra una referencia, y pasarla por alto en silencio permitiría que otra entidad del mismo nombre, de un directorio de catálogo posterior, se resolviera en su lugar. Así, aggrega build, aggrega pull, aggrega validate, aggrega inspect dondequiera que lea el catálogo, un lint de una sola Release, y las solicitudes del editor y de un asistente que compilan, previsualizan, grafican, validan o describen una Release se detienen todos antes de resolver nada, nombrando el enlace. Un lint de todo el catálogo se detiene del mismo modo: su veredicto responde por cada documento que contienen los directorios de catálogo, así que no informa de un catálogo limpio mientras uno de ellos no pudo leerse. El directorio de la Release se somete a la misma regla dondequiera que una Release nombre su Aggregate o su Manifest por identidad, o que un Manifest nombre así el Manifest que extiende, y el escaneo se detiene en un enlace entre los documentos junto a la Release aunque el enlace no sea el que nombra una referencia, por la misma razón por la que allí lo detiene un duplicado: el directorio no puede responder por un nombre mientras uno de sus documentos no pueda leerse. La Release sobre la que se invocó la operación — o un Manifest que inspeccionas por sí solo — no es uno de esos documentos: se leyó donde se nombró, así que una Release que es a su vez un enlace que lleva fuera se lee allí adonde apunta, y lo que nombra se busca junto al enlace, en el directorio en el que la nombraste (Una Release o un Manifest nombrados a través de un enlace).
Un listado, en cambio, pasa por alto un enlace así y no lista nada de lo que hay detrás. El índice de entidades del editor, sus autocompletados y los candidatos que ofrece no listan una entidad representada por un enlace que lleva fuera, y el índice de entidades nombra un enlace así dentro del espacio de trabajo entre los enlaces que no leyó.
Los archivos de configuración del espacio de trabajo se someten al espacio de trabajo del mismo modo. Cada .aggrega-config.yaml desde la raíz del espacio de trabajo hasta el directorio en el que se ejecuta un comando, y el .aggrega-config-append-ci.yaml que un pipeline guarda junto a cualquiera de ellos, es contenido propio del espacio de trabajo. Uno que sea un enlace que lleva fuera del espacio de trabajo — o al que se llega a través de un enlace de directorio que lleva fuera — no se lee, y como cada comando, el servidor de lenguaje del editor y las herramientas de un asistente leen la configuración antes que cualquier otra cosa, cada uno se detiene ahí, nombrando el enlace, en lugar de ejecutarse con una configuración hecha de lo que quedara. El servidor de lenguaje, y el servidor de un asistente que se comunica por sus propios flujos, arrancan igualmente sobre un espacio de trabajo así: los listados de sus Releases y de sus entidades responden, leídos sin nada configurado, y nombran el archivo entre los enlaces que no leyeron, mientras que cualquier otra solicitud que decide la configuración se rechaza con esta condición, nombrando el enlace. El remedio que nombra este mensaje es el propio de la configuración: el archivo de configuración global es la única configuración que se lee dondequiera que se guarde, nombrada con --config o AGGREGA_CONFIG.
El archivo de bloqueo de una Release se somete del mismo modo, tanto donde se lee como donde se escribe. El archivo de bloqueo junto a una Release se lee para obtener las fijaciones contra las que resuelven una compilación, un pull, una validación, un lint, una inspección, aggrega cache prune y las solicitudes del editor y de un asistente, y se somete al directorio al que se somete su escritura: el espacio de trabajo, o el directorio propio de la Release para una Release nombrada fuera de él. Uno que sea un enlace que lleva fuera no se lee, y cada una de esas operaciones se detiene nombrando el enlace en lugar de resolver contra fijaciones guardadas en otro lugar de la máquina, o sin ellos. El remedio que nombra este mensaje es el propio del archivo de bloqueo: tiene un único lugar, junto a la Release, donde lo escribe un pull.
Un archivo leído junto a una entidad se somete del mismo modo. Dos operaciones leen un archivo que está junto al documento propio de una entidad en lugar de uno que nombra una referencia. Fijar una entidad, o publicarla, lee cada uno de los demás documentos YAML del directorio de la entidad para saber si otra entidad lo comparte. Cargar una entidad Plugin escrita en un directorio de catálogo lee el .wasm compilado depositado junto a ella. Cada uno se somete al directorio bajo el que se leyó el documento propio de la entidad — el espacio de trabajo, un directorio de catálogo que nombraste fuera de él o, para una entidad que fijas o publicas nombrando su documento fuera del espacio de trabajo, el directorio propio de ese documento — y uno que sea un enlace que lleva fuera de él no se lee. aggrega pin, aggrega push con o sin --dry-run, un pull que fija, y la fijación y la publicación del editor y de un asistente se detienen nombrando el enlace, porque un documento que quedó sin leer podría ser la entidad que estorba. Una compilación o un pull que carga el plugin también se detiene nombrando el enlace, en lugar de ejecutar bytes guardados en otro lugar de la máquina o de buscar el plugin en otra parte. El remedio que nombra este mensaje es el propio de un archivo junto a una entidad: guarda allí el archivo en sí.
La caché de artefactos del espacio de trabajo se somete del mismo modo, tanto donde se lee como donde se escribe. Todo lo que se lee de la caché bajo artifact_cache_dir — una entidad, un plugin o una biblioteca en caché y el manifiesto junto a ellos, un archivo de código fuente y sus metadatos, una entrada externa fijada, un bundle de firma, el índice de búsqueda local de un registro — y cada entrada del espacio de trabajo que listan aggrega cache status, aggrega cache prune y aggrega cache clear, se somete al directorio al que se somete una escritura en la caché: el propio directorio de la caché, tanto el predeterminado .aggrega/cache como uno que la configuración nombre subiendo fuera de la raíz del espacio de trabajo. Cualquier cosa en ella que sea un enlace que lleva fuera del directorio de la caché — a otro lugar dentro del espacio de trabajo tanto como a cualquier otro sitio — no se lee, y tampoco nada detrás de un directorio de caché escrito dentro de la raíz del espacio de trabajo que sea a su vez un enlace que lleva fuera del espacio de trabajo: una compilación, un pull, una validación, una búsqueda, los tres comandos de la caché y las solicitudes del editor y de un asistente que leen la caché se detienen nombrando el enlace — incluido el contenido que la caché guarda bajo un digest registrado, ya que un digest dice qué son los bytes, no desde dónde pueden leerse. Un directorio de caché escrito dentro de la raíz del espacio de trabajo que sea un enlace a otro lugar dentro del espacio de trabajo se lee allí adonde lleva. El aviso de obsolescencia que imprime aggrega inspect, que no decide nada, queda fuera. Un prune o un clear trata uno de los directorios propios de la caché que sea un enlace que lleva fuera del directorio de la caché, o un directorio de caché que sea a su vez un enlace que lleva fuera del espacio de trabajo, como la eliminación que sería, bajo «A path the operation writes leads through a link out of the directory it must stay inside (Una ruta que la operación escribe lleva, a través de un enlace, fuera del directorio dentro del cual debe permanecer)», antes de listar nada. El remedio que nombra este mensaje es el propio de la caché: una vez eliminado el enlace, un pull vuelve a llenar la caché, y una caché guardada en otro lugar se nombra con artifact_cache_dir, relativa a la raíz del espacio de trabajo, en lugar de alcanzarse a través de un enlace.
Un repositorio que obtiene una fuente se somete a su propio checkout. Cuando un pull — aggrega pull, o una compilación o una solicitud del editor o de un asistente que resuelve las dependencias de una Release — obtiene una fuente git-repository, hace checkout del repositorio y archiva el directorio que nombra la fuente, y el checkout es un directorio propio: cada enlace que contiene el repositorio, incluido el propio module_subdir, se somete a él. Un enlace a un archivo o a un directorio dentro del repositorio se archiva como aquello a lo que apunta, con el nombre del enlace. Un enlace que lleva fuera del repositorio — que podría apuntar a cualquier archivo de la máquina que ejecuta el pull — no se lee: el pull se detiene nombrando el enlace y adónde lleva, y no se guarda nada en caché. El checkout es un directorio temporal que se elimina en cuanto el pull se detiene, así que el mensaje nombra el enlace por su lugar en el repositorio — chart/secret.txt, como en la primera línea de la salida de la línea de comandos y en la frase — y el directorio dentro del cual debe permanecer como el repositorio y la revisión que nombra la fuente: which must stay inside the repository <url> at <ref> (commit <commit>), o at commit <commit> cuando la fuente no nombra ningún ref o nombra el propio commit. Adónde lleva el enlace se nombra como el lugar de tu máquina que es. El remedio que nombra este mensaje es el propio del repositorio: el enlace está confirmado allí, así que se cambia allí — haciéndolo apuntar dentro del repositorio, o sustituyéndolo por el archivo en sí — y la fuente nombra entonces una revisión que contiene el cambio. Un enlace de directorio que lleva de vuelta a un directorio que el archivado ya está leyendo a través de él también detiene el pull, porque el árbol que representa no tiene fin; ese rechazo es un error simple y no esta condición.
Las superposiciones que lee una generación de catálogo se someten del mismo modo.aggrega plugin gen-catalog --from-embedded lee cada superposición bajo el directorio de superposiciones que recibe — escrito con --overlay, elegido en el editor o nombrado por un asistente — y somete cada una al directorio bajo el que se lee ese directorio de superposiciones: el espacio de trabajo, para un directorio de superposiciones dentro de él, y el propio directorio de superposiciones para uno nombrado fuera del espacio de trabajo. El directorio de superposiciones se usa tal como lo nombraste — uno que es un enlace se lee allí adonde apunta. Una superposición bajo él que sea un enlace que lleva fuera del directorio al que se somete no se lee, y tampoco un enlace de directorio que lleva fuera de él, que puede contener superposiciones propias: la generación se detiene nombrando el enlace, sin escribir nada, en lugar de generar sin la superposición. Una superposición que es un enlace que lleva a otro lugar dentro del directorio al que se somete se lee allí adonde apunta; en un enlace de directorio que lleva dentro de él no se entra. El remedio que nombra este mensaje es el propio de una superposición: guarda la superposición en sí bajo el directorio de superposiciones, o nombra como directorio de superposiciones un directorio que contenga todas las superposiciones.
Un directorio que importas queda limitado a sí mismo.aggrega import con un directorio, la herramienta de importación del asistente y el método aggrega/import de la sesión entregan al importador los archivos del directorio que seleccionan sus patrones de archivo, cada uno en su lugar dentro del directorio, de modo que el directorio es aquel dentro del cual permanecen esas lecturas, dondequiera que esté — dentro del espacio de trabajo tanto como fuera de él. Lo que se evalúa es cada entrada de la que la importación tomaría algo: un enlace a un archivo que selecciona uno de los patrones pertinentes — los patrones del importador que sirve el formato indicado o, donde el formato se reconoce, los de cada importador entre los que elige la importación, incluidos los importadores core del compilador — y un enlace a un directorio, en el que nunca se entra. Un enlace que sale del directorio, hacia otro lugar del espacio de trabajo o a cualquier otro sitio, no se lee: la importación se detiene nombrando el enlace antes de que se abra ningún archivo del directorio, sin escribir nada. Un enlace seleccionado a un archivo situado en otro lugar dentro del directorio se lee donde apunta, con el nombre propio del enlace, y un enlace a un archivo que ningún patrón selecciona no se evalúa ni se lee. El propio directorio se usa tal como lo nombraste — uno que es un enlace se lee donde apunta. Alcanzada a través de un listener, la herramienta del asistente nombra el enlace por su lugar en el espacio de trabajo y no dice nada de adónde lleva. El remedio que nombra este mensaje es el propio de un directorio importado: conserva el archivo en sí en el directorio en lugar de un enlace a él, o importa el directorio al que lleva el enlace.
Mensaje emitido. Se abre con la frase propia de la condición, luego la ruta que alcanzó la lectura, el directorio dentro del cual debe permanecer, el enlace que encuentra en el camino y el lugar al que lleva ese enlace, y luego el remedio:
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 archivo que lee esta operación sale, a través de un enlace, del directorio dentro del cual debe permanecer (al leer un archivo que debe permanecer dentro del espacio de trabajo, el enlace lleva a otro lugar). no se leyó nada a través de ese enlace. Elimina el enlace, o haz que lleve a un lugar dentro del espacio de trabajo. Para leer lo que se guarda fuera, enumera el directorio que lo contiene como directorio de catálogo en la configuración del espacio de trabajo, en lugar de alcanzarlo mediante un enlace bajo uno de ellos: un directorio enumerado se lee donde lleva, incluso cuando es en sí mismo un enlace)
El diagnóstico no lleva categoría: lo que falla es la disposición en disco, no un documento que hayas escrito.
Cómo corregirlo: sustituye el enlace por una copia de aquello a lo que lleva, o elimínalo; o, donde la entidad deba permanecer fuera del espacio de trabajo, enumera el directorio que la contiene en catalog_dirs en la configuración del espacio de trabajo, o pásalo con --catalog, de modo que el directorio se lea como un directorio de catálogo propio. Enumera el directorio al que lleva el enlace, no aquel en el que se encuentra: un enlace encontrado bajo un directorio se evalúa igual sea cual sea la forma en que se leyó ese directorio, así que enumerarlo no cambia nada. Donde el enlace es el propio directorio catalog convencional del espacio de trabajo, basta con enumerar catalog — o el directorio al que apunta — en catalog_dirs, o pasar cualquiera de los dos con --catalog, ya que un directorio que nombras se lee donde apunta. Donde el enlace es el archivo de bloqueo de una Release, elimínalo y vuelve a hacer el pull de la Release, que escribe un archivo de bloqueo nuevo junto a ella. Un Manifest no tiene nivel de catálogo, así que un Manifest que lee la Release se guarda junto a la propia Release. Donde el enlace es un archivo de configuración, sustitúyelo por una copia guardada en el espacio de trabajo; una configuración que quieras compartir entre espacios de trabajo se lee nombrándola como archivo de configuración global, con --config o AGGREGA_CONFIG, por debajo de los archivos propios de cada espacio de trabajo. Donde el enlace está junto a una entidad que se fija o se publica, sustitúyelo por el propio archivo, o mueve un documento que sea una entidad a un directorio propio; donde es el .wasm junto a una entidad Plugin, coloca allí el propio .wasm compilado. Donde el enlace es el directorio de la caché de artefactos o algo dentro de él, elimínalo — un pull vuelve a llenar la caché — o, para guardar la caché en otro lugar, establece artifact_cache_dir en ese directorio, escrito de forma relativa a la raíz del espacio de trabajo (../shared-cache). Donde el enlace está confirmado en un repositorio que recupera una fuente git-repository, cámbialo en ese repositorio — haz que apunte dentro del repositorio, o confirma el propio archivo — y nombra la revisión que contiene el cambio. Donde el enlace es una superposición bajo el directorio de superposiciones de una generación de catálogo, sustitúyelo por la propia superposición, o nombra como directorio de superposiciones un directorio que contenga todas las superposiciones. Donde el enlace está en un directorio que importas, conserva el archivo en sí en el directorio en lugar de un enlace a él, o importa el directorio al que lleva el enlace.
A reference to another file leads out of the directory it must stay inside (Una referencia a otro archivo sale del directorio dentro del cual debe permanecer)
Una Release y un Manifest pueden nombrar otro archivo mediante una ruta: los aggregate: y manifest: de una Release escritos como ./… o ../…, su extends:, el extends: de un Manifest escrito como ruta, y los parameters: { $import: … } de una Release. Un documento del espacio de trabajo solo alcanza de esa forma archivos dentro del espacio de trabajo. Una Release que se encuentra fuera del espacio de trabajo — una que nombras en la línea de comandos, o una que nombra la configuración del espacio de trabajo — y un Manifest que nombras por sí solo en la línea de comandos fuera del espacio de trabajo solo alcanzan archivos dentro de su propio directorio: ese directorio es una raíz propia, como lo es un directorio que nombras fuera del espacio de trabajo, y cada Release a la que lleva su cadena extends: queda limitada al mismo directorio. Una ruta que, tal como está escrita, sube fuera de ese directorio, y una ruta que permanece dentro tal como está escrita pero encuentra en el camino un enlace simbólico que lleva fuera, se rechazan ambas, y no se lee nada del archivo que nombran. Una ruta que lleva a un archivo que aún no existe bajo el directorio no se rechaza aquí; se informa como un archivo que no se pudo leer. El límite del espacio de trabajo explica por qué se limita una referencia además de la ruta que nombras.
Desde dónde se resuelve una ruta sigue la misma regla que la referencia del lenguaje enseña para cada clave: los aggregate: y manifest: de una Release, y el extends: de un Manifest, junto a la Release que nombra un comando o una solicitud — o, para un Manifest que nombras por sí solo, junto a ese Manifest; el extends: de una Release y un $import: de los parámetros, junto a la Release que lo escribe, de modo que cada eslabón de una cadena extends: nombra a su padre junto a sí mismo. El diagnóstico nombra el directorio desde el que se resolvió.
Un nombre en lugar de una ruta no se evalúa aquí — aggregate: payments, extends: base-manifest. Se busca entre los documentos junto a la Release y, para un Aggregate, en los directorios de catálogo, que quedan limitados por la regla de «A file the operation reads leads through a link out of the directory it must stay inside (Un archivo que la operación lee lleva, a través de un enlace, fuera del directorio dentro del cual debe permanecer)» más arriba.
Cada superficie que resuelve lo que nombra una Release se detiene en ello, antes de que se lea el archivo: aggrega pull, aggrega build, aggrega validate, aggrega inspect de una Release o de un Manifest, un lint de una sola Release, y las solicitudes del editor y de un asistente que compilan, previsualizan, representan como grafo, validan o describen una Release. En el editor, el diagnóstico se coloca en la clave de la Release que llevó al archivo.
Mensaje emitido. Se abre con la frase propia de la condición, luego la referencia tal como está escrita, el documento en el que está escrita para un extends: y un $import: de los parámetros, el directorio desde el que se resuelve, el lugar al que lleva, el directorio dentro del cual debe permanecer, y el enlace donde uno la saca fuera; luego el remedio. Para un documento del espacio de trabajo:
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 (una referencia que hace un documento a otro archivo sale del directorio dentro del cual debe permanecer: la referencia, resuelta desde el espacio de trabajo, lleva fuera del espacio de trabajo. no se leyó nada de ese archivo. Un documento del espacio de trabajo solo alcanza archivos dentro del espacio de trabajo: mueve allí el archivo — o, donde un enlace saca fuera la referencia, haz que el enlace lleve allí — o abre el espacio de trabajo en un directorio que contenga ambos documentos. Un Aggregate guardado fuera de ese directorio se alcanza por su nombre en lugar de por una ruta, desde un directorio de catálogo que enumera la configuración del espacio de trabajo)
y para una Release o un Manifest nombrados fuera del espacio de trabajo, cuyo propio directorio es aquel dentro del cual deben permanecer:
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 (una referencia que hace un documento a otro archivo sale del directorio dentro del cual debe permanecer: la referencia, resuelta desde el directorio, lleva fuera del directorio de un documento nombrado fuera del espacio de trabajo. no se leyó nada de ese archivo. Una Release o un Manifest nombrados fuera del espacio de trabajo — en la línea de comandos, o por la configuración del espacio de trabajo — solo alcanzan archivos dentro de su propio directorio: mueve allí el archivo — o, donde un enlace saca fuera la referencia, haz que el enlace lleve allí — o nombra el documento desde un espacio de trabajo que contenga ambos documentos. Un Aggregate guardado fuera de ese directorio se alcanza por su nombre en lugar de por una ruta, desde un directorio de catálogo que enumera la configuración del espacio de trabajo)
con written in <document> después de la referencia para un extends: o un $import: de los parámetros, y the link <link> leads to <place> al final, donde un enlace saca fuera la ruta. Una referencia aggregate: o manifest: no nombra ningún documento: una Release que extiende otra puede haberla heredado de una Release más arriba en la cadena, y se resuelve junto a la Release que nombra el comando en cualquier caso.
La categoría del diagnóstico es [OPS_ERROR]: la referencia está escrita en una Release o en un Manifest.
Cómo corregirlo: para un Aggregate guardado fuera del espacio de trabajo, escribe su metadata.name en lugar de una ruta, y enumera el directorio que lo contiene en catalog_dirs en la configuración del espacio de trabajo, o pásalo con --catalog — un directorio de catálogo es la forma en que un espacio de trabajo alcanza entidades guardadas fuera de él. Un Manifest, una Release que nombra un extends: y un archivo de parámetros se leen junto a la Release y nunca se buscan por nombre, así que mantenlos dentro del espacio de trabajo, o abre el espacio de trabajo en un directorio que contenga tanto la Release como el archivo. Para una Release o un Manifest que nombraste desde fuera del espacio de trabajo, mantén lo que nombra en su propio directorio, o compílalo en el espacio de trabajo que contiene tanto el documento como lo que nombra. Donde un enlace saca fuera la ruta, sustituye el enlace por una copia de aquello a lo que lleva, o haz que lleve dentro del directorio.
No catalog version satisfies a version constraint (Ninguna versión del catálogo satisface una restricción de versión)
Una referencia nombra una entidad que el catálogo contiene y fija una versión que el catálogo no contiene: una versión exacta que falta, o un rango caret con el que no coincide nada disponible. Se distingue de una simple ausencia, en la que el propio nombre es desconocido — aquí la entidad existe y solo la versión no puede satisfacerse, por eso el mensaje lo dice en lugar de informar de la entidad como ausente y enviarte a buscar una errata en el nombre.
Todo tipo de entidad llega aquí a través de una única selección, de modo que una fijación imposible de satisfacer se comporta igual dondequiera que esté escrita: una errata de versión en el mapeo de una Recipe de un Manifest se rechaza exactamente igual que la misma errata en un tipo de componente.
La condición es recuperable, lo que permite al editor mostrarla como diagnóstico mientras sigues escribiendo en lugar de abandonar el documento. En la línea de comandos se une en una detención.
Mensaje emitido, para una referencia que alcanzan las dependencias de una Release — un tipo de componente, un valor de mapeo de un Manifest — indicando dónde se recogió:
no catalog version satisfies the referenced version constraint: entity "<reference>" (referenced from <referring paths>) (ninguna versión del catálogo satisface la restricción de versión referenciada)
Mensaje emitido, para una fijación en un puntero extends::
no catalog version satisfies the referenced version constraint (Component <name>, at .extends, no catalog version satisfies extends parent "<reference>") (ninguna versión del catálogo satisface la restricción de versión referenciada: ninguna versión del catálogo satisface el padre de extends)
con Feature en lugar de Component donde es la cadena de una Feature la que lleva la fijación.
Cómo corregirlo: cambia la fijación a una versión que el catálogo contenga, o añade esa versión al catálogo. aggrega inspect enumera las versiones en las que está disponible una entidad. Un rango caret con el que no coincide nada suele significar que las versiones disponibles están todas por debajo del mínimo que indica — amplía el rango, o publica la versión que la referencia está esperando.
Una fijación que no tiene ninguna de las formas que adopta una fijación es una condición distinta, descrita más abajo en «A version pin is none of the forms a pin takes (Una fijación de versión no tiene ninguna de las formas que adopta una fijación)».
A version pin is none of the forms a pin takes (Una fijación de versión no tiene ninguna de las formas que adopta una fijación)
Una referencia nombra otra entidad y puede fijar la versión que quiere después de dos puntos, en una de dos formas: una fijación exacta, que es una versión semántica como 1.0.0 — la forma que adopta el metadata.version de toda entidad — o una fijación caret, ^ seguido de una versión como ^1.0.0, que selecciona la versión más alta compatible con ella. Una fijación que no es ninguna de las dos — un caret cuyo texto no se lee como un rango de versiones, como ^garbage, o una fijación exacta que no es una versión semántica, como 1.x, 1.0 o v1.0.0 — no nombra ninguna versión, así que ningún catálogo podría contener lo que pide.
Una fijación así se informa como mal formada en lugar de como una entidad o una versión que el catálogo no contiene, de modo que el diagnóstico te remite al texto que escribiste en lugar de hacerte buscar algo que no existe. Es la misma condición dondequiera que se escriba la fijación: el type de un componente o de una funcionalidad, el extends: de un Component o de una Feature, una clave o un valor de mapeo de un Manifest, el spec.aggregate de una Release, el implements: de una Recipe o de una FeatureRecipe, la versión que fija el capability: de una Recipe cuando se selecciona el plugin que la sirve, y el plugin: de un paso de pipeline.
Se informa donde se informa una referencia que no se pudo resolver, de modo que una fijación mal formada nunca cambia qué referencias se resuelven — cambia lo que dice el fallo. Una fijación bien formada pero que ninguna versión disponible satisface conserva la condición que esa superficie informa para ella: «No catalog version satisfies a version constraint (Ninguna versión del catálogo satisface una restricción de versión)» más arriba, o la condición de no encontrado de la superficie en la que está escrita.
Solo el texto tras los últimos dos puntos es una fijación, y solo cuando no contiene /. Una referencia a un host de registro con un puerto, como localhost:5000/core/api-server, no lleva por tanto ninguna fijación — el texto tras los dos puntos del puerto continúa la referencia — y nunca se informa como una fijación mal formada.
Mensaje emitido, para una fijación caret en un tipo de componente:
reference carries a malformed version pin (reference "<reference>", pin "<pin>", the text after ^ is not a version range, referenced from <authored location>). write the reference as , as : with a semantic version such as 1.0.0, or as :^ for the highest version compatible with it (la referencia lleva una fijación de versión mal formada (referencia, fijación, el texto tras ^ no es un rango de versiones, referenciada desde la ubicación en que está escrita). escribe la referencia como nombre, como nombre:versión con una versión semántica como 1.0.0, o como nombre:^versión para la versión más alta compatible con ella)
Una fijación exacta dice an exact pin must be a semantic version en lugar de la cláusula del caret. El valor que le sigue indica dónde se escribió la referencia, con las palabras de la superficie que la informa — referenced from y la ubicación en que está escrita, in the Release's spec.aggregate o in the recipe's spec.implements. Cuando un mapeo de un Manifest se evalúa frente al implements: de su Recipe, la entrada del mapeo y el lado de ella que lleva la fijación — in the mapping key o in the recipe's spec.implements — van en cambio antes de la referencia, y el extends: de un Component o de una Feature nombra la entidad que extiende y el campo antes de ella.
Cómo corregirlo: reescribe la fijación en una de las dos formas, o elimínala para seleccionar la versión más alta disponible. Un comodín como 1.x se escribe como fijación caret, ^1.0.0; una versión con una v inicial o con menos de tres números se escribe completa, 1.0.0.
Every version a reference could select has been withdrawn (Toda versión que una referencia podría seleccionar ha sido retirada)
Una referencia se resuelve en un repositorio que contiene el registro, y toda versión entre las que el descubrimiento de versiones podría haber elegido se ha marcado como retirada. No queda nada elegible que seleccionar.
Esto deliberadamente no se informa como una entidad que falta. El repositorio existe y todavía contiene esas versiones; llamarlo ausente nombraría el problema equivocado, te haría buscar una errata y parecería un recurso alternativo silencioso en lugar del rechazo que es. El mensaje nombra cada versión retirada con el motivo registrado para ella, de modo que lo que se te dice es lo que registró quien la publicó.
Nombrar una versión retirada explícitamente no es esta detención. Una versión exacta omite por completo el descubrimiento de versiones, así que fijar una es la forma de seguir usándola deliberadamente; la compilación informa de la retirada y continúa.
Mensaje emitido:
every published version this reference could select has been withdrawn: <reference>: withdrawn: <version> (<recorded reason>), <version> (<recorded reason>) (toda versión publicada que esta referencia podría seleccionar ha sido retirada: retiradas, cada una con su motivo registrado)
Cómo corregirlo: lee los motivos registrados, que suelen nombrar hacia dónde migrar. Migra a lo que sustituya a la entidad retirada — ese es el resultado que pide una retirada. Cuando tengas que conservar la antigua por ahora, fija una versión exacta en la referencia: nombrar la versión es lo que dice que la aceptas, y la compilación entonces informa de la retirada cada vez en lugar de rechazarla.
A plugins.providers binding names a plugin that does not serve the capability (Un enlace nombra un plugin que no sirve la capacidad)
El bloque plugins.providers del espacio de trabajo selecciona una identidad de plugin para una capacidad, y ningún Plugin de renderizado de proveedores que sirva esa capacidad tiene esa identidad. El enlace es una elección explícita que el catálogo no puede respetar, así que provoca una detención en lugar de recurrir silenciosamente a otro plugin — un recurso alternativo renderizaría tu salida mediante un plugin que habías dicho que no se usara, sin decir nada.
Un enlace selecciona por la identidad de coordenada del plugin — el tipo de plugin y el nombre del plugin, que es también lo que fija el archivo de bloqueo — y puede llevar una versión detrás.
Se evalúa tanto si una Recipe pide la capacidad como si no. De lo contrario, un enlace solo se lee cuando el capability: de una Recipe lo nombra, de modo que un enlace con la capacidad mal escrita no sería consultado por nada ni informado por nada. Cada compilación y cada aggrega validate --release comprueban por tanto cada enlace que nombra un plugin: un pull resuelve un enlace así tanto si una Recipe lo usa como si no, de modo que la compilación contiene el plugin y sabe lo que sirve, y una capacidad que ese plugin no sirve es sin duda errónea. La comprobación lee los enlaces en la configuración del espacio de trabajo, no el archivo de bloqueo, y no cambia nada sobre qué plugin renderiza una Recipe — eso sigue correspondiendo al archivo de bloqueo. Un enlace que nombra un plugin que la compilación no contiene — un plugin de registro que ningún pull ha descargado todavía — no se evalúa hasta que un pull lo haya descargado. Un enlace que no nombra ningún plugin se evalúa de otro modo, como aviso: consulta «A provider binding names a capability no plugin the build reads serves (Un enlace de proveedor nombra una capacidad que ningún plugin leído por la compilación sirve)» en «Condiciones que no detienen una compilación» más abajo.
Mensaje emitido, que añade lo que el plugin nombrado sí sirve, y una grafía a una edición de distancia cuando la capacidad del enlace lo está:
plugins.providers entry names a plugin no provider-rendering plugin serving the capability matches: capability "<capability>" is bound to plugin "<plugin-identity>", but no provider-rendering plugin serving "<capability>" matches that identity; "<plugin-identity>" serves "<served capability>", and "<capability>" is one edit from "<served capability>" (la entrada plugins.providers nombra un plugin con el que no coincide ningún plugin de renderizado de proveedores que sirva la capacidad: la capacidad está enlazada al plugin, pero ningún plugin de renderizado de proveedores que la sirva coincide con esa identidad; el plugin sirve otra capacidad, y la capacidad está a una edición de ella)
Cuando el plugin que nombra el enlace no está en el catálogo que lee la compilación, el mensaje termina tras «matches that identity (coincide con esa identidad)», porque no hay nada que decir sobre lo que sirve.
Cómo corregirlo: comprueba primero la grafía del enlace frente a la coordenada propia del plugin — un enlace que nombra la capacidad donde debería nombrar el plugin es el desliz habitual. Cuando el mensaje nombra una capacidad a una edición de la que escribiste, la errata está en el capability: del enlace. Después confirma que el plugin está en el catálogo que lee la compilación y que enumera esta capacidad en spec.provider.capabilities; un plugin que en su día sirvió la capacidad y ya no la declara produce exactamente este mensaje. Eliminar el enlace es la corrección adecuada cuando solo un plugin sirve la capacidad, ya que entonces el enlace no tiene nada que desambiguar.
No provider plugin version satisfies a Recipe’s provider pin (Ninguna versión de plugin proveedor satisface la fijación de proveedor de una Recipe)
Una Recipe enlaza un proveedor con versión fijada — helm:1.0.0 o helm:^1.0.0 — y ninguna versión de Plugin de renderizado de proveedores satisface la fijación. La fijación es una petición explícita, así que la compilación se detiene en lugar de ignorarla y renderizar mediante cualquier versión que sirva al proveedor en ese momento; anular una fijación silenciosamente produciría una salida que la propia declaración del autor dice que no debería existir.
Dos situaciones llevan a ella, y el mensaje las distingue: nada sirve la capacidad en absoluto, o algo la sirve y ninguna de sus versiones satisface la restricción.
Esto es distinto de una versión de entidad insatisfacible de más arriba. Aquella trata de una entidad del catálogo nombrada en una versión que el catálogo no contiene; esta trata de seleccionar el plugin que renderiza una capacidad.
Mensajes emitidos:
no provider-rendering plugin version satisfies the recipe’s provider version pin: capability "<capability>" pins "<version>" but no provider-rendering plugin serves it (ninguna versión de plugin de renderizado de proveedores satisface la fijación de versión de proveedor de la Recipe: la capacidad fija una versión, pero ningún plugin de renderizado de proveedores la sirve) no provider-rendering plugin version satisfies the recipe’s provider version pin: capability "<capability>" pins "<version>" but no serving plugin version satisfies it (ninguna versión de plugin de renderizado de proveedores satisface la fijación de versión de proveedor de la Recipe: la capacidad fija una versión, pero ninguna versión de plugin que la sirva la satisface)
Cómo corregirlo: amplía o corrige la fijación en el campo capability: de la Recipe, o añade al catálogo la versión del plugin que pide. Una fijación caret coincide con las versiones iguales o superiores al mínimo dentro de la misma versión mayor, así que una fijación ^2.0.0 no la satisface un plugin 1.x, por reciente que sea. Cuando el mensaje dice que nada sirve la capacidad, la fijación no es el problema: el plugin falta por completo, y quitar la fijación no ayudará.
No plugin advertises a requested parse or import format (Ningún plugin anuncia un formato de análisis o de importación solicitado)
Se solicitó un formato y ningún plugin lo anuncia. Los dos sockets que enrutan por formato tienen cada uno su propia condición, y solo difieren en el trabajo que se pidió: un plugin analizador lee un formato de origen externo, y un plugin importador incorpora contenido externo como entidades de Aggrega.
El espacio de formatos es abierto y pertenece por completo a los plugins. Ninguno de los dos sockets contiene una lista de formatos que conozca el compilador: un plugin declara como capacidades los formatos que maneja, y un formato nuevo se distribuye como un plugin nuevo sin ningún cambio en el compilador. Por eso esta detención informa del conjunto anunciado tal como está en lugar de una enumeración fija, y toda ausencia se informa de forma explícita: la petición o tiene un plugin que la anuncie o no puede atenderse. Nada sustituye a un plugin que falta, con la única excepción de los analizadores que incluye el compilador, descrita más abajo.
Mensajes emitidos:
no parser plugin advertises the requested format: no parser plugin advertises "parse:<format>" (ningún plugin analizador anuncia el formato solicitado) no importer plugin advertises the requested format: no importer plugin advertises "import:<format>" (ningún plugin importador anuncia el formato solicitado)
Un único plugin analizador que anuncia el formato pero lleva una estructura de versión que no se puede resolver se trata como si ningún plugin anunciara el formato, en lugar de dejarlo pasar en silencio, y lo dice:
no parser plugin advertises the requested format: no parser plugin version resolves for "parse:<format>" (ningún plugin analizador anuncia el formato solicitado: ninguna versión de plugin analizador se resuelve para el formato)
Un análisis recurre a los analizadores que incluye el compilador. Una compilación analiza cada archivo que entrega a una política render-verdict en un formato que la política no lee de forma nativa, un importador lee su origen mediante el analizador de la sintaxis que nombra, y una importación que no nombra ningún formato analiza el origen en la sintaxis que nombra cada firma aplicable. Para cada sintaxis se usa el analizador que sirve el catálogo del espacio de trabajo y, donde el catálogo no sirve ninguno, el analizador que el propio compilador incluye para ella —entre ellos el analizador HCL mediante el cual una compilación lee la salida de Terraform y el analizador JSON mediante el cual leen los importadores core del compilador, de modo que ni una política sobre la salida de Terraform ni una importación mediante un importador core necesitan un analizador en el catálogo. Donde el catálogo sí sirve un analizador para una sintaxis, el del compilador no interviene, y dos de nombres distintos en el catálogo se rechazan como describe A parse or import format is advertised by more than one plugin (Un formato de análisis o de importación lo anuncia más de un plugin). Así que esta detención nombra una sintaxis para la que ni el catálogo ni el compilador sirven un analizador.
Cómo corregirlo: confirma que el formato está escrito como lo anuncia el plugin — la capacidad es el prefijo del socket y el nombre del formato, así que un plugin que anuncia parse:hcl sirve el formato hcl y nada más. Después confirma que el plugin está presente en el catálogo que lee la compilación. Donde no existe ningún plugin para el formato, ese plugin es la pieza que falta; el compilador no puede leer un formato que nada anuncia.
A parse or import format is advertised by more than one plugin (Un formato de análisis o de importación lo anuncia más de un plugin)
Dos o más plugins distintos anuncian el mismo formato, y la petición no se puede enrutar sin adivinar cuál usar.
Un catálogo que contiene ambos es válido y se carga sin objeciones. Dos publicadores pueden distribuir cada uno un analizador o un importador para un mismo formato, y federar sus catálogos es algo admitido. La ambigüedad es una condición en el punto de uso: provoca una detención cuando el formato en disputa se solicita realmente, de modo que un par en competencia que queda fuera del alcance de una compilación nunca la bloquea.
Cada candidato se nombra, ordenado, de modo que el mensaje es el mismo en cada ejecución.
Mensajes emitidos:
format is advertised by more than one parser plugin: format "<format>" is advertised by parser plugins [<plugin-names>] (el formato lo anuncia más de un plugin analizador) format is advertised by more than one importer plugin: format "<format>" is advertised by importer plugins [<plugin-names>] (el formato lo anuncia más de un plugin importador)
Para un importador, la detención se produce en una estructura más: las entradas plugins.importer del espacio de trabajo vinculan más de uno de los importadores que anuncian el formato, y los importadores que nombra son entonces los vinculados.
Los importadores entre los que elige una importación son los del catálogo del espacio de trabajo y los importadores core del compilador, que anuncian sus formatos en todo espacio de trabajo. Así, un catálogo que contiene su propio importador de otro nombre para un formato que sirve un importador core — import:langflow o import:flowise — se encuentra con esta detención en una importación que no vincula ninguno de los dos, y el mensaje nombra el importador core junto al del catálogo. Un importador que el catálogo contiene con el mismo nombre de un importador core no es un segundo plugin que anuncie el formato: dentro de un mismo nombre se elige la versión más alta, y uno en la versión propia del importador core, con su módulo junto a él, se ejecuta en su lugar. Uno sin módulo junto a él no es candidato donde un importador de ese nombre que pueda ejecutarse anuncia el formato, como describe Cuál se ejecuta junto a tus propios importadores.
Cómo corregirlo: para un importador, conserva ambos en el catálogo — o conserva el tuyo junto al importador core — y vincula el que quieras — una entrada plugins.importer cuyo uri lo nombre por su identidad y versión, uri: importer/<name>:<version>, tal como lo escribe aggrega plugin add importer. El importador vinculado se elige entre los que anuncian el formato, como una entrada plugins.providers elige entre los plugins que sirven una capacidad en el socket proveedor, descrito en «A capability is served by more than one provider plugin (Una capacidad la sirve más de un plugin proveedor)» más abajo. Cuando los importadores nombrados son los que vinculan tus entradas, conserva la entrada del que quieras y elimina la otra. El socket de análisis no tiene una selección así, así que para un analizador el remedio es acotar el catálogo que lee la compilación para que solo esté en él el plugin que quieres — apuntar --catalog al directorio que contiene tu elección es la forma directa.
A plugins.importer entry pins a version of its importer the catalog does not hold (Una entrada fija una versión de su importador que el catálogo no contiene)
Una entrada plugins.importer vincula un importador mediante su identidad y una versión — una exacta, uri: importer/<name>:1.2.0, o un rango, uri: importer/<name>:^1.2.0 — y ese importador anuncia el formato que pide la importación, pero ninguna de sus versiones entre las que elige la importación satisface la fijación — las versiones que contiene el catálogo del espacio de trabajo y, para un importador core, también la versión propia del compilador: la versión exacta no está, o ninguna de sus versiones cae dentro del rango. La versión es una elección explícita, así que la importación se rechaza antes de que se ejecute ningún importador, en lugar de ejecutar otra versión del importador en su lugar.
Esto es distinto de que ningún importador anuncie el formato, descrito arriba: aquí el importador es uno de aquellos entre los que elige la importación y anuncia el formato, y solo falta la versión que nombra la entrada. Una fijación que no tiene ninguna de las formas que adopta una fijación de versión, como :latest, se informa en cambio como mal formada, como describe «A version pin is none of the forms a pin takes (Una fijación de versión no tiene ninguna de las formas que adopta una fijación)».
Mensaje emitido, que nombra la capacidad del formato y la versión que fija la entrada:
no importer plugin version satisfies the plugins.importer entry’s version pin: capability "import:<format>" pins "<version>" but no serving plugin version satisfies it (ninguna versión de plugin importador satisface la fijación de versión de la entrada plugins.importer: la capacidad fija una versión, pero ninguna versión de plugin que la sirva la satisface)
Cómo corregirlo: cambia la versión en el uri de la entrada por una que contenga el catálogo — para un importador core, la versión propia del compilador también lo es —, o amplía el rango, o añade al catálogo la versión que nombra la entrada. Un rango caret coincide con las versiones iguales o superiores a su mínimo dentro de la misma versión mayor, así que ^2.0.0 no se satisface con un importador 1.x, por reciente que sea.
A plugin reference carries a registry host or an artifact path (Una referencia de plugin contiene un host de registro o una ruta de artefacto)
Una referencia de Plugin empieza con un segmento con forma de host de registro — uno que contiene un punto o dos puntos, como un nombre DNS o un par de host y puerto — o con una ruta de artefacto. Un Plugin se direcciona por su identidad de coordenada: su tipo de plugin, una barra, su nombre y, opcionalmente, una versión. El pull enlaza esa identidad a una ubicación física anteponiendo el registro configurado y la propia ruta del plugin, así que una referencia que ya contiene uno recibiría el prefijo dos veces y se enlazaría a una ubicación que no se puede descargar.
Se rechaza donde se forma la ubicación y no en la descarga, de modo que el mensaje nombra lo que escribiste en lugar de aparecer más tarde como un error de etiqueta ilegible.
Mensaje emitido, enmarcado por el pull que estaba formando la ubicación, con el remedio en la línea de debajo:
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>" (catálogo: pull de nivel 3: la referencia de plugin wasm debe ser la identidad de coordenada del plugin, no una ruta calificada con registro ni una ruta de artefacto) 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 (solución: elimina el host del registro y la ruta del artefacto, dejando solo la coordenada; el pull antepone por sí mismo el registro configurado, así que una referencia que ya contiene uno recibe el prefijo dos veces)
Cómo corregirlo: quita todo lo que precede al tipo de plugin, dejando la coordenada sola — provider/helm:1.0.0, no hub.example.com/plugin/provider/helm:1.0.0. El registro del que una compilación hace pull es configuración del espacio de trabajo y no parte de una identidad, que es lo que permite servir un catálogo desde más de un registro sin editar las entidades que contiene.
A plugin or recipe reference carries no scope (Una referencia de plugin o de receta no lleva ámbito)
Una referencia de Plugin o de Recipe no tiene un segmento de ámbito inicial — ninguna barra, o un segmento vacío antes de la barra, como en /name. Ambos tipos se identifican por dos partes, y la primera es la que mantiene separadas dos entidades con el mismo nombre: un Plugin por su tipo de plugin y su nombre, una Recipe por su proveedor y su nombre. Dos sockets pueden contener cada uno un plugin llamado redact, y dos proveedores pueden distribuir cada uno una receta llamada postgres, así que el ámbito forma parte de la identidad en lugar de ser un adorno.
Una ubicación construida a partir de un ámbito vacío contiene un segmento de ruta vacío — una barra doble — que no se puede resolver, así que la referencia se rechaza donde se forma la ubicación en lugar de dejar que falle más tarde como una descarga ilegible.
Los dos remedios son opuestos al caso del plugin calificado de arriba y entre sí, por eso cada uno se formula por separado: aquí a una referencia le falta un segmento y lo añades, mientras que una referencia calificada lleva uno de más y lo quitas.
Mensajes emitidos, cada uno enmarcado por el pull y con su propio remedio debajo:
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>" (catálogo: pull de nivel 3: la referencia de plugin wasm debe llevar un ámbito pluginType; un ámbito vacío no puede enlazarse a una ubicación 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 (solución: añade el segmento pluginType que falta — escribe la referencia como tipo de plugin, barra y nombre — usando el pluginType que declara la entidad del plugin)
catalog: tier-3 pull <uri>: recipe reference must be provider-scoped (<provider>/<name>); an empty provider cannot bind to an OCI location: "<identity>" (catálogo: pull de nivel 3: la referencia de receta debe tener un proveedor como ámbito; un proveedor vacío no puede enlazarse a una ubicación 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) (solución: ningún directorio de catálogo local contenía esta referencia, así que se buscó en el registro, donde se requiere un segmento de proveedor; vuelve a ejecutar el pull indicando con la opción de catálogo el directorio que la contiene, para que se busque primero; la opción se puede repetir)
Cómo corregirlo: para un plugin, antepón el tipo de plugin que la entidad Plugin declara en metadata.pluginType. Para una receta, antepón el proveedor que la Recipe declara en spec.capability. El remedio para la receta nombra una segunda posibilidad que vale la pena leer: llegar al registro significa que primero se buscó en los directorios de catálogo locales y ninguno contenía la referencia, así que, si la receta debe venir de un directorio local, apunta la compilación a ese directorio en lugar de añadir un ámbito.
The build consumes an artifact its publisher has deprecated (La compilación consume un artefacto que su editor ha declarado obsoleto)
Una referencia que esta compilación resuelve lleva un marcador de obsolescencia que registró su editor, y la gravedad de ese marcador es igual o superior a la gravedad que el espacio de trabajo configuró como umbral de detención. Un marcador se adjunta a un artefacto publicado a posteriori, así que un artefacto que ayer se compilaba sin problemas puede llevar uno hoy sin que haya cambiado nada en tus propios archivos.
Informar y detener son cosas separadas, y solo la detención es configurable. Cada marcador registrado se informa, con cualquier gravedad, y ninguna configuración lo silencia. Si un marcador además detiene la compilación lo decide halt_on_deprecated_severity, comparando la gravedad registrada con el umbral configurado en el orden warning < error < retracted. Sin umbral configurado, nada se detiene y cada marcador es un aviso. Una gravedad fuera de las tres, o un umbral fuera de ellas, nunca coincide: un valor mal formado no puede ni causar una detención ni suprimir una.
Cada notificación se imprime antes de que la compilación se detenga, no solo la que la detuvo, así que subir el umbral nunca te hace perder un hallazgo — la detención misma nombra la única referencia en la que se detuvo. Los hallazgos se ordenan por referencia, así que el mismo archivo de bloqueo informa la misma secuencia en cada ejecución y el que provoca la detención es siempre el mismo.
Se comprueban dos almacenes y ambos informan de la misma manera: las referencias que fija el archivo de bloqueo y los plugins registrados como de confianza para un veredicto de aceptar o rechazar. Ninguna de las dos comprobaciones llega a un registro — ambas leen lo que ya estaba registrado —, así que la compilación sigue siendo ahead-of-time.
Mensaje emitido. Cada hallazgo se imprime a medida que se recorre, y después la detención repite el que alcanzó el umbral y nombra el ajuste que detuvo la compilación:
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" (obsolescencia: la compilación consume una entidad obsoleta: la referencia está retirada, con el mensaje registrado por el editor (registrado en el archivo de bloqueo en el pull; vuelve a ejecutar el pull para actualizarlo): halt_on_deprecated_severity tiene el valor indicado)
Un marcador con una de las dos gravedades de aviso se indica como deprecated (warning) o deprecated (error) en lugar de retracted. La distinción se mantiene porque ambos significan cosas distintas — desaconsejado pero aún seleccionable, frente a excluido de la selección — e informar del más fuerte como si fuera el más débil minimizaría lo que ocurrió.
Cómo corregirlo: lee el mensaje registrado, que es la explicación del propio editor sobre a qué migrar, y migra. Donde todavía no puedas migrar, subir halt_on_deprecated_severity — o quitar su valor — vuelve a convertir la detención en un aviso que sigues viendo; es una aceptación deliberada y no un apaño, y la notificación se sigue imprimiendo. Un marcador registrado para una versión que ya no usas desaparece cuando el archivo de bloqueo se actualiza con aggrega pull.
A trusted plugin’s recorded digest disagrees with the cached artifact (El digest registrado de un plugin de confianza no coincide con el artefacto en caché)
Un plugin vinculado en un rol que acepta o rechaza una compilación tiene un digest registrado como de confianza, y el manifiesto en caché del plugin informa de uno distinto. Los dos se comparan antes de leer el ejecutable del plugin, y un desacuerdo detiene ahí la resolución.
La comparación es lo que convierte el digest registrado en una autoridad y no en una repetición. Sin ella, los bytes de un plugin solo se comprueban contra una fijación derivada del mismo manifiesto cuyos bytes luego valida — coherente consigo mismo por construcción e incapaz de notar que se ha sustituido el artefacto entero. Comparar lo registrado con lo que el manifiesto informa ahora es lo que da a esa comprobación una opinión externa.
Esto es distinto de una discrepancia del digest de contenido, que informa de bytes resueltos en desacuerdo con el digest declarado para ellos. Aquí no se ha leído nada, y los bytes bien pueden coincidir con el manifiesto; lo que discrepa es qué artefacto se está resolviendo. Mantener ambos casos separados importa porque los remedios son opuestos — uno es un artefacto dañado o manipulado, el otro un plugin modificado legítimamente cuya nueva identidad aún no se ha revisado.
Mensaje emitido:
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 (resolver el plugin en caché: el digest registrado como de confianza para él difiere del que informa el manifiesto del plugin en la caché de contenido; revisa qué cambió y vuelve a registrar el digest de confianza, o restaura el artefacto registrado: el digest registrado como de confianza para este plugin no coincide con el digest que informa su manifiesto en caché)
Cómo corregirlo: averigua qué cambió antes de volver a registrar nada — este es un plugin que puede rechazar tus compilaciones, y el digest registrado es la constancia de que alguien lo revisó. Donde el cambio es esperado, porque actualizaste el plugin deliberadamente, revisa el nuevo artefacto y vuelve a registrar el digest de confianza para él. Donde no es esperado, restaura el artefacto que nombra lo registrado; el desacuerdo te está diciendo que la identidad cambió sin que nadie decidiera que debía hacerlo.
An extends: chain cannot be assembled (No se puede ensamblar una cadena de extensión)
La cadena extends: de un Component, una Feature, un Manifest o una Release nombra un padre que no se puede resolver, así que la cadena no se puede convertir en una única entidad resuelta.
Es distinto de un ciclo, que tiene su propia condición y su propio remedio — consulta «Cyclic extends chain (Cadena extends cíclica)» más arriba —; de una cadena que supera el límite de profundidad, que tiene su propia condición más abajo; y de una fijación de versión insatisfacible, en la que el padre existe y solo falta la versión.
Mensaje emitido, que nombra la entidad que lleva el extends: irresoluble y la referencia que declara:
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 (falló la fusión de la herencia: la entidad extiende una referencia que ninguna entidad del catálogo proporciona. Verifica que la referencia extends nombre una entidad presente en el catálogo)
Cuando la comprobación que lo informa lee un padre de la caché de artefactos según la fijación de un lockfile — la comprobación extends de una compilación y de aggrega validate --release, aggrega validate sobre todo el catálogo y aggrega inspect, así como las mismas comprobaciones ejecutadas desde el editor y la herramienta validate del asistente —, el consejo continúa nombrando el pull: «a base published to a registry is fetched by aggrega pull --release <release>» (una base publicada en un registro se obtiene con el comando indicado). Validar un único archivo de entidad no lee ningún lockfile, así que un pull no cambiaría nada de lo que lee, y su mensaje se detiene en el catálogo.
Feature aparece en lugar de Component cuando la cadena que falló es la de una Feature. Como con un bucle, la entidad nombrada primero es aquella desde la que empezó la resolución y la entidad nombrada en la arista es aquella cuya línea extends: hay que abrir; a lo largo de una cadena de varios niveles, ambas difieren.
El extends: de un Manifest se resuelve contra otro lugar, así que recibe otro consejo. Un Manifest es configuración del operador escrita junto a la Release y no contenido del catálogo, y su extends: nombra un archivo por ruta relativa o el metadata.name de un Manifest en el propio directorio de la Release — nunca una entidad del catálogo. Por eso su mensaje termina con aquello a lo que la referencia no consiguió resolverse y con dónde buscar en su lugar:
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 (falló la fusión de la herencia: la entidad extiende una referencia que no se pudo resolver. Verifica que la referencia extends sea una ruta relativa o el nombre de un Manifest en el directorio de la Release)
Ese detalle final es el fallo que informó la propia búsqueda — el archivo que no se pudo leer, o el escaneo que no indexó ningún Manifest con ese nombre —, así que normalmente dice cuál de las dos formas se intentó y por qué no dio resultado.
El extends: de una Release se resuelve contra un directorio, y acepta una sola forma. Una Release nombra a su padre con una ruta relativa — ./base-release.yaml, o ../shared/base-release.yaml. El directorio contra el que se resuelve es el que contiene la Release que escribe la referencia, y cada eslabón de una cadena se resuelve contra su propio directorio — así, una Release intermedia guardada en un subdirectorio nombra a su padre junto a sí misma, esté donde esté la Release que nombra un comando. Un token sin más no es una ruta y no nombra una Release que el compilador vaya a buscar, así que se informa aquí en lugar de buscarse en un lugar donde no puede encontrarse:
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 (falló la fusión de la herencia: la entidad extiende una referencia que no se pudo resolver. Verifica que la referencia extends sea una ruta relativa a un archivo de Release, como ./base-release.yaml, resuelta desde el directorio que contiene esta Release)
Cómo corregirlo: para un Component o una Feature, confirma que el valor de extends: nombra una entidad que contiene el catálogo, escrita como el propio metadata.name de esa entidad — mayúsculas y minúsculas incluidas. Una base publicada en un registro se lee de la caché de artefactos según la fijación que el lockfile de la Release registra para ella, así que, cuando la base está en un registro, ejecuta aggrega pull --release <release>: el pull sigue la cadena, obtiene la base y la fija. Para un Manifest, confirma que el archivo está donde apunta la ruta relativa, o que un Manifest con ese metadata.name está en el directorio de la Release y se analiza correctamente. Para una Release, confirma que el valor empieza por ./ o ../ y que el archivo al que apunta existe y se analiza como una Release.
An extends: chain runs past the depth bound (Una cadena de extensión supera el límite de profundidad)
La cadena extends: de un Component, una Feature, un Manifest o una Release termina limpiamente, pero recorre más entidades de las que permite el límite de diez.
Tiene una condición propia en lugar de compartir la anterior, porque los dos remedios no tienen nada en común: un padre ausente es una referencia que corregir, y una cadena demasiado profunda es una estructura que aplanar. El límite es una protección frente a un descuido de autoría y no un límite estructural — los arquitectos suelen extender una base en uno o dos niveles, y una cadena de diez niveles suele ser un árbol base que fue creciendo más que un diseño deliberado.
Solo una cadena que TERMINA llega a ella. Una cadena que vuelve sobre sí misma se informa como bucle, sea cual sea su longitud, así que esta condición nunca sustituye a un ciclo y su consejo — acortar la cadena — nunca se da para uno.
Mensaje emitido, que nombra el límite y la longitud que alcanzó la cadena:
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 cadena extends supera la profundidad máxima. el límite es 10 y esta cadena lo sobrepasa; acorta la cadena, o extiende una base que esté más cerca de su raíz)
Feature, Manifest o Release aparece en lugar de Component cuando la cadena que falló es una de esas. El límite es el mismo diez para cada tipo que declara extends, y cuenta las entidades de la cadena, no los eslabones entre ellas: una cadena de exactamente diez entidades se compila, y la undécima entidad es lo que esto informa. Así, una entidad que extiende una base que extiende una base — tres entidades, dos eslabones — ha llegado a tres.
Cómo corregirlo: comprime la parte central de la cadena. Una cadena tan profunda suele significar que cada nivel añade poco, y fundir varios niveles en una sola entidad base es a la vez la corrección y la estructura más clara. Donde los niveles son realmente distintos, una entidad más abajo en la cadena puede extender directamente una base más cercana a la raíz en lugar de heredar a través de cada nivel intermedio. Una cadena de Manifest tan profunda suele ser una pila de superposiciones por entorno — funde los niveles que nadie varía en la base que superponen.
An assertion name is declared twice along an extends: chain (Un nombre de aserción se declara dos veces a lo largo de una cadena de extensión)
Una entidad y algo que ella extiende declaran ambos una aserción con el mismo nombre, y las dos declaran reglas distintas. Las aserciones de una entidad que extiende se suman a las de su base; nunca reemplazan una. Así que un nombre declarado dos veces con dos reglas distintas retiraría en silencio el invariante de la base, que es lo contrario de para qué sirve extender una entidad.
Declarar el mismo nombre con la regla idéntica no es una colisión y se compila. Eso es lo que mantiene la comprobación idempotente a lo largo de una cadena: sin ello, una cadena de tres niveles colisionaría cada vez con su propio nivel intermedio.
El orden forma parte del contrato y no es accidental. Las aserciones se evalúan en el orden fusionado y la primera que falla provoca la detención, así que el invariante de una base se comprueba antes que el de un descendiente, y a lo largo de una cadena el conjunto se acumula desde la raíz hacia abajo.
Mensaje emitido:
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 (nombre de aserción declarado dos veces a lo largo de la cadena extends. la aserción ya la declara el Component base, con una regla distinta; cambia el nombre de la aserción de la entidad que extiende; las aserciones de una entidad que extiende se suman a las de la base y nunca reemplazan una)
Cómo corregirlo: cambia el nombre de la aserción de la entidad que extiende, que el mensaje nombra junto con la base que ya la declara. Donde querías reemplazar la regla de la base, eso no es algo que la extensión admita — restringe la aserción de la base para que se cumpla en cada entidad que la extiende, o mueve la regla hacia abajo, a las entidades que realmente la necesitan. Donde las dos reglas deben ser la misma, hazlas textualmente idénticas y la colisión desaparece.
A Release chain’s links disagree about the routing shape (Los eslabones de una cadena de Release no coinciden en la estructura de enrutamiento)
Una Release enruta los componentes de su Aggregate de una de dos maneras: límites con nombre bajo boundaries:, o componentes de nivel superior bajo components:. Ambas se excluyen mutuamente, y un único documento que declare las dos se rechaza en cuanto se lee. Esta condición es la misma regla a lo largo de una cadena extends:: una base que declara límites con nombre y un hijo que declara componentes de nivel superior están bien formados cada uno por sí mismo, y solo al fusionarlos se reúnen las dos opciones en una única Release resuelta.
Ninguno de los dos documentos es incorrecto por sí mismo, por eso el mensaje nombra a ambos y ambas claves. Un diagnóstico que solo nombrara la Release a la que se dirigió la compilación te enviaría al archivo que no tiene nada incorrecto.
Una cadena cuyos eslabones coinciden no se ve afectada. Cada eslabón que declara límites con nombre se compone con normalidad, y lo mismo ocurre con cada eslabón que declara componentes de nivel superior. Es la mezcla lo que se detiene.
Mensaje emitido, que nombra los dos archivos y la clave que declara cada uno:
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 cadena de extensión de la Release compone tanto límites con nombre como componentes de nivel superior: declara una sola estructura de enrutamiento en toda la cadena, nunca ambas — Release, archivo que declara los límites, archivo que declara los componentes)
Cómo corregirlo: elige la estructura de enrutamiento que debe usar la cadena y escríbela en toda ella. Donde la base declara límites con nombre, un hijo que quiere configurar componentes los indica dentro del límite que los contiene en lugar de en la raíz de la Release — que es también lo que le permite cambiar el dimensionamiento de un componente sin volver a declarar la topología. Donde la base declara componentes de nivel superior, un hijo que necesita límites con nombre está describiendo una estructura de enrutamiento distinta de la de su base, y conviene escribirlo como una Release propia en lugar de como hijo de esa.
An external input’s URL uses a scheme that is not allowed (La URL de una entrada externa usa un esquema no permitido)
Una URL a la que apunta una entidad usa un esquema fuera del conjunto permitido. Se permiten tres: https; http, pero solo hacia un host de loopback, de modo que el texto sin cifrar solo pueda llegar a la máquina local; y oci, para el contenido descargado de un registro.
Mensajes emitidos, para una URL http que no es de loopback y para cualquier otro esquema:
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 sin cifrar solo se permite para hosts de loopback (esquemas permitidos: https, http hacia un host de loopback, oci): externalinputs: el esquema de la URL no está permitido) externalinputs: "<url>": scheme "<scheme>" is not allowed (allowed schemes: https, http to a loopback host, oci): externalinputs: URL scheme is not allowed (externalinputs: el esquema no está permitido (esquemas permitidos: https, http hacia un host de loopback, oci): externalinputs: el esquema de la URL no está permitido)
Cómo corregirlo: cambia la URL a https, o a oci donde el contenido esté publicado en un registro. Una URL http sin cifrar hacia un host remoto se rechaza en lugar de degradarse, así que la corrección es apuntarla al esquema seguro; un servidor de desarrollo local sigue funcionando sobre http porque se permite un host de loopback.
A render requests an external input the lockfile does not pin (Un renderizado solicita una entrada externa que el archivo de bloqueo no fija)
Algo que una compilación necesita se descarga de una URL que el archivo de bloqueo no fija. Una compilación renderiza la clausura que registra su archivo de bloqueo y no descarga nada, así que no existe ningún ajuste que permita a esta ejecución adquirir la URL en su lugar: la clausura congelada es lo que hace reproducible una compilación, y ampliar silenciosamente el conjunto de entradas es lo único que no debe hacer.
Llegar a esta detención es, por tanto, informativo y no un error de configuración. Las fijaciones estaban completas cuando se resolvió la Release, así que una URL sin fijar significa ahora que algo ha cambiado desde entonces — un valor que orienta qué referencias solicita un renderizado, un chart que empezó a apuntar a otro sitio, o un archivo de bloqueo resuelto contra una Release distinta.
Mensaje emitido:
"<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 (no está fijada en el archivo de bloqueo; ejecuta el comando para fijar cada entrada externa que consume el renderizado de esta Release y vuelve a compilar: externalinputs: la adquisición está deshabilitada para las entradas sin fijar)
Cómo corregirlo: fija la entrada. aggrega pull --release <path> renderiza la Release para averiguar qué entradas externas consume, descarga cada una y registra su digest en el archivo de bloqueo junto a las fijaciones de dependencias — tras lo cual cada compilación posterior la sirve desde el registro fijado y no necesita red en absoluto. Donde la URL es nueva porque algo que escribiste empezó a apuntar a ella, el paso que se omitió es volver a resolver la Release; donde es inesperada, vale la pena encontrar la referencia que la introdujo antes de fijarla.
Fetched bytes do not match a pinned digest (Los bytes descargados no coinciden con un digest fijado)
Una URL fijada se volvió a descargar — porque faltaba su copia almacenada — y lo que llegó no es lo que el archivo de bloqueo fijó. El digest registrado siempre prevalece: no se escribe nada en el almacén y no se devuelve ningún byte.
Una recarga se descarga por el digest registrado y no por la etiqueta de la URL, de modo que una etiqueta que se haya movido para apuntar a otro contenido no puede cambiar lo que sirve una entrada fijada. Llegar a esta detención significa, por tanto, que es el propio contenido detrás del digest el que no llegó intacto.
Mensajes emitidos, para el contenido descargado de un registro y para el contenido descargado por HTTPS:
externalinputs: "<url>": refilled manifest digest is <digest>, pinned digest is <digest>: externalinputs: fetched bytes mismatch the pinned digest (externalinputs: el digest del manifiesto recargado difiere del digest fijado: externalinputs: los bytes descargados no coinciden con el digest fijado) externalinputs: "<url>": refetched bytes hash to <digest>, pinned digest is <digest>: externalinputs: fetched bytes mismatch the pinned digest (externalinputs: el hash de los bytes descargados de nuevo difiere del digest fijado: externalinputs: los bytes descargados no coinciden con el digest fijado)
Cómo corregirlo: trátalo primero como una cuestión de cadena de suministro y no como un archivo de bloqueo que actualizar — la fijación es la afirmación de que estos bytes exactos eran aquello con lo que compilaste, y el rechazo es esa afirmación sosteniéndose. Confirma que el origen sigue publicando el contenido que nombra el digest, y comprueba si algo entre tú y él está reescribiendo las respuestas; un proxy o un espejo que sirve un sustituto es una causa habitual. Solo cuando sepas qué cambió y lo aceptes deberías volver a fijar con aggrega pull, que registra el nuevo digest.
A stored external input no longer matches its record (Una entrada externa almacenada ya no coincide con su registro)
Una entrada fijada se volvió a leer del almacén local y no coincide con el registro fijado para ella. La comprobación se ejecuta en cada lectura, antes de servir los bytes, de modo que un almacén dañado o manipulado aflora en el punto de uso en lugar de alimentar silenciosamente una compilación.
Lo que se compara depende de cómo esté fijada la entrada. El contenido descargado por HTTPS se fija calculando el hash de la carga útil, así que se vuelve a calcular su hash en cada lectura y se informan ambos digests. El contenido descargado de un registro se fija por el digest de su manifiesto, que compromete la carga útil a través del propio manifiesto del registro en lugar de calcular su hash directamente, así que una copia almacenada se comprueba contra el tamaño registrado — la verificación completa del digest se ancla, en cambio, en la adquisición y en cada recarga direccionada por digest.
Mensajes emitidos:
externalinputs: "<url>": store blob sha256 is <digest>, pinned digest is <digest>: externalinputs: store blob mismatches its pinned record (externalinputs: el sha256 del blob del almacén difiere del digest fijado: externalinputs: el blob del almacén no coincide con su registro fijado) externalinputs: "<url>": store blob sha256/<digest> is <n> bytes but the pinned record says <n>: externalinputs: store blob mismatches its pinned record (externalinputs: el tamaño en bytes del blob sha256 del almacén difiere del que indica el registro fijado: externalinputs: el blob del almacén no coincide con su registro fijado)
Cómo corregirlo: elimina del almacén el blob afectado y deja que la siguiente ejecución lo recargue desde el origen, lo cual se verifica contra el digest registrado antes de escribir nada. Si entonces una recarga también informa de una discrepancia de digest, el desacuerdo está aguas arriba y no en local, y la entrada anterior es la que hay que leer. Un almacén compartido entre máquinas, o uno restaurado desde una copia de seguridad tomada a mitad de una escritura, es la causa local habitual.
A guard needs a catalog entity the build resolved and cannot see (Una guarda necesita una entidad del catálogo que la compilación resolvió y que no puede ver)
Una guarda semántica buscó la entidad del catálogo detrás del tipo de un componente, y la entidad no está en la vista que se le dio a la guarda — aunque la resolución resolvió ese tipo como una referencia al catálogo. Una referencia realmente irresoluble se detiene antes, en la resolución, así que llegar a una guarda con la entidad ausente significa que el conjunto resuelto de la compilación y la vista de la guarda se han separado.
La compilación se detiene en lugar de omitir la guarda. Omitirla retiraría una comprobación sin nada que indicara que ha desaparecido, y los componentes de los que se ocupaba la guarda pasarían sin examinar mientras la compilación informa de éxito.
Un tipo escrito como ruta relativa — que empieza por ./ o ../ — no se evalúa aquí: un tipo nunca se lee como archivo, así que un valor así no nombra ninguna entidad del catálogo y se rechaza antes, cuando se resuelven las dependencias de la Release, como una referencia que ningún catálogo contiene. Solo una referencia al catálogo en forma de token simple llega a esta detención.
Dondequiera que se cumpla la condición, se informa con las mismas palabras, de modo que el texto nombra el tipo y el fallo en lugar de la comprobación que lo generó.
Tampoco nombra ningún documento ni ninguna clave dentro de uno, lo cual es deliberado y es el único lugar en el que esta detención se lee de forma distinta a todas las demás. Cualquier otra detención se sitúa en el archivo y el campo que editarías para eliminarla; aquí no existe tal archivo, así que una posición te enviaría a una clave que no tiene la culpa. En su lugar se informa del tipo en el que no coinciden las dos vistas, porque es lo que hace reproducible la divergencia para quien la investigue.
Mensaje emitido:
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>") (las propias vistas del catálogo del compilador no coinciden (error interno: esta compilación resolvió un tipo de componente para el que el catálogo que lee no tenía después ninguna entrada. Es un fallo del compilador y no de un documento escrito por un autor, así que no hay nada que corregir en el Aggregate, la Release ni el catálogo. Informa de ello, indicando el comando que produjo esta compilación y el tipo en el que no coinciden las vistas))
Cómo corregirlo: nada en tus propios archivos — esto informa de una incoherencia dentro del compilador y no de un fallo en lo que escribiste, y vale la pena informar de ello como un defecto con el tipo que nombra el mensaje. Es casi seguro que el tipo del componente está bien.
A reference names no entity the catalog holds (Una referencia no nombra ninguna entidad que contenga el catálogo)
Antes de que una compilación renderice nada, se recorre todo el conjunto de entidades de las que depende una Release y se fija cada una, de modo que el archivo de bloqueo registre exactamente lo que la compilación leerá. Una referencia que el catálogo no puede responder detiene ese recorrido: no se puede fijar nada para ella, y continuar escribiría un archivo de bloqueo al que le falta una entrada que la compilación necesitará más adelante, sin nada que lo indique.
El rechazo nombra la referencia y el lugar donde se recopiló, porque a una entidad se llega desde muchos lugares y el lugar que la nombra es donde va la corrección. Una referencia a biblioteca se informa por sí sola, sin ruta de recopilación — a una biblioteca se llega desde las entidades que la referencian con $ref o $import, y el nombre que falla es todo el fallo.
Mensaje emitido, para una entidad del catálogo — la parte final enumera los lugares que la referencian:
resolve: no entity in the catalog matches this URI: entity "<reference>" (referenced from <referring paths>) (resolve: ninguna entidad del catálogo coincide con este URI: entidad, con las rutas desde las que se referencia)
para una biblioteca:
resolve: no entity in the catalog matches this URI: library "<reference>" (resolve: ninguna entidad del catálogo coincide con este URI: biblioteca)
y para un plugin enlazado a un socket de proveedor, que se nombra por la clave de configuración del espacio de trabajo que lo contenía en lugar de por un documento del catálogo:
resolve: no entity in the catalog matches this URI: entity "<reference>" (referenced from .aggrega-config.yaml.plugins.providers) (resolve: ninguna entidad del catálogo coincide con este URI: entidad, referenciada desde .aggrega-config.yaml.plugins.providers)
Donde un archivo bajo los directorios de catálogo declara el nombre que pide la referencia bajo un tipo de entidad que ningún catálogo contiene — un kind mal escrito, por ejemplo —, la nota bajo este fallo nombra ese archivo, el tipo que declara y los tipos que contiene un catálogo, y omite el consejo sobre dónde se leen las entidades locales, tanto en una compilación que rellena su archivo de bloqueo como en una que lo lee, y en cualquier otra superficie que informe de este fallo; consulta Un archivo del catálogo rechazado y el fallo que explica.
Cómo corregirlo: lee la referencia exactamente como la cita el mensaje. Un nombre que no existe, una versión que nunca se publicó y un nombre simple a cuyo registro no apunta el espacio de trabajo llegan todos aquí de forma idéntica, así que comprueba los tres en este orden: corrige la grafía; confirma que la versión existe; confirma que el registro que la contiene está configurado y es accesible. Donde la entidad es una que escribes en local, confirma que el archivo está dentro del catálogo que recorre la compilación.
Donde aggrega pull, o aggrega build --auto-pull, se detiene en una referencia a biblioteca mientras la caché de artefactos contiene una SchemaLibrary que ninguna entrada del archivo de bloqueo fija y que ningún directorio de catálogo proporciona, al mensaje le sigue una línea remediation: que nombra cada una de esas bibliotecas. Una biblioteca en caché cuenta como contenido del catálogo solo donde una entrada del archivo de bloqueo avala su digest, y el pull registra esa entrada desde el registro que sirve la biblioteca. En modo sin conexión, el pull no puede ni descargar la biblioteca ni registrar una entrada para ella, así que la línea indica ejecutar aggrega pull --release <release> donde pueda llegar a un registro, o escribir la biblioteca bajo un directorio de catálogo. Con conexión, ningún directorio de catálogo ni ningún registro que lea el pull sirve la biblioteca, así que no hay ninguna entrada que registrar, y la línea indica escribir la biblioteca bajo un directorio de catálogo.
A library reference is not written in the identity form (Una referencia a biblioteca no está escrita en la forma de identidad)
Un $ref: o $import: entre bibliotecas nombra la biblioteca por su identidad y luego la entrada dentro de ella: el nombre simple de la biblioteca, opcionalmente un : y una versión mínima, luego # y la ruta de la entrada en la superficie que lee el campo. En esa forma no hay ningún host de registro. Por qué registro se resuelve un nombre es configuración del espacio de trabajo, y qué versión usa una compilación es la respuesta del archivo de bloqueo, así que una referencia que llevara cualquiera de los dos fijaría en el documento algo que se supone que decide la compilación.
Se rechazan aquí: un valor que lleva un host de registro; un ancla interna al documento escrita donde se esperaba una referencia entre bibliotecas; un nombre de biblioteca vacío; y @ escrito como separador de versión, que se informa con la grafía corregida en lugar de como una queja genérica sobre la estructura, porque es el error que más atrae esta forma.
Mensaje emitido:
resolve: invalid library reference URI: "<the value as written>" (resolve: URI de referencia a biblioteca no válido)
y donde se usó @ como separador, citando lo que debería decir el valor en su lugar:
resolve: invalid library reference URI: version separator is ’:’, not ’@’ — use "<the corrected value>" (resolve: URI de referencia a biblioteca no válido: el separador de versión es ’:’, no ’@’ — usa el valor corregido)
Cómo corregirlo: reescribe el valor como <Library>#<entry-path>, añadiendo :<version> después del nombre de la biblioteca solo donde necesites un mínimo sobre qué versión puede seleccionarse. Elimina cualquier host de registro. Donde la referencia debía apuntar dentro del mismo documento, un ancla interna al documento es algo distinto de una referencia a biblioteca, y el campo en el que la escribiste espera la forma de biblioteca.
Two consumers of one library require incompatible versions (Dos consumidores de una misma biblioteca exigen versiones incompatibles)
Varias entidades pueden hacer referencia a una misma biblioteca, cada una indicando una versión mínima o ninguna, y la versión que selecciona la compilación es la versión mínima más alta que haya indicado cualquiera de ellas. Eso es lo que permite que un consumidor que pide menos reciba aun así una versión que lo satisface, y es la razón por la que añadir un consumidor con una versión mínima más alta hace subir a todos en lugar de dividir la compilación entre dos copias.
La regla solo se mantiene mientras las versiones mínimas coincidan en el número de versión inicial. Dos consumidores que indican versiones mayores distintas piden dos bibliotecas que casualmente comparten nombre, y ninguna selección única satisface a ambos — así que, en lugar de elegir una y dejar que el otro consumidor lea una estructura para la que no fue escrito, la compilación se detiene e indica el desacuerdo. Un consumidor que no indica ninguna versión mínima no participa en nada de esto: la selección la deciden los consumidores que fijaron una versión.
Mensaje emitido. Los consumidores se comparan en orden, una vez ordenados: el primero que indica una versión mínima fija la versión mayor, y el mensaje enumera cada consumidor comparado, hasta el primero, inclusive, cuya versión mínima indica una versión mayor distinta, junto con la versión que exigía — así, los mismos documentos siempre nombran a los mismos consumidores:
resolve: minimal version selection conflict — incompatible library version requirements: library "<library>" has consumers requiring incompatible majors: <consumer> wants <version>; <consumer> wants <version> (resolución: conflicto en la selección de versión mínima — requisitos de versión de biblioteca incompatibles: la biblioteca tiene consumidores que exigen versiones mayores incompatibles: el consumidor quiere la versión; el consumidor quiere la versión)
Cómo corregirlo: sube la versión mínima del consumidor más bajo a la misma versión mayor, que es la respuesta habitual una vez que la estructura más nueva es la que todos quieren. Cuando ambas versiones mayores se necesitan de verdad a la vez, son dos bibliotecas: publica la estructura más antigua con un nombre propio y haz que el consumidor que la necesita apunte allí, de modo que cada referencia nombre aquello para lo que fue escrita.
The chain of module imports is deeper than the pin walk descends (La cadena de importaciones de módulos es más profunda de lo que desciende el recorrido de fijación)
La fijación recorre cada módulo que importa un Aggregate y luego cada módulo que estos importan, de modo que el conjunto completo llega al archivo de bloqueo y no solo el primer nivel. Un módulo ya registrado no se recorre por segunda vez, y eso es lo que pone fin a un bucle ordinario — un Aggregate que importa un módulo que a su vez lo importa termina sin queja, tras haber registrado cada uno una sola vez.
Un límite de profundidad de diez sirve de respaldo para la cadena que la detección de repeticiones no puede ver: una que presenta una identidad nueva en cada nivel, como hace un módulo republicado con una nueva versión en cada paso. El límite es el mismo que aplica el constructor del grafo, de modo que una composición que se puede fijar es también una composición que se puede construir.
Mensaje emitido:
resolve: sub-aggregate inclusion depth exceeded: "<module>" at depth <depth> (resolución: profundidad de inclusión de subagregados superada: en la profundidad)
Cómo corregirlo: acorta la cadena. Una cadena tan profunda suele reflejar cómo está organizada una empresa más que cómo está organizada la Release, así que busca los niveles que no aportan componentes propios y fusiónalos en su padre. Cuando cada nivel existe solo para republicar el nivel inferior con una nueva versión, las versiones son la cadena: importa directamente el módulo que de verdad quieres, en la versión que quieres.
Este es el límite del recorrido de fijación. El constructor del grafo aplica el suyo propio, que se informa más abajo como «Sub-aggregate nesting depth exceeded (Profundidad de anidamiento de subagregados superada)», y ambos son informes distintos del mismo límite alcanzado en dos puntos — el primero mientras se rellena el archivo de bloqueo, el segundo mientras se construye el grafo.
The catalog view a build was given cannot load the bodies pinning needs (La vista del catálogo que recibió una compilación no puede cargar los cuerpos que necesita la fijación)
Dos de los ejes que recorre la fijación necesitan del catálogo algo más que una respuesta sobre la versión: necesitan los propios documentos. Los módulos que importa un Aggregate tienen que leerse para encontrar lo que importan ellos a su vez. Las Recipes, FeatureRecipes y Plugins que enlaza una compilación tienen que leerse para encontrar los artefactos y las bibliotecas que nombran ellos. Una vista del catálogo que puede resolver una versión pero no puede devolver esos cuerpos deja a ambos ejes sin nada que leer.
Ambos se rechazan de entrada en lugar de omitirse, y la razón es lo que produciría omitirlos: un archivo de bloqueo al que le falta una clase entera de entradas, escrito sin queja, que una compilación posterior reconstruye fielmente y encuentra incompleto. Ninguno de los dos mensajes lleva valores propios, porque ninguno trata de un documento que hayas escrito — cada uno indica qué eje no se puede calcular:
resolve: catalog lookup cannot load resolved sub-aggregate bodies (resolución: la búsqueda en el catálogo no puede cargar los cuerpos de los subagregados resueltos) resolve: catalog lookup cannot load resolved recipe and plugin bodies (resolución: la búsqueda en el catálogo no puede cargar los cuerpos de Recipe y de plugin resueltos)
Cómo corregirlo: nada en tus archivos produce ninguno de los dos, y no hay ningún cambio en lo que escribiste que elimine uno — el fallo está en cómo se conectó la compilación y no en lo que se le pidió construir. Infórmalo con el comando que ejecutaste y la configuración del espacio de trabajo con la que se ejecutó.
An annotation-transform plugin names a component it was not given, or injects a value no annotation takes (Un plugin annotation-transform nombra un componente que no se le entregó, o inyecta un valor que ninguna anotación admite)
Un operador puede vincular un plugin de gobernanza en un rol que añade anotaciones, y esa vinculación es una declaración: el operador pidió la transformación, de modo que lo que añade el plugin es explícito y no inyectado a espaldas de nadie. El rol está acotado en consecuencia. El plugin recibe las coordenadas de componentes que declaran tus documentos y puede añadir anotaciones sobre ellas, cada una con un valor que tú mismo podrías haber escrito en esa anotación: una cadena o un objeto de subclaves. La estructura que devuelve no admite ningún otro campo, así que lo que queda por comprobar cuando se aplica su salida es si cada inyección nombró una coordenada que se le entregó y si cada valor es uno que una anotación admite.
Una inyección que nombra un par de límite y componente fuera de ese conjunto detiene la compilación. Un plugin que alcanzara un componente que tus documentos nunca expusieron estaría configurando infraestructura que nadie declaró, y las anotaciones que añade se expanden en vinculaciones de Feature exactamente igual que las escritas por el autor, de modo que el efecto serían recursos que aparecen a partir de un componente que el operador no le puso delante.
Una inyección cuyo valor es null, una lista, un número, un booleano o un objeto sin subclaves también detiene la compilación. Null y un objeto vacío se interpretan como el valor que escribes para excluir un componente de una anotación que heredaría, y el rol añade anotaciones en lugar de quitarlas; las demás estructuras no son valores que una anotación admita. Toda la salida se comprueba antes de aplicar cualquier parte de ella, de modo que una salida rechazada no cambia nada.
Cada inyección aceptada lleva además una anotación acompañante, aggrega.ai/injected-by, que nombra el plugin que la hizo. Es el host quien escribe esa anotación; un plugin no puede suministrar una, de modo que lo que dice sobre el origen de una anotación inyectada no le corresponde al plugin darle forma.
Mensaje emitido, para una coordenada que no se entregó al plugin y para un valor que ninguna anotación admite:
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 salida del plugin annotation-transform fue rechazada: una inyección apunta a una coordenada de componente que el host no suministró, o lleva un valor que no es una cadena ni un objeto de subclaves: la inyección apunta al límite, componente (anotación)) 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 salida del plugin annotation-transform fue rechazada: una inyección apunta a una coordenada de componente que el host no suministró, o lleva un valor que no es una cadena ni un objeto de subclaves: la inyección para el límite, componente (anotación) lleva una lista; un valor de anotación inyectado es una cadena o un objeto de subclaves)
Cómo corregirlo: el fallo es del plugin y no de tus documentos — corrígelo para que inyecte solo sobre las coordenadas que se le entregan, cada una de las cuales llega en su entrada, y solo una cadena o un objeto de subclaves como valor. Si el componente del mensaje es uno que esperabas que el plugin viera, comprueba que la Release lo declare dentro de un límite: solo se entregan las coordenadas de componentes declarados. Quitar la vinculación de plugins.governance es la forma inmediata de desbloquear una compilación mientras se corrige el plugin.
A plugin reference is not a Plugin entity (Una referencia a un plugin no es una entidad Plugin)
Un plugin se referencia mediante su entidad Plugin, siempre en el ámbito del propio tipo de socket del plugin: <pluginType>/<name>, opcionalmente con una versión, como en parser/yaml o parser/yaml:1.0.0. El ámbito es obligatorio, no una forma entre varias — un name:version sin ámbito se rechaza, porque dos sockets pueden contener un plugin con el mismo nombre y es el ámbito lo que hace resoluble la entidad. Al binario al que apunta la entidad se llega a través de la entidad, nunca se nombra directamente, de modo que es la entidad la que lleva la declaración de capacidades, los límites de ejecución y el conjunto de comandos registrado con los que la carga comprueba el binario. Por tanto, una referencia que no nombra ninguna entidad Plugin no tiene nada con lo que comprobar el binario, y la compilación se detiene en lugar de cargar bytes a partir de una referencia sin comprobar.
Aquí se informan dos estructuras, y se comprueban en momentos distintos. Una referencia cuya forma no puede ser una entidad — una ruta del sistema de archivos, o una referencia a un artefacto como una URL oci://, un .wasm sin más o un resumen @sha256: — se rechaza de entrada en las superficies que solo aceptan referencias a entidades. Una referencia que no nombra ninguna entidad que algo contenga se rechaza tras la búsqueda, y lo que dice el mensaje depende de cómo esté escrita: un URI de entidad Plugin — <pluginType>/<name>, opcionalmente con versión — se informa como una entidad que ningún directorio de catálogo contiene, que el binario no incluye y que ningún pull ha descargado, y a cualquier otra referencia se le indica que adopte esa forma. Ambas estructuras informan de la misma condición, de modo que la respuesta de una compilación a cualquiera de ellas es la misma.
Un pull rechaza la segunda estructura antes de que una compilación se encuentre con ella. Cada Plugin que nombra la pipeline de una Recipe o de una FeatureRecipe se resuelve junto con el resto de las dependencias de la Release — desde un directorio de catálogo, la copia incluida en el binario del compilador, la caché de contenido o un registro — y uno que ninguno de ellos contiene detiene aggrega pull antes de que escriba el archivo de bloqueo, con esta condición y el mismo mensaje, nombrando la Recipe o la FeatureRecipe cuya pipeline lo nombra.
No todas las superficies rechazan una forma que no es una entidad. La superficie de plugins de pipeline solo acepta referencias a entidades; las superficies a las que un operador vincula un plugin directamente aceptan cualquier forma y pasan una referencia que no es una entidad para que se resuelva como artefacto. Así, la misma referencia puede aceptarse en un punto de vinculación y rechazarse en otro, y esa diferencia es de la superficie, no de la referencia.
Mensajes emitidos. Una ruta del sistema de archivos:
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 referencia al plugin no es una entidad Plugin: es una ruta del sistema de archivos, pero un plugin de pipeline debe ser un URI de entidad Plugin en el ámbito de un tipo de plugin (opcionalmente con versión))
una referencia a un artefacto:
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 referencia al plugin no es una entidad Plugin: es una referencia a un artefacto (un esquema de URL, un archivo Wasm sin más o un resumen), pero un plugin de pipeline debe ser un URI de entidad Plugin en el ámbito de un tipo de plugin (opcionalmente con versión))
un URI de entidad Plugin que nada contiene:
plugin reference is not a Plugin entity: "<reference>" is a Plugin entity URI, but no catalog directory holds the entity it names, the binary does not carry it, and no pull has fetched it into the content cache; place the Plugin entity in a catalog directory, or publish it to a registry and run aggrega pull (la referencia al plugin no es una entidad Plugin: es un URI de entidad Plugin, pero ningún directorio de catálogo contiene la entidad que nombra, el binario no la incluye y ningún pull la ha descargado en la caché de contenido; coloca la entidad Plugin en un directorio de catálogo, o publícala en un registro y ejecuta el pull)
y cualquier otra referencia que no nombre ninguna entidad — una sin ámbito de tipo de plugin, con más de una / antes de su versión, o que lleve un host de registro:
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 referencia al plugin no es una entidad Plugin: debe ser un URI de entidad Plugin en el ámbito de un tipo de plugin (opcionalmente con versión); una referencia a un archivo Wasm sin más o una referencia a un artefacto no nombra ninguna entidad Plugin)
Cómo corregirlo: escribe la referencia como la identidad de la entidad Plugin en el ámbito de su tipo de socket, opcionalmente con su versión — <pluginType>/<name> o <pluginType>/<name>:<version>. Si apuntabas directamente a un archivo o a un artefacto, publica o escribe una entidad Plugin para él y haz referencia a ella en su lugar — la entidad es donde residen las declaraciones que comprueba la carga, así que no existe una forma equivalente que la omita. Si el mensaje dice que la referencia es un URI de entidad Plugin, su forma es correcta y lo que falta es la entidad: coloca la entidad Plugin en un directorio de catálogo que el espacio de trabajo enumere, con su .wasm compilado al lado, o publica el plugin en un registro que lea el espacio de trabajo y ejecuta aggrega pull, que lo descarga en la caché de contenido — y comprueba que la versión que indicas exista.
A cached signature bundle does not match the digest recorded for it (Un bundle de firma en caché no coincide con el digest registrado para él)
Un artefacto cuya firma se verificó al descargarlo conserva ese hecho en su entrada del archivo de bloqueo — o, para un plugin vinculado a un rol de veredicto, en su entrada de plugins-trust.yaml — como un digest registrado del material de firma, almacenado en caché junto al artefacto. Antes de que se renderice nada, la compilación vuelve a leer ese material en caché para cada entrada que lee y que registra uno — una entidad de catálogo de cualquier tipo, una biblioteca, un plugin — y recalcula su hash, que debe ser el registrado. Un plugin que el archivo de bloqueo fija, y un plugin vinculado a un rol de veredicto, vuelve a tener su material comprobado cuando se cargan sus bytes, y es eso lo que alcanza a los comandos que cargan un plugin fuera de una compilación — entre ellos aggrega lint --release y aggrega validate --release. Un bundle que falta, que no se puede leer o cuyo hash es otro significa que el material revisado no es lo que hay ahora en el disco, y la ejecución se detiene en lugar de usar un artefacto cuya evidencia de firma ha cambiado sin que lo refleje el registro.
La nueva comprobación es una comparación de hashes y nada más. No vuelve a verificar ninguna firma, no contacta con ninguna red ni consulta ningún material de confianza, por lo que se mantiene en una compilación sin ningún acceso a la red — y eso es lo que permite que un artefacto verificado una vez siga verificado en las compilaciones posteriores sin conexión.
El siguiente pull lo repara. Un pull somete a la misma comprobación cada entrada que sirvió la caché de contenido y, donde la comprobación rechaza una entrada, vuelve a preguntar al registro del artefacto por la firma — diga lo que diga el requisito de firma, mediante la misma verificación que recibe un artefacto que descarga —, registra en la entrada lo que esa verificación confirma y almacena en caché el bundle que esta nombra, reescribiendo una copia en caché que ya no coincide con su digest. Un plugin vinculado a un rol de veredicto se verifica de nuevo en cada pull, registre lo que registre su entrada, y su bundle se almacena en caché de la misma manera. Por eso el mensaje de una entrada que sirvió la caché de contenido nombra ese pull. Una entrada leída de un directorio de catálogo, de la copia incluida en el binario del compilador o de junto a la Release nunca se consulta en un registro, por lo que un pull deja tal cual una firma registrada en ella, y su mensaje no nombra ningún pull.
Mensajes emitidos, que nombran el artefacto, el archivo en caché y — para una entrada que sirvió la caché de contenido — el pull que la repara, el archivo en el que registra la firma y la Release que descarga. Desde la comprobación de la compilación, ilegible o ausente:
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 (artefacto: el bundle de firma en caché no se puede leer: el bundle de firma en caché no coincide con su digest registrado. solución: ejecuta el pull para volver a verificar la firma del artefacto en su registro, registrarla en el archivo y almacenar en caché el bundle que nombra)
y divergente:
artifact "<reference>": cached signature bundle <path> has digest <actual>, recorded digest is <recorded>: cached signature bundle does not match its recorded digest. remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (artefacto: el bundle de firma en caché tiene un digest distinto del registrado: el bundle de firma en caché no coincide con su digest registrado. solución: ejecuta el pull para volver a verificar la firma del artefacto en su registro, registrarla en el archivo y almacenar en caché el bundle que nombra)
y, cuando los bytes de un plugin se cargan desde la caché de contenido, nombrando también de dónde proceden:
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 resuelto desde su fuente: el bundle de firma en caché no se puede leer: el bundle de firma en caché no coincide con su digest registrado. solución: ejecuta el pull para volver a verificar la firma del artefacto en su registro, registrarla en el archivo y almacenar en caché el bundle que nombra)
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 resuelto desde su fuente: el bundle de firma en caché tiene un digest distinto del registrado: el bundle de firma en caché no coincide con su digest registrado. solución: ejecuta el pull para volver a verificar la firma del artefacto en su registro, registrarla en el archivo y almacenar en caché el bundle que nombra)
<file> es el archivo de bloqueo de la Release, o plugins-trust.yaml en el directorio de la Release. Para una entrada por la que ningún pull pregunta, el mensaje termina antes de remediation:.
Un pull que no tiene ningún registro al que preguntar se detiene en su lugar. Una entidad de catálogo o una biblioteca se nombra sin registro y se enlaza a uno mediante el default_registry del espacio de trabajo. Donde el espacio de trabajo no nombra ninguno — lo hacía cuando se registró la firma, y ya no lo hace —, no hay ningún registro configurado al que volver a preguntar por la entrada, por lo que el pull se detiene con esta condición en lugar de escribir un archivo de bloqueo que la siguiente compilación rechaza, y deja el archivo de bloqueo como estaba. Su mensaje contiene, después del paso que el pull estaba realizando:
verify: "<reference>" records a signature a build does not accept, and no registry is configured to ask about it again: cached signature bundle <path> is unreadable: cached signature bundle does not match its recorded digest (verify: registra una firma que una compilación no acepta, y no hay ningún registro configurado al que volver a preguntar por ella: el bundle de firma en caché no se puede leer: el bundle de firma en caché no coincide con su digest registrado)
Cómo corregirlo: nada en tus archivos de entidades causa esto — la caché es de la compilación, no tuya. Ejecuta aggrega pull --release <release>, el comando que nombra el mensaje: vuelve a verificar la firma del artefacto y escribe juntos la firma y su bundle, lo que repara un bundle eliminado o alterado desde el pull que lo almacenó en caché. En modo sin conexión ese pull se detiene — con el rechazo sin conexión, porque reparar implica preguntar al registro, o, para un plugin vinculado a un rol de veredicto, antes de eso, nombrando el .wasm del plugin como uno que no pudo resolver, porque un pull resuelve ese .wasm desde el registro del plugin; permitir la red para esa única ejecución lo repara. Donde el pull se detiene diciendo que no hay ningún registro configurado al que preguntar por la entrada, establece default_registry en el registro del que se hizo el pull del artefacto, y vuelve a hacer el pull. Donde el espacio de trabajo omite la verificación de firmas para el artefacto, el pull no registra en su lugar ninguna firma en la entrada, lo que la compilación admite con ese mismo ajuste. Donde la firma que sirve el registro no se verifica, el pull se detiene con el rechazo propio de esa verificación: la firma registrada y el material que sirve el editor discrepan de verdad, y esa es una cuestión para quien publica el artefacto. Para una entrada cuyo mensaje no nombra ningún pull — una leída de un directorio de catálogo, de la copia incluida en el binario del compilador o de junto a la Release —, elimina la signature de su entrada: una entrada así nunca se somete a un requisito de firma, por lo que la compilación sigue adelante.
A recorded signature was made for a different artifact (Una firma registrada se creó para un artefacto diferente)
Una firma indica para qué artefacto se creó. Cuando un pull verifica la firma de un artefacto, registra el hecho en la entrada del archivo de bloqueo del artefacto — o, para un plugin vinculado a un rol de veredicto, en su entrada de plugins-trust.yaml — y almacena en caché la firma que verificó. Antes de que se renderice nada, la compilación lee, en la firma en caché de cada entrada que sirvió la caché de contenido, para qué artefacto se creó, y ese tiene que ser el artefacto que la propia compilación leyó para la entrada: aquel cuyo manifiesto se conserva junto a sus bytes en la caché de contenido, nunca nada que registre la entrada. Una firma creada para un artefacto diferente detiene la compilación. Es el aspecto que tiene una signature copiada de una entrada a otra: la firma en caché que nombra está intacta — sigue coincidiendo con el digest registrado para ella — y se creó para el artefacto de la otra entrada.
No depende de un requisito de firma. Una firma registrada se contrasta con lo que afirma tanto si se requiere una firma como si no, como ocurre con la comprobación de que la firma en caché coincide con su digest registrado.
Un plugin se somete al mismo control dondequiera que se cargue. Un plugin que el archivo de bloqueo fija, y un plugin vinculado a un rol de veredicto, tiene su firma registrada contrastada con el artefacto del que se leyeron sus bytes cuando esos bytes se cargan desde la caché de contenido, lo que alcanza a los comandos que cargan un plugin fuera de una compilación — entre ellos aggrega lint --release y aggrega validate --release, y las mismas operaciones a las que se llega mediante aggrega serve y aggrega mcp.
Qué lee la comprobación y qué no puede distinguir. Lee la firma en caché y el manifiesto junto al artefacto, y compara hashes: no verifica ninguna firma, no contacta con ninguna red ni consulta ningún material de confianza, por lo que se mantiene en una compilación sin ningún acceso a la red. Lee para qué artefacto se creó una firma en las dos formas que acepta un pull — una firma hecha sobre el propio artefacto, que es lo que producen los firmantes propios de la cadena de herramientas, y una declaración firmada que nombra el artefacto —, por lo que una firma copiada de una entrada a otra se rechaza en cualquiera de las dos formas. Es la misma lectura que un pull aplica a cada firma que acepta: un pull rechaza una firma que se verifica pero que la lectura no encuentra creada para el artefacto, o de la que no puede leer el artefacto en absoluto, por lo que ninguna firma que registra un pull es una que la comprobación no pueda leer. Una entrada leída de un directorio de catálogo, de la copia incluida en el binario del compilador o de junto a la Release no trae ningún manifiesto, por lo que su firma registrada solo se contrasta con su digest registrado; lo mismo ocurre con una firma colocada a mano en la caché en una forma que no es ninguna de esas dos. Y como no se verifica ninguna firma, una firma escrita a mano en la caché, emitida para el propio artefacto de la entrada, no se distingue de una que verificó un pull.
El siguiente pull lo repara. Un pull somete a la misma comprobación cada entrada que sirvió la caché de contenido y, donde la comprobación rechaza una entrada, vuelve a preguntar al registro del artefacto por la firma — diga lo que diga el requisito de firma — y registra en la entrada lo que esa verificación confirma en lugar de la firma copiada. Un plugin vinculado a un rol de veredicto se verifica de nuevo en cada pull, registre lo que registre su entrada. Solo en una entrada que sirvió la caché de contenido se comprueba para qué artefacto se creó su firma, por lo que cada rechazo de esta condición por parte de una compilación o de una carga de plugin nombra ese pull.
Mensajes emitidos, que nombran la entrada, el archivo que registra la firma, la firma en caché, el manifiesto que la compilación leyó para la entrada y el pull que la repara. Desde la comprobación de la compilación:
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 (artefacto: signing: la firma registrada se creó para un artefacto diferente, con el archivo que la registra, el bundle de firma en caché y el manifiesto del artefacto leído. solución: ejecuta el pull para volver a verificar la firma del artefacto en su registro, registrarla en el archivo y almacenar en caché el bundle que nombra)
y, cuando se cargan los bytes de un plugin, nombrando también de dónde proceden:
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 resuelto desde su fuente: signing: la firma registrada se creó para un artefacto diferente, con el archivo que la registra, el bundle de firma en caché y el manifiesto del artefacto leído. solución: ejecuta el pull para volver a verificar la firma del artefacto en su registro, registrarla en el archivo y almacenar en caché el bundle que nombra)
<file> es el archivo de bloqueo de la Release, o plugins-trust.yaml en el directorio de la Release.
Un pull que no tiene ningún registro al que preguntar se detiene en su lugar, como hace con un bundle de firma en caché que ya no coincide con su digest: donde una entidad de catálogo o una biblioteca lleva una firma copiada y el espacio de trabajo ya no nombra un default_registry al que enlazarla, el pull se detiene con esta condición y deja el archivo de bloqueo como estaba. Su mensaje contiene, después del paso que el pull estaba realizando:
verify: "<reference>" records a signature a build does not accept, and no registry is configured to ask about it again: signing: the recorded signature was made for a different artifact (cached signature bundle <path>, the artifact read has manifest <manifest-digest>) (verify: registra una firma que una compilación no acepta, y no hay ningún registro configurado al que volver a preguntar por ella: signing: la firma registrada se creó para un artefacto diferente, con el bundle de firma en caché y el manifiesto del artefacto leído)
Cómo corregirlo: nada en tus archivos de entidades causa esto — la firma que registra la entrada pertenece a otro artefacto. Ejecuta aggrega pull --release <release>, el comando que nombra el mensaje: verifica la firma propia de la entrada en su registro y la registra en lugar de la copiada, tanto para una entrada del archivo de bloqueo como para un plugin vinculado a un rol de veredicto. Restaurar desde el control de versiones la firma registrada propia de la entrada, donde el archivo está confirmado, también funciona. En modo sin conexión el pull se detiene — con el rechazo sin conexión, porque reparar implica preguntar al registro, o, para un plugin vinculado a un rol de veredicto, antes de eso, nombrando el .wasm del plugin como uno que no pudo resolver, porque un pull resuelve ese .wasm desde el registro del plugin; permitir la red para esa única ejecución lo repara. Donde el pull se detiene diciendo que no hay ningún registro configurado al que preguntar por la entrada, establece default_registry en el registro del que se hizo el pull del artefacto, y vuelve a hacer el pull. Donde el espacio de trabajo omite la verificación de firmas para el artefacto, el pull no registra en su lugar ninguna firma en la entrada, lo que la compilación admite con ese mismo ajuste.
No verified signature is recorded for an artifact that requires one (No hay ninguna firma verificada registrada para un artefacto que la requiere)
Un pull que descarga un artefacto de un registro verifica su firma según la política de confianza de ese registro y registra el hecho verificado en la entrada del archivo de bloqueo del artefacto. Una compilación no llega a ningún registro, así que lee el hecho registrado en lugar de verificar de nuevo — y, antes de que se renderice nada, somete cada entrada que lee al requisito que el pull aplicó cuando descargó el artefacto. Una entrada servida por la caché de contenido, para un artefacto para el que se requiere una firma, que no registra ninguna firma verificada detiene la compilación: nada de lo que la compilación tiene dice que el artefacto a partir del cual está a punto de renderizar se haya verificado alguna vez.
El requisito es el del pull, ajuste por ajuste. Se requiere una firma donde la política de firma de todo el espacio de trabajo cubre el tipo del artefacto, o donde la propia entrada del registro en .aggrega-config.yaml — o, para hub.aggrega.ai sin entrada propia, la política integrada del hub oficial — exige una; un artefacto cuyo tipo no se pudo determinar cuenta como requerido bajo una política activa. Lo que permite a un pull admitir un artefacto sin firma permite también a la compilación admitir su entrada: skip_signature_verification en el nivel superior, el mismo interruptor en la propia entrada del registro salvo para un tipo que la política de todo el espacio de trabajo requiere, y un registro marcado como advisory.
De dónde viene una entrada se lee de la compilación, nunca del archivo de bloqueo. Toda entrada servida por la caché de contenido se somete al requisito, registre lo que registre la entrada además, así que eliminar el digest del manifiesto de una entrada junto con su firma no la exime. Una entrada leída de un directorio de catálogo, de la copia incluida en el binario del compilador o de junto a la Release nunca se somete a él, porque no existe ninguna firma de registro para bytes que no provienen de uno. Las entradas de todas las secciones se comprueban por igual — entidades de catálogo, bibliotecas y artefactos de plugin — y cada entrada que la comprobación rechaza se nombra en la misma ejecución.
Un plugin vinculado en un rol de veredicto queda sujeto a la misma comprobación, a través de plugins-trust.yaml. Una vinculación plugins.governance en un rol ir-verdict o render-verdict, y toda vinculación plugins.linter, no da forma a ningún byte renderizado, así que no tiene entrada en el archivo de bloqueo; el archivo de confianza junto al archivo de bloqueo lleva en su lugar su firma verificada. Cada uno de estos plugins que la compilación lee de la caché de contenido queda sujeto al mismo requisito, a través de los mismos ajustes: una entrada de ese archivo de confianza que no registra ninguna firma detiene la compilación, y también la ausencia de toda entrada para el plugin — eliminar el archivo de confianza no lo exime. Un plugin servido desde un directorio de catálogo o desde la copia incluida en el binario del compilador no queda sujeto. El requisito se aplica a un plugin así dondequiera que se cargue para una Release, no solo en una compilación: aggrega lint --release y aggrega validate --release, y las mismas operaciones alcanzadas a través de aggrega serve y aggrega mcp, fallan por esta condición cuando lo cargan.
Mensajes emitidos, que nombran la entrada, el archivo que no registra ninguna firma para ella, los ajustes que exigen su firma y el comando que la registra en ese archivo. Para una entrada del archivo de bloqueo, nombrando el archivo de bloqueo:
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: no hay ninguna firma verificada registrada para un artefacto que la requiere: el archivo de bloqueo no registra ninguna firma para él, requerida por los ajustes indicados. solución: ejecuta el pull para verificar la firma del artefacto en su registro y registrarla en el archivo de bloqueo)
y para un plugin vinculado en un rol de veredicto, nombrando su archivo de confianza:
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: no hay ninguna firma verificada registrada para un artefacto que la requiere: el archivo de confianza no registra ninguna firma para el plugin, requerida por los ajustes indicados. solución: ejecuta el pull para verificar la firma del plugin en su registro y registrarla en el archivo de confianza)
Ambos archivos se nombran por su ruta junto a la Release que se dio al comando: <lockfile-path> es el archivo de bloqueo de la Release, y <record-path> es plugins-trust.yaml en el directorio de la Release.
Los ajustes se nombran con las propias palabras del archivo de configuración: `signing.required` at the top level of the workspace configuration, `signing.required` on the `registries` entry for "<host>" o the official hub's built-in signature requirement for "hub.aggrega.ai", unidos donde se aplica más de uno.
Cómo corregirlo: ejecuta el pull que nombra el mensaje. Para una entrada servida por la caché de contenido que no registra ninguna firma donde se requiere una, el pull pide al registro del artefacto su firma, por el digest del manifiesto que registra la entrada, exactamente como lo hace para un artefacto que descarga, y registra la firma verificada en la entrada — de modo que la siguiente compilación la lee. Por un plugin vinculado en un rol de veredicto se pregunta en cada pull en cualquier caso, y el pull registra lo que verificó en la entrada del plugin en plugins-trust.yaml, creando la entrada donde no la hay. Un registro que no vincula ninguna firma, o una firma que la configuración de confianza no acepta, detiene en cambio ese pull, nombrando el artefacto, y eso es una cuestión para quien lo publica. En modo sin conexión el pull no puede preguntar: sobre una entrada del archivo de bloqueo rechaza indicando cómo permitir la red para una ejecución, y sobre un plugin vinculado en un rol de veredicto se detiene antes de preguntar, nombrando el .wasm del plugin como uno que no pudo resolver, porque un pull resuelve ese .wasm desde el registro del plugin. Restaurar la firma registrada de la entrada desde el control de versiones lo resuelve sin la red, donde la caché aún contiene el material de firma que nombra esa entrada. Donde el artefacto no está pensado para firmarse, lo que hay que cambiar es el requisito, y el mensaje nombra qué ajuste es — pero relajarlo significa que los artefactos de ese registro dejan de comprobarse también en un pull, así que es preferible restringir los tipos de la política de todo el espacio de trabajo antes que desactivar un requisito.
A recorded signature is not the one a pull would record (Una firma registrada no es la que registraría un pull)
aggrega pull --verify informa de si ejecutar aggrega pull ahora cambiaría los archivos que un pull escribe, y la firma que un pull verificó para un artefacto forma parte de lo que escribe: la signature en una entrada del archivo de bloqueo, y en una entrada de plugins-trust.yaml para un plugin vinculado en un rol de veredicto. Esta condición es lo que una verificación informa para cada firma registrada que un pull simple escribiría de otro modo — una que registraría donde no hay ninguna registrada, una que reemplazaría o una que borraría. La verificación no escribe ninguno de los dos archivos y nombra cada una de esas entradas, en cualquiera de los dos archivos, en la misma ejecución.
Dos entradas del archivo de bloqueo se informan sin preguntar a un registro, porque un pull las reescribe responda lo que responda el registro, así que se informan también en modo sin conexión: una entrada servida por la caché de contenido que no registra ninguna firma donde la configuración de confianza exige una — el pull registra la firma del artefacto, o se detiene donde no puede establecer una — y una entrada cuya firma registrada se hizo para otro artefacto, que el pull reemplaza por la propia del artefacto.
Por toda otra entrada que un pull volvería a consultar se pregunta, porque solo la respuesta del registro dice si el pull la cambiaría: una entrada cuyos bytes descargó la verificación porque la caché de contenido no los contenía, y una entrada cuyo bundle de firma en caché se eliminó, es ilegible o se alteró. La verificación pregunta al registro como lo haría el pull, informa de la entrada donde la respuesta registra, reemplaza o borra su firma, y guarda en caché el bundle que verificó como lo guarda un pull. En modo sin conexión no se pregunta por una entrada así ni se informa de ella: la verificación imprime una línea que la nombra y dice que su firma no se comprobó.
Para el archivo de confianza de plugins, todo pull verifica la firma de cada plugin vinculado en un rol de veredicto en su registro, y también lo hace una verificación: se informa de una entrada cuya firma esa verificación registraría, reemplazaría o borraría, y también de un plugin para el que el archivo de confianza no contiene ninguna entrada donde una compilación lo rechaza por no registrar ninguna firma, porque un pull escribe una entrada que lleva su firma y la compilación rechaza el plugin hasta entonces. Cualquier otro plugin que el archivo de confianza aún no contiene es una primera aparición y no se informa. En modo sin conexión una verificación no pregunta a ningún registro por estos plugins: lee cada uno de la caché de contenido, como lo lee una compilación, y comprueba su identidad y sus funciones host como lo hace una verificación conectada. Informa sin preguntar de un plugin que una compilación rechaza por no registrar ninguna firma — su entrada no registra ninguna, o el archivo de confianza no contiene ninguna entrada para él — y de uno que una compilación rechaza porque la firma que registra su entrada se hizo para otro artefacto, porque un pull reescribe esa entrada responda lo que responda el registro; imprime una línea que nombra cada otra entrada y dice que su firma no se comprobó.
Los marcadores de obsolescencia no se comparan. Un marcador vinculado a un artefacto después del pull es el estado del registro y cambia sin que cambie nada en el espacio de trabajo, así que una verificación que fallara por uno haría fallar una comprobación sobre archivos que nadie ha tocado — la razón por la que un marcador registrado advierte a una compilación en lugar de detenerla.
Mensajes emitidos, uno por entrada, que nombran la entrada, el archivo y lo que registra, lo que un pull registraría en su lugar, y el pull que actualiza el archivo. Donde la respuesta del registro, o la verificación propia del archivo de confianza, da la firma que un pull registraría:
signing: a recorded signature is not the one a pull would record ("<reference>", <file> records <signature>, a pull would record <signature>). remediation: run aggrega pull --release <release> to bring <file> up to date (signing: una firma registrada no es la que registraría un pull: el archivo registra una firma, un pull registraría otra. solución: ejecuta el pull para actualizar el archivo)
para una entrada que no registra ninguna firma donde se requiere una — una entrada del archivo de bloqueo o, en modo sin conexión, una entrada del archivo de confianza de 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: una firma registrada no es la que registraría un pull: el archivo no registra ninguna firma, un pull pediría a su registro la firma que exige un requisito y la registraría. solución: ejecuta el pull para actualizar el archivo)
para una entrada cuya firma registrada se hizo para otro artefacto — una entrada del archivo de bloqueo o, en modo sin conexión, una entrada del archivo de confianza de 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: una firma registrada no es la que registraría un pull: el archivo registra una firma hecha para otro artefacto, un pull pediría a su registro la firma propia de este artefacto y la registraría. solución: ejecuta el pull para actualizar el archivo)
y para un plugin para el que el archivo de confianza no contiene ninguna entrada, donde una compilación lo rechaza por no registrar ninguna firma — la segunda forma en modo sin conexión, donde la verificación no pregunta a ningún registro:
signing: a recorded signature is not the one a pull would record ("<plugin>", <record-path> records no entry for it and a signature is required for it, a pull would record <signature>). remediation: run aggrega pull --release <release> to bring <record-path> up to date (signing: una firma registrada no es la que registraría un pull: el archivo de confianza no contiene ninguna entrada para el plugin y se requiere una firma para él, un pull registraría una firma. solución: ejecuta el pull para actualizar el archivo de confianza)
signing: a recorded signature is not the one a pull would record ("<plugin>", <record-path> records no entry for it and a signature is required for it, a pull would ask its registry for the signature a requirement asks for and record it). remediation: run aggrega pull --release <release> to bring <record-path> up to date (signing: una firma registrada no es la que registraría un pull: el archivo de confianza no contiene ninguna entrada para el plugin y se requiere una firma para él, un pull pediría a su registro la firma que exige un requisito y la registraría. solución: ejecuta el pull para actualizar el archivo de confianza)
<signature> indica una firma por su modo, su firmante y el digest de su bundle — a keyed signature by keyed:sha256:<fingerprint> with bundle digest sha256:<digest>, con issued by <issuer> después del firmante para una firma sin clave — o es no signature. <file> es el archivo de bloqueo de la Release, <lockfile-path>, o plugins-trust.yaml en el directorio de la Release, <record-path>.
Cómo corregirlo: ejecuta el pull que nombra el mensaje. Escribe en el archivo nombrado la firma que el mensaje dice que escribiría, y guarda su bundle en caché, de modo que la siguiente verificación pasa. Donde el mensaje dice que un pull preguntaría al registro, el pull registra lo que el registro verifica — y se detiene en cambio, nombrando el artefacto, donde el registro vincula una firma que la configuración de confianza no acepta, o ninguna donde se requiere una, lo cual es una cuestión para quien lo publica. En modo sin conexión ese pull se detiene: sobre una entrada del archivo de bloqueo con el rechazo sin conexión, porque tiene que preguntar al registro, y sobre un plugin vinculado en un rol de veredicto antes de eso, nombrando el .wasm del plugin como uno que no pudo resolver, porque un pull resuelve ese .wasm desde el registro del plugin. Permitir la red para esa única ejecución actualiza el archivo. Donde el mensaje dice que un pull no registraría ninguna firma, el registro ya no vincula ninguna y nada la requiere: el pull borra la firma de la entrada, lo que una compilación admite con los mismos ajustes — si no esperabas que el registro dejara de firmar el artefacto, eso también es una cuestión para su editor.
A plugin’s .wasm is not on this machine (El archivo Wasm de un plugin no está en esta máquina)
El .wasm de un plugin se lee de uno de cuatro lugares, en este orden: los plugins integrados en el binario del compilador, un archivo junto a la entidad Plugin del plugin en un directorio de catálogo, una ruta explícita del sistema de archivos que nombra la referencia, y la caché de contenido del espacio de trabajo que llena aggrega pull. Resolver un plugin solo lee lo que ya está en la máquina y no descarga nada, por lo que esta condición informa de que ninguno de los cuatro contiene los bytes — no de que una descarga haya fallado. Un plugin es la excepción: un importador core que una importación necesita. Su módulo se lee solo del binario o de la caché de contenido, nunca de junto a una entidad de catálogo, y donde ninguno de los dos lo contiene, la importación lo descarga una vez del registro predeterminado del espacio de trabajo; la condición informa entonces también de que la descarga no fue posible — el espacio de trabajo está sin conexión, su registro no pudo alcanzarse o no contiene el módulo, o el espacio de trabajo no nombra ningún registro predeterminado. Un módulo que se descargó y no supera la verificación se rechaza en cambio bajo su propia condición, una discrepancia de digest o un rechazo de firma, y no se conserva nada.
El archivo junto a la entidad recibe su nombre del tipo de plugin y del nombre de la entidad, y el rechazo del pull que aparece más abajo da el nombre: para pipeline-step/patch es pipeline-step--patch.wasm, en el directorio en el que está el documento de la entidad.
Una entidad Plugin escrita en uno de tus directorios de catálogo se rechaza cuando el pull la resuelve. Un pull nunca descarga el .wasm de una entidad así: busca en los cuatro lugares anteriores, exactamente donde busca una compilación. Un paso de pipeline, un proveedor o un plugin vinculado a un rol de veredicto no se fija en absoluto, y una compilación lee su entidad del directorio de catálogo cada vez. Un plugin vinculado a un rol de transformación se fija, porque sus bytes dan forma a la salida renderizada: el pull registra su entidad y el digest de contenido del .wasm que encontró allí, y una compilación rechaza un .wasm que ya no coincide. Así, un pull que no encuentra el artefacto en ninguno de los cuatro lugares se detiene ahí, antes de escribir el archivo de bloqueo o cualquier entity.lock, en lugar de dejar que una compilación falle más tarde, en el paso que carga el plugin. Un .wasm que lleva el binario, o uno que ya está en la caché de contenido, satisface al pull exactamente como satisface a la compilación, por lo que una entidad para un plugin que se distribuye dentro del compilador no necesita ningún archivo junto a ella.
Mensajes emitidos. El rechazo del pull, que señala el directorio en el que esperaba el archivo, con debajo la resolución por la que preguntó:
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 (artefacto de plugin no encontrado en esta máquina: la entidad Plugin está escrita en un directorio de catálogo y se esperaba el archivo indicado en el directorio indicado. Coloca el .wasm compilado junto a la entidad con ese nombre, o publica el plugin y haz referencia a la entidad Plugin publicada en lugar de a la del directorio de catálogo)
un plugin que una compilación o una importación carga sin que ninguna fuente contenga sus bytes — y un plugin vinculado a un rol de veredicto que aggrega pull --verify en modo sin conexión lee de la caché de contenido como lo hace una compilación. Donde la entidad Plugin del plugin está en una carpeta de catálogo, nombrando la versión en la que está y adónde va su módulo:
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 (el plugin, en la versión indicada, no está en esta máquina; coloca su módulo, con el nombre indicado, junto a su entidad Plugin en el directorio indicado: artefacto de plugin no encontrado en esta máquina)
y en otro caso, nombrando cada lugar en el que se buscó el módulo:
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 (el plugin no está en esta máquina: el binario no lleva su módulo, ninguna carpeta de catálogo contiene su entidad Plugin y la caché de contenido en la que descarga un pull no lo contiene: artefacto de plugin no encontrado en esta máquina)
Un lint, que solo busca en el binario, nombra únicamente el primero de esos lugares.
y lo mismo para una referencia escrita como una ubicación de registro:
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 no resoluble: un URI de plugin OCI requiere un pull previo, para que sus bytes estén en caché, o una ruta local explícita; la resolución de plugins no descarga de un registro: artefacto de plugin no encontrado en esta máquina)
un importador core que una importación no pudo ni leer ni descargar, nombrando el importador, su versión y el motivo — aquí, que el espacio de trabajo está sin conexión — y luego lo que pone su módulo en la máquina:
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 (el importador core, en la versión indicada, no está en esta máquina, y el espacio de trabajo está sin conexión, por lo que no se le pide a su registro; ejecuta la importación una vez con la red disponible, lo que lo descarga del registro predeterminado del espacio de trabajo, lo verifica y lo conserva en la caché de contenido para cada importación posterior, o coloca su módulo, con el nombre indicado, junto a una entidad Plugin de ese importador en esa versión en una carpeta de catálogo: artefacto de plugin no encontrado en esta máquina)
Los otros motivos dicen its registry <host> could not be reached (<cause>), its registry <host> holds no <location>:<version> y the workspace names no default registry to fetch it from; los dos últimos nombran solo el segundo remedio, porque una ejecución con la red disponible no los cambiaría.
Cómo corregirlo: donde la entidad es una que escribes tú, compila el plugin y coloca su .wasm junto a la entidad con el nombre que da el mensaje — o publica el plugin con aggrega push y haz referencia a la entidad publicada en lugar de a la copia del catálogo, ya que ni un pull ni una compilación descargan el .wasm de una entidad de tu catálogo. Donde el plugin es uno que consumes desde un registro, ejecuta aggrega pull para la Release, lo que lo guarda en caché. Donde esperabas que el compilador llevara el plugin él mismo, comprueba que el binario que ejecutas lo lleva: aggrega plugin list nombra los plugins integrados. Donde se trata de un importador core, ejecuta la importación una vez donde el espacio de trabajo pueda alcanzar su registro predeterminado — esa ejecución lo descarga, lo verifica y lo guarda en caché, y cada importación posterior es sin conexión — o, donde ese registro no lo contiene, coloca su módulo junto a una entidad Plugin de ese importador en esa versión en una carpeta de catálogo, con el nombre que da el mensaje; esa entidad se ejecuta entonces en lugar del importador core.
A plugin recorded as a trusted gate is no longer attached (Un plugin registrado como control de confianza ya no está vinculado)
Un plugin que devuelve un veredicto de aceptación o rechazo sobre una compilación se registra una vez resuelto, de modo que el espacio de trabajo conserva un archivo de confianza que indica qué controles se revisaron. Esta condición es lo que informa un control registrado que ya nada vincula. La razón por la que detiene la compilación en lugar de dejarla pasar en silencio es que, de lo contrario, su salida sería indistinguible de una salida que el control aprobó: una compilación con el control ausente en silencio y una compilación que el control dejó pasar producen los mismos archivos, y nadie que revisara el resultado podría saber cuál de las dos tiene en las manos.
Es una cuestión distinta de la de un plugin cuyos bytes han cambiado. Aquella rechaza ejecutar un plugin que no es el revisado — una cuestión de identidad. Esta rechaza compilar con un control revisado del todo ausente — una cuestión de presencia. Los remedios difieren en consecuencia: restaurar el artefacto, frente a restaurar la vinculación.
Qué establece y qué no. Ajustar la configuración al archivo de confianza establece que cada control registrado sigue vinculado y que el artefacto de cada uno es el registrado. No establece nada sobre si un control vinculado devuelve siquiera un veredicto: una vinculación cuya función de entrada nombra una exportación declarada que no devuelve ningún veredicto se ejecuta, no informa de nada y deja pasar la compilación, y ninguna comparación con el archivo de confianza lo nota — el plugin que se ejecutó es exactamente el registrado y simplemente no ejecutó nada. Dos casos vecinos sí detienen la compilación, y se nombran para que este límite no se lea como más amplio de lo que es: una función de entrada que nombra una exportación que el plugin no declara se rechaza cuando se carga el plugin, y una salida que lleva una clave que la estructura del veredicto no declara se rechaza en lugar de leerse como una lista de veredictos vacía.
Mensaje emitido, que nombra el archivo de confianza, los controles retirados y ambos remedios:
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 registrado como de confianza para un veredicto de aceptación o rechazo ya no está vinculado a ningún rol de veredicto: el archivo de confianza registra el plugin como de confianza, pero ninguna vinculación de veredicto en la configuración del espacio de trabajo lo nombra; un control que se revisó y ahora está ausente deja una salida indistinguible de una salida que ese control aprobó. Vincula de nuevo el plugin en la sección de gobernanza de los plugins a un rol de veredicto IR o de veredicto de renderizado, o en la sección del linter; o, si debía retirarse, ejecuta la actualización dirigida para quitarlo del archivo de confianza — un pull ordinario deja el archivo de confianza como está, por lo que solo una actualización explícita quita una entrada)
Donde se retiró más de un control, se nombran juntos en un único comando de actualización en lugar de en un comando cada uno: una actualización dirigida admite varios destinos y deja intacta cada fijación que no nombró, por lo que nombrarlos juntos es a la vez más corto y más acotado que la actualización completa que la alternativa necesitaría.
Cómo corregirlo: el mensaje ofrece dos remedios porque solo tú sabes cuál se aplica. Si el control se retiró por error, vincula de nuevo el plugin bajo plugins.governance a un rol de veredicto, o bajo plugins.linter. Si debía retirarse, dilo explícitamente con la actualización dirigida que el mensaje detalla, que es lo que quita su entrada. No edites ni borres el archivo de confianza para eliminar esta condición — es la constancia, confirmada en el repositorio, de lo que se revisó, y un pull ordinario lo deja como está deliberadamente, porque adoptar una retirada en silencio es exactamente lo que este rechazo existe para impedir.
A gate recorded as trusted resolves to a different identity (Un control registrado como de confianza se resuelve en una identidad diferente)
Un plugin que devuelve un veredicto de aceptación o rechazo sobre una compilación se registra una vez resuelto, junto con la versión y el digest del artefacto en los que se resolvió. Esta condición es lo que informa una resolución posterior cuando llega a una versión distinta o a bytes distintos para un control que el archivo de confianza ya contiene, y la ejecución nunca pidió adoptar esa identidad.
Una sola condición cubre tanto una versión desplazada como bytes desplazados, porque el archivo de confianza se direcciona por la identidad del plugin y lleva la versión y el digest como campos de una sola entrada: comparar una resolución con él es una sola comparación con un solo resultado. Una republicación que no cambió ningún byte y un nuevo push en la misma versión son el mismo evento para quien revisa — la identidad ya no es la que se revisó.
Es una cuestión distinta de la de un control registrado que ya nada vincula, que es una cuestión de presencia y no de identidad. También es distinta de la de un plugin cuyos bytes en caché no concuerdan con el digest registrado: aquella rechaza ejecutar un plugin que no es el revisado, y su remedio es restaurar o volver a registrar el artefacto, mientras que esta rechaza adoptar una identidad nueva sin que se pida, y su remedio es nombrar el plugin en una actualización. Dos remedios, dos condiciones.
Pedir la nueva identidad es lo que un pull ya ofrece, y hay dos formas de pedirla. Una actualización completa vuelve a resolverlo todo, y una actualización dirigida vuelve a resolver los plugins que nombra; cualquiera de las dos se lee como que se pidió la nueva identidad, y el archivo de confianza se pone al día. Cualquier otro pull mantiene la identidad registrada y se detiene, que es el sentido de registrarla — un archivo de confianza que adoptara lo que se resolviera a continuación seguiría a la resolución en lugar de gobernarla. Una primera aparición no es un desacuerdo: una identidad que el archivo de confianza aún no contiene simplemente se completa.
La comparación también se ejecuta en un pull que solo verifica, que no escribe ni el archivo de confianza ni el archivo de bloqueo. Una verificación que omitiera el archivo de confianza mientras comprueba el archivo de bloqueo que está a su lado informaría de una concordancia que nunca buscó.
Mensaje emitido, que nombra el plugin, ambas identidades y ambos remedios:
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: el archivo de confianza registra para él una versión y un digest como de confianza, pero esta resolución informa de otra versión y otro digest; revisa lo que cambió y adóptalo con la actualización dirigida, o restaura la identidad registrada: la identidad del plugin registrada como de confianza ya no coincide con lo que informa esta resolución)
Cómo corregirlo: decide cuál de las dos identidades es la que quieres, porque solo tú puedes hacerlo. Si el cambio es uno que pretendes — el control se republicó y revisaste lo que cambió — adóptalo con la actualización dirigida que el mensaje detalla, que vuelve a resolver ese plugin y reescribe su entrada. Si no lo esperabas, la identidad registrada es la que se revisó: restaura la versión o el artefacto que nombra el archivo de confianza, e investiga por qué la referencia se resuelve ahora en otro lugar. No edites el archivo de confianza para eliminar esta condición — es una declaración, confirmada en el repositorio, de lo que se revisó, y un pull ordinario lo deja como está deliberadamente, porque adoptar en silencio un control cambiado es exactamente lo que este rechazo existe para impedir.
A Plugin entity’s claims disagree with the plugin’s own self-report (Las afirmaciones de una entidad Plugin no concuerdan con la autodescripción del propio plugin)
Una entidad Plugin indica lo que ofrece el plugin al que apunta: qué exportaciones tiene, sobre qué opera cada una de ellas y con qué ámbito, y — para un plugin que sirve a un proveedor — cómo se comporta al renderizar. El plugin informa lo mismo sobre sí mismo cuando se carga. Esta condición es lo que informa un desacuerdo entre ambos.
La comparación se hace por exportación, indexada por nombre, y va en una sola dirección: todo lo que la entidad afirma debe coincidir, y el plugin puede ofrecer más. Una entidad que describe parte de la superficie del plugin no está obligada a enumerar el resto, así que una exportación que el plugin declara y la entidad omite no es un desacuerdo. Lo que sí es un desacuerdo es una exportación afirmada que el plugin no declara, o una exportación afirmada cuyo operates o scope difiere de lo que informa el plugin. El selector de forma libre no se compara.
Cuando la entidad también define un bloque de comportamiento de renderizado, sus campos se comparan uno por uno — los tipos de entrada, el modo de ensamblado, el par de delimitadores de las plantillas de artefacto, la anotación del nombre de ensamblado, la afirmación de instancia reutilizable, la afirmación de enlace entre límites, la afirmación de entradas omitidas y el directorio de anidamiento — y se nombra el primero que no coincide. Una entidad que no define ningún bloque así omite por completo esa comparación.
La misma comprobación se ejecuta al publicar, por lo que una discrepancia normalmente aparece antes de que se publique la entidad y no cuando una compilación la carga.
Mensajes emitidos. Una exportación afirmada que el plugin no tiene:
entity "<entity>" claims export "<export>", which the plugin’s describe() does not declare: wasm: entity contract claim does not match plugin describe() (la entidad afirma una exportación que el describe() del plugin no declara: wasm: la afirmación del contrato de la entidad no coincide con el describe() del plugin)
un campo de una exportación afirmada:
entity "<entity>" export "<export>" declares operates "<claimed>" but the plugin’s describe() reports "<reported>": wasm: entity contract claim does not match plugin describe() (la exportación de la entidad declara un valor de operates, pero el describe() del plugin informa otro: wasm: la afirmación del contrato de la entidad no coincide con el describe() del plugin)
y un campo de comportamiento de renderizado, que se informa con la misma estructura nombrando el campo que no coincidió:
entity "<entity>" declares boundary_assembly "<claimed>" but the plugin’s describe() reports "<reported>": wasm: entity contract claim does not match plugin describe() (la entidad declara un valor de boundary_assembly, pero el describe() del plugin informa otro: wasm: la afirmación del contrato de la entidad no coincide con el describe() del plugin)
Cómo corregirlo: lo que hay que corregir es la afirmación de la entidad Plugin, no tu Aggregate ni tu Release. Ajusta la afirmación a lo que informa el plugin — el mensaje nombra ambos valores, así que en qué dirección debe cambiar se ve en el propio mensaje. Si la entidad es una que publicas tú, regenerarla a partir del binario es la forma fiable de que ambos coincidan; si consumes una entidad publicada, selecciona una versión cuya afirmación coincida con el binario al que apunta e informa del desacuerdo a quien la publicó.
A Plugin entity’s recorded command set does not match the plugin (El conjunto de comandos registrado de una entidad Plugin no coincide con el plugin)
Un plugin que aporta comandos de terminal tiene esos comandos registrados en su entidad Plugin. Ese registro lo escribe la máquina y no un autor: se lee del plugin y se anota, así que refleja exactamente el binario. Esta condición es lo que informa un registro que ha dejado de reflejarlo — una diferencia en el nombre de un comando, en su breve texto de ayuda o en el orden en que se declaran los comandos.
La comparación es de igualdad completa, y es deliberado. Las afirmaciones de capacidades y de exportaciones en otras partes de la entidad las selecciona un autor: un autor puede describir legítimamente parte de la superficie y dejar fuera el resto, así que se comprueban como un subconjunto. El registro de comandos no lo selecciona ningún autor, así que cualquier cosa que no sea una coincidencia exacta significa que el registro se ha desviado de lo que el plugin ofrece realmente, y una lista de comandos parecida pero incorrecta es lo que enrutaría mal una invocación.
Un plugin cargado sin una entidad no se comprueba aquí. El registro está en la entidad, así que los bytes cargados directamente no llevan ninguno y la comparación no tiene contra qué ejecutarse.
Mensaje emitido, que nombra ambos conjuntos y cómo volver a registrarlos:
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: para el plugin indicado, el espejo de comandos registrado no coincide con los comandos del describe() del plugin; vuelve a ejecutar la sincronización de plugins y confirma el resultado: wasm: el espejo de comandos registrado no coincide con el describe() del plugin)
La misma comparación al publicar informa los conjuntos sin la instrucción de volver a registrarlos:
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() (para el plugin indicado, el espejo de comandos registrado no coincide con los comandos del describe() del plugin: wasm: el espejo de comandos registrado no coincide con el describe() del plugin)
Cómo corregirlo: vuelve a registrar el conjunto a partir del binario y confirma el resultado — el mensaje nombra el comando que lo hace. No edites el registro a mano para que coincida: lo gestiona la máquina, y una edición a mano que hoy coincide se vuelve a derivar y se sobrescribe la próxima vez que se registra. Si consumes una entidad publicada en lugar de publicarla, la entidad se publicó con un registro que su propio binario no respalda, y esa es una cuestión para quien la publicó.
A Plugin entity’s recorded version does not match the plugin (La versión registrada de una entidad Plugin no coincide con el plugin)
Un plugin informa la versión que su compilación registró en él, y su entidad Plugin también registra una versión; ambas deben ser la misma cadena. Las recetas de compilación con las que se compilan los plugins de Aggrega toman esa versión de la etiqueta que publica el plugin — la propia etiqueta del compilador para un plugin que se distribuye con el compilador, una etiqueta propia del plugin para uno que se distribuye fuera de él —, así que una compilación del commit que nombra la etiqueta informa la versión publicada, y una compilación de cualquier otro commit informa una versión de desarrollo como 1.0.0-3-g1a2b3c4. Esta condición es lo que informa un par que se ha separado, y se comprueba antes de publicar ningún byte para que un par divergente no llegue a un catálogo.
La comparación es una coincidencia exacta de cadenas. Un plugin compilado sin una versión de compilación registrada informa una vacía, y ese valor vacío es entonces aquel al que debe ser igual la versión de la entidad — la comprobación no trata «ninguna versión informada» como «se acepta cualquier versión», porque su propósito es que la versión de una entidad publicada diga siempre lo que su binario informa realmente.
Mensaje emitido:
plugin "<plugin>": recorded metadata.version "<recorded>" does not match the plugin describe() version "<reported>": wasm: entity metadata.version does not match plugin describe() (para el plugin indicado, el metadata.version registrado no coincide con la versión del describe() del plugin: wasm: el metadata.version de la entidad no coincide con el describe() del plugin)
Al publicar, el rechazo nombra además el archivo de la entidad, el .wasm y la solución:
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() (para el Plugin indicado, el metadata.version del archivo de la entidad no coincide con la versión del describe() del .wasm en la ruta indicada — establece metadata.version en la versión que estás publicando y compila el plugin a partir de un checkout limpio del commit que nombra la etiqueta de esa versión, para que informe esa versión por sí mismo; para una nueva versión, confirma la entidad con el código fuente que publica y etiqueta primero ese commit: para el plugin indicado, el metadata.version registrado no coincide con la versión del describe() del plugin: wasm: el metadata.version de la entidad no coincide con el describe() del plugin)
Cómo corregirlo: establece el metadata.version de la entidad en la versión que estás publicando, y compila el plugin a partir de un checkout limpio del commit que nombra la etiqueta de esa versión, para que informe esa versión por sí mismo. Para una nueva versión, confirma la entidad con el código fuente que publica y etiqueta primero ese commit — la etiqueta tiene que nombrar un commit que ya contenga la entidad. No copies en la entidad la versión que informa el plugin: una compilación de cualquier otro commit informa una versión de desarrollo, y copiarla publicaría esa compilación con una versión que ninguna etiqueta de versión nombra. Si el plugin no informa ninguna versión, se compiló sin su versión registrada; compílalo con su versión registrada.
A plugin was built from a working tree with uncommitted changes (Un plugin se compiló a partir de un árbol de trabajo con cambios sin confirmar)
La compilación de un plugin registra su versión a partir del commit del que se compiló, y una compilación hecha desde un árbol de trabajo con cambios sin confirmar lleva la marca -dirty al final de esa versión — 1.0.0-dirty en una etiqueta, 1.0.0-3-g1a2b3c4-dirty después de una. Una versión así es una versión semántica válida, pero nombra un commit que no contiene los bytes compilados, así que nadie puede volver a compilar lo que se publicaría a partir de la versión con la que se publicaría. Publicar un Plugin rechaza un plugin cuya propia versión lleva la marca, antes de publicar ningún byte y antes de contactar con el registro; una ejecución de prueba también lo rechaza.
Solo se rechaza la marca. Una versión de desarrollo compilada desde un commit, como 1.0.0-3-g1a2b3c4, nombra un commit que sí contiene lo que se compiló, y se publica; lo mismo ocurre con una versión preliminar como 1.0.0-rc.1. Validar un plugin frente a su entidad fuera de una publicación no provoca esta condición, ya que una compilación en desarrollo se hace habitualmente desde un árbol editado.
La comprobación lee la versión que el plugin informa sobre su propia compilación, y se ejecuta antes de la comparación con el metadata.version de la entidad — así que un plugin compilado con cambios sin confirmar bajo una entidad que registra la versión limpia se informa aquí, y no como una versión registrada que no coincide con el plugin.
Mensaje emitido, que nombra el plugin, la versión que informa y el remedio:
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") (para el Plugin indicado, el .wasm en la ruta indicada se compiló a partir de un árbol de trabajo con cambios sin confirmar — establece metadata.version en el archivo de la entidad en la versión que estás publicando y compila el plugin a partir de un checkout limpio del commit que nombra la etiqueta de esa versión, para que informe esa versión por sí mismo; para una nueva versión, confirma la entidad con el código fuente que publica y etiqueta primero ese commit: el plugin se compiló a partir de un árbol de trabajo con cambios sin confirmar, así que ningún commit reproduce la versión que informa (con el plugin y su versión de describe(), que termina con la marca dirty))
Cómo corregirlo: compila el plugin a partir de un checkout limpio del commit que nombra la etiqueta de la versión, para que informe la versión publicada que registra la entidad. Para publicar el propio cambio, establece el metadata.version de la entidad en la nueva versión, confirma la entidad junto con el cambio, etiqueta ese commit y compila ahí. Confirmar el cambio y volver a compilar no basta por sí solo para abrir paso a una publicación: el plugin recompilado informa una versión de desarrollo, y copiarla en la entidad publicaría la compilación con una versión que ninguna etiqueta de versión nombra.
A Plugin entity’s recorded host functions do not match the binary (Las funciones host registradas de una entidad Plugin no coinciden con el binario)
Un plugin declara cuáles de las llamadas propias del host utiliza, y ese conjunto se registra en su entidad Plugin cuando se publica el plugin — leído del propio binario en lugar de escrito por un autor. Cuando se descarga el plugin, el conjunto se deriva de nuevo de los bytes cuyo contenido se acaba de verificar, y se compara con el registro. Una diferencia en cualquiera de las dos direcciones detiene la descarga.
Esto se suma a la fijación del contenido en lugar de repetirla, y detecta dos cosas que la fijación sola no detecta: un binario publicado por algo distinto de la vía de publicación habitual, que no lleva ningún registro o lleva uno que no describe sus propios bytes; y un fallo en el propio paso de registro. La fijación establece que los bytes son los bytes que se fijaron; esto establece que lo que se anotó sobre ellos es cierto para ellos.
Una entidad que no lleva ningún registro se compara con un conjunto vacío, que coincide con un plugin que no usa ninguna de las llamadas del host — la misma coincidencia inocua en ambos sentidos, así que una entidad sin registro no se rechaza por carecer de uno.
Mensaje emitido, que nombra el plugin, ambos conjuntos y el artefacto del que proceden los bytes:
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 (para el plugin indicado, el spec.runtime.hostFunctions estampado no coincide con el conjunto derivado del .wasm verificado: wasm: el registro estampado de funciones host no coincide con las importaciones del .wasm)
La misma comparación ejecutada mientras se valida un plugin informa los dos conjuntos sin el artefacto:
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 (para el plugin indicado, el registro de funciones host registrado no coincide con las importaciones del .wasm: wasm: el registro estampado de funciones host no coincide con las importaciones del .wasm)
Cómo corregirlo: nada en tus archivos de entidad causa esto y ningún cambio en lo que escribes lo resuelve. Vuelve a publicar el plugin por la vía de publicación habitual, que deriva el registro del binario y escribe ambos juntos. Si consumes un plugin publicado, la entidad y el binario al que apunta se publicaron desfasados, así que informa de la discrepancia a quien lo publica, citando ambos conjuntos del mensaje — y no edites el registro a mano para que coincida, ya que se deriva en lugar de escribirse y la siguiente derivación descarta la edición.
The lockfile no longer matches what the release resolves to (El archivo de bloqueo ya no coincide con aquello en lo que se resuelve la Release)
El archivo de bloqueo de una Release fija cada entidad, biblioteca y plugin que la Release alcanza, cada uno con la versión seleccionada y un digest, y registra los propios archivos de Release — la Release y cada Release que extiende — mediante el digest de su contenido. El digest de una entidad cubre lo que contiene una publicación de ella: su documento y cada archivo que nombra junto a ella, cada uno por su ruta y sus bytes. El de una biblioteca y el de un plugin cubren sus bytes. Resolver de nuevo la Release produce el mismo conjunto, y ambos se comparan. Esta condición es lo que informa un desacuerdo.
Todos los desacuerdos se recopilan antes de informar de cualquiera de ellos, en todo lo que fija el archivo de bloqueo, de modo que una sola ejecución te muestra el panorama completo en lugar de una entrada cada vez.
Se informan estas estructuras de desacuerdo, y vale la pena distinguirlas porque los remedios difieren:
Una referencia que el archivo de bloqueo no fija. La Release ahora alcanza algo para lo que el archivo de bloqueo no tiene ninguna entrada — una dependencia añadida después del pull que lo escribió. La entrada indica dónde la solicita la Release, de modo que una Recipe o FeatureRecipe que el Manifest enlaza se informa con la entrada de mapeo que la enlaza, y una que enlaza el nivel name nombra la instancia o la vinculación para la que se eligió.
Una referencia fijada que la Release ya no alcanza. El archivo de bloqueo todavía fija algo de lo que ya nada en la Release depende.
Un archivo de Release editado desde el pull. La Release, o una Release que extiende, ya no contiene los bytes que el archivo de bloqueo registró para ella. Todo lo que la Release solicita — qué versión de la fuente descargar, qué componentes colocar dónde — se resuelve a partir de lo que contiene el archivo, de modo que las fijaciones registradas pueden ya no describir lo que ahora solicita. Se informa aquí, antes de que se renderice nada, en lugar de como aquello en lo que el renderizado habría fallado: una versión de la fuente editada aparecería si no más tarde como una descarga que no encuentra ninguna fijación. Un archivo de bloqueo que no registra ningún archivo de Release informa de la Release como no registrada, y un archivo de Release que la Release ya no extiende se informa como ya no leído.
Una referencia de fuente que se movió en su remoto. Una fuente escrita en un ref: de git se registra en el commit al que se resolvió el ref. Cada pull que no es una actualización pregunta al remoto adónde apunta ahora el ref, y lo mismo hace aggrega pull --verify donde se puede alcanzar la red; un ref que se resuelve en un commit diferente se informa aquí en lugar de adoptarse. Solo esos dos lo informan: una compilación lee el commit registrado y no pregunta.
La comparación es sobre el contenido, de modo que un contenido idéntico alcanzado por otra ruta no se desvía: lo que tiene que diferir para que esto se active son los bytes. Para un archivo de Release eso incluye un comentario o un cambio de espacios en blanco, exactamente como ocurre con el Aggregate y el Manifest que la Release nombra. Para una entidad es el contenido de lo que contiene, de modo que la misma entidad leída desde un directorio de catálogo y descargada desde un registro no se desvía, ni tampoco un checkout cuyos archivos difieren solo en los bits de permisos, incluido el bit de ejecución, ni una publicación cuyo archivo empaquetado se comprimió de otra manera.
Mensaje emitido. Lo abre la frase propia de la condición, y le sigue cada discrepancia recopilada, cada una nombrando su eje — y, para una entidad, su tipo, porque una entidad se identifica por su tipo y su URI juntos, de modo que una Release cuyo Aggregate y cuyo Manifest comparten nombre tiene dos entradas, y una edición de cualquiera de los dos se informa contra el que se editó:
lockfile: out of date; it no longer matches what its Release resolves to: entity "<uri>" (<kind>) not in lockfile (referenced from <site>) (lockfile: desactualizado; ya no coincide con aquello en lo que se resuelve su Release: entidad, con su tipo, ausente del archivo de bloqueo, con el lugar desde donde se hace referencia a ella) <axis>"<uri>" changed: lockfile=(<version>,<digest>) current=(<version>,<digest>) (la referencia indicada cambió en el eje indicado: la versión y el digest del archivo de bloqueo difieren de los actuales) entity "<uri>" (<kind>) changed: lockfile=(<version>,<digest>) current=(<version>,<digest>) (la entidad indicada, del tipo indicado, cambió: la versión y el digest del archivo de bloqueo difieren de los actuales) <axis>"<uri>" no longer used by the release (la Release ya no usa la referencia indicada en el eje indicado) 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 (el documento de Release indicado se editó después de escribirse el archivo de bloqueo: su contenido ya no coincide con el digest registrado, por lo que las fijaciones pueden ya no describir lo que solicita; resolver de nuevo la Release registra los archivos que lee tal como están ahora)
<site> es el lugar donde la Release solicita la referencia, escrito como la ruta a la entrada que la nombra — manifest.spec.mappings.components.name.db-primary, por ejemplo — con hasta tres de esos lugares enumerados en orden y ... después de ellos cuando hay más. Una referencia cuya resolución no registra ningún lugar así se informa sin el paréntesis.
Un pull que informa de una referencia de fuente movida nombra el artefacto tal como lo escribió su autor, con chart= y module_subdir= donde la fuente los nombra:
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 referencia indicada se movió — el archivo de bloqueo fija un commit, y ahora se resuelve en otro; adopta adonde apunta ahora con un pull de actualización)
Una compilación imprime el remedio después de las entradas:
run aggrega pull --release <release> to re-resolve the Release and rewrite its lockfile (ejecuta el pull para volver a resolver la Release y reescribir su archivo de bloqueo)
Qué comandos atan una release a su lockfile.aggrega build compara antes de renderizar y se detiene. aggrega validate --release, y cada selección de aggrega inspect que resuelve una release — la vista predeterminada, --resolved, --ir-graph y --closure — ejecutan la misma comparación en cuanto se resuelven las dependencias de la release, y se detienen con el mismo mensaje y el mismo remedio, sin escribir nada en la salida estándar; así que ninguno de los dos deja pasar un lockfile que una compilación rechaza por desviado. Las herramientas del asistente build, validate con release y describe con release rechazan en los mismos términos. aggrega pull la ejecuta contra el lockfile que está a punto de escribir, y aggrega pull --verify contra el que está en disco. Un comando que no resuelve ninguna release — aggrega validate sin argumento, que lee las fijaciones del lockfile solo para encontrar un padre extends, o con una ruta de entidad, y aggrega inspect --raw o --output yaml sin --ir-graph — no está atado a ningún lockfile, y tampoco lo está una release sin lockfile al lado. El servidor de lenguaje del editor detiene sus compilaciones por ello, y lo informa en una solicitud de grafo como una advertencia sobre el lockfile mientras sigue dibujando el grafo.
Cómo corregirlo: vuelve a resolver la Release y confirma en el repositorio el archivo de bloqueo reescrito. Para todo lo que informa una compilación, un aggrega pull --release <release> simple — el comando que imprime la compilación — es toda la corrección: resuelve la Release tal como está ahora, reescribe las fijaciones que se movieron y mantiene todas las demás, de modo que nada que no hayas tocado se mueva. Donde lo que se movió es un archivo bajo la fuente local de una Recipe o de una FeatureRecipe, ese pull primero se detiene nombrando aggrega pin para la entidad, porque registrar la nueva fijación junto a ella es el paso del autor; ejecútalo, o pasa --pin-sources al pull, y el pull elimina la desviación. La única entrada que un pull simple no elimina es una referencia de fuente que se movió en su remoto, porque eliminarla significa adoptar el commit que la referencia nombra ahora: aggrega pull --upgrade --release <release> hace eso, y la entrada lo dice — donde el entity.lock de la Recipe registra esa fuente, la actualización se detiene de la misma manera hasta que el nuevo commit se fija junto a ella. Lee las entradas antes de hacerlo, porque la tercera estructura es la que merece una pausa: una referencia que la Release ya no alcanza suele ser una dependencia que eliminaste a propósito, pero donde no la eliminaste tú, algo más cambió que la hizo inalcanzable. Un par que se movió en una referencia que no tocaste significa que el contenido en esa versión no es el contenido que se revisó, lo cual es una pregunta para quien lo suministra y no algo que adoptar sin mirar.
Un pull ejecuta esta misma comparación con el archivo de bloqueo que está a punto de escribir y no escribe uno que la comparación rechace, de modo que un archivo de bloqueo que un pull acaba de escribir la supera para una compilación que recibe las mismas entradas. Donde esta condición vuelve a aparecer justo después de un pull que se completó, las dos ejecuciones recibieron entradas diferentes: un directorio de catálogo pasado a una y no a la otra, o una configuración del espacio de trabajo editada entre ellas. Ejecuta el pull y la compilación sobre las mismas entradas.
An artifact is not at the source the build was told to find it (Un artefacto no está en la fuente donde se indicó a la compilación que lo encontrara)
Una referencia de catálogo nombra un artefacto y una versión. Esta condición informa de que nada responde a ese par — ni en el registro en el que se resuelve la referencia, ni en la caché local de artefactos de la que lee la compilación.
Una compilación lee la caché; no sale al exterior por su cuenta. La adquisición es un paso separado: el pull que resuelve una Release descarga lo que la Release necesita y lo escribe en la caché, y luego la compilación lee lo que hay allí. Así, esta condición llega a una compilación como un fallo de caché, y llega a un pull como un registro que no tiene tal artefacto. Donde una compilación está configurada para llenar su archivo de bloqueo al iniciarse, la adquisición que ejecuta es ese mismo pull.
Mensajes emitidos. Un registro sin tal etiqueta, y una descarga que resolvió un manifiesto cuyo blob de contenido falta:
oci: "<reference>:<version>": oci: artifact not found at remote source (oci: para la referencia y la versión indicadas: oci: artefacto no encontrado en la fuente remota)
oci: content for "<reference>:<version>": oci: artifact not found at remote source (oci: contenido para la referencia y la versión indicadas: oci: artefacto no encontrado en la fuente remota)
una lectura de la caché que no encontró ninguna entrada, que es la estructura que encuentra una compilación:
oci: cache miss for <reference>@<version>: oci: artifact not found at remote source (oci: fallo de caché para la referencia y la versión indicadas: oci: artefacto no encontrado en la fuente remota)
y lo mismo para un artefacto en caché cuyo manifiesto falta junto a él:
oci: manifest cache miss for <reference>@<version>: oci: artifact not found at remote source (oci: fallo de caché del manifiesto para la referencia y la versión indicadas: oci: artefacto no encontrado en la fuente remota)
Cómo corregirlo: comprueba primero la referencia y la versión — una versión que ya no existe y un nombre con una errata producen la misma respuesta, y el mensaje cita ambos para que puedan compararse con el catálogo. Donde la referencia es correcta, el artefacto no se ha adquirido: ejecuta el pull para la Release, que descarga lo que la Release alcanza y llena la caché. Donde el espacio de trabajo está sin conexión, ese pull tiene que ejecutarse desde algún lugar con acceso a la red; una compilación sin conexión solo lee lo que ya está en caché, y esto es lo que dice cuando la caché no lo contiene.
The registry will not serve an artifact without credentials it accepts (El registro no sirve un artefacto sin credenciales que acepte)
El registro respondió, y declinó: o no se presentaron credenciales, o las presentadas no se aceptaron. Es distinto de un registro que no se pudo alcanzar en absoluto — aquí la conversación tuvo lugar y la respuesta fue no.
Cuatro momentos lo informan, todos mientras se adquieren o publican artefactos: la resolución de una referencia, el pull de su contenido, el listado de las versiones que contiene un repositorio, y la comprobación de una credencial en el momento en que se almacena.
Mensajes emitidos, cada uno nombrando lo que se solicitaba y citando lo que respondió el registro:
oci: resolve "<reference>:<version>": <what the registry replied>: oci: authentication required or failed (oci: resolución de la referencia indicada, con la respuesta del registro: oci: autenticación requerida o fallida)
el listado de las versiones de un repositorio, que nombra en cambio el estado:
oci: tags/list "<repository>": status <code>: oci: authentication required or failed (oci: tags/list del repositorio indicado, con el código de estado: oci: autenticación requerida o fallida)
y la comprobación de una credencial mientras se almacena:
oci: verify credential for "<host>": <what the registry replied>: oci: authentication required or failed (oci: verificación de la credencial para el host indicado, con la respuesta del registro: oci: autenticación requerida o fallida)
Donde el fallo lo muestra un paso que proporciona una solución, la línea termina con el inicio de sesión que hay que ejecutar en el host que derivó:
remediation: aggrega login <host> (or docker login <host>) before re-running aggrega pull —release <release> (solución: ejecuta aggrega login, o docker login, para el host indicado antes de volver a ejecutar aggrega pull —release para la Release indicada)
y, donde una importación estaba obteniendo uno de los importadores core del compilador, el mismo inicio de sesión antes de volver a ejecutar la importación:
remediation: aggrega login <host> (or docker login <host>) before re-running the import (solución: aggrega login (o docker login) antes de volver a ejecutar la importación)
Un repositorio clásico de charts de Helm o un archivo de chart, un fragmento de compose y un repositorio Git descargados por http o https también informan de esta condición cuando el servidor rechaza la solicitud como no autorizada, y su solución nombra la entrada de netrc que hay que añadir en lugar de un inicio de sesión, ya que ese archivo es donde esas descargas leen su credencial:
remediation: add an entry for <host> (machine <host> login <user> password <secret>) to the netrc file <path>, then run the command again (solución: añade al archivo netrc una entrada para el host (con machine, login y password) y luego vuelve a ejecutar el comando)
Cómo corregirlo: esto corresponde al operador y no al autor de la entidad — nada en un Aggregate, un Component o una Recipe lo causa. El hub oficial, hub.aggrega.ai, sirve a cualquiera lo que publica, así que leer de él no requiere ninguna credencial, mientras que publicar en él sí; otro registro puede requerir una credencial también para la lectura. Inicia sesión en el host que nombra el mensaje — o, para un origen descargado por http o https, añade la entrada de netrc que nombra la solución — y vuelve a ejecutar la adquisición. Si ya has iniciado sesión, la credencial del almacén no es una que ese host acepte para ese repositorio: vuelve a iniciar sesión para renovarla, y comprueba que la cuenta tenga acceso de lectura al repositorio en el que se resuelve la referencia, ya que un repositorio privado responde exactamente así a una cuenta que no puede verlo. Si la referencia se resuelve en un host que no esperabas, el alias del registro o el registro predeterminado en .aggrega-config.yaml apunta a otro lugar.
The netrc file cannot be read (No se puede leer el archivo netrc)
Un repositorio clásico de charts de Helm o un archivo comprimido de chart, un fragmento de compose y un repositorio Git descargados por http o https toman su credencial del archivo netrc, que se lee cuando se descarga una fuente así — mediante un pull, una fijación o una compilación que llena su archivo de bloqueo. Qué archivo se lee, y qué entrada responde a una solicitud, se explica en Autenticación. Esta condición informa de un archivo netrc que existe y no se pudo usar: no se pudo leer — es un directorio, por ejemplo, o no tienes permiso para leerlo — o no sigue el formato netrc. El formato se lee de forma estricta, porque una palabra leída en el lugar equivocado desplaza todas las palabras que la siguen: una palabra clave mal escrita convertiría si no la contraseña que la sigue en la siguiente palabra clave, y la solicitud saldría sin credencial, o con la equivocada, mientras el archivo parecía correcto.
Un archivo que no existe no es esta condición: no contiene credenciales, y a una solicitud que necesita una le responde el rechazo del servidor. Un archivo que otros usuarios de la máquina pueden leer tampoco es esta condición: en Linux y macOS genera una advertencia que nombra el archivo, y se lee de todos modos.
El mensaje nombra el archivo y, para un fallo de formato, la línea, y dice qué está mal solo en términos del formato — nunca una palabra que contenga el archivo, ya que una palabra fuera de lugar puede ser una contraseña. El diagnóstico no lleva ninguna categoría: el archivo netrc es tu propio archivo de credenciales y no un documento que lea la compilación.
Mensaje emitido para un fallo de formato, que es uno de estos: una palabra situada donde se espera una palabra clave, una palabra clave no seguida de su valor, un login, password o account situado antes de cualquier entrada machine o default, y una palabra entre comillas no cerrada en la línea en que se abre:
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 (no se pudo leer el archivo netrc: en el archivo y la línea indicados hay una palabra donde se espera una palabra clave (machine, default, login, password, account o macdef). Corrige el archivo, o establece NETRC en la ruta de otro archivo netrc para leerlo en su lugar)
y para un archivo que no se pudo leer, citando por qué:
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 (no se pudo leer el archivo netrc: el archivo indicado, con el motivo por el que no se pudo leer. Corrige el archivo, o establece NETRC en la ruta de otro archivo netrc para leerlo en su lugar)
Cómo corregirlo: abre el archivo que nombra el mensaje. Para un fallo de formato, ve a la línea que nombra: cada entrada es machine <host> — o default — seguida de login <user> y password <secret>, y una palabra clave mal escrita o sin su valor es la causa habitual. Para un archivo que no se pudo leer, conviértelo en un archivo que puedas leer, legible solo por ti (chmod 600). Si el archivo no es el que querías que se leyera, establece NETRC en la ruta del que querías.
The registry could not be reached (No se pudo acceder al registro)
La conversación con el registro nunca tuvo lugar: falló la resolución de nombres, la conexión o la negociación segura. Es la contraparte de un registro que respondió y rechazó — aquí no se estableció nada en ningún sentido, de modo que el estado del artefacto en el otro extremo es desconocido, en lugar de saberse que falta.
También es lo que informa un fallo de transporte sin una causa más específica mientras se adquiere la fuente de una Recipe, así que en esa ruta es la respuesta general «no se pudo acceder al otro extremo» y no una afirmación sobre qué nivel falló.
Mensaje emitido, que nombra la fuente que se está adquiriendo y cita el fallo de transporte subyacente, con la solución que lleva la condición:
sourceresolver: kind=<kind> url=<url> version=<version>: oci: network unreachable (cause: <the transport failure>); remediation: check network connectivity to <host>; corporate proxies typically need HTTPS_PROXY exported (sourceresolver: con el tipo, la URL y la versión indicados: oci: red inaccesible (causa: el fallo de transporte); solución: comprueba la conectividad de red con el host indicado; los proxies corporativos suelen necesitar que HTTPS_PROXY esté exportada)
Cómo corregirlo: la corrección corresponde al operador y está fuera de tu catálogo. Comprueba que el host del mensaje sea accesible desde donde se ejecuta el comando. Donde el entorno llega a la red a través de un proxy, el proxy tiene que exportarse al entorno, como indica la solución — un proxy configurado solo para un navegador o un gestor de paquetes no se tendrá en cuenta. Donde el host es accesible a mano pero no desde aquí, la diferencia suele estar en credenciales ante un proxy o en un certificado de interceptación que la negociación no aceptó. Una vez que los artefactos están en caché, las compilaciones posteriores leen la caché y no necesitan la red en absoluto.
A server did not answer in time (Un servidor no respondió a tiempo)
Una solicitud se quedó esperando al servidor al que se dirigía — un registro, o cualquier otro servidor al que llega un comando, como el registro de transparencia en el que se anota una firma — y se retiró. Una solicitud espera como máximo 30 segundos a que el servidor comience su respuesta una vez enviada la solicitud por completo, y como máximo 30 segundos la siguiente parte de una respuesta que ya está llegando; superado cualquiera de los dos, se rechaza con esta condición, que nombra el servidor y la espera. Es lo que produce un servidor que acepta una conexión y nunca responde, y lo que produce también una dirección que nunca acepta ninguna, en lugar de un comando que espera sin fin. Un recorrido por todo el listado de repositorios de un registro, en cambio, espera en cada página tanto como el recorrido pueda durar, y está acotado por su propia condición, E0377.
Solo la espera está acotada. Una descarga o una subida que sigue avanzando tarda lo que tenga que tardar, porque la espera solo se mide mientras no llega nada. Un chart de Helm que el source: de una Recipe obtiene por HTTPS está sujeto solo a la espera de que su respuesta comience, y ese vencimiento se informa con las propias palabras de la biblioteca de red en lugar de con esta condición. Una solicitud que un comando ya repite cuando se agota su tiempo — una lectura durante aggrega registry update, una escritura durante una publicación — se repite primero, de modo que el rechazo es lo que queda tras su último intento.
Mensaje emitido, para un listado de versiones al que el registro no respondió:
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: listar las versiones de plugin/cli/mo: oci: listar las etiquetas: Get: 127.0.0.1:18471 no respondió en 30s: egress: el servidor no respondió a tiempo)
y para una respuesta que se detuvo a medias:
<host> stopped answering: nothing more of its answer arrived for 30s: egress: the server did not answer in time (dejó de responder: no llegó nada más de su respuesta durante 30s: egress: el servidor no respondió a tiempo)
Cómo corregirlo: la corrección corresponde al operador y está fuera de tu catálogo. Comprueba que el servidor que nombra el mensaje está activo y es accesible desde donde se ejecuta el comando; un registro con carga o en mantenimiento vuelve a responder más tarde, y basta con ejecutar el comando de nuevo. Si el entorno llega a la red a través de un proxy, comprueba que el proxy reenvía la solicitud en lugar de retenerla. La espera es fija; no hay ninguna configuración que la alargue.
A registry’s repository listing did not end in time (El listado de repositorios de un registro no terminó a tiempo)
Un recorrido por todo el listado de repositorios de un registro duró cinco minutos sin llegar al final del listado y se detuvo. Dos comandos recorren el listado: aggrega plugin add, solo cuando ningún plugin lleva exactamente el nombre que recibió y busca uno cuyo nombre lo contenga, y aggrega registry update, que lista los repositorios de un registro antes de leer cada uno. Un listado que sigue nombrando repositorios nuevos sin fin y uno que un registro sirve demasiado despacio para terminar acaban ambos aquí en lugar de retener el comando; el recorrido no produce ningún repositorio, así que no se elige ni se indexa nada de un listado que quedó truncado. El mensaje indica cuántos repositorios había nombrado el listado cuando se detuvo.
Mensaje emitido, para la adición de un plugin cuya consulta es parte de un nombre:
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: ningún plugin cli se llama «mo», y la búsqueda en cada repositorio de un nombre que lo contenga no terminó; nombra el plugin exactamente, como aggrega plugin add cli seguido del nombre: el recorrido se detuvo tras 5m0s, antes de que terminara el listado (repositorios nombrados hasta ahora: 146): registry: el listado de repositorios no terminó a tiempo)
Cómo corregirlo: para aggrega plugin add, nombra el plugin exactamente — aggrega plugin add cli moo en lugar de aggrega plugin add cli mo —, lo que busca el plugin por ese nombre con una sola solicitud y nunca recorre el listado. Para aggrega registry update, la causa es el listado del registro: confirma con quien administra el registro que su listado termina, y vuelve a ejecutar la actualización cuando lo haga. El límite de cinco minutos es fijo; no hay ninguna configuración que lo alargue.
A registry kept asking to slow down (Un registro siguió pidiendo ir más despacio)
Un registro demasiado ocupado responde 429 Too Many Requests, o 503 Service Unavailable con una cabecera Retry-After que indica cuánto esperar. Cada solicitud que un comando hace a un registro espera lo que el registro pida —diez segundos cuando no lo indica— y se vuelve a enviar; cada solicitud a ese registro espera con ella, y se le envían menos a la vez hasta que vuelve a responder. Un registro que durante cinco minutos no responde otra cosa que «más despacio» se rechaza con esta condición, indicando el registro, su última respuesta y cuánto tiempo llevaba sin responder otra cosa, y lo mismo ocurre con una solicitud cuyo propio límite de tiempo vence mientras espera. aggrega registry update informa entonces de ese registro como no indexado, y este conserva el índice que tenía antes de la ejecución.
Mensaje emitido, para un registro que pidió ir más despacio durante cinco minutos:
<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 (siguió pidiendo ir más despacio: su última respuesta fue 429 Too Many Requests, y no había respondido otra cosa durante 5m0s: oci: el registro siguió pidiendo ir más despacio)
y para una solicitud cuyo propio límite de tiempo puso fin a la espera:
<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 (siguió pidiendo ir más despacio: su última respuesta fue 429 Too Many Requests, y no había respondido otra cosa cuando se agotó el propio tiempo de la solicitud: oci: el registro siguió pidiendo ir más despacio)
Cómo solucionarlo: la causa es el límite de frecuencia del registro, no algo que hayas escrito. Un registro que limita la rapidez con la que un cliente puede hacer solicitudes suele limitar todo lo que llega desde la misma dirección, así que comprueba si otros comandos u otras máquinas detrás de esa dirección le están haciendo solicitudes al mismo tiempo, y vuelve a ejecutar el comando cuando hayan terminado. Si el registro lo gestionas tú, comprueba su límite de frecuencia. El límite de cinco minutos es fijo; no hay ningún ajuste que lo alargue.
Fetched or cached bytes do not match the digest committed for them (Los bytes descargados o en caché no coinciden con el digest declarado para ellos)
Cada artefacto lleva un manifiesto que declara el digest de su contenido, y el archivo de bloqueo fija de forma independiente el digest de ese manifiesto. Ambas declaraciones se comprueban volviendo a calcular el hash de los bytes disponibles y comparando. Esto es lo que informa una comparación que falla, y se dispara del mismo modo con bytes recién descargados y con bytes leídos de nuevo desde la caché.
Dos condiciones, y la que se dispara indica qué nivel discrepó. Una nombra contenido que no coincide con el digest que declara su propio manifiesto. La otra nombra un manifiesto en caché que no coincide con el digest que el archivo de bloqueo fijó para él — la comprobación que impide que un manifiesto manipulado se convierta en la autoridad en la que confía una comprobación de contenido posterior. La fijación es lo que da sentido a esa segunda comprobación: procede del archivo de bloqueo en lugar de volver a derivar el manifiesto a partir de los bytes en caché, de modo que ambas son realmente independientes.
Después, una entidad se contrasta con su propia fila, por encima de lo que llevan los bytes. Una vez que los bytes de una entidad en caché concuerdan con su manifiesto, se comparan con el digest que el archivo de bloqueo registra para la entidad, que abarca los archivos que lleva su publicación — cada uno por su ruta y sus bytes — en lugar de los bytes comprimidos. Así, los mismos archivos publicados con otra compresión siguen concordando, mientras que archivos distintos bajo la misma versión no, y una discrepancia se informa bajo la condición de contenido. Un pull que respeta una fijación hace la misma comparación sobre lo que un registro sirve bajo la versión fijada.
Ninguna de estas comprobaciones necesita la red. Cada una es una comparación de hashes sobre bytes ya disponibles, lo que permite que una compilación completamente sin conexión establezca aun así que lo que lee es lo que se fijó.
Mensajes emitidos. El contenido frente a su manifiesto:
oci: content digest <computed> != manifest layer <committed>: oci: content digest mismatch (oci: el digest calculado del contenido difiere del que declara la capa del manifiesto: oci: discrepancia del digest de contenido)
una entidad de plugin, que un manifiesto declara en otra posición:
oci: config digest <computed> != manifest config <committed>: oci: content digest mismatch (oci: el digest calculado de la configuración difiere del de la configuración del manifiesto: oci: discrepancia del digest de contenido)
un manifiesto en caché frente al digest fijado:
oci: cached manifest digest <computed> != pinned <pinned>: oci: cached manifest digest mismatch (oci: el digest calculado del manifiesto en caché difiere del fijado: oci: discrepancia del digest del manifiesto en caché)
una entidad en caché frente a su fila, y un registro que sirve otro contenido bajo una versión fijada:
catalog: cached <uri> content digest <computed> does not match lockfile pin <pinned>: oci: content digest mismatch (catalog: el digest de contenido de la entidad en caché indicada no coincide con la fijación del archivo de bloqueo: oci: discrepancia del digest de contenido)
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: discrepancia del digest de contenido: entidad fijada indicada: el registro sirve ahora para la versión fijada un digest distinto del fijado; ejecuta el pull de actualización para actualizar la fijación)
Ambos van enmarcados por lo que se estaba leyendo. Una entidad fijada que ninguna fuente contiene en su fijación, con la condición del manifiesto donde el manifiesto de la entrada de caché discrepaba y la del contenido en otro caso:
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> (entidad fijada indicada: ninguna fuente contiene los bytes fijados, con lo que contenía cada fuente leída; con un registro accesible, el pull vuelve a descargar la versión fijada: el mensaje anterior)
Una entrada de archivo comprimido que nombra una ruta que escapa del archivo comprimido también se informa bajo la condición de contenido, ya que un bundle que lo intenta no es el bundle que se declaró:
path traversal entry "<name>": oci: content digest mismatch (entrada indicada con recorrido de ruta: oci: discrepancia del digest de contenido)
Ambas llevan la misma solución donde el paso que las hace aflorar proporciona una:
remediation: run aggrega pull —upgrade —release <release> to refresh the lockfile and cache (solución: ejecuta aggrega pull —upgrade —release para la Release indicada, para actualizar el archivo de bloqueo y la caché)
Cómo corregirlo: nada en tus archivos de entidad causa esto y ningún cambio de autoría lo resuelve. Actualiza juntos la caché y el archivo de bloqueo con aggrega pull --upgrade --release <release>, que vuelve a descargar desde la fuente y reescribe ambos. Si eso lo resuelve, la copia en caché se había alterado o truncado desde que se escribió. Si la discrepancia persiste tras una actualización, los bytes que sirve el editor difieren realmente de lo que se fijó — una versión republicada, que es una pregunta para quien la publica, y que conviene hacer antes de adoptar el nuevo digest y no después.
A manifest carries no layer of the expected kind, or more than one (Un manifiesto no lleva ninguna capa del tipo esperado, o lleva más de una)
El manifiesto de un artefacto enumera sus capas, y la que lleva el contenido se selecciona por su tipo de medio y no por su posición. Eso es lo que permite que un artefacto agrupe más de una capa — un chart con una capa de procedencia separada a su lado, por ejemplo — y que aun así el contenido se identifique de forma fiable.
Dos estructuras no dejan nada que seleccionar. Ninguna capa del tipo esperado significa que el manifiesto describe algo distinto de lo que se supuso que indicaba la referencia. Más de una significa que la elección no tiene respuesta, y tomar la primera sería a veces correcto y a veces incorrecto sin ningún aviso.
Mensajes emitidos, cada uno con el tipo de medio que se esperaba. Ninguna:
oci: manifest has no layer of media type "<media-type>": oci: manifest has no layer of the expected content media type (oci: el manifiesto no tiene ninguna capa del tipo de medio indicado: oci: el manifiesto no tiene ninguna capa del tipo de medio de contenido esperado)
y más de una, que también indica cuántas:
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: el manifiesto tiene varias capas del tipo de medio indicado; se esperaba exactamente una: oci: el manifiesto tiene varias capas del tipo de medio de contenido esperado)
Cómo corregirlo: la corrección corresponde al editor y no a ti — el manifiesto no es algo que escriba un autor de catálogo. Comprueba primero que la referencia apunte adonde querías: una referencia que se resuelve en otro tipo de artefacto produce la primera estructura, porque el manifiesto es un manifiesto real de otra cosa. Si la referencia es correcta, el artefacto se publicó con un manifiesto que no lo describe como el tipo que se afirma que es, así que comunica el tipo de medio del mensaje a quien lo publica. Publicar por la vía de publicación habitual produce un manifiesto con exactamente una capa de contenido, así que un artefacto en cualquiera de las dos estructuras se ensambló de otra manera.
A published bundle holds no entity, or holds two (Un bundle publicado no contiene ninguna entidad, o contiene dos)
Una entidad que declara archivos junto a su documento — el chart local de una Recipe o su lock, el esquema importado de un Component — se publica como un .tar.gz que agrupa la entidad junto con esos archivos. Volver a leer uno significa encontrar de nuevo la entidad entre ellos — y el archivo en el que se escribió puede llamarse de cualquier manera, así que lo que la identifica es el preámbulo de entidad que lleva y no su nombre. El documento en la raíz del bundle cuyo kind: es un tipo de entidad publicable es la entidad; un fragmento compose, una plantilla de chart o un manifiesto de Kubernetes a su lado no lo son, como tampoco lo es un documento de entidad más abajo dentro de un árbol source/, que es contenido que la entidad distribuye y no la entidad misma.
Dos estructuras no dejan nada que seleccionar, y ambas son propiedades de cómo se publicó el artefacto.
Ningún documento de entidad en la raíz del bundle. El bundle se empaquetó sin la entidad en su raíz — su documento omitido, o colocado en un subdirectorio en lugar de junto a los archivos que lleva. El mensaje enumera lo que sí lleva la raíz del bundle, lo que suele bastar para ver qué ocurrió.
Dos documentos de entidad en la raíz del bundle. El bundle se empaquetó a partir de un directorio completo en el que se escribieron dos entidades — algo que aggrega push nunca hace, ya que cada entidad lleva solo los archivos que declara, pero que otro cliente sí puede hacer. Empaquetadas así, cada una de sus coordenadas publicadas lleva los mismos bytes — de modo que responder con cualquiera de ellas devolvería la otra entidad bajo el nombre que se pidió, sin que nada aguas abajo pudiera notarlo. No hay ninguna elección segura que hacer, así que no se hace ninguna.
Mensajes emitidos, que enumeran lo que se encontró. Ninguno, donde el bundle lleva otros archivos:
bundle root carries no entity document among <file>, <file>: oci: published bundle carries no entity document (la raíz del bundle no lleva ningún documento de entidad entre los archivos indicados: oci: el bundle publicado no lleva ningún documento de entidad)
ninguno, donde no lleva nada en absoluto:
bundle root carries no files at all: oci: published bundle carries no entity document (la raíz del bundle no lleva ningún archivo: oci: el bundle publicado no lleva ningún documento de entidad)
y más de uno, que nombra tanto el número como los documentos en conflicto:
bundle root carries <count> entity documents (<file>, <file>): oci: published bundle carries more than one entity document (la raíz del bundle lleva varios documentos de entidad, en los archivos indicados: oci: el bundle publicado lleva más de un documento de entidad)
Cómo corregirlo: resolver ambos corresponde al editor y no a ti, y la corrección está en el directorio de versión desde el que se publicó la entidad. Da a cada entidad un directorio de versión propio, de modo que ese directorio contenga una entidad y los archivos que le pertenecen — la estructura que ya sigue toda entidad publicada, en la que el directorio se llama como el metadata.version de la entidad y está bajo el propio nombre de la entidad. Después publica de nuevo con una versión nueva: los bytes publicados están congelados, así que volver a publicar sobre la versión existente se rechaza en lugar de corregirse. Si estás consumiendo en lugar de publicando, comunica el mensaje a quien publica el artefacto; los nombres de archivo que contiene identifican el directorio que hay que dividir.
A published artifact cannot be read as an entity (Un artefacto publicado no se puede leer como una entidad)
Leer una entidad desde la coordenada en la que está publicada parte de los bytes que el registro sirve allí — aggrega inspect oci://… los lee para que puedas examinarlos, y un pull de dependencias lee del mismo modo los de un archivo comprimido para encontrar la versión que fija. Dos estructuras de esos bytes no contienen ninguna entidad que leer.
Un archivo comprimido que no se desempaqueta. Una entidad publicada con los archivos que declara se publica como un .tar.gz, y los bytes empiezan como tal, pero el flujo de compresión o el archivo comprimido que contiene no está bien formado — casi siempre porque quedó truncado. Los bytes siguen coincidiendo con el digest que el propio manifiesto del artefacto registra para ellos, así que son exactamente lo que se publicó: el daño ocurrió antes o durante la publicación y no en el camino hacia ti.
Un documento que no es una entidad. La coordenada lleva un único documento, y este no se analiza, no declara ningún kind: o declara un tipo que nunca se publica, como una Release o un Manifest. La referencia nombra entonces algo publicado junto al catálogo en lugar de una entidad — un artefacto de datos publicado con aggrega push-artifact, por ejemplo.
Mensajes emitidos. Un archivo comprimido cuyo flujo de compresión no está bien formado, con el error que lo detuvo:
oci: unbundle gzip: <archive error>: oci: published bundle cannot be unpacked (oci: desempaquetado gzip del bundle: el error del archivo comprimido: oci: el bundle publicado no se puede desempaquetar)
uno que se detiene a mitad de un archivo:
read <file> from the published bundle: <archive error>: oci: published bundle cannot be unpacked (lectura del archivo indicado desde el bundle publicado: el error del archivo comprimido: oci: el bundle publicado no se puede desempaquetar)
un documento que declara un tipo que nunca se publica:
the published document declares kind <kind>, which a registry does not publish: oci: published artifact is not an entity document (el documento publicado declara un tipo que un registro no publica: oci: el artefacto publicado no es un documento de entidad)
y bytes que no son un documento en absoluto:
the published bytes do not parse as a document (<parse error>): oci: published artifact is not an entity document (los bytes publicados no se analizan como un documento, con el error de análisis: oci: el artefacto publicado no es un documento de entidad)
Cómo corregirlo: un archivo comprimido que no se desempaqueta lo tiene que sustituir el editor. Los bytes publicados están congelados, así que el remedio es publicar la entidad de nuevo con una versión nueva; si la estás consumiendo, comunica el mensaje a quien la publica. Un documento que no es una entidad casi siempre significa que la referencia no es la que querías: comprueba que nombre la coordenada en la que está publicada una entidad, que es la referencia que aggrega push imprime cuando publica una.
The registry could not answer what is attached to an artifact (El registro no pudo responder qué está vinculado a un artefacto)
Las firmas y otras vinculaciones cuelgan de un artefacto en lugar de estar dentro de él, y encontrarlas es una pregunta que se hace al registro. Esta condición dice que la pregunta quedó sin respuesta — el registro no sirve esa búsqueda, no se pudo localizar el artefacto del que cuelgan las vinculaciones, o la propia solicitud falló.
Eso no es lo mismo que una respuesta de «no hay nada vinculado», y confundir ambas es exactamente lo que esto existe para evitar. Un artefacto que realmente no lleva ninguna firma se resuelve con normalidad y produce una lista vacía. Esto dice que la lista nunca se obtuvo, así que no se sabe nada en absoluto de lo que está vinculado.
Que la compilación se detenga depende de si se requiere una firma, y ambas direcciones son deliberadas:
Se requiere una firma. La compilación se detiene. Una comprobación requerida que no pudo ejecutarse no se ha superado, y admitir el artefacto se basaría en una pregunta que nadie consiguió hacer.
No se requiere ninguna firma. La compilación continúa y lo dice en voz alta, en lugar de en silencio. La búsqueda no produjo nada que verificar en ningún sentido, así que rechazar descartaría un artefacto por una pregunta sin respuesta — pero el silencio se leería como un pull limpio sin firma, que no lo es.
Mensajes emitidos. Un registro que no sirve la búsqueda:
oci: target does not support referrer discovery: <target kind>: oci: referrer discovery could not be completed (oci: el destino no admite el descubrimiento de referrers, con el tipo de destino indicado: oci: no se pudo completar el descubrimiento de referrers)
el propio artefacto no localizable:
oci: resolve subject "<reference>": <the underlying failure>: oci: referrer discovery could not be completed (oci: resolución del sujeto indicado: el fallo subyacente: oci: no se pudo completar el descubrimiento de referrers)
y la búsqueda que falla:
oci: list referrers of "<reference>": <the underlying failure>: oci: referrer discovery could not be completed (oci: listado de los referrers de la referencia indicada: el fallo subyacente: oci: no se pudo completar el descubrimiento de referrers)
Donde no se requiere ninguna firma, el mismo texto aparece en cambio como aviso:
signature verification could not run for <uri> (the registry could not answer the signature lookup and no signature is required; continuing): <the message above> (no se pudo ejecutar la verificación de firma para el artefacto indicado (el registro no pudo responder a la búsqueda de firma y no se requiere ninguna firma; se continúa): el mensaje anterior)
Cómo corregirlo: la corrección corresponde al operador y depende del registro, no de tu catálogo. Donde el registro no sirve en absoluto búsquedas de vinculaciones, no puede llevar firmas, así que replica el artefacto en uno que sí pueda o deja de exigir firmas de ese host en .aggrega-config.yaml — y toma nota de cuál de las dos opciones eliges, porque la segunda significa que las firmas de ese host ya no se comprueban. Donde la búsqueda falló en un registro que sí la sirve, se trata de un problema de transporte o de permisos específicamente en el endpoint de vinculaciones, y volver a ejecutar una vez que el registro sea accesible es todo el remedio.
An artifact that must be signed carries no signature (Un artefacto que debe estar firmado no lleva ninguna firma)
Se requiere una firma para un artefacto cuando la política de firma propia del espacio de trabajo cubre su tipo o cuando el registro del que procede está configurado para exigir una. Esta condición informa de que el registro respondió a la búsqueda de vinculaciones, de que no había nada vinculado y de que se requería una firma.
Los dos requisitos son una sola postura leída en dos ámbitos. La política de todo el espacio de trabajo impone una firma a un tipo dentro de su ámbito incluso desde un host cuya propia entrada no exige ninguna, así que un host que no exige nada no exime a un artefacto que cubre la política de todo el espacio de trabajo.
Donde no se requiere ninguna firma, esto no es un fallo en absoluto. El artefacto se verifica si hay una firma y pasa sin aviso si no la hay, que es lo que hace que un host sin una postura configurada se pueda usar sin ceremonias.
Un artefacto cuyo tipo no se pudo determinar mientras está activa una política de todo el espacio de trabajo se trata como si requiriera una firma y no como exento, de modo que un artefacto no clasificable no puede colarse ante una política que está activada.
Mensaje emitido, enmarcado por la referencia que estaba comprobando:
verifying the signature of <uri>: signing: no signature found for an artifact that requires one (verificación de la firma del artefacto indicado: signing: no se encontró ninguna firma para un artefacto que la requiere)
Cómo corregirlo: la corrección corresponde al operador o al editor, no al autor de la entidad. Donde esperabas que el artefacto estuviera firmado, se publicó sin firma — comunica la referencia a quien lo publica, ya que solo quien lo publica puede vincular una. Donde el artefacto no está pensado para firmarse, lo que hay que cambiar es el requisito: procede de la entrada del registro en .aggrega-config.yaml o de la política de firma de todo el espacio de trabajo, y la referencia del mensaje te indica qué host revisar. Desactivar un requisito significa que los artefactos de ese host ya no se comprueban, así que es preferible restringir el ámbito de la política a un tipo antes que desactivarla por completo.
A signature does not verify (Una firma no supera la verificación)
Se encontró y comprobó una firma, y la comprobación falló. Es el resultado negativo general de esa comprobación, y abarca una cadena de certificados que no tiene su raíz en el material de confianza, una firma sin entrada en el log de transparencia donde se requiere una, una firma sobre un artefacto distinto del que se tiene, un bundle que ha sido alterado y un bundle comprobado frente a una clave fijada con la que no supera la verificación.
Se distingue deliberadamente de una firma cuyo firmante no es de confianza. Aquella es estructuralmente correcta y la hizo el firmante equivocado; esta no superó la comprobación en absoluto. Mantenerlas separadas es lo que te permite distinguir «el artefacto no es lo que se firmó» de «el artefacto lo firmó alguien a quien no has aceptado».
Para qué artefacto se hizo una firma se comprueba dos veces. Una vez que la comprobación criptográfica de la firma se cumple, la cadena de herramientas lee en la propia firma para qué artefacto se hizo — la misma lectura con la que cada compilación posterior contrasta la firma registrada, que es lo que permite a una compilación rechazar una firma copiada de un artefacto a otro sin verificar nada — y rechaza la firma donde esa lectura no nombra el artefacto que se tiene, o donde la firma está en una forma de la que la lectura no puede deducir el artefacto. Se leen las dos formas que acepta un pull: una firma hecha sobre el propio artefacto y una declaración firmada que lo nombra. La lectura sigue las propias reglas de la comprobación criptográfica, así que, sobre una firma que esa comprobación acepta, ambas coinciden; un rechazo de este tipo significa que no coincidieron, y merece la pena informar de él con la referencia y el mensaje en lugar de sortearlo con la configuración.
Donde la entrada de un registro marca la verificación como consultiva, el mismo texto se informa como aviso y la ejecución continúa.
Mensajes emitidos. De la propia comprobación, citando lo que informó el verificador:
signing: signature bundle does not verify: <what the verifier reported> (signing: el bundle de firma no supera la verificación: lo que informó el verificador)
y, donde la comprobación criptográfica se cumple y la lectura de para qué artefacto se hizo la firma no coincide:
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: el bundle de firma no supera la verificación: su comprobación criptográfica se cumple, pero no nombra el digest del manifiesto indicado como el artefacto para el que se hizo)
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: el bundle de firma no supera la verificación: su comprobación criptográfica se cumple, pero está en una forma de la que no se puede leer el artefacto para el que se hizo)
cada uno enmarcado por la referencia que se está verificando:
verifying the signature of <uri>: <the message above> (verificación de la firma del artefacto indicado: el mensaje anterior)
y, donde la entrada del registro hace que la verificación sea consultiva, como aviso en lugar de como detención:
signature verification failed for <uri> (advisory; continuing): <the message above> (la verificación de firma falló para el artefacto indicado (consultiva; se continúa): el mensaje anterior)
Cómo corregirlo: nada en tus archivos de entidad causa esto y ningún cambio de autoría lo resuelve. Trátalo como una afirmación sobre el artefacto y no sobre tu configuración: los bytes que se tienen no son los bytes que se firmaron, o la firma no es una que el material de confianza configurado pueda comprobar. Vuelve a adquirir primero el artefacto, ya que una copia en caché truncada o alterada falla exactamente así y una descarga nueva lo resuelve. Donde persiste tras una descarga nueva, comunica la referencia y las propias palabras del verificador a quien publica el artefacto. No recurras al ajuste consultivo para superarlo — ese ajuste mantiene la comprobación en ejecución e impide que detenga la compilación, lo cual es una decisión deliberada de aceptar artefactos no verificados de ese host y no una forma de corregir uno.
A signature verifies but its signer is not one the registry trusts (Una firma supera la verificación, pero su firmante no es uno en quien confíe el registro)
La firma superó la comprobación — la cadena de certificados tiene su raíz en el material de confianza y la entrada de transparencia está presente — y la identidad de ese certificado no coincide con ninguna de las identidades configuradas como aceptables para el registro. El artefacto lo firmó un firmante real que no ha sido aceptado.
Se comparan las dos mitades de una identidad, el sujeto y el emisor que respondió por él, y cualquiera de las dos puede ser la que no coincidió. El mensaje nombra ambas donde se pueden leer del certificado, porque un firmante que presenta un sujeto esperado bajo un emisor que nadie aceptó parece idéntico a un sujeto equivocado, a menos que se muestren ambas.
Mensajes emitidos. Con ambas mitades legibles:
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: la identidad de la firma no es de confianza para este registro: lo que informó el verificador; el firmante presentó el emisor indicado con la identidad indicada, pero ninguna identidad de confianza permite ese emisor)
y donde no se pueden leer, recurriendo al propio informe del verificador:
signing: signature identity is not trusted for this registry: <what the verifier reported> (signing: la identidad de la firma no es de confianza para este registro: lo que informó el verificador)
Cómo corregirlo: esta es una decisión del operador, y es una decisión real, no una formalidad. Compara el emisor y la identidad del mensaje con las identidades de confianza configuradas para ese registro en .aggrega-config.yaml. Donde el firmante es uno que quieres aceptar, añádelo — una entrada nombra una identidad, o un patrón que coincide con una, junto con el emisor, y ambos tienen que ser correctos. Donde no lo es, el artefacto lo firmó alguien a quien no has aceptado, y añadir la identidad para que la compilación pase es la única respuesta que hay que evitar. Los registros que anuncian su propia política de confianza pueden tenerla fijada cuando se añade el registro, que es la forma de incorporar las identidades previstas sin transcribirlas.
A keyless trust policy names no acceptable signer (Una política de confianza sin clave no nombra ningún firmante aceptable)
La verificación sin clave decide si aceptar un artefacto comparando la identidad de su certificado de firma con un conjunto de identidades configuradas como aceptables. Un conjunto vacío se rechaza en lugar de tratarse como una política: comparar con nada aceptaría a todos los firmantes o los rechazaría a todos, y ninguna de las dos cosas es lo que pretendía un operador que configuró la verificación.
Mensaje emitido, que es la propia frase de la condición:
signing: keyless verification requires at least one trusted identity (signing: la verificación sin clave requiere al menos una identidad de confianza)
Cómo corregirlo: configura al menos una identidad de confianza para el registro en .aggrega-config.yaml. Una entrada nombra la identidad — como sujeto exacto o como patrón que coincide con uno — junto con el emisor que responde por ella, y ambos son obligatorios. Donde el registro anuncia su propia política de confianza, fijar esa política cuando se añade el registro llena el conjunto con lo que publica el registro. Donde no tienes intención de verificar en absoluto las firmas de este registro, se trata de un ajuste distinto de un conjunto de identidades vacío, y establecerlo explícitamente es lo que lo indica.
The pinned trust root cannot be read (La raíz de confianza fijada no se puede leer)
Una raíz de confianza fijada en el espacio de trabajo es lo que permite a una comprobación sin clave verificar sin acceso a la red dondequiera que se ejecute: un archivo cuyo contenido es el material con el que se comprueba cada firma. Esta condición informa de que el archivo en la ruta configurada no se pudo convertir en material de confianza utilizable — no existe, no se puede leer o su contenido no es una raíz de confianza.
Se detiene en lugar de recurrir a otra cosa. Una raíz fijada es una decisión deliberada de comprobar las firmas con material que tú controlas, así que descargar una en silencio en su lugar sustituiría esa decisión por otra y produciría un resultado de verificación que nadie pidió.
Mensaje emitido, que nombra la ruta y cita lo que informó la lectura:
signing: cannot load pinned trust root: <path>: <what the read reported> (signing: no se puede cargar la raíz de confianza fijada: la ruta indicada: lo que informó la lectura)
Cómo corregirlo: esto corresponde al operador. Comprueba que la ruta configurada para la raíz de confianza existe y que quien ejecuta el comando puede leerla — una ruta relativa a un directorio de trabajo distinto y un archivo presente pero ilegible se informan ambos aquí. Donde el archivo existe y se puede leer, su contenido no es una raíz de confianza, así que sustitúyelo por un bundle actual de la fuente de la que lo obtuviste en lugar de editarlo. Donde no se pretendía una raíz fijada, lo que hay que cambiar es la configuración: elimina la fijación y la verificación usa el material que se le daría de otro modo.
A pinned verification key is not the key profile the verifier accepts (Una clave de verificación fijada no es del perfil de clave que acepta el verificador)
Firmar y verificar con una clave en posesión usan un único perfil de clave, y una clave de cualquier otro tipo se rechaza en lugar de intentarse. Es una afirmación sobre el tipo de la clave, no sobre si verifica algo.
Los dos momentos en que se informa son tareas distintas. Uno es cargar una clave con la que firmar, lo que ocurre donde se publica un artefacto; el otro es comprobar una firma frente a una clave fijada para un registro, lo que ocurre donde se verifica un artefacto. El rechazo es el mismo en ambos.
Mensajes emitidos, cada uno de los cuales nombra el algoritmo de la clave que realmente se proporcionó — an RSA key o an Ed25519 key. Una clave de verificación fijada:
signing: unsupported held-key type: pinned key is <the key's algorithm>, want ECDSA P-256 (signing: tipo de clave en posesión no admitido: la clave fijada usa el algoritmo indicado, se espera ECDSA P-256)
y una clave cargada para firmar:
signing: unsupported held-key type: held key is <the key's algorithm>, want ECDSA P-256 (signing: tipo de clave en posesión no admitido: la clave en posesión usa el algoritmo indicado, se espera ECDSA P-256)
Cómo corregirlo: proporciona una clave del perfil que nombra el mensaje. Donde estás verificando, la clave es la fijada para el registro en .aggrega-config.yaml, y tiene que ser la mitad pública de la clave con la que firma el editor — una discrepancia aquí suele significar que se fijó el archivo equivocado, ya que una clave del tipo correcto pero que no es la clave correcta se informa en cambio como una firma que no supera la verificación. Donde estás firmando, genera una clave del perfil indicado, o usa la vía sin clave, que no necesita ninguna clave en posesión.
The workspace is offline and the step needs the network (El espacio de trabajo está sin conexión y el paso necesita la red)
Un espacio de trabajo se puede marcar como sin conexión, y ese ajuste es un rechazo, no una preferencia: cada paso que llegaría a la red se rechaza donde se construye, antes de que se abra ninguna conexión. Rechazar pronto es lo que hace que el fallo diga «este espacio de trabajo está sin conexión» en lugar de aparecer más tarde como un tiempo de espera agotado sin explicación.
Una sola decisión, leída en un solo lugar. Un paso que necesita saber de antemano si se podría llegar a la red hace la misma pregunta que hace la propia descarga, de modo que una comprobación y la operación que protege no pueden llegar a conclusiones distintas.
Alcanza varios tipos de trabajo, todos con el mismo rechazo: adquirir un artefacto de un registro, adquirir la fuente de una Recipe por la red, descargar una entrada externa, obtener una identidad con la que firmar y descargar material de confianza. Una compilación que lee una caché poblada no alcanza ninguno de ellos, que es el sentido del ajuste.
Donde todo el comando es un viaje de ida y vuelta por la red, el rechazo llega primero en lugar de al final.push, push-artifact y registry update existen para llegar a un registro, así que lo dicen antes de leer tu entidad o recorrer tus repositorios, y nombran cuál de los tres lugares estableció el modo — la opción que escribiste, la variable de entorno, o el archivo y la clave que contiene. Un --dry-run es la excepción, y es una excepción por lo que hace y no por cómo se llama: informa de lo que publicaría y no llama a nada, así que es la forma de una publicación que es segura sin conexión y sigue funcionando.
Mensaje emitido, que lleva su propia solución y es la propia frase de la condición:
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: acceso a la red rechazado porque el espacio de trabajo está sin conexión; solución: pasa la opción que permite la red para esta única ejecución, o borra la clave de nivel superior del modo sin conexión en el archivo de configuración (o AGGREGA_OFFLINE) para permitirla a partir de ahora; donde el trabajo es una compilación que necesita contenido que la máquina no tiene, ejecuta primero el pull de la Release indicada desde un entorno conectado para poblar la caché)
Enmarcado por lo que necesitaba la red — la adquisición de la fuente de una Recipe, por ejemplo:
sourceresolver: kind=<kind> url=<url> version=<version>: <the message above> (sourceresolver: con el tipo, la URL y la versión indicados: el mensaje anterior)
Añadir el hub oficial en un espacio de trabajo sin conexión no se rechaza: el hub se añade con su base integrada, y el aviso dice que no se le preguntó al hub por su política de confianza porque el espacio de trabajo está sin conexión.
Cómo corregirlo: el mensaje nombra tres vías y cuál se aplica lo decides tú. Donde el modo está establecido y quieres saltártelo para este único comando, pasa --offline=false; para eso está la opción, y es la única respuesta disponible para quien no escribió personalmente el archivo de configuración. Donde el espacio de trabajo debe estar sin conexión, lo que hay que corregir es el contenido que falta: ejecuta el pull desde algún lugar con acceso a la red para que la caché contenga todo lo que alcanza la Release, y después la compilación sin conexión no necesita nada más. Donde no debe estar sin conexión en absoluto, borra el ajuste en su origen — la clave de nivel superior offline en .aggrega-config.yaml, o la variable de entorno que nombra el mensaje, y la variable es la que pilla desprevenida a la gente porque no está en ningún archivo. Ten en cuenta que un espacio de trabajo sin conexión no puede firmar en absoluto por la vía sin clave, ya que emitir un certificado y registrarlo son operaciones de red que no tienen forma sin conexión.
Al construir la topología
Una vez que cada Component tiene una Recipe resuelta, el compilador une los Components en el grafo IR leyendo el bloque uses: de cada Component y cruzando los destinos y las vinculaciones de funcionalidades.
Dangling uses target (Destino de arista colgante)
Una arista uses: nombra un componente de destino que no existe en la topología resuelta. La detención es agnóstica respecto al origen — una arista del Aggregate escrita por el desarrollador y una arista cableada por una Release se detectan por igual. Un destino colgante es una detención fatal, no un descarte silencioso: una arista hacia un destino inexistente desaparecería de otro modo y dejaría silenciosamente vacíos los valores inyectados del consumidor en el momento del despliegue. Es el hermano estructural de la detención por socket no declarado que aparece más abajo: sea cual sea el socket en el que se cablea una conexión, su destino debe resolverse en un componente existente antes de que se compruebe el tipo de la arista.
Mensaje emitido. Primero va el rechazo, luego el destino que no corresponde a nada y el socket en el que se cableó la conexión — y después qué hacer al respecto:
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. (el destino de la arista uses no existe: el destino indicado, cableado en el socket indicado. Apunta el destino a un componente que el Aggregate declare, o declara un componente con ese nombre.)
El hallazgo se sitúa en la entrada escrita a la que se refiere, en el documento en el que se escribió esa entrada, de modo que una conexión que trazó el propio bloque uses: de un componente, una que proyectó una vinculación y una que cableó una Release se informan cada una en su propio bloque. Cada conexión infractora se informa como un hallazgo propio, de modo que una sola compilación las nombra todas en lugar de detenerse en la primera.
Cómo corregirlo: declara el componente de destino que falta, o corrige el nombre del destino en la entrada uses: para que coincida con un componente existente.
Two connections of one component under one alias (Dos conexiones de un componente bajo un mismo alias)
Un componente lee cada una de sus conexiones por su alias — la clave bajo la que se escribió la conexión o, para una conexión escrita como entrada de lista, el propio nombre de su destino. Una plantilla de Recipe lee las conexiones de un componente indexadas solo por alias, y una aserción las lee indexadas por socket y luego por alias, de modo que dos conexiones de un componente bajo un mismo alias compartirían un único slot en al menos una de esas vistas: la posterior lo ocuparía, y la otra faltaría en lo que ve la plantilla o la aserción. Así, un alias nombra una sola conexión de un componente — sea cual sea el socket en el que se cablea cada una, lo que la haya trazado (el propio bloque uses: del componente, el bloque uses: de una vinculación en cualquier nivel o una entrada por arista de una Release) y sea cual sea su destino. Un par detiene la compilación una vez que el grafo es definitivo, antes de que se ejecute ninguna aserción y antes de que se renderice nada.
El par surge de una autoría que es legal en cada superficie por separado: la entrada propia de un componente y la de una vinculación en un mismo socket y alias; una lista que nombra dos veces un mismo destino (models: [llama, llama]); un alias escrito en dos sockets (models: { local: … } junto a databases: { local: … }); dos vinculaciones que cablean un mismo alias; o una entrada de Release que traza una conexión en un socket que el Aggregate dejó sin enlazar, bajo un alias que el Aggregate ya usó en otro socket. Dos estructuras vecinas nunca llegan a esta detención: una clave escrita dos veces en un mismo bloque de entradas con clave hace que el documento no se cargue, y una entrada de Release en un socket y un alias que otro bloque ya trazó configura esa conexión — o, si nombra un destino distinto, se detiene como un cambio de destino — en lugar de trazar una segunda.
Mensaje emitido. Primero va el rechazo, luego el alias y el componente, luego el socket de esta conexión, su destino y dónde se escribió su entrada, luego lo mismo para la conexión que ya ocupa el alias — y después qué hacer al respecto:
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. (el alias de conexión ya lo usa otra conexión del mismo componente: el alias y el componente indicados, el socket, el destino, el archivo y la ruta de claves de esta conexión, y luego los mismos datos de la conexión que ya ocupa el alias. Da a una de las dos conexiones un alias propio: un componente lee cada conexión por su alias, sea cual sea el socket en el que esté cableada. Una entrada de lista toma como alias el nombre de su destino, así que un destino listado dos veces se lista una sola vez, o se escribe como dos entradas con clave bajo dos alias.)
Donde ambas conexiones se escribieron en una misma ruta de claves — una lista que nombra dos veces un mismo destino —, cada una se nombra también por su posición en esa lista, list entry "2" junto a list entry "1", que es lo único que distingue las dos entradas.
El hallazgo se sitúa en la entrada propia de la conexión posterior — la trazada en segundo lugar, que es la que de otro modo habría ocupado el slot del alias — en el documento en el que se escribió esa entrada. Así, una entrada de Release, o una vinculación que escribe la Release, se clasifica como un fallo de operaciones, y una entrada en el Aggregate como un fallo del desarrollador. Cada conexión infractora se informa como un hallazgo propio, de modo que una sola compilación las nombra todas.
Algunas estructuras se nombran con menos exactitud. Un nombre de vinculación declarado en más de un nivel — en un componente y en el subsistema que lo contiene, por ejemplo — traza una conexión desde cada bloque que lo declara, y la compilación registra ambas solo bajo el nombre de la vinculación. Ambas conexiones se nombran entonces en uno de los bloques declarantes — el propio bloque de vinculaciones del componente, dondequiera que el nombre se declare allí — y ninguna lleva una posición de lista. Lo mismo ocurre dentro de un Aggregate importado, donde los bloques declarantes — el de un componente y el de uno de los propios subsistemas del módulo — se nombran en el propio documento del módulo. En cada una de estas estructuras el par se rechaza igualmente.
Cómo corregirlo: da a una de las dos conexiones un alias propio. Para una lista que nombra dos veces un mismo destino, lista el destino una sola vez, o escribe las dos conexiones como entradas con clave bajo dos alias. Para un alias en dos sockets, cambia el nombre de una de las dos claves. Una vinculación que cablea un socket bajo un alias que el componente ya usa toma una clave distinta en su propio bloque uses:.
uses: socket not declared in the owning entity’s usesSchema (Socket no declarado en el esquema de sockets de la entidad propietaria)
Un bloque uses: nombra un socket que la entidad propietaria de la superficie no declara en su usesSchema, en una de las dos superficies donde solo puede nombrarse un socket declarado: el uses:de una vinculación de Feature, donde el socket debe declararse en la Feature vinculada, y el uses: por arista de una Release, donde debe declararse en el Component consumidor. Una Release solo puede cablear o configurar aristas dentro de los sockets que el usesSchema del Component ya declara.
La superficie de las vinculaciones se comprueba en cada nivel en el que se escribe una vinculación: en un componente, en un subsistema — del Aggregate o de un módulo que importa —, en un límite de Release y en una entrada de componente de Release, incluida la entrada de un componente que aporta un módulo. Las declaraciones propias de un módulo se comprueban una vez construida la composición que lo importa, y el hallazgo nombra el Aggregate del módulo y la clave dentro de su documento.
El bloque uses:propio de un componente no es, deliberadamente, una de esas superficies, así que esta detención no se activa para él. Un desarrollador es dueño de la topología que declara el Aggregate y puede nombrar un socket que el catálogo no declaró; el silencio del catálogo sobre un socket significa que la conexión no estaba prevista, no que esté prohibida. Un socket así es legal y su arista se construye — lo que pierde es el selector y el contrato por arista que aporta un socket declarado. Un nombre de socket mal escrito ahí no es, por tanto, una detención, sino una conexión ad hoc propia, y se informa como una advertencia que nombra ambas grafías — consulta warnings.md «Uses-socket near-miss lint (Lint de casi coincidencia de sockets uses)».
Mensaje emitido:
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 desconocido: nombra un socket que la entidad declare en su usesSchema — solo el propio bloque uses de un componente puede nombrar uno que el catálogo no declaró; con la Release, la entrada del componente, el tipo de componente, el nombre del socket y los sockets declarados)
La rama de las vinculaciones nombra el tipo de funcionalidad en lugar del tipo de componente; una Feature vinculada que no declara ningún usesSchema informa en cambio de que las declaraciones uses: no están permitidas para ella.
Cómo corregirlo: en una vinculación, corrige el nombre del socket por uno que declare la Feature vinculada, o declara ese socket en el usesSchema de la Feature. En una entrada por arista de una Release, corrige el nombre del socket por uno que declare el Component consumidor — una Release no puede introducir un socket que el Component no declare, y trasladar la declaración a la entidad del catálogo es la vía admitida. Si la entidad del catálogo no declara ningún usesSchema, no acepta declaraciones uses: en esa superficie — elimina el bloque.
A connection carries an attachment under a name its socket declares no slot for (Una conexión lleva una vinculación bajo un nombre para el que su socket no declara ningún slot)
El bloque features: de una entrada de conexión nombra una vinculación que ningún slot del socket de la conexión declara. Las vinculaciones que lleva una conexión son un conjunto cerrado: el socket a través del cual se cablea la conexión declara, en un featuresSchema en la entrada del usesSchema del Component consumidor, cada slot que puede llenar una conexión en él, y una vinculación bajo cualquier otro nombre se rechaza cuando se carga la compilación. Un socket que no declara ningún featuresSchema no admite vinculaciones en sus conexiones, y tampoco un socket que el Aggregate nombra sin que el Component lo declare — un socket así no declara ningún slot.
La regla se aplica en los dos documentos que escriben las vinculaciones de una conexión: la entrada de conexión del Aggregate bajo el uses: de un componente y la entrada uses: por arista de la Release. Para un componente que aporta un subagregado, los nombres del desarrollador se comprueban una vez leído el propio documento del subagregado, y el hallazgo nombra el archivo de ese documento y la entrada del componente en él. Los nombres de la Release se comprueban una vez aplanada la composición, para cada componente sobre el que escribe la Release, y el hallazgo nombra la propia entrada de la Release — dentro del límite en el que se encuentra, o bajo la entrada de enrutamiento que alcanza el componente de un subagregado. Una entrada de Release en un socket que el Component no declara la informa la detención por socket no declarado que aparece más arriba, que enumera los sockets que sí existen, y no esta.
Mensaje emitido. Primero va el rechazo, luego el documento y la entrada, el nombre de la vinculación, la conexión, el socket, el componente y los slots que declara el socket — y después qué hacer al respecto:
a connection carries an attachment under a name its socket declares no slot for (Aggregate <aggregate-name>, at .spec.components.<component>.uses.<socket>.<alias>, "<attachment>", on the connection "<alias>", through socket "<socket>", of component "<component>", the socket declaring the slots "<slots>"). Write the attachment under one of the slots the socket declares, or declare this slot in the socket’s featuresSchema on the Component. (una conexión lleva una vinculación bajo un nombre para el que su socket no declara ningún slot: el Aggregate, la entrada, la vinculación, la conexión, el socket y el componente indicados, con los slots que declara el socket. Escribe la vinculación bajo uno de los slots que declara el socket, o declara este slot en el featuresSchema del socket en el Component.)
Donde el nombre está a una edición de distancia de un slot que declara el socket — un carácter transpuesto, omitido, duplicado o erróneo, la estructura que adopta una errata —, ese slot se nombra justo después, de modo que la grafía probablemente pretendida está en la misma frase:
a connection carries an attachment under a name its socket declares no slot for (Release <release-name>, at .spec.boundaries.<boundary>.components.<component>.uses.<socket>.<alias>, "credentail", near the declared slot "credential", on the connection "<alias>", …) (una conexión lleva una vinculación bajo un nombre para el que su socket no declara ningún slot: la Release y la entrada indicadas, el nombre de la vinculación cercano al slot declarado, la conexión indicada, …)
No se genera ningún aviso aparte para un nombre así. En el propio bloque features: de un componente, un nombre a una edición de distancia de un slot declarado es legal y solo produce el aviso descrito en «An attachment name is one edit from a declared slot (Un nombre de vinculación está a una edición de distancia de un slot declarado)» más abajo; en una conexión el nombre se rechaza, y el rechazo lleva consigo el emparejamiento.
Donde el socket no declara ningún slot, la lista no aparece y la recomendación dice «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. (El socket no declara ningún slot, así que ninguna conexión cableada a través de él lleva una vinculación: elimina la vinculación, o declara el slot en el featuresSchema del socket en el Component.)» Donde el Component no declara el socket en absoluto, dice «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. (El tipo del componente no declara este socket, así que el socket no declara ningún slot y ninguna conexión cableada a través de él lleva una vinculación: elimina la vinculación, o declara el socket y su slot en el usesSchema del Component.)»
Cada vinculación infractora se informa como un hallazgo propio, de modo que una sola compilación las nombra todas.
Cómo corregirlo: escribe la vinculación bajo un slot que declare el socket; o, si la conexión necesita un slot que el socket no tiene, decláralo en el featuresSchema del socket en el Component. En un socket que el Component no declara, declara el socket y su slot en el usesSchema del Component, o elimina la vinculación.
Release retargets a developer-declared edge (La Release cambia el destino de una arista declarada por el desarrollador)
Una entrada uses: por arista de una Release nombra un destino distinto del que el desarrollador ya cableó para el mismo socket y alias. Una Release puede configurar una arista que declaró el desarrollador (fijar infra por arista, nombrando el mismo destino u omitiéndolo) y puede cablear una arista en un socket declarado pero sin enlazar, pero no puede cambiar el destino de una arista que declaró el desarrollador — el desarrollador es dueño de la arquitectura que escribió.
Ambos destinos se comparan tal como se escribieron, no tal como se resuelven. Un target: puede nombrar el alias publicado de un subagregado en lugar de un id de componente, y ese alias se resuelve en el componente para el que el módulo lo publica — así que una entrada de Release que repite exactamente el alias que escribió el desarrollador es una configuración y se acepta, igual que la repetición de un simple id de componente.
La arista conserva el destino que le dio el desarrollador, se active o no esta detención, y el bloque infra: de la entrada de Release no se le aplica. Un cambio de destino rechazado nunca se aplica a medias.
Mensaje emitido. Primero va el rechazo, luego el destino que declaró el desarrollador, el destino que nombró la Release y el socket — y después qué hacer al respecto:
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. (la arista de la Release cambia el destino de una arista declarada por el desarrollador: el destino declarado, el destino que nombra la Release y el socket en el que está cableada, indicados. Quita el destino de la entrada de la Release para configurar la conexión tal como se declaró, o cambia el destino donde se declara la conexión.)
El hallazgo se sitúa en la entrada escrita en la que se declaró la conexión, en el documento que la declaró. Cada entrada infractora se informa como un hallazgo propio, de modo que una sola compilación las nombra todas en lugar de una por ejecución.
Cómo corregirlo: quita el target distinto de la entrada uses: de la Release para configurar la arista existente (solo infra por arista), o, si la conexión pertenece realmente a otro socket, cabléala a través de un socket que el desarrollador dejó sin enlazar. Para cambiar el destino en sí, cámbialo en el Aggregate, donde se escribe la topología.
Release per-edge configuration has no edge to apply to (La configuración por arista de la Release no tiene ninguna arista a la que aplicarse)
Una entrada uses: por arista de una Release fija infra:, vinculaciones bajo features:, o ambas cosas, pero no existe ninguna arista en el consumidor, el socket y el alias que nombra, una vez trazadas todas las aristas de la compilación.
Las dos cosas que puede hacer una entrada de Release son cablear una arista y configurar una, y cuál hace depende de si nombra un target:. Una entrada con un destino crea la arista que configura. Una entrada sin destino configura una arista que ya debe existir — declarada por el desarrollador en el Aggregate, o aportada por una Feature vinculada. Así que una entrada que no nombra ningún destino y no coincide con ninguna arista existente no se aplica a nada: el bloque infra: y las vinculaciones que hay debajo nunca llegan a ninguna salida. La compilación se detiene en lugar de aceptar una autoría que no hace nada, porque de otro modo una compilación correcta se leería como confirmación de que la infraestructura se aplicó y de que la conexión lleva lo que la entrada le puso.
El alias forma parte de lo que nombra una entrada, así que una entrada que configura un alias que el desarrollador nunca declaró no alcanza ninguna arista, aunque el socket esté enlazado bajo otro alias. Lo mismo ocurre con una entrada que nombra un componente que el Aggregate no declara.
Dos condiciones vecinas las informan sus propias detenciones y no esta, porque cada una tiene más que decirte. Un socket que el usesSchema del Component consumidor no declara se informa como socket no declarado, lo que permite enumerar los sockets que sí existen. Un target: que no nombra ningún componente se informa como destino colgante. Un componente desactivado por un interruptor active: se lleva sus aristas consigo por diseño, así que una entrada que queda sobre él se acepta en lugar de detenerse.
Se informa cada entrada infractora. Una Release con varias entradas que no alcanzan ninguna arista se detiene con uno de estos mensajes por entrada en una sola compilación, en el orden en que el documento las declara, en lugar de informar la primera y dejar el resto para la siguiente compilación.
Mensaje emitido, donde la entrada nombra un componente que existe. Lleva la ruta de la propia entrada, de modo que se nombra la línea que hay que editar y no el componente que la contiene:
release per-edge configuration has no edge to apply to (Release <release-name>, at .spec.boundaries.<boundary>.components.<consumer>.uses.<socket>.<alias>, "<consumer>", on socket "<socket>", under alias "<alias>"). Give the entry a target to wire the edge, or remove it: an entry with no target configures an edge that must already exist. (la configuración por arista de la Release no tiene ninguna arista a la que aplicarse: la Release, la entrada, el consumidor, el socket y el alias indicados. Da a la entrada un destino para cablear la arista, o elimínala: una entrada sin destino configura una arista que ya debe existir.)
Una Release que nombra sus componentes en el nivel superior en lugar de bajo límites lleva la estructura que escribió su autor — .spec.components.<consumer>.uses.<socket>.<alias> — y un componente nombrado dentro de una entrada de enrutamiento aggregates: se nombra a través de esa entrada, con el nombre local que lleva allí.
Donde la entrada nombra un componente que el Aggregate no declara, la detención procede de una fase anterior de la compilación y dice lo siguiente, nombrando lo que fija la entrada — infra, features o 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 configuración por arista de la Release no tiene ninguna arista a la que aplicarse: la arista de la Release indicada fija los bloques indicados en el consumidor indicado, que no es un componente de la topología)
Cómo corregirlo: añade un target: a la entrada, lo que cablea la arista y le aplica la configuración; corrige el alias por el que el Aggregate declaró para esa conexión, de modo que la entrada configure la arista existente; corrige el nombre del componente por uno que el Aggregate declare; o elimina la entrada si ya no se quiere la configuración.
A Release attachment takes the name of a connection’s attachment (Una vinculación de la Release toma el nombre de la vinculación de una conexión)
Una Release escribe una vinculación bajo el nombre que toma una vinculación en una de las conexiones de un componente: el alias de la conexión, un punto y el slot que llena la vinculación — gpt.credential para la vinculación que llena el slot credential en la conexión gpt. La vinculación de una conexión se escribe en su entrada de conexión — la conexión del Aggregate bajo el uses: del componente, o la entrada uses: por arista de la Release para la misma conexión — y se convierte en una vinculación del componente consumidor bajo ese nombre compuesto. La Release escribe vinculaciones en otros dos niveles cuyas claves pueden llevar un punto, así que el nombre compuesto también puede escribirse allí:
El propio bloque features: de una entrada de componente, que se vincula a ese componente.
El propio bloque features: de un límite, que se vincula a cada componente colocado en ese límite o en un límite anidado dentro de él — incluidos los componentes de un subagregado que el límite enruta hacia dentro sin nombrarlos. Una clave ahí se detiene cuando es igual al nombre compuesto en cualquiera de los componentes que alcanza, nombre o no un type:.
La compilación se detiene en lugar de fundir cualquiera de las dos en la vinculación de la conexión, porque entonces ninguno de los dos documentos mostraría completo lo que la compilación hace con ella. El slot de un socket se llena por conexión, mediante la propia entrada de la conexión, y nunca mediante una vinculación que caiga en cascada sobre él desde un nivel más amplio. Una clave con punto que no toma ninguna vinculación de conexión de los componentes que alcanza es un nombre de vinculación ordinario, y no se rechaza.
La comprobación abarca una vinculación que cualquiera de los dos documentos puso en la conexión, y tanto un componente que aporta un subagregado como uno que declara el Aggregate.
Mensaje emitido, para una clave en una entrada de componente. Primero va el rechazo, luego la Release y la entrada de componente, la clave que escribió la Release, el componente, la conexión, el socket y el slot — y después la entrada de conexión en la que escribirla:
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. (una vinculación de la Release toma el nombre de una vinculación que lleva una de las conexiones de un componente: la Release, la entrada del componente, la clave, el componente, la conexión, el socket y el slot indicados. Escríbela en la entrada de conexión, bajo la ruta indicada, y quita la clave de las features de esta entrada: una vinculación que lleva una conexión se escribe en esa conexión y en ningún otro sitio.)
Mensaje emitido, para una clave en un límite. Nombra el bloque de vinculaciones del límite y el componente cuya conexión lleva la vinculación:
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. (una vinculación de la Release toma el nombre de una vinculación que lleva una de las conexiones de un componente: la Release, el bloque de vinculaciones del límite, la clave, el componente, la conexión, el socket y el slot indicados. Escríbela en la entrada de conexión del componente indicado, bajo la ruta indicada, y quita la clave de las features de este límite: una vinculación que lleva una conexión se escribe en esa conexión y en ningún otro sitio.)
Una clave en un límite que alcanza varios componentes cuyas conexiones llevan el nombre compuesto se informa una vez por cada uno de ellos, porque cada conexión es una edición independiente.
El hallazgo se sitúa en el bloque en el que se escribió la clave — la entrada de componente, o el features: del límite — porque la propia clave lleva un punto y una posición no puede direccionar una clave así; en su lugar, la clave se nombra en el mensaje. En una Release que nombra límites, una entrada de componente se lee .spec.boundaries.<boundary>.components.<component>, un componente nombrado dentro de una entrada de enrutamiento aggregates: se nombra a través de esa entrada, con el nombre local que lleva allí, y el bloque de un límite anidado se lee .spec.boundaries.<outer>.boundaries.<inner>.features.
Cómo corregirlo: mueve la vinculación a la entrada de la Release para esa conexión — uses.<socket>.<alias>.features.<slot> bajo el componente — escribiendo allí solo infra: para dimensionar una vinculación que declara el Aggregate, o type: e infra: para una que solo crea la Release; después quita la clave con punto del features: del componente o del límite. Una clave válida para todo el límite y pensada para las conexiones de varios componentes se escribe una vez en cada una de esas conexiones.
A Release connection attachment names no Feature type (Una vinculación de conexión de la Release no nombra ningún tipo de Feature)
Una entrada uses: por arista de una Release pone una vinculación en una conexión, bajo un slot para el que el Aggregate no declara ninguna vinculación en esa conexión, y no nombra ningún type:. Una vinculación que una Release escribe en una conexión es una de dos cosas. O dimensiona una vinculación que el Aggregate ya declara en la misma conexión, y no nombra ningún tipo porque lo nombra la declaración del Aggregate; o es una vinculación que solo crea la Release, y entonces la entrada de la Release es el único lugar del que puede venir su tipo de Feature. Sin un tipo, nada puede elegir una FeatureRecipe para la vinculación.
La comprobación abarca tanto un componente que aporta un subagregado como uno que declara el Aggregate. Un componente que un interruptor active: desactivó se lleva sus conexiones consigo, así que una entrada que queda sobre él no se comprueba.
Mensaje emitido. Primero va el rechazo, luego la Release y la entrada de conexión, el slot, la conexión, el socket y el componente — y después qué hacer al respecto:
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. (una vinculación de conexión de la Release no nombra ningún tipo de Feature, y el tipo es obligatorio para una vinculación que solo crea la Release: la Release, la entrada de conexión, el slot, la conexión, el socket y el componente indicados. Nombra, por su tipo, la Feature que vincula esta vinculación, o declara la vinculación en la entrada de conexión del Aggregate y dimensiónala aquí.)
Cada vinculación infractora se informa como un hallazgo propio, de modo que una sola compilación las nombra todas.
Cómo corregirlo: añade un type: que nombre la Feature que vincula la vinculación; o, donde declarar la vinculación le corresponde al desarrollador, declárala en la entrada de conexión del Aggregate con sus values: y deja solo infra: en la entrada de la Release.
Component identity cannot be stamped on what it emits (La identidad del Component no se puede estampar en lo que emite)
La identidad de un componente no es solo una clave en tu Aggregate — es un nombre dentro del clúster. Cada recurso que emite un componente lleva estampada esa identidad, bajo aggrega.ai/component-id y app.kubernetes.io/name, y los sintetizadores de cargas de trabajo nombran lo que emiten a partir de ella. Así que la identidad tiene que ser un nombre que el destino acepte, y tiene que ser uno que signifique lo que dice.
Un nombre que escribiste llega a su salida exactamente como lo escribiste, y eso es lo que hace que el nombre de tu Aggregate sea el nombre que puedes buscar en tu clúster. Vale la pena tenerlo, y es la razón por la que una identidad que el destino rechazaría se informa aquí en lugar de repararse en silencio como algo que nunca escribiste.
Un carácter es la excepción, y es uno que no puedes escribir: el punto que une el nombre de un módulo con el nombre de un componente que contiene. Está excluido de todo nombre que escribes precisamente para que esa unión no sea ambigua, y se elimina de la identidad antes de estamparla — data-layer.main-db se estampa como data-layer-zdmain-db. Eso no cuesta ningún nombre que alguien haya tecleado, y es lo que permite siquiera estampar un componente que aporta un Aggregate importado: un punto no es un carácter que acepte un nombre de Service, y dentro de una dirección del clúster separa un servicio de su namespace, así que un nombre con punto que se entrega a un consumidor como host se resolvería en otro servicio en lugar de fallar.
Se rechazan dos estructuras.
Una identidad que el alfabeto de estampado no puede llevar. La identidad se escribe en el valor de la etiqueta que lleva cada recurso emitido, y ese alfabeto admite letras, dígitos, -, _ y ., y exige que el valor empiece y termine con una letra o un dígito. Las reglas de los nombres escritos se parecen a esta, pero no son iguales — permiten que un nombre empiece o termine con - o _ —, así que _api y api- son ambos nombres que puedes escribir y ninguno de los dos se puede estampar.
Aquí no se pregunta qué longitud puede tener un nombre. Eso le corresponde al destino en el que se despliega un componente, y distintos destinos responden de forma distinta: esta condición abarca las estructuras que ningún destino podría llevar. Un nombre rechazado por su longitud lo informa en su lugar el propio rechazo del destino, que lleva el motivo de ese destino y la longitud que aceptaría.
Una identidad que empieza como empieza una identidad compuesta. Los recursos que emite una Feature no pueden estamparse con un nombre de componente que hayas escrito, así que Aggrega compone para ellos una identidad a partir de las partes que sí escribiste, detrás de un prefijo fijo que indica dónde se vinculó la Feature. Donde la Feature está vinculada a un único componente, la identidad se compone a partir de ese componente y de la clave bajo la que está vinculada la Feature, y empieza por cfr--. Donde está vinculada a un límite completo, no se aplica el nombre de ningún componente, así que la identidad se compone a partir de la ruta del límite y del nombre bajo el que está vinculada la Feature, y empieza por bfr--. El prefijo es lo que le dice al lector de cuál de los dos procede un recurso, en lugar de proceder de un componente. Así que bfr-- y cfr-- están ambos reservados al inicio de una identidad de componente. Un componente llamado bfr--api o cfr--api se estamparía de forma idéntica a uno compuesto, y nada en la salida emitida podría distinguirlos. Solo se reserva el prefijo completo: un componente llamado bfr, cfr, bfr-api o bfrontend tiene un nombre ordinario y la compilación se completa.
La comprobación lee la identidad que lleva realmente un componente, que para un componente aportado por un Aggregate importado es la cualificada — el nombre del módulo, un punto y el nombre propio del componente. Así que dos nombres que por separado son aceptables pueden unirse igualmente en una identidad que no lo es: un módulo llamado bfr--x y un componente llamado y dentro de él se unen en bfr--x.y, que empieza como empieza una identidad compuesta. La detención nombra la identidad unida mientras señala la clave que escribiste.
Mensaje emitido, para una identidad que el destino rechazaría:
component identity cannot be the name its emitted resources are stamped with: rename the component (Aggregate, at <field-path>, "<identity>", which must "<rule>") (la identidad del componente no puede ser el nombre que se estampa en los recursos que emite: cambia el nombre del componente; con el Aggregate, la ruta del campo y la identidad indicados, y la regla que la identidad debe cumplir)
y para una que empieza como empieza una identidad compuesta, donde <opening> es el prefijo reservado con el que coincidió el nombre:
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>") (la identidad del componente no puede ser el nombre que se estampa en los recursos que emite: cambia el nombre del componente; con el Aggregate, la ruta del campo y la identidad indicados, que no debe empezar por el prefijo reservado indicado)
Cómo corregirlo: cambia el nombre del componente, en cada superficie que lo nombra — el Aggregate que lo declara y la Release que lo coloca y lo configura. Dale un nombre que empiece y termine con una letra o un dígito y que no empiece ni por bfr-- ni por cfr--. Cambiar el nombre de un componente cambia el nombre que llevan sus recursos en el clúster, así que, en una aplicación ya desplegada, trátalo como cualquier otro cambio de nombre de un recurso.
The target will not accept a name derived from an authored identity (El destino no acepta un nombre derivado de una identidad escrita)
Cada destino deriva sus propios nombres de la identidad de un componente: un instalador de charts deriva un nombre de release, un orquestador de contenedores deriva nombres de servicio. Esta detención es ese destino indicando que no puede usar uno de ellos.
Aggrega no contiene las reglas de nomenclatura de ningún destino. No sabe qué longitud puede tener un nombre, qué caracteres admite un destino ni qué exige la gramática de un destino al inicio de un nombre — y deliberadamente no lo sabe, porque eso varía según el destino, según el tipo de recurso en el que acaba un nombre y, a veces, según un servicio dentro de un mismo proveedor. Por eso, antes de que se determine un nombre, el compilador pregunta al proveedor que renderizará el componente, y esta detención informa de la respuesta del proveedor. Esa es la razón por la que el mensaje lleva la palabra propia del destino para lo que rechazó (release name, Service name) y el motivo propio del destino, en lugar de una regla escrita en el compilador.
Por qué el nombre se rechaza en lugar de acortarse. Un nombre que escribiste es el nombre con el que se despliega tu carga de trabajo: acortarlo cambiaría el nombre de cada recurso en cada salida existente, y lo haría en tu nombre sin que lo hubieras pedido. La persona que puede elegir un nombre distinto es la persona que escribió este, así que la detención apunta a la clave spec.components que escribiste y deja el nombre como está. Los nombres que compone el propio Aggrega — la identidad de una Feature vinculada a un límite entero, por ejemplo — se acortan en cambio, porque se ensamblan a partir de partes escritas en varios documentos y ningún autor por sí solo puede ver la longitud que alcanzan.
Dos respuestas que puede dar un destino, y llevan a lugares distintos. Donde se aceptaría un nombre más corto, la detención indica la longitud que funcionaría, de modo que un nuevo nombre se elige una vez y no dos. Donde ninguna longitud ayudaría — un carácter que la gramática del destino rechaza en la posición en la que quedó —, no se indica ninguna longitud, porque acortar no puede alcanzarlo. El caso más común del segundo tipo: un destino cuyos nombres solo admiten minúsculas escapa cada carácter que no admite, y cada escape empieza con un guion, de modo que un nombre cuyo primer carácter se escapa produce un nombre que empieza con un guion. Un destino que exige ahí una letra minúscula o un dígito lo rechaza por corto que sea el resto. Un destino también puede someter el inicio de un nombre a la regla más estricta de los recursos que llevan su nombre: el destino helm rechaza un nombre que empieza con un dígito, informado como Service name, porque Helm acepta un nombre de release así mientras que el clúster rechaza un Service de Kubernetes que lleve su nombre.
Una tercera forma aparece solo para un nombre compuesto: un destino puede indicar una longitud menor que la identidad más corta que el compilador puede componer a partir de las partes que recibió, ya que una identidad compuesta reserva espacio para un discriminador. La detención lo dice y nombra el remedio — acortar las partes escritas — en lugar de informar de que el proveedor es defectuoso.
Algunos nombres existen solo para la carga de trabajo que renderiza un componente. Se consulta al provider una vez resuelto el Workload de ese componente, y la consulta lleva el form del Workload y sus claves Service, de modo que un destino puede juzgar también los nombres que construye a partir de ellos. Con el destino helm eso añade dos: un CronJob name, de 52 caracteres como máximo y juzgado solo para un Workload scheduled, porque el clúster nombra el Job de cada ejecución a partir del CronJob con un sufijo añadido; y cada Service name, <release name>-<service key>, de 63 caracteres como máximo. Un nombre de Service se construye con partes de dos autores — el nombre de tu componente y la clave que declara la carga de trabajo, en la Recipe o en una FeatureRecipe —, así que su motivo nombra la clave y dónde la declara la carga de trabajo, spec.workload.services.<key>, junto al campo que escribiste. Una clave lo bastante larga como para no dejar sitio a ningún nombre de componente no indica ninguna longitud dentro de la cual elegir, y el motivo dice que es la clave la que tiene que ser más corta. Estos nombres no se juzgan para una Feature asociada a un boundary entero: su identidad se fija antes de que se resuelva su Workload, porque el lugar donde se ensambla su salida puede depender de ella.
Mensaje emitido, para una identidad escrita:
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 (el destino no acepta un nombre derivado de la identidad escrita de este componente: cambia el nombre del componente (el componente indicado, escrito en la ruta indicada, que el destino no puede usar como el tipo de nombre indicado, con el motivo del destino). elige un nombre que el destino acepte, de como máximo el número de caracteres indicado)
Cómo corregirlo: cambia el nombre del componente por uno que el destino acepte, en cada superficie que lo nombra — el Aggregate que lo declara y la Release que lo coloca y lo configura. Donde el mensaje indica una longitud, no la superes. Donde no la indica, lee el motivo del destino: suele ser un carácter que el destino no admite, y con mayor frecuencia una letra mayúscula al inicio del nombre — o, con el destino helm, un dígito en esa posición. Prefiere letras minúsculas y dígitos con guiones entre las palabras; el capítulo sobre nomenclatura explica lo que cuesta un nombre con cada tipo de destino. Donde el motivo nombra una clave Service, la longitud también puede recuperarse acortando esa clave donde la declara la carga de trabajo — y donde el motivo dice que la clave no deja sitio, solo eso funcionará. Cambiar el nombre de un componente cambia el nombre que llevan sus recursos, así que en una aplicación ya desplegada trátalo como cualquier otro cambio de nombre de recursos.
Donde la identidad es una que compuso el compilador en lugar de una que escribiste tú, la misma detención informa del valor compuesto y te pide que acortes las partes a partir de las cuales se construyó — el nombre bajo el que vinculaste una Feature y la ruta del límite al que la vinculaste.
A provider never accepted a name the compiler composed (Un proveedor nunca aceptó un nombre compuesto por el compilador)
Esta informa de un defecto en un plugin, no en nada que hayas escrito.
Determinar un nombre compuesto es un intercambio: el compilador propone una identidad, el proveedor la acepta o dice cuán corta tendría que ser, el compilador compone una más corta y se vuelve a preguntar al proveedor. Un segundo rechazo es normal y esperado — acortar a una longitud puede dejar un carácter donde la gramática de ese destino no lo admite, y que el proveedor lo diga es la forma en que un compilador que no conoce la gramática de ningún destino y un proveedor que sí la conoce llegan a un acuerdo.
Lo que no es normal es un proveedor que nunca acepta nada: uno que indica una longitud, recibe un nombre de esa longitud y vuelve a rechazarlo. El intercambio está acotado y, al alcanzar el tope, la compilación se detiene y nombra al proveedor en lugar de usar un nombre que el proveedor nunca aceptó. Un nombre determinado por abandono se estamparía en recursos reales sin que nada en la salida registrara que no se llegó a ningún acuerdo, y la consecuencia aparecería en el momento de aplicarlo en lugar de en la compilación que lo produjo.
Mensaje emitido:
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 (el guest del proveedor nunca aceptó una identidad de componente que el compilador compuso para él (el guest del proveedor indicado rechazó el número de propuestas indicado, la última de ellas la identidad indicada). informa del defecto a quien mantenga ese plugin de proveedor)
Cómo corregirlo: infórmalo a quien mantenga el plugin de proveedor nombrado, citando la última propuesta del mensaje. No hay ningún cambio de autoría que lo evite: el compilador ya ofreció cada longitud que pidió el proveedor. Si el proveedor es uno que mantienes tú, la comprobación que hay que hacer es que un nombre recortado a un tope que indica sea un nombre que luego acepta.
Required uses: socket not populated (Socket obligatorio no poblado)
Un Component declara en su usesSchema un socket marcado con required: true, y nada en la compilación cablea una conexión en ese socket para una de las instancias de ese Component.
Tres superficies pueden cablearlo, y la detención solo se activa cuando las tres están vacías. El propio bloque uses: de la instancia en el Aggregate; una entrada uses: por arista de una Release que nombra un target:, la cual crea la conexión en un socket declarado pero sin enlazar; y el conjunto de conexiones que produjo la composición, que es lo que responde por un componente que aporta un Aggregate importado — el bloque uses: de un componente así está en el propio documento de ese Aggregate, que solo se lee una vez ensamblada la composición. Como la tercera superficie es la última en estar completa, la comprobación se ejecuta una vez que existe la composición entera y no mientras se leen los dos documentos escritos, y plantea la misma pregunta a cada componente, sea cual sea el documento que lo declaró.
Dos estructuras que parecen deber poblar el socket no lo hacen. Una entrada de Release que no nombra ningún target: configura una conexión que ya debe existir en lugar de crear una, así que no cablea nada (y, donde lleva infra:, la informa su propia detención más arriba). Y el uses: de una vinculación de Feature nombra sockets declarados en la Feature vinculada, un conjunto de sockets distinto en una entidad distinta, así que una vinculación nunca puede poblar un socket propio de un Component.
Mensaje emitido:
required uses socket not populated (Component, at .spec.components.<instance>.uses.<socket>, "<socket-name>", declared required by component type "<component-type>") (socket uses obligatorio no poblado (Component, en la ruta del socket, con el nombre del socket, declarado obligatorio por el tipo de componente indicado))
El hallazgo se sitúa en la entrada de socket que el autor tiene que escribir, .spec.components.<instance>.uses.<socket>. El nombre de instancia que contiene es el nombre que lleva el componente en el documento que lo declara, así que, para un componente que aportó un Aggregate importado, el localizador nombra una clave que contiene el propio archivo de ese Aggregate y no el nombre con prefijo que le dio la composición.
Se informa de cada socket obligatorio no poblado, en cada componente: una sola compilación te informa de todos en lugar de solo del primero.
Cómo corregirlo: añade una entrada uses: para el socket obligatorio, cableándola a un destino que acepte el selector: del socket; o cabléalo desde la Release con una entrada que nombre un target:. Si el socket ya no debe ser obligatorio, actualiza el usesSchema del Component para establecer required: false o elimina la declaración required.
Sub-aggregate nesting depth exceeded (Profundidad de anidamiento de subagregados superada)
Una cadena de importaciones de subagregados supera la profundidad máxima de anidamiento del compilador. El límite impide un aplanamiento descontrolado de topologías profundamente anidadas y obliga a una descomposición arquitectónica por encima de un umbral.
Mensaje emitido:
max sub-aggregate nesting depth exceeded: depth <depth> at prefix <flattened-prefix>. (profundidad máxima de anidamiento de subagregados superada: la profundidad indicada en el prefijo aplanado indicado.)
Cómo corregirlo: reestructura la topología del agregado para reducir el anidamiento. Un anidamiento tan profundo suele indicar que la forma del Aggregate refleja la jerarquía organizativa en lugar de la topología de despliegue — considera aplanar grupos de subagregados en subsistemas del mismo nivel dentro de un único Aggregate padre.
Feature type mismatch between Aggregate and Release (Discrepancia del tipo de Feature entre Aggregate y Release)
El Aggregate y la Release vinculan ambos una funcionalidad con el mismo nombre de instancia, pero cada uno declara un type: distinto, y la vinculación de la Release llega al componente desde los features: de un límite. Donde la Release la escribe en cambio en su propia entrada para el componente, el mismo conflicto se rechaza antes y se informa como E0153, en «A feature attached by both the Aggregate and the Release cannot be merged (Una funcionalidad vinculada tanto por el Aggregate como por la Release no se puede fusionar)» más arriba.
Mensaje emitido:
feature type mismatch between Aggregate and Release (node <node-id>, attachment <instance-name>, existing type <type-in-aggregate> conflicts with <type-in-release>) (discrepancia del tipo de funcionalidad entre Aggregate y Release (el nodo y la vinculación indicados, el tipo existente en el Aggregate entra en conflicto con el tipo en la Release))
Cómo corregirlo: quita el type: de la Release (lo heredará del Aggregate), o cambia uno de los lados para que ambos declaren el mismo tipo. La Release puede omitir type: o repetir el tipo del Aggregate, pero no puede sustituirlo por otro distinto.
Cyclic extends on Components or Features (Extends cíclico en Components o Features)
La cadena extends: de un Component o la cadena extends: de una Feature vuelve sobre sí misma.
Mensaje emitido, con Feature en lugar de Component cuando la cadena que forma el bucle es la de una Feature:
cyclic extends chain (Component <name>, rule extends). <entity> extends <reference>, which is already in the chain; remove the extends on <entity>, or point it at an entity outside the chain (cadena extends cíclica (Component indicado, regla extends). La entidad extiende la referencia, que ya está en la cadena; elimina el extends de la entidad, o haz que apunte a una entidad fuera de la cadena)
Cómo corregirlo: abre la entidad que nombra la arista — que, a lo largo de una cadena de tres o más, no es la entidad nombrada al principio del mensaje — y elimina su extends: o haz que apunte a otro sitio.
A component the composition holds is placed in no boundary (Un componente que contiene la composición no está colocado en ningún límite)
Una Release coloca un componente en un límite de dos maneras, y cualquiera de las dos cuenta. Nombra el componente bajo los components de un límite, direccionado por el id que lleva el componente una vez aplanada la composición entera. O enruta el módulo que aporta el componente hacia un límite bajo aggregates, lo que coloca de una vez cada componente que contiene ese módulo.
Un componente que no llega a ninguna de las dos se renderiza fuera de todo límite que declaró la Release. Su directorio de salida, su sync wave, sus anotaciones y su infra por componente no vienen entonces de ninguna parte — y la compilación, de otro modo, tendría éxito, emitiría los artefactos y no diría nada de que la configuración del operador nunca se le aplicó. Dos componentes separados por esa línea también se renderizan en salidas distintas y pierden el orden que tienen cuando se colocan juntos.
Dos estructuras deliberadamente no caen en ella. Una Release que declara components de nivel superior en lugar de límites con nombre coloca todo lo que nombra: normalizar una Release así le da un límite propio que contiene exactamente esos componentes. Y un componente cuyo módulo entero la Release no colocó en ninguna parte se informa en cambio una sola vez frente al módulo, en la entrada siguiente — un fallo, un remedio, una clave que editar — en lugar de una vez por cada componente cuya propia declaración es correcta.
Mensaje emitido. El valor del final es el id que lleva el componente una vez aplanada la composición, que, para un componente que aportó un módulo, es el nombre de ese módulo, un punto y el nombre propio del componente:
component placed in no boundary: name it under a boundary’s components, or place the sub-module that contributes it under aggregates (Release <name>, at <authored key>, "<component-id>") (componente no colocado en ningún límite: nómbralo entre los componentes de un límite, o coloca el submódulo que lo aporta entre los agregados (con la Release, la clave escrita y el id del componente indicados))
Cómo corregirlo: nombra el componente bajo los components de un límite, usando exactamente el id que cita el mensaje — para un componente que aportó un módulo es el id con prefijo, no el nombre escrito dentro del propio archivo del módulo. O, donde el módulo entero pertenece a un único límite, enrútalo allí bajo aggregates y deja que cada componente que contiene se coloque de una vez.
A sub-module’s components are placed in no boundary (Los componentes de un submódulo no están colocados en ningún límite)
La forma a escala de módulo de la regla anterior: un módulo que la composición incorporó ha aportado componentes, y ningún límite contiene ninguno de ellos. Se informa una sola vez para el módulo en lugar de una vez por componente, porque un módulo no colocado en ninguna parte es un único fallo de autoría con un único remedio en una única clave — e informarlo por componente nombraría componentes cuyas propias declaraciones son perfectamente correctas.
La regla lee la colocación y no la grafía, así que un módulo cuyos componentes se nombran cada uno individualmente bajo los components de un límite está colocado y pasa: rechazarlo por falta de una entrada de enrutamiento rechazaría una forma de autoría que el lenguaje admite. También pasa un módulo colocado solo en parte — cuáles de sus componentes llevan entradas propias es asunto de la regla de componentes, y los que haya dejado fuera se informan allí, cada uno en su propia clave.
Un módulo que no aportó ningún componente no cae en ella: no hay nada que colocar. Tampoco uno que eliminó un interruptor active: en false, que nunca llegó a componerse.
Mensaje emitido, situado en la entrada aggregates que declaró el módulo, bajo el nombre local que escribió el documento importador:
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>") (submódulo no colocado en ningún límite: enrútalo hacia un límite entre los agregados, o nombra allí sus componentes entre los componentes (con la Release, la clave escrita y la ruta del módulo indicadas))
Cómo corregirlo: añade una entrada aggregates para el módulo bajo el límite al que pertenece, lo que coloca cada componente que aporta. O, donde sus componentes pertenecen a límites distintos, nombra cada uno de ellos bajo el límite al que pertenece, usando los id con prefijo que llevan una vez aplanados.
A boundary names a component the composition does not hold (Un límite nombra un componente que la composición no contiene)
La contrapartida por exceso de nombres de las dos reglas anteriores, y una cuestión aparte en lugar de una rama de cualquiera de ellas: aquellas preguntan de un componente si algo lo colocó, esta pregunta de una entrada que escribió la Release si algo le responde. Ninguna implica la otra. Una Release puede nombrar un componente que no existe mientras cada componente que sí existe está bien colocado, y puede dejar sin colocar un componente real mientras cada entrada que escribió se resuelve.
La entrada que no nombra nada no configura nada: su directory, su subDirectory, su syncWave, sus anotaciones y su infra por componente están escritos para un componente que no está, así que nada se renderiza bajo ellos y la compilación, de otro modo, tendría éxito con la configuración del operador silenciosamente inerte.
Un límite nombra un componente de dos maneras, y ambas se comprueban. Bajo components, una entrada direcciona el componente por el id que lleva una vez aplanada la composición — así que un componente que aporta un módulo se escribe con el prefijo de ese módulo delante de su propio nombre. Dentro de una entrada de enrutamiento aggregates, una entrada direcciona el componente por el nombre local que lleva dentro de ese módulo, que se resuelve en el mismo id. El mensaje cita el id que la entrada direccionó, que en el eje enrutado no es el nombre que escribe el archivo: el archivo lleva la mitad local y el módulo aporta el resto.
Un subsistema no aporta nada al id de un componente, así que un componente declarado dentro de un subsistema se direcciona por su nombre a secas. Una entrada escrita como si el subsistema formara parte del id no direcciona nada y cae en esta regla.
Un componente desactivado por un interruptor active: en false no cae en ella. Desactivar un componente es un acto de autoría, y no se espera que la Release que lo configura se reescriba en la misma edición — rechazar la entrada haría inutilizable el interruptor mientras cualquier Release nombrara el componente.
Mensaje emitido:
boundary names a component the composition does not hold: correct the name, or remove the entry (Release <name>, at <authored key>, "<addressed id>") (el límite nombra un componente que la composición no contiene: corrige el nombre, o elimina la entrada (con la Release, la clave escrita y el id direccionado indicados))
Cómo corregirlo: compara el id que cita el mensaje con los componentes que la composición contiene realmente. Un prefijo de módulo que falta y un nombre de subsistema escrito en el id son las dos causas comunes; quita el subsistema, añade el prefijo del módulo o corrige la grafía. Donde la entrada quedó de un componente que desde entonces se eliminó o cambió de nombre, bórrala.
A uses edge targets a component an active: toggle removed (Una arista tiene como destino un componente que un interruptor eliminó)
El hermano de la detención por destino colgante de más arriba, que se informa por separado para que al autor se le diga por qué falta el destino. El destino no está ausente porque nunca se declarara — está declarado, y se eliminó deliberadamente de esta compilación porque su interruptor active: se resolvió en false, llevándose consigo sus aristas. Un componente que sobrevivió todavía depende de él, y dejar que la arista desapareciera dejaría silenciosamente vacíos los valores inyectados de ese consumidor en el momento del despliegue.
Mensaje emitido. Primero va el rechazo, luego el destino que eliminó el interruptor y el socket en el que se cableó la conexión — y después qué hacer al respecto:
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. (el destino de la arista uses se eliminó porque su interruptor active se resolvió en false: el destino indicado, cableado en el socket indicado. Mantén en true el interruptor del destino, o elimina la dependencia de él.)
El hallazgo se sitúa en la entrada escrita a la que se refiere, en las mismas rutas que nombra la detención por destino colgante de más arriba, y se informa de cada conexión infractora en lugar de solo de la primera.
Cómo corregirlo: decide cuál de los dos corresponde a este entorno. Vuelve a activar el destino — donde su interruptor lee un parámetro, eso significa proporcionar el parámetro para esta Release. O somete el consumidor al mismo interruptor, para que los dos salgan juntos y ninguna arista quede apuntando a nada. O, donde el consumidor realmente ya no lo necesita, elimina la arista del bloque uses: del consumidor.
A uses target names a module’s component the module does not export (Un destino de arista nombra un componente de un módulo que el módulo no exporta)
Un módulo publica su interfaz bajo exportedComponents:, y un documento que importa el módulo llega a los componentes del módulo solo a través de esos nombres: el nombre del módulo, un punto y uno de sus alias. Un destino de uses: que llega a un componente dentro de un módulo de cualquier otro modo — por el nombre del componente dentro del módulo, o por una ruta que atraviesa el módulo hasta un módulo anidado en él — detiene la compilación, porque la conexión se enlazaría a algo que el autor del módulo no publicó y que puede renombrar o eliminar libremente. El propio bloque uses: de un componente, el de una vinculación y una conexión cableada por una Release están sujetos a ello por igual. En qué módulos entra una conexión se lee desde donde se encuentra su consumidor, así que una conexión entre dos componentes de un mismo módulo — incluida una Release que los cablea entre sí — no cruza ninguna interfaz y no se rechaza. Un destino que no responde a ningún componente lo informa en cambio la detención por destino colgante, así que un nombre mal escrito se informa una sola vez.
Mensaje emitido. Primero va el rechazo, luego el destino tal como está escrito, el módulo en el que entra y los alias que exporta ese módulo, y el socket — y después qué hacer al respecto:
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. (el destino de la arista uses nombra un componente que su módulo no exporta: el destino, el módulo, los alias que exporta y el socket en el que está cableado, indicados. Nombra el componente mediante uno de los alias exportados del módulo, o inclúyelo entre los componentes exportados del módulo.)
Un módulo que no exporta nada se nombra como exportando "nothing". El hallazgo se sitúa en la entrada escrita del documento que trazó la conexión.
Cómo corregirlo: nombra el componente a través de un alias que el módulo exporte — finance-db-subsystem.primary_db en lugar de finance-db-subsystem.internal-pg-primary — o, donde eres el autor del módulo y quieres publicar el componente, inclúyelo bajo los exportedComponents del módulo, con su propio nombre si ese es el nombre que deben usar los importadores.
An active: toggle does not resolve to true or false (Un interruptor no se resuelve en true ni en false)
Un interruptor active: llega al constructor del grafo ya resuelto en un literal — un booleano escrito directamente, o una referencia a un parámetro en la que se sustituyeron los valores de la Release antes de leer el documento. Después se lee de forma estricta: un literal que no es un booleano detiene la compilación en lugar de recurrir a un valor predeterminado cualquiera. La regla es la misma para el interruptor de un componente y para el de un módulo.
Un literal vacío es el caso que merece nombrarse, porque es lo que produce un parámetro no satisfecho. Un interruptor que lee {{ .parameters.<key> }} no se resuelve en nada mientras ese parámetro no tenga valor, y leer ese nada como «presente» desplegaría precisamente la entidad que el autor condicionó al parámetro. Solo un interruptor que nadie escribió vale por defecto como presente, y eso se lee de la ausencia del interruptor y no de su valor — por eso escribir active: sin nada detrás no es lo mismo que omitir la clave.
Mensaje emitido:
active toggle did not resolve to a boolean (node "<node>", active resolved to "<value>") (el interruptor active no se resolvió en un booleano (el nodo indicado, con active resuelto en el valor indicado))
y, donde no se resolvió en nada en absoluto, con la recomendación que nombra la causa habitual:
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 (el interruptor active no se resolvió en un booleano (el nodo indicado, con active resuelto en una cadena vacía). un interruptor que lee un parámetro no se resuelve en nada hasta que ese parámetro se satisface)
Cómo corregirlo: escribe true o false. Donde el interruptor lee un parámetro, proporciona ese parámetro en la Release, o dale un default: donde se declara en el Aggregate, para que cada entorno tenga una respuesta. Para que una entidad esté presente de forma incondicional, elimina la clave active: en lugar de dejarla vacía.
A module a composition imports cannot be loaded, or imports itself (Un módulo importado por una composición no se puede cargar, o se importa a sí mismo)
Un Aggregate compone otros Aggregates nombrándolos bajo aggregates:, y cada uno se carga y se recorre a su vez para que sus componentes se incorporen al grafo. Dos cosas detienen aquí ese recorrido.
El módulo no se puede cargar en absoluto — la referencia no se resuelve en nada que el catálogo pueda devolver, o el documento que hay detrás no se puede leer. El motivo que dio el cargador se lleva debajo de la detención en lugar de incorporarse a ella, así que lo que falló se informa con las propias palabras del cargador.
O el módulo nombra un tipo que ya está en la cadena que se recorre. Expandirlo reproduciría la cadena que lo contiene, sin fin. Se informa en el punto en que la referencia cierra el bucle, nombrando tanto el tipo como el lugar de la composición en el que se encuentra.
Mensaje emitido, para una referencia circular:
sub-aggregate load failed (circular sub-aggregate reference "<module-type>", at "<path in the composition>") (falló la carga del subagregado (referencia circular de subagregado, con el tipo de módulo y la ruta en la composición indicados))
y para un fallo de carga, donde la detención se lee como la frase sola, situada en la ruta del módulo, con el propio motivo del cargador debajo:
sub-aggregate load failed (falló la carga del subagregado)
Cómo corregirlo: para un fallo de carga, lee el motivo que hay debajo de la detención — un nombre o una versión a los que el catálogo no sabe responder es el caso común, y la corrección va en la entrada aggregates: que lo nombra. Para una referencia circular, rompe el bucle: la ruta del mensaje es donde se cierra la cadena, y uno de los módulos que la forman tiene que dejar de importar el que lo importa. Donde dos módulos necesitan realmente cada uno los componentes del otro, la parte compartida corresponde a un tercer módulo que importen ambos.
Two instances flatten to one identifier (Dos instancias se aplanan en un único identificador)
Componer un Aggregate aplana cada componente en un único conjunto, y un componente que aportó un módulo lleva el nombre de ese módulo, un punto y su propio nombre. El conjunto se niega a contener dos entradas bajo un mismo identificador: la segunda sustituiría a la primera, y uno de los dos componentes desaparecería de la salida sin que se dijera nada al respecto.
Esta detención es la que se produce al fusionar los componentes de un módulo, y la superficie de autoría no ofrece los nombres que la producirían. Cada componente que aporta un módulo lleva el nombre de ese módulo delante del suyo; un nombre de instancia se escribe con letras, dígitos, - y _, así que no puede llevar el punto con el que se unen los dos, y dos identificadores construidos a partir de nombres de módulo distintos no pueden coincidir. Dos módulos importados bajo un mismo nombre son una única clave duplicada, y el documento se rechaza al cargarse. Así que esto sirve de red de seguridad para una composición ensamblada por algo distinto de la vía de autoría ordinaria, y encontrarse con una merece informarse en lugar de sortearse.
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>") (colisión de ID de nodos aplanados: cambia el nombre de una de las instancias en colisión para que sus ID aplanados sean distintos (el identificador y la ruta en la composición indicados, en colisión con la entrada existente procedente del otro contribuidor indicado))
Cómo corregirlo: cambia el nombre de una de las dos instancias que nombra el mensaje, en el documento que la declara y en cada entrada de Release que la direcciona.
Two subsystems declare a component under one name (Dos subsistemas declaran un componente con un mismo nombre)
Los subsistemas agrupan los componentes de un Aggregate para el lector y para lo que se propaga en cascada hacia ellos; no califican el nombre al que responde un componente. Un componente declarado bajo subsystems.frontend se direcciona como api, no como frontend.api, y uno que aportó un módulo lleva el nombre de ese módulo y no el del subsistema. Así que dos subsistemas de un mismo Aggregate pueden declarar cada uno un componente llamado api, y los dos responden entonces al mismo identificador.
El documento está bien formado — los dos son claves separadas en bloques separados, que es exactamente por lo que nada lo rechaza antes — pero solo un componente puede llevar un identificador. La compilación se detiene en lugar de quedarse con el que se leyó en último lugar y renderizar como si se hubiera declarado un único componente.
El mismo nombre dos veces dentro de un mismo subsistema es un fallo distinto: son dos entradas bajo una misma clave, y el documento se rechaza al leerse.
Mensaje emitido:
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>") (componentes de subsistemas distintos toman la misma identidad: cambia el nombre de uno de ellos, ya que un subsistema no aporta nada a la identidad de un componente (con el Aggregate, la ruta y el identificador indicados, declarado bajo los subsistemas indicados))
Cómo corregirlo: cambia el nombre de uno de los dos componentes, en el documento que lo declara y en cada entrada de Release que lo direcciona. Donde los dos son realmente el mismo componente que se quiere en dos lugares, decláralo una sola vez y haz que el otro subsistema dependa de él. Cambiar el nombre del subsistema no ayuda: el subsistema no forma parte del nombre.
A re-published component alias points back at itself (Un alias de componente republicado apunta a sí mismo)
Un módulo publica parte de sí mismo exportando componentes bajo alias, y un Aggregate que lo importa puede republicar uno de esos alias bajo un nombre propio. Resolver un alias así sigue la cadena de republicaciones hasta el componente que en última instancia nombra, de modo que una arista que apunta al nombre público llega a un componente real.
Una cadena que vuelve a pasar por un alias antes de llegar a un componente nunca termina de llegar. El recorrido se detiene en lugar de seguirla indefinidamente, y nombra la cadena que recorrió para que el eslabón que cierra el bucle sea visible.
Nada de lo que puedes escribir produce una cadena así. El árbol de importaciones es acíclico, y cada eslabón nombra algo anidado más profundamente que el eslabón anterior, así que una cadena ensamblada a partir de importaciones desciende y termina. Por tanto, esto sirve de red de seguridad para una tabla de alias ensamblada por algo distinto de la vía de autoría ordinaria, y no para una estructura que un Aggregate pueda declarar.
Mensaje emitido:
re-exported component alias forms a cycle (alias chain <first> -> <second> -> <first>) (el alias de componente reexportado forma un ciclo (con la cadena de alias indicada))
Cómo corregirlo: nada en tus archivos lo produce, y no hay ningún cambio de autoría que lo elimine. Infórmalo con el comando que ejecutaste y la cadena de alias que nombra el mensaje, que es el detalle que indica dónde se cerró el bucle.
An Aggregate reached graph building without being normalised (Un Aggregate llegó a la construcción del grafo sin haber sido normalizado)
Un Aggregate escrito con componentes en su nivel superior y uno escrito con subsistemas con nombre adoptan la misma forma al leerse: los componentes de nivel superior se integran en un subsistema que proporciona el compilador, y el nivel superior se vacía. Esa integración es lo que permite que todo lo que viene después haga una sola pregunta a una sola forma.
Un Aggregate que llega a la construcción del grafo con ambos poblados no lo produjo esa lectura. Las dos formas se excluyen mutuamente donde se escriben — un documento que declara ambas se rechaza al cargarse — y la integración es lo que las convierte después en una sola forma, así que nada que pueda escribir un autor llega hasta aquí. Sirve de red de seguridad para un Aggregate ensamblado por algo distinto de la vía de carga ordinaria, y encontrarse con una merece informarse en lugar de sortearse.
Su mensaje empieza así:
aggregate reached topology un-normalized (non-empty root components alongside a synthesized default subsystem) (el agregado llegó a la topología sin normalizar (componentes raíz no vacíos junto a un subsistema predeterminado sintetizado))
y continúa con la ruta de construcción que espera el compilador, que es una nota para quien esté depurando la compilación y no una instrucción de autoría.
Cómo corregirlo: nada en tus archivos lo produce, y no hay ningún cambio de autoría que lo elimine. Infórmalo con el comando que ejecutaste.
A label-transform plugin’s patch reaches outside node labels (El parche de un plugin label-transform llega fuera de las etiquetas de los nodos)
Un plugin de gobernanza vinculado en un rol label-transform recibe una proyección del grafo — una entrada por nodo, con las etiquetas de ese nodo y los valores que declara su instancia, retenido cualquier valor que su Component declare sensible — y devuelve parches sobre las etiquetas de los nodos. El host los aplica solo a las etiquetas y luego comprueba que lo que volvió sigue siendo esa vista de las etiquetas: los mismos nodos, cada uno solo con etiquetas, cada valor de etiqueta una cadena.
Cualquier otra cosa se rechaza y la compilación se detiene. Añadir o quitar un nodo, o cambiar un campo de un nodo distinto de sus etiquetas, es precisamente la aparición silenciosa de infraestructura que nadie declaró — así que, en lugar de absorber un cambio que el rol no cubre, la compilación dice qué regla de confinamiento infringió el parche. Las etiquetas son toda la superficie del rol, y un operador que vinculó el plugin declaró eso y nada más.
Mensajes emitidos. El parche se rechazó antes de aplicarse:
mutator patch rejected: patch <n> does not decode as a JSON Patch document: <what the reader could not do> (parche del mutador rechazado: el parche indicado no se decodifica como un documento JSON Patch: lo que el lector no pudo hacer) mutator patch rejected: patch <n> does not apply to the node-label surface: <what the patch engine refused> (parche del mutador rechazado: el parche indicado no se aplica a la superficie de etiquetas de nodos: lo que rechazó el motor de parches)
o el resultado de aplicarlo no era la vista que había entregado el host:
mutator patch rejected: mutated node set changed size (a mutator may not add or remove nodes) (parche del mutador rechazado: el conjunto de nodos mutado cambió de tamaño (un mutador no puede añadir ni quitar nodos)) mutator patch rejected: mutated node set introduced node "<node>" (a mutator may not add nodes) (parche del mutador rechazado: el conjunto de nodos mutado introdujo el nodo indicado (un mutador no puede añadir nodos)) mutator patch rejected: node "<node>" gained a field outside "labels" (a mutator may only touch labels) (parche del mutador rechazado: el nodo indicado ganó un campo fuera de las etiquetas (un mutador solo puede tocar etiquetas)) mutator patch rejected: node "<node>" lost its "labels" field (parche del mutador rechazado: el nodo indicado perdió su campo de etiquetas) mutator patch rejected: node "<node>" carries a non-string label value after patching: <what the reader found> (parche del mutador rechazado: el nodo indicado lleva un valor de etiqueta que no es una cadena después de aplicar el parche: lo que encontró el lector)
Cómo corregirlo: el fallo es del plugin y no de tus documentos. Corrígelo para que cada operación que devuelve se dirija a una entrada bajo las labels de algún nodo y establezca solo valores de cadena — un valor de etiqueta numérico o booleano es el caso común, ya que la superficie solo acepta cadenas. Quitar la vinculación de plugins.governance es la forma inmediata de desbloquear una compilación mientras se corrige el plugin.
Omisión intencionada: no se exige que la topología sea acíclica
Aggrega permite ciclos en la topología: no exige que el grafo de dependencias sea un grafo acíclico dirigido. Las arquitecturas de agente a agente, los patrones de callback y los pares de autenticación mutua producen todos aristas cíclicas, y el compilador las acepta. El orden en el momento del despliegue es asunto del renderizador (mediante un syncWave por límite o un equivalente), no del grafo IR.
Al comprobar los contratos de inject
El compilador recorre cada bloque inject: — tanto self-inject (un Component que inyecta en sí mismo) como uses-inject (cableado de un Component a otro) — y valida el contrato de entrega frente al esquema provides: del Component de destino, la partición de etiquetas de la Feature y el conjunto de claves de entrega declaradas. Una clave from: en un bloque que escribió el propio componente del Aggregate se comprueba en cuanto se resuelve el catálogo, así que falla frente a la línea que escribiste; una en el bloque de un componente que aporta un módulo se comprueba una vez construida la composición que importa el módulo, y falla frente a la línea del propio documento del módulo; una clave from: en una conexión que aporta una Feature vinculada se comprueba una vez que cada superficie que puede trazar una conexión ha hecho su aportación, que es el primer momento en que existe una conexión así que comprobar.
Inject from key is not in the target’s provides (La clave de inject no figura entre lo que proporciona el destino)
Una entrada inject: hace referencia a una clave from: que la fuente de la que lee no publica: el esquema provides: del Component de destino para el propio bloque de un componente o para una conexión, y la FeatureRecipe de la Feature vinculada para el propio bloque inject: de una Feature vinculada.
La comprobación se aplica dondequiera que se haya escrito la conexión. Una conexión uses: llega a la topología construida desde más de una superficie de autoría — el propio bloque uses: de un Component y el bloque uses: de una Feature vinculada a él, ya esté esa vinculación escrita en el componente, en un subsistema, en un límite de la Release o en la entrada de componente de un límite de la Release — y la misma clave mal escrita se rechaza en cada una de ellas. El diagnóstico apunta al bloque cuyo autor la escribió: la propia entrada uses: de una vinculación, en el lugar donde se declaró la propia vinculación, y no el bloque uses: del componente consumidor, que para una conexión aportada no contiene nada en absoluto.
Frente a qué se resuelve la referencia depende de dónde esté. Un from: de self-inject a nivel de Component se resuelve frente al propio provides: de ese mismo Component. Un from: en una conexión uses: se resuelve frente al provides: del componente al que apunta esa conexión — y donde dos superficies escriben un mismo socket y un mismo alias, cada conexión se resuelve frente al destino que ella misma nombra, en la misma compilación que rechaza el par por compartir un alias. Un Component que no declara ningún provides: rechaza toda referencia from: dirigida a él.
El propio bloque inject: de una Feature vinculada. Allí, un from: se resuelve con respecto a las claves que la FeatureRecipe de la Feature publica en su provides:, tal como se evalúan para el componente al que está vinculada la Feature, y se comprueba cuando ese componente se renderiza. Una clave que la FeatureRecipe no publica no pondría nada en el entorno, el archivo o el argumento del componente, así que en su lugar la compilación se detiene — a menos que la FeatureRecipe lea ella misma las entradas de la Feature vinculada, en .inject, en una plantilla que evalúa con respecto al propio contexto de renderizado de la Feature vinculada — el que lleva .inject: su mapeo de valores, su carga de trabajo, sus artefactos, sus omisiones o el with: o el when: de un paso del pipeline, escritos en línea o importados. Sus locals:, provides:, source: y assertions: no llevan .inject, y su injectMapping: se evalúa con respecto al contexto del componente, así que una lectura en cualquiera de ellos no cuenta. Una FeatureRecipe así recibe cada entrada tal como está escrita y la entrega a su manera, así que sus entradas no se rechazan, y una clave que no publica no entrega nada a través de la entrega propia del componente y queda a disposición de la FeatureRecipe. Si una FeatureRecipe lee .inject se decide a partir de las rutas que nombran sus plantillas: una plantilla que transmite todo su contexto (toJson .) o que llega a las entradas mediante una función como index . "inject" no cuenta como lectura de las entradas, y sus entradas que nombran una clave no publicada se rechazan. Una Feature vinculada en un límite cuya FeatureRecipe se renderiza una vez para ese límite se comprueba con respecto a esa única evaluación; donde ningún límite que contiene el componente ha producido una, no hay nada con respecto a lo cual comprobar sus claves y no se rechazan. Un from: que nombra una clave publicada entrega como antes. El hallazgo se sitúa en la propia entrada de la Feature vinculada, en el documento que la escribió — .spec.components.<component>.features.<attachment> en el Aggregate, por ejemplo — y una entrada cuya clave de entrega ya tiene además otra fuente de inject se notifica también en «An attachment delivers a key another inject source already claimed (Una vinculación entrega una clave que otra fuente de inject ya reclamó)», ya que cada una necesita su propia corrección.
En el propio bloque inject: de un componente, una entrada value: lleva un literal y no se resuelve frente a nada, así que un literal que por casualidad parece una clave provides no se rechaza ahí; en una conexión, una entrada value: se rechaza, como describe «An inject: entry on a connection carries a literal (Una entrada de inject en una conexión lleva un literal)» más abajo. Solo from: nombra una clave.
La propia superficie uses: por arista de la Release lleva target e infra y ningún inject:, así que una conexión cableada ahí no dicta ninguna entrega y no tiene ninguna clave from: que comprobar.
Mensaje emitido, para un from: leído en el propio bloque inject: de un Component. Primero va el rechazo, luego la clave errónea, el tipo de componente frente al que se resolvió y las claves declaradas de ese tipo, ordenadas — las alternativas entre las que elegir:
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>") (clave inject no válida: la from-key debe nombrar una clave provides que publique su fuente (con el Aggregate, la ruta, la from-key, el tipo de componente y las claves declaradas indicados))
Para un from: leído en una conexión uses:, el mismo rechazo va primero, y el mecanismo y la clave de entrega bajo los que se escribió la entrada van antes de la clave errónea:
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>") (clave inject no válida: la from-key debe nombrar una clave provides que publique su fuente (con el Aggregate y la conexión indicados, el mecanismo, la clave de entrega, la from-key, el tipo de componente y la clave declarada))
Para un from: leído en el propio bloque inject: de una Feature vinculada, la clave errónea va primero, luego el in: y el mecanismo de la entrada, la FeatureRecipe con respecto a la cual se resolvió y, ordenadas, todas las claves que publica esa FeatureRecipe:
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>") (clave inject no válida: la from-key debe nombrar una clave provides que publique su fuente (con el Aggregate, la ruta, la from-key, el in, el mecanismo, la FeatureRecipe y las claves publicadas indicados))
Cuando el destino no declara ninguna clave provides: no hay alternativas que enumerar, así que el mensaje termina después del tipo de componente — o, en el bloque de una Feature vinculada, después de la FeatureRecipe.
Cómo corregirlo: cambia la clave from: para que coincida con una de las claves declaradas que enumera el mensaje, o amplía el esquema provides: del Component de destino para declarar la clave que necesitas. En el bloque de una Feature vinculada, cambia la clave from: por una que publique la FeatureRecipe, o — si la FeatureRecipe es tuya — publica la clave en su provides:, o haz que lea ella misma la entrada en .inject si entrega el valor a su manera.
Required feature not attached (Funcionalidad obligatoria no vinculada)
El Component declara un mandato de presencia — una anotación features.aggrega.ai/requiredType.<label> — que nombra un tipo de Feature que no está presente entre las vinculaciones con las que termina esta instancia de componente, contando cada nivel: los bloques de nivel de componente y de nivel de subsistema del Aggregate, los bloques de nivel de límite y de nivel de componente de la Release, y la expansión dirigida por anotaciones.
Mensaje emitido:
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>) (falta una funcionalidad obligatoria: vincula al componente una Feature del tipo requerido (el tipo requerido indicado, exigido por el tipo de componente indicado, bajo la etiqueta de requisito indicada))
Los tres valores son el tipo de Feature que exige el mandato — que la frase anterior ya nombra, así que aparece sin rótulo —, luego el tipo de componente que declara el mandato y la etiqueta que lleva el mandato, cada uno con su rótulo para que un lector pueda distinguir dos referencias a entidades. Un componente que exige dos tipos distintos produce dos mensajes que difieren, y a dos componentes que declaran el mandato desde tipos distintos se les dice qué tipo hizo cada exigencia. El hallazgo se sitúa en la propia clave del componente bajo components:, y un componente escrito dentro de un subsistema se sitúa primero bajo la clave de ese subsistema.
El nombre bajo el que se escribe una vinculación no importa aquí: el mandato pregunta si hay presente alguna vinculación del tipo nombrado. Enlazar un slot lo satisface, y también lo hace una vinculación bajo cualquier otro nombre.
Cómo corregirlo: vincula una Feature del tipo requerido al componente en el Aggregate o en la Release, o en un nivel más amplio del que herede el componente. Si el Component ya no debe exigirla, elimina la anotación del mandato de su declaración de catálogo.
Malformed attachment requirement (Requisito de vinculación mal formado)
La declaración de un mandato de presencia no se puede evaluar. El valor de una anotación es una cadena opaca, así que nada valida su forma antes de que el compilador la lea: un valor que no es un URI de tipo de Feature, o una clave que nombra la familia de mandatos sin una etiqueta después del prefijo, se informa como una declaración defectuosa y no como un requisito no satisfecho — una errata nunca debe leerse como un requisito satisfecho.
Mensajes emitidos:
malformed attachment requirement (<key>, declared by component type <component-type>, which cannot be evaluated because the value must be a Feature type URI of the form <publisher>/<name> in lower-case kebab segments, as in core/prometheus-exporter). Correct that annotation on the component type’s catalog entity. (requisito de vinculación mal formado (la clave indicada, declarada por el tipo de componente indicado, que no se puede evaluar porque el valor debe ser un URI de tipo de Feature con la forma editor/nombre en segmentos kebab en minúsculas, como en el ejemplo indicado). Corrige esa anotación en la entidad de catálogo del tipo de componente.)
malformed attachment requirement (<key>, declared by component type <component-type>, which cannot be evaluated because the key needs a label naming the requirement, as in features.aggrega.ai/requiredType.database). Correct that annotation on the component type’s catalog entity. (requisito de vinculación mal formado (la clave indicada, declarada por el tipo de componente indicado, que no se puede evaluar porque la clave necesita una etiqueta que nombre el requisito, como en el ejemplo indicado). Corrige esa anotación en la entidad de catálogo del tipo de componente.)
El mensaje empieza por la clave de la anotación — la declaración de la que trata la detención — y después nombra el tipo de componente cuya declaración es defectuosa, de modo que nombra la entidad que hay que corregir aunque el hallazgo se sitúe en la instancia de componente que usa ese tipo: la instancia es donde lo ves, y la entidad de catálogo es donde está el remedio.
Esta detención se genera en cuanto se ensambla la composición, lo que ocurre antes que cualquier comprobación que lea el grafo terminado. Por eso, una compilación con un mandato defectuoso lo informa por sí solo: las comprobaciones que se ejecutarían después no se alcanzan, porque razonan sobre lo que dice la declaración y la declaración no se puede leer. Corrígelo y vuelve a compilar para ver el resto.
Cómo corregirlo: corrige la entidad de catálogo del Component. El remedio está en el catálogo, no en el Aggregate — por eso esta detención es distinta de «Required feature not attached (Funcionalidad obligatoria no vinculada)», donde lo que hay que cambiar son tus propios documentos.
Required attachment slot not bound (Slot de vinculación obligatorio sin enlazar)
Una entidad de catálogo declara un slot de vinculación con required: true en su featuresSchema, y nada enlaza el nombre de ese slot en una instancia de la entidad. La comprobación se ejecuta sobre las vinculaciones con las que termina la instancia después de combinar todos los niveles — los bloques features: de nivel de componente y de nivel de subsistema del Aggregate, los bloques de nivel de límite y de nivel de componente de la Release, y las vinculaciones producidas por la expansión dirigida por anotaciones —, así que una credencial vinculada una vez en un nivel del que hereda la instancia enlaza el slot exactamente igual que un llenado escrito en la instancia.
Mensaje emitido:
required attachment slot unfilled (<slot>, declared required by component type <component-type>). Attach a Feature at that name, in the Aggregate or in the Release, on the component or at a scope above it. (slot de vinculación obligatorio sin llenar (el slot indicado, declarado obligatorio por el tipo de componente indicado). Vincula una Feature con ese nombre, en el Aggregate o en la Release, en el componente o en un nivel superior.)
Los dos valores son el propio nombre del slot y el tipo de componente que lo declara, así que una instancia que deja dos slots sin enlazar produce dos mensajes que difieren. El hallazgo se sitúa en la clave del slot bajo el bloque features: del componente en el Aggregate; como esa clave es exactamente lo que falta, un editor lo coloca en la clave existente más cercana — el bloque features: donde el componente escribe uno, y el propio componente donde no. Nada escribió la vinculación que falta, así que no se señala a ningún autor de documento: el hallazgo queda en el componente y se clasifica como fallo del desarrollador, y el remedio nombra ambos documentos, porque cualquiera de los dos puede llenar el slot — el Aggregate en el componente o en un subsistema que lo contiene, la Release en su entrada para el componente o en un límite que lo contiene.
Un slot que declara un socket — en el featuresSchema de una entrada de usesSchema — se exige a cada conexión cableada a través del socket y no al componente: cada conexión lo llena por sí misma, en su propia entrada en el Aggregate o en la Release, y ningún nivel superior lo alcanza. Así, un socket con dos conexiones, una de las cuales llena el slot, informa solo de la otra, nombrándola:
required attachment slot unfilled ("<slot>", declared required by socket "<socket>", of component type "<component-type>", left unfilled by the connection "<alias>"). Attach a Feature under that slot in this connection’s features, on its entry in the Aggregate or in the Release. (slot de vinculación obligatorio sin llenar (el slot indicado, declarado obligatorio por el socket indicado, del tipo de componente indicado, que la conexión indicada dejó sin llenar). Vincula una Feature bajo ese slot en las funcionalidades de esta conexión, en su entrada en el Aggregate o en la Release.)
Ese hallazgo se sitúa en la entrada de la conexión en el documento que trazó la conexión — la entrada uses: del Aggregate, o la entrada por arista de la Release para una conexión que cableó la Release. Una conexión que traza una Feature vinculada se cablea en un socket que declara la Feature, no en uno del componente, así que no le corresponde llenar los slots de los sockets del componente.
Cómo corregirlo: vincula una Feature bajo el nombre del slot, en el Aggregate o en la Release — en el componente, o en un nivel más amplio que compartan todos los consumidores del slot; para el slot de un socket, en la conexión que nombra el hallazgo. Una vinculación bajo un nombre distinto no enlaza el slot: un slot es un punto de enlace con nombre, así que el nombre es el enlace. Si el slot ya no debe ser obligatorio, actualiza el featuresSchema de la entidad de catálogo — el del propio componente o el del socket — para quitar la declaración required.
Two Features declared to conflict reach one component (Dos Features declaradas en conflicto llegan a un mismo componente)
El campo interoperability.conflictsWith de una Feature nombra las Features junto a las que no se puede vincular, y un componente termina llevando la Feature y una de las que nombra. La comprobación se ejecuta sobre las vinculaciones con las que termina el componente después de combinar todos los niveles — los bloques features: de nivel de componente y de nivel de subsistema del Aggregate, los bloques de nivel de límite de la Release (cada límite dentro del que está el componente, incluidos los anidados) y sus entradas de nivel de componente, y las vinculaciones producidas por la expansión dirigida por anotaciones. Así, un par provoca la detención cuando ambas están escritas en el componente, cuando una está en un límite o un subsistema que lo contiene, o cuando una está en un límite exterior y la otra en un límite anidado dentro de él. Dos Features vinculadas a límites hermanos que no comparten ningún componente nunca se encuentran, y un límite que no contiene ningún componente no alcanza nada, así que ninguno de esos casos provoca la detención.
Basta con una declaración: la detención se activa cuando la lista de una u otra Feature nombra a la otra. Los nombres se comparan sin ninguna versión, en ambos lados, así que una entrada coincide con cada versión de la Feature que nombra. El compilador compara los nombres que declaró el autor de la Feature con las Features que lleva el componente y no interpreta nada más en ninguno de los dos.
Mensaje emitido:
a Feature reaches a component alongside a Feature it declares a conflict with ("<feature>", attached in the Release on boundary "<boundary-path>", conflicts with "<other-feature>", attached in the Aggregate on component "<component>", on component "<component>"). Attach only one of the two where they meet: remove one attachment, or move it to a scope that does not hold this component. (una Feature llega a un componente junto a una Feature con la que declara un conflicto (la Feature indicada, vinculada en la Release en el límite indicado, entra en conflicto con la otra Feature indicada, vinculada en el Aggregate en el componente indicado, en el componente indicado). Vincula solo una de las dos donde se encuentran: elimina una vinculación, o muévela a un nivel que no contenga este componente.)
El primer valor es la Feature cuya lista nombra a la otra — la que nombra la frase anterior — seguida de cada lugar en el que se vinculó; luego la Feature con la que entra en conflicto, y cada lugar en el que se vinculó esa; y por último el componente donde se encuentran. Cada lugar se expresa con las palabras del documento que abrirías para cambiarlo: attached in the Aggregate on component, attached in the Aggregate on subsystem, attached in the Release on boundary (la ruta de un límite anidado une sus niveles con /), attached in the Release on the entry for component seguido de in boundary, o attached by annotation-driven expansion of seguido de la anotación, y de declared at con el lugar donde se escribió. Una vinculación escrita en una conexión se expresa como la entrada de esa conexión, ya que es esa entrada, y no el propio bloque del componente, donde se edita: attached in the Aggregate on the connection seguido de through socket y of component, o attached in the Release on the connection seguido de through socket, of the entry for component e in boundary. Una Feature vinculada en dos lugares enumera ambos. El hallazgo se sitúa en la propia clave del componente bajo components:, y un par que se encuentra en varios componentes se informa una vez por cada uno de ellos, en el orden en que el Aggregate declara los componentes.
Cómo corregirlo: vincula solo una de las dos donde se encuentran — elimina una de las vinculaciones, o mueve una a un nivel que no contenga este componente, como un límite hermano. Donde la vinculación procede de la expansión dirigida por anotaciones, lo que hay que cambiar es la anotación, no el bloque sobre el que se expandió. Si en realidad las dos Features pueden combinarse, lo que está mal es la declaración: elimina la otra Feature de la lista conflictsWith en la entidad de catálogo de la Feature que la declara.
Attachment does not conform to its declared slot shape (La vinculación no se ajusta a la forma declarada de su slot)
Una vinculación enlaza un slot declarado pero no coincide con la forma que ese slot declara. El caso habitual es la entrega: la lista de permitidos inject de un slot nombra los mecanismos a través de los que un llenado puede entregar su material, y una lista de permitidos vacía es blackbox — la Recipe entrega el material internamente y un llenado no puede dictar ninguna entrega. Un bloque inject: {} vacío no dicta ninguna entrega, así que se ajusta a la forma de cualquier slot, incluido uno con la lista de permitidos vacía, y recibe el mismo veredicto dondequiera que esté escrita la vinculación: en un componente que declara el Aggregate, en un componente que aporta un módulo importado o en un ámbito más amplio. Una vinculación bajo un nombre que ningún slot declara es una vinculación libre y no lleva ninguna restricción de slot.
Mensaje emitido, cuando la vinculación dicta una entrega que su slot no acepta — el slot, luego el mecanismo, luego cada mecanismo que acepta la lista de permitidos inject del slot, en el orden en que el slot los declara (con una lista de permitidos vacía no sigue ninguno):
attachment does not conform to its declared slot shape (Aggregate <name>, at .spec.components.<component>.features.<attachment>, "<slot>", "<mechanism>", "<permitted-mechanism>") (la vinculación no se ajusta a la forma declarada de su slot (con el Aggregate, la ruta, el slot, el mecanismo y el mecanismo permitido indicados))
Un componente que aporta un módulo importado se comprueba una vez construida la composición que lo importa, y se informa con una segunda forma. Esta nombra el Aggregate del módulo y la clave, dentro del documento del módulo, que el slot no declara — un mecanismo bajo el bloque inject: de la vinculación, o el propio bloque inject: cuando nombra algún mecanismo en un slot cuya lista de permitidos está vacía:
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>) (la vinculación no se ajusta a la forma declarada de su slot (con el Aggregate y la ruta indicados, la vinculación no se ajusta a la forma de slot declarada: esta clave no forma parte de la declaración del slot — el remedio indicado))
donde <remedy> depende de la clave:
remove it, para un bloque inject: que nombra un mecanismo en un slot cuya lista de permitidos está vacía;
remove it, or add it to the slot's inject allowlist in the entity's featuresSchema, para un mecanismo que la lista de permitidos de un slot puede nombrar — env, file o arg;
remove it: a slot's inject allowlist in the entity's featuresSchema accepts only env, file and arg, para cualquier otro mecanismo, que ningún slot puede declarar.
Una vinculación declarada en un nivel más amplio — en todo un subsistema, en cascada sobre cada componente que hay debajo — está sujeta a la misma forma, y se comprueba frente al slot en cada componente al que llega. Por eso la misma vinculación puede ajustarse a la forma para un componente y no para otro, así que esta forma nombra el componente y el slot frente al que falló, y sitúa la vinculación en el nivel donde se declaró y no en una clave dentro de su bloque de entrega:
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) (la vinculación no se ajusta a la forma declarada de su slot (con el Aggregate y la ruta indicados, esta vinculación está declarada en un nivel que llega al componente indicado, cuyo slot de vinculación indicado no acepta la entrega que lleva: baja la vinculación a los componentes que pueden recibirla))
Una vinculación que lleva una conexión nunca llega a esta detención. Su forma está cerrada donde se escribe: en la entrada de conexión del Aggregate admite type, description y values, y en la de la Release type, description e infra, así que no puede dictar ninguna entrega — un inject: escrito ahí se rechaza cuando se carga el documento, nombrando la clave — y la entrada del Workload que la entrega está sujeta, en cambio, a la lista de permitidos inject del slot del socket. Tampoco ningún nivel llega al slot de un socket, así que la forma para todo un nivel descrita arriba no tiene equivalente en una conexión.
Cómo corregirlo: las formas piden dos cambios distintos, y la ruta del campo te dice cuál tienes. Donde nombra una vinculación en un componente, o una clave dentro de ella, el fallo está en la entrega: elimínala, o mueve sus entradas bajo un mecanismo que nombre la lista de permitidos inject del slot. Donde el material de verdad debe llegar a la carga de trabajo a través de un mecanismo que el slot no enumera, se puede ampliar la lista de permitidos en el featuresSchema de la entidad de catálogo — pero solo con env, file o arg, los mecanismos que un slot puede declarar; un Component que nombre ahí cualquier otro mecanismo no supera la validación cuando se carga, así que para cualquier otro mecanismo eliminarlo es la única corrección. Donde nombra una vinculación en un nivel, la vinculación está bien formada y el fallo está en su ubicación: bájala a los componentes cuyo slot acepta la entrega, dejando fuera de su alcance los componentes que reservan la entrega a su Recipe.
Duplicate delivery key across inject sources (Clave de entrega duplicada entre las fuentes de inject)
La misma clave de entrega (por ejemplo, el mismo nombre de variable de entorno) se reclama dos veces entre las fuentes de inject escritas por el desarrollador para un componente — a nivel de Component y bajo una entrada uses[], por dos entradas uses[] en el mismo componente, o bajo dos mecanismos de entrega del propio bloque inject: del Component. La entrega no puede venir de dos lugares a la vez, así que una clave reclamada dos veces es una contradicción y no una cuestión de cuál gana.
La compilación lee esto en cuatro lugares, porque ven conjuntos distintos de fuentes escritas y de conexiones de dependencia y les hacen preguntas distintas, y cada uno informa con su propia forma.
El primero lee las conexiones que escribiste en el Aggregate, e informa mientras se resuelven tus archivos. Nombra el mecanismo de entrega, la clave, y luego el socket y el alias de la primera conexión, en el orden de escritura, que también la reclama:
duplicate delivery key across inject sources (Aggregate <name>, at .spec.components.<component>.inject.<mechanism>.<key>, "<mechanism>", "<key>", "<socket>", "<alias>") (clave de entrega duplicada entre las fuentes de inject (con el Aggregate, la ruta, el mecanismo, la clave, el socket y el alias indicados))
El segundo lee ese mismo bloque escrito y le hace una pregunta distinta: si el componente reclama una clave bajo dos de sus propios mecanismos de entrega, sin ninguna conexión de por medio. Informa una vez por cada mecanismo que reclama la clave, situado en la propia entrada de ese mecanismo, y nombra el mecanismo del que trata el hallazgo, la clave, y luego cada otro mecanismo que la reclama, en el orden de escritura:
duplicate delivery key across inject sources (Aggregate <name>, at .spec.components.<component>.inject.<mechanism>.<key>, "<mechanism>", "<key>", "<other-mechanism>") (clave de entrega duplicada entre las fuentes de inject (con el Aggregate, la ruta, el mecanismo, la clave y el otro mecanismo indicados))
Ninguno de los dos mecanismos es el infractor y te corresponde a ti actuar sobre ambos hallazgos: cambia el nombre de la clave bajo uno de ellos, o quita una de las dos entregas. Qué mecanismos puede usar un componente es una cuestión aparte, que responde su lista de permitidos spec.inject — consulta «Self-inject mechanism not in the component’s allowlist (Mecanismo de self-inject que no figura en la lista de permitidos del componente)» más abajo.
Un componente que aporta un módulo también se encuentra con estas dos primeras formas, leídas del propio documento del módulo una vez construida la composición que lo importa; entonces nombran el Aggregate del módulo y la clave dentro de su documento.
El tercero lee las conexiones que lleva la topología terminada, incluidas las que una vinculación de Feature aportó en tu nombre. Se ejecuta antes de que se renderice nada, y nombra la clave de entrega que escribiste junto con el socket de dependencia que también la entrega:
duplicate delivery key across self-inject and uses-inject ("<key>", socket "<socket>") (clave de entrega duplicada entre self-inject y uses-inject (la clave indicada, el socket indicado))
Una clave escrita que se entrega a través de dos sockets de dependencia se informa una vez por socket, así que una sola compilación te informa de todos ellos y no solo del que se alcanzó primero.
El cuarto lee la misma topología terminada y le hace una pregunta distinta: si dos de las propias conexiones de dependencia de un componente entregan una misma clave entre ellas, sin que el propio componente reclame nada. Informa una vez en cada conexión, situado en la propia entrada de entrega de esa conexión, y nombra la ruta de la entrada seguida de cada socket que entrega la clave:
duplicate delivery key across inject sources ("inject.<mechanism>.<key>", "<socket>", "<socket>") (clave de entrega duplicada entre las fuentes de inject (con la ruta de la entrada y los sockets indicados))
Un socket nombrado dos veces es lo que te dice que las dos conexiones están en un mismo socket bajo alias distintos — ahí la posición es lo único que las separa, así que lee la ruta del campo de cada uno de los dos hallazgos en lugar de los nombres de los sockets.
Ninguna de las dos conexiones es la infractora y te corresponde a ti actuar sobre ambas: cambia el nombre de una de las claves, o quita una de las dos entregas.
Donde la clave es una ruta, la ruta del campo nombra en su lugar el bloque del mecanismo. Lo que expresa una clave de entrega es asunto del propio mecanismo, y un mecanismo file entrega en una ruta de montaje — así que una clave así contiene puntos, mientras que una ruta del campo separa sus propios pasos con ellos. Una ruta del campo se detiene en el último paso que puede nombrar sin ambigüedad en lugar de escribir uno que se leería como un recorrido por claves que tu documento no contiene, así que para una clave como /etc/app/config.yaml se lee .spec.components.<component>.inject.<mechanism> y se detiene ahí. El mensaje nombra la clave en cualquier caso, que es lo que mantiene el hallazgo igual de accionable — pero en qué parte del mensaje leerla difiere entre las cuatro formas anteriores, así que lee la ruta del campo para el bloque y luego toma la clave de la que tengas de las cuatro: donde el detalle empieza por el mecanismo de entrega, la clave es el valor entre comillas que le sigue inmediatamente; donde el detalle empieza por la clave sola, es el primer valor entre comillas; y donde el detalle empieza por la propia ruta de la entrada de entrega, la clave es el último paso de esa ruta.
Cómo corregirlo: cambia el nombre de una de las claves en conflicto, o quita la declaración duplicada. Ten en cuenta que el injectMapping de una FeatureRecipe que reescribe una clave que entregó el propio bloque inject: del componente o uno de los bloques inject: de sus conexiones es una interceptación intencionada y no se señala aquí ni en ningún otro lugar.
Una clave reclamada por una Feature vinculada al componente se encuentra con el mismo espacio compartido desde la tercera de sus tres superficies de autoría, y se informa bajo «An attachment delivers a key another inject source already claimed (Una vinculación entrega una clave que otra fuente de inject ya reclamó)» más abajo; una clave que entregan dos Features vinculadas, donde la posterior de las dos la entrega a través del injectMapping de su FeatureRecipe, se informa bajo «Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Dos Features vinculadas entregan una misma clave, la posterior a través del injectMapping de su FeatureRecipe)».
Self-inject on a component without an allowlist (Self-inject en un componente sin lista de permitidos)
El desarrollador escribió un bloque inject: a nivel de componente, pero la entidad de catálogo del Component no declara spec.inject. Los Components sin una lista de permitidos spec.inject son tipos Black-Box — no reciben ninguna inyección escrita por el desarrollador.
Mensaje emitido:
self-inject on component without spec.inject allowlist (Aggregate <name>, at .spec.components.<component>.inject, "inject", "<component-type>") (self-inject en un componente sin lista de permitidos spec.inject (con el Aggregate, la ruta, la clave inject y el tipo de componente indicados))
El hallazgo se sitúa en el propio bloque inject:, que es el elemento que hay que quitar.
Cómo corregirlo: quita el bloque inject: de esta instancia de Component, o cambia a un tipo de Component White-Box cuya declaración de catálogo incluya spec.inject.
Self-inject mechanism not in the component’s allowlist (Mecanismo de self-inject que no figura en la lista de permitidos del componente)
El desarrollador escribió un bloque inject: a nivel de componente usando un mecanismo (por ejemplo, env o una forma concreta de montaje de archivos) que no figura en la lista de permitidos spec.inject del Component.
Mensaje emitido:
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 en un componente sin lista de permitidos spec.inject (con el Aggregate, la ruta, el tipo de componente, el mecanismo y los mecanismos permitidos indicados))
Los mecanismos que el tipo sí permite siguen al que se dictó, así que el mensaje lleva tanto lo que se escribió como lo que el tipo permite. Un tipo que no declara ninguna lista de permitidos informa del mecanismo dictado sin nada después.
Tanto esta regla como la anterior se aplican a un componente que aporta un módulo, una vez construida la composición que importa el módulo; el hallazgo nombra entonces el Aggregate del módulo y la clave dentro de su documento.
Cómo corregirlo: cambia a un mecanismo de la lista de permitidos, o, si el Component debe admitir el mecanismo que necesitas, amplía su lista de permitidos spec.inject en el catálogo.
uses edge dictates delivery on a socket that allowlists none (Una arista dicta la entrega en un socket que no permite ningún mecanismo)
Un bloque inject: en una arista uses: se cablea a un socket cuya entrada de usesSchema no declara ninguna lista de permitidos inject:, o declara una vacía. Un socket así es una conexión Black-Box: la entidad que lo declaró maneja internamente los valores de la dependencia, así que el consumidor toma lo que emita la Recipe del productor y no elige la forma de entrega. Una clave inject: ausente e inject: [] son la misma declaración.
El socket se lee en la entidad que lo haya declarado: una arista escrita en una vinculación de Feature se resuelve frente al usesSchema de la Feature vinculada, y cualquier otra arista frente al del Component consumidor.
Mensaje emitido. Primero va el rechazo, luego los mecanismos que dictó la arista, el socket y la entidad cuya declaración se leyó — y luego qué hacer al respecto:
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. (el inject de la arista uses dicta un mecanismo de entrega que el socket no permite (el mecanismo indicado, en el socket indicado, declarado en el tipo de componente indicado). El socket no declara ninguna lista de permitidos de entrega, así que no permite dictar nada — la entidad que lo declaró entrega ella misma los valores de la dependencia. Quita el bloque inject de esta conexión y lee los valores de los provides de la conexión en la Recipe consumidora, o declara los mecanismos que el socket permite en su entrada de usesSchema.)
El hallazgo se sitúa en la entrada escrita a la que se refiere, en el documento en el que se escribió esa entrada: .spec.components.<consumer>.uses.<socket>.<alias> para una arista que trazó el propio bloque uses: de un componente, y .spec.components.<consumer>.features.<attachment>.uses.<socket>.<alias> para una que trazó una vinculación — con raíz en el bloque que declaró la vinculación, que puede ser el de un subsistema o el de un límite en lugar del propio del componente. Donde el socket se declaró en la Feature vinculada, el mensaje nombra el tipo de funcionalidad en lugar del tipo de componente. Cada arista errónea se informa como un hallazgo propio, así que una sola compilación las nombra todas.
Cómo corregirlo: quita el bloque inject: de la arista y lee en su lugar los valores de la dependencia desde .context.uses.<alias>.provides.<name> en la Recipe consumidora; o, si la conexión debe ser transparente, declara los mecanismos de entrega que el socket permite en la lista de permitidos inject: de su entrada de usesSchema.
Un socket que la entidad declarante nunca declaró es un caso distinto y aquí no se rechaza: un socket ad hoc no lleva ninguna lista de permitidos, así que no hay nada fuera de lo cual pueda quedar la arista.
uses edge dictates a delivery mechanism outside the socket’s allowlist (Una arista dicta un mecanismo de entrega fuera de la lista de permitidos del socket)
Un bloque inject: en una arista uses: nombra un mecanismo de entrega que la lista de permitidos inject: del socket no incluye. La lista de permitidos es la declaración de la entidad declarante de las formas de entrega desde las que su punto de entrada puede leer realmente los valores de la dependencia, así que un mecanismo fuera de ella entregaría valores que nada consume.
Se comprueba cada mecanismo que nombra el bloque, y se informa de cada uno que esté fuera de la lista de permitidos, así que una sola compilación los nombra todos en lugar de uno por ejecución.
Mensaje emitido. Primero va el rechazo, luego el mecanismo rechazado, el socket, lo que ese socket sí permite y la entidad cuya declaración se leyó:
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. (el inject de la arista uses dicta un mecanismo de entrega que el socket no permite (el mecanismo indicado, en el socket indicado, que permite los mecanismos indicados, declarado en el tipo de componente indicado). Dicta uno de los mecanismos que el socket permite, o amplía la lista de permitidos de inject de ese socket en la entrada de usesSchema de la entidad declarante.)
El hallazgo se sitúa en la entrada escrita a la que se refiere, en las mismas rutas que nombra el rechazo anterior. Donde el socket se declaró en la Feature vinculada, el mensaje nombra el tipo de funcionalidad en lugar del tipo de componente.
Cómo corregirlo: cambia a uno de los mecanismos permitidos, o, si la entidad debe admitir el mecanismo que necesitas, amplía la lista de permitidos inject: de ese socket en su entrada usesSchema del catálogo.
An inject: entry carries both a literal and a source key (Una entrada de inject lleva a la vez un literal y una clave de origen)
Una entrada inject: entrega una de dos cosas: un literal, escrito bajo value: — en el propio bloque de un componente, el único lugar donde se entrega un literal — o una clave leída del componente al que apunta la conexión, escrita bajo from:. Una entrada que lleva ambas dice dos cosas a la vez y no ofrece ninguna regla para elegir entre ellas, así que se rechaza en lugar de dejar que una de las dos gane sin avisar.
Los esquemas de autoría admiten exactamente una de las dos, así que un documento leído de un archivo se rechaza al cargarse. Esta es la comprobación que respalda a aquella: lee cada bloque inject: que llevan el Aggregate y la Release mientras se resuelven los dos documentos, así que un documento construido por una vía distinta de un archivo se rechaza igualmente antes de que se construya nada a partir de él, en lugar de que se elija un campo en silencio. Cubre los mismos bloques que la comprobación de forma de más abajo.
Cada mecanismo de entrega que contiene una entrada errónea se informa como un hallazgo propio, situado en ese mecanismo en el documento que lo escribió — .spec.components.<component>.inject.env para el propio bloque de un componente — y se informa de todos los de la compilación a la vez. El hallazgo nombra el mecanismo y luego el campo in: de cada entrada errónea en la lista de ese mecanismo.
Mensaje emitido:
inject entry carries both value: and from:; schema requires exactly one ("<mechanism>", "<in-1>", "<in-2>") (la entrada de inject lleva ambos campos; el esquema exige exactamente uno (con el mecanismo y las entradas indicados))
Cómo corregirlo: abre cada entrada que nombra el mensaje y borra el de los dos que no necesite. Conserva from: donde el valor deba venir del componente al que apunta la conexión — nombra una clave que declara el provides: de ese componente. Conserva value: donde el valor sea un literal que aporta este lado, en el propio bloque de un componente; en una conexión y en el propio bloque de una Feature vinculada un literal se rechaza, así que ahí conserva from:.
An inject: entry on a connection carries a literal (Una entrada de inject en una conexión lleva un literal)
Una conexión entrega al componente consumidor lo que publica el componente al que apunta: cada entrada del bloque inject: de la conexión nombra bajo from: una de las claves provides: de ese componente. Un literal escrito bajo value: no nombra nada que publique el destino, así que no tiene cabida en una conexión, y la entrada se rechaza en lugar de descartarse. Un literal que un componente se entrega a sí mismo pertenece al propio bloque inject: del componente, donde value: se admite.
Se comprueba cada conexión, sea cual sea el documento que la trazó: una en el propio bloque uses: de un componente, una que traza una Feature vinculada en el Aggregate y una que traza una vinculación escrita en la Release. Se rechaza antes de que se renderice nada, así que aggrega validate --release la informa igual que aggrega build.
Cada entrada errónea se informa como un hallazgo propio, situado en la entrada de la conexión en el documento que la trazó — .spec.components.<component>.uses.<socket>.<alias> para la propia conexión de un componente, .spec.components.<component>.features.<attachment>.uses.<socket>.<alias> para una que traza una vinculación y, en la Release, la misma ruta bajo la entrada de la vinculación, como .spec.boundaries.<boundary>.components.<component>.features.<attachment>.uses.<socket>.<alias> — y se informa de todas las de la compilación a la vez. Un hallazgo en el Aggregate se clasifica bajo DEVELOPER_ERROR, uno en la Release bajo OPS_ERROR. El hallazgo nombra el mecanismo y el campo in: de la entrada.
Mensaje emitido:
inject entry on a connection carries value:; a connection delivers the target’s published keys, each named with from: ("<mechanism>", "<in>") (la entrada de inject en una conexión lleva un literal; una conexión entrega las claves publicadas del destino, cada una nombrada como origen (con el mecanismo y la entrada indicados))
Cómo corregirlo: donde el valor sea uno que publica el destino, sustituye value: por from: que nombre esa clave provides:. Donde sea un literal que necesita el componente consumidor, mueve la entrada al propio bloque inject: de ese componente, cuyos mecanismos rige la lista de permitidos spec.inject de su tipo de Component.
An inject: entry on an attached Feature carries a literal (Una entrada de inyección en una Feature vinculada lleva un literal)
El bloque inject: escrito en una Feature vinculada entrega al componente lo que publica la FeatureRecipe de esa vinculación: cada entrada nombra una de las claves que publica el provides: de la FeatureRecipe, bajo from:. Un literal escrito bajo value: no nombra nada que publique la vinculación, así que nada llegaría al componente bajo el in: de esa entrada; la entrada se rechaza en lugar de construirse y descartarse. Un literal que el componente necesita va en el propio bloque inject: del componente, donde value: se admite y se entrega.
Se comprueba cada vinculación en la que un Aggregate escribe un bloque inject:: una en el propio bloque features: de un componente y una en el bloque features: de un subsistema, que alcanza a cada componente que contiene el subsistema — en el Aggregate que nombra la Release y en cada módulo que ese Aggregate importa bajo aggregates:, a cualquier profundidad. Una conexión que traza una vinculación lleva su propio bloque inject:, y un literal ahí corresponde al rechazo de la conexión descrito arriba. Una vinculación de la Release no escribe ningún bloque inject: propio. La entrada se rechaza antes de que se renderice nada, así que aggrega validate --release la notifica igual que aggrega build.
Cada entrada infractora se notifica como un hallazgo propio, registrado como DEVELOPER_ERROR contra el Aggregate cuyo documento escribió el bloque — el propio documento de un módulo para una vinculación escrita en un módulo — y situado en el mecanismo de entrega dentro del bloque de la vinculación en ese documento: .spec.components.<component>.features.<attachment>.inject.<mechanism>, o .spec.subsystems.<subsystem>.features.<attachment>.inject.<mechanism> para la vinculación de un subsistema. Todas las de un documento se notifican a la vez; las de un módulo importado se notifican en cuanto el Aggregate que lo importa pasa la comprobación. El hallazgo nombra el mecanismo y el in: de la entrada. Una entrada que lleva tanto value: como from: se notifica una sola vez, en «An inject: entry carries both a literal and a source key (Una entrada de inyección lleva tanto un literal como una clave de origen)» arriba.
Mensaje emitido:
inject entry on an attachment carries value:; an attachment delivers the keys its FeatureRecipe publishes, each named with from:, and a literal belongs in the component’s own inject block ("<mechanism>", "<in>") (una entrada inject en una vinculación lleva un literal; una vinculación entrega las claves que publica su FeatureRecipe, cada una nombrada como clave de origen, y un literal va en el propio bloque inject del componente)
Cómo corregirlo: donde el valor sea uno que publica la FeatureRecipe de la vinculación, sustituye value: por from: nombrando esa clave provides:. Donde sea un literal que necesita el componente, mueve la entrada al propio bloque inject: del componente, cuyos mecanismos rige la lista de permitidos spec.inject de su tipo 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 (Una entrega de inject no es una lista de entradas)
Cada mecanismo de entrega de un bloque inject: — env, file, arg o un mecanismo nombrado junto a ellos — es una lista de entradas, cada una con in: y exactamente uno de from: o value:. Un mecanismo que contiene cualquier otra cosa, como un mapeo de nombres a claves, no entrega nada que el compilador pueda leer, así que se rechaza en lugar de descartarse. Un mecanismo escrito sin ningún valor no entrega nada y no se rechaza.
Los esquemas de autoría admiten solo la lista, así que un documento leído de un archivo se rechaza al cargarse, como un documento que no coincide con el esquema de su tipo. Esta es la comprobación que respalda a aquella: lee cada bloque inject: que llevan el Aggregate y la Release mientras se resuelven los dos documentos, así que un documento construido por una vía distinta de un archivo se rechaza igualmente antes de que se construya nada a partir de él, en lugar de que la entrega desaparezca. Cubre cada bloque que lleva cualquiera de los dos documentos: en el Aggregate, el propio de un componente, el de una vinculación y los de las conexiones que traza cualquiera de los dos; en la Release, los de las conexiones que trazan sus vinculaciones.
Cada mecanismo erróneo se informa como un hallazgo propio, situado en ese mecanismo en el documento que lo escribió y nombrando el mecanismo, y se informa de todos los de la compilación a la vez. Los hallazgos del Aggregate se informan antes que los de la Release.
Mensaje emitido:
inject delivery: shape must be a list of entries, each in: with exactly one of from: or value: ("<mechanism>") (entrega de inject: la forma debe ser una lista de entradas, cada una con un destino y exactamente un origen o un literal (con el mecanismo indicado))
La posición es la ruta de claves que escribió el autor. En el Aggregate, .spec.components.<component>.inject.<mechanism> para el propio bloque de un componente, .spec.components.<component>.uses.<socket>.<alias>.inject.<mechanism> para un bloque en una de sus conexiones y .spec.components.<component>.features.<attachment>… para el de una vinculación, con .subsystems.<name> por cada subsistema en el que se declara un componente o una vinculación. En la Release, el bloque en una conexión que traza una vinculación, a través de esa vinculación — .spec.boundaries.<boundary>.features.<attachment>.uses.<socket>.<alias>.inject.<mechanism> para una vinculada a todo el límite, .spec.boundaries.<boundary>.components.<component>.features.<attachment>… para una en un componente, con .boundaries.<name> por cada límite anidado y .aggregates.<module> por cada entrada de enrutamiento a través de la cual se nombra un componente.
Cómo corregirlo: escribe como lista cada mecanismo que nombra el mensaje. Una entrada DB_URL: host bajo env: se convierte en - in: DB_URL con from: host cuando host nombra una clave provides: — la del componente conectado en una conexión, la propia del componente en su propio bloque — o, en el propio bloque del componente, con value: host cuando es un literal que aporta este lado.
The Feature filling an attachment slot does not satisfy the slot’s selector (La Feature que llena un slot de vinculación no satisface el selector del slot)
Un Component declara puntos de enlace con nombre para las Features que espera, y un slot puede declarar un selector: que restringe las etiquetas de lo que lo llene. Una vinculación enlaza un slot llevando el nombre del slot; cuando lo hace, las etiquetas de la Feature que nombra se comparan con esa restricción, y un llenado que no la satisface detiene la compilación. Un slot que no declara ninguna restricción acepta cualquier llenado.
Si un slot puede quedar sin enlazar es otra cuestión, con otro remedio, de la que informa su propia detención más arriba: esta presupone un llenado y pregunta si el llenado es admisible, así que un slot sin enlazar no le concierne.
Bajo esta única condición se informan dos resultados, y el mensaje los distingue por lo que dice su último valor. Un llenado que no satisfizo la restricción nombra la Feature cuyas etiquetas no coincidieron. Una restricción que no se pudo leer en absoluto nombra en su lugar el motivo — una expresión que el comparador de etiquetas no pudo evaluar —, lo cual es un fallo en la propia declaración del slot y no en lo que se vinculó a él.
Mensaje emitido, cuando las etiquetas del llenado no satisficieron la restricción:
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. (selector del slot de vinculación no satisfecho (el selector indicado, declarado en el slot indicado, no satisfecho por las etiquetas de la Feature que lo llena, el tipo de Feature indicado). Añade a las etiquetas de la Feature las etiquetas que exige el selector del slot, o llena el slot con una Feature que ya las lleve.)
y cuando la propia restricción no se pudo evaluar:
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. (selector del slot de vinculación no satisfecho (el selector indicado, declarado en el slot indicado, que no se pudo evaluar: con el motivo indicado). Corrige el selector en la declaración del slot en la entidad de catálogo del componente.)
Se sitúa en la clave del llenado en el documento que escribió el llenado, y se clasifica bajo el autor de ese documento: el bloque features: del componente en el Aggregate es un fallo del desarrollador, y un llenado que solo hace la Release — en su entrada para el componente, o en un límite que lo contiene — es un fallo del operador, informado en la propia ruta 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.
El mismo llenado escrito en el componente en el Aggregate informa [DEVELOPER_ERROR E0008] aggregate.yaml at .spec.components.app.features.identity.
Un slot que declara un socket — en el featuresSchema de una entrada de usesSchema — somete del mismo modo el llenado de cada conexión a su selector:. La vinculación que una conexión lleva en el slot se compara con la restricción, y un llenado que esta no admite detiene la compilación, nombrando el socket y la conexión además del slot:
attachment slot selector unsatisfied ("<selector>", declared on slot "<slot>", of socket "<socket>", filled on the connection "<alias>", not satisfied by the labels of the Feature filling it, "<feature-type>"). Add the labels the slot’s selector requires to the Feature’s labels, or fill the slot with a Feature that already carries them. (selector del slot de vinculación no satisfecho (el selector indicado, declarado en el slot indicado, del socket indicado, llenado en la conexión indicada, no satisfecho por las etiquetas de la Feature que lo llena, el tipo de Feature indicado). Añade a las etiquetas de la Feature las etiquetas que exige el selector del slot, o llena el slot con una Feature que ya las lleve.)
Se sitúa en la clave de la vinculación bajo el features: de esa conexión, en el documento que escribió el llenado: la entrada de la conexión del Aggregate, o la entrada por arista de la Release para un llenado que solo hace la Release.
Un selector de slot que la gramática no puede leer también se rechaza antes de que nada llene el slot.aggrega validate, sobre todo el catálogo o sobre un único Component o Feature, lee cada selector de slot que declara el propio documento de la entidad — los slots propios de un Component, los slots que declaran sus sockets y los slots de una Feature — y rechaza el que la gramática no puede leer bajo esta misma condición, tanto si algo llena el slot como si no. El mensaje es la forma «no se pudo evaluar» de arriba; un slot que declara un socket añade el 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. (selector del slot de vinculación no satisfecho, declarado en el slot del socket, que no se pudo evaluar. Corrige el selector en la declaración del slot en el featuresSchema del socket, en la entidad de catálogo del componente.)
En un slot de una Feature, el remedio nombra en su lugar la entidad de catálogo de la Feature. Nada ha llenado el slot, así que el fallo es de la entidad de catálogo: se clasifica como CATALOG_ERROR y nombra el archivo de la entidad.
Cómo corregirlo: para un llenado que no satisfizo la restricción, vincula una Feature cuyas etiquetas sí la satisfagan — el selector del mensaje dice qué etiquetas se piden — o amplía el selector: del slot en el Component que lo declara. Donde el mensaje dice que la restricción no se pudo evaluar, el fallo está en la expresión del selector: corrígela en la declaración del slot del Component, o en la del socket.
An attachment written under another name fits a slot its component leaves empty (Una vinculación escrita bajo otro nombre encaja en un slot que su componente deja vacío)
La superficie de vinculación propia de un Component es abierta: una vinculación bajo un nombre que ningún slot declara es una vinculación libre, y es legal. Una sola forma en esa superficie provoca una detención, porque es la forma que adopta un llenado destinado a un slot cuando se escribe bajo el nombre equivocado. La compilación se detiene cuando se cumplen todas estas condiciones para una misma vinculación:
está escrita en el propio componente — en el propio bloque features: del componente en el Aggregate, o en la entrada de la Release para ese único componente;
su nombre no es un slot que declare el tipo del componente;
las etiquetas de su Feature satisfacen el selector: de un slot que declara el tipo;
nada enlaza ese slot en el componente una vez combinados todos los niveles.
Si se deja así, esa vinculación es una vinculación libre mientras el slot al que estaba destinada queda vacío — y un slot opcional que se deja vacío produce una compilación en verde y no entrega nada. La regla se aplica a toda Feature, no solo a las credenciales.
Todo lo demás en la superficie sigue siendo libre. Una vinculación cuya Feature no encaja en ningún slot declarado no detiene la compilación; tampoco una vinculación adicional junto a un slot que algo ya enlaza, siempre que no quede vacío ningún otro slot en el que encaje. Una vinculación que el componente hereda de un subsistema o de un límite de Release nunca se juzga, así que la forma compartida — una credencial vinculada una sola vez en un nivel en el que se encuentran varios componentes, sin que ningún componente llene el slot — no detiene la compilación. Un slot que no declara ningún selector: no dice nada sobre a qué Feature está destinado, así que ninguna vinculación se somete a él de este modo. Tampoco se juzga aquí una vinculación que lleva una conexión: los slots de un socket son un conjunto cerrado, y cualquier otro nombre en una conexión provoca una detención bajo «A connection carries an attachment under a name its socket declares no slot for (Una conexión lleva una vinculación bajo un nombre para el que su socket no declara ningún slot)».
Mensaje emitido. Primero va la frase de la condición, luego el nombre bajo el que se escribió la vinculación, el componente, la Feature que vincula y el slot vacío en el que encaja — y después qué hacer al respecto:
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. (una vinculación escrita bajo un nombre que ningún slot declara encaja en un slot que su componente deja vacío (la vinculación indicada, en el componente indicado, que vincula la Feature indicada, la cual encaja en el slot vacío indicado). Vincúlala con el nombre del slot indicado para llenar el slot.)
Cuando la Feature encaja en más de un slot vacío, el mensaje nombra cada uno, en el orden en que los declara el tipo del componente, y te deja la elección:
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. (una vinculación escrita bajo un nombre que ningún slot declara encaja en un slot que su componente deja vacío (la vinculación indicada, en el componente indicado, que vincula la Feature indicada, la cual encaja en el slot vacío indicado y en el otro slot vacío indicado). Vincúlala bajo el nombre del slot que debe llenar.)
Se sitúa en la clave de la vinculación en el documento que la escribió, y se clasifica bajo el autor de ese documento. Una vinculación en el propio bloque features: del componente en el Aggregate se informa en .spec.components.<component>.features.<attachment> como un fallo del desarrollador; una que solo escribió la Release, en su entrada para el componente, se informa ahí — bajo el límite que nombra el componente, .spec.boundaries.<boundary>.components.<component>.features.<attachment> — como un fallo del operador:
[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.
El propio slot vacío es un hallazgo aparte cuando es obligatorio, que se informa en el componente en el Aggregate bajo «Required attachment slot not bound (Slot de vinculación obligatorio sin enlazar)».
En qué se diferencia del aviso de casi coincidencia. El aviso descrito en «An attachment name is one edit from a declared slot (Un nombre de vinculación está a una edición de distancia de un slot declarado)» trata de cómo se escribe un nombre: un nombre a una edición de distancia de un slot cuyo selector: no satisface la Feature de la vinculación, lo cual no detiene la compilación e informa de una advertencia. Esta detención trata de en qué encaja la Feature, sea cual sea el nombre: el nombre puede ser cualquiera, y el slot en el que encaja debe haberse dejado vacío. Cuando un nombre está a una edición de distancia de un slot y su Feature sí encaja en ese slot, no se genera ningún aviso, y si el slot se deja vacío esta detención es el único hallazgo que se informa.
Cómo corregirlo: vincúlala bajo el nombre del slot, para que llene el slot — el mensaje nombra el slot, o cada candidato cuando hay varios. Si de verdad es una vinculación aparte, llena también el slot, ya que una vinculación adicional es libre una vez que está enlazado cada slot en el que encaja; o, cuando deba llegar a varios componentes, vincúlala en el subsistema o el límite de Release en el que se encuentran. Si la Feature nunca debe llenar ese slot, restringe el selector: del slot en el Component que lo declara.
An attachment delivers a key another inject source already claimed (Una vinculación entrega una clave que otra fuente de inject ya reclamó)
Tres superficies de autoría entregan en el canal de inyección de un componente a través de un bloque inject:: el propio bloque inject: del componente, los bloques inject: de las entradas de su bloque de dependencias y el bloque de cada Feature vinculada a él. Comparten un único espacio con claves por mecanismo de entrega, así que una clave que reclaman dos de ellas es ambigua respecto a qué valor llega, y la compilación se detiene en lugar de dejar que una superficie desplace silenciosamente a otra. Una Feature vinculada también puede entregar de una segunda manera, a través del injectMapping de su FeatureRecipe; esa vía se encuentra con el mismo espacio después de que todos los bloques hayan entregado, y se informa más abajo bajo «Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Dos Features vinculadas entregan una misma clave, la posterior a través del injectMapping de su FeatureRecipe)».
Esta condición es el lado de ese espacio que corresponde al bloque de la vinculación. Se informa cuando el propio bloque inject: de una vinculación reclama una clave que ya tiene alguna entrega anterior — la entrada de más arriba, «Duplicate delivery key across inject sources (Clave de entrega duplicada entre las fuentes de inject)», es la misma regla leída desde el lado escrito por el desarrollador, y entre las dos queda cubierta la reclamación de cada bloque.
El orden es lo que decide quién colisionó. La primera reclamación bajo una clave es la que la tiene, y las reclamaciones posteriores son las que se informan — así que a una vinculación cuya clave ya está tomada se le dice, mientras que a una vinculación que reclamó primero no se le dice nada de una posterior que no desplazó nada. Una reclamación que no entregó nada en absoluto deja la clave libre y no participa en nada de esto.
El hallazgo se sitúa en la propia entrada de la vinculación dentro del bloque del componente, que es la posición que hay que editar; el mensaje nombra la clave y el mecanismo en cuyo espacio con claves se encuentra. Cada clave en colisión se informa por separado, así que una vinculación que duplica dos claves te informa de ambas.
Mensaje emitido:
duplicate delivery key across attachment-inject and another inject source ("<key>", mechanism "<mechanism>") (clave de entrega duplicada entre el inject de la vinculación y otra fuente de inject (la clave indicada, el mecanismo indicado))
Cómo corregirlo: ningún lado es el infractor y te corresponde a ti actuar sobre ambos. Cambia el nombre de la clave en el lado que controles — casi siempre la propia entrada inject: del componente, ya que el mapeo de la Feature está escrito en un documento de catálogo — o quita una de las dos entregas. Cuando la vinculación de verdad deba aportar el valor, quita la reclamación escrita por el desarrollador y no la de la vinculación. Ten en cuenta que el injectMapping de la FeatureRecipe de una Feature que escribe una clave es una vía distinta y no se informa aquí: reescribir una clave que entregó el propio bloque inject: del componente o una de sus conexiones es interceptación y no se informa en absoluto, y escribir una clave que entregó otra Feature vinculada se informa bajo la entrada siguiente.
Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Dos Features vinculadas entregan una misma clave, la posterior a través del injectMapping de su FeatureRecipe)
Una Feature vinculada entrega en el canal de inyección de su componente por dos vías: el bloque inject: escrito en la vinculación y el injectMapping de su FeatureRecipe, cuya salida nombra la clave de entrega — a menudo a partir de un valor que lleva la vinculación, como la variable de entorno elegida para una credencial. Cuando dos Features vinculadas llegan a una misma clave bajo un mismo mecanismo de entrega, y la posterior de las dos llega ahí a través de su mapeo, la compilación se detiene. Si se la dejara seguir, el componente leería el valor que se hubiera escrito en último lugar, así que una credencial podría presentarse en lugar de otra sin que nada en la salida lo indicara.
Cubre cada Feature vinculada, dondequiera que se haya vinculado: el propio bloque features: del componente, un subsistema, un límite de Release o una entrada de componente de la Release, la expansión de una anotación y la entrada features: de una conexión. La anterior de las dos entregas puede ser el mapeo de la otra Feature o su propio bloque inject: — la compilación informa de ambos emparejamientos bajo esta única condición.
El orden es lo que decide quién colisionó. Cada bloque inject: entrega antes de que se renderice ningún mapeo, y los mapeos se renderizan en un único orden fijo — el orden en que el mapeo de inject recorre las Features vinculadas de un componente, descrito en el pipeline de compilación — así que la primera entrega bajo una clave es la que la tiene, y la Feature posterior es la que se informa. Decide solo la presencia: los valores no se comparan, así que dos Features que entregan el mismo valor bajo una misma clave se informan igualmente. Una clave que la salida de un mapeo no lleva en absoluto no es una entrega; una clave que lleva con un valor vacío sí lo es, porque el valor vacío sustituye lo que hubiera ahí. Una misma clave bajo dos mecanismos de entrega distintos son dos claves, no una colisión.
Qué no se informa. El injectMapping de una FeatureRecipe que reescribe una clave que entregó el propio bloque inject: del componente o uno de los bloques inject: de sus conexiones es interceptación — una Feature de enrutamiento que califica un host, una protección que redirige un upstream — y el valor del mapeo sustituye esa única entrada. El mapeo de una Feature que reescribe una clave que entregó su propio bloque inject: es esa Feature transformando su propia entrega, y tampoco se informa.
El hallazgo se sitúa en la propia entrada de la Feature posterior — dentro del bloque features: del componente o, para una Feature que lleva una conexión, en su entrada bajo esa conexión en el documento que la escribió, como .spec.components.<component>.uses.<socket>.<alias>.features.<slot> en el Aggregate. El mensaje nombra la clave, el mecanismo de entrega y ambas Features por los nombres que llevan en el componente; una Feature que lleva una conexión se nombra por el alias de la conexión y el slot que llena, unidos por un punto. Cada clave en colisión se informa por separado.
Mensaje emitido:
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. (clave de entrega duplicada entre dos vinculaciones: la FeatureRecipe de una vinculación escribe una clave de entrega que otra vinculación ya entregó. Da a una de las dos vinculaciones una clave propia, o vincula una menos: la clave bajo la que entrega esta vinculación la elige su FeatureRecipe, que puede leer los values y la infra propios de la vinculación, y la de la otra se elige del mismo modo o mediante su propio bloque inject, si entregó a través de uno. Una Release establece la infra de una vinculación y nunca sus values, así que, cuando una clave se elige mediante un valor, haz esa vinculación en el Aggregate con el valor y sigue aportando el resto desde la Release.)
Cómo corregirlo: da a una de las dos Features una clave propia — para una Feature de credenciales, suele ser la clave que nombran sus valores — o quita una de las dos vinculaciones. Cuando ambas deban aportar una misma variable, decide cuál debe leer el componente y vincula solo esa. Dos credenciales que una Release vincula por sí sola llegan ambas bajo la clave que su Feature nombra de forma predeterminada, porque una Release no puede escribir los values de una vinculación: vincula una de ellas en el Aggregate con el valor que nombra su clave y da su origen desde la Release en la misma entrada.
A component declares an inject mechanism the attached Feature maps nothing to (Un componente declara un mecanismo de inject al que la Feature vinculada no mapea nada)
La lista de permitidos spec.inject de un Component puede nombrar mecanismos de entrega más allá de los estándar — un mecanismo que entiende la propia lógica interna del componente, y para el que todo lo que entregue en él tiene que producir un valor. Cuando se vincula una Feature a un componente así, el injectMapping de la FeatureRecipe es lo que dice bajo qué mecanismo se entrega cada valor que produce. Un mecanismo que el componente declaró y para el que el mapeo no produce ninguna clave es una entrega que silenciosamente nunca ocurriría, así que la compilación se detiene en su lugar.
Un mapeo que no dice nada sobre mecanismos no es un mapeo que los excluya todos. Una FeatureRecipe cuyo mapeo se renderiza como un diccionario plano de entregas no afirma nada sobre mecanismos — es la forma habitual de escribir una Feature que produce entregas como variables de entorno —, y tampoco lo hace una vinculación que enlaza una FeatureRecipe sin ningún mapeo que evaluar. Ninguno de los dos se informa aquí; esta condición trata solo de un mapeo que nombra mecanismos y omite uno que el componente declaró.
Cada mecanismo sin mapear es un hallazgo propio, así que un componente que declara dos, sin que una vinculación mapee ninguno de ellos, te informa de ambos. El hallazgo se sitúa en la entrada de la vinculación en tu propio archivo, y nombra también la FeatureRecipe — porque ese es el documento en el que está escrito el mapeo, y se encuentra en un lugar completamente distinto.
Mensaje emitido:
custom inject mechanism has no matching key in injectMapping output; add the mechanism’s key to the Recipe injectMapping ("<mechanism>", recipe "<featurerecipe>") (el mecanismo de inject personalizado no tiene ninguna clave correspondiente en la salida del injectMapping; añade la clave del mecanismo al injectMapping de la Recipe (el mecanismo indicado, la FeatureRecipe indicada))
Cómo corregirlo: el mensaje nombra ambas mitades. Añade la clave del mecanismo al injectMapping de la FeatureRecipe para que la Feature produzca un valor para él, o quita el mecanismo de la lista de permitidos spec.inject del Component cuando no se espere que nada entregue bajo él. Cuando la FeatureRecipe pertenece al catálogo de otra persona, vincular una Feature cuyo mapeo cubra el mecanismo es la tercera respuesta.
An attached Feature’s injectMapping output cannot be read (La salida de injectMapping de una Feature vinculada no se puede leer)
El injectMapping de una FeatureRecipe es una plantilla, y lo que produce se lee como YAML: un diccionario con claves por mecanismo de entrega — env, file, arg o un mecanismo propio del componente — o un diccionario plano de entregas de entorno. Cuando la salida no se lee como ninguno de los dos, ninguna de sus claves se puede entregar, así que la compilación se detiene en lugar de renderizar el componente como si la Feature vinculada no hubiera entregado nada. Una credencial es el caso que más importa: un componente que espera una contraseña que nunca recibió podría, de lo contrario, ejecutarse sin ella, y nada en la salida lo indicaría.
La causa habitual es un valor que la plantilla escribió tal cual entre comillas. Una comilla doble dentro de él termina antes de tiempo el escalar entre comillas, y una barra invertida inicia un escape que YAML puede no conocer, así que un mapeo que se renderiza correctamente para la mayoría de los valores falla con el que contiene un carácter así — a menudo una contraseña. Una salida vacía, o que se interpreta como un diccionario que no entrega nada, no es esta condición: no entrega nada, y eso es lo que dice.
El marco que hay sobre el mensaje nombra el componente que se está renderizando, luego la vinculación por el nombre que lleva en el componente y la FeatureRecipe en la que está escrito el mapeo, como feature "<attachment>" (recipe "<featurerecipe>") injectMapping output. Debajo del mensaje está el motivo por el que no se pudo leer la salida — la línea y lo que YAML encontró ahí, como yaml: line 2: found unknown escape character. Cuando la plantilla lee un valor que un autor declaró sensible y el motivo depende de lo que contiene ese valor, el motivo se omite y en su lugar aparece una frase que lo indica, de modo que la detención nunca cita el valor que rompió la salida. La compilación informa de la detención bajo una etiqueta CATALOG_ERROR, porque el mapeo lo escribe el autor de la FeatureRecipe.
Mensaje emitido:
FeatureRecipe injectMapping output could not be read as a dictionary of deliveries (la salida de injectMapping de la FeatureRecipe no se pudo leer como un diccionario de entregas)
Cómo corregirlo: en el injectMapping de la FeatureRecipe, escribe cada valor a través de toJson — {{ .values.key }}: {{ .values.origin | toJson }} —, que lo escribe como una cadena JSON que YAML vuelve a leer exactamente, contenga los caracteres que contenga. Cuando la FeatureRecipe pertenece al catálogo de otra persona, también se puede cambiar el valor para que no contenga comillas dobles ni barras invertidas hasta que se corrija el mapeo.
An attached Feature’s injectMapping output writes deliveries under a key nothing delivers (La salida de injectMapping de una Feature vinculada escribe entregas bajo una clave que nada entrega)
La salida del injectMapping de una FeatureRecipe se fusiona en el canal de inyección del componente según sus claves de primer nivel. env, file y arg se entregan como esos mecanismos, y cualquier otra clave se entrega como un mecanismo propio con ese nombre, que la Recipe del componente lee en .context.inject.<name>. La vista all es distinta: se construye a partir de los mecanismos después de la fusión, nunca se fusiona desde una salida, así que los valores que un mapeo escribe bajo all: no llegan a nada. La salida se sigue leyendo sin errores, así que sin esta detención una compilación que lee esos valores de forma opcional tiene éxito sin ellos — una credencial escrita ahí nunca llega al componente, y nada en la compilación nombra el mapeo que la perdió.
Se aplica dondequiera que all: lleve al menos una entrada, solo o junto a otros mecanismos; los demás mecanismos de la misma salida no son el problema, y un all: escrito vacío no pierde nada y no se informa. Un diccionario plano que por casualidad lleva una clave llamada all con un único valor es una entrega de entorno llamada all, no esta condición.
El hallazgo se sitúa en la entrada de la vinculación en tu propio archivo, y nombra la clave y la FeatureRecipe en la que está escrito el mapeo — porque ese es el documento que hay que cambiar, y se encuentra en un lugar completamente distinto — junto con las claves que puede llevar una salida. Cada una de esas claves es un hallazgo propio. La compilación lo informa bajo una etiqueta CATALOG_ERROR.
Mensaje emitido:
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 salida de injectMapping de la FeatureRecipe escribe una clave que ningún mecanismo de entrega del anfitrión lee (la clave all, la FeatureRecipe indicada y las claves que puede llevar una salida))
Cómo corregirlo: en el injectMapping de la FeatureRecipe, mueve las entradas de debajo de all: al mecanismo desde el que el componente las lee — normalmente env:, o el nombre del mecanismo que lee la Recipe del componente. Cuando la FeatureRecipe pertenece al catálogo de otra persona, vincula en su lugar una Feature cuyo mapeo entregue el valor.
Al renderizar la salida
Una vez validado cada contrato, el compilador evalúa las plantillas Go sobre los valores de Component, los bloques injectMapping de FeatureRecipe y las fuentes de Recipe y FeatureRecipe, y luego entrega el resultado al renderizador.
provides: template references a non-self-contained root (La plantilla de provides hace referencia a una raíz no autocontenida)
La plantilla provides: de una Recipe hace referencia a una raíz fuera del conjunto autocontenido. El bloque provides se evalúa en la evaluación de provides, antes de que se hidrate el canal de inject y antes de que se recorran las aristas entre nodos, así que solo puede hacer referencia a datos que pertenecen a su propio nodo: .context.instance_id, .context.rendered_name donde el proveedor del nodo informa uno, .values, .infra, los .locals resueltos del nodo y cadenas estáticas. La comprobación es una lista de permitidos positiva, así que cualquier otra raíz provoca una detención — .context.inject y .context.uses (entre nodos), .context.annotations.*, .context.labels, .context.metadata y .metadata.* (datos ligados a la colocación o al despliegue que la superficie de provides no expone), y .attachment_name (la pasada de provides de una Recipe base no resuelve ninguna vinculación). Hacer referencia a una de ellas detiene la compilación de forma explícita en lugar de renderizar en silencio un valor vacío.
.locals forma parte de la superficie: los locals de un nodo se resuelven en el preámbulo de la misma etapa, antes de sus provides, así que una plantilla provides los lee y recibe valores resueltos.
Mensaje emitido:
provides block references a root outside the self-contained set ("<expression>") (el bloque provides hace referencia a una raíz fuera del conjunto autocontenido (con la expresión indicada))
La detención se sitúa en la Recipe que declara la entrada y en la clave escrita dentro de ella — .spec.provides.<name> —, así que nombra el bloque que hay que editar en lugar del componente que enlazó la Recipe. Cada entrada que sale de la superficie se informa en la misma compilación; donde hay más de una, los hallazgos se agrupan bajo provides entries that reach outside the data they are evaluated against.
Cómo corregirlo: reestructura la plantilla para que tome datos solo de los pilares propios de la Recipe. Si el valor depende de la salida de otro nodo, esa dependencia pertenece al bloque uses[].inject de un llamador, no a los provides del destino. Si el valor es calculado, pon la expresión en una entrada locals: y léela desde provides — así la expresión vive en un solo lugar. Si intentabas alcanzar el namespace de despliegue (u otros datos de colocación) para construir un host entre namespaces, publica aquí el host sin calificar y califícalo del lado del consumidor con una funcionalidad de enrutamiento — los provides del productor no deben depender de dónde se desplegó.
El provides: de una FeatureRecipe sigue la misma regla de locals: sus propios locals: se resuelven antes que su provides:, así que una entrada provides de una FeatureRecipe también lee .locals.
locals: entry references a sibling defined later in the same block (Una entrada de locals hace referencia a una entrada hermana definida más adelante en el mismo bloque)
Un bloque locals: se resuelve en el orden en que están escritas sus entradas, y una entrada solo lee una entrada hermana definida encima de ella. Una referencia directa .locals.<key> a una entrada que el bloque define más adelante provoca una detención: el compilador nunca ordena ni reordena el bloque para que la referencia se resuelva, porque entonces la salida emitida seguiría una inferencia en lugar de lo que se escribió. Sin la detención, la referencia se resolvería, a través de la política de claves ausentes, en una cadena vacía, así que un nombre de host o un nombre de secreto derivado perdería en silencio el segmento a partir del cual se construyó.
Las dos resoluciones de un bloque locals: deciden este fallo, y una de ellas es la fijación. Un bloque se resuelve con dos fines distintos: para que las propias plantillas de la Recipe puedan leerlo mientras se renderiza un artefacto, y para que una coordenada source: estructurada pueda resolverse y fijarse el artefacto que nombra. El fallo se decide a partir del orden de claves declarado y del texto escrito, que es todo lo que necesita, así que ambas resoluciones lo alcanzan e informan la misma condición — aggrega pull, y una compilación que rellena el lockfile, rechazan el bloque exactamente como lo hace un renderizado. Vale la pena conocer dos consecuencias al escribir. El bloque entero se lee mientras se resuelve una coordenada, así que una entrada fuera de orden provoca una detención incluso donde cada campo source: es literal y no lee ningún local. Y una Recipe cuyo source: es una cadena simple, o que no declara ningún source:, no resuelve ninguna coordenada, así que en esa Recipe el fallo se informa cuando se renderiza la salida.
Mensaje emitido, para una entrada del propio bloque locals: de la Recipe de un componente. Se sitúa en la clave escrita dentro de la Recipe, y cada entrada errónea se informa en una sola compilación; donde hay más de una, los hallazgos se agrupan bajo locals entries that read a sibling they cannot:
locals entry references a sibling defined later in the same block ("<expression>", the key it names is "<referenced>", resolved at this point "<the locals available here>", reached through the component "<component>"). define "<referenced>" above "<key>" in the locals block (la entrada de locals hace referencia a una entrada hermana definida más adelante en el mismo bloque (con la expresión, la clave que nombra, los locals resueltos en este punto y el componente a través del cual se alcanzó indicados). define la clave nombrada encima de la entrada indicada en el bloque locals)
Una autorreferencia es la misma condición — la clave está declarada y sin resolver — y ningún reordenamiento la corrige, así que el mensaje lo dice en lugar de la instrucción de moverla:
locals entry references a sibling defined later in the same block ("<expression>", the key it names is "<key>", resolved at this point "<the locals available here>", reached through the component "<component>"). a locals entry cannot read itself; compute the value from .values and .infra directly (la entrada de locals hace referencia a una entrada hermana definida más adelante en el mismo bloque (con la expresión, la clave que nombra, los locals resueltos en este punto y el componente a través del cual se alcanzó indicados). una entrada de locals no puede leerse a sí misma; calcula el valor directamente a partir de .values y .infra)
Una Recipe la enlazan muchos componentes, así que un error en un bloque compartido se informa una vez por cada componente que lo enlaza — y reached through the component es lo que distingue esos hallazgos. Comparten una posición, porque todos tratan de la misma entrada escrita en el mismo documento; la posición es dónde editar, y el nombre del componente es a cuál de tus componentes corresponde cada hallazgo. Los hallazgos no se fusionan en uno, porque fusionarlos diría que algo está mal sin decir a qué componentes alcanza, y esa es la parte sobre la que tienes que actuar.
El mismo fallo en un bloque locals: que declara la receta de una Feature se informa de la misma manera: situado en la clave escrita dentro de esa receta, nombrado por el componente en el que está la vinculación y agrupado con cualquier entrada hermana que tenga el mismo fallo. Donde la receta está vinculada en más de un lugar, el fallo se informa una vez por cada uno — cada vinculación enlaza ese bloque de forma independiente, así que cada una es una ocurrencia propia en lugar de una repetición de una sola.
Donde esa forma informa una autorreferencia, su cláusula de posición nombra la propia entrada que hace la referencia en lugar de una posterior, porque es ahí donde está la clave.
Cómo corregirlo: mueve la entrada referenciada encima de quien la lee. Reordenar un bloque locals: es un cambio de comportamiento allí donde una entrada lee otra, así que la corrección es exactamente el reordenamiento que nombra el mensaje. Una autorreferencia — una entrada que nombra su propia clave — no se puede corregir reordenando; en su lugar, calcula el valor directamente a partir de .values y .infra, que es lo que dice el mensaje en lugar de la instrucción de moverla.
locals: key does not exist (La clave de locals no existe)
Una plantilla lee .locals.<key> para una clave que el bloque locals: no declara en absoluto — una errata, o una clave que se renombró o se eliminó. Toda superficie que lee el pilar genera esta detención: una entrada locals:, una plantilla provides:, una plantilla source: de Recipe y la resolución de una coordenada source: estructurada, que lee el bloque entero para fijar el artefacto que nombra la coordenada. El pilar de locals es un mapa abierto con claves, así que una clave desconocida bajo él supera la comprobación de raíz y, de otro modo, se resolvería en una cadena vacía; la detención es lo que impide que ese valor vacío llegue a un artefacto emitido.
Mensaje emitido, donde la referencia errónea está en una plantilla 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 (la plantilla hace referencia a una clave que el bloque locals no declara (la entrada de provides indicada de la Recipe indicada hace referencia a la expresión indicada, el bloque locals no declara la clave indicada, declara las claves indicadas). corrige el nombre de la clave)
Mensaje emitido, donde está en una entrada locals: en sí. Lleva el componente a través del cual se enlazó el bloque, por el motivo que expone la detención por orden de más arriba — un bloque compartido se informa una vez por cada componente que lo enlaza, y esto es lo que separa esos hallazgos:
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 (la plantilla hace referencia a una clave que el bloque locals no declara (con la expresión, la clave ausente, las claves que declara el bloque y el componente a través del cual se alcanzó indicados). corrige el nombre de la clave)
Cómo corregirlo: corrige el nombre de la clave por uno que el bloque declare; el mensaje los enumera. La detención es distinta de la detención por orden de más arriba porque los remedios difieren — ningún reordenamiento hace que se resuelva una clave que no existe.
La comprobación lee la ruta a la que se resuelve una referencia en lugar de lo que se tecleó, así que se sigue un alias del bloque: una clave alcanzada a través del punto que vuelve a vincular un cuerpo with .locals, o a través de una variable vinculada a .locals, se comprueba exactamente en los mismos términos que la escritura directa y detiene la compilación de la misma manera, y lo mismo ocurre con una clave leída del bloque entre paréntesis — {{ (.locals).nope }} o {{ ($.locals).nope }} — porque los paréntesis producen el propio bloque y nada más. Una sola escritura escapa a la comprobación: una clave alcanzada a través de una llamada cuyo resultado el texto de la plantilla no puede nombrar — {{ index .locals "nope" }}, o {{ (default dict .locals).nope }} — porque lo que produce una llamada así se decide cuando se ejecuta la plantilla y no por lo que está escrito. Una clave ausente leída como campo del resultado de una llamada así — la forma (default dict .locals).nope — no detiene la compilación, y renderiza el texto de marcador de posición del motor de plantillas <no value>. Una clave ausente alcanzada a través de index detiene la compilación, pero como «A template indexes a map with a key the map does not hold (Una plantilla indexa un mapa con una clave que el mapa no contiene)» más abajo y no como esta comprobación: index detiene la compilación ante cualquier clave de mapa que el mapa no contenga. Por tanto, index sigue siendo la forma de alcanzar una clave cuyo nombre se calcula, y un nombre calculado que el bloque no declara se sigue informando por su clave.
Template references a root the render context does not define (La plantilla hace referencia a una raíz que el contexto de renderizado no define)
Una plantilla hace referencia a una raíz de primer nivel — el primer segmento de la ruta después del punto inicial — que su contexto de renderizado no define: una errata como {{ .valeus.port }}, o una raíz que no existe en la superficie que se está escribiendo. La comprobación es una lista de permitidos positiva sobre nombres de raíz, y el conjunto admitido se deriva de la propia forma del contexto de renderizado en lugar de mantenerse como una lista aparte junto a él, así que el conjunto que la compilación rechaza y el conjunto que el contexto realmente entrega no pueden divergir. El diagnóstico nombra la referencia errónea y enumera las raíces que ese contexto define.
La detención se produce de forma idéntica tanto si la referencia está sola como si está envuelta en un respaldo default, if, with o range, y la forma envuelta es la que más importa: un envoltorio puede aportar un respaldo para una clave ausente bajo una raíz definida, pero nunca para una raíz ausente, así que sin esta detención la forma envuelta se resolvería en silencio en un valor vacío y dejaría que la compilación terminara con éxito. Una clave ausente bajo una raíz definida no se ve afectada y sigue la política missingkey=zero para plantillas de valores descrita en «Missing template key — asymmetric policy (Clave de plantilla ausente — política asimétrica)» más abajo, así que modismos de clave opcional como {{ .values.optional_field | default "fallback" }} siguen funcionando.
La misma detención cubre una clave mal escrita un nivel más abajo, bajo un pilar cuya forma está declarada. Algunos pilares tienen un conjunto de claves que define el compilador: .context, .metadata, .inject, .workload y .boundary en el contexto de renderizado de Recipe y FeatureRecipe, y .manifest en una plantilla de ruta. Una referencia a una clave que uno de esos pilares no define — {{ .context.nmae }}, {{ .metadata.typo }}, {{ .workload.containres }}, {{ .boundary.nmae }} — provoca una detención exactamente igual que una raíz equivocada, y el diagnóstico enumera las claves que define ese pilar. En las plantillas propias de la vinculación de una Feature, .inject define una clave más por cada mecanismo de entrega que nombra el bloque inject: propio de la vinculación, además de env, file, arg y all: una vinculación que escribe un mecanismo vault_ref: se lee en {{ .inject.vault_ref.VAULT_PATH }}, y el diagnóstico enumera .inject.vault_ref entre las claves que define .inject. Un mecanismo que la vinculación no nombra provoca una detención incluso dentro de un if o de un with, porque la referencia se comprueba antes de que se ejecute la plantilla. Para leer uno que la vinculación podría no nombrar, protégelo: {{ with .inject }}{{ if hasKey . "vault_ref" }}{{ index . "vault_ref" "VAULT_PATH" }}{{ end }}{{ end }}. Con el par protegido la compilación se completa tanto si la vinculación nombra el mecanismo como si no, y tanto si escribe un bloque inject: como si no escribe ninguno — .inject no contiene nada entonces, así que el with se salta su cuerpo, mientras que hasKey aplicado directamente sobre .inject provocaría una detención ante un valor que no es un mapa. Dentro de la protección, index sigue provocando una detención ante una clave que el mecanismo nombrado no contiene. Otros pilares son abiertos, porque lo que contienen son datos con claves y no un conjunto que declare el compilador — entre ellos .values, .infra, .locals, .provides, .features y .steps en el contexto de renderizado, y .parameters y .parent_boundary en una plantilla de ruta. Un pilar abierto acepta cualquier clave. Una clave ausente bajo un pilar abierto no es esta detención — sigue la política de claves ausentes de la superficie descrita en «Missing template key — asymmetric policy (Clave de plantilla ausente — política asimétrica)» más abajo, así que {{ .values.optional_field | default "fallback" }} y cualquier otro modismo de clave opcional siguen funcionando.
Qué pilares están declarados y cuáles son abiertos es una propiedad de la superficie, no algo en lo que una plantilla pueda influir: el compilador lo lee de la forma del contexto de renderizado que está a punto de entregar. Eso es lo que permite que la detención por errata y el renderizado de la clave opcional convivan en la misma plantilla.
Una superficie también puede restringir una clave que su pilar define en otros casos, y un informe así no es una errata. Donde una clave lleva una respuesta que carece de sentido — o que pertenece a otro nodo — en una superficie concreta, esa superficie rechaza la referencia en lugar de resolverla en algo equivocado, y el diagnóstico enumera las claves que sí define. Dos casos que conviene conocer, ambos {{ .context.rendered_name }}. En las plantillas propias de una vinculación de Feature, la clave lleva el nombre del componente anfitrión tal como lo informa el propio proveedor del anfitrión, así que se rechaza en la vinculación de un anfitrión cuyo proveedor no informa ningún nombre — un anfitrión que coloca por sí solo un conjunto de artefactos, o uno que renderiza a través de un proveedor que no deriva tal nombre — y se admite en cualquier otro anfitrión. {{ .context.instance_id }} se admite en esa superficie y nombra el componente anfitrión para el que se está resolviendo la vinculación, que es el nombre que llevan los recursos propios del anfitrión en un anfitrión así. En las entradas locals: de una Recipe, la clave se rechaza informe lo que informe el proveedor del nodo: un local comparte su contexto con la plantilla source: de la Recipe, y si el nodo aporta una fuente es una de las cosas de las que depende el nombre, así que ahí no se ofrece el nombre. El diagnóstico enumera .context.instance_id como la única clave que .context define ahí; lee el nombre renderizado en una entrada provides: o en una plantilla en línea. Consulta ../templates/rendered-resource-names.md para saber qué nombra cada una de las dos claves y dónde se puede leer cada una.
Mensaje emitido cuando la propia raíz no está definida:
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>) (la plantilla hace referencia a una raíz que el contexto de renderizado no define (la plantilla indicada hace referencia a la ruta indicada, el contexto de renderizado define las raíces indicadas))
Y cuando la raíz es correcta pero una clave bajo un pilar declarado no lo es:
template references a root the render context does not define (template <template-name> references <dotted-path>, <pillar> defines <the keys that pillar defines>) (la plantilla hace referencia a una raíz que el contexto de renderizado no define (la plantilla indicada hace referencia a la ruta indicada, el pilar indicado define las claves indicadas))
Cómo corregirlo: corrige la referencia por una de las que enumera el diagnóstico — la mayoría de los informes son una errata de .values, .infra o .context, o de una clave bajo .context o .metadata. Quitar el envoltorio de respaldo no elimina la detención, y añadir uno nunca la suprimió; el envoltorio solo ocultaba qué referencia era errónea. Si los datos pertenecen realmente a otro nodo, llegan a esta plantilla a través del canal de inject — cabléalos con una entrada uses[].inject en el consumidor y léelos desde .context.inject — y no a través de una raíz propia.
La comprobación cubre toda superficie de plantilla que evalúa el renderizador, cada una frente al conjunto de referencias que define su propia superficie: valuesMapping, injectMapping y workload de Recipe y FeatureRecipe, los cuerpos de artifacts:, las entradas provides: y locals:, source:, los cuerpos when: y with: de los pasos de pipeline, assertions:, las plantillas value: de self-inject a nivel de componente en un Aggregate y las plantillas de ruta de los límites de la Release (directory: / subDirectory:). Dos de esas superficies nombran algunos rechazos con un diagnóstico propio, porque el error que describen es más específico que «esta referencia no existe»: una plantilla de ruta que intenta alcanzar una variable que no se le da está cubierta por «Path-template references a variable outside the allowlist (La plantilla de ruta hace referencia a una variable fuera de la lista de permitidos)» más abajo, y una FeatureRecipe de nivel de límite que intenta alcanzar un pilar por componente, por «FeatureRecipe template references a field outside its scope’s allowlist (La plantilla de FeatureRecipe hace referencia a un campo fuera de la lista de permitidos de su nivel)». Todo lo demás que rechazan esas dos superficies — incluida una clave mal escrita bajo un pilar que sí admiten — informa esta detención, así que ningún diagnóstico te dice que tu referencia es algo que no es.
An artifacts: template reads a pillar the Recipe does not declare (Una plantilla de artifacts lee un pilar que la Recipe no declara)
La plantilla de una entrada artifacts: lee .workload, o una clave bajo él, en una Recipe que no declara ningún workload:; o lee .source, o una clave bajo él, en una Recipe que no declara ningún source:. Ambos pilares están siempre presentes en el contexto de renderizado de los artefactos — son raíces que define la superficie —, así que la referencia está bien formada y la detención trata de que falta la declaración, no de que la referencia sea errónea. Una Recipe que renderiza un Deployment a partir de su carga de trabajo sintetizada y una Recipe que renderiza un chart a partir de una fuente son formas distintas, y un cuerpo artifacts: escrito para una de ellas intenta alcanzar un pilar que la otra nunca llena.
La comprobación se ejecuta antes de que se evalúe la entrada, y ese orden es lo que hace útil el informe. Un pilar ausente llega a la plantilla como un valor vacío, así que, si se dejara a la evaluación, la compilación o bien no insertaría nada en el archivo emitido, o bien fallaría con lo que diga el motor de plantillas sobre leer una clave de la nada — y ninguna de las dos cosas nombra el pilar ni la declaración que falta. Rechazar primero permite que la detención nombre la expresión exacta que intentó alcanzar el pilar, citada tal como la escribiste.
Un source: que está declarado pero cuyo renderizado da una cadena vacía se lee como ninguna fuente, porque lo que lee la comprobación es la fuente después de que se haya evaluado su propia plantilla. Es el mismo valor a partir del cual el proveedor renderiza después, así que una Recipe cuyo source: se resolvió en nada tampoco tiene una fuente que ofrecer a un cuerpo artifacts:.
Mensaje emitido, con una sola forma dondequiera que se haya escrito la entrada artifacts:. Lo que varía no es la frase sino las leyendas que la siguen, que dicen qué documento contiene la entrada.
Cada referencia errónea de la plantilla se nombra, así que un cuerpo que intenta alcanzar dos pilares ausentes te informa de ambos y no solo del que apareció primero. Cada referencia se informa en el documento que declara la entrada, citada tal como la escribiste y con la leyenda de la salida a la que pertenece:
artifact template references a pillar the Recipe does not declare (<expression>, artifact <output-name>) (la plantilla de artefacto hace referencia a un pilar que la Recipe no declara (con la expresión y el artefacto indicados))
La expresión nombra el pilar en su primer segmento, y eso es lo que te dice qué declaración falta: .source.chart intenta alcanzar source:, y .workload.containers, workload:.
Una entrada que declara la propia Recipe de un componente se informa en el bloque artifacts: de esa Recipe.
Una entrada que declara una FeatureRecipe — vinculada a un componente como funcionalidad, o declarada en un límite — se comprueba frente a los pilares que declara esa FeatureRecipe y no frente a los del componente anfitrión, se informa en el bloque artifacts: de la FeatureRecipe y lleva una leyenda adicional que nombra la vinculación que la enlaza:
artifact template references a pillar the Recipe does not declare (<expression>, artifact <output-name>, attachment <attachment-name>) (la plantilla de artefacto hace referencia a un pilar que la Recipe no declara (con la expresión, el artefacto y la vinculación indicados))
La leyenda de la vinculación es lo que la posición no puede decir por sí sola: un componente puede llevar varias vinculaciones, y una vinculación declarada en un límite alcanza a cada componente que contiene el límite. La frase en sí nombra una Recipe en ambos casos; son la posición y la leyenda de la vinculación juntas las que dicen qué documento abrir.
Donde una plantilla nombra varias referencias, cada una recibe un informe propio bajo una línea que nombra la entrada que comparten, y esa línea nombra también el documento:
artifact <output-name> references pillars its Recipe does not declare (el artefacto indicado hace referencia a pilares que su Recipe no declara)
artifact <output-name> references pillars the FeatureRecipe attachment <attachment-name> binds does not declare (el artefacto indicado hace referencia a pilares que la FeatureRecipe enlazada por la vinculación indicada no declara)
Cada uno de estos informes lleva la misma condición de detención, sea cual sea el documento del que trate, así que todo lo que compara con la condición y no con el texto no ve ninguna diferencia entre ellos.
Cómo corregirlo: declara el pilar que lee la plantilla, o deja de leerlo. Declararlo es la corrección cuando el cuerpo artifacts: corresponde a esa forma de Recipe — añade el workload: que esperan las referencias de la plantilla a contenedores, puertos o volúmenes, o el source: cuya ruta de chart o de módulo interpola. Quitar la referencia es la corrección cuando el cuerpo se escribió para otra Recipe y reutiliza un fragmento que aquí no se aplica; donde el valor realmente viene de otra parte, publícalo a través del provides: del nodo productor y léelo desde el canal de inject en lugar de intentar alcanzar un pilar que esta Recipe no llena. Proteger la referencia con un envoltorio de respaldo no elimina la detención — falta el pilar, no la clave bajo él —, y tampoco la elimina mover la referencia a otra entrada de la misma Recipe, porque cada entrada de un mismo bloque artifacts: se evalúa frente a los mismos pilares.
Esta detención es distinta de «Template references a root the render context does not define (La plantilla hace referencia a una raíz que el contexto de renderizado no define)» más arriba, y vale la pena distinguirlas porque los remedios difieren. Aquella se produce ante una raíz que la superficie no define en absoluto, o ante una clave mal escrita bajo un pilar cuya forma es fija — {{ .workload.containres }} en una Recipe que sí declara una carga de trabajo. Esta se produce ante una referencia correctamente escrita a un pilar que sencillamente no está.
A template reads a rendered name the node’s provider does not report (Una plantilla lee un nombre renderizado que el proveedor del nodo no informa)
Una plantilla lee {{ .context.rendered_name }} — el nombre que el proveedor enlazado da a la salida que renderiza para el nodo, a partir de una fuente que aportó el autor o de una carga de trabajo que sintetiza — en un nodo cuyo proveedor no informa ningún nombre así. La referencia está bien formada y la clave es una de las que define el contexto de renderizado; lo que falta es una respuesta para este nodo.
El rechazo existe porque la alternativa es peor que una detención. El nombre llega a una plantilla como una cadena simple, así que un nodo sin nombre haría desaparecer la referencia al renderizar y emitiría una dirección a la que le falta un segmento — .svc.cluster.local donde se pretendía un nombre de host — con código de salida cero, sin nada que leer en la compilación. Ese artefacto se despliega, y lo que nombra no existe. Rechazar antes de evaluar nada informa del fallo, en cambio, en la plantilla que escribió el autor.
Si el proveedor de un nodo informa un nombre así lo establece el enlace de la Recipe, antes de cualquier evaluación, así que aquí no se adivina nada.
Dos informes, y cuál recibes depende del nodo y no de dónde escribiste la referencia. Un nodo que no aporta ninguna fuente propia, bajo un proveedor que no informa ningún nombre para él, tiene sus recursos nombrados según su identidad, así que existe un valor correcto y el informe lo nombra. Un nodo que sí aporta una fuente, bajo un proveedor que no deriva ningún nombre para él, no tiene sustituto — y ofrecer ahí la identidad te enviaría a un valor que no nombra ninguno de los recursos de ese nodo, así que el informe lo dice en su lugar.
Mensaje emitido, donde el nodo no aporta ninguna fuente propia:
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 (la plantilla lee el nombre que el destino da a los recursos que renderiza para el nodo, y el proveedor de este nodo no informa ningún nombre así; una plantilla conforme lee un valor que aporta el propio proveedor del nodo (con la clave y el proveedor indicados). lee en su lugar la clave indicada: este nodo no aporta ninguna fuente propia, así que sus recursos se nombran según la identidad del nodo)
Y donde sí aporta una fuente, bajo un proveedor que no deriva ningún nombre así:
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 (la plantilla lee el nombre que el destino da a los recursos que renderiza para el nodo, y el proveedor de este nodo no informa ningún nombre así; una plantilla conforme lee un valor que aporta el propio proveedor del nodo (con la clave y el proveedor indicados). escribe un valor que no dependa de un nombre que derive este destino: no informa ninguno para la salida que renderiza a partir de una fuente aportada, así que aquí no hay nada de ese tipo que leer)
Donde la referencia está en una plantilla distinta de una entrada provides:, el informe nombra además el campo en el que se escribió — field "valuesMapping", field "artifacts[probe.tf.json]" —, porque la clave de una entrada artifacts: es un nombre de archivo de salida y contiene el carácter con el que la posición separa sus propios segmentos, así que la posición se detiene en el bloque que contiene la entrada.
Qué plantillas cubre: toda plantilla que una Recipe escribe en línea — sus entradas provides:, su valuesMapping:, su cuerpo workload:, cada entrada artifacts: y los with: y when: de cada paso de pipeline. Una superficie de plantilla queda fuera: una entrada valuesMapping:, workload: o artifacts: aportada mediante $import: — tanto si el import nombra un archivo local como una entrada de biblioteca — no lleva ningún texto en la Recipe hasta que el renderizado la resuelve, así que una referencia dentro de un cuerpo así se renderiza como un valor vacío en lugar de detener la compilación.
Cómo corregirlo: lee la clave que nombra el informe. Donde la salida de tu nodo es algo construido para él bajo un proveedor que no informa ningún nombre — una carga de trabajo sintetizada, un conjunto de artefactos colocado —, {{ .context.instance_id }} es el nombre que esos recursos llevan realmente, y es el valor correcto, no un respaldo. Donde tu nodo aporta un chart o un módulo propio y el informe no ofrece ningún sustituto, el nombre que intentabas alcanzar no es uno que derive ese proveedor: publica algo que no dependa de él, o nombra el recurso en la fuente que aportaste y vuelve a leer ese nombre desde un valor que tú establezcas. ../templates/rendered-resource-names.md expone qué proveedores informan un nombre y, para cada uno de los demás, por qué no existe ninguno que informar.
A template reads its callers’ render facts without declaring it (Una plantilla lee los hechos de renderizado de sus llamadores sin declararlo)
Una plantilla de una FeatureRecipe vinculada a un componente lee render_facts bajo .context.used_by — lo que los componentes que se conectan al anfitrión de la vinculación informaron sobre sus propios renderizados — y la FeatureRecipe no establece readsCallerRenderFacts: true.
La clave es lo que decide cuándo se renderiza la vinculación. Sin ella, la vinculación se renderiza justo después del componente al que está vinculada, y un componente que se conecta y que viene más tarde en el orden de la compilación aún no se ha renderizado en ese momento, así que lo que emitió no puede estar ahí para leerse. Rechazar la plantilla antes de renderizar nada informa de la declaración que falta en el campo que escribiste, en lugar de una compilación cuya plantilla lee lo que emitieron algunos de sus llamadores y no los demás.
Mensaje emitido:
template reads its callers’ render facts, but the FeatureRecipe does not set readsCallerRenderFacts (<reference>, written in <field>) (la plantilla lee los hechos de renderizado de sus llamadores, pero la FeatureRecipe no establece readsCallerRenderFacts (con la referencia y el campo en el que está escrita indicados))
La referencia se cita relativa a la conexión de la que se leyó — .render_facts, o .render_facts.<name> —, porque una plantilla lee los llamadores una conexión a la vez, dentro de {{ range .context.used_by }} o de una conexión que elige. El campo nombra el bloque en el que se escribió la plantilla: valuesMapping, workload o artifacts[<output-name>]. Un with: o un when: de un paso de pipeline que lee los mismos hechos lo informa en su lugar la entrada siguiente, establezca lo que establezca la FeatureRecipe, porque establecer la clave no permitiría a un paso leerlos. Donde varios campos leen los hechos, cada uno recibe un informe propio bajo una línea que nombra lo que comparten:
attachment templates reading their callers’ render facts without declaring it (plantillas de vinculación que leen los hechos de renderizado de sus llamadores sin declararlo)
Cómo corregirlo: establece readsCallerRenderFacts: true en el spec de la FeatureRecipe. Eso renderiza sus vinculaciones después de que se haya renderizado cada componente y no cambia nada más de lo que renderizan — consulta la página de la entidad FeatureRecipe. La clave es el contrato, y esta detención solo te ayuda a encontrar una plantilla que la necesita de forma visible: la comprobación lee la plantilla tal como está escrita, así que una referencia construida mientras se ejecuta la plantilla, o una escrita en contenido importado de un archivo o de una biblioteca, no detiene la compilación — establece de todos modos la clave en una FeatureRecipe así. Una plantilla que lee un campo llamado render_facts de alguna otra lista junto a .context.used_by también detiene la compilación, y lo mismo ocurre con una que lee los hechos propios de su anfitrión como .render_facts dentro de {{ with .context }} junto a ella — escribe los del anfitrión completos como .context.render_facts, que nunca se toma por los de los llamadores; establecer la clave elimina ambos casos sin más coste que el renderizado posterior.
Una FeatureRecipe que se renderiza una sola vez por límite (executionScope: boundary) no se comprueba aquí: las plantillas que producen sus recursos no tienen ningún .context que leer, y una referencia a él se rechaza en su lugar como un campo fuera de la lista de permitidos de su nivel.
A pipeline step reads its callers’ render facts (Un paso de pipeline lee los hechos de renderizado de sus llamadores)
El with: o el when: de un paso de pipeline, en una FeatureRecipe vinculada a un componente, lee render_facts bajo .context.used_by — lo que los componentes que se conectan al anfitrión de la vinculación informaron sobre sus propios renderizados.
Un paso de pipeline nunca ve esas conexiones. Un paso puede reescribir los documentos propios del componente anfitrión, y la salida propia de un componente sigue siendo la misma se conecte quien se conecte a él, así que las plantillas de un paso se evalúan sin .context.used_by — para toda FeatureRecipe, establezca o no readsCallerRenderFacts: true. Esa clave decide cuándo se renderiza la vinculación, nunca lo que ve un paso. Un paso que leyera los hechos de sus llamadores no leería, por tanto, nada, y la compilación se detiene antes de que se renderice nada en lugar de renderizar esa lectura como un valor vacío.
Mensaje emitido:
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>) (el paso de pipeline lee los hechos de renderizado de sus llamadores, pero un paso de pipeline no lee los componentes que se conectan a su anfitrión; lee solo los hechos de renderizado propios del anfitrión (con la referencia y el campo en el que está escrita indicados))
La referencia se cita en relación con la conexión de la que se leyó — .render_facts, o .render_facts.<name> — como en la entrada anterior, y el campo nombra el paso por su id: pipeline[<step>].with o pipeline[<step>].when. Donde varios pasos leen los hechos, cada uno recibe su propio informe bajo una línea que nombra lo que comparten:
pipeline steps reading their callers’ render facts (pasos de pipeline que leen los hechos de renderizado de sus llamadores)
Cómo corregirlo: en un paso, lee los hechos de renderizado propios del anfitrión en .context.render_facts, escrito completo — provienen del renderizado propio del anfitrión, así que leerlos no hace que nada dependa de quién se conecta a él. Lee en cambio los hechos de los llamadores en las plantillas que producen los recursos propios de la vinculación — su valuesMapping:, workload: o artifacts: — con readsCallerRenderFacts: true establecido, como describe la página de la entidad FeatureRecipe. Establecer solo la clave no elimina esta detención. La comprobación lee la plantilla tal como está escrita, con los límites que describe la entrada anterior: una referencia construida mientras se ejecuta la plantilla, o una escrita en contenido importado de un archivo o de una biblioteca, no detiene la compilación, y un paso que lee un campo llamado render_facts de alguna otra lista junto a .context.used_by, o los hechos propios de su anfitrión como .render_facts dentro de {{ with .context }} junto a ella, también la detiene.
Una FeatureRecipe que se renderiza una sola vez para un límite (executionScope: boundary) no se comprueba aquí, por el motivo que da la entrada anterior.
A template reads its targets’ render facts without declaring it (Una plantilla lee los hechos de renderizado de sus destinos sin declararlo)
Una plantilla de una FeatureRecipe vinculada a un componente lee render_facts bajo .context.uses — lo que los componentes a los que está cableado el anfitrión de la vinculación informaron sobre sus propios renderizados — y la FeatureRecipe no establece readsTargetRenderFacts: true.
La clave decide dos cosas. Hace que la vinculación se renderice una vez que todos los componentes se han renderizado: sin ella, la vinculación se renderiza justo después del componente al que está vinculada, y un destino que viene más tarde en el orden de la compilación todavía no se ha renderizado en ese momento. Y es lo que pone los hechos de cada destino en las conexiones que lee la vinculación: sin ella, ninguna entrada de .context.uses lleva .render_facts en absoluto. Rechazar la plantilla antes de que se renderice nada informa la declaración que falta en el campo que escribiste, en lugar de una compilación cuya plantilla no lee nada donde esperaba los hechos de un destino.
Mensaje emitido:
template reads the render facts of a component its host is wired to, but the FeatureRecipe does not set readsTargetRenderFacts (<reference>, written in <field>) (la plantilla lee los hechos de renderizado de un componente al que está cableado su anfitrión, pero la FeatureRecipe no establece readsTargetRenderFacts (con la referencia y el campo en el que está escrita indicados))
La referencia es la que escribió la plantilla: completa bajo el alias de una conexión — .context.uses.<alias>.render_facts, o .context.uses.<alias>.render_facts.<name> — o, donde la plantilla lee las conexiones de una en una, dentro de {{ range .context.uses }}, {{ with .context.uses.<alias> }} o de una conexión que elige, en relación con esa conexión: .render_facts, o .render_facts.<name>. El campo nombra el bloque en el que se escribió la plantilla: valuesMapping, workload o artifacts[<output-name>]. El with: o el when: de un paso de pipeline que lee los mismos hechos lo informa en cambio la entrada siguiente, establezca lo que establezca la FeatureRecipe. Donde varios campos leen los hechos, cada uno recibe su propio informe bajo una línea que nombra lo que comparten:
attachment templates reading the render facts of the components their host is wired to, without declaring it (plantillas de vinculación que leen los hechos de renderizado de los componentes a los que está cableado su anfitrión, sin declararlo)
Cómo corregirlo: establece readsTargetRenderFacts: true en el spec de la FeatureRecipe — readsCallerRenderFacts: true no elimina esta detención, ya que pone los hechos en los componentes que se conectan al anfitrión y no en aquellos a los que está cableado. Eso renderiza sus vinculaciones después de que todos los componentes se hayan renderizado, pone los hechos de cada destino en su conexión y no cambia nada más de lo que renderizan — consulta la página de la entidad FeatureRecipe. La clave es el contrato, y esta detención solo te ayuda a encontrar una plantilla que visiblemente la necesita: la comprobación lee la plantilla tal como está escrita, así que una referencia construida mientras se ejecuta la plantilla, o una escrita en contenido importado de un archivo o de una biblioteca, no detiene la compilación — establece la clave en una FeatureRecipe así de todos modos. Una plantilla que lee .context.uses de cualquier forma y además lee un campo llamado render_facts de algún otro valor — entre ellos los hechos de un llamador dentro de {{ range .context.used_by }} — también detiene la compilación; establece la clave, y también readsCallerRenderFacts donde la plantilla lee los hechos de sus llamadores.
Una FeatureRecipe que se renderiza una sola vez para un límite (executionScope: boundary) no se comprueba aquí, por el motivo que da la entrada anterior sobre los llamadores.
A pipeline step reads its targets’ render facts (Un paso de pipeline lee los hechos de renderizado de sus destinos)
El with: o el when: de un paso de pipeline, en una FeatureRecipe vinculada a un componente, lee render_facts bajo .context.uses — lo que los componentes a los que está cableado el anfitrión de la vinculación informaron sobre sus propios renderizados.
Un paso lee las conexiones que hace su anfitrión, tal como las lee la Recipe propia del anfitrión, y nunca los hechos de renderizado de sus destinos — para toda FeatureRecipe, establezca o no readsTargetRenderFacts: true. Un paso puede reescribir los documentos propios del componente anfitrión, y el renderizado propio del anfitrión lee lo que sus destinos publican, nunca lo que emitieron, así que las plantillas de un paso se evalúan sin esos hechos. Un paso que los leyera no leería, por tanto, nada, y la compilación se detiene antes de que se renderice nada en lugar de renderizar esa lectura como un valor vacío.
Mensaje emitido:
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>) (el paso de pipeline lee los hechos de renderizado de un componente al que está cableado su anfitrión, pero un paso de pipeline lee solo los hechos de renderizado propios del anfitrión (con la referencia y el campo en el que está escrita indicados))
La referencia se cita como en la entrada anterior, y el campo nombra el paso por su id: pipeline[<step>].with o pipeline[<step>].when. Donde varios pasos leen los hechos, cada uno recibe su propio informe bajo una línea que nombra lo que comparten:
pipeline steps reading the render facts of the components their host is wired to (pasos de pipeline que leen los hechos de renderizado de los componentes a los que está cableado su anfitrión)
Cómo corregirlo: en un paso, lee los hechos de renderizado propios del anfitrión en .context.render_facts, escrito completo. Lee en cambio los hechos de los destinos en las plantillas que producen los recursos propios de la vinculación — su valuesMapping:, workload: o artifacts: — con readsTargetRenderFacts: true establecido, como describe la página de la entidad FeatureRecipe. Establecer solo la clave no elimina esta detención. La comprobación lee la plantilla tal como está escrita, con los límites que describe la entrada anterior.
Una FeatureRecipe que se renderiza una sola vez para un límite (executionScope: boundary) no se comprueba aquí, por el motivo que da la entrada anterior sobre los llamadores.
Cross-node type safety violation via selector: (Violación de la seguridad de tipos entre nodos mediante selector)
Una sola detención cubre las dos expresiones de etiquetas que un autor de catálogo escribe para restringir lo que se puede cablear o vincular, porque ambas fallan de la misma manera: un conjunto de etiquetas que no satisface una expresión que declaró una entidad del catálogo.
Una arista uses: cuyo destino no satisface el selector: de su socket. Un socket usesSchema declara un campo selector: que excluye el Component de destino conectado en el otro extremo de la arista. El selector es la forma en que el autor del catálogo dice «este socket solo acepta destinos cuyas etiquetas coincidan con esta expresión»; una arista que satisface la búsqueda por nombre de socket pero no la expresión del selector es una violación de la seguridad de tipos.
Mensaje emitido:
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. (violación del selector (la expresión indicada, declarada en el socket indicado, no la satisfacen las etiquetas del destino indicado). Añade al tipo de componente del destino las etiquetas que exige el selector, o cablea el socket a un componente que ya las lleve.)
Una vinculación cuyo componente no satisface el campo appliesTo: de la Feature. Una Feature declara a qué componentes puede vincularse, en appliesTo: y en appliesToAnyOf:. Los requisitos de la expresión única se cumplen juntos y las alternativas se cumplen de forma alternativa, y basta con cualquiera de ellas; ambas superficies deben cumplirse, y una superficie que la Feature omite la satisface cualquier cosa. Una vinculación cuyo componente lleva etiquetas que la declaración de la Feature no admite es la misma clase de violación que el caso de la arista anterior.
Mensaje emitido:
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. (violación del selector (la expresión appliesTo indicada, declarada por la Feature indicada, no la satisfacen las etiquetas del componente indicado). Añade al tipo de este componente las etiquetas que exige el appliesTo de la Feature, o vincula una Feature cuya aplicabilidad ya satisfaga el componente.)
Cualquiera de las dos expresiones también puede escribirse en una forma que la gramática de etiquetas no puede leer en absoluto. Eso se informa como la misma detención, cuyo último valor es el motivo por el que no se pudo leer en lugar del conjunto de etiquetas que no la satisfizo — que es lo que distingue una expresión que no se pudo evaluar de una que se evaluó y resultó falsa:
selector violation ("", declared by Feature "", which could not be evaluated: ""). Correct the appliesTo selector on the Feature’s catalog entity. (violación del selector (la expresión appliesTo indicada, declarada por la Feature indicada, que no se pudo evaluar, por el motivo indicado). Corrige el selector appliesTo en la entidad de catálogo de la Feature.)
Un selector de socket que la gramática no puede leer también se rechaza antes de que nada conecte el socket.aggrega validate, sobre todo el catálogo o sobre un único Component o Feature, lee cada selector de socket que declara el propio documento de la entidad, y rechaza el que la gramática no puede leer bajo esta misma condición, tanto si hay alguna arista conectada a través del socket como si no:
selector violation ("", declared on socket "", which could not be evaluated: ""). Correct the selector on the socket’s declaration in the component type’s usesSchema. (infracción del selector, declarado en el socket, que no se pudo evaluar. Corrige el selector en la declaración del socket en el usesSchema del tipo de componente.)
En un socket de una Feature, el remedio nombra en su lugar el usesSchema de la Feature. Nada ha conectado el socket, así que el fallo es de la entidad de catálogo: se clasifica como CATALOG_ERROR y nombra el archivo de la entidad.
La detención lleva la clave escrita a la que se refiere — la entrada de socket uses:, o la entrada features: que nombra la vinculación — junto con el archivo que la declara, así que la posición que informa es la entrada que editas en lugar del comienzo del documento. Un Component escrito dentro de un subsistema se sitúa en el subsistema bajo el que se escribió, nivel por nivel. Una vinculación se sitúa en la entrada features: que la escribió, en el documento que la escribió, y se atribuye al autor de ese documento: el bloque propio del componente o el bloque de un subsistema en el Aggregate, un fallo del desarrollador; y, para una vinculación que solo hace la Release, su entrada para el componente o el bloque features: de un límite que contiene el componente, un fallo del operador. Donde ambos documentos escriben la vinculación, se sitúa donde se nombra su type, cosa que el Aggregate siempre hace. Una vinculación escrita en una conexión se sitúa en su clave bajo el features: de esa conexión, en el documento que la escribió — la entrada de conexión del Aggregate, o la entrada por arista de la Release para una vinculación que solo hace la Release. Una Feature que solo la Release vincula a un componente que su declaración no admite se informa así:
[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.
y la misma vinculación escrita en el componente en el Aggregate se informa como [DEVELOPER_ERROR E0007] aggregate.yaml at .spec.components.app.features.metrics. Una vinculación que produjo la expansión impulsada por anotaciones no la escribió ninguna entrada features:, así que se sitúa en la clave features: propia del componente en el documento que declara el componente, como un fallo del desarrollador.
Cómo corregir una violación de arista: o bien enruta la arista uses: hacia un Component cuyas etiquetas satisfagan el selector, o bien ajusta la expresión del selector en la entidad del catálogo para que acepte la clase de destino prevista. Revisa los metadata.labels del Component de destino con aggrega inspect para confirmar qué etiquetas lleva.
Cómo corregir una violación de vinculación: o bien vincula la Feature a un componente cuyas etiquetas admita su declaración, o bien amplía el appliesTo: de la Feature — añadiendo una alternativa bajo appliesToAnyOf: donde la Feature realmente sirva a más de una clase de componente. Donde el componente debería cumplir los requisitos y no los cumple, la pieza que falta suele ser una etiqueta: revísalo con aggrega inspect y añade lo que pide la expresión en los metadata.labels del Component.
Unknown provider (Proveedor desconocido)
Una Recipe declara capability: <name> donde <name> no nombra ningún proveedor que sirva el compilador. El compilador no puede despachar el renderizado a un proveedor del que nunca ha oído hablar.
Mensaje emitido:
unknown provider: <provider-name> (proveedor desconocido: el nombre indicado)
Cómo corregirlo: confirma que el nombre del proveedor está bien escrito — cloudformation, compose, helm, helm-chart y terraform son los nombres que sirven los plugins proveedores integrados. Si querías un proveedor empresarial personalizado, asegúrate de que un Plugin de renderizado de proveedores que sirva ese nombre (pluginType: provider con el nombre en sus spec.provider.capabilities) esté presente en el espacio de trabajo del catálogo al que apunta la compilación.
A capability is served by more than one provider plugin (Una capacidad la sirve más de un plugin proveedor)
Una compilación alcanza una capacidad — o un pull resuelve una — que sirve más de un Plugin de renderizado de proveedores (pluginType: provider, cada uno de los cuales enumera esa capacidad en sus spec.provider.capabilities), y el espacio de trabajo no ha seleccionado cuál la renderiza. En lugar de elegir un proveedor arbitrariamente, la compilación se detiene y nombra a ambos candidatos. Un catálogo que contiene dos plugins para la misma capacidad es válido — dos editores pueden distribuir cada uno un plugin para helm o compose, y el catálogo acepta ambos. La ambigüedad surge solo en el punto de uso: la detención se produce cuando una compilación o un pull alcanza realmente la capacidad disputada, no en el momento de la carga.
Mensaje emitido. La regla que detuvo la compilación va primero, y los detalles — qué capacidad, qué candidatos y el enlace que hay que escribir — la siguen:
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 capacidad la sirve más de un plugin proveedor; añade una entrada plugins.providers para seleccionar uno: la capacidad indicada la sirve más de un plugin proveedor (los indicados); añade una entrada plugins.providers para la capacidad indicada que seleccione uno)
Cómo corregirlo: añade una entrada plugins.providers en la configuración del espacio de trabajo, con la capacidad como clave y cuyo valor seleccione la identidad del plugin que la renderiza. Mantén ambos plugins en el catálogo federado; el enlace indica a este espacio de trabajo a cuál despachar la capacidad disputada.
The plugin serving a provider cannot assemble what that provider combines (El plugin que sirve a un proveedor no puede ensamblar lo que ese proveedor combina)
Un proveedor declara qué ocurre con la salida por nodo de un grupo de despacho: la salida de cada nodo escrita directamente en la ruta de despacho, los fragmentos fusionados en un único documento, o cada nodo colocado en su propia posición dentro de una única estructura que los envuelve. Donde un proveedor declara que la salida se combina — un archivo compose fusionado, un chart paraguas — el plugin que lo sirve tiene que ofrecer el export que realiza la combinación. Esta detención se produce donde no lo hace: el plugin anuncia el renderizado por nodo (render_node) y ningún assemble_boundary correspondiente, así que los nodos del grupo pueden renderizarse pero su salida no puede fusionarse.
Las dos mitades de ese desacuerdo pertenecen al plugin. Qué ocurre con la salida de un grupo de despacho forma parte de lo que el plugin informa sobre sí mismo cuando se carga, y el export que realizaría la combinación es una de las entradas bajo spec.exports de una entidad Plugin, contrastada con ese mismo informe — así que la detención nombra un plugin que declara un ensamblado que su superficie de export no proporciona.
La compilación se detiene en lugar de omitir el ensamblado. Omitirlo escribiría el fragmento de cada nodo en la ruta en la que se esperaba un único artefacto e informaría de un éxito, y nada más adelante puede distinguir esos fragmentos de la salida plana por nodo que un proveedor que no declara ningún ensamblado emite por diseño — así que un artefacto ausente aparecería allí donde se aplique la salida y no en tiempo de compilación.
Un grupo de despacho sin ruta de despacho se omite. La salida escrita en ninguna ruta es salida por nodo, así que allí no se ensambla nada sobre lo que pueda regir una declaración de combinación.
Mensaje emitido — un hallazgo por cada grupo de despacho infractor, que nombra el proveedor y la ruta en la que ese grupo se ensambla:
provider expected to assemble its dispatch group provides no boundary assembler ("<provider>", dispatch path "<path>") (el proveedor que debía ensamblar su grupo de despacho no proporciona ningún ensamblador de límite (con el proveedor y la ruta de despacho indicados))
Donde más de un grupo de despacho es infractor, los hallazgos llegan juntos bajo el informe dispatch groups whose provider offers no boundary assembler.
Cómo corregirlo: sirve la capacidad con un plugin que anuncie tanto render_node como assemble_boundary — consulta ../entities/plugin.md para la superficie de autoría spec.exports, y ../schema/plugins/wasm-provider.md para lo que recibe el export de ensamblado. Si escribes tú el plugin, te corresponde alinear los dos lados: añade el export de ensamblado, o no informes ninguna declaración de ensamblado y deja que la salida de cada nodo llegue a la ruta de despacho sin fusionar. Si consumes un plugin publicado, selecciona una versión que ofrezca ambos exports, o selecciona un plugin cuyo proveedor no declare ningún ensamblado para esa capacidad.
A boundary-level Feature’s output reaches no assembled file (La salida de una Feature de nivel de límite no llega a ningún archivo ensamblado)
Una Feature vinculada bajo el features: de un límite, cuya FeatureRecipe declara executionScope: boundary, se renderiza una sola vez para todo el límite, y su salida va al directorio al que se evalúan para ella el directory: y el subDirectory: propios del límite. Un proveedor que fusiona su salida en un único documento — compose, en un único docker-compose.yaml; cloudformation, en un único stack — escribe la contribución de esa Feature solo como parte del archivo que ensambla allí a partir de los componentes del límite. Ese archivo solo existe donde la salida de al menos un componente llega al mismo directorio bajo el mismo proveedor.
No existe donde los componentes del límite llegan a otro lugar: cuando se encuentran en límites anidados cuyo subDirectory: los envía a otra parte — "{{ .component_id }}", por ejemplo, para que cada componente tenga un archivo propio — o bajo un directorio que la salida de la Feature no comparte. En el directorio de la Feature no se ensambla nada, así que su salida no se escribiría en ninguna parte — para el puente compose, un servicio de gateway que ningún archivo contiene — y la compilación informaría de un éxito. En su lugar, la compilación se detiene.
Una Feature cuyo proveedor escribe cada contribución como archivos propios — helm, helm-chart y terraform — no se ve afectada: esos archivos se escriben tanto si se ensambla algo junto a ellos como si no.
Mensaje emitido — un hallazgo por cada Feature infractora, posicionado en su entrada bajo el features: del límite, que nombra el límite, la Feature, la ruta de despacho a la que se dirigió su salida y el proveedor:
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 salida de la Feature de nivel de límite se dirige a una ruta de despacho en la que nada se ensambla (con el límite, la instancia de Feature, la ruta de despacho y el proveedor indicados). vincula la Feature a un límite cuya ruta de salida reciba también sus componentes, o da a los componentes del límite el directorio al que se dirige la salida de la Feature)
Un puente compose vinculado a un límite padre bridge, cuyo único límite hijo coloca cada componente bajo subDirectory: "{{ .component_id }}", imprime:
[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
Donde más de una Feature es infractora, los hallazgos llegan juntos bajo el informe boundary-level Features whose output is routed to a dispatch path nothing assembles.
Cómo corregirlo: haz que el directorio de la Feature sea uno en el que también lleguen los componentes de su límite. Vincula la Feature a un límite cuya propia ruta de salida reciba esos componentes, o da a los componentes el directorio al que se dirige la salida de la Feature — para los límites hijos, directory: "{{ .parent_boundary.directory }}" sin un subDirectory: propio, para que compartan el archivo del padre. El mensaje nombra el directorio al que se dirigió la salida de la Feature, que es el que hay que compartir.
Path-template references a variable outside the allowlist (La plantilla de ruta hace referencia a una variable fuera de la lista de permitidos)
Una plantilla directory: o subDirectory: hace referencia a un nombre de variable que la lista de permitidos de variables de plantillas de ruta no incluye — por ejemplo, una errata como {{ .parmaeters.region }}, o un campo que existe en el contexto de renderizado de la Recipe pero no está expuesto a las plantillas de ruta (como .context.inject o .values). La misma detención cubre {{ .component_id }} en una plantilla directory:: la variable existe, y las plantillas subDirectory: pueden leerla, pero el directory: de un límite se evalúa una sola vez para todo el límite y no una vez por componente, así que allí una variable por componente haría que la ruta emitida dependiera de qué componente se hubiera evaluado primero.
Las plantillas de ruta se validan en tiempo de análisis, antes de que empiece cualquier trabajo de renderizado, frente a las variables que define el contexto de plantillas de ruta, menos las que rechaza la superficie concreta. El compilador también evalúa las plantillas de ruta con la semántica missingkey=error, así que una referencia que está en la lista de permitidos pero no está definida en tiempo de evaluación produce un error explícito en lugar de renderizar en silencio una cadena vacía en una ruta de directorio.
Esta detención trata de la variable. Una clave mal escrita bajo una variable permitida — {{ .manifest.recipe_nmae }} — informa en su lugar «Template references a root the render context does not define (La plantilla hace referencia a una raíz que el contexto de renderizado no define)» más arriba, nombrando las claves que .manifest sí define, porque la variable en sí fue admitida y solo la clave era errónea.
Mensaje emitido:
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>") (la plantilla de ruta hace referencia a un campo que no está en la lista de permitidos documentada (con la ruta indicada, escrita en el campo indicado; el contexto de renderizado define las variables indicadas))
Cómo corregirlo: corrige el nombre del campo por uno de la lista de permitidos de las plantillas de ruta, o elimina la referencia. La lista de permitidos para directory: es {{ .capability }}, {{ .boundary_name }}, {{ .parameters.X }}, {{ .manifest.recipe_name }} y {{ .parent_boundary.* }}; subDirectory: añade {{ .component_id }}. Otras superficies (valuesMapping de la Recipe, injectMapping de la FeatureRecipe, etc.) usan una forma de contexto distinta; las referencias a .context.*, .values, .infra o .locals no se exponen deliberadamente a las plantillas de ruta porque la emisión de rutas es una cuestión estructural, no una cuestión de renderizado de valores.
Path collision: two contributors emit at incompatible paths (Colisión de rutas: dos contribuidores emiten en rutas incompatibles)
Dos límites cuyas declaraciones de ruta se evalúan a la misma ruta de ensamblado pasan por proveedores distintos. Ambos ensamblan allí, y cada uno escribe archivos de los que el otro no sabe nada, así que uno desplaza en silencio al otro en el disco — y la compilación que produjo la salida desplazada parece haber tenido éxito.
El subDirectory: predeterminado da a cada proveedor una subruta propia, así que dos proveedores llegan a una misma ruta solo donde las declaraciones se escribieron para evaluarse igual: dos límites que comparten un directory: y que fijan ambos subDirectory: al mismo literal, por ejemplo.
Mensajes emitidos. Se informa un hallazgo por cada límite contribuidor, así que cada límite cuya salida llegó a la ruta se nombra por separado en lugar de agruparse en una lista dentro de un único mensaje. El fallo es que dos proveedores coinciden en una misma ruta, así que siempre hay al menos dos hallazgos, y llegan juntos bajo un informe que indica lo que tienen en común:
assembly paths reached by more than one provider (rutas de ensamblado alcanzadas por más de un proveedor)
Cada hallazgo nombra la ruta, el límite cuya salida llegó a ella y el proveedor por el que pasa ese límite:
dispatch path produced multiple provider outputs ("<path>", boundary "<boundary>", provider "<provider>") (la ruta de despacho produjo varias salidas de proveedor (con la ruta, el límite y el proveedor indicados))
Una compilación cuyos límites api-net y db-net declaran ambos directory: ./dist/shared y subDirectory: merged, uno dirigido a través de helm y el otro a través de compose, imprime:
El informe lleva el código corto y cada hallazgo debajo de él lleva solo su categoría, que es la forma que usa todo informe de fallos recopilados — consulta error-translation.md para esa gramática.
Cómo corregirlo: da a cada límite un directory: distinto (para que se ensamblen en rutas separadas), o deja subDirectory: en su valor predeterminado para que la salida de cada proveedor llegue a una subruta propia. El patrón del puente compose reúne intencionadamente dos sublímites en una única ruta de ensamblado; ese patrón requiere que ambos límites apunten al mismo proveedor y lleven anotaciones resueltas en cascada compatibles.
A boundary’s output directory is not a directory beneath the output root (El directorio de salida de un límite no es un directorio bajo la raíz de salida)
El directory: y el subDirectory: de un límite se evalúan y se unen en el directorio bajo el que se escribe su salida, y esa ruta se normaliza una vez: out/a, out//a, ./out/a y out/a/ son un único directorio. Donde la ruta normalizada no es un directorio bajo la raíz de salida, la compilación se detiene antes de escribir nada. Se trata de una ruta que sale de la raíz de salida (.., ../escape, a/../..), de una absoluta (/srv/out), o de una que no nombra ningún directorio: un valor vacío, o uno que se normaliza en la propia raíz de salida, como directory: "." con el subdirectorio desactivado.
La ruta se comprueba tal como se evaluó, así que se juzga el resultado de una plantilla, no el texto escrito. El mensaje nombra el campo del que proviene el fallo — directory: donde el directorio por sí solo ya sale de la raíz de salida o donde no se le une ningún subdirectorio, y subDirectory: en otro caso — junto con el valor al que se evaluó ese campo y la ruta que produjo.
Mensaje emitido:
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 (el directorio de salida del límite no nombra un directorio bajo la raíz de salida (con la Release, el límite, el valor de directory y la ruta de salida indicados). escribe un directorio bajo la raíz de salida, como «deploy/prod» — sin «/» inicial, sin «..» que suba por encima de ella, y que no sea la propia raíz de salida)
Donde el fallo está en el subdirectorio, el tercer valor indica en su lugar subDirectory: "<value>".
Cómo corregirlo: escribe el campo que nombra el mensaje como un directorio bajo la raíz de salida. Un directorio pensado para estar junto a la raíz de salida debe estar, en cambio, dentro de ella. Para escribir la salida de un límite directamente en su directory:, establece subDirectory: "." — el propio directorio debe seguir nombrando un directorio propio.
A boundary-level Feature is named . or .. (Una Feature de nivel de límite se llama . o ..)
Un proveedor que da a cada contribuidor un directorio propio — terraform, bajo modules/, y helm-chart, bajo charts/ — coloca una Feature vinculada a un límite en un directorio que lleva el nombre de la instancia sola, junto a los componentes del límite. La clave features: de un límite admite . y .., y ninguno de los dos es un nombre de directorio: . pondría los archivos de la Feature en el directorio que contiene a todos los contribuidores, y .. en el de encima, así que los archivos acabarían fuera de la posición que el proveedor dio a la Feature. En su lugar, la compilación se detiene. Cualquier otro nombre no se toca, incluido uno con puntos como audit.v2.
Mensaje emitido:
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” (el nombre de instancia de la Feature de nivel de límite no es un nombre de directorio (con la Release, el límite y la instancia de Feature indicados). cambia el nombre de la instancia de Feature bajo los features del límite por un nombre corriente, como «audit»)
Cómo corregirlo: cambia el nombre de la instancia bajo el features: del límite por un nombre corriente.
Instance-ID collision across boundaries assembling to the same path (Colisión de ID de instancia entre límites que se ensamblan en la misma ruta)
Dos límites que se ensamblan en la misma tupla (ruta, proveedor) aportan componentes con ID de instancia idénticos. El ensamblado fusionado no puede distinguir los dos fragmentos de componente — un único chart de Helm no puede llevar dos Deployments llamados web-server, y un único archivo docker-compose no puede llevar dos servicios llamados api.
Mensaje emitido:
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 (varios contribuidores comparten un ID de instancia en la misma ruta de despacho: la ruta de despacho y el proveedor indicados ya contienen el nodo indicado (con los límites contribuidores indicados); los ID de instancia de los componentes deben ser únicos dentro de un grupo de ensamblado)
Cómo corregirlo: cambia el nombre de uno de los componentes en colisión en el Aggregate, o separa los dos límites en rutas directory: distintas para que cada instancia de componente llegue a su propio ensamblado.
Two contributors write the same output path (Dos contribuidores escriben la misma ruta de salida)
Dos contribuidores a un mismo ensamblado producen un archivo en la misma ruta de salida. Esto es distinto de la colisión de ID de instancia anterior: los componentes tienen nombres distintos y el ensamblado puede distinguirlos — son los archivos que emiten los que acaban en una misma ruta. Ocurre con más frecuencia donde un proveedor escribe la salida de cada contribuidor una junto a otra en lugar de bajo una posición por componente, de modo que dos componentes cuyas Recipes emiten el mismo nombre de archivo (dos entradas artifacts: ambas llamadas main.tf, por ejemplo) coinciden en una misma ruta. La salida propia del ensamblador puede colisionar con el archivo de un contribuidor de la misma manera.
Que dos contribuidores que emiten un mismo nombre de archivo colisionen depende de dónde los coloca su proveedor. Un proveedor que anida a cada contribuidor bajo su propia posición en el ensamblado mantiene separados dos archivos con el mismo nombre; un proveedor que escribe los contribuidores uno junto a otro, no. La comparación se hace sobre la ruta final en la que se escribiría un archivo, no sobre el nombre que emitió el contribuidor, así que el caso anidado no se informa.
La compilación se detiene en lugar de escribir uno de los dos archivos y descartar el otro. No hay ninguna resolución silenciosa correcta: renombrar un archivo o añadirle un sufijo inventaría un nombre que nadie escribió, y fusionar sus contenidos inventaría un documento que nadie redactó. Se informa cada ruta en colisión, y se nombra a cada contribuidor que la escribe, de modo que una sola compilación te da el panorama completo en lugar de una colisión cada vez.
Mensajes emitidos. Se informa un hallazgo por cada ruta en colisión — una sola vez, sin importar cuántos límites alimentaran el ensamblado en el que ocurrió —, de modo que una compilación cuyos contribuidores coincidieron en dos rutas te informa de ambas y ninguna colisión se informa dos veces:
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>") (colisión en la salida ensamblada: dos contribuidores escriben la misma ruta de salida (con la ruta de salida, los contribuidores que la escriben y los límites dentro de los cuales se ensambló indicados))
Cada contribuidor se nombra según lo que es, que es lo que indica dónde está escrito su nombre: component <name> para una instancia de componente, feature <name> para una funcionalidad vinculada a un límite, y the <provider> assembly para la salida fusionada propia del ensamblado. Los contribuidores se enumeran por orden de nombre, así que la frase es la misma en cada compilación de la misma entrada.
Un archivo que una Recipe aporta a la salida compartida del límite también está sujeto a esta regla. El bloque boundary: de una Recipe escribe sus archivos junto a la salida ensamblada propia del proveedor, una vez por nombre de archivo. Varios componentes que declaran un nombre con bytes idénticos son un solo archivo y nunca colisionan; declararlo con bytes distintos colisiona aquí, nombrando el archivo y cada componente que lo declaró, y lo mismo ocurre con un nombre que el propio ensamblado del proveedor escribe — aggrega.modules.tf para terraform, por ejemplo, que nombra the terraform assembly entre los contribuidores. Un archivo que varios componentes declararon de forma idéntica y que coincide con el archivo propio del ensamblado se nombra con todos ellos, como component <name-1> and component <name-2>.
También se nombran los límites que alimentaron el ensamblado, y se enumeran en lugar de señalarse uno solo. Los límites cuyas declaraciones directory: se evalúan igual se ensamblan como uno, y nada en una colisión indica en cuál de ellos se declararon los contribuidores que coincidieron — así que el hallazgo te da cada límite cuya declaración podría separarlos y no afirma de ninguno que sea el que está en falta. El hallazgo se informa sobre el documento de la Release en su conjunto por la misma razón: nombrar un límite dentro de él te enviaría a un documento que quizá no aportó nada a la ruta.
Donde colisiona más de una ruta, los hallazgos llegan juntos bajo un informe que indica lo que tienen en común:
assembled output paths written by more than one contributor (rutas de la salida ensamblada escritas por más de un contribuidor)
Cómo corregirlo: renombra el archivo emitido en la Recipe que controles — una clave de artifacts:, la clave de un bloque boundary:, o el nombre de archivo que deriva una traducción de Workload — para que los dos ya no coincidan. Donde dos Recipes declaran un mismo archivo compartido y se refieren a la misma configuración, haz que sus declaraciones sean idénticas byte a byte. Donde los dos contribuidores pertenecen realmente a salidas separadas, da a sus límites rutas directory: distintas para que cada uno se ensamble por separado.
The same name is derived more than once inside the output (El mismo nombre se deriva más de una vez dentro de la salida)
Un ensamblado acaba usando el mismo nombre dos veces para algo dentro de los archivos que emite, en un lugar donde solo cabe uno. Ocurre de dos maneras: dos contribuidores derivan el mismo nombre, o la salida propia de un único contribuidor lleva ese nombre dos veces. Esto es distinto de las dos colisiones anteriores: donde intervienen dos contribuidores, los componentes tienen nombres distintos y sus archivos acaban en rutas distintas, así que nada en la estructura del ensamblado está mal — es un nombre en el contenido, como el identificador que un destino usa para direccionar un recurso, o el nombre con el que se publica una salida para que otra haga referencia a ella.
Qué nombres se comparan depende de lo que el proveedor hace con la salida de un ensamblado. Donde el proveedor fusiona esa salida en un único documento — una plantilla de stack, un archivo compose —, los nombres dentro de ese documento se comparan entre sí, y un contribuidor cuya salida se escribe como archivos separados propios queda fuera de él. Sus nombres no coinciden con los de nadie más, así que nada se detiene entre ellos, y nada que pudieras renombrar cambiaría eso. Donde, en cambio, el proveedor escribe la salida de cada contribuidor como archivos propios — un renderizado de chart, un conjunto de manifiestos —, cada contribuidor al ensamblado se compara con todos los demás, porque un nombre en una salida así es único en todo lo que lee esos archivos como conjunto, y no dentro de un solo archivo.
Los recursos propios de una FeatureRecipe siguen el mismo camino que los de su componente anfitrión, porque una vinculación contribuye al ensamblado al que pertenece su anfitrión. Así que, donde el proveedor fusiona, los nombres de una vinculación se comparan con los de su componente anfitrión y con los de cada otra vinculación, exactamente como los nombres de dos componentes: todos acaban dentro del único documento, y de dos nombres iguales uno desplaza al otro allí. Donde el proveedor no fusiona, los recursos de la vinculación se escriben bajo un directorio que nombra el componente al que está vinculada, y sus nombres se siguen comparando con cada contribuidor al ensamblado — que es donde se detecta una identidad de recurso que tiene que ser única en todo un clúster. La comparación es, por tanto, la misma en ambos casos, y lo único que difiere es dónde acaba el nombre que quedaría desplazado.
Una mitad de la detención no se ve afectada por nada de esto: la salida propia de un único contribuidor que lleva un nombre dos veces. Es un nombre usado dos veces dentro de una salida que escribió un solo contribuidor, así que detiene la compilación dondequiera que se escribiera esa salida, y las dos cosas que hay que separar están siempre dentro de ella.
La mayoría de esos nombres son propios de un proveedor, derivados de la instancia de componente y del recurso, así que dos componentes pueden llegar a un mismo nombre siempre que coincidan las partes de las que se deriva — y un componente puede llegar dos veces a un mismo nombre de la misma manera, cuando dos de sus propios recursos se construyen a partir de partes que coinciden. Como el nombre vive en los propios bytes del archivo, el ensamblado no puede verlo: el proveedor informa de los nombres que derivó, y la compilación los compara.
Un tipo de nombre es propio de la compilación y no de un proveedor, y se informa de la misma manera: la identidad con la que se etiqueta cada recurso que emite una FeatureRecipe, que llega a tu salida como la etiqueta aggrega.ai/component-id. Se informa bajo el tipo de nombre component-id, para que puedas encontrar la misma cadena en tu propia salida emitida. Donde una FeatureRecipe sintetiza sus recursos, esa identidad es también aquello por lo que se nombran; donde renderiza un chart o un fragmento proporcionado por su autor, los nombres dentro de ese renderizado siguen siendo los del componente anfitrión y solo las etiquetas llevan la identidad.
Para una funcionalidad vinculada a un componente, se compone a partir del componente al que está vinculada la funcionalidad y de la clave que escribiste bajo features:, tras un prefijo fijo. El componente anfitrión forma parte del valor porque un mismo nombre de funcionalidad vinculado a varios componentes emite un conjunto separado de recursos en cada uno, y cada conjunto necesita una identidad propia.
Para una funcionalidad vinculada a un límite, se compone a partir del nombre de la funcionalidad y de cada segmento de la ruta del límite, tras un prefijo propio. Ambos casos componen en lugar de sustituir: un carácter que el alfabeto de etiquetas rechaza se transcribe en lugar de reemplazarse, y las partes se unen con una secuencia que ninguna parte escrita puede contener, así que dos vinculaciones que puedes distinguir siempre llegan a dos identidades. El único residuo es la longitud: una identidad compuesta demasiado larga para el valor de una etiqueta se acorta en torno a un digest de su totalidad, y dos identidades acortadas pueden, en principio, coincidir. Esta detención informa de una coincidencia así entre dos contribuidores cuyos nombres se comparan, y dos vinculaciones en un componente son dos contribuidores de ese tipo dondequiera que el proveedor de su anfitrión las ensamble juntas. Consulta ../providers/well-known-annotations.md para ver cómo se construye cada una.
Un renderizado de Kubernetes informa de un tipo de nombre propio: el nombre que lleva en su metadata.name cada recurso que produce su propio renderizado. Un nombre así tiene que ser único dentro de su kind — y, para un tipo que el clúster mantiene en namespaces, dentro de su namespace — en lugar de en toda la salida, así que el tipo de nombre indica a cuál de esos ámbitos se limita. Empieza por resource-names y luego lleva el kind del recurso y el namespace en el que acaba el recurso, que es el que el recurso nombra para sí mismo o, donde no nombra ninguno, aquel con el que está anotado el límite. Así, resource-names:Service--default son los nombres de los Services que acaban en default. Un tipo que la API de Kubernetes mantiene fuera de todo namespace — un ClusterRole, una StorageClass, una CustomResourceDefinition — y un tipo personalizado que una CustomResourceDefinition del mismo renderizado declara con el ámbito Cluster llevan solo su kind, sea cual sea el namespace que escriba su documento: resource-names:ClusterRole son los nombres de cada ClusterRole que lleva la salida. Todo lo que queda fuera de las letras y los dígitos se transcribe en lugar de reemplazarse y las dos partes se unen con una secuencia que ninguna parte escrita puede contener, así que dos pares distintos nunca llegan a un mismo tipo de nombre, y un tipo por sí solo nunca llega al tipo de nombre de un tipo y un namespace. Un Service y un Deployment pueden compartir un nombre, y dos namespaces contienen un mismo nombre de un tipo con namespace de forma independiente, así que ninguno de esos casos detiene la compilación. El nombre en sí se informa exactamente como lo escribió tu chart, lo que lo convierte en la cadena que buscar en tus plantillas.
Así, dos contribuidores a una misma salida que escriben cada uno un mismo objeto de alcance de clúster con un mismo nombre detienen la compilación incluso donde la Release los coloca en dos namespaces, porque aplicar ambos escribe ese único objeto dos veces; y un chart que escribe un objeto así bajo dos namespaces distintos, que el renderizado emite como dos archivos, la detiene como un único contribuidor que lleva el nombre dos veces. Un tipo que nada en el renderizado clasifica — un tipo personalizado cuya CustomResourceDefinition el renderizado no emite, o un documento que no nombra ningún apiVersion — se compara dentro de su namespace, como un tipo con namespace, porque nada en el renderizado dice que el clúster lo mantenga fuera de uno; por tanto, dos contribuidores que escriben un objeto así en dos namespaces no coinciden.
Los nombres se comparan entre los contribuidores a una misma salida, y nunca entre dos salidas. Dos límites son dos salidas cuando cada uno tiene un directorio propio — uno que nombra, o el que se asigna a cada límite que no nombra ningún directory: — y nada en una compilación indica si dos salidas se aplican a un mismo clúster o a dos: la CustomResourceDefinition de un mismo operador enviada a cada uno de dos clústeres es el mismo nombre en dos salidas, y es correcto. Así, dos límites que escriben cada uno un mismo objeto de alcance de clúster con un mismo nombre no detienen la compilación incluso donde ambos se aplican a un mismo clúster; donde es así, emite el objeto desde solo uno de ellos.
La disposición que llega a esta detención con más frecuencia es la de dos Features vinculadas a un mismo componente, cada una de las cuales entrega un chart proporcionado por su autor. Ambos charts se renderizan con el mismo nombre de release — el del componente anfitrión, para que vincular un chart no renombre recursos que su autor ya declaró y desplegó — y nombrar un recurso según el nombre de release es una de las cosas más comunes que hace un chart. Nada en la estructura de la salida está mal: los dos recursos simplemente llevan un mismo nombre. Donde el proveedor del componente escribe documentos separados, cada vinculación escribe bajo un directorio propio y aplicar ambas deja la que se aplicó en último lugar; donde reúne su grupo en un único documento, ambas vinculaciones contribuyen a ese documento y uno de los dos nombres desplaza al otro dentro de él. Renombra el recurso en el chart que controles, o dale un nombre que lleve algo que distinga las dos vinculaciones — y es la vinculación la que tiene que llegar a la plantilla, porque ambos charts se renderizan con el nombre de release del anfitrión, así que renombrar solo la vinculación no cambia nada. Pasa .attachment_name al chart a través del valuesMapping: de la FeatureRecipe, y establécelo en aquel de los valores propios del chart a partir del cual se construyen los nombres de sus recursos.
Una segunda disposición llega a la misma detención con una sola Feature en lugar de dos: un chart cuya plantilla escribe un nombre de recurso como literal, vinculado a dos componentes. Cada anfitrión lo renderiza con un nombre de release propio, así que el literal es la única razón por la que las dos copias llevan un mismo nombre — nombra el recurso según .Release.Name y el anfitrión vuelve a estar en él, que es lo que ya hace un chart que construye los nombres de sus recursos a partir de su identidad de release.
Una tercera disposición tiene la misma estructura, una superficie de autoría más adentro: una FeatureRecipe que entrega sus recursos mediante artifacts: en lugar de mediante un chart, vinculada con un mismo nombre a dos componentes, cuyo cuerpo escribe un nombre de recurso como literal. La salida de cada vinculación acaba bajo un directorio que nombra su anfitrión, así que las rutas emitidas difieren y nada en la estructura de la salida está mal — pero ambos cuerpos llevan el mismo nombre, y aplicar ambos deja el que se aplicó en último lugar. Un nombre en un cuerpo de artifacts se compara exactamente como un nombre que renderizó un chart: los dos describen el mismo recurso en el mismo clúster, así que de dónde vino el nombre no cambia nada de lo que ocurre cuando se aplican ambos. Esa lectura se basa en que los dos nombres se lean juntos, que es lo que ocurre donde un proveedor escribe la salida de cada contribuidor como archivos que un destino lee como un único conjunto. Donde, en cambio, el proveedor fusiona la salida de un ensamblado en un único documento, los archivos de cada vinculación quedan fuera de ese documento y un nombre dentro de uno de ellos se limita a él, así que dos vinculaciones así nunca coinciden y la compilación continúa.
No se informa de todos los nombres, así que una compilación que no se detiene no ha establecido que se haya comparado cada nombre que su salida acabará llevando. Un recurso cuyo nombre se deja al clúster — uno que declara generateName en lugar de name — todavía no lleva ningún nombre, así que no hay ninguno que informar. Y un nombre escrito en algún otro campo para que un controlador lo lea más tarde no es un nombre de recurso, así que nada lo compara. Ambas limitaciones son propiedades de la lectura del documento emitido, así que ambas se aplican a un cuerpo de artifacts exactamente igual que a una plantilla de chart renderizada.
Un cuerpo de artifacts: es una plantilla, así que un nombre dentro de él que tiene que ser distinto en cada anfitrión se compone en lugar de escribirse como literal. .context.rendered_name es el nombre que le da el propio proveedor del componente anfitrión — bajo helm, su nombre de release, escrito con los caracteres que admite un nombre de Kubernetes — y .attachment_name es la clave con la que lo vinculaste, así que {{ .context.rendered_name }}-{{ .attachment_name }} da a un recurso un nombre propio en cada anfitrión y bajo cada vinculación. En un anfitrión cuyo proveedor no informa de ningún nombre así, compónlo en su lugar a partir de .context.instance_id, la identidad del anfitrión. Un mismo cuerpo escrito llega a cada anfitrión al que está vinculado llevando los nombres que contenga, y un literal es el mismo en todos ellos — así que da esa estructura a un nombre que tenga que ser único en el clúster.
Nada del significado de un nombre se interpreta — dos nombres informados son el mismo texto o no lo son —, y por eso el mismo informe cubre todo tipo de nombre, lo haya derivado quien lo haya derivado.
Un nombre puede aparecer en más de un informe para un mismo componente, porque cada parte de un componente se informa a medida que se renderiza. Es un único recurso nombrado en cada informe al que pertenece, no un nombre usado dos veces, y no detiene la compilación. Lo que la detiene es un único informe que lleva un nombre dos veces, porque ese informe describe una salida en la que el nombre se usa realmente dos veces.
Esa lectura depende de lo que cuenta como un único contribuidor, y para el tipo component-id la respuesta es la vinculación y no el componente o el límite en el que se encuentra. Una vinculación se identifica por las dos coordenadas que escribiste para ella — el componente al que está vinculada junto con la clave bajo features:, o la ruta del límite junto con el nombre en ese límite —, así que dos vinculaciones en un componente son dos contribuidores, exactamente igual que dos en componentes distintos, y un nombre de funcionalidad escrito en dos límites son dos contribuidores aunque el nombre sea el mismo en cada uno. Ser dos contribuidores es lo que hace comparables sus identidades en cada una de esas disposiciones; si dos de ellos llegan a compararse sigue la misma regla que cualquier otro nombre aquí, así que, donde el proveedor fusiona, una vinculación cuya salida se escribe como archivos separados propios queda fuera del documento fusionado y solo se compara consigo misma. Por tanto, dos vinculaciones que llegan a una misma identidad detienen la compilación dondequiera que su salida pueda alcanzar la de la otra, y cada hallazgo nombra sus dos coordenadas para que puedas saber qué dos cosas separar. Como ambas coordenadas forman parte del valor compuesto, dos vinculaciones que puedes distinguir llegan a dos identidades con cualquier longitud que quepa — así que la disposición que llega a esta detención es aquella en la que un valor demasiado largo para su destino se acortó y dos valores acortados coincidieron. Donde dos identidades acortadas coinciden y su salida no puede alcanzar la de la otra — dos vinculaciones en un componente, bajo un proveedor que fusiona, cada una escrita como archivos separados propios —, nada las compara, y los dos conjuntos de recursos llevan entre ambos un mismo aggrega.ai/component-id.
Hay una disposición que conviene enunciar expresamente porque parece que debería detener la compilación y no lo hace: vincular una funcionalidad con el mismo nombre en dos componentes está totalmente admitido y no requiere ningún cambio de nombre. El componente forma parte del valor compuesto, así que metrics en api y metrics en web llegan a dos identidades y los recursos de cada componente reciben una identidad propia — lo cual importa porque una cascada que, por diseño, acuña un mismo nombre de vinculación en muchos componentes no le deja a un autor ningún otro nombre que escribir. Toda forma en que una FeatureRecipe entrega recursos pone su identidad en lo que emite, incluida la que solo incorpora una fuente y la renderiza tal cual, así que todas ellas se comparan; una funcionalidad cuya FeatureRecipe no emite nada en absoluto no tiene nada que comparar.
La compilación se detiene en lugar de conservar uno y descartar el otro. No hay ninguna resolución silenciosa correcta: conservar el primero eliminaría por completo de la salida un recurso que declaraste y dejaría la compilación informando de un éxito, y todo lo que hiciera referencia al eliminado se resolvería discretamente al que sobrevive. Se informa cada nombre en colisión, cada uno con el tipo de nombre que es y con cada contribuidor que lo derivó nombrado — de modo que una sola compilación te da el panorama completo en lugar de una colisión cada vez. Un contribuidor cuya salida propia lleva el nombre dos veces se nombra como habiendo derivado el nombre más de una vez, que es lo que te indica que las dos cosas que hay que separar están dentro de ese único componente y no entre dos de ellos.
Mensajes emitidos. Se informa un hallazgo por cada contribuidor y por cada nombre en colisión, de modo que cada contribuidor que derivó el nombre se nombra por separado en lugar de agruparse en una lista dentro de un único mensaje. Donde dos contribuidores derivaron el nombre hay al menos dos hallazgos, y llegan juntos bajo un informe que indica lo que tienen en común:
dispatch groups whose contributors derive one name more than once in one key space (grupos de despacho cuyos contribuidores derivan un mismo nombre más de una vez en un mismo espacio de claves)
Cada hallazgo nombra el nombre, el tipo de nombre que es, el contribuidor que lo derivó, y el proveedor y la ruta del ensamblado en el que se fusiona su salida:
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>") (colisión de nombres derivados: un mismo nombre se deriva más de una vez en un mismo espacio de claves (con el nombre, el espacio de claves, el componente que lo derivó, el proveedor y la ruta de despacho indicados))
El contribuidor se nombra según lo que es, que es lo que indica dónde está escrito su nombre: derived by component para una instancia de componente, y derived by feature para una funcionalidad vinculada a un límite.
Donde el nombre propio del contribuidor no lo identifica por sí solo, sigue una segunda coordenada, y cuál es depende del tipo. Una funcionalidad vinculada a un límite lleva la ruta del límite, porque un mismo nombre de funcionalidad puede escribirse en más de un límite:
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>") (colisión de nombres derivados: un mismo nombre se deriva más de una vez en un mismo espacio de claves (con el nombre, el espacio de claves, la funcionalidad que lo derivó, el límite al que está vinculada, el proveedor y la ruta de despacho indicados))
Un componente lleva la clave de la vinculación cuyo renderizado derivó el nombre, porque un componente lleva una vinculación por cada clave que escribiste:
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>") (colisión de nombres derivados: un mismo nombre se deriva más de una vez en un mismo espacio de claves (con el nombre, el espacio de claves, el componente que lo derivó, la vinculación que lleva, el proveedor y la ruta de despacho indicados))
El renderizado propio de un componente — un nombre que su proveedor derivó para el propio componente y no para una de sus vinculaciones — no lleva ninguna segunda coordenada, así que el hallazgo termina en el nombre del componente.
Donde la salida propia de un único contribuidor lleva el nombre dos veces, ese único contribuidor es el único hallazgo, así que llega solo, sin ningún informe por encima — y se nombra como habiendo derivado el nombre más de una vez, en lugar de como habiendo coincidido con otro contribuidor:
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>") (colisión de nombres derivados: un mismo nombre se deriva más de una vez en un mismo espacio de claves (con el nombre, el espacio de claves, el componente que lo derivó más de una vez, el proveedor y la ruta de despacho indicados))
La segunda coordenada sigue aquí al contribuidor en los mismos términos que arriba, así que una repetición dentro de la salida propia de una vinculación nombra esa vinculación y no solo el componente que la lleva.
Cómo corregirlo: donde se nombran dos contribuidores, renombra uno de ellos en el Aggregate, para que los nombres derivados de él ya no coincidan con los del otro. Donde el tipo de nombre es component-id, cada hallazgo ya nombra lo que hay que renombrar: carrying attachment "…" es la clave bajo el bloque features: de ese componente, y un feature "…"attached at boundary "…" es el nombre bajo el bloque features: de ese límite. Donde los dos hallazgos solo difieren en el límite que nombran, las dos vinculaciones llevan un mismo nombre en dos límites — renombra una de ellas, o da a los dos límites rutas directory: distintas para que su salida ya no se fusione. Donde los dos nombres son nombres que compuso la compilación, solo pueden haber coincidido después de acortarse para caber en el destino, así que acorta tú mismo las partes de las que se componen en lugar de dejar que lo haga la compilación. Donde ambos nombres se derivan de algo que estableciste explícitamente — un valor que la Recipe pasa al proveedor, o una anotación que lee el proveedor —, cambia eso en su lugar en aquel de los dos que controles. Donde los dos contribuidores pertenecen realmente a salidas separadas, da a sus límites rutas directory: distintas para que cada uno se ensamble por separado y los dos nombres nunca coincidan. Donde un único contribuidor se nombra como habiendo derivado el nombre más de una vez, las dos cosas en colisión están ambas dentro de ese único componente: busca los dos recursos que produce su Recipe cuyos nombres coinciden, y cambia aquello según lo cual se nombra uno de ellos — la clave bajo la que se declara, o un valor a partir del cual se construye — para que el proveedor derive un nombre distinto para cada uno. Donde el tipo de nombre es solo un tipo de alcance de clúster, como resource-names:ClusterRole, los documentos nombrados describen un único objeto en el clúster, sean cuales sean los namespaces en los que se colocaron: emítelo desde un solo contribuidor — mediante un valor que ofrezca su chart, como un interruptor para instalar sus definiciones — o, donde los dos deban ser dos objetos, da a uno de ellos un nombre propio en el chart o el cuerpo que controles; un único contribuidor nombrado dos veces por él lo escribe bajo dos namespaces, y uno de los dos documentos es el que hay que eliminar.
An authored export name is one the build derives for a cross-stack reference (Un nombre de exportación escrito es uno que la compilación deriva para una referencia entre stacks)
El bloque Outputs: de una Recipe cloudformation es CloudFormation escrito por el autor, y una entrada en él puede llevar su propio Export: con un Name:; ese nombre llega al stack ensamblado exactamente como está escrito. Por otro lado, cuando una arista uses cruza de un límite a otro, el proveedor publica el valor consumido como un Output del stack con un Export bajo un nombre que deriva de la release, el límite, el componente y la clave proporcionada. Esta detención se produce donde ambos coinciden: el nombre que escribiste es el nombre que la derivación produjo para la misma compilación, así que el stack declararía un mismo nombre de exportación dos veces desde dos lugares, y un nombre de exportación tiene que ser único.
Solo la coincidencia detiene la compilación. Declarar un nombre de exportación en una entrada Outputs está admitido, y uno que no coincide con ningún nombre derivado se publica junto a los derivados sin comentarios — en toda entrada salvo la salida del stack en la que una referencia entre stacks publica su propia exportación, para una clave que consume. Un Export: ahí detiene la compilación a menos que lleve exactamente el nombre derivado; ese caso es The output a cross-stack reference publishes on already carries an Export (La salida en la que publica una referencia entre stacks ya lleva un Export).
La detención da el nombre de exportación derivado junto con las cuatro partes a partir de las que se construyó, para que puedas ver qué referencia entre límites lo produjo, y nombra la salida del stack bajo la que está tu declaración — marcada como un nombre que ensambla el proveedor y no como uno que escribió una Recipe, porque el proveedor construye ese nombre codificando el componente y la entrada en las letras y los dígitos que admite un ID lógico, así que no es la cadena con la que se escribió ninguno de los dos. El nombre de exportación es la parte que buscar. Tu entrada lo escribe exactamente como la detención, que es lo que convierte a los dos en una colisión, así que es la única cadena que aparece tanto en el mensaje como en tus propios archivos.
La comparación se limita a un único stack: los nombres de exportación que declara ese stack, frente a los nombres derivados para las referencias entre límites que publican en él. Dos stacks no se comparan entre sí, y un nombre de exportación escrito como función intrínseca de CloudFormation se resuelve en el momento del despliegue, así que no hay ningún nombre que comparar. Con qué se encuentra un nombre entre las exportaciones ya desplegadas en una cuenta y una región es una propiedad del despliegue, que una compilación no observa.
Mensaje emitido. La condición nombra el tipo de fallo y la frase propia del proveedor dice qué ocurrió; el informe que la rodea también nombra la arista uses que se está cableando:
two things a plugin produced occupy one name in its output (dos cosas que produjo un plugin ocupan un mismo nombre en su salida) 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 nombre de exportación que deriva un enlace entre límites ya está declarado por otra entrada Outputs del mismo stack: el enlace deriva el nombre de exportación indicado para la clave provides indicada del componente indicado en el límite indicado de la Release indicada, y otra entrada Outputs del mismo stack ya declara ese mismo nombre de exportación — esa declaración está bajo la salida del stack indicada, un nombre que este proveedor ensambla y no uno que escribió una Recipe; cada entrada Outputs que lo oculta escribe su nombre de exportación exactamente como la detención, así que buscar ese nombre en tus Recipes lleva a la entrada — renombra el nombre de exportación que declara la entrada, o elimina el bloque Export de esa entrada y deja que el enlace publique la exportación)
Cómo corregirlo: busca en tus Recipes el nombre de exportación que nombra la detención — la entrada Outputs que lo declara lo escribe de forma idéntica — y luego renombra ese nombre de exportación para que ya no coincida, o elimina el bloque Export: de esa entrada y deja que el cableado entre stacks publique la exportación por sí mismo. Eliminarlo suele ser lo correcto donde la entrada existía para exportar el mismo valor que consume la arista: el proveedor publica un Export para ese valor de todos modos, así que el escrito por el autor no aporta nada. Conserva en cambio el Export: escrito y renómbralo donde la entrada exporta el valor para otro consumidor que lo importa con un nombre que elegiste.
The output a cross-stack reference publishes on already carries an Export (La salida en la que publica una referencia entre stacks ya lleva un Export)
Cuando una arista uses pasa de un límite a otro, el proveedor publica el Export del valor consumido en la salida del stack que ensambla para el componente productor y la clave proporcionada — la misma salida que alcanza una Recipe de cloudformation cuando su bloque Outputs: escribe una entrada bajo esa clave. Un Export: que ya está en esa salida solo se conserva cuando su Name: es exactamente el nombre que deriva el proveedor: esa es la exportación que una referencia entre stacks anterior al mismo valor ya publicó, así que todo consumidor importa ese único nombre. Cualquier otro Export: en ese punto detiene la compilación, porque escribir la exportación del proveedor sobrescribiría lo que escribiste, y conservar el tuyo dejaría a todo consumidor importando un nombre que la referencia nunca publicó.
La detención se produce ante cuatro formas de Export: en esa salida:
un Name: que es una cadena distinta;
un Name: escrito como función intrínseca de CloudFormation, que se resuelve en el momento del despliegue, así que el proveedor no puede leer lo que expresa;
un bloque Export: que no nombra nada;
un Export: escrito como valor simple en lugar de como bloque.
Mensaje emitido. La condición nombra el tipo de fallo y la frase propia del proveedor dice qué ocurrió; el informe que la rodea también nombra la arista uses que se está cableando:
two things a plugin produced occupy one name in its output (dos cosas que produjo un plugin ocupan un mismo nombre en su salida) 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 salida del stack en la que un enlace entre límites publica su exportación ya lleva un Export que el enlace no escribió: el enlace deriva el nombre de exportación indicado para la clave provides indicada del componente indicado en el límite indicado de la Release indicada, y la salida del stack que este proveedor ensambla para esa clave y ese componente presenta lo indicado; elimina el bloque Export de esa entrada y deja que el enlace publique la exportación que importa todo consumidor)
<what-it-found> es uno de los siguientes, en el orden de las formas anteriores:
already declares the export name <name> (ya declara el nombre de exportación indicado) 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 (ya declara un nombre de exportación que no es una cadena — uno dado como función intrínseca, que se resuelve en el momento del despliegue, así que este proveedor no puede leer lo que expresa) already carries an Export block declaring no export name (ya lleva un bloque Export que no declara ningún nombre de exportación) already carries an Export that is not a block, where CloudFormation expects one carrying a Name (ya lleva un Export que no es un bloque, donde CloudFormation espera uno que lleve un Name)
Cómo corregirlo: en la Recipe del componente que nombra la detención, busca la entrada Outputs escrita bajo la clave proporcionada que nombra, y elimina el bloque Export: de esa entrada — el cableado entre stacks publica entonces la exportación que importa todo consumidor. Si además necesitas que el valor se exporte con un nombre propio, para un consumidor ajeno a esta compilación, escribe ese Export: en una entrada Outputs bajo otra clave: ahí un nombre de exportación está admitido, siempre que no sea uno que la compilación deriva.
Chart-name mismatch on a merged helm-chart umbrella (Nombre de chart discordante en un chart paraguas helm-chart fusionado)
Dos o más límites contribuyen a la misma ruta de ensamblado del proveedor helm-chart, pero sus anotaciones aggrega.ai/chart-name efectivas (resueltas a través de la cascada de anotaciones de los límites) no coinciden. Un chart paraguas de Helm tiene exactamente un nombre de chart; el renderizador no puede elegir uno de los candidatos en conflicto.
Mensajes emitidos. Se informa un hallazgo por cada límite contribuidor, cada uno con el valor al que se resolvió ese límite, así que los nombres discordantes llegan uno por hallazgo en lugar de como una única colección impresa. El informe bajo el que llegan indica lo que tienen en común:
merged dispatch groups whose boundaries disagree on the assembly name (grupos de despacho fusionados cuyos límites no coinciden en el nombre de ensamblado)
Cada hallazgo nombra el valor al que se resolvió ese límite, la anotación de la que se leyó, el límite, el proveedor y la ruta en la que se fusionan:
merged-path assembly has conflicting assembly-name annotation values ("<value>", annotation "<annotation>", boundary "<boundary>", provider "<provider>", dispatch path "<path>") (el ensamblado de ruta fusionada tiene valores en conflicto para la anotación del nombre de ensamblado (con el valor, la anotación, el límite, el proveedor y la ruta de despacho indicados))
Cómo corregirlo: declara una anotación aggrega.ai/chart-name coincidente en cada límite contribuidor (el mecanismo de cascada lo hace DRY cuando los contribuidores comparten un límite padre — decláralo una vez en el padre), o separa los límites en rutas directory: distintas para que cada uno obtenga su propio chart paraguas.
FeatureRecipe template references a field outside its scope’s allowlist (La plantilla de FeatureRecipe hace referencia a un campo fuera de la lista de permitidos de su nivel)
Una FeatureRecipe con executionScope: boundary hace referencia a un campo exclusivo de cada componente como .context.instance_id, .context.inject o .context.uses — campos que no tienen un valor significativo en el nivel de límite — en una plantilla que se ejecuta una sola vez para el límite: sus locals:, provides:, valuesMapping:, artifacts: o el with: o el when: de un paso de pipeline. La condición simétrica también se cumple: una FeatureRecipe de nivel de componente (el valor predeterminado) que hace referencia a campos .boundary.* no supera el mismo validador. La validación se ejecuta en el momento del análisis frente a la lista de permitidos de campos del nivel correspondiente, antes de que empiece cualquier trabajo de renderizado. El injectMapping de una FeatureRecipe de nivel de límite no se comprueba aquí: se ejecuta una vez por cada componente al que llega la vinculación, en el contexto de ese componente, así que lee .context.*, y una referencia a .boundary en él se informa mediante «Template references a root the render context does not define (La plantilla hace referencia a una raíz que el contexto de renderizado no define)» más arriba.
Mensaje emitido:
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>") (la plantilla de FeatureRecipe hace referencia a un campo exclusivo de cada componente con executionScope: boundary (con la ruta indicada, escrita en el campo indicado; el contexto de renderizado define las raíces indicadas))
Una FeatureRecipe de nivel de límite cuyo valuesMapping lee .context.instance_id imprime:
[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")
Cómo corregirlo: reescribe la plantilla en función de los campos disponibles en el nivel, o cambia el executionScope de la FeatureRecipe. Las FeatureRecipes de nivel de límite hacen referencia a .boundary.path, .boundary.boundary_name, .boundary.components, las colecciones .boundary.*_uses_edges, .boundary.labels, .boundary.annotations y .boundary.feature_attachments. Las FeatureRecipes de nivel de Component hacen referencia a .context.instance_id, .context.inject, .context.uses, .context.labels, .context.annotations. Ambos niveles comparten .values, .infra, .locals, .provides, .steps y .metadata. Un parámetro de la Release no es un pilar propio en esta superficie — llega a una plantilla de FeatureRecipe a través de una entrada values o infra que hace referencia a él.
Self-inject value template references cross-node data (La plantilla del valor de self-inject hace referencia a datos entre nodos)
Una plantilla inject:value: a nivel de componente toma datos de .context.inject o .context.uses. El canal de inject es precisamente lo que esta pasada está construyendo — una plantilla dentro del valor de self-inject propio de un componente no puede leer de él.
Es el .context de la superficie lo que lo determina: lleva instance_id, labels y annotations, y nada más. .context.inject y .context.uses son, por tanto, claves que el contexto de esta superficie no define, y la referencia detiene la compilación como «Template references a root the render context does not define (La plantilla hace referencia a una raíz que el contexto de renderizado no define)» más arriba, en el momento del análisis, antes de que se renderice nada. El diagnóstico nombra el mecanismo y la clave de entrega a los que pertenece la plantilla, y enumera las claves que .context sí define aquí — así que el mismo informe cubre tanto un intento real de alcanzar datos entre nodos como una simple errata como {{ .context.nmae }}, que es el error más común y que de otro modo se habría renderizado como nada.
Mensaje emitido — el detalle a nivel de referencia; el informe que lo rodea también nombra el nodo, el mecanismo y la clave de entrega:
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) (la plantilla hace referencia a una raíz que el contexto de renderizado no define (la plantilla de self-inject indicada hace referencia a la ruta indicada, el contexto define las claves indicadas))
Cada marco del informe pertenece al dominio del desarrollador, porque un bloque inject: a nivel de componente se escribe en el Aggregate.
Cómo corregirlo: traslada el cableado entre componentes a una entrada uses[].inject — ahí es donde está disponible el contexto entre nodos. Mantén las plantillas value: de self-inject a nivel de componente cerradas sobre los values y la infra propios del componente, sus .context.instance_id / .context.labels / .context.annotations, y .metadata.
Missing template key — asymmetric policy (Clave de plantilla ausente — política asimétrica)
El tratamiento de las claves ausentes depende de la superficie de plantilla. Donde un renderizado vacío acaba en un lugar acotado — un campo de manifiesto que el autor puede volver a leer — la ausencia se tolera y la lectura no renderiza nada. Donde, en cambio, un renderizado vacío produciría una estructura errónea o un veredicto erróneo, la superficie rechaza la referencia en lugar de resolverla en nada.
La interpolación de parámetros en un Aggregate — las referencias {{ .parameters.<key> }} que lleva el texto propio del Aggregate — es la primera de estas superficies: se ejecuta sobre el documento en bruto antes de que se resuelva el catálogo, así que su política se aplica a texto que ninguna otra superficie ha visto todavía. Una referencia a un parámetro que la Release nunca rellenó se renderiza como nada, y un pipe default o una guarda if sobre una lectura así se comporta exactamente igual que sobre el parámetro sin rellenar. Una referencia que la plantilla itera sigue iterando como nada, que es lo que busca un range sobre una lista opcional — salvo que el texto también la imprima, en cuyo caso detiene la compilación como describe «A template reads and iterates a path that holds nothing (Una plantilla lee e itera una ruta que no contiene nada)» más abajo. Una referencia cuyo padre está ausente — .parameters.db.host donde no se rellenó ningún parámetro db — sigue deteniendo la compilación, porque no hay nada en lo que descender y aportar un padre cambiaría la detención por un artefacto erróneo en silencio. Una limitación merece enunciarse como limitación y no como política: una referencia anclada en una raíz que la superficie no define se deja tal cual en lugar de renderizarse como nada, así que sobrevive en el documento interpolado como el texto de marcador de posición propio del motor de plantillas, <no value>. Nada en esta superficie detiene la compilación por ello, así que ancla toda referencia a parámetros en .parameters, y lee un <no value> suelto como una raíz mal escrita.
Las plantillas de ruta (directory: / subDirectory: de los límites de la Release) se evalúan con missingkey=error. Una referencia a una variable que la superficie no les da detiene la compilación en el momento del análisis — consulta «Path-template references a variable outside the allowlist (La plantilla de ruta hace referencia a una variable fuera de la lista de permitidos)» más arriba — y lo mismo ocurre con una clave mal escrita bajo .manifest, cuyas claves están declaradas. Una referencia permitida pero no definida en el momento de la evaluación, como una clave de .parameters que la Release no aporta, produce un error explícito en lugar de renderizar en silencio una cadena vacía en una ruta de directorio.
Las assertions (en un Component, una Feature, una Recipe o una FeatureRecipe) se evalúan con missingkey=error. Una referencia a una clave no definida detiene la compilación con un diagnóstico de clave inexistente que nombra la entidad, la instancia y la aserción. La rigurosidad es lo que hace fiable una aserción: un predicado cuya referencia se renderizara como un valor vacío compararía contra nada y pasaría, así que una sola errata retiraría en silencio la regla que la aserción se escribió para hacer cumplir. Como la referencia sola detiene la compilación antes de que pueda ejecutarse cualquier respaldo, un default simple no aporta un respaldo para un campo opcional en esta superficie — protege la referencia con hasKey, o usa el helper optional, que realiza directamente la comprobación de presencia. Leer la clave a través de index tampoco aporta uno: index detiene la compilación ante una clave de mapa que el mapa no contiene, nombrando la clave.
Las plantillas de valores (valuesMapping de la Recipe, entradas locals: y provides:, cuerpos de artifacts:, cuerpos de Workload, injectMapping y pipeline.with de la FeatureRecipe, y plantillas value: de self-inject a nivel de componente) se evalúan con missingkey=zero, así que una referencia a una clave no definida no detiene la compilación — la lectura no renderiza nada, y nada es lo que llega al artefacto. Lo que sí sigue deteniendo la compilación en esta superficie es una referencia que desciende a través de un contenedor que el autor nunca aportó — .values.tls.ca donde no se escribió ningún tls — porque no hay nada en lo que descender. Solo la clave final de una referencia cuyos contenedores están todos presentes se renderiza como nada. Un campo de primer nivel que el contexto define pero para el que no contiene nada — .workload en una Recipe que no sintetiza ninguno, .features en un componente sin vinculaciones — se renderiza como nada de la misma manera cuando se lee entero. Una referencia es una sola referencia se escriba como se escriba: .values.list, $.values.list y (.values).list nombran la misma clave, así que recorrerla con range en una escritura es recorrerla en todas, y una clave leída de un pilar entre paréntesis se renderiza, o detiene la compilación, exactamente igual que la escritura directa. Una clave que la plantilla recorre con range sigue iterando como nada cuando no está definida, y una clave que la plantilla imprime y recorre a la vez detiene la compilación cuando no está definida — consulta «A template reads and iterates a path that holds nothing (Una plantilla lee e itera una ruta que no contiene nada)» más abajo. Las protecciones funcionan como se espera: {{ .values.optional_field | default "fallback" }} sí aporta el respaldo, porque un valor no definido cuenta como vacío para default y como falso para if. Quien necesite el discriminante entre ausente y cero — distinguir «clave ausente» de «clave presente y vacía» — usa el helper optional documentado en templates/sprig-functions.md, y lee una clave dada de una sola manera por plantilla: una clave que la misma plantilla también lee como .values.<key> cuenta como presente, así que optional informa su valor vacío en lugar del respaldo. Lo que esta política no cubre es una lectura a través de index: indexar un mapa con una clave que no contiene detiene la compilación nombrando la clave, aquí como en cualquier superficie — consulta «A template indexes a map with a key the map does not hold (Una plantilla indexa un mapa con una clave que el mapa no contiene)» más abajo.
Una coordenada source: — los campos con plantilla de un bloque source: estructurado en una Recipe o una FeatureRecipe (version, ref, chart, module_subdir) — se evalúa con missingkey=error. Una referencia a una clave que nada aporta detiene la compilación nombrando el campo de la fuente, en lugar de resolverse en nada: una versión o un ref vacíos fijarían un artefacto distinto del que nombró el autor, y la fijación es lo que reproduce toda compilación posterior. Esta superficie es también aquella en la que difiere el conjunto de funciones disponible, y en la que una referencia de locals: que el propio orden de escritura del bloque rechaza detiene la compilación antes de que se evalúe nada — consulta más abajo.
Los contratos de parámetros tipados detectan los casos de parámetro obligatorio ausente y de violación del contrato en la capa del contrato de parámetros, antes de que se ejecute la interpolación — consulta «Parameter type mismatch / contract violation (Tipo de parámetro no coincidente / infracción del contrato)» más arriba.
El conjunto de helpers es el mismo en las plantillas de valores, las plantillas de ruta y las aserciones: las funciones de Sprig más las propias de Aggrega (optional y capitalizedWords). El fail de Sprig está entre ellas, así que una plantilla de valores puede detener la compilación con un mensaje propio, como describe «A value template failed while it ran (Una plantilla de valores falló durante su ejecución)» más abajo; una aserción es la superficie escrita para eso, ya que detener la compilación es todo su propósito. Entre esas tres, lo que difiere es la política de claves ausentes — optional también está disponible en una plantilla de ruta, donde lee una clave de .parameters sin que la política estricta se active antes. La resolución de una coordenada source: difiere en el propio conjunto de funciones, y tiene su propia subsección más abajo. La interpolación de parámetros en un Aggregate ofrece solo las funciones de Sprig, así que ahí no está disponible ninguno de los dos helpers de Aggrega. Una función se lee igual en cada una de estas superficies, incluidas la coordenada y la interpolación: index, que detiene la compilación nombrando la clave cuando el mapa que lee no la contiene.
El mensaje que imprime una ausencia en una plantilla de ruta se cita bajo la entrada que documenta esa condición, «Path-template references a variable outside the allowlist (La plantilla de ruta hace referencia a una variable fuera de la lista de permitidos)» más arriba, así que se escribe una sola vez en lugar de repetirse aquí.
Cómo corregirlo: para las ausencias en plantillas de ruta, corrige el nombre del campo por uno de la lista de permitidos documentada en path-template-variables.md. Para una ausencia en una aserción, corrige la referencia — la mayoría de los informes son una clave mal escrita — o, donde el campo sea realmente opcional, protégela con hasKey o usa el helper optional; envolver la referencia sola en un default no eliminará la detención, porque la referencia se resuelve antes de que se ejecute el respaldo, y leerla a través de index tampoco, porque index detiene la compilación ante una clave que el mapa no contiene. Para las ausencias en plantillas de valores donde no se desea un renderizado vacío, usa el helper optional o aporta la clave ausente como una declaración parameters.* tipada en el Aggregate con un valor de la Release, como una entrada provides: de un Component de origen cableada a través de uses[].inject, o como una entrada locals: en la misma entidad.
Resolving a source: coordinate registers a narrower function set (La resolución de una coordenada source registra un conjunto de funciones más reducido)
Un bloque source: estructurado se resuelve para que el artefacto que nombra pueda fijarse, y esa resolución registra los helpers propios de Aggrega y nada más — optional y capitalizedWords están disponibles, e index detiene la compilación ante una clave de mapa que el mapa no contiene exactamente igual que cuando la Recipe renderiza; las funciones de Sprig no. De las superficies en las que una Recipe o una FeatureRecipe escribe plantillas, esta es la única cuyo conjunto de funciones difiere, así que una expresión que se renderiza correctamente en otra parte de la misma Recipe puede rechazarse aquí. El conjunto más reducido es deliberado: lo que se fija lo deciden los values y el infra que aporta el autor, y entre las funciones de Sprig hay algunas que leen el reloj, el entorno, una fuente aleatoria o la red.
Llamar a una función de Sprig en un campo source:, o en una entrada locals: que ese campo lee, detiene la compilación en el momento del análisis. El diagnóstico lleva como encabezado E0111 y nombra la entrada, el campo source: que la lee, la función que no pudo resolver y los helpers que esta superficie sí registra:
resolve: parse template at <name>:<version>.spec.locals.<key>, read by <name>:<version>.spec.source.<field>: resolve: source-template parse error (cause: template: <name>:<version>.spec.locals.<key>:1: function "<function>" not defined); a source field, and every locals entry it reads, is evaluated when the source is resolved with Aggrega’s own helpers only (optional, capitalizedWords and index), not the Sprig functions a render adds; write the value without that function, or move the value into a locals entry no source field reads (resolución: análisis de la plantilla en la entrada de locals indicada, leída por el campo source indicado: resolución: error de análisis de la plantilla de la fuente (causa: la función indicada no está definida); un campo source, y cada entrada de locals que lee, se evalúa al resolver la fuente solo con los helpers propios de Aggrega (optional, capitalizedWords e index), no con las funciones de Sprig que añade un renderizado; escribe el valor sin esa función, o mueve el valor a una entrada de locals que ningún campo source lea)
Un campo source: que llama directamente a la función se informa de la misma manera, nombrando solo el campo.
El alcance son las entradas que lee la coordenada. Resolver una coordenada evalúa cada entrada locals: que lee un campo source:, y cada entrada que a su vez lee una entrada así — y ninguna otra. Una entrada a la que no llega ningún campo source: no se evalúa, ni se analiza, ni se comprueba mientras se resuelve la fuente, así que una entrada de locals que el renderizado necesita — una que hace aritmética con las funciones de Sprig, o que nombra un recurso según .context.instance_id — no tiene ningún efecto en la fijación del artefacto; se evalúa, y cualquier fallo en ella se informa, cuando la Recipe renderiza. Qué entradas lee un campo se decide a partir de su texto, así que un campo que lee .locals de una manera que no nombra ninguna entrada concreta — {{ index .locals "version" }}, el bloque entero pasado a optional o asignado a una variable — hace que se evalúen en su lugar todas las entradas, y el diagnóstico de una entrada a la que llega de ese modo lo indica: en lugar de read by <field> dice evaluated for <field>, which reads the locals block as a whole rather than by entry, so every entry is evaluated.
Dos formas quedan fuera de esta superficie, y saber en cuál está una Recipe explica por qué la misma expresión se acepta en una Recipe y se rechaza en otra:
Un source: escrito como cadena simple — un URI o una ruta local en lugar de un mapa — se toma tal cual, así que no tiene campos que evaluar y el bloque locals: no se resuelve aquí en absoluto.
Una entidad que no declara ningún source: no resuelve ninguna coordenada, así que su bloque locals: se resuelve solo para el renderizado propio de esa entidad, donde se aplica el conjunto completo de funciones.
El contrato de orden de referencias es aquí el mismo para cada entrada que lee la coordenada. Resolver una coordenada rechaza las mismas referencias que rechaza un renderizado en cada entrada que evalúa: una entrada que lee una entrada hermana que el bloque declara más abajo, y cualquier plantilla que lee una clave que el bloque no declara. Ambas informan las condiciones documentadas más arriba bajo «locals: entry references a sibling defined later in the same block (Una entrada de locals hace referencia a una entrada hermana definida más adelante en el mismo bloque)» y «locals: key does not exist (La clave de locals no existe)» — la misma condición, con el mismo remedio, sea cual sea la resolución que la alcanzó primero — y el informe nombra el campo source: para el que se evaluó la entrada. Un fallo en una entrada que ningún campo source: lee se rechaza cuando la Recipe renderiza, bajo la misma condición.
Lo que esta superficie sí deja pasar es una entrada que una coordenada realmente no puede resolver: una que lee datos que solo existen mientras se renderiza un artefacto, siendo .context.instance_id el caso para el que existe. Una entrada así se omite, de modo que una Recipe cuya coordenada llega a una en una rama que no toma se fija igualmente. Donde la propia coordenada necesitaba esa entrada, la resolución se detiene nombrando el campo source: — el informe de clave ausente descrito más arriba para esta superficie, con el encabezado E0110 — y cita, junto a la clave que no pudo leer, por qué esa entrada no contiene ningún valor aquí:
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") (resolución: evaluación de la plantilla en el campo source indicado: resolución: fallo de evaluación de la plantilla de la fuente en el momento del bloqueo (causa: el mapa no tiene ninguna entrada para la clave indicada); lee la entrada de locals indicada, que no pudo evaluarse aquí (causa: el mapa no tiene ninguna entrada para la clave context))
Ni un campo source: ni una entrada locals: que este lea pueden leer .provides. Un bloque locals: alimenta un bloque provides: y nunca al revés, así que una plantilla en esta superficie que lee .provides se rechaza como la referencia inversa que es en lugar de resolverse en nada. El rechazo no es una ausencia en el momento del bloqueo que una fase posterior satisfaría — ningún orden hace válida la referencia — así que se informa de la misma manera dondequiera que se resuelva la coordenada. El diagnóstico lleva como encabezado E0112; nombra el campo, o la entrada y el campo que la lee, dice qué está mal en la referencia e indica la superficie que la expresión puede leer en su lugar:
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) (la plantilla de versión de la fuente en el campo source indicado hace referencia a .provides, que es una referencia inversa no válida (locals alimenta provides, nunca al revés) — refactoriza para leer solo .values e .infra (y .locals sobre los mismos): resolución: la plantilla de la fuente hace referencia a .provides (referencia inversa no válida))
Dónde aparece la detención: mientras se rellena o actualiza el lockfile — aggrega pull, o una compilación que lo rellena (--auto-pull, --upgrade o el ajuste auto_pull del espacio de trabajo). Cada fallo se informa como un único diagnóstico, encabezado por el código de lo que salió mal — E0111 para una plantilla que no se analiza, E0112 para una referencia a .provides, E0110 para una plantilla que se analizó y no pudo evaluarse — tanto en el terminal como en un editor conectado a aggrega serve. Una clave ausente en un campo source:, a diferencia de una función no disponible, se informa en el momento de la ejecución y no del análisis, nombrando el campo y la clave que no pudo leerse.
Cómo corregirlo:optional está registrado en esta superficie y en cada plantilla de valores, plantilla de ruta y aserción, lo que lo convierte en la opción portable — {{ optional .values "chart_version" "25.0.8" }} en lugar de {{ default "25.0.8" .values.chart_version }}. Lee la diferencia semántica antes de sustituir: optional se activa cuando la clave está ausente, mientras que default se activa cuando el valor está vacío, así que una clave escrita como cadena vacía o como cero conserva su valor escrito con optional y se sustituye con default. Donde la expresión necesite realmente una función de Sprig — para remodelar una cadena en lugar de aportar un respaldo — mantenla fuera de lo que lee la coordenada: en una entrada locals: que ningún campo source: lea, o en la superficie que la consume (valuesMapping, un cuerpo de Workload, una entrada artifacts:).
A template indexes a map with a key the map does not hold (Una plantilla indexa un mapa con una clave que el mapa no contiene)
Una plantilla lee un mapa a través de index — {{ index .values "replicas" }}, o {{ index .context.inject.env $apiKeyVar }} con un nombre de clave que la plantilla calculó — y el mapa no contiene la clave que se le pide. index detiene ahí la compilación y nombra la clave, en cada superficie que evalúa una plantilla: plantillas de valores, entradas locals: y provides:, plantillas de ruta, aserciones, una coordenada source: estructurada, la interpolación de parámetros en un Aggregate y los predicados validate: de sus parámetros, y los predicados x-aggrega-when: y x-aggrega-validate: de un esquema.
Esta es una propiedad exclusiva de index, y la política de claves ausentes de ninguna superficie la cambia. Una lectura con punto de una clave no definida bajo un pilar abierto sigue sin renderizar nada en una plantilla de valores, como describe «Missing template key — asymmetric policy (Clave de plantilla ausente — política asimétrica)» más arriba, y una plantilla que comprueba si el autor aportó una clave así no se ve afectada. Lo que detiene la compilación es pedir a index una clave que el mapa no contiene. index es la forma en que una plantilla llega a una clave cuyo nombre calcula — una credencial leída bajo el nombre de variable que eligió la Recipe consumidora, por ejemplo — y sin la detención esa lectura pondría en el artefacto el texto de marcador de posición del motor de plantillas <no value> mientras la compilación tiene éxito: un servidor iniciado con ese texto como clave. Cualquier otra respuesta que da index es la propia del motor de plantillas: una posición en una lista o en una cadena, una posición fuera de rango, una clave que el mapa contiene — incluida una cuyo valor es null, que imprime <no value>.
Mensaje emitido, como última línea del informe — los marcos que lo preceden nombran el nodo y el campo en el que está la plantilla, y en una plantilla de valores de una Recipe o una FeatureRecipe el encabezado lleva el código de esta condición:
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 (plantilla: ejecución de la plantilla indicada, en la línea y la columna indicadas, en la expresión index indicada: error al llamar a index: la plantilla indexa un mapa con una clave que el mapa no contiene (con la clave indicada). lee una clave que puede estar ausente a través de una función que primero compruebe su presencia, como optional, get o hasKey)
En una superficie que informa un fallo de plantilla bajo una condición propia — una entrada provides: («A provides: template could not be evaluated (No se puede evaluar una plantilla de provides)»), la interpolación de parámetros («A {{ .parameters.* }} reference cannot be interpolated (No se puede interpolar una referencia a parámetros)»), un predicado de esquema («An x-aggrega-when: or x-aggrega-validate: predicate cannot be evaluated (No se puede evaluar un predicado)»), una coordenada source: («Resolving a source: coordinate registers a narrower function set (La resolución de una coordenada source registra un conjunto de funciones más reducido)») — el encabezado lleva el código de esa condición y la línea anterior es el motivo que lleva, clave incluida.
Cómo corregirlo: decide si la clave puede estar ausente legítimamente.
Puede. Léela a través de una función que primero compruebe su presencia: {{ optional .values "replicas" 1 }} devuelve el respaldo cuando la clave está ausente y el valor, sea cual sea, cuando está presente; el get de Sprig devuelve una cadena vacía para una clave ausente; hasKey comprueba sin leer. optional está registrado en todas las superficies excepto la interpolación de parámetros y los predicados de un parámetro o de un esquema, que ofrecen get y hasKey de Sprig; una coordenada source: registra optional y no Sprig.
No debe. Apórtala. La clave que nombra el mensaje es la que pidió la plantilla, así que las causas habituales son una clave publicada con otro nombre — una credencial cuya key no es el nombre de variable que lee la Recipe — una clave mal escrita en la plantilla o en los valores escritos, y una conexión que entregaría la clave y no está cableada.
A template reads and iterates a path that holds nothing (Una plantilla lee e itera una ruta que no contiene nada)
Una plantilla imprime una ruta tal cual y además recorre la misma ruta — "user": "{{ .values.user }}" y "users": "{{ range .values.user }}…{{ end }}" en un mismo valuesMapping, por ejemplo — y los datos no contienen nada ahí: la clave no está definida, contiene null, o es un campo de primer nivel que el contexto define y para el que no contiene nada, como .workload en una Recipe que no sintetiza ninguno. La compilación se detiene antes de que se ejecute la plantilla y nombra la ruta, en cada superficie que renderiza un valor no definido como nada: las plantillas de valores que enumera «Missing template key — asymmetric policy (Clave de plantilla ausente — política asimétrica)» más arriba, y la interpolación de parámetros en un Aggregate.
Cada lectura por separado tiene una respuesta. Un valor no definido que se imprime no renderiza nada, y uno que se recorre con range no itera nada. Una ruta leída de las dos maneras no puede tener ninguna de las dos: renderizarla como nada haría fallar el range sobre texto, y dejarla sin definir imprimiría en el artefacto el texto de marcador de posición del motor de plantillas <no value> mientras la compilación tiene éxito. Así que no se da ninguna de las dos respuestas y, en su lugar, la compilación se detiene.
Lo que cuenta como imprimir la ruta es estrecho, y la línea se traza donde la plantilla la imprime con certeza:
Se imprime cuando una acción consiste en la ruta y nada más — {{ .values.user }}, {{ $.values.user }}, {{ (.values).user }}, o una variable ligada a la ruta, {{ $u }} después de {{ $u := .values.user }} — en un punto que la plantilla alcanza cada vez que se ejecuta.
No se imprime cuando la lectura está dentro de un cuerpo if, with o range o de una rama else, porque que esa lectura se ejecute depende de una condición, y la condición puede ser precisamente la prueba que le impide encontrarse con nada — así que {{ if .values.user }}{{ .values.user }}{{ end }} junto a un range .values.user se renderiza como siempre. Tampoco se imprime cuando es la propia prueba de una guarda, la asignación de una variable o un argumento de una función — {{ .values.user | quote }}, {{ toYaml .values.user }} — cuya salida es la respuesta de la función y no el marcador de posición.
Una impresión dentro de un cuerpo que sí se ejecuta sobre una ruta que no contiene nada sigue escribiendo <no value>, algo que esta comprobación no alcanza. Una escritura de una ruta es la misma ruta que cualquier otra, así que una impresión en una escritura y un range en otra se juzgan juntos, y el mensaje cita la escritura que la plantilla usó primero. Una ruta que contiene un valor se imprime y se itera como siempre, y una ruta cuyo padre no contiene nada se deja a la detención que ya provoca descender a través de nada.
Mensaje emitido, como última línea del informe — los marcos que lo preceden nombran el nodo y la plantilla, y el encabezado lleva el código de esta condición:
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 (la plantilla lee una ruta como valor y la itera, y los datos no contienen nada en esa ruta (con la ruta indicada). aporta un valor en la ruta, protege la lectura impresa con un if o un with sobre la ruta, o léela de una sola manera)
La interpolación de parámetros en un Aggregate también informa la misma línea bajo el código de esta condición. Una entrada provides: informa un fallo de plantilla bajo «A provides: template could not be evaluated (No se puede evaluar una plantilla de provides)», así que ahí el encabezado lleva el código de esa condición y la línea anterior es el motivo que lleva, ruta incluida.
Cómo corregirlo: decide cuál de las dos lecturas pretende la plantilla.
La ruta debe estar ahí. Apórtala — en los values: del Aggregate, en el infra: de la Release o en el parámetro que rellena la Release — o declárala obligatoria en el esquema que la rige, para que su ausencia se informe donde se escribe.
La ruta puede estar ausente. Protege la lectura impresa: {{ with .values.user }}{{ . }}{{ end }} o {{ if .values.user }}{{ .values.user }}{{ end }} no imprime nada cuando no está definida, y el range de al lado sigue iterando como nada.
Una sola lectura basta. Lee la ruta de una sola manera — un range que también escriba lo que necesita, o una impresión a través de una función como toYaml o join que responda por sí misma ante un valor no definido.
A value template failed while it ran (Una plantilla de valores falló durante su ejecución)
La plantilla de valores de una Recipe o de una FeatureRecipe — una de las plantillas que enumera «Missing template key — asymmetric policy (Clave de plantilla ausente — política asimétrica)» más arriba, entre ellas un cuerpo de Workload, un cuerpo de artifacts: o una entrada locals: — se analizó, empezó a ejecutarse y se detuvo antes de producir su texto. Lo que la detuvo es el motivo propio del motor de plantillas, que la detención lleva debajo: una referencia que desciende a través de un contenedor que nada aportó, como {{ .values.tls.ca }} donde no se escribió ningún tls; una comparación entre valores de dos tipos, como {{ if eq .context.instance_id 1 }}, que compara texto con un número y detiene la compilación con cannot compare text with a number; o una llamada al fail de Sprig, que una plantilla de valores puede hacer para rechazar una entrada con un mensaje propio.
Cuatro fallos en estas plantillas se informan, en cambio, bajo condiciones propias. Una entrada provides: se informa bajo «A provides: template could not be evaluated (No se puede evaluar una plantilla de provides)» más abajo, con esta frase y el motivo del motor dentro de su mensaje. Una lectura a través de index de una clave que el mapa no contiene se informa bajo «A template indexes a map with a key the map does not hold (Una plantilla indexa un mapa con una clave que el mapa no contiene)» más arriba. Una plantilla que imprime y recorre con range una misma ruta que no contiene nada se rechaza antes de ejecutarse, bajo «A template reads and iterates a path that holds nothing (Una plantilla lee e itera una ruta que no contiene nada)» más arriba. Y una plantilla que no se puede analizar se detiene antes de ejecutarse, así que no es esta condición.
Mensaje emitido — los marcos que tiene encima nombran la instancia del componente y la plantilla, como recipe "<recipe>" workload template o Recipe "<recipe>" locals["<key>"], y la línea propia del motor de plantillas sigue debajo:
a value template failed while it ran (una plantilla de valores falló durante su ejecución)
La línea del motor dice template: <template>:<line>:<column>: executing "<template>" at <<expression>>: <reason> — para una llamada a fail, error calling fail: <the message the template wrote>. La compilación informa la detención bajo una etiqueta CATALOG_ERROR, porque la plantilla la escribe el autor de la Recipe o de la FeatureRecipe. aggrega pull se encuentra con el mismo fallo cuando renderiza la Release para descubrir las entradas externas que lee: informa el fallo, escribe de todos modos las fijaciones de dependencias del lockfile y advierte que las fijaciones de las entradas externas pueden estar incompletas; la compilación, en cambio, se detiene ante él.
Cómo corregirlo: lee el motivo del motor al final del informe — nombra la plantilla, la línea y la columna, y la expresión en la que se detuvo. Para un contenedor que nada aportó, apórtalo, o protege la lectura para que nunca descienda en algo ausente: {{ with .values.tls }}{{ .ca }}{{ end }}, o el helper optional. Para dos tipos comparados, compara lo comparable — un número con un número escrito sin comillas, texto con texto escrito entre comillas — o convierte uno de los lados en texto con toString. Para una llamada a fail, el mensaje es del autor de la plantilla, y dice lo que la Recipe necesita: dáselo, o asigna el componente a una Recipe que acepte lo que escribiste.
A governance plugin rejected the build (Un plugin de gobernanza rechazó la compilación)
Un operador puede vincular un plugin de gobernanza en un rol de veredicto, sobre el grafo que construyó el compilador o sobre los artefactos que renderizó. Un plugin así lee y devuelve un veredicto. El anfitrión no tiene ninguna ruta que aplique un cambio que vuelva de él, así que un rol de veredicto puede rechazar una compilación y no puede reescribirla para que cumpla — el rechazo es todo lo que puede hacer, y qué cambiar queda en manos de quien lo lea.
Solo un veredicto de detención detiene la compilación. Los veredictos de advertencia e informativos se informan y la compilación continúa. Cada veredicto de detención que devolvió un plugin se informa, en el orden en que el plugin los emitió, así que una sola ejecución te informa de todos ellos.
El mensaje que imprime una compilación es el propio del plugin, mostrado exactamente como se devolvió y enmarcado solo por el plugin que lo devolvió — así que cuán específico es, y cuán útil para actuar, lo decide el plugin y no el compilador. Cualquier detalle opcional que llevara el veredicto sigue entre corchetes, con cada parte nombrada: un código, un identificador de regla, una clasificación, una referencia de origen, una ubicación, una sugerencia. La condición bajo la que se registra es policy violation, que es aquello en lo que se resuelve un código corto en el encabezado del diagnóstico.
El rechazo se atribuye a la vinculación de gobernanza y no a uno de tus documentos, así que no lleva ninguna posición de archivo: no hay ninguna clave que lo haya producido, y la respuesta es cumplir la política o reconsiderar la vinculación.
Mensaje emitido:
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>] (el plugin de políticas indicado rechazó la compilación: con el mensaje propio del plugin y, entre corchetes, el código, el identificador de regla, la clasificación, la referencia de origen, la ubicación y la sugerencia indicados)
La parte entre corchetes solo está presente donde el veredicto llevaba detalles, y cada parte dentro de ella solo donde el plugin la estableció.
Cómo corregirlo: lee el mensaje del plugin y la sugerencia, donde haya aportado una. Donde el hallazgo sea correcto, cambia aquello a lo que se opone. Donde la política no deba aplicarse a esta Release, se trata de una cuestión sobre la vinculación: las vinculaciones de gobernanza se configuran bajo plugins.governance en la configuración del espacio de trabajo, y qué plugin se ejecuta en qué rol es una decisión del operador y no algo que un documento pueda anular.
A governance attachment’s settings do not match the plugin’s declared schema (La configuración de una vinculación de gobernanza no coincide con el esquema declarado del plugin)
Un plugin de gobernanza puede declarar un esquema para la configuración que le pasa su vinculación. La configuración escrita bajo with.settings de la vinculación se comprueba contra ese esquema antes de que se invoque el plugin, así que una vinculación mal configurada se informa como el fallo de configuración que es, en lugar de llegar al plugin como una entrada mal formada y volver como lo que el plugin haga de ella.
Ese orden es el sentido mismo de la comprobación. También hace que esta condición se distinga claramente de un rechazo: el plugin no se ha ejecutado, no se ha llegado a ningún veredicto y no se ha juzgado nada de la compilación. Un plugin que no declara ningún esquema de configuración acepta cualquier configuración, así que una vinculación con uno de ellos nunca se encuentra con esta condición.
La comprobación cubre todos los roles de gobernanza. Una vinculación escrita en ir-verdict, render-verdict, label-transform o annotation-transform tiene su configuración comprobada contra el esquema antes de que se invoque el plugin — with.settings es la misma clave escrita en todos los roles, y todos los roles la leen primero contra el esquema. Un rol de transformación se ejecuta donde la compilación lo aplica, lo que, en una compilación que primero hace un pull, ocurre durante ese pull, así que allí el mensaje empieza por el paso que lo invocó, como en auto-pull: label-transform:.
Mensaje emitido — el rol en el que se escribió la vinculación y el plugin que nombra, después la frase fija, después lo que encontró la comprobación del esquema:
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: el plugin indicado: with.settings no cumple el esquema de configuración declarado del plugin: con el resultado indicado de la comprobación del esquema: la configuración de la vinculación de políticas no cumple el esquema de configuración declarado del plugin)
La cláusula inicial dice render-verdict para una vinculación escrita en ese rol. Lo que encontró la comprobación del esquema es el informe propio del validador del esquema y ocupa más de una línea.
Cómo corregirlo: corrige la configuración bajo with.settings de esa vinculación en plugins.governance. El detalle en medio del mensaje nombra la clave errónea y lo que el esquema esperaba allí; la referencia propia del plugin documenta la configuración que declara.
A pipeline step failed (Un paso de pipeline falló)
Una FeatureRecipe puede declarar un pipeline: una secuencia de pasos, cada uno de los cuales invoca un export de plugin sobre los documentos que ha emitido el nodo, para que una Feature pueda dar forma a la salida que produjo la Recipe propia del componente. Esta es la condición bajo la que un paso informa cuando falla por cualquier motivo distinto de un parche que direcciona algo que el conjunto de documentos no contiene, que tiene un informe propio más abajo.
Lo que falló se nombra según el id del paso y su índice, y la cláusula que sigue dice qué parte cedió: el renderizado de la entrada with del paso, la propia llamada, una salida que el anfitrión no pudo leer, un error que devolvió el plugin, un diagnóstico de gravedad error que emitió el plugin, un parche que rechazó el motor de parches, o un parche que nombra un ámbito que el recorrido no tiene.
Un paso fallido se revierte por completo. Los documentos se restauran a como estaban antes de que se ejecutara el paso, y las salidas propias del paso se descartan con ellos, así que el when o el with de un paso posterior no puede leer un resultado parcial. Un paso declarado optional: true se informa entonces como una advertencia y el recorrido continúa; un paso que no es opcional detiene la compilación. Lo que optional:no tolera es un contrato declarado infringido — consulta la entrada más abajo.
Mensajes emitidos:
pipeline step failed: step "<id>" (index <n>) with: <what the render could not do> (el paso de pipeline falló: en la entrada del paso indicado, con el índice indicado, el renderizado no pudo hacer lo indicado) pipeline step failed: step "<id>" (index <n>) invoke: <what the call could not do> (el paso de pipeline falló: en la invocación del paso indicado, con el índice indicado, la llamada no pudo hacer lo indicado) pipeline step failed: step "<id>" (index <n>) error diagnostic: <the plugin's message> (el paso de pipeline falló: el paso indicado, con el índice indicado, emitió un diagnóstico de error con el mensaje del plugin indicado) pipeline step failed: scope "<scope>" key "<key>": <what the patch engine refused> (el paso de pipeline falló: en el ámbito y la clave indicados, el motor de parches rechazó lo indicado) pipeline step failed: unknown patch scope "<scope>" (el paso de pipeline falló: ámbito de parche desconocido, el indicado)
Cómo corregirlo: lee el id del paso y después la cláusula que sigue al índice — dice qué mitad del paso mirar. Un fallo de with es una plantilla en el bloque with: propio del paso, y te corresponde corregirlo. Un diagnóstico de error son las propias palabras del plugin sobre tu entrada. Un parche rechazado y un ámbito desconocido son la salida del plugin frente a lo que emitió el nodo, y corresponden al autor del plugin. Donde a un paso se le permita realmente fallar — un enriquecimiento opcional y no una transformación obligatoria — decláralo optional: true, recordando que esto tolera un fallo y no un contrato roto.
A pipeline step’s typed input or output does not satisfy its declared contract (La entrada o la salida tipada de un paso de pipeline no cumple su contrato declarado)
Un export de plugin puede declarar un esquema para la entrada que recibe y para las salidas que devuelve. Ambos se comprueban: el valor with renderizado antes de la llamada, y las salidas devueltas después de ella. Un diagnóstico cuya gravedad no declara el contrato compartido se rechaza de la misma manera.
Esto detiene la compilación incluso para un paso declarado optional: true, y esa distinción es todo el motivo por el que la condición está separada de un fallo del paso. Opcional tolera un paso que no pudo hacer su trabajo — una llamada que falló, un plugin que puso una objeción. No tolera una salida que el anfitrión no puede encaminar, ni una entrada que nunca tuvo la estructura que el export decía recibir: un contrato declarado es un compromiso, y una compilación que se saltara en silencio un paso cuyo contrato se rompió estaría informando de un éxito sobre una Feature que no hizo nada.
Mensajes emitidos:
pipeline step "<id>"with input does not satisfy the declared input contract: <what the schema check found>: pipeline step typed-I/O contract violation (la entrada del paso de pipeline indicado no cumple el contrato de entrada declarado: con el resultado indicado de la comprobación del esquema: infracción del contrato de E/S tipada del paso 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 (el paso de pipeline indicado devolvió salidas que no cumplen el contrato de salida declarado: con el resultado indicado de la comprobación del esquema: infracción del contrato de E/S tipada del paso de pipeline)
y, para una gravedad de diagnóstico que el contrato no declara, que llega dentro del marco del fallo del paso:
pipeline step failed: step "<id>" (index <n>): <the severity the host could not route>: pipeline step typed-I/O contract violation (el paso de pipeline falló: el paso indicado, con el índice indicado: con la gravedad indicada que el anfitrión no pudo encaminar: infracción del contrato de E/S tipada del paso de pipeline)
Donde la plantilla with del paso lee un valor declarado sensible, una infracción de la entrada no nombra ningún valor. Lo que encontró la comprobación del esquema se sustituye por cada posición fallida y la palabra clave que la rechazó, cerradas por un aviso que nombra el motivo — at '/origin': pattern (the value is withheld because the template that rendered this input reads a value declared sensitive) — así que el campo que hay que corregir sigue nombrándose. Consulta vocabulary/compact-form-authoring.md «Qué dice un rechazo sobre un valor declarado».
Cómo corregirlo: para una infracción de la entrada, corrige el bloque with: del paso según el esquema que declara su export — el detalle nombra el campo y lo que se esperaba. Una infracción de la salida y una gravedad no declarada le corresponde corregirlas al plugin; la declaración del paso no es lo que está mal, así que marcarlo como opcional no eliminará ninguna de las dos.
A pipeline patch addresses a document the set does not hold, or one with no tree to address (Un parche de pipeline direcciona un documento que el conjunto no contiene, o uno sin árbol que direccionar)
Un paso de pipeline direcciona un documento mediante un ámbito y una clave, y se rechazan dos formas de dirección.
El conjunto no lo contiene. El paso aplicó un parche a un par de ámbito y clave que no está entre los documentos que recibió. No se editaría nada, así que, en lugar de aplicar un parche a nada e informar de un éxito, el recorrido se detiene:
pipeline patch targets a document not present in the set: scope "<scope>" key "<key>" (el parche de pipeline apunta a un documento que no está presente en el conjunto: con el ámbito y la clave indicados)
No lleva ningún árbol que direccionar. Algunas unidades no tienen ninguna estructura a la que pueda apuntar un parche — un cuerpo binario, texto libre, una región que el proveedor no puede recorrer con seguridad. Una unidad así se entrega igualmente al paso, etiquetada con su tipo de medio y sus bytes, para que pueda seleccionarse y emitirse entera; lo que no puede es recibir un parche, porque no hay nada contra lo que una ruta pueda resolverse. Un parche contra una de ellas se detiene en lugar de omitirse en silencio:
pipeline patch targets an opaque (non-structured) unit: scope "<scope>" key "<key>" (el parche de pipeline apunta a una unidad opaca, no estructurada: con el ámbito y la clave indicados)
Lo que cuenta como estructurado es la lectura propia que el proveedor hace de la unidad y no una prueba fija, así que el mismo contenido puede ser direccionable con un proveedor y opaco con otro.
Ambos son rechazos propios del recorrido, y una compilación los informa sobre el nodo cuyo pipeline aplicó el parche, así que el mensaje de arriba llega debajo de una detención que nombra ese nodo. Esa detención es la forma que detiene la compilación de los mismos dos fallos de direccionamiento, documentada bajo «A pipeline step addresses documents the node does not have (Un paso de pipeline direcciona documentos que el nodo no tiene)» más abajo — que también cubre la tercera dirección con la que un paso puede no alcanzar nada, una solicitud de los documentos de un componente anfitrión en un lugar donde no hay ninguno.
Cómo corregirlo: ambos corresponden al autor del plugin y no a ti. Un paso recibe el conjunto de documentos sobre el que se ejecuta y puede leer qué claves contiene, así que un destino ausente es un paso que direcciona un documento que este nodo no emitió — aplica el parche a un documento que esté presente, o emite primero el que querías y aplícale el parche en un paso posterior. Para una unidad opaca, sustituye el parche por una emisión de la unidad entera: un cuerpo opaco se sustituye en lugar de editarse.
A patch’s test operation did not match the document (La operación de prueba de un parche no coincidió con el documento)
Un parche puede llevar una operación test, que afirma lo que hay en una ruta antes de que se apliquen las operaciones que la siguen. El motor rechaza el parche entero cuando la afirmación no se cumple, que es lo que hace que un parche condicional sea condicional y no optimista: un plugin que comprueba antes de editar está diciendo que no tocará un documento que no reconoce.
Dos formas se informan bajo esta condición. No hay nada en absoluto en la ruta, cosa que dice el mensaje. O hay un valor y no es el afirmado, lo que se informa como el rechazo sin más — no se cita ni el valor afirmado ni el encontrado.
Mensajes emitidos:
jsonpatch: test operation failed: no value at path (jsonpatch: la operación de prueba falló: no hay ningún valor en la ruta) jsonpatch: test operation failed (jsonpatch: la operación de prueba falló)
Donde la salida de un paso de pipeline llevaba el parche, el rechazo llega debajo del fallo de ese paso, nombrando el paso. Donde lo llevaba el parche de un plugin label-transform, llega debajo del rechazo del parche de labels.
Cómo corregirlo: el fallo es del plugin y no de tus documentos. Una prueba que esperaba un valor que el documento no tiene suele significar que el plugin se está ejecutando sobre una estructura para la que no se escribió — la salida de otro proveedor, o un documento que un paso anterior del mismo pipeline ya cambió. Donde te corresponda corregir el parche, relaja la prueba a lo que el documento contiene realmente, o haz que la condición when del paso omita el caso en lugar de comprobarlo dentro del parche.
A workload: form and the fields beside it do not agree (La forma de una carga de trabajo y los campos junto a ella no concuerdan)
Un workload: declara una form: — la estructura de lo que se ejecuta, expresada en términos que todo destino entiende y no en el vocabulario de un destino concreto. Algunos campos solo tienen sentido en una forma, y una forma declarada sin el campo que necesita no tiene nada coherente que renderizar. Se comprueban ambas direcciones, antes de que ningún destino traduzca la carga de trabajo, así que el desacuerdo se informa una sola vez frente a lo que escribiste y no una vez por destino con las palabras que cada destino tenga para ello.
Se aplican cinco emparejamientos, y cada uno informa con una frase propia que nombra ambas mitades y qué escribir:
workload declares a persistentTemplate volume but is not form: stateful; declare form: stateful (la carga de trabajo declara un volumen persistentTemplate pero no es form: stateful; declara form: stateful) workload is form: reference but declares no endpoint; set endpoint to the external host or URL the reference points at (la carga de trabajo es form: reference pero no declara ningún endpoint; establece endpoint en el host externo o la URL a la que apunta la referencia) workload declares an endpoint but is not form: reference; declare form: reference or remove the endpoint (la carga de trabajo declara un endpoint pero no es form: reference; declara form: reference o elimina el endpoint) workload is form: scheduled but declares no schedule; set schedule to a 5-field cron expression or an @-macro (e.g. @daily) (la carga de trabajo es form: scheduled pero no declara ninguna programación; establece schedule en una expresión cron de 5 campos o una macro @, p. ej. @daily) workload declares a schedule but is not form: scheduled; declare form: scheduled or remove the schedule (la carga de trabajo declara una programación pero no es form: scheduled; declara form: scheduled o elimina la programación)
Cada uno se sitúa en la instancia del componente cuya carga de trabajo se estaba leyendo, y se informa como un fallo de traducción, porque el desacuerdo está entre dos campos de un mismo bloque escrito por el autor.
Las condiciones bajo las que se registran, que es aquello en lo que se resuelven sus códigos cortos, son persistentTemplate volume requires form: stateful, form: reference requires an endpoint, endpoint requires form: reference, form: scheduled requires a schedule y schedule requires form: scheduled.
Un emparejamiento funciona en un solo sentido. Una carga de trabajo form: stateful sin plantilla de claim por réplica es normal y no provoca nada — la regla es que una plantilla de claim necesita la identidad estable por réplica que solo esa forma da, no que la forma necesite una plantilla de claim. Los otros dos emparejamientos funcionan en ambos sentidos, porque un endpoint y una programación tienen cada uno exactamente una forma en la que significan algo.
Los dos emparejamientos de endpoint están también en el esquema de Workload, así que una carga de trabajo que incumple cualquiera de ellos se rechaza en la etapa de esquema, bajo E0214, antes de llegar a su frase de arriba. Un endpoint: en cualquier forma distinta de reference — incluida una form: omitida, ya que se lee como stateless — se rechaza como
workload validation failed (Workload in Recipe <name>:<version>, at <path>, schema stage): .endpoint: value matches a shape that is not allowed here (la validación de la carga de trabajo falló, en el Workload de la Recipe y en la ruta indicados, etapa de esquema: .endpoint: el valor coincide con una forma que no está permitida aquí)
y form: reference sin endpoint: termina en cambio con .endpoint: missing required property: endpoint. El remedio es el que da la frase del emparejamiento.
Cómo corregirlo: cada frase nombra los dos campos y da ambas respuestas. Añade el campo que la forma necesita, o cambia la forma por aquella a la que pertenece el campo, o elimina el campo donde lo dejó atrás una edición — borrar un valor de schedule: y dejar la clave es la forma que este error adopta con más frecuencia.
A workload schedule: is not an expression the check accepts (La programación de una carga de trabajo no es una expresión que la comprobación acepte)
Una carga de trabajo form: scheduled lleva un schedule: que dice cuándo se ejecuta, y se comprueba la estructura del valor antes de que ningún destino lo lea. Se aceptan dos grafías: una de las cinco macros @hourly, @daily, @weekly, @monthly y @yearly, o una expresión crontab de cinco campos cuyos campos usan solo dígitos y los caracteres *, ,, - y /.
Lo que la comprobación lee y lo que no. Cuenta los campos y mira los caracteres que contienen. No evalúa rangos, aritmética de pasos ni nombres de días de la semana, así que una expresión de cinco campos cuyos números están fuera de rango pasa aquí y le corresponde rechazarla al destino. Una expresión de seis campos que lleva un campo inicial de segundos se rechaza: cinco campos es lo que acepta esta superficie, y un destino que quiere segundos los recibe de otra manera.
Mensaje emitido:
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 programación de la carga de trabajo no es una expresión cron válida; usa una expresión crontab de 5 campos, como la del ejemplo, o una de @hourly, @daily, @weekly, @monthly, @yearly)
La condición bajo la que se registra es schedule is not a valid cron expression, que es aquello en lo que se resuelve su código corto.
Cómo corregirlo: cuenta primero los campos — una programación con cuatro o seis de ellos es la causa más común, y un espacio de más dentro de un campo lo divide en dos. Sustituye un día o un mes con nombre por su número, y recurre a una macro donde alguna diga lo que querías.
A workload suspend: is set on a form other than scheduled (La suspensión de una carga de trabajo está establecida en una forma distinta de la programada)
suspend: true retiene la programación recurrente de una carga de trabajo form: scheduled: el recurso programado se renderiza, y no se inicia ninguna ejecución desde su programación hasta que se reanuda. Ninguna otra forma lleva una programación, así que en cualquier otra forma el campo no tiene nada que retener, y la compilación se detiene en lugar de renderizar una carga de trabajo que lo descarta en silencio. La comprobación se ejecuta junto con los demás emparejamientos de forma, antes de que ningún destino traduzca la carga de trabajo, y aquí también una form: omitida se lee como stateless.
Mensaje emitido:
workload declares suspend but is not form: scheduled; declare form: scheduled with a schedule or remove suspend (la carga de trabajo declara suspend pero no es form: scheduled; declara form: scheduled con una programación o elimina suspend)
Se sitúa en la instancia del componente cuya carga de trabajo se estaba leyendo, y se informa como un fallo de traducción. La condición bajo la que se registra es suspend requires form: scheduled, que es aquello en lo que se resuelve su código corto.
La regla funciona en un solo sentido, y solo con true. Una carga de trabajo form: scheduled sin suspend: es normal y se ejecuta según su programación, y suspend: false, el valor predeterminado, no provoca nada en ninguna forma.
Cómo corregirlo: donde la carga de trabajo debía ejecutarse solo cuando alguien la inicia, conviértela en una carga de trabajo form: scheduled con un schedule: y conserva suspend: true; en caso contrario, conserva la forma tal como está escrita y elimina suspend:, que ninguna otra forma lee.
A library $import: is not written in the bare-name form (Una importación de biblioteca no está escrita en la forma de nombre simple)
Tres campos de una Recipe y de una FeatureRecipe pueden tomar su cuerpo de una biblioteca en lugar de escribirlo en el sitio: una entrada artifacts.<name>:, un valuesMapping: y un workload:. Cada uno escribe $import: con el nombre simple de la biblioteca, luego #, luego la ruta de la entrada en la superficie que lee ese campo — #/artifacts/, #/mappings/ y #/workloads/ respectivamente. Un valor que no tiene esa forma no nombra nada que la compilación pueda resolver, y se rechaza cuando se resuelve el campo.
Los tres campos son reflejos deliberados unos de otros, así que el fallo se lee igual en los tres y solo cambia la superficie:
artifacts $import: is not a bare-name artifact-library reference (#/artifacts/): "<the value as written>" (la importación de artifacts no es una referencia de nombre simple a una biblioteca de artefactos: con el valor indicado, tal como se escribió) valuesMapping $import: is not a bare-name mapping-library reference (#/mappings/): "<the value as written>" (la importación de valuesMapping no es una referencia de nombre simple a una biblioteca de mapeos: con el valor indicado, tal como se escribió) workload $import: is not a bare-name workload-library reference (#/workloads/): "<the value as written>" (la importación de workload no es una referencia de nombre simple a una biblioteca de workloads: con el valor indicado, tal como se escribió)
Una versión escrita con @ se informa con la grafía que se debe usar en su lugar, en lugar de acabar en una queja de que no se encontró la biblioteca, porque es el error que esta forma provoca con más frecuencia:
artifacts $import: is not a bare-name artifact-library reference (#/artifacts/): version separator is ’:’, not ’@’ — use "<the corrected value>" (la importación de artifacts no es una referencia de nombre simple a una biblioteca de artefactos: el separador de versión es ’:’, no ’@’ — usa el valor corregido indicado)
Una forma más se informa aquí, y no es un error de escritura. El cuerpo propio de un archivo de un bundle de una ArtifactLibrary no puede ser a su vez un $import: de otro bundle: una posición de archivo no puede expandirse en muchos archivos, así que una importación anidada se rechaza en lugar de resolverse en algo que el autor no escribió. Compón en su lugar los bundles en el punto en que se consumen.
Una entrada artifacts: que escribe la Recipe propia de un componente se decide antes de que se renderice nada, así que el informe se sitúa en el bloque artifacts: de esa Recipe y nombra la referencia, el bundle, el archivo cuyo cuerpo lleva la importación anidada y la entrada en la que se escribió la importación. Cada archivo del bundle con esa forma se informa en una sola compilación; donde hay más de uno, los hallazgos se agrupan bajo 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 (la importación de artifacts no es una referencia de nombre simple a una biblioteca de artefactos, con el valor tal como se escribió, el bundle, el archivo del bundle y la entrada de artifacts indicados. El cuerpo de un archivo de bundle no puede importar otro bundle — compón los dos en la entrada de artifacts que los consume)
Una entrada artifacts: que escribe una FeatureRecipe informa la misma condición cuando se resuelve el bundle, nombrando el primer archivo con esa forma:
artifacts $import: is not a bare-name artifact-library reference (#/artifacts/): bundle "<bundle>" file "<filename>" body is a field-root $import: (nested library import inside a bundle file is not supported; compose at the consumption site) (la importación de artifacts no es una referencia de nombre simple a una biblioteca de artefactos: el cuerpo del archivo indicado del bundle indicado es una importación en la raíz del campo; no se admite una importación de biblioteca anidada dentro de un archivo de bundle; compón en el punto de consumo)
Un valuesMapping: que escribe la Recipe propia de un componente se decide antes de que se renderice nada, así que el informe se sitúa en la clave valuesMapping: de esa Recipe y lleva la grafía que se debe usar:
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/ (la importación de valuesMapping no es una referencia de nombre simple a una biblioteca de mapeos, con el valor indicado, tal como se escribió. Nombra la biblioteca y la entrada a ambos lados del fragmento — escribe la forma indicada)
Un valuesMapping: que escribe una FeatureRecipe informa cuando se resuelve la referencia, en la forma que recoge la lista de arriba.
Un workload: que escribe la Recipe propia de un componente se decide antes de que se renderice nada, así que el informe se sitúa en la clave workload: de esa Recipe y lleva la grafía que se debe usar:
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/ (la importación de workload no es una referencia de nombre simple a una biblioteca de workloads, con el valor indicado, tal como se escribió. Nombra la biblioteca y la entrada a ambos lados del fragmento — escribe la forma indicada)
Un workload: que escribe una FeatureRecipe informa cuando se resuelve la referencia, en la forma que recoge la lista de arriba.
Cómo corregirlo: reescribe el valor como <Library>#<entry-path>, añadiendo :<version> después del nombre de la biblioteca solo donde necesites un mínimo sobre qué versión se puede seleccionar. Comprueba que el fragmento coincide con el campo — una ruta de entrada #/mappings/… en un workload: nombra una superficie que ese campo no lee, y se informa aquí y no como una entrada ausente. La misma forma de identidad rige el $ref: de un esquema, cuyos rechazos están documentados bajo «A $ref: is not written in a form the compiler can resolve (Una referencia no está escrita en una forma que el compilador pueda resolver)» más arriba.
A library $import: names a library or an entry the catalog does not hold (Una importación de biblioteca nombra una biblioteca o una entrada que el catálogo no contiene)
Un $import: está escrito correctamente y aquello a lo que apunta no está. Seis condiciones cubren las dos mitades de una referencia en los tres tipos de biblioteca, y cuál obtienes te dice qué mitad mirar: la biblioteca en sí está ausente de lo que la compilación puede ver, o la biblioteca está y no publica la entrada.
El conjunto contra el que se resuelve una referencia es el catálogo propio del espacio de trabajo más las bibliotecas que el lockfile fijó e incorporó mientras se cargaba la compilación. Así que una biblioteca de la que nada en el cierre de dependencias de la Release declara depender no está en ese conjunto, por correcta que parezca la referencia a ella.
La biblioteca no está:
artifact-library import references an ArtifactLibrary not present in the catalog: ArtifactLibrary "<library>" (bundle "<entry>") (una importación de biblioteca de artefactos hace referencia a una ArtifactLibrary que no está presente en el catálogo: con la ArtifactLibrary y el bundle indicados) mapping-library import references a MappingLibrary not present in the catalog: MappingLibrary "<library>" (entry "<entry>") (una importación de biblioteca de mapeos hace referencia a una MappingLibrary que no está presente en el catálogo: con la MappingLibrary y la entrada indicadas) workload-library import references a WorkloadLibrary not present in the catalog: WorkloadLibrary "<library>" (entry "<entry>") (una importación de biblioteca de workloads hace referencia a una WorkloadLibrary que no está presente en el catálogo: con la WorkloadLibrary y la entrada indicadas)
La entrada no está:
artifact-library import references a bundle not present in the ArtifactLibrary: bundle "<entry>" in ArtifactLibrary "<library>" (una importación de biblioteca de artefactos hace referencia a un bundle que no está presente en la ArtifactLibrary: con el bundle y la ArtifactLibrary indicados) mapping-library import references an entry not present in the MappingLibrary: entry "<entry>" in MappingLibrary "<library>" (una importación de biblioteca de mapeos hace referencia a una entrada que no está presente en la MappingLibrary: con la entrada y la MappingLibrary indicadas) workload-library import references an entry not present in the WorkloadLibrary: entry "<entry>" in WorkloadLibrary "<library>" (una importación de biblioteca de workloads hace referencia a una entrada que no está presente en la WorkloadLibrary: con la entrada y la WorkloadLibrary indicadas)
Una entrada artifacts: que escribe la Recipe propia de un componente informa un bundle ausente en una forma propia. Esa entrada se decide antes de que se renderice nada, así que el informe se sitúa en el bloque artifacts: de esa Recipe y nombra la entrada en la que se escribió la importación junto con las dos mitades de la referencia:
artifact-library import references a bundle not present in the ArtifactLibrary ("<entry>", ArtifactLibrary "<library>", artifacts entry "<key>") (una importación de biblioteca de artefactos hace referencia a un bundle que no está presente en la ArtifactLibrary: con el bundle, la ArtifactLibrary y la entrada de artifacts indicados)
Un valuesMapping: que escribe la Recipe propia de un componente informa una entrada ausente en una forma propia, por la misma razón: también se decide antes de que se renderice nada, así que el informe se sitúa en la clave valuesMapping: de esa Recipe y nombra las dos mitades de la referencia:
mapping-library import references an entry not present in the MappingLibrary ("<entry>", MappingLibrary "<library>") (una importación de biblioteca de mapeos hace referencia a una entrada que no está presente en la MappingLibrary: con la entrada y la MappingLibrary indicadas)
Un workload: que escribe la Recipe propia de un componente informa una entrada ausente en una forma propia, por la misma razón: también se decide antes de que se renderice nada, así que el informe se sitúa en la clave workload: de esa Recipe y nombra las dos mitades de la referencia:
workload-library import references an entry not present in the WorkloadLibrary ("<entry>", WorkloadLibrary "<library>") (una importación de biblioteca de workloads hace referencia a una entrada que no está presente en la WorkloadLibrary: con la entrada y la WorkloadLibrary indicadas)
Una entrada artifacts: que escribe una FeatureRecipe, un valuesMapping: o un workload: que escribe una FeatureRecipe, y toda referencia a una biblioteca que la compilación no puede ver, se informan a medida que se resuelve la referencia, en las formas que recogen las dos listas anteriores.
Cada uno nombra tanto la biblioteca como la entrada, sea cual sea la mitad que falló, así que un solo informe basta para distinguir una biblioteca ausente de una entrada ausente sin abrir nada.
Cómo corregirlo: para una entrada ausente, comprueba el nombre frente a lo que publica la biblioteca — el nombre de una entrada es una clave del mapa propio de esa biblioteca, y distingue entre mayúsculas y minúsculas. Para una biblioteca ausente, la referencia suele ser correcta y lo que se queda corto es el cierre: declara la dependencia de esa biblioteca para que se cargue, y actualiza el lockfile para que quede fijada. Una biblioteca alcanzable en un espacio de trabajo y no en otro es el mismo fallo visto desde el otro lado.
A library $import: addresses its library by registry location (Una importación de biblioteca direcciona su biblioteca por su ubicación en un registro)
Un $import: de biblioteca nombra su biblioteca por identidad, nunca por el registro en el que resulte estar publicada. A través de qué registro se resuelve un nombre es configuración del espacio de trabajo, y qué versión se usa es la respuesta del lockfile, así que una referencia que lleva un host fija en un documento de catálogo dos cosas que corresponde decidir a la compilación — y el documento deja entonces de funcionar en cualquier espacio de trabajo configurado de otra manera.
Los casos en que una referencia así todavía puede llegar a esta detención son más reducidos de lo que parece. Los campos $import: propios de una Recipe y de una FeatureRecipe se rechazan antes, por su esquema, que no admite ningún prefijo de registro en ninguna de las tres posiciones. Lo que queda es la referencia que ningún esquema describe: una leída del propio cuerpo de una entrada de biblioteca, que la entidad que la consume no escribió y no puede ver hasta que se resuelve el cuerpo.
Mensaje emitido, desde las superficies valuesMapping: y workload:, donde el resolutor informa solo el valor:
library $import: carries a registry host; reference the library by bare-name identity: "<the value as written>" (la importación de biblioteca lleva un host de registro; haz referencia a la biblioteca por su identidad de nombre simple: con el valor indicado, tal como se escribió)
Una entrada artifacts: no llega a esta detención, y vale la pena conocer la razón si la estás buscando ahí. Su propia referencia se rechaza junto con el resto del documento, como cualquier otra posición; y, a diferencia de las otras dos superficies, un archivo de bundle cuyo cuerpo es a su vez una importación se rechaza en lugar de seguirse — así que no hay ningún cuerpo del que pudiera llegar una referencia que lleve un host.
Cómo corregirlo: elimina el host y todo lo que precede al nombre de la biblioteca, dejando <Library>#<entry-path>. Donde el valor problemático está dentro de una biblioteca que consumes y no en una que publicas, la corrección corresponde al autor de esa biblioteca; hasta que llegue, importar una entrada distinta o escribir el cuerpo en su sitio desbloquea la compilación.
Two artifact outputs of one Recipe carry the same filename (Dos salidas de artefactos de una misma Recipe llevan el mismo nombre de archivo)
El bloque artifacts: de una Recipe nombra una salida por clave, y un bundle importado en una clave aporta sus archivos debajo de ella. Dos salidas que llegaran a un mismo nombre de archivo significarían que una sobrescribe a la otra, así que la compilación se detiene en lugar de elegir cuál sobrevive.
Esta es una protección residual, y decirlo forma parte de lo que es. Una salida se nombra por la clave bajo la que se escribió, las claves de un mapa son únicas dentro de un documento, y la superficie de autoría limita una clave a un único nombre de archivo — así que dos entradas escritas por el autor no pueden colisionar, y una clave tampoco puede escribir el nombre anidado que produce el bundle de otra clave. Lo que la protección todavía cubre es el contenido que llegó a la proyección sin pasar por el rechazo de claves duplicadas propio de un documento escrito por el autor: estado ensamblado mientras se ejecuta la compilación en lugar de leído de un archivo. Por eso, una colisión informada aquí apunta a cómo se ensambló la compilación y no a una línea que puedas ver.
Se plantea por Recipe, sobre las salidas propias de esa Recipe, y eso es lo que la separa de dos contribuidores distintos que acaban en una misma ruta en un ensamblado — eso es «Two contributors write the same output path (Dos contribuidores escriben la misma ruta de salida)» más arriba, con un remedio distinto.
Mensaje emitido:
artifacts output filename collision: two artifact outputs carry the same filename (Recipe "<recipe>", artifact output "<filename>" emitted more than once) (colisión de nombre de archivo de una salida de artifacts: dos salidas de artefactos llevan el mismo nombre de archivo, con la Recipe y la salida de artefacto indicadas, emitida más de una vez)
Cómo corregirlo: abre la Recipe que nombra el mensaje y comprueba sus claves artifacts: frente a los archivos que aporta cualquier bundle que importe. Donde las claves son realmente distintas y la colisión se mantiene, nada en el documento está mal, y vale la pena plantear el informe a quien mantenga la compilación.
An ArtifactLibrary bundle file names no file of its own under the key it was imported at (Un archivo de bundle de una ArtifactLibrary no nombra ningún archivo propio bajo la clave en la que se importó)
Una entrada artifacts: que importa un bundle se expande en una salida por cada archivo de ese bundle, cada una anidada bajo la clave en la que se escribió la importación. Así que la clave nombra un directorio y cada archivo que aporta el bundle va debajo de él, con un nombre propio. Un nombre de archivo que sale de ese directorio, nombra una ubicación absoluta o no nombra nada en absoluto no va ahí, y la compilación se detiene en lugar de colocar el archivo en algún lugar que la Recipe que lo consume nunca eligió.
No nombrar nada abarca todo nombre que no sea la única escritura de un solo archivo debajo de la clave.. y ./, y un nombre que vuelve a caer sobre la clave como x/.., nombran la propia clave, así que el archivo se escribiría donde corresponde al directorio de la clave. Un nombre con una / final o doble, o con una parte . o .. — x/, a//b, ./a, a/./b, a/../b — es una segunda escritura de un archivo que otro nombre puede llevar: a//b junto a a/b son dos nombres para un mismo archivo, y uno se escribiría encima del otro sin que se informara ninguna colisión. El nombre vacío también se rechaza.
Lo que evita es una reorganización silenciosa más que una escritura fuera del directorio de salida. El lugar donde se escriben los archivos está protegido de nuevo, así que un nombre que sube lo suficiente se rechaza ahí de todos modos. El nombre que supera esa protección es el que sube exactamente un nivel: vuelve a caer dentro del directorio de salida, en una posición que nadie eligió. Eso es peor que una escritura rechazada, porque toda protección contra colisiones en esta ruta lee un nombre tal como se compuso y no tal como se resuelve — así que dos archivos así pueden resolverse sobre una misma salida sin que nada informe de una colisión, y cuál sobrevive no lo decide nada que nadie haya escrito.
Una estructura anidada escrita de forma simple dentro de la clave no se toca. Un bundle puede llevar sus propios subdirectorios, como rbac/role.yaml, y anidarlos bajo la clave de consumo es precisamente para lo que sirve la clave. Un nombre que simplemente contiene puntos dentro de una parte, como ..config o role.v1.yaml, es un nombre corriente.
La Recipe que consume y el bundle publicado suelen escribirlos autores distintos, así que el mensaje nombra ambas mitades junto con el remedio.
Una entrada artifacts: que escribe la Recipe propia de un componente se decide antes de que se renderice nada, así que el informe se sitúa en el bloque artifacts: de esa Recipe y nombra primero el archivo, luego la biblioteca de la que procede y la entrada en la que se consume. Cada archivo del bundle cuyo nombre se rechaza se informa en una sola compilación; donde hay más de uno, los hallazgos se agrupan bajo 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 ”/” (el nombre de un archivo del bundle de una biblioteca de artefactos no nombra un archivo propio debajo de la clave de artifacts bajo la que se anida su salida, con el archivo, la ArtifactLibrary y la entrada de artifacts indicados. cambia el nombre del archivo dentro del bundle de la ArtifactLibrary por un nombre de archivo corriente debajo de la clave de artifacts en la que se consume, como «config.yaml» o «rbac/role.yaml» — sin ninguna parte «.» o «..», y sin ninguna «/» inicial, final o doble)
Una entrada artifacts: que escribe una FeatureRecipe informa la misma condición a medida que se resuelve el bundle, nombrando la receta en la que se escribió y el primero de esos archivos:
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 ”/” (el nombre de un archivo del bundle de una biblioteca de artefactos no nombra un archivo propio debajo de la clave de artifacts bajo la que se anida su salida, con la Recipe, el artefacto y el archivo de bundle indicados. cambia el nombre del archivo dentro del bundle de la ArtifactLibrary por un nombre de archivo corriente debajo de la clave de artifacts en la que se consume, como «config.yaml» o «rbac/role.yaml» — sin ninguna parte «.» o «..», y sin ninguna «/» inicial, final o doble)
Cómo corregirlo: cambia el nombre del archivo dentro de la ArtifactLibrary por un nombre de archivo corriente debajo de la clave. Donde la biblioteca no es tuya, importar un bundle distinto o escribir la entrada en su sitio desbloquea la compilación mientras la corrección se hace en el origen. Un archivo pensado para acabar en un lugar completamente distinto es una segunda entrada artifacts: en la clave a la que pertenece, no un nombre que sube hasta allí.
An imported artifact no longer matches the digest recorded beside its Recipe (Un artefacto importado ya no coincide con el digest registrado junto a su Recipe)
Una entrada artifacts: que importa un archivo local tiene su contenido fijado cuando se fija la Recipe — mediante aggrega pin, o mediante un pull o un push al que se pide ejecutar el mismo paso: el digest de los bytes del archivo se registra en entity.lock, junto a la Recipe. Una entrada del boundary.artifacts: de una Recipe se fija y se compara de la misma manera, y se registra bajo boundary/<key>, que es el nombre que le da el mensaje. Cada compilación vuelve a leer el archivo, vuelve a calcular su digest y rechaza la discrepancia — así, un archivo editado después de fijarse nunca se renderiza como si se hubiera comprobado. aggrega pull --verify hace la misma comparación e informa una discrepancia con el mismo mensaje.
Lo que se compara es el contenido de la entrada, no lo que produjo su renderizado. El cuerpo de un artefacto es una plantilla, y evaluarla sustituye valores que difieren según la instancia del componente, así que un digest sobre la salida discreparía para cada instancia cuyos valores difieran. El contenido registrado es el mismo texto para cada instancia que se enlaza con la Recipe, y eso es lo que hace de un único digest registrado lo correcto para comparar.
Tres superficies llevan la misma comprobación sobre documentos distintos — la Recipe propia de un componente, una Feature vinculada a un componente y una Feature vinculada a un límite — así que el contenido de la FeatureRecipe se mide contra el digest registrado junto a la FeatureRecipe y no junto a la Recipe del componente anfitrión. En las dos superficies de vinculación, el mensaje nombra también la vinculación, y eso es lo que dice qué documento abrir.
Mensajes emitidos:
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 (el contenido del artefacto importado no coincide con el digest registrado para él en entity.lock, con el artefacto, el archivo importado, el digest de su contenido y la fijación registrada indicados. Si el archivo se cambió a propósito, ejecuta aggrega pin sobre la entidad que lo importa para registrar su nuevo digest; si no, restaura el archivo) 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 (el contenido del artefacto importado no coincide con el digest registrado para él en entity.lock, con el artefacto, el archivo importado, el digest de su contenido, la fijación registrada y la vinculación indicados. Si el archivo se cambió a propósito, ejecuta aggrega pin sobre la entidad que lo importa para registrar su nuevo digest; si no, restaura el archivo)
Cómo corregirlo: dos respuestas, y cuál es la correcta depende de si la edición era intencionada. Si lo era, ejecuta aggrega pin sobre la Recipe para que la fijación se tome de nuevo a partir de los bytes actuales del archivo, y haz commit del entity.lock que reescribe. Si no lo era, restaura el archivo — el digest registrado es la constancia de los bytes que se fijaron, y una compilación que renderizara el archivo modificado estaría entregando contenido que nada verificó.
A local source no longer matches the pins recorded beside its Recipe (Una fuente local ya no coincide con las fijaciones registradas junto a su Recipe)
Una Recipe o FeatureRecipe cuyo source: nombra un directorio o un archivo junto a ella tiene esa fuente fijada cuando se fija la entidad — mediante aggrega pin, o mediante un pull o un push al que se pide ejecutar el mismo paso. El entity.lock junto a la entidad registra un digest por cada archivo que la fuente aporta a lo que lleva una publicación de la entidad, indexado por la ruta del archivo. Una vez que el lock los registra, cada compilación compara la fuente tal como está con esas fijaciones antes de que el proveedor la lea, y rechaza una discrepancia — así, un chart o un módulo editado después de fijarse nunca se renderiza como si se hubiera comprobado. aggrega pull --verify hace la misma comparación e informa una discrepancia con el mismo mensaje. Una compilación nombra la instancia de componente cuya fuente estaba resolviendo y, debajo de ella, el documento de la Recipe.
La fuente se compara como un único conjunto de archivos. Un archivo cuyo contenido cambió, un archivo añadido a la fuente y un archivo eliminado de ella cambian cada uno aquello a partir de lo que se renderiza la entidad, así que cada uno se informa, con el digest que el archivo tiene ahora y el digest registrado para él. Un archivo junto a la entidad que la fuente no aporta — una nota o un README al lado de la Recipe — no se compara. Una fuente escrita como plantilla, como ./charts/{{ .values.flavour }}, aporta cada archivo del directorio de la entidad, porque qué directorio nombra lo decide cada Release; para esa forma se informa una edición de cualquier archivo del directorio.
Una Recipe cuyo lock no registra ninguna fijación para su fuente no tiene nada que una compilación pueda comparar. Una compilación no la rechaza; un pull o un push que no fija sí la rechaza, como describe An entity reads an input the lock beside it records no pin for (Una entidad lee una entrada para la que el lock junto a ella no registra ninguna fijación). Las fijaciones que un lock aún registra para una fuente local que la Recipe ya no declara no fijan nada de lo que lee, así que no se comparan con nada. Una Recipe que un pull resolvió desde un registro queda cubierta en cambio por el digest que el lockfile registra para lo que lleva su publicación.
Un lockfile escrito antes del cambio informa primero. El lockfile registra la entidad por lo que lleva, y los archivos de la fuente forman parte de ello, así que una compilación o aggrega pull --verify con un lockfile escrito antes de que cambiara un archivo se detiene antes de que se ejecute esta comparación, con The lockfile no longer matches what the release resolves to (El archivo de bloqueo ya no coincide con aquello en lo que se resuelve la Release) nombrando la entidad y ambos digests. Un aggrega pull simple nombra el archivo que cambió, con An entity reads an input the lock beside it records no pin for (Una entidad lee una entrada para la que el lock junto a ella no registra ninguna fijación). Lo mismo vale para un archivo importado. Donde el lockfile no tiene ninguna entrada propia de la entidad, esta comparación es la que encuentran una compilación y un pull de verificación: una Recipe o FeatureRecipe que el Manifest nombra mediante una referencia que también es el nombre de un Component o de una Feature que alcanza la Release se registra bajo esa referencia como el Component o la Feature, así que nada en el lockfile cambia cuando cambian los archivos de la Recipe.
Mensajes emitidos:
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 (los archivos de la fuente local de la entidad no coinciden con las fijaciones registradas para ellos en entity.lock, con el archivo, su digest y su fijación registrada indicados. Si la fuente se cambió a propósito, ejecuta aggrega pin sobre la entidad para volver a registrar sus archivos; si no, restaura los archivos) 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 (los archivos de la fuente local de la entidad no coinciden con las fijaciones registradas para ellos en entity.lock, con el archivo y su digest indicados, para el que no hay ninguna fijación registrada. Si la fuente se cambió a propósito, ejecuta aggrega pin sobre la entidad para volver a registrar sus archivos; si no, restaura los archivos) 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 (los archivos de la fuente local de la entidad no coinciden con las fijaciones registradas para ellos en entity.lock, con el archivo indicado, que ya no está en la fuente, y su fijación registrada. Si la fuente se cambió a propósito, ejecuta aggrega pin sobre la entidad para volver a registrar sus archivos; si no, restaura los archivos)
Cómo corregirlo: como para un archivo importado, dos respuestas, y cuál es la correcta depende de si el cambio era intencionado. Si lo era, ejecuta aggrega pin sobre la Recipe para que los archivos de su fuente se fijen de nuevo, y haz commit del entity.lock que reescribe. Si no lo era, restaura los archivos que nombra el mensaje.
A symbolic link sits among the files an entity carries (Un enlace simbólico se encuentra entre los archivos que lleva una entidad)
Cada archivo que lleva una publicación de una entidad se lee del directorio propio de la entidad, y un enlace simbólico allí se rechaza en lugar de seguirse. Seguirlo publicaría los bytes a los que apunta bajo el nombre propio del enlace — desde dondequiera que apunte, incluido fuera del directorio de la entidad — en un artefacto cuyo digest se calcula después y que, donde se aplica la firma, se firma. Omitirlo en cambio publicaría un artefacto cuyo contenido difiere silenciosamente de tu directorio. Así que toda forma de enlace se rechaza de la misma manera: un enlace a un archivo, un enlace a un directorio, un enlace que no apunta a ninguna parte, un enlace que apunta a sí mismo y dos enlaces que apuntan el uno al otro.
El rechazo se produce dondequiera que se leen los archivos de la entidad: por aggrega pin, por una publicación antes de empaquetar nada (incluida una ejecución de prueba), por un pull y un pull de verificación que contrastan el entity.lock con los archivos de la entidad, por una compilación que compara una fuente local con sus fijaciones, y por un renderizado que lee un directorio de fuente local antes de que se entregue nada de él a un proveedor. El mensaje nombra el enlace por su ruta junto al documento de la entidad, y el diagnóstico se sitúa en el propio enlace.
Un enlace que tus reglas de exclusión dejan fuera no es un archivo que lleve la entidad, así que se omite como cualquier otro archivo que esas reglas dejan fuera, y nunca se sigue. Esas reglas son las registradas en el entity.lock cuando se fijó la entidad, así que una línea que añadas a .aggregaignore surte efecto cuando vuelvas a fijar la entidad.
Mensaje emitido:
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 enlace simbólico se encuentra entre los archivos que lleva una entidad, con la ruta indicada. solución: sustituye el enlace por una copia de aquello a lo que apunta, colocada dentro del directorio propio de la entidad. Un enlace encontrado dentro de un directorio de fuente puede en cambio dejarse fuera con una línea en el .aggregaignore junto a la entidad, que surte efecto cuando la entidad se vuelve a fijar. Un enlace se rechaza en lugar de seguirse porque los bytes a los que apunta viajarían bajo el nombre del enlace, desde dondequiera que apunte)
Cómo corregirlo: donde la entidad necesita aquello a lo que apunta el enlace, sustituye el enlace por una copia de su destino dentro del directorio de la entidad, y vuelve a fijar la entidad. Donde el enlace está ahí para tu propia comodidad y la entidad no lo lee, añade su ruta al .aggregaignore junto al documento de la entidad y vuelve a fijar. Qué archivos se distribuyen con una entidad describe las reglas que deciden qué lleva una entidad.
An entity reads an input the lock beside it records no pin for (Una entidad lee una entrada para la que el lock junto a ella no registra ninguna fijación)
Una Recipe o FeatureRecipe puede depender de bytes ajenos a su propio documento: un source: remoto cuyas coordenadas están escritas por completo, un archivo que una entrada artifacts importa con $import, y los archivos de un source: que nombra un directorio o un archivo junto a ella. La fijación de cada uno se registra en el entity.lock junto a la entidad, y registrarla es el paso del autor de la entidad, aggrega pin. Así que un pull no registra esas fijaciones por su cuenta: sobre una entidad de uno de tus directorios de catálogo que la Release compila, compara lo que registraría el paso con lo que contiene el lock, y se detiene cuando al lock le falta una fijación — o contiene una con la que la entrada ya no coincide — en lugar de escribir en el directorio del autor sin que se le pida. Una compilación que rellena su propio lockfile es un pull y se detiene de la misma manera.
Un push se detiene ante la misma comparación, sobre la única entidad que está a punto de publicar. Antes de construir el bundle, y antes de contactar con ningún registro, compara lo que registraría el paso para la entidad con el lock junto a ella, y rechaza de la misma manera — incluida una ejecución de prueba — salvo que se haya pedido al push que ejecute el paso él mismo. Lo que el mensaje sugiere al final difiere entre ambos, porque cada comando tiene sus propias maneras de hacer registrar las fijaciones; lo que informa, no.
Una fuente local se contrasta con sus fijaciones como un único conjunto de archivos. Donde el lock no registra ninguna de ellas, cada archivo que aporta la fuente se informa aquí como ausente. Donde las registra, un archivo añadido después de la fijación se informa como ausente y un archivo cambiado o eliminado como una fijación con la que la entrada ya no coincide, y una compilación informa el mismo cambio como A local source no longer matches the pins recorded beside its Recipe (Una fuente local ya no coincide con las fijaciones registradas junto a su Recipe). Las fijaciones que un lock aún registra para una fuente local que la Recipe ya no declara — su source: eliminado, o que ahora nombra un artefacto remoto — no fijan nada de lo que lee la Recipe, así que no detienen ni un pull, ni un push, ni un pull de verificación, ni una compilación; el siguiente aggrega pin las descarta.
El mensaje nombra cada entrada que le falta, por clase. Cada una es una remote source, nombrada por su url y la versión a la que se resolvió, un imported file, nombrado por la clave artifacts que lo consume, o un local source file, nombrado por su ruta junto a la entidad — así sabes si lo que necesita fijarse es una fuente o un archivo. Cada entidad de este tipo en la Release se informa en una sola ejecución.
Un pull nunca contrasta así una entidad resuelta desde un registro, porque su publicación ya lo fue. Vive en la caché de contenido y no en un directorio del que seas autor, así que un pull no lee ni escribe ningún lock junto a ella, y sus fuentes se contrastan con el lockfile de la Release. Una entidad publicada con aggrega push se rechazó en la publicación a menos que su lock registrara cada fijación que el paso habría registrado para ella entonces, y ese lock viaja dentro del bundle publicado.
Mensajes emitidos, por un pull y por 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 (una entrada que lee la entidad no tiene ninguna fijación registrada para ella en el entity.lock junto a ella, con la Recipe indicada, una fuente remota indicada con su versión para la que no hay ninguna fijación registrada, y un archivo importado indicado con el que la fijación registrada ya no coincide. solución: ejecuta aggrega pin sobre la ruta de la entidad indicada y haz commit del entity.lock que escribe junto a la entidad; para que en cambio cada pull de este espacio de trabajo registre las fijaciones por sí mismo, establece pin_sources_at_pull: true en la configuración del espacio de trabajo) 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 (una entrada que lee la entidad no tiene ninguna fijación registrada para ella en el entity.lock junto a ella, con la Recipe indicada y una fuente remota indicada con su versión para la que no hay ninguna fijación registrada. solución: ejecuta aggrega pin sobre la ruta de la entidad indicada y haz commit del entity.lock que escribe junto a la entidad; para que en cambio esta publicación registre las fijaciones por sí misma, vuelve a ejecutarla con —pin-sources; para que cada publicación de este espacio de trabajo las registre, establece pin_sources_at_push: true en la configuración del espacio de trabajo)
La cláusula central del mensaje de la publicación nombra lo que acepta la superficie desde la que publicaste: --pin-sources en una terminal, el campo pinSources en el daemon y el argumento pin_sources de la herramienta del asistente.
Cómo corregirlo: donde la entidad es tuya, ejecuta aggrega pin sobre ella y haz commit del entity.lock que escribe, y luego vuelve a hacer el pull o el push — o haz el push con --pin-sources, que ejecuta el paso antes de construir el bundle. Donde es de otra persona — un catálogo que consumes desde un directorio propio —, quien la publica aún no la ha fijado; establece pin_sources_at_pull: true en la configuración de tu espacio de trabajo para que cada pull registre las fijaciones por sí mismo, o pasa --pin-sources a un único pull. aggrega pin describe el paso por completo.
A provides: template could not be evaluated (No se puede evaluar una plantilla de provides)
Una entrada provides: es una plantilla que produce el valor que otro componente lee a través de una conexión de dependencia. Esta condición es lo que informa una entrada que no se pudo evaluar: una plantilla que no se puede analizar, una función a la que llama y que esta superficie no registra, una referencia que desciende a través de algo que el contexto de renderizado no proporcionó, o una lectura con index de una clave que el mapa no contiene.
Es distinta de los dos rechazos que se ejecutan antes de la evaluación sobre el mismo bloque — una referencia a una raíz fuera del conjunto autónomo y una referencia que rechaza el propio orden de autoría del bloque —, ambos documentados más arriba. Esos nombran la expresión que hay que cambiar; esta lleva lo que haya informado la propia evaluación, y por eso la entrada se nombra a su lado.
Mensaje emitido, que nombra la instancia de componente, la entrada dentro del bloque y lo que informó la evaluación:
provides template evaluation failed (node "<instance>", provides["<key>"], <what the evaluation reported>) (la evaluación de la plantilla de provides falló, con el nodo, la clave de provides y lo que informó la evaluación indicados)
El encabezado lleva el código de esta condición, E0056, sea lo que sea lo que informó la evaluación. Donde la evaluación se detuvo en una condición de detención propia — una lectura con index de una clave que el mapa no contiene es la habitual —, esa condición se informa debajo de esta en lugar de en su sitio: bajo caused by (2):, la frase de esta condición va primero y el informe propio de la evaluación después, incluida su frase. Así, quien coteja códigos asocia cada entrada provides: fallida a E0056, y lee qué hizo fallar la evaluación en la condición de debajo, cuya frase remite a su propio código en la tabla de todas las condiciones — E0327 para la clave ausente.
Cómo corregirlo: abre el bloque provides: de la Recipe en la clave que nombra el mensaje y lee el motivo informado — suele nombrar una posición de análisis o una función. El manejo de claves ausentes en esta superficie renderiza una clave final ausente como nada en lugar de fallar, así que un fallo aquí es un defecto estructural: una plantilla que no se puede analizar, una referencia que desciende a través de un contenedor que nunca se proporcionó, o una lectura con index de una clave que el mapa no contiene, que nombra el motivo informado. Donde el valor es realmente opcional, léelo a través del helper optional en lugar de descender a algo que puede no estar ahí.
A Recipe or FeatureRecipe does not publish a provides key its contract declares (Una Recipe o una FeatureRecipe no publica una clave provides que su contrato declara)
Un Component y una Feature declaran cada uno, bajo schema.provides, las claves que publicará todo lo que los asocie — el contrato de salida contra el que un consumidor escribe sus conexiones. La Recipe asociada a un Component y la FeatureRecipe asociada a una Feature tienen que producir cada clave que nombra ese contrato. Una que no lo hace se rechaza, porque de lo contrario la clave ausente no entregaría absolutamente nada: la referencia del consumidor llegaría como una variable no definida, un argumento vacío o un archivo que no está, sin que nada diga por qué.
El contrato es la presencia de las claves, y nada más. Cada clave declarada tiene que aparecer; se permiten claves adicionales. Los propios valores nunca se inspeccionan — son punteros opacos canalizados como cadenas, así que los tipos que declara un contrato siguen siendo una indicación para el consumidor y no una comprobación que haga la compilación.
Se informa de cada carencia. Una Recipe a la que le faltan tres claves genera tres hallazgos, cada uno situado en su propia entrada del bloque provides: de esa Recipe, así que los tres se corrigen a partir de una sola compilación. El mensaje nombra la clave ausente, el tipo cuyo contrato la declara y la instancia a la que estaba asociada la Recipe — esta última es lo que distingue dos hallazgos cuando una Recipe sirve a varias instancias de un mismo tipo.
Mensaje emitido:
Recipe or FeatureRecipe does not publish a provides key its abstract entity’s schema.provides contract declares ("<key>", declared by component type "<type>", bound to component instance "<instance>") (la Recipe o la FeatureRecipe no publica una clave provides que declara el contrato schema.provides de su entidad abstracta (con la clave indicada, declarada por el tipo de componente indicado, asociada a la instancia de componente indicada))
El emparejamiento entre Feature y FeatureRecipe informa de la misma condición a través de la resolución propia de la vinculación, nombrando el par y la clave:
Recipe or FeatureRecipe does not publish a provides key its abstract entity’s schema.provides contract declares (<attachment context>, <the FeatureRecipe> does not publish provides key "<key>" declared by <the Feature>’s schema.provides contract) (la Recipe o la FeatureRecipe no publica una clave provides que declara el contrato schema.provides de su entidad abstracta (con el contexto de vinculación indicado: la FeatureRecipe indicada no publica la clave provides indicada, declarada por el contrato schema.provides de la Feature indicada))
Allí informa de la primera clave ausente en orden alfabético y se detiene, así que ese emparejamiento nombra una clave por compilación mientras que el emparejamiento del Component las nombra todas. Las claves se recorren en orden alfabético en ambos casos, que es lo que hace que ambos sean iguales de una ejecución a otra.
Cómo corregirlo: añade la clave ausente al bloque provides: de la Recipe o la FeatureRecipe, o quítala del schema.provides del Component o la Feature donde no se espera que nada la publique. Una clave cuya plantilla se renderiza como nada se publica igualmente, con la cadena vacía como valor, así que una entrada presente y vacía cumple el contrato y no se informa aquí. Donde un valor vacío deba detener la compilación, recházalo en una aserción: las aserciones de una Recipe leen sus valores provides: resueltos.
An assertion stopped the build (Una aserción detuvo la compilación)
Un Component, una Feature, una Recipe o una FeatureRecipe puede llevar assertions: — plantillas con nombre cuyo propósito es rechazar una entrada en lugar de producir texto. Una aserción llama a fail, y esa llamada es lo que detiene la compilación; el argumento es el mensaje que su autor escribió para quien se encuentre con ella.
Las aserciones se evalúan en dos momentos, para que una regla lea el estado del que trata: las de un Component o una Feature se ejecutan una vez resuelto el catálogo y antes de que se renderice nada, y las de una Recipe o una FeatureRecipe se ejecutan una vez establecida la asociación y antes de que esa asociación se renderice.
Una referencia a una clave que nada aporta también se informa aquí. La superficie evalúa con un tratamiento estricto de claves ausentes, precisamente para que un predicado cuya referencia se renderizó vacía no pueda compararse con nada y pasar en silencio — de lo contrario, una sola errata dejaría sin efecto la regla que la aserción se escribió para hacer cumplir. Por eso un default simple no aporta un respaldo en esta superficie: la referencia desnuda detiene la evaluación antes de que el respaldo pueda ejecutarse. Condiciona la referencia con hasKey, o usa el helper optional; leerla a través de index también detiene la compilación, nombrando la clave, como describe «A template indexes a map with a key the map does not hold (Una plantilla indexa un mapa con una clave que el mapa no contiene)».
Mensaje emitido, que nombra la clase de entidad y el tipo, la instancia y la aserción, y después lleva el mensaje que escribió la propia aserción:
<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> (aserción indicada de la instancia indicada, del tipo y la clase de entidad indicados: aserción indicada: plantilla: en la línea y la columna indicadas: ejecución de la aserción indicada en la expresión fail indicada: error al llamar a fail: la aserción falló: con el mensaje que escribió la aserción)
y, para una clave que nada aporta, la frase del motor de plantillas después de la propia de la condición:
<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>" (aserción indicada de la instancia indicada, del tipo y la clase de entidad indicados: aserción indicada: la aserción falló: plantilla: en la línea y la columna indicadas: ejecución de la aserción indicada en la referencia indicada: el mapa no tiene ninguna entrada para la clave indicada)
y donde lo que falló fue la evaluación y no el predicado:
<entity-kind>"<type>" instance "<instance>" assertion "<name>": assertion "<kind>/<type>/<instance>/<name>" parse: <what the parse reported> (aserción indicada de la instancia indicada, del tipo y la clase de entidad indicados: análisis de la aserción indicada: con el resultado del análisis indicado)
Un valor declarado sensible no aparece en el mensaje. Donde la aserción lee un valor así y llama a fail con su frase escrita completa como una única cadena entre comillas — fail "…", sin nada canalizado hacia ella y sin nada compuesto —, el mensaje lleva esa frase tal como está escrita, contenga lo que contenga el valor, porque la frase no cita nada de lo que leyó la aserción. Donde su mensaje cita el valor, el mensaje muestra <redacted> en el lugar del valor. Donde el mensaje se compone de cualquier otra forma y lo que hizo la aserción dependía de lo que contiene el valor, el mensaje que sigue a la expresión fallida se sustituye por failure text withheld: this template reads a value declared sensitive, and the failure depends on what that value holds; la detención y su código no cambian. Qué cuenta como declarado, y qué rechazos quedan fuera de esto, se describe en vocabulary/compact-form-authoring.md «Qué dice un rechazo sobre un valor declarado».
Comprobada por sí sola, una entidad informa de una aserción fallida como una advertencia.aggrega validate con el archivo de una Recipe, la comprobación de ese archivo por parte del editor a través de aggrega serve y la herramienta validate de aggrega mcp con una entity construyen la Recipe en torno a marcadores de posición y valores predeterminados del esquema en lugar de los valores que fija una Release, así que no pueden distinguir una aserción que espera una Release de una que está rota. Ahí, una aserción que llama a fail — la propia de la Recipe, o una que declara el Component que esta implementa — se informa como una advertencia que lleva el mensaje anterior, cerrado por la frase A Release must satisfy this assertion before a build of it can pass., y la comprobación pasa. Una referencia a una clave que nada aporta y una aserción que no se puede analizar no son aserciones fallidas: cada una es un fallo en el propio texto de la aserción, y esa comprobación la juzga como juzga cualquier otro fallo. Una compilación siempre tiene una Release, y se detiene en la aserción como se describe aquí; consulta una aserción fallida es una advertencia.
Cómo corregirlo: el mensaje que sigue a los últimos dos puntos es del autor de la aserción, y es el que dice qué cambiar — una aserción se escribe para que encontrarse con ella te dé la respuesta. Donde el informe es una clave ausente en lugar de la frase del autor, el fallo está en la propia aserción: corrige la referencia, o condiciónala como se describe más arriba. Donde la regla no debería aplicarse a esta Release, se trata de una cuestión sobre la entidad que lleva la aserción y no sobre tu propio archivo.
A pipeline step addresses documents the node does not have (Un paso de pipeline direcciona documentos que el nodo no tiene)
Un paso de pipeline direcciona un documento mediante un ámbito y una clave. Tres condiciones cubren las formas en que una dirección no alcanza nada, y cada una detiene la compilación en lugar de dejar que un paso informe de un éxito sobre una edición que nunca ocurrió.
El nodo no lo emitió. Un parche nombra un par de ámbito y clave que no está entre los documentos que produjo este nodo:
node "<instance>": pipeline PATCH targets a document the node did not emit (nodo indicado: el PATCH de pipeline apunta a un documento que el nodo no emitió)
No hay ningún anfitrión que direccionar. Un paso buscó los documentos de un componente anfitrión en un lugar donde no hay ninguno — el pipeline propio de un componente, cuyo único ámbito es su propia salida, o una Feature vinculada a un límite y no a un solo componente. El ámbito del anfitrión está vacío dondequiera que se ejecute un pipeline así, así que una dirección dentro de él no se resuelve contra nada:
node "<instance>": pipeline /host operation from a step with no host component (nodo indicado: operación /host de pipeline desde un paso sin componente anfitrión)
El documento no lleva ningún árbol que direccionar. Algunas unidades no tienen ninguna estructura a la que pueda apuntar una ruta — un cuerpo binario, texto libre, una región que el destino no puede recorrer con seguridad. Una unidad así se entrega igualmente al paso, para que pueda seleccionarse y emitirse entera; lo que no puede es recibir un parche:
node "<instance>": pipeline PATCH target is not parseable structured YAML/JSON (nodo indicado: el destino del PATCH de pipeline no es YAML/JSON estructurado analizable) pipeline PATCH target is not parseable structured YAML/JSON (node "<instance>", document "<key>") (el destino del PATCH de pipeline no es YAML/JSON estructurado analizable (con el nodo y el documento indicados))
Cada una llega con el relato propio del recorrido sobre la dirección debajo, y cada una se sitúa en la instancia de componente cuyo pipeline la produjo.
Dos de las tres también se informan antes de cualquier recorrido. Que un lugar tenga o no documentos del anfitrión se deduce de dónde se escribió el pipeline, así que un paso que declara operar sobre documentos del anfitrión en un lugar que no los tiene se nombra en cuanto la compilación sabe lo que declara cada plugin, sin esperar a que se renderice un nodo — y una Feature vinculada a un límite se nombra junto al paso:
pipeline /host operation from a step with no host component (operación /host de pipeline desde un paso sin componente anfitrión) pipeline /host operation from a step with no host component ("<attachment>") (operación /host de pipeline desde un paso sin componente anfitrión (con la vinculación indicada))
Las dos lecturas son una división de una sola condición y no el mismo hallazgo dos veces: lo que una declaración puede resolver se resuelve a partir de la declaración, y lo que solo la ejecución puede ver queda en la ejecución — un paso que declara su propio ámbito todavía puede devolver una operación contra otro.
Estas tres son la forma que detiene la compilación de los rechazos de direccionamiento que informa el propio recorrido del pipeline, documentados bajo «A pipeline patch addresses a document the set does not hold, or one with no tree to address (Un parche de pipeline direcciona un documento que el conjunto no contiene, o uno sin árbol que direccionar)» más arriba.
Cómo corregirlo: las tres corresponden al autor del paso y no a ti. Para un destino ausente, aplica el parche a un documento que el nodo sí emita, o emite el que querías en un paso anterior y aplícale el parche en uno posterior — un paso puede leer qué claves recibió. Para un anfitrión que falta, mueve el paso a un lugar donde haya un componente anfitrión, direcciona en su lugar los documentos propios del lugar, o elimínalo. Para una unidad sin árbol, sustituye el parche por una emisión de la unidad entera: un cuerpo opaco se sustituye en lugar de editarse.
A pipeline patch addresses output that has not been assembled yet (Un parche de pipeline direcciona una salida que todavía no se ha ensamblado)
Algunos proveedores combinan la salida por nodo de un grupo de despacho en un solo documento — un archivo compose fusionado, un chart paraguas. Hasta que se produce esa fusión no hay documentos separados, solo fragmentos, así que un parche que direcciona uno no tiene nada a lo que apuntar. Por eso un pipeline contra un componente así se aplaza entero y se vuelve a ejecutar una vez que la fusión ha producido los documentos, que es el camino ordinario y no requiere nada del autor.
Esta condición es lo que llega a la compilación cuando un parche alcanza de todos modos un fragmento. El caso que nombra es la salida propia de una Feature vinculada. Donde el proveedor del componente combina su grupo, todo el pipeline de la vinculación se retiene hasta que la fusión ha producido los documentos — y lo que recibe esa reejecución son únicamente los documentos del componente. Un paso contra la salida propia de la Feature solo se ofrece mientras el componente se renderiza, es decir, antes de que haya ocurrido ninguna fusión, así que no tiene nada que direccionar. Eso se cumple sea cual sea la forma en que viaje la salida propia de la Feature: tanto si se une a la fusión como si se escribe como documentos propios, su propio ámbito nunca es el ámbito que lleva la reejecución.
La emisión nunca se ve afectada. Una emisión añade un documento en lugar de editar uno, y se ejecuta por nodo con cada proveedor, así que queda completamente fuera de esto.
La condición se informa antes de cualquier recorrido, a partir de lo que declaran los plugins y los proveedores, y de nuevo como salvaguarda mientras se renderiza un nodo. Mensajes emitidos:
pipeline PATCH targets an assembler provider’s pre-assembly fragments ("<attachment>") (el PATCH de pipeline apunta a los fragmentos previos al ensamblado de un proveedor ensamblador (con la vinculación indicada)) 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 (el PATCH de pipeline apunta a los fragmentos previos al ensamblado de un proveedor ensamblador (nodo indicado; el documento indicado, en el ámbito indicado, lo renderiza un proveedor ensamblador). la fase posterior al ensamblado vuelve a ejecutar este PATCH una vez que los documentos están separados)
Cómo corregirlo: direcciona los documentos del componente en lugar de los propios de la Feature, que es la forma que se vuelve a ejecutar después de la fusión; o pon el componente en un proveedor que no combine su grupo de despacho; o elimina el paso. Cuál de las tres es la correcta depende de lo que el paso debía cambiar, y el mensaje nombra el ámbito que direccionó para que puedas saberlo. Cambiar la capability: propia de la FeatureRecipe no está entre ellas: no cambia qué ámbito recibe la reejecución después de la fusión, y de eso trata precisamente esta condición.
A pipeline step’s plugin does not claim the provider rendering what it addresses (El plugin de un paso de pipeline no reivindica el proveedor que renderiza lo que el paso direcciona)
Un plugin que usa un paso de pipeline puede declarar los proveedores con los que se ha probado. Esa lista es una reivindicación explícita y no un «cualquier cosa parecida» implícito: ejecutar un plugin con un proveedor que no nombra arriesga un parche escrito para otra forma de salida, así que la compilación se detiene en lugar de intentarlo.
El proveedor con el que se compara un paso es el que renderiza los documentos que ese paso direcciona — el proveedor propio del componente para un paso contra los documentos del componente, y el proveedor propio de la Feature para un paso contra los de la Feature. En una Feature vinculada a un componente surgen ambos, y son dos valores distintos de dos documentos distintos.
Una lista de reivindicaciones vacía o ausente no coincide con nada, así que cada paso que usa un plugin así se informa aquí. Un plugin al que la compilación no pudo preguntar es un caso distinto y no se informa aquí: una autodeclaración imposible de obtener es la ausencia de una reivindicación y no una reivindicación vacía, y un paso así se detiene con el propio fallo de resolución, de carga o de autodeclaración, que es lo que hay que reparar.
La condición se informa en cuanto la compilación sabe lo que cada plugin declara sobre sí mismo, antes de la ejecución que invocaría el paso, y una vez por cada paso escrito en lugar de una vez por compilación — así un autor ve todos los pasos problemáticos de un pipeline a partir de una sola compilación. Los nombres de Provider se comparan de forma exacta.
Mensajes emitidos, el primero desde el pipeline propio de un componente y el segundo desde el de una Feature, que también nombra la vinculación:
pipeline plugin is not compatible with the rendering provider ("<provider>") (el plugin de pipeline no es compatible con el proveedor que renderiza, el indicado) pipeline plugin is not compatible with the rendering provider ("<attachment>", "<provider>") (el plugin de pipeline no es compatible con el proveedor que renderiza (con la vinculación y el proveedor indicados))
Cómo corregirlo: el hallazgo se sitúa en el paso escrito, y el proveedor que nombra es aquello con lo que hay que conciliar la declaración. Donde el plugin es tuyo, añade el proveedor a la compatibilidad que declara una vez que lo hayas probado con él. Donde no lo es, selecciona una versión del plugin que reivindique el proveedor, renderiza ese ámbito a través de un proveedor que el plugin sí reivindique, o elimina el paso.
A provider refused a node’s input (Un proveedor rechazó la entrada de un nodo)
Un proveedor puede comprobar la entrada que recibe para un componente antes de renderizarla, e informar de lo que encuentra. Los hallazgos con gravedad de detención detienen la compilación; los hallazgos con gravedad de advertencia y de información se muestran junto a la salida de la compilación y no cambian nada de los bytes emitidos.
Esta es la lectura que el propio proveedor hace de tu entrada y no la del compilador, así que a qué se opone y con cuánta precisión lo dice lo decide el proveedor. El compilador nombra el componente y el proveedor, y transmite los mensajes del proveedor tal como se devolvieron; cuando un proveedor informó de varios, llegan juntos separados por punto y coma, así que una sola compilación te informa de todos.
Se usa el mismo encaminamiento tanto si la entrada pertenece a la Recipe propia de un componente como si pertenece a una Feature vinculada, así que la comprobación de un proveedor se lee de forma idéntica en ambos casos.
Mensaje emitido:
provider rejected node input: node "<instance>", provider "<provider>": <the provider's messages> (el proveedor rechazó la entrada del nodo: con el nodo, el proveedor y los mensajes del proveedor indicados)
Cómo corregirlo: lee los mensajes del proveedor — nombran lo que no pudo aceptar de la entrada resuelta. La entrada se compone a partir de los valores de la Recipe y de la configuración propia del componente, así que la corrección suele estar en uno de ellos; la página de referencia propia del proveedor dice lo que requiere. Donde el proveedor se opone a algo que no puedes cambiar desde un documento, es una cuestión para quien escribió la Recipe o el plugin.
A provider rendered the same input twice and produced different output (Un proveedor renderizó dos veces la misma entrada y produjo salidas distintas)
Con una entrada idéntica, una compilación produce una salida idéntica — ese es el contrato con el que las herramientas de revisión y las herramientas de despliegue leen el resultado de una compilación. Un modo de compilación opcional lo comprueba directamente: cada componente se renderiza dos veces a partir de la misma entrada y se comparan los bytes emitidos. Un proveedor cuyos dos renderizados no coinciden arrastra estado de uno a otro, o de algún otro modo no es una función de su entrada, y la compilación se detiene.
La compilación ordinaria renderiza cada componente una vez, así que esta condición solo se da en el modo de comprobación. Nada de una compilación normal cambia porque ese modo esté disponible.
Lo que se compara es la salida bruta emitida por el proveedor — los mismos bytes de los que se recortan los artefactos renderizados —, así que se detecta una diferencia en cualquier parte de lo que produjo, y no solo una diferencia que sobrevive hasta un archivo final.
Mensaje emitido:
rendering node "<instance>": node "<instance>" (provider "<provider>"): two renders of identical input produced different output: provider render is not deterministic (renderizado del nodo indicado: nodo indicado, con el proveedor indicado: dos renderizados de una entrada idéntica produjeron salidas distintas: el renderizado del proveedor no es determinista)
Cómo corregirlo: primero averigua qué difiere entre dos compilaciones del componente que nombra el mensaje — compílalo dos veces y compara las salidas. Donde la diferencia es un valor que un chart que usas como fuente genera de nuevo en cada renderizado — una contraseña aleatoria, una clave generada, una marca de tiempo en un Secret o una ConfigMap —, el fallo está en la salida de ese chart y no en el proveedor, y puedes eliminarlo tú mismo de una de dos formas. Proporciona el valor, mediante el ajuste que el chart ofrezca para él, desde el valuesMapping: de la Recipe, para que el chart deje de generarlo. O bien, donde el documento generado es uno que la Release no debe entregar — un Secret que el operador proporciona por separado, por ejemplo —, déjalo fuera de la compilación con una entrada omits: en la Recipe; consulta Recipe → El campo omits:. De lo contrario, el fallo es del proveedor y no de tus documentos, y nada que puedas escribir lo elimina. Infórmalo a quien publique el plugin que sirve ese proveedor, nombrando el componente que identifica el mensaje — las causas habituales son una marca de tiempo, un valor aleatorio o un orden que sigue la iteración de un mapa en lugar del orden que escribió el autor. Hasta que se corrija, el modo de compilación ordinario no se ve afectado, y fijar el plugin a una versión que superó la comprobación es la respuesta práctica.
An omits entry left out nothing the source rendered (Una entrada omits no dejó fuera nada de lo que renderizó la fuente)
Toda entrada de la lista omits: de una Recipe o de una FeatureRecipe que se aplica a una compilación — con su when: ausente, vacío o verdadero — debe dejar fuera de la salida al menos una cosa que renderizó la fuente: un documento que renderiza un chart, un servicio, un volumen o una config que declara un archivo compose, o un recurso que declara una plantilla CloudFormation. El proveedor que renderiza la fuente compara cada entrada con lo que renderizó e informa de cuántas unidades dejó fuera cada una; una entrada que no dejó ninguna fuera detiene la compilación.
Una entrada que no coincide con nada es una afirmación sobre la fuente que ya no es cierta. La causa habitual es una actualización de la fuente que renombró o eliminó lo que nombra la entrada — y un documento o servicio renombrado está entonces en la salida con su nuevo nombre, que es exactamente lo que la entrada se escribió para mantener fuera —, y la otra es un error en la propia entrada. Pasarla por alto entregaría lo que la entrada debía dejar fuera, así que la compilación se detiene y nombra la entrada.
El mensaje nombra el nodo, el proveedor, el documento que declara la entrada y la posición de la entrada en la lista omits: de ese documento, contando desde 0, y el kind, el nombre y el namespace en los que se resolvió la entrada, el namespace solo donde la entrada nombra uno. Para una FeatureRecipe vinculada a un componente, el nodo es ese componente; para una vinculada a un límite, la línea sobre el mensaje nombra la vinculación y su límite. Donde varias entradas no coincidieron con nada, se nombra la primera en el orden en que las escribiste, así que se nombra la misma entrada en cada ejecución. Un campo cuya plantilla leyó un valor declarado sensible se muestra como <redacted> en lugar de como aquello en lo que se resolvió. Una entrada que su when: descartó nunca se entrega al proveedor ni se comprueba.
Mensaje emitido. La categoría te llega en el encabezado entre corchetes:
an omits entry left out nothing the source rendered (node "<node-id>", provider "<provider>", "<document>" omits[<position>], kind "<kind>", name "<name>", namespace "<namespace>"). correct the entry so it names something the source renders, or remove it; a source upgrade that renamed or removed it is the usual cause (una entrada omits no dejó fuera nada de lo que renderizó la fuente (con el nodo, el proveedor, la posición en la lista omits del documento, el kind, el nombre y el namespace indicados). corrige la entrada para que nombre algo que renderiza la fuente, o elimínala; la causa habitual es una actualización de la fuente que renombró o eliminó lo que nombraba)
El encabezado lleva el código corto de esta condición, E0334.
Cómo corregirlo: compara la entrada con lo que renderiza ahora la fuente — compila con la entrada eliminada y lee lo que renderiza el componente —, y luego corrige el kind, el nombre o el namespace de la entrada, o elimina la entrada donde lo que nombraba ya no existe. Para un chart, una entrada nombra un documento por el kind y el metadata.name propios del documento y, cuando la entrada nombra un namespace, por el namespace en el que está el documento; para un archivo compose, nombra un service, un volume o un config por su clave; para una plantilla CloudFormation, nombra un recurso por su Type y su ID lógico, en cualquiera de las plantillas de la fuente. Consulta Recipe → El campo omits:.
A provider’s omitted counts do not match the omits entries it was handed (Los recuentos de omisiones de un proveedor no coinciden con las entradas omits que recibió)
Un proveedor que declara que deja fuera unidades renderizadas informa, para cada entrada omits: que recibió, con cuántas unidades coincidió esa entrada — un recuento por entrada, en el orden en que se entregaron las entradas. Un informe ausente, que contiene demasiado pocos o demasiados recuentos, o que contiene un recuento inferior a cero no deja forma de saber si una entrada dejó algo fuera, así que la compilación se detiene. Nada de lo que escribiste lo causa: informa de un proveedor cuya salida devuelta no cumple el contrato que declara.
Mensaje emitido. El mensaje nombra el nodo y el proveedor, y luego cuántas entradas se entregaron y qué volvió — o bien cuántos recuentos, o bien el recuento inferior a cero y la entrada para la que se dio:
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) (los recuentos de omisiones de un proveedor no coinciden con las entradas omits que recibió (con el nodo y el proveedor indicados, el número indicado de entradas omits entregadas y el número indicado de recuentos de omisiones devueltos))
El encabezado lleva el código corto de esta condición, E0336.
Cómo corregirlo: infórmalo a quien publique el plugin que sirve ese proveedor, nombrando el componente que identifica el mensaje. Lo que debe cumplir un proveedor se expone en el contrato de plugins en Dejar fuera unidades renderizadas.
Assembled output still carries a cross-boundary placeholder (La salida ensamblada todavía lleva un marcador de posición entre límites)
Donde una conexión de dependencia cruza entre dos salidas ensambladas, el valor que lleva no puede conocerse mientras se renderiza el lado consumidor — lo publica el otro lado y se resuelve una vez que ambos se han ensamblado. Así que la compilación escribe un marcador de posición en la entrada del componente consumidor, y el proveedor lo sustituye por su propia forma de referencia cruzada una vez que existe el ensamblado.
Esta condición es lo que informa un marcador de posición que sobrevivió a esa sustitución. Sobrevivir significa que la resolución nunca lo alcanzó: el valor acabó en algún lugar que el proveedor no podía direccionar — insertado en una cadena más larga en lugar de figurar como valor entero, lo más habitual —, o se marcó un cruce sin nada al otro lado que lo resolviera. Un marcador de posición nunca es una salida válida, así que la compilación se detiene en lugar de entregar un archivo que contenga uno.
El mensaje nombra el proveedor que escribió el archivo y la ruta en la que está el archivo: una ruta solo es única dentro de un mismo ensamblado, así que son las dos juntas las que identifican un archivo. Se informa de cada archivo problemático, no solo del primero, y cada uno se informa una sola vez, sean cuantos sean los límites que alimentaron el ensamblado en el que está. Se informa sobre el documento de la Release en su conjunto y no sobre un límite dentro de él — el fallo está en cómo un valor llegó al archivo y no en una declaración de límite, así que ninguna declaración de límite es lo que hay que cambiar.
Mensaje emitido:
assembled output retains an unresolved cross-boundary link placeholder ("<provider>", "<output-path>") (la salida ensamblada conserva un marcador de posición de enlace entre límites sin resolver (con el proveedor y la ruta de salida indicados))
Cómo corregirlo: la causa más común es un valor que el lado consumidor interpoló en una cadena más larga. Una referencia cruzada tiene que constituir la totalidad del valor como el que se inyecta, así que cambia el mapeo de la Recipe para que la entregue entera y, en su lugar, compón alrededor de ella en el vocabulario propio del destino. Donde el valor está entero y el marcador de posición aun así sobrevive, el fallo está del lado del proveedor en la resolución y corresponde a quien publique ese plugin.
A template did more than copy a value it read off a cross-boundary link (Una plantilla hizo algo más que copiar un valor que leyó de un enlace entre límites)
Una plantilla puede leer los valores de un productor directamente de una conexión, en .context.uses.<alias>.provides — o, en una FeatureRecipe con ámbito de límite, de las conexiones del límite bajo .boundary. Donde la conexión une dos componentes que se renderizan en salidas distintas y el proveedor la cablea con una referencia propia, cada uno de esos valores llega a la plantilla como un marcador de posición que el proveedor sustituye una vez que ambas salidas se han ensamblado: con una referencia entre stacks, o con el propio valor. Así que una plantilla solo puede copiar un valor así — escribirlo entero, dentro de una cadena más larga, o a través de una función que lo deje tal cual, como quote.
Una comparación, una bifurcación, una longitud o una función que cambia el valor — eq, if, len, upper, trimPrefix — se decidiría contra el marcador de posición y no contra el valor, en silencio. La compilación lo comprueba evaluando la plantilla dos veces, una sobre los marcadores de posición y otra sobre los valores reales, y se detiene donde ambas no coinciden una vez que cada marcador de posición se ha vuelto a escribir. Se aplica a toda plantilla que lee una conexión así: las plantillas propias de una Recipe, el injectMapping: de una FeatureRecipe vinculada y las plantillas de una FeatureRecipe con ámbito de límite.
El mensaje nombra la plantilla — el campo y la Recipe a la que pertenece — y, para cada valor provides del que depende la diferencia, el componente consumidor, el alias y el socket de la conexión, y el componente productor. Un valor que la plantilla solo copió no se nombra.
Mensaje emitido:
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 (una plantilla hace algo más que copiar un valor que lee de un enlace entre límites (con la plantilla indicada y la clave provides indicada que el componente consumidor indicado lee de su conexión indicada, en el socket indicado, hacia el componente productor indicado). Copia el valor tal como está, entero o dentro de una cadena más larga, porque el proveedor escribe en su lugar aquello en lo que se convierte el valor en la otra salida, y bifurca en cambio según un valor propio del componente)
Cómo corregirlo: copia el valor que nombra el mensaje en lugar de comprobarlo o transformarlo, y basa la decisión en un valor que el componente consumidor escribe por sí mismo — una de sus propias claves values o infra — en lugar de en lo que lee su conexión. El proveedor CloudFormation describe en qué se convierte un valor copiado en el otro stack.
A provider named a directory for a contributor that is not one directory (Un proveedor nombró para un contribuidor un directorio que no es un único directorio)
Un proveedor que coloca a cada contribuidor bajo su propia posición dentro de una misma salida contenedora declara el directorio bajo el que están esas posiciones, y la compilación compone en él la identidad de cada componente. El valor tiene que nombrar exactamente un directorio: un valor que lleve un separador de ruta, o que nombre el directorio actual o el directorio padre, colocaría los archivos de un componente en otro lugar que no fuera bajo su propia posición — o bien completamente fuera del ensamblado, o bien reorganizados en silencio dentro de él.
La compilación se detiene en lugar de componer una ruta así. El mensaje nombra el proveedor que declaró el valor y el propio valor, así que queda claro qué proveedor hay que cambiar y qué declaró.
Un proveedor que no declara ningún directorio así no se ve afectado. Cada contribuidor se sitúa entonces directamente en el directorio de despliegue con su propio nombre, así que no nombrar un directorio contenedor es una respuesta legítima y no una omisión.
Mensaje emitido:
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 (el proveedor nombró, para el subdirectorio propio de cada contribuidor, un directorio que no es un único nombre de directorio: el proveedor indicado declaró nest_segment con el valor indicado; el valor debe nombrar un solo directorio, sin separador de ruta y sin nombrar ni el directorio actual ni el directorio padre)
Cómo corregirlo: nada en ningún documento de catálogo produce este valor, así que no hay nada que corregir en tus propios archivos — procede del plugin que sirve el proveedor. Infórmalo a quien publique ese plugin, citando el valor que nombra el mensaje. Donde el plugin es tuyo, declara un único nombre de directorio, o no declares ninguno y deja que cada contribuidor se sitúe en el directorio de despliegue.
A boundary-scope Feature is attached only to a component (Una Feature con ámbito de límite está vinculada solo a un componente)
Una FeatureRecipe puede declarar que genera una sola vez para un límite en lugar de una vez para cada componente — un recurso compartido para todo lo que contiene el límite, en lugar de uno por componente. Por eso el límite es donde hay que escribir una vinculación así: una vinculación con ese nombre escrita solo sobre un componente no nombra ningún ámbito para el que la receta pueda generar, así que nada decide en qué límite se ejecutaría, qué valores leería ni dónde se escribiría su salida.
Escribirla también sobre un componente es habitual y no se informa. Una vinculación declarada en un límite llega a cada componente que contiene ese límite, incluidos los de los ámbitos anidados dentro de él, así que llevarla es la forma normal. Lo que se comprueba es si el ámbito propio del componente, o uno que lo envuelve, declara el nombre — la búsqueda avanza hacia fuera desde donde está el componente y se detiene en el primer ámbito que lo declara. Un componente que repite sobre sí mismo una vinculación que su ámbito envolvente ya declara se renderiza exactamente igual que la forma declarada solo en el ámbito, y se admite por el mismo motivo.
Un componente colocado en ningún ámbito no tiene nada que recorrer, así que una vinculación con ámbito de límite sobre él se informa aquí — que es la lectura honesta, ya que no hay ningún ámbito para el que una receta así pueda generar.
Mensaje emitido, que nombra la vinculación y el ámbito en el que está el componente:
attachment binds a FeatureRecipe with executionScope: boundary and no boundary holding the component declares it ("<attachment>", on a component in boundary "<boundary>") (la vinculación asocia una FeatureRecipe con executionScope: boundary y ningún límite que contiene el componente la declara (con la vinculación indicada, sobre un componente en el límite indicado))
y, para un componente en ningún ámbito, que no aporta ningún valor así:
attachment binds a FeatureRecipe with executionScope: boundary and no boundary holding the component declares it ("<attachment>") (la vinculación asocia una FeatureRecipe con executionScope: boundary y ningún límite que contiene el componente la declara (con la vinculación indicada))
Cómo corregirlo: declara la vinculación bajo features: en el límite para el que debe generar — el ámbito en el que está el componente, o uno que lo envuelva — en lugar de solo sobre el componente. Si lo que querías era una generación por componente, vincula en su lugar una Feature cuya FeatureRecipe no declare el ámbito de límite.
The sandbox refused a plugin (El sandbox rechazó un plugin)
Cada plugin informa de qué es y qué necesita antes de que se le permita hacer ningún trabajo, y el sandbox contrasta ese informe con lo que está dispuesto a conceder. Esta condición cubre toda la clase de informes que el sandbox no acepta, y la frase dice qué parte se rechazó: una versión de la interfaz de plugins que el anfitrión no habla, un tipo de plugin para el que el anfitrión no tiene vocabulario, un plugin que pide acceso de red saliente o acceso al sistema de archivos, un plugin que nombra una llamada al anfitrión fuera del conjunto que este ofrece o que importa desde un espacio de nombres fuera del conjunto que admite, un export ausente o mal formado, un campo que lleva un valor fuera del conjunto al que está restringido, o una autodeclaración que no se puede leer en absoluto.
El rechazo se produce antes de que el plugin se ejecute, y un plugin rechazado se detiene antes de que el fallo se propague, así que nada de lo que pidió se concede, ni siquiera brevemente.
Parte de lo que un plugin no puede tener no se comprueba aquí, porque nunca se concede. El anfitrión da a un invitado un reloj congelado, ningún sistema de archivos, ningún entorno y ningún lugar al que pueda ir su propia salida, así que un invitado que intenta alcanzar cualquiera de ellos falla en el intento en lugar de ser rechazado de antemano. Lo que cubre esta condición es el informe que el plugin hace sobre sí mismo, comprobado antes de que arranque.
Mensajes emitidos. La frase de la condición cierra cada uno, y lo que la precede nombra el plugin y la parte de su informe que se rechazó. Una versión de interfaz que el anfitrión no habla:
plugin "<plugin>" declares abi_version "<declared>"; host speaks "<supported>": wasm: plugin rejected by the sandbox (el plugin indicado declara la abi_version indicada; el anfitrión habla la versión admitida indicada: wasm: plugin rechazado por el sandbox)
un tipo de plugin para el que el anfitrión no tiene vocabulario:
plugin "<plugin>" declares unknown plugin_type "<declared>": wasm: plugin rejected by the sandbox (el plugin indicado declara un plugin_type desconocido, el indicado: wasm: plugin rechazado por el sandbox)
una autodeclaración que no se puede leer:
wasm: plugin "<plugin>" describe() output is not valid JSON: <what the read reported>: wasm: plugin rejected by the sandbox (wasm: la salida de describe() del plugin indicado no es JSON válido: con el resultado de la lectura indicado: wasm: plugin rechazado por el sandbox)
un plugin al que le falta el export que exige su tipo, nombrado a partir del mismo registro del que se lee el propio tipo:
<kind> plugin "<plugin>" declares no "<export>" export: wasm: plugin rejected by the sandbox (el plugin indicado, del tipo indicado, no declara el export indicado: wasm: plugin rechazado por el sandbox)
un campo restringido a un conjunto fijo que lleva otra cosa — la misma forma cubre el modo de ensamblado y los campos operates y scope de cada export:
plugin "<plugin>" export "<export>" declares unknown scope "<declared>" (want "own", "host", or empty): wasm: plugin rejected by the sandbox (el export indicado del plugin indicado declara un ámbito desconocido, el indicado (se espera uno de los valores indicados, o vacío): wasm: plugin rechazado por el sandbox)
una capacidad emparejada declarada sin sus dos exports, o los exports sin la reivindicación:
plugin "<plugin>" declares the cross-boundary linking capability but does not export both "link_publish" and "link_resolve": wasm: plugin rejected by the sandbox (el plugin indicado declara la capacidad de enlace entre límites pero no exporta los dos exports indicados: wasm: plugin rechazado por el sandbox)
un nombre de capacidad que ninguna Recipe podría seleccionar nunca — un proveedor que sirve un nombre que contiene dos puntos, o un paso de pipeline compatible con uno así — porque el capability: de una Recipe se lee como el nombre hasta sus últimos dos puntos, seguido de una fijación de versión. El parse:<format> de un parser y el import:<format> de un importador no se rechazan: los dos puntos forman parte de esos nombres, y se buscan por formato y no a través de una Recipe. El mismo rechazo impide que la entidad de un plugin así se genere para su publicación:
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 (el plugin indicado (con el plugin_type indicado) sirve la capacidad indicada, que contiene dos puntos; la referencia de capacidad de una Recipe se lee como la capacidad hasta sus últimos dos puntos, seguida de una fijación de versión, así que ninguna Recipe puede nombrar esa capacidad: informa el nombre de la capacidad sin dos puntos: wasm: plugin rechazado por el sandbox)
y las llamadas al anfitrión que un plugin reivindica frente a las que su binario usa realmente, lo que se comprueba en ambas direcciones para que un plugin no pueda anunciar una superficie que no usa ni ocultar una que sí usa:
plugin "<plugin>" declares host function "<name>" in describe() that its wasm does not import: wasm: plugin rejected by the sandbox (el plugin indicado declara en describe() la función del anfitrión indicada, que su wasm no importa: wasm: plugin rechazado por el sandbox) plugin "<plugin>" imports host function "<name>" that its describe() does not declare: wasm: plugin rejected by the sandbox (el plugin indicado importa la función del anfitrión indicada, que su describe() no declara: wasm: plugin rechazado por el sandbox)
Cómo corregirlo: nada en tus archivos de entidades causa esto y ningún cambio de autoría lo elimina — el informe que se rechaza es el propio del plugin. Si consumes un plugin publicado, informa del mensaje a quien lo publique y, mientras tanto, selecciona una versión que el anfitrión acepte. Si el plugin es tuyo, el mensaje nombra el campo y los dos valores, así que la corrección es la que señala la frase: habla la versión de interfaz que habla el anfitrión, declara un tipo que conozca, mantén cada campo dentro del conjunto al que está restringido, declara el export que exige tu tipo y declara exactamente las llamadas al anfitrión que usa tu binario — ni más ni menos.
A plugin is not the kind of plugin the socket expects (Un plugin no es del tipo de plugin que espera el socket)
Cada punto de vinculación indica a qué tipo de plugin despacha, y cada plugin informa de su propio tipo. Esta condición es lo que informa un desacuerdo entre ambos: un plugin que sirve a un proveedor vinculado donde se espera un linter, un parser vinculado donde se espera un importador, un plugin que no es un comando de terminal ejecutado como tal. La comprobación se produce al cargarse el plugin, así que un plugin del tipo equivocado nunca llega al trabajo que se le habría pedido hacer.
El motivo por el que se detiene en lugar de intentarlo de todos modos es que los tipos no comparten una interfaz. Un plugin de otro tipo se llamaría a través de exports que no tiene, y lo que volviera se leería frente a una estructura que nunca produjo.
La lectura de la autodeclaración de un plugin sin afirmar un tipo no se ve afectada. Una superficie que solo quiere saber qué dice un plugin de sí mismo — listar lo que está configurado, generar una entidad para un plugin — no expresa ninguna expectativa, y allí esta comprobación se omite.
Mensaje emitido, que nombra el plugin y los dos tipos, con el tipo esperado dado en palabras además de en su valor declarado:
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: el plugin indicado: se esperaba un plugin del tipo indicado en palabras (con el tipo de plugin esperado indicado), pero su describe() informa del tipo de plugin indicado: wasm: el tipo de plugin declarado no coincide con el describe() del plugin)
Cómo corregirlo: vincula un plugin del tipo que admite el punto de vinculación — el mensaje nombra el tipo esperado. Si el plugin es el que querías, la vinculación está en el lugar equivocado: muévela a la superficie a la que pertenece su tipo. Si escribes tú el plugin y debería ser del tipo esperado, está informando del tipo equivocado sobre sí mismo, y eso es una corrección en el plugin y no en la configuración que lo vincula.
A plugin failed while it was running (Un plugin falló durante su ejecución)
Un plugin al que se le pidió hacer algo no volvió con un resultado. Tres condiciones cubren esto, y lo único que las separa es cómo se propagó el fallo — un plugin que se bloqueó, un plugin que detuvo su propia ejecución y un plugin que se ejecutó hasta el final e informó de que no podía hacer lo que se le pidió. Forman deliberadamente una sola taxonomía, para que una compilación trate igual todas las formas en que un plugin puede fallar.
Un plugin que se bloqueó. La mayoría de los fallos dentro de un plugin — una instrucción inalcanzable, una división por cero, una lectura fuera de su memoria — se convierten en fallos ordinarios a la salida y nunca llegan a esta condición. Esta es la red de seguridad detrás de ese camino, para un bloqueo que se le escape.
Un plugin que detuvo su propia ejecución. Un plugin que pide salir está haciendo algo para lo que el modelo de plugins no tiene uso: un plugin devuelve su resultado a través de la llamada con la que se le invocó, no saliendo. Su propia ejecución se detiene; el proceso de compilación no se ve afectado.
Un plugin que informó de un fallo. El sobre de resultado que devuelve un plugin tiene un lugar donde puede decir que no pudo completarse, y un mensaje que lo dice se transmite como un fallo en lugar de leerse como un resultado.
Mensajes emitidos, cada uno de los cuales nombra el plugin o el export y lleva lo que haya aportado el fallo. Un bloqueo lleva el valor recuperado:
wasm: guest plugin "<plugin>" panicked in <export>: <the recovered value>: wasm: guest plugin panicked during call (wasm: el plugin invitado indicado entró en pánico en el export indicado: con el valor recuperado indicado: wasm: el plugin invitado entró en pánico durante la llamada)
un plugin que se detuvo por sí mismo lleva el código con el que se detuvo:
wasm: plugin "<plugin>" call to <export> invoked proc_exit(<code>): wasm: plugin invoked proc_exit (wasm: la llamada del plugin indicado al export indicado invocó proc_exit con el código indicado: wasm: el plugin invocó proc_exit)
y un fallo informado lleva el mensaje propio del plugin:
call "<export>": wasm: guest plugin reported an error: <the plugin's message> (llamada al export indicado: wasm: el plugin invitado informó de un error: con el mensaje del plugin indicado)
Cómo corregirlo: nada en tus archivos de entidades causa ninguno de los tres, y ningún cambio de autoría los elimina — cada uno es un fallo dentro del plugin. Informa del mensaje a quien lo publique, nombrando el export que identifica, y fija el plugin a una versión que funcionaba mientras se corrige. Si el plugin es tuyo: devuelve un fallo en el sobre de resultado en lugar de bloquearse o salir, para que la compilación reciba un mensaje que pueda mostrar; y donde el fallo informado sea la respuesta meditada del propio plugin, su mensaje es lo que verá un lector, así que vale la pena decir qué de la entrada no pudo aceptar.
A plugin returned something that is not the shape the socket reads (Un plugin devolvió algo que no tiene la estructura que lee el socket)
Cada punto de vinculación lee el resultado que recibe frente a la estructura que espera, y rechaza cualquier otra cosa — un campo que la estructura no declara, un campo cuyo valor no es del tipo declarado para él, o bytes que no son en absoluto un resultado bien formado.
Rechaza en lugar de leer lo que pueda, y el motivo es que leer lo que pueda sería silencioso. Qué export llama una vinculación puede elegirse por vinculación, así que una vinculación puede nombrar un export cuyo resultado tiene una estructura completamente distinta. Omitir las partes que no encajan da un resultado vacío — y un resultado vacío es en sí mismo una respuesta legítima: ningún veredicto devuelto, ningún hallazgo planteado. Entonces los dos serían indistinguibles, y una compilación continuaría exactamente como si el plugin la hubiera aprobado.
Mensaje emitido, que nombra el export del que volvió el resultado y lleva el motivo por el que falló la lectura — juntos identifican el export que la vinculación debería haber nombrado:
call "<export>": wasm: guest plugin returned an output that is not the shape the socket reads: <what could not be read> (llamada al export indicado: wasm: el plugin invitado devolvió una salida que no tiene la estructura que lee el socket: con lo que no se pudo leer indicado)
Cómo corregirlo: comprueba la función de entrada que nombra la vinculación frente a los exports que declara el plugin — una vinculación que apunta al export equivocado es la causa habitual, y el motivo del mensaje nombra el campo que sobra. Si el export es el correcto, el plugin está devolviendo una estructura que el punto de vinculación no lee, lo que es una corrección en el plugin; infórmalo a quien lo publique, citando tanto el export como el motivo.
A plugin returned a diagnostic at a severity that is not declared (Un plugin devolvió un diagnóstico con una gravedad que no está declarada)
Un plugin puede devolver observaciones junto con su resultado, y cada una lleva una gravedad de un conjunto cerrado: una que detiene la compilación y nombra qué corregir, una que se muestra junto a una compilación que aun así se completa, y una que registra la observación y no cambia nada. Una gravedad fuera de ese conjunto es una para la que el anfitrión no tiene ningún encaminamiento, y la compilación se detiene.
Rechaza en lugar de elegir un encaminamiento, y las dos alternativas son peores. Pasar por alto una observación que no puede encaminar la trataría como si no hubiera nada que hacer — lo que, donde el plugin está decidiendo si acepta la compilación, se lee como una aprobación: una objeción que planteó el plugin dejaría pasar la compilación sin mostrarse nunca. Tratarla como la gravedad que detiene la compilación rechazaría una compilación por un valor que nadie eligió. Ambas son silenciosas, así que el anfitrión dice que el valor es erróneo y, en su lugar, se corrige el plugin.
La comprobación se ejecuta una sola vez, donde se lee el resultado, y no en cada lugar donde más tarde se muestra una observación — que es también el único punto en el que la identidad del plugin sigue a mano, ya que una observación integrada en un informe ya no sabe qué plugin la planteó.
Mensaje emitido, que nombra el plugin, el export, qué observación era la errónea, su valor y los valores declarados:
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" (llamada al export indicado del plugin indicado: wasm: el plugin invitado devolvió un diagnóstico cuya gravedad el contrato no declara: el diagnóstico con el índice indicado tiene la gravedad indicada; las gravedades declaradas son las tres indicadas)
Cómo corregirlo: nada en tus archivos de entidades causa esto — el valor provino del plugin. Infórmalo a quien publique el plugin, citando el valor que nombra el mensaje. Si el plugin es tuyo, emite una de las tres gravedades declaradas; el mensaje las nombra, y el índice te dice qué observación revisar.
A provider returned two output files under one path (Un proveedor devolvió dos archivos de salida bajo una misma ruta)
Un proveedor devuelve su salida como una lista de archivos, cada uno de los cuales nombra la ruta en la que se escribe. El anfitrión los recoge indexados por ruta y escribe los bytes de cada archivo tal cual, sin ejecutar ningún serializador propio. Dos archivos que nombran la misma ruta dejan esa colección con dos valores para una sola clave.
Rechaza en lugar de elegir uno, porque ninguna de las dos elecciones puede distinguirse de la otra después. Quedarse con el último descarta un archivo que el proveedor indicó escribir; quedarse con el primero descarta uno posterior. En cualquier caso, la salida en disco está bien formada y le falta un archivo, sin que nada registre que se descartó un archivo — y la ruta que sobrevivió es la ruta que habría sobrevivido de todos modos, así que nada en el resultado dice que se produjo una colisión. Cuál de los dos se pretendía es una pregunta que solo el proveedor puede responder.
Se produce dondequiera que un proveedor devuelve archivos: al renderizar un nodo y al ensamblar la salida de un grupo de despacho en un único artefacto. La condición y la corrección son las mismas en ambos casos, así que ambos la informan.
Mensaje emitido, que nombra la ruta devuelta dos veces y el nodo o la ruta de despacho para la que se devolvió:
provider guest returned two output files under one path; a conforming guest returns each output path at most once (path "<path>", node "<node>") (el invitado proveedor devolvió dos archivos de salida bajo una misma ruta; un invitado conforme devuelve cada ruta de salida como máximo una vez (con la ruta y el nodo indicados))
Cómo corregirlo: nada en tus archivos de entidades causa esto — las rutas provinieron del proveedor. Infórmalo a quien lo publique, citando la ruta que nombra el mensaje. Si el proveedor es tuyo, devuelve cada ruta de salida como máximo una vez: construye la lista de rutas frente a un conjunto, para que un segundo archivo en una misma ruta se detecte donde se produce, y da al segundo archivo una ruta distinta si se quieren ambos.
A provider reported a render fact whose value is not a list (Un proveedor informó de un hecho de renderizado cuyo valor no es una lista)
Un proveedor puede informar, junto a sus archivos, de hechos sobre la salida que renderizó — un nombre y un valor cada uno, en el vocabulario documentado propio de ese proveedor — y las Features vinculadas a un componente los leen desde sus plantillas. El valor de cada hecho es una lista, incluso cuando contiene una sola entrada: un mismo nombre puede ser informado por más de un renderizado de un componente, las llamadas a su propio proveedor y los renderizados de las Features vinculadas a él, y las listas se unen en una sola bajo ese nombre para las plantillas que lo leen. Un proveedor no puede saber al renderizar si su informe será el único bajo un nombre, así que un valor que sea un objeto, una cadena, un número, un booleano o null se rechaza donde el proveedor lo entrega, en cada renderizado, lo lea o no alguna plantilla.
Mensaje emitido, que nombra el hecho, el nodo para el que se informó, el proveedor que lo informó y de qué clase era el valor:
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>) (el invitado proveedor informó de un hecho de renderizado cuyo valor no es una lista; un invitado conforme informa del valor de cada hecho de renderizado como un array JSON, incluso con una sola entrada (con el hecho, el nodo y el proveedor indicados; su valor es de la clase indicada))
Cómo corregirlo: nada en tus archivos de entidades causa esto — el valor provino del proveedor. Infórmalo a quien lo publique, citando el hecho que nombra el mensaje. Si el proveedor es tuyo, informa del valor de ese hecho como un array JSON — un único objeto se convierte en una lista que contiene ese objeto — y documéntalo como lista en los hechos que informa tu proveedor; consulta Informar de hechos sobre lo que emitió un invitado.
A provider’s link wiring names an output file that was never emitted (El cableado de enlace de un proveedor nombra un archivo de salida que nunca se emitió)
Cuando una conexión cruza entre dos grupos de despacho, se pide al proveedor de cada lado que la cablee: el extremo consumido publica una identidad, el extremo consumidor se resuelve frente a ella, y cada uno puede devolver un cableado estructural que aplicar a la salida de su propio grupo. Cada pieza de cableado nombra el archivo de salida al que se aplica. Una pasada posterior trocea ese archivo, aplica las operaciones y lo reensambla con fidelidad byte a byte.
Un nombre que no coincide con ningún archivo emitido no deja a esa pasada nada que trocear, y la pasada rechaza en lugar de pasar por alto el cableado. Las operaciones que lleva son lo que resuelve la conexión, así que descartarlas deja una salida ensamblada que hace referencia a un extremo que nada cableó — lo que falla en el momento del despliegue, lejos del proveedor que lo causó, y parece un error en la conexión y no en el cableado.
Los archivos que una pieza de cableado puede nombrar son los archivos que devolvió el renderizado propio de ese grupo. Se entregan al proveedor en la misma llamada, así que el proveedor nunca tiene que adivinar un nombre: elige uno del conjunto que recibió.
Mensaje emitido, que nombra el archivo que pidió el cableado y el extremo para el que se devolvió:
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>") (el parche de enlace nombra un archivo de salida que el grupo de despacho no emitió; un parche de enlace conforme nombra un archivo que devolvió el renderizado propio del grupo (con el archivo y el nodo indicados))
Cómo corregirlo: nada en tus archivos de entidades causa esto — el nombre provino del proveedor. Infórmalo a quien lo publique, citando el archivo que nombra el mensaje. Si el proveedor es tuyo, toma el nombre del archivo de los archivos ensamblados que te entrega la llamada y no de un nombre construido de forma independiente — una ruta compuesta a mano queda obsoleta en el momento en que cambia el renderizado que la produce, y este es el aspecto que tiene.
A pipeline step’s file emission carries no file (La emisión de archivo de un paso de pipeline no lleva ningún archivo)
Un paso de pipeline puede emitir un documento nuevo junto a los que parchea. Cada emisión declara su tipo, y una emisión del tipo archivo lleva el archivo que escribe: la ruta y el contenido.
Aquí el tipo es correcto y el archivo está ausente, así que el paso declaró una intención que su respuesta no lleva a cabo. Esa es la diferencia entre esta detención y la de un tipo no definido más abajo: el anfitrión sabe exactamente qué hacer con una emisión emit_file y no tiene nada con lo que hacerlo.
Rechaza en lugar de no emitir nada, porque una emisión que en silencio no aportara ningún archivo sería invisible. Un paso que emite un documento es a menudo toda la razón de que esté en el pipeline, y su salida es un archivo que antes no existía — así que una compilación que lo omitiera produciría una salida a la que le falta un documento, mientras el paso informa de que se ejecutó.
Mensaje emitido, que nombra el nodo y cuál de las emisiones del paso era la errónea:
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>) (el efecto secundario emit_file no lleva ningún archivo; un efecto secundario emit_file conforme lleva un archivo con su ruta y su contenido (con el nodo y el índice del efecto secundario indicados))
Cómo corregirlo: nada en tus archivos de entidades causa esto — la respuesta provino del plugin. Infórmalo a quien lo publique, citando el índice que nombra el mensaje. Si el plugin es tuyo, rellena el miembro de archivo en cada emisión emit_file, con su ruta y su contenido; el índice dice qué emisión de la respuesta de ese paso revisar.
A pipeline step declares an emission kind the contract does not define (Un paso de pipeline declara un tipo de emisión que el contrato no define)
Cada emisión que devuelve un paso de pipeline declara su tipo, y el contrato define dos: uno escribe un archivo, otro aporta un documento de recurso personalizado. El tipo es una cadena abierta en el formato de transmisión, que es lo que permite añadir un tipo posterior sin romper los plugins existentes.
Esa apertura es exactamente la razón por la que un tipo no definido se rechaza en lugar de pasarse por alto. Un valor que el anfitrión no define no puede distinguirse, solo por su estructura, de uno que definirá una versión posterior — así que un anfitrión que lo omitiera descartaría en silencio lo que el paso quiso decir con él, en cada compilación, mientras el paso informa de éxito. Rechazar mantiene abierto el punto de extensión sin convertirlo en un agujero: un tipo que esta compilación no define se informa como no definido, citando el valor que envió el paso, en lugar de aceptarse e ignorarse.
Mensaje emitido, que nombra el nodo, qué emisión era la errónea y el tipo que declaró:
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>") (el efecto secundario declara un tipo que el contrato de plugins no define; un efecto secundario conforme declara emit_file o emit_crd (con el nodo, el índice del efecto secundario y el tipo indicados))
Cómo corregirlo: nada en tus archivos de entidades causa esto — el valor provino del plugin. Infórmalo a quien lo publique, citando el tipo que nombra el mensaje. Si el plugin es tuyo, declara uno de los tipos que enumera el mensaje; una errata en un tipo definido es la causa habitual, y el valor que se devuelve citado es lo que enviaste.
A provider’s reassembly is handed a unit its own carve never produced (El reensamblado de un proveedor recibe una unidad que su propio troceado nunca produjo)
Un proveedor cuya forma de salida no puede direccionarse directamente puede trocearla por sí mismo: divide un archivo de salida en unidades direccionables, cada una bajo un token, y las devuelve. Un paso de pipeline direcciona entonces una unidad mediante ese token, y el reensamblado vuelve a insertar las unidades editadas en el archivo con fidelidad byte a byte. Las dos mitades son un único contrato — los tokens bajo los que se trocea un archivo son los tokens que resuelve su reensamblado.
Cuando el reensamblado recibe un token que el troceado de ese mismo archivo no produjo, no hay ningún rango de bytes al que pueda volver el contenido editado. Rechaza en lugar de descartar la unidad, porque una unidad descartada da un archivo bien formado al que le falta una edición que se pidió hacer a un paso: nada falló, nada está mal formado, y la edición simplemente no está.
Las dos mitades solo pueden discrepar donde están separadas — un códec que trocea por sí mismo y toma prestado el reensamblado estructural estándar para el resto. Trocear bajo un conjunto de tokens y reensamblar frente a otro produce entonces exactamente esto. Un códec que posee ambas mitades no puede llegar a ello: su propio reensamblado responde de sus propios tokens.
Mensaje emitido, que nombra el token que no se resolvió en nada y el archivo frente al que se nombró:
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>") (el reensamblado nombra un token de unidad parcheada que el troceado no produjo; un códec conforme trocea y reensambla un archivo bajo los mismos tokens (con el token y el archivo indicados))
Cómo corregirlo: nada en tus archivos de entidades causa esto. Si el proveedor es tuyo, haz que los tokens que produce una mitad sean los tokens que resuelve la otra: derívalos una sola vez y transmítelos, en lugar de derivarlos de forma independiente en cada lado, y donde el troceado reescriba un archivo antes de dividirlo, reensambla frente a la misma forma reescrita. Si el proveedor no es tuyo, infórmalo a quien lo publique, citando el token que nombra el mensaje.
A workload declares a form compose cannot express (Una carga de trabajo declara una forma que compose no puede expresar)
El proveedor compose renderiza servicios de larga duración. Una carga de trabajo que declara que ejecuta una copia por máquina, que se ejecuta según una programación o que se ejecuta una vez y termina no tiene un equivalente limpio en una sola máquina, así que el renderizado se detiene en lugar de emitir un servicio simple — que la iniciaría, la mantendría en ejecución y tergiversaría lo que se pidió.
Mensaje emitido. La condición nombra la clase de fallo — un proveedor sin expresión para algo que la compilación declara — y la frase propia del proveedor nombra la forma que recibió:
a plugin has no expression for a construct this build declares (un plugin no tiene expresión para una construcción que declara esta compilación) compose: workload form "<form>" has no compose mapping; compose supports stateless and stateful only: compose cannot express this workload form (compose: la forma de carga de trabajo indicada no tiene correspondencia en compose; compose solo admite stateless y stateful: compose no puede expresar esta forma de carga de trabajo)
Cómo corregirlo: donde el destino sea realmente un entorno compose de una sola máquina, expresa el trabajo como un servicio de larga duración — las formas stateless y stateful son las dos que renderiza. Donde la forma sea lo que querías, renderiza ese límite mediante un proveedor cuyo destino tenga un equivalente: una copia por máquina, una ejecución programada y un job que se ejecuta hasta completarse tienen todos expresiones directas en otros lugares, y la elección del proveedor corresponde al límite y no a la carga de trabajo.
A container declares a field compose has no primitive for (Un contenedor declara un campo para el que compose no tiene primitiva)
Dos campos de contenedor no tienen equivalente en compose, y ambos detienen el renderizado en lugar de descartarse.
Hooks que se ejecutan cuando un contenedor se inicia o está a punto de detenerse. compose no tiene nada que los ejecute, y un hook que en silencio no se ejecuta es una sorpresa de corrección que aflora en tiempo de ejecución y no en tiempo de compilación.
Entorno en bloque tomado de un objeto con nombre. compose puede leer variables de un archivo, pero una referencia a un objeto no es un archivo — reinterpretar uno como el otro cambiaría lo que recibe el contenedor sin decirlo.
Ambos se comprueban para los contenedores ordinarios y para los contenedores que se ejecutan antes del principal, así que el mismo campo provoca una detención dondequiera que se declare y el mensaje nombra de qué contenedor procede.
Mensajes emitidos. Ambos informan de la misma condición — un proveedor sin expresión para algo que la compilación declara — y la frase propia del proveedor es lo que dice qué campo:
a plugin has no expression for a construct this build declares (un plugin no tiene expresión para una construcción que declara esta compilación) 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: en el nodo y el contenedor indicados: compose: el nodo indicado declara hooks de ciclo de vida del contenedor; compose no tiene ninguna primitiva de hook de ciclo de vida: compose no tiene ninguna primitiva de hook de ciclo de vida; el contenedor declara hooks de ciclo de vida)
a plugin has no expression for a construct this build declares (un plugin no tiene expresión para una construcción que declara esta compilación) 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: en el nodo y el contenedor indicados: compose: el nodo indicado declara envFrom para el contenedor; compose no tiene ninguna primitiva de entorno desde un objeto: compose no tiene ninguna primitiva de entorno desde un objeto; el contenedor declara envFrom)
Cómo corregirlo: para un destino compose, elimina el campo y haz su trabajo de otra manera — el trabajo de arranque corresponde a un contenedor que se ejecuta antes del principal, y el trabajo de apagado al propio manejo de señales del contenedor; el entorno en bloque puede escribirse como variables explícitas, o suministrarse desde un archivo que el destino compose pueda leer. Donde el campo sea lo que querías, renderiza ese límite mediante un proveedor cuyo destino tenga la primitiva.
An omits entry names a kind or a namespace a compose file does not have (Una entrada omits nombra un kind o un namespace que un archivo compose no tiene)
Una entrada omits: en una Recipe o una FeatureRecipe que toma como fuente un archivo compose deja fuera una unidad de nivel superior de ese archivo, y un archivo compose tiene exactamente tres kinds que una entrada puede nombrar — un service, un volume y un config, cada uno identificado por su clave bajo services:, volumes: o configs: — y ningún namespace. Una entrada que nombra cualquier otro kind, entre ellos el Secret de un documento de chart o un network de compose, o que lleva un namespace, no nombra nada que el archivo pueda dejar fuera, así que el renderizado se detiene en lugar de tratar la entrada como una que no coincidió con nada. Los kinds se comparan exactamente, así que Service se rechaza donde se quiere decir service. Cada entrada se comprueba antes de dejar fuera nada, y se nombra la primera errónea, en el orden en que se escribieron las entradas.
Mensajes emitidos. Ambos informan de la condición de una construcción para la que un proveedor no tiene expresión, y la frase propia del proveedor nombra la entrada y los kinds que acepta. Un campo cuya plantilla leyó un valor declarado sensible se muestra como <redacted>:
a plugin has no expression for a construct this build declares (un plugin no tiene expresión para una construcción que declara esta compilación) compose: an omits entry (name "<name>") names kind "<kind>": compose leaves out a service, a volume or a config, each named by its key under services:, volumes: or configs:, and no other kind (compose: una entrada omits (con el nombre indicado) nombra el kind indicado: compose deja fuera un servicio, un volumen o una config, cada uno nombrado por su clave bajo services:, volumes: o configs:, y ningún otro kind)
a plugin has no expression for a construct this build declares (un plugin no tiene expresión para una construcción que declara esta compilación) compose: an omits entry (kind "<kind>", name "<name>") names namespace "<namespace>", and a compose file has no namespaces: compose leaves out a service, a volume or a config, each named by its key under services:, volumes: or configs:, and no other kind; remove the namespace from the entry (compose: una entrada omits (con el kind y el nombre indicados) nombra el namespace indicado, y un archivo compose no tiene namespaces: compose deja fuera un servicio, un volumen o una config, cada uno nombrado por su clave bajo services:, volumes: o configs:, y ningún otro kind; elimina el namespace de la entrada)
Cómo corregirlo: nombra la unidad como lo hace el archivo compose — kind: service, volume o config, y como name: su clave bajo esa sección — y quita el namespace:. Consulta compose → Modo con fuente.
An omits entry names a namespace a CloudFormation template does not have (Una entrada omits nombra un namespace que una plantilla CloudFormation no tiene)
Una entrada omits: en una Recipe o una FeatureRecipe que toma como fuente una plantilla CloudFormation deja fuera un recurso, nombrado por su Type como el kind de la entrada y por su ID lógico como el name de la entrada. Una plantilla no tiene namespaces, así que una entrada que lleva un namespace no nombra nada que una plantilla pueda dejar fuera, y el renderizado se detiene en lugar de tratar la entrada como una que no coincidió con nada. Cada entrada se comprueba antes de dejar fuera nada, y se nombra la primera que lleva un namespace, en el orden en que se escribieron las entradas.
Mensaje emitido. Informa de la condición de una construcción para la que un proveedor no tiene expresión, y la frase propia del proveedor nombra la entrada y lo que este proveedor deja fuera. Un campo cuya plantilla leyó un valor declarado sensible se muestra como <redacted>:
a plugin has no expression for a construct this build declares (un plugin no tiene expresión para una construcción que declara esta compilación) cloudformation-provider: an omits entry (kind "<kind>", name "<name>") names namespace "<namespace>", and a CloudFormation template has no namespaces: cloudformation leaves out a resource, named by its Type as the entry’s kind and its logical ID under Resources as the entry’s name; remove the namespace from the entry (cloudformation-provider: una entrada omits (con el kind y el nombre indicados) nombra el namespace indicado, y una plantilla CloudFormation no tiene namespaces: cloudformation deja fuera un recurso, nombrado por su Type como el kind de la entrada y por su ID lógico bajo Resources como el nombre de la entrada; elimina el namespace de la entrada)
A published port declares a transport compose cannot spell (Un puerto publicado declara un transporte que compose no puede escribir)
Un puerto publicado de compose lleva su transporte como sufijo en la entrada, y ese sufijo tiene dos grafías. Un puerto que declara cualquier otro transporte no tiene ninguna grafía en compose.
El renderizado se detiene en lugar de quitar el sufijo, porque un puerto publicado que recurre silenciosamente al transporte predeterminado se levanta transportando tráfico que sus clientes no pueden alcanzar — que es exactamente el fallo que declarar un transporte existe para evitar, reintroducido en el momento de la traducción.
Un puerto que no declara ningún transporte no se ve afectado. Se publica sin sufijo, exactamente como lo haría un puerto que nunca llevó un transporte.
Mensaje emitido. La condición nombra el tipo de fallo — un valor sin representación en lo que emite el proveedor — y la frase propia del proveedor la sigue:
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: en el nodo indicado, aplicación de los puertos del servicio: compose publica el transporte de un puerto como sufijo tcp o udp; este puerto declara un transporte que compose no puede expresar)
Cómo corregirlo: para un destino compose, declara el transporte del puerto como uno de los dos que compose puede escribir, o déjalo sin declarar y deja que la entrada se publique sin sufijo. Donde el transporte es lo que querías, renderiza ese límite mediante un proveedor cuyo destino pueda expresarlo.
A resources quantity cannot be converted to a compose value (Una cantidad de recursos no se puede convertir en un valor de compose)
Las cantidades de procesador y de memoria de un contenedor, y su recuento nvidia.com/gpu, se escriben en la notación que Kubernetes usa para los recursos, y compose las lleva en unidades propias — un recuento de GPU se convierte en el recuento de una reserva de dispositivos NVIDIA —, así que cada una se lee como una cantidad y se convierte a partir de su valor. Dos cosas lo impiden, y el mensaje dice cuál encontró: un valor que no es en absoluto una cantidad, y una cantidad para la que compose no tiene una forma exacta — una cantidad negativa, una cantidad de memoria que no es un número entero de bytes, una cantidad de procesador más fina que nueve decimales de un núcleo, un recuento de GPU que no es un número entero de dispositivos, o una cantidad por encima de la mayor que compose puede contener. Un contenedor cuya solicitud y cuyo límite nvidia.com/gpu piden recuentos distintos también detiene el renderizado, porque compose reserva un solo recuento para un servicio. El renderizado se detiene en lugar de redondear el valor o emitir una aproximación, porque un límite que silenciosamente no es el límite que se pidió es el tipo de diferencia que nadie busca hasta que algo se detiene por superarlo.
Mensajes emitidos. Cada uno comienza con la condición — un valor sin representación en lo que emite el proveedor —, luego nombra el recurso, si el valor es una solicitud o un límite, su ruta en el Workload y el valor. A un valor que no es una cantidad le sigue lo que impidió que lo fuera y la forma que adopta una cantidad:
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: en el nodo y el contenedor indicados: compose: la solicitud o el límite indicado del recurso indicado, en la ruta indicada: el valor indicado no es una cantidad: con el motivo indicado; una cantidad es un número como 2, 0.5 o 1.5, con un signo opcional y como máximo uno de un exponente entero (1e3, 5E-2) o un sufijo de unidad (n, u, m, k, M, G, T, P, E, Ki, Mi, Gi, Ti, Pi, Ei): la cantidad de resources no se puede convertir en un valor deploy.resources de compose)
A una cantidad que compose no puede representar le sigue el rango que compose admite para ese recurso:
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: en el nodo y el contenedor indicados: compose: la solicitud o el límite de memoria indicado, en la ruta indicada, es el valor indicado, una cantidad que compose no puede representar exactamente; un valor de memoria de compose es un número entero de bytes de 0 a 9223372036854775807: la cantidad de resources no se puede convertir en un valor deploy.resources de compose)
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: en el nodo y el contenedor indicados: compose: la solicitud o el límite de cpu indicado, en la ruta indicada, es el valor indicado, una cantidad que compose no puede representar exactamente; un valor cpus de compose es un recuento de núcleos de 0 a 9223372036.854775807 con como máximo nueve decimales: la cantidad de resources no se puede convertir en un valor deploy.resources de compose)
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: en el nodo y el contenedor indicados: compose: la solicitud o el límite nvidia.com/gpu indicado, en la ruta indicada, es el valor indicado, una cantidad que compose no puede representar exactamente; un recuento de dispositivos de compose es un número entero de dispositivos de 0 a 9223372036854775807: la cantidad de resources no se puede convertir en un valor deploy.resources de compose)
Una solicitud y un límite de GPU que piden recuentos distintos nombran ambas rutas y ambos recuentos:
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: en el nodo y el contenedor indicados: compose: la solicitud nvidia.com/gpu en la ruta indicada y el límite en la ruta indicada piden recuentos distintos (los indicados); compose reserva un solo recuento de dispositivos para un servicio, así que escribe el mismo recuento en ambos o solo el límite: la cantidad de resources no se puede convertir en un valor deploy.resources de compose)
Donde la plantilla del Workload lee un valor que un autor declaró sensible, ningún mensaje cita el valor que rechazó, y los dos recuentos se omiten del mismo modo.
Cómo corregirlo: donde el valor no es una cantidad, escríbelo en la forma descrita en Workload → Cantidades de recursos; un sufijo suelto como m es lo que deja una plantilla cuando el valor que interpola está vacío, así que la entrada que hay que corregir es la que leyó la plantilla. Donde es una cantidad que compose no puede representar, escribe una cantidad dentro del rango que indica el mensaje — la memoria como un número entero de bytes en cualquier unidad (1536Mi en lugar de 1.5001Gi), el tiempo de procesador con como máximo nueve decimales de un núcleo, y un recuento de GPU como un número entero de dispositivos (1, no 0.5 ni 500m). Donde una solicitud y un límite de GPU no coinciden, escribe el mismo recuento en ambos, o escribe solo el límite, que es el recuento que Kubernetes planifica para el mismo Workload.
A resource quantity the helm provider emits is not a quantity (Una cantidad de recurso que emite el proveedor helm no es una cantidad)
El proveedor helm copia tal cual cada cantidad de recurso en los manifiestos que emite — los valores resources.requests y resources.limits de cada contenedor y contenedor de inicialización, recursos extendidos incluidos, y los ephemeral.sizeLimit, persistent.size y persistentTemplate.size de cada volumen — y primero comprueba cada una frente a la forma de una cantidad, sobre el Workload tal como lo evaluaron las plantillas de la Recipe. Un valor fuera de esa forma detiene la compilación aquí, donde de otro modo compilaría sin errores y el clúster lo rechazaría al instalar el chart.
Mensaje emitido. Comienza con la condición, luego nombra el nodo, la ruta del campo en el Workload, el valor y lo que impidió que fuera una cantidad, e indica la forma que adopta una cantidad:
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: en el nodo indicado: ruta indicada: el valor indicado no es una cantidad: con el motivo indicado; una cantidad es un número como 2, 0.5 o 1.5, con un signo opcional y como máximo uno de un exponente entero (1e3, 5E-2) o un sufijo de unidad (n, u, m, k, M, G, T, P, E, Ki, Mi, Gi, Ti, Pi, Ei))
Cómo corregirlo: escribe el valor en la forma descrita en Workload → Cantidades de recursos. Donde el campo es una plantilla, el valor que hay que corregir es el que leyó la plantilla: un sufijo suelto como m o Mi es lo que deja una plantilla cuando el valor que interpola está vacío, y un parámetro de la Release llega al campo exactamente como se escribió.
A service type the helm provider cannot render (Un tipo de servicio que el proveedor helm no puede renderizar)
El proveedor helm renderiza cada entrada services de un Workload como un Service de Kubernetes cuyo tipo es el type de la entrada. Una entrada Loopback pide que sus puertos sean alcanzables desde la propia dirección de loopback del host y desde ningún otro lugar, y un Service de Kubernetes no tiene ningún tipo que haga eso: en qué direcciones de nodo escucha un Service NodePort es un ajuste de todo el clúster, no de un solo Service. Así que la compilación se detiene en la primera entrada Loopback, en el orden en que se declaran los servicios, antes de que se escriba ningún recurso.
La compilación se detiene en lugar de renderizar la entrada como otro tipo, porque cada uno de los tipos que sí tiene un Service cambia lo que alcanza el puerto: un Service ClusterIP pierde el alcance publicado que pide la entrada, y uno NodePort publica el puerto en cada dirección de nodo que permite el clúster — la exposición más amplia que la entrada existe para evitar.
Mensaje emitido. Comienza con la condición, luego nombra el nodo, la ruta del servicio en el Workload y el tipo:
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: en el nodo indicado: servicio indicado bajo services: el tipo «Loopback» publica los puertos del servicio solo en la dirección de loopback del host, y un Service de Kubernetes no tiene ningún tipo que lo haga; declara ClusterIP para mantener los puertos dentro del clúster, o NodePort o LoadBalancer para publicarlos fuera de él)
Cómo corregirlo: para un destino helm, declara el tipo que indica hasta dónde debe llegar el puerto en el clúster — ClusterIP para mantenerlo dentro, NodePort o LoadBalancer para publicarlo. Una entrada Loopback es para un destino compose, que publica el puerto en 127.0.0.1; consulta Workload → services.
A Kubernetes version the helm provider cannot render a chart for (Una versión de Kubernetes para la que el proveedor helm no puede renderizar un chart)
El proveedor helm renderiza un chart desde la fuente para la versión de Kubernetes que la anotación aggrega.ai/kubernetes-version nombra en un componente o en su límite, y lee el valor del modo en que helm template --kube-version lee su opción. Un valor que esa opción rechazaría — "one.two", "latest", un solo número como "1", un número escrito con un cero inicial como "01.20" — no tiene ninguna versión que el chart pueda leer como .Capabilities.KubeVersion, así que la compilación se detiene antes de que se renderice el chart.
La compilación se detiene en lugar de renderizar el chart para la versión predeterminada, porque un chart lee la versión para elegir una versión de API, un campo o un mecanismo entero, y un chart renderizado para una versión distinta de la que nombraste emite la forma de esa otra versión — una que el clúster en el que se despliega puede no ejecutar.
Un valor vacío no se rechaza. Se trata como no definido, y el chart se renderiza para la versión predeterminada: aquella para la que renderiza el helm template estándar de la misma versión de helm.
Mensaje emitido. Comienza con la condición, luego nombra el nodo y el límite en el que está situado, la anotación, el valor y lo que impidió que fuera una versión, e indica la forma que hay que escribir:
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: en el nodo indicado, en el límite indicado: anotación aggrega.ai/kubernetes-version: el valor indicado no es una versión de Kubernetes para la que se pueda renderizar un chart: con el motivo indicado; escribe la versión del clúster en el que se despliega el chart, como «1.31» o «v1.31.2», en el componente o en su límite)
El mensaje nombra tanto el nodo como su límite porque el proveedor lee juntas las anotaciones de un componente y las de su límite, y prevalece el valor propio del componente, así que el valor puede haberse escrito en cualquiera de los dos.
Cómo corregirlo: escribe la versión del clúster en el que se despliega el chart — una versión mayor y menor como "1.31", o una completa como "v1.31.2" — en el componente o en su límite, o elimina la anotación para renderizar para la versión predeterminada. Consulta helm → La versión de Kubernetes para la que se renderiza un chart.
A health probe cannot be turned into a compose healthcheck (Una sonda de estado no se puede convertir en un healthcheck de compose)
Una sonda de estado declarada se convierte en un healthcheck de compose, y dos cosas pueden impedirlo.
Una sonda que comprueba una ruta por HTTP, en un contenedor que no publica ningún puerto. La comprobación se construye como una solicitud a un puerto del contenedor, así que sin ningún puerto declarado no hay ninguna dirección contra la que construirla.
Una sonda que no declara ninguna forma de comprobar — ni una ruta, ni un puerto al que conectarse, ni un comando que ejecutar. No hay nada que convertir en una comprobación. Esta es una salvaguarda detrás del esquema más que una forma que probablemente escribas: se comprueba que una sonda tenga una de las tres antes de que llegue aquí.
Mensajes emitidos. Ambos informan de la misma condición — algo que el proveedor requiere y que no pudo resolver a exactamente un valor — y la frase propia del proveedor dice cuál:
a plugin could not resolve something it requires to exactly one value (un plugin no pudo resolver a exactamente un valor algo que requiere) compose: node "<node>" container "<container>": probe http: requires at least one container port; container declares none (compose: en el nodo y el contenedor indicados: sonda http: requiere al menos un puerto de contenedor; el contenedor no declara ninguno)
a plugin could not resolve something it requires to exactly one value (un plugin no pudo resolver a exactamente un valor algo que requiere) compose: node "<node>" container "<container>": probe declares no shape (http/tcp/exec) (compose: en el nodo y el contenedor indicados: la sonda no declara ninguna forma (http/tcp/exec))
Cómo corregirlo: declara el puerto contra el que debe hacerse la comprobación en el mismo contenedor que la sonda — una sonda por HTTP lee el primer puerto del contenedor, así que el puerto tiene que existir para que la comprobación pueda construirse. Donde el contenedor realmente no publica nada, compruébalo de otra forma: una sonda que ejecuta un comando no necesita ningún puerto. Para una sonda sin ninguna forma de comprobar declarada, dale una de las tres.
A configmap volume has no file behind it (Un volumen configmap no tiene ningún archivo detrás)
Un volumen que monta configuración se entrega mediante el mecanismo propio de compose para ello, referenciado por nombre, y la entrada que contiene el contenido procede de un archivo que emite la Recipe. Esta condición es lo que informa una referencia sin ninguna entrada coincidente: el archivo no está, así que el montaje existiría sin nada detrás y el contenedor se levantaría leyendo una ruta vacía.
La comprobación se ejecuta sobre toda la salida ensamblada en lugar de por componente, y es deliberado: la referencia y la entrada que contiene el contenido llegan por vías distintas y pueden proceder de componentes distintos del mismo grupo, así que la salida ensamblada es el primer punto en el que ambas están presentes. Una comprobación por componente rechazaría una referencia cuyo contenido suministra otro componente del mismo grupo.
Se informa de cada referencia sin resolver, no solo de la primera, en un orden estable, así que una sola compilación las nombra todas.
Mensaje emitido. La condición va primero, luego cada servicio, la referencia que hizo y dónde se monta:
a plugin could not resolve something it requires to exactly one value (un plugin no pudo resolver a exactamente un valor algo que requiere) 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: el servicio indicado referencia la config indicada, montada en la ruta indicada; declara cada una como una entrada configs: de nivel superior desde la entrada artifacts: de la Recipe: un volumen configmap requiere un archivo emitido mediante la entrada artifacts: de la Recipe; no se encontró ninguno)
Cómo corregirlo: emite el archivo desde la entrada artifacts: de la Recipe con el nombre que referencia el volumen — los dos se emparejan por ese nombre, así que una discrepancia entre lo que pide el volumen y lo que emite la Recipe es la causa habitual. Donde el contenido debía venir de otro lugar, el volumen es el mecanismo equivocado para ello: un valor que pertenece al entorno va allí en su lugar.
What an omits entry left out is still named by the compose file (Lo que una entrada omits dejó fuera sigue nombrado por el archivo compose)
Una entrada omits: deja fuera un servicio, un volumen o una config de un archivo compose de origen, y compose rechaza un archivo que nombra uno que no declara. Así que, una vez eliminadas las unidades de las entradas, cada referencia que el resto del archivo sigue haciendo a una de ellas detiene el renderizado: un servicio nombrado por depends_on, links, volumes_from, extends, un valor de build.additional_contexts o un modo de red, IPC, PID o UTS service:; un volumen nombrado como origen de una entrada volumes:; una config nombrada por una entrada configs: — leídos en cada servicio, en los hooks pre_start de cada servicio y en cada job. La lista completa, y los valores que solo parecen referencias, están en compose → Modo con fuente.
La comprobación lee el archivo propio de la Recipe o la FeatureRecipe que declara la entrada, así que detiene el renderizado incluso donde otro contribuidor al mismo archivo ensamblado declara una unidad con el nombre de la que se dejó fuera. Se informa de cada referencia, no solo de la primera — los servicios en orden de clave, luego los jobs, los hooks de cada servicio después de él —, así que una sola compilación las nombra todas.
Mensaje emitido. La condición va primero, luego cada entrada que hace referencia, la unidad que nombra y el campo en el que está la referencia:
a plugin could not resolve something it requires to exactly one value (un plugin no pudo resolver a exactamente un valor algo que requiere) 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: lo que una entrada omits dejó fuera sigue nombrado por el archivo: el servicio indicado nombra la unidad del kind y el nombre indicados en el campo indicado; compose rechaza un archivo que nombra un servicio, un volumen o una config que no declara: deja fuera también lo que lo nombra, cambia la referencia mediante valuesMapping, o elimina la entrada)
Una unidad cuyo nombre de entrada se construyó a partir de un valor declarado sensible se muestra como <redacted>.
Cómo corregirlo: decide cuál de las dos cosas querías. Donde el servicio que hace referencia todavía necesita la unidad, consérvala: elimina la entrada. Donde no, cambia la referencia mediante el valuesMapping: de la Recipe — una lista allí sustituye la lista del archivo base, así que depends_on: [] vacía una — o deja fuera el servicio que hace referencia con una entrada propia.
What an omits entry left out is still named by a CloudFormation template (Lo que una entrada omits dejó fuera sigue nombrado por una plantilla CloudFormation)
Una entrada omits: deja fuera un recurso de una plantilla CloudFormation de origen, y CloudFormation rechaza una plantilla que nombra un recurso que no declara. Así que, una vez eliminados los recursos de las entradas, cada referencia que las plantillas restantes siguen haciendo a uno de ellos detiene el renderizado: un Ref, un Fn::GetAtt en su forma de lista o en su forma de cadena con punto, el DependsOn de un recurso, o una variable de un Fn::Sub — leídos en cualquier parte del cuerpo de cada recurso y de cada salida. La lista completa, y los valores que solo parecen referencias, están en cloudformation → Dejar recursos fuera de una plantilla de origen.
La comprobación lee juntas las plantillas propias de la Recipe o la FeatureRecipe que declara la entrada: una referencia a un ID lógico que otra de esas plantillas sigue declarando no se detiene, mientras que una a un recurso dejado fuera detiene el renderizado incluso donde otro componente declara un recurso con ese ID lógico. Se informa de cada referencia, no solo de la primera — plantilla por plantilla en el orden en que la fuente las lleva, en cada plantilla sus recursos y luego sus salidas en orden de clave —, así que una sola compilación las nombra todas.
Mensaje emitido. La condición va primero, luego cada referencia: la plantilla en la que está, el recurso que nombra, cómo lo nombra y dónde se sitúa como ruta desde la raíz de la plantilla:
a plugin could not resolve something it requires to exactly one value (un plugin no pudo resolver a exactamente un valor algo que requiere) 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: lo que una entrada omits dejó fuera sigue nombrado por las plantillas de la fuente: la plantilla indicada nombra el recurso indicado (del tipo indicado) de la forma indicada en la ruta indicada; CloudFormation rechaza una plantilla que nombra un recurso que no declara: deja fuera también lo que lo nombra, o elimina la entrada)
Donde los campos de una entrada se construyeron a partir de un valor declarado sensible, el ID lógico y el tipo de su recurso se muestran como <redacted>, y también cualquier paso de la ruta que escriba ese ID lógico.
Cómo corregirlo: decide cuál de las dos cosas querías. Donde el recurso que hace referencia todavía necesita el que se dejó fuera, consérvalo: elimina la entrada. Donde no, deja fuera también el recurso que hace referencia, con una entrada propia — un valor asociado a un parámetro sustituye solo una referencia a ese parámetro, así que una referencia a un recurso no se puede cambiar de ese modo. Una salida que nombra el recurso no se puede dejar fuera, así que un recurso que nombra una salida se queda.
A valuesMapping key names no parameter of a sourced CloudFormation template (Una clave de valuesMapping no nombra ningún parámetro de una plantilla CloudFormation de origen)
Una plantilla CloudFormation de origen recibe valores a través de los Parameters que declara, y el valuesMapping de la Recipe o la FeatureRecipe que la toma como fuente escribe una clave por cada parámetro que rellena. Una clave que no nombra ningún parámetro que declare alguna plantilla de la fuente no tiene adónde ir, así que el renderizado se detiene en lugar de descartarla — el fallo que CloudFormation mismo informaría para un parámetro desconocido, informado mientras todavía te corresponde corregirlo. Solo un valuesMapping rellena parámetros: los valores que nada mapeó nunca se leen de este modo, así que los valores propios de un componente o de una vinculación escritos para sus otras entradas nunca se encuentran con esto.
Mensaje emitido. La condición va primero, luego cada clave que no nombró nada y lo que declara cada plantilla de la fuente:
a plugin could not resolve something it requires to exactly one value (un plugin no pudo resolver a exactamente un valor algo que requiere) 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: el valuesMapping de la Recipe o la FeatureRecipe escribe la clave indicada, y ninguna plantilla de la fuente declara un parámetro con ese nombre: la plantilla indicada declara el parámetro indicado, …; una plantilla de origen recibe valores solo a través de los parámetros que declara, así que renombra la clave al parámetro al que está destinada, o elimínala del valuesMapping)
Another component references a CloudFormation parameter a sourced template’s binding filled (Otro componente referencia un parámetro de CloudFormation que la asociación de una plantilla de origen rellenó)
Rellenar el parámetro de una plantilla de origen mediante el valuesMapping de la Recipe o de la FeatureRecipe de la Feature vinculada que la toma como fuente sustituye cada referencia a él en cada plantilla de esa fuente y elimina su declaración. El contenido de otras partes del mismo stack ensamblado — el fragmento o la plantilla de origen de otro componente, o el fragmento del componente al que está vinculada una Feature — que sigue nombrando el parámetro mediante Ref, una variable de Fn::Sub o el Fn::ValueOf de una regla nombra entonces algo que el stack ya no declara, lo que CloudFormation rechaza cuando se despliega el stack, así que el ensamblado se detiene. Un nombre que algún componente del stack sigue declarando, como parámetro propio o como ID lógico de un recurso, es una referencia que el stack resuelve y no se detiene.
Mensaje emitido. La condición va primero, luego cada referencia: el componente y la plantilla en los que está, el parámetro, y el componente cuyo valuesMapping de la Recipe o de la FeatureRecipe vinculada lo rellenó — una Feature vinculada a un componente se nombra por ese componente, y una vinculada a un límite por la identidad que sus recursos llevan como aggrega.ai/component-id, compuesta a partir de la ruta del límite y el nombre de la vinculación, como bfr--stack--aux:
a plugin could not resolve something it requires to exactly one value (un plugin no pudo resolver a exactamente un valor algo que requiere) 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 parámetro que la asociación de una plantilla de origen rellenó sigue referenciado desde otra parte del stack ensamblado: la plantilla indicada del componente indicado referencia el parámetro indicado, que asocia el valuesMapping de una Recipe o una FeatureRecipe que renderiza para el componente indicado; …; asociar un parámetro elimina su declaración de la fuente que lo declara, y ninguna plantilla del stack lo declara ya, así que la referencia no nombra nada que CloudFormation pueda resolver: referencia en su lugar lo que publica el componente que lo asocia, declara el parámetro en la plantilla que lo referencia, o elimina la clave del valuesMapping)
Cómo corregirlo: donde el componente que hace referencia necesita el valor, haz que el componente que lo rellena lo publique mediante provides y referencia eso; o declara el parámetro en la plantilla que hace referencia para que reciba su propio valor; o elimina la clave del valuesMapping, para que el parámetro siga declarado y cada componente lea el valor que se pasa cuando se despliega el stack. Consulta cloudformation → Valores para los parámetros de una plantilla de origen.
A value bound to a CloudFormation parameter cannot take the parameter’s type (Un valor asociado a un parámetro de CloudFormation no puede adoptar el tipo del parámetro)
Un literal asociado a un parámetro se convierte del modo en que CloudFormation convierte el mismo valor pasado para el Type de ese parámetro cuando se despliega el stack. Donde no existe tal conversión, el renderizado se detiene: un valor que no es un número asociado a un Number o a un List<Number>, una lista o un mapa asociado a un parámetro que admite un solo valor, y cualquier literal asociado a un parámetro AWS::SSM::Parameter::Value<…>, cuyo valor CloudFormation lee de Parameter Store en lugar de la plantilla. Una lista asociada a un parámetro que la plantilla nombra como variable de Fn::Sub también detiene el renderizado, porque una variable sustituye una sola cadena.
Mensaje emitido. La condición va primero, luego el parámetro, su plantilla y su tipo, y por qué el valor no encaja; no se cita ningún valor:
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) cloudformation-provider: parameter "<parameter>" of template "<template>" is of type <type>, and <why the value does not fit> (cloudformation-provider: el parámetro indicado de la plantilla indicada es del tipo indicado, y el valor no encaja por el motivo indicado)
Cómo corregirlo: asocia un valor del tipo del parámetro — o, para un tipo de Parameter Store, una referencia dinámica {{resolve:ssm:…}} o una función intrínseca — o deja el parámetro sin asociar para un valor que se pasa cuando se despliega el stack.
A value bound to a CloudFormation parameter is one its constraints refuse (Un valor asociado a un parámetro de CloudFormation es uno que sus restricciones rechazan)
Un literal asociado a un parámetro se comprueba frente a las restricciones que la plantilla declara para él — AllowedValues, AllowedPattern, MinLength, MaxLength, MinValue y MaxValue —, la comprobación que CloudFormation hace sobre un valor pasado cuando se despliega el stack, trasladada al momento de la compilación para que rellenar un parámetro no elimine ninguna comprobación que la plantilla declaró. Una función intrínseca y una referencia dinámica se dejan para que CloudFormation las compruebe, ya que su valor no existe hasta que se despliega el stack.
Mensaje emitido. La condición va primero, luego el parámetro, su plantilla y la restricción; no se cita ningún valor:
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: el valor asociado al parámetro indicado de la plantilla indicada no satisface su restricción indicada, que CloudFormation rechazaría cuando se despliega el stack; asocia un valor que el parámetro admita)
Cómo corregirlo: asocia un valor que la restricción admita; la propia declaración del parámetro en la plantilla enumera lo que permite.
A secret bound to a CloudFormation parameter would be written into the template (Un secreto asociado a un parámetro de CloudFormation se escribiría en la plantilla)
Un valor asociado a un parámetro se escribe en la plantilla, donde cualquiera que pueda leer la plantilla del stack puede leerlo. El renderizado se detiene ante un literal asociado a un parámetro que la plantilla declara NoEcho y, donde el valuesMapping de la Recipe o la FeatureRecipe lee un valor que un autor declaró sensible, ante cada literal que asocia ese mapeo, ya que ninguna parte de su salida puede rastrearse hasta el valor del que provino. Una referencia dinámica y una función intrínseca se escriben tal como se dan — incluido el texto dentro de una función intrínseca —, así que un valor sensible que el mapeo inserta en una cadena Fn::Sub llega a la plantilla como ese texto, y solo una referencia dinámica mantiene el propio secreto fuera de ella.
Mensaje emitido. La condición va primero, luego los parámetros y lo que asociar en su lugar; no se cita ningún valor. Uno de:
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: el parámetro indicado de la plantilla indicada está declarado NoEcho, y el valor asociado a él se escribiría en la plantilla tal cual; asocia en su lugar una referencia dinámica ({{resolve:secretsmanager:…}} o {{resolve:ssm-secure:…}}) o una función intrínseca, o deja el parámetro sin asociar para un valor en el momento del despliegue)
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: el valuesMapping de la Recipe o la FeatureRecipe lee un valor declarado sensible, así que un literal que produce se rechaza, y asociar el parámetro o los parámetros indicados, … escribiría un literal en la plantilla tal cual; …)
Cómo corregirlo: guarda el secreto en Secrets Manager o como cadena segura de Parameter Store y asocia una referencia dinámica que apunte a él — {{resolve:secretsmanager:<secret>}} o {{resolve:ssm-secure:<name>}} — en lugar de insertarlo en el texto de una función intrínseca, o deja el parámetro sin asociar para un valor pasado cuando se despliega el stack. Consulta cloudformation → Valores para los parámetros de una plantilla de origen.
A dynamic reference is bound where CloudFormation does not resolve it (Una referencia dinámica está asociada donde CloudFormation no la resuelve)
CloudFormation resuelve una referencia dinámica en las propiedades de un recurso, pero no en los datos de usuario de EC2 ni en los metadatos AWS::CloudFormation::Init, y muestra los Outputs de una plantilla a quien lea el stack. Así que una referencia dinámica asociada a un parámetro al que cualquier plantilla de la fuente hace referencia en una propiedad UserData, en esos metadatos o en sus Outputs detiene el renderizado en lugar de llegar a un lugar donde o bien no puede desplegarse o bien queda expuesta.
Mensaje emitido. La condición va primero, luego el parámetro, la plantilla y el lugar donde esa plantilla hace referencia a él; no se cita ningún valor:
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: el valor asociado al parámetro indicado es una referencia dinámica, y la plantilla indicada hace referencia al parámetro en el lugar indicado, donde CloudFormation no resuelve una referencia dinámica o la muestra a quien lea el stack; asocia en su lugar una función intrínseca, o deja el parámetro sin asociar para un valor en el momento del despliegue)
Cómo corregirlo: deja el parámetro sin asociar y pasa su valor cuando se despliega el stack, o asocia una función intrínseca que produzca lo que la plantilla necesita ahí.
A rule reads a bound CloudFormation parameter by name (Una regla lee por su nombre un parámetro de CloudFormation asociado)
Fn::ValueOf en las Rules de una plantilla nombra un parámetro por su ID lógico en lugar de mediante Ref, y lee el valor pasado para él cuando se despliega el stack. Asociar el parámetro elimina su declaración de todas las plantillas de la fuente, lo que dejaría a la regla — en cualquiera de esas plantillas — sin nombrar nada, así que el renderizado se detiene.
Mensaje emitido. La condición va primero, luego la regla, su plantilla y el parámetro:
a plugin has no expression for a construct this build declares (un plugin no tiene expresión para una construcción que declara esta compilación) 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 regla indicada de la plantilla indicada lee el parámetro indicado mediante Fn::ValueOf, que nombra un parámetro declarado por su ID lógico, y asociar el parámetro elimina su declaración de la fuente; deja el parámetro sin asociar para que la regla pueda leerlo en el momento del despliegue)
Cómo corregirlo: quita la clave del parámetro del valuesMapping, para que el parámetro siga declarado y la regla lea el valor pasado cuando se despliega el stack.
The assembled CloudFormation stack cannot carry a transform (El stack de CloudFormation ensamblado no puede llevar una transformación)
El Transform del stack ensamblado se construye a partir del de cada componente, y una transformación procesa toda la plantilla, así que una transformación cuyo efecto no se limita al contenido escrito para ella se rechaza en lugar de permitirle cambiar cómo se despliega el contenido de otro componente: AWS::CodeDeployBlueGreen y AWS::Include siempre, una macro que define tu cuenta y AWS::ServiceCatalog junto a cualquier otro componente, AWS::LanguageExtensions junto al contenido serverless de otro componente, y AWS::Serverless-2016-10-31 donde sus Globals alcanzarían los recursos serverless de otro componente o uno de sus orígenes de eventos nombra un recurso que declara otro componente. La tabla completa está en cloudformation → Secciones de nivel superior en el stack ensamblado.
Mensaje emitido. La condición va primero, luego cada componente del stack, la transformación y los componentes que la declaran, y por qué no se puede llevar:
a plugin has no expression for a construct this build declares (un plugin no tiene expresión para una construcción que declara esta compilación) cloudformation-provider: the assembled stack of component "<component>", … cannot carry the transform "<transform>", declared by component "<component>": <why> (cloudformation-provider: el stack ensamblado del componente indicado, … no puede llevar la transformación indicada, declarada por el componente indicado: con el motivo indicado)
Cómo corregirlo: coloca el componente que declara la transformación en un límite propio, para que su stack no contenga nada que la transformación pueda cambiar; o, donde el mensaje nombra contenido que declara otro componente, mueve ese contenido al componente que declara la transformación.
Two components order one pair of transforms oppositely (Dos componentes ordenan un mismo par de transformaciones de forma opuesta)
El stack ensamblado ejecuta sus transformaciones en un único orden, construido a partir del orden propio de cada componente y del que documenta CloudFormation. Donde dos órdenes no pueden cumplirse a la vez — dos componentes que enumeran un mismo par de transformaciones al revés, o un componente que enumera AWS::Serverless-2016-10-31 antes de AWS::LanguageExtensions, que CloudFormation documenta al revés —, no hay un único orden que escribir, así que el renderizado se detiene.
Mensaje emitido. La condición va primero, luego el par y quién lo ordenó en cada sentido:
a plugin could not resolve something it requires to exactly one value (un plugin no pudo resolver a exactamente un valor algo que requiere) 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: las transformaciones indicadas están ordenadas en ambos sentidos — la primera antes de la segunda por parte de quien se indica, y la segunda antes de la primera por parte de quien se indica — y el Transform del stack ensamblado las ejecuta en un único orden; decláralas en un único orden)
Cómo corregirlo: declara el par en un único orden en cada componente que enumere ambas, siguiendo el orden propio de CloudFormation donde documente uno.
Two entries reach one stack output name (Dos entradas llegan a un mismo nombre de salida del stack)
Un nombre de salida del stack solo admite letras y dígitos, así que se construye a partir de lo que escribiste codificando los caracteres que ese alfabeto no admite en lugar de quitarlos. Por tanto, dos entradas que escribiste distintas siguen siendo distintas, y esta detención es lo que informa del caso en que dos de ellas llegan, aun así, a un mismo nombre. El renderizado se detiene en lugar de emitir una sola salida donde se escribieron dos entradas, lo que descartaría silenciosamente una de ellas.
Se informa de cada nombre tras el que se encontraron dos o más entradas, y se nombra cada entrada tras cada nombre, en un orden estable — así una sola compilación te muestra la colisión entera en lugar de uno de sus lados.
Mensaje emitido, que comienza con la condición y continúa con el detalle propio del proveedor:
two things a plugin produced occupy one name in its output (dos cosas que produjo un plugin ocupan un mismo nombre en su salida) 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: dos entradas que escribió un autor llegan a un mismo nombre de Output del stack: las entradas indicadas que se encontraron llegan al nombre de Output indicado; un nombre de Output se construye codificando el componente y la entrada en las letras y los dígitos que admite un ID lógico, en lugar de quitar lo que no admite, así que dos entradas que un autor escribió distintas siguen siendo distintas — renombrar cualquiera de los dos extremos desbloquea la compilación)
Cómo corregirlo: renombra una de las entradas, o uno de los componentes, para que las dos ya no lleguen a un mismo nombre — el mensaje nombra ambos lados. El nombre lleva la puntuación y las mayúsculas y minúsculas que escribiste, codificadas en lugar de quitadas, así que una diferencia en cualquiera de ellas se conserva en él y dos entradas escritas de forma distinta reciben nombres distintos.
A CloudFormation fragment writes one key twice (Un fragmento de CloudFormation escribe una misma clave dos veces)
Un mapa contiene un valor por clave, así que un fragmento que escribe la misma clave dos veces conservaría el cuerpo que vino al final y descartaría el otro. Donde el mapa es el bloque que contiene los recursos o las salidas, el cuerpo descartado es un recurso o una salida que se escribió y que no estaría en el resultado. En su lugar, el renderizado se detiene.
Se informa de los dos lugares donde se escribió la clave, porque una clave escrita dos veces suele ser dos ediciones pensadas como dos claves distintas — y el autor necesita ambos para saber cuál cambiar.
Mensaje emitido, que comienza con la condición y continúa con el detalle propio del proveedor:
two things a plugin produced occupy one name in its output (dos cosas que produjo un plugin ocupan un mismo nombre en su salida) cloudformation-provider: one mapping key is written more than once: the key "<key>" is written at line <first> and again at line <second>; a mapping holds one value per key, so one of the two bodies would be dropped — remove one, or rename one so each key is written once (cloudformation-provider: una clave de mapa se escribe más de una vez: la clave indicada se escribe en la línea indicada y de nuevo en la segunda línea indicada; un mapa contiene un valor por clave, así que uno de los dos cuerpos se descartaría — quita uno, o renombra uno para que cada clave se escriba una sola vez)
Cómo corregirlo: abre el fragmento en las dos líneas que nombra el mensaje. Donde los dos cuerpos debían ser una sola cosa, quita el que ahora sobra; donde debían ser dos, renombra uno para que cada uno tenga su propia clave. El fragmento es una plantilla, así que comprueba el texto renderizado y no solo la fuente donde una clave se compone en lugar de escribirse literalmente.
A cross-boundary reference has no consuming stack to be written into (Una referencia entre límites no tiene ningún stack consumidor en el que escribirse)
Donde una conexión de dependencia cruza entre dos salidas ensambladas por separado, el lado consumidor se renderiza con un marcador de posición y la referencia se escribe una vez que existen ambos lados. Esta condición es lo que ocurre cuando la salida ensamblada del lado consumidor no contiene ninguna plantilla de stack: no hay ningún documento en el que escribir la referencia, así que el marcador de posición no puede sustituirse.
Mensaje emitido. La condición nombra el tipo de fallo, y la frase propia del proveedor dice qué entrada:
a plugin could not resolve something it requires to exactly one value (un plugin no pudo resolver a exactamente un valor algo que requiere) cloudformation-provider: cross-boundary link resolve received no consumer stack template (cloudformation-provider: la resolución del enlace entre límites no recibió ninguna plantilla de stack del consumidor)
Cómo corregirlo: nada de lo que escribes dentro del componente consumidor produce esto — es la forma de lo que ensambló su límite. Comprueba que el lado consumidor lo renderice realmente el proveedor CloudFormation: una conexión que cruza hacia un límite que ensambla otra cosa no tiene ningún stack en el que pueda caer la referencia, y la conexión corresponde entre dos límites que ensambla el mismo proveedor. Donde ambos lados deberían ser CloudFormation, el límite consumidor no produjo ninguna plantilla de stack, lo cual es una cuestión para quien escribió las Recipes que contribuyen a él.
A cross-boundary reference was spliced into a longer string (Una referencia entre límites se insertó en una cadena más larga)
Una referencia cruzada de CloudFormation es un objeto y no texto, así que solo puede sustituir un valor completo. Esta condición es lo que informa un marcador de posición encontrado dentro de una cadena más amplia — un valor compuesto a su alrededor, en lugar de entregado como la totalidad de lo que se inyectó. No hay nada por lo que cambiar el objeto, así que el renderizado se detiene en lugar de emitir una referencia en una forma que el destino no puede leer.
Mensaje emitido. La condición va primero, luego el valor y la conexión por la que llegó:
a plugin has no representation for a value it was given (un plugin no tiene representación para un valor que recibió) 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: el valor del enlace entre límites está interpolado en una cadena más amplia; solo una inyección de un escalar completo puede llevar una referencia entre stacks: con la clave de salida indicada en el socket indicado)
Cómo corregirlo: entrega el valor completo en lugar de componer a su alrededor. Donde el lado consumidor necesita el valor dentro de una cadena más larga — una cadena de conexión, una URL —, construye esa composición en el vocabulario propio del destino a partir de la referencia, en lugar de en la plantilla de la Recipe antes de que exista la referencia. El mapeo que inyecta el valor es donde ocurre la inserción, así que esa es la línea que cambiar.
Two rendered resources land at one output file (Dos recursos renderizados acaban en un mismo archivo de salida)
Cada recurso renderizado se escribe en un archivo cuyo nombre proviene de lo que es el recurso y de cómo se llama. Dos recursos que comparten ambas cosas llevan el mismo nombre de archivo, así que uno ocuparía el hueco del otro y el renderizado se detiene en lugar de emitir un solo archivo donde se renderizaron dos recursos.
Dos recursos que se renderizan de forma idéntica no son una colisión. Donde el contenido coincide byte a byte, conservar uno no pierde nada y el renderizado continúa — así que una plantilla incluida dos veces con el mismo resultado no se informa.
Mensaje emitido. La condición va primero, luego las dos plantillas que los produjeron y el archivo en el que se encontraron:
two things a plugin produced occupy one name in its output (dos cosas que produjo un plugin ocupan un mismo nombre en su salida) 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: en el nodo indicado: los recursos renderizados indicados, uno y otro, derivan ambos la salida indicada con contenido distinto: dos recursos renderizados derivan el mismo nombre de archivo de salida con contenido distinto)
Cómo corregirlo: da a los dos recursos identidades distintas — el nombre es lo que suele diferir, y el nombre del archivo se deriva de él. El mensaje nombra ambas plantillas, así que ábrelas y comprueba qué produce cada una: dos plantillas que renderizan el mismo recurso con un mismo nombre suelen significar que una de ellas es una copia más antigua. Donde se quieren ambos, son dos recursos y cada uno necesita su propio nombre.
A synthesized StatefulSet has no single service to govern it (Un StatefulSet sintetizado no tiene un único servicio que lo gobierne)
Una carga de trabajo que declara almacenamiento por instancia se renderiza como un StatefulSet, y un StatefulSet nombra un servicio que lo gobierna — el que da a cada instancia su dirección estable. Ese servicio es el que se declara sin una dirección de clúster propia. Dos formas detienen el renderizado: ninguno declarado, así que no hay nada que nombrar; y más de uno, así que la pregunta de cuál de ellos gobierna no tiene respuesta. Cualquiera de las dos produciría un StatefulSet que el destino rechaza, así que el renderizado se detiene en lugar de emitir uno.
Mensajes emitidos. Ambos informan de la misma condición — algo que el proveedor requiere y que no pudo resolver a exactamente un valor — y la frase propia del proveedor dice cuál de las dos formas se encontró. Cada uno se imprime bajo un marco que nombra el nodo:
a plugin could not resolve something it requires to exactly one value (un plugin no pudo resolver a exactamente un valor algo que requiere) synthesized StatefulSet requires a headless governing Service (declare a service with type: Headless); none found: synthesized StatefulSet has no headless governing Service (el StatefulSet sintetizado requiere un Service headless que lo gobierne (declara un servicio con type: Headless); no se encontró ninguno: el StatefulSet sintetizado no tiene ningún Service headless que lo gobierne)
a plugin could not resolve something it requires to exactly one value (un plugin no pudo resolver a exactamente un valor algo que requiere) 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 (el StatefulSet sintetizado declara más de un Service headless; el Service que lo gobierna es ambiguo (declara exactamente un servicio type: Headless): el StatefulSet sintetizado tiene más de un Service headless)
Cómo corregirlo: declara exactamente un servicio de tipo headless en la carga de trabajo. Donde no se declara ninguno, añádelo — una carga de trabajo con almacenamiento por instancia lo necesita, y es lo que da a cada instancia una dirección que se queda con ella. Donde se declara más de uno, conserva el que debe gobernar y da a los demás un tipo ordinario, o quítalos; un segundo servicio headless suele ser uno que no necesitaba ser headless.
A plugin reported a failure it did not classify (Un plugin informó de un fallo que no clasificó)
Un plugin que detiene una compilación informa de dos cosas: una frase propia que dice qué ocurrió, y qué tipo de fallo nombra esa frase. Los tipos son un pequeño conjunto que declara el compilador — una construcción sin expresión, una entrada que no pudo resolverse a un solo valor, dos cosas producidas que quieren un mismo nombre, un valor sin representación — y esta condición es la que elige un plugin cuando su fallo no encaja en ninguno de ellos.
Es un recurso de reserva y no un destino. Un plugin que recurre a ella donde encaja uno de los otros tipos te está diciendo menos de lo que sabe, y la redacción dice claramente que el plugin declinó clasificar, y no que algo simplemente salió mal — así un recurso de reserva usado en exceso es reconocible en lugar de indistinguible de un informe correcto.
Mensaje emitido. La condición va primero y la frase propia del plugin la sigue:
a plugin reported a failure that none of the declared kinds names (un plugin informó de un fallo que no nombra ninguno de los tipos declarados) <the plugin's own sentence>
Cómo corregirlo: lee la frase propia del plugin, que es donde está todo lo específico de tu compilación. La condición en sí solo te dice que el plugin no tenía ningún tipo para él. Donde el plugin es tuyo, elige el tipo que el fallo realmente es; donde no lo es, la frase es lo que debes citar a quien lo publique.
A plugin named a condition the socket does not declare (Un plugin nombró una condición que el socket no declara)
Un plugin informa de una condición que declara este compilador en lugar de inventar un número propio, así que el identificador que te llega es siempre uno al que aggrega explain responde. Esta detención es lo que produce un informe que nombra cualquier otra cosa: un número bajo el que no hay nada registrado, un número que se retiró, un código corto escrito de forma distinta del registro al que se resuelve, o un par de identificadores que nombran dos condiciones distintas.
Se detiene en lugar de retirar el informe en silencio. Descartar los identificadores y dejar en pie la condición genérica de fallo de plugin produciría una compilación idéntica a la de un plugin que no nombró ninguna condición, así que quien tenga que corregirlo nunca sabría que había algo que corregir. Informar en su lugar del número ofrecido te entregaría un identificador que no se resuelve a nada.
Tu compilación sigue recibiendo lo que la detuvo. La detención cita el número infractor, dice por qué no se resuelve a ninguna condición, nombra las condiciones genéricas a las que recurre un plugin cuando no tiene una identidad mejor, y transmite sin cambios la frase propia del plugin.
Mensaje emitido:
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: el plugin invitado nombró una condición que el socket no declara: el invitado nombró el valor indicado, con el motivo indicado por el que no se resuelve a ninguna condición; un plugin nombra una condición que declara este compilador, y recurre a una de las condiciones genéricas indicadas, con sus códigos, cuando no tiene una mejor: seguido de la frase propia del plugin)
Cómo corregirlo: nada en tus archivos de entidad causa esto — es el informe del plugin lo que está mal, y el fallo del que informaba es real. Actúa según la frase propia del plugin, que es la última parte del mensaje. Donde el plugin es tuyo, informa de una condición que declare este compilador — uno de los tipos genéricos que enumera el mensaje, donde el fallo no encaje en ninguna de las condiciones más específicas; donde el plugin no es tuyo, cita el número infractor a quien lo publique.
A source artifact is cached without a workspace root to anchor it (Un artefacto fuente se almacena en caché sin una raíz del espacio de trabajo a la que anclarlo)
Un artefacto fuente adquirido se guarda en un slot bajo la caché de artefactos del espacio de trabajo, y la ruta a ese slot se construye desde la raíz del espacio de trabajo hacia fuera. Esta condición informa de que la raíz llega vacía, lo que dejaría relativa la ruta del slot — resuelta contra el directorio en el que el proceso se encuentre cuando se escriben los bytes, y dejando la caché en un lugar que nadie eligió.
Se rechaza en lugar de resolverse, porque un slot escrito en el lugar equivocado es peor que ningún slot: las lecturas posteriores miran en el correcto, no encuentran nada y vuelven a adquirir, así que lo que verías es una caché que nunca parece contener nada, y nada más que señale el porqué.
Mensaje emitido. Lo abre la frase propia de la condición, y le sigue lo que identifica el artefacto:
cacheslot: empty workspaceRoot (kind=<kind> url=<url> chart=<chart> version=<version>) (cacheslot: workspaceRoot vacío (con kind, url, chart y version indicados))
Cómo corregirlo: nada en tus archivos de entidad causa esto y ningún cambio en lo que escribes lo resuelve — la raíz del espacio de trabajo la proporciona lo que esté impulsando la compilación, no se escribe en un catálogo. Ejecuta la compilación desde dentro del espacio de trabajo, para que la raíz se descubra en lugar de pasarse como nada. Donde impulses el compilador desde software propio, pasa la raíz del espacio de trabajo de forma explícita; un llamador que de verdad quiere la caché relativa al directorio actual pasa un solo punto, que se acepta y lo expresa deliberadamente.
A value would place a cached file outside the cache (Un valor colocaría un archivo en caché fuera de la caché)
Una entidad en caché y un artefacto fuente en caché viven cada uno en un slot que la caché nombra para él, y ese slot se compone a partir de valores: la referencia de la entidad y la versión a la que se resolvió, o el tipo, url, chart, module_subdir, la versión y el digest de una fuente. Cada valor nombra una posición en la estructura. Esta condición informa de un valor que movería lo que se escribe para él a un lugar distinto de la posición que nombra — junto a otro slot, o fuera de la caché por completo — y lo rechaza antes de que se escriba o lea nada allí.
La mayoría de esos valores llegan de un lugar que la caché no controla: un cuerpo que sirvió un registro, una entrada releída del disco, una coordenada que escribió el autor de una Recipe o una FeatureRecipe. Una versión que es una ruta en lugar de una versión, una ruta url o un module_subdir que sube por encima de su lugar, y una referencia que se resuelve a un directorio de puntos se rechazan aquí, cada uno. Un valor que nombra un solo directorio — y una ruta url o un module_subdir que se queda en su lugar o por debajo — no se toca.
Un module_subdir que sube se rechaza antes de obtener nada. Para una fuente git-repository el mismo valor nombra también el directorio del repositorio que archiva el pull, y uno que suba por encima del repositorio haría que el pull leyera los archivos junto a su checkout. Así que el pull juzga module_subdir antes de obtener el repositorio, y rechaza un valor que sube con esta condición, citándolo bajo su clave: no se obtiene nada, y no se lee nada junto al checkout. Una barra invertida en él se lee como separador, como la lee una ruta de Windows, así que ..\shared se rechaza en todas las máquinas en lugar de leerse desde junto al checkout en una de ellas; un separador al principio o al final del valor se elimina, así que /charts/app nombra charts/app.
Mensaje emitido. Lo abre la frase propia de la condición, luego el valor tal como se escribió bajo la clave con la que se escribió, y el remedio:
a value a cache location is built from would place cached files outside the place it names in the cache (version "../../../etc" for entity "demo/app/web"). a version, a name, a kind or a host names one directory of the cache, so it carries no / or \ and is neither . nor ..; a URL path or a module subdirectory may name directories beneath its place but may not climb above it. Correct the value where it was written, or, where a registry served it, ask its publisher to publish a version that carries a well-formed one (un valor a partir del cual se construye una ubicación de la caché colocaría archivos en caché fuera del lugar que nombra en la caché (la versión indicada para la entidad indicada). una versión, un nombre, un tipo o un host nombra un solo directorio de la caché, así que no contiene ni barra ni barra invertida y no es ni un punto simple ni un punto doble; una ruta de URL o un subdirectorio de módulo puede nombrar directorios por debajo de su lugar pero no puede subir por encima de él. Corrige el valor donde se escribió o, donde lo sirvió un registro, pide a quien lo publica que publique una versión que lleve uno bien formado)
Cómo corregirlo: donde el valor es uno que escribiste tú — source.version, url o module_subdir de una Recipe o una FeatureRecipe —, corrígelo para que nombre un solo directorio, o una ruta que se quede dentro de su lugar; el mensaje cita el valor y la clave de la que se leyó. Donde lo sirvió un registro, la entidad publicada lleva una versión o una coordenada que no lo es, lo que ningún cambio tuyo puede corregir: el mensaje nombra lo que se obtuvo, y el remedio está en manos de quien la publica.
A path the operation writes leads through a link out of the directory it must stay inside (Una ruta que la operación escribe lleva, a través de un enlace, fuera del directorio dentro del cual debe permanecer)
Varias operaciones escriben o eliminan archivos propios, en lugares que determinan por sí mismas en lugar de lugares que nombraste tú: el directorio de salida de una compilación y cada archivo que escribe en él, y el directorio .trace que sustituye una compilación con traza; el archivo de bloqueo de una Release, y el registro de confianza de plugins junto a él, que escribe un pull; el archivo entity.lock junto a una entidad, que escribe aggrega pin, y que un pull que fija fuentes escribe junto a cada entidad que fija; el archivo .aggrega-config.yaml del espacio de trabajo, cuando un comando escribe la configuración del espacio de trabajo; la caché de artefactos y cada uno de sus subárboles, que llena un pull y que vacían aggrega cache clear y aggrega cache prune; los bundles de firma que un pull guarda en esa caché para cada artefacto cuya firma verificó; los borradores que escribe aggrega import; las entidades Plugin que escribe aggrega plugin gen-catalog bajo su directorio de salida; y el marcador .aggrega/active-release que escribe el servidor de lenguaje del editor cuando se registra una Release predeterminada, y el directorio .aggrega que lo contiene. Lo mismo vale sea cual sea la superficie que inició la operación — la línea de comandos, el servidor de lenguaje del editor o las herramientas de un asistente. El límite del espacio de trabajo establece la regla que se aplica aquí, y las rutas que salen del espacio de trabajo a propósito.
Cada uno de esos lugares tiene un directorio dentro del cual debe permanecer, y cuál es depende del directorio bajo el que la operación lo compone:
El espacio de trabajo, para todo lo que se compone dentro de él. Es el caso habitual, y vale también para un directorio que nombraste y que está dentro del espacio de trabajo. dist y .trace de una compilación se componen siempre aquí, bajo la raíz del espacio de trabajo, sea cual sea la carpeta desde la que se ejecute la compilación, y lo mismo los borradores de una importación que no nombra ningún directorio de salida.
Un directorio que nombraste y que está fuera del espacio de trabajo, para todo lo que se compone debajo de él: el directorio de salida que pasas a aggrega plugin gen-catalog o a aggrega import; el directorio de una Release que nombras, o que nombra la configuración del espacio de trabajo, que está fuera del espacio de trabajo, para el archivo de bloqueo y el registro de confianza junto a ella; y el directorio de una entidad que nombras a aggrega pin, o un directorio de catálogo que nombras con --catalog o que la configuración incluye en catalog_dirs, para el archivo entity.lock junto a cada entidad que haya allí. El directorio en sí se usa tal como lo nombraste — en uno que es un enlace se escribe a través de él, allí adonde apunta — y lo que se escribe debajo de él permanece dentro de él.
El propio directorio de la caché de artefactos, para todo lo que se escribe en la caché debajo de él y todo lo que aggrega cache clear y aggrega cache prune eliminan allí — tanto el predeterminado .aggrega/cache como un artifact_cache_dir que la configuración escribe subiendo fuera de la raíz del espacio de trabajo (../shared-cache). Uno de los directorios propios de la caché, o un archivo en ella, que sea un enlace que lleva fuera del directorio de la caché se rechaza incluso donde lleva a otro lugar dentro del espacio de trabajo, para que nada de lo que se escribe en la caché, y nada de lo que elimina un clear o un prune, acabe en un archivo fuera de ella. Dónde está el propio directorio de la caché se juzga primero: uno escrito dentro de la raíz del espacio de trabajo se sigue adondequiera que lleve dentro del espacio de trabajo y se rechaza, sometido al espacio de trabajo, donde lleva fuera de él; uno escrito subiendo fuera de la raíz del espacio de trabajo se usa tal como lo nombraste, y se escribe a través de él hasta donde apunta si es un enlace.
Cada uno de esos lugares se comprueba antes de que se escriba o elimine nada allí. La parte más profunda de la ruta que existe, siguiendo cada enlace simbólico del camino, tiene que ser el directorio dentro del cual debe permanecer o estar debajo de él. Un enlace en cualquier punto del camino que lleve fuera de ese directorio — un dist enlazado a un directorio en otro lugar, un archivo de bloqueo enlazado a un archivo de otro proyecto, un .aggrega/cache enlazado a un directorio compartido con otro trabajo, un directorio bajo un directorio de salida de gen-catalog enlazado a otra parte — haría que la escritura o la eliminación acabara fuera, así que la operación se detiene en su lugar, y esa ruta se deja exactamente como estaba. Importa sobre todo para una compilación: vaciar y reescribir un directorio de salida que es un enlace borraría y reescribiría de otro modo un directorio en otro lugar de la máquina.
Un enlace que no lleva a ninguna parte se trata como lo que es — no algo que existe — así que se comprueba el directorio que lo contiene. Donde un enlace así está justo al final de una ruta que la operación está a punto de crear, el archivo se crearía donde apunta el enlace, así que también se comprueba el lugar al que apunta. Un enlace que apunta a algún lugar dentro del directorio dentro del cual debe permanecer la ruta se sigue como de costumbre.
Mensaje emitido. Lo abre la frase propia de la condición, luego la ruta que la operación iba a escribir o eliminar — writing o removing dice cuál — el directorio dentro del cual debe permanecer, el enlace que encuentra en el camino y el lugar al que lleva ese enlace, y luego el remedio. Una compilación cuyo dist es un enlace que lleva fuera del espacio de trabajo se detiene en lo primero que tocaría, el vaciado de la salida anterior:
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 (una ruta que esta operación escribe o elimina lleva, a través de un enlace, fuera del directorio dentro del cual debe permanecer (eliminación de la ruta indicada, que debe permanecer dentro del espacio de trabajo indicado; el enlace indicado lleva al destino indicado). no se escribió nada en esa ruta ni se eliminó nada de ella. Quita el enlace, o haz que lleve a un lugar dentro del espacio de trabajo indicado, y vuelve a ejecutar la operación)
El diagnóstico no lleva categoría: lo que falla es la disposición en disco, no un documento que hayas escrito.
Cómo corregirlo: quita el enlace que nombra el mensaje y vuelve a ejecutar la operación, para que cree un directorio o un archivo real en ese lugar; o haz que el enlace lleve a algún lugar dentro del directorio que nombra el mensaje, donde se sigue. Nada en tus archivos de entidad causa esto y ningún cambio en lo que escribes lo resuelve.
A name the operation writes holds a part Windows cannot hold (Un nombre que la operación escribe contiene una parte que Windows no puede contener)
En Windows, algunos nombres no llegan a un archivo tal como están escritos. Un nombre que Windows reserva para un dispositivo — CON, PRN, AUX, NUL, CONIN$, CONOUT$, de COM0 a COM9 y de LPT0 a LPT9, y los nombres COM y LPT escritos con un uno, un dos o un tres en superíndice — nombra el dispositivo en lugar de un archivo, con cualquier combinación de mayúsculas y minúsculas y sea cual sea la extensión que lo siga, de modo que nul, Aux.yaml y com1.txt son todos dispositivos. Y una parte de una ruta que termina en un punto o un espacio es una parte que Windows puede recortar en lugar de conservarla tal como está escrita. Escribir un nombre así pondría sus bytes en un lugar distinto del archivo que nombra.
Así que, cuando una operación está a punto de escribir bajo un directorio, en una máquina Windows, un nombre que no eligió ella misma, un nombre que contiene una parte así se rechaza antes de que se escriba nada: una entrada del archivo comprimido que lleva un artefacto fuente o una entidad del catálogo, cuando la caché despliega el archivo comprimido para leerlo; un archivo que una compilación renderiza en su directorio de salida; un borrador que un importador devuelve a aggrega import, tanto en una ejecución de prueba como en una escritura; y el documento que aggrega edit-document vuelve a escribir, sea cual sea la superficie que pidió la edición. Se juzga cada parte del nombre, leyendo una barra invertida como separador, tal como la lee Windows — así, aux/x.yaml se rechaza por su directorio aux, report. por su punto final y .. \evil.yaml por su primera parte, dos caracteres de punto y un espacio. Un conjunto rechazado por un solo nombre no escribe ninguno de los demás: no se despliega un archivo comprimido, la salida de una compilación no se vacía ni se escribe, y ningún borrador llega al disco.
En Linux y macOS los mismos nombres se escriben tal como se nombran, y esta condición nunca se activa. Un nombre que sale del directorio bajo el que se escribe es un fallo distinto, rechazado en todas las plataformas con el mensaje propio de esa operación antes de que se consulte esta condición.
Mensaje emitido. Lo abre la frase propia de la condición, luego el nombre, la parte que Windows no puede contener y el directorio bajo el que iba a escribirse el nombre, y después el remedio:
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 nombre que esta operación escribe contiene un segmento de ruta que Windows no puede contener tal como está escrito (el nombre, su segmento y el directorio indicados). No se escribió. Windows reserva nombres de dispositivo como CON, PRN, AUX, NUL, COM1 y LPT1, con cualquier combinación de mayúsculas y minúsculas y sea cual sea la extensión que siga, y no conserva tal como está escrito un segmento que termina en un punto o un espacio; cambia el nombre de ese segmento donde se produce el nombre)
El diagnóstico no lleva ninguna categoría: el nombre procede de lo que lo produjo — quien publica un archivo comprimido, una Recipe o una biblioteca, un importador, la ruta que nombra una edición — y no de un único documento al que el compilador atribuya el fallo.
Cómo corregirlo: cambia el nombre de la parte que nombra el mensaje allí de donde procede el nombre. Para una entrada de un archivo comprimido, se trata del artefacto fuente o de la entidad publicados, que solo quien los publica puede cambiar. Para un archivo renderizado, es el nombre de salida que le da una Recipe o una ArtifactLibrary; para un borrador, el importador que lo nombró; para una edición, la ruta del documento. Nada en la máquina Windows hace que el nombre sea utilizable tal como está escrito.
Condiciones que no detienen una compilación
Cada condición anterior detiene una compilación. Algunas condiciones llevan un código corto y un mensaje propios sin detener nunca ninguna, y se catalogan aquí para que un código que tengas en la mano siempre se resuelva en algo, sea cual sea la página desde la que llegaste.
Se dividen en cuatro tipos, y vale la pena conocer la diferencia antes de ponerse a buscar una corrección.
Un aviso. La compilación lo informa y continúa, y la salida renderizada es la misma tanto si actúas sobre él como si no. Cada uno se explica en detalle en warnings.md — qué lo activa, en qué punto de la compilación se lee, qué imprime y qué hacer al respecto — y las entradas siguientes indican qué sección, en lugar de repetirlo aquí.
Una condición que absorbe el editor. La responde la propia integración del editor y no llega ni a la salida de una compilación ni a un diagnóstico.
Una salvaguarda detrás de un rechazo anterior. La regla que protege se aplica antes que ella mediante una condición que sí detiene, de modo que una compilación se encuentra primero con la anterior.
Un rechazo en un comando que no es una compilación. Es una detención firme con un remedio real — termina el comando que se la encontró, y no se publica, escribe ni cambia nada — pero ninguna etapa de la compilación la alcanza, así que ninguna compilación la informa. Publicar o firmar un artefacto, fijar las entradas de una entidad, añadir un registro, editar un documento, convertir la descripción de un origen externo en archivos de autoría en borrador y comprobar un catálogo completo — en cuanto a su corrección o frente a las convenciones de publicación — son los lugares donde se encuentran, y cada entrada dice a qué comando pertenece y quién tiene la corrección en sus manos.
An annotation binding declares one path in both pillar lists (Un enlace de anotación declara una misma ruta en ambas listas de pilares)
Un aviso. Un enlace de anotación del Manifest nombra la misma ruta con puntos tanto en su lista maps.infra como en su lista maps.values. Declarar el solapamiento es legal y el compilador no lo vigila: el criterio de desempate del enrutamiento envía de forma determinista la ruta a través de infra, lo que deja el lado values de esa ruta inalcanzable desde el Aggregate.
Su mensaje empieza así:
annotation binding declares one path in both pillar lists (un enlace de anotación declara una misma ruta en ambas listas de pilares)
Es lo que te avisa antes de que una compilación llegue a la detención descrita más arriba en «An annotation routes through a pillar its authoring side may not use (Una anotación se enruta a través de un pilar que su lado de autoría no puede usar)» — el aviso es la superficie temprana; esa detención, la que hace cumplir la regla. El lint se explica en «Binding-map-overlap lint (Lint de solapamiento de mapas del enlace)» en warnings.md.
An attachment name is one edit from a declared slot (Un nombre de vinculación está a una edición de distancia de un slot declarado)
Un aviso. Un componente vincula una Feature bajo un nombre que no es uno de los slots declarados de su tipo pero que está a una sola edición de uno de ellos — la estructura que adopta una errata en el nombre de un slot. Una vinculación bajo un nombre que ningún slot declara es legal, así que nada se detiene; lo que el aviso nombra es la consecuencia, que es que la vinculación es una vinculación libre en lugar del relleno del slot que pretendías, y el slot queda vacío. En una conexión la misma errata no es legal y provoca en cambio una detención, que nombra el slot cercano; consulta «A connection carries an attachment under a name its socket declares no slot for (Una conexión lleva una vinculación bajo un nombre para el que su socket no declara ningún slot)». Donde la Feature de la vinculación satisface el selector: del slot cercano, el aviso no se genera: ese emparejamiento lo juzga la detención descrita en «An attachment written under another name fits a slot its component leaves empty (Una vinculación escrita bajo otro nombre encaja en un slot que su componente deja vacío)», que lo informa cuando el slot queda vacío.
Su mensaje empieza así:
attachment name is a near miss for a declared slot (el nombre de la vinculación es una casi coincidencia con un slot declarado)
Se explica en «Attachment-slot near-miss lint (Lint de casi coincidencia de slots de vinculación)» en warnings.md, con el umbral de emparejamiento y lo que deliberadamente no detecta.
A uses: socket name is one edit from a declared socket (Un nombre de socket está a una edición de distancia de un socket declarado)
Un aviso. El propio bloque uses: de un componente nombra un socket que su tipo no declara pero que está a una sola edición de uno de ellos. Un desarrollador es dueño de la topología que declara el Aggregate y puede nombrar un socket que el catálogo no previó, así que un nombre de socket que el tipo no declara es legal en esa superficie y nada se detiene. Lo que el aviso nombra es la consecuencia: el nombre mal escrito traza una conexión ad hoc propia, sin selector ni contrato por arista, mientras el socket que pretendías queda sin cablear.
Su mensaje empieza así:
uses socket name is a near miss for a declared socket (el nombre del socket uses es una casi coincidencia con un socket declarado)
Se explica en «Uses-socket near-miss lint (Lint de casi coincidencia de sockets uses)» en warnings.md. Las dos superficies vecinas en las que un nombre de socket ausente del usesSchema de la entidad propietaria sí provoca una detención se tratan más arriba en «uses: socket not declared in the owning entity’s usesSchema (Socket no declarado en el esquema de sockets de la entidad propietaria)».
A Recipe publishes a provides key its Component does not declare (Una Recipe publica una clave que su Component no declara)
Un aviso. La Recipe asociada a un componente publica bajo provides: una clave que el tipo del componente no declara en su contrato spec.schema.provides:. Publicar más de lo que declara el Component es legal y sigue siéndolo — el contrato exige el subconjunto y permite el superconjunto. Lo que el aviso nombra es una consecuencia invisible desde ambos lados: un consumidor que lee a través de una arista uses: ve el contrato declarado del destino, no lo que emita su Recipe, así que una clave no declarada no se entrega y una plantilla consumidora que la lee se renderiza vacía.
Su mensaje empieza así:
Recipe publishes a provides key its Component does not declare (la Recipe publica una clave provides que su Component no declara)
El caso opuesto no es un aviso: un Component que declara una clave que su Recipe no publica deja el contrato sin cumplir y provoca una detención. Se explica en «Undeclared-provides-key lint (Lint de claves provides no declaradas)» en warnings.md.
A declared parameter is read by nothing (Un parámetro declarado no es leído por nada)
Un aviso. Un Aggregate declara una entrada bajo spec.parameters: y ninguna referencia {{ .parameters.<key> }} en el propio texto de ese Aggregate la lee, así que, sea lo que sea lo que una Release aporte para ella, la salida renderizada es la misma. El compilador no vigila qué ajustes expone un autor, y un parámetro puede declararse legítimamente antes de la referencia que lo leerá, así que esto avisa en lugar de detener.
Su mensaje empieza así:
declared parameter is read by no reference in the Aggregate (el parámetro declarado no es leído por ninguna referencia en el Aggregate)
Se explica en «Unread declared-parameter warnings (Advertencias de parámetros declarados no leídos)» en warnings.md, incluido por qué un valor por defecto no es una exención y qué referencias puede y no puede ver la lectura.
A provider binding names a capability no plugin the build reads serves (Un enlace de proveedor nombra una capacidad que ningún plugin leído por la compilación sirve)
Un aviso. Una entrada plugins.providers nombra una capacidad y ningún plugin, y ninguno de los plugins de proveedor que lee la compilación — en los directorios del catálogo, dentro del compilador o entre los que registra el archivo de bloqueo — sirve esa capacidad. Es la estructura que adopta una capacidad mal escrita, y una entrada así no la lee nada: un enlace solo se consulta cuando una Recipe pide su capacidad, y uno que no nombra ningún plugin no selecciona nada que la resolución de la capacidad no seleccionaría sin él.
Avisa en lugar de detener porque la compilación no puede estar segura. Los enlaces se escriben una sola vez para todo el espacio de trabajo, mientras que una compilación es de una sola Release, así que el plugin que sirve la capacidad puede ser uno que solo lee otra Release. La entrada que nombra un plugin se juzga de otro modo, y se detiene donde es sin duda errónea — consulta más arriba «A plugins.providers binding names a plugin that does not serve the capability (Un enlace nombra un plugin que no sirve la capacidad)».
Su mensaje empieza así:
plugins.providers entry names a capability no provider-rendering plugin the build reads serves (la entrada plugins.providers nombra una capacidad que ningún plugin de renderizado de proveedores leído por la compilación sirve)
y continúa con la capacidad, y con una capacidad servida a una edición de distancia, cuando la hay. Se explica en «Provider-binding unserved-capability warning (Advertencia de capacidad no servida de un enlace de proveedor)» en warnings.md.
An editor position falls outside the document (Una posición del editor queda fuera del documento)
Una condición que absorbe el editor. Las funciones del editor que dependen de dónde está tu cursor — ir a la definición, información al pasar el cursor, autocompletado — localizan primero el cursor dentro de la estructura analizada del documento. Esta condición es lo que informa ese paso cuando la posición apunta a una línea que el documento no tiene, lo que ocurre de forma transitoria mientras una edición está en curso y la posición que envió el editor se midió sobre un texto que el documento ya ha dejado atrás.
Su mensaje dice:
position out of range (posición fuera de rango)
No llega a ninguna compilación ni a ningún diagnóstico. Toda función que pueda encontrarla responde sin resultado en lugar de mostrar un error, que es el comportamiento que pide el protocolo del editor: una solicitud que no se puede responder no devuelve nada, y el editor vuelve a preguntar tras la siguiente pulsación de tecla.
No hay nada que corregir en tus archivos, y nada aparece en una compilación. Una función que deja de responder en lugar de recuperarse con la siguiente edición merece notificarse como defecto.
The schema-merge step’s own input guard (La salvaguarda de entrada propia del paso de fusión de esquemas)
Una salvaguarda que una compilación no alcanza. Cuando un Component o una Feature extiende a otro y ambos declaran esquemas, esos esquemas se combinan en uno solo. La biblioteca que realiza la combinación rechaza una entrada que no puede fusionar estructuralmente:
merger: invalid merge input (merger: entrada de fusión no válida)
Pertenece al paso de combinación, al que una compilación sí llega siempre que una entidad que extiende a otra y su base declaran ambas esquemas. Contra lo que protege es contra recibir una cadena vacía, o una entrada de la cadena cuyo esquema falta — y el llamador no puede pasarle ninguna de las dos: ensambla la cadena solo a partir de esquemas que ya ha encontrado presentes, y combina solo cuando esa cadena no ha quedado vacía.
La salvaguarda se mantiene porque es el rechazo de una entrada malformada por parte de una biblioteca exportada. Eliminarla no eliminaría ninguna detención a la que pueda llegar una compilación; convertiría un rechazo claro en un fallo abrupto para un llamador ajeno al compilador que pasara una entrada así, lo cual es estrictamente peor.
La cadena en sí no es asunto de este paso. Una cadena que forma un bucle y una cadena que supera el límite de profundidad las rechaza el único recorrido de extends: antes de que se combine ningún esquema — consulta más arriba «Cyclic extends chain (Cadena extends cíclica)» y «An extends: chain runs past the depth bound (Una cadena de extensión supera el límite de profundidad)».
Está catalogada porque está declarada y lleva un código propio, de modo que un código que tengas en la mano se resuelve. Nada que puedas escribir produce una, y encontrarse con una significaría que la disposición descrita arriba ya no se cumple — merece notificarse como defecto en lugar de esquivarse.
An explicit value displaced one an annotation supplied (Un valor explícito desplazó a uno que aportaba una anotación)
Un aviso. La expansión guiada por anotaciones convierte una anotación que lleva un Aggregate o una Release en una vinculación de Feature con configuración propia. Donde la misma vinculación lleva además configuración escrita explícitamente — en el componente, en un ámbito por encima de él o en la Release —, el valor explícito prevalece en cada clave que ambos cubren. Esa es la regla prevista y la salida emitida no es incorrecta, así que la compilación termina. Lo que el aviso nombra es la consecuencia: la aportación de la anotación a esa clave ya no es visible en ninguna parte de la salida, y el autor que escribió la anotación puede no saber que se suprimió.
Informa de cada desplazamiento en lugar de solo los que cambiaron algo. La fusión sobrescribe el valor suprimido, así que no queda ninguna comparación que hacer ni nada que pueda decir si los dos coincidían — la constancia de que hubo un desplazamiento es toda la prueba. Se lee una vez que toda la cascada de vinculaciones y la expansión se han combinado, que es el primer punto en que existe esa constancia.
Su mensaje empieza así:
annotation contribution overridden by an explicit value (aportación de la anotación sobrescrita por un valor explícito)
y continúa con la anotación que se desplazó, luego las coordenadas de la clave que la desplazó y luego dónde se escribió la anotación desplazada. La posición que lo precede es el documento en el que está el hallazgo y la clave dentro de él:
<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>") (en el archivo y la clave indicados: aportación de la anotación sobrescrita por un valor explícito (anotación, componente, vinculación, pilar, clave en cuestión y lugar donde se declaró la anotación indicados))
Dos de esos valores son fáciles de malinterpretar. El valor component solo se nombra donde la entrada que desplaza tiene un componente: una entrada escrita para todo un ámbito no tiene componente propio, y nombrar uno que nunca tuvo enviaría al lector a una clave que nadie escribió. Y annotation declared at nombra dónde se escribió la anotación desplazada, que es el ámbito del que se heredó siempre que no se escribiera en el componente que la desplazó — así que no es la clave del componente repetida bajo otro rótulo.
Qué hacer al respecto: nada, donde el valor explícito es lo que pretendías. El aviso existe para que la precedencia sea una elección y no una sorpresa. Donde no es lo que pretendías, hay dos salidas y difieren en alcance. Elimina la entrada explícita, y el valor de la anotación llega hasta esa clave. O quita la anotación del componente o del ámbito que la lleva, y no se hace ninguna aportación — lo que afecta también a cualquier otra clave que aporte esa anotación. Donde se quieren ambos lados pero para claves distintas, restringe el que llegue más lejos de lo previsto para que los dos dejen de solaparse.
A connection crosses between two different providers’ assembled outputs (Una conexión cruza entre las salidas ensambladas de dos proveedores distintos)
Donde los dos extremos de una conexión de dependencia se ensamblan en salidas distintas, un proveedor que anuncia el enlace entre límites la cablea de forma nativa — publicando una referencia en el lado productor y resolviéndola en el consumidor. Ese cableado se escribe en el vocabulario propio de un proveedor, y un proveedor no puede resolver una referencia que publicó otro. Así que una conexión cuyos dos extremos se renderizan mediante proveedores distintos no la cablea ninguno de los dos.
Esto avisa y no detiene la compilación. La conexión sigue llevando su valor: el contrato de inyección canaliza el escalar del lado productor hasta el lado consumidor exactamente como lo hace en cualquier otro lugar, así que lo que queda es una conexión que funciona, cableada de la forma ordinaria, y no una rota. Lo que te dice el hallazgo es que el cableado nativo que quizá esperabas no se produjo — y la salida no cambia tanto si actúas sobre ello como si no.
Basta con que un proveedor anuncie el enlace para que se informe. No es necesario que ambos extremos lo declaren: una sola declaración significa que se esperaba el cableado nativo y que es imposible, y el autor que vinculó ese proveedor es quien lo quería. Exigir ambas declaraciones no diría nada en la Release mixta habitual, donde un proveedor enlaza y el otro no, que es precisamente el caso para el que existe.
Dónde se colocaron los extremos no interviene. Una salida ensamblada se identifica por su ruta y su proveedor juntos, así que dos extremos cuyos proveedores difieren están siempre en salidas distintas, sea cual sea su ubicación. Lo que se lee son los dos proveedores y sus dos declaraciones.
Se informa una vez por cada conexión de este tipo, situado en el documento y la clave en que se escribió la conexión.
Mensaje emitido, que empieza por el extremo remoto y luego nombra el socket y el proveedor de cada extremo:
cross-boundary link between endpoints rendered by different providers is not supported ("<target-component>", socket "<socket>", consumer provider "<provider>", target provider "<provider>") (el enlace entre límites entre extremos renderizados por proveedores distintos no es compatible (componente de destino, socket, proveedor del consumidor y proveedor de destino indicados))
Cómo corregirlo: donde basta el valor escalar que la conexión ya lleva, no hay nada que hacer — es una notificación y no un fallo. Donde se quiere el cableado nativo, los dos extremos tienen que renderizarse mediante un solo proveedor: mueve un extremo a un límite que pase por el proveedor del otro, o sirve ambas capacidades con uno solo. Donde ninguna de las dos cosas es posible, la forma que lleva el valor es la que tiene la Release, y la conexión funciona.
A command-line plugin runner was built without a way to find plugins (Un ejecutor de plugins de línea de comandos se construyó sin una forma de encontrar plugins)
Un plugin que aporta un comando de terminal lo ejecuta un componente que primero tiene que convertir la referencia del plugin en bytes. Esta condición informa de que ese componente se construyó sin la parte que hace la conversión, de modo que no hay ningún camino de la referencia a algo que ejecutar.
Se refiere a un comando de terminal y no a una compilación, así que ninguna etapa de la compilación la alcanza: se genera donde se despacha un comando instalado, y la respuesta que produce es que ese comando no arranca, no una detención en ninguna compilación.
Ninguna ruta de la herramienta de línea de comandos distribuida puede generarla. Cada lugar en que la herramienta construye ese componente aporta la búsqueda, así que la salvaguarda solo salta donde otra cosa lo construye y omite la búsqueda.
Mensaje emitido, que es la propia frase de la condición:
cliplugin: no plugin resolver configured (cliplugin: no hay ningún resolutor de plugins configurado)
Cómo corregirlo: nada en tus archivos de entidad causa esto, y nada que puedas escribir en un catálogo o en un espacio de trabajo lo elimina. Donde ejecutas la herramienta de línea de comandos publicada, esta no es una condición a la que puedas llegar — un comando instalado que no arranca está informando de otra cosa, y el mensaje que imprimió es el que hay que leer. Donde integras el ejecutor de plugins en software propio, aporta al construirlo la búsqueda que resuelve una referencia de plugin en sus bytes.
A registry alias is already bound to another host (Un alias de registro ya está asociado a otro host)
Un rechazo al añadir un registro al espacio de trabajo, no en una compilación. Un alias es un nombre corto que selecciona una entrada de registro, así que es único entre las entradas. Registrar un alias que ya tiene un host distinto se rechaza en lugar de permitir que oculte la asociación existente, lo que cambiaría silenciosamente adónde apunta cada referencia que usa ese alias.
Volver a añadir el mismo host con su alias existente no es un conflicto — actualiza la entrada en su sitio, que es lo que hace volver a ejecutar el comando para cambiar otros ajustes de un host.
Mensaje emitido, que nombra el alias y el host que ya lo tiene:
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: el alias de registro indicado ya lo usa el host indicado; elige otro alias o dirígete a ese host directamente: el alias de registro ya lo usa otro host)
Cómo corregirlo: la corrección es del operador, en la línea de comandos. Da al nuevo registro otro alias, o déjalo sin alias y refiérete a él por su host. Si pretendías mover el alias al nuevo host, quítalo primero de la entrada que nombra el mensaje en .aggrega-config.yaml — el rechazo existe para que mover un alias sea algo que haces a propósito y no un efecto secundario de añadir un registro.
A registry serves a trust document that cannot be read as one (Un registro sirve un documento de confianza que no se puede leer como tal)
Un rechazo al añadir un registro, no en una compilación. Un registro puede publicar las identidades de firma con las que espera que se firmen los artefactos, para que al añadir el registro se puedan fijar en lugar de obligar a un operador a transcribirlas. Esta condición informa de un registro que respondió con un documento que no se puede usar como política de confianza.
Es un rechazo firme precisamente porque el endpoint respondió. Un registro que no publica nada es un resultado ordinario y esperado, que se tolera; uno que publica algo ilegible es una configuración errónea, y no fijar nada a partir de él dejaría el registro sin fijar en silencio mientras parece que se fijó.
Aquí se informan tres estructuras: contenido que no se decodifica en absoluto, incluido un documento que lleva un campo que el formato no define; una entrada de identidad que no nombra ni una identidad exacta ni un patrón; y una entrada de identidad sin emisor. Las dos últimas se rechazan porque una entrada así nunca puede coincidir con una firma, de modo que debilitaría la fijación aparentando reforzarla.
Mensajes emitidos. Contenido que no se decodifica:
registrytrust: advertised trust config is malformed: <what the decoder reported> (registrytrust: la configuración de confianza anunciada está malformada, seguida de lo que informó el decodificador)
una entrada de identidad sin nada con lo que coincidir:
registrytrust: advertised trust config is malformed: <list>[<index>]: an identity entry must set identity or identity_regexp (registrytrust: la configuración de confianza anunciada está malformada: en la lista y el índice indicados, una entrada de identidad debe establecer identity o identity_regexp)
y una sin emisor:
registrytrust: advertised trust config is malformed: <list>[<index>]: an identity entry must set issuer (registrytrust: la configuración de confianza anunciada está malformada: en la lista y el índice indicados, una entrada de identidad debe establecer issuer)
Cada uno va enmarcado por el comando que lo encontró:
Cómo corregirlo: la corrección corresponde a quien opera el registro, no a ti — cítale el mensaje, ya que nombra la entrada exacta y lo que le falta. Para continuar mientras tanto, añade el registro sin fijar la política que anuncia y aporta tú mismo las identidades o la clave; el comando las acepta directamente, que es también lo que haces para un registro que no publica ninguna política.
A registry publishes no trust document (Un registro no publica ningún documento de confianza)
Un resultado ordinario y esperado, no un fallo, y no detiene nada. Un registro puede publicar las identidades de firma que espera, y la mayoría no lo hace. Cuando se le pide uno, un registro así responde que no lo tiene, y la adición del registro continúa — el resultado se informa como una notificación y las identidades se fijan a mano en su lugar.
Es deliberadamente distinto de un registro al que no se pudo llegar. Este respondió; la respuesta fue que no publica ninguna política. Mantener los dos separados es lo que permite tolerar una ausencia deliberada mientras un problema de accesibilidad sigue siendo visible como tal.
Se informa como una notificación, que nombra el registro, lo que respondió y qué hacer en su lugar:
Notice: <host> publishes no trust policy (HTTP 404); pin its trust by hand with —identity or —key (Notificación: el host indicado no publica ninguna política de confianza (HTTP 404); fija su confianza a mano con —identity o —key)
La condición bajo la que se recoge es registrytrust: registry advertises no trust config.
El hub oficial es la excepción: lleva una línea base integrada, así que donde no publica ningún documento se fija en su lugar esa línea base, y la notificación dice lo que respondió el hub y que se usa la línea base en su lugar, sin pedirte que fijes identidades.
Cómo corregirlo: no hay nada roto. Si quieres que se comprueben las firmas de este registro, aporta la identidad o la clave al añadirlo, exactamente como dice la notificación — es el camino normal para un registro que no publica ninguna política. Si no, el registro se añade sin una postura de firma y los artefactos que proceden de él se verifican solo cuando llevan una firma.
A registry is added offline with no trust policy to pin (Un registro se añade sin conexión sin una política de confianza que fijar)
Un rechazo al añadir un registro, no en una compilación. Añadir un registro es el único momento en que se fija su confianza: las identidades de firma que anuncia se obtienen una vez y cada pull posterior verifica contra esa copia fijada. Cuando el espacio de trabajo está sin conexión, esa obtención no puede hacerse, así que nunca se consulta al registro. En lugar de escribir una entrada que no confía en nada — y a la que cada pull posterior sometería al registro —, se rechaza añadir un registro distinto del hub oficial a menos que proporciones tú mismo la política.
Tres casos no se rechazan. Proporcionar identidades o una clave registra exactamente esas y no hace ninguna obtención, así que funciona igual sin conexión que con conexión. El hub oficial se añade sobre su línea base integrada, que lleva consigo tanto si la obtención se hace como si no. Y pedir que no haya obtención — --fetch-trust=false — registra la entrada a partir de los flags, exactamente como lo hace con conexión.
Se encuentra dondequiera que se añada un registro: aggrega registry add, aggrega config init --registry <host>, las solicitudes aggrega/registryAdd y aggrega/configInit de aggrega serve, cuyo mensaje de error lleva el código corto delante de la frase, y las herramientas de registro de aggrega mcp, que ejecutan esos comandos. Inicializar una configuración no admite identidades ni clave, así que sin conexión solo puede inicializar el hub; añade cualquier otro registro con aggrega registry add en su lugar.
Mensaje emitido, que es la propia frase de la condición:
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 registro distinto del hub oficial no se registra sin conexión sin una política de confianza proporcionada a mano, porque la política que anuncia no puede obtenerse; regístralo una vez mientras tengas conexión, o fija su confianza a mano con una identidad y su emisor o con un archivo de clave pública)
enmarcado por el comando que lo encontró y el registro que nombra:
aggrega registry add: <host>: <the message above> (aggrega registry add: el host indicado y luego el mensaje anterior)
Cómo corregirlo: da de alta el registro una vez mientras el espacio de trabajo tiene conexión — pasa --offline=false para esa única ejecución, o borra el ajuste offline — para que su política anunciada se obtenga y se fije; después no hay que repetir nada, ya que los pulls posteriores verifican contra la copia fijada. Donde no puedas conectarte, proporciona la política a mano: una o más entradas --identity <identity>=<issuer> para un registro sin clave, o --key apuntando a su archivo de clave pública para uno con clave, que es lo que habrías fijado a partir de su anuncio.
A tag is already published with different content (Un tag ya está publicado con un contenido distinto)
Un rechazo al publicar, no en una compilación. Los bytes publicados están congelados: antes de subir nada, se busca la versión de destino y el digest al que apunta se compara con el digest que produciría el contenido que se tiene a mano. Una versión que ya apunta a un contenido distinto se rechaza.
Volver a publicar un contenido idéntico byte a byte no es un conflicto. Los digests coinciden, no se sube nada y el comando informa de que la versión ya está publicada — así que volver a ejecutar una publicación que tuvo éxito en parte es seguro, y completa la publicación: la fecha de publicación que aún le falta a la versión, y su firma donde el push firma, se adjuntan, y una versión a la que no le falta ninguna de las dos no recibe nada, como describe Completar una publicación que un push anterior dejó parcial.
No hay ningún flag que anule esto. El contenido modificado se publica con una versión nueva, que es lo que deja a los consumidores una versión a la que pasar deliberadamente en lugar de una versión que cambió sin que se dieran cuenta.
Mensajes emitidos, que nombran la versión, el digest que contiene y el digest ofrecido. Al publicar una entidad del catálogo, que también nombra la comprobación que verifica el incremento de versión:
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 versión indicada ya está publicada con el digest existente indicado; se rechaza sobrescribirla con el digest propuesto — publica una versión nueva (aggrega lint —pre-publish verifica el incremento): oci: tag ya publicado con un contenido distinto)
y al publicar un artefacto de datos:
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 versión indicada ya está publicada con el digest existente indicado; se rechaza sobrescribirla con el digest propuesto — publica una versión nueva: oci: tag ya publicado con un contenido distinto)
Cómo corregirlo: sube la versión y publica de nuevo. Para una entidad del catálogo eso significa metadata.version y el directorio por versión en el que está la entidad, que cambian juntos. Antes de hacerlo, comprueba que el cambio es uno que pretendías: que los dos digests difieran en una versión que crees no haber tocado significa que el contenido en disco no es el contenido que se publicó, y averiguar por qué vale más que publicar encima. La comprobación previa a la publicación nombrada en el mensaje compara una versión con la anterior y es la forma de confirmar que el incremento es correcto.
An entity shares its directory with another entity (Una entidad comparte su directorio con otra entidad)
Un rechazo al fijar y al publicar, no en una compilación. Cada tipo de entidad tiene un directorio propio, salvo los tres que una raíz del espacio de trabajo contiene uno junto a otro: un Aggregate, una Release y un Manifest. Una entidad publicada es un artefacto en una coordenada por cada versión, y el directorio en el que se escribe lo refleja — el paso de fijación escribe el único archivo entity.lock para el que un directorio tiene espacio, y una publicación empaqueta la entidad desde su directorio. Así que una entidad de cualquier otro tipo con otra entidad a su lado se rechaza en esos dos momentos: por aggrega pin, por un pull o un push al que se pide fijar en nombre del autor, y por aggrega push, fije o no. Se rechaza antes de obtener nada, y no se escribe nada.
Un directorio que contiene varias entidades sigue cargándose, pasando el lint, validándose y compilándose. La disposición solo se juzga cuando algo se produce a partir del directorio, que es también el momento en que el mensaje puede nombrar la entidad que estorba. Un pull que no fija no escribe nada junto a la entidad y no se rechaza.
Lo que cuenta como entidad a su lado es cualquier otro documento YAML directamente en el mismo directorio cuyo kind: sea un tipo de entidad. Los archivos propios de un chart, un fragmento de compose, un manifiesto de Kubernetes o un README no son entidades, y un subdirectorio — un chart local, un árbol source/ — no está junto a la entidad, contenga lo que contenga. Solo se leen el tipo y el nombre de cada vecino, así que nada de lo que declare un vecino puede cambiar la respuesta.
El nombre del directorio no se juzga. Una entidad sola en su directorio se fija y se publica en la versión que declara, esté donde esté ese directorio; la disposición <name>/<version>/ que usa el catálogo de la biblioteca estándar es una convención y no una comprobación.
Mensaje emitido, que nombra la entidad, cada entidad a su lado y los archivos que hay que mover:
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 (la entidad comparte su directorio con otra entidad, y una entidad de su tipo tiene un directorio propio (la Recipe indicada y, a su lado, la Recipe indicada en el archivo indicado). remedio: da a cada entidad un directorio propio — mueve el archivo indicado a un directorio propio, junto con cualquier archivo que solo esa entidad lea; solo los tipos Aggregate, Manifest y Release pueden compartir un directorio con otras entidades)
Cómo corregirlo: mueve cada entidad que nombra el mensaje a un directorio propio, llevándote los archivos que solo ella lee — un chart local, un archivo importado y el archivo entity.lock si registra las fijaciones de esa entidad — y ejecuta aggrega pin en cada una que lea un origen remoto o importe un archivo, para que cada lock registre su propia entidad. Disponer cada una como <kind>/<provider-or-publisher>/…/<name>/<version>/ la mantiene donde el catálogo de la biblioteca estándar guarda cada entidad. Un directorio de catálogo se encuentra recorriéndolo, así que una compilación sobre el catálogo renderiza la misma salida después del traslado.
An entity kind has no artifact media type (Un tipo de entidad no tiene tipo de medio de artefacto)
Un rechazo al publicar, no en una compilación. Cada tipo de entidad publicable tiene un tipo de medio para cada una de las dos formas que adopta su artefacto — su documento solo, o un archivo comprimido del documento y de los archivos que declara — y empaquetar una entidad lo busca por tipo. Esta condición informa de un tipo sin entrada.
Ninguna compilación lo alcanza. El único otro lugar donde se ejecuta la misma búsqueda trata una entrada que falta como «esto no es una biblioteca» y continúa, así que la condición nunca aflora allí.
Mensaje emitido, la frase propia de la condición enmarcada por el comando y el archivo que estaba empaquetando:
aggrega push: bundle <path>: oci: unknown entity kind for mediatype dispatch (aggrega push: bundle en la ruta indicada: oci: tipo de entidad desconocido para la selección del tipo de medio)
Cómo corregirlo: compara el campo kind: del archivo que estás publicando con los tipos que imprime aggrega push --list-kinds — un tipo mal escrito o no admitido se informa aquí, y corregir el campo es todo el remedio. Donde el tipo es uno que esa lista incluye, se trata de una carencia de la cadena de herramientas y no de tu entidad, y vale la pena informar de ella citando el tipo.
A published archive carries an entry Windows cannot use (Un archivo comprimido publicado lleva una entrada que Windows no puede usar)
Un aviso que se genera cuando se publica una entidad; nunca detiene nada, y una compilación no lo genera. Una entidad que lleva archivos junto a su documento se publica como archivo comprimido, y cada nombre que contiene el archivo comprimido — el propio nombre de archivo del documento de la entidad y luego cada archivo que lleva — se juzga con la regla que la detención «A name the operation writes holds a part Windows cannot hold (Un nombre que la operación escribe contiene una parte que Windows no puede contener)» descrita más arriba aplica en Windows: una parte que Windows reserva para un dispositivo, con cualquier combinación de mayúsculas y minúsculas y sea cual sea la extensión que la siga, o una parte que termina en un punto o un espacio. Así, aux/x.yaml lo provoca por su directorio aux, report. por su punto final, y un documento llamado con.yaml que importa un archivo de esquema, por su propio nombre. Una entidad que no lleva nada se publica como su documento solo, dispuesto bajo un nombre que elige el producto, y un Plugin no publica ningún archivo comprimido, así que ninguno de los dos lo provoca.
Se genera en todas las plataformas y no rechaza nada. Un espacio de trabajo en Windows se niega a desplegar una entrada así, bajo esa detención, así que no puede usar la versión; el aviso es la forma en que quien publica se entera de ello antes de que lo haga alguien en Windows. La publicación, o su ejecución de prueba, sigue adelante o se detiene exactamente como lo haría sin él.
Cada superficie que publica una entidad lo genera, cada una a su manera.aggrega push, y su --dry-run, imprime una línea por entrada en la salida de error estándar, cada una empezando por warning: . La herramienta publish-entity del asistente responde con las entradas como windows_unusable_entries, y el texto de la respuesta también las nombra. aggrega serve responde a aggrega/publishEntity con ellas como windowsUnusableEntries, y pasa las propias líneas de advertencia a una solicitud que pidió que se le informara. Cada respuesta omite el campo donde no hay ninguna entrada así.
Su mensaje empieza así:
an entry this publication carries cannot be used on Windows (una entrada que lleva esta publicación no puede usarse en Windows)
y continúa con la entrada y la primera de sus partes que Windows no puede contener, y después el remedio. Se explica en «A published archive carries an entry Windows cannot use (Un archivo comprimido publicado lleva una entrada que Windows no puede usar)» en warnings.md.
Cómo corregirlo: cambia el nombre de la parte que nombra el mensaje, en disco y dondequiera que las declaraciones de la entidad nombren el archivo, y publica de nuevo. Donde la versión no está pensada para usarse en Windows, no hay que cambiar nada.
Two catalog identities publish to one repository location (Dos identidades del catálogo publican en una misma ubicación de repositorio)
Un rechazo al comprobar un catálogo completo, no en una compilación. El lugar donde se publica una entidad se deriva de su identidad y se pasa a minúsculas, así que dos identidades que solo difieren en mayúsculas y minúsculas acaban en el mismo lugar. Publicar ambas dejaría los bytes de una entidad sobrescritos por los de la otra, y nada en ninguna de las dos entidades lo diría.
La comprobación se ejecuta sobre todo el catálogo a la vez, porque una colisión es una propiedad de un par y no de cada entidad por separado — ninguna está mal por sí misma, y leer cualquiera de ellas aisladamente no muestra nada.
Mensaje emitido. Lo abre el marco de la comprobación del catálogo, luego la frase propia de la condición y luego cada grupo en colisión, cada uno con la ubicación compartida y las identidades que llegan a ella:
catalog validation failed: oci: distinct catalog identities map to the same OCI repository location: (la validación del catálogo falló: oci: identidades de catálogo distintas corresponden a la misma ubicación de repositorio OCI)
<location> <- <identity>, <identity>
Cómo corregirlo: cambia el nombre de una de las entidades que nombra el mensaje, en su metadata.name y en el directorio que lo refleja. Cuál renombrar lo eliges tú; los pares que solo difieren en mayúsculas y minúsculas son la forma habitual, y elegir una grafía y usarla de forma coherente es lo que impide que el par se repita. Renombrar es un cambio real de la identidad de una entidad, así que todo lo que se refiere al nombre antiguo tiene que cambiar con él — es un motivo para resolver la colisión antes de que se publique cualquiera de los dos nombres y no después.
Keyless signing was asked for without the services it needs (Se pidió la firma sin clave sin los servicios que necesita)
Un rechazo al firmar durante la publicación, no en una compilación. La firma sin clave no tiene una forma sin conexión: obtiene una identidad, hace que se emita para ella un certificado de corta duración, registra la firma donde pueda comprobarse más tarde y luego descarta la clave. Cada uno de esos pasos es un intercambio con un servicio en ejecución. Esta condición informa de que la identidad de la que parte el flujo no estaba disponible, así que el flujo se rechaza en lugar de iniciarse y abandonarse a medias.
Dos formas la informan: nada configurado para proporcionar una identidad, y algo configurado que no produjo nada.
Un espacio de trabajo sin conexión lo informa de otro modo, bajo el rechazo que cubre cada paso de red, porque el rechazo ocurre antes de que llegue a pedirse una identidad.
Mensajes emitidos. Ningún origen de identidad:
signing: keyless signing requires a live identity provider, Fulcio, and Rekor: an identity token source is required (signing: la firma sin clave requiere un proveedor de identidad activo, Fulcio y Rekor: se requiere un origen de tokens de identidad)
y un origen que no produjo nada:
signing: keyless signing requires a live identity provider, Fulcio, and Rekor: an identity token is required (signing: la firma sin clave requiere un proveedor de identidad activo, Fulcio y Rekor: se requiere un token de identidad)
Cómo corregirlo: la corrección es del operador, en cómo se ejecuta la publicación. En un pipeline automatizado la identidad procede de las propias credenciales del pipeline, así que esto suele significar que al job no se le concedió el permiso que las emite. En una ejecución interactiva, la identidad procede del inicio de sesión, que el comando te pedirá. Donde no quieras ninguna identidad activa, firma en su lugar con una clave propia — esa vía no necesita ninguno de estos servicios, y es la que hay que usar desde un entorno que no puede alcanzarlos.
An unsigned publish targets a registry or a policy that requires a signature (Una publicación sin firmar se dirige a un registro o a una política que exige una firma)
Un rechazo al publicar, no en una compilación. Donde se exige una firma, el contenido sin firmar no se publica. La comprobación se ejecuta antes de subir ningún byte, así que nada parcial llega al registro.
Dos condiciones, porque un requisito tiene dos orígenes y los remedios difieren. Uno es la postura propia del registro de destino, que se aplica a todo lo que se publica en él. El otro es la política de firma del espacio de trabajo, que cubre un conjunto de tipos de artefacto dondequiera que se publiquen. Cuando se cumplen ambos, se informa el del registro, porque nombrar el destino es lo más útil de los dos.
Aquí no hay ningún flag que publique contenido sin firmar. Desactivar la firma explícitamente no relaja el rechazo — solo cambia el valor predeterminado para los artefactos en los que la firma es opcional.
La firma se produce antes de la subida y no después, así que un fallo de firma también acaba aquí y no se publica nada.
Mensajes emitidos. El requisito propio del registro:
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: el registro indicado exige firmas; vuelve a ejecutar firmando el artefacto (aquí no hay ningún flag para hacer push de contenido sin firmar): signing: el registro exige firmas; se rechaza hacer push de contenido sin firmar)
el de la política del espacio de trabajo, que nombra el tipo que hizo entrar el artefacto en su ámbito:
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 política de firma exige una firma para el tipo indicado; vuelve a ejecutar firmando el artefacto (aquí no hay ningún flag para hacer push de contenido sin firmar): signing: la política de firma exige una firma para este tipo de artefacto; se rechaza hacer push de contenido sin firmar)
y una firma que no pudo producirse, que se informa bajo la condición del registro y cita el fallo subyacente:
aggrega push: sign <reference>:<version>: <the underlying failure>: signing: registry requires signatures; refusing to push unsigned content (aggrega push: firma de la versión indicada: el fallo subyacente indicado: signing: el registro exige firmas; se rechaza hacer push de contenido sin firmar)
Una forma de fallo de firma se nombra específicamente, porque un rechazo genérico lleva a la gente a volver a obtener una credencial que no puede ayudar:
aggrega push: sign <reference>:<version>: the identity token carries no verified email or subject claim — the OIDC flow/client did not return an email-scoped identity (re-exporting or re-acquiring the token will not help); configure the identity provider/client/scope to return one: <the underlying failure>: signing: registry requires signatures; refusing to push unsigned content (aggrega push: firma de la versión indicada: el token de identidad no lleva ningún claim de email o subject verificado — el flujo/cliente OIDC no devolvió una identidad con ámbito de email (volver a exportar o volver a obtener el token no ayudará); configura el proveedor de identidad/cliente/ámbito para que devuelva una: el fallo subyacente indicado: signing: el registro exige firmas; se rechaza hacer push de contenido sin firmar)
Cómo corregirlo: la corrección es del operador. Firma el artefacto y publica de nuevo — con una clave propia o con la vía sin clave, según para cuál esté configurado el espacio de trabajo. Donde no esperabas que se exigiera una firma, el mensaje dice qué origen la exigió: la postura propia de un registro está en la entrada de ese registro en .aggrega-config.yaml, y el requisito limitado a un tipo está en la política de firma de todo el espacio de trabajo. Relajar cualquiera de los dos es una decisión sobre lo que estás dispuesto a publicar sin firmar, así que acotar el ámbito de la política suele ser mejor que desactivarla.
References signed together need different signing credentials (Las referencias firmadas juntas necesitan credenciales de firma distintas)
Un rechazo al firmar, no en una compilación. aggrega sign con varias referencias, y aggrega deprecate --from con un archivo de lote, firman todo lo que reciben con una sola credencial: una única clave propia o una única identidad sin clave. Qué credencial necesita una referencia lo decide la configuración de su registro — un signing.key_path que se aplica a ese registro selecciona la clave que nombra, y donde no se aplica ninguno la referencia se firma sin clave. Cuando las referencias nombradas juntas necesitarían credenciales distintas — una clave para un registro y ninguna para otro, o dos claves distintas —, no se firma nada, y el mensaje nombra los registros de cada lado.
La comprobación se ejecuta antes de que se pida una identidad y antes de que se lea ningún registro, así que no se firma ni se adjunta nada y no se le pide nada a nadie para una ejecución que no va a seguir adelante. Una firma no puede retirarse de nadie que la haya obtenido, y por eso la ejecución se rechaza en lugar de firmarse con la credencial que necesite una de las referencias.
Una clave pasada con --key decide por cada referencia. Se aplica a cada referencia nombrada, diga lo que diga la configuración para cada registro, así que una ejecución así nunca se rechaza aquí.
Se encuentra dondequiera que se firme un lote: aggrega sign, aggrega deprecate --from, las solicitudes aggrega/signArtifacts y aggrega/deprecateArtifact de aggrega serve, cuyo mensaje de error lleva el código corto delante de la frase, y las herramientas sign-artifacts y deprecate-artifact de aggrega mcp. Una llamada a una herramienta que llega a un servidor a través de un listener nunca usa una clave que nombre la configuración, así que allí cada referencia se firma con la identidad que envía la llamada y la llamada no se rechaza aquí.
Mensaje emitido. Lo abre la frase propia de la condición, cada credencial sigue con los registros para los que firmaría, y el remedio va al final:
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: las referencias nombradas juntas necesitan credenciales de firma distintas, así que no se firmó nada (el registro indicado firma con la clave propia que nombra signing.key_path, el registro indicado firma sin clave: no se aplica ningún signing.key_path). remedio: fírmalas en ejecuciones separadas, una por credencial: las referencias del registro indicado y luego las referencias del registro indicado; cada ejecución firma como lo haría por sí sola)
y, cuando un registro del lote exige firmas, nombrándolo al final del remedio:
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: las referencias nombradas juntas necesitan credenciales de firma distintas, así que no se firmó nada (el registro indicado firma con la clave propia que nombra signing.key_path, el registro indicado firma sin clave: no se aplica ningún signing.key_path). remedio: fírmalas en ejecuciones separadas, una por credencial: las referencias del registro indicado y luego las referencias del registro indicado; cada ejecución firma como lo haría por sí sola, y el registro indicado exige firmas, así que este rechazo retiene una firma que de otro modo habría seguido adelante, y no una firma imposible de hacer)
Un segundo registro con una clave propia se nombra como firmante «with a different held key (con otra clave propia)». La ruta de una clave nunca se imprime: el mensaje nombra el ajuste, que es lo que puedes cambiar.
Cómo corregirlo: divide las referencias según la credencial que necesitan sus registros y ejecuta una vez por credencial — un aggrega sign que nombre las referencias de los registros firmados con una clave y otro que nombre el resto; para aggrega deprecate --from, un archivo de lote por credencial. Cada ejecución firma entonces como lo habría hecho por sí sola. Para firmar en cambio cada referencia con una sola clave en una única ejecución, pasa esa clave con --key.
A detached signature does not verify against the key supplied (Una firma separada no se verifica con la clave proporcionada)
El resultado negativo de comprobar una firma suelta sobre una carga útil frente a una clave pública, completamente sin conexión: la carga útil difiere de lo que se firmó, la firma se ha alterado o la clave no es la que la produjo.
Nada en la cadena de herramientas distribuida lo alcanza. La comprobación a la que pertenece no tiene ningún llamador fuera de sus propias pruebas, así que ningún comando que ejecute un usuario — compilación, pull o publicación — lo informa. Está catalogado aquí para que el código remita a algo, no porque una compilación pueda imprimirlo. La verificación que realmente hace un pull se hace sobre un bundle de firma completo y se informa por separado.
Mensaje emitido, que cita lo que informó el verificador:
signing: signature does not verify: <what the verifier reported> (signing: la firma no se verifica, seguido de lo que informó el verificador)
Cómo corregirlo: nada en tus archivos de entidad lo causa, y nada que puedas escribir en un catálogo o en un espacio de trabajo lo elimina. Si ejecutas la herramienta de línea de comandos publicada, esta no es una condición que puedas alcanzar, y un problema de firma que estés viendo realmente lo informa en su lugar una de las condiciones de verificación del bundle descritas más arriba. Si usas el paquete de firma directamente desde software propio, la carga útil, la firma y la clave tienen que ser las tres que van juntas — una carga útil reserializada entre la firma y la verificación es la causa habitual, ya que los bytes difieren aunque el contenido se lea igual.
A resolved artifact is not a documentation bundle (Un artefacto resuelto no es un bundle de documentación)
Una referencia que se resuelve en un artefacto de otro tipo — una entidad del catálogo, un plugin — se rechaza en lugar de guardarse en caché como documentación, de modo que una referencia mal dirigida falla donde se dirige y no más tarde como un bundle que no puede leerse.
Dónde surge. El bundle de documentación se adquiere en la caché que comparten todos los proyectos de la máquina, desde el registro configurado del espacio de trabajo bajo el espacio de nombres reservado docs: por el servidor orientado a asistentes una vez, al arrancar y antes de responder nada, por aggrega explain y por la explicación de un código en un editor la primera vez que cualquiera de los dos lo necesita, y por aggrega scaffold --example — en cada caso solo donde la máquina no tiene ninguna copia que admita la comprobación de firmas del espacio de trabajo. Esta es la comprobación que cada adquisición ejecuta sobre lo que volvió.
Nunca detiene una sesión. La adquisición informa de su resultado en el flujo de logs del servidor y la conexión continúa en cualquier caso; lo que cuesta un artefacto rechazado son los recursos de documentación, que entonces responden «no encontrado» en esa sesión. aggrega scaffold --example no tiene nada que escribir sin el bundle, así que allí es el rechazo del comando, y no se escribe nada.
Mensaje emitido, que nombra la referencia y ambos tipos de medio:
docscache: <reference>@<version> has media type "<what was found>", want "<what a documentation bundle is>": docscache: artifact is not a documentation bundle (docscache: la referencia indicada en la versión indicada tiene el tipo de medio encontrado, cuando se esperaba el de un bundle de documentación: docscache: el artefacto no es un bundle de documentación)
Cómo corregirlo: nada en tus archivos de entidad lo causa, y ningún cambio de autoría lo elimina. La referencia que usó la adquisición apunta a algo que no es un bundle de documentación — comprueba el registro configurado del espacio de trabajo, ya que la referencia del bundle se deriva de él, y una referencia bien formada que apunta a otro artefacto se resuelve correctamente y solo falla aquí.
A page is absent from a documentation bundle (Una página falta en un bundle de documentación)
Un bundle de documentación se guardó en caché y se verificó su contenido, y la página pedida — o, para aggrega scaffold --example, el directorio del ejemplo — no está en él. Es distinto de no tener ningún bundle: el bundle está presente y en buen estado, y la entrada falta en él.
No llega a ninguna compilación. La superficie que sirve páginas de documentación a un editor o a un asistente lo convierte en una respuesta ordinaria de «no encontrado» para el recurso solicitado. aggrega scaffold --example lo informa como un rechazo que nombra el ejemplo y el bundle, seguido de una indicación hacia aggrega scaffold --example --list, que imprime los ejemplos que el bundle sí contiene, y no escribe nada.
Vale la pena saber distinguir cuál de las dos respuestas de «no encontrado» recibes, aunque la superficie las presente igual. Esta significa que el bundle está en caché y en buen estado y que la página no está en él. La otra — ningún bundle que el espacio de trabajo pueda leer, porque no hay ninguno en caché o la única copia es una que rechaza la comprobación de firmas del espacio de trabajo — significa que la adquisición no se completó, y el flujo de logs del servidor dice por qué.
Mensaje emitido, que nombra la página y el bundle en el que se buscó:
page "<page>" in <reference>@<version>: docscache: page not found in documentation bundle (la página indicada en la referencia y la versión indicadas: docscache: página no encontrada en el bundle de documentación)
Cómo corregirlo: no hay nada roto en tus archivos. Una página que falta en el bundle falta porque el bundle es anterior a ella o porque la ruta pedida no es aquella bajo la que se publica — el bundle se adquiere en la versión que el servidor indica como propia, así que una página añadida después de esa versión no está en él. Donde la página nunca ha existido, la solicitud nombró una ruta que la documentación no usa, y la documentación publicada es donde encontrar la que sí usa.
An edit would produce a document its schema refuses (Una edición produciría un documento que su esquema rechaza)
Un rechazo en una edición de documento, no en una compilación. Una edición estructurada — añadir un componente, vincular una Feature, cablear una arista o establecer un valor — se compone y se inserta en el documento, y el resultado se comprueba después frente al esquema del tipo de documento que es. Donde esa comprobación pone objeciones, la edición se rechaza y no se escribe nada. Pertenece a aggrega edit-document, y a la misma capacidad a la que llega un editor a través de aggrega serve o un asistente, que son puntos de entrada ligeros a una única implementación.
El tipo se lee del documento, nunca lo proporciona quien llama. Un llamador que nombrara el tipo podría nombrar el equivocado, y el resultado se comprobaría entonces frente a un esquema según el cual el documento no está escrito — lo que admitiría exactamente la edición que esta comprobación existe para rechazar.
El archivo queda byte a byte como estaba, y la escritura es atómica, así que una edición rechazada no se distingue de una que nunca se intentó, y una solicitud corregida puede reintentarse sobre el documento con el que empezaste.
Su objeto es una solicitud bien formada. La solicitud nombraba una edición que esta capacidad aplica, y el documento que habría producido es uno que el esquema de autoría habría rechazado si lo hubieras escrito a mano — por eso no se repite para ella ninguna regla de autoría: pedir a una Release que lleve un valor del desarrollador lo rechaza el mismo esquema en ambos casos. Una solicitud que nunca apuntó a una edición — una ruta de nodo que no llega a nada en el documento, un valor escrito como mapping donde se requiere un escalar, una entrada ya presente que lleva otra cosa — se rechaza por sus propios motivos, y cada superficie lo informa en su propio canal.
Un documento que ya era inválido también lo informa. La comprobación se ejecuta incluso donde la edición no cambió nada, así que una edición sobre un documento que el producto se negaría a leer lo dice en lugar de informar de éxito.
La comprobación es la misma que aplica cada lectura del documento, así que también rechaza una Recipe o FeatureRecipe cuyo pipeline declara dos veces un mismo id de paso, una regla que ningún esquema puede expresar; la objeción tras la frase se abre entonces con la frase y el consejo propios de esa condición, como se describe en A pipeline declares one step id twice (Un pipeline declara dos veces un mismo id de paso).
Mensaje emitido, que lleva la objeción propia del esquema tras la frase — el tipo de documento y el archivo, luego la posición, la clave errónea y lo que el esquema dijo allí — y termina con el consejo:
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 edición se rechazó porque el documento resultante no sería válido, y no se escribió nada: la validación del envoltorio del documento falló (el tipo indicado, en la ruta indicada); la línea y la columna indicadas: la ruta del campo indicada: … seguido de la objeción propia del esquema. corrige el documento para que coincida con el esquema de su tipo)
Cómo corregirlo: abre el documento en la posición que cita el mensaje y lee la objeción, que dice qué quería el esquema en esa clave. El cambio que hay que hacer suele estar en la solicitud y no en el documento — pide una entrada que el esquema admita en ese lugar, y la misma solicitud se aplica limpiamente. Donde la clave es una que el tipo de ese documento no puede llevar en absoluto, pertenece a la superficie de autoría que sí puede, y la página de la entidad de ese tipo nombra los campos que declara. Lo que es semánticamente admisible no se decide en este punto — si un socket de dependencia es uno que el productor declara, por ejemplo —, así que este rechazo trata siempre de la forma del documento, nunca de lo que puede consumirse a través de una conexión.
An annotation key uses a prefix the platform reserves (Una clave de anotación usa un prefijo que la plataforma reserva)
Un rechazo al comprobar una entidad frente a las convenciones de publicación, no en una compilación. El prefijo aggrega.ai/, y feature.aggrega.ai/ fuera de una Feature, pertenecen a la plataforma: una clave escrita bajo uno de ellos lleva un significado que asigna la plataforma, así que una entidad tuya que escribe ahí reclama un espacio de nombres que no le pertenece.
Avisa mientras redactas y rechaza en el control de publicación, y ambas lecturas nombran esta misma condición. Lo que se encontró es lo mismo en ambos casos; solo cambia la consecuencia. Esa división es como se comporta la mayoría de las reglas de las convenciones de publicación catalogadas aquí, así que se enuncia una vez y se da por supuesta en las entradas siguientes que no digan lo contrario — las dos que comparan con una versión ya publicada lo dicen en sus propias entradas, porque esas no pueden ejecutarse en absoluto sobre contenido local.
Su mensaje empieza así:
an annotation key on the entity uses a prefix the platform reserves (una clave de anotación de la entidad usa un prefijo que la plataforma reserva)
Cómo corregirlo: mueve la clave bajo un prefijo que pertenezca a tu propia organización. Donde un espacio de trabajo tenga aun así un motivo para escribir bajo el prefijo reservado, esta regla es de las que tienen una opción de exclusión, descritas en «Las reglas de disciplina» en aggrega-lint.md.
An entity’s name does not follow the shape its kind expects (El nombre de una entidad no sigue la forma que espera su tipo)
Un rechazo al comprobar una entidad frente a las convenciones de publicación, no en una compilación. Cada tipo de entidad lleva una convención sobre la forma del nombre — el número de segmentos para los tipos cloud-native, PascalCase para los tipos de biblioteca — y el nombre que declara esta entidad no coincide con el que espera su tipo.
Su mensaje empieza así:
the entity’s name does not follow the documented name shape for its kind (el nombre de la entidad no sigue la forma de nombre documentada para su tipo)
Cómo corregirlo: cambia el nombre de la entidad a la forma que espera su tipo; las convenciones por tipo se enumeran en «Las reglas de disciplina» en aggrega-lint.md, junto con la opción de exclusión para un catálogo que nombra deliberadamente sus entidades a su manera.
A schema uses a dynamic reference that cannot be resolved ahead of time (Un esquema usa una referencia dinámica que no puede resolverse de antemano)
Un rechazo al comprobar una entidad frente a las convenciones de publicación, no en una compilación. Un esquema que lleva la entidad usa una construcción de referencia dinámica, cuyo destino se elige mientras se valida un documento en lugar de fijarse cuando se escribe el esquema. Aquí las referencias se expanden de antemano, así que no hay ninguna validación en curso contra la que pueda resolverse una construcción así.
Su mensaje empieza así:
a schema in the entity uses a dynamic reference construct that cross-document reference resolution cannot follow (un esquema de la entidad usa una construcción de referencia dinámica que la resolución de referencias entre documentos no puede seguir)
Cómo corregirlo: sustituye la construcción dinámica por una referencia simple que nombre directamente el destino. Donde el esquema realmente necesite la construcción y no vaya a referenciarse entre documentos, la regla tiene una opción de exclusión descrita en «Las reglas de disciplina» en aggrega-lint.md.
A schema declares an identifier the platform owns (Un esquema declara un identificador que pertenece a la plataforma)
Un rechazo al comprobar una entidad frente a las convenciones de publicación, no en una compilación. Un esquema que lleva la entidad declara un identificador propio, cuando el identificador canónico se deriva de la identidad de la entidad. El declarado desplaza al derivado, así que una referencia escrita contra el identificador canónico deja de resolverse.
Su mensaje empieza así:
a schema in the entity declares an identifier of its own, where the platform owns that schema’s identity (un esquema de la entidad declara un identificador propio, cuando la identidad de ese esquema pertenece a la plataforma)
Cómo corregirlo: elimina el identificador declarado y deja que se derive. La opción de exclusión, para un esquema publicado deliberadamente bajo un identificador propio, se describe en «Las reglas de disciplina» en aggrega-lint.md.
A Component’s category label and its directory name different categories (La etiqueta de categoría de un Component y su directorio nombran categorías distintas)
Un rechazo al comprobar una entidad frente a las convenciones de publicación, no en una compilación. Un Component lleva una etiqueta de categoría y está archivado bajo un directorio de categoría; la convención es que ambos nombren la misma categoría, para que el directorio que recorre un lector y la etiqueta con la que empareja un selector no puedan discrepar.
Su mensaje empieza así:
the entity’s category label does not match the category directory the entity is filed under (la etiqueta de categoría de la entidad no coincide con el directorio de categoría bajo el que está archivada la entidad)
Cómo corregirlo: cambia el que esté mal de los dos para que coincidan — mueve el archivo bajo el directorio que nombra su etiqueta, o corrige la etiqueta a la categoría que nombra el directorio. El conjunto cerrado de categorías, y la opción de exclusión, están en «Las reglas de disciplina» en aggrega-lint.md.
A schema extension is written directly into schema content (Una extensión de esquema se escribe directamente en el contenido del esquema)
Un rechazo al comprobar una entidad frente a las convenciones de publicación, no en una compilación. Un Component o una Feature escribe una extensión de esquema de Aggrega directamente en el contenido de su esquema, cuando la entidad dispone de una superficie de primera clase para declarar lo mismo. La forma escrita directamente funciona, y la convención prefiere la superficie declarada porque es la que enseñan las páginas de entidades y la que leen las herramientas.
Esta es la única regla del grupo que también informa una compilación, como aviso que no detiene la compilación. Comprobar la entidad frente a las convenciones de publicación en el control de publicación eleva el mismo hallazgo a rechazo.
Su mensaje empieza así:
the entity writes an Aggrega schema extension directly into schema content instead of declaring it under usesSchema or featuresSchema (la entidad escribe una extensión de esquema de Aggrega directamente en el contenido del esquema en lugar de declararla en el esquema de sockets o en el esquema de vinculaciones)
Cómo corregirlo: mueve la extensión a la superficie de sockets o de vinculaciones propia de la entidad, que es donde la declaran las páginas de entidades de component.md y feature.md. La opción de exclusión está en «Las reglas de disciplina» en aggrega-lint.md.
A Plugin pins neither runtime cap, so the platform’s own apply (Un Plugin no fija ninguno de los dos límites de ejecución, así que se aplican los de la plataforma)
Un aviso que se genera cuando se comprueba una entidad frente a las convenciones de publicación, tanto mientras redactas como en el control de publicación; nunca detiene nada, y una compilación no lo genera. Un Plugin declara el techo de memoria y el límite de tiempo que el host aplica cuando carga y ejecuta el plugin. Uno que no declara ninguno de los dos se ejecuta con los valores predeterminados de la plataforma, lo cual es un resultado admitido y no un error — así que lo que esto informa es que los valores predeterminados están en vigor y que es posible fijarlos explícitamente.
Su mensaje empieza así:
the Plugin entity declares no runtime resource cap of its own, so the platform defaults apply (la entidad Plugin no declara ningún límite de recursos de ejecución propio, así que se aplican los valores predeterminados de la plataforma)
Cómo corregirlo: fija los límites que el plugin realmente necesita, o deja deliberadamente los valores predeterminados en su lugar. No tiene ningún ajuste de exclusión, y el motivo es que informa de un hecho sobre la entidad y no de un juicio sobre ella: no hay nada que relajar. Los campos se describen en plugin.md.
An attachment slot admits only secret material without saying it handles it (Un slot de vinculación admite solo material secreto sin decir que lo maneja)
Un aviso que se genera cuando se comprueba una entidad frente a las convenciones de publicación, tanto mientras redactas como en el control de publicación; nunca detiene nada, y una compilación no lo genera. Un slot de vinculación puede fijar, mediante su selector, que solo una Feature que lleve secretos pueda llenarlo, y puede dejar constancia por separado de que lo que lo llene maneja material secreto. El selector establece qué rellenos son admisibles; la constancia establece el manejo. Un slot que fija lo primero y omite lo segundo deja que el manejo se deduzca del selector en lugar de leerse en el slot. Se comprueba cada slot que declara una entidad: los de su propio bloque de vinculaciones y, en un Component, los que un socket de dependencia declara para cada conexión cableada a través de él — el hallazgo sobre el slot de un socket nombra el socket junto al slot.
Su mensaje empieza así:
an attachment slot admits only secret material and does not declare that it handles it (un slot de vinculación admite solo material secreto y no declara que lo maneja)
Cómo corregirlo: declara el manejo en el slot, junto al selector que fija lo que admite. No tiene ningún ajuste de exclusión, por el mismo motivo por el que no lo tiene la regla de los límites del Plugin: informa de un hecho sobre la entidad y deja la decisión en tus manos.
A Recipe publishes a provides key its Component does not declare, checked at publication (Una Recipe publica una clave que su Component no declara, con comprobación al publicar)
Un aviso que se genera cuando se comprueba una entidad frente a las convenciones de publicación, tanto mientras redactas como en el control de publicación; nunca detiene nada, y una compilación no lo genera. Una Recipe publica una clave bajo provides:, y el Component que implementa la Recipe no declara esa clave en el pilar provides de su esquema. Un consumidor que cablea a través de una conexión lee el contrato declarado del Component y no lo que emita la Recipe, así que la clave se produce y luego se rechaza donde algo intenta consumirla.
🔴 Dos condiciones describen esto, y no son la misma. El aviso que informa una compilación está documentado más arriba en «A Recipe publishes a provides key its Component does not declare (Una Recipe publica una clave que su Component no declara)»; esta se genera cuando la entidad se comprueba frente a las convenciones de publicación, y lleva su propio código. El hallazgo es el mismo hecho encontrado en dos superficies — lee el código del diagnóstico para saber cuál tienes en la mano.
Su mensaje empieza así:
the Recipe publishes a provides key the Component it implements does not declare, so a consumer wiring that key is refused (la Recipe publica una clave provides que el Component que implementa no declara, así que un consumidor que cablea esa clave se rechaza)
Cómo corregirlo: declara la clave en el Component, para que el contrato que lee un consumidor incluya lo que emite la Recipe — o deja de publicarla desde la Recipe donde nada vaya a consumirla. La opción de exclusión está en «Las reglas de disciplina» en aggrega-lint.md.
A Component’s metrics annotation and its provides key disagree (La anotación de métricas de un Component y su clave provides discrepan)
Un aviso que se genera cuando se comprueba una entidad frente a las convenciones de publicación, tanto mientras redactas como en el control de publicación; nunca detiene nada, y una compilación no lo genera. Un Component puede indicar cómo se autentican las métricas de su producto, en su anotación observability.aggrega.ai/metrics-credential — none, target-key o separate-token — y puede declarar la clave provides metrics_credential_required, que cada una de sus Recipes publica para decir si las métricas de una instancia necesitan una credencial. Ambas son un único hecho sobre el producto visto desde dos lados, así que un Component que indica que sus métricas no requieren credencial no declara ninguna clave así, y uno que indica que requieren una credencial la declara. Esta condición informa de un Component en el que ambas discrepan, nombrando el Component, el valor de la anotación y la clave que sobra o falta.
Su mensaje empieza así:
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 (la anotación de un Component que indica cómo se autentican sus métricas discrepa de si declara o no la clave provides que dice que las métricas de una instancia necesitan una credencial)
Cómo corregirlo: corrige el que esté mal de los dos — declara metrics_credential_required en el pilar provides, y publícala desde cada Recipe, donde las métricas requieran una credencial; elimínala donde no requieran ninguna; o cambia la anotación al valor que describe el producto. No tiene ningún ajuste de exclusión, por el mismo motivo por el que no lo tiene la regla de los límites del Plugin; qué valores lee, y qué Components deja sin leer, está en «Las reglas de disciplina» en aggrega-lint.md.
A connection and the target it reaches do not name one key (Una conexión y el destino al que llega no nombran una misma clave)
Un aviso que se genera cuando se comprueba una Release frente a las convenciones de publicación; nunca detiene nada, y una compilación no lo genera. Un servidor que comprueba una clave guarda la clave que verifica en un slot propio, y un llamante presenta una clave en la conexión a través de la cual llega a ese servidor. Ninguno de los dos extremos ve la del otro, así que ambas son una sola clave solo porque sus autores escriben el mismo localizador en ambos extremos. Esta condición informa de una conexión cuyo destino declara el slot para la clave que exige a sus llamantes, en los casos en que no son una misma clave: la conexión lleva una credencial y el slot de clave del destino no está lleno, el slot de clave del destino está lleno y la conexión no lleva ninguna credencial, o ambos están llenos y los dos escriben sus localizadores de forma distinta.
A diferencia de las reglas anteriores, esta lee una Release completa y no una sola entidad, así que solo se encuentra cuando se comprueba una Release y nunca en el control de publicación, que comprueba una sola entidad por separado; dondequiera que se informe, es un consejo. El hallazgo nombra el componente, la conexión, el destino y los dos slots, y nunca cita ninguno de los dos localizadores. Un scrape — una conexión en el socket scrape_target — se juzga por lo que su destino indica sobre sus métricas: en absoluto donde la anotación observability.aggrega.ai/metrics-credential del destino dice none, nunca frente a la clave del destino donde dice separate-token, y como cualquier otra conexión en los demás casos; una conexión en cualquier otro socket se juzga indique lo que indique el destino.
Su mensaje empieza así:
a connection and the target it reaches do not name one key: they write different locators for it, or only one of them names one (una conexión y el destino al que llega no nombran una misma clave: escriben localizadores distintos para ella, o solo uno de los dos nombra una)
Cómo corregirlo: haz que ambos extremos lean un único parámetro — el campo credential de la conexión y el campo api_key del destino — para que la clave que presenta el llamante y la clave que verifica el servidor no puedan escribirse por separado; o, donde una conexión no deba presentar ninguna clave, quítale la credencial. Qué slots se leen, qué se compara y la opción de exclusión están en «Las reglas de disciplina» en aggrega-lint.md.
The change being published breaks what the evolution rubric allows (El cambio que se publica incumple lo que permite la rúbrica de evolución)
Un rechazo en la comprobación que precede a la publicación, no en una compilación. La versión que se publica se compara con la versión ya publicada antes que ella, y la diferencia entre ambas se clasifica según una rúbrica documentada. Esta condición informa de que la diferencia es una a la que la rúbrica pone objeciones.
Necesita un predecesor publicado con el que compararse, así que ella y la comprobación del incremento de versión de más abajo son las dos reglas de este grupo que no pueden ejecutarse solo sobre contenido local: sin consultar ningún registro no hay nada que comparar, y la comprobación se omite en lugar de darse por superada.
Su mensaje empieza así:
the version being published changes the published predecessor in a way the documented evolution rubric objects to (la versión que se publica cambia el predecesor publicado de una forma a la que la rúbrica de evolución documentada pone objeciones)
Cómo corregirlo: lee la clasificación en el diagnóstico, que nombra qué del cambio motivó la objeción de la rúbrica, y haz el cambio compatible o publícalo con una versión que lo admita. La rúbrica se expone en «La rúbrica del incremento de versión» en aggrega-lint.md.
The version offered is a smaller bump than the change requires (La versión ofrecida es un incremento menor del que requiere el cambio)
Un rechazo en la comprobación que precede a la publicación, no en una compilación. El cambio que se publica se clasifica según la rúbrica de evolución, y la versión ofrecida para él es un paso menor del que exige esa clasificación — una eliminación o una restricción ofrecida como patch, por ejemplo. Un incremento excesivo siempre se acepta; es un incremento insuficiente lo que se detiene aquí.
A diferencia de las reglas anteriores, esta se decide aquí y no en el plugin de convenciones. Qué incremento se ofreció solo se sabe en el momento de la publicación, y entonces no hay ninguna compilación en curso, así que la comparación entre la clasificación y la versión ofrecida se hace en ese punto.
Su mensaje empieza así:
the version bump being published is smaller than the evolution check’s classification of the change requires (el incremento de versión que se publica es menor de lo que requiere la clasificación del cambio hecha por la comprobación de evolución)
Cómo corregirlo: publica con la versión que exige la clasificación; el diagnóstico nombra cuál es. Donde creas que el cambio es menor de lo que indica su clasificación, la rúbrica de «La rúbrica del incremento de versión» en aggrega-lint.md dice qué sitúa un cambio en cada clase. La primera publicación de una entidad no tiene predecesor, así que la comparación se omite y se informa como no realizada en lugar de superada.
An import stopped partway through translating a source (Una importación se detuvo a mitad de la traducción de una fuente)
Un rechazo al convertir una descripción de fuente externa en borradores de archivos de autoría, no en una compilación. El importer informó de un diagnóstico lo bastante grave como para detener la traducción, así que lo que produjo es parcial: parte de la fuente se convirtió en borradores de archivos de autoría y parte no.
El resultado parcial es deliberado, no un despojo. Nombra el desenlace y no la causa — lo que no se pudo traducir se informa en los diagnósticos que lo acompañan, uno por cada construcción que el importer no pudo trasladar, con las propias palabras del importer. Esta condición es lo que permite a un llamador distinguir «la importación se detuvo y produjo parte de una respuesta» de «la importación falló por completo», que son situaciones distintas con pasos siguientes distintos.
Su mensaje empieza así:
the importer reported a diagnostic that stops the import, so the source was not fully turned into draft authoring files (el importer informó de un diagnóstico que detiene la importación, así que la fuente no se convirtió por completo en borradores de archivos de autoría)
Cómo corregirlo: lee los diagnósticos que se informan junto a ella — cada uno nombra una construcción de la fuente que el importer no pudo traducir. La corrección está en la fuente que entregaste, o en terminar el borrador a mano: una importación produce un punto de partida para editar, así que una construcción que no sobrevivió a la traducción hay que escribirla directamente del lado de Aggrega. aggrega-import.md describe lo que produce el comando y dónde escribe.
More than one importer recognises the source (Más de un importer reconoce la fuente)
Un rechazo al convertir una descripción de fuente externa en borradores de archivos de autoría, no en una compilación. La importación no nombró ningún formato, así que el formato se reconoció a partir de las firmas que declaran los importers — tanto los del catálogo del espacio de trabajo como los importers básicos del compilador, cada uno de los cuales nombra la sintaxis en la que se lee una fuente, los nombres de archivo a los que se aplica y las rutas que su árbol analizado debe o no debe contener — y coincidieron con la fuente firmas de importers que sirven más de un formato. La importación no elige entre ellos: en qué formato está una fuente es una afirmación de los importers, no del compilador, y elegir sería una conjetura que entregaría la fuente a un importer al que quizá no está destinada.
Esto no es lo mismo que un único formato anunciado por más de un importer, descrito en «A parse or import format is advertised by more than one plugin (Un formato de análisis o de importación lo anuncia más de un plugin)» más arriba. Allí el formato está decidido y los importers que lo sirven compiten, así que una entrada plugins.importer elige entre ellos; aquí son los propios formatos los que difieren, así que ninguna vinculación lo resuelve y sí lo resuelve nombrar el formato. Un importer que reconoce una fuente la reconoce como cada formato que anuncia, así que un importer que anuncia más de un formato, una de cuyas firmas coincide, también se rechaza aquí.
Su mensaje empieza así:
more than one importer recognises the source (más de un importer reconoce la fuente)
El resto del mensaje nombra la fuente y cada formato como el que se reconoció, en el orden de las identidades y versiones de los importers, y después el remedio:
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>) (más de un importer reconoce la fuente (fuente indicada, reconocida como los formatos indicados). Pasa —format para nombrar el formato con el que leerla (por ejemplo —format seguido de uno de los formatos))
Cómo corregirlo: nombra el formato — --format en aggrega import, o format en la herramienta de importación del asistente y en el método aggrega/import de la sesión. Donde uno de los importers no debería reconocer nunca una fuente así, el cambio corresponde a las firmas de ese importer, que su autor declara en su autoinforme describe() y que su entidad Plugin registra cuando se genera; o, donde sea uno que contiene el catálogo del espacio de trabajo, déjalo fuera del catálogo que lee el espacio de trabajo — un importer básico siempre está entre los que se prueban, así que una fuente que uno de ellos reconoce junto con otro importer se resuelve nombrando el formato. aggrega-import.md describe cómo se reconoce un formato.
No importer recognises the source (Ningún importer reconoce la fuente)
Un rechazo al convertir una descripción de fuente externa en borradores de archivos de autoría, no en una compilación. La importación no nombró ningún formato, así que el formato se reconoció a partir de las firmas que declaran los importers — tanto los del catálogo del espacio de trabajo como los importers básicos del compilador — y las firmas de ningún formato coincidieron con la fuente. La importación no adivina: entregar la fuente a un importer que nunca declaró que lee esa forma generaría un borrador a partir de una fuente a la que quizá no está destinado.
Es la contrapartida de «More than one importer recognises the source (Más de un importer reconoce la fuente)» más arriba. Allí varios formatos reclaman la fuente; aquí ninguno lo hace. En ambos casos, nombrar el formato lo resuelve, y no se escribe nada hasta que se nombra.
Su mensaje empieza así:
no importer recognises the source (ningún importer reconoce la fuente)
El resto del mensaje nombra la fuente, después el remedio y cada formato que anuncian los importers del catálogo, en el orden en que se leyeron:
no importer recognises the source (source "<source>"). Pass —format to name it explicitly (for example —format <format> or —format <format>) (ningún importer reconoce la fuente (fuente indicada). Pasa —format para nombrarlo explícitamente (por ejemplo —format seguido de uno de los formatos anunciados))
Donde ningún importer anuncia formato alguno, el remedio lo dice en lugar de los ejemplos.
A un directorio se le ofrece un remedio distinto, porque nombrar un formato cualquiera no puede ayudarle. Un directorio solo se lee a través de los patrones de archivo que declara su importer, y una firma que no declara ningún patrón de archivo no se aplica a ninguno de los archivos de un directorio — así, un directorio que contiene, por ejemplo, una sola exportación de Langflow no es reconocido por ninguna firma, y nombrar el formato langflow sería rechazado a su vez según An importer that declares no file patterns is handed a directory (Un importer que no declara patrones de archivo recibe un directorio). Por eso, el rechazo de un directorio lo nombra como directorio y ofrece importar uno de sus archivos por separado, o nombrar un formato cuyo importer declare patrones de archivo — solo esos formatos, tomados de las propias declaraciones de los 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>) (ningún importer reconoce la fuente (directorio). Importa por separado uno de los archivos del directorio, o pasa —format nombrando un formato cuyo importer lea un directorio a través de los patrones de archivo que declara (por ejemplo —format o —format))
Cuando ningún importer declara un patrón de archivo, el rechazo ofrece importar por separado uno de los archivos del directorio e indica que ningún importer del catálogo declara los patrones de archivo a través de los cuales se lee un directorio.
Cómo corregirlo: nombra el formato — --format en aggrega import, o format en la herramienta de importación del asistente y en el método aggrega/import de la sesión, cada uno de los cuales formula el rechazo en torno al campo que recibe y lo abre con el código corto de esta condición; la respuesta de la sesión lleva además los dos códigos de la condición en sus datos. Para un directorio, importa por separado el archivo que querías — una firma que no nombra ningún archivo se aplica a un archivo importado por separado, se llame como se llame — o nombra uno de los formatos que enumera el rechazo. Donde la fuente debería haberse reconocido, el cambio corresponde a las firmas del importer que sirve su formato, que su autor declara en su autoinforme describe() y que su entidad Plugin registra cuando se genera. aggrega-import.md describe cómo se reconoce un formato.
An importer that declares no file patterns is handed a directory (A un importer que no declara patrones de archivo se le entrega un directorio)
Un rechazo al convertir una descripción de fuente externa en borradores de archivos de autoría, no en una compilación. La fuente nombrada es un directorio, y un directorio se entrega a su importer exactamente como los archivos que seleccionan los patrones de archivo declarados por el importer — así que qué archivos de un directorio lee un importer es una afirmación del propio importer. El importer que sirve el formato de la fuente no declara patrones de archivo: lee un solo archivo y no dice nada sobre qué archivos de un directorio son suyos.
No se abre nada. La importación se detiene una vez resuelto el importer y antes de leer ningún archivo del directorio, en lugar de entregar al importer todos los archivos que contiene el directorio.
Su mensaje empieza así:
the importer serving the source’s format declares no file patterns, so it reads one file and cannot read a directory (el importer que sirve el formato de la fuente no declara patrones de archivo, así que lee un solo archivo y no puede leer un directorio)
El resto del mensaje nombra el formato, el importer y el directorio tal como lo nombraste, y después el remedio:
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 (el importer que sirve el formato de la fuente no declara patrones de archivo, así que lee un solo archivo y no puede leer un directorio (formato, importer y directorio indicados). Importa en su lugar uno de los archivos del directorio por separado; el importer lee un directorio en cuanto declara los patrones de archivo con los que se nombran sus archivos)
Cómo corregirlo: importa por separado un archivo del formato. Para que un importer lea directorios de su formato, su autor declara los patrones con los que se nombran sus archivos — el campo files de una firma de reconocimiento en su autoinforme describe(), que su entidad Plugin registra cuando se genera. aggrega-import.md describe qué lee una importación de un directorio.
No file in the directory matches the importer’s file patterns (Ningún archivo del directorio coincide con los patrones de archivo del importer)
Un rechazo al convertir una descripción de fuente externa en borradores de archivos de autoría, no en una compilación. La fuente nombrada es un directorio, el formato está decidido y el importer que lo sirve declara patrones de archivo — pero ningún archivo que contiene el directorio, a ninguna profundidad, coincide con uno de ellos. No entregar al importer ninguna fuente lo haría fallar con una vacía, con palabras sobre el contenido en lugar de sobre qué archivos se leyeron, así que la importación se detiene aquí sin haber leído nada.
Donde el formato se reconoció en lugar de nombrarse, el importer cuya firma reconoció el directorio coincidió con uno de sus archivos, así que esto solo se da donde el importer que se ejecuta no es ese — otro importer del mismo formato que selecciona una entrada plugins.importer, u otra versión de él.
Su mensaje empieza así:
no file in the directory matches the file patterns the importer serving the source’s format declares (ningún archivo del directorio coincide con los patrones de archivo que declara el importer que sirve el formato de la fuente)
El resto del mensaje nombra el formato, el importer, el directorio tal como lo nombraste y cada patrón que declara el importer, y después el remedio:
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 (ningún archivo del directorio coincide con los patrones de archivo que declara el importer que sirve el formato de la fuente (formato, importer, directorio y patrones de archivo indicados). Nombra un directorio que contenga un archivo con el que coincida uno de esos patrones, o el formato de un importer cuyos patrones coincidan con los archivos que contiene este directorio)
Cómo corregirlo: importa el directorio que contiene los archivos del formato — un patrón se compara con el final de la ruta de un archivo dentro del directorio, así que cuenta un archivo a cualquier profundidad — o nombra el formato en el que están los archivos del directorio. aggrega-import.md describe qué lee una importación de un directorio.
A file read from the directory and a file named in the importer’s with.sources have the same name (Un archivo leído del directorio y un archivo nombrado en las fuentes del importer tienen el mismo nombre)
Un rechazo al convertir una descripción de fuente externa en borradores de archivos de autoría, no en una compilación. La fuente nombrada es un directorio, y sus archivos llegan al importer como fuentes con nombre, cada uno bajo su ruta dentro del directorio. La entrada plugins.importer que vincula el importer nombra archivos propios bajo with.sources, que también le llegan como fuentes con nombre, cada uno bajo su nombre base — y un mismo nombre lo llevan ambos. Un nombre es la forma en que un importer distingue una fuente de otra, así que entregarle ambos dejaría que uno ocultara al otro sin nada que diga cuál; en su lugar, la importación se detiene, sin entregar nada.
Su mensaje empieza así:
a file read from the directory and a file named in the importer’s with.sources have the same name (un archivo leído del directorio y un archivo nombrado en las fuentes del importer tienen el mismo nombre)
El resto del mensaje nombra el nombre y el archivo de with.sources, y después el remedio:
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 archivo leído del directorio y un archivo nombrado en las fuentes del importer tienen el mismo nombre (nombre y archivo de with.sources indicados). Cada fuente llega al importer con un solo nombre, así que cambia el nombre de uno de los dos archivos, o deja el archivo fuera de las with.sources del importer)
Cómo corregirlo: cambia el nombre de uno de los dos archivos, o quita el archivo del campo with.sources de la entrada donde el directorio ya lo contiene. Un archivo de with.sources conserva su nombre base, así que con lo que se encuentra es con un archivo del mismo nombre en el nivel superior del directorio; un archivo en un directorio inferior lleva ese directorio en su nombre. Qué importer convierte una fuente en borradores describe el campo with.sources de una entrada.
An import’s target names a capability no Recipe in the catalog binds to (El destino de una importación nombra una capacidad a la que no se vincula ninguna Recipe del catálogo)
Un rechazo al convertir una descripción de fuente externa en borradores de archivos de autoría, no en una compilación. A la importación se le dio un destino — --target en aggrega import, o target en la herramienta de importación del asistente y en el método aggrega/import de la sesión — para que genere un borrador de Manifest que asigne cada tipo de componente del borrador a una Recipe de ese proveedor. El destino es una capacidad de proveedor, que se compara con el spec.capability al que se vincula cada Recipe del catálogo del espacio de trabajo, y ninguna Recipe de ese catálogo se vincula a la indicada. Un Manifest generado para él no asignaría nada en absoluto, y entonces todos los tipos de componente aparecerían como ausentes del catálogo cuando lo que está mal es la propia opción — casi siempre una errata.
No se ejecuta nada y no se escribe nada. La importación se detiene una vez cargado el catálogo, antes de que se reconozca el formato de la fuente y antes de que se ejecute el importer, así que no se produce ningún borrador ni se escribe ningún archivo, tampoco en una ejecución de prueba.
Su mensaje empieza así:
no Recipe in the workspace’s catalog binds to the capability the import’s target names (ninguna Recipe del catálogo del espacio de trabajo se vincula a la capacidad que nombra el destino de la importación)
El resto del mensaje nombra el destino exactamente como se dio y las capacidades a las que sí se vinculan las Recipes del catálogo, cada una una vez y en orden, y después el remedio:
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 (ninguna Recipe del catálogo del espacio de trabajo se vincula a la capacidad que nombra el destino de la importación (destino indicado, capacidades a las que se vinculan las Recipes del catálogo). Nombra una de esas capacidades como destino, u omite el destino y no se genera ningún Manifest; no se generó ni se escribió nada)
Donde el catálogo no contiene ninguna Recipe, el mensaje lo dice en lugar de la lista, y el remedio es añadir al catálogo una Recipe del proveedor.
Cómo corregirlo: nombra una de las capacidades que lista el mensaje — compose o helm, por ejemplo, tal como las escribe el spec.capability de una Recipe — u omite el destino, lo que no genera ningún borrador de Manifest. Donde el proveedor al que te referías sea uno para el que el catálogo aún no contiene ninguna Recipe, añade sus Recipes a una carpeta de catálogo que el espacio de trabajo lea primero. aggrega-import.md describe qué genera una importación a la que se le da un destino.
A child Release inherits a boundary directory that resolves where its parent writes (Una Release hija hereda un directorio de límite que se resuelve donde escribe su Release padre)
Un aviso. Una Release extiende otra y hereda de ella el directorio de salida de un límite, y ese directorio no lleva ninguna variable de plantilla — así que se resuelve en la misma ruta para ambas, y la compilación de la hija escribe donde escribe la compilación de la Release padre.
Heredar el directorio es la forma admitida, no un error. Un directorio es una plantilla, así que una Release padre lo escribe una vez y una hija que cumple un parámetro lo resuelve en otro lugar sin duplicar nada; esa es toda la razón por la que una hija no necesita repetir la topología de límites de su Release padre. Lo que es acotado y real es el caso residual que esto nombra: sin ninguna variable en él, no queda nada que resolver de otra forma.
No puede provocar una detención, y eso es una propiedad de la regla, no cautela respecto a ella. Escribir en la misma ruta resuelta es algo que un autor puede querer legítimamente — una hija que solo cambia las Recipes de renderizado para comparar su salida, o que solo cambia el dimensionamiento — así que una regla que se detuviera por la inferencia rechazaría una entrada legítima basándose en una conjetura.
Su mensaje empieza así:
inherited boundary directory carries no template variable, so it resolves to the path the extended Release writes to (el directorio de límite heredado no lleva ninguna variable de plantilla, así que se resuelve en la ruta en la que escribe la Release extendida)
Cómo corregirlo: donde las dos debían escribir en lugares distintos, pon una referencia a un parámetro en el directorio y deja que cada Release la cumpla. Donde escribir en una sola ruta es lo que querías, no hay que cambiar nada — el aviso te ha dicho lo que hará, y la compilación produce su salida de cualquier forma.
Encontrar una detención a partir del código corto que imprimió la compilación
El encabezado entre corchetes de un diagnóstico de detención nombra la categoría a la que es atribuible el fallo y, donde el fallo nombra una de las condiciones catalogadas aquí, el código corto de esa condición — la letra E y cuatro dígitos, como en [CATALOG_ERROR E0209]. Un número se asigna una vez y después queda fijo, así que un código corto que pegues en un informe o en una búsqueda sigue nombrando la condición que nombraba cuando lo anotaste. Los otros dos identificadores que lleva una condición, y cuál de los tres usar y cuándo, se explican en sentinels.md.
La propia línea de mensaje de la condición empieza con una frase fija que enuncia la condición. Todo lo que sigue a esa frase varía con cada caso — el documento en falta, la clave escrita, el valor problemático y el consejo para ese caso — y las entradas de arriba citan la forma completa para la condición que documenta cada una. La frase fija es la parte que es igual cada vez, y eso es lo que la convierte en la parte con la que buscar coincidencias.
La tabla siguiente empareja ambas cosas, limitada a esta página: para cada condición catalogada aquí, el código corto que imprime una compilación y la frase con la que empieza su línea de mensaje, frente a la entrada de arriba que explica la corrección de autoría. Los encabezados de las entradas se citan exactamente, así que buscar uno en esta página lleva a su entrada. La tabla de todas las condiciones resuelve un código corto entre todas las condiciones que declara el compilador, incluidas las que no cubre ninguna entrada de aquí.
Donde una entrada aparece frente a dos códigos cortos, cubre dos condiciones distintas y cada una registra su propia frase; lee las frases en lugar del encabezado compartido para saber cuál informó una compilación.
aggrega explain <code> hace esta búsqueda por ti en el terminal, admitiendo cualquiera de los códigos de la condición e imprimiendo la condición junto con la entrada de arriba que la documenta. Se describe en aggrega explain.
Código corto
Empieza con
Documentado en
E0001
cliplugin: no plugin resolver configured
A command-line plugin runner was built without a way to find plugins (Un ejecutor de plugins de línea de comandos se construyó sin una forma de encontrar plugins)
E0003
malformed attachment requirement
Malformed attachment requirement (Requisito de vinculación mal formado)
E0004
annotation contribution overridden by an explicit value
An explicit value displaced one an annotation supplied (Un valor explícito desplazó a uno que aportaba una anotación)
E0005
policy violation
A governance plugin rejected the build (Un plugin de gobernanza rechazó la compilación)
E0006
required attachment slot unfilled
Required attachment slot not bound (Slot de vinculación obligatorio sin enlazar)
E0007
selector violation
Cross-node type safety violation via selector: (Violación de la seguridad de tipos entre nodos mediante selector)
E0008
attachment slot selector unsatisfied
The Feature filling an attachment slot does not satisfy the slot’s selector (La Feature que llena un slot de vinculación no satisface el selector del slot)
E0009
pipeline step typed-I/O contract violation
A pipeline step’s typed input or output does not satisfy its declared contract (La entrada o la salida tipada de un paso de pipeline no cumple su contrato declarado)
E0010
pipeline step failed
A pipeline step failed (Un paso de pipeline falló)
E0011
pipeline patch targets a document not present in the set
A pipeline patch addresses a document the set does not hold, or one with no tree to address (Un parche de pipeline direcciona un documento que el conjunto no contiene, o uno sin árbol que direccionar)
E0012
pipeline patch targets an opaque (non-structured) unit
A pipeline patch addresses a document the set does not hold, or one with no tree to address (Un parche de pipeline direcciona un documento que el conjunto no contiene, o uno sin árbol que direccionar)
E0013
feature type mismatch between Aggregate and Release
Feature type mismatch between Aggregate and Release (Discrepancia del tipo de Feature entre Aggregate y Release)
E0014
inject entry carries both `value:` and `from:`; schema requires exactly one
An inject: entry carries both a literal and a source key (Una entrada de inject lleva a la vez un literal y una clave de origen)
E0015
uses-edge inject dictates a delivery mechanism the socket does not permit
uses edge dictates delivery on a socket that allowlists none (Una arista dicta la entrega en un socket que no permite ningún mecanismo); uses edge dictates a delivery mechanism outside the socket’s allowlist (Una arista dicta un mecanismo de entrega fuera de la lista de permitidos del socket)
E0016
jsonpatch: test operation failed
A patch’s test operation did not match the document (La operación de prueba de un parche no coincidió con el documento)
E0017
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
An annotation-transform plugin names a component it was not given, or injects a value no annotation takes (Un plugin annotation-transform nombra un componente que no se le entregó, o inyecta un valor que ninguna anotación admite)
E0018
policy attachment settings do not satisfy the plugin's declared settings schema
A governance attachment’s settings do not match the plugin’s declared schema (La configuración de una vinculación de gobernanza no coincide con el esquema declarado del plugin)
E0019
endpoint requires form: reference
A workload: form and the fields beside it do not agree (La forma de una carga de trabajo y los campos junto a ella no concuerdan)
E0020
schedule is not a valid cron expression
A workload schedule: is not an expression the check accepts (La programación de una carga de trabajo no es una expresión que la comprobación acepte)
E0021
persistentTemplate volume requires form: stateful
A workload: form and the fields beside it do not agree (La forma de una carga de trabajo y los campos junto a ella no concuerdan)
E0022
pipeline PATCH target is not parseable structured YAML/JSON
A pipeline step addresses documents the node does not have (Un paso de pipeline direcciona documentos que el nodo no tiene)
E0023
form: reference requires an endpoint
A workload: form and the fields beside it do not agree (La forma de una carga de trabajo y los campos junto a ella no concuerdan)
E0024
schedule requires form: scheduled
A workload: form and the fields beside it do not agree (La forma de una carga de trabajo y los campos junto a ella no concuerdan)
E0025
form: scheduled requires a schedule
A workload: form and the fields beside it do not agree (La forma de una carga de trabajo y los campos junto a ella no concuerdan)
E0026
imported artifact content does not match the digest recorded for it in entity.lock
An imported artifact no longer matches the digest recorded beside its Recipe (Un artefacto importado ya no coincide con el digest registrado junto a su Recipe)
E0027
artifacts $import: is not a bare-name artifact-library reference (<Library>#/artifacts/<entry>)
A library $import: is not written in the bare-name form (Una importación de biblioteca no está escrita en la forma de nombre simple)
E0028
artifacts output filename collision: two artifact outputs carry the same filename
Two artifact outputs of one Recipe carry the same filename (Dos salidas de artefactos de una misma Recipe llevan el mismo nombre de archivo)
E0029
artifact template references a pillar the Recipe does not declare
An artifacts: template reads a pillar the Recipe does not declare (Una plantilla de artifacts lee un pilar que la Recipe no declara)
E0030
artifact-library import references a bundle not present in the ArtifactLibrary
A library $import: names a library or an entry the catalog does not hold (Una importación de biblioteca nombra una biblioteca o una entrada que el catálogo no contiene)
E0031
artifact-library import references an ArtifactLibrary not present in the catalog
A library $import: names a library or an entry the catalog does not hold (Una importación de biblioteca nombra una biblioteca o una entrada que el catálogo no contiene)
E0032
assembled output collision: two contributors write the same output path
Two contributors write the same output path (Dos contribuidores escriben la misma ruta de salida)
E0033
assertion failed
An assertion stopped the build (Una aserción detuvo la compilación)
E0034
duplicate delivery key across attachment-inject and another inject source
An attachment delivers a key another inject source already claimed (Una vinculación entrega una clave que otra fuente de inject ya reclamó)
E0035
provider expected to assemble its dispatch group provides no boundary assembler
The plugin serving a provider cannot assemble what that provider combines (El plugin que sirve a un proveedor no puede ensamblar lo que ese proveedor combina)
E0036
merged-path assembly has conflicting assembly-name annotation values
Chart-name mismatch on a merged helm-chart umbrella (Nombre de chart discordante en un chart paraguas helm-chart fusionado)
E0037
cross-boundary link between endpoints rendered by different providers is not supported
A connection crosses between two different providers’ assembled outputs (Una conexión cruza entre las salidas ensambladas de dos proveedores distintos)
E0038
derived name collision: one name is derived more than once in one key space
The same name is derived more than once inside the output (El mismo nombre se deriva más de una vez dentro de la salida)
E0039
FeatureRecipe template references a per-component-only field with executionScope: boundary
FeatureRecipe template references a field outside its scope’s allowlist (La plantilla de FeatureRecipe hace referencia a un campo fuera de la lista de permitidos de su nivel)
E0040
library $import: carries a registry host; reference the library by bare-name identity
A library $import: addresses its library by registry location (Una importación de biblioteca direcciona su biblioteca por su ubicación en un registro)
E0041
multiple contributors share an instance ID at the same dispatch path
Instance-ID collision across boundaries assembling to the same path (Colisión de ID de instancia entre límites que se ensamblan en la misma ruta)
E0042
locals entry references a sibling defined later in the same block
locals: entry references a sibling defined later in the same block (Una entrada de locals hace referencia a una entrada hermana definida más adelante en el mismo bloque)
E0043
template references a key the locals block does not declare
locals: key does not exist (La clave de locals no existe)
E0044
mapping-library import references an entry not present in the MappingLibrary
A library $import: names a library or an entry the catalog does not hold (Una importación de biblioteca nombra una biblioteca o una entrada que el catálogo no contiene)
E0045
valuesMapping $import: is not a bare-name mapping-library reference (<Library>#/mappings/<entry>)
A library $import: is not written in the bare-name form (Una importación de biblioteca no está escrita en la forma de nombre simple)
E0046
mapping-library import references a MappingLibrary not present in the catalog
A library $import: names a library or an entry the catalog does not hold (Una importación de biblioteca nombra una biblioteca o una entrada que el catálogo no contiene)
E0047
assembled output retains an unresolved cross-boundary link placeholder
Assembled output still carries a cross-boundary placeholder (La salida ensamblada todavía lleva un marcador de posición entre límites)
E0048
dispatch path produced multiple provider outputs
Path collision: two contributors emit at incompatible paths (Colisión de rutas: dos contribuidores emiten en rutas incompatibles)
E0049
path template references a field not in the documented allowlist
Path-template references a variable outside the allowlist (La plantilla de ruta hace referencia a una variable fuera de la lista de permitidos)
E0050
pipeline /host operation from a step with no host component
A pipeline step addresses documents the node does not have (Un paso de pipeline direcciona documentos que el nodo no tiene)
E0051
pipeline PATCH targets an assembler provider's pre-assembly fragments
A pipeline patch addresses output that has not been assembled yet (Un parche de pipeline direcciona una salida que todavía no se ha ensamblado)
E0052
pipeline PATCH targets a document the node did not emit
A pipeline step addresses documents the node does not have (Un paso de pipeline direcciona documentos que el nodo no tiene)
E0053
pipeline plugin is not compatible with the rendering provider
A pipeline step’s plugin does not claim the provider rendering what it addresses (El plugin de un paso de pipeline no reivindica el proveedor que renderiza lo que el paso direcciona)
E0054
provider rejected node input
A provider refused a node’s input (Un proveedor rechazó la entrada de un nodo)
E0055
Recipe or FeatureRecipe does not publish a provides key its abstract entity's schema.provides contract declares
A Recipe or FeatureRecipe does not publish a provides key its contract declares (Una Recipe o una FeatureRecipe no publica una clave provides que su contrato declara)
E0056
provides template evaluation failed
A provides: template could not be evaluated (No se puede evaluar una plantilla de provides)
E0057
provides block references a root outside the self-contained set
provides: template references a non-self-contained root (La plantilla de provides hace referencia a una raíz no autocontenida)
E0058
provider render is not deterministic
A provider rendered the same input twice and produced different output (Un proveedor renderizó dos veces la misma entrada y produjo salidas distintas)
E0059
duplicate delivery key across self-inject and uses-inject
Duplicate delivery key across inject sources (Clave de entrega duplicada entre las fuentes de inject)
E0060
template references a root the render context does not define
Template references a root the render context does not define (La plantilla hace referencia a una raíz que el contexto de renderizado no define); Self-inject value template references cross-node data (La plantilla del valor de self-inject hace referencia a datos entre nodos)
E0061
unknown provider
Unknown provider (Proveedor desconocido)
E0062
custom inject mechanism has no matching key in injectMapping output; add the mechanism's key to the Recipe injectMapping
A component declares an inject mechanism the attached Feature maps nothing to (Un componente declara un mecanismo de inject al que la Feature vinculada no mapea nada)
E0063
workload-library import references an entry not present in the WorkloadLibrary
A library $import: names a library or an entry the catalog does not hold (Una importación de biblioteca nombra una biblioteca o una entrada que el catálogo no contiene)
E0064
workload $import: is not a bare-name workload-library reference (<Library>#/workloads/<entry>)
A library $import: is not written in the bare-name form (Una importación de biblioteca no está escrita en la forma de nombre simple)
E0065
workload-library import references a WorkloadLibrary not present in the catalog
A library $import: names a library or an entry the catalog does not hold (Una importación de biblioteca nombra una biblioteca o una entrada que el catálogo no contiene)
E0066
uses edge target does not exist
Dangling uses target (Destino de arista colgante)
E0067
active toggle did not resolve to a boolean
An active: toggle does not resolve to true or false (Un interruptor no se resuelve en true ni en false)
E0068
max sub-aggregate nesting depth exceeded
Sub-aggregate nesting depth exceeded (Profundidad de anidamiento de subagregados superada)
E0069
mutator patch rejected
A label-transform plugin’s patch reaches outside node labels (El parche de un plugin label-transform llega fuera de las etiquetas de los nodos)
E0070
re-exported component alias forms a cycle
A re-published component alias points back at itself (Un alias de componente republicado apunta a sí mismo)
E0071
release edge retargets a developer-declared edge
Release retargets a developer-declared edge (La Release cambia el destino de una arista declarada por el desarrollador)
E0072
sub-aggregate load failed
A module a composition imports cannot be loaded, or imports itself (Un módulo importado por una composición no se puede cargar, o se importa a sí mismo)
E0073
flattened node ID collision: rename one of the colliding instances so their flattened IDs differ
Two instances flatten to one identifier (Dos instancias se aplanan en un único identificador)
E0074
release per-edge configuration has no edge to apply to
Release per-edge configuration has no edge to apply to (La configuración por arista de la Release no tiene ninguna arista a la que aplicarse)
An Aggregate reached graph building without being normalised (Un Aggregate llegó a la construcción del grafo sin haber sido normalizado)
E0076
sub-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 (Los componentes de un submódulo no están colocados en ningún límite)
E0077
uses edge target was pruned because its active toggle resolved to false
A uses edge targets a component an active: toggle removed (Una arista tiene como destino un componente que un interruptor eliminó)
E0078
producer-consumption re-entry denied: a producer reached through the host may not issue a further producer-consumption call
A plugin asks the host to parse a source while a parse is already running for it (Un plugin pide al host que analice una fuente mientras ya hay un análisis en curso para él)
E0079
wasm: recorded command mirror does not match plugin describe()
A Plugin entity’s recorded command set does not match the plugin (El conjunto de comandos registrado de una entidad Plugin no coincide con el plugin)
E0080
wasm: entity contract claim does not match plugin describe()
A Plugin entity’s claims disagree with the plugin’s own self-report (Las afirmaciones de una entidad Plugin no concuerdan con la autodescripción del propio plugin)
E0081
wasm: guest plugin returned a diagnostic whose severity the contract does not declare
A plugin returned a diagnostic at a severity that is not declared (Un plugin devolvió un diagnóstico con una gravedad que no está declarada)
E0082
wasm: guest plugin reported an error
A plugin failed while it was running (Un plugin falló durante su ejecución)
E0083
wasm: guest plugin panicked during call
A plugin failed while it was running (Un plugin falló durante su ejecución)
E0084
wasm: stamped host-function record does not match .wasm imports
A Plugin entity’s recorded host functions do not match the binary (Las funciones host registradas de una entidad Plugin no coinciden con el binario)
E0085
wasm: plugin rejected by the sandbox
The sandbox refused a plugin (El sandbox rechazó un plugin)
E0086
wasm: plugin invoked proc_exit
A plugin failed while it was running (Un plugin falló durante su ejecución)
E0087
wasm: declared plugin type does not match plugin describe()
A plugin is not the kind of plugin the socket expects (Un plugin no es del tipo de plugin que espera el socket)
E0088
wasm: entity metadata.version does not match plugin describe()
A Plugin entity’s recorded version does not match the plugin (La versión registrada de una entidad Plugin no coincide con el plugin)
E0089
every published version this reference could select has been withdrawn
Every version a reference could select has been withdrawn (Toda versión que una referencia podría seleccionar ha sido retirada)
E0090
format is advertised by more than one importer plugin
A parse or import format is advertised by more than one plugin (Un formato de análisis o de importación lo anuncia más de un plugin)
E0091
format is advertised by more than one parser plugin
A parse or import format is advertised by more than one plugin (Un formato de análisis o de importación lo anuncia más de un plugin)
E0092
capability is served by more than one provider plugin; add a plugins.providers entry to select one
A capability is served by more than one provider plugin (Una capacidad la sirve más de un plugin proveedor)
E0093
manifest maps multiple version-distinct keys to the same base type; the type-to-recipe lookup is ambiguous
A Manifest maps two version-distinct keys onto one type (Un Manifest asigna dos claves de versión distinta a un mismo tipo)
E0094
duplicate entity identity within a single catalog directory
Two catalog entities in one directory share an identity (Dos entidades del catálogo en un mismo directorio comparten una identidad)
E0095
malformed recipe reference in a Manifest mapping value
Manifest mapping value is not a shape a recipe reference accepts (El valor de mapeo del Manifest no tiene una estructura que acepte una referencia de receta)
E0096
manifest mapping entry's recipe spec.implements does not match the mapped component-type / feature-type key
Recipe implements does not match the mapped component type (La declaración de implementación de la Recipe no coincide con el tipo de componente mapeado)
E0097
no importer plugin advertises the requested format
No plugin advertises a requested parse or import format (Ningún plugin anuncia un formato de análisis o de importación solicitado)
E0098
no parser plugin advertises the requested format
No plugin advertises a requested parse or import format (Ningún plugin anuncia un formato de análisis o de importación solicitado)
E0099
no recipe resolved for component/feature instance: add an explicit Manifest mapping for its type
No Recipe is mapped for a component or feature instance (Ninguna Recipe está mapeada para una instancia de componente o de funcionalidad)
E0100
plugins.providers entry names a plugin no provider-rendering plugin serving the capability matches
A plugins.providers binding names a plugin that does not serve the capability (Un enlace nombra un plugin que no sirve la capacidad)
E0101
no provider-rendering plugin version satisfies the recipe's provider version pin
No provider plugin version satisfies a Recipe’s provider pin (Ninguna versión de plugin proveedor satisface la fijación de proveedor de una Recipe)
E0102
wasm plugin reference must be the plugin coordinate identity (<pluginType>/<name>:<version>), not a registry-qualified or artifact path
A plugin reference carries a registry host or an artifact path (Una referencia de plugin contiene un host de registro o una ruta de artefacto)
E0103
no catalog version satisfies the referenced version constraint
No catalog version satisfies a version constraint (Ninguna versión del catálogo satisface una restricción de versión)
E0104
wasm plugin reference must carry a pluginType scope (<pluginType>/<name>); an empty scope cannot bind to an OCI location
A plugin or recipe reference carries no scope (Una referencia de plugin o de receta no lleva ámbito)
E0105
recipe reference must be provider-scoped (<provider>/<name>); an empty provider cannot bind to an OCI location
A plugin or recipe reference carries no scope (Una referencia de plugin o de receta no lleva ámbito)
E0106
resolve: invalid library reference URI
A library reference is not written in the identity form (Una referencia a biblioteca no está escrita en la forma de identidad)
E0107
resolve: minimal version selection conflict — incompatible library version requirements
Two consumers of one library require incompatible versions (Dos consumidores de una misma biblioteca exigen versiones incompatibles)
The catalog view a build was given cannot load the bodies pinning needs (La vista del catálogo que recibió una compilación no puede cargar los cuerpos que necesita la fijación)
E0109
resolve: catalog lookup cannot load resolved recipe and plugin bodies
The catalog view a build was given cannot load the bodies pinning needs (La vista del catálogo que recibió una compilación no puede cargar los cuerpos que necesita la fijación)
E0110
resolve: source-template evaluation failure at lock time
Resolving a source: coordinate registers a narrower function set (La resolución de una coordenada source registra un conjunto de funciones más reducido)
E0111
resolve: source-template parse error
Resolving a source: coordinate registers a narrower function set (La resolución de una coordenada source registra un conjunto de funciones más reducido)
Resolving a source: coordinate registers a narrower function set (La resolución de una coordenada source registra un conjunto de funciones más reducido)
E0113
resolve: sub-aggregate inclusion depth exceeded
The chain of module imports is deeper than the pin walk descends (La cadena de importaciones de módulos es más profunda de lo que desciende el recorrido de fijación)
E0114
resolve: no entity in the catalog matches this URI
A reference names no entity the catalog holds (Una referencia no nombra ninguna entidad que contenga el catálogo)
E0115
compactform: ambiguous dispatch — $mode required
A compact-form schema declares a field literally named type (Un esquema en forma compacta declara un campo que se llama literalmente así)
E0116
compactform: constraint not valid for declared type
A compact-form constraint does not apply to the type it was written on (Una restricción en forma compacta no se aplica al tipo sobre el que se escribió)
E0117
compactform: $jsonschema content invalid
A $jsonschema: escape carries content that is not a schema (Un escape contiene un contenido que no es un esquema)
E0118
compactform: cross-document $ref carries a registry host; reference the library by identity
A $ref: addresses a library by registry location (Una referencia direcciona una biblioteca por su ubicación en un registro)
E0119
compactform: $ref unresolvable
A $ref: is not written in a form the compiler can resolve (Una referencia no está escrita en una forma que el compilador pueda resolver)
E0120
compactform: unknown keyword
A compact-form schema uses a keyword the compact form does not know (Un esquema en forma compacta usa una palabra clave que la forma compacta no conoce)
E0121
compactform: cross-document $ref target not found
A $ref: is not written in a form the compiler can resolve (Una referencia no está escrita en una forma que el compilador pueda resolver)
E0122
deprecation: build consumes a deprecated entity
The build consumes an artifact its publisher has deprecated (La compilación consume un artefacto que su editor ha declarado obsoleto)
E0123
docscache: artifact is not a documentation bundle
A resolved artifact is not a documentation bundle (Un artefacto resuelto no es un bundle de documentación)
E0124
docscache: page not found in documentation bundle
A page is absent from a documentation bundle (Una página falta en un bundle de documentación)
E0125
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
The workspace is offline and the step needs the network (El espacio de trabajo está sin conexión y el paso necesita la red)
E0126
externalinputs: acquisition is disabled for unpinned inputs
A render requests an external input the lockfile does not pin (Un renderizado solicita una entrada externa que el archivo de bloqueo no fija)
E0127
externalinputs: fetched bytes mismatch the pinned digest
Fetched bytes do not match a pinned digest (Los bytes descargados no coinciden con un digest fijado)
E0128
externalinputs: URL scheme is not allowed
An external input’s URL uses a scheme that is not allowed (La URL de una entrada externa usa un esquema no permitido)
E0129
externalinputs: store blob mismatches its pinned record
A stored external input no longer matches its record (Una entrada externa almacenada ya no coincide con su registro)
E0130
lockfile: out of date; it no longer matches what its Release resolves to
The lockfile no longer matches what the release resolves to (El archivo de bloqueo ya no coincide con aquello en lo que se resuelve la Release)
E0131
lockfile: file failed schema validation
The lockfile does not satisfy its schema (El archivo de bloqueo no cumple su esquema)
E0132
oci: manifest has multiple layers of the expected content media type
A manifest carries no layer of the expected kind, or more than one (Un manifiesto no lleva ninguna capa del tipo esperado, o lleva más de una)
E0133
oci: cached manifest digest mismatch
Fetched or cached bytes do not match the digest committed for them (Los bytes descargados o en caché no coinciden con el digest declarado para ellos)
E0135
oci: content digest mismatch
Fetched or cached bytes do not match the digest committed for them (Los bytes descargados o en caché no coinciden con el digest declarado para ellos)
E0136
oci: network unreachable
The registry could not be reached (No se pudo acceder al registro)
E0137
oci: artifact not found at remote source
An artifact is not at the source the build was told to find it (Un artefacto no está en la fuente donde se indicó a la compilación que lo encontrara)
E0138
oci: authentication required or failed
The registry will not serve an artifact without credentials it accepts (El registro no sirve un artefacto sin credenciales que acepte)
E0139
oci: tag already published with different content
A tag is already published with different content (Un tag ya está publicado con un contenido distinto)
E0140
oci: manifest has no layer of the expected content media type
A manifest carries no layer of the expected kind, or more than one (Un manifiesto no lleva ninguna capa del tipo esperado, o lleva más de una)
E0141
oci: distinct catalog identities map to the same OCI repository location
Two catalog identities publish to one repository location (Dos identidades del catálogo publican en una misma ubicación de repositorio)
E0142
oci: referrer discovery could not be completed
The registry could not answer what is attached to an artifact (El registro no pudo responder qué está vinculado a un artefacto)
E0143
oci: unknown entity kind for mediatype dispatch
An entity kind has no artifact media type (Un tipo de entidad no tiene tipo de medio de artefacto)
E0144
cached signature bundle does not match its recorded digest
A cached signature bundle does not match the digest recorded for it (Un bundle de firma en caché no coincide con el digest registrado para él)
E0145
plugin reference is not a Plugin entity
A plugin reference is not a Plugin entity (Una referencia a un plugin no es una entidad Plugin)
E0146
circular reference expansion
A library reference expands into itself (Una referencia a una biblioteca se expande en sí misma)
E0147
registrytrust: advertised trust config is malformed
A registry serves a trust document that cannot be read as one (Un registro sirve un documento de confianza que no se puede leer como tal)
E0148
registrytrust: registry advertises no trust config
A registry publishes no trust document (Un registro no publica ningún documento de confianza)
E0149
attachment name is a near miss for a declared slot
An attachment name is one edit from a declared slot (Un nombre de vinculación está a una edición de distancia de un slot declarado)
E0150
attachment does not conform to its declared slot shape
Attachment does not conform to its declared slot shape (La vinculación no se ajusta a la forma declarada de su slot)
E0151
component declared in more than one boundary: declare each component in exactly one boundary
A component is placed in more than one boundary (Un componente está colocado en más de un límite)
E0152
duplicate Aggregate/Manifest identity (metadata.name) in the Release directory
The Release directory declares one Aggregate or Manifest twice (El directorio de la Release declara dos veces un Aggregate o un Manifest)
E0153
feature merge conflict: reconcile the Aggregate and Release declarations for the feature
A feature attached by both the Aggregate and the Release cannot be merged (Una funcionalidad vinculada tanto por el Aggregate como por la Release no se puede fusionar)
E0154
the compiler's own views of the catalog disagree
A guard needs a catalog entity the build resolved and cannot see (Una guarda necesita una entidad del catálogo que la compilación resolvió y que no puede ver)
E0155
duplicate delivery key across inject sources
Duplicate delivery key across inject sources (Clave de entrega duplicada entre las fuentes de inject)
E0156
invalid inject key: the from-key must name a provides key its source publishes
Inject from key is not in the target’s provides (La clave de inject no figura entre lo que proporciona el destino)
E0158
invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template
A {{ .parameters.* }} reference cannot be interpolated (No se puede interpolar una referencia a parámetros)
E0160
manifest annotation bindings collide on same Feature path+pillar
Two Manifest annotation bindings compete for one routing slot (Dos enlaces de anotación del Manifest compiten por un mismo slot de enrutamiento)
E0161
manifest annotation binding uses reserved prefix
A Manifest annotation binding claims the reserved aggrega.ai/ prefix (Un enlace de anotación del Manifest reclama el prefijo reservado)
E0162
missing required feature: attach a Feature of the required type to the component
Required feature not attached (Funcionalidad obligatoria no vinculada)
E0163
required uses socket not populated
Required uses: socket not populated (Socket obligatorio no poblado)
E0164
parameter contract violated
Parameter type mismatch / contract violation (Tipo de parámetro no coincidente / infracción del contrato)
E0165
required parameter not supplied
Parameter type mismatch / contract violation (Tipo de parámetro no coincidente / infracción del contrato)
E0167
Recipe publishes a provides key its Component does not declare
A Recipe publishes a provides key its Component does not declare (Una Recipe publica una clave que su Component no declara)
E0168
authored pillar does not conform to its declared schema
Authored values or infra do not conform to the declared schema (Los values o infra escritos no se ajustan al esquema declarado)
E0169
self-inject on component without spec.inject allowlist
Self-inject on a component without an allowlist (Self-inject en un componente sin lista de permitidos); Self-inject mechanism not in the component’s allowlist (Mecanismo de self-inject que no figura en la lista de permitidos del componente)
E0170
aggregate/manifest reference unresolvable
A Release’s aggregate: or manifest: reference resolves to nothing (La referencia de una Release no se resuelve en nada)
E0171
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
uses: socket not declared in the owning entity’s usesSchema (Socket no declarado en el esquema de sockets de la entidad propietaria)
A Release reached resolution without passing through the load path (Una Release llegó a la resolución sin pasar por la ruta de carga)
E0173
declared parameter is read by no reference in the Aggregate
A declared parameter is read by nothing (Un parámetro declarado no es leído por nada)
E0174
uses socket name is a near miss for a declared socket
A uses: socket name is one edit from a declared socket (Un nombre de socket está a una edición de distancia de un socket declarado)
E0175
file load failed: the file could not be read, or its bytes did not parse
A file cannot be read, or its bytes do not parse (No se puede leer un archivo, o sus bytes no se pueden analizar)
E0176
signing: keyless signing requires a live identity provider, Fulcio, and Rekor
Keyless signing was asked for without the services it needs (Se pidió la firma sin clave sin los servicios que necesita)
E0177
signing: no signature found for an artifact that requires one
An artifact that must be signed carries no signature (Un artefacto que debe estar firmado no lleva ninguna firma)
E0178
signing: keyless verification requires at least one trusted identity
A keyless trust policy names no acceptable signer (Una política de confianza sin clave no nombra ningún firmante aceptable)
E0179
signing: signature does not verify
A detached signature does not verify against the key supplied (Una firma separada no se verifica con la clave proporcionada)
E0180
signing: signature bundle does not verify
A signature does not verify (Una firma no supera la verificación)
E0181
signing: signing policy requires a signature for this artifact kind; refusing to push unsigned content
An unsigned publish targets a registry or a policy that requires a signature (Una publicación sin firmar se dirige a un registro o a una política que exige una firma)
E0182
signing: cannot load pinned trust root
The pinned trust root cannot be read (La raíz de confianza fijada no se puede leer)
E0183
signing: registry requires signatures; refusing to push unsigned content
An unsigned publish targets a registry or a policy that requires a signature (Una publicación sin firmar se dirige a un registro o a una política que exige una firma)
E0184
signing: unsupported held-key type
A pinned verification key is not the key profile the verifier accepts (Una clave de verificación fijada no es del perfil de clave que acepta el verificador)
E0185
signing: signature identity is not trusted for this registry
A signature verifies but its signer is not one the registry trusts (Una firma supera la verificación, pero su firmante no es uno en quien confíe el registro)
E0186
no source adapter serves the source kind
A Recipe’s source: names a kind nothing knows how to acquire (La fuente de una Recipe nombra un tipo que nada sabe cómo adquirir)
E0187
cacheslot: empty workspaceRoot
A source artifact is cached without a workspace root to anchor it (Un artefacto fuente se almacena en caché sin una raíz del espacio de trabajo a la que anclarlo)
E0188
artifacts entry: shape must be a string scalar or {$import: <local-path>}
An inline-or-import field is written in neither shape (Un campo en línea o de importación no está escrito en ninguna de las dos formas)
E0189
artifactlibrary: entry must be a mapping of filename to a string body
A library entry’s body is not the shape that library holds (El cuerpo de una entrada de biblioteca no tiene la forma que contiene esa biblioteca)
E0190
schemalibrary: forbidden JSON Schema keyword
A schema uses a JSON Schema keyword the library does not admit (Un esquema usa una palabra clave de JSON Schema que la biblioteca no admite)
E0191
mappinglibrary: entry body must be a string scalar
A library entry’s body is not the shape that library holds (El cuerpo de una entrada de biblioteca no tiene la forma que contiene esa biblioteca)
E0192
a document nests too many levels deep
A document nests deeper than the reader will descend (Un documento se anida a más profundidad de la que desciende el lector)
E0193
parameters: shape must be an inline object or {$import: <local-path>}
A Release’s parameters: block is written in neither of its two shapes (El bloque de parámetros de una Release no está escrito en ninguna de sus dos formas)
E0194
schemalibrary: template not found
A $instantiate: reference cannot be resolved (No se puede resolver una referencia)
E0195
schemalibrary: template parameter missing
A $instantiate: reference cannot be resolved (No se puede resolver una referencia)
E0196
schemalibrary: template parameter type mismatch
A $instantiate: reference cannot be resolved (No se puede resolver una referencia)
E0197
valuesmapping: shape must be a string scalar or {$import: <path-or-library-identity>}
An inline-or-import field is written in neither shape (Un campo en línea o de importación no está escrito en ninguna de las dos formas)
E0198
wellKnownAnnotations: a key is declared at a scope the provider's contract does not render
A provider declares a well-known annotation at a scope it does not render (Un proveedor declara una anotación well-known en un nivel que no renderiza)
E0199
workloadlibrary: entry body must be a string scalar
A library entry’s body is not the shape that library holds (El cuerpo de una entrada de biblioteca no tiene la forma que contiene esa biblioteca)
E0200
workload: shape must be a string scalar or {$import: <path-or-library-identity>}
An inline-or-import field is written in neither shape (Un campo en línea o de importación no está escrito en ninguna de las dos formas)
E0201
assertion name declared twice across the extends chain
An assertion name is declared twice along an extends: chain (Un nombre de aserción se declara dos veces a lo largo de una cadena de extensión)
E0202
cyclic extends chain
Cyclic extends chain (Cadena extends cíclica); Cyclic extends on Components or Features (Extends cíclico en Components o Features)
E0204
FeatureRecipe: valuesMapping requires source
A FeatureRecipe’s valuesMapping requires source (El mapeo de valores de una FeatureRecipe requiere una fuente)
E0205
inheritance merge failed
An extends: chain cannot be assembled (No se puede ensamblar una cadena de extensión)
E0207
recipe output-component-labels constraint: key is also declared in outputLabels
A promoted component label is also declared literally (Una etiqueta de componente promovida también se declara literalmente)
E0208
recipe output-labels constraint: key uses a reserved namespace
An output-label key uses a reserved namespace (Una clave de etiqueta de salida usa un espacio de nombres reservado)
E0209
Recipe: valuesMapping requires source
valuesMapping requires source (el mapeo de valores requiere una fuente)
E0210
Recipe: at least one input kind required
At least one input kind must be present (Debe haber al menos un tipo de entrada)
E0211
filename collision across input kinds: two input-kind blocks produced a file under one output name
Emission-time filename collision across input kinds (Colisión de nombres de archivo en tiempo de emisión entre tipos de entrada)
E0212
workload attachment slot is not referenceable
A Workload references a slot whose fill publishes no locator (Un Workload hace referencia a un slot cuyo relleno no publica ningún localizador)
E0213
workload featuresSchema cross-check failed
A Workload attachment names a slot the entity does not declare, or a delivery the slot forbids (Una vinculación de Workload nombra un slot que la entidad no declara, o una entrega que el slot prohíbe)
E0214
workload validation failed
A Workload does not satisfy the Workload schema (Un Workload no satisface el esquema Workload)
E0215
document envelope validation failed
YAML anchor aliased inside its own content (Ancla YAML referenciada mediante un alias dentro de su propio contenido); Divergent Release (extends + aggregate pointer) (Release divergente (extends + puntero aggregate))
An x-aggrega-when: or x-aggrega-validate: predicate cannot be evaluated (No se puede evaluar un predicado)
E0218
validator/jsonschema: schema resolution failed
A declared schema cannot be resolved (Un esquema declarado no se puede resolver)
E0220
extends chain exceeds maximum depth
An extends: chain runs past the depth bound (Una cadena de extensión supera el límite de profundidad)
E0221
merger: invalid merge input
The schema-merge step’s own input guard (La salvaguarda de entrada propia del paso de fusión de esquemas)
E0222
registry alias matches more than one host
A registry alias matches more than one host (Un alias de registro coincide con más de un host)
E0223
a cross-cutting socket is bound by capability but attaches by uri
A plugin binding sets a key the socket it attaches to does not read (Un enlace de plugin establece una clave que el socket al que se vincula no lee)
E0224
workspace configuration is invalid
The workspace configuration is invalid (La configuración del espacio de trabajo no es válida)
E0225
capability is bound to more than one provider plugin
A capability is bound to more than one provider plugin (Una capacidad está enlazada a más de un plugin proveedor)
E0226
registry alias is already used by another host
A registry alias is already bound to another host (Un alias de registro ya está asociado a otro host)
E0227
a governance attachment declares no role or an unknown role
A governance attachment declares no role, or one that is not a known role (Una vinculación de gobernanza no declara ningún rol, o declara uno que no es un rol conocido)
E0228
a provider socket binding sets a field with no referent on that socket
A plugin binding sets a key the socket it attaches to does not read (Un enlace de plugin establece una clave que el socket al que se vincula no lee)
E0229
position out of range
An editor position falls outside the document (Una posición del editor queda fuera del documento)
E0246
the digest recorded as trusted for this plugin does not match the digest its cached manifest reports
A trusted plugin’s recorded digest disagrees with the cached artifact (El digest registrado de un plugin de confianza no coincide con el artefacto en caché)
E0247
a plugin recorded as trusted for an accept-or-reject verdict is no longer attached at any verdict role
A plugin recorded as a trusted gate is no longer attached (Un plugin registrado como control de confianza ya no está vinculado)
E0248
wasm: guest plugin returned an output that is not the shape the socket reads
A plugin returned something that is not the shape the socket reads (Un plugin devolvió algo que no tiene la estructura que lee el socket)
E0250
provider named a directory for each contributor's own sub-directory that is not a single directory name
A provider named a directory for a contributor that is not one directory (Un proveedor nombró para un contribuidor un directorio que no es un único directorio)
E0251
recipe source is an empty string, which names neither sourceless mode nor sourced mode
Recipe source: is an empty string (El campo source de la Recipe es una cadena vacía)
E0252
artifact-library bundle file name does not name a file of its own beneath the artifacts key its output is nested under
An ArtifactLibrary bundle file names no file of its own under the key it was imported at (Un archivo de bundle de una ArtifactLibrary no nombra ningún archivo propio bajo la clave en la que se importó)
E0253
annotation binding does not resolve against its target Feature
Annotation binding does not resolve against its target Feature (El enlace de la anotación no se resuelve contra su Feature de destino)
E0254
annotation subkey does not conform to the target Feature's schema at the routed pillar
A bound annotation value does not conform to the target Feature’s schema (Un valor de anotación enlazado no se ajusta al esquema de la Feature de destino)
E0255
annotation routes through a pillar its authoring side may not use
An annotation routes through a pillar its authoring side may not use (Una anotación se enruta a través de un pilar que su lado de autoría no puede usar)
E0256
annotation binding declares one path in both pillar lists
An annotation binding declares one path in both pillar lists (Un enlace de anotación declara una misma ruta en ambas listas de pilares)
E0257
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
A declared schema contract cannot be read as a schema (Un contrato de esquema declarado no se puede leer como esquema)
E0259
attachment binds a FeatureRecipe with executionScope: boundary and no boundary holding the component declares it
A boundary-scope Feature is attached only to a component (Una Feature con ámbito de límite está vinculada solo a un componente)
E0260
component placed in no boundary: name it under a boundary's `components`, or place the sub-module that contributes it under `aggregates`
A component the composition holds is placed in no boundary (Un componente que contiene la composición no está colocado en ningún límite)
E0261
boundary names a component the composition does not hold: correct the name, or remove the entry
A boundary names a component the composition does not hold (Un límite nombra un componente que la composición no contiene)
E0262
component identity cannot be the name its emitted resources are stamped with: rename the component
Component identity cannot be stamped on what it emits (La identidad del Component no se puede estampar en lo que emite)
E0263
the target will not accept a name derived from this component's authored identity: rename the component
The target will not accept a name derived from an authored identity (El destino no acepta un nombre derivado de una identidad escrita)
E0264
provider guest never accepted a component identity the compiler composed for it
A provider never accepted a name the compiler composed (Un proveedor nunca aceptó un nombre compuesto por el compilador)
E0265
provider does not support the node's input kind
workload: requires a provider that can synthesize (requiere un proveedor capaz de sintetizar)
E0266
a schema `$import:` could not be applied
A schema $import: cannot be applied (No se puede aplicar una importación de esquema)
E0267
a schema block declares a key that names no data pillar
A schema block names a key that is not a data pillar (Un bloque de esquema nombra una clave que no es un pilar de datos)
E0268
reassemble names a patched unit token the carve did not produce; a conforming codec carves and reassembles a file under the same tokens
A provider’s reassembly is handed a unit its own carve never produced (El reensamblado de un proveedor recibe una unidad que su propio troceado nunca produjo)
E0269
provider guest returned two output files under one path; a conforming guest returns each output path at most once
A provider returned two output files under one path (Un proveedor devolvió dos archivos de salida bajo una misma ruta)
E0270
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
A provider’s link wiring names an output file that was never emitted (El cableado de enlace de un proveedor nombra un archivo de salida que nunca se emitió)
E0271
emit_file side effect carries no file; a conforming emit_file side effect carries a file with its path and content
A pipeline step’s file emission carries no file (La emisión de archivo de un paso de pipeline no lleva ningún archivo)
E0272
side effect declares a kind the plugin contract does not define; a conforming side effect declares emit_file or emit_crd
A pipeline step declares an emission kind the contract does not define (Un paso de pipeline declara un tipo de emisión que el contrato no define)
E0273
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
A template reads a rendered name the node’s provider does not report (Una plantilla lee un nombre renderizado que el proveedor del nodo no informa)
E0274
the plugin identity recorded as trusted no longer matches what this resolution reports
A gate recorded as trusted resolves to a different identity (Un control registrado como de confianza se resuelve en una identidad diferente)
E0275
the edit was refused because the resulting document would not be valid, and nothing was written
An edit would produce a document its schema refuses (Una edición produciría un documento que su esquema rechaza)
E0276
the version being published changes the published predecessor in a way the documented evolution rubric objects to
The change being published breaks what the evolution rubric allows (El cambio que se publica incumple lo que permite la rúbrica de evolución)
E0277
an annotation key on the entity uses a prefix the platform reserves
An annotation key uses a prefix the platform reserves (Una clave de anotación usa un prefijo que la plataforma reserva)
E0278
the entity's name does not follow the documented name shape for its kind
An entity’s name does not follow the shape its kind expects (El nombre de una entidad no sigue la forma que espera su tipo)
E0279
a schema in the entity uses a dynamic reference construct that cross-document reference resolution cannot follow
A schema uses a dynamic reference that cannot be resolved ahead of time (Un esquema usa una referencia dinámica que no puede resolverse de antemano)
E0280
a schema in the entity declares an identifier of its own, where the platform owns that schema's identity
A schema declares an identifier the platform owns (Un esquema declara un identificador que pertenece a la plataforma)
E0281
the entity's category label does not match the category directory the entity is filed under
A Component’s category label and its directory name different categories (La etiqueta de categoría de un Component y su directorio nombran categorías distintas)
E0282
the entity writes an Aggrega schema extension directly into schema content instead of declaring it under usesSchema or featuresSchema
A schema extension is written directly into schema content (Una extensión de esquema se escribe directamente en el contenido del esquema)
E0283
the Plugin entity declares no runtime resource cap of its own, so the platform defaults apply
A Plugin pins neither runtime cap, so the platform’s own apply (Un Plugin no fija ninguno de los dos límites de ejecución, así que se aplican los de la plataforma)
E0284
an attachment slot admits only secret material and does not declare that it handles it
An attachment slot admits only secret material without saying it handles it (Un slot de vinculación admite solo material secreto sin decir que lo maneja)
E0285
the Recipe publishes a provides key the Component it implements does not declare, so a consumer wiring that key is refused
A Recipe publishes a provides key its Component does not declare, checked at publication (Una Recipe publica una clave que su Component no declara, con comprobación al publicar)
E0286
the version bump being published is smaller than the evolution check's classification of the change requires
The version offered is a smaller bump than the change requires (La versión ofrecida es un incremento menor del que requiere el cambio)
E0287
the importer reported a diagnostic that stops the import, so the source was not fully turned into draft authoring files
An import stopped partway through translating a source (Una importación se detuvo a mitad de la traducción de una fuente)
E0288
a plugin has no expression for a construct this build declares
A workload declares a form compose cannot express (Una carga de trabajo declara una forma que compose no puede expresar); A container declares a field compose has no primitive for (Un contenedor declara un campo para el que compose no tiene primitiva); An omits entry names a kind or a namespace a compose file does not have (Una entrada omits nombra un kind o un namespace que un archivo compose no tiene); An omits entry names a namespace a CloudFormation template does not have (Una entrada omits nombra un namespace que una plantilla CloudFormation no tiene); A rule reads a bound CloudFormation parameter by name (Una regla lee por su nombre un parámetro de CloudFormation asociado); The assembled CloudFormation stack cannot carry a transform (El stack de CloudFormation ensamblado no puede llevar una transformación)
E0289
a plugin could not resolve something it requires to exactly one value
A health probe cannot be turned into a compose healthcheck (Una sonda de estado no se puede convertir en un healthcheck de compose); A configmap volume has no file behind it (Un volumen configmap no tiene ningún archivo detrás); What an omits entry left out is still named by the compose file (Lo que una entrada omits dejó fuera sigue nombrado por el archivo compose); What an omits entry left out is still named by a CloudFormation template (Lo que una entrada omits dejó fuera sigue nombrado por una plantilla CloudFormation); A valuesMapping key names no parameter of a sourced CloudFormation template (Una clave de valuesMapping no nombra ningún parámetro de una plantilla CloudFormation de origen); Another component references a CloudFormation parameter a sourced template’s binding filled (Otro componente referencia un parámetro de CloudFormation que la asociación de una plantilla de origen rellenó); Two components order one pair of transforms oppositely (Dos componentes ordenan un mismo par de transformaciones de forma opuesta); A cross-boundary reference has no consuming stack to be written into (Una referencia entre límites no tiene ningún stack consumidor en el que escribirse); A synthesized StatefulSet has no single service to govern it (Un StatefulSet sintetizado no tiene un único servicio que lo gobierne)
E0290
two things a plugin produced occupy one name in its output
An authored export name is one the build derives for a cross-stack reference (Un nombre de exportación escrito es uno que la compilación deriva para una referencia entre stacks); The output a cross-stack reference publishes on already carries an Export (La salida en la que publica una referencia entre stacks ya lleva un Export); Two entries reach one stack output name (Dos entradas llegan a un mismo nombre de salida del stack); A CloudFormation fragment writes one key twice (Un fragmento de CloudFormation escribe una misma clave dos veces); Two rendered resources land at one output file (Dos recursos renderizados acaban en un mismo archivo de salida)
E0291
a plugin has no representation for a value it was given
A published port declares a transport compose cannot spell (Un puerto publicado declara un transporte que compose no puede escribir); A resources quantity cannot be converted to a compose value (Una cantidad de recursos no se puede convertir en un valor de compose); A resource quantity the helm provider emits is not a quantity (Una cantidad de recurso que emite el proveedor helm no es una cantidad); A service type the helm provider cannot render (Un tipo de servicio que el proveedor helm no puede renderizar); A Kubernetes version the helm provider cannot render a chart for (Una versión de Kubernetes para la que el proveedor helm no puede renderizar un chart); A value bound to a CloudFormation parameter cannot take the parameter’s type (Un valor asociado a un parámetro de CloudFormation no puede adoptar el tipo del parámetro); A value bound to a CloudFormation parameter is one its constraints refuse (Un valor asociado a un parámetro de CloudFormation es uno que sus restricciones rechazan); A secret bound to a CloudFormation parameter would be written into the template (Un secreto asociado a un parámetro de CloudFormation se escribiría en la plantilla); A dynamic reference is bound where CloudFormation does not resolve it (Una referencia dinámica está asociada donde CloudFormation no la resuelve); A cross-boundary reference was spliced into a longer string (Una referencia entre límites se insertó en una cadena más larga)
E0292
a plugin reported a failure that none of the declared kinds names
A plugin reported a failure it did not classify (Un plugin informó de un fallo que no clasificó)
E0293
wasm: guest plugin named a condition the socket does not declare
A plugin named a condition the socket does not declare (Un plugin nombró una condición que el socket no declara)
E0294
components in different subsystems take the same identity: rename one of them, since a subsystem contributes nothing to a component's identity
Two subsystems declare a component under one name (Dos subsistemas declaran un componente con un mismo nombre)
E0295
library reference: a reference to a library entry carries no whitespace or line break
A reference to a library entry carries whitespace (Una referencia a una entrada de biblioteca contiene espacios en blanco)
E0296
release extends chain composes both named boundaries and top-level components: declare one routing shape across the chain, never both
A Release chain’s links disagree about the routing shape (Los eslabones de una cadena de Release no coinciden en la estructura de enrutamiento)
E0297
inherited boundary directory carries no template variable, so it resolves to the path the extended Release writes to
A child Release inherits a boundary directory that resolves where its parent writes (Una Release hija hereda un directorio de límite que se resuelve donde escribe su Release padre)
E0298
oci: published bundle carries no entity document
A published bundle holds no entity, or holds two (Un bundle publicado no contiene ninguna entidad, o contiene dos)
E0299
oci: published bundle carries more than one entity document
A published bundle holds no entity, or holds two (Un bundle publicado no contiene ninguna entidad, o contiene dos)
E0300
oci: published bundle cannot be unpacked
A published artifact cannot be read as an entity (Un artefacto publicado no se puede leer como una entidad)
E0301
oci: published artifact is not an entity document
A published artifact cannot be read as an entity (Un artefacto publicado no se puede leer como una entidad)
E0302
an input the entity reads has no pin recorded for it in the entity.lock beside it
An entity reads an input the lock beside it records no pin for (Una entidad lee una entrada para la que el lock junto a ella no registra ninguna fijación)
E0303
the entity shares its directory with another entity, and an entity of its kind has a directory of its own
An entity shares its directory with another entity (Una entidad comparte su directorio con otra entidad)
E0304
a path names content outside the entity's own directory
A path names content outside the entity’s own directory (Una ruta nombra contenido fuera del directorio propio de la entidad)
E0305
the files of the entity's local source do not match the pins recorded for them in entity.lock
A local source no longer matches the pins recorded beside its Recipe (Una fuente local ya no coincide con las fijaciones registradas junto a su Recipe)
E0306
plugin artifact not found on this machine
A plugin’s .wasm is not on this machine (El archivo Wasm de un plugin no está en esta máquina)
E0307
a value a cache location is built from would place cached files outside the place it names in the cache
A value would place a cached file outside the cache (Un valor colocaría un archivo en caché fuera de la caché)
E0308
a Feature reaches a component alongside a Feature it declares a conflict with
Two Features declared to conflict reach one component (Dos Features declaradas en conflicto llegan a un mismo componente)
E0309
a symbolic link sits among the files an entity carries
A symbolic link sits among the files an entity carries (Un enlace simbólico se encuentra entre los archivos que lleva una entidad)
E0310
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>`
A registry is added offline with no trust policy to pin (Un registro se añade sin conexión sin una política de confianza que fijar)
E0311
reference carries a malformed version pin
A version pin is none of the forms a pin takes (Una fijación de versión no tiene ninguna de las formas que adopta una fijación)
E0312
a provider socket binding names a capability containing a colon, which no Recipe can select
A provider binding names a capability containing a colon (Un enlace de proveedor nombra una capacidad que contiene dos puntos)
E0313
plugins.providers entry names a capability no provider-rendering plugin the build reads serves
A provider binding names a capability no plugin the build reads serves (Un enlace de proveedor nombra una capacidad que ningún plugin leído por la compilación sirve)
E0314
plugin was built from a working tree with uncommitted changes, so no commit reproduces the version it reports
A plugin was built from a working tree with uncommitted changes (Un plugin se compiló a partir de un árbol de trabajo con cambios sin confirmar)
E0315
a connection carries an attachment under a name its socket declares no slot for
A connection carries an attachment under a name its socket declares no slot for (Una conexión lleva una vinculación bajo un nombre para el que su socket no declara ningún slot)
E0316
a Release attachment takes the name of an attachment one of a component's connections carries
A Release attachment takes the name of a connection’s attachment (Una vinculación de la Release toma el nombre de la vinculación de una conexión)
E0317
a Release connection attachment names no Feature type, and the type is required for an attachment only the Release makes
A Release connection attachment names no Feature type (Una vinculación de conexión de la Release no nombra ningún tipo de Feature)
E0318
duplicate delivery key across two attachments: an attachment's FeatureRecipe writes a delivery key another attachment already delivered
Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Dos Features vinculadas entregan una misma clave, la posterior a través del injectMapping de su FeatureRecipe)
E0319
connection alias is already used by another connection of the same component
Two connections of one component under one alias (Dos conexiones de un componente bajo un mismo alias)
E0320
a path this operation writes or deletes leads through a link out of the directory it must stay inside
A path the operation writes leads through a link out of the directory it must stay inside (Una ruta que la operación escribe lleva, a través de un enlace, fuera del directorio dentro del cual debe permanecer)
E0321
a file this operation reads leads through a link out of the directory it must stay inside
A file the operation reads leads through a link out of the directory it must stay inside (Un archivo que la operación lee lleva, a través de un enlace, fuera del directorio dentro del cual debe permanecer)
E0323
template reads its callers' render facts, but the FeatureRecipe does not set readsCallerRenderFacts
A template reads its callers’ render facts without declaring it (Una plantilla lee los hechos de renderizado de sus llamadores sin declararlo)
E0324
a reference a document makes to another file leads out of the directory it must stay inside
A reference to another file leads out of the directory it must stay inside (Una referencia a otro archivo sale del directorio dentro del cual debe permanecer)
E0325
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
A provider reported a render fact whose value is not a list (Un proveedor informó de un hecho de renderizado cuyo valor no es una lista)
E0326
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
A pipeline step reads its callers’ render facts (Un paso de pipeline lee los hechos de renderizado de sus llamadores)
E0327
template indexes a map with a key the map does not hold
A template indexes a map with a key the map does not hold (Una plantilla indexa un mapa con una clave que el mapa no contiene)
E0328
attachment written under a name no slot declares fits a slot its component leaves empty
An attachment written under another name fits a slot its component leaves empty (Una vinculación escrita bajo otro nombre encaja en un slot que su componente deja vacío)
E0329
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
A connection and the target it reaches do not name one key (Una conexión y el destino al que llega no nombran una misma clave)
E0330
signing: the references named together need different signing credentials, so nothing was signed
References signed together need different signing credentials (Las referencias firmadas juntas necesitan credenciales de firma distintas)
E0331
signing: no verified signature is recorded for an artifact that requires one
No verified signature is recorded for an artifact that requires one (No hay ninguna firma verificada registrada para un artefacto que la requiere)
E0332
signing: the recorded signature was made for a different artifact
A recorded signature was made for a different artifact (Una firma registrada se creó para un artefacto diferente)
E0333
signing: a recorded signature is not the one a pull would record
A recorded signature is not the one a pull would record (Una firma registrada no es la que registraría un pull)
E0334
an omits entry left out nothing the source rendered
An omits entry left out nothing the source rendered (Una entrada omits no dejó fuera nada de lo que renderizó la fuente)
E0335
provider does not support omits
The provider does not support omits (El proveedor no admite omits)
E0336
a provider's omitted counts do not match the omits entries it was handed
A provider’s omitted counts do not match the omits entries it was handed (Los recuentos de omisiones de un proveedor no coinciden con las entradas omits que recibió)
E0337
no importer plugin version satisfies the plugins.importer entry's version pin
A plugins.importer entry pins a version of its importer the catalog does not hold (Una entrada fija una versión de su importador que el catálogo no contiene)
E0338
importer is attached by more than one plugins.importer entry
An importer is attached by more than one plugins.importer entry (Un importador está vinculado por más de una entrada)
E0339
more than one importer recognises the source
More than one importer recognises the source (Más de un importer reconoce la fuente)
E0340
a name this operation writes holds a path segment Windows cannot hold as written
A name the operation writes holds a part Windows cannot hold (Un nombre que la operación escribe contiene una parte que Windows no puede contener)
E0341
the importer serving the source's format declares no file patterns, so it reads one file and cannot read a directory
An importer that declares no file patterns is handed a directory (A un importer que no declara patrones de archivo se le entrega un directorio)
E0342
no file in the directory matches the file patterns the importer serving the source's format declares
No file in the directory matches the importer’s file patterns (Ningún archivo del directorio coincide con los patrones de archivo del importer)
E0343
a file read from the directory and a file named in the importer's `with.sources` have the same name
A file read from the directory and a file named in the importer’s with.sources have the same name (Un archivo leído del directorio y un archivo nombrado en las fuentes del importer tienen el mismo nombre)
E0344
an entry this publication carries cannot be used on Windows
A published archive carries an entry Windows cannot use (Un archivo comprimido publicado lleva una entrada que Windows no puede usar)
E0345
a container declares one environment variable twice
A container gives one environment variable two values (Un contenedor da dos valores a una misma variable de entorno)
E0346
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
A Component’s metrics annotation and its provides key disagree (La anotación de métricas de un Component y su clave provides discrepan)
E0347
template reads the render facts of a component its host is wired to, but the FeatureRecipe does not set readsTargetRenderFacts
A template reads its targets’ render facts without declaring it (Una plantilla lee los hechos de renderizado de sus destinos sin declararlo)
E0348
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
A pipeline step reads its targets’ render facts (Un paso de pipeline lee los hechos de renderizado de sus destinos)
E0349
no Recipe in the workspace's catalog binds to the capability the import's target names
An import’s target names a capability no Recipe in the catalog binds to (El destino de una importación nombra una capacidad a la que no se vincula ninguna Recipe del catálogo)
E0350
no importer recognises the source
No importer recognises the source (Ningún importer reconoce la fuente)
E0351
provider does not support boundary artifacts
The provider does not support boundary artifacts (El proveedor no admite artefactos de límite)
E0352
boundary output directory does not name a directory beneath the output root
A boundary’s output directory is not a directory beneath the output root (El directorio de salida de un límite no es un directorio bajo la raíz de salida)
E0353
boundary-level Feature instance name is not a directory name
A boundary-level Feature is named . or .. (Una Feature de nivel de límite se llama . o ..)
E0354
a template does more than copy a value it reads off a cross-boundary link
A template did more than copy a value it read off a cross-boundary link (Una plantilla hizo algo más que copiar un valor que leyó de un enlace entre límites)
E0355
inject delivery: shape must be a list of entries, each `in:` with exactly one of `from:` or `value:`
An inject: delivery is not a list of entries (Una entrega de inject no es una lista de entradas)
E0356
suspend requires form: scheduled
A workload suspend: is set on a form other than scheduled (La suspensión de una carga de trabajo está establecida en una forma distinta de la programada)
E0357
a Manifest name mapping's key names no component instance or attachment in this build, so the entry binds nothing
A Manifest name mapping names nothing in the build (Un mapeo por nombre del Manifest no nombra nada de la compilación)
E0358
uses edge target names a component its module does not export
A uses target names a module’s component the module does not export (Un destino de arista nombra un componente de un módulo que el módulo no exporta)
E0359
no source adapter is registered in this program for the source kind
No source adapter is registered in this program for a source kind (No hay ningún adaptador de fuentes registrado en este programa para un tipo de fuente)
E0360
the netrc file could not be read
The netrc file cannot be read (No se puede leer el archivo netrc)
E0361
the source URL carries a credential
A source URL carries a credential (Una URL de fuente contiene una credencial)
E0362
inject entry on a connection carries `value:`; a connection delivers the target's published keys, each named with `from:`
An inject: entry on a connection carries a literal (Una entrada de inject en una conexión lleva un literal)
E0363
annotation subkey is not routed by the annotation's binding
An annotation subkey is not routed by its binding (Una subclave de anotación no es enrutada por su enlace)
E0364
a value template failed while it ran
A value template failed while it ran (Una plantilla de valores falló durante su ejecución)
E0365
boundary-level Feature's output is routed to a dispatch path nothing assembles
A boundary-level Feature’s output reaches no assembled file (La salida de una Feature de nivel de límite no llega a ningún archivo ensamblado)
E0366
FeatureRecipe injectMapping output could not be read as a dictionary of deliveries
An attached Feature’s injectMapping output cannot be read (La salida de injectMapping de una Feature vinculada no se puede leer)
E0367
a scalar annotation value does not route to exactly one path of its binding
A bare annotation value does not route to exactly one path of its binding (Un valor de anotación simple no se enruta hacia exactamente una ruta de su enlace)
E0368
FeatureRecipe injectMapping output writes a key no delivery mechanism of the host reads
An attached Feature’s injectMapping output writes deliveries under a key nothing delivers (La salida de injectMapping de una Feature vinculada escribe entregas bajo una clave que nada entrega)
E0369
template reads a path as a value and iterates it, and the data holds nothing at that path
A template reads and iterates a path that holds nothing (Una plantilla lee e itera una ruta que no contiene nada)
E0370
a pipeline declares one step id twice
A pipeline declares one step id twice (Un pipeline declara dos veces un mismo id de paso)
E0371
catalog document declares a kind a catalog does not hold
A catalog document declares a kind a catalog does not hold (Un documento de catálogo declara un tipo que un catálogo no contiene)
E0372
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
An inject: entry on an attached Feature carries a literal (Una entrada de inyección en una Feature vinculada lleva un literal)
E0373
a document declares an API version this compiler no longer reads
A document declares an API version this compiler no longer reads (Un documento declara una versión de API que este compilador ya no lee)
E0374
a plugin declares a plugin ABI version this compiler no longer speaks
A plugin declares a plugin ABI version this compiler no longer speaks (Un plugin declara una versión de la ABI de plugins que este compilador ya no admite)
E0375
oci: artifact carries a media type this compiler no longer reads
An artifact carries a media type this compiler no longer reads (Un artefacto lleva un tipo de medio que este compilador ya no lee)
E0376
egress: the server did not answer in time
A server did not answer in time (Un servidor no respondió a tiempo)
E0377
registry: the repository listing did not end in time
A registry’s repository listing did not end in time (El listado de repositorios de un registro no terminó a tiempo)
E0378
oci: the registry kept asking to slow down
A registry kept asking to slow down (Un registro siguió pidiendo ir más despacio)
El dominio del linter (no fatal)
El compilador se mantiene estrictamente sin opiniones propias en cuanto a la ejecución. Nunca detiene la compilación por patrones que solo son sospechosos — valores sin usar, secretos huérfanos, destinos desconectados. Como mucho, un patrón así provoca un aviso — el de la propia compilación, para los pocos catalogados arriba en «Condiciones que no detienen una compilación», como un parámetro declarado que nada lee — y el resto pertenece al dominio del linter, donde las empresas optan por adoptar plugins Wasm que aplican sus propias convenciones.
Credenciales huérfanas
Una Feature de credenciales vinculada sin un contrato de entrega inject: no es un error de compilación. El compilador central conserva la declaración en el grafo IR y no emite ninguna advertencia. Los plugins linter empresariales pueden detectar este patrón y advertir sobre él; los renderizadores empresariales también pueden optar por montar implícitamente los secretos huérfanos según sus propias convenciones Black-Box. Como ambas interpretaciones son válidas, el compilador central no toma partido por ninguna.